@vp-tw/eslint-config 0.0.9 → 0.0.11

package/dist/esm/extends/yaml.mjs

@@ -0,0 +1,71 @@
+import { omit } from "es-toolkit";
+import eslintPluginYml from "eslint-plugin-yml";
+import { GLOB_PNPM_WORKSPACE_YAML } from "../globs.mjs";
+import { extendsConfig } from "../utils/extendsConfig.mjs";
+import { renameRules } from "../utils/renameRules.mjs";
+import { ignoreKeys } from "./_utils.mjs";
+const configNamesMapSource = {
+  rules: "vdustr/yaml/rules",
+  sortKeys: "vdustr/yaml/sortKeys"
+};
+const yamlInternal = (composer, options) => {
+  extendsConfig(composer, "antfu/yaml/rules", (config) => [
+    config,
+    {
+      /**
+       * Inherited.
+       */
+      ...omit(config, ignoreKeys),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.rules,
+      /**
+       * Overridable.
+       */
+      ...options,
+      rules: {
+        /**
+         * Inherited from `eslint-plugin-yml`.
+         */
+        ...renameRules({
+          ...Object.fromEntries([
+            ...eslintPluginYml.configs["flat/recommended"].flatMap(
+              (config2) => Object.entries(config2.rules ?? {})
+            ),
+            ...eslintPluginYml.configs["flat/prettier"].flatMap(
+              (config2) => Object.entries(config2.rules ?? {})
+            )
+          ])
+        }),
+        /**
+         * Overridable.
+         */
+        ...options?.yaml?.rules
+      }
+    },
+    {
+      /**
+       * Inherited.
+       */
+      ...config,
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.sortKeys,
+      /**
+       * Overridable.
+       */
+      ...options?.sortKeys,
+      files: [GLOB_PNPM_WORKSPACE_YAML, ...options?.sortKeys?.files ?? []],
+      rules: {
+        "yaml/sort-keys": ["error", "asc"],
+        ...options?.sortKeys?.rules
+      }
+    }
+  ]);
+};
+const yaml = Object.assign(yamlInternal, {
+  configNamesMapSource
+});
+export { yaml };

package/dist/esm/globs.d.ts

@@ -0,0 +1,6 @@
+declare const GLOB_CODE_WORKSPACE: string;
+declare const GLOB_PACKAGE_JSON: string;
+declare const GLOB_PNPM_WORKSPACE_YAML: string;
+declare const GLOB_CSPELL_JSON: string;
+declare const GLOB_CONFIG_JS: string;
+export { GLOB_CODE_WORKSPACE, GLOB_CONFIG_JS, GLOB_CSPELL_JSON, GLOB_PACKAGE_JSON, GLOB_PNPM_WORKSPACE_YAML, };

package/dist/esm/globs.mjs

@@ -0,0 +1,12 @@
+const GLOB_CODE_WORKSPACE = "**/*.code-workspace";
+const GLOB_PACKAGE_JSON = "**/package.json";
+const GLOB_PNPM_WORKSPACE_YAML = "**/pnpm-workspace.y?(a)ml";
+const GLOB_CSPELL_JSON = "**/cspell.json";
+const GLOB_CONFIG_JS = "**/*.config.?([cm])([jt])s";
+export {
+  GLOB_CODE_WORKSPACE,
+  GLOB_CONFIG_JS,
+  GLOB_CSPELL_JSON,
+  GLOB_PACKAGE_JSON,
+  GLOB_PNPM_WORKSPACE_YAML
+};

package/dist/esm/types.d.ts

@@ -1,3 +1,37 @@
+import type { TypedFlatConfigItem } from "@antfu/eslint-config";
 import type antfu from "@antfu/eslint-config";
+import type { DistributiveOmit } from "@mui/types";
 type Config = NonNullable<Parameters<typeof antfu>[1]>;
-export type { Config };
+/**
+ * A map of config names.
+ *
+ * @example
+ *
+ * ```ts
+ *
+ * ```
+ */
+interface ConfigNamesMap {
+}
+type BaseConfigNamesMapSource = Record<string, string>;
+/**
+ * Transfroms a config names map source to a config names map.
+ *
+ * @example
+ *
+ * ```ts
+ * BaseConfigNamesMapSource<{
+ *   setup: "my-config/setup",
+ *   rules: "my-config/rules",
+ * }> => {
+ *   "my-config/setup": true,
+ *   "my-config/rules": true,
+ * }
+ * ```
+ */
+type ResolveConfigNamesMap<TSource extends BaseConfigNamesMapSource> = {
+    [K in TSource[keyof TSource]]: true;
+};
+interface ConfigOverrides extends DistributiveOmit<TypedFlatConfigItem, "process"> {
+}
+export type { BaseConfigNamesMapSource, Config, ConfigNamesMap, ConfigOverrides, ResolveConfigNamesMap, };

