@vp-tw/eslint-config 0.0.9 → 0.0.11

package/dist/esm/configs/storybook.mjs

@@ -1,21 +1,79 @@
 import { ensurePackages, interopDefault } from "@antfu/eslint-config";
-import { renameRules } from "../utils/renameRules.mjs";
-const storybook = async () => {
+import { pick } from "es-toolkit";
+const configNamesMapSource = {
+  setup: "vdustr/stroybook/setup",
+  storiesRules: "vdustr/storybook/stories-rules",
+  mainRules: "vdustr/storybook/main-rules"
+};
+const storybookInternal = async (options) => {
   await ensurePackages(["eslint-plugin-storybook"]);
   const storybookPlugin = await interopDefault(
     import("eslint-plugin-storybook")
   );
-  return storybookPlugin.configs["flat/csf-strict"].map((config) => {
-    const allConfig = config;
-    const { rules, files, plugins, ...rest } = allConfig;
-    return {
-      ...rest,
-      ...!rules ? null : {
-        rules: renameRules(rules)
-      },
-      ...!files ? null : { files },
-      ...!plugins ? null : { plugins }
-    };
-  });
+  const inheritingConfigs = storybookPlugin.configs["flat/csf-strict"];
+  const originalSetupConfig = inheritingConfigs[0];
+  const originalStoryRulesConfig = inheritingConfigs[1];
+  const originalMainRulesConfig = inheritingConfigs[2];
+  const originalCsfStrictConfig = inheritingConfigs[3];
+  if (!originalSetupConfig) throw new Error("Missing setup config");
+  if (!originalStoryRulesConfig) throw new Error("Missing story rules config");
+  if (!originalMainRulesConfig) throw new Error("Missing main rules config");
+  if (!originalCsfStrictConfig) throw new Error("Missing csf strict config");
+  const setupConfig = {
+    ...pick(originalSetupConfig, ["plugins"]),
+    name: configNamesMapSource.setup
+  };
+  const storyRulesConfig = {
+    /**
+     * Inherited.
+     */
+    ...originalStoryRulesConfig,
+    ...originalCsfStrictConfig,
+    /**
+     * Default.
+     */
+    name: configNamesMapSource.storiesRules,
+    /**
+     * Overridable.
+     */
+    ...options?.storiesConfig,
+    rules: {
+      /**
+       * Inherited.
+       */
+      ...originalStoryRulesConfig.rules,
+      ...originalCsfStrictConfig.rules,
+      /**
+       * Default.
+       */
+      "import/no-default-export": "off",
+      /**
+       * Overridable.
+       */
+      ...options?.storiesConfig?.rules
+    }
+  };
+  const mainRulesConfig = {
+    /**
+     * Inherited.
+     */
+    ...originalMainRulesConfig,
+    /**
+     * Default.
+     */
+    name: configNamesMapSource.mainRules,
+    /**
+     * Overridable.
+     */
+    ...options?.mainConfig
+  };
+  return [
+    setupConfig,
+    storyRulesConfig,
+    mainRulesConfig
+  ];
 };
+const storybook = Object.assign(storybookInternal, {
+  configNamesMapSource
+});
 export { storybook };

package/dist/esm/eslint-typegen.mjs

@@ -1 +1 @@
-// This is a placeholder for `eslint-typegen.d.ts`.
+// Placeholder for `eslint-typegen.d.ts`.

package/dist/esm/extends/_utils.d.ts

@@ -0,0 +1,2 @@
+declare const ignoreKeys: ("plugins" | "rules")[];
+export { ignoreKeys };

package/dist/esm/extends/_utils.mjs

@@ -0,0 +1,2 @@
+const ignoreKeys = ["plugins", "rules"];
+export { ignoreKeys };

package/dist/esm/extends/imports.d.ts

@@ -0,0 +1,25 @@
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { ConfigOverrides, ResolveConfigNamesMap } from "../types";
+declare const configNamesMapSource: {
+    readonly imports: "vdustr/imports/rules";
+    readonly noDefaultExport: "vdustr/no-default-export/rules";
+};
+declare module "../types" {
+    interface ConfigNamesMap extends ResolveConfigNamesMap<imports.ConfigNamesMapSource> {
+    }
+}
+declare namespace imports {
+    type ConfigNamesMapSource = typeof configNamesMapSource;
+    interface Options {
+        imports?: ConfigOverrides;
+        noDefaultExport: ConfigOverrides;
+    }
+}
+declare const imports: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: imports.Options) => void) & {
+    configNamesMapSource: {
+        readonly imports: "vdustr/imports/rules";
+        readonly noDefaultExport: "vdustr/no-default-export/rules";
+    };
+};
+export { imports };

package/dist/esm/extends/imports.mjs

