feat: ✨ dynamically import astro plugin and parser

jimmy-guzman · Nov 8, 2024 · 1d982ef · 1d982ef
1 parent f6667f1
commit 1d982ef
Show file tree

Hide file tree

Showing 4 changed files with 55 additions and 44 deletions.
diff --git a/scripts/typegen.ts b/scripts/typegen.ts
@@ -3,7 +3,9 @@ import fs from "node:fs/promises";
 import { builtinRules } from "eslint/use-at-your-own-risk";
 import { flatConfigsToRulesDTS } from "eslint-typegen/core";
 
-import config from "../src";
+import jimmyDotCodes from "../src";
+
+const configs = await jimmyDotCodes();
 
 const ruleDts = await flatConfigsToRulesDTS(
   [
@@ -15,7 +17,7 @@ const ruleDts = await flatConfigsToRulesDTS(
       },
     },
     // @ts-expect-error TODO: config types don't seem to match
-    ...config(),
+    ...configs,
   ],
   {
     includeAugmentation: false,

diff --git a/src/configs/astro.ts b/src/configs/astro.ts
@@ -1,5 +1,3 @@
-import parserAstro from "astro-eslint-parser";
-import pluginAstro from "eslint-plugin-astro";
 import jsxA11y from "eslint-plugin-jsx-a11y";
 import globals from "globals";
 import { configs, parser as parserTs } from "typescript-eslint";
@@ -8,9 +6,14 @@ import type { TypedConfigItem } from "../types";
 
 import { GLOB_ASTRO } from "../constants";
 
-export const astroConfig = () => {
+export const astroConfig = async () => {
   const files = [GLOB_ASTRO];
 
+  const [pluginAstro, parserAstro] = await Promise.all([
+    import("eslint-plugin-astro"),
+    import("astro-eslint-parser"),
+  ]);
+
   return [
     {
       files,

diff --git a/src/factory.spec.ts b/src/factory.spec.ts
@@ -15,52 +15,54 @@ describe("jimmyDotCodes", () => {
       "prettier",
       "ignores",
       "javascript",
-    ])("should create configuration w/ %s", (input) => {
-      expect(jimmyDotCodes({ autoDetect: false })).toStrictEqual(
+    ])("should create configuration w/ %s", async (input) => {
+      await expect(jimmyDotCodes({ autoDetect: false })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.objectContaining({ name: `jimmy.codes/${input}` }),
         ]),
       );
     });
   });
 
-  it("should create configuration w/ typescript", () => {
-    expect(
+  it("should create configuration w/ typescript", async () => {
+    await expect(
       jimmyDotCodes({ autoDetect: false, typescript: true }),
-    ).toStrictEqual(
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/typescript" }),
         expect.objectContaining({ name: "jimmy.codes/imports/typescript" }),
       ]),
     );
   });
 
-  it("should create configuration w/ react", () => {
-    expect(jimmyDotCodes({ autoDetect: false, react: true })).toStrictEqual(
+  it("should create configuration w/ react", async () => {
+    await expect(
+      jimmyDotCodes({ autoDetect: false, react: true }),
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/react" }),
       ]),
     );
   });
 
-  it("should create configuration w/ react & @tanstack/query", () => {
-    expect(
+  it("should create configuration w/ react & @tanstack/query", async () => {
+    await expect(
       jimmyDotCodes({
         autoDetect: false,
         react: { utilities: ["@tanstack/query"] },
       }),
-    ).toStrictEqual(
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/react" }),
         expect.objectContaining({ name: "jimmy.codes/react/query" }),
       ]),
     );
   });
 
-  it("should create configuration w/ jest", () => {
-    expect(
+  it("should create configuration w/ jest", async () => {
+    await expect(
       jimmyDotCodes({ autoDetect: false, testing: { framework: "jest" } }),
-    ).toStrictEqual(
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/testing" }),
         expect.objectContaining({ name: "jimmy.codes/testing/disabled" }),
@@ -70,8 +72,10 @@ describe("jimmyDotCodes", () => {
     );
   });
 
-  it("should create configuration w/ vitest", () => {
-    expect(jimmyDotCodes({ autoDetect: false, testing: true })).toStrictEqual(
+  it("should create configuration w/ vitest", async () => {
+    await expect(
+      jimmyDotCodes({ autoDetect: false, testing: true }),
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/testing" }),
         expect.objectContaining({ name: "jimmy.codes/testing/disabled" }),
@@ -81,14 +85,14 @@ describe("jimmyDotCodes", () => {
     );
   });
 
-  it("should create configuration w/ jest & react & testing library", () => {
-    expect(
+  it("should create configuration w/ jest & react & testing library", async () => {
+    await expect(
       jimmyDotCodes({
         autoDetect: false,
         react: true,
         testing: { framework: "jest", utilities: ["testing-library"] },
       }),
-    ).toStrictEqual(
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/testing" }),
         expect.objectContaining({ name: "jimmy.codes/testing/disabled" }),
@@ -104,14 +108,14 @@ describe("jimmyDotCodes", () => {
     );
   });
 
-  it("should create configuration w/ vitest & react & testing library", () => {
-    expect(
+  it("should create configuration w/ vitest & react & testing library", async () => {
+    await expect(
       jimmyDotCodes({
         autoDetect: false,
         react: true,
         testing: { utilities: ["testing-library"] },
       }),
-    ).toStrictEqual(
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({ name: "jimmy.codes/testing" }),
         expect.objectContaining({ name: "jimmy.codes/testing/disabled" }),
@@ -127,8 +131,10 @@ describe("jimmyDotCodes", () => {
     );
   });
 
-  it("should create configuration w/ astro", () => {
-    expect(jimmyDotCodes({ astro: true, autoDetect: false })).toStrictEqual(
+  it("should create configuration w/ astro", async () => {
+    await expect(
+      jimmyDotCodes({ astro: true, autoDetect: false }),
+    ).resolves.toStrictEqual(
       expect.arrayContaining([
         expect.objectContaining({
           name: "jimmy.codes/astro",
@@ -144,12 +150,12 @@ describe("jimmyDotCodes", () => {
   });
 
   describe("autoDetect", () => {
-    it("should include typescript when auto detection is enabled", () => {
+    it("should include typescript when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         return name === "typescript";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.objectContaining({ name: "jimmy.codes/typescript" }),
           expect.not.objectContaining({ name: "jimmy.codes/testing" }),
@@ -164,12 +170,12 @@ describe("jimmyDotCodes", () => {
       );
     });
 
-    it("should include react when auto detection is enabled", () => {
+    it("should include react when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         return name === "react";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.not.objectContaining({ name: "jimmy.codes/typescript" }),
           expect.not.objectContaining({ name: "jimmy.codes/testing" }),
@@ -184,13 +190,13 @@ describe("jimmyDotCodes", () => {
       );
     });
 
-    it("should include react-query when auto detection is enabled", () => {
+    it("should include react-query when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         // eslint-disable-next-line jest/no-conditional-in-test -- this condition is only for the mock.
         return name === "react" || name === "@tanstack/react-query";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.not.objectContaining({ name: "jimmy.codes/typescript" }),
           expect.not.objectContaining({ name: "jimmy.codes/testing" }),
@@ -205,12 +211,12 @@ describe("jimmyDotCodes", () => {
       );
     });
 
-    it("should include vitest when auto detection is enabled", () => {
+    it("should include vitest when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         return name === "vitest";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.not.objectContaining({ name: "jimmy.codes/typescript" }),
           expect.objectContaining({ name: "jimmy.codes/testing" }),
@@ -225,12 +231,12 @@ describe("jimmyDotCodes", () => {
       );
     });
 
-    it("should include jest when auto detection is enabled", () => {
+    it("should include jest when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         return name === "jest";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.not.objectContaining({ name: "jimmy.codes/typescript" }),
           expect.objectContaining({ name: "jimmy.codes/testing" }),
@@ -245,13 +251,13 @@ describe("jimmyDotCodes", () => {
       );
     });
 
-    it("should include test-library when auto detection is enabled", () => {
+    it("should include test-library when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         // eslint-disable-next-line jest/no-conditional-in-test -- this condition is only for the mock.
         return name === "@testing-library/react" || name === "vitest";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.not.objectContaining({ name: "jimmy.codes/typescript" }),
           expect.objectContaining({ name: "jimmy.codes/testing" }),
@@ -266,12 +272,12 @@ describe("jimmyDotCodes", () => {
       );
     });
 
-    it("should include astro when auto detection is enabled", () => {
+    it("should include astro when auto detection is enabled", async () => {
       vi.mocked(isPackageExists).mockImplementation((name) => {
         return name === "astro";
       });
 
-      expect(jimmyDotCodes({ autoDetect: true })).toStrictEqual(
+      await expect(jimmyDotCodes({ autoDetect: true })).resolves.toStrictEqual(
         expect.arrayContaining([
           expect.objectContaining({
             name: "jimmy.codes/astro",

diff --git a/src/factory.ts b/src/factory.ts
@@ -18,7 +18,7 @@ import { unicornConfig } from "./configs/unicorn";
 import { hasAstro, hasReact, hasTesting, hasTypescript } from "./has-dep";
 import { reactOptions, testingOptions, typescriptOptions } from "./utils";
 
-export const jimmyDotCodes = (
+export const jimmyDotCodes = async (
   {
     astro = false,
     autoDetect = true,
@@ -44,7 +44,7 @@ export const jimmyDotCodes = (
     importsConfig({ typescript: isTypescriptEnabled }),
     isTypescriptEnabled ? typescriptConfig(typescriptOptions(typescript)) : [],
     isReactEnabled ? reactConfig(reactOptions(react), autoDetect) : [],
-    isAstroEnabled ? astroConfig() : [],
+    isAstroEnabled ? await astroConfig() : [],
     isTestingEnabled ? testingConfig(testingOptions(testing), autoDetect) : [],
     prettierConfig(),
     commonjsConfig(),