@utoo/lint 0.3.9 → 0.4.1

package/lib/load-config.js

@@ -2,15 +2,88 @@ 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
+// and frequently reference themselves (`plugin.configs.recommended.plugins`).
+// Serialize them down to the rule names the wrapper needs to route rules; the
+// plugin objects themselves are re-imported in-process when rules run.
+function serializablePlugins(plugins, seen) {
+  const result = {};
+  for (const [name, plugin] of Object.entries(plugins)) {
+    if (!plugin || typeof plugin !== "object") {
+      continue;
+    }
+    const rules = {};
+    for (const [ruleName, rule] of Object.entries(plugin.rules ?? {})) {
+      rules[ruleName] = { meta: serializable(rule?.meta ?? {}, seen) ?? {} };
+    }
+    result[name] = {
+      ...(plugin.meta && typeof plugin.meta === "object" ? { meta: serializable(plugin.meta, seen) ?? {} } : {}),
+      rules
+    };
+  }
+  return result;
+}
+
+function serializable(value, seen = new WeakSet()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value !== "object") {
+    return undefined;
+  }
+  if (typeof value.toJSON === "function") {
+    return serializable(value.toJSON(), seen);
+  }
+  if (seen.has(value)) {
+    return undefined;
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((item) => {
+        const item2 = serializable(item, seen);
+        return item2 === undefined ? null : item2;
+      });
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (key === "plugins" && item && typeof item === "object" && !Array.isArray(item)) {
+        result.plugins = serializablePlugins(item, seen);
+        continue;
+      }
+      // 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;
+      }
+    }
+    return result;
+  } finally {
+    seen.delete(value);
+  }
+}
+
 try {
   if (!configPath) {
     throw new TypeError("missing config path");
   }
   const jiti = createJiti(dirname(configPath));
   const value = await jiti.import(configPath, { default: true });
-  const json = JSON.stringify(value);
+  const json = JSON.stringify(serializable(value));
   if (json === undefined) {
     throw new TypeError("config did not export a JSON-serializable value");
   }

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/lib/plugin-runner.cjs

@@ -0,0 +1,342 @@
+"use strict";
+
+// Runs ESLint plugin rule listeners over an ESTree AST.
+//
+// Listener keys are esquery selectors (`Identifier`, `CallExpression > Literal`,
+// `Program:exit`, ...). This mirrors ESLint's NodeEventGenerator: selectors are
+// parsed once, indexed by the node types they can match, and applied in
+// specificity order while the AST is traversed with the parser's visitor keys.
+//
+// CommonJS on purpose: shared by the ESM and CommonJS entry points.
+
+const esquery = require("esquery");
+
+const NON_CHILD_KEYS = new Set(["type", "start", "end", "range", "loc", "parent", "comments", "tokens"]);
+
+function isNode(value) {
+  return value !== null && typeof value === "object" && typeof value.type === "string";
+}
+
+function fallbackKeys(node) {
+  return Object.keys(node).filter((key) => !NON_CHILD_KEYS.has(key));
+}
+
+function childKeys(node, visitorKeys) {
+  return visitorKeys?.[node.type] ?? fallbackKeys(node);
+}
+
+function possibleTypes(selector) {
+  switch (selector.type) {
+    case "identifier":
+      return [selector.value];
+    case "matches": {
+      const types = [];
+      for (const child of selector.selectors) {
+        const childTypes = possibleTypes(child);
+        if (!childTypes) {
+          return null;
+        }
+        types.push(...childTypes);
+      }
+      return types;
+    }
+    case "compound": {
+      const typesForComponents = selector.selectors.map(possibleTypes).filter(Boolean);
+      return typesForComponents.length === 0 ? null : typesForComponents[0];
+    }
+    case "child":
+    case "descendant":
+    case "sibling":
+    case "adjacent":
+      return possibleTypes(selector.right);
+    case "class":
+      if (selector.name === "function") {
+        return ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"];
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+function countClassAttributes(selector) {
+  switch (selector.type) {
+    case "child":
+    case "descendant":
+    case "sibling":
+    case "adjacent":
+      return countClassAttributes(selector.left) + countClassAttributes(selector.right);
+    case "compound":
+    case "not":
+    case "matches":
+      return selector.selectors.reduce((sum, child) => sum + countClassAttributes(child), 0);
+    case "attribute":
+    case "field":
+    case "nth-child":
+    case "nth-last-child":
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+function countIdentifiers(selector) {
+  switch (selector.type) {
+    case "child":
+    case "descendant":
+    case "sibling":
+    case "adjacent":
+      return countIdentifiers(selector.left) + countIdentifiers(selector.right);
+    case "compound":
+    case "not":
+    case "matches":
+      return selector.selectors.reduce((sum, child) => sum + countIdentifiers(child), 0);
+    case "identifier":
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+function compareSpecificity(left, right) {
+  return left.attributeCount - right.attributeCount
+    || left.identifierCount - right.identifierCount
+    || (left.rawSelector <= right.rawSelector ? -1 : 1);
+}
+
+const selectorCache = new Map();
+
+function parseSelector(rawSelector) {
+  if (selectorCache.has(rawSelector)) {
+    return selectorCache.get(rawSelector);
+  }
+  const isExit = rawSelector.endsWith(":exit");
+  const source = isExit ? rawSelector.slice(0, -":exit".length) : rawSelector;
+  let parsedSelector;
+  try {
+    parsedSelector = esquery.parse(source.replace(/:exit$/u, ""));
+  } catch (error) {
+    const wrapped = new SyntaxError(`Syntax error in selector "${source}": ${error.message}`);
+    wrapped.cause = error;
+    throw wrapped;
+  }
+  const selector = {
+    rawSelector,
+    isExit,
+    parsedSelector,
+    listenerTypes: possibleTypes(parsedSelector),
+    attributeCount: countClassAttributes(parsedSelector),
+    identifierCount: countIdentifiers(parsedSelector)
+  };
+  selectorCache.set(rawSelector, selector);
+  return selector;
+}
+
+function indexSelectors(selectors) {
+  const byType = new Map();
+  const anyType = [];
+  for (const selector of selectors) {
+    if (selector.listenerTypes) {
+      for (const type of selector.listenerTypes) {
+        if (!byType.has(type)) {
+          byType.set(type, []);
+        }
+        byType.get(type).push(selector);
+      }
+    } else {
+      anyType.push(selector);
+    }
+  }
+  for (const list of byType.values()) {
+    list.sort(compareSpecificity);
+  }
+  anyType.sort(compareSpecificity);
+  return { byType, anyType };
+}
+
+function wrapListenerError(error, entry, node) {
+  if (error && typeof error === "object" && !error.utooLintRuleId) {
+    const location = node?.loc?.start ? ` at ${node.loc.start.line}:${node.loc.start.column + 1}` : "";
+    const wrapped = new Error(`Error while running ESLint plugin rule "${entry.ruleId}"${location}: ${error.message}`);
+    wrapped.cause = error;
+    wrapped.stack = `${wrapped.message}\n${error.stack ?? ""}`;
+    wrapped.utooLintRuleId = entry.ruleId;
+    return wrapped;
+  }
+  return error;
+}
+
+/**
+ * Traverse `program` and invoke matching listeners.
+ *
+ * `listenersBySelector` maps a raw selector string to entries of shape
+ * `{ ruleId, listener }`. Listeners for the same selector are invoked in
+ * registration order; different selectors are ordered by specificity.
+ */
+function runRuleListeners(program, listenersBySelector, options = {}) {
+  const visitorKeys = options.visitorKeys ?? null;
+  const esqueryOptions = {
+    visitorKeys: visitorKeys ?? undefined,
+    fallback: fallbackKeys
+  };
+  const selectors = [];
+  const entriesBySelector = new Map();
+  for (const [rawSelector, entries] of listenersBySelector) {
+    const selector = parseSelector(rawSelector);
+    selectors.push(selector);
+    entriesBySelector.set(selector, entries);
+  }
+  const enter = indexSelectors(selectors.filter((selector) => !selector.isExit));
+  const exit = indexSelectors(selectors.filter((selector) => selector.isExit));
+  const ancestry = [];
+
+  function apply(index, node) {
+    const typed = index.byType.get(node.type) ?? [];
+    const untyped = index.anyType;
+    let typedIndex = 0;
+    let untypedIndex = 0;
+    while (typedIndex < typed.length || untypedIndex < untyped.length) {
+      let selector;
+      if (untypedIndex >= untyped.length || (typedIndex < typed.length && compareSpecificity(typed[typedIndex], untyped[untypedIndex]) < 0)) {
+        selector = typed[typedIndex];
+        typedIndex += 1;
+      } else {
+        selector = untyped[untypedIndex];
+        untypedIndex += 1;
+      }
+      if (!esquery.matches(node, selector.parsedSelector, ancestry, esqueryOptions)) {
+        continue;
+      }
+      for (const entry of entriesBySelector.get(selector)) {
+        try {
+          entry.listener(node);
+        } catch (error) {
+          throw wrapListenerError(error, entry, node);
+        }
+      }
+    }
+  }
+
+  function visit(node) {
+    apply(enter, node);
+    ancestry.unshift(node);
+    for (const key of childKeys(node, visitorKeys)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (isNode(item)) {
+            visit(item);
+          }
+        }
+      } else if (isNode(value)) {
+        visit(value);
+      }
+    }
+    ancestry.shift();
+    apply(exit, node);
+  }
+
+  visit(program);
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function deepMergeDefaults(defaults, value) {
+  if (value === undefined) {
+    return structuredCloneSafe(defaults);
+  }
+  if (isPlainObject(defaults) && isPlainObject(value)) {
+    const result = { ...value };
+    for (const [key, defaultValue] of Object.entries(defaults)) {
+      result[key] = deepMergeDefaults(defaultValue, value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+
+function structuredCloneSafe(value) {
+  if (Array.isArray(value)) {
+    return value.map(structuredCloneSafe);
+  }
+  if (isPlainObject(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, structuredCloneSafe(item)]));
+  }
+  return value;
+}
+
+function schemaItemAt(schema, index) {
+  if (Array.isArray(schema)) {
+    return schema[index];
+  }
+  if (!isPlainObject(schema)) {
+    return undefined;
+  }
+  if (Array.isArray(schema.items)) {
+    return schema.items[index];
+  }
+  if (isPlainObject(schema.items)) {
+    return schema.items;
+  }
+  if (Array.isArray(schema.prefixItems)) {
+    return schema.prefixItems[index];
+  }
+  return undefined;
+}
+
+// Applies JSON-schema `default` values the way ESLint's validator does: only
+// properties of objects the user actually passed are filled in.
+function applySchemaDefaults(schema, value) {
+  if (!isPlainObject(schema)) {
+    return value;
+  }
+  if (isPlainObject(value) && isPlainObject(schema.properties)) {
+    const result = { ...value };
+    for (const [key, propertySchema] of Object.entries(schema.properties)) {
+      if (!isPlainObject(propertySchema)) {
+        continue;
+      }
+      if (result[key] === undefined && propertySchema.default !== undefined) {
+        result[key] = structuredCloneSafe(propertySchema.default);
+      }
+      if (result[key] !== undefined) {
+        result[key] = applySchemaDefaults(propertySchema, result[key]);
+      }
+    }
+    return result;
+  }
+  if (Array.isArray(value) && isPlainObject(schema.items)) {
+    return value.map((item) => applySchemaDefaults(schema.items, item));
+  }
+  return value;
+}
+
+/**
+ * Compute the effective `context.options` for a rule: user options with
+ * `meta.defaultOptions` merged in (ESLint >= 9.15) and JSON-schema defaults
+ * filled in for the object options that were provided.
+ */
+function applyRuleOptionDefaults(rule, options = []) {
+  const meta = rule?.meta ?? {};
+  let result = Array.isArray(options) ? options.slice() : [];
+  if (Array.isArray(meta.defaultOptions)) {
+    const merged = [];
+    const length = Math.max(meta.defaultOptions.length, result.length);
+    for (let index = 0; index < length; index += 1) {
+      merged.push(deepMergeDefaults(meta.defaultOptions[index], result[index]));
+    }
+    result = merged;
+  }
+  if (meta.schema) {
+    result = result.map((value, index) => applySchemaDefaults(schemaItemAt(meta.schema, index), value));
+  }
+  return result;
+}
+
+module.exports = {
+  applyRuleOptionDefaults,
+  parseSelector,
+  runRuleListeners
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/lint",
-  "version": "0.3.9",
+  "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,16 +74,21 @@
     "use-at-your-own-risk.js"
   ],
   "optionalDependencies": {
-    "@utoo/lint-darwin-arm64": "0.3.9",
-    "@utoo/lint-darwin-x64": "0.3.9",
-    "@utoo/lint-linux-arm64": "0.3.9",
-    "@utoo/lint-linux-x64": "0.3.9",
-    "@utoo/lint-win32-x64": "0.3.9"
+    "@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",
     "@eslint/js": "8.57.1",
-    "jiti": "2.7.0"
+    "@typescript-eslint/scope-manager": "8.61.0",
+    "@typescript-eslint/visitor-keys": "8.61.0",
+    "eslint-scope": "9.1.2",
+    "esquery": "1.7.0",
+    "jiti": "2.7.0",
+    "yuku-parser": "0.10.1"
   },
   "publishConfig": {
     "access": "public",

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": [