Add ESM support and change to jiti

.github/workflows/build.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [16.x, 18.x, 20.x]
     steps:
       - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
@@ -31,7 +31,7 @@ jobs:
         run: npm run test
       - name: Import with CJS
         if: ${{ always() }}
-        run: node smoke-tests/smoke-test-cjs.js
+        run: node smoke-tests/smoke-test-cjs.cjs
       - name: Import with ESM
         if: ${{ always() }}
         run: node smoke-tests/smoke-test-esm.mjs

.github/workflows/release.yml

@@ -17,7 +17,6 @@ jobs:
     env:
       CI: true
       GITHUB_TOKEN: ${{ secrets.ACTION_GITHUB_TOKEN }}
-      NPM_OTP_TOKEN: ${{ github.event.inputs.otp }}
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
     runs-on: ubuntu-latest
     steps:

.gitignore

@@ -1,5 +1,9 @@
 .idea
-.npmrc
+.vscode
+
+node_modules
+
 coverage
 dist
-node_modules
+
+.npmrc

jest.config.ts

@@ -6,6 +6,9 @@ const config: Config.InitialOptions = {
     "!<rootDir>/lib/__fixtures__/**/*",
   ],
   moduleFileExtensions: ["ts", "js"],
+  moduleNameMapper: {
+    "^(\\.{1,2}/.*)\\.js$": "$1",
+  },
   transform: {
     "^.+\\.ts$": "@swc/jest",
   },

lib/index.spec.ts

@@ -14,34 +14,68 @@ describe("TypeScriptLoader", () => {
   });
 
   describe("cosmiconfig", () => {
-    it("should load a valid TS file", async () => {
-      const cfg = cosmiconfig("test", {
-        loaders: {
-          ".ts": TypeScriptLoader(),
-        },
+    describe("synchronous", () => {
+      it("should load a valid TS file", () => {
+        const cfg = cosmiconfigSync("test", {
+          loaders: {
+            ".ts": TypeScriptLoader(),
+          },
+        });
+        const loadedCfg = cfg.load(
+          path.resolve(fixturesPath, "valid.fixture.ts")
+        );
+
+        expect(typeof loadedCfg!.config).toStrictEqual("object");
+        expect(typeof loadedCfg!.config.test).toStrictEqual("object");
+        expect(loadedCfg!.config.test.cake).toStrictEqual("a lie");
       });
-      const loadedCfg = await cfg.load(
-        path.resolve(fixturesPath, "valid.fixture.ts")
-      );
 
-      expect(typeof loadedCfg!.config).toStrictEqual("object");
-      expect(typeof loadedCfg!.config.test).toStrictEqual("object");
-      expect(loadedCfg!.config.test.cake).toStrictEqual("a lie");
+      it("should throw an error on loading an invalid TS file", () => {
+        const cfg = cosmiconfigSync("test", {
+          loaders: {
+            ".ts": TypeScriptLoader(),
+          },
+        });
+
+        try {
+          cfg.load(path.resolve(fixturesPath, "invalid.fixture.ts"));
+          fail("Should fail to load invalid TS");
+        } catch (error: any) {
+          expect(error?.name).toStrictEqual("TypeScriptCompileError");
+        }
+      });
     });
 
-    it("should throw an error on loading an invalid TS file", async () => {
-      const cfg = cosmiconfig("test", {
-        loaders: {
-          ".ts": TypeScriptLoader(),
-        },
+    describe("asynchronous", () => {
+      it("should load a valid TS file", async () => {
+        const cfg = cosmiconfig("test", {
+          loaders: {
+            ".ts": TypeScriptLoader(),
+          },
+        });
+        const loadedCfg = await cfg.load(
+          path.resolve(fixturesPath, "valid.fixture.ts")
+        );
+
+        expect(typeof loadedCfg!.config).toStrictEqual("object");
+        expect(typeof loadedCfg!.config.test).toStrictEqual("object");
+        expect(loadedCfg!.config.test.cake).toStrictEqual("a lie");
       });
 
-      try {
-        await cfg.load(path.resolve(fixturesPath, "invalid.fixture.ts"));
-        fail("Should fail to load invalid TS");
-      } catch (error: any) {
-        expect(error?.name).toStrictEqual("TypeScriptCompileError");
-      }
+      it("should throw an error on loading an invalid TS file", async () => {
+        const cfg = cosmiconfig("test", {
+          loaders: {
+            ".ts": TypeScriptLoader(),
+          },
+        });
+
+        try {
+          await cfg.load(path.resolve(fixturesPath, "invalid.fixture.ts"));
+          fail("Should fail to load invalid TS");
+        } catch (error: any) {
+          expect(error?.name).toStrictEqual("TypeScriptCompileError");
+        }
+      });
     });
   });
 

lib/index.ts

@@ -1,2 +1,2 @@
-export { TypeScriptLoader } from "./loader";
-export type { TypeScriptCompileError } from "./typescript-compile-error";
+export { TypeScriptLoader } from "./loader.js";
+export type { TypeScriptCompileError } from "./typescript-compile-error.js";

lib/loader.spec.ts

@@ -2,14 +2,23 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { Loader } from "cosmiconfig";
-import * as tsnode from "ts-node";
+import * as jiti from "jiti";
 
 import { TypeScriptLoader } from "./loader";
 import { TypeScriptCompileError } from "./typescript-compile-error";
 
+// Handle jiti using `export default`
+jest.mock("jiti", () => {
+  const actual = jest.requireActual("jiti");
+  return {
+    __esModule: true,
+    default: jest.fn(actual),
+  };
+});
+
 describe("TypeScriptLoader", () => {
   const fixturesPath = path.resolve(__dirname, "__fixtures__");
-  const tsNodeSpy = jest.spyOn(tsnode, "register");
+  const jitiSpy = jest.spyOn(jiti, "default");
 
   let loader: Loader;
 
@@ -31,11 +40,11 @@ describe("TypeScriptLoader", () => {
     expect(() => loader(filePath, readFixtureContent(filePath))).toThrowError();
   });
 
-  it("should use the same instance of ts-node across multiple calls", () => {
+  it("should use the same instance of jiti across multiple calls", () => {
     const filePath = path.resolve(fixturesPath, "valid.fixture.ts");
     loader(filePath, readFixtureContent(filePath));
     loader(filePath, readFixtureContent(filePath));
-    expect(tsNodeSpy).toHaveBeenCalledTimes(1);
+    expect(jitiSpy).toHaveBeenCalledTimes(1);
   });
 
   it("should throw a TypeScriptCompileError on error", () => {
@@ -50,21 +59,17 @@ describe("TypeScriptLoader", () => {
     }
   });
 
-  describe("ts-node", () => {
+  describe("jiti", () => {
     const unknownError = "Test Error";
 
-    let stub: jest.SpyInstance<tsnode.Service, [service: tsnode.Service]>;
+    let stub: jest.SpyInstance;
 
     beforeEach(() => {
-      stub = jest.spyOn(tsnode, "register").mockImplementation(
-        () =>
-          ({
-            compile: (): string => {
-              // eslint-disable-next-line @typescript-eslint/no-throw-literal
-              throw unknownError;
-            },
-          } as any)
-      );
+      stub = jest.spyOn(jiti, "default").mockImplementation((() => () => {
+        // eslint-disable-next-line @typescript-eslint/no-throw-literal
+        throw unknownError;
+      }) as any);
+
       loader = TypeScriptLoader();
     });
 

lib/loader.ts

@@ -1,18 +1,13 @@
 import type { Loader } from "cosmiconfig";
-import { register, RegisterOptions } from "ts-node";
+import jiti, { type JITIOptions } from "jiti";
 
-import { TypeScriptCompileError } from "./typescript-compile-error";
+import { TypeScriptCompileError } from "./typescript-compile-error.js";
 
-export function TypeScriptLoader(options?: RegisterOptions): Loader {
-  const tsNodeInstance = register({
-    ...options,
-    compilerOptions: { module: "commonjs" },
-  });
-  return (path: string, content: string) => {
+export function TypeScriptLoader(options?: JITIOptions): Loader {
+  const loader = jiti("", { interopDefault: true, ...options });
+  return (path: string) => {
     try {
-      // cosmiconfig requires the transpiled configuration to be CJS
-      tsNodeInstance.compile(content, path);
-      const result = require(path);
+      const result = loader(path);
 
       // `default` is used when exporting using export default, some modules
       // may still use `module.exports` or if in TS `export = `

lib/typescript-compile-error.spec.ts

@@ -17,21 +17,14 @@ describe("TypeScriptCompileError", () => {
       expect(tscError.stack).toBe(testError.stack);
     });
 
-    it("should replace the legacy tsc error string", () => {
-      const testMsg =
-        "TypeScript compiler encountered syntax errors while transpiling. Errors: ";
+    it("should prefix the jiti parser error", () => {
+      const testMsg = 'ParseError: Unexpected token, expected ","';
       const legacyError = new Error(testMsg);
       const tscError = TypeScriptCompileError.fromError(legacyError);
 
-      expect(tscError).not.toContainEqual(testMsg);
-    });
-
-    it("should replace the tsc error string", () => {
-      const testMsg = "⨯ Unable to compile TypeScript:";
-      const newError = new Error(testMsg);
-      const tscError = TypeScriptCompileError.fromError(newError);
-
-      expect(tscError).not.toContainEqual(testMsg);
+      expect(tscError.message).toContain(
+        "TypeScriptLoader failed to compile TypeScript:"
+      );
     });
   });
 });

lib/typescript-compile-error.ts

@@ -8,12 +8,7 @@ export class TypeScriptCompileError extends Error {
   }
 
   public static fromError(error: Error): TypeScriptCompileError {
-    const errMsg = error.message.replace(
-      /(TypeScript compiler encountered syntax errors while transpiling\. Errors:\s?)|(⨯ Unable to compile TypeScript:\s?)/,
-      ""
-    );
-
-    const message = `TypeScriptLoader failed to compile TypeScript:\n${errMsg}`;
+    const message = `TypeScriptLoader failed to compile TypeScript:\n${error.message}`;
 
     const newError = new TypeScriptCompileError(message);
     newError.stack = error.stack;