oxlint-plugin-effector 0.0.1 → 0.0.2

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:
 

package/dist/index.js

@@ -26,22 +26,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 +71,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 +111,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 +216,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())
@@ -682,6 +742,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 +769,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 +1498,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 +1622,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.2",
   "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",