@vp-tw/eslint-config 0.0.9 → 0.0.11

package/dist/extends/jsonc.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonc = void 0;
+var _esToolkit = require("es-toolkit");
+var _recommended = _interopRequireDefault(require("eslint-plugin-package-json/configs/recommended"));
+var _globs = require("../globs");
+var _extendsConfig = require("../utils/extendsConfig");
+var _utils = require("./_utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const configNamesMapSource = {
+  rules: "vdustr/jsonc/rules",
+  sortArrayValues: "vdustr/jsonc/sortArrayValues",
+  packageJsonSetup: "vdustr/package-json/setup",
+  packageJsonRules: "vdustr/package-json/rules"
+};
+const jsoncInternal = (composer, options) => {
+  (0, _extendsConfig.extendsConfig)(composer, "antfu/jsonc/rules", config => {
+    config = {
+      ...config,
+      files: [
+      /**
+       * Inherited.
+       */
+      ...(config.files ?? []),
+      /**
+       * Default.
+       */
+      _globs.GLOB_CODE_WORKSPACE,
+      /**
+       * Overridable.
+       */
+      ...(options?.jsonc?.files ?? [])],
+      ignores: [
+      /**
+       * Inherited.
+       */
+      ...(config.ignores ?? []),
+      /**
+       * Default.
+       */
+      _globs.GLOB_PACKAGE_JSON,
+      /**
+       * Overridable.
+       */
+      ...(options?.jsonc?.ignores ?? [])]
+    };
+    return [config, {
+      /**
+       * Inherited.
+       */
+      ...(0, _esToolkit.omit)(config, _utils.ignoreKeys),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.rules,
+      files: [...(config.files ?? [])],
+      ignores: [...(config.ignores ?? [])],
+      /**
+       * Overridable.
+       */
+      ...(0, _esToolkit.omit)(options?.jsonc ?? {}, ["files", "ignores"]),
+      rules: {
+        /**
+         * Default.
+         */
+        "jsonc/sort-keys": "error",
+        /**
+         * Overridable.
+         */
+        ...options?.jsonc?.rules
+      }
+    }, {
+      plugins: _recommended.default.plugins,
+      name: configNamesMapSource.packageJsonSetup
+    }, {
+      /**
+       * Inherited.
+       */
+      ...(0, _esToolkit.omit)(_recommended.default, ["plugins"]),
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.packageJsonRules,
+      /**
+       * Overridable.
+       */
+      ...options?.packageJson,
+      plugins: {
+        /**
+         * Inherited.
+         */
+        ..._recommended.default.plugins,
+        /**
+         * Overridable.
+         */
+        ...options?.packageJson?.plugins
+      },
+      rules: {
+        /**
+         * Inherited.
+         */
+        ..._recommended.default.rules,
+        /**
+         * Overridable.
+         */
+        ...options?.packageJson?.rules
+      }
+    }, {
+      /**
+       * Default.
+       */
+      name: configNamesMapSource.sortArrayValues,
+      /**
+       * Overridable.
+       */
+      ...options?.sortArrayValues,
+      files: [_globs.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 = exports.jsonc = Object.assign(jsoncInternal, {
+  configNamesMapSource
+});

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.react = void 0;
+var _esToolkit = require("es-toolkit");
+var _eslintPluginReactCompiler = require("../lib/eslint-plugin-react-compiler");
+var _extendsConfig = require("../utils/extendsConfig");
+var _utils = require("./_utils");
+const configNamesMapSource = {
+  rules: "vdustr/react/rules"
+};
+const reactInternal = (composer, options) => {
+  (0, _extendsConfig.extendsConfig)(composer, "antfu/react/rules", async config => [config, {
+    /**
+     * Inherited.
+     */
+    ...(0, _esToolkit.omit)(config, _utils.ignoreKeys),
+    /**
+     * Default.
+     */
+    name: configNamesMapSource.rules,
+    plugins: {
+      /**
+       * Inherited.
+       */
+      ...config.plugins,
+      /**
+       * Default.
+       */
+      "react-compiler": await (0, _eslintPluginReactCompiler.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 = exports.react = Object.assign(reactInternal, {
+  configNamesMapSource
+});

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

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

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

package/dist/extends/yaml.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.yaml = void 0;
+var _esToolkit = require("es-toolkit");
+var _eslintPluginYml = _interopRequireDefault(require("eslint-plugin-yml"));
+var _globs = require("../globs");
+var _extendsConfig = require("../utils/extendsConfig");
+var _renameRules = require("../utils/renameRules");
+var _utils = require("./_utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const configNamesMapSource = {
+  rules: "vdustr/yaml/rules",
+  sortKeys: "vdustr/yaml/sortKeys"
+};
+const yamlInternal = (composer, options) => {
+  (0, _extendsConfig.extendsConfig)(composer, "antfu/yaml/rules", config => [config, {
+    /**
+     * Inherited.
+     */
+    ...(0, _esToolkit.omit)(config, _utils.ignoreKeys),
+    /**
+     * Default.
+     */
+    name: configNamesMapSource.rules,
+    /**
+     * Overridable.
+     */
+    ...options,
+    rules: {
+      /**
+       * Inherited from `eslint-plugin-yml`.
+       */
+      ...(0, _renameRules.renameRules)({
+        ...Object.fromEntries([..._eslintPluginYml.default.configs["flat/recommended"].flatMap(config2 => Object.entries(config2.rules ?? {})), ..._eslintPluginYml.default.configs["flat/prettier"].flatMap(config2 => Object.entries(config2.rules ?? {}))])
+      }),
+      /**
+       * Overridable.
+       */
+      ...options?.yaml?.rules
+    }
+  }, {
+    /**
+     * Inherited.
+     */
+    ...config,
+    /**
+     * Default.
+     */
+    name: configNamesMapSource.sortKeys,
+    /**
+     * Overridable.
+     */
+    ...options?.sortKeys,
+    files: [_globs.GLOB_PNPM_WORKSPACE_YAML, ...(options?.sortKeys?.files ?? [])],
+    rules: {
+      "yaml/sort-keys": ["error", "asc"],
+      ...options?.sortKeys?.rules
+    }
+  }]);
+};
+const yaml = exports.yaml = Object.assign(yamlInternal, {
+  configNamesMapSource
+});

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GLOB_PNPM_WORKSPACE_YAML = exports.GLOB_PACKAGE_JSON = exports.GLOB_CSPELL_JSON = exports.GLOB_CONFIG_JS = exports.GLOB_CODE_WORKSPACE = void 0;
+const GLOB_CODE_WORKSPACE = exports.GLOB_CODE_WORKSPACE = "**/*.code-workspace";
+const GLOB_PACKAGE_JSON = exports.GLOB_PACKAGE_JSON = "**/package.json";
+const GLOB_PNPM_WORKSPACE_YAML = exports.GLOB_PNPM_WORKSPACE_YAML = "**/pnpm-workspace.y?(a)ml";
+const GLOB_CSPELL_JSON = exports.GLOB_CSPELL_JSON = "**/cspell.json";
+const GLOB_CONFIG_JS = exports.GLOB_CONFIG_JS = "**/*.config.?([cm])([jt])s";

package/dist/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/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/utils/extendsConfig.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extendsConfig = extendsConfig;
+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)];
+  });
+}

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