@lzear/eslint-config 3.0.1 → 4.0.2

package/dist/index.d.ts

@@ -1,17 +1,11 @@
 import { Linter } from 'eslint';
-declare const CONFIG_OPTIONS: readonly ["perfectionist", "typescript", "vitest", "react", "node"];
-type ConfigOptionKeys = (typeof CONFIG_OPTIONS)[number];
-type ConfigOptionFlags = Record<ConfigOptionKeys, boolean>;
-export type ConfigOptions = Required<ConfigOptionFlags>;
-type RawConfigOptions = {
-    extends?: Linter.Config[] | Linter.Config;
-} & Partial<ConfigOptionFlags>;
-declare const configGenerator: ({ extends: customExtends, ...rawConfig }?: RawConfigOptions) => Promise<Linter.Config[]>;
-export default configGenerator;
-export declare const defaultOptions: {
-    perfectionist: boolean;
+
+interface ConfigOptions {
+    node: boolean;
+    react: boolean;
     typescript: boolean;
     vitest: boolean;
-    react: boolean;
-    node: boolean;
-};
+}
+declare const configGenerator: (options?: Partial<ConfigOptions>) => Promise<Linter.Config[]>;
+
+export { type ConfigOptions, configGenerator as default };

package/dist/index.js

@@ -0,0 +1,622 @@
+// configs/a11y.ts
+import jsxA11y from "eslint-plugin-jsx-a11y";
+var a11y = (config) => {
+  if (!config.react) {
+    return {};
+  }
+  const files = ["**/*.jsx"];
+  if (config.typescript) {
+    files.push("**/*.tsx");
+  }
+  return {
+    name: "lzear/a11y",
+    files,
+    plugins: {
+      "jsx-a11y": jsxA11y
+    },
+    rules: {
+      ...jsxA11y.flatConfigs.recommended.rules
+    }
+  };
+};
+
+// configs/core.ts
+import js from "@eslint/js";
+import eslintCommentsPlugin from "@eslint-community/eslint-plugin-eslint-comments";
+import deMorganPlugin from "eslint-plugin-de-morgan";
+import importXPlugin from "eslint-plugin-import-x";
+import preferArrowPlugin from "eslint-plugin-prefer-arrow";
+import promisePlugin from "eslint-plugin-promise";
+import regexpPlugin from "eslint-plugin-regexp";
+import sonarjsPlugin from "eslint-plugin-sonarjs";
+import unicornPlugin from "eslint-plugin-unicorn";
+import globals from "globals";
+
+// plugin/rules/major-version-only.ts
+var DEP_FIELDS = /* @__PURE__ */ new Set([
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+]);
+var VERSION_RE = /^([~^])(\d+)\.(\d+)(?:\.\d+)?$/;
+var simplify = (version) => {
+  const match = VERSION_RE.exec(version);
+  if (!match) {
+    return null;
+  }
+  const [, operator, major, minor] = match;
+  if (major === "0" && operator === "^") {
+    const target2 = `^0.${minor}`;
+    return target2 === version ? null : target2;
+  }
+  const target = `${operator}${major}`;
+  return target === version ? null : target;
+};
+var isIgnored = (pkgName, ignore) => ignore.some(
+  (pattern) => pattern instanceof RegExp ? pattern.test(pkgName) : pattern === pkgName
+);
+var majorVersionOnly = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce major-only version specifiers in package.json"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignore: {
+            type: "array",
+            items: {
+              oneOf: [
+                { type: "string" },
+                {
+                  type: "object",
+                  properties: { regex: { type: "string" } },
+                  required: ["regex"],
+                  additionalProperties: false
+                }
+              ]
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      useMajorOnly: 'Use "{{suggested}}" instead of "{{current}}"'
+    }
+  },
+  create: (context) => {
+    const opts = context.options[0];
+    const ignore = (opts?.ignore ?? []).map(
+      (item) => typeof item === "string" ? item : new RegExp(item.regex)
+    );
+    return {
+      JSONProperty: (rawNode) => {
+        const node2 = rawNode;
+        const keyName = node2.key.type === "JSONLiteral" ? String(node2.key.value) : node2.key.name ?? "";
+        if (!DEP_FIELDS.has(keyName)) {
+          return;
+        }
+        const depsNode = node2.value;
+        if (depsNode.type !== "JSONObjectExpression") {
+          return;
+        }
+        for (const prop of depsNode.properties) {
+          const pkgName = prop.key.type === "JSONLiteral" ? String(prop.key.value) : prop.key.name ?? "";
+          if (isIgnored(pkgName, ignore)) {
+            continue;
+          }
+          const versionNode = prop.value;
+          if (versionNode.type !== "JSONLiteral") {
+            continue;
+          }
+          const version = versionNode.value;
+          if (typeof version !== "string") {
+            continue;
+          }
+          const suggested = simplify(version);
+          if (!suggested) {
+            continue;
+          }
+          context.report({
+            node: versionNode,
+            messageId: "useMajorOnly",
+            data: { current: version, suggested },
+            fix: (fixer) => fixer.replaceText(versionNode, JSON.stringify(suggested))
+          });
+        }
+      }
+    };
+  }
+};
+
+// plugin/rules/prefer-relative-imports.ts
+import path from "path";
+
+// utils.ts
+var interopDefault = async (m) => {
+  const resolved = await m;
+  const mod = resolved.default ?? resolved;
+  if (mod.__esModule) {
+    const inner = mod.default;
+    if (inner !== void 0) return inner;
+  }
+  return mod;
+};
+
+// plugin/rules/prefer-relative-imports.ts
+var moduleVisitor = await interopDefault(
+  import("eslint-module-utils/moduleVisitor")
+);
+var resolve = await interopDefault(import("eslint-module-utils/resolve"));
+var toRelative = (from, importPath, context) => {
+  const resolved = resolve(importPath, context);
+  if (!resolved) {
+    return null;
+  }
+  let rel = path.relative(path.dirname(from), resolved);
+  if (!rel) {
+    return null;
+  }
+  if (!rel.startsWith(".")) {
+    rel = `./${rel}`;
+  }
+  if (!path.extname(importPath)) {
+    const ext = path.extname(rel);
+    if (ext) {
+      const withoutExt = rel.slice(0, -ext.length);
+      rel = withoutExt.endsWith("/index") ? withoutExt.slice(0, -"/index".length) || "." : withoutExt;
+      if (!rel.startsWith(".")) {
+        rel = `./${rel}`;
+      }
+    }
+  }
+  return rel;
+};
+var countParentPrefixes = (p) => {
+  const match = /^(?:\.\.\/)+/.exec(p);
+  return match ? match[0].length / 3 : 0;
+};
+var preferRelativeImports = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer relative imports when a shorter path exists" },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: { maxParentPrefixes: { type: "number", minimum: 0 } },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      preferRelative: 'Use relative import "{{relative}}" instead of "{{original}}"'
+    }
+  },
+  create: (context) => {
+    const opts = context.options[0];
+    const maxParentPrefixes = opts?.maxParentPrefixes ?? 1;
+    const filename = context.physicalFilename;
+    const check = (source) => {
+      const importPath = source.value;
+      if (typeof importPath !== "string" || importPath.startsWith(".")) {
+        return;
+      }
+      const relative = toRelative(filename, importPath, context);
+      if (!relative || relative.length >= importPath.length) {
+        return;
+      }
+      if (countParentPrefixes(relative) > maxParentPrefixes) {
+        return;
+      }
+      context.report({
+        node: source,
+        messageId: "preferRelative",
+        data: { relative, original: importPath },
+        fix: (fixer) => fixer.replaceText(source, JSON.stringify(relative))
+      });
+    };
+    return moduleVisitor(check, { commonjs: false });
+  }
+};
+
+// plugin/index.ts
+var plugin = {
+  meta: {
+    name: "lzear",
+    version: "1.0.0"
+  },
+  rules: {
+    "major-version-only": majorVersionOnly,
+    "prefer-relative-imports": preferRelativeImports
+  }
+};
+
+// configs/core.ts
+var core = () => {
+  const files = [
+    "**/*.js",
+    "**/*.cjs",
+    "**/*.mjs",
+    "**/*.ts",
+    "**/*.cts",
+    "**/*.mts",
+    "**/*.jsx",
+    "**/*.tsx"
+  ];
+  const sonarRules = (sonarjsPlugin.configs?.recommended).rules;
+  const rules = {
+    ...js.configs.recommended.rules,
+    ...eslintCommentsPlugin.configs.recommended.rules,
+    "@eslint-community/eslint-comments/disable-enable-pair": 0,
+    "@eslint-community/eslint-comments/no-unlimited-disable": 0,
+    ...deMorganPlugin.configs.recommended.rules,
+    ...importXPlugin.configs.recommended.rules,
+    "import-x/no-named-as-default-member": 0,
+    "import-x/no-unresolved": 0,
+    "import-x/order": [
+      2,
+      {
+        alphabetize: { order: "asc", orderImportKind: "asc" },
+        "newlines-between": "never"
+      }
+    ],
+    "lzear/prefer-relative-imports": 2,
+    "prefer-arrow/prefer-arrow-functions": [
+      2,
+      {
+        classPropertiesAllowed: false,
+        disallowPrototype: true,
+        singleReturnOnly: false
+      }
+    ],
+    ...promisePlugin.configs.recommended.rules,
+    ...regexpPlugin.configs.recommended.rules,
+    ...sonarRules,
+    "sonarjs/fixme-tag": 0,
+    "sonarjs/no-invariant-returns": 0,
+    // annoying
+    "sonarjs/no-os-command-from-path": 0,
+    // annoying
+    "sonarjs/os-command": 0,
+    // annoying
+    "sonarjs/prefer-read-only-props": 0,
+    // annoying
+    "sonarjs/pseudo-random": 0,
+    "sonarjs/todo-tag": 0,
+    "sonarjs/void-use": 0,
+    ...unicornPlugin.configs.recommended.rules,
+    "unicorn/no-abusive-eslint-disable": 0,
+    "unicorn/no-null": 0,
+    "unicorn/prevent-abbreviations": 0
+  };
+  return {
+    name: "lzear/core",
+    files,
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        ...globals.es2025,
+        ...globals.node
+      },
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module"
+      }
+    },
+    plugins: {
+      "@eslint-community/eslint-comments": eslintCommentsPlugin,
+      "de-morgan": deMorganPlugin,
+      "import-x": importXPlugin,
+      lzear: plugin,
+      "prefer-arrow": preferArrowPlugin,
+      promise: promisePlugin,
+      regexp: regexpPlugin,
+      sonarjs: sonarjsPlugin,
+      unicorn: unicornPlugin
+    },
+    rules,
+    settings: {
+      // import-x uses import-x/resolver; eslint-module-utils (used by lzear/prefer-relative-imports) reads import/resolver
+      "import-x/resolver": { typescript: true },
+      "import/resolver": { typescript: true }
+    }
+  };
+};
+
+// configs/ignores.ts
+var ignores = [
+  "**/.eslint-config-inspector/**",
+  "**/vite.config.*.timestamp-*",
+  "**/.vitepress/cache/**",
+  "**/node_modules/**",
+  "**/coverage/**",
+  "**/.history/**",
+  "**/.netlify/**",
+  "**/.vercel/**",
+  "**/.output/**",
+  "**/output/**",
+  "**/.cache/**",
+  "**/.temp/**",
+  "**/build/**",
+  "**/.nuxt/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/temp/**",
+  "**/.tmp/**",
+  "**/tmp/**"
+];
+
+// configs/node.ts
+var node = async (config) => {
+  if (!config.node) {
+    return {};
+  }
+  const nodePlugin = await interopDefault(import("eslint-plugin-n"));
+  const files = ["**/*.js", "**/*.cjs", "**/*.mjs"];
+  if (config.typescript) {
+    files.push("**/*.ts", "**/*.cts", "**/*.mts");
+  }
+  if (config.react) {
+    files.push("**/*.jsx");
+    if (config.typescript) {
+      files.push("**/*.tsx");
+    }
+  }
+  return {
+    name: "lzear/node",
+    files,
+    plugins: {
+      n: nodePlugin
+    },
+    rules: {
+      ...nodePlugin.configs["flat/recommended"].rules,
+      "n/hashbang": 0,
+      // n resolver doesn't understand TypeScript imports; TypeScript handles this
+      "n/no-extraneous-import": 0,
+      "n/no-missing-import": 0,
+      "n/no-process-exit": 0
+    },
+    settings: {
+      // Align with the minimum version where import.meta.dirname is stable
+      node: { version: ">=22.16.0" }
+    }
+  };
+};
+
+// configs/package-json.ts
+import * as packageJsonPlugin from "eslint-plugin-package-json";
+import * as jsoncParser from "jsonc-eslint-parser";
+var packageJson = () => ({
+  name: "lzear/package-json",
+  files: ["**/package.json"],
+  plugins: {
+    lzear: plugin,
+    "package-json": packageJsonPlugin
+  },
+  languageOptions: {
+    parser: jsoncParser
+  },
+  rules: {
+    ...packageJsonPlugin.configs.recommended.rules,
+    "lzear/major-version-only": 2,
+    "package-json/repository-shorthand": [2, { form: "shorthand" }]
+  }
+});
+
+// configs/prettier.ts
+import prettierConfig from "eslint-plugin-prettier/recommended";
+var prettier = {
+  ...prettierConfig,
+  rules: {
+    ...prettierConfig.rules,
+    "prettier/prettier": [
+      2,
+      {
+        semi: false,
+        singleQuote: true
+      }
+    ]
+  }
+};
+
+// configs/react.ts
+var react = async (config) => {
+  if (!config.react) {
+    return {};
+  }
+  const [
+    reactCompilerPlugin,
+    reactHooksPlugin,
+    reactPerfPlugin,
+    reactPlugin,
+    nextPlugin,
+    reactXPlugin,
+    reactDomPlugin,
+    reactWebApiPlugin
+  ] = await Promise.all([
+    interopDefault(import("eslint-plugin-react-compiler")),
+    interopDefault(import("eslint-plugin-react-hooks")),
+    interopDefault(import("eslint-plugin-react-perf")),
+    interopDefault(import("eslint-plugin-react")),
+    interopDefault(import("@next/eslint-plugin-next")),
+    interopDefault(import("eslint-plugin-react-x")),
+    interopDefault(import("eslint-plugin-react-dom")),
+    interopDefault(import("eslint-plugin-react-web-api"))
+  ]);
+  const files = ["**/*.jsx"];
+  if (config.typescript) {
+    files.push("**/*.tsx");
+  }
+  return {
+    name: "lzear/react",
+    files,
+    plugins: {
+      "@next/next": nextPlugin,
+      react: reactPlugin,
+      "react-compiler": reactCompilerPlugin,
+      "react-dom": reactDomPlugin,
+      "react-hooks": reactHooksPlugin,
+      "react-perf": reactPerfPlugin,
+      "react-web-api": reactWebApiPlugin,
+      "react-x": reactXPlugin
+    },
+    rules: {
+      "react-compiler/react-compiler": 2,
+      ...reactHooksPlugin.configs.recommended.rules,
+      ...reactPerfPlugin.configs.recommended.rules,
+      "react-perf/jsx-no-new-function-as-prop": 0,
+      "react-perf/jsx-no-new-object-as-prop": 0,
+      ...reactPlugin.configs.recommended.rules,
+      ...nextPlugin.configs.recommended.rules,
+      ...nextPlugin.configs["core-web-vitals"].rules,
+      "react/react-in-jsx-scope": 0,
+      "react/no-unknown-property": ["error", { ignore: ["jsx", "global"] }],
+      ...config.typescript ? reactXPlugin.configs["recommended-typescript"].rules : reactXPlugin.configs.recommended.rules,
+      ...reactDomPlugin.configs.recommended.rules,
+      ...reactWebApiPlugin.configs.recommended.rules
+    },
+    settings: {
+      react: {
+        fragment: "Fragment",
+        pragma: "React",
+        version: "19.0"
+      },
+      "react-x": {
+        importSource: "react",
+        polymorphicPropName: "as",
+        version: "19.0"
+      }
+    }
+  };
+};
+
+// configs/typescript.ts
+import eslint from "@eslint/js";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
+var typescript = async (config) => {
+  if (!config.typescript) {
+    return [];
+  }
+  const { parser: typescriptParser } = await interopDefault(
+    import("typescript-eslint")
+  );
+  const files = ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"];
+  return defineConfig({
+    name: "lzear/typescript",
+    extends: [
+      eslint.configs.recommended,
+      tseslint.configs.strictTypeChecked,
+      tseslint.configs.stylisticTypeChecked
+    ],
+    files,
+    rules: {
+      "@typescript-eslint/no-unnecessary-condition": [
+        2,
+        { allowConstantLoopConditions: "only-allowed-literals" }
+      ],
+      "@typescript-eslint/no-unused-expressions": [2, { allowTernary: true }],
+      "@typescript-eslint/restrict-template-expressions": [
+        2,
+        { allowNumber: true }
+      ]
+    },
+    languageOptions: {
+      parser: typescriptParser,
+      parserOptions: {
+        ecmaFeatures: { jsx: config.react },
+        ecmaVersion: "latest",
+        projectService: true,
+        sourceType: "module",
+        tsconfigRootDir: process.cwd()
+      }
+    }
+  });
+};
+
+// configs/vitest.ts
+var vitest = async (config) => {
+  if (!config.vitest) {
+    return {};
+  }
+  const vitestPlugin = await interopDefault(import("@vitest/eslint-plugin"));
+  const files = [
+    "**/test/*.js",
+    "**/test/*.cjs",
+    "**/test/*.mjs",
+    "**/*.test.js",
+    "**/*.test.cjs",
+    "**/*.test.mjs"
+  ];
+  if (config.typescript) {
+    files.push(
+      "**/test/*.ts",
+      "**/test/*.cts",
+      "**/test/*.mts",
+      "**/*.test.ts",
+      "**/*.test.cts",
+      "**/*.test.mts"
+    );
+  }
+  if (config.react) {
+    files.push("**/test/*.jsx", "**/*.test.jsx");
+    if (config.typescript) {
+      files.push("**/test/*.tsx", "**/*.test.tsx");
+    }
+  }
+  return {
+    name: "lzear/vitest",
+    files,
+    plugins: {
+      vitest: vitestPlugin
+    },
+    rules: {
+      ...vitestPlugin.configs.recommended.rules,
+      "vitest/consistent-test-it": [2, { fn: "it" }],
+      // Using Vitest globals mode — explicit imports not required
+      "vitest/prefer-importing-vitest-globals": 0
+    },
+    settings: {
+      vitest: {
+        typecheck: true
+      }
+    }
+  };
+};
+
+// index.ts
+var configGenerator = async (options = {}) => {
+  const config = {
+    node: true,
+    react: true,
+    typescript: true,
+    vitest: true,
+    ...options
+  };
+  const [reactConfig, nodeConfig, typescriptConfig, vitestConfig] = await Promise.all([
+    react(config),
+    node(config),
+    typescript(config),
+    vitest(config)
+  ]);
+  return [
+    { name: "lzear/ignores", ignores },
+    core(),
+    a11y(config),
+    reactConfig,
+    nodeConfig,
+    typescriptConfig,
+    vitestConfig,
+    packageJson(),
+    prettier
+  ].flat();
+};
+var index_default = configGenerator;
+export {
+  index_default as default
+};