Convert to ESM

.node-version

@@ -1 +1 @@
-21.6.2
+22.9.0

__fixtures__/core.ts

@@ -0,0 +1,10 @@
+import type * as core from '@actions/core'
+import { jest } from '@jest/globals'
+
+export const debug = jest.fn<typeof core.debug>()
+export const error = jest.fn<typeof core.error>()
+export const info = jest.fn<typeof core.info>()
+export const getInput = jest.fn<typeof core.getInput>()
+export const setOutput = jest.fn<typeof core.setOutput>()
+export const setFailed = jest.fn<typeof core.setFailed>()
+export const warning = jest.fn<typeof core.warning>()

__fixtures__/wait.ts

@@ -0,0 +1,3 @@
+import { jest } from '@jest/globals'
+
+export const wait = jest.fn<typeof import('../src/wait.js').wait>()

__tests__/index.test.ts

@@ -1,17 +0,0 @@
-/**
- * Unit tests for the action's entrypoint, src/index.ts
- */
-
-import * as main from '../src/main'
-
-// Mock the action's entrypoint
-const runMock = jest.spyOn(main, 'run').mockImplementation()
-
-describe('index', () => {
-  it('calls run when imported', () => {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    require('../src/index')
-
-    expect(runMock).toHaveBeenCalled()
-  })
-})

__tests__/main.test.ts

@@ -1,89 +1,62 @@
 /**
  * Unit tests for the action's main functionality, src/main.ts
  *
- * These should be run as if the action was called from a workflow.
- * Specifically, the inputs listed in `action.yml` should be set as environment
- * variables following the pattern `INPUT_<INPUT_NAME>`.
+ * To mock dependencies in ESM, you can create fixtures that export mock
+ * functions and objects. For example, the core module is mocked in this test,
+ * so that the actual '@actions/core' module is not imported.
  */
+import { jest } from '@jest/globals'
+import * as core from '../__fixtures__/core.js'
+import { wait } from '../__fixtures__/wait.js'
 
-import * as core from '@actions/core'
-import * as main from '../src/main'
+// Mocks should be declared before the module being tested is imported.
+jest.unstable_mockModule('@actions/core', () => core)
+jest.unstable_mockModule('../src/wait.js', () => ({ wait }))
 
-// Mock the action's main function
-const runMock = jest.spyOn(main, 'run')
+// The module being tested should be imported dynamically. This ensures that the
+// mocks are used in place of any actual dependencies.
+const { run } = await import('../src/main.js')
 
