@utoo/lint 0.4.0 → 0.4.1

package/README.md

@@ -144,7 +144,8 @@ With utoo, run these scripts as `ut lint` and `ut lint:fix`.
 | Select rules for one run | `utx @utoo/lint --rules=no-debugger,no-unused-vars src` |
 | Use an explicit config | `utx @utoo/lint --config=utlint.config.json src` |
 
-Run `utx @utoo/lint --help` for all CLI options.
+Run `utx @utoo/lint --help` for all CLI options. Once the package is installed,
+`utlint` is a shorter alias for the `utoo-lint` command.
 
 ## Configuration
 
@@ -218,8 +219,12 @@ utx @utoo/lint migrate eslint \
   --output utlint.config.json
 ```
 
-The package also exposes `eslint` and `fishlint` compatibility commands for
-incremental replacement workflows. See the
+The package registers only the `utoo-lint` and `utlint` commands. For
+incremental replacement workflows it also ships an ESLint CLI wrapper at
+`@utoo/lint/bin/eslint.js` and a fishlint compatibility CLI at
+`@utoo/lint/bin/fishlint.js`. Neither is registered as a bin, so installing
+`@utoo/lint` never changes what existing `eslint` or `fishlint` scripts run;
+opt in per script instead. See the
 [migration guide](https://github.com/utooland/utoo-lint/blob/main/docs/eslint-migration.md)
 for supported mappings and known differences.
 

package/bin/eslint.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+// ESLint CLI compatibility wrapper. It is deliberately not registered as an
+// `eslint` bin: installing @utoo/lint must never change which tool an
+// existing `eslint` script runs. Scripts opt in explicitly, for example
+// `node node_modules/@utoo/lint/bin/eslint.js src`.
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 

package/index.cjs

@@ -6,6 +6,7 @@ const { dirname, extname, isAbsolute, join, relative, resolve: resolvePath } = r
 
 const { platformPackageName, resolveBinary } = require("./lib/binary.cjs");
 const { createLegacyConfigResolver } = require("./lib/legacy-config.cjs");
+const { nativeFlatConfigEntries, nativeRules } = require("./lib/native-rule-options.cjs");
 const { formatESLintResults } = require("./lib/stylish-formatter.cjs");
 const {
   findConfigPath: findConfigPathFromDirectory,
@@ -1480,11 +1481,28 @@ function nativeFlatConfigOptions(options) {
   };
 }
 
+// Globals declared by a config entry, merged the way ESLint does: flat
+// `languageOptions.globals` wins over eslintrc-style `globals`.
+function nativeConfigGlobals(config) {
+  if (!config || typeof config !== "object") {
+    return undefined;
+  }
+  const globals = {
+    ...(isGlobalsObject(config.globals) ? config.globals : {}),
+    ...(isGlobalsObject(config.languageOptions?.globals) ? config.languageOptions.globals : {})
+  };
+  return Object.keys(globals).length > 0 ? globals : undefined;
+}
+
+function isGlobalsObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 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) {
+    if (!entry || typeof entry !== "object" || Object.keys(entry.settings ?? {}).length > 0 || nativeConfigGlobals(entry)) {
       return false;
     }
     for (const ruleConfig of Object.values(entry.rules ?? {})) {
@@ -1507,11 +1525,16 @@ function nativeSerializableConfig(config) {
   if (!config || typeof config !== "object") {
     return config;
   }
-  return Object.fromEntries(
+  const serialized = Object.fromEntries(
     ["$schema", "name", "files", "ignores", "rules", "settings"]
       .filter((key) => config[key] !== undefined)
       .map((key) => [key, config[key]])
   );
+  const globals = nativeConfigGlobals(config);
+  if (globals) {
+    serialized.languageOptions = { globals };
+  }
+  return serialized;
 }
 
 function expandNativeConfigRunPaths(paths, options) {
@@ -1590,15 +1613,16 @@ function nativeConfigRunsForFiles(paths, options) {
     const calculated = configured ? calculatedConfig({ ...options, rules: undefined }, matchPath) : {};
     let rules = calculated.rules;
     const settings = calculated.settings;
+    const globals = configured ? nativeConfigGlobals(calculated) : undefined;
     if (configured && options.rules) {
       rules = selectedRulesWithConfigOptions(rules, options.rules);
     }
     if (configured) {
       rules = withoutJsPluginRules(rules, jsPluginRuleIdsForOptions(options, matchPath));
     }
-    const signature = configured ? stableConfigSignature({ rules, settings }) : "<native-defaults>";
+    const signature = configured ? stableConfigSignature({ rules, settings, globals }) : "<native-defaults>";
     if (!groups.has(signature)) {
-      groups.set(signature, { paths: [], rules, settings, configured });
+      groups.set(signature, { paths: [], rules, settings, globals, configured });
     }
     groups.get(signature).paths.push(filePath);
   }
@@ -1621,7 +1645,7 @@ function nativeConfigRunsForFiles(paths, options) {
       };
     }
 
-    const selectedRules = severityOnlyNativeRuleNames(group.rules, group.settings);
+    const selectedRules = severityOnlyNativeRuleNames(group.rules, group.settings, group.globals);
     if (selectedRules) {
       return {
         paths: group.paths,
@@ -1646,7 +1670,8 @@ function nativeConfigRunsForFiles(paths, options) {
         baseConfig: undefined,
         overrideConfig: {
           rules: allDisabledNativeRules(group.rules),
-          ...(group.settings ? { settings: group.settings } : {})
+          ...(group.settings ? { settings: group.settings } : {}),
+          ...(group.globals ? { languageOptions: { globals: group.globals } } : {})
         },
         forceMaterializedConfig: true
       }
@@ -1654,8 +1679,8 @@ function nativeConfigRunsForFiles(paths, options) {
   });
 }
 
-function severityOnlyNativeRuleNames(rules, settings) {
-  if (Object.keys(settings ?? {}).length > 0) {
+function severityOnlyNativeRuleNames(rules, settings, globals) {
+  if (globals || Object.keys(settings ?? {}).length > 0) {
     return undefined;
   }
 
@@ -1979,6 +2004,10 @@ function mergeConfigData(base, override) {
   }
   if (base.languageOptions || override.languageOptions) {
     result.languageOptions = { ...(base.languageOptions ?? {}), ...(override.languageOptions ?? {}) };
+    // ESLint merges `languageOptions.globals` per name across config objects.
+    if (isGlobalsObject(base.languageOptions?.globals) && isGlobalsObject(override.languageOptions?.globals)) {
+      result.languageOptions.globals = { ...base.languageOptions.globals, ...override.languageOptions.globals };
+    }
   }
   if (base.parserOptions || override.parserOptions) {
     result.parserOptions = { ...(base.parserOptions ?? {}), ...(override.parserOptions ?? {}) };
@@ -2274,7 +2303,7 @@ function withTemporaryConfig(options, callback) {
     const tmp = mkdtempSync(join(tmpdir(), "utoo-lint-flat-config-"));
     const configPath = join(tmp, "utlint.config.json");
     try {
-      writeFileSync(configPath, JSON.stringify(options.nativeFlatConfigData));
+      writeFileSync(configPath, JSON.stringify(nativeFlatConfigEntries(options.nativeFlatConfigData)));
       return callback({
         ...options,
         config: configPath,
@@ -2307,7 +2336,15 @@ function withTemporaryConfig(options, callback) {
     {}
   );
   const hasSettings = Object.keys(settings).length > 0;
-  if (Object.keys(rules).length === 0 && !hasSettings) {
+  const globals = configs.reduce(
+    (result, config) => ({
+      ...result,
+      ...(nativeConfigGlobals(configDataFromConfig(config, options.filePath ?? options.filename, options.cwd)) ?? {})
+    }),
+    {}
+  );
+  const hasGlobals = Object.keys(globals).length > 0;
+  if (Object.keys(rules).length === 0 && !hasSettings && !hasGlobals) {
     if (shouldMaterializeFileConfig) {
       return callback({
         ...options,
@@ -2319,7 +2356,7 @@ function withTemporaryConfig(options, callback) {
   }
   const enabledRules = enabledRuleNamesFromConfigs(...configs).filter((rule) => !jsPluginRuleIds.has(rule));
   const hasExplicitOffRules = Object.values(rules).some((value) => ruleConfigSeverity(value) === 0);
-  if (!shouldMaterializeFileConfig && !hasSettings && !hasRuleOptions(rules) && !hasExplicitOffRules && !options.forceMaterializedConfig) {
+  if (!shouldMaterializeFileConfig && !hasSettings && !hasGlobals && !hasRuleOptions(rules) && !hasExplicitOffRules && !options.forceMaterializedConfig) {
     return callback({
       ...options,
       config: shouldMaterializeFileConfig ? undefined : options.config,
@@ -2331,7 +2368,11 @@ 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, ...(hasSettings ? { settings } : {}) }));
+    writeFileSync(configPath, JSON.stringify({
+      rules: nativeRules(rules),
+      ...(hasSettings ? { settings } : {}),
+      ...(hasGlobals ? { languageOptions: { globals } } : {})
+    }));
     return callback({
       ...options,
       config: shouldMaterializeFileConfig ? configPath : options.config ?? configPath,

package/index.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 
 import { resolveBinary } from "./lib/binary.js";
 import { createLegacyConfigResolver } from "./lib/legacy-config.cjs";
+import { nativeFlatConfigEntries, nativeRules } from "./lib/native-rule-options.cjs";
 import { formatESLintResults } from "./lib/stylish-formatter.cjs";
 import {
   findConfigPath as findConfigPathFromDirectory,
@@ -3528,11 +3529,28 @@ function nativeFlatConfigOptions(options) {
   };
 }
 
+// Globals declared by a config entry, merged the way ESLint does: flat
+// `languageOptions.globals` wins over eslintrc-style `globals`.
+function nativeConfigGlobals(config) {
+  if (!config || typeof config !== "object") {
+    return undefined;
+  }
+  const globals = {
+    ...(isGlobalsObject(config.globals) ? config.globals : {}),
+    ...(isGlobalsObject(config.languageOptions?.globals) ? config.languageOptions.globals : {})
+  };
+  return Object.keys(globals).length > 0 ? globals : undefined;
+}
+
+function isGlobalsObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 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) {
+    if (!entry || typeof entry !== "object" || Object.keys(entry.settings ?? {}).length > 0 || nativeConfigGlobals(entry)) {
       return false;
     }
     for (const ruleConfig of Object.values(entry.rules ?? {})) {
@@ -3555,11 +3573,16 @@ function nativeSerializableConfig(config) {
   if (!config || typeof config !== "object") {
     return config;
   }
-  return Object.fromEntries(
+  const serialized = Object.fromEntries(
     ["$schema", "name", "files", "ignores", "rules", "settings"]
       .filter((key) => config[key] !== undefined)
       .map((key) => [key, config[key]])
   );
+  const globals = nativeConfigGlobals(config);
+  if (globals) {
+    serialized.languageOptions = { globals };
+  }
+  return serialized;
 }
 
 function expandNativeConfigRunPaths(paths, options) {
@@ -3638,15 +3661,16 @@ function nativeConfigRunsForFiles(paths, options) {
     const calculated = configured ? calculatedConfig({ ...options, rules: undefined }, matchPath) : {};
     let rules = calculated.rules;
     const settings = calculated.settings;
+    const globals = configured ? nativeConfigGlobals(calculated) : undefined;
     if (configured && options.rules) {
       rules = selectedRulesWithConfigOptions(rules, options.rules);
     }
     if (configured) {
       rules = withoutJsPluginRules(rules, jsPluginRuleIdsForOptions(options, matchPath));
     }
-    const signature = configured ? stableConfigSignature({ rules, settings }) : "<native-defaults>";
+    const signature = configured ? stableConfigSignature({ rules, settings, globals }) : "<native-defaults>";
     if (!groups.has(signature)) {
-      groups.set(signature, { paths: [], rules, settings, configured });
+      groups.set(signature, { paths: [], rules, settings, globals, configured });
     }
     groups.get(signature).paths.push(filePath);
   }
@@ -3669,7 +3693,7 @@ function nativeConfigRunsForFiles(paths, options) {
       };
     }
 
-    const selectedRules = severityOnlyNativeRuleNames(group.rules, group.settings);
+    const selectedRules = severityOnlyNativeRuleNames(group.rules, group.settings, group.globals);
     if (selectedRules) {
       return {
         paths: group.paths,
@@ -3694,7 +3718,8 @@ function nativeConfigRunsForFiles(paths, options) {
         baseConfig: undefined,
         overrideConfig: {
           rules: allDisabledNativeRules(group.rules),
-          ...(group.settings ? { settings: group.settings } : {})
+          ...(group.settings ? { settings: group.settings } : {}),
+          ...(group.globals ? { languageOptions: { globals: group.globals } } : {})
         },
         forceMaterializedConfig: true
       }
@@ -3702,8 +3727,8 @@ function nativeConfigRunsForFiles(paths, options) {
   });
 }
 
-function severityOnlyNativeRuleNames(rules, settings) {
-  if (Object.keys(settings ?? {}).length > 0) {
+function severityOnlyNativeRuleNames(rules, settings, globals) {
+  if (globals || Object.keys(settings ?? {}).length > 0) {
     return undefined;
   }
 
@@ -4027,6 +4052,10 @@ function mergeConfigData(base, override) {
   }
   if (base.languageOptions || override.languageOptions) {
     result.languageOptions = { ...(base.languageOptions ?? {}), ...(override.languageOptions ?? {}) };
+    // ESLint merges `languageOptions.globals` per name across config objects.
+    if (isGlobalsObject(base.languageOptions?.globals) && isGlobalsObject(override.languageOptions?.globals)) {
+      result.languageOptions.globals = { ...base.languageOptions.globals, ...override.languageOptions.globals };
+    }
   }
   if (base.parserOptions || override.parserOptions) {
     result.parserOptions = { ...(base.parserOptions ?? {}), ...(override.parserOptions ?? {}) };
@@ -4322,7 +4351,7 @@ function withTemporaryConfig(options, callback) {
     const tmp = mkdtempSync(join(tmpdir(), "utoo-lint-flat-config-"));
     const configPath = join(tmp, "utlint.config.json");
     try {
-      writeFileSync(configPath, JSON.stringify(options.nativeFlatConfigData));
+      writeFileSync(configPath, JSON.stringify(nativeFlatConfigEntries(options.nativeFlatConfigData)));
       return callback({
         ...options,
         config: configPath,
@@ -4355,7 +4384,15 @@ function withTemporaryConfig(options, callback) {
     {}
   );
   const hasSettings = Object.keys(settings).length > 0;
-  if (Object.keys(rules).length === 0 && !hasSettings) {
+  const globals = configs.reduce(
+    (result, config) => ({
+      ...result,
+      ...(nativeConfigGlobals(configDataFromConfig(config, options.filePath ?? options.filename, options.cwd)) ?? {})
+    }),
+    {}
+  );
+  const hasGlobals = Object.keys(globals).length > 0;
+  if (Object.keys(rules).length === 0 && !hasSettings && !hasGlobals) {
     if (shouldMaterializeFileConfig) {
       return callback({
         ...options,
@@ -4367,7 +4404,7 @@ function withTemporaryConfig(options, callback) {
   }
   const enabledRules = enabledRuleNamesFromConfigs(...configs).filter((rule) => !jsPluginRuleIds.has(rule));
   const hasExplicitOffRules = Object.values(rules).some((value) => ruleConfigSeverity(value) === 0);
-  if (!shouldMaterializeFileConfig && !hasSettings && !hasRuleOptions(rules) && !hasExplicitOffRules && !options.forceMaterializedConfig) {
+  if (!shouldMaterializeFileConfig && !hasSettings && !hasGlobals && !hasRuleOptions(rules) && !hasExplicitOffRules && !options.forceMaterializedConfig) {
     return callback({
       ...options,
       config: shouldMaterializeFileConfig ? undefined : options.config,
@@ -4379,7 +4416,11 @@ 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, ...(hasSettings ? { settings } : {}) }));
+    writeFileSync(configPath, JSON.stringify({
+      rules: nativeRules(rules),
+      ...(hasSettings ? { settings } : {}),
+      ...(hasGlobals ? { languageOptions: { globals } } : {})
+    }));
     return callback({
       ...options,
       config: shouldMaterializeFileConfig ? configPath : options.config ?? configPath,

package/lib/load-config.js

@@ -2,6 +2,8 @@ import { dirname } from "node:path";
 import { writeFileSync } from "node:fs";
 import { createJiti } from "jiti";
 
+import { nativeRules } from "./native-rule-options.cjs";
+
 const configPath = process.argv[2];
 
 // Config modules may mount live ESLint plugin objects, which contain functions
@@ -59,7 +61,12 @@ function serializable(value, seen = new WeakSet()) {
         result.plugins = serializablePlugins(item, seen);
         continue;
       }
-      const serialized = serializable(item, seen);
+      // Rule options such as `maxDepth: Infinity` have a JSON spelling the
+      // native binary understands; rewrite them before Infinity becomes null.
+      // Other non-finite values stay null here because this loader cannot
+      // tell native rules from plugin rules; the wrapper reports the native
+      // ones with the rule and option name.
+      const serialized = serializable(key === "rules" ? nativeRules(item, { strict: false }) : item, seen);
       if (serialized !== undefined) {
         result[key] = serialized;
       }

package/lib/native-rule-options.cjs

@@ -0,0 +1,99 @@
+"use strict";
+
+// JSON has no representation for Infinity or NaN, so JSON.stringify turns them
+// into null and the native binary rejects the rule option with an opaque
+// UnsupportedRuleConfigValue error. Options with a documented unlimited
+// spelling are rewritten to it. Anything else fails with a message that names
+// the rule and option, or becomes null again in lenient mode (used by the
+// config loader subprocess, which cannot tell native rules from plugin rules).
+const UNLIMITED = "∞";
+const INFINITE_OPTION_SPELLINGS = {
+  "import/no-cycle": { maxDepth: UNLIMITED }
+};
+
+function nativeRuleConfig(ruleId, ruleConfig, options = {}) {
+  if (!Array.isArray(ruleConfig)) {
+    return ruleConfig;
+  }
+  const strict = options.strict !== false;
+  const spellings = INFINITE_OPTION_SPELLINGS[ruleId] ?? {};
+  return ruleConfig.map((item, index) => {
+    if (index === 0) {
+      return item;
+    }
+    if (!isPlainObject(item)) {
+      return nativeRuleOptionValue(ruleId, item, `[${index}]`, strict);
+    }
+    const seen = new WeakSet([item]);
+    return Object.fromEntries(
+      Object.entries(item).map(([key, value]) => [
+        key,
+        value === Infinity && Object.hasOwn(spellings, key)
+          ? spellings[key]
+          : nativeRuleOptionValue(ruleId, value, key, strict, seen)
+      ])
+    );
+  });
+}
+
+function nativeRuleOptionValue(ruleId, value, path, strict, seen = new WeakSet()) {
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) {
+      return value;
+    }
+    if (!strict) {
+      return null;
+    }
+    throw new TypeError(
+      `Rule "${ruleId}" option "${path}" is ${String(value)}, which cannot be written to the native JSON config.`
+    );
+  }
+  if (value === null || typeof value !== "object" || seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((item, index) => nativeRuleOptionValue(ruleId, item, `${path}[${index}]`, strict, seen));
+    }
+    if (!isPlainObject(value)) {
+      return value;
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        nativeRuleOptionValue(ruleId, item, `${path}.${key}`, strict, seen)
+      ])
+    );
+  } finally {
+    seen.delete(value);
+  }
+}
+
+function nativeRules(rules, options = {}) {
+  if (!isPlainObject(rules)) {
+    return rules;
+  }
+  return Object.fromEntries(
+    Object.entries(rules).map(([ruleId, ruleConfig]) => [ruleId, nativeRuleConfig(ruleId, ruleConfig, options)])
+  );
+}
+
+function nativeFlatConfigEntries(entries, options = {}) {
+  if (!Array.isArray(entries)) {
+    return entries;
+  }
+  return entries.map((entry) =>
+    isPlainObject(entry) && entry.rules ? { ...entry, rules: nativeRules(entry.rules, options) } : entry
+  );
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+module.exports = { nativeFlatConfigEntries, nativeRuleConfig, nativeRules };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/lint",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "High-performance JavaScript and TypeScript linter powered by Yuku",
   "license": "MIT",
   "repository": {
@@ -50,9 +50,7 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "eslint": "./bin/eslint.js",
-    "fishlint": "./bin/fishlint.js",
-    "fishlint-lint-staged": "./bin/fishlint-lint-staged.js",
+    "utlint": "./bin/utoo-lint.js",
     "utoo-lint": "./bin/utoo-lint.js"
   },
   "files": [
@@ -76,11 +74,11 @@
     "use-at-your-own-risk.js"
   ],
   "optionalDependencies": {
-    "@utoo/lint-darwin-arm64": "0.4.0",
-    "@utoo/lint-darwin-x64": "0.4.0",
-    "@utoo/lint-linux-arm64": "0.4.0",
-    "@utoo/lint-linux-x64": "0.4.0",
-    "@utoo/lint-win32-x64": "0.4.0"
+    "@utoo/lint-darwin-arm64": "0.4.1",
+    "@utoo/lint-darwin-x64": "0.4.1",
+    "@utoo/lint-linux-arm64": "0.4.1",
+    "@utoo/lint-linux-x64": "0.4.1",
+    "@utoo/lint-win32-x64": "0.4.1"
   },
   "dependencies": {
     "@eslint/eslintrc": "2.1.4",

package/schema.json

@@ -82,6 +82,30 @@
             }
           ]
         },
+        "languageOptions": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "globals": {
+              "description": "Globals declared for matching files, using ESLint flat config values. \"readonly\" accepts reads, \"writable\" also accepts writes, and \"off\" removes a built-in global.",
+              "type": "object",
+              "additionalProperties": {
+                "oneOf": [
+                  {
+                    "type": "string",
+                    "enum": ["readonly", "readable", "writable", "writeable", "off"]
+                  },
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "type": "null"
+                  }
+                ]
+              }
+            }
+          }
+        },
         "ignores": {
           "description": "File globs ignored by this config entry.",
           "oneOf": [