oxlint-plugin-effector 0.0.1 → 0.0.3

package/README.md

@@ -12,9 +12,11 @@ checker and passes it.
 The Effector rules need TypeScript types (to tell a `Store` from an `Event`, follow units across files, etc.).
 oxlint does not hand type information to JS plugins. So instead of relying on it, **the plugin builds its own
 `ts.Program`** using the `typescript` package directly and calls `getTypeAtLocation` itself, mapping oxlint's AST
-nodes to TS nodes by source range. Under ESLint / the test runner it transparently uses the parser's existing
-services; under oxlint it constructs its own. Same rule code, real types, either way. There is **no
-`@typescript-eslint` in the runtime** — the only runtime dependencies are `typescript` (peer) and `esquery`.
+nodes to TS nodes by source range. This is an oxlint plugin — it does **not** target or support ESLint; under
+oxlint the plugin always constructs its own program. There is **no `@typescript-eslint` in the runtime** — the
+only runtime dependencies are `typescript` (peer) and `esquery`. (The test suite happens to run the rules through
+`@typescript-eslint/rule-tester` to validate against the real type checker, but that's a testing detail, not a
+runtime target.)
 
 Program discovery (`src/shared/services.ts`) is on plain `typescript` and handles the awkward setups:
 
@@ -23,9 +25,21 @@ Program discovery (`src/shared/services.ts`) is on plain `typescript` and handle
 - if no tsconfig is found, a node-resolution fallback is used so `effector`/`react` types still resolve;
 - set **`OXLINT_EFFECTOR_TSCONFIG`** to point at a specific tsconfig (custom names, monorepo roots).
 
