@utoo/lint 0.2.9 → 0.3.5

package/index.js

@@ -17,6 +17,7 @@ export const version = JSON.parse(readFileSync(new URL("./package.json", import.
 
 const LINTABLE_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
 const MAX_AUTOFIX_PASSES = 10;
+const CONFIG_DISCOVERY_CACHE = Symbol("configDiscoveryCache");
 const JS_KEYWORDS = new Set([
   "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete",
   "do", "else", "export", "extends", "finally", "for", "function", "if", "import", "in",
@@ -80,6 +81,7 @@ const BUILTIN_RULE_IDS = [
   "block-scoped-var",
   "camelcase",
   "capitalized-comments",
+  "class-methods-use-this",
   "complexity",
   "consistent-return",
   "consistent-this",
@@ -171,6 +173,7 @@ const BUILTIN_RULE_IDS = [
   "no-inline-comments",
   "no-inner-declarations",
   "no-invalid-regexp",
+  "no-invalid-this",
   "no-irregular-whitespace",
   "no-iterator",
   "no-label-var",
@@ -179,6 +182,7 @@ const BUILTIN_RULE_IDS = [
   "no-lonely-if",
   "no-loop-func",
   "no-loss-of-precision",
+  "no-magic-numbers",
   "no-mixed-spaces-and-tabs",
   "no-misleading-character-class",
   "no-multi-assign",
@@ -237,6 +241,8 @@ const BUILTIN_RULE_IDS = [
   "no-underscore-dangle",
   "no-undefined",
   "no-unneeded-ternary",
+  "no-unexpected-multiline",
+  "no-unmodified-loop-condition",
   "no-unreachable",
   "no-unreachable-loop",
   "no-unsafe-finally",
@@ -247,6 +253,7 @@ const BUILTIN_RULE_IDS = [
   "no-unused-private-class-members",
   "no-unused-vars",
   "no-use-before-define",
+  "no-useless-assignment",
   "no-useless-backreference",
   "no-useless-call",
   "no-useless-catch",
@@ -308,6 +315,19 @@ const BUILTIN_RULE_IDS = [
   "import/no-named-as-default-member",
   "import/no-unresolved",
   "import/no-self-import",
+  "jest/no-conditional-expect",
+  "jest/no-deprecated-functions",
+  "jest/no-export",
+  "jest/no-focused-tests",
+  "jest/no-identical-title",
+  "jest/no-interpolation-in-snapshots",
+  "jest/no-jasmine-globals",
+  "jest/no-mocks-import",
+  "jest/no-standalone-expect",
+  "jest/valid-describe-callback",
+  "jest/valid-expect-in-promise",
+  "jest/valid-expect",
+  "jest/valid-title",
   "promise/no-promise-in-callback",
   "promise/no-return-in-finally",
   "promise/no-return-wrap",
@@ -352,9 +372,12 @@ const BUILTIN_RULE_IDS = [
   "react/no-danger",
   "react/no-danger-with-children",
   "react/no-deprecated",
+  "react/no-direct-mutation-state",
   "react/no-find-dom-node",
+  "react/no-forward-ref",
   "react/no-is-mounted",
   "react/no-multi-comp",
+  "react/no-unstable-nested-components",
   "react/no-redundant-should-component-update",
   "react/no-render-return-value",
   "react/no-string-refs",
@@ -452,10 +475,15 @@ const NATIVE_ONLY_RULE_IDS = [
 ];
 const NATIVE_RULE_IDS = [...BUILTIN_RULE_IDS, ...NATIVE_ONLY_RULE_IDS];
 const FIXABLE_BUILTIN_RULE_IDS = new Set([
+  "jest/no-deprecated-functions",
+  "jest/no-jasmine-globals",
   "no-extra-semi",
   "@typescript-eslint/no-extra-semi",
   "unused-imports/no-unused-imports"
 ]);
+const SUGGESTION_BUILTIN_RULE_IDS = new Set([
+  "jest/no-focused-tests"
+]);
 const BUILTIN_RULES = new Map(BUILTIN_RULE_IDS.map((ruleId) => [ruleId, createBuiltinRule(ruleId)]));
 
 export class UtooLint {
@@ -545,7 +573,7 @@ export class UtooLint {
   }
 
   async isPathIgnored(filePath) {
-    return isPathIgnored(filePath, mergeLintOptions(this.options, {}));
+    return isPathIgnored(filePath, withConfigCache(mergeLintOptions(this.options, {})));
   }
 
   async calculateConfigForFile(filePath) {
@@ -553,7 +581,7 @@ export class UtooLint {
   }
 
   async findConfigFile(filePath) {
-    const options = eslintConstructorOptions(this.options);
+    const options = withConfigCache(eslintConstructorOptions(this.options));
     if (options.noConfig) {
       return undefined;
     }
@@ -652,15 +680,20 @@ export class Linter {
       filename: filePath,
       config: calculatedConfig({ cwd: verifyOptions.cwd, noConfig: true, overrideConfig: config }, normalizedFilePath)
     });
+    const nativeRuleFilter = applyDisableDirectives(
+      (report.diagnostics ?? []).map((diagnostic) => diagnosticToESLintMessage(diagnostic, ruleSeverities)),
+      sourceCode
+    );
     const customRuleFilter = applyDisableDirectives(customRuleMessages, sourceCode);
     this.suppressedMessages = [
       ...(report.suppressedDiagnostics ?? []).map((diagnostic) => suppressedDiagnosticToESLintMessage(diagnostic, ruleSeverities)),
+      ...nativeRuleFilter.suppressedMessages,
       ...customRuleFilter.suppressedMessages
     ];
     this.times = { passes: [] };
     this.fixPassCount = 0;
     return [
-      ...(report.diagnostics ?? []).map((diagnostic) => diagnosticToESLintMessage(diagnostic, ruleSeverities)),
+      ...nativeRuleFilter.messages,
       ...customRuleFilter.messages
     ];
   }
@@ -765,7 +798,7 @@ function parserOptionsForConfig(config, filePath, cwd) {
 
 function customRuleEntriesForConfig(config, rules, filePath, cwd) {
   const entries = new Map();
-  for (const [ruleId, ruleConfig] of ruleConfigEntries(config, filePath, cwd)) {
+  for (const [ruleId, ruleConfig] of Object.entries(rulesFromConfig(config, filePath, cwd))) {
     if (!rules.has(ruleId)) {
       continue;
     }
@@ -822,19 +855,6 @@ function matchingConfigEntries(config, filePath = undefined, cwd = undefined) {
   return [config];
 }
 
-function ruleConfigEntries(config, filePath = undefined, cwd = undefined) {
-  if (Array.isArray(config)) {
-    return config.flatMap((item) => ruleConfigEntries(item, filePath, cwd));
-  }
-  if (!config || typeof config !== "object" || !config.rules || typeof config.rules !== "object") {
-    return [];
-  }
-  if (!configAppliesToFile(config, filePath, cwd)) {
-    return [];
-  }
-  return Object.entries(config.rules);
-}
-
 function configWithoutCustomRules(config, rules) {
   if (Array.isArray(config)) {
     return config.map((item) => configWithoutCustomRules(item, rules));
@@ -964,6 +984,7 @@ function applyDisableDirectives(messages, sourceCode) {
   }
   const directives = sourceCode.getDisableDirectives()
     .filter((directive) => directive.node?.loc?.start?.line)
+    .filter((directive) => directive.type !== "eslint-disable-line" || directive.node.loc.start.line === directive.node.loc.end.line)
     .sort((left, right) => left.node.loc.start.line - right.node.loc.start.line);
   const utlintDirectives = sourceCode.getAllComments()
     .map((comment) => utlintDirectiveFromComment(comment, sourceCode))
@@ -976,6 +997,10 @@ function applyDisableDirectives(messages, sourceCode) {
   const kept = [];
   const suppressed = [];
   for (const message of messages) {
+    if (!message.ruleId || message.ruleId === "parse" || message.ruleId === "io") {
+      kept.push(message);
+      continue;
+    }
     const directive = utlintDirectiveForMessage(message, utlintDirectives) ?? disableDirectiveForMessage(message, directives);
     if (directive) {
       suppressed.push({
@@ -2135,10 +2160,7 @@ function mergeRuleTesterConfig(baseConfig, overrideConfig) {
   return {
     ...baseConfig,
     ...overrideConfig,
-    rules: {
-      ...(baseConfig.rules ?? {}),
-      ...(overrideConfig.rules ?? {})
-    }
+    rules: mergeRuleConfigMaps(baseConfig.rules, overrideConfig.rules)
   };
 }
 
@@ -2589,7 +2611,7 @@ export class CLIEngine {
   }
 
   isPathIgnored(filePath) {
-    return isPathIgnored(filePath, eslintConstructorOptions(this.options));
+    return isPathIgnored(filePath, withConfigCache(eslintConstructorOptions(this.options)));
   }
 
   getConfigForFile(filePath) {
@@ -2597,6 +2619,20 @@ export class CLIEngine {
   }
 }
 
+const DEFAULT_NATIVE_MAX_BUFFER = 64 * 1024 * 1024;
+
+function nativeMaxBuffer(options, env) {
+  const configured = options.maxBuffer ?? env.UTOO_LINT_MAX_BUFFER;
+  if (configured === undefined || configured === "") {
+    return DEFAULT_NATIVE_MAX_BUFFER;
+  }
+  const value = typeof configured === "number" ? configured : Number(configured);
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError("maxBuffer and UTOO_LINT_MAX_BUFFER must be a positive integer byte count");
+  }
+  return value;
+}
+
 export function run(args = [], options = {}) {
   const cliArgs = normalizeStringArray(args, "args");
   const env = options.env ? { ...process.env, ...options.env } : process.env;
@@ -2607,7 +2643,8 @@ export function run(args = [], options = {}) {
     env,
     encoding: options.encoding ?? "utf8",
     input: options.input,
-    stdio: options.stdio
+    stdio: options.stdio,
+    maxBuffer: nativeMaxBuffer(options, env)
   });
 }
 
@@ -2749,8 +2786,9 @@ export function runCli(args = [], options = {}) {
     extraArgs: parsed.passthroughArgs,
     preserveNativeDefaults: Boolean(parsed.options.noConfig)
   });
-  const targets = parsed.targets.length > 0 ? parsed.targets : defaultLintTargets(cliOptions);
-  const report = lintFiles(targets, cliOptions);
+  const usesDefaultTargets = parsed.targets.length === 0;
+  const targets = usesDefaultTargets ? defaultLintTargets(cliOptions) : parsed.targets;
+  const report = lintFiles(targets, { ...cliOptions, useDefaultConfigTargets: usesDefaultTargets });
   report.diagnostics = normalizeReportDiagnostics(report.diagnostics, cliOptions);
   report.exitCode = exitCodeForDiagnostics(report.diagnostics);
   const status = report.exitCode ?? exitCodeForDiagnostics(report.diagnostics);
@@ -2858,7 +2896,8 @@ export function runFishlint(args = [], options = {}) {
     env,
     encoding: options.encoding ?? "utf8",
     input: options.input,
-    stdio: options.stdio
+    stdio: options.stdio,
+    maxBuffer: nativeMaxBuffer(options, env)
   });
 }
 
@@ -3060,13 +3099,23 @@ function booleanFlagValue(arg) {
 
 export function lintFiles(paths, options = {}) {
   options = withConfigCache(options);
+  const usesDefaultTargets = paths == null || options.useDefaultConfigTargets;
   const targets = lintTargetsForInput(paths, options);
   const ignoredDiagnostics = ignoredLintPathDiagnostics(targets, options);
-  const lintPaths = filteredLintPaths(targets, options);
+  let lintPaths = filteredLintPaths(targets, options);
+  if (usesDefaultTargets) {
+    lintPaths = filterDefaultConfigLintPaths(lintPaths, options);
+  }
   if (lintPaths.length === 0) {
     return { files: 0, filePaths: [], diagnostics: ignoredDiagnostics, suppressedDiagnostics: [], exitCode: exitCodeForDiagnostics(ignoredDiagnostics) };
   }
 
+  const nativeFlatOptions = nativeFlatConfigOptions(options);
+  if (nativeFlatOptions) {
+    const report = runNativeLintReport(lintPaths, nativeFlatOptions);
+    return finalizeLintReport(report, ignoredDiagnostics, options);
+  }
+
   const configRuns = nativeConfigRunsForFiles(expandNativeConfigRunPaths(lintPaths, options), options);
   if (configRuns) {
     const report = mergeNativeReports(
@@ -3079,6 +3128,76 @@ export function lintFiles(paths, options = {}) {
   return finalizeLintReport(report, ignoredDiagnostics, options);
 }
 
+function nativeFlatConfigOptions(options) {
+  if (options.rules || options.extraArgs?.some((arg) => arg.startsWith("--") && arg !== "--fix" && arg !== "--fix-dry-run")) {
+    return undefined;
+  }
+
+  const fileConfigPath = options.noConfig ? undefined : configPathForOptions(options);
+  const inlineConfigs = [options.baseConfig, options.overrideConfig].filter(Boolean);
+  if (fileConfigPath && inlineConfigs.length > 0) {
+    return undefined;
+  }
+
+  let config;
+  let configRoot;
+  if (fileConfigPath) {
+    config = readConfig(fileConfigPath, options.cwd, options.configCache);
+    configRoot = dirname(fileConfigPath);
+  } else if (inlineConfigs.length > 0) {
+    config = inlineConfigs.length === 1 ? inlineConfigs[0] : inlineConfigs;
+    configRoot = resolvePath(options.cwd ?? process.cwd());
+  } else {
+    return undefined;
+  }
+
+  if (configCanUseNativeRulesFastPath(config)) {
+    return undefined;
+  }
+
+  const serializedConfig = nativeSerializableConfig(config);
+  return {
+    ...options,
+    nativeFlatConfigData: Array.isArray(serializedConfig) ? serializedConfig : [serializedConfig],
+    nativeConfigRoot: configRoot,
+    nativeConfigCwd: resolvePath(options.cwd ?? process.cwd())
+  };
+}
+
+function configCanUseNativeRulesFastPath(config) {
+  const entries = Array.isArray(config) ? config : [config];
+  let hasEnabledRule = false;
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object" || Object.keys(entry.settings ?? {}).length > 0) {
+      return false;
+    }
+    for (const ruleConfig of Object.values(entry.rules ?? {})) {
+      if (ruleConfigSeverity(ruleConfig) === 0) {
+        continue;
+      }
+      if (!isPureRuleSeverity(ruleConfig)) {
+        return false;
+      }
+      hasEnabledRule = true;
+    }
+  }
+  return hasEnabledRule;
+}
+
+function nativeSerializableConfig(config) {
+  if (Array.isArray(config)) {
+    return config.map(nativeSerializableConfig);
+  }
+  if (!config || typeof config !== "object") {
+    return config;
+  }
+  return Object.fromEntries(
+    ["$schema", "name", "files", "ignores", "rules", "settings"]
+      .filter((key) => config[key] !== undefined)
+      .map((key) => [key, config[key]])
+  );
+}
+
 function expandNativeConfigRunPaths(paths, options) {
   const cwd = options.cwd ?? process.cwd();
   const patterns = ignoreDisabled(options) ? [] : ignorePatternsForOptions(options, cwd);
@@ -3152,13 +3271,15 @@ function nativeConfigRunsForFiles(paths, options) {
     const fileConfigPath = options.noConfig ? undefined : configPathForFile(options, matchPath);
     const configured = Boolean(options.baseConfig || options.overrideConfig || fileConfigPath);
     hasConfigSource ||= configured;
-    let rules = configured ? calculatedConfig({ ...options, rules: undefined }, matchPath).rules : undefined;
+    const calculated = configured ? calculatedConfig({ ...options, rules: undefined }, matchPath) : {};
+    let rules = calculated.rules;
+    const settings = calculated.settings;
     if (configured && options.rules) {
       rules = selectedRulesWithConfigOptions(rules, options.rules);
     }
-    const signature = configured ? stableConfigSignature(rules) : "<native-defaults>";
+    const signature = configured ? stableConfigSignature({ rules, settings }) : "<native-defaults>";
     if (!groups.has(signature)) {
-      groups.set(signature, { paths: [], rules, configured });
+      groups.set(signature, { paths: [], rules, settings, configured });
     }
     groups.get(signature).paths.push(filePath);
   }
@@ -3181,6 +3302,22 @@ function nativeConfigRunsForFiles(paths, options) {
       };
     }
 
+    const selectedRules = severityOnlyNativeRuleNames(group.rules, group.settings);
+    if (selectedRules) {
+      return {
+        paths: group.paths,
+        options: {
+          ...options,
+          config: undefined,
+          noConfig: true,
+          baseConfig: undefined,
+          overrideConfig: undefined,
+          rules: selectedRules,
+          forceMaterializedConfig: undefined
+        }
+      };
+    }
+
     return {
       paths: group.paths,
       options: {
@@ -3188,13 +3325,50 @@ function nativeConfigRunsForFiles(paths, options) {
         config: undefined,
         noConfig: true,
         baseConfig: undefined,
-        overrideConfig: { rules: allDisabledNativeRules(group.rules) },
+        overrideConfig: {
+          rules: allDisabledNativeRules(group.rules),
+          ...(group.settings ? { settings: group.settings } : {})
+        },
         forceMaterializedConfig: true
       }
     };
   });
 }
 
+function severityOnlyNativeRuleNames(rules, settings) {
+  if (Object.keys(settings ?? {}).length > 0) {
+    return undefined;
+  }
+
+  const selected = [];
+  for (const [rule, config] of Object.entries(rules ?? {})) {
+    if (ruleConfigSeverity(config) === 0) {
+      continue;
+    }
+    if (!isPureRuleSeverity(config)) {
+      return undefined;
+    }
+    selected.push(rule);
+  }
+  return selected.length > 0 ? selected : undefined;
+}
+
+function isPureRuleSeverity(config) {
+  if (Array.isArray(config)) {
+    if (config.length !== 1) {
+      return false;
+    }
+    [config] = config;
+  }
+  if (typeof config === "boolean") {
+    return true;
+  }
+  if (typeof config === "number") {
+    return config === 0 || config === 1 || config === 2;
+  }
+  return typeof config === "string" && ["off", "warn", "warning", "error", "0", "1", "2"].includes(config.toLowerCase());
+}
+
 function allDisabledNativeRules(rules) {
   return {
     ...Object.fromEntries(NATIVE_RULE_IDS.map((rule) => [rule, "off"])),
@@ -3311,7 +3485,7 @@ function buildNativeLintArgs(paths, options) {
   if (options.noConfig) {
     cliArgs.push("--no-config");
   }
-  if (!options.rules && !options.forceMaterializedConfig && (options.config || options.baseConfig || options.overrideConfig)) {
+  if (!options.nativeFlatConfigData && !options.rules && !options.forceMaterializedConfig && (options.config || options.baseConfig || options.overrideConfig)) {
     const configForRuleSelection = options.noConfig
       ? undefined
       : options.config ? readConfig(options.config, options.cwd, options.configCache) : undefined;
@@ -3327,6 +3501,12 @@ function buildNativeLintArgs(paths, options) {
   if (options.config) {
     cliArgs.push(`--config=${options.config}`);
   }
+  if (options.nativeConfigRoot) {
+    cliArgs.push(`--config-root=${options.nativeConfigRoot}`);
+  }
+  if (options.nativeConfigCwd) {
+    cliArgs.push(`--config-cwd=${options.nativeConfigCwd}`);
+  }
   if (options.rules) {
     const rules = Array.isArray(options.rules) ? options.rules.join(",") : options.rules;
     if (rules) {
@@ -3361,9 +3541,17 @@ function mergeLintOptions(base, override) {
 }
 
 function withConfigCache(options) {
-  // Executable configs are otherwise re-evaluated at every per-file lookup.
-  // Keep the cache on the options object so one public invocation shares it.
-  return options.configCache ? options : { ...options, configCache: new Map() };
+  if (options.configCache && options[CONFIG_DISCOVERY_CACHE]) {
+    return options;
+  }
+
+  return {
+    ...options,
+    // Executable configs are otherwise re-evaluated at every per-file lookup.
+    configCache: options.configCache ?? new Map(),
+    // Discovery results must not survive into a later public invocation.
+    [CONFIG_DISCOVERY_CACHE]: new Map()
+  };
 }
 
 function eslintConstructorOptions(options) {
@@ -3417,12 +3605,12 @@ function calculatedConfig(options = {}, filePath) {
   );
   return {
     ...configData,
-    rules: {
-      ...rulesFromConfig(options.baseConfig, filePath, options.cwd),
-      ...rulesFromFileConfig(options, filePath),
-      ...rulesFromConfig(options.overrideConfig, filePath, options.cwd),
-      ...rulesFromNativeRuleList(options.rules)
-    }
+    rules: mergeRuleConfigMaps(
+      rulesFromConfig(options.baseConfig, filePath, options.cwd),
+      rulesFromFileConfig(options, filePath),
+      rulesFromConfig(options.overrideConfig, filePath, options.cwd),
+      rulesFromNativeRuleList(options.rules)
+    )
   };
 }
 
@@ -3517,10 +3705,10 @@ function rulesFromConfig(config, filePath, cwd) {
     return {};
   }
   if (Array.isArray(config)) {
-    return config.reduce((rules, entry) => ({
-      ...rules,
-      ...rulesFromConfig(entry, filePath, cwd)
-    }), {});
+    return config.reduce(
+      (rules, entry) => mergeRuleConfigMaps(rules, rulesFromConfig(entry, filePath, cwd)),
+      {}
+    );
   }
   if (!configAppliesToFile(config, filePath, cwd)) {
     return {};
@@ -3573,12 +3761,64 @@ function defaultLintTargets(options = {}) {
     return ["."];
   }
 
-  const targets = filePatternsFromConfig(readConfig(configPath, options.cwd, options.configCache));
+  const config = readConfig(configPath, options.cwd, options.configCache);
+  if (configHasUnscopedRules(config)) {
+    return ["."];
+  }
+
+  const targets = filePatternsFromConfig(config);
   return targets.length > 0
     ? targets.map((target) => resolveConfigPattern(target, dirname(configPath)))
     : ["."];
 }
 
+function filterDefaultConfigLintPaths(paths, options) {
+  const configPath = configPathForOptions(options);
+  if (!configPath) {
+    return paths;
+  }
+  const config = readConfig(configPath, options.cwd, options.configCache);
+  if (!configHasFileSelectors(config)) {
+    return paths;
+  }
+  const cwd = dirname(configPath);
+  return paths.filter((filePath) => configSelectsFile(config, filePath, cwd));
+}
+
+function configHasFileSelectors(config) {
+  if (Array.isArray(config)) {
+    return config.some(configHasFileSelectors);
+  }
+  return Boolean(config && typeof config === "object" && normalizeConfigFileSelectors(config.files).length > 0);
+}
+
+function configHasUnscopedRules(config) {
+  if (Array.isArray(config)) {
+    return config.some(configHasUnscopedRules);
+  }
+  return Boolean(
+    config &&
+    typeof config === "object" &&
+    normalizeConfigFileSelectors(config.files).length === 0 &&
+    config.rules &&
+    typeof config.rules === "object" &&
+    Object.keys(config.rules).length > 0
+  );
+}
+
+function configSelectsFile(config, filePath, cwd) {
+  if (Array.isArray(config)) {
+    return config.some((entry) => configSelectsFile(entry, filePath, cwd));
+  }
+  if (!config || typeof config !== "object") {
+    return false;
+  }
+  const selectors = normalizeConfigFileSelectors(config.files);
+  return selectors.length > 0
+    ? configAppliesToFile(config, filePath, cwd)
+    : configHasUnscopedRules(config) && configAppliesToFile(config, filePath, cwd);
+}
+
 function resolveConfigPattern(pattern, configDirectory) {
   if (isAbsolute(pattern)) {
     return pattern;
@@ -3602,8 +3842,10 @@ function configAppliesToFile(config, filePath, cwd) {
   }
 
   const normalized = normalizeIgnoredPath(filePath, cwd ?? process.cwd());
-  const files = normalizeConfigPatterns(config.files);
-  if (files.length > 0 && !files.some((pattern) => matchesConfigFilePattern(normalized, normalizeIgnoredPattern(pattern)))) {
+  const files = normalizeConfigFileSelectors(config.files);
+  if (files.length > 0 && !files.some((selector) => selector.every(
+    (pattern) => matchesConfigFilePattern(normalized, normalizeIgnoredPattern(pattern))
+  ))) {
     return false;
   }
 
@@ -3611,6 +3853,23 @@ function configAppliesToFile(config, filePath, cwd) {
   return !pathIgnoredByPatterns(normalized, ignores);
 }
 
+function normalizeConfigFileSelectors(patterns) {
+  if (!patterns) {
+    return [];
+  }
+  const values = Array.isArray(patterns) ? patterns : [patterns];
+  return values.flatMap((value) => {
+    if (typeof value === "string") {
+      return [[value]];
+    }
+    if (Array.isArray(value)) {
+      const selector = normalizeConfigPatterns(value);
+      return selector.length > 0 ? [selector] : [];
+    }
+    return [];
+  });
+}
+
 function normalizeConfigPatterns(patterns) {
   if (!patterns) {
     return [];
@@ -3633,7 +3892,7 @@ function configPathForOptions(options) {
   }
 
   const cwd = options.cwd ?? process.cwd();
-  return configPathFromDirectory(cwd);
+  return configPathFromDirectory(cwd, options);
 }
 
 function configPathForFile(options, filePath) {
@@ -3643,7 +3902,7 @@ function configPathForFile(options, filePath) {
   if (options.config) {
     return resolvePath(options.cwd ?? process.cwd(), options.config);
   }
-  return configPathFromDirectory(configSearchDirectoryForFile(filePath, options.cwd));
+  return configPathFromDirectory(configSearchDirectoryForFile(filePath, options.cwd), options);
 }
 
 function configSearchDirectoryForFile(filePath, cwd) {
@@ -3658,11 +3917,29 @@ function configSearchDirectoryForFile(filePath, cwd) {
   return dirname(absolute);
 }
 
-function configPathFromDirectory(directory) {
-  return findConfigPathFromDirectory(directory);
+function configPathFromDirectory(directory, options) {
+  return findConfigPathFromDirectory(directory, options[CONFIG_DISCOVERY_CACHE]);
 }
 
 function withTemporaryConfig(options, callback) {
+  if (options.nativeFlatConfigData !== undefined) {
+    const tmp = mkdtempSync(join(tmpdir(), "utoo-lint-flat-config-"));
+    const configPath = join(tmp, "utlint.config.json");
+    try {
+      writeFileSync(configPath, JSON.stringify(options.nativeFlatConfigData));
+      return callback({
+        ...options,
+        config: configPath,
+        noConfig: false,
+        baseConfig: undefined,
+        overrideConfig: undefined,
+        forceMaterializedConfig: true
+      });
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  }
+
   const fileConfigPath = !options.noConfig ? configPathForOptions(options) : undefined;
   const shouldMaterializeFileConfig = Boolean(fileConfigPath);
   const fileConfig = shouldMaterializeFileConfig
@@ -3672,7 +3949,15 @@ function withTemporaryConfig(options, callback) {
   const rules = shouldMaterializeFileConfig
     ? materializedRulesFromConfigs(...configs)
     : runtimeRulesFromConfigs(...configs);
-  if (Object.keys(rules).length === 0) {
+  const settings = configs.reduce(
+    (result, config) => ({
+      ...result,
+      ...(configDataFromConfig(config, options.filePath ?? options.filename, options.cwd).settings ?? {})
+    }),
+    {}
+  );
+  const hasSettings = Object.keys(settings).length > 0;
+  if (Object.keys(rules).length === 0 && !hasSettings) {
     if (shouldMaterializeFileConfig) {
       return callback({
         ...options,
@@ -3684,7 +3969,7 @@ function withTemporaryConfig(options, callback) {
   }
   const enabledRules = enabledRuleNamesFromConfigs(...configs);
   const hasExplicitOffRules = Object.values(rules).some((value) => ruleConfigSeverity(value) === 0);
-  if (!shouldMaterializeFileConfig && !hasRuleOptions(rules) && !hasExplicitOffRules && !options.forceMaterializedConfig) {
+  if (!shouldMaterializeFileConfig && !hasSettings && !hasRuleOptions(rules) && !hasExplicitOffRules && !options.forceMaterializedConfig) {
     return callback({
       ...options,
       config: shouldMaterializeFileConfig ? undefined : options.config,
@@ -3696,7 +3981,7 @@ function withTemporaryConfig(options, callback) {
   const tmp = mkdtempSync(join(tmpdir(), "utoo-lint-config-"));
   const configPath = join(tmp, "utlint.config.json");
   try {
-    writeFileSync(configPath, JSON.stringify({ rules }));
+    writeFileSync(configPath, JSON.stringify({ rules, ...(hasSettings ? { settings } : {}) }));
     return callback({
       ...options,
       config: shouldMaterializeFileConfig ? configPath : options.config ?? configPath,
@@ -3715,11 +4000,7 @@ function enabledRuleNames(rules) {
 }
 
 function runtimeRulesFromConfigs(...configs) {
-  const rules = {};
-  for (const config of configs) {
-    Object.assign(rules, runtimeRulesFromConfig(config));
-  }
-  return rules;
+  return mergeRuleConfigMaps(...configs.map(runtimeRulesFromConfig));
 }
 
 function materializedRulesFromConfigs(...configs) {
@@ -3731,10 +4012,10 @@ function runtimeRulesFromConfig(config) {
     return {};
   }
   if (Array.isArray(config)) {
-    return config.reduce((rules, entry) => ({
-      ...rules,
-      ...runtimeRulesFromConfig(entry)
-    }), {});
+    return config.reduce(
+      (rules, entry) => mergeRuleConfigMaps(rules, runtimeRulesFromConfig(entry)),
+      {}
+    );
   }
 
   const rules = {};
@@ -3744,6 +4025,26 @@ function runtimeRulesFromConfig(config) {
   return rules;
 }
 
+function mergeRuleConfigMaps(...ruleMaps) {
+  const result = {};
+  for (const rules of ruleMaps) {
+    for (const [ruleId, ruleConfig] of Object.entries(rules ?? {})) {
+      const previous = result[ruleId];
+      if (previous !== undefined && isSeverityOnlyRuleConfig(ruleConfig) && Array.isArray(previous) && previous.length > 1) {
+        const severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
+        result[ruleId] = [severity, ...previous.slice(1)];
+      } else {
+        result[ruleId] = ruleConfig;
+      }
+    }
+  }
+  return result;
+}
+
+function isSeverityOnlyRuleConfig(ruleConfig) {
+  return !Array.isArray(ruleConfig) || ruleConfig.length === 1;
+}
+
 function enabledRuleNamesFromConfigs(...configs) {
   const rules = new Set();
   for (const config of configs) {
@@ -3825,12 +4126,38 @@ function reportToESLintResults(report, textOptions = {}) {
   }
 
   for (const result of byFile.values()) {
+    applyCompatibilityDisableDirectives(result, textOptions);
     finalizeESLintResult(result);
   }
 
   return [...byFile.values()];
 }
 
+function applyCompatibilityDisableDirectives(result, textOptions) {
+  if (result.messages.length === 0) {
+    return;
+  }
+
+  let source = result.source;
+  if (typeof source !== "string" && textOptions.filePath === result.filePath) {
+    source = textOptions.source;
+  }
+  if (typeof source !== "string") {
+    try {
+      source = readFileSync(result.filePath, "utf8");
+    } catch {
+      return;
+    }
+  }
+  if (!source.includes("eslint-")) {
+    return;
+  }
+
+  const filtered = applyDisableDirectives(result.messages, createLinterSourceCode(source));
+  result.messages = filtered.messages;
+  result.suppressedMessages.push(...filtered.suppressedMessages);
+}
+
 function normalizeReportDiagnostics(diagnostics, options = {}) {
   return (diagnostics ?? []).flatMap((diagnostic) => {
     if (!diagnostic?.ruleId) {
@@ -4058,7 +4385,7 @@ function collectGlobFiles(target, cwd, patterns, expression, files) {
 
     const child = join(target, entry.name);
     if (entry.isDirectory()) {
-      if (!pathIgnoredByPatterns(normalizeIgnoredPath(child, cwd), patterns)) {
+      if (shouldTraverseDirectory(normalizeIgnoredPath(child, cwd), patterns)) {
         collectGlobFiles(child, cwd, patterns, expression, files);
       }
       continue;
@@ -4128,7 +4455,7 @@ function expandLintTarget(target, cwd, patterns) {
   if (stat.isFile()) {
     return isLintableFilePath(target) && !pathIgnoredByPatterns(normalizeIgnoredPath(target, cwd), patterns) ? [target] : [];
   }
-  if (!stat.isDirectory() || pathIgnoredByPatterns(normalizeIgnoredPath(target, cwd), patterns)) {
+  if (!stat.isDirectory() || !shouldTraverseDirectory(normalizeIgnoredPath(target, cwd), patterns)) {
     return [];
   }
 
@@ -4146,7 +4473,7 @@ function collectLintableFiles(target, cwd, patterns, files) {
 
     const child = join(target, entry.name);
     if (entry.isDirectory()) {
-      if (!pathIgnoredByPatterns(normalizeIgnoredPath(child, cwd), patterns)) {
+      if (shouldTraverseDirectory(normalizeIgnoredPath(child, cwd), patterns)) {
         collectLintableFiles(child, cwd, patterns, files);
       }
       continue;
@@ -4279,7 +4606,7 @@ function normalizeIgnoredPath(filePath, cwd) {
 }
 
 function normalizeIgnoredPattern(pattern) {
-  return normalizePath(pattern.replace(/^!/, "").replace(/^\//, "")).replace(/\/+$/, "");
+  return normalizePath(pattern.replace(/^!/, "")).replace(/\/+$/, "");
 }
 
 function pathIgnoredByPatterns(target, patterns) {
@@ -4293,10 +4620,55 @@ function pathIgnoredByPatterns(target, patterns) {
   return ignored;
 }
 
+function shouldTraverseDirectory(target, patterns) {
+  return !pathIgnoredByPatterns(target, patterns) || patterns.some(
+    (pattern) => pattern.startsWith("!") && negatedPatternMayMatchDescendant(target, pattern)
+  );
+}
+
+function negatedPatternMayMatchDescendant(target, pattern) {
+  pattern = normalizeIgnoredPattern(pattern);
+  if (pattern.startsWith("/")) {
+    pattern = pattern.slice(1);
+    if (target.startsWith("/")) {
+      target = target.slice(1);
+    }
+  }
+  if (!pattern.includes("/")) {
+    return true;
+  }
+
+  const directoryPattern = pattern.slice(0, pattern.lastIndexOf("/"));
+  if (hasGlobSyntax(directoryPattern)) {
+    const directoryExpression = new RegExp(`^${globPatternRegExpSource(directoryPattern)}(?:/.*)?$`);
+    if (directoryExpression.test(target)) {
+      return true;
+    }
+  }
+
+  const globIndex = pattern.search(/[*?[{]/u);
+  const staticPrefix = (globIndex === -1 ? pattern : pattern.slice(0, globIndex)).replace(/\/+$/u, "");
+  return !staticPrefix ||
+    staticPrefix === target ||
+    staticPrefix.startsWith(`${target}/`) ||
+    target.startsWith(`${staticPrefix}/`);
+}
+
 function matchesIgnorePattern(target, pattern) {
+  const anchored = pattern.startsWith("/");
+  if (anchored) {
+    pattern = pattern.slice(1);
+    if (target.startsWith("/")) {
+      target = target.slice(1);
+    }
+  }
   if (pattern.endsWith("/**")) {
-    const prefix = pattern.slice(0, -3);
-    return target === prefix || target.startsWith(`${prefix}/`) || target.includes(`/${prefix}/`);
+    const directoryPattern = pattern.slice(0, -3);
+    if (hasGlobSyntax(directoryPattern)) {
+      const expression = new RegExp(`^${globPatternRegExpSource(directoryPattern)}(?:/.*)?$`);
+      return expression.test(target);
+    }
+    return target === directoryPattern || target.startsWith(`${directoryPattern}/`);
   }
   if (pattern.startsWith("**/")) {
     const suffix = pattern.slice(3);
@@ -4305,10 +4677,14 @@ function matchesIgnorePattern(target, pattern) {
     }
   }
   if (!hasGlobSyntax(pattern)) {
+    if (anchored || pattern.includes("/")) {
+      return target === pattern || target.startsWith(`${pattern}/`);
+    }
     return target === pattern || target.endsWith(`/${pattern}`) || target.startsWith(`${pattern}/`);
   }
 
-  const expression = new RegExp(`(^|/)${globPatternRegExpSource(pattern)}$`);
+  const prefix = anchored || pattern.includes("/") ? "^" : "(^|/)";
+  const expression = new RegExp(`${prefix}${globPatternRegExpSource(pattern)}$`);
   return expression.test(target);
 }
 
@@ -4417,6 +4793,9 @@ function ruleMetaForRuleId(ruleId) {
   if (FIXABLE_BUILTIN_RULE_IDS.has(ruleId)) {
     meta.fixable = "code";
   }
+  if (SUGGESTION_BUILTIN_RULE_IDS.has(ruleId)) {
+    meta.hasSuggestions = true;
+  }
   return meta;
 }
 
@@ -4507,16 +4886,33 @@ function diagnosticToESLintMessage(diagnostic, ruleSeverities) {
   if (fixes.length > 0) {
     message.fix = fixes.length === 1 ? fixes[0] : fixes;
   }
+  const suggestions = (diagnostic.suggestions ?? []).map((suggestion) => {
+    const suggestionFixes = (suggestion.fix ?? []).map((fix) => ({
+      range: fix.range,
+      text: fix.text
+    }));
+    return {
+      desc: suggestion.desc,
+      ...(suggestionFixes.length === 0 ? {} : {
+        fix: suggestionFixes.length === 1 ? suggestionFixes[0] : suggestionFixes
+      })
+    };
+  });
+  if (suggestions.length > 0) {
+    message.suggestions = suggestions;
+  }
   return message;
 }
 
 function suppressedDiagnosticToESLintMessage(diagnostic, ruleSeverities) {
   return {
     ...diagnosticToESLintMessage(diagnostic, ruleSeverities),
-    suppressions: [{
-      kind: diagnostic.suppression?.kind ?? "directive",
-      justification: diagnostic.suppression?.justification ?? ""
-    }]
+    suppressions: diagnostic.suppressions?.length > 0
+      ? diagnostic.suppressions
+      : [{
+          kind: diagnostic.suppression?.kind ?? "directive",
+          justification: diagnostic.suppression?.justification ?? ""
+        }]
   };
 }