@eslint-config-snapshot/api 0.1.0

package/dist/index.js

@@ -0,0 +1,554 @@
+// 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
+import { getPackages } from "@manypkg/get-packages";
+import path from "path";
+import picomatch from "picomatch";
+async function discoverWorkspaces(options) {
+  const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd();
+  const workspaceInput = options?.workspaceInput ?? { mode: "discover" };
+  if (workspaceInput.mode === "manual") {
+    const rootAbs2 = path.resolve(workspaceInput.rootAbs ?? cwd);
+    return {
+      rootAbs: rootAbs2,
+      workspacesRel: sortUnique(workspaceInput.workspaces)
+    };
+  }
+  const { rootDir, packages } = await getPackages(cwd);
+  const workspacesAbs = packages.map((pkg) => pkg.dir);
+  const rootAbs = rootDir ? path.resolve(rootDir) : lowestCommonAncestor(workspacesAbs);
+  const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(path.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) => picomatch(pattern, { dot: true })(workspace));
+  if (!isPositiveMatch) {
+    return false;
+  }
+  const isNegativeMatch = negatives.some((pattern) => picomatch(pattern, { dot: true })(workspace));
+  return !isNegativeMatch;
+}
+function lowestCommonAncestor(paths) {
+  if (paths.length === 0) {
+    return process.cwd();
+  }
+  const segments = paths.map((entry) => path.resolve(entry).split(path.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 path.parse(path.resolve(paths[0])).root;
+  }
+  return common.join(path.sep);
+}
+
+// src/sampling.ts
+import fg from "fast-glob";
+import picomatch2 from "picomatch";
+async function sampleWorkspaceFiles(workspaceAbs, config) {
+  const all = await fg(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) => picomatch2(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
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+function resolveEslintBinForWorkspace(workspaceAbs) {
+  const anchor = path2.join(workspaceAbs, "__snapshot_anchor__.cjs");
+  const req = createRequire(anchor);
+  try {
+    return req.resolve("eslint/bin/eslint.js");
+  } catch {
+    try {
+      const eslintEntry = req.resolve("eslint");
+      const eslintRoot = findPackageRoot(eslintEntry);
+      const packageJsonPath = path2.join(eslintRoot, "package.json");
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const relativeBin = resolveBinPath(packageJson.bin);
+      const binAbs = path2.resolve(eslintRoot, relativeBin);
+      if (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 = path2.dirname(entryAbs);
+  while (true) {
+    const packageJsonPath = path2.join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      throw new Error("Package root not found");
+    }
+    current = parent;
+  }
+}
+function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
+  const eslintBin = resolveEslintBinForWorkspace(workspaceAbs);
+  const proc = 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
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path3 from "path";
+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 mkdir(snapshotDirAbs, { recursive: true });
+  const filePath = path3.join(snapshotDirAbs, `${snapshot.groupId}.json`);
+  await mkdir(path3.dirname(filePath), { recursive: true });
+  const payload = JSON.stringify(snapshot, null, 2);
+  await writeFile(filePath, `${payload}
+`, "utf8");
+  return filePath;
+}
+async function readSnapshotFile(fileAbs) {
+  const raw = await 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
+import { cosmiconfig } from "cosmiconfig";
+import path4 from "path";
+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 = path4.resolve(cwd ?? process.cwd());
+  const explorer = 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: []
+  }
+}
+`;
+}
+export {
+  DEFAULT_CONFIG,
+  aggregateRules,
+  assignGroupsByMatch,
+  buildSnapshot,
+  canonicalizeJson,
+  compareSeverity,
+  diffSnapshots,
+  discoverWorkspaces,
+  extractRulesFromPrintConfig,
+  findConfigPath,
+  getConfigScaffold,
+  hasDiff,
+  loadConfig,
+  normalizePath,
+  normalizeSeverity,
+  readSnapshotFile,
+  resolveEslintBinForWorkspace,
+  sampleWorkspaceFiles,
+  sortUnique,
+  writeSnapshotFile
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@eslint-config-snapshot/api",
+  "version": "0.1.0",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@manypkg/get-packages": "^3.1.0",
+    "cosmiconfig": "^9.0.0",
+    "fast-glob": "^3.3.3",
+    "picomatch": "^4.0.3"
+  }
+}

package/project.json

@@ -0,0 +1,35 @@
+{
+  "name": "api",
+  "sourceRoot": "packages/api/src",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "packages/api",
+        "command": "pnpm tsup src/index.ts --format esm,cjs --out-dir dist --clean"
+      }
+    },
+    "typecheck": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "packages/api",
+        "command": "pnpm tsc -p tsconfig.json --noEmit"
+      }
+    },
+    "lint": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "packages/api",
+        "command": "pnpm eslint ."
+      }
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "packages/api",
+        "command": "pnpm vitest run"
+      }
+    }
+  }
+}
+