@utoo/lint 0.2.9 → 0.3.5

package/bin/migrate.js

@@ -1,14 +1,19 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, extname, resolve as resolvePath } from "node:path";
+import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, relative, resolve as resolvePath } from "node:path";
 import { pathToFileURL } from "node:url";
 
+import { Legacy } from "@eslint/eslintrc";
+import eslintJs from "@eslint/js";
+
 import { Linter } from "../index.js";
 
 const ESLINT_CONFIG_FILENAMES = [
   "eslint.config.js",
   "eslint.config.mjs",
   "eslint.config.cjs",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
   ".eslintrc.json",
   ".eslintrc"
 ];
@@ -16,7 +21,11 @@ const JAVASCRIPT_CONFIG_EXTENSIONS = new Set([".js", ".mjs", ".cjs"]);
 const IGNORED_RULES = new Map([
   ["prettier/prettier", "formatting is outside utoo-lint"]
 ]);
-const RULE_ALIASES = new Map([
+// Add aliases only after reviewing the source rule against the target rule's
+// implemented behavior and supported options.
+const REVIEWED_RULE_ALIASES = new Map([
+  ["no-native-reassign", "no-global-assign"],
+  ["@typescript-eslint/no-invalid-this", "no-invalid-this"],
   ["@eslint-react/no-array-index-key", "react/no-array-index-key"],
   ["@eslint-react/dom-no-find-dom-node", "react/no-find-dom-node"],
   ["@eslint-react/dom-no-render-return-value", "react/no-render-return-value"],
@@ -24,6 +33,7 @@ const RULE_ALIASES = new Map([
   ["@eslint-react/rules-of-hooks", "react-hooks/rules-of-hooks"]
 ]);
 const SCHEMA_URL = "https://raw.githubusercontent.com/utooland/utoo-lint/main/npm/utoo-lint/schema.json";
+const MIGRATION_SOURCE = Symbol("migrationSource");
 const JAVASCRIPT_CONFIG_LOADER_SCRIPT = `
 import { writeFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -184,10 +194,15 @@ function migrateEslintConfig(options) {
 
   const eslintConfig = loadEslintConfig(sourcePath, options.cwd);
   const supportedRuleIds = new Set(new Linter().getRules().keys());
-  const entries = normalizeConfigEntries(eslintConfig);
+  const migrationInput = migrationInputFromConfig(
+    eslintConfig,
+    sourcePath,
+    realpathSync(dirname(options.output))
+  );
+  const entries = migrationInput.entries;
   const migratedEntries = [];
   const supportedRules = [];
-  const unsupportedRules = [];
+  let unsupportedRules = [];
   const ignoredRules = [];
   const translatedRules = [];
 
@@ -195,16 +210,18 @@ function migrateEslintConfig(options) {
     const rules = {};
     if (entry.rules && typeof entry.rules === "object") {
       for (const [ruleId, ruleConfig] of Object.entries(entry.rules)) {
-        const migratedRuleId = RULE_ALIASES.get(ruleId) ?? ruleId;
+        const migratedRuleId = REVIEWED_RULE_ALIASES.get(ruleId) ?? ruleId;
         if (IGNORED_RULES.has(ruleId)) {
           ignoredRules.push({ ruleId, reason: IGNORED_RULES.get(ruleId) });
           continue;
         }
         if (!supportedRuleIds.has(migratedRuleId)) {
           if (isRuleDisabled(ruleConfig)) {
+            unsupportedRules = removeDisabledUnsupportedRule(unsupportedRules, ruleId, entry);
             continue;
           }
-          unsupportedRules.push(ruleId);
+          const source = entry[MIGRATION_SOURCE];
+          unsupportedRules.push({ ruleId, scope: migrationRuleScope(entry), source });
           continue;
         }
         rules[migratedRuleId] = migratableRuleConfig(ruleConfig);
@@ -217,7 +234,7 @@ function migrateEslintConfig(options) {
     migratedEntries.push(migratableConfigEntry(entry, rules));
   }
 
-  const config = Array.isArray(eslintConfig)
+  const config = Array.isArray(eslintConfig) || migratedEntries.length > 1
     ? [{ $schema: SCHEMA_URL }, ...migratedEntries]
     : { $schema: SCHEMA_URL, ...(migratedEntries[0] ?? { rules: {} }) };
 
@@ -227,14 +244,410 @@ function migrateEslintConfig(options) {
       source: sourcePath,
       output: options.print ? null : options.output,
       supportedRules: uniqueSorted(supportedRules),
-      unsupportedRules: uniqueSorted(unsupportedRules),
+      unsupportedRules: uniqueSorted(unsupportedRules.map((rule) => rule.ruleId)),
       ignoredRules: uniqueByRuleId(ignoredRules),
       translatedRules: uniqueTranslatedRules(translatedRules),
+      inheritedSources: migrationInput.inheritedSources,
+      unsupportedInheritedRules: uniqueUnsupportedInheritedRules(
+        unsupportedRules
+          .filter((rule) => rule.source?.inherited)
+          .map((rule) => ({
+            ruleId: rule.ruleId,
+            sourceName: rule.source.name,
+            sourcePath: rule.source.filePath
+          }))
+      ),
       optionDroppedRules: []
     }
   };
 }
 
+function migrationInputFromConfig(eslintConfig, sourcePath, outputDirectory) {
+  if (!isClassicEslintConfig(eslintConfig, sourcePath)) {
+    return { entries: normalizeConfigEntries(eslintConfig), inheritedSources: [] };
+  }
+
+  const basePath = realpathSync(dirname(sourcePath));
+  const factory = new MigrationConfigArrayFactory({
+    cwd: basePath,
+    getEslintRecommendedConfig: () => eslintJs.configs.recommended,
+    getEslintAllConfig: () => eslintJs.configs.all
+  });
+
+  let configArray;
+  try {
+    configArray = factory.create(eslintConfig, {
+      basePath,
+      filePath: sourcePath,
+      name: sourcePath
+    });
+  } catch (error) {
+    throw new Error(`utoo-lint migrate eslint: unable to resolve classic config ${sourcePath}: ${error.message}`);
+  }
+
+  return migrationInputFromClassicConfigArray(configArray, basePath, outputDirectory);
+}
+
+function isClassicEslintConfig(eslintConfig, sourcePath) {
+  if (/^\.eslintrc(?:\.|$)/u.test(basename(sourcePath))) {
+    return true;
+  }
+  return Boolean(
+    eslintConfig &&
+    !Array.isArray(eslintConfig) &&
+    typeof eslintConfig === "object" &&
+    (eslintConfig.extends || eslintConfig.overrides || eslintConfig.ignorePatterns)
+  );
+}
+
+class MigrationConfigArrayFactory extends Legacy.ConfigArrayFactory {
+  activeSources = [];
+
+  _loadPlugin(name, context) {
+    return super._loadPlugin(name, {
+      ...context,
+      pluginBasePath: context.filePath ? dirname(context.filePath) : context.pluginBasePath
+    });
+  }
+
+  *_normalizeConfigData(configData, context) {
+    const source = classicContextSource(context);
+    const cycleIndex = this.activeSources.findIndex((active) => active.key === source.key);
+    if (cycleIndex !== -1) {
+      const chain = [...this.activeSources.slice(cycleIndex), source].map((active) => active.label).join(" -> ");
+      throw new Error(`Circular ESLint extends chain detected: ${chain}`);
+    }
+
+    this.activeSources.push(source);
+    try {
+      yield* super._normalizeConfigData(configData, context);
+    } finally {
+      this.activeSources.pop();
+    }
+  }
+}
+
+function classicContextSource(context) {
+  const label = classicSourceName(context.name ?? context.filePath ?? "inline config");
+  const key = label.startsWith("plugin:")
+    ? `plugin:${context.filePath ?? ""}:${label}`
+    : context.filePath
+      ? `file:${resolvePath(context.filePath)}`
+      : `name:${label}`;
+  return { key, label };
+}
+
+function migrationInputFromClassicConfigArray(configArray, basePath, outputDirectory) {
+  const entries = [];
+  const inheritedSources = [];
+  const records = [...configArray].map((element) => ({
+    element,
+    source: classicElementSource(element),
+    selector: rebaseClassicSelector(classicSelector(element.criteria), basePath, outputDirectory),
+    ignorePatterns: element.ignorePattern?.getPatternsRelativeTo(basePath) ?? []
+  }));
+  const scopedIgnores = new Map();
+
+  for (const record of records) {
+    if (record.element.criteria && record.ignorePatterns.length > 0) {
+      const key = classicOverrideChainKey(record.element);
+      scopedIgnores.set(key, uniquePatterns([...(scopedIgnores.get(key) ?? []), ...record.ignorePatterns]));
+    }
+  }
+
+  for (const { element, source, selector, ignorePatterns } of records) {
+    if (source.inherited) {
+      inheritedSources.push({ name: source.name, filePath: source.filePath });
+    }
+
+    const effectiveIgnorePatterns = (element.criteria
+      ? scopedIgnores.get(classicOverrideChainKey(element)) ?? []
+      : ignorePatterns).map((pattern) => rebaseClassicPattern(pattern, basePath, outputDirectory, true));
+    const rebasedIgnorePatterns = ignorePatterns.map(
+      (pattern) => rebaseClassicPattern(pattern, basePath, outputDirectory, true)
+    );
+    const hasRules = element.rules && typeof element.rules === "object";
+
+    if (rebasedIgnorePatterns.length > 0 && !element.criteria) {
+      entries.push(withMigrationSource({ ignores: rebasedIgnorePatterns }, source));
+    }
+
+    if (hasRules) {
+      const entry = { ...selector, rules: element.rules };
+      if (effectiveIgnorePatterns.length > 0 && element.criteria) {
+        entry.ignores = uniquePatterns([...(entry.ignores ?? []), ...effectiveIgnorePatterns]);
+      }
+      entries.push(withMigrationSource(entry, source));
+    } else if (rebasedIgnorePatterns.length > 0 && element.criteria) {
+      entries.push(withMigrationSource({ ...selector, ignores: [...(selector.ignores ?? []), ...rebasedIgnorePatterns] }, source));
+    }
+  }
+
+  return {
+    entries,
+    inheritedSources: uniqueInheritedSources(inheritedSources)
+  };
+}
+
+function classicOverrideChainKey(element) {
+  const segments = String(element.name ?? "").split(" » ");
+  let overrideIndex = -1;
+  for (let index = 0; index < segments.length; index += 1) {
+    if (/#overrides\[\d+\]/u.test(segments[index])) {
+      overrideIndex = index;
+    }
+  }
+  return overrideIndex === -1
+    ? `criteria:${classicCriteriaKey(element.criteria)}`
+    : `override:${segments.slice(0, overrideIndex + 1).join(" » ")}`;
+}
+
+function rebaseClassicSelector(selector, basePath, outputDirectory) {
+  return {
+    ...(selector.files ? {
+      files: selector.files.map((value) => Array.isArray(value)
+        ? value.map((pattern) => rebaseClassicPattern(pattern, basePath, outputDirectory))
+        : rebaseClassicPattern(value, basePath, outputDirectory))
+    } : {}),
+    ...(selector.ignores ? {
+      ignores: selector.ignores.map(
+        (pattern) => rebaseClassicPattern(pattern, basePath, outputDirectory, true)
+      )
+    } : {})
+  };
+}
+
+function rebaseClassicPattern(pattern, basePath, outputDirectory, preserveBasenameMatch = false) {
+  const negated = pattern.startsWith("!");
+  const unsignedPattern = negated ? pattern.slice(1) : pattern;
+  const rootAnchored = unsignedPattern.startsWith("/");
+  const value = rootAnchored ? unsignedPattern.slice(1) : unsignedPattern;
+  if (preserveBasenameMatch && !rootAnchored && !value.includes("/")) {
+    return pattern;
+  }
+
+  const absolutePattern = resolvePath(basePath, value);
+  const relativePattern = normalizeMigrationPath(relative(outputDirectory, absolutePattern));
+  const rebased = relativePattern === ".." || relativePattern.startsWith("../")
+    ? normalizeMigrationPath(absolutePattern)
+    : relativePattern || ".";
+  const anchoredPattern = rootAnchored && !rebased.includes("/") ? `/${rebased}` : rebased;
+  return negated ? `!${anchoredPattern}` : anchoredPattern;
+}
+
+function normalizeMigrationPath(path) {
+  return path.replaceAll("\\", "/");
+}
+
+function classicCriteriaKey(criteria) {
+  return JSON.stringify(classicSelector(criteria));
+}
+
+function classicSelector(criteria) {
+  if (!criteria) {
+    return {};
+  }
+
+  const includeGroups = [];
+  const ignores = [];
+  for (const patternGroup of criteria.patterns) {
+    includeGroups.push(uniquePatterns(
+      (patternGroup.includes ?? []).flatMap((matcher) => expandClassicExtglobs(classicIncludePattern(matcher)))
+    ));
+    ignores.push(...(patternGroup.excludes ?? []).flatMap(
+      (matcher) => expandClassicExtglobs(classicExcludePattern(matcher))
+    ));
+  }
+  const files = classicFileSelectors(includeGroups);
+
+  return {
+    ...(files.length > 0 ? { files } : {}),
+    ...(ignores.length > 0 ? { ignores: uniquePatterns(ignores) } : {})
+  };
+}
+
+function classicIncludePattern(matcher) {
+  return matcher.options?.matchBase && !matcher.pattern.includes("/")
+    ? `**/${matcher.pattern}`
+    : matcher.pattern;
+}
+
+function classicExcludePattern(matcher) {
+  return matcher.options?.matchBase === false && !matcher.pattern.includes("/")
+    ? `/${matcher.pattern}`
+    : matcher.pattern;
+}
+
+function expandClassicExtglobs(pattern) {
+  let expansions = [pattern];
+  while (expansions.some((value) => /@\([^()]*\)/u.test(value))) {
+    expansions = expansions.flatMap((value) => {
+      const match = /@\(([^()]*)\)/u.exec(value);
+      if (!match) {
+        return value;
+      }
+      const alternatives = match[1].split("|");
+      if (alternatives.some((alternative) => !alternative || /[*?[\]{}()]/u.test(alternative))) {
+        throw unsupportedClassicExtglobError(pattern);
+      }
+      return alternatives.map((alternative) =>
+        `${value.slice(0, match.index)}${alternative}${value.slice(match.index + match[0].length)}`
+      );
+    });
+  }
+  if (/[?+*!@]\(/u.test(expansions[0])) {
+    throw unsupportedClassicExtglobError(pattern);
+  }
+  return uniquePatterns(expansions);
+}
+
+function unsupportedClassicExtglobError(pattern) {
+  return new Error(
+    `utoo-lint migrate eslint: cannot migrate classic selector pattern "${pattern}": ` +
+    "only literal @(one|two) extglob alternatives are supported"
+  );
+}
+
+function classicFileSelectors(includeGroups) {
+  const groups = includeGroups.filter((group) => group.length > 0);
+  if (groups.length <= 1) {
+    return groups[0] ?? [];
+  }
+
+  let selectors = [[]];
+  for (const group of groups) {
+    selectors = selectors.flatMap((selector) => group.map((pattern) => [...selector, pattern]));
+  }
+  return selectors;
+}
+
+function uniquePatterns(patterns) {
+  return [...new Set(patterns)];
+}
+
+function migrationRuleScope(entry) {
+  if (!entry.files && !entry.ignores) {
+    return null;
+  }
+  return {
+    files: migratableFilePatterns(entry.files),
+    ignores: migratablePatterns(entry.ignores)
+  };
+}
+
+function removeDisabledUnsupportedRule(rules, ruleId, entry) {
+  const disabledScope = migrationRuleScope(entry);
+  const remaining = [];
+  for (const rule of rules) {
+    if (rule.ruleId !== ruleId) {
+      remaining.push(rule);
+      continue;
+    }
+    const scope = subtractDisabledScope(rule.scope, disabledScope);
+    if (scope !== undefined) {
+      remaining.push({ ...rule, scope });
+    }
+  }
+  return remaining;
+}
+
+function subtractDisabledScope(enabledScope, disabledScope) {
+  if (disabledScope === null) {
+    return undefined;
+  }
+  if (enabledScope === null) {
+    return enabledScope;
+  }
+  if (
+    disabledScope.ignores.length > 0 &&
+    JSON.stringify(enabledScope.ignores) !== JSON.stringify(disabledScope.ignores)
+  ) {
+    return enabledScope;
+  }
+  if (disabledScope.files.length === 0) {
+    return undefined;
+  }
+  if (enabledScope.files.length === 0) {
+    return enabledScope;
+  }
+
+  const disabledGroups = disabledScope.files.map((selector) => Array.isArray(selector) ? selector : [selector]);
+  const files = enabledScope.files.filter((selector) => {
+    const enabledGroup = Array.isArray(selector) ? selector : [selector];
+    return !disabledGroups.some((disabledGroup) => selectorGroupCovers(enabledGroup, disabledGroup));
+  });
+  return files.length === 0 ? undefined : { ...enabledScope, files };
+}
+
+function selectorGroupCovers(enabledGroup, disabledGroup) {
+  return disabledGroup.every((disabledPattern) => enabledGroup.some((enabledPattern) =>
+    globPatternCovers(enabledPattern, disabledPattern)
+  ));
+}
+
+function globPatternCovers(enabledPattern, disabledPattern) {
+  if (enabledPattern === disabledPattern) {
+    return true;
+  }
+  const enabledSegments = enabledPattern.split("/");
+  const disabledSegments = disabledPattern.split("/");
+  return globSegmentsCover(enabledSegments, disabledSegments, 0, 0);
+}
+
+function globSegmentsCover(enabled, disabled, enabledIndex, disabledIndex) {
+  if (disabledIndex === disabled.length) {
+    return enabledIndex === enabled.length;
+  }
+  if (disabled[disabledIndex] === "**") {
+    if (disabledIndex === disabled.length - 1) {
+      return true;
+    }
+    for (let index = enabledIndex; index <= enabled.length; index += 1) {
+      if (globSegmentsCover(enabled, disabled, index, disabledIndex + 1)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (enabledIndex === enabled.length || enabled[enabledIndex] === "**") {
+    return false;
+  }
+  return globSegmentCovers(enabled[enabledIndex], disabled[disabledIndex]) &&
+    globSegmentsCover(enabled, disabled, enabledIndex + 1, disabledIndex + 1);
+}
+
+function globSegmentCovers(enabledSegment, disabledSegment) {
+  if (enabledSegment === disabledSegment) {
+    return true;
+  }
+  if (/[?[{]/u.test(disabledSegment)) {
+    return false;
+  }
+  const expression = new RegExp(`^${disabledSegment
+    .split("*")
+    .map((part) => part.replace(/[.+?^${}()|[\]\\]/gu, "\\$&"))
+    .join(".*")}$`);
+  return expression.test(enabledSegment);
+}
+
+function classicElementSource(element) {
+  const name = classicSourceName(element.name ?? element.filePath ?? "inline config");
+  return {
+    inherited: String(element.name ?? "").includes(" » "),
+    name,
+    filePath: element.filePath || null
+  };
+}
+
+function classicSourceName(name) {
+  return String(name).split(" » ").at(-1).replace(/#overrides\[\d+\]$/u, "");
+}
+
+function withMigrationSource(entry, source) {
+  Object.defineProperty(entry, MIGRATION_SOURCE, { value: source });
+  return entry;
+}
+
 function findEslintConfig(cwd) {
   let current = cwd;
   while (true) {
@@ -293,7 +706,7 @@ function migratableConfigEntry(entry, rules) {
   if (typeof entry.name === "string") {
     migrated.name = entry.name;
   }
-  const files = migratablePatterns(entry.files);
+  const files = migratableFilePatterns(entry.files);
   if (files.length > 0) {
     migrated.files = files;
   }
@@ -307,6 +720,27 @@ function migratableConfigEntry(entry, rules) {
   return migrated;
 }
 
+function migratableFilePatterns(value) {
+  const result = [];
+  const seen = new Set();
+  for (const pattern of Array.isArray(value) ? value : [value]) {
+    const migrated = Array.isArray(pattern)
+      ? migratablePatterns(pattern)
+      : typeof pattern === "string"
+        ? pattern
+        : null;
+    if (migrated === null || (Array.isArray(migrated) && migrated.length === 0)) {
+      continue;
+    }
+    const key = JSON.stringify(migrated);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(migrated);
+    }
+  }
+  return result;
+}
+
 function migratablePatterns(value) {
   const patterns = [];
   collectMigratablePatterns(value, patterns);
@@ -360,6 +794,28 @@ function uniqueTranslatedRules(values) {
   return [...result.values()].sort((left, right) => left.sourceRuleId.localeCompare(right.sourceRuleId));
 }
 
+function uniqueInheritedSources(values) {
+  const result = new Map();
+  for (const value of values) {
+    result.set(`${value.name}\0${value.filePath ?? ""}`, value);
+  }
+  return [...result.values()].sort((left, right) =>
+    left.name.localeCompare(right.name) || String(left.filePath ?? "").localeCompare(String(right.filePath ?? ""))
+  );
+}
+
+function uniqueUnsupportedInheritedRules(values) {
+  const result = new Map();
+  for (const value of values) {
+    result.set(`${value.ruleId}\0${value.sourceName}\0${value.sourcePath ?? ""}`, value);
+  }
+  return [...result.values()].sort((left, right) =>
+    left.ruleId.localeCompare(right.ruleId) ||
+    left.sourceName.localeCompare(right.sourceName) ||
+    String(left.sourcePath ?? "").localeCompare(String(right.sourcePath ?? ""))
+  );
+}
+
 function writeReport(report, options, stream) {
   if (options.report === "json") {
     stream.write(JSON.stringify(report, null, 2) + "\n");
@@ -371,6 +827,9 @@ function writeReport(report, options, stream) {
     stream.write(`utoo-lint migrate eslint: wrote ${report.output}\n`);
   }
   stream.write(`utoo-lint migrate eslint: migrated ${report.supportedRules.length} supported rule(s)\n`);
+  if (report.inheritedSources.length > 0) {
+    stream.write(`utoo-lint migrate eslint: resolved ${report.inheritedSources.length} inherited config source(s): ${report.inheritedSources.map(formatInheritedSource).join(", ")}\n`);
+  }
   if (report.translatedRules.length > 0) {
     stream.write(`utoo-lint migrate eslint: translated ${report.translatedRules.length} rule alias(es): ${report.translatedRules.map((rule) => `${rule.sourceRuleId} -> ${rule.targetRuleId}`).join(", ")}\n`);
   }
@@ -380,6 +839,13 @@ function writeReport(report, options, stream) {
   if (report.unsupportedRules.length > 0) {
     stream.write(`utoo-lint migrate eslint: ${report.unsupportedRules.length} unsupported rule(s): ${report.unsupportedRules.join(", ")}\n`);
   }
+  if (report.unsupportedInheritedRules.length > 0) {
+    stream.write(`utoo-lint migrate eslint: unsupported inherited rule source(s): ${report.unsupportedInheritedRules.map((rule) => `${rule.ruleId} from ${formatInheritedSource({ name: rule.sourceName, filePath: rule.sourcePath })}`).join(", ")}\n`);
+  }
+}
+
+function formatInheritedSource(source) {
+  return source.filePath ? `${source.name} (${pathToFileURL(source.filePath).href})` : source.name;
 }
 
 function printMigrateHelp() {

package/bin/utoo-lint.js

@@ -4,20 +4,20 @@ import { runCli } from "../index.js";
 
 if (process.argv[2] === "migrate") {
   const { runMigrate } = await import("./migrate.js");
-  process.exit(await runMigrate(process.argv.slice(3)));
-}
-
-let result;
-try {
-  result = runCli(process.argv.slice(2), { stdio: "inherit" });
-} catch (error) {
-  console.error(error.message);
-  process.exit(1);
-}
+  process.exitCode = await runMigrate(process.argv.slice(3));
+} else {
+  let result;
+  try {
+    result = runCli(process.argv.slice(2), { stdio: "inherit" });
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
 
-if (result.error) {
-  console.error(`utoo-lint: failed to run native binary: ${result.error.message}`);
-  process.exit(1);
+  if (result?.error) {
+    console.error(`utoo-lint: failed to run native binary: ${result.error.message}`);
+    process.exitCode = 1;
+  } else if (result) {
+    process.exitCode = result.status ?? 1;
+  }
 }
-
-process.exit(result.status ?? 1);

package/configs/frontend.d.ts

@@ -1,8 +1,60 @@
-import type { ConfigObject } from "../index.js";
+import type { ConfigObject, RuleConfig } from "../index.js";
+
+export type FrontendRuleId =
+  | "no-debugger"
+  | "no-alert"
+  | "no-console"
+  | "no-unused-vars"
+  | "prefer-const"
+  | "eqeqeq"
+  | "use-isnan"
+  | "valid-typeof"
+  | "no-constant-condition"
+  | "no-dupe-keys"
+  | "no-duplicate-imports"
+  | "no-script-url"
+  | "import/first"
+  | "import/newline-after-import"
+  | "import/no-duplicates"
+  | "import/no-self-import"
+  | "promise/no-nesting"
+  | "react-hooks/rules-of-hooks"
+  | "react-hooks/exhaustive-deps"
+  | "react/jsx-no-duplicate-props"
+  | "react/jsx-key"
+  | "react/jsx-no-target-blank"
+  | "react/jsx-pascal-case"
+  | "react/no-array-index-key"
+  | "react/no-children-prop"
+  | "react/no-danger"
+  | "react/no-danger-with-children"
+  | "react/no-find-dom-node"
+  | "react/no-forward-ref"
+  | "react/no-unstable-nested-components"
+  | "react/no-unescaped-entities"
+  | "react/void-dom-elements-no-children"
+  | "jsx-a11y/aria-props"
+  | "jsx-a11y/aria-unsupported-elements"
+  | "jsx-a11y/iframe-has-title"
+  | "jsx-a11y/img-redundant-alt"
+  | "jsx-a11y/no-access-key"
+  | "unused-imports/no-unused-imports"
+  | "@typescript-eslint/ban-types"
+  | "@typescript-eslint/no-unused-vars"
+  | "@typescript-eslint/no-use-before-define"
+  | "@typescript-eslint/no-shadow"
+  | "@typescript-eslint/no-redeclare"
+  | "@typescript-eslint/no-require-imports"
+  | "@typescript-eslint/consistent-type-assertions"
+  | "@typescript-eslint/consistent-type-definitions"
+  | "@typescript-eslint/no-empty-interface"
+  | "@typescript-eslint/no-non-null-asserted-optional-chain";
 
 declare const frontend: ConfigObject & {
   readonly $schema: string;
-  readonly rules: NonNullable<ConfigObject["rules"]>;
+  readonly files: ["src/**/*.{js,jsx,ts,tsx}"];
+  readonly ignores: ["dist", "coverage", "node_modules"];
+  readonly rules: Readonly<Record<FrontendRuleId, RuleConfig>>;
 };
 
 export default frontend;