@@ -0,0 +1,87 @@
+import {
+  GLOB_ASTRO_TS,
+  GLOB_JS,
+  GLOB_JSX,
+  GLOB_MARKDOWN_CODE,
+  GLOB_TS,
+  GLOB_TSX
+} from "@antfu/eslint-config";
+import { omit } from "es-toolkit";
+import { GLOB_CONFIG_JS } from "../globs.mjs";
+import { extendsConfig } from "../utils/extendsConfig.mjs";
+import { ignoreKeys } from "./_utils.mjs";
+const configNamesMapSource = {
+  imports: "vdustr/imports/rules",
+  noDefaultExport: "vdustr/no-default-export/rules"
+};
+const importsInternal = (composer, options) => {
+  extendsConfig(composer, "antfu/imports/rules", (config) => [
+    config,
+    {
+      /**
+       * Inherited.
+       */
+      ...omit(config, ignoreKeys),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.imports,
+      /**
+       * Overridable.
+       */
+      ...options?.imports,
+      rules: {
+        /**
+         * Default.
+         */
+        /**
+         * Forbid `import {} from "module"`.
+         */
+        "import/no-empty-named-blocks": "error",
+        /**
+         * Wildcard imports can prevent tree shaking and cause name conflicts.
+         * Consider using named imports instead.
+         */
+        "import/no-namespace": "error",
+        /**
+         * Overridable.
+         */
+        ...options?.imports?.rules
+      }
+    },
+    {
+      name: configNamesMapSource.noDefaultExport,
+      /**
+       * Overridable.
+       */
+      ...options?.noDefaultExport,
+      rules: {
+        /**
+         * 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.
+         */
+        "import/no-default-export": "error",
+        ...options?.noDefaultExport?.rules
+      },
+      files: [
+        GLOB_JS,
+        GLOB_JSX,
+        GLOB_TS,
+        GLOB_TSX,
+        ...options?.noDefaultExport?.files || []
+      ],
+      ignores: [
+        // Configuration files
+        GLOB_CONFIG_JS,
+        GLOB_MARKDOWN_CODE,
+        GLOB_ASTRO_TS,
+        ...options?.noDefaultExport?.ignores || []
+      ]
+    }
+  ]);
+};
+const imports = Object.assign(importsInternal, {
+  configNamesMapSource
+});
+export { imports };

package/dist/esm/extends/javascript.d.ts

@@ -0,0 +1,21 @@
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { ConfigOverrides, ResolveConfigNamesMap } from "../types";
+declare const configNamesMapSource: {
+    readonly rules: "vdustr/javascript/rules";
+};
+declare module "../types" {
+    interface ConfigNamesMap extends ResolveConfigNamesMap<javascript.ConfigNamesMapSource> {
+    }
+}
+declare namespace javascript {
+    type ConfigNamesMapSource = typeof configNamesMapSource;
+    interface Options extends ConfigOverrides {
+    }
+}
+declare const javascript: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: javascript.Options) => void) & {
+    configNamesMapSource: {
+        readonly rules: "vdustr/javascript/rules";
+    };
+};
+export { javascript };

package/dist/esm/extends/javascript.mjs

@@ -0,0 +1,51 @@
+import { omit } from "es-toolkit";
+import { extendsConfig } from "../utils/extendsConfig.mjs";
+import { ignoreKeys } from "./_utils.mjs";
+const configNamesMapSource = {
+  rules: "vdustr/javascript/rules"
+};
+const javascriptInternal = (composer, options) => {
+  extendsConfig(composer, "antfu/javascript/rules", (config) => [
+    config,
+    {
+      /**
+       * Inherited.
+       */
+      ...omit(config, ignoreKeys),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.rules,
+      /**
+       * Overridable.
+       */
+      ...options,
+      rules: {
+        /**
+         * Default.
+         */
+        /**
+         * Some callbacks are purposefully named to make the code self-documenting.
+         */
+        "prefer-arrow-callback": "off",
+        /**
+         * This rule does not integrate well with JSDoc `@link` tags. It's advised
+         * to verify its behavior with TypeScript instead.
+         */
+        "no-unused-vars": "off",
+        "unused-imports/no-unused-vars": "off",
+        "unused-imports/no-unused-imports-ts": "off",
+        "unused-imports/no-unused-vars-ts": "off",
+        "unused-imports/no-unused-imports": "off",
+        /**
+         * Overridable.
+         */
+        ...options?.rules
+      }
+    }
+  ]);
+};
+const javascript = Object.assign(javascriptInternal, {
+  configNamesMapSource
+});
+export { javascript };