package/dist/esm/utils/extendsConfig.d.ts

@@ -0,0 +1,4 @@
+import type { Linter } from "eslint";
+import type { Arrayable, Awaitable, DefaultConfigNamesMap, FlatConfigComposer, StringLiteralUnion } from "eslint-flat-config-utils";
+declare function extendsConfig<T extends object = Linter.Config, ConfigNames extends string = keyof DefaultConfigNamesMap>(composer: FlatConfigComposer<T, ConfigNames>, sourceOrIndex: StringLiteralUnion<ConfigNames, string | number>, config: Awaitable<Arrayable<T>> | ((config: T) => Awaitable<Arrayable<T>>), remove?: Arrayable<StringLiteralUnion<ConfigNames, string | number>>): void;
+export { extendsConfig };

package/dist/esm/utils/extendsConfig.mjs

@@ -0,0 +1,56 @@
+function getConfigIndex(configs, nameOrIndex) {
+  if (typeof nameOrIndex === "number") {
+    if (nameOrIndex < 0 || nameOrIndex >= configs.length)
+      throw new Error(
+        `ESLintFlatConfigUtils: Failed to locate config at index ${nameOrIndex}
+(${configs.length} configs in total)`
+      );
+    return nameOrIndex;
+  } else {
+    const index = configs.findIndex((config) => config.name === nameOrIndex);
+    if (index === -1) {
+      const named = configs.map((config) => config.name).filter(Boolean);
+      const countUnnamed = configs.length - named.length;
+      const messages = [
+        `Failed to locate config with name "${nameOrIndex}"`,
+        `Available names are: ${named.join(", ")}`,
+        countUnnamed ? `(${countUnnamed} unnamed configs)` : ""
+      ].filter(Boolean).join("\n");
+      throw new Error(`ESLintFlatConfigUtils: ${messages}`);
+    }
+    return index;
+  }
+}
+const tryGetConfigIndex = (configs, nameOrIndex) => {
+  try {
+    return getConfigIndex(configs, nameOrIndex);
+  } catch {
+    return -1;
+  }
+};
+function extendsConfig(composer, sourceOrIndex, config, remove) {
+  const operations = (
+    // @ts-expect-error -- Hijacking the composer's operations.
+    composer._operations
+  );
+  operations.push(async (items) => {
+    const removingTargets = (() => {
+      if (!remove) return [];
+      const removeSources = Array.isArray(remove) ? remove : [remove];
+      return removeSources.flatMap((removeSource) => {
+        const index2 = tryGetConfigIndex(items, removeSource);
+        return index2 === -1 ? [] : [index2];
+      });
+    })();
+    items = removingTargets.length === 0 ? items : items.filter((_, index2) => !removingTargets.includes(index2));
+    const index = tryGetConfigIndex(items, sourceOrIndex);
+    const source = items[index];
+    if (!source) return items;
+    const newConfigs = await (async () => {
+      const awaited = typeof config === "function" ? await config(source) : await config;
+      return Array.isArray(awaited) ? awaited : [awaited];
+    })();
+    return [...items.slice(0, index), ...newConfigs, ...items.slice(index + 1)];
+  });
+}
+export { extendsConfig };

package/dist/esm/vdustr.d.ts

@@ -1,10 +1,27 @@
-import type { Config } from "./types";
+import type { ConfigNames, TypedFlatConfigItem } from "@antfu/eslint-config";
+import type { FlatConfigComposer } from "eslint-flat-config-utils";
+import type { Config, ConfigNamesMap } from "./types";
 import antfu from "@antfu/eslint-config";
 import { mdx } from "./configs/mdx";
+import { prettier } from "./configs/prettier";
+import { storybook } from "./configs/storybook";
+import { imports } from "./extends/imports";
+import { javascript } from "./extends/javascript";
+import { jsonc } from "./extends/jsonc";
+import { react } from "./extends/react";
+import { typescript } from "./extends/typescript";
+import { yaml } from "./extends/yaml";
 import "./eslint-typegen";
