@geonosis/oxlint-plugin-biological-architecture 3.1.0 → 3.2.0

package/dist/rules/lib/direction-rule.js

@@ -3,6 +3,7 @@ import { dirname, relative } from "node:path";
 import { resolveRelative } from "./imports.js";
 import { exportedNamesOf, landingsOf, namesATierFolder, rootOf } from "./landing.js";
 import { propertyNameOf } from "./nodes.js";
+import { destructuredNamesOf, withoutTypes } from "./objects.js";
 import { fileOf, normalise } from "./paths.js";
 import { featureOf, inTier, tierOf } from "./tiers.js";
 import { onImportSource } from "./visitors.js";
@@ -13,7 +14,6 @@ var classify = (path, source = path) => ({
   source,
   tier: tierOf(path)
 });
-var FORBIDDEN = "forbidden";
 var placeAndSource = (target, importer) => ({
   file: importer.file,
   source: target.source
@@ -51,7 +51,7 @@ var targetsOf = (filename, importer, source, taken) => {
 var directionRule = (declaration) => {
   const {
     data = placeAndSource,
-    messageId = FORBIDDEN,
+    messageId = "forbidden",
     optionsFrom,
     scope,
     typeOnly = "skip"
@@ -89,7 +89,8 @@ var directionRule = (declaration) => {
         reachedThrough.set(local, reached);
         namespaces.push({ node, reached, source });
       }, { typeOnly });
-      const whole = onImportSource((source, node) => judge(source, node, WHOLE), { typeOnly });
+      const destructured = new WeakMap;
+      const whole = onImportSource((source, node) => judge(source, node, destructured.get(node) ?? WHOLE), { typeOnly });
       return {
         CallExpression: whole.CallExpression,
         ExportAllDeclaration: whole.ExportAllDeclaration,
@@ -103,6 +104,13 @@ var directionRule = (declaration) => {
         MemberExpression(node) {
           reach(node.object, propertyNameOf(node));
         },
+        VariableDeclarator(node) {
+          const names = destructuredNamesOf(node.id);
+          const init = withoutTypes(node.init);
+          const call = init?.type === "AwaitExpression" ? withoutTypes(init.argument) : init;
+          if (names !== null && call !== undefined)
+            destructured.set(call, names);
+        },
         "Program:exit"() {
           for (const { node, reached, source } of namespaces) {
             judge(source, node, reached.size === 0 ? WHOLE : [...reached]);
@@ -111,6 +119,7 @@ var directionRule = (declaration) => {
       };
     },
     fixShape: declaration.fixShape,
+    ...declaration.probe === undefined ? {} : { probe: declaration.probe },
     meta: {
       docs: { description: declaration.description },
       messages: declaration.messages,

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

@@ -1,26 +1,10 @@
-/**
- * A package's doors, read off its own `package.json` `exports`: each subpath, and the names the
- * file behind it exports — the map `subpath-over-barrel` needs, which one consumer kept by hand.
- *
- * Read with the same regexes three rules already read a re-export shim with, never a parser: a
- * door's entry is `export … from` lines and declarations, and `export *` is followed inside the
- * package to a small fixed depth. A door written as a pattern (`./icons/*`) names no file to read
- * and is left out; a name two doors both export is placed under neither, because the rule could
- * not tell a reader which one to open.
- */
 export type Doors = {
     name: string;
-    /** exported name → the door (subpath, no `./`) it lives under */ homes: Map<string, string>;
+    homes: Map<string, string>;
 };
-/** The doors a manifest declares, each with the names behind it. */
 export declare const doorsOf: (manifestPath: string) => Doors | undefined;
-/**
- * Where a bare specifier resolves from a file: the nearest `node_modules/<name>/package.json`
- * walking up. `own` says whether it is the repo's: linked in from outside any `node_modules` (a
- * workspace link — pnpm links a dependency too, but into its store's `node_modules/<name>`) or
- * private (npm refuses to publish one, so under `node_modules` it is the repo's).
- */
 export declare const resolvePackage: (from: string, name: string) => {
     manifest: string;
     own: boolean;
 } | undefined;
+export declare const nodeModulesAbove: (from: string) => boolean;

package/dist/rules/lib/doors.js

@@ -1,48 +1,55 @@
 // src/rules/lib/doors.ts
-import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, 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)
+import { exportedNamesOf } from "./landing.js";
+import { conditionTargetOf, fileFor, readManifest, recordOf } from "./module-text.js";
+import { workspaceMemberNamed } from "./workspace-members.js";
+var LISTED_FILES = 4000;
+var filesBelow = (dir, budget) => {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
     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");
+  return entries.flatMap((entry) => {
+    if (budget.left <= 0 || entry.name === "node_modules")
+      return [];
+    if (entry.isDirectory()) {
+      return filesBelow(join(dir, entry.name), budget).map((one) => `${entry.name}/${one}`);
+    }
+    budget.left -= 1;
+    return [entry.name];
+  });
+};
+var expanded = (dir, key, target) => {
+  const star = target.indexOf("*");
+  const before = target.slice(0, star);
+  const suffix = target.slice(star + 1);
+  const folder = before.slice(0, before.lastIndexOf("/") + 1);
+  const stem = before.slice(folder.length);
+  return filesBelow(join(dir, folder), { left: LISTED_FILES }).flatMap((relative) => {
+    if (!relative.startsWith(stem) || !relative.endsWith(suffix))
+      return [];
+    const matched = relative.slice(stem.length, relative.length - suffix.length);
+    return matched === "" ? [] : [[key.replace("*", matched).slice(2), `${folder}${relative}`]];
+  });
 };
 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)
+  const manifest = readManifest(manifestPath);
+  const exported = recordOf(manifest?.exports);
+  if (typeof manifest?.name !== "string" || exported === undefined)
     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 place = (door, target) => {
     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))) {
+      return;
+    for (const name of exportedNamesOf(entry)) {
+      if (name === "default")
+        continue;
       if (contested.has(name))
         continue;
       const already = placed.get(name);
@@ -53,10 +60,25 @@ var doorsOf = (manifestPath) => {
       }
       placed.set(name, door);
     }
+  };
+  for (const [key, value] of Object.entries(exported)) {
+    if (key === "." || !key.startsWith("./"))
+      continue;
+    const target = conditionTargetOf(value);
+    if (target === undefined)
+      continue;
+    if (key.includes("*")) {
+      if (!target.includes("*"))
+        continue;
+      for (const [door, concrete] of expanded(dir, key, target))
+        place(door, concrete);
+      continue;
+    }
+    place(key.slice(2), target);
   }
   return { homes: placed, name: manifest.name };
 };
-var resolvePackage = (from, name) => {
+var resolveInNodeModules = (from, name) => {
   let dir = dirname(from);
   for (;; ) {
     const packageDir = join(dir, "node_modules", name);
@@ -68,13 +90,8 @@ var resolvePackage = (from, name) => {
       } catch {
         own = false;
       }
-      if (!own) {
-        try {
-          own = JSON.parse(readFileSync(manifest, "utf8")).private === true;
-        } catch {
-          own = false;
-        }
-      }
+      if (!own)
+        own = readManifest(manifest)?.private === true;
       return { manifest, own };
     }
     const parent = dirname(dir);
@@ -83,7 +100,28 @@ var resolvePackage = (from, name) => {
     dir = parent;
   }
 };
+var resolvePackage = (from, name) => {
+  const found = resolveInNodeModules(from, name);
+  if (found?.own === true)
+    return found;
+  const member = workspaceMemberNamed(from, name);
+  if (member === undefined)
+    return found;
+  return { manifest: found?.manifest ?? member, own: true };
+};
+var nodeModulesAbove = (from) => {
+  let dir = dirname(from);
+  for (;; ) {
+    if (existsSync(join(dir, "node_modules")))
+      return true;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return false;
+    dir = parent;
+  }
+};
 export {
   doorsOf,
+  nodeModulesAbove,
   resolvePackage
 };

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

@@ -1,20 +1,5 @@
 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 STORE_HOOK_NAME: RegExp;
 export declare const hookCalledBy: (node: AnyNode) => string | null;
+export declare const hookNameOf: (node: AnyNode) => string | null;

package/dist/rules/lib/hooks.js

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

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

@@ -1,9 +1,3 @@
-/**
- * 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;
@@ -19,34 +13,19 @@ export type ModuleNode = {
         type?: string;
         value?: unknown;
     } | null;
-    /** What the import brought in, for the rules that judge an import by its names. */
     specifiers?: {
         imported?: {
             name?: string;
         };
+        importKind?: 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;
+export declare const isR3fImport: (node: ModuleNode) => boolean;

package/dist/rules/lib/imports.js

@@ -2,13 +2,13 @@
 import * as path from "node:path";
 import { literalNamedBy } from "./literal-call.js";
 import { normalise } from "./paths.js";
-var REQUIRE = "require";
+var R3F_PACKAGES = new Set(["@react-three/drei", "@react-three/fiber"]);
 var sourceOf = (node) => {
   const source = node.source;
   if (source === undefined || source === null) {
     if (node.callee === undefined)
       return null;
-    return literalNamedBy(node, REQUIRE);
+    return literalNamedBy(node, "require");
   }
   if (source.type !== undefined && source.type !== "Literal")
     return null;
@@ -17,7 +17,12 @@ var sourceOf = (node) => {
 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;
+var isR3fImport = (node) => {
+  const source = sourceOf(node);
+  return source !== null && R3F_PACKAGES.has(source);
+};
 export {
+  isR3fImport,
   isRelative,
   isTypeOnly,
   resolveRelative,

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

@@ -0,0 +1,31 @@
+export interface JsxAttribute {
+    name?: {
+        name?: string;
+        type: string;
+    };
+    type: string;
+    value?: {
+        type: string;
+        value?: unknown;
+    } | null;
+}
+export interface JsxOpeningElement {
+    attributes?: JsxAttribute[];
+    loc?: unknown;
+    name: {
+        name?: string;
+        type: string;
+    };
+    type: 'JSXOpeningElement';
+}
+export declare const isCapitalised: (name: string) => boolean;
+export declare const attributeNamed: (node: {
+    attributes?: readonly JsxAttribute[];
+}, name: string) => JsxAttribute | undefined;
+export declare const tagNameOf: (node: {
+    name?: JsxOpeningElement['name'];
+} | undefined) => string | undefined;
+export declare const meaningfulChildren: <Child extends {
+    type: string;
+    value?: string;
+}>(children: readonly Child[] | undefined) => Child[];

package/dist/rules/lib/jsx.js

@@ -0,0 +1,11 @@
+// src/rules/lib/jsx.ts
+var isCapitalised = (name) => /^[A-Z]/.test(name);
+var attributeNamed = (node, name) => node.attributes?.find((attribute) => attribute?.type === "JSXAttribute" && attribute.name?.type === "JSXIdentifier" && attribute.name.name === name);
+var tagNameOf = (node) => node?.name?.type === "JSXIdentifier" && node.name.name ? node.name.name : undefined;
+var meaningfulChildren = (children) => (children ?? []).filter((child) => child.type !== "JSXText" || (child.value ?? "").trim() !== "");
+export {
+  attributeNamed,
+  isCapitalised,
+  meaningfulChildren,
+  tagNameOf
+};

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

@@ -1,50 +1,10 @@
-/**
- * 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/literal-call.d.ts

@@ -8,4 +8,5 @@ export type LiteralCall = {
         value?: unknown;
     }[];
 };
+export declare const TABLE_CALLEES: string[];
 export declare const literalNamedBy: (node: LiteralCall, callee: string) => string | null;

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

@@ -1,4 +1,5 @@
 // src/rules/lib/literal-call.ts
+var TABLE_CALLEES = ["sqliteTable", "pgTable"];
 var literalNamedBy = (node, callee) => {
   if (node.callee.type !== "Identifier" || node.callee.name !== callee)
     return null;
@@ -6,5 +7,6 @@ var literalNamedBy = (node, callee) => {
   return name?.type === "Literal" && typeof name.value === "string" ? name.value : null;
 };
 export {
+  TABLE_CALLEES,
   literalNamedBy
 };

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

@@ -1,43 +1,19 @@
-/**
- * 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 readSource: (file: string) => string | undefined;
+export declare const recordOf: (value: unknown) => Record<string, unknown> | undefined;
+export declare const readManifest: (file: string) => Record<string, unknown> | undefined;
 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/rules/lib/module-text.js

@@ -49,14 +49,26 @@ 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 = new Map;
-var readTable = (file) => {
-  let source;
+var readSource = (file) => {
   try {
-    source = stripComments(readFileSync(file, "utf8"));
+    return stripComments(readFileSync(file, "utf8"));
   } catch {
     return;
   }
+};
+var recordOf = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : undefined;
+var readManifest = (file) => {
+  try {
+    return recordOf(JSON.parse(readFileSync(file, "utf8")));
+  } catch {
+    return;
+  }
+};
+var tables = new Map;
+var readTable = (file) => {
+  const source = readSource(file);
+  if (source === undefined)
+    return;
   const declared = new Set;
   const reexports = new Map;
   const stars = [];
@@ -119,5 +131,8 @@ export {
   fileAt,
   fileFor,
   parseLooseJson,
+  readManifest,
+  readSource,
+  recordOf,
   stripComments
 };

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

@@ -1,19 +1,5 @@
 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/nodes.d.ts

@@ -1,25 +1,8 @@
 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 FUNCTION_BOUNDARY_TYPES: Set<string>;
 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;

package/dist/rules/lib/nodes.js

@@ -64,6 +64,7 @@ var calleeNameOf = (node) => {
   return callee?.type === "Identifier" && typeof callee.name === "string" ? callee.name : null;
 };
 export {
+  FUNCTION_BOUNDARY_TYPES,
   calleeNameOf,
   propertyNameOf,
   walkNode,