js-style-kit 0.2.11 → 0.3.0

package/dist/index.js

@@ -11,6 +11,7 @@ var configNames = {
   base: "base",
   disableTypeChecked: "typescript-eslint/disable-type-checked",
   ignores: "ignores",
+  import: "import",
   jsdoc: "jsdoc",
   markdown: "markdown",
   nextjs: "nextjs",
@@ -27,9 +28,30 @@ var configNames = {
   typescriptTesting: "tseslint-testing",
   unicorn: "unicorn"
 };
+var pluginPrefixMap = /* @__PURE__ */ new Map([
+  ["@typescript-eslint", configNames.typescript],
+  ["import", configNames.import],
+  ["import-x", configNames.import],
+  ["jest", configNames.testing],
+  ["jsdoc", configNames.jsdoc],
+  ["nextjs", configNames.nextjs],
+  ["perfectionist", configNames.perfectionist],
+  ["react", configNames.react],
+  ["react-compiler", configNames.reactCompiler],
+  ["react-hooks", configNames.react],
+  ["react-refresh", configNames.reactRefresh],
+  ["storybook", configNames.storybook],
+  ["turbo", configNames.turbo],
+  ["unicorn", configNames.unicorn],
+  ["vitest", configNames.testing]
+]);
 
 // src/eslint/base/rules.ts
-var baseEslintRules = (functionStyle) => ({
+var baseEslintRules = (functionStyle, typescript) => ({
+  ...!typescript ? {
+    "no-unused-expressions": "warn",
+    "no-unused-vars": "warn"
+  } : {},
   /**
    * Require return statements in array methods callbacks.
    *
@@ -84,10 +106,8 @@ var baseEslintRules = (functionStyle) => ({
    * 🚫 Not fixable - https://eslint.org/docs/rules/func-names
    */
   "func-names": ["warn", "as-needed"],
-  "func-style": (
-    // if arrow function, we use the prefer-arrow-functions plugin
-    functionStyle === "off" || functionStyle === "arrow" ? "off" : ["warn", functionStyle, { allowArrowFunctions: true }]
-  ),
+  // if arrow function, we use the prefer-arrow-functions plugin
+  ...functionStyle === "off" ? { "func-style": "off" } : functionStyle === "arrow" ? { "func-style": "off" } : { "func-style": ["warn", functionStyle, { allowArrowFunctions: true }] },
   /**
    * Require grouped accessor pairs in object literals and classes.
    *
@@ -451,13 +471,17 @@ var baseEslintRules = (functionStyle) => ({
 });
 
 // src/eslint/base/config.ts
-var baseEslintConfig = (functionStyle) => ({
+var baseEslintConfig = (functionStyle, typescript, customRules) => ({
   languageOptions: {
-    ecmaVersion: 2022
+    ecmaVersion: "latest",
+    sourceType: "module"
   },
   linterOptions: { reportUnusedDisableDirectives: true },
   name: configNames.base,
-  rules: baseEslintRules(functionStyle)
+  rules: {
+    ...baseEslintRules(functionStyle, typescript),
+    ...customRules ?? {}
+  }
 });
 
 // src/eslint/ignores.ts
@@ -467,9 +491,7 @@ var ignoresConfig = ({
   userIgnores = []
 } = {}) => ({
   ignores: [
-    "**/node_modules/",
     "**/dist/",
-    ".git/",
     ...next ? [".next"] : [],
     ...storybook ? ["!.storybook"] : [],
     ...userIgnores
@@ -477,6 +499,110 @@ var ignoresConfig = ({
   name: configNames.ignores
 });
 
+// src/eslint/import/config.ts
+import tsParser from "@typescript-eslint/parser";
+import { createTypeScriptImportResolver } from "eslint-import-resolver-typescript";
+import importXPlugin from "eslint-plugin-import-x";
+
+// src/eslint/import/rules.ts
+var importRules = (typescript) => ({
+  // these rules are better handled by typescript
+  ...!typescript ? {
+    "import-x/default": "warn",
+    "import-x/export": "warn",
+    "import-x/named": "warn",
+    "import-x/namespace": "warn",
+    "import-x/no-unresolved": "warn"
+  } : {},
+  /**
+   * Disallow non-import statements appearing before import statements.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/first.md
+   */
+  "import-x/first": "warn",
+  /**
+   * Require a newline after the last import-x/require.
+   *
+   * 🔧 Fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/newline-after-import.md
+   */
+  "import-x/newline-after-import": "warn",
+  /**
+   * Disallow import of modules using absolute paths.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-absolute-path.md
+   */
+  "import-x/no-absolute-path": "warn",
+  /**
+   * Disallow cyclical dependencies between modules.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-cycle.md
+   */
+  "import-x/no-cycle": "warn",
+  "import-x/no-duplicates": "warn",
+  /**
+   * Disallow the use of extraneous packages.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-extraneous-dependencies.md
+   */
+  "import-x/no-extraneous-dependencies": ["warn", { includeTypes: true }],
+  /**
+   * Disallow mutable exports.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-mutable-exports.md
+   */
+  "import-x/no-mutable-exports": "warn",
+  // red flags (thus, warnings)
+  "import-x/no-named-as-default": "warn",
+  "import-x/no-named-as-default-member": "warn",
+  /**
+   * Disallow importing packages through relative paths.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-relative-packages.md
+   */
+  "import-x/no-relative-packages": "warn",
+  /**
+   * Disallow a module from importing itself.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-self-import.md
+   */
+  "import-x/no-self-import": "warn",
+  /**
+   * Ensures that there are no useless path segments.
+   *
+   * 🚫 Not fixable - https://github.com/import-js/eslint-plugin-import-x/blob/main/docs/rules/no-useless-path-segments.md
+   */
+  "import-x/no-useless-path-segments": ["warn"]
+});
+
+// src/eslint/import/config.ts
+var importConfig = (typescript, customRules) => ({
+  languageOptions: {
+    ecmaVersion: "latest",
+    parser: tsParser,
+    sourceType: "module"
+  },
+  name: configNames.import,
+  plugins: {
+    "import-x": importXPlugin
+  },
+  rules: {
+    ...importRules(typescript),
+    ...customRules ?? {}
+  },
+  settings: {
+    "import-x/resolver": {
+      node: true,
+      typescript
+    },
+    "import-x/resolver-next": [
+      createTypeScriptImportResolver({
+        alwaysTryTypes: true,
+        bun: true
+      })
+    ]
+  }
+});
+
 // src/eslint/jsdoc/config.ts
 import jsdoc from "eslint-plugin-jsdoc";
 
@@ -551,14 +677,17 @@ var jsdocRules = (requireJsdoc = false, typescript = true) => ({
 });
 
 // src/eslint/jsdoc/config.ts
-var jsdocConfig = (requireJsdoc = false, typescript = true) => ({
+var jsdocConfig = (requireJsdoc = false, customRules) => ({
   files: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
   ignores: ["**/*.{test,spec}.{js,jsx,ts,tsx,cjs,mjs}"],
   name: configNames.jsdoc,
   plugins: {
     jsdoc
   },
-  rules: jsdocRules(requireJsdoc, typescript)
+  rules: {
+    ...jsdocRules(requireJsdoc),
+    ...customRules ?? {}
+  }
 });
 
 // src/eslint/nextjs/config.ts
@@ -590,12 +719,15 @@ var nextjsRules = {
 };
 
 // src/eslint/nextjs/config.ts
-var nextjsConfig = () => ({
+var nextjsConfig = (customRules) => ({
   name: configNames.nextjs,
   plugins: {
     nextjs
   },
-  rules: nextjsRules
+  rules: {
+    ...nextjsRules,
+    ...customRules ?? {}
+  }
 });
 
 // src/eslint/perfectionist/config.ts
@@ -630,17 +762,20 @@ var perfectionistRules = {
 };
 
 // src/eslint/perfectionist/config.ts
-var perfectionistConfig = {
+var perfectionistConfig = (customRules) => ({
   name: configNames.perfectionist,
   plugins: {
     perfectionist
   },
-  rules: perfectionistRules
-};
+  rules: {
+    ...perfectionistRules,
+    ...customRules ?? {}
+  }
+});
 
 // src/eslint/prefer-arrow-function/config.ts
 import preferArrowFunctions from "eslint-plugin-prefer-arrow-functions";
-var preferArrowFunctionConfig = () => ({
+var preferArrowFunctionConfig = (customRules) => ({
   name: configNames.preferArrowFunction,
   plugins: {
     "prefer-arrow-functions": preferArrowFunctions
@@ -652,21 +787,59 @@ var preferArrowFunctionConfig = () => ({
         returnStyle: "unchanged",
         singleReturnOnly: false
       }
-    ]
+    ],
+    ...customRules ?? {}
   }
 });
 
+// src/eslint/process-custom-rules.ts
+var processCustomRules = (customRules) => {
+  const categorizedRules = Object.values(configNames).reduce(
+    (acc, configName) => {
+      acc[configName] = {};
+      return acc;
+    },
+    {}
+  );
+  for (const [ruleKey, ruleValue] of Object.entries(customRules)) {
+    if (!ruleKey.includes("/") && !ruleKey.startsWith("@")) {
+      categorizedRules[configNames.base][ruleKey] = ruleValue;
+      continue;
+    }
+    let prefix = null;
+    if (ruleKey.startsWith("@")) {
+      const firstSlashIndex = ruleKey.indexOf("/");
+      if (firstSlashIndex !== -1) {
+        prefix = ruleKey.substring(0, firstSlashIndex);
+      }
+    } else {
+      const firstSlashIndex = ruleKey.indexOf("/");
+      if (firstSlashIndex !== -1) {
+        prefix = ruleKey.substring(0, firstSlashIndex);
+      }
+    }
+    const configName = prefix ? pluginPrefixMap.get(prefix) ?? configNames.base : configNames.base;
+    categorizedRules[configName][ruleKey] = ruleValue;
+  }
+  return Object.entries(categorizedRules).reduce((acc, [configName, rules2]) => {
+    if (Object.keys(rules2).length > 0) {
+      acc[configName] = rules2;
+    }
+    return acc;
+  }, {});
+};
+
 // src/eslint/react-compiler/config.ts
 import reactCompiler from "eslint-plugin-react-compiler";
-var reactCompilerEslintConfig = {
+var reactCompilerEslintConfig = (customRules) => ({
   name: configNames.reactCompiler,
   plugins: {
     "react-compiler": reactCompiler
   },
-  rules: {
+  rules: customRules ?? {
     "react-compiler/react-compiler": "warn"
   }
-};
+});
 
 // src/eslint/react-refresh/config.ts
 import reactRefresh from "eslint-plugin-react-refresh";
@@ -688,13 +861,13 @@ var reactRefreshRules = {
 };
 
 // src/eslint/react-refresh/config.ts
-var reactRefreshEslintConfig = () => {
+var reactRefreshEslintConfig = (customRules) => {
   return {
     name: configNames.reactRefresh,
     plugins: {
       "react-refresh": reactRefresh
     },
-    rules: reactRefreshRules
+    rules: customRules ?? reactRefreshRules
   };
 };
 
@@ -833,7 +1006,7 @@ var reactRules = (functionStyle, typescript) => {
 };
 
 // src/eslint/react/config.ts
-var reactEslintConfig = (functionStyle, typescript) => {
+var reactEslintConfig = (functionStyle, typescript, customRules) => {
   return {
     languageOptions: {
       globals: {
@@ -850,7 +1023,10 @@ var reactEslintConfig = (functionStyle, typescript) => {
       react,
       "react-hooks": pluginReactHooks
     },
-    rules: reactRules(functionStyle, typescript),
+    rules: {
+      ...reactRules(functionStyle, typescript),
+      ...customRules ?? {}
+    },
     settings: {
       react: {
         version: "detect"
@@ -861,7 +1037,7 @@ var reactEslintConfig = (functionStyle, typescript) => {
 
 // src/eslint/storybook/config.ts
 import storybookPlugin from "eslint-plugin-storybook";
-var storybookConfig = [
+var storybookConfig = (customRules) => [
   {
     files: [
       "**/*.stories.@(ts|tsx|js|jsx|mjs|cjs)",
@@ -872,6 +1048,7 @@ var storybookConfig = [
       storybook: storybookPlugin
     },
     rules: {
+      // Default Storybook rules
       "import/no-anonymous-default-export": "off",
       "react-hooks/rules-of-hooks": "off",
       "storybook/await-interactions": "warn",
@@ -884,7 +1061,9 @@ var storybookConfig = [
       "storybook/prefer-pascal-case": "warn",
       "storybook/story-exports": "warn",
       "storybook/use-storybook-expect": "warn",
-      "storybook/use-storybook-testing-library": "warn"
+      "storybook/use-storybook-testing-library": "warn",
+      // Merge custom rules
+      ...customRules ?? {}
     }
   },
   {
@@ -1003,7 +1182,7 @@ var testingConfig = ({
   formattingRules: true,
   framework: "vitest",
   itOrTest: "test"
-}) => ({
+}, customRules) => ({
   files: files ?? ["**/*.{test,spec}.{ts,tsx,js,jsx}"],
   languageOptions: {
     globals: framework === "vitest" ? { ...vitest.environments.env.globals } : jest.environments.globals.globals
@@ -1032,7 +1211,8 @@ var testingConfig = ({
       "jest/padding-around-describe-blocks": "warn",
       "jest/padding-around-expect-groups": "warn",
       "jest/padding-around-test-blocks": "warn"
-    } : {}
+    } : {},
+    ...customRules ?? {}
   },
   ...framework !== "jest" && framework !== "vitest" ? {
     settings: {
@@ -1045,12 +1225,12 @@ var testingConfig = ({
 
 // src/eslint/turbo/config.ts
 import turbo from "eslint-plugin-turbo";
-var turboConfig = () => ({
+var turboConfig = (customRules) => ({
   name: configNames.turbo,
   plugins: {
     turbo
   },
-  rules: {
+  rules: customRules ?? {
     "turbo/no-undeclared-env-vars": "warn"
   }
 });
@@ -1150,7 +1330,12 @@ var tseslintRules = {
   "@typescript-eslint/prefer-includes": "warn",
   "@typescript-eslint/prefer-literal-enum-member": "warn",
   "@typescript-eslint/prefer-namespace-keyword": "warn",
-  "@typescript-eslint/prefer-nullish-coalescing": "warn",
+  "@typescript-eslint/prefer-nullish-coalescing": [
+    "warn",
+    {
+      ignorePrimitives: { string: true }
+    }
+  ],
   "@typescript-eslint/prefer-optional-chain": "warn",
   "@typescript-eslint/prefer-promise-reject-errors": "warn",
   "@typescript-eslint/prefer-reduce-type-parameter": "warn",
@@ -1191,7 +1376,7 @@ var tseslintRules = {
 };
 
 // src/eslint/typescript/config.ts
-var tseslintConfig = (tsconfigPath) => {
+var tseslintConfig = (tsconfigPath, customRules) => {
   const userCwd = process.cwd();
   return tseslint.config(
     {
@@ -1206,7 +1391,10 @@ var tseslintConfig = (tsconfigPath) => {
       plugins: {
         "@typescript-eslint": tseslint.plugin
       },
-      rules: tseslintRules
+      rules: {
+        ...tseslintRules,
+        ...customRules ?? {}
+      }
     },
     {
       // disable type-aware linting on JS files
@@ -1296,108 +1484,138 @@ var rules = {
 };
 
 // src/eslint/unicorn/config.ts
-var unicornConfig = {
+var unicornConfig = (customRules) => ({
   name: configNames.unicorn,
   plugins: {
     unicorn
   },
-  rules
-};
+  rules: {
+    ...rules,
+    ...customRules ?? {}
+  }
+});
 
 // src/eslint/index.ts
+var defaultTestingConfig = {
+  filenamePattern: "test",
+  files: ["**/*.{test,spec}.{ts,tsx,js,jsx}"],
+  formattingRules: true,
+  framework: "vitest",
+  itOrTest: "it"
+};
 var eslintConfig = ({
   functionStyle = "arrow",
   ignores = [],
+  importPlugin = true,
   jsdoc: jsdoc2 = { requireJsdoc: false },
   react: react2 = false,
+  rules: rules2,
   sorting = true,
   storybook = false,
-  testing,
-  /**
-   * Some preceding documentation...
-   *
-   * @param options.turbo - Whether to include Turborepo rules. Defaults to false.
-   *
-   * Some following documentation...
-   */
+  testing = defaultTestingConfig,
   turbo: turbo2 = false,
   typescript = true,
   unicorn: unicorn2 = true
 } = {}, ...additionalConfigs) => {
+  const categorizedRules = rules2 === void 0 ? {} : processCustomRules(rules2);
+  const usingNextjs = isObject(react2) && react2.framework === "next";
   const configs = [
     ignoresConfig({
-      next: isObject(react2) && (react2.framework === "next" || react2.next === true),
+      next: usingNextjs,
       storybook,
       userIgnores: ignores
     }),
-    baseEslintConfig(functionStyle)
+    baseEslintConfig(
+      functionStyle,
+      Boolean(typescript),
+      categorizedRules[configNames.base]
+    )
   ];
   if (jsdoc2 !== false) {
-    configs.push(jsdocConfig(jsdoc2.requireJsdoc ?? false));
+    configs.push(
+      jsdocConfig(
+        jsdoc2.requireJsdoc ?? false,
+        categorizedRules[configNames.jsdoc]
+      )
+    );
   }
   if (typescript) {
     configs.push(
       ...tseslintConfig(
-        isString(typescript) ? typescript : void 0
+        isString(typescript) ? typescript : void 0,
+        categorizedRules[configNames.typescript]
       )
     );
   }
+  if (importPlugin) {
+    configs.push(
+      importConfig(Boolean(typescript), categorizedRules[configNames.import])
+    );
+  }
   if (react2) {
-    configs.push(reactEslintConfig(functionStyle, Boolean(typescript)));
-    const shouldUseReactCompiler = react2 === true || isObject(react2) && react2.reactCompiler !== false;
-    if (shouldUseReactCompiler) {
-      configs.push(reactCompilerEslintConfig);
-    }
-    const isNextFramework = isObject(react2) && (react2.framework === "next" || react2.next === true && react2.framework === void 0);
-    if (isNextFramework) {
-      configs.push(nextjsConfig());
-    }
     const shouldUseReactRefresh = (
       // Explicit setting takes precedence
       isObject(react2) && react2.reactRefresh === true || // Framework-based default (vite/none use reactRefresh by default)
       isObject(react2) && (react2.framework === "vite" || react2.framework === "none") && react2.reactRefresh !== false
     );
     if (shouldUseReactRefresh) {
-      configs.push(reactRefreshEslintConfig());
+      configs.push(
+        reactRefreshEslintConfig(categorizedRules[configNames.reactRefresh])
+      );
+    }
+    configs.push(
+      reactEslintConfig(
+        functionStyle,
+        Boolean(typescript),
+        categorizedRules[configNames.react]
+      )
+    );
+    const shouldUseReactCompiler = react2 === true || isObject(react2) && react2.reactCompiler !== false;
+    if (shouldUseReactCompiler) {
+      configs.push(
+        reactCompilerEslintConfig(categorizedRules[configNames.reactCompiler])
+      );
+    }
+    if (usingNextjs) {
+      configs.push(nextjsConfig(categorizedRules[configNames.nextjs]));
     }
   }
   if (testing !== false) {
-    const defaultTestingConfig = {
-      filenamePattern: "test",
-      files: ["**/*.{test,spec}.{ts,tsx,js,jsx}"],
-      formattingRules: true,
-      framework: "vitest",
-      itOrTest: "it"
-    };
-    const mergedTestingConfig = {
-      ...defaultTestingConfig,
-      ...isObject(testing) ? testing : {}
-    };
+    const mergedTestingConfig = isObject(testing) ? { ...defaultTestingConfig, ...testing } : defaultTestingConfig;
     const { filenamePattern, files, formattingRules, framework, itOrTest } = mergedTestingConfig;
     configs.push(
-      testingConfig({
-        filenamePattern,
-        files,
-        formattingRules,
-        framework,
-        itOrTest
-      })
+      testingConfig(
+        {
+          filenamePattern,
+          files,
+          formattingRules,
+          framework,
+          itOrTest
+        },
+        categorizedRules[configNames.testing]
+      )
     );
   }
   if (sorting) {
-    configs.push(perfectionistConfig);
+    configs.push(
+      perfectionistConfig(categorizedRules[configNames.perfectionist])
+    );
   }
   if (unicorn2) {
-    configs.push(unicornConfig);
+    configs.push(unicornConfig(categorizedRules[configNames.unicorn]));
   }
   if (functionStyle === "arrow") {
-    configs.push(preferArrowFunctionConfig());
+    configs.push(
+      preferArrowFunctionConfig(
+        categorizedRules[configNames.preferArrowFunction]
+      )
+    );
   }
   if (storybook) {
-    configs.push(...storybookConfig);
+    configs.push(...storybookConfig(categorizedRules[configNames.storybook]));
   }
   if (turbo2) {
-    configs.push(turboConfig());
+    configs.push(turboConfig(categorizedRules[configNames.turbo]));
   }
   if (additionalConfigs.length > 0) {
     configs.push(...additionalConfigs);