oxlint-plugin-effector 0.0.2 → 0.0.3

package/README.md

@@ -25,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";
@@ -278,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;
@@ -473,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;
@@ -539,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effector",
-  "version": "0.0.2",
+  "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>",