@santi020k/eslint-config-basic 3.1.0 → 3.2.0

package/dist/cli-preset.js

@@ -0,0 +1,315 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { createRequire, findPackageJSON } from "node:module";
+import { join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  detectProjectOptions,
+  Preset
+} from "@santi020k/eslint-config-core";
+import { getDefineConfigMetadata } from "./define-config-metadata.js";
+import { defineConfig } from "./index.js";
+import { isMissingRequestedPackage } from "./optional-package-errors.js";
+import { resolvePreset } from "./resolvers.js";
+const PRESETS = new Set(Object.values(Preset));
+const CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+const loadDefineConfigMetadata = async (cwd) => {
+  const configPath = CONFIG_FILENAMES.map((name) => join(cwd, name)).find((path) => existsSync(path));
+  if (!configPath) return void 0;
+  try {
+    const loaded = await import(`${pathToFileURL(configPath).href}?basic-eslint-preset=${Date.now()}`);
+    return getDefineConfigMetadata(await loaded.default);
+  } catch {
+    return void 0;
+  }
+};
+const PRESET_FEATURE_PACKAGES = {
+  extensions: "@santi020k/eslint-config-extensions",
+  formats: "@santi020k/eslint-config-formats",
+  libraries: "@santi020k/eslint-config-libraries",
+  testing: "@santi020k/eslint-config-testing",
+  tools: "@santi020k/eslint-config-tools"
+};
+const FRAMEWORK_PACKAGES = {
+  angular: "@santi020k/eslint-config-angular",
+  astro: "@santi020k/eslint-config-astro",
+  expo: "@santi020k/eslint-config-expo",
+  hono: "@santi020k/eslint-config-hono",
+  lit: "@santi020k/eslint-config-lit",
+  nest: "@santi020k/eslint-config-nest",
+  next: "@santi020k/eslint-config-next",
+  nuxt: "@santi020k/eslint-config-nuxt",
+  preact: "@santi020k/eslint-config-preact",
+  qwik: "@santi020k/eslint-config-qwik",
+  react: "@santi020k/eslint-config-react",
+  "react-router": "@santi020k/eslint-config-react-router",
+  slidev: "@santi020k/eslint-config-slidev",
+  solid: "@santi020k/eslint-config-solid",
+  svelte: "@santi020k/eslint-config-svelte",
+  "tanstack-start": "@santi020k/eslint-config-tanstack-start",
+  vite: "@santi020k/eslint-config-vite",
+  vue: "@santi020k/eslint-config-vue"
+};
+const FRAMEWORK_PREFIXES = /* @__PURE__ */ new Set([
+  "@angular-eslint",
+  "@eslint-react",
+  "@next/next",
+  "astro",
+  "lit",
+  "qwik",
+  "react",
+  "react-hooks",
+  "react-refresh",
+  "solid",
+  "svelte",
+  "vue"
+]);
+const DOMAIN_PREFIXES = /* @__PURE__ */ new Set([
+  "better-tailwindcss",
+  "drizzle",
+  "graphql-eslint",
+  "i18next",
+  "prisma",
+  "storybook",
+  "tailwindcss",
+  "tanstack-query",
+  "turbo",
+  "zod"
+]);
+const FORMAT_PREFIXES = /* @__PURE__ */ new Set([
+  "@stylistic",
+  "css",
+  "html",
+  "jsonc",
+  "markdown",
+  "mdx",
+  "prettier",
+  "toml",
+  "yaml"
+]);
+const MULTI_SEGMENT_RULE_PREFIXES = /* @__PURE__ */ new Set(["@next/next"]);
+const getRulePrefix = (rule) => {
+  const segments = rule.split("/");
+  if (!rule.startsWith("@")) return segments[0];
+  const multiSegmentPrefix = segments.slice(0, 2).join("/");
+  return MULTI_SEGMENT_RULE_PREFIXES.has(multiSegmentPrefix) ? multiSegmentPrefix : segments[0];
+};
+const getRuleGroup = (rule) => {
+  const prefix = getRulePrefix(rule);
+  if (prefix === "security" || prefix === "no-secrets" || rule.includes("security") || rule.includes("no-unsanitized")) return "security";
+  if (FRAMEWORK_PREFIXES.has(prefix)) return "framework";
+  if (DOMAIN_PREFIXES.has(prefix)) return "domain";
+  if (FORMAT_PREFIXES.has(prefix) || rule.includes("format") || rule.includes("spacing")) return "formatting";
+  return "correctness";
+};
+const getSeverity = (value) => Array.isArray(value) ? value[0] : value;
+const isEnabled = (value) => {
+  const severity = getSeverity(value);
+  return severity !== 0 && severity !== "off" && severity !== void 0;
+};
+const normalizeRule = (value) => JSON.stringify(value);
+const loadProjectEslint = (cwd, overrideConfig) => {
+  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,
+    ...overrideConfig ? { overrideConfig, overrideConfigFile: true } : {}
+  });
+};
+const getResolvablePresetOptions = (cwd, presetOptions) => {
+  const projectPackageUrl = pathToFileURL(join(cwd, "package.json"));
+  const options = { ...presetOptions };
+  const detectedOptions = detectProjectOptions(cwd);
+  const missingPackages = /* @__PURE__ */ new Set();
+  const detection = options.detection;
+  const detectionControls = typeof detection === "object" ? detection : {};
+  const detectionEnabled = (category) => detection !== false && detectionControls[category] !== false;
+  for (const [category, specifier] of Object.entries(PRESET_FEATURE_PACKAGES)) {
+    const categoryKey = category;
+    const explicit = options[categoryKey];
+    const detected = detectionEnabled(categoryKey) ? detectedOptions[categoryKey] : [];
+    const selected = [.../* @__PURE__ */ new Set([
+      ...Array.isArray(explicit) ? explicit : [],
+      ...Array.isArray(detected) ? detected : []
+    ])];
+    if (selected.length === 0) continue;
+    try {
+      findPackageJSON(specifier, projectPackageUrl);
+    } catch (error) {
+      if (!isMissingRequestedPackage(error, specifier)) throw error;
+      Object.assign(options, {
+        [category]: [],
+        detection: {
+          ...typeof options.detection === "object" ? options.detection : detectionControls,
+          [category]: false
+        },
+        features: {
+          ...options.features,
+          ...Object.fromEntries(selected.map((feature) => [feature, false]))
+        }
+      });
+      missingPackages.add(specifier);
+    }
+  }
+  const frameworkDetectionEnabled = detection !== false && detectionControls.frameworks !== false;
+  const detectedFrameworks = frameworkDetectionEnabled ? detectedOptions.detectedFrameworks ?? [] : [];
+  const configuredFrameworks = Object.entries(options.frameworks ?? {}).filter((entry) => entry[1] === true).map(([framework]) => framework);
+  const selectedFrameworks = [.../* @__PURE__ */ new Set([...detectedFrameworks, ...configuredFrameworks])];
+  const resolvableFrameworks = {
+    ...options.frameworks
+  };
+  for (const framework of selectedFrameworks) {
+    const specifier = FRAMEWORK_PACKAGES[framework];
+    try {
+      findPackageJSON(specifier, projectPackageUrl);
+      resolvableFrameworks[framework] = true;
+    } catch (error) {
+      if (!isMissingRequestedPackage(error, specifier)) throw error;
+      Reflect.deleteProperty(resolvableFrameworks, framework);
+      missingPackages.add(specifier);
+    }
+  }
+  if (!resolvableFrameworks.react) {
+    delete resolvableFrameworks.expo;
+    delete resolvableFrameworks.next;
+    delete resolvableFrameworks["react-router"];
+    if (!resolvableFrameworks.solid) delete resolvableFrameworks["tanstack-start"];
+  }
+  if (!resolvableFrameworks.vue) {
+    delete resolvableFrameworks.nuxt;
+    delete resolvableFrameworks.slidev;
+  }
+  if (selectedFrameworks.length > 0) {
+    options.autoFrameworks = false;
+    options.frameworks = resolvableFrameworks;
+  }
+  return { missingPackages: [...missingPackages], options };
+};
+const createCompatibilityConfig = (preset, addedRules, changedRules) => [
+  `// Temporary compatibility override generated for Preset.${preset.charAt(0).toUpperCase()}${preset.slice(1)}.`,
+  "// Remove entries as the project adopts the preset findings.",
+  "export default {",
+  `  name: 'eslint-config-basic/preset-${preset}-compatibility',`,
+  "  rules: {",
+  ...Object.keys(addedRules).sort().map((rule) => `    ${JSON.stringify(rule)}: 'off',`),
+  ...Object.keys(changedRules).sort().map((rule) => `    ${JSON.stringify(rule)}: ${JSON.stringify(changedRules[rule].from)},`),
+  "  },",
+  "}",
+  ""
+].join("\n");
+const createPresetReport = async (cwd, presetName, file = "eslint.config.js") => {
+  const normalizedPreset = presetName.toLowerCase();
+  if (!PRESETS.has(normalizedPreset)) {
+    throw new Error(
+      `Unknown preset "${presetName}". Use one of: ${[...PRESETS].sort().join(", ")}.`
+    );
+  }
+  const preset = normalizedPreset;
+  const presetOptions = resolvePreset(preset);
+  const current = await loadProjectEslint(cwd).calculateConfigForFile(file);
+  const currentMetadata = await loadDefineConfigMetadata(cwd);
+  const currentOptions = currentMetadata?.options ?? {};
+  const targetOptions = {
+    ...presetOptions,
+    ...currentOptions,
+    features: {
+      ...presetOptions.features,
+      ...currentOptions.features
+    },
+    frameworks: {
+      ...presetOptions.frameworks,
+      ...currentOptions.frameworks
+    },
+    preset,
+    root: currentOptions.root ?? cwd
+  };
+  const { missingPackages, options: resolvablePresetOptions } = getResolvablePresetOptions(cwd, targetOptions);
+  if (!current) {
+    throw new Error(`ESLint did not calculate a current configuration for ${file}. Check that the file is not ignored.`);
+  }
+  const selectedConfig = await defineConfig(
+    resolvablePresetOptions,
+    ...currentMetadata?.extraConfigs ?? []
+  );
+  const selected = await loadProjectEslint(cwd, selectedConfig).calculateConfigForFile(file);
+  if (!selected) {
+    throw new Error(`The ${normalizedPreset} preset did not produce a configuration for ${file}.`);
+  }
+  const currentRules = current.rules ?? {};
+  const selectedRules = selected.rules ?? {};
+  const added = {};
+  const changed = {};
+  const removed = {};
+  for (const [rule, value] of Object.entries(selectedRules)) {
+    const currentValue = currentRules[rule];
+    if (isEnabled(value) && !isEnabled(currentValue)) {
+      added[rule] = value;
+    } else if (isEnabled(value) && isEnabled(currentValue) && normalizeRule(value) !== normalizeRule(currentValue)) {
+      changed[rule] = { from: currentValue, to: value };
+    }
+  }
+  for (const [rule, value] of Object.entries(currentRules)) {
+    if (isEnabled(value) && !isEnabled(selectedRules[rule])) removed[rule] = value;
+  }
+  const groups = Object.fromEntries(
+    ["formatting", "correctness", "security", "framework", "domain"].map((group) => [
+      group,
+      Object.keys(added).filter((rule) => getRuleGroup(rule) === group).sort()
+    ])
+  );
+  return {
+    added,
+    changed,
+    file,
+    groups,
+    missingPackages,
+    preset: normalizedPreset,
+    presetOptions,
+    removed,
+    totals: {
+      added: Object.keys(added).length,
+      changed: Object.keys(changed).length,
+      removed: Object.keys(removed).length
+    }
+  };
+};
+const handleExplainPreset = async (cwd = process.cwd(), preset, options = {}) => {
+  const report = await createPresetReport(cwd, preset, options.file);
+  let compatibilityFile = null;
+  if (options.compatibility) {
+    const output = options.output ?? `.eslint-preset-${report.preset}-compat.mjs`;
+    const outputPath = join(cwd, output);
+    if (existsSync(outputPath)) {
+      throw new Error(`${output} already exists; remove it or choose another path with --output.`);
+    }
+    writeFileSync(outputPath, createCompatibilityConfig(report.preset, report.added, report.changed));
+    compatibilityFile = relative(cwd, outputPath);
+  }
+  const payload = { ...report, compatibilityFile };
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log([
+    `Preset adoption report: ${report.preset}`,
+    `- Representative file: ${report.file}`,
+    `- Newly enabled rules: ${report.totals.added}`,
+    `- Changed rule options: ${report.totals.changed}`,
+    `- Rules no longer enabled: ${report.totals.removed}`,
+    `- Optional packs not installed (excluded from comparison): ${report.missingPackages.length > 0 ? report.missingPackages.join(", ") : "none"}`,
+    "",
+    ...Object.entries(report.groups).map(([group, rules]) => `- ${group}: ${rules.length}${rules.length > 0 ? ` (${rules.join(", ")})` : ""}`),
+    ...compatibilityFile ? ["", `Compatibility override written to ${compatibilityFile}. Import it after the preset config.`] : ["", "Pass --compatibility to write a temporary override that disables newly enabled rules."]
+  ].join("\n"));
+};
+export {
+  createPresetReport,
+  handleExplainPreset
+};

package/dist/cli.d.ts

@@ -1,3 +1,15 @@
+interface InstallResult {
+    error?: Error;
+    status: null | number;
+    stderr?: Buffer | string;
+    stdout?: Buffer | string;
+}
+type InstallRunner = (command: string, args: string[], options: {
+    cwd: string;
+    encoding: 'utf8';
+    maxBuffer: number;
+    stdio: 'pipe';
+}) => InstallResult;
 declare const handleInit: (cwd?: string, check?: boolean, explicit?: boolean) => void;
 declare const handleUpdate: (cwd?: string) => void;
 declare const handleExplain: (cwd?: string, json?: boolean) => void;
@@ -15,7 +27,7 @@ interface DuplicateEslintInfo {
  */
 declare const findDuplicateEslint: (cwd?: string) => DuplicateEslintInfo | null;
 declare const handleDoctor: (cwd?: string, json?: boolean, liteInstall?: boolean, fix?: boolean) => Promise<void>;
-declare const handleInstall: (cwd?: string, dryRun?: boolean) => void;
+declare const handleInstall: (cwd?: string, dryRun?: boolean, runner?: InstallRunner) => void;
 declare const handleDocs: (cwd?: string) => void;
 declare const handleMigrate: (cwd?: string, write?: boolean, json?: boolean, target?: string, check?: boolean, full?: boolean) => void;
 declare const runCli: (argv?: string[], cwd?: string) => void;