@vp-tw/eslint-config 0.0.2 → 0.0.4

package/dist/esm/vdustr.mjs

@@ -1,20 +1,25 @@
 import antfu from "@antfu/eslint-config";
 import packageJson from "eslint-plugin-package-json/configs/recommended";
-import * as reactCompilerPlugin from "eslint-plugin-react-compiler";
+import { isPackageExists } from "local-pkg";
 import { mdx } from "./configs/mdx.mjs";
 import { prettier } from "./configs/prettier.mjs";
-import "./eslint-typegen.d";
+import { storybook } from "./configs/storybook.mjs";
+import { reactCompiler } from "./lib/eslint-plugin-react-compiler.mjs";
 const vdustr = (options, ...userConfigs) => {
-  const mdxOptions = options?.mdx ?? true;
+  const typescriptEnabled = isPackageExists("typescript");
   const jsoncEnabled = Boolean(options?.jsonc ?? true);
+  const reactEnabled = Boolean(options?.react ?? false);
+  const storybookEnabled = Boolean(options?.storybook ?? false);
+  const mdxOptions = options?.mdx ?? true;
   const defaultConfigs = [
     ...!jsoncEnabled ? [] : [packageJson],
     ...!mdxOptions ? [] : mdx({
       ...typeof mdxOptions !== "object" ? null : mdxOptions
     }),
+    ...!storybookEnabled ? [] : storybook,
     prettier
   ];
-  return antfu(
+  let config = antfu(
     {
       // We use `prettier`.
       stylistic: false,
@@ -22,10 +27,11 @@ const vdustr = (options, ...userConfigs) => {
     },
     ...defaultConfigs,
     ...userConfigs
-  ).override("antfu/javascript/rules", (config) => ({
-    ...config,
+  );
+  config = config.override("antfu/javascript/rules", (config2) => ({
+    ...config2,
     rules: {
-      ...config.rules,
+      ...config2.rules,
       /**
        * Some callbacks are purposefully named to make the code self-documenting.
        */
@@ -40,62 +46,103 @@ const vdustr = (options, ...userConfigs) => {
       "unused-imports/no-unused-vars-ts": "off",
       "unused-imports/no-unused-imports": "off"
     }
-  })).override("antfu/imports/rules", (config) => ({
-    ...config,
+  })).override("antfu/imports/rules", (config2) => ({
+    ...config2,
     rules: {
-      ...config.rules,
+      ...config2.rules,
       /**
        * Forbid `import {} from "module"`.
        */
-      "import/no-empty-named-blocks": "error"
-    }
-  })).override("antfu/typescript/rules", (config) => ({
-    ...config,
-    rules: {
-      ...config.rules,
-      "ts/array-type": ["error", { default: "generic" }],
+      "import/no-empty-named-blocks": "error",
       /**
-       * Namespaces are useful for centralizing the management of types. Just avoid
-       * overusing them with runtime code.
-       *
-       * - References:
-       *   - <https://x.com/mattpocockuk/status/1805606072167940167>
+       * Wildcard imports can prevent tree shaking and cause name conflicts.
+       * Consider using named imports instead.
        */
-      "ts/no-namespace": "off",
-      "ts/no-redeclare": "off",
+      "import/no-namespace": "error",
       /**
-       * Check for unused variables in TypeScript.
+       * Enforcing named exports improves consistency, enhances auto-completion and refactoring, and avoids issues
+       * with default export renaming. Additionally, default exports might lead to different behavior when transformed
+       * to CJS.
        */
-      "ts/no-unused-vars": "off"
+      "import/no-default-export": "error"
     }
-  })).override("antfu/jsonc/rules", (config) => ({
-    ...config,
+  })).insertAfter("antfu/imports/rules", {
+    name: "vdustr/allow-default-export",
     rules: {
-      ...config.rules,
-      "jsonc/sort-keys": "error"
+      "import/no-default-export": "off"
     },
-    files: [...config.files ?? [], "**/*.code-workspace"],
-    ignores: [
-      ...config.ignores ?? [],
-      /**
-       * Lint `package.json` files with `eslint-plugin-package-json` instead.
-       */
-      "**/package.json"
+    files: [
+      "**/*.config.*",
+      // Single file components
+      "**/*.vue",
+      "**/*.svelte"
     ]
-  })).remove("antfu/sort/package-json").remove("antfu/sort/tsconfig-json").override("antfu/react/rules", (config) => ({
-    ...config,
-    plugins: {
-      ...config.plugins,
-      "react-compiler": reactCompilerPlugin
-    },
-    rules: {
-      ...config.rules,
-      "react-compiler/react-compiler": "error",
-      /**
-       * Not all destructuring assignments are more readable than their alternatives.
-       */
-      "react/prefer-destructuring-assignment": "off"
-    }
-  }));
+  });
+  if (typescriptEnabled) {
+    config = config.override("antfu/typescript/rules", (config2) => ({
+      ...config2,
+      rules: {
+        ...config2.rules,
+        "ts/array-type": ["error", { default: "generic" }],
+        /**
+         * Namespaces are useful for centralizing the management of types. Just avoid
+         * overusing them with runtime code.
+         *
+         * - References:
+         *   - <https://x.com/mattpocockuk/status/1805606072167940167>
+         */
+        "ts/no-namespace": "off",
+        "ts/no-redeclare": "off",
+        /**
+         * Check for unused variables in TypeScript.
+         */
+        "ts/no-unused-vars": "off"
+      }
+    }));
+  }
+  if (jsoncEnabled) {
+    config = config.override("antfu/jsonc/rules", (config2) => ({
+      ...config2,
+      rules: {
+        ...config2.rules,
+        "jsonc/sort-keys": "error"
+      },
+      files: [...config2.files ?? [], "**/*.code-workspace"],
+      ignores: [
+        ...config2.ignores ?? [],
+        /**
+         * Lint `package.json` files with `eslint-plugin-package-json` instead.
+         */
+        "**/package.json"
+      ]
+    })).remove("antfu/sort/package-json").remove("antfu/sort/tsconfig-json");
+  }
+  if (reactEnabled) {
+    config = config.override("antfu/react/rules", (config2) => ({
+      ...config2,
+      plugins: {
+        ...config2.plugins,
+        "react-compiler": reactCompiler
+      },
+      rules: {
+        ...config2.rules,
+        "react-compiler/react-compiler": "error",
+        /**
+         * Not all destructuring assignments are more readable than their alternatives.
+         */
+        "react/prefer-destructuring-assignment": "off"
+      }
+    }));
+  }
+  if (storybookEnabled) {
+    config = config.override("storybook:csf:stories-rules", (config2) => ({
+      ...config2,
+      rules: {
+        ...config2.rules,
+        "import/no-default-export": "off"
+      }
+    }));
+  }
+  return config;
 };
 export { vdustr };

package/dist/lib/eslint-plugin-react-compiler.d.ts

@@ -1,13 +1,9 @@
-declare module "eslint-plugin-react-compiler" {
-    type Plugin = import("eslint").ESLint.Plugin;
-    type LegacyConfig = import("eslint").Linter.LegacyConfig;
-    interface ReactCompiler extends Plugin {
-        rules: NonNullable<Plugin["rules"]>;
-        configs: {
-            recommended: LegacyConfig;
-        };
-    }
-    const rules: ReactCompiler["rules"];
-    const configs: ReactCompiler["configs"];
-    export { configs, rules };
+import type { ESLint, Linter } from "eslint";
+interface ReactCompiler extends ESLint.Plugin {
+    rules: NonNullable<ESLint.Plugin["rules"]>;
+    configs: {
+        recommended: Linter.LegacyConfig;
+    };
 }
+declare const reactCompilerInternal: ReactCompiler;
+export { reactCompilerInternal as reactCompiler };

package/dist/lib/eslint-plugin-react-compiler.js

@@ -1 +1,10 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reactCompiler = void 0;
+var reactCompiler = _interopRequireWildcard(require("eslint-plugin-react-compiler"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const reactCompilerInternal = exports.reactCompiler = reactCompiler.default ?? reactCompiler;

package/dist/utils/renameRules.d.ts

@@ -0,0 +1,3 @@
+import { renameRules } from "@antfu/eslint-config";
+declare function renameRulesInternal(rules: Parameters<typeof renameRules>[0]): Record<string, any>;
+export { renameRulesInternal as renameRules };

package/dist/utils/renameRules.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renameRules = renameRulesInternal;
+var _eslintConfig = require("@antfu/eslint-config");
+function renameRulesInternal(rules) {
+  return (0, _eslintConfig.renameRules)(rules, _eslintConfig.defaultPluginRenaming);
+}

package/dist/vdustr.d.ts

@@ -1,9 +1,9 @@
 import type { Config } from "./types";
 import antfu from "@antfu/eslint-config";
 import { mdx } from "./configs/mdx";
-import "./eslint-typegen.d";
 type Options = NonNullable<Parameters<typeof antfu>[0]> & {
     mdx?: boolean | mdx.Options;
+    storybook?: boolean;
 };
 declare const vdustr: (options?: Options, ...userConfigs: Array<Config>) => import("eslint-flat-config-utils/index").FlatConfigComposer<import("@antfu/eslint-config").TypedFlatConfigItem, import("@antfu/eslint-config").ConfigNames>;
 export { vdustr };

package/dist/vdustr.js

@@ -6,27 +6,30 @@ Object.defineProperty(exports, "__esModule", {
 exports.vdustr = void 0;
 var _eslintConfig = _interopRequireDefault(require("@antfu/eslint-config"));
 var _recommended = _interopRequireDefault(require("eslint-plugin-package-json/configs/recommended"));
-var reactCompilerPlugin = _interopRequireWildcard(require("eslint-plugin-react-compiler"));
+var _localPkg = require("local-pkg");
 var _mdx = require("./configs/mdx");
 var _prettier = require("./configs/prettier");
-require("./eslint-typegen.d");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _storybook = require("./configs/storybook");
+var _eslintPluginReactCompiler = require("./lib/eslint-plugin-react-compiler");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const vdustr = (options, ...userConfigs) => {
-  const mdxOptions = options?.mdx ?? true;
+  const typescriptEnabled = (0, _localPkg.isPackageExists)("typescript");
   const jsoncEnabled = Boolean(options?.jsonc ?? true);
+  const reactEnabled = Boolean(options?.react ?? false);
+  const storybookEnabled = Boolean(options?.storybook ?? false);
+  const mdxOptions = options?.mdx ?? true;
   const defaultConfigs = [...(!jsoncEnabled ? [] : [_recommended.default]), ...(!mdxOptions ? [] : (0, _mdx.mdx)({
     ...(typeof mdxOptions !== "object" ? null : mdxOptions)
-  })), _prettier.prettier];
-  return (0, _eslintConfig.default)({
+  })), ...(!storybookEnabled ? [] : _storybook.storybook), _prettier.prettier];
+  let config = (0, _eslintConfig.default)({
     // We use `prettier`.
     stylistic: false,
     ...options
-  }, ...defaultConfigs, ...userConfigs).override("antfu/javascript/rules", config => ({
-    ...config,
+  }, ...defaultConfigs, ...userConfigs);
+  config = config.override("antfu/javascript/rules", config2 => ({
+    ...config2,
     rules: {
-      ...config.rules,
+      ...config2.rules,
       /**
        * Some callbacks are purposefully named to make the code self-documenting.
        */
@@ -41,62 +44,100 @@ const vdustr = (options, ...userConfigs) => {
       "unused-imports/no-unused-vars-ts": "off",
       "unused-imports/no-unused-imports": "off"
     }
-  })).override("antfu/imports/rules", config => ({
-    ...config,
+  })).override("antfu/imports/rules", config2 => ({
+    ...config2,
     rules: {
-      ...config.rules,
+      ...config2.rules,
       /**
        * Forbid `import {} from "module"`.
        */
-      "import/no-empty-named-blocks": "error"
-    }
-  })).override("antfu/typescript/rules", config => ({
-    ...config,
-    rules: {
-      ...config.rules,
-      "ts/array-type": ["error", {
-        default: "generic"
-      }],
+      "import/no-empty-named-blocks": "error",
       /**
-       * Namespaces are useful for centralizing the management of types. Just avoid
-       * overusing them with runtime code.
-       *
-       * - References:
-       *   - <https://x.com/mattpocockuk/status/1805606072167940167>
+       * Wildcard imports can prevent tree shaking and cause name conflicts.
+       * Consider using named imports instead.
        */
-      "ts/no-namespace": "off",
-      "ts/no-redeclare": "off",
+      "import/no-namespace": "error",
       /**
-       * Check for unused variables in TypeScript.
+       * Enforcing named exports improves consistency, enhances auto-completion and refactoring, and avoids issues
+       * with default export renaming. Additionally, default exports might lead to different behavior when transformed
+       * to CJS.
        */
-      "ts/no-unused-vars": "off"
+      "import/no-default-export": "error"
     }
-  })).override("antfu/jsonc/rules", config => ({
-    ...config,
+  })).insertAfter("antfu/imports/rules", {
+    name: "vdustr/allow-default-export",
     rules: {
-      ...config.rules,
-      "jsonc/sort-keys": "error"
+      "import/no-default-export": "off"
     },
-    files: [...(config.files ?? []), "**/*.code-workspace"],
-    ignores: [...(config.ignores ?? []),
-    /**
-     * Lint `package.json` files with `eslint-plugin-package-json` instead.
-     */
-    "**/package.json"]
-  })).remove("antfu/sort/package-json").remove("antfu/sort/tsconfig-json").override("antfu/react/rules", config => ({
-    ...config,
-    plugins: {
-      ...config.plugins,
-      "react-compiler": reactCompilerPlugin
-    },
-    rules: {
-      ...config.rules,
-      "react-compiler/react-compiler": "error",
+    files: ["**/*.config.*",
+    // Single file components
+    "**/*.vue", "**/*.svelte"]
+  });
+  if (typescriptEnabled) {
+    config = config.override("antfu/typescript/rules", config2 => ({
+      ...config2,
+      rules: {
+        ...config2.rules,
+        "ts/array-type": ["error", {
+          default: "generic"
+        }],
+        /**
+         * Namespaces are useful for centralizing the management of types. Just avoid
+         * overusing them with runtime code.
+         *
+         * - References:
+         *   - <https://x.com/mattpocockuk/status/1805606072167940167>
+         */
+        "ts/no-namespace": "off",
+        "ts/no-redeclare": "off",
+        /**
+         * Check for unused variables in TypeScript.
+         */
+        "ts/no-unused-vars": "off"
+      }
+    }));
+  }
+  if (jsoncEnabled) {
+    config = config.override("antfu/jsonc/rules", config2 => ({
+      ...config2,
+      rules: {
+        ...config2.rules,
+        "jsonc/sort-keys": "error"
+      },
+      files: [...(config2.files ?? []), "**/*.code-workspace"],
+      ignores: [...(config2.ignores ?? []),
       /**
-       * Not all destructuring assignments are more readable than their alternatives.
+       * Lint `package.json` files with `eslint-plugin-package-json` instead.
        */
-      "react/prefer-destructuring-assignment": "off"
-    }
-  }));
+      "**/package.json"]
+    })).remove("antfu/sort/package-json").remove("antfu/sort/tsconfig-json");
+  }
+  if (reactEnabled) {
+    config = config.override("antfu/react/rules", config2 => ({
+      ...config2,
+      plugins: {
+        ...config2.plugins,
+        "react-compiler": _eslintPluginReactCompiler.reactCompiler
+      },
+      rules: {
+        ...config2.rules,
+        "react-compiler/react-compiler": "error",
+        /**
+         * Not all destructuring assignments are more readable than their alternatives.
+         */
+        "react/prefer-destructuring-assignment": "off"
+      }
+    }));
+  }
+  if (storybookEnabled) {
+    config = config.override("storybook:csf:stories-rules", config2 => ({
+      ...config2,
+      rules: {
+        ...config2.rules,
+        "import/no-default-export": "off"
+      }
+    }));
+  }
+  return config;
 };
 exports.vdustr = vdustr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vp-tw/eslint-config",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "ViPro's ESLint configuration",
   "homepage": "https://github.com/vdustr/eslint-config",
   "author": {

package/scripts/typegen.ts

@@ -1,11 +1,12 @@
 import type { ESLint } from "eslint";
 import { rules as mdxRules } from "eslint-plugin-mdx/lib/rules";
-import reactCompiler from "eslint-plugin-react-compiler";
+
 import storybook from "eslint-plugin-storybook";
 import { pluginsToRulesDTS } from "eslint-typegen/core";
 import fs from "fs-extra";
 import path from "pathe";
 import { packageDirectory } from "pkg-dir";
+import { reactCompiler } from "../src/lib/eslint-plugin-react-compiler";
 
 (async () => {
   const pkgDir = await packageDirectory();

package/src/configs/mdx.ts

@@ -1,9 +1,9 @@
 import type { TypedFlatConfigItem } from "@antfu/eslint-config";
 import type { DistributiveOmit } from "@mui/types";
-import { defaultPluginRenaming, renameRules } from "@antfu/eslint-config";
 
 // eslint-disable-next-line import/no-namespace -- `mdx` exports the plugin as a namespace.
 import * as mdxPlugin from "eslint-plugin-mdx";
+import { renameRules } from "../utils/renameRules";
 
 namespace mdx {
   export interface Options
@@ -20,18 +20,15 @@ const mdx = ({
 }: mdx.Options = {}) => {
   const flatCodeBlocksOptions: TypedFlatConfigItem =
     typeof flatCodeBlocks !== "object" ? {} : flatCodeBlocks;
-  return [
+  const configs: Array<TypedFlatConfigItem> = [
     {
       name: "vdustr/mdx",
       ...mdxPlugin.flat,
       ...options,
       rules: {
-        ...renameRules(
-          {
-            ...mdxPlugin.flat.rules,
-          },
-          defaultPluginRenaming,
-        ),
+        ...renameRules({
+          ...mdxPlugin.flat.rules,
+        }),
         ...options.rules,
       },
       processor: mdxPlugin.createRemarkProcessor({
@@ -50,17 +47,15 @@ const mdx = ({
             ...mdxPlugin.flatCodeBlocks,
             ...flatCodeBlocksOptions,
             rules: {
-              ...renameRules(
-                {
-                  ...mdxPlugin.flatCodeBlocks.rules,
-                },
-                defaultPluginRenaming,
-              ),
+              ...renameRules({
+                ...mdxPlugin.flatCodeBlocks.rules,
+              }),
               ...flatCodeBlocksOptions.rules,
             },
           } satisfies TypedFlatConfigItem,
         ]),
-  ] satisfies Array<TypedFlatConfigItem>;
+  ];
+  return configs;
 };
 
 export { mdx };

package/src/lib/eslint-plugin-react-compiler.ts

@@ -1,13 +1,16 @@
-declare module "eslint-plugin-react-compiler" {
-  type Plugin = import("eslint").ESLint.Plugin;
-  type LegacyConfig = import("eslint").Linter.LegacyConfig;
-  interface ReactCompiler extends Plugin {
-    rules: NonNullable<Plugin["rules"]>;
-    configs: {
-      recommended: LegacyConfig;
-    };
-  }
-  const rules: ReactCompiler["rules"];
-  const configs: ReactCompiler["configs"];
-  export { configs, rules };
+import type { ESLint, Linter } from "eslint";
+// @ts-expect-error -- Untyped library.
+// eslint-disable-next-line import/no-namespace -- `react-compiler` exports the plugin as a namespace.
+import * as reactCompiler from "eslint-plugin-react-compiler";
+
+interface ReactCompiler extends ESLint.Plugin {
+  rules: NonNullable<ESLint.Plugin["rules"]>;
+  configs: {
+    recommended: Linter.LegacyConfig;
+  };
 }
+
+const reactCompilerInternal: ReactCompiler =
+  reactCompiler.default ?? reactCompiler;
+
+export { reactCompilerInternal as reactCompiler };

package/src/vdustr.ts

@@ -1,14 +1,15 @@
+// eslint-disable-next-line import/no-empty-named-blocks -- Type only import.
+import type {} from "./eslint-typegen";
 import type { Config } from "./types";
 import antfu from "@antfu/eslint-config";
+
 import packageJson from "eslint-plugin-package-json/configs/recommended";
 
-// eslint-disable-next-line import/no-namespace -- This is a cjs module.
-import * as reactCompilerPlugin from "eslint-plugin-react-compiler";
 import { isPackageExists } from "local-pkg";
 import { mdx } from "./configs/mdx";
 import { prettier } from "./configs/prettier";
 import { storybook } from "./configs/storybook";
-import "./eslint-typegen.d";
+import { reactCompiler } from "./lib/eslint-plugin-react-compiler";
 
 type Options = NonNullable<Parameters<typeof antfu>[0]> & {
   mdx?: boolean | mdx.Options;
@@ -154,7 +155,7 @@ const vdustr = (options?: Options, ...userConfigs: Array<Config>) => {
       ...config,
       plugins: {
         ...config.plugins,
-        "react-compiler": reactCompilerPlugin,
+        "react-compiler": reactCompiler,
       },
       rules: {
         ...config.rules,

package/tsconfig.json

@@ -1,4 +1,4 @@
 {
-  "exclude": ["configs", "./*.ts", "src/lib"],
+  "exclude": ["scripts", "./*.ts", "src/lib"],
   "extends": ["@vp-tw/tsconfig/base/bundler/tsconfig"]
 }