@utoo/lint 0.2.9 → 0.3.4

package/configs/frontend.json

@@ -1,5 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/utooland/utoo-lint/main/npm/utoo-lint/schema.json",
+  "files": ["src/**/*.{js,jsx,ts,tsx}"],
+  "ignores": ["dist", "coverage", "node_modules"],
   "rules": {
     "no-debugger": "error",
     "no-alert": "error",
@@ -12,21 +14,34 @@
     "no-constant-condition": "error",
     "no-dupe-keys": "error",
     "no-duplicate-imports": "error",
+    "no-script-url": "error",
     "import/first": "error",
     "import/newline-after-import": "warn",
     "import/no-duplicates": "error",
     "import/no-self-import": "error",
+    "promise/no-nesting": "error",
+    "react-hooks/rules-of-hooks": "error",
+    "react-hooks/exhaustive-deps": "warn",
     "react/jsx-no-duplicate-props": "error",
+    "react/jsx-key": "error",
     "react/jsx-no-target-blank": "error",
     "react/jsx-pascal-case": "warn",
+    "react/no-array-index-key": "warn",
+    "react/no-children-prop": "error",
     "react/no-danger": "warn",
+    "react/no-danger-with-children": "error",
     "react/no-find-dom-node": "error",
+    "react/no-forward-ref": "warn",
+    "react/no-unstable-nested-components": "warn",
     "react/no-unescaped-entities": "error",
+    "react/void-dom-elements-no-children": "error",
     "jsx-a11y/aria-props": "error",
     "jsx-a11y/aria-unsupported-elements": "error",
     "jsx-a11y/iframe-has-title": "error",
     "jsx-a11y/img-redundant-alt": "warn",
     "jsx-a11y/no-access-key": "error",
+    "unused-imports/no-unused-imports": "warn",
+    "@typescript-eslint/ban-types": "warn",
     "@typescript-eslint/no-unused-vars": "warn",
     "@typescript-eslint/no-use-before-define": "error",
     "@typescript-eslint/no-shadow": "error",

package/index.cjs

@@ -77,6 +77,7 @@ const BUILTIN_RULE_IDS = [
   "block-scoped-var",
   "camelcase",
   "capitalized-comments",
+  "class-methods-use-this",
   "complexity",
   "consistent-return",
   "consistent-this",
@@ -168,6 +169,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",
@@ -176,6 +178,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",
@@ -234,6 +237,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",
@@ -244,6 +249,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",
@@ -305,6 +311,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",
@@ -349,9 +368,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",
@@ -449,10 +471,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)]));
 
 class UtooLint {
@@ -692,6 +719,20 @@ 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;
+}
+
 function run(args = [], options = {}) {
   const cliArgs = normalizeStringArray(args, "args");
   const env = options.env ? { ...process.env, ...options.env } : process.env;
@@ -702,7 +743,8 @@ function run(args = [], options = {}) {
     env,
     encoding: options.encoding ?? "utf8",
     input: options.input,
-    stdio: options.stdio
+    stdio: options.stdio,
+    maxBuffer: nativeMaxBuffer(options, env)
   });
 }
 
@@ -844,8 +886,9 @@ 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);
@@ -953,7 +996,8 @@ function runFishlint(args = [], options = {}) {
     env,
     encoding: options.encoding ?? "utf8",
     input: options.input,
-    stdio: options.stdio
+    stdio: options.stdio,
+    maxBuffer: nativeMaxBuffer(options, env)
   });
 }
 
@@ -1155,9 +1199,13 @@ function booleanFlagValue(arg) {
 
 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) };
   }
@@ -1247,13 +1295,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);
   }
@@ -1283,7 +1333,10 @@ 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
       }
     };
@@ -1512,12 +1565,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)
+    )
   };
 }
 
@@ -1612,10 +1665,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 {};
@@ -1668,12 +1721,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;
@@ -1697,8 +1802,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;
   }
 
@@ -1706,6 +1813,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 [];
@@ -1767,7 +1891,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,
@@ -1779,7 +1911,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,
@@ -1791,7 +1923,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,
@@ -1810,11 +1942,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) {
@@ -1826,10 +1954,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 = {};
@@ -1839,6 +1967,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) {
@@ -2028,7 +2176,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;
     }
@@ -2085,19 +2233,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));
@@ -3398,10 +3533,7 @@ function mergeRuleTesterConfig(baseConfig, overrideConfig) {
   return {
     ...baseConfig,
     ...overrideConfig,
-    rules: {
-      ...(baseConfig.rules ?? {}),
-      ...(overrideConfig.rules ?? {})
-    }
+    rules: mergeRuleConfigMaps(baseConfig.rules, overrideConfig.rules)
   };
 }
 
@@ -4055,7 +4187,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;
@@ -4125,7 +4257,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 [];
   }
 
@@ -4143,7 +4275,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;
@@ -4276,7 +4408,7 @@ function normalizeIgnoredPath(filePath, cwd) {
 }
 
 function normalizeIgnoredPattern(pattern) {
-  return normalizePath(pattern.replace(/^!/, "").replace(/^\//, "")).replace(/\/+$/, "");
+  return normalizePath(pattern.replace(/^!/, "")).replace(/\/+$/, "");
 }
 
 function pathIgnoredByPatterns(target, patterns) {
@@ -4290,10 +4422,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);
@@ -4302,10 +4479,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);
 }
 
@@ -4414,6 +4595,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;
 }
 
@@ -4504,6 +4688,21 @@ 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;
 }
 

package/index.d.ts

@@ -67,13 +67,24 @@ export interface PluginObject {
   [key: string]: unknown;
 }
 
+export interface JestPluginSettings {
+  version?: string | number;
+  globalAliases?: Record<string, string[]>;
+  [key: string]: unknown;
+}
+
+export interface SharedSettings {
+  jest?: JestPluginSettings;
+  [key: string]: unknown;
+}
+
 export interface ConfigObject {
   name?: string;
   files?: Array<string | string[]>;
   ignores?: string[];
   rules?: Record<string, RuleConfig>;
   plugins?: Record<string, PluginObject>;
-  settings?: Record<string, unknown>;
+  settings?: SharedSettings;
   languageOptions?: {
     parser?: unknown;
     parserOptions?: Record<string, unknown>;
@@ -93,6 +104,8 @@ export interface LintOptions {
   cwd?: string;
   binary?: string;
   env?: Record<string, string | undefined>;
+  /** Maximum bytes captured from each native stdout/stderr stream. Defaults to 64 MiB. */
+  maxBuffer?: number;
   threads?: number;
   rules?: string[] | string;
   format?: "text" | "json" | string;