package/dist/esm/extends/jsonc.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { ConfigOverrides, ResolveConfigNamesMap } from "../types";
+declare const configNamesMapSource: {
+    readonly rules: "vdustr/jsonc/rules";
+    readonly sortArrayValues: "vdustr/jsonc/sortArrayValues";
+    readonly packageJsonSetup: "vdustr/package-json/setup";
+    readonly packageJsonRules: "vdustr/package-json/rules";
+};
+declare module "../types" {
+    interface ConfigNamesMap extends ResolveConfigNamesMap<jsonc.ConfigNamesMapSource> {
+    }
+}
+declare namespace jsonc {
+    type ConfigNamesMapSource = typeof configNamesMapSource;
+    interface Options {
+        jsonc?: ConfigOverrides;
+        packageJson?: ConfigOverrides;
+        sortArrayValues: ConfigOverrides;
+    }
+}
+declare const jsonc: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: jsonc.Options) => void) & {
+    configNamesMapSource: {
+        readonly rules: "vdustr/jsonc/rules";
+        readonly sortArrayValues: "vdustr/jsonc/sortArrayValues";
+        readonly packageJsonSetup: "vdustr/package-json/setup";
+        readonly packageJsonRules: "vdustr/package-json/rules";
+    };
+};
+export { jsonc };

package/dist/esm/extends/jsonc.mjs

@@ -0,0 +1,149 @@
+import { omit } from "es-toolkit";
+import packageJson from "eslint-plugin-package-json/configs/recommended";
+import {
+  GLOB_CODE_WORKSPACE,
+  GLOB_CSPELL_JSON,
+  GLOB_PACKAGE_JSON
+} from "../globs.mjs";
+import { extendsConfig } from "../utils/extendsConfig.mjs";
+import { ignoreKeys } from "./_utils.mjs";
+const configNamesMapSource = {
+  rules: "vdustr/jsonc/rules",
+  sortArrayValues: "vdustr/jsonc/sortArrayValues",
+  packageJsonSetup: "vdustr/package-json/setup",
+  packageJsonRules: "vdustr/package-json/rules"
+};
+const jsoncInternal = (composer, options) => {
+  extendsConfig(
+    composer,
+    "antfu/jsonc/rules",
+    (config) => {
+      config = {
+        ...config,
+        files: [
+          /**
+           * Inherited.
+           */
+          ...config.files ?? [],
+          /**
+           * Default.
+           */
+          GLOB_CODE_WORKSPACE,
+          /**
+           * Overridable.
+           */
+          ...options?.jsonc?.files ?? []
+        ],
+        ignores: [
+          /**
+           * Inherited.
+           */
+          ...config.ignores ?? [],
+          /**
+           * Default.
+           */
+          GLOB_PACKAGE_JSON,
+          /**
+           * Overridable.
+           */
+          ...options?.jsonc?.ignores ?? []
+        ]
+      };
+      return [
+        config,
+        {
+          /**
+           * Inherited.
+           */
+          ...omit(config, ignoreKeys),
+          /**
+           * Default.
+           */
+          name: configNamesMapSource.rules,
+          files: [...config.files ?? []],
+          ignores: [...config.ignores ?? []],
+          /**
+           * Overridable.
+           */
+          ...omit(options?.jsonc ?? {}, ["files", "ignores"]),
+          rules: {
+            /**
+             * Default.
+             */
+            "jsonc/sort-keys": "error",
+            /**
+             * Overridable.
+             */
+            ...options?.jsonc?.rules
+          }
+        },
+        {
+          plugins: packageJson.plugins,
+          name: configNamesMapSource.packageJsonSetup
+        },
+        {
+          /**
+           * Inherited.
+           */
+          ...omit(packageJson, ["plugins"]),
+          /**
+           * Default.
+           */
+          name: configNamesMapSource.packageJsonRules,
+          /**
+           * Overridable.
+           */
+          ...options?.packageJson,
+          plugins: {
+            /**
+             * Inherited.
+             */
+            ...packageJson.plugins,
+            /**
+             * Overridable.
+             */
+            ...options?.packageJson?.plugins
+          },
+          rules: {
+            /**
+             * Inherited.
+             */
+            ...packageJson.rules,
+            /**
+             * Overridable.
+             */
+            ...options?.packageJson?.rules
+          }
+        },
+        {
+          /**
+           * Default.
+           */
+          name: configNamesMapSource.sortArrayValues,
+          /**
+           * Overridable.
+           */
+          ...options?.sortArrayValues,
+          files: [GLOB_CSPELL_JSON, ...options?.sortArrayValues?.files ?? []],
+          rules: {
+            "jsonc/sort-array-values": [
+              "error",
+              {
+                pathPattern: ".*",
+                order: {
+                  type: "asc"
+                }
+              }
+            ],
+            ...options?.sortArrayValues?.rules
+          }
+        }
+      ];
+    },
+    ["antfu/sort/package-json", "antfu/sort/tsconfig-json"]
+  );
+};
+const jsonc = Object.assign(jsoncInternal, {
+  configNamesMapSource
+});
+export { jsonc };

package/dist/esm/extends/react.d.ts

@@ -0,0 +1,21 @@
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { ConfigOverrides, ResolveConfigNamesMap } from "../types";
+declare const configNamesMapSource: {
+    readonly rules: "vdustr/react/rules";
+};
+declare module "../types" {
+    interface ConfigNamesMap extends ResolveConfigNamesMap<react.ConfigNamesMapSource> {
+    }
+}
+declare namespace react {
+    type ConfigNamesMapSource = typeof configNamesMapSource;
+    interface Options extends ConfigOverrides {
+    }
+}
+declare const react: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: react.Options) => void) & {
+    configNamesMapSource: {
+        readonly rules: "vdustr/react/rules";
+    };
+};
+export { react };

package/dist/esm/extends/react.mjs

@@ -0,0 +1,58 @@
+import { omit } from "es-toolkit";
+import { reactCompiler } from "../lib/eslint-plugin-react-compiler.mjs";
+import { extendsConfig } from "../utils/extendsConfig.mjs";
+import { ignoreKeys } from "./_utils.mjs";
+const configNamesMapSource = {
+  rules: "vdustr/react/rules"
+};
+const reactInternal = (composer, options) => {
+  extendsConfig(composer, "antfu/react/rules", async (config) => [
+    config,
+    {
+      /**
+       * Inherited.
+       */
+      ...omit(config, ignoreKeys),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.rules,
+      plugins: {
+        /**
+         * Inherited.
+         */
+        ...config.plugins,
+        /**
+         * Default.
+         */
+        "react-compiler": await reactCompiler(),
+        /**
+         * Overridable.
+         */
+        ...options?.plugins
+      },
+      /**
+       * Overridable.
+       */
+      ...options,
+      rules: {
+        /**
+         * Default.
+         */
+        "react-compiler/react-compiler": "error",
+        /**
+         * Not all destructuring assignments are more readable than their alternatives.
+         */
+        "react/prefer-destructuring-assignment": "off",
+        /**
+         * Overridable.
+         */
+        ...options?.rules
+      }
+    }
+  ]);
+};
+const react = Object.assign(reactInternal, {
+  configNamesMapSource
+});
+export { react };

package/dist/esm/extends/typescript.d.ts

@@ -0,0 +1,21 @@
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { ConfigOverrides, ResolveConfigNamesMap } from "../types";
+declare const configNamesMapSource: {
+    readonly rules: "vdustr/typescript/rules";
+};
+declare module "../types" {
+    interface ConfigNamesMap extends ResolveConfigNamesMap<typescript.ConfigNamesMapSource> {
+    }
+}
+declare namespace typescript {
+    type ConfigNamesMapSource = typeof configNamesMapSource;
+    interface Options extends ConfigOverrides {
+    }
+}
+declare const typescript: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: typescript.Options) => void) & {
+    configNamesMapSource: {
+        readonly rules: "vdustr/typescript/rules";
+    };
+};
+export { typescript };

package/dist/esm/extends/typescript.mjs

@@ -0,0 +1,52 @@
+import { omit } from "es-toolkit";
+import { extendsConfig } from "../utils/extendsConfig.mjs";
+import { ignoreKeys } from "./_utils.mjs";
+const configNamesMapSource = {
+  rules: "vdustr/typescript/rules"
+};
+const typescriptInternal = (composer, options) => {
+  extendsConfig(composer, "antfu/typescript/rules", (config) => [
+    config,
+    {
+      /**
+       * Inherited.
+       */
+      ...omit(config, ignoreKeys),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.rules,
+      /**
+       * Overridable.
+       */
+      ...options,
+      rules: {
+        /**
+         * Default.
+         */
+        "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",
+        /**
+         * Overridable.
+         */
+        ...options?.rules
+      }
+    }
+  ]);
+};
+const typescript = Object.assign(typescriptInternal, {
+  configNamesMapSource
+});
+export { typescript };

package/dist/esm/extends/yaml.d.ts

@@ -0,0 +1,25 @@
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { ConfigOverrides, ResolveConfigNamesMap } from "../types";
+declare const configNamesMapSource: {
+    readonly rules: "vdustr/yaml/rules";
+    readonly sortKeys: "vdustr/yaml/sortKeys";
+};
+declare module "../types" {
+    interface ConfigNamesMap extends ResolveConfigNamesMap<yaml.ConfigNamesMapSource> {
+    }
+}
+declare namespace yaml {
+    type ConfigNamesMapSource = typeof configNamesMapSource;
+    interface Options {
+        yaml?: ConfigOverrides;
+        sortKeys?: ConfigOverrides;
+    }
+}
+declare const yaml: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: yaml.Options) => void) & {
+    configNamesMapSource: {
+        readonly rules: "vdustr/yaml/rules";
+        readonly sortKeys: "vdustr/yaml/sortKeys";
+    };
+};
+export { yaml };