@eslint-config-snapshot/api 0.1.0

package/dist/index.cjs

@@ -0,0 +1,610 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  aggregateRules: () => aggregateRules,
+  assignGroupsByMatch: () => assignGroupsByMatch,
+  buildSnapshot: () => buildSnapshot,
+  canonicalizeJson: () => canonicalizeJson,
+  compareSeverity: () => compareSeverity,
+  diffSnapshots: () => diffSnapshots,
+  discoverWorkspaces: () => discoverWorkspaces,
+  extractRulesFromPrintConfig: () => extractRulesFromPrintConfig,
+  findConfigPath: () => findConfigPath,
+  getConfigScaffold: () => getConfigScaffold,
+  hasDiff: () => hasDiff,
+  loadConfig: () => loadConfig,
+  normalizePath: () => normalizePath,
+  normalizeSeverity: () => normalizeSeverity,
+  readSnapshotFile: () => readSnapshotFile,
+  resolveEslintBinForWorkspace: () => resolveEslintBinForWorkspace,
+  sampleWorkspaceFiles: () => sampleWorkspaceFiles,
+  sortUnique: () => sortUnique,
+  writeSnapshotFile: () => writeSnapshotFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+function normalizePath(input) {
+  const withSlashes = input.replaceAll("\\", "/");
+  const collapsed = withSlashes.replaceAll(/\/+/g, "/");
+  const withoutTrailing = collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
+  return withoutTrailing === "" ? "." : withoutTrailing;
+}
+function sortUnique(list) {
+  return [...new Set(list.map((item) => normalizePath(item)))].sort();
+}
+function canonicalizeJson(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => canonicalizeJson(entry));
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const result = {};
+    for (const key of Object.keys(record).sort()) {
+      const entry = record[key];
+      if (entry !== void 0) {
+        result[key] = canonicalizeJson(entry);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function compareSeverity(a, b) {
+  const rank = { off: 0, warn: 1, error: 2 };
+  return rank[a] - rank[b];
+}
+function normalizeSeverity(value) {
+  if (value === 0 || value === "off") {
+    return "off";
+  }
+  if (value === 1 || value === "warn") {
+    return "warn";
+  }
+  if (value === 2 || value === "error") {
+    return "error";
+  }
+  throw new Error(`Unsupported severity: ${String(value)}`);
+}
+
+// src/workspace.ts
+var import_get_packages = require("@manypkg/get-packages");
+var import_node_path = __toESM(require("path"), 1);
+var import_picomatch = __toESM(require("picomatch"), 1);
+async function discoverWorkspaces(options) {
+  const cwd = options?.cwd ? import_node_path.default.resolve(options.cwd) : process.cwd();
+  const workspaceInput = options?.workspaceInput ?? { mode: "discover" };
+  if (workspaceInput.mode === "manual") {
+    const rootAbs2 = import_node_path.default.resolve(workspaceInput.rootAbs ?? cwd);
+    return {
+      rootAbs: rootAbs2,
+      workspacesRel: sortUnique(workspaceInput.workspaces)
+    };
+  }
+  const { rootDir, packages } = await (0, import_get_packages.getPackages)(cwd);
+  const workspacesAbs = packages.map((pkg) => pkg.dir);
+  const rootAbs = rootDir ? import_node_path.default.resolve(rootDir) : lowestCommonAncestor(workspacesAbs);
+  const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(import_node_path.default.relative(rootAbs, entry))));
+  return {
+    rootAbs,
+    workspacesRel
+  };
+}
+function assignGroupsByMatch(workspacesRel, groups) {
+  const sortedWorkspaces = sortUnique([...workspacesRel]);
+  const assignments = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    assignments.set(group.name, []);
+  }
+  const unmatched = [];
+  for (const workspace of sortedWorkspaces) {
+    let assigned = false;
+    for (const group of groups) {
+      if (matchesWorkspace(workspace, group.match)) {
+        assignments.get(group.name)?.push(workspace);
+        assigned = true;
+        break;
+      }
+    }
+    if (!assigned) {
+      unmatched.push(workspace);
+    }
+  }
+  if (unmatched.length > 0) {
+    throw new Error(`Unmatched workspaces: ${unmatched.join(", ")}`);
+  }
+  return groups.map((group) => ({
+    name: group.name,
+    workspaces: assignments.get(group.name) ?? []
+  }));
+}
+function matchesWorkspace(workspace, patterns) {
+  const positives = patterns.filter((pattern) => !pattern.startsWith("!"));
+  const negatives = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+  const isPositiveMatch = positives.some((pattern) => (0, import_picomatch.default)(pattern, { dot: true })(workspace));
+  if (!isPositiveMatch) {
+    return false;
+  }
+  const isNegativeMatch = negatives.some((pattern) => (0, import_picomatch.default)(pattern, { dot: true })(workspace));
+  return !isNegativeMatch;
+}
+function lowestCommonAncestor(paths) {
+  if (paths.length === 0) {
+    return process.cwd();
+  }
+  const segments = paths.map((entry) => import_node_path.default.resolve(entry).split(import_node_path.default.sep));
+  const minLen = Math.min(...segments.map((parts) => parts.length));
+  const common = [];
+  for (let index = 0; index < minLen; index += 1) {
+    const value = segments[0][index];
+    if (segments.every((parts) => parts[index] === value)) {
+      common.push(value);
+    } else {
+      break;
+    }
+  }
+  if (common.length === 0) {
+    return import_node_path.default.parse(import_node_path.default.resolve(paths[0])).root;
+  }
+  return common.join(import_node_path.default.sep);
+}
+
+// src/sampling.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_picomatch2 = __toESM(require("picomatch"), 1);
+async function sampleWorkspaceFiles(workspaceAbs, config) {
+  const all = await (0, import_fast_glob.default)(config.includeGlobs, {
+    cwd: workspaceAbs,
+    ignore: config.excludeGlobs,
+    onlyFiles: true,
+    dot: true,
+    unique: true
+  });
+  const normalized = sortUnique(all.map((entry) => normalizePath(entry)));
+  if (normalized.length === 0) {
+    return [];
+  }
+  if (normalized.length <= config.maxFilesPerWorkspace) {
+    return normalized;
+  }
+  if (config.hintGlobs.length === 0) {
+    return selectDistributed(normalized, config.maxFilesPerWorkspace);
+  }
+  const hinted = normalized.filter((entry) => config.hintGlobs.some((pattern) => (0, import_picomatch2.default)(pattern, { dot: true })(entry)));
+  const notHinted = normalized.filter((entry) => !hinted.includes(entry));
+  return selectDistributed([...hinted, ...notHinted], config.maxFilesPerWorkspace);
+}
+function selectDistributed(files, count) {
+  if (files.length <= count) {
+    return files;
+  }
+  const selected = [];
+  const selectedSet = /* @__PURE__ */ new Set();
+  const tokenSeen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (selected.length >= count) {
+      break;
+    }
+    const token = getPrimaryToken(file);
+    if (!token || tokenSeen.has(token)) {
+      continue;
+    }
+    tokenSeen.add(token);
+    selected.push(file);
+    selectedSet.add(file);
+  }
+  if (selected.length >= count) {
+    return sortUnique(selected).slice(0, count);
+  }
+  const remaining = files.filter((file) => !selectedSet.has(file));
+  const needed = count - selected.length;
+  const spaced = pickUniformly(remaining, needed);
+  return sortUnique([...selected, ...spaced]).slice(0, count);
+}
+function pickUniformly(files, count) {
+  if (count <= 0 || files.length === 0) {
+    return [];
+  }
+  if (files.length <= count) {
+    return files;
+  }
+  if (count === 1) {
+    return [files[0]];
+  }
+  const picked = [];
+  const usedIndices = /* @__PURE__ */ new Set();
+  for (let index = 0; index < count; index += 1) {
+    const raw = Math.round(index * (files.length - 1) / (count - 1));
+    const safeIndex = nextFreeIndex(raw, usedIndices, files.length);
+    usedIndices.add(safeIndex);
+    picked.push(files[safeIndex]);
+  }
+  return picked;
+}
+function nextFreeIndex(candidate, used, max) {
+  if (!used.has(candidate)) {
+    return candidate;
+  }
+  for (let delta = 1; delta < max; delta += 1) {
+    const forward = candidate + delta;
+    if (forward < max && !used.has(forward)) {
+      return forward;
+    }
+    const backward = candidate - delta;
+    if (backward >= 0 && !used.has(backward)) {
+      return backward;
+    }
+  }
+  return candidate;
+}
+function getPrimaryToken(file) {
+  const parts = file.split("/");
+  const basename = parts.slice(-1)[0];
+  if (!basename) {
+    return null;
+  }
+  const nameOnly = basename.replace(/\.[^.]+$/u, "");
+  const expanded = nameOnly.replaceAll(/([a-z])([A-Z])/gu, "$1 $2").replaceAll(/[_\-.]+/gu, " ").toLowerCase();
+  const token = expanded.split(/\s+/u).find((entry) => entry.length > 1 && !GENERIC_TOKENS.has(entry));
+  return token ?? null;
+}
+var GENERIC_TOKENS = /* @__PURE__ */ new Set(["src", "index", "main", "test", "spec", "package", "packages", "lib", "dist"]);
+
+// src/extract.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_module = require("module");
+var import_node_path2 = __toESM(require("path"), 1);
+function resolveEslintBinForWorkspace(workspaceAbs) {
+  const anchor = import_node_path2.default.join(workspaceAbs, "__snapshot_anchor__.cjs");
+  const req = (0, import_node_module.createRequire)(anchor);
+  try {
+    return req.resolve("eslint/bin/eslint.js");
+  } catch {
+    try {
+      const eslintEntry = req.resolve("eslint");
+      const eslintRoot = findPackageRoot(eslintEntry);
+      const packageJsonPath = import_node_path2.default.join(eslintRoot, "package.json");
+      const packageJson = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
+      const relativeBin = resolveBinPath(packageJson.bin);
+      const binAbs = import_node_path2.default.resolve(eslintRoot, relativeBin);
+      if ((0, import_node_fs.existsSync)(binAbs)) {
+        return binAbs;
+      }
+    } catch {
+    }
+    throw new Error(`Unable to resolve eslint from workspace: ${workspaceAbs}`);
+  }
+}
+function resolveBinPath(bin) {
+  if (typeof bin === "string") {
+    return bin;
+  }
+  if (typeof bin?.eslint === "string") {
+    return bin.eslint;
+  }
+  return "bin/eslint.js";
+}
+function findPackageRoot(entryAbs) {
+  let current = import_node_path2.default.dirname(entryAbs);
+  while (true) {
+    const packageJsonPath = import_node_path2.default.join(current, "package.json");
+    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
+      return current;
+    }
+    const parent = import_node_path2.default.dirname(current);
+    if (parent === current) {
+      throw new Error("Package root not found");
+    }
+    current = parent;
+  }
+}
+function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
+  const eslintBin = resolveEslintBinForWorkspace(workspaceAbs);
+  const proc = (0, import_node_child_process.spawnSync)(process.execPath, [eslintBin, "--print-config", fileAbs], {
+    cwd: workspaceAbs,
+    encoding: "utf8"
+  });
+  if (proc.status !== 0) {
+    throw new Error(`Failed to run eslint --print-config for ${fileAbs}`);
+  }
+  const stdout = proc.stdout.trim();
+  if (stdout.length === 0 || stdout === "undefined") {
+    throw new Error(`Empty ESLint print-config output for ${fileAbs}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new Error(`Invalid JSON from eslint --print-config for ${fileAbs}`);
+  }
+  const rules = parsed.rules ?? {};
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [ruleName, ruleConfig] of Object.entries(rules)) {
+    normalized.set(ruleName, normalizeRuleEntry(ruleConfig));
+  }
+  return normalized;
+}
+function normalizeRuleEntry(raw) {
+  if (Array.isArray(raw)) {
+    if (raw.length === 0) {
+      throw new Error("Rule configuration array cannot be empty");
+    }
+    const severity = normalizeSeverity(raw[0]);
+    const rest = raw.slice(1).map((item) => canonicalizeJson(item));
+    if (rest.length === 0) {
+      return [severity];
+    }
+    if (rest.length === 1) {
+      return [severity, rest[0]];
+    }
+    return [severity, canonicalizeJson(rest)];
+  }
+  return [normalizeSeverity(raw)];
+}
+
+// src/snapshot.ts
+var import_promises = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
+function aggregateRules(ruleMaps) {
+  const aggregated = /* @__PURE__ */ new Map();
+  for (const rules of ruleMaps) {
+    for (const [ruleName, nextEntry] of rules.entries()) {
+      const currentEntry = aggregated.get(ruleName);
+      if (!currentEntry) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry));
+        continue;
+      }
+      const severityCmp = compareSeverity(nextEntry[0], currentEntry[0]);
+      if (severityCmp > 0) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry));
+        continue;
+      }
+      if (severityCmp < 0) {
+        continue;
+      }
+      const currentOptions = currentEntry.length > 1 ? canonicalizeJson(currentEntry[1]) : void 0;
+      const nextOptions = nextEntry.length > 1 ? canonicalizeJson(nextEntry[1]) : void 0;
+      if (JSON.stringify(currentOptions) !== JSON.stringify(nextOptions)) {
+        throw new Error(`Conflicting rule options for ${ruleName} at severity ${currentEntry[0]}`);
+      }
+    }
+  }
+  return new Map([...aggregated.entries()].sort(([a], [b]) => a.localeCompare(b)));
+}
+function buildSnapshot(groupId, workspaces, rules) {
+  const sortedRules = [...rules.entries()].sort(([a], [b]) => a.localeCompare(b));
+  const rulesObject = {};
+  for (const [name, config] of sortedRules) {
+    rulesObject[name] = canonicalizeJson(config);
+  }
+  return {
+    formatVersion: 1,
+    groupId,
+    workspaces: sortUnique(workspaces),
+    rules: rulesObject
+  };
+}
+async function writeSnapshotFile(snapshotDirAbs, snapshot) {
+  await (0, import_promises.mkdir)(snapshotDirAbs, { recursive: true });
+  const filePath = import_node_path3.default.join(snapshotDirAbs, `${snapshot.groupId}.json`);
+  await (0, import_promises.mkdir)(import_node_path3.default.dirname(filePath), { recursive: true });
+  const payload = JSON.stringify(snapshot, null, 2);
+  await (0, import_promises.writeFile)(filePath, `${payload}
+`, "utf8");
+  return filePath;
+}
+async function readSnapshotFile(fileAbs) {
+  const raw = await (0, import_promises.readFile)(fileAbs, "utf8");
+  return JSON.parse(raw);
+}
+
+// src/diff.ts
+function diffSnapshots(before, after) {
+  const beforeRules = before.rules;
+  const afterRules = after.rules;
+  const beforeNames = Object.keys(beforeRules).sort();
+  const afterNames = Object.keys(afterRules).sort();
+  const introducedRules = afterNames.filter((name) => !beforeNames.includes(name));
+  const removedRules = beforeNames.filter((name) => !afterNames.includes(name));
+  const severityChanges = [];
+  const optionChanges = [];
+  for (const name of beforeNames.filter((entry) => afterNames.includes(entry))) {
+    const oldEntry = beforeRules[name];
+    const newEntry = afterRules[name];
+    if (oldEntry[0] !== newEntry[0]) {
+      severityChanges.push({
+        rule: name,
+        before: oldEntry[0],
+        after: newEntry[0]
+      });
+    }
+    const oldOptions = oldEntry.length > 1 ? canonicalizeJson(oldEntry[1]) : void 0;
+    const newOptions = newEntry.length > 1 ? canonicalizeJson(newEntry[1]) : void 0;
+    if (oldEntry[0] === "off" || newEntry[0] === "off") {
+      if (oldEntry[0] === "off" && newEntry[0] === "off") {
+        if (oldOptions !== void 0 && newOptions === void 0) {
+          removedRules.push(name);
+        } else if (oldOptions === void 0 && newOptions !== void 0) {
+          introducedRules.push(name);
+        }
+      }
+      continue;
+    }
+    if (JSON.stringify(oldOptions) !== JSON.stringify(newOptions)) {
+      optionChanges.push({
+        rule: name,
+        before: oldOptions,
+        after: newOptions
+      });
+    }
+  }
+  const beforeWorkspaces = sortUnique(before.workspaces);
+  const afterWorkspaces = sortUnique(after.workspaces);
+  return {
+    introducedRules: sortUnique(introducedRules),
+    removedRules: sortUnique(removedRules),
+    severityChanges,
+    optionChanges,
+    workspaceMembershipChanges: {
+      added: afterWorkspaces.filter((ws) => !beforeWorkspaces.includes(ws)),
+      removed: beforeWorkspaces.filter((ws) => !afterWorkspaces.includes(ws))
+    }
+  };
+}
+function hasDiff(diff) {
+  return diff.introducedRules.length > 0 || diff.removedRules.length > 0 || diff.severityChanges.length > 0 || diff.optionChanges.length > 0 || diff.workspaceMembershipChanges.added.length > 0 || diff.workspaceMembershipChanges.removed.length > 0;
+}
+
+// src/config.ts
+var import_cosmiconfig = require("cosmiconfig");
+var import_node_path4 = __toESM(require("path"), 1);
+var DEFAULT_CONFIG = {
+  workspaceInput: { mode: "discover" },
+  grouping: {
+    mode: "match",
+    groups: [{ name: "default", match: ["**/*"] }]
+  },
+  sampling: {
+    maxFilesPerWorkspace: 8,
+    includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
+    excludeGlobs: ["**/node_modules/**", "**/dist/**"],
+    hintGlobs: []
+  }
+};
+var SPEC_SEARCH_PLACES = [
+  ".eslint-config-snapshot.js",
+  ".eslint-config-snapshot.cjs",
+  ".eslint-config-snapshot.mjs",
+  "eslint-config-snapshot.config.js",
+  "eslint-config-snapshot.config.cjs",
+  "eslint-config-snapshot.config.mjs",
+  "package.json",
+  ".eslint-config-snapshotrc",
+  ".eslint-config-snapshotrc.json",
+  ".eslint-config-snapshotrc.yaml",
+  ".eslint-config-snapshotrc.yml",
+  ".eslint-config-snapshotrc.js",
+  ".eslint-config-snapshotrc.cjs",
+  ".eslint-config-snapshotrc.mjs"
+];
+async function loadConfig(cwd) {
+  const found = await findConfigPath(cwd);
+  if (!found) {
+    return DEFAULT_CONFIG;
+  }
+  return found.config;
+}
+async function findConfigPath(cwd) {
+  const root = import_node_path4.default.resolve(cwd ?? process.cwd());
+  const explorer = (0, import_cosmiconfig.cosmiconfig)("eslint-config-snapshot", {
+    searchPlaces: SPEC_SEARCH_PLACES,
+    stopDir: root
+  });
+  const result = await explorer.search(root);
+  if (!result) {
+    return null;
+  }
+  const maybeConfig = await loadUserConfig(result.config);
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...maybeConfig,
+    grouping: {
+      ...DEFAULT_CONFIG.grouping,
+      ...maybeConfig.grouping
+    },
+    sampling: {
+      ...DEFAULT_CONFIG.sampling,
+      ...maybeConfig.sampling
+    }
+  };
+  return {
+    path: result.filepath,
+    config
+  };
+}
+async function loadUserConfig(rawConfig) {
+  const resolved = typeof rawConfig === "function" ? await rawConfig() : rawConfig;
+  if (resolved === null || resolved === void 0) {
+    return {};
+  }
+  if (typeof resolved !== "object" || Array.isArray(resolved)) {
+    throw new TypeError("Invalid config export: expected object, function, or async function returning an object");
+  }
+  return resolved;
+}
+function getConfigScaffold(preset = "minimal") {
+  if (preset === "minimal") {
+    return "export default {}\n";
+  }
+  return `export default {
+  workspaceInput: { mode: 'discover' },
+  grouping: {
+    mode: 'match',
+    groups: [{ name: 'default', match: ['**/*'] }]
+  },
+  sampling: {
+    maxFilesPerWorkspace: 8,
+    includeGlobs: ['**/*.{js,jsx,ts,tsx,cjs,mjs}'],
+    excludeGlobs: ['**/node_modules/**', '**/dist/**'],
+    hintGlobs: []
+  }
+}
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CONFIG,
+  aggregateRules,
+  assignGroupsByMatch,
+  buildSnapshot,
+  canonicalizeJson,
+  compareSeverity,
+  diffSnapshots,
+  discoverWorkspaces,
+  extractRulesFromPrintConfig,
+  findConfigPath,
+  getConfigScaffold,
+  hasDiff,
+  loadConfig,
+  normalizePath,
+  normalizeSeverity,
+  readSnapshotFile,
+  resolveEslintBinForWorkspace,
+  sampleWorkspaceFiles,
+  sortUnique,
+  writeSnapshotFile
+});