feat!: Upgrade to Jiti 2

Author: renovate[bot]

.github/workflows/build.yml

@@ -42,6 +42,15 @@ jobs:
       - name: Import with both CJS and ESM
         if: ${{ always() }}
         run: node smoke-tests/smoke-test.js
+      - name: Import synchronously with CJS
+        if: ${{ always() }}
+        run: node smoke-tests/smoke-test-cjs-sync.cjs
+      - name: Import synchronously with ESM
+        if: ${{ always() }}
+        run: node smoke-tests/smoke-test-esm-sync.mjs
+      - name: Import synchronously with both CJS and ESM
+        if: ${{ always() }}
+        run: node smoke-tests/smoke-test-sync.js
       - name: lint
         if: ${{ always() }}
         run: pnpm lint

README.md

@@ -8,7 +8,7 @@
 
 ## Usage
 
-Simply add `TypeScriptLoader` to the list of loaders for the `.ts` file type:
+Simply add `TypeScriptLoader` to the list of loaders for the `.ts` file type, and `await` loading:
 
 ```ts
 import { cosmiconfig } from "cosmiconfig";
@@ -34,7 +34,7 @@ const explorer = cosmiconfig("test", {
   },
 });
 
-const cfg = explorer.load("./");
+const cfg = await explorer.load("./");
 ```
 
 Or more simply if you only support loading of a TypeScript based configuration file:
@@ -50,15 +50,23 @@ const explorer = cosmiconfig("test", {
   },
 });
 
-const cfg = explorer.load("./amazing.config.ts");
+const cfg = await explorer.load("./amazing.config.ts");
 ```
 
-## `@endemolshinegroup/cosmiconfig-typescript-loader`
+### Synchronously loading
 
-This package serves as a drop in replacement for `@endemolshinegroup/cosmiconfig-typescript-loader`. At the time of publishing this, `endemolshinegroup` is not maintaining the original package. I can only assume this is to do with the fact that Endemol Shine Group [was purchased and absorbed by another business](https://en.wikipedia.org/wiki/Endemol_Shine_Group#Sale_to_Banijay). This discontinuation of development efforts towards the original package left any open issues and pull requests unresolved.
+With the release of Jiti 2, the synchronous loader has now been deprecated. It can still be used by using the `TypeScriptLoaderSync` export:
 
-This new package resolves the following original issues:
+```ts
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoaderSync } from "cosmiconfig-typescript-loader";
 
