@santi020k/eslint-config-basic 3.0.0 → 3.2.0

package/dist/cli-advanced.js

@@ -0,0 +1,217 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+const CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+const RULE_PACKAGE_HINTS = {
+  "@angular-eslint": "@santi020k/eslint-config-angular",
+  "@eslint-react": "@santi020k/eslint-config-react",
+  "@next/next": "@santi020k/eslint-config-next",
+  "@typescript-eslint": "@santi020k/eslint-config-typescript",
+  astro: "@santi020k/eslint-config-astro",
+  cypress: "@santi020k/eslint-config-testing",
+  jest: "@santi020k/eslint-config-testing",
+  "jsonc": "@santi020k/eslint-config-formats",
+  playwright: "@santi020k/eslint-config-testing",
+  react: "@santi020k/eslint-config-react",
+  "testing-library": "@santi020k/eslint-config-testing",
+  unicorn: "@santi020k/eslint-config-extensions",
+  vue: "@santi020k/eslint-config-vue"
+};
+const semver = createRequire(import.meta.url)("semver");
+const readJson = (filePath) => {
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+};
+const findConfigPath = (cwd) => CONFIG_FILENAMES.map((file) => join(cwd, file)).find((file) => existsSync(file)) ?? null;
+const flattenConfig = async (value) => {
+  const resolved = await value;
+  if (Array.isArray(resolved)) {
+    const nested = await Promise.all(resolved.map((entry) => flattenConfig(entry)));
+    return nested.flat();
+  }
+  if (resolved && typeof resolved === "object") return [resolved];
+  return [];
+};
+const loadConfigEntries = async (configPath) => {
+  if (!configPath) return [];
+  try {
+    const loaded = await import(`${pathToFileURL(configPath).href}?basic-eslint-explain=${Date.now()}`);
+    if (!loaded || typeof loaded !== "object" || !("default" in loaded)) return [];
+    return await flattenConfig(loaded.default);
+  } catch {
+    return [];
+  }
+};
+const loadProjectEslint = (cwd) => {
+  const projectRequire = createRequire(join(cwd, "package.json"));
+  const eslintModule = projectRequire("eslint");
+  if (!eslintModule.ESLint) throw new Error("The installed eslint package does not expose the ESLint API.");
+  return new eslintModule.ESLint({ cwd });
+};
+const getRuleSeverity = (ruleValue) => Array.isArray(ruleValue) ? ruleValue[0] : ruleValue;
+const isRuleEnabled = (ruleValue) => {
+  const severity = getRuleSeverity(ruleValue);
+  return severity !== 0 && severity !== "off";
+};
+const getPackageHint = (rule) => {
+  const prefix = rule.includes("/") ? rule.slice(0, rule.indexOf("/")) : rule;
+  const scopedPrefix = rule.startsWith("@") ? rule.split("/").slice(0, 2).join("/") : prefix;
+  return RULE_PACKAGE_HINTS[scopedPrefix] ?? RULE_PACKAGE_HINTS[prefix] ?? null;
+};
+const handleExplainRule = async (cwd = process.cwd(), options) => {
+  const configPath = findConfigPath(cwd);
+  const file = options.file ?? "eslint.config.js";
+  const eslint = loadProjectEslint(cwd);
+  const effective = await eslint.calculateConfigForFile(file);
+  const effectiveValue = effective?.rules?.[options.rule];
+  const entries = await loadConfigEntries(configPath);
+  const sources = entries.flatMap((entry, index) => {
+    if (!entry.rules || !Object.hasOwn(entry.rules, options.rule)) return [];
+    return [{
+      files: entry.files ?? null,
+      index,
+      name: entry.name ?? `anonymous config #${index + 1}`,
+      value: entry.rules[options.rule]
+    }];
+  });
+  const payload = {
+    configFile: configPath ? basename(configPath) : null,
+    effective: effectiveValue ?? null,
+    enabled: effectiveValue !== void 0 && isRuleEnabled(effectiveValue),
+    file,
+    packageHint: getPackageHint(options.rule),
+    rule: options.rule,
+    severity: effectiveValue === void 0 ? null : getRuleSeverity(effectiveValue),
+    sources
+  };
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log([
+      `ESLint rule explanation: ${payload.rule}`,
+      `- File: ${payload.file}`,
+      `- Config: ${payload.configFile ?? "none"}`,
+      `- Effective value: ${JSON.stringify(payload.effective)}`,
+      `- Enabled: ${payload.enabled ? "yes" : "no"}`,
+      `- Likely package: ${payload.packageHint ?? "core or custom config"}`,
+      `- Defining entries: ${payload.sources.length}`
+    ].join("\n"));
+    for (const source of payload.sources) {
+      console.log(`  - ${source.name}: ${JSON.stringify(source.value)}`);
+    }
+  }
+  if (effectiveValue === void 0) process.exitCode = 1;
+};
+const getDependencyVersions = (manifest) => {
+  const fields = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+  const dependencies = {};
+  for (const field of fields) {
+    const values = manifest?.[field];
+    if (!values || typeof values !== "object" || Array.isArray(values)) continue;
+    for (const [name, version] of Object.entries(values)) {
+      if (typeof version === "string") dependencies[name] = version;
+    }
+  }
+  return dependencies;
+};
+const readResolvedManifest = (projectRequire, packageName) => {
+  try {
+    let directory = dirname(projectRequire.resolve(packageName));
+    for (let depth = 0; depth < 6; depth++) {
+      const manifestPath = join(directory, "package.json");
+      const manifest = readJson(manifestPath);
+      if (manifest?.name === packageName) return manifest;
+      directory = dirname(directory);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+const readWorkspaceManifest = (cwd, packageName) => {
+  const packagesPath = join(cwd, "packages");
+  if (!existsSync(packagesPath)) return null;
+  for (const entry of readdirSync(packagesPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const manifest = readJson(join(packagesPath, entry.name, "package.json"));
+    if (manifest?.name === packageName) return manifest;
+  }
+  return null;
+};
+const createCompatibilityReport = (cwd = process.cwd()) => {
+  const rootManifest = readJson(join(cwd, "package.json"));
+  const declared = getDependencyVersions(rootManifest);
+  const projectRequire = createRequire(join(cwd, "package.json"));
+  const configPackages = Object.keys(declared).filter((name) => name.startsWith("@santi020k/eslint-config-")).sort();
+  const runtimeVersions = {
+    eslint: readResolvedManifest(projectRequire, "eslint")?.version ?? null,
+    node: process.versions.node,
+    typescript: readResolvedManifest(projectRequire, "typescript")?.version ?? null
+  };
+  const packages = configPackages.map((name) => {
+    const manifest = readResolvedManifest(projectRequire, name) ?? readWorkspaceManifest(cwd, name);
+    const issues = [];
+    if (!manifest) {
+      issues.push("declared but not installed");
+    } else {
+      const nodeRange = manifest.engines?.node;
+      if (nodeRange && !semver.satisfies(runtimeVersions.node, nodeRange)) {
+        issues.push(`requires Node ${nodeRange}`);
+      }
+      for (const peer of ["eslint", "typescript"]) {
+        const range = manifest.peerDependencies?.[peer];
+        const version = runtimeVersions[peer];
+        if (range && version && !semver.satisfies(version, range)) {
+          issues.push(`requires ${peer} ${range}, resolved ${version}`);
+        }
+      }
+    }
+    return {
+      declared: declared[name],
+      issues,
+      name,
+      resolved: manifest?.version ?? null
+    };
+  });
+  return {
+    compatible: packages.every((item) => item.issues.length === 0),
+    packages,
+    runtime: runtimeVersions
+  };
+};
+const handleCompatibility = (cwd = process.cwd(), json = false) => {
+  const report = createCompatibilityReport(cwd);
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log([
+      `ESLint compatibility: ${report.compatible ? "compatible" : "issues found"}`,
+      `- Node: ${report.runtime.node}`,
+      `- ESLint: ${report.runtime.eslint ?? "not installed"}`,
+      `- TypeScript: ${report.runtime.typescript ?? "not installed"}`
+    ].join("\n"));
+    for (const item of report.packages) {
+      console.log(
+        `- ${item.name}: ${item.resolved ?? "not installed"}` + (item.issues.length > 0 ? ` (${item.issues.join("; ")})` : "")
+      );
+    }
+  }
+  if (!report.compatible) process.exitCode = 1;
+};
+export {
+  createCompatibilityReport,
+  handleCompatibility,
+  handleExplainRule
+};

package/dist/cli-migration.d.ts

@@ -0,0 +1,26 @@
+interface V3MigrationContext {
+    declaredConfigPackages?: string[];
+    extensions: string[];
+    formats: string[];
+    frameworks: string[];
+    libraries: string[];
+    packageManager: string;
+    testing: string[];
+    tools: string[];
+    typescript: boolean;
+}
+interface V3MigrationOptions {
+    check?: boolean;
+    full?: boolean;
+    json?: boolean;
+    write?: boolean;
+}
+declare const getExplicitConfigFeaturePackages: (content: string) => string[];
+declare const migrateConfigToV3: (content: string, mode: "full" | "lean") => {
+    changes: string[];
+    content: string;
+    featurePackages: string[];
+};
+declare const handleMigrateV3: (cwd: string, context: V3MigrationContext, options?: V3MigrationOptions) => void;
+
+export { type V3MigrationContext, type V3MigrationOptions, getExplicitConfigFeaturePackages, handleMigrateV3, migrateConfigToV3 };