@santi020k/eslint-config-basic 3.1.0 → 3.2.0

package/dist/cli-migration.js

@@ -175,6 +175,13 @@ const FACTORY_ALIAS_REPLACEMENTS = /* @__PURE__ */ new Set([
   "astroConfig",
   "gitignore"
 ]);
+const PARAMETER_PROPERTY_MODIFIERS = /* @__PURE__ */ new Set([
+  "override",
+  "private",
+  "protected",
+  "public",
+  "readonly"
+]);
 const dependencyFields = [
   "dependencies",
   "devDependencies",
@@ -323,16 +330,121 @@ const getEnclosingDelimiter = (content, offset) => {
   }
   return null;
 };
+const findClosingDelimiter = (content, start, opener, closer) => {
+  let depth = 0;
+  for (let index = start; index < content.length; index++) {
+    if (content[index] === opener) depth++;
+    else if (content[index] === closer && --depth === 0) return index + 1;
+  }
+  return content.length;
+};
+const getShadowedRanges = (content, name) => {
+  const masked = maskNonCode(content);
+  const importRanges = getImportRanges(content);
+  let searchable = masked;
+  for (const range of importRanges.toReversed()) {
+    searchable = `${searchable.slice(0, range.start)}${" ".repeat(range.end - range.start)}${searchable.slice(range.end)}`;
+  }
+  const getArrowRange = (start, arrowIndex) => {
+    const relativeBodyStart = searchable.slice(arrowIndex + 2).search(/\S/);
+    const bodyStart = relativeBodyStart === -1 ? searchable.length : arrowIndex + 2 + relativeBodyStart;
+    const bodyDelimiter = searchable[bodyStart];
+    let bodyCloser;
+    if (bodyDelimiter === "(") bodyCloser = ")";
+    else if (bodyDelimiter === "[") bodyCloser = "]";
+    if (bodyDelimiter === "{") {
+      return { end: findClosingDelimiter(searchable, bodyStart, "{", "}"), start };
+    }
+    if (bodyCloser) {
+      return { end: findClosingDelimiter(searchable, bodyStart, bodyDelimiter, bodyCloser), start };
+    }
+    const lineEnd = searchable.indexOf("\n", arrowIndex + 2);
+    return { end: lineEnd === -1 ? searchable.length : lineEnd, start };
+  };
+  const unparenthesizedArrowPattern = new RegExp(`\\b${name}\\b\\s*=>`, "gm");
+  const ranges = [...searchable.matchAll(unparenthesizedArrowPattern)].map((match) => getArrowRange(match.index, searchable.indexOf("=>", match.index)));
+  const splitAtTopLevel = (value, separator) => {
+    const parts = [];
+    const closers = { "(": ")", "[": "]", "{": "}" };
+    const expectedClosers = [];
+    let partStart = 0;
+    for (let index = 0; index < value.length; index++) {
+      const character = value[index];
+      const closer = closers[character];
+      if (closer) expectedClosers.push(closer);
+      else if (character === expectedClosers.at(-1)) expectedClosers.pop();
+      else if (character === separator && expectedClosers.length === 0) {
+        parts.push(value.slice(partStart, index));
+        partStart = index + 1;
+      }
+    }
+    parts.push(value.slice(partStart));
+    return parts;
+  };
+  const hasBindingName = (value) => {
+    let binding = splitAtTopLevel(value, "=")[0].trim();
+    if (binding.startsWith("...")) binding = binding.slice(3).trim();
+    binding = splitAtTopLevel(binding, ":")[0].trim();
+    const bindingParts = binding.split(/\s+/);
+    while (PARAMETER_PROPERTY_MODIFIERS.has(bindingParts[0])) bindingParts.shift();
+    binding = bindingParts.join(" ");
+    if (binding.startsWith("{") && binding.endsWith("}")) {
+      return splitAtTopLevel(binding.slice(1, -1), ",").some((property) => {
+        const propertyParts = splitAtTopLevel(property, ":");
+        return hasBindingName(propertyParts.length > 1 ? propertyParts.slice(1).join(":") : property);
+      });
+    }
+    if (binding.startsWith("[") && binding.endsWith("]")) {
+      return splitAtTopLevel(binding.slice(1, -1), ",").some(hasBindingName);
+    }
+    return binding.replace(/\?$/, "") === name;
+  };
+  const hasParameterBinding = (parameters) => splitAtTopLevel(parameters, ",").some(hasBindingName);
+  const parameterOwnerPattern = /(?:\bfunction\b[^()]*|\bcatch|\b(?:constructor|[a-zA-Z_$][\w$]*))\s*$/;
+  for (let parameterStart = 0; parameterStart < searchable.length; parameterStart++) {
+    if (searchable[parameterStart] !== "(") continue;
+    const parameterEnd = findClosingDelimiter(searchable, parameterStart, "(", ")");
+    if (searchable[parameterEnd - 1] !== ")") continue;
+    const parameters = searchable.slice(parameterStart + 1, parameterEnd - 1);
+    if (!hasParameterBinding(parameters)) continue;
+    const relativeBodyStart = searchable.slice(parameterEnd).search(/\S/);
+    const bodyStart = relativeBodyStart === -1 ? searchable.length : parameterEnd + relativeBodyStart;
+    if (searchable.startsWith("=>", bodyStart)) {
+      ranges.push(getArrowRange(parameterStart, bodyStart));
+      continue;
+    }
+    if (searchable[bodyStart] !== "{") continue;
+    const ownerMatch = parameterOwnerPattern.exec(searchable.slice(0, parameterStart));
+    if (!ownerMatch) continue;
+    ranges.push({
+      end: findClosingDelimiter(searchable, bodyStart, "{", "}"),
+      start: ownerMatch.index
+    });
+  }
+  const blockBindingPattern = new RegExp(`\\b(?:const|let|var|function|class)\\s+${name}\\b`, "g");
+  for (const match of searchable.matchAll(blockBindingPattern)) {
+    const blockStart = searchable.lastIndexOf("{", match.index);
+    if (blockStart !== -1) {
+      ranges.push({
+        end: findClosingDelimiter(searchable, blockStart, "{", "}"),
+        start: blockStart
+      });
+    }
+  }
+  return ranges;
+};
 const replaceBindingReferences = (content, from, to, invokeReferences = false) => {
   const importRanges = getImportRanges(content);
   const masked = maskNonCode(content);
   const identifierPattern = new RegExp(`\\b${from}\\b`, "g");
   const matches = [...masked.matchAll(identifierPattern)];
+  const shadowedRanges = getShadowedRanges(content, from);
   let updated = content;
   for (const match of matches.reverse()) {
     const offset = match.index;
     const isImportSpecifier = importRanges.some((range) => offset >= range.start && offset < range.end);
-    if (isImportSpecifier) continue;
+    const isShadowed = shadowedRanges.some((range) => offset >= range.start && offset < range.end);
+    if (isImportSpecifier || isShadowed) continue;
     const precedingContent = masked.slice(0, offset).trimEnd();
     const preceding = precedingContent.at(-1);
     const following = masked.slice(offset + from.length);
@@ -420,17 +532,235 @@ const hasCodePropertySeparator = (codeContent, match) => {
   const matchIndex = match.index ?? -1;
   return matchIndex >= 0 && separatorOffset >= 0 && codeContent[matchIndex + separatorOffset] === ":";
 };
+const replaceCodeProperty = (content, property, replacement, matches) => {
+  const masked = maskNonCode(content, true);
+  const pattern = new RegExp(`\\b${property}\\b(?=\\s*:)`, "g");
+  const propertyMatches = matches ?? [...masked.matchAll(pattern)];
+  let updated = content;
+  for (const match of propertyMatches.toReversed()) {
+    const { index } = match;
+    if (index === void 0) continue;
+    updated = `${updated.slice(0, index)}${replacement}${updated.slice(index + property.length)}`;
+  }
+  return updated;
+};
+const toFeatureName = (value) => {
+  const trimmed = value.trim();
+  const enumMatch = /^(?:Extension|Format|Library|Testing|Tool)\.([a-zA-Z0-9_$]+)$/.exec(trimmed);
+  const stringMatch = /^(['"])([^'"]+)\1$/.exec(trimmed);
+  const raw = enumMatch?.[1] ?? stringMatch?.[2];
+  return raw ? toKebabCase(raw) : null;
+};
+const getOwningObjectStart = (structure, position) => {
+  const objectStarts = [];
+  for (let index = 0; index < position; index++) {
+    if (structure[index] === "{") objectStarts.push(index);
+    if (structure[index] === "}") objectStarts.pop();
+  }
+  return objectStarts.at(-1);
+};
+const getDefineConfigOptionOwners = (searchable) => {
+  const owners = new Set(
+    [...searchable.matchAll(/\bdefineConfig\s*\(\s*\{/g)].map((match) => match.index + match[0].lastIndexOf("{"))
+  );
+  const optionNames = new Set(
+    [...searchable.matchAll(/\bdefineConfig\s*\(\s*([a-zA-Z_$][\w$]*)\b/g)].map((match) => match[1])
+  );
+  for (const optionName of optionNames) {
+    const bindingPattern = new RegExp(`\\b(?:const|let|var)\\s+${optionName}\\s*=\\s*\\{`, "g");
+    for (const match of searchable.matchAll(bindingPattern)) {
+      owners.add(match.index + match[0].lastIndexOf("{"));
+    }
+  }
+  return owners;
+};
+const getDirectChildObjectStarts = (structure, containerStart) => {
+  const children = [];
+  const objectStarts = [containerStart];
+  for (let index = containerStart + 1; index < structure.length && objectStarts.length > 0; index++) {
+    if (structure[index] === "{") {
+      if (objectStarts.at(-1) === containerStart) children.push(index);
+      objectStarts.push(index);
+    } else if (structure[index] === "}") {
+      objectStarts.pop();
+    }
+  }
+  return children;
+};
+const getOwnedObjectPropertyStarts = (searchable, structure, property, owners) => {
+  const pattern = new RegExp(`\\b${property}\\b\\s*:\\s*\\{`, "g");
+  return [...searchable.matchAll(pattern)].flatMap((match) => {
+    const owner = getOwningObjectStart(structure, match.index);
+    const objectStart = match.index + match[0].lastIndexOf("{");
+    return owner !== void 0 && owners.has(owner) && hasCodePropertySeparator(structure, match) && structure[objectStart] === "{" ? [objectStart] : [];
+  });
+};
+const getBasicOptionOwners = (searchable, structure) => {
+  const owners = getDefineConfigOptionOwners(searchable);
+  for (const projectDefaultsOwner of getOwnedObjectPropertyStarts(
+    searchable,
+    structure,
+    "projectDefaults",
+    owners
+  )) {
+    owners.add(projectDefaultsOwner);
+  }
+  const visitedProjectContainers = /* @__PURE__ */ new Set();
+  let projectContainers = getOwnedObjectPropertyStarts(searchable, structure, "projects", owners);
+  while (projectContainers.length > 0) {
+    for (const container of projectContainers) {
+      visitedProjectContainers.add(container);
+      for (const projectOwner of getDirectChildObjectStarts(structure, container)) {
+        owners.add(projectOwner);
+      }
+    }
+    projectContainers = getOwnedObjectPropertyStarts(searchable, structure, "projects", owners).filter((container) => !visitedProjectContainers.has(container));
+  }
+  return owners;
+};
+const getOwnedPropertyMatches = (searchable, structure, property, owners) => {
+  const pattern = new RegExp(`\\b${property}\\b\\s*:`, "g");
+  return [...searchable.matchAll(pattern)].flatMap((match) => {
+    const owner = getOwningObjectStart(structure, match.index);
+    return owner !== void 0 && owners.has(owner) && hasCodePropertySeparator(structure, match) ? [match] : [];
+  });
+};
+const modernizeLiteralFeatureArrays = (content) => {
+  const searchable = maskNonCode(content, true);
+  const structure = maskNonCode(content);
+  const optionOwners = getBasicOptionOwners(searchable, structure);
+  const selections = [...searchable.matchAll(
+    /\b(?:extensions|formats|libraries|testing|tools)\b\s*:\s*\[([\s\S]*?)\]\s*,?/g
+  )].flatMap((match) => {
+    if (/\/[/*]/.test(content.slice(match.index, match.index + match[0].length))) return [];
+    const features2 = match[1].split(",").filter(Boolean).map(toFeatureName);
+    const owner = getOwningObjectStart(structure, match.index);
+    if (owner === void 0 || !optionOwners.has(owner) || !hasCodePropertySeparator(structure, match) || features2.length === 0 || features2.some((feature) => feature === null)) return [];
+    return [{
+      end: match.index + match[0].length,
+      features: features2,
+      owner,
+      start: match.index
+    }];
+  });
+  if (selections.length === 0) return { changed: false, content, features: [] };
+  const features = [...new Set(selections.flatMap((selection) => selection.features))];
+  const selectionsByOwner = /* @__PURE__ */ new Map();
+  for (const selection of selections) {
+    const ownedSelections = selectionsByOwner.get(selection.owner);
+    if (ownedSelections) ownedSelections.push(selection);
+    else selectionsByOwner.set(selection.owner, [selection]);
+  }
+  const existingFeaturesByOwner = /* @__PURE__ */ new Map();
+  for (const match of searchable.matchAll(/\bfeatures\b\s*:\s*\{/g)) {
+    const owner = getOwningObjectStart(structure, match.index);
+    if (owner !== void 0 && !existingFeaturesByOwner.has(owner)) {
+      existingFeaturesByOwner.set(owner, match);
+    }
+  }
+  const edits = [];
+  for (const [owner, ownedSelections] of selectionsByOwner) {
+    const ownedFeatures = [...new Set(ownedSelections.flatMap((selection) => selection.features))];
+    const first = ownedSelections[0];
+    const lineStart = content.lastIndexOf("\n", first.start) + 1;
+    const indent = /^\s*/.exec(content.slice(lineStart, first.start))?.[0] ?? "";
+    const existingFeatures = existingFeaturesByOwner.get(owner);
+    const featureBlock = existingFeatures ? `
+${ownedFeatures.map((feature) => `${indent}  ${JSON.stringify(feature)}: true,`).join("\n")}` : [
+      "features: {",
+      ...ownedFeatures.map((feature) => `${indent}  ${JSON.stringify(feature)}: true,`),
+      `${indent}},`
+    ].join("\n");
+    for (const selection of ownedSelections) {
+      edits.push({
+        end: selection.end,
+        replacement: !existingFeatures && selection === first ? featureBlock : "",
+        start: selection.start
+      });
+    }
+    if (existingFeatures) {
+      const insertionIndex = (existingFeatures.index ?? 0) + existingFeatures[0].length;
+      edits.push({
+        end: insertionIndex,
+        replacement: featureBlock,
+        start: insertionIndex
+      });
+    }
+  }
+  let updated = content;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    updated = `${updated.slice(0, edit.start)}${edit.replacement}${updated.slice(edit.end)}`;
+  }
+  return { changed: updated !== content, content: updated, features };
+};
+const modernizeConfigOptions = (content) => {
+  const changes = [];
+  let updated = content;
+  const searchable = maskNonCode(updated, true);
+  const structure = maskNonCode(updated);
+  const basicOptionOwners = getBasicOptionOwners(searchable, structure);
+  const featureOwners = new Set(
+    getOwnedPropertyMatches(searchable, structure, "features", basicOptionOwners).flatMap((match) => {
+      if (match.index === void 0) return [];
+      const owner = getOwningObjectStart(structure, match.index);
+      return owner === void 0 ? [] : [owner];
+    })
+  );
+  const integrationMatches = getOwnedPropertyMatches(searchable, structure, "integrations", basicOptionOwners).filter((match) => {
+    if (match.index === void 0) return false;
+    const owner = getOwningObjectStart(structure, match.index);
+    return owner !== void 0 && !featureOwners.has(owner);
+  });
+  if (integrationMatches.length > 0) {
+    updated = replaceCodeProperty(updated, "integrations", "features", integrationMatches);
+    changes.push("Replaced the deprecated integrations map with features.");
+  }
+  const updatedSearchable = maskNonCode(updated, true);
+  const updatedStructure = maskNonCode(updated);
+  const optionOwners = getDefineConfigOptionOwners(updatedSearchable);
+  const rootMatches = getOwnedPropertyMatches(updatedSearchable, updatedStructure, "root", optionOwners);
+  const rootAliasMatches = /* @__PURE__ */ new Map([
+    ["detectRootDir", getOwnedPropertyMatches(updatedSearchable, updatedStructure, "detectRootDir", optionOwners)],
+    ["tsconfigRootDir", getOwnedPropertyMatches(updatedSearchable, updatedStructure, "tsconfigRootDir", optionOwners)]
+  ]);
+  const rootAliases = [...rootAliasMatches].filter(([, matches]) => matches.length > 0).map(([alias]) => alias);
+  if (rootMatches.length === 0 && rootAliases.length === 1) {
+    const alias = rootAliases[0];
+    updated = replaceCodeProperty(updated, alias, "root", rootAliasMatches.get(alias));
+    changes.push(`Replaced ${alias} with the v3 root option.`);
+  } else if (rootAliases.length > 0) {
+    changes.push(
+      `Manual action required: consolidate ${rootAliases.join(" and ")} into root after confirming they resolve to the same directory.`
+    );
+  }
+  const featureMigration = modernizeLiteralFeatureArrays(updated);
+  if (featureMigration.changed) {
+    updated = featureMigration.content;
+    changes.push(`Replaced literal category arrays with the v3 features map (${featureMigration.features.join(", ")}).`);
+  }
+  if (maskNonCode(updated, true).includes("better-tailwindcss/no-unknown-classes")) {
+    changes.push(
+      'Manual action required: replace the raw better-tailwindcss/no-unknown-classes override with projects["<scope>"].tailwind.noUnknownClasses.'
+    );
+  }
+  return { changes, content: updated };
+};
 const getExplicitConfigFeaturePackages = (content) => {
   const packages = /* @__PURE__ */ new Set();
   const codeContent = maskNonCode(content);
   const searchableContent = maskNonCode(content, true);
+  const optionOwners = getBasicOptionOwners(searchableContent, codeContent);
+  const isBasicOption = (match) => {
+    const owner = getOwningObjectStart(codeContent, match.index ?? -1);
+    return owner !== void 0 && optionOwners.has(owner) && hasCodePropertySeparator(codeContent, match);
+  };
   for (const category of Object.keys(FEATURE_PACKAGES)) {
     const categorySelections = searchableContent.matchAll(
       // eslint-disable-next-line security/detect-non-literal-regexp -- category names come from the internal package registry
       new RegExp(`(?:\\b${category}\\b|['"]${category}['"])\\s*:\\s*\\[([\\s\\S]*?)\\]`, "g")
     );
     for (const selection of categorySelections) {
-      if (hasCodePropertySeparator(codeContent, selection) && selection[1].trim()) {
+      if (isBasicOption(selection) && selection[1].trim()) {
         packages.add(FEATURE_PACKAGES[category]);
         break;
       }
@@ -438,7 +768,7 @@ const getExplicitConfigFeaturePackages = (content) => {
   }
   const featureSelections = /(?:\b(?:features|integrations)\b|['"](?:features|integrations)['"])\s*:\s*\{([\s\S]*?)\}/g;
   for (const selection of searchableContent.matchAll(featureSelections)) {
-    if (!hasCodePropertySeparator(codeContent, selection)) continue;
+    if (!isBasicOption(selection)) continue;
     const enabledFeaturePattern = /(?:['"]([^'"]+)['"]|([a-zA-Z_$][\w$-]*))\s*:\s*true\b/g;
     for (const match of selection[1].matchAll(enabledFeaturePattern)) {
       const featureName = (match[1] || match[2]).toLowerCase();
@@ -448,7 +778,7 @@ const getExplicitConfigFeaturePackages = (content) => {
   }
   const enumPresetPattern = /(?:\bpreset\b|['"]preset['"])\s*:\s*Preset\.(All|App|CI|Library|Monorepo)/g;
   for (const match of searchableContent.matchAll(enumPresetPattern)) {
-    if (!hasCodePropertySeparator(codeContent, match)) continue;
+    if (!isBasicOption(match)) continue;
     const presetName = match[1].toLowerCase();
     for (const packageName of PRESET_FEATURE_PACKAGES[presetName] ?? []) {
       packages.add(packageName);
@@ -456,31 +786,40 @@ const getExplicitConfigFeaturePackages = (content) => {
   }
   const stringPresetPattern = /(?:\bpreset\b|['"]preset['"])\s*:\s*(['"`])(all|app|ci|library|monorepo)\1/g;
   for (const match of searchableContent.matchAll(stringPresetPattern)) {
-    if (!hasCodePropertySeparator(codeContent, match)) continue;
+    if (!isBasicOption(match)) continue;
     for (const packageName of PRESET_FEATURE_PACKAGES[match[2]] ?? []) {
       packages.add(packageName);
     }
   }
   const strictPattern = /(?:\bstrict\b|['"]strict['"])\s*:\s*(['"`])pedantic\1/g;
   for (const match of searchableContent.matchAll(strictPattern)) {
-    if (hasCodePropertySeparator(codeContent, match)) {
+    if (isBasicOption(match)) {
       packages.add(FEATURE_PACKAGES.extensions);
       break;
     }
   }
   return [...packages];
 };
+const replacePackageSpecifiers = (content, from, to) => content.replace(
+  // eslint-disable-next-line security/detect-unsafe-regex -- bounded module specifiers cannot cross quote characters
+  /(\b(?:from|import|export)\s*(?:\(\s*)?|\brequire\s*\(\s*)(['"])([^'"]+)\2/g,
+  (statement, prefix, quote, specifier) => specifier === from ? `${prefix}${quote}${to}${quote}` : statement
+);
 const migrateConfigToV3 = (content, mode) => {
   const changes = [];
   const featurePackages = new Set(getExplicitConfigFeaturePackages(content));
   let migrated = content;
-  if (migrated.includes(LITE_PACKAGE)) {
-    migrated = migrated.replaceAll(LITE_PACKAGE, BASIC_PACKAGE);
+  const liteMigrated = replacePackageSpecifiers(migrated, LITE_PACKAGE, BASIC_PACKAGE);
+  if (liteMigrated !== migrated) {
+    migrated = liteMigrated;
     changes.push("Replaced the Lite compatibility import with Basic.");
   }
-  if (mode === "full" && migrated.includes(BASIC_PACKAGE)) {
-    migrated = migrated.replaceAll(BASIC_PACKAGE, FULL_PACKAGE);
-    changes.push("Switched the root config import to the full bundle.");
+  if (mode === "full") {
+    const fullMigrated = replacePackageSpecifiers(migrated, BASIC_PACKAGE, FULL_PACKAGE);
+    if (fullMigrated !== migrated) {
+      migrated = fullMigrated;
+      changes.push("Switched the root config import to the full bundle.");
+    }
   }
   if (mode === "lean") {
     const split = splitBasicIntegrationImports(migrated);
@@ -506,13 +845,21 @@ const migrateConfigToV3 = (content, mode) => {
     migrated = remixMigrated;
     changes.push('Moved frameworks.remix to frameworks["react-router"].');
   }
-  if (migrated.includes(REMIX_PACKAGE)) {
-    migrated = migrated.replaceAll(REMIX_PACKAGE, FRAMEWORK_PACKAGES["react-router"]);
+  const reactRouterMigrated = replacePackageSpecifiers(
+    migrated,
+    REMIX_PACKAGE,
+    FRAMEWORK_PACKAGES["react-router"]
+  );
+  if (reactRouterMigrated !== migrated) {
+    migrated = reactRouterMigrated;
     changes.push("Replaced the Remix package import with React Router.");
   }
   if (/\bloadModule\b/.test(migrated)) {
     changes.push("Manual action required: replace loadModule usage with createModuleLoader(resolver).");
   }
+  const modernized = modernizeConfigOptions(migrated);
+  migrated = modernized.content;
+  changes.push(...modernized.changes);
   return {
     changes,
     content: migrated,
@@ -525,13 +872,18 @@ const shouldUseFullBundle = (configContent, packageJson, forceFull) => {
   if (configContent) {
     const codeContent = maskNonCode(configContent);
     const searchableContent = maskNonCode(configContent, true);
+    const optionOwners = getDefineConfigOptionOwners(searchableContent);
+    const isRootOption = (match) => {
+      const owner = getOwningObjectStart(codeContent, match.index ?? -1);
+      return owner !== void 0 && optionOwners.has(owner) && hasCodePropertySeparator(codeContent, match);
+    };
     const enumPresetPattern = /(?:\bpreset\b|['"]preset['"])\s*:\s*Preset\.All/g;
     for (const match of searchableContent.matchAll(enumPresetPattern)) {
-      if (hasCodePropertySeparator(codeContent, match)) return true;
+      if (isRootOption(match)) return true;
     }
     const stringPresetPattern = /(?:\bpreset\b|['"]preset['"])\s*:\s*(['"`])all\1/g;
     for (const match of searchableContent.matchAll(stringPresetPattern)) {
-      if (hasCodePropertySeparator(codeContent, match)) return true;
+      if (isRootOption(match)) return true;
     }
   }
   return getDeclaredConfigPackages(packageJson).has(FULL_PACKAGE);

package/dist/cli-preset.d.ts

@@ -0,0 +1,31 @@
+import { EslintConfigOptions } from '@santi020k/eslint-config-core';
+
+interface ExplainPresetOptions {
+    compatibility?: boolean;
+    file?: string;
+    json?: boolean;
+    output?: string;
+}
+declare const createPresetReport: (cwd: string, presetName: string, file?: string) => Promise<{
+    added: Record<string, unknown>;
+    changed: Record<string, {
+        from: unknown;
+        to: unknown;
+    }>;
+    file: string;
+    groups: {
+        [k: string]: string[];
+    };
+    missingPackages: string[];
+    preset: string;
+    presetOptions: Partial<EslintConfigOptions>;
+    removed: Record<string, unknown>;
+    totals: {
+        added: number;
+        changed: number;
+        removed: number;
+    };
+}>;
+declare const handleExplainPreset: (cwd: string | undefined, preset: string, options?: ExplainPresetOptions) => Promise<void>;
+
+export { type ExplainPresetOptions, createPresetReport, handleExplainPreset };