-type Options = Omit<NonNullable<Parameters<typeof antfu>[0]>, "stylistic"> & {
+type Options = NonNullable<Parameters<typeof antfu>[0]> & {
+    javascriptExtends?: javascript.Options;
+    importsExtends?: imports.Options;
+    typescriptExtends?: typescript.Options;
+    jsoncExtends?: jsonc.Options;
+    yamlExtends?: yaml.Options;
+    reactExtends?: react.Options;
     mdx?: boolean | mdx.Options;
-    storybook?: boolean;
+    storybook?: boolean | storybook.Options;
+    prettier?: boolean | prettier.Options;
 };
-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>;
+declare const vdustr: (options?: Options, ...userConfigs: Array<Config>) => FlatConfigComposer<TypedFlatConfigItem, ConfigNames | keyof ConfigNamesMap>;
 export { vdustr };

package/dist/esm/vdustr.mjs

@@ -1,32 +1,15 @@
-import antfu, {
-  GLOB_ASTRO_TS,
-  GLOB_JS,
-  GLOB_JSX,
-  GLOB_TS,
-  GLOB_TSX
-} from "@antfu/eslint-config";
-import packageJson from "eslint-plugin-package-json/configs/recommended";
-import { isPackageExists } from "local-pkg";
+import antfu from "@antfu/eslint-config";
 import { mdx } from "./configs/mdx.mjs";
 import { prettier } from "./configs/prettier.mjs";
 import { storybook } from "./configs/storybook.mjs";
-import { reactCompiler } from "./lib/eslint-plugin-react-compiler.mjs";
-import "./eslint-typegen";
+import { imports } from "./extends/imports.mjs";
+import { javascript } from "./extends/javascript.mjs";
+import { jsonc } from "./extends/jsonc.mjs";
+import { react } from "./extends/react.mjs";
+import { typescript } from "./extends/typescript.mjs";
+import { yaml } from "./extends/yaml.mjs";
+import "./eslint-typegen.mjs";
 const vdustr = (options, ...userConfigs) => {
-  const typescriptEnabled = isPackageExists("typescript");
-  const jsoncEnabled = Boolean(options?.jsonc ?? true);
-  const reactEnabled = Boolean(options?.react ?? false);
-  const storybookEnabled = Boolean(options?.storybook ?? false);
-  const mdxEnabled = Boolean(options?.mdx ?? false);
-  const mdxOptions = {
-    ...typeof options?.mdx !== "object" ? null : options.mdx
-  };
-  const mdxFlatCodeBlocksEnabled = Boolean(
-    mdxOptions?.flatCodeBlocks ?? true
-  );
-  const mdxFlatCodeBlocksOptions = {
-    ...typeof mdxOptions?.flatCodeBlocks !== "object" ? null : mdxOptions.flatCodeBlocks
-  };
   let config = antfu(
     {
       // We use `prettier`.
@@ -35,127 +18,34 @@ const vdustr = (options, ...userConfigs) => {
     },
     ...userConfigs
   );
-  config = config.override("antfu/javascript/rules", (config2) => ({
-    ...config2,
-    rules: {
-      ...config2.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"
-    }
-  })).override("antfu/imports/rules", (config2) => ({
-    ...config2,
-    rules: {
-      ...config2.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"
-    }
-  })).insertAfter("antfu/imports/rules", {
-    name: "vdustr/no-default-export",
-    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],
-    ignores: [
-      // Configuration files
-      "**/*.config.*",
-      GLOB_ASTRO_TS
-    ]
-  });
-  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"
-      ]
-    })).insertAfter("antfu/jsonc/rules", packageJson).remove("antfu/sort/package-json").remove("antfu/sort/tsconfig-json");
-  }
-  if (reactEnabled) {
-    config = config.override("antfu/react/rules", async (config2) => {
-      return {
-        ...config2,
-        plugins: {
-          ...config2.plugins,
-          "react-compiler": await reactCompiler()
-        },
-        rules: {
-          ...config2.rules,
-          "react-compiler/react-compiler": "error",
-          /**
-           * Not all destructuring assignments are more readable than their alternatives.
-           */
-          "react/prefer-destructuring-assignment": "off"
-        }
-      };
-    });
-  }
+  javascript(config, options?.javascriptExtends);
+  imports(config, options?.importsExtends);
+  typescript(config, options?.typescriptExtends);
+  jsonc(config, options?.jsoncExtends);
+  yaml(config, options?.yamlExtends);
+  react(config, options?.reactExtends);
+  const storybookEnabled = Boolean(options?.storybook ?? false);
   if (storybookEnabled) {
-    config = config.append(storybook()).override("storybook:csf:stories-rules", (config2) => ({
-      ...config2,
-      rules: {
-        ...config2.rules,
-        "import/no-default-export": "off"
-      }
-    }));
+    const storybookOptions = typeof options?.storybook !== "object" ? void 0 : options.storybook;
+    config = config.append(
+      storybook(...!storybookOptions ? [] : [storybookOptions])
+    );
   }
+  const mdxEnabled = Boolean(options?.mdx ?? false);
   if (mdxEnabled) {
+    const mdxOptions = {
+      ...typeof options?.mdx !== "object" ? null : options.mdx
+    };
+    const mdxFlatCodeBlocksEnabled = Boolean(
+      mdxOptions?.codeBlocks ?? true
+    );
+    const mdxFlatCodeBlocksOptions = {
+      ...typeof mdxOptions?.codeBlocks !== "object" ? null : mdxOptions.codeBlocks
+    };
     config = config.append(
       mdx({
         ...mdxOptions,
-        flatCodeBlocks: !mdxFlatCodeBlocksEnabled ? false : {
+        codeBlocks: !mdxFlatCodeBlocksEnabled ? false : {
           ...mdxFlatCodeBlocksOptions,
           rules: {
             "import/no-default-export": "off",
@@ -165,7 +55,13 @@ const vdustr = (options, ...userConfigs) => {
       })
     );
   }
-  config = config.append(prettier());
+  const prettierEnabled = Boolean(options?.prettier ?? true);
+  if (prettierEnabled) {
+    const prettierOptions = typeof options?.prettier !== "object" ? void 0 : options.prettier;
+    config = config.append(
+      prettier(...!prettierOptions ? [] : [prettierOptions])
+    );
+  }
   return config;
 };
 export { vdustr };

package/dist/extends/_utils.d.ts

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

package/dist/extends/_utils.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ignoreKeys = void 0;
+const ignoreKeys = exports.ignoreKeys = ["plugins", "rules"];

package/dist/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/extends/imports.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.imports = void 0;
+var _eslintConfig = require("@antfu/eslint-config");
+var _esToolkit = require("es-toolkit");
+var _globs = require("../globs");
+var _extendsConfig = require("../utils/extendsConfig");
+var _utils = require("./_utils");
+const configNamesMapSource = {
+  imports: "vdustr/imports/rules",
+  noDefaultExport: "vdustr/no-default-export/rules"
+};
+const importsInternal = (composer, options) => {
+  (0, _extendsConfig.extendsConfig)(composer, "antfu/imports/rules", config => [config, {
+    /**
+     * Inherited.
+     */
+    ...(0, _esToolkit.omit)(config, _utils.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: [_eslintConfig.GLOB_JS, _eslintConfig.GLOB_JSX, _eslintConfig.GLOB_TS, _eslintConfig.GLOB_TSX, ...(options?.noDefaultExport?.files || [])],
+    ignores: [
+    // Configuration files
+    _globs.GLOB_CONFIG_JS, _eslintConfig.GLOB_MARKDOWN_CODE, _eslintConfig.GLOB_ASTRO_TS, ...(options?.noDefaultExport?.ignores || [])]
+  }]);
+};
+const imports = exports.imports = Object.assign(importsInternal, {
+  configNamesMapSource
+});

package/dist/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/extends/javascript.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.javascript = void 0;
+var _esToolkit = require("es-toolkit");
+var _extendsConfig = require("../utils/extendsConfig");
+var _utils = require("./_utils");
+const configNamesMapSource = {
+  rules: "vdustr/javascript/rules"
+};
+const javascriptInternal = (composer, options) => {
+  (0, _extendsConfig.extendsConfig)(composer, "antfu/javascript/rules", config => [config, {
+    /**
+     * Inherited.
+     */
+    ...(0, _esToolkit.omit)(config, _utils.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 = exports.javascript = Object.assign(javascriptInternal, {
+  configNamesMapSource
+});

package/dist/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 };