@vp-tw/eslint-config 0.0.14 → 0.0.16

package/dist/esm/extends/imports.mjs

@@ -6,80 +6,69 @@ import {
   GLOB_TS,
   GLOB_TSX
 } from "@antfu/eslint-config";
-import { omit } from "es-toolkit";
+import defu from "defu";
+import { omit, pick } 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"
+  noDefaultExport: "vdustr/imports/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
+  extendsConfig(composer, "antfu/imports/rules", (config) => {
+    const modifiedConfig = defu(pick(options?.imports ?? {}, ["files", "ignores"]), config);
+    const omittedConfig = omit(modifiedConfig, ignoreKeys);
+    const rulesConfig = defu(
+      omit(options?.imports ?? {}, ["files", "ignores"]),
+      {
+        name: configNamesMapSource.imports,
+        rules: {
+          /**
+           * 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"
+        }
       },
-      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 || []
-      ]
-    }
-  ]);
+      omittedConfig
+    );
+    const noDefaultExportConfig = defu(
+      options?.noDefaultExport,
+      {
+        name: configNamesMapSource.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"
+        },
+        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 || []
+        ]
+      },
+      omit(omittedConfig, ["files", "ignores"])
+    );
+    return [modifiedConfig, rulesConfig, noDefaultExportConfig];
+  });
 };
 const imports = Object.assign(importsInternal, {
   configNamesMapSource

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

@@ -2,7 +2,7 @@ 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";
+    readonly javascript: "vdustr/javascript/rules";
 };
 declare module "../types" {
     interface ConfigNamesMap extends ResolveConfigNamesMap<javascript.ConfigNamesMapSource> {
@@ -10,12 +10,13 @@ declare module "../types" {
 }
 declare namespace javascript {
     type ConfigNamesMapSource = typeof configNamesMapSource;
-    interface Options extends ConfigOverrides {
+    interface Options {
+        javascript?: ConfigOverrides;
     }
 }
 declare const javascript: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: javascript.Options) => void) & {
     configNamesMapSource: {
-        readonly rules: "vdustr/javascript/rules";
+        readonly javascript: "vdustr/javascript/rules";
     };
 };
 export { javascript };

package/dist/esm/extends/javascript.mjs

@@ -1,49 +1,38 @@
-import { omit } from "es-toolkit";
+import defu from "defu";
+import { omit, pick } from "es-toolkit";
 import { extendsConfig } from "../utils/extendsConfig.mjs";
 import { ignoreKeys } from "./_utils.mjs";
 const configNamesMapSource = {
-  rules: "vdustr/javascript/rules"
+  javascript: "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
-      }
-    }
-  ]);
+  extendsConfig(composer, "antfu/javascript/rules", (config) => {
+    const modifiedConfig = defu(pick(options?.javascript ?? {}, ["files", "ignores"]), config);
+    const omittedConfig = omit(modifiedConfig, ignoreKeys);
+    const rulesConfig = defu(
+      omit(options?.javascript ?? {}, ["files", "ignores"]),
+      {
+        name: configNamesMapSource.javascript,
+        rules: {
+          /**
+           * 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"
+        }
+      },
+      omittedConfig
+    );
+    return [modifiedConfig, rulesConfig];
+  });
 };
 const javascript = Object.assign(javascriptInternal, {
   configNamesMapSource

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

@@ -2,8 +2,8 @@ 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 jsonc: "vdustr/jsonc/rules";
+    readonly sortArrayValues: "vdustr/jsonc/sort-array-values/rules";
     readonly packageJsonSetup: "vdustr/package-json/setup";
     readonly packageJsonRules: "vdustr/package-json/rules";
 };
@@ -15,14 +15,14 @@ declare namespace jsonc {
     type ConfigNamesMapSource = typeof configNamesMapSource;
     interface Options {
         jsonc?: ConfigOverrides;
+        sortArrayValues?: ConfigOverrides;
         packageJson?: ConfigOverrides;
-        sortArrayValues: ConfigOverrides;
     }
 }
-declare const jsonc: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: jsonc.Options) => void) & {
+declare const jsonc: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: jsonc.Options) => Promise<void>) & {
     configNamesMapSource: {
-        readonly rules: "vdustr/jsonc/rules";
-        readonly sortArrayValues: "vdustr/jsonc/sortArrayValues";
+        readonly jsonc: "vdustr/jsonc/rules";
+        readonly sortArrayValues: "vdustr/jsonc/sort-array-values/rules";
         readonly packageJsonSetup: "vdustr/package-json/setup";
         readonly packageJsonRules: "vdustr/package-json/rules";
     };

package/dist/esm/extends/jsonc.mjs

@@ -1,5 +1,6 @@
-import { omit } from "es-toolkit";
-import packageJson from "eslint-plugin-package-json/configs/recommended";
+import { ensurePackages, interopDefault } from "@antfu/eslint-config";
+import defu from "defu";
+import { omit, pick } from "es-toolkit";
 import {
   GLOB_CODE_WORKSPACE,
   GLOB_CSPELL_JSON,
@@ -8,64 +9,29 @@ import {
 import { extendsConfig } from "../utils/extendsConfig.mjs";
 import { ignoreKeys } from "./_utils.mjs";
 const configNamesMapSource = {
-  rules: "vdustr/jsonc/rules",
-  sortArrayValues: "vdustr/jsonc/sortArrayValues",
+  jsonc: "vdustr/jsonc/rules",
+  sortArrayValues: "vdustr/jsonc/sort-array-values/rules",
   packageJsonSetup: "vdustr/package-json/setup",
   packageJsonRules: "vdustr/package-json/rules"
 };
-const jsoncInternal = (composer, options) => {
+const jsoncInternal = async (composer, options) => {
+  await ensurePackages(["eslint-plugin-package-json"]);
+  const packageJson = await interopDefault(
+    import("eslint-plugin-package-json/configs/recommended")
+  );
   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,
+      const modifiedConfig = defu(pick(options?.jsonc ?? {}, ["files", "ignores"]), config, {
+        files: [GLOB_CODE_WORKSPACE],
+        ignores: [GLOB_PACKAGE_JSON]
+      });
+      const omittedConfig = omit(modifiedConfig, ignoreKeys);
+      const rulesConfig = defu(
+        omit(options?.jsonc ?? {}, ["files", "ignores"]),
         {
-          /**
-           * Inherited.
-           */
-          ...omit(config, ignoreKeys),
-          /**
-           * Default.
-           */
-          name: configNamesMapSource.rules,
-          files: [...config.files ?? []],
-          ignores: [...config.ignores ?? []],
-          /**
-           * Overridable.
-           */
-          ...omit(options?.jsonc ?? {}, ["files", "ignores"]),
+          name: configNamesMapSource.jsonc,
           rules: {
             /**
              * Default.
@@ -80,76 +46,42 @@ const jsoncInternal = (composer, options) => {
                   natural: true
                 }
               }
-            ],
-            /**
-             * 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",
-                  caseSensitive: false,
-                  natural: true
-                }
+        omittedConfig
+      );
+      const sortArrayValuesConfig = defu(options?.sortArrayValues, {
+        name: configNamesMapSource.sortArrayValues,
+        files: [GLOB_CSPELL_JSON],
+        rules: {
+          "jsonc/sort-array-values": [
+            "error",
+            {
+              pathPattern: ".*",
+              order: {
+                type: "asc",
+                caseSensitive: false,
+                natural: true
               }
-            ],
-            ...options?.sortArrayValues?.rules
-          }
+            }
+          ]
         }
+      });
+      const packageJsonSetupConfig = {
+        plugins: packageJson.plugins,
+        name: configNamesMapSource.packageJsonSetup
+      };
+      const packageJsonRulesConfig = defu(options?.packageJson, {
+        ...omit(packageJson, ["name", "plugins"]),
+        name: configNamesMapSource.packageJsonRules
+      });
+      return [
+        modifiedConfig,
+        rulesConfig,
+        sortArrayValuesConfig,
+        packageJsonSetupConfig,
+        packageJsonRulesConfig
       ];
     },
     ["antfu/sort/package-json", "antfu/sort/tsconfig-json"]

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

@@ -2,7 +2,9 @@ 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";
+    readonly react: "vdustr/react/rules";
+    readonly reactCompilerSetup: "vdustr/react/react-compiler/setup";
+    readonly reactCompilerRules: "vdustr/react/react-compiler/rules";
 };
 declare module "../types" {
     interface ConfigNamesMap extends ResolveConfigNamesMap<react.ConfigNamesMapSource> {
@@ -10,12 +12,17 @@ declare module "../types" {
 }
 declare namespace react {
     type ConfigNamesMapSource = typeof configNamesMapSource;
-    interface Options extends ConfigOverrides {
+    interface Options {
+        react?: ConfigOverrides;
+        reactCompilerSetup?: ConfigOverrides;
+        reactCompilerRules?: ConfigOverrides;
     }
 }
 declare const react: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: react.Options) => void) & {
     configNamesMapSource: {
-        readonly rules: "vdustr/react/rules";
+        readonly react: "vdustr/react/rules";
+        readonly reactCompilerSetup: "vdustr/react/react-compiler/setup";
+        readonly reactCompilerRules: "vdustr/react/react-compiler/rules";
     };
 };
 export { react };

package/dist/esm/extends/react.mjs

@@ -1,56 +1,50 @@
-import { omit } from "es-toolkit";
+import defu from "defu";
+import { omit, pick } 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"
+  react: "vdustr/react/rules",
+  reactCompilerSetup: "vdustr/react/react-compiler/setup",
+  reactCompilerRules: "vdustr/react/react-compiler/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
+  extendsConfig(composer, "antfu/react/rules", async (config) => {
+    const modifiedConfig = defu(pick(options?.react ?? {}, ["files", "ignores"]), config);
+    const omittedConfig = omit(modifiedConfig, ignoreKeys);
+    const rulesConfig = defu(
+      omit(options?.react ?? {}, ["files", "ignores"]),
+      {
+        name: configNamesMapSource.react,
+        rules: {
+          "react/prefer-destructuring-assignment": "off"
+        }
       },
-      /**
-       * 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
+      omittedConfig
+    );
+    const reactCompilerSetupConfig = defu(options?.reactCompilerSetup, {
+      name: configNamesMapSource.reactCompilerSetup,
+      plugins: {
+        "react-compiler": await reactCompiler()
       }
-    }
-  ]);
+    });
+    const reactCompilerRulesConfig = defu(
+      options?.reactCompilerRules,
+      {
+        name: configNamesMapSource.reactCompilerRules,
+        rules: {
+          "react-compiler/react-compiler": "error"
+        }
+      },
+      omittedConfig
+    );
+    return [
+      modifiedConfig,
+      rulesConfig,
+      reactCompilerSetupConfig,
+      reactCompilerRulesConfig
+    ];
+  });
 };
 const react = Object.assign(reactInternal, {
   configNamesMapSource

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

@@ -2,7 +2,7 @@ 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";
+    readonly typescript: "vdustr/typescript/rules";
 };
 declare module "../types" {
     interface ConfigNamesMap extends ResolveConfigNamesMap<typescript.ConfigNamesMapSource> {
@@ -10,12 +10,13 @@ declare module "../types" {
 }
 declare namespace typescript {
     type ConfigNamesMapSource = typeof configNamesMapSource;
-    interface Options extends ConfigOverrides {
+    interface Options {
+        typescript?: ConfigOverrides;
     }
 }
 declare const typescript: ((composer: FlatConfigComposer<TypedFlatConfigItem, ConfigNames>, options?: typescript.Options) => void) & {
     configNamesMapSource: {
-        readonly rules: "vdustr/typescript/rules";
+        readonly typescript: "vdustr/typescript/rules";
     };
 };
 export { typescript };