-// Other utilities
-const timeRegex = /^\d{2}:\d{2}:\d{2}/
-
-// Mock the GitHub Actions core library
-let debugMock: jest.SpiedFunction<typeof core.debug>
-let errorMock: jest.SpiedFunction<typeof core.error>
-let getInputMock: jest.SpiedFunction<typeof core.getInput>
-let setFailedMock: jest.SpiedFunction<typeof core.setFailed>
-let setOutputMock: jest.SpiedFunction<typeof core.setOutput>
-
-describe('action', () => {
+describe('main.ts', () => {
   beforeEach(() => {
-    jest.clearAllMocks()
+    // Set the action's inputs as return values from core.getInput().
+    core.getInput.mockImplementation(() => '500')
 
-    debugMock = jest.spyOn(core, 'debug').mockImplementation()
-    errorMock = jest.spyOn(core, 'error').mockImplementation()
-    getInputMock = jest.spyOn(core, 'getInput').mockImplementation()
-    setFailedMock = jest.spyOn(core, 'setFailed').mockImplementation()
-    setOutputMock = jest.spyOn(core, 'setOutput').mockImplementation()
+    // Mock the wait function so that it does not actually wait.
+    wait.mockImplementation(() => Promise.resolve('done!'))
   })
 
-  it('sets the time output', async () => {
-    // Set the action's inputs as return values from core.getInput()
-    getInputMock.mockImplementation(name => {
-      switch (name) {
-        case 'milliseconds':
-          return '500'
-        default:
-          return ''
-      }
-    })
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
 
-    await main.run()
-    expect(runMock).toHaveReturned()
+  it('Sets the time output', async () => {
+    await run()
 
-    // Verify that all of the core library functions were called correctly
-    expect(debugMock).toHaveBeenNthCalledWith(1, 'Waiting 500 milliseconds ...')
-    expect(debugMock).toHaveBeenNthCalledWith(
-      2,
-      expect.stringMatching(timeRegex)
-    )
-    expect(debugMock).toHaveBeenNthCalledWith(
-      3,
-      expect.stringMatching(timeRegex)
-    )
-    expect(setOutputMock).toHaveBeenNthCalledWith(
+    // Verify the time output was set.
+    expect(core.setOutput).toHaveBeenNthCalledWith(
       1,
       'time',
-      expect.stringMatching(timeRegex)
+      // Simple regex to match a time string in the format HH:MM:SS.
+      expect.stringMatching(/^\d{2}:\d{2}:\d{2}/)
     )
-    expect(errorMock).not.toHaveBeenCalled()
   })
 
-  it('sets a failed status', async () => {
-    // Set the action's inputs as return values from core.getInput()
-    getInputMock.mockImplementation(name => {
-      switch (name) {
-        case 'milliseconds':
-          return 'this is not a number'
-        default:
-          return ''
-      }
-    })
+  it('Sets a failed status', async () => {
+    // Clear the getInput mock and return an invalid value.
+    core.getInput.mockClear().mockReturnValueOnce('this is not a number')
 
-    await main.run()
-    expect(runMock).toHaveReturned()
+    // Clear the wait mock and return a rejected promise.
+    wait
+      .mockClear()
+      .mockRejectedValueOnce(new Error('milliseconds is not a number'))
 
-    // Verify that all of the core library functions were called correctly
-    expect(setFailedMock).toHaveBeenNthCalledWith(
+    await run()
+
+    // Verify that the action was marked as failed.
+    expect(core.setFailed).toHaveBeenNthCalledWith(
       1,
-      'milliseconds not a number'
+      'milliseconds is not a number'
     )
-    expect(errorMock).not.toHaveBeenCalled()
   })
 })

__tests__/wait.test.ts

@@ -1,19 +1,18 @@
 /**
  * Unit tests for src/wait.ts
  */
-
-import { wait } from '../src/wait'
-import { expect } from '@jest/globals'
+import { wait } from '../src/wait.js'
 
 describe('wait.ts', () => {
-  it('throws an invalid number', async () => {
+  it('Throws an invalid number', async () => {
     const input = parseInt('foo', 10)
+
     expect(isNaN(input)).toBe(true)
 
-    await expect(wait(input)).rejects.toThrow('milliseconds not a number')
+    await expect(wait(input)).rejects.toThrow('milliseconds is not a number')
   })
 
-  it('waits with a valid number', async () => {
+  it('Waits with a valid number', async () => {
     const start = new Date()
     await wait(500)
     const end = new Date()

jest.config.ts

@@ -0,0 +1,43 @@
+// See: https://jestjs.io/docs/configuration
+
+import type { JestConfigWithTsJest } from 'ts-jest'
+
+const jestConfig: JestConfigWithTsJest = {
+  clearMocks: true,
+  collectCoverage: true,
+  collectCoverageFrom: ['./src/**'],
+  coverageDirectory: './coverage',
+  coveragePathIgnorePatterns: ['/node_modules/', '/dist/'],
+  coverageReporters: ['json-summary', 'text', 'lcov'],
+  // Uncomment the below lines if you would like to enforce a coverage threshold
+  // for your action. This will fail the build if the coverage is below the
+  // specified thresholds.
+  // coverageThreshold: {
+  //   global: {
+  //     branches: 100,
+  //     functions: 100,
+  //     lines: 100,
+  //     statements: 100
+  //   }
+  // },
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleFileExtensions: ['ts', 'js'],
+  preset: 'ts-jest',
+  reporters: ['default'],
+  resolver: 'ts-jest-resolver',
+  testEnvironment: 'node',
+  testMatch: ['**/*.test.ts'],
+  testPathIgnorePatterns: ['/dist/', '/node_modules/'],
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        tsconfig: 'tsconfig.eslint.json',
+        useESM: true
+      }
+    ]
+  },
+  verbose: true
+}
+
+export default jestConfig

package.json

@@ -3,6 +3,7 @@
   "description": "GitHub Actions TypeScript template",
   "version": "0.0.0",
   "author": "",
+  "type": "module",
   "private": true,
   "homepage": "https://github.com/actions/typescript-action",
   "repository": {
@@ -13,9 +14,7 @@
     "url": "https://github.com/actions/typescript-action/issues"
   },
   "keywords": [
-    "actions",
-    "node",
-    "setup"
+    "actions"
   ],
   "exports": {
     ".": "./dist/index.js"
@@ -25,15 +24,15 @@
   },
   "scripts": {
     "bundle": "npm run format:write && npm run package",
-    "ci-test": "npx jest",
+    "ci-test": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 npx jest",
     "coverage": "npx make-coverage-badge --output-path ./badges/coverage.svg",
     "format:write": "npx prettier --write .",
     "format:check": "npx prettier --check .",
-    "lint": "npx eslint . -c ./.github/linters/.eslintrc.yml",
+    "lint": "npx eslint .",
     "local-action": "npx local-action . src/main.ts .env",
-    "package": "npx ncc build src/index.ts -o dist --source-map --license licenses.txt",
+    "package": "npx rollup --config rollup.config.ts --configPlugin @rollup/plugin-typescript",
     "package:watch": "npm run package -- --watch",
-    "test": "npx jest",
+    "test": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 npx jest",
     "all": "npm run format:write && npm run lint && npm run test && npm run coverage && npm run package"
   },
   "license": "MIT",
@@ -44,6 +43,9 @@
     "@eslint/compat": "^1.2.3",
     "@github/local-action": "^2.2.0",
     "@jest/globals": "^29.7.0",
+    "@rollup/plugin-commonjs": "^28.0.1",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-typescript": "^12.1.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.9.0",
     "@typescript-eslint/eslint-plugin": "^8.14.0",
@@ -58,7 +60,10 @@
     "make-coverage-badge": "^1.2.0",
     "prettier": "^3.3.3",
     "prettier-eslint": "^16.3.0",
+    "rollup": "^4.27.0",
     "ts-jest": "^29.2.5",
+    "ts-jest-resolver": "^2.0.1",
+    "ts-node": "^10.9.2",
     "typescript": "^5.6.3"
   }
 }

rollup.config.ts

@@ -0,0 +1,18 @@
+// See: https://rollupjs.org/introduction/
+
+import commonjs from '@rollup/plugin-commonjs'
+import nodeResolve from '@rollup/plugin-node-resolve'
+import typescript from '@rollup/plugin-typescript'
+
+const config = {
+  input: 'src/index.ts',
+  output: {
+    esModule: true,
+    file: 'dist/index.js',
+    format: 'es',
+    sourcemap: true
+  },
+  plugins: [typescript(), nodeResolve(), commonjs()]
+}
+
+export default config

src/index.ts

@@ -1,7 +1,8 @@
 /**
- * The entrypoint for the action.
+ * The entrypoint for the action. This file simply imports and runs the action's
+ * main logic.
  */
-import { run } from './main'
+import { run } from './main.js'
 
-// eslint-disable-next-line @typescript-eslint/no-floating-promises
+/* istanbul ignore next */
 run()

src/main.ts

@@ -1,9 +1,10 @@
 import * as core from '@actions/core'
-import { wait } from './wait'
+import { wait } from './wait.js'
 
 /**
  * The main function for the action.
- * @returns {Promise<void>} Resolves when the action is complete.
+ *
+ * @returns Resolves when the action is complete.
  */
 export async function run(): Promise<void> {
   try {

src/wait.ts

@@ -1,13 +1,12 @@
 /**
- * Wait for a number of milliseconds.
+ * Waits for a number of milliseconds.
+ *
  * @param milliseconds The number of milliseconds to wait.
- * @returns {Promise<string>} Resolves with 'done!' after the wait is over.
+ * @returns Resolves with 'done!' after the wait is over.
  */
 export async function wait(milliseconds: number): Promise<string> {
-  return new Promise(resolve => {
-    if (isNaN(milliseconds)) {
-      throw new Error('milliseconds not a number')
-    }
+  return new Promise((resolve) => {
+    if (isNaN(milliseconds)) throw new Error('milliseconds is not a number')
 
     setTimeout(() => resolve('done!'), milliseconds)
   })