@geonosis/oxlint-plugin-biological-architecture 2.13.0 → 3.0.0

package/dist/rules/lib/doors.js

@@ -0,0 +1,89 @@
+// src/rules/lib/doors.ts
+import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { conditionTargetOf, exportTableOf, fileFor } from "./module-text.js";
+var DEPTH = 8;
+var exportsOf = (file, seen, depth) => {
+  if (depth > DEPTH || seen.has(file))
+    return [];
+  seen.add(file);
+  const table = exportTableOf(file);
+  if (table === undefined)
+    return [];
+  const names = [...table.declared, ...table.reexports.keys()];
+  for (const star of table.stars) {
+    const next = fileFor(file, star);
+    if (next !== undefined)
+      names.push(...exportsOf(next, seen, depth + 1));
+  }
+  return names.filter((one) => one !== "default");
+};
+var doorsOf = (manifestPath) => {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof manifest.name !== "string")
+    return;
+  if (typeof manifest.exports !== "object" || manifest.exports === null)
+    return;
+  const dir = dirname(manifestPath);
+  const placed = new Map;
+  const contested = new Set;
+  for (const [key, value] of Object.entries(manifest.exports)) {
+    if (key === "." || !key.startsWith("./") || key.includes("*"))
+      continue;
+    const target = conditionTargetOf(value);
+    if (target === undefined)
+      continue;
+    const entry = fileFor(join(dir, "package.json"), target);
+    if (entry === undefined)
+      continue;
+    const door = key.slice(2);
+    for (const name of new Set(exportsOf(entry, new Set, 0))) {
+      if (contested.has(name))
+        continue;
+      const already = placed.get(name);
+      if (already !== undefined && already !== door) {
+        placed.delete(name);
+        contested.add(name);
+        continue;
+      }
+      placed.set(name, door);
+    }
+  }
+  return { homes: placed, name: manifest.name };
+};
+var resolvePackage = (from, name) => {
+  let dir = dirname(from);
+  for (;; ) {
+    const packageDir = join(dir, "node_modules", name);
+    const manifest = join(packageDir, "package.json");
+    if (existsSync(manifest)) {
+      let own = false;
+      try {
+        own = lstatSync(packageDir).isSymbolicLink() && !realpathSync(packageDir).replaceAll("\\", "/").endsWith(`/node_modules/${name}`);
+      } catch {
+        own = false;
+      }
+      if (!own) {
+        try {
+          own = JSON.parse(readFileSync(manifest, "utf8")).private === true;
+        } catch {
+          own = false;
+        }
+      }
+      return { manifest, own };
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+};
+export {
+  doorsOf,
+  resolvePackage
+};

package/dist/rules/lib/hooks.d.ts

@@ -0,0 +1,20 @@
+import { type AnyNode } from './nodes.js';
+/**
+ * React's own naming convention: a function called `use<Something>` is a hook.
+ *
+ * Exported because two other rules test a bare callee identifier against this exact pattern
+ * without needing `hookCalledBy`'s member-expression reach — spelling the regex a second and a
+ * third time drifted nothing here, but there is no reason to trust that forever.
+ */
+export declare const HOOK_NAME: RegExp;
+/**
+ * The hook a call names, spelled as the file spelled it — or null when the call is not a hook.
+ *
+ * Two stateless-tier rules read a call's callee as a bare identifier and nothing else, so
+ * `React.useState(0)` and `hooks.useCart()` held state in a tissue and in a compound under both
+ * rules at "error": the hook was there, the name was there, and the rule was looking one node too
+ * high. A member call is read here too — the object is whatever the file imported the hook
+ * through, and the property is the hook. A computed member (`hooks[name]()`) names nothing this
+ * can read and is left alone, as every unreadable shape in this plugin is.
+ */
+export declare const hookCalledBy: (node: AnyNode) => string | null;

package/dist/rules/lib/hooks.js

@@ -0,0 +1,21 @@
+// src/rules/lib/hooks.ts
+import { calleeNameOf, propertyNameOf } from "./nodes.js";
+var HOOK_NAME = /^use[A-Z]/;
+var hookCalledBy = (node) => {
+  const bare = calleeNameOf(node);
+  if (bare !== null)
+    return HOOK_NAME.test(bare) ? bare : null;
+  const callee = node.callee;
+  if (callee === undefined)
+    return null;
+  const property = propertyNameOf(callee);
+  if (property === null || !HOOK_NAME.test(property))
+    return null;
+  const object = callee.object;
+  const through = object?.type === "Identifier" && typeof object.name === "string" ? object.name : null;
+  return through === null ? property : `${through}.${property}`;
+};
+export {
+  HOOK_NAME,
+  hookCalledBy
+};

package/dist/rules/lib/imports.d.ts

@@ -0,0 +1,52 @@
+/**
+ * How a file names another file, read once.
+ *
+ * Twenty-one rules parsed an import source themselves and each covered a different subset of the
+ * five ways it can be written, because each was written by whoever needed one of them that day.
+ */
+export type ModuleNode = {
+    arguments?: {
+        type?: string;
+        value?: unknown;
+    }[];
+    callee?: {
+        name?: string;
+        type?: string;
+    };
+    exportKind?: string;
+    importKind?: string;
+    source?: {
+        type?: string;
+        value?: unknown;
+    } | null;
+    /** What the import brought in, for the rules that judge an import by its names. */
+    specifiers?: {
+        imported?: {
+            name?: string;
+        };
+        local?: {
+            name?: string;
+        };
+        type?: string;
+    }[];
+};
+/**
+ * The module a node names, or null when it names none — `export const x = 1` names nothing, a call
+ * that is not a `require` names nothing, and `import(`./${name}`)` names something no rule can
+ * read. A rule that guessed at the last one would report a finding whose source it cannot print.
+ */
+export declare const sourceOf: (node: ModuleNode) => string | null;
+/** `import type X from`, `import { … } from` graded type, and `export type … from`. */
+export declare const isTypeOnly: (node: ModuleNode) => boolean;
+/** Whether a specifier is relative — walked from the importer, never resolved through an alias. */
+export declare const isRelative: (source: string) => boolean;
+/**
+ * Where a relative source lands, as a path — and any other source unchanged.
+ *
+ * `../../billing/organelles/totals` carries no feature name and no tier name until it is resolved
+ * against the file that wrote it. Two rules did that and the rest did not, so the same breach was a
+ * finding or not depending on which rule happened to look at it. `@/features/x` is NOT relative: it
+ * is an alias the bundler resolves, and joining it to the importer's directory would invent a path
+ * that exists nowhere.
+ */
+export declare const resolveRelative: (importer: string, source: string) => string;

package/dist/rules/lib/imports.js

@@ -0,0 +1,25 @@
+// src/rules/lib/imports.ts
+import * as path from "node:path";
+import { literalNamedBy } from "./literal-call.js";
+import { normalise } from "./paths.js";
+var REQUIRE = "require";
+var sourceOf = (node) => {
+  const source = node.source;
+  if (source === undefined || source === null) {
+    if (node.callee === undefined)
+      return null;
+    return literalNamedBy(node, REQUIRE);
+  }
+  if (source.type !== undefined && source.type !== "Literal")
+    return null;
+  return typeof source.value === "string" ? source.value : null;
+};
+var isTypeOnly = (node) => node.importKind === "type" || node.exportKind === "type";
+var isRelative = (source) => source === "." || source === ".." || source.startsWith("./") || source.startsWith("../");
+var resolveRelative = (importer, source) => isRelative(source) ? path.posix.normalize(path.posix.join(path.posix.dirname(normalise(importer)), source)) : source;
+export {
+  isRelative,
+  isTypeOnly,
+  resolveRelative,
+  sourceOf
+};

package/dist/rules/lib/landing.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Where an import LANDS, and where the code behind each name it takes LIVES.
+ *
+ * Two consumer issues were one blindness. A direction rule read the specifier as a string and
+ * stopped, so `@/components/organelles` — a bare barrel, which names no file in a tier folder —
+ * was invisible (#4), and a one-line `export { CustomCarousel } from '@/kit/organelles/carousel'`
+ * sitting in `cells/` laundered an organelle into the cell tier for every rule that looked (#11).
+ * The Store adoption that found #4 read 78 → 8 → 5 → 1 as tier fixes landed, which is to say its
+ * early numbers measured the rules' blindness as much as the code.
+ *
+ * So the specifier is resolved on disk: relative to the importer, through the repo's own
+ * `package.json` `imports` for a `#` subpath, or through its `tsconfig.json` (or `jsconfig.json`)
+ * `paths` — never an alias this plugin knows (LAW 6). The file it lands on is the
+ * DOOR. Each name the import takes is then followed through `export … from` and `export *` to the
+ * file that declares it, the HOME, to a depth of eight and never twice through one file. A name
+ * the door does not export and a bare package are left at the door; a specifier nothing on disk
+ * answers lands nowhere, and the rule judges the spelling as before. An import that takes the
+ * whole module — a namespace, `export *`, `import()`, `require()` — takes every name the door
+ * carries (row 593), narrowed to the members the file reaches when it is a namespace.
+ */
+type Landings = {
+    /** The file the specifier resolves to, absolute — or nowhere. */
+    door: string | undefined;
+    /** Imported name → the absolute file whose code it is; the door when it could not be followed. */
+    homes: Map<string, string>;
+};
+/** The absolute file a specifier names from a file, or undefined when nothing on disk answers. */
+export declare const resolveSource: (importer: string, source: string) => string | undefined;
+/**
+ * Every name a module exports, its `export *` modules followed to the same depth as a home is. A
+ * namespace import, an `export *`, `import()` and `require()` take the whole module (row 593), and
+ * "the whole module" is this list — each name then lands where its code lives, as a named import's
+ * would.
+ */
+export declare const exportedNamesOf: (file: string) => Set<string>;
+export declare const landingsOf: (importer: string, source: string, names: readonly string[]) => Landings;
+/**
+ * Whether a specifier's last segment IS a tier folder — `@/components/organelles`, `../cells`.
+ * A folder named `organelles` is the organelles tier whichever alias reaches it, so when nothing
+ * on disk answers the spelling is still judged as the folder it names.
+ */
+export declare const namesATierFolder: (source: string) => boolean;
+/**
+ * The root a landed path is judged from: the nearest directory above the importer holding a
+ * `package.json` or a `tsconfig.json`, else the importer's own. An absolute path would be judged
+ * with every directory above the repo in it, and a checkout under `/app/` or `/home/cells/` would
+ * make every resolved import a breach.
+ */
+export declare const rootOf: (file: string) => string;
+export {};

package/dist/rules/lib/landing.js

@@ -0,0 +1,111 @@
+// src/rules/lib/landing.ts
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { isRelative } from "./imports.js";
+import { exportTableOf, fileAt } from "./module-text.js";
+import { importCandidates } from "./package-imports.js";
+import { TIERS } from "./tiers.js";
+import { aliasCandidates } from "./tsconfig-paths.js";
+var DEPTH = 8;
+var resolved = new Map;
+var find = (importer, source) => {
+  if (isRelative(source))
+    return fileAt(resolve(dirname(importer), source));
+  if (source.startsWith("/") || source.startsWith("."))
+    return;
+  for (const candidate of [
+    ...importCandidates(importer, source),
+    ...aliasCandidates(importer, source)
+  ]) {
+    const found = fileAt(candidate);
+    if (found !== undefined)
+      return found;
+  }
+  return;
+};
+var resolveSource = (importer, source) => {
+  const key = `${dirname(importer)}\x00${source}`;
+  if (!resolved.has(key))
+    resolved.set(key, find(importer, source));
+  return resolved.get(key);
+};
+var homeOf = (file, name, seen, depth) => {
+  if (depth > DEPTH || seen.has(file))
+    return;
+  seen.add(file);
+  const table = exportTableOf(file);
+  if (table === undefined)
+    return;
+  if (table.declared.has(name))
+    return file;
+  const taken = table.reexports.get(name);
+  if (taken !== undefined) {
+    const next = resolveSource(file, taken.source);
+    return next === undefined ? file : homeOf(next, taken.name, seen, depth + 1) ?? next;
+  }
+  for (const star of table.stars) {
+    const next = resolveSource(file, star);
+    if (next === undefined)
+      continue;
+    const found = homeOf(next, name, seen, depth + 1);
+    if (found !== undefined)
+      return found;
+  }
+  return;
+};
+var collectNames = (file, into, seen, depth) => {
+  if (depth > DEPTH || seen.has(file))
+    return;
+  seen.add(file);
+  const table = exportTableOf(file);
+  if (table === undefined)
+    return;
+  for (const name of table.declared)
+    into.add(name);
+  for (const name of table.reexports.keys())
+    into.add(name);
+  for (const star of table.stars) {
+    const next = resolveSource(file, star);
+    if (next !== undefined)
+      collectNames(next, into, seen, depth + 1);
+  }
+};
+var exportedNamesOf = (file) => {
+  const names = new Set;
+  collectNames(file, names, new Set, 0);
+  return names;
+};
+var landingsOf = (importer, source, names) => {
+  const door = resolveSource(importer, source);
+  const homes = new Map;
+  if (door === undefined)
+    return { door, homes };
+  for (const name of names)
+    homes.set(name, homeOf(door, name, new Set, 0) ?? door);
+  return { door, homes };
+};
+var TIER_FOLDER = new RegExp(`(?:^|/)(?:${TIERS.join("|")})$`);
+var namesATierFolder = (source) => TIER_FOLDER.test(source);
+var roots = new Map;
+var rootAbove = (dir) => {
+  const known = roots.get(dir);
+  if (known !== undefined || roots.has(dir))
+    return known;
+  let found;
+  if (existsSync(join(dir, "package.json")) || existsSync(join(dir, "tsconfig.json")))
+    found = dir;
+  else {
+    const parent = dirname(dir);
+    found = parent === dir ? undefined : rootAbove(parent);
+  }
+  roots.set(dir, found);
+  return found;
+};
+var rootOf = (file) => rootAbove(dirname(file)) ?? dirname(file);
+export {
+  exportedNamesOf,
+  landingsOf,
+  namesATierFolder,
+  resolveSource,
+  rootOf
+};

package/dist/rules/lib/literal-call.d.ts

@@ -0,0 +1,11 @@
+export type LiteralCall = {
+    callee: {
+        type?: string;
+        name?: string;
+    };
+    arguments?: {
+        type?: string;
+        value?: unknown;
+    }[];
+};
+export declare const literalNamedBy: (node: LiteralCall, callee: string) => string | null;

package/dist/rules/lib/literal-call.js

@@ -0,0 +1,10 @@
+// src/rules/lib/literal-call.ts
+var literalNamedBy = (node, callee) => {
+  if (node.callee.type !== "Identifier" || node.callee.name !== callee)
+    return null;
+  const [name] = node.arguments ?? [];
+  return name?.type === "Literal" && typeof name.value === "string" ? name.value : null;
+};
+export {
+  literalNamedBy
+};

package/dist/rules/lib/module-text.d.ts

@@ -0,0 +1,43 @@
+/**
+ * What a module's TEXT says it exports, read with regexes and never a parser — the same reading
+ * `doors.ts` did for a package's `exports` map, shared now with the landing resolver, because a
+ * barrel and a re-export shim are the same shape read for a different question.
+ *
+ * A table is read once per file per process: `create` runs once per FILE, and the tree does not
+ * change under a lint run.
+ */
+type ExportTable = {
+    /** Names whose code is HERE: declarations, `export { A as B }` with no `from`, `default`. */
+    declared: Set<string>;
+    /** Exported name → the name and module it is taken from: `export { A as B } from './x'`. */
+    reexports: Map<string, {
+        name: string;
+        source: string;
+    }>;
+    /** The modules `export * from` hands through, in order. */
+    stars: string[];
+};
+export declare const EXTENSIONS: string[];
+/**
+ * Source with its comments blanked to spaces, strings stepped over whole — a glob like `'src/*'`
+ * opens no comment and a URL keeps its `//`. Blanked, not cut: the tokens either side of a comment
+ * stay apart and every line keeps its number. Every text reader in the plugin reads through it.
+ */
+export declare const stripComments: (source: string) => string;
+/** The file at a base path: itself, with an extension, or its index — or nothing on disk. */
+export declare const fileAt: (base: string) => string | undefined;
+/** A relative module specifier as the file it names, or undefined when nothing on disk answers. */
+export declare const fileFor: (from: string, specifier: string) => string | undefined;
+/** The export table of a file, or undefined when it cannot be read. */
+export declare const exportTableOf: (file: string) => ExportTable | undefined;
+/**
+ * The file an `exports` or `imports` value points at, whatever conditions it is wrapped in — a
+ * string, an array of alternatives, or a conditions object read in the order a bundler would.
+ */
+export declare const conditionTargetOf: (value: unknown) => string | undefined;
+/**
+ * JSON as `tsconfig.json` writes it: comments and trailing commas allowed. `JSON.parse` refuses
+ * both, and a reader that stripped `//` blindly would cut `"$schema": "https://…"` in half.
+ */
+export declare const parseLooseJson: (text: string) => unknown;
+export {};

package/dist/{chunk-H7UQNDFE.js → rules/lib/module-text.js}

@@ -1,30 +1,33 @@
 // src/rules/lib/module-text.ts
-import { existsSync, readFileSync, statSync } from "fs";
-import { dirname, resolve } from "path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 var EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs", ".cjs", ".d.ts"];
 var INDEXES = EXTENSIONS.map((extension) => `/index${extension}`);
-var QUOTES = /* @__PURE__ */ new Set(['"', "'", "`"]);
+var QUOTES = new Set(['"', "'", "`"]);
 var stripComments = (source) => {
   let out = "";
   let quote;
-  for (let at = 0; at < source.length; at += 1) {
+  for (let at = 0;at < source.length; at += 1) {
     const char = source[at] ?? "";
-    if (quote !== void 0) {
+    if (quote !== undefined) {
       out += char;
       if (char === "\\") {
         out += source[at + 1] ?? "";
         at += 1;
-      } else if (char === quote) quote = void 0;
+      } else if (char === quote)
+        quote = undefined;
     } else if (QUOTES.has(char)) {
       quote = char;
       out += char;
     } else if (char === "/" && (source[at + 1] === "/" || source[at + 1] === "*")) {
       const block = source[at + 1] === "*";
-      const found = block ? source.indexOf("*/", at + 2) : source.indexOf("\n", at);
+      const found = block ? source.indexOf("*/", at + 2) : source.indexOf(`
+`, at);
       const end = found === -1 ? source.length : block ? found + 2 : found;
       out += source.slice(at, end).replaceAll(/[^\n]/g, " ");
       at = end - 1;
-    } else out += char;
+    } else
+      out += char;
   }
   return out;
 };
@@ -46,64 +49,75 @@ var entriesOf = (list) => list.split(",").map((one) => one.trim().replace(/^type
   const [taken, exported] = one.split(/\s+as\s+/);
   return { exported: exported ?? taken ?? "", taken: taken ?? "" };
 });
-var tables = /* @__PURE__ */ new Map();
+var tables = new Map;
 var readTable = (file) => {
   let source;
   try {
     source = stripComments(readFileSync(file, "utf8"));
   } catch {
-    return void 0;
+    return;
   }
-  const declared = /* @__PURE__ */ new Set();
-  const reexports = /* @__PURE__ */ new Map();
+  const declared = new Set;
+  const reexports = new Map;
   const stars = [];
-  for (const found of source.matchAll(DECLARED)) declared.add(found[1] ?? "");
-  if (DEFAULT.test(source)) declared.add("default");
+  for (const found of source.matchAll(DECLARED))
+    declared.add(found[1] ?? "");
+  if (DEFAULT.test(source))
+    declared.add("default");
   for (const found of source.matchAll(LISTED)) {
     const from = found[2];
     for (const { exported, taken } of entriesOf(found[1] ?? "")) {
-      if (from === void 0) declared.add(exported);
-      else reexports.set(exported, { name: taken, source: from });
+      if (from === undefined)
+        declared.add(exported);
+      else
+        reexports.set(exported, { name: taken, source: from });
     }
   }
   for (const found of source.matchAll(STAR)) {
     const alias = found[1];
-    if (alias !== void 0) declared.add(alias);
-    else stars.push(found[2] ?? "");
+    if (alias !== undefined)
+      declared.add(alias);
+    else
+      stars.push(found[2] ?? "");
   }
   declared.delete("");
   return { declared, reexports, stars };
 };
 var exportTableOf = (file) => {
-  if (!tables.has(file)) tables.set(file, readTable(file));
+  if (!tables.has(file))
+    tables.set(file, readTable(file));
   return tables.get(file);
 };
 var CONDITIONS = ["source", "import", "default", "types", "require", "node", "browser"];
 var conditionTargetOf = (value) => {
-  if (typeof value === "string") return value;
-  if (Array.isArray(value)) return value.map(conditionTargetOf).find((one) => one !== void 0);
-  if (typeof value !== "object" || value === null) return void 0;
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.map(conditionTargetOf).find((one) => one !== undefined);
+  if (typeof value !== "object" || value === null)
+    return;
   const conditions = value;
   for (const condition of CONDITIONS) {
     const found = conditionTargetOf(conditions[condition]);
-    if (found !== void 0) return found;
+    if (found !== undefined)
+      return found;
   }
-  return Object.values(conditions).map(conditionTargetOf).find((one) => one !== void 0);
+  return Object.values(conditions).map(conditionTargetOf).find((one) => one !== undefined);
 };
 var parseLooseJson = (text) => {
   const out = stripComments(text);
   try {
     return JSON.parse(out.replaceAll(/,\s*([}\]])/g, "$1"));
   } catch {
-    return void 0;
+    return;
   }
 };
-
 export {
-  stripComments,
+  EXTENSIONS,
+  conditionTargetOf,
+  exportTableOf,
   fileAt,
   fileFor,
-  exportTableOf,
-  conditionTargetOf,
-  parseLooseJson
+  parseLooseJson,
+  stripComments
 };

package/dist/rules/lib/mutations.d.ts

@@ -0,0 +1,19 @@
+import { type AnyNode } from './nodes.js';
+/**
+ * What a WRITE is, in one place. `mutating-step-declares-retry` asks it of a step's invoke body and
+ * `route-no-inline-mutation` asks it of a route handler; two copies of this, spelled slightly
+ * differently, is how the two rules would come to disagree about which calls are writes — the same
+ * drift `lib/steps.ts` exists to prevent for what a step is.
+ *
+ * The CRUD names `MedusaService` generates. A framework fact, so a default rather than a blank.
+ */
+export declare const DEFAULT_MUTATION_PREFIXES: string[];
+export declare const mutationPrefixesOf: (rule: string, configured: string[] | undefined) => string[];
+/**
+ * `svc.createOrder(…)` — a generated CRUD write, told from `listOrders` by the capital after the
+ * prefix, and from `createOrderWorkflow(scope)` by being a METHOD on something. A bare identifier
+ * call is the workflow door itself, which is the shape both rules exist to send people towards.
+ */
+export declare const writesWith: (prefixes: readonly string[]) => (node: AnyNode) => boolean;
+/** The method name a write call carries, for a message that points at something. */
+export declare const writeNameOf: (node: AnyNode) => string;

package/dist/rules/lib/mutations.js

@@ -0,0 +1,27 @@
+// src/rules/lib/mutations.ts
+import { propertyNameOf } from "./nodes.js";
+import { requireOption } from "./options.js";
+var DEFAULT_MUTATION_PREFIXES = [
+  "create",
+  "update",
+  "upsert",
+  "delete",
+  "softDelete",
+  "restore"
+];
+var mutationPrefixesOf = (rule, configured) => requireOption(rule, configured ?? DEFAULT_MUTATION_PREFIXES, "mutationPrefixes");
+var writesWith = (prefixes) => (node) => {
+  if (node.type !== "CallExpression")
+    return false;
+  const property = propertyNameOf(node.callee ?? {});
+  if (property === null)
+    return false;
+  return prefixes.some((prefix) => property.startsWith(prefix) && /^[A-Z]/.test(property.slice(prefix.length)));
+};
+var writeNameOf = (node) => propertyNameOf(node.callee ?? {}) ?? "a service write";
+export {
+  DEFAULT_MUTATION_PREFIXES,
+  mutationPrefixesOf,
+  writeNameOf,
+  writesWith
+};

package/dist/rules/lib/nodes.d.ts

@@ -0,0 +1,25 @@
+export type AnyNode = {
+    type?: string;
+} & Record<string, unknown>;
+/**
+ * Every node under this one, this one included.
+ *
+ * A visitor is handed the node it asked for, and some facts live in its BODY — whether a step's
+ * invoke function writes anything is the one that made this necessary, and it can be behind an
+ * `if`, inside a `try`, or two closures down. A rule that only read the statements directly under
+ * the arrow would pass every step that guarded its write. Children are visited in source order.
+ *
+ * `parent` is skipped: oxlint hands nodes with back-references, and following one walks the whole
+ * program from wherever it started.
+ */
+export declare const walkNode: (node: unknown, visit: (node: AnyNode) => void, descends?: (node: AnyNode) => boolean) => void;
+/**
+ * Every node under a function's OWN body, stopping at a nested function — a hook called inside a
+ * closure this function merely defines belongs to that closure, not to this one. Two rules walked
+ * this by hand, one to find a hook call and one to collect `return` statements.
+ */
+export declare const walkOwnFunctionBody: (body: unknown, visit: (node: AnyNode) => void) => void;
+/** The name a `MemberExpression`'s non-computed property carries, or null. */
+export declare const propertyNameOf: (node: AnyNode) => string | null;
+/** The name an `Identifier` callee carries, or null — a method call is never one of these. */
+export declare const calleeNameOf: (node: AnyNode) => string | null;