-- [`#134`](https://github.com/EndemolShineGroup/cosmiconfig-typescript-loader/issues/134): "Doesn't work with Cosmiconfig sync API"
-- [`#147`](https://github.com/EndemolShineGroup/cosmiconfig-typescript-loader/issues/147): "doesn't provide typescript, requested by ts-node"
-- [`#155`](https://github.com/EndemolShineGroup/cosmiconfig-typescript-loader/issues/155): "Misleading TypeScriptCompileError when user's tsconfig.json "module" is set to "es2015""
+const moduleName = "module";
+const explorer = cosmiconfig("test", {
+  loaders: {
+    ".ts": TypeScriptLoaderSync(),
+  },
+});
+
+const cfg = explorer.load("./amazing.config.ts");
+```

lib/index.spec.ts

@@ -1,15 +1,18 @@
+/* eslint-disable @typescript-eslint/no-deprecated */
+
 import path from "node:path";
 
 import { cosmiconfig, cosmiconfigSync } from "cosmiconfig";
 
-import { TypeScriptLoader } from ".";
+import { TypeScriptLoader, TypeScriptLoaderSync } from ".";
 
 describe("TypeScriptLoader", () => {
   const fixturesPath = path.resolve(__dirname, "__fixtures__");
 
   describe("exports", () => {
     it("should export the loader function as a default", () => {
       expect(typeof TypeScriptLoader).toStrictEqual("function");
+      expect(typeof TypeScriptLoaderSync).toStrictEqual("function");
     });
   });
 
@@ -18,7 +21,7 @@ describe("TypeScriptLoader", () => {
       it("should load a valid TS file", () => {
         const cfg = cosmiconfigSync("test", {
           loaders: {
-            ".ts": TypeScriptLoader(),
+            ".ts": TypeScriptLoaderSync(),
           },
         });
         const loadedCfg = cfg.load(
@@ -33,7 +36,7 @@ describe("TypeScriptLoader", () => {
       it("should throw an error on loading an invalid TS file", () => {
         const cfg = cosmiconfigSync("test", {
           loaders: {
-            ".ts": TypeScriptLoader(),
+            ".ts": TypeScriptLoaderSync(),
           },
         });
 
@@ -80,33 +83,4 @@ describe("TypeScriptLoader", () => {
       });
     });
   });
-
-  describe("cosmiconfigSync", () => {
-    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");
-    });
-
-    it("should throw an error on loading an invalid TS file", () => {
-      const cfg = cosmiconfigSync("test", {
-        loaders: {
-          ".ts": TypeScriptLoader(),
-        },
-      });
-
-      expect(() =>
-        cfg.load(path.resolve(fixturesPath, "invalid.fixture.ts")),
-      ).toThrow();
-    });
-  });
 });

lib/index.ts

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

lib/loader.spec.ts

@@ -1,94 +1,166 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { Loader } from "cosmiconfig";
+import type { LoaderResult, LoaderSync } from "cosmiconfig";
 import * as jiti from "jiti";
 
-import { TypeScriptLoader } from "./loader";
+import { TypeScriptLoader, TypeScriptLoaderSync } 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),
+    createJiti: actual.createJiti,
   };
 });
 
 describe("TypeScriptLoader", () => {
   const fixturesPath = path.resolve(__dirname, "__fixtures__");
-  const jitiSpy = jest.spyOn(jiti, "default");
-
-  let loader: Loader;
+  let jitiCreateJitiSpy: jest.SpyInstance<typeof jiti.createJiti>;
 
   function readFixtureContent(file: string): string {
     return fs.readFileSync(file).toString();
   }
 
-  beforeAll(() => {
-    loader = TypeScriptLoader();
+  beforeEach(() => {
+    jitiCreateJitiSpy = jest.spyOn(jiti, "createJiti");
   });
 
-  it("should parse a valid TS file", () => {
-    const filePath = path.resolve(fixturesPath, "valid.fixture.ts");
-    loader(filePath, readFixtureContent(filePath));
+  afterEach(() => {
+    jest.restoreAllMocks();
   });
 
-  it("should fail on parsing an invalid TS file", () => {
-    const filePath = path.resolve(fixturesPath, "invalid.fixture.ts");
-    expect((): unknown =>
-      loader(filePath, readFixtureContent(filePath)),
-    ).toThrow();
-  });
+  describe("asynchronous", () => {
+    let loader: (filepath: string, content: string) => Promise<LoaderResult>;
 
-  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(jitiSpy).toHaveBeenCalledTimes(1);
-  });
+    beforeEach(() => {
+      loader = TypeScriptLoader();
+    });
+
+    it("should parse a valid TS file", async () => {
+      const filePath = path.resolve(fixturesPath, "valid.fixture.ts");
+      await loader(filePath, readFixtureContent(filePath));
+    });
 
-  it("should throw a TypeScriptCompileError on error", () => {
-    try {
+    it("should fail on parsing an invalid TS file", async () => {
       const filePath = path.resolve(fixturesPath, "invalid.fixture.ts");
-      loader(filePath, readFixtureContent(filePath));
-      fail(
-        "Error should be thrown upon failing to transpile an invalid TS file.",
-      );
-    } catch (error: unknown) {
-      expect(error).toBeInstanceOf(TypeScriptCompileError);
-    }
-  });
+      await expect(
+        loader(filePath, readFixtureContent(filePath)),
+      ).rejects.toThrow();
+    });
 
-  describe("jiti", () => {
-    const unknownError = "Test Error";
+    it("should use the same instance of jiti across multiple calls", async () => {
+      const filePath = path.resolve(fixturesPath, "valid.fixture.ts");
+      await loader(filePath, readFixtureContent(filePath));
+      await loader(filePath, readFixtureContent(filePath));
+      expect(jitiCreateJitiSpy).toHaveBeenCalledTimes(1);
+    });
 
-    let stub: jest.SpyInstance;
+    it("should throw a TypeScriptCompileError on error", async () => {
+      try {
+        const filePath = path.resolve(fixturesPath, "invalid.fixture.ts");
+        await loader(filePath, readFixtureContent(filePath));
+        fail(
+          "Error should be thrown upon failing to transpile an invalid TS file.",
+        );
+      } catch (error: unknown) {
+        expect(error).toBeInstanceOf(TypeScriptCompileError);
+      }
+    });
+
+    describe("jiti", () => {
+      const unknownError = "Test Error";
+
+      beforeEach(() => {
+        jitiCreateJitiSpy.mockImplementation((() => ({
+          import: () => {
+            // eslint-disable-next-line @typescript-eslint/only-throw-error
+            throw unknownError;
+          },
+        })) as never);
+
+        loader = TypeScriptLoader();
+      });
+
+      it("rethrows an error if it is not an instance of Error", async () => {
+        try {
+          await loader("filePath", "readFixtureContent(filePath)");
+          fail(
+            "Error should be thrown upon failing to transpile an invalid TS file.",
+          );
+        } catch (error: unknown) {
+          expect(error).not.toBeInstanceOf(TypeScriptCompileError);
+          expect(error).toStrictEqual(unknownError);
+        }
+      });
+    });
+  });
+
+  describe("synchronous", () => {
+    let loader: LoaderSync;
 
     beforeEach(() => {
-      stub = jest.spyOn(jiti, "default").mockImplementation((() => () => {
-        // eslint-disable-next-line @typescript-eslint/only-throw-error
-        throw unknownError;
-      }) as never);
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      loader = TypeScriptLoaderSync();
+    });
 
-      loader = TypeScriptLoader();
+    it("should parse a valid TS file", () => {
+      const filePath = path.resolve(fixturesPath, "valid.fixture.ts");
+      loader(filePath, readFixtureContent(filePath));
+    });
+
+    it("should fail on parsing an invalid TS file", () => {
+      const filePath = path.resolve(fixturesPath, "invalid.fixture.ts");
+      expect((): unknown =>
+        loader(filePath, readFixtureContent(filePath)),
+      ).toThrow();
     });
 
-    afterEach(() => {
-      stub.mockRestore();
+    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(jitiCreateJitiSpy).toHaveBeenCalledTimes(1);
     });
 
-    it("rethrows an error if it is not an instance of Error", () => {
+    it("should throw a TypeScriptCompileError on error", () => {
       try {
-        loader("filePath", "readFixtureContent(filePath)");
+        const filePath = path.resolve(fixturesPath, "invalid.fixture.ts");
+        loader(filePath, readFixtureContent(filePath));
         fail(
           "Error should be thrown upon failing to transpile an invalid TS file.",
         );
       } catch (error: unknown) {
-        expect(error).not.toBeInstanceOf(TypeScriptCompileError);
-        expect(error).toStrictEqual(unknownError);
+        expect(error).toBeInstanceOf(TypeScriptCompileError);
       }
     });
+
+    describe("jiti", () => {
+      const unknownError = "Test Error";
+
+      beforeEach(() => {
+        jitiCreateJitiSpy.mockImplementation((() => () => {
+          // eslint-disable-next-line @typescript-eslint/only-throw-error
+          throw unknownError;
+        }) as never);
+
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        loader = TypeScriptLoaderSync();
+      });
+
+      it("rethrows an error if it is not an instance of Error", () => {
+        try {
+          loader("filePath", "readFixtureContent(filePath)");
+          fail(
+            "Error should be thrown upon failing to transpile an invalid TS file.",
+          );
+        } catch (error: unknown) {
+          expect(error).not.toBeInstanceOf(TypeScriptCompileError);
+          expect(error).toStrictEqual(unknownError);
+        }
+      });
+    });
   });
 });