chore: bump rollup from 4.39.0 to 4.40.0 (#680)

Bumps [rollup](https://github.com/rollup/rollup) from 4.39.0 to 4.40.0.
- [Release notes](https://github.com/rollup/rollup/releases)
- [Changelog](https://github.com/rollup/rollup/blob/master/CHANGELOG.md)
- [Commits](https://github.com/rollup/rollup/compare/v4.39.0...v4.40.0)

---
updated-dependencies:
- dependency-name: rollup
  dependency-version: 4.40.0
  dependency-type: direct:development
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.gitattributes

@@ -0,0 +1,2 @@
+dist/** -diff linguist-generated
+pnpm-lock.yaml -diff linguist-generated

.github/dependabot.yaml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: daily
+    commit-message:
+      prefix: chore
+    labels: []
+
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    commit-message:
+      prefix: chore
+    labels: []
+    versioning-strategy: increase

.github/dependabot.yml

@@ -1,8 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: daily
-    commit-message:
-      prefix: chore

.github/workflows/build.yaml

@@ -0,0 +1,25 @@
+name: Build
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches: [main]
+jobs:
+  build-package:
+    name: Build Package
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Project
+        uses: actions/checkout@v4.2.2
+
+      - name: Setup pnpm
+        uses: threeal/setup-pnpm-action@v1.0.0
+
+      - name: Install Dependencies
+        run: pnpm install
+
+      - name: Build Package
+        run: pnpm build
+
+      - name: Check Diff
+        run: git diff && git diff-index --quiet --exit-code HEAD

.github/workflows/check.yaml

@@ -0,0 +1,28 @@
+name: Check
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches: [main]
+jobs:
+  check-package:
+    name: Check Package
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Project
+        uses: actions/checkout@v4.2.2
+
+      - name: Setup pnpm
+        uses: threeal/setup-pnpm-action@v1.0.0
+
+      - name: Install Dependencies
+        run: pnpm install
+
+      - name: Check Formatting
+        run: pnpm format
+
+      - name: Check Diff
+        run: git diff && git diff-index --quiet --exit-code HEAD
+
+      - name: Check Lint
+        run: pnpm lint

.github/workflows/test.yaml

@@ -0,0 +1,168 @@
+name: Test
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches: [main]
+jobs:
+  test-package:
+    name: Test Package
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Project
+        uses: actions/checkout@v4.2.2
+
+      - name: Setup pnpm
+        uses: threeal/setup-pnpm-action@v1.0.0
+
+      - name: Install Dependencies
+        run: pnpm install
+
+      - name: Test Package
+        run: pnpm test
+
+  test-action:
+    name: Test Action
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, macos-14, windows-2022]
+    steps:
+      - name: Checkout Sample Project
+        uses: actions/checkout@v4.2.2
+        with:
+          repository: threeal/cpp-starter
+          ref: v1.0.0
+
+      - name: Checkout Action
+        uses: actions/checkout@v4.2.2
+        with:
+          path: cmake-action
+          sparse-checkout: |
+            action.yml
+            dist
+          sparse-checkout-cone-mode: false
+
+      - name: Build Sample Project
+        id: cmake-action
+        uses: ./cmake-action
+
+      - name: Run Sample Project
+        run: ${{ steps.cmake-action.outputs.build-dir }}/${{ matrix.os == 'windows-2022' && 'Debug/generate_sequence.exe' || 'generate_sequence' }} 5
+
+  test-action-with-specified-dirs:
+    name: Test Action With Specified Directories
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Sample Project
+        uses: actions/checkout@v4.2.2
+        with:
+          repository: threeal/cpp-starter
+          ref: v1.0.0
+          path: project
+
+      - name: Checkout Action
+        uses: actions/checkout@v4.2.2
+        with:
+          path: cmake-action
+          sparse-checkout: |
+            action.yml
+            dist
+          sparse-checkout-cone-mode: false
+
+      - name: Build Sample Project
+        id: cmake-action
+        uses: ./cmake-action
+        with:
+          source-dir: project
+          build-dir: output
+
+      - name: Run Sample Project
+        run: output/generate_sequence 5
+
+  test-action-without-run-build:
+    name: Test Action Without Run Build
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Sample Project
+        uses: actions/checkout@v4.2.2
+        with:
+          repository: threeal/cpp-starter
+          ref: v1.0.0
+
+      - name: Checkout Action
+        uses: actions/checkout@v4.2.2
+        with:
+          path: cmake-action
+          sparse-checkout: |
+            action.yml
+            dist
+          sparse-checkout-cone-mode: false
+
+      - name: Modify Sample Project
+        run: echo 'invalid' >> src/main.cpp
+
+      - name: Configure Sample Project
+        uses: ./cmake-action
+        with:
+          run-build: false
+
+  test-action-with-additional-options:
+    name: Test Action With Additional Options
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Sample Project
+        uses: actions/checkout@v4.2.2
+        with:
+          repository: threeal/cpp-starter
+          ref: v1.0.0
+
+      - name: Checkout Action
+        uses: actions/checkout@v4.2.2
+        with:
+          path: cmake-action
+          sparse-checkout: |
+            action.yml
+            dist
+          sparse-checkout-cone-mode: false
+
+      - name: Build Sample Project
+        uses: ./cmake-action
+        with:
+          options: BUILD_TESTING=ON
+
+      - name: Test Sample Project
+        uses: threeal/ctest-action@v1.1.0
+
+  test-action-with-custom-generator:
+    name: Test Action With Custom Generator
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Sample Project
+        uses: actions/checkout@v4.2.2
+        with:
+          repository: threeal/cpp-starter
+          ref: v1.0.0
+
+      - name: Checkout Action
+        uses: actions/checkout@v4.2.2
+        with:
+          path: cmake-action
+          sparse-checkout: |
+            action.yml
+            dist
+          sparse-checkout-cone-mode: false
+
+      - name: Setup Ninja
+        uses: seanmiddleditch/gha-setup-ninja@v6
+
+      - name: Configure Sample Project
+        id: cmake-action
+        uses: ./cmake-action
+        with:
+          generator: Ninja
+          run-build: false
+
+      - name: Build Sample Project
+        run: ninja -C ${{ steps.cmake-action.outputs.build-dir }}

.github/workflows/test.yml

@@ -1,147 +0,0 @@
-name: test
-on:
-  workflow_dispatch:
-  pull_request:
-  push:
-    branches: [latest, main]
-jobs:
-  default-usage:
-    runs-on: ${{ matrix.os }}-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [windows, ubuntu, macos]
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Move the test project to the working directory
-        run: mv test/* .
-
-      - name: Use the action
-        id: cmake-action
-        uses: ./
-
-      - name: Try to test the project
-        id: failed-step
-        continue-on-error: true
-        run: ctest --test-dir ${{ steps.cmake-action.outputs.build-dir }} --output-on-failure --no-tests=error -R hello_world ${{ matrix.os == 'windows' && '-C Debug' || '' }}
-
-      - name: Check on success
-        if: steps.failed-step.outcome == 'success'
-        run: exit 1
-
-      - name: Build and test the project
-        run: |
-          cmake --build ${{ steps.cmake-action.outputs.build-dir }}
-          ctest --test-dir ${{ steps.cmake-action.outputs.build-dir }} --output-on-failure --no-tests=error -R hello_world ${{ matrix.os == 'windows' && '-C Debug' || '' }}
-
-  specified-dir-usage:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Use the action with specified directories
-        id: cmake-action
-        uses: ./
-        with:
-          source-dir: test
-          build-dir: output
-
-      - name: Check if the default build directory does not exist
-        shell: bash
-        run: test ! -e build && test ! -e test/build
-
-      - name: Build and test the project
-        run: |
-          cmake --build ${{ steps.cmake-action.outputs.build-dir }}
-          ctest --test-dir ${{ steps.cmake-action.outputs.build-dir }} --output-on-failure --no-tests=error -R hello_world
-
-  run-build-usage:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Use the action with run build enabled
-        id: cmake-action
-        uses: ./
-        with:
-          source-dir: test
-          run-build: true
-          build-args: --target test_c --target test_cpp
-
-      - name: Test the project
-        run: ctest --test-dir ${{ steps.cmake-action.outputs.build-dir }} --output-on-failure --no-tests=error -R test
-
-  run-test-usage:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Use the action with run test enabled
-        uses: ./
-        with:
-          source-dir: test
-          run-test: true
-          test-args: -R hello_world
-
-  additional-flags-usage:
-    runs-on: ${{ matrix.compiler == 'msvc' && 'windows' || 'ubuntu' }}-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        compiler: [gcc, msvc]
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Use the action with additional compiler flags
-        uses: ./
-        with:
-          source-dir: test
-          c-flags: ${{ matrix.compiler == 'msvc' && '/w /WX-' || '-Wno-unused-variable' }}
-          cxx-flags: ${{ matrix.compiler == 'msvc' && '/w /WX-' || '-Wno-unused-variable' }}
-          options: CHECK_SURPASS_WARNING=ON
-          run-build: true
-          build-args: --target test_c --target test_cpp
-          run-test: true
-          test-args: -R test ${{ matrix.compiler == 'msvc' && '-C Debug' || '' }}
-
-  specified-generator-and-compiler-usage:
-    runs-on: ${{ matrix.os }}-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [windows, ubuntu, macos]
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Use the action with specified generator and compilers
-        uses: ./
-        with:
-          source-dir: test
-          generator: Ninja
-          c-compiler: clang
-          cxx-compiler: clang++
-          options: CHECK_USING_CLANG=ON
-          run-build: true
-          build-args: --target test_c --target test_cpp
-          run-test: true
-          test-args: -R test
-
-  specified-shell:
-    runs-on: windows-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
-
-      - name: Use the action with specified shell
-        uses: ./
-        with:
-          shell: bash
-          source-dir: test
-          run-build: true

.gitignore

@@ -1,4 +1,6 @@
 .*
 !.git*
+!.npmrc
+!.prettierignore
 
-build
+node_modules/

.npmrc

@@ -0,0 +1 @@
+use-node-version=23.10.0

.prettierignore

@@ -0,0 +1 @@
+pnpm-lock.yaml

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Alfi Maulana
+Copyright (c) 2023-2025 Alfi Maulana
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,53 +1,34 @@
 # CMake Action
 
-[![Latest Version](https://img.shields.io/github/v/release/threeal/cmake-action)](https://github.com/threeal/cmake-action/releases/)
-[![License](https://img.shields.io/github/license/threeal/cmake-action)](./LICENSE)
-[![Test Status](https://img.shields.io/github/actions/workflow/status/threeal/cmake-action/test.yml?label=test&branch=main)](https://github.com/threeal/cmake-action/actions/workflows/test.yml)
+Configure and build [CMake](https://cmake.org/) projects on [GitHub Actions](https://github.com/features/actions).
 
-Configure, build, and test your [CMake](https://cmake.org/) project using [GitHub Actions](https://github.com/features/actions). This action simplifies the workflow for configuring the build environment of a CMake project. It can also be optionally specified to build a CMake project using the `cmake --build` command and test it using the `ctest` command.
+This action wraps the [`cmake`](https://cmake.org/cmake/help/latest/manual/cmake.1.html) command for configuring and building CMake projects. It provides a more streamlined syntax for specifying build options compared to calling the `cmake` command directly.
 
-## Features
-
-- Configures a CMake project using the [`cmake`](https://cmake.org/cmake/help/latest/manual/cmake.1.html) command.
-- Optionally builds a CMake project using the `cmake --build` command.
-- Optionally tests a CMake project using the [`ctest`](https://cmake.org/cmake/help/latest/manual/ctest.1.html) command.
-- Auto-detects and installs required dependencies.
-- Supports specifying multiple CMake options directly from the action inputs.
-
-## Usage
-
-For more information, refer to [action.yml](./action.yml) and the [GitHub Actions guide](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions).
-
-### Inputs
+## Available Inputs
 
 | Name | Value Type | Description |
 | --- | --- | --- |
-| `shell` | String | The shell to be used to run the commands. It defaults to `pwsh` on Windows and `bash` on Linux and macOS. Refer to [this](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsshell) for more information on available shell options. |
-| `source-dir` | Path | The source directory of the CMake project. It defaults to the current directory. |
-| `build-dir` | Path | The build directory of the CMake project. It defaults to the `build` directory inside the source directory. |
-| `generator` | String | The build system generator for the CMake project. It appends the CMake configuration arguments with `-G [val]`. |
-| `c-compiler` | String | The preferred executable for compiling C language files. It appends the CMake configuration arguments with `-D CMAKE_C_COMPILER=[val]`. |
-| `cxx-compiler` | String | The preferred executable for compiling C++ language files. It appends the CMake configuration arguments with `-D CMAKE_CXX_COMPILER=[val]`. |
-| `c-flags` | Multiple strings | Additional flags to pass when compiling C language files. It appends the CMake configuration arguments with `-D CMAKE_C_FLAGS=[vals]`. |
-| `cxx-flags` | Multiple strings | Additional flags to pass when compiling C++ language files. It appends the CMake configuration arguments with `-D CMAKE_CXX_FLAGS=[vals]`. |
-| `options` | Multiple strings | Additional options to pass during the CMake configuration. It appends the CMake configuration arguments with each of `-D [val]`. |
+| `source-dir` | Path | The source directory of the CMake project. Defaults to the current working directory. |
+| `build-dir` | Path | The build directory of the CMake project. Defaults to the `build` directory inside the source directory. |
+| `generator` | String | The build system generator for the CMake project. Equivalent to setting the `-G` option. |
+| `c-compiler` | String | The preferred executable for compiling C language files. Equivalent to defining the `CMAKE_C_COMPILER` variable. |
+| `cxx-compiler` | String | The preferred executable for compiling C++ language files. Equivalent to defining the `CMAKE_CXX_COMPILER` variable. |
+| `c-flags` | Multiple strings | Additional flags to pass when compiling C language files. Equivalent to defining the `CMAKE_C_FLAGS` variable. |
+| `cxx-flags` | Multiple strings | Additional flags to pass when compiling C++ language files. Equivalent to defining the `CMAKE_CXX_FLAGS` variable. |
+| `options` | Multiple strings | Additional options to pass during the CMake configuration. Equivalent to setting the `-D` option. |
 | `args` | Multiple strings | Additional arguments to pass during the CMake configuration. |
-| `run-build` | `true` or `false` | If enabled, it builds the project using CMake. It defaults to `false`. |
+| `run-build` | `true` or `false` | If enabled, builds the project using CMake. Defaults to `true`. |
 | `build-args` | Multiple strings | Additional arguments to pass during the CMake build. |
-| `run-test` | `true` or `false` | If enabled, it runs testing using [CTest](https://cmake.org/cmake/help/latest/manual/ctest.1.html). It defaults to `false`. |
-| `test-args` | Multiple strings | Additional arguments to pass during the CTest run. |
 
-> **Note**: Multiple strings mean that the input can be specified with more than one value. Separate each value with a space or a new line.
-
-> **Note**: All inputs are optional.
-
-### Outputs
+## Available Outputs
 
 | Name | Value Type | Description |
 | --- | --- | --- |
 | `build-dir` | Path | The build directory of the CMake project. |
 
-### Examples
+## Example Usages
+
+This example demonstrates how to use this action to configure and build a CMake project in a GitHub Actions workflow:
 
 ```yaml
 name: Build
@@ -55,56 +36,71 @@ on:
   push:
 jobs:
   build-project:
-    runs-on: ubuntu-latest
+    name: Build Project
+    runs-on: ubuntu-24.04
     steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3.5.3
+      - name: Checkout Project
+        uses: actions/checkout@v4.2.2
 
-      - name: Configure the project
-        uses: threeal/cmake-action@v1.3.0
-
-      - name: Build the project
-        runs: cmake --build build
-
-      - name: Test the project
-        runs: ctest --test-dir build
+      - name: Build Project
+        uses: threeal/cmake-action@v2.1.0
 ```
 
-> **Note**: You can replace [`v1.3.0`](https://github.com/threeal/cmake-action/releases/tag/v1.3.0) with any version you prefer. See [this](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsuses).
+### Specify the Source and Build Directories
 
-#### Configure, Build, and Test in the Same Step
+By default, this action uses the current working directory as the source directory and the `build` directory inside the source directory as the build directory. To use different directories, set the `source-dir` and/or `build-dir` inputs:
 
 ```yaml
-- name: Configure, build, and test the project
-  uses: threeal/cmake-action@v1.3.0
+- name: Build Project
+  uses: threeal/cmake-action@v2.1.0
   with:
-    run-build: true
-    run-test: true
+    source-dir: source
+    build-dir: output
 ```
 
-#### Specify the Source and Build Directories
+### Specify Build System Generator and Compiler
+
+The following example demonstrates how to use this action to configure and build the project using [Ninja](https://ninja-build.org/) as the build system generator and [Clang](https://clang.llvm.org/) as the compiler:
 
 ```yaml
-- name: Configure the project
-  uses: threeal/cmake-action@v1.3.0
-  with:
-    source-dir: submodules
-    build-dir: submodules/out
-```
+- name: Setup Ninja
+  uses: seanmiddleditch/gha-setup-ninja@v5
 
-#### Using Ninja as the Generator and Clang as the Compiler
-
-```yaml
-- name: Configure the project
-  uses: threeal/cmake-action@v1.3.0
+- name: Build Project
+  uses: threeal/cmake-action@v2.1.0
   with:
     generator: Ninja
-    c-compiler: clang
     cxx-compiler: clang++
 ```
 
+### Specify Additional Options
+
+Use the `options` input to specify additional options for configuring a project:
+
+```yaml
+- name: Build Project
+  uses: threeal/cmake-action@v2.1.0
+  with:
+    options: |
+      BUILD_TESTS=ON
+      BUILD_EXAMPLES=ON
+```
+
+The above example is equivalent to calling the `cmake` command with the `-DBUILD_TESTS=ON` and `-DBUILD_EXAMPLES=ON` arguments.
+
+### Configure Project Without Building
+
+By default, this action builds the project after configuration. To skip the build process, set the `run-build` option to `false`:
+
+```yaml
+- name: Configure Project
+  uses: threeal/cmake-action@v2.1.0
+  with:
+    run-build: false
+```
+
 ## License
 
 This project is licensed under the terms of the [MIT License](./LICENSE).
 
-Copyright © 2023 [Alfi Maulana](https://github.com/threeal/)
+Copyright © 2023-2025 [Alfi Maulana](https://github.com/threeal/)

action.yml

@@ -1,145 +1,37 @@
 name: CMake Action
-description: Configure, build, and test your CMake project
+description: Configure and build CMake projects
 author: Alfi Maulana
 branding:
   color: gray-dark
   icon: terminal
 inputs:
-  shell:
-    description: The shell to be used to run the commands
-    required: false
   source-dir:
     description: The source directory of the CMake project
-    required: false
   build-dir:
     description: The build directory of the CMake project
-    required: false
   generator:
     description: The build system generator for the CMake project
-    required: false
   c-compiler:
     description: The preferred executable for compiling C language files
-    required: false
   cxx-compiler:
     description: The preferred executable for compiling C++ language files
-    required: false
   c-flags:
     description: Additional flags to pass when compiling C language files
-    required: false
   cxx-flags:
     description: Additional flags to pass when compiling C++ language files
-    required: false
   options:
     description: Additional options to pass during the CMake configuration
-    required: false
   args:
     description: Additional arguments to pass during the CMake configuration
-    required: false
   run-build:
-    description: If enabled, it builds the project using CMake (true/false)
-    required: false
-    default: false
+    description: If enabled, builds the project using CMake
+    default: true
   build-args:
     description: Additional arguments to pass during the CMake build
-    required: false
-  run-test:
-    description: If enabled, it runs testing using CTest (true/false)
-    required: false
-    default: false
-  test-args:
-    description: Additional arguments to pass during the CTest run
-    required: false
 outputs:
   build-dir:
     description: The build directory of the CMake project
     value: ${{ steps.process-inputs.outputs.build-dir }}
 runs:
-  using: composite
-  steps:
-    - name: Process the inputs
-      id: process-inputs
-      shell: bash
-      run: |
-        if [ -n '${{ inputs.shell }}' ]; then
-          SHELL='${{ inputs.shell }}'
-        else
-          SHELL='${{ runner.os == 'Windows' && 'pwsh' || 'bash' }}'
-        fi
-        echo "shell=$SHELL" >> $GITHUB_OUTPUT
-
-        SOURCE_DIR="."
-        if [ -n '${{ inputs.source-dir }}' ]; then
-          SOURCE_DIR="${{ inputs.source-dir }}"
-        fi
-
-        BUILD_DIR="build"
-        if [ -n '${{ inputs.build-dir }}' ]; then
-          BUILD_DIR="${{ inputs.build-dir }}"
-        elif [ -n "${{ inputs.source-dir }}" ]; then
-          BUILD_DIR="${{ inputs.source-dir }}/build"
-        fi
-        echo "build-dir=$BUILD_DIR" >> $GITHUB_OUTPUT
-
-        ARGS="'$SOURCE_DIR' -B '$BUILD_DIR'"
-        if [ -n '${{ inputs.generator }}' ]; then
-          ARGS="$ARGS -G '${{ inputs.generator }}'"
-        fi
-        if [ -n '${{ inputs.c-compiler }}' ]; then
-          ARGS="$ARGS -D CMAKE_C_COMPILER='${{ inputs.c-compiler }}'"
-        fi
-        if [ -n '${{ inputs.cxx-compiler }}' ]; then
-          ARGS="$ARGS -D CMAKE_CXX_COMPILER='${{ inputs.cxx-compiler }}'"
-        fi
-        if [ -n '${{ inputs.c-flags }}' ]; then
-          ARGS="$ARGS -D CMAKE_C_FLAGS='${{ inputs.c-flags }}'"
-        fi
-        if [ -n '${{ inputs.cxx-flags }}' ]; then
-          ARGS="$ARGS -D CMAKE_CXX_FLAGS='${{ inputs.cxx-flags }}'"
-        fi
-        for OPT in ${{ inputs.options }}; do
-          ARGS="$ARGS -D $OPT"
-        done
-        if [ -n '${{ inputs.args }}' ]; then
-          ARGS="$ARGS ${{ inputs.args }}"
-        fi
-        echo "cmake-args=${ARGS//[$'\t\r\n']}" >> $GITHUB_OUTPUT
-
-        if [ '${{ inputs.run-build }}' == 'true' ] || [ '${{ inputs.run-test }}' == 'true' ]; then
-          BUILD_ARGS="--build '$BUILD_DIR'"
-          if [ -n '${{ inputs.build-args }}' ]; then
-            BUILD_ARGS="$BUILD_ARGS ${{ inputs.build-args }}"
-          fi
-          echo "cmake-build-args=${BUILD_ARGS//[$'\t\r\n']}" >> $GITHUB_OUTPUT
-        fi
-
-        if [ '${{ inputs.run-test }}' == 'true' ]; then
-          TEST_ARGS="--test-dir '$BUILD_DIR' --output-on-failure --no-tests=error"
-          if [ -n '${{ inputs.test-args }}' ]; then
-            TEST_ARGS="$TEST_ARGS ${{ inputs.test-args }}"
-          fi
-          echo "cmake-test-args=${TEST_ARGS//[$'\t\r\n']}" >> $GITHUB_OUTPUT
-        fi
-
-    - name: Install Ninja
-      if: ${{ inputs.generator == 'Ninja' }}
-      shell: bash
-      run: |
-        case "$OSTYPE" in
-          darwin*)  brew install ninja ;;
-          linux*)   sudo apt install -y ninja-build ;;
-          *)        choco install ninja ;;
-        esac
-
-    - name: Configure the CMake project
-      shell: ${{ steps.process-inputs.outputs.shell }}
-      run: cmake ${{ steps.process-inputs.outputs.cmake-args }}
-
-    - name: Build targets
-      if: inputs.run-build != 'false' || inputs.run-test != 'false'
-      shell: ${{ steps.process-inputs.outputs.shell }}
-      run: cmake ${{ steps.process-inputs.outputs.cmake-build-args }}
-
-    - name: Run tests
-      if: inputs.run-test != 'false'
-      shell: ${{ steps.process-inputs.outputs.shell }}
-      run: ctest ${{ steps.process-inputs.outputs.cmake-test-args }}
+  using: node20
+  main: dist/action.mjs

dist/action.mjs

@@ -0,0 +1,193 @@
+import 'node:fs';
+import fsPromises from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+/**
+ * @internal
+ * Retrieves the value of an environment variable.
+ *
+ * @param name - The name of the environment variable.
+ * @returns The value of the environment variable.
+ * @throws Error if the environment variable is not defined.
+ */
+function mustGetEnvironment(name) {
+    const value = process.env[name];
+    if (value === undefined) {
+        throw new Error(`the ${name} environment variable must be defined`);
+    }
+    return value;
+}
+/**
+ * Retrieves the value of a GitHub Actions input.
+ *
+ * @param name - The name of the GitHub Actions input.
+ * @returns The value of the GitHub Actions input, or an empty string if not found.
+ */
+function getInput(name) {
+    const value = process.env[`INPUT_${name.toUpperCase()}`] ?? "";
+    return value.trim();
+}
+/**
+ * Sets the value of a GitHub Actions output.
+ *
+ * @param name - The name of the GitHub Actions output.
+ * @param value - The value to set for the GitHub Actions output.
+ * @returns A promise that resolves when the value is successfully set.
+ */
+async function setOutput(name, value) {
+    const filePath = mustGetEnvironment("GITHUB_OUTPUT");
+    await fsPromises.appendFile(filePath, `${name}=${value}${os.EOL}`);
+}
+
+/**
+ * Logs an error message in GitHub Actions.
+ *
+ * @param err - The error, which can be of any type.
+ */
+function logError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stdout.write(`::error::${message}${os.EOL}`);
+}
+/**
+ * Logs a command along with its arguments in GitHub Actions.
+ *
+ * @param command - The command to log.
+ * @param args - The arguments of the command.
+ */
+function logCommand(command, ...args) {
+    const message = [command, ...args].join(" ");
+    process.stdout.write(`[command]${message}${os.EOL}`);
+}
+
+/**
+ * Executes a command with the given arguments.
+ *
+ * The command is executed with `stdin` ignored and both `stdout` and `stderr` inherited by the parent process.
+ *
+ * @param command The command to execute.
+ * @param args The arguments to pass to the command.
+ * @returns A promise that resolves when the command exits successfully or rejects if it exits with a non-zero status code or encounters an error.
+ */
+async function exec(command, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(command, args, {
+            stdio: ["ignore", "inherit", "inherit"],
+        });
+        logCommand(proc.spawnfile, ...proc.spawnargs.splice(1));
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command exited with status code ${code}`));
+            }
+        });
+    });
+}
+
+/**
+ * Configures the build system for a CMake project.
+ *
+ * Constructs and runs the `cmake` command to configure the project with the specified
+ * source directory, build directory, generator, options, and additional arguments.
+ *
+ * @param context - The action context containing configuration details.
+ * @returns A promise that resolves when the build system is successfully configured.
+ */
+async function configureProject(context) {
+    const configureArgs = [];
+    if (context.sourceDir) {
+        configureArgs.push(context.sourceDir);
+    }
+    configureArgs.push("-B", context.buildDir);
+    if (context.configure.generator) {
+        configureArgs.push("-G", context.configure.generator);
+    }
+    configureArgs.push(...context.configure.options.map((opt) => "-D" + opt));
+    configureArgs.push(...context.configure.args);
+    await exec("cmake", configureArgs);
+}
+/**
+ * Builds a CMake project.
+ *
+ * Runs the `cmake --build` command to build the project using the specified
+ * build directory and additional arguments.
+ *
+ * @param context - The action context containing build details.
+ * @returns A promise that resolves when the project is successfully built.
+ */
+async function buildProject(context) {
+    await exec("cmake", ["--build", context.buildDir, ...context.build.args]);
+}
+
+const regex = /"([^"]*)"|'([^']*)'|`([^`]*)`|(\S+)/g;
+/**
+ * Converts a space-separated string into a list of arguments.
+ *
+ * This function parses the provided string, which contains arguments separated by spaces and possibly enclosed in quotes, into a list of arguments.
+ *
+ * @param str - The space-separated string to parse.
+ * @returns A list of arguments.
+ */
+function parse(str) {
+    const args = [];
+    let match;
+    while ((match = regex.exec(str)) !== null) {
+        args.push(match[1] ?? match[2] ?? match[3] ?? match[4]);
+    }
+    return args;
+}
+
+function getContext() {
+    const sourceDir = getInput("source-dir");
+    const options = [];
+    let input = getInput("c-compiler");
+    if (input)
+        options.push(`CMAKE_C_COMPILER=${input}`);
+    input = getInput("cxx-compiler");
+    if (input)
+        options.push(`CMAKE_CXX_COMPILER=${input}`);
+    input = getInput("c-flags");
+    if (input) {
+        const flags = input.replaceAll(/\s+/g, " ");
+        options.push(`CMAKE_C_FLAGS=${flags}`);
+    }
+    input = getInput("cxx-flags");
+    if (input) {
+        const flags = input.replaceAll(/\s+/g, " ");
+        options.push(`CMAKE_CXX_FLAGS=${flags}`);
+    }
+    input = getInput("options");
+    if (input) {
+        options.push(...parse(input).map((opt) => opt.toString()));
+    }
+    return {
+        sourceDir,
+        buildDir: getInput("build-dir") || path.join(sourceDir, "build"),
+        configure: {
+            generator: getInput("generator"),
+            options,
+            args: parse(getInput("args")).map((arg) => arg.toString()),
+        },
+        build: {
+            enabled: getInput("run-build") == "true",
+            args: parse(getInput("build-args")).map((arg) => arg.toString()),
+        },
+    };
+}
+
+try {
+    const context = getContext();
+    await configureProject(context);
+    await setOutput("build-dir", context.buildDir);
+    if (context.build.enabled) {
+        await buildProject(context);
+    }
+}
+catch (err) {
+    logError(err);
+    process.exit(1);
+}

eslint.config.js

@@ -0,0 +1,11 @@
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...tseslint.configs.stylistic,
+  {
+    ignores: [".*", "dist"],
+  },
+];

package.json

@@ -0,0 +1,34 @@
+{
+  "name": "root",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "rollup -c",
+    "format": "prettier --write --cache . !dist !README.md",
+    "lint": "eslint",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "gha-utils": "^0.4.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@tsconfig/node23": "^23.0.1",
+    "@types/node": "^22.14.1",
+    "@vitest/coverage-v8": "^3.0.8",
+    "eslint": "^9.24.0",
+    "prettier": "^3.5.3",
+    "rollup": "^4.40.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.29.1",
+    "vitest": "^3.0.8"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}

rollup.config.js

@@ -0,0 +1,11 @@
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import typescript from "@rollup/plugin-typescript";
+
+export default {
+  input: "src/action.ts",
+  output: {
+    dir: "dist",
+    entryFileNames: "[name].mjs",
+  },
+  plugins: [nodeResolve(), typescript()],
+};

src/action.ts

@@ -0,0 +1,18 @@
+import { logError, setOutput } from "gha-utils";
+import { buildProject, configureProject } from "./cmake.js";
+import { getContext } from "./context.js";
+
+try {
+  const context = getContext();
+
+  await configureProject(context);
+
+  await setOutput("build-dir", context.buildDir);
+
+  if (context.build.enabled) {
+    await buildProject(context);
+  }
+} catch (err) {
+  logError(err);
+  process.exit(1);
+}

src/cmake.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from "vitest";
+import { buildProject, configureProject } from "./cmake.js";
+import type { Context } from "./context.js";
+import { exec } from "./exec.js";
+
+interface TestCase {
+  name: string;
+  context?: Partial<Context>;
+  expectedArgs: string[];
+}
+
+const defaultContext: Context = {
+  sourceDir: "",
+  buildDir: "build",
+  configure: {
+    generator: "",
+    options: [],
+    args: [],
+  },
+  build: {
+    enabled: true,
+    args: [],
+  },
+};
+
+vi.mock("./exec.js", () => ({ exec: vi.fn() }));
+
+describe("configure a CMake project", () => {
+  const testCases: TestCase[] = [
+    {
+      name: "with nothing specified",
+      expectedArgs: ["-B", "build"],
+    },
+    {
+      name: "with source directory specified",
+      context: { sourceDir: "project" },
+      expectedArgs: ["project", "-B", "build"],
+    },
+    {
+      name: "with build directory specified",
+      context: { buildDir: "output" },
+      expectedArgs: ["-B", "output"],
+    },
+    {
+      name: "with generator specified",
+      context: { configure: { generator: "Ninja", options: [], args: [] } },
+      expectedArgs: ["-B", "build", "-G", "Ninja"],
+    },
+    {
+      name: "with additional options specified",
+      context: {
+        configure: {
+          generator: "",
+          options: ["BUILD_TESTING=ON", "BUILD_EXAMPLES=ON"],
+          args: [],
+        },
+      },
+      expectedArgs: [
+        "-B",
+        "build",
+        "-DBUILD_TESTING=ON",
+        "-DBUILD_EXAMPLES=ON",
+      ],
+    },
+    {
+      name: "with additional arguments specified",
+      context: {
+        configure: {
+          generator: "",
+          options: [],
+          args: ["-Wdev", "-Wdeprecated"],
+        },
+      },
+      expectedArgs: ["-B", "build", "-Wdev", "-Wdeprecated"],
+    },
+    {
+      name: "with all specified",
+      context: {
+        sourceDir: "project",
+        buildDir: "output",
+        configure: {
+          generator: "Ninja",
+          options: ["BUILD_TESTING=ON", "BUILD_EXAMPLES=ON"],
+          args: ["-Wdev", "-Wdeprecated"],
+        },
+      },
+      expectedArgs: [
+        "project",
+        "-B",
+        "output",
+        "-G",
+        "Ninja",
+        "-DBUILD_TESTING=ON",
+        "-DBUILD_EXAMPLES=ON",
+        "-Wdev",
+        "-Wdeprecated",
+      ],
+    },
+  ];
+
+  for (const testCase of testCases) {
+    it(`should execute the correct command ${testCase.name}`, async () => {
+      vi.mocked(exec).mockReset();
+
+      await configureProject({ ...defaultContext, ...testCase.context });
+
+      expect(exec).toHaveBeenCalledTimes(1);
+      expect(exec).toHaveBeenLastCalledWith("cmake", testCase.expectedArgs);
+    });
+  }
+});
+
+describe("build a CMake project", () => {
+  const testCases: TestCase[] = [
+    {
+      name: "with nothing specified",
+      expectedArgs: ["--build", "build"],
+    },
+    {
+      name: "with build directory specified",
+      context: { buildDir: "output" },
+      expectedArgs: ["--build", "output"],
+    },
+    {
+      name: "with additional arguments specified",
+      context: { build: { enabled: true, args: ["--target", "foo"] } },
+      expectedArgs: ["--build", "build", "--target", "foo"],
+    },
+    {
+      name: "with all specified",
+      context: {
+        buildDir: "output",
+        build: {
+          enabled: true,
+          args: ["--target", "foo"],
+        },
+      },
+      expectedArgs: ["--build", "output", "--target", "foo"],
+    },
+  ];
+
+  for (const testCase of testCases) {
+    it(`should execute the correct command ${testCase.name}`, async () => {
+      vi.mocked(exec).mockReset();
+
+      await buildProject({ ...defaultContext, ...testCase.context });
+
+      expect(exec).toHaveBeenCalledTimes(1);
+      expect(exec).toHaveBeenLastCalledWith("cmake", testCase.expectedArgs);
+    });
+  }
+});

src/cmake.ts

@@ -0,0 +1,43 @@
+import { exec } from "./exec.js";
+import type { Context } from "./context.js";
+
+/**
+ * Configures the build system for a CMake project.
+ *
+ * Constructs and runs the `cmake` command to configure the project with the specified
+ * source directory, build directory, generator, options, and additional arguments.
+ *
+ * @param context - The action context containing configuration details.
+ * @returns A promise that resolves when the build system is successfully configured.
+ */
+export async function configureProject(context: Context): Promise<void> {
+  const configureArgs = [];
+
+  if (context.sourceDir) {
+    configureArgs.push(context.sourceDir);
+  }
+
+  configureArgs.push("-B", context.buildDir);
+
+  if (context.configure.generator) {
+    configureArgs.push("-G", context.configure.generator);
+  }
+
+  configureArgs.push(...context.configure.options.map((opt) => "-D" + opt));
+  configureArgs.push(...context.configure.args);
+
+  await exec("cmake", configureArgs);
+}
+
+/**
+ * Builds a CMake project.
+ *
+ * Runs the `cmake --build` command to build the project using the specified
+ * build directory and additional arguments.
+ *
+ * @param context - The action context containing build details.
+ * @returns A promise that resolves when the project is successfully built.
+ */
+export async function buildProject(context: Context): Promise<void> {
+  await exec("cmake", ["--build", context.buildDir, ...context.build.args]);
+}

src/context.test.ts

@@ -0,0 +1,205 @@
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import type { Context } from "./context.js";
+
+vi.mock("gha-utils", () => ({ getInput: vi.fn() }));
+
+describe("get action context", () => {
+  interface TestCase {
+    name: string;
+    inputs?: Record<string, string>;
+    expectedContext?: Partial<Context>;
+  }
+
+  const testCases: TestCase[] = [
+    {
+      name: "with nothing specified",
+    },
+    {
+      name: "with source directory specified",
+      inputs: { "source-dir": "project" },
+      expectedContext: {
+        sourceDir: "project",
+        buildDir: path.join("project", "build"),
+      },
+    },
+    {
+      name: "with build directory specified",
+      inputs: { "build-dir": "output" },
+      expectedContext: { buildDir: "output" },
+    },
+    {
+      name: "with source and build directories specified",
+      inputs: {
+        "source-dir": "project",
+        "build-dir": "output",
+      },
+      expectedContext: {
+        sourceDir: "project",
+        buildDir: "output",
+      },
+    },
+    {
+      name: "with generator specified",
+      inputs: { generator: "Ninja" },
+      expectedContext: {
+        configure: {
+          generator: "Ninja",
+          options: [],
+          args: [],
+        },
+      },
+    },
+    {
+      name: "with C compiler specified",
+      inputs: { "c-compiler": "clang" },
+      expectedContext: {
+        configure: {
+          generator: "",
+          options: ["CMAKE_C_COMPILER=clang"],
+          args: [],
+        },
+      },
+    },
+    {
+      name: "with C++ compiler specified",
+      inputs: { "cxx-compiler": "clang++" },
+      expectedContext: {
+        configure: {
+          generator: "",
+          options: ["CMAKE_CXX_COMPILER=clang++"],
+          args: [],
+        },
+      },
+    },
+    {
+      name: "with C flags specified",
+      inputs: { "c-flags": "-Werror -Wall\n-Wextra" },
+      expectedContext: {
+        configure: {
+          generator: "",
+          options: ["CMAKE_C_FLAGS=-Werror -Wall -Wextra"],
+          args: [],
+        },
+      },
+    },
+    {
+      name: "with C++ flags specified",
+      inputs: { "cxx-flags": "-Werror -Wall\n-Wextra  -Wpedantic" },
+      expectedContext: {
+        configure: {
+          generator: "",
+          options: ["CMAKE_CXX_FLAGS=-Werror -Wall -Wextra -Wpedantic"],
+          args: [],
+        },
+      },
+    },
+    {
+      name: "with additional options specified",
+      inputs: {
+        options: `BUILD_TESTING=ON BUILD_EXAMPLES=ON\nBUILD_DOCS=ON "FOO=BAR BAZ"`,
+      },
+      expectedContext: {
+        configure: {
+          generator: "",
+          options: [
+            "BUILD_TESTING=ON",
+            "BUILD_EXAMPLES=ON",
+            "BUILD_DOCS=ON",
+            "FOO=BAR BAZ",
+          ],
+          args: [],
+        },
+      },
+    },
+    {
+      name: "with additional arguments specified",
+      inputs: { args: `-Wdev -Wdeprecated\n--fresh --foo "bar baz"` },
+      expectedContext: {
+        configure: {
+          generator: "",
+          options: [],
+          args: ["-Wdev", "-Wdeprecated", "--fresh", "--foo", "bar baz"],
+        },
+      },
+    },
+    {
+      name: "with run build specified",
+      inputs: { "run-build": "true" },
+      expectedContext: { build: { enabled: true, args: [] } },
+    },
+    {
+      name: "with additional build arguments specified",
+      inputs: { "build-args": `--target foo\n--parallel  8 --foo "bar baz"` },
+      expectedContext: {
+        build: {
+          enabled: false,
+          args: ["--target", "foo", "--parallel", "8", "--foo", "bar baz"],
+        },
+      },
+    },
+    {
+      name: "with all specified",
+      inputs: {
+        "source-dir": "project",
+        "build-dir": "output",
+        generator: "Ninja",
+        "c-compiler": "clang",
+        "cxx-compiler": "clang++",
+        "c-flags": "-Werror -Wall\n-Wextra",
+        "cxx-flags": "-Werror -Wall\n-Wextra  -Wpedantic",
+        options: `BUILD_TESTING=ON BUILD_EXAMPLES=ON\nBUILD_DOCS=ON "FOO=BAR BAZ"`,
+        args: `-Wdev -Wdeprecated\n--fresh --foo "bar baz"`,
+        "run-build": "true",
+        "build-args": `--target foo\n--parallel  8 --foo "bar baz"`,
+      },
+      expectedContext: {
+        sourceDir: "project",
+        buildDir: "output",
+        configure: {
+          generator: "Ninja",
+          options: [
+            "CMAKE_C_COMPILER=clang",
+            "CMAKE_CXX_COMPILER=clang++",
+            "CMAKE_C_FLAGS=-Werror -Wall -Wextra",
+            "CMAKE_CXX_FLAGS=-Werror -Wall -Wextra -Wpedantic",
+            "BUILD_TESTING=ON",
+            "BUILD_EXAMPLES=ON",
+            "BUILD_DOCS=ON",
+            "FOO=BAR BAZ",
+          ],
+          args: ["-Wdev", "-Wdeprecated", "--fresh", "--foo", "bar baz"],
+        },
+        build: {
+          enabled: true,
+          args: ["--target", "foo", "--parallel", "8", "--foo", "bar baz"],
+        },
+      },
+    },
+  ];
+
+  for (const testCase of testCases) {
+    it(`should get the action context ${testCase.name}`, async () => {
+      const { getInput } = await import("gha-utils");
+      const { getContext } = await import("./context.js");
+
+      const inputs = testCase.inputs || {};
+      vi.mocked(getInput).mockImplementation((name) => inputs[name] ?? "");
+
+      expect(getContext()).toStrictEqual({
+        sourceDir: "",
+        buildDir: "build",
+        configure: {
+          generator: "",
+          options: [],
+          args: [],
+        },
+        build: {
+          enabled: false,
+          args: [],
+        },
+        ...testCase.expectedContext,
+      });
+    });
+  }
+});

src/context.ts

@@ -0,0 +1,59 @@
+import { getInput } from "gha-utils";
+import path from "node:path";
+import { parse } from "./utils.js";
+
+export interface Context {
+  sourceDir: string;
+  buildDir: string;
+  configure: {
+    generator: string;
+    options: string[];
+    args: string[];
+  };
+  build: {
+    enabled: boolean;
+    args: string[];
+  };
+}
+
+export function getContext(): Context {
+  const sourceDir = getInput("source-dir");
+  const options: string[] = [];
+
+  let input = getInput("c-compiler");
+  if (input) options.push(`CMAKE_C_COMPILER=${input}`);
+
+  input = getInput("cxx-compiler");
+  if (input) options.push(`CMAKE_CXX_COMPILER=${input}`);
+
+  input = getInput("c-flags");
+  if (input) {
+    const flags = input.replaceAll(/\s+/g, " ");
+    options.push(`CMAKE_C_FLAGS=${flags}`);
+  }
+
+  input = getInput("cxx-flags");
+  if (input) {
+    const flags = input.replaceAll(/\s+/g, " ");
+    options.push(`CMAKE_CXX_FLAGS=${flags}`);
+  }
+
+  input = getInput("options");
+  if (input) {
+    options.push(...parse(input).map((opt) => opt.toString()));
+  }
+
+  return {
+    sourceDir,
+    buildDir: getInput("build-dir") || path.join(sourceDir, "build"),
+    configure: {
+      generator: getInput("generator"),
+      options,
+      args: parse(getInput("args")).map((arg) => arg.toString()),
+    },
+    build: {
+      enabled: getInput("run-build") == "true",
+      args: parse(getInput("build-args")).map((arg) => arg.toString()),
+    },
+  };
+}

src/exec.test.ts

@@ -0,0 +1,29 @@
+import { logCommand } from "gha-utils";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { exec } from "./exec.js";
+
+describe("execute commands", () => {
+  vi.mock("gha-utils", () => ({
+    logCommand: vi.fn<(command: string, ...args: string[]) => void>(),
+  }));
+
+  beforeEach(() => {
+    vi.mocked(logCommand).mockClear();
+  });
+
+  it("should successfully execute a command", async () => {
+    await exec("node", ["--version"]);
+
+    expect(logCommand).toHaveBeenCalledTimes(1);
+    expect(logCommand).toHaveBeenCalledWith("node", "--version");
+  });
+
+  it("should fail to execute a command", async () => {
+    await expect(exec("node", ["--invalid"])).rejects.toThrow(
+      "Command exited with status code 9",
+    );
+
+    expect(logCommand).toHaveBeenCalledTimes(1);
+    expect(logCommand).toHaveBeenCalledWith("node", "--invalid");
+  });
+});

src/exec.ts

@@ -0,0 +1,28 @@
+import { logCommand } from "gha-utils";
+import { spawn } from "node:child_process";
+
+/**
+ * Executes a command with the given arguments.
+ *
+ * The command is executed with `stdin` ignored and both `stdout` and `stderr` inherited by the parent process.
+ *
+ * @param command The command to execute.
+ * @param args The arguments to pass to the command.
+ * @returns A promise that resolves when the command exits successfully or rejects if it exits with a non-zero status code or encounters an error.
+ */
+export async function exec(command: string, args: string[]): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ["ignore", "inherit", "inherit"],
+    });
+    logCommand(proc.spawnfile, ...proc.spawnargs.splice(1));
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with status code ${code}`));
+      }
+    });
+  });
+}

src/utils.ts

@@ -0,0 +1,18 @@
+const regex = /"([^"]*)"|'([^']*)'|`([^`]*)`|(\S+)/g;
+
+/**
+ * Converts a space-separated string into a list of arguments.
+ *
+ * This function parses the provided string, which contains arguments separated by spaces and possibly enclosed in quotes, into a list of arguments.
+ *
+ * @param str - The space-separated string to parse.
+ * @returns A list of arguments.
+ */
+export function parse(str: string): string[] {
+  const args: string[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(str)) !== null) {
+    args.push(match[1] ?? match[2] ?? match[3] ?? match[4]);
+  }
+  return args;
+}

test/CMakeLists.txt

@@ -1,32 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-project(test)
-
-option(CHECK_USING_CLANG "Check if the target is compiled using Clang" OFF)
-option(CHECK_SURPASS_WARNING "Check if the target could surpass a compiler warning" OFF)
-
-if(CHECK_SURPASS_WARNING)
-  if(MSVC)
-    set(CMAKE_C_FLAGS "/WX /W4 ${CMAKE_C_FLAGS}")
-    set(CMAKE_CXX_FLAGS "/WX /W4 ${CMAKE_CXX_FLAGS}")
-  else()
-    set(CMAKE_C_FLAGS "-Werror -Wunused-variable ${CMAKE_C_FLAGS}")
-    set(CMAKE_CXX_FLAGS "-Werror -Wunused-variable ${CMAKE_CXX_FLAGS}")
-  endif()
-endif()
-
-enable_testing()
-add_executable(hello_world hello_world.cpp)
-add_test(NAME hello_world COMMAND $<TARGET_FILE:hello_world>)
-
-list(APPEND LANGS c cpp)
-foreach(LANG ${LANGS})
-  configure_file(test.in ${CMAKE_CURRENT_BINARY_DIR}/test.${LANG})
-  add_executable(test_${LANG} EXCLUDE_FROM_ALL ${CMAKE_CURRENT_BINARY_DIR}/test.${LANG})
-  target_compile_definitions(
-    test_${LANG} PRIVATE
-    $<$<STREQUAL:"${LANG}","c">:IS_C>
-    $<$<BOOL:${CHECK_USING_CLANG}>:CHECK_USING_CLANG>
-    $<$<BOOL:${CHECK_SURPASS_WARNING}>:CHECK_SURPASS_WARNING>
-  )
-  add_test(NAME test_${LANG} COMMAND $<TARGET_FILE:test_${LANG}>)
-endforeach()

test/hello_world.cpp

@@ -1,6 +0,0 @@
-#include <iostream>
-
-int main() {
-  std::cout << "Hello world!" << std::endl;
-  return 0;
-}

test/test.in

@@ -1,19 +0,0 @@
-#ifdef IS_C
-#include <stdio.h>
-#define PRINT(STR) printf(STR); printf("\n")
-#else
-#include <iostream>
-#define PRINT(STR) std::cout << STR << std::endl
-#endif
-
-int main() {
-#ifdef CHECK_SURPASS_WARNING
-  int unused;
-#endif
-#if defined(CHECK_USING_CLANG) && !defined(__clang__)
-  PRINT("compiler is not clang");
-  return 1;
-#endif
-  PRINT("all ok");
-  return 0;
-}

tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@tsconfig/node23",
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"],
+  "compilerOptions": {
+    "module": "node16"
+  }
+}

vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    watch: false,
+    coverage: {
+      all: false,
+      enabled: true,
+      reporter: ["text"],
+      thresholds: { 100: true },
+    },
+  },
+});