@eslint-config-snapshot/api 1.2.0 → 1.3.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @eslint-config-snapshot/api
 
+## 1.3.1
+
+### Patch Changes
+
+- Improve catalog check/update summaries and dedupe baseline totals across groups.
+
+## 1.3.0
+
+### Minor Changes
+
+- Promote catalog baseline hooks and OSS compatibility hardening with improved docs.
+
 ## 1.2.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(index_exports, {
   canonicalizeJson: () => canonicalizeJson,
   compareSeverity: () => compareSeverity,
   diffSnapshots: () => diffSnapshots,
+  discoverWorkspaceRuleCatalog: () => discoverWorkspaceRuleCatalog,
   discoverWorkspaces: () => discoverWorkspaces,
   extractRulesForWorkspaceSamples: () => extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig: () => extractRulesFromPrintConfig,
@@ -330,6 +331,18 @@ function selectDistributed(files, count, tokenHints) {
   return sortUnique([...selected, ...preferredPicked, ...fallbackPicked]).slice(0, count);
 }
 function pickUniformly(files, count) {
+  const early = pickUniformlyEarlyReturn(files, count);
+  if (early) {
+    return early;
+  }
+  const picked = [];
+  const usedIndices = /* @__PURE__ */ new Set();
+  appendAnchors(files, count, picked, usedIndices);
+  appendDistributed(files, count, picked, usedIndices);
+  appendSequentialFallback(files, count, picked, usedIndices);
+  return picked;
+}
+function pickUniformlyEarlyReturn(files, count) {
   if (count <= 0 || files.length === 0) {
     return [];
   }
@@ -337,26 +350,30 @@ function pickUniformly(files, count) {
     return files;
   }
   if (count === 1) {
-    return [files[0]];
+    return [files[0]].filter((entry) => entry !== void 0);
   }
-  const picked = [];
-  const usedIndices = /* @__PURE__ */ new Set();
-  if (count >= 3) {
-    const anchorIndices = [0, Math.floor((files.length - 1) / 2), files.length - 1];
-    for (const anchorIndex of anchorIndices) {
-      if (picked.length >= count || usedIndices.has(anchorIndex)) {
-        continue;
-      }
-      usedIndices.add(anchorIndex);
-      const anchored = files[anchorIndex];
-      if (anchored !== void 0) {
-        picked.push(anchored);
-      }
+  return void 0;
+}
+function appendAnchors(files, count, picked, usedIndices) {
+  if (count < 3) {
+    return;
+  }
+  const anchorIndices = [0, Math.floor((files.length - 1) / 2), files.length - 1];
+  for (const anchorIndex of anchorIndices) {
+    if (picked.length >= count || usedIndices.has(anchorIndex)) {
+      continue;
+    }
+    usedIndices.add(anchorIndex);
+    const anchored = files[anchorIndex];
+    if (anchored !== void 0) {
+      picked.push(anchored);
     }
   }
+}
+function appendDistributed(files, count, picked, usedIndices) {
   for (const candidate of buildDistributedCandidates(files.length, count)) {
     if (picked.length >= count) {
-      break;
+      return;
     }
     const safeIndex = nextFreeIndex(candidate, usedIndices, files.length);
     if (usedIndices.has(safeIndex)) {
@@ -368,19 +385,21 @@ function pickUniformly(files, count) {
       picked.push(selected);
     }
   }
-  if (picked.length < count) {
-    for (let index = 0; index < files.length && picked.length < count; index += 1) {
-      if (usedIndices.has(index)) {
-        continue;
-      }
-      usedIndices.add(index);
-      const fallback = files[index];
-      if (fallback !== void 0) {
-        picked.push(fallback);
-      }
+}
+function appendSequentialFallback(files, count, picked, usedIndices) {
+  if (picked.length >= count) {
+    return;
+  }
+  for (let index = 0; index < files.length && picked.length < count; index += 1) {
+    if (usedIndices.has(index)) {
+      continue;
+    }
+    usedIndices.add(index);
+    const fallback = files[index];
+    if (fallback !== void 0) {
+      picked.push(fallback);
     }
   }
-  return picked;
 }
 function buildDistributedCandidates(length, count) {
   if (length <= 0 || count <= 0) {
@@ -906,35 +925,11 @@ function diffSnapshots(before, after) {
     if (oldSerialized === newSerialized) {
       continue;
     }
-    const oldIsOnlyOff = oldVariants.every((entry) => entry[0] === "off");
-    const newIsOnlyOff = newVariants.every((entry) => entry[0] === "off");
-    if (oldIsOnlyOff || newIsOnlyOff) {
-      if (oldIsOnlyOff && newIsOnlyOff) {
-        const oldHasOptions = oldVariants.some((variant) => variant.length > 1);
-        const newHasOptions = newVariants.some((variant) => variant.length > 1);
-        if (oldHasOptions && !newHasOptions) {
-          removedRules.push(name);
-        } else if (!oldHasOptions && newHasOptions) {
-          introducedRules.push(name);
-        } else if (oldVariants.length > newVariants.length) {
-          removedRules.push(name);
-        } else if (oldVariants.length < newVariants.length) {
-          introducedRules.push(name);
-        } else {
-          optionChanges.push({
-            rule: name,
-            before: oldVariants,
-            after: newVariants
-          });
-        }
-      }
+    if (hasOffOnlyVariants(oldVariants) || hasOffOnlyVariants(newVariants)) {
+      applyOffOnlyVariantDiff(name, oldVariants, newVariants, introducedRules, removedRules, optionChanges);
       continue;
     }
-    optionChanges.push({
-      rule: name,
-      before: oldVariants,
-      after: newVariants
-    });
+    pushOptionChange(optionChanges, name, oldVariants, newVariants);
   }
   const beforeWorkspaces = sortUnique(before.workspaces);
   const afterWorkspaces = sortUnique(after.workspaces);
@@ -949,6 +944,41 @@ function diffSnapshots(before, after) {
     }
   };
 }
+function hasOffOnlyVariants(variants) {
+  return variants.every((entry) => entry[0] === "off");
+}
+function applyOffOnlyVariantDiff(ruleName, oldVariants, newVariants, introducedRules, removedRules, optionChanges) {
+  const oldIsOnlyOff = hasOffOnlyVariants(oldVariants);
+  const newIsOnlyOff = hasOffOnlyVariants(newVariants);
+  if (!oldIsOnlyOff || !newIsOnlyOff) {
+    return;
+  }
+  const oldHasOptions = hasAnyVariantOptions(oldVariants);
+  const newHasOptions = hasAnyVariantOptions(newVariants);
+  if (oldHasOptions && !newHasOptions) {
+    removedRules.push(ruleName);
+    return;
+  }
+  if (!oldHasOptions && newHasOptions) {
+    introducedRules.push(ruleName);
+    return;
+  }
+  if (oldVariants.length > newVariants.length) {
+    removedRules.push(ruleName);
+    return;
+  }
+  if (oldVariants.length < newVariants.length) {
+    introducedRules.push(ruleName);
+    return;
+  }
+  pushOptionChange(optionChanges, ruleName, oldVariants, newVariants);
+}
+function hasAnyVariantOptions(variants) {
+  return variants.some((variant) => variant.length > 1);
+}
+function pushOptionChange(optionChanges, rule, before, after) {
+  optionChanges.push({ rule, before, after });
+}
 function toVariants(entry) {
   if (!Array.isArray(entry[0])) {
     return [canonicalizeJson(entry)];
@@ -968,6 +998,7 @@ function hasDiff(diff) {
 var import_cosmiconfig = require("cosmiconfig");
 var import_node_path4 = __toESM(require("path"), 1);
 var DEFAULT_CONFIG = {
+  experimentalWithCatalog: false,
   workspaceInput: { mode: "discover" },
   grouping: {
     mode: "match",
@@ -1045,6 +1076,7 @@ function getConfigScaffold(preset = "minimal") {
     return "export default {}\n";
   }
   return `export default {
+  experimentalWithCatalog: false,
   workspaceInput: { mode: 'discover' },
   grouping: {
     mode: 'match',
@@ -1084,6 +1116,202 @@ function getConfigScaffold(preset = "minimal") {
 }
 `;
 }
+
+// src/catalog.ts
+var import_promises3 = require("fs/promises");
+var import_node_module2 = require("module");
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+async function discoverWorkspaceRuleCatalog(workspaceAbs) {
+  const anchor = import_node_path5.default.join(workspaceAbs, "__snapshot_anchor__.cjs");
+  const req = (0, import_node_module2.createRequire)(anchor);
+  const coreRules = await discoverCoreRules(req);
+  const pluginPackageNames = await discoverPluginPackageNames(workspaceAbs);
+  const pluginRulesByPrefix = {};
+  for (const packageName of pluginPackageNames) {
+    const prefix = pluginPrefixFromPackageName(packageName);
+    if (!prefix) {
+      continue;
+    }
+    const ruleNames = await discoverPluginRuleNames(req, packageName);
+    if (ruleNames.length === 0) {
+      continue;
+    }
+    const current = pluginRulesByPrefix[prefix] ?? [];
+    current.push(...ruleNames.map((ruleName) => `${prefix}${ruleName}`));
+    pluginRulesByPrefix[prefix] = sortUnique2(current);
+  }
+  const allRules = sortUnique2([...coreRules, ...Object.values(pluginRulesByPrefix).flat()]);
+  return {
+    coreRules,
+    pluginRulesByPrefix: Object.fromEntries(
+      Object.entries(pluginRulesByPrefix).sort((a, b) => a[0].localeCompare(b[0]))
+    ),
+    allRules
+  };
+}
+async function discoverCoreRules(req) {
+  try {
+    const resolved = req.resolve("eslint/use-at-your-own-risk");
+    const moduleExports = await import((0, import_node_url2.pathToFileURL)(resolved).href);
+    const builtinRules = moduleExports.builtinRules ?? moduleExports.default?.builtinRules;
+    if (!builtinRules) {
+      return [];
+    }
+    return sortUnique2([...builtinRules.keys()]);
+  } catch {
+    return [];
+  }
+}
+async function discoverPluginRuleNames(req, packageName) {
+  try {
+    const resolved = req.resolve(packageName);
+    const moduleExports = await import((0, import_node_url2.pathToFileURL)(resolved).href);
+    const pluginRules = moduleExports.rules ?? moduleExports.default?.rules;
+    if (!pluginRules || typeof pluginRules !== "object") {
+      return [];
+    }
+    return sortUnique2(Object.keys(pluginRules));
+  } catch {
+    return [];
+  }
+}
+function pluginPrefixFromPackageName(packageName) {
+  if (packageName.startsWith("@")) {
+    const [scope, name] = packageName.split("/");
+    if (!scope || !name) {
+      return void 0;
+    }
+    if (name === "eslint-plugin") {
+      return `${scope}/`;
+    }
+    if (name.startsWith("eslint-plugin-")) {
+      return `${scope}/${name.slice("eslint-plugin-".length)}/`;
+    }
+    return void 0;
+  }
+  if (packageName === "eslint-plugin") {
+    return "";
+  }
+  if (packageName.startsWith("eslint-plugin-")) {
+    return `${packageName.slice("eslint-plugin-".length)}/`;
+  }
+  return void 0;
+}
+async function discoverPluginPackageNames(workspaceAbs) {
+  const results = /* @__PURE__ */ new Set();
+  const nodeModulesDirectories = collectNodeModulesDirectories(workspaceAbs);
+  for (const nodeModulesDirectory of nodeModulesDirectories) {
+    const packageNames = await readPluginPackagesFromNodeModules(nodeModulesDirectory);
+    for (const packageName of packageNames) {
+      results.add(packageName);
+    }
+  }
+  for (const packageJsonPath of collectPackageJsonPaths(workspaceAbs)) {
+    const dependencyNames = await readPluginPackageNamesFromPackageJson(packageJsonPath);
+    for (const packageName of dependencyNames) {
+      results.add(packageName);
+    }
+  }
+  return sortUnique2([...results]);
+}
+function collectNodeModulesDirectories(workspaceAbs) {
+  const directories = [];
+  let current = import_node_path5.default.resolve(workspaceAbs);
+  while (true) {
+    directories.push(import_node_path5.default.join(current, "node_modules"));
+    const parent = import_node_path5.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return directories;
+}
+function collectPackageJsonPaths(workspaceAbs) {
+  const paths = [];
+  let current = import_node_path5.default.resolve(workspaceAbs);
+  while (true) {
+    paths.push(import_node_path5.default.join(current, "package.json"));
+    const parent = import_node_path5.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return paths;
+}
+async function readPluginPackagesFromNodeModules(nodeModulesDirectory) {
+  try {
+    const entries = await (0, import_promises3.readdir)(nodeModulesDirectory, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (isRootPluginDirectory(entry.name)) {
+        results.push(entry.name);
+        continue;
+      }
+      if (!entry.name.startsWith("@")) {
+        continue;
+      }
+      const scopedPackages = await readScopedPluginPackages(nodeModulesDirectory, entry.name);
+      results.push(...scopedPackages);
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function isRootPluginDirectory(name) {
+  return name.startsWith("eslint-plugin-");
+}
+async function readScopedPluginPackages(nodeModulesDirectory, scopeName) {
+  const scopeDirectory = import_node_path5.default.join(nodeModulesDirectory, scopeName);
+  const scopedEntries = await (0, import_promises3.readdir)(scopeDirectory, { withFileTypes: true });
+  const packages = [];
+  for (const scopedEntry of scopedEntries) {
+    if (!scopedEntry.isDirectory()) {
+      continue;
+    }
+    if (isScopedPluginDirectory(scopedEntry.name)) {
+      packages.push(`${scopeName}/${scopedEntry.name}`);
+    }
+  }
+  return packages;
+}
+function isScopedPluginDirectory(name) {
+  return name === "eslint-plugin" || name.startsWith("eslint-plugin-");
+}
+async function readPluginPackageNamesFromPackageJson(packageJsonPath) {
+  try {
+    const raw = await (0, import_promises3.readFile)(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const allNames = /* @__PURE__ */ new Set();
+    for (const record of [
+      parsed.dependencies,
+      parsed.devDependencies,
+      parsed.peerDependencies,
+      parsed.optionalDependencies
+    ]) {
+      for (const name of Object.keys(record ?? {})) {
+        if (isEslintPluginPackageName(name)) {
+          allNames.add(name);
+        }
+      }
+    }
+    return [...allNames];
+  } catch {
+    return [];
+  }
+}
+function isEslintPluginPackageName(name) {
+  return name.startsWith("eslint-plugin-") || name === "eslint-plugin" || name.includes("/eslint-plugin-") || name.endsWith("/eslint-plugin");
+}
+function sortUnique2(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_CONFIG,
@@ -1093,6 +1321,7 @@ function getConfigScaffold(preset = "minimal") {
   canonicalizeJson,
   compareSeverity,
   diffSnapshots,
+  discoverWorkspaceRuleCatalog,
   discoverWorkspaces,
   extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig,