@utoo/lint 0.2.9 → 0.3.4

package/index.js

@@ -80,6 +80,7 @@ const BUILTIN_RULE_IDS = [
   "block-scoped-var",
   "camelcase",
   "capitalized-comments",
+  "class-methods-use-this",
   "complexity",
   "consistent-return",
   "consistent-this",
@@ -171,6 +172,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 +181,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 +240,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 +252,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 +314,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 +371,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 +474,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 {
@@ -765,7 +792,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 +849,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));
@@ -2135,10 +2149,7 @@ function mergeRuleTesterConfig(baseConfig, overrideConfig) {
   return {
     ...baseConfig,
     ...overrideConfig,
-    rules: {
-      ...(baseConfig.rules ?? {}),
-      ...(overrideConfig.rules ?? {})
-    }
+    rules: mergeRuleConfigMaps(baseConfig.rules, overrideConfig.rules)
   };
 }
 
@@ -2597,6 +2608,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 +2632,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 +2775,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 +2885,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,9 +3088,13 @@ 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) };
   }
@@ -3152,13 +3184,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);
   }
@@ -3188,7 +3222,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
       }
     };
@@ -3417,12 +3454,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 +3554,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 +3610,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 +3691,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 +3702,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 [];
@@ -3672,7 +3780,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 +3800,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 +3812,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 +3831,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 +3843,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 +3856,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) {
@@ -4058,7 +4190,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 +4260,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 +4278,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 +4411,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 +4425,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 +4482,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 +4598,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,6 +4691,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/lint",
-  "version": "0.2.9",
+  "version": "0.3.4",
   "description": "High-performance JavaScript and TypeScript linter powered by Yuku",
   "license": "MIT",
   "repository": {
@@ -76,13 +76,15 @@
     "use-at-your-own-risk.js"
   ],
   "optionalDependencies": {
-    "@utoo/lint-darwin-arm64": "0.2.9",
-    "@utoo/lint-darwin-x64": "0.2.9",
-    "@utoo/lint-linux-arm64": "0.2.9",
-    "@utoo/lint-linux-x64": "0.2.9",
-    "@utoo/lint-win32-x64": "0.2.9"
+    "@utoo/lint-darwin-arm64": "0.3.4",
+    "@utoo/lint-darwin-x64": "0.3.4",
+    "@utoo/lint-linux-arm64": "0.3.4",
+    "@utoo/lint-linux-x64": "0.3.4",
+    "@utoo/lint-win32-x64": "0.3.4"
   },
   "dependencies": {
+    "@eslint/eslintrc": "2.1.4",
+    "@eslint/js": "8.57.1",
     "jiti": "2.7.0"
   },
   "publishConfig": {

package/schema.json

@@ -28,6 +28,35 @@
             "$ref": "#/definitions/ruleSeverity"
           }
         },
+        "settings": {
+          "description": "Shared plugin settings.",
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "jest": {
+              "type": "object",
+              "additionalProperties": true,
+              "properties": {
+                "version": {
+                  "description": "Jest version used by version-aware Jest rules.",
+                  "oneOf": [
+                    { "type": "integer", "minimum": 1 },
+                    { "type": "string", "pattern": "^[0-9]+(?:\\..*)?$" }
+                  ]
+                },
+                "globalAliases": {
+                  "description": "Additional global aliases for canonical Jest functions.",
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "array",
+                    "items": { "type": "string", "minLength": 1 },
+                    "uniqueItems": true
+                  }
+                }
+              }
+            }
+          }
+        },
         "files": {
           "description": "File globs this config entry applies to.",
           "oneOf": [
@@ -37,7 +66,18 @@
             {
               "type": "array",
               "items": {
-                "type": "string"
+                "oneOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    },
+                    "minItems": 1
+                  }
+                ]
               }
             }
           ]