-Trade-off: building a TypeScript program means these rules are not "native oxlint" fast — the first lint of a
-project pays for program creation. Functionally there are **no limitations** versus `eslint-plugin-effector`
-(the full upstream test suite — 349 cases — passes against the real type checker).
+### Performance
+
+These rules are **type-aware**, so each oxlint worker thread builds a TypeScript program for the project and
+resolves types — the same fixed cost any type-aware linter pays (comparable to `typescript-eslint` with
+`parserOptions.project`). On a real ~350-file React project expect a few seconds of overhead over oxlint's native
+rules; it is dominated by the one-time program build + type resolution, which parallelizes across threads and is
+largely inherent (it cannot be shared with oxlint's own type checker). Functionally there are **no limitations**
+versus `eslint-plugin-effector` (the full upstream test suite — 349 cases — passes against the real type checker).
+
+Levers if it's too slow:
+
+- **`OXLINT_EFFECTOR_TSCONFIG`** → point at a lean tsconfig that `include`s only your source (skip tests/build
+  output) so the program is smaller;
+- **`oxlint --threads N`** → on a type-aware run, fewer threads can be as fast or faster (each thread builds its
+  own program), so try a lower number than your core count.
 
 ## Installation
 

package/dist/index.js

@@ -19,6 +19,24 @@ var NodeType = {
   SpreadElement: "SpreadElement",
   VariableDeclarator: "VariableDeclarator"
 };
+var NON_UNIT_INIT = /* @__PURE__ */ new Set([
+  "ArrayExpression",
+  "ArrowFunctionExpression",
+  "BinaryExpression",
+  "ClassExpression",
+  "FunctionExpression",
+  "JSXElement",
+  "JSXFragment",
+  "Literal",
+  "ObjectExpression",
+  "TaggedTemplateExpression",
+  "TemplateLiteral",
+  "UnaryExpression"
+]);
+var bindingCannotBeUnit = (node) => {
+  const parent = node.parent;
+  return parent?.type === NodeType.VariableDeclarator && parent.id === node && parent.init != null && NON_UNIT_INIT.has(parent.init.type);
+};
 
 // src/shared/services.ts
 import { dirname, resolve } from "node:path";
@@ -26,22 +44,33 @@ import * as ts from "typescript";
 function getParserServices(context) {
   const existing = context.sourceCode?.parserServices;
   if (existing?.program && existing.esTreeNodeToTSNodeMap) return existing;
-  return buildServices(context);
+  const filename = context.filename ?? context.physicalFilename;
+  let services = servicesCache.get(filename);
+  if (!services) {
+    services = buildServices(context);
+    servicesCache.set(filename, services);
+  }
+  return services;
 }
+var servicesCache = /* @__PURE__ */ new Map();
 var programCache = /* @__PURE__ */ new Map();
+var standaloneCache = /* @__PURE__ */ new Map();
+var findSourceFile = (program, filename) => program.getSourceFile(filename) ?? program.getSourceFiles().find((sf) => norm(sf.fileName) === norm(filename));
 function buildServices(context) {
   const filename = context.filename ?? context.physicalFilename;
-  const program = getProgram(filename);
-  const sourceFile = program.getSourceFile(filename);
-  if (!sourceFile)
-    throw new Error(
-      `oxlint-plugin-effector: cannot load "${filename}" into a TypeScript program`
-    );
+  let program = getProgram(filename);
+  let sourceFile = findSourceFile(program, filename);
+  if (!sourceFile) {
+    program = getStandaloneProgram(filename);
+    sourceFile = findSourceFile(program, filename);
+  }
+  if (!sourceFile) return getInertServices();
+  const file = sourceFile;
   const checker = program.getTypeChecker();
-  const byRange = indexByRange(sourceFile);
+  const byRange = indexByRange(file);
   const toTSNode = (node) => {
     const [start, end] = node.range;
-    return byRange.get(key(start, end)) ?? deepestContaining(sourceFile, start, end);
+    return byRange.get(key(start, end)) ?? deepestContaining(file, start, end);
   };
   return {
     program,
@@ -60,7 +89,14 @@ var FALLBACK_OPTIONS = {
   skipLibCheck: true
 };
 var norm = (p) => p.replace(/\\/g, "/");
-var parseConfig = (configPath) => ts.getParsedCommandLineOfConfigFile(configPath, {}, ts.sys) ?? void 0;
+var parsedConfigCache = /* @__PURE__ */ new Map();
+var parseConfig = (configPath) => {
+  if (parsedConfigCache.has(configPath))
+    return parsedConfigCache.get(configPath);
+  const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, ts.sys) ?? void 0;
+  parsedConfigCache.set(configPath, parsed);
+  return parsed;
+};
 function projectContaining(configPath, filename, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(norm(configPath))) return void 0;
   seen.add(norm(configPath));
@@ -93,6 +129,48 @@ function getProgram(filename) {
   programCache.set(cacheKey, program);
   return program;
 }
+function getStandaloneProgram(filename) {
+  let program = standaloneCache.get(filename);
+  if (!program) {
+    program = ts.createProgram({
+      rootNames: [filename],
+      options: FALLBACK_OPTIONS
+    });
+    standaloneCache.set(filename, program);
+  }
+  return program;
+}
+var inertServices;
+function getInertServices() {
+  if (inertServices) return inertServices;
+  const name = "__oxlint-plugin-effector-empty__.ts";
+  const sf = ts.createSourceFile(name, "", ts.ScriptTarget.Latest, true);
+  const host = {
+    getSourceFile: (f) => norm(f) === norm(name) ? sf : void 0,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => void 0,
+    getCurrentDirectory: () => "",
+    getDirectories: () => [],
+    getCanonicalFileName: (f) => f,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (f) => norm(f) === norm(name),
+    readFile: () => ""
+  };
+  const program = ts.createProgram(
+    [name],
+    { noLib: true, skipLibCheck: true },
+    host
+  );
+  inertServices = {
+    program,
+    esTreeNodeToTSNodeMap: { get: () => void 0, has: () => false },
+    tsNodeToESTreeNodeMap: { get: () => void 0, has: () => false },
+    getTypeAtLocation: () => void 0,
+    getSymbolAtLocation: () => void 0
+  };
+  return inertServices;
+}
 function deepestContaining(sourceFile, start, end) {
   let best = sourceFile;
   const visit = (node) => {
@@ -156,7 +234,7 @@ var symbolMatches = (symbol, names, from) => {
   return declarations.map((decl) => decl.getSourceFile().fileName).some((fname) => fname.includes("node_modules") && fname.includes(from));
 };
 var typeMatches = (type, names, from, depth = 0) => {
-  if (depth > 10) return false;
+  if (!type || depth > 10) return false;
   const symbol = type.getSymbol() ?? type.aliasSymbol;
   if (symbol && symbolMatches(symbol, names, from)) return true;
   if (type.isUnion() || type.isIntersection())
@@ -218,6 +296,7 @@ var enforce_effect_naming_convention_default = createRule({
     ].join(", ");
     return {
       [identifierSelectors]: (node) => {
+        if (bindingCannotBeUnit(node)) return;
         const type = services.getTypeAtLocation(node);
         const isEffect = isType.effect(type);
         if (!isEffect) return;
@@ -413,6 +492,7 @@ var enforce_gate_naming_convention_default = createRule({
     const services = getParserServices(context);
     return {
       [`VariableDeclarator[id.name=${GateRegex}]`]: (node) => {
+        if (bindingCannotBeUnit(node.id)) return;
         const type = services.getTypeAtLocation(node);
         const isGate = isType.gate(type);
         if (!isGate) return;
@@ -479,6 +559,7 @@ var enforce_store_naming_convention_default = createRule({
     ].join(", ");
     return {
       [identifierSelectors]: (node) => {
+        if (bindingCannotBeUnit(node)) return;
         const type = services.getTypeAtLocation(node);
         const isStore = isType.store(type);
         if (!isStore) return;
@@ -682,6 +763,7 @@ var mandatory_scope_binding_default = createRule({
     const inHook = [];
     const isExpectingUnit = (slot) => {
       const tsnode = services.esTreeNodeToTSNodeMap.get(slot);
+      if (!tsnode) return false;
       const type = checker.getContextualType(tsnode);
       if (type) return isType.event(type) || isType.effect(type);
       else return false;
@@ -708,6 +790,7 @@ var mandatory_scope_binding_default = createRule({
         const name = nameOf.function(node);
         if (name && UseRegex.test(name.name)) return void inRender.push(true);
         const tsnode = services.esTreeNodeToTSNodeMap.get(node);
+        if (!tsnode) return void inRender.push(false);
         const signature = checker.getSignatureFromDeclaration(tsnode);
         const returnType = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
         const isJSX = matchesType(returnType, (type) => isType.jsx(type));
@@ -1436,6 +1519,7 @@ var no_units_spawn_in_render_default = createRule({
         if (name && UseRegex2.test(name.name))
           return void stack.render.push(true);
         const tsnode = services.esTreeNodeToTSNodeMap.get(node);
+        if (!tsnode) return void stack.render.push(false);
         const signature = checker.getSignatureFromDeclaration(tsnode);
         const returnType = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
         const isJSX = matchesType2(returnType, (type) => isType.jsx(type));
@@ -1559,6 +1643,7 @@ function getCalleeName(callee) {
   else return null;
 }
 function hasEffectorUnitInType(ctx, type, depth = 3) {
+  if (!type) return false;
   if (isType.unit(type)) return true;
   if (depth <= 0) return false;
   if (type.isUnion())

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "oxlint-plugin-effector",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Enforcing best practices for Effector — a full type-aware oxlint plugin (port of eslint-plugin-effector)",
+  "license": "MIT",
+  "author": "Marsel Abazbekov <marsel.ave@gmail.com>",
   "keywords": [
     "oxlint",
     "oxlint-plugin",