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

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

@@ -1,12 +1,3 @@
-/**
- * Reading the two places a component says what something looks like: `className` and `style`.
- *
- * Both conformance rules need the same three things — the string behind a `className`, the
- * `property: 'literal'` pairs behind a `style` object, and the arbitrary values a Tailwind class
- * carries in brackets — and neither of them needs the other's vocabulary. Written once here so the
- * two cannot disagree about what a className IS, which is the divergence the union of two plugins
- * was cut to end.
- */
 interface Node {
     type: string;
 }
@@ -20,46 +11,22 @@ interface Attribute extends Node {
 export interface OpeningElement extends Node {
     attributes?: Attribute[];
 }
-/** One `key: 'value'` pair of an inline style object, where both sides were written out. */
 interface StyleEntry {
     property: string;
     value: string;
 }
-/**
- * The literal text of a `className`, or nothing.
- *
- * A className assembled at runtime — `cn(base, isActive && 'x')`, a template with a hole — has no
- * one text, and guessing at one is how a rule reports a line the reader cannot find the value on.
- * Template quasis are joined because their static halves ARE written out, and a hardcoded colour
- * hides in them exactly as well as in a plain string.
- */
 export declare const classNameOf: (node: OpeningElement) => string | undefined;
-/**
- * The written-out entries of a `style={{ … }}` object.
- *
- * Only the pairs where BOTH halves are written out: a computed key or a value read from a variable
- * is a value this file cannot see, and reporting on it would be a guess. A spread is skipped for
- * the same reason.
- */
+export declare const staticClassNameOf: (node: OpeningElement) => string | undefined;
+export declare const keyOf: (property: {
+    computed?: boolean;
+    key?: Node & {
+        name?: string;
+        value?: unknown;
+    };
+}) => string | undefined;
 export declare const styleEntriesOf: (node: OpeningElement) => StyleEntry[];
-/**
- * Tailwind arbitrary values, as `[utility, inner]` pairs: `bg-[#fff]` → `['bg', '#fff']`.
- *
- * The utility half is returned because what is inside the brackets only means something with it:
- * `[tan]` is a colour after `text-` and a font after `font-`, and a rule that looked at the inner
- * text alone would have to guess which.
- */
+export declare const styleObjectOf: (node: OpeningElement) => Node | null;
 export declare const arbitraryValuesOf: (className: string) => [utility: string, inner: string][];
-/**
- * The custom properties the element sets on ITSELF, in its own `style`.
- *
- * A component that writes `style={{ '--pb-text': fromAProp }}` and reads `text-[var(--pb-text)]`
- * back is using a local alias: the variable is declared and consumed on one element and never
- * leaves it. Treating that as a component reaching around the theme reports an accepted convention,
- * which is how a rule earns the reputation that gets it switched off — measured on a consumer's
- * kit, where the pattern appears fifty times.
- */
 export declare const localVariablesOf: (node: OpeningElement) => Set<string>;
-/** The custom property a `var(--x)` names, or nothing. */
 export declare const variableOf: (value: string) => string | undefined;
 export {};

package/dist/rules/lib/styling.js

@@ -1,5 +1,7 @@
 // src/rules/lib/styling.ts
-var attributeNamed = (node, name) => node.attributes?.find((attribute) => attribute?.type === "JSXAttribute" && attribute.name?.type === "JSXIdentifier" && attribute.name.name === name);
+import { attributeNamed } from "./jsx.js";
+var isContainer = (node) => node.type === "JSXExpressionContainer";
+var isTemplate = (node) => node?.type === "TemplateLiteral";
 var classNameOf = (node) => {
   const value = attributeNamed(node, "className")?.value;
   if (value === undefined || value === null)
@@ -8,11 +10,19 @@ var classNameOf = (node) => {
     const literal = value.value;
     return typeof literal === "string" ? literal : undefined;
   }
-  if (value.type === "JSXExpressionContainer") {
+  if (isContainer(value))
     return expressionText(unwrap(value.expression));
-  }
   return;
 };
+var staticClassNameOf = (node) => {
+  const value = attributeNamed(node, "className")?.value;
+  if (value !== undefined && value !== null && isContainer(value)) {
+    const expression = unwrap(value.expression);
+    if (isTemplate(expression) && (expression.expressions ?? []).length > 0)
+      return;
+  }
+  return classNameOf(node);
+};
 var unwrap = (node) => {
   let current = node ?? null;
   while (current !== null && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) {
@@ -55,16 +65,29 @@ var styleEntriesOf = (node) => {
     return text === undefined ? [] : [{ property: name, value: text }];
   });
 };
-var styleProperties = (node) => {
+var styleObjectOf = (node) => {
   const value = attributeNamed(node, "style")?.value;
-  if (value?.type !== "JSXExpressionContainer")
-    return [];
+  if (value === undefined || value === null || !isContainer(value))
+    return null;
   const expression = unwrap(value.expression);
-  if (expression === null || expression.type !== "ObjectExpression")
-    return [];
-  return expression.properties ?? [];
+  return expression?.type === "ObjectExpression" ? expression : null;
+};
+var styleProperties = (node) => styleObjectOf(node)?.properties ?? [];
+var withoutVariants = (token) => {
+  let depth = 0;
+  let from = 0;
+  for (const [at, char] of [...token].entries()) {
+    if (char === "[")
+      depth += 1;
+    else if (char === "]")
+      depth -= 1;
+    else if (char === ":" && depth === 0)
+      from = at + 1;
+  }
+  return token.slice(from);
 };
-var arbitraryValuesOf = (className) => className.split(/\s+/).flatMap((token) => {
+var arbitraryValuesOf = (className) => className.split(/\s+/).flatMap((classToken) => {
+  const token = withoutVariants(classToken).replace(/^!|!$/g, "");
   const open = token.indexOf("[");
   const close = token.lastIndexOf("]");
   if (open <= 0 || close <= open)
@@ -84,7 +107,10 @@ var variableOf = (value) => /^var\(\s*(--[A-Za-z0-9_-]+)/.exec(value.trim())?.[1
 export {
   arbitraryValuesOf,
   classNameOf,
+  keyOf,
   localVariablesOf,
+  staticClassNameOf,
   styleEntriesOf,
+  styleObjectOf,
   variableOf
 };

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

@@ -1,31 +1,18 @@
-/**
- * The tiers, and the one path pattern every rule here tests a filename against.
- *
- * `(?:features/[^/]+/)?<tier>/` is a Medusa storefront's broader form, kept when the two forks were
- * merged: it reaches a flat kit (`packages/ui/src/tissues/…`) as well as a feature-sliced app, and
- * a rule that reaches more files is the stricter rule. The `(?:^|/)` anchor is this file's
- * addition, so `subtissues/` is not read as `tissues/`.
- */
 export declare const TIERS: readonly ['atoms', 'molecules', 'compounds', 'organelles', 'cells', 'tissues'];
 export type Tier = (typeof TIERS)[number];
+export declare const APP_FOLDER: RegExp;
+export declare const LAYOUTS_FOLDER: RegExp;
+export declare const STORES_FOLDER: RegExp;
+export declare const ABOVE_ATOMS_FOLDER: RegExp;
+export declare const ORGANS_FOLDER: RegExp;
+export declare const COMPONENT_FILE_PATTERN: RegExp;
+export declare const PRIVATE_SIBLING: RegExp;
+export declare const CELL_PRIVATE_SIBLING: RegExp;
 export declare const inTier: (filename: string, tier: Tier) => boolean;
-/** The tier a path sits in, or none. The layout gives a file one tier folder, so the first wins. */
+export declare const inOrgans: (filename: string) => boolean;
+export declare const folderOf: <Name extends string>(source: string, names: readonly Name[]) => Name | undefined;
+export declare const inTiersAbove: (filename: string, tier: Tier) => boolean;
 export declare const tierOf: (filename: string) => Tier | undefined;
-/**
- * The tier a file sits DIRECTLY in — the folder that is its own parent — or none.
- *
- * `tierOf` answers for anywhere in the path, which is what a rule about IMPORTS wants. A rule about
- * the file's own folder wants the parent and nothing else: `cells/parts/helper.ts` is in `parts/`,
- * and `subtissues/` is not `tissues/` however a regex written without an anchor read it (#5).
- */
 export declare const tierFolderOf: (filename: string) => Tier | undefined;
-/**
- * The feature a path belongs to, or none — a flat kit (`packages/ui/src/atoms/`) has tiers and no
- * features, and a rule that assumed otherwise simply never fired there.
- */
 export declare const featureOf: (filename: string) => string | undefined;
-/**
- * A `scope` naming something that is not a tier matches no file, which is the inert rule the
- * option refusal exists to stop — one option along. So it is a config error, and it stops the run.
- */
 export declare const requireTiers: (rule: string, names: readonly string[]) => Tier[];

package/dist/rules/lib/tiers.js

@@ -9,7 +9,35 @@ var PATTERNS = {
   organelles: /(?:^|\/)(?:features\/[^/]+\/)?organelles\//,
   tissues: /(?:^|\/)(?:features\/[^/]+\/)?tissues\//
 };
+var APP_FOLDER = /(?:^|\/)app\//;
+var LAYOUTS_FOLDER = /(?:^|\/)layouts\//;
+var STORES_FOLDER = /(?:^|\/)stores\//;
+var ABOVE_ATOMS_FOLDER = /(?:^|\/)(molecules|compounds|organelles|cells|layouts)\//;
+var ORGANS_FOLDER = /(?:^|\/)(?:features\/[^/]+\/)?organs\//;
+var COMPONENT_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+var SHARED_PRIVATE_SUFFIXES = [
+  "parts",
+  "sections",
+  "summary",
+  "layouts",
+  "icons",
+  "types",
+  "sidebar",
+  "data",
+  "stories",
+  "spec",
+  "test"
+];
+var privateSiblingOf = (...own) => new RegExp(`\\.(?:${[...SHARED_PRIVATE_SUFFIXES, ...own].join("|")})\\.tsx$`);
+var PRIVATE_SIBLING = privateSiblingOf("hooks", "utils", "context", "store", "config");
+var CELL_PRIVATE_SIBLING = privateSiblingOf("form", "steps");
 var inTier = (filename, tier) => PATTERNS[tier].test(normalise(filename));
+var inOrgans = (filename) => ORGANS_FOLDER.test(normalise(filename));
+var folderOf = (source, names) => {
+  const listed = new Set(names);
+  return normalise(source).split("/").find((segment) => listed.has(segment));
+};
+var inTiersAbove = (filename, tier) => TIERS.slice(TIERS.indexOf(tier) + 1).some((above) => inTier(filename, above));
 var tierOf = (filename) => TIERS.find((tier) => inTier(filename, tier));
 var tierFolderOf = (filename) => {
   const parent = normalise(filename).split("/").at(-2);
@@ -17,15 +45,27 @@ var tierFolderOf = (filename) => {
 };
 var FEATURE = /(?:^|\/)features\/([^/]+)\//;
 var featureOf = (filename) => FEATURE.exec(normalise(filename))?.[1];
+var isTier = (name) => TIERS.some((tier) => tier === name);
 var requireTiers = (rule, names) => names.map((name) => {
-  if (TIERS.includes(name))
+  if (isTier(name))
     return name;
   throw new Error(`biological-architecture/${rule} is scoped to "${name}", which is not a tier, so that scope can never match a file. The tiers are ${TIERS.join(", ")}.`);
 });
 export {
+  ABOVE_ATOMS_FOLDER,
+  APP_FOLDER,
+  CELL_PRIVATE_SIBLING,
+  COMPONENT_FILE_PATTERN,
+  LAYOUTS_FOLDER,
+  ORGANS_FOLDER,
+  PRIVATE_SIBLING,
+  STORES_FOLDER,
   TIERS,
   featureOf,
+  folderOf,
+  inOrgans,
   inTier,
+  inTiersAbove,
   requireTiers,
   tierFolderOf,
   tierOf

package/dist/rules/lib/tissue-entrypoint.d.ts

@@ -1,4 +1,3 @@
-/** `filename`'s last segment, and whether it IS the tissue arrangement entrypoint. */
 export declare const tissueEntrypointOf: (filename: string) => {
     basename: string;
     isEntrypoint: boolean;

package/dist/rules/lib/tissue-entrypoint.js

@@ -1,13 +1,12 @@
 // src/rules/lib/tissue-entrypoint.ts
-import { normalise } from "./paths.js";
-var TISSUE_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?tissues\//;
-var PRIVATE_TISSUE_SIBLING = /\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config|stories|spec|test)\.tsx$/;
+import { fileOf, normalise } from "./paths.js";
+import { inTier, PRIVATE_SIBLING } from "./tiers.js";
 var tissueEntrypointOf = (filename) => {
   const normalized = normalise(filename);
-  const basename = normalized.split("/").pop() || normalized;
+  const basename = fileOf(normalized);
   return {
     basename,
-    isEntrypoint: TISSUE_FILE_PATTERN.test(normalized) && basename.endsWith(".tsx") && basename !== "index.tsx" && !PRIVATE_TISSUE_SIBLING.test(basename)
+    isEntrypoint: inTier(normalized, "tissues") && basename.endsWith(".tsx") && basename !== "index.tsx" && !PRIVATE_SIBLING.test(basename)
   };
 };
 export {

package/dist/rules/lib/tsconfig-paths.d.ts

@@ -1,5 +1 @@
-/**
- * The places `paths` says a specifier may be, best match first — as bases without extensions,
- * for the caller to find the file at. Empty when no config maps it.
- */
 export declare const aliasCandidates: (importer: string, source: string) => string[];

package/dist/rules/lib/tsconfig-paths.js

@@ -1,7 +1,7 @@
 // src/rules/lib/tsconfig-paths.ts
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { parseLooseJson } from "./module-text.js";
+import { parseLooseJson, readManifest } from "./module-text.js";
 import { longestMatch } from "./pattern-match.js";
 var CHAIN = 5;
 var configs = new Map;
@@ -26,12 +26,7 @@ var baseFileOf = (dir, base) => {
     return;
   if (rest !== "")
     return withJson(join(packageDir, rest));
-  let declared;
-  try {
-    declared = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")).tsconfig;
-  } catch {
-    declared = undefined;
-  }
+  const declared = readManifest(join(packageDir, "package.json"))?.tsconfig;
   return join(packageDir, typeof declared === "string" ? declared : "tsconfig.json");
 };
 var packageDirAbove = (dir, name) => {
@@ -77,19 +72,56 @@ var readConfig = (file) => {
   }
   return { anchor, paths };
 };
+var GLOB = /[*?{[]/;
+var strings = (value) => Array.isArray(value) ? value.filter((one) => typeof one === "string") : [];
+var referencePathsOf = (references) => (Array.isArray(references) ? references : []).flatMap((one) => {
+  if (typeof one !== "object" || one === null || !("path" in one))
+    return [];
+  return typeof one.path === "string" ? [one.path] : [];
+});
+var includedBy = (file) => {
+  const dir = dirname(file);
+  const entries = strings(rawOf(file)?.include);
+  return entries.length === 0 ? [dir] : entries.map((entry) => {
+    const segments = entry.split("/");
+    const globAt = segments.findIndex((one) => GLOB.test(one));
+    const head = globAt === -1 ? segments : segments.slice(0, globAt);
+    const last = head.at(-1);
+    const literal = last !== undefined && /\.[a-z]+$/.test(last) ? head.slice(0, -1) : head;
+    return resolve(dir, ...literal);
+  });
+};
+var isUnder = (dir, parent) => dir === parent || dir.startsWith(`${parent}/`);
+var referencedConfig = (file, dir) => {
+  const refs = rawOf(file)?.references;
+  for (const named of referencePathsOf(refs)) {
+    const target = resolve(dirname(file), named);
+    const config = CONFIG_FILES.map((name) => join(target, name)).find((one) => existsSync(one));
+    const project = config ?? (target.endsWith(".json") ? target : withJson(target));
+    if (!existsSync(project))
+      continue;
+    if (!includedBy(project).some((included) => isUnder(dir, included)))
+      continue;
+    const found = readConfig(project);
+    if (found !== null)
+      return found;
+  }
+  return null;
+};
 var CONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+var nearestConfigFile = (dir) => {
+  const file = CONFIG_FILES.map((name) => join(dir, name)).find((one) => existsSync(one));
+  if (file !== undefined)
+    return file;
+  const parent = dirname(dir);
+  return parent === dir ? undefined : nearestConfigFile(parent);
+};
 var configFor = (dir) => {
   const known = configs.get(dir);
   if (known !== undefined)
     return known;
-  let found = null;
-  const file = CONFIG_FILES.map((name) => join(dir, name)).find((one) => existsSync(one));
-  if (file !== undefined)
-    found = readConfig(file);
-  else {
-    const parent = dirname(dir);
-    found = parent === dir ? null : configFor(parent);
-  }
+  const file = nearestConfigFile(dir);
+  const found = file === undefined ? null : readConfig(file) ?? referencedConfig(file, dir);
   configs.set(dir, found);
   return found;
 };

package/dist/rules/lib/type-members.d.ts

@@ -0,0 +1,6 @@
+export interface TypeMember {
+    name: string;
+    type: string;
+}
+export declare const membersOfNamedType: (file: string, name: string) => TypeMember[] | undefined;
+export declare const callableOrUndeclared: (type: string) => 'handler' | 'undeclared' | undefined;

package/dist/rules/lib/type-members.js

@@ -0,0 +1,165 @@
+// src/rules/lib/type-members.ts
+import { readSource } from "./module-text.js";
+var DEPTH = 4;
+var OPENERS = new Set(["(", "[", "{", "<"]);
+var CLOSERS = new Set([")", "]", "}", ">"]);
+var QUOTES = new Set(['"', "'", "`"]);
+var nextOutside = (text, from) => {
+  const quote = text[from];
+  if (quote === undefined || !QUOTES.has(quote))
+    return from;
+  let at = from + 1;
+  while (at < text.length && text[at] !== quote)
+    at += text[at] === "\\" ? 2 : 1;
+  return at;
+};
+function* scan(text, from = 0) {
+  let depth = 0;
+  for (let at = from;at < text.length; at += 1) {
+    at = nextOutside(text, at);
+    const char = text[at] ?? "";
+    const closes = CLOSERS.has(char) && !(char === ">" && text[at - 1] === "=");
+    if (OPENERS.has(char))
+      depth += 1;
+    else if (closes)
+      depth -= 1;
+    yield { at, char, closes, depth };
+  }
+}
+var closesAt = (text, open) => {
+  for (const { at, closes, depth } of scan(text, open))
+    if (closes && depth === 0)
+      return at;
+  return -1;
+};
+var splitTop = (text, separators) => {
+  const parts = [];
+  let from = 0;
+  for (const { at, char, depth } of scan(text)) {
+    if (depth === 0 && separators.has(char)) {
+      parts.push(text.slice(from, at));
+      from = at + 1;
+    }
+  }
+  parts.push(text.slice(from));
+  return parts.map((one) => one.trim()).filter((one) => one !== "");
+};
+var CONTINUES_BEFORE = /(?:[|&:=,(<]|=>)\s*$/;
+var CONTINUES_AFTER = /^\s*[|&?:.=)]/;
+var membersText = (body) => {
+  const members = [];
+  let from = 0;
+  for (const { at, char, depth } of scan(body)) {
+    if (depth !== 0)
+      continue;
+    if (char === ";" || char === ",") {
+      members.push(body.slice(from, at));
+      from = at + 1;
+    } else if (char === `
+`) {
+      const current = body.slice(from, at);
+      if (current.trim() !== "" && !CONTINUES_BEFORE.test(current) && !CONTINUES_AFTER.test(body.slice(at + 1))) {
+        members.push(current);
+        from = at + 1;
+      }
+    }
+  }
+  members.push(body.slice(from));
+  return members.map((one) => one.trim()).filter((one) => one !== "");
+};
+var KEY = /^(?:readonly\s+)?(?:(["'])(.*?)\1|([A-Za-z_$][\w$]*))\s*\??\s*(?=[:(<])/;
+var memberOf = (text) => {
+  const key = KEY.exec(text);
+  if (key === null)
+    return;
+  const name = key[2] ?? key[3] ?? "";
+  const rest = text.slice(key[0].length).trim();
+  if (rest.startsWith(":"))
+    return { name, type: rest.slice(1).trim() };
+  const generics = rest.startsWith("<") ? closesAt(rest, 0) + 1 : 0;
+  const open = generics > 0 ? generics : 0;
+  if (rest[open] !== "(")
+    return;
+  const close = closesAt(rest, open);
+  if (close === -1)
+    return;
+  const returned = rest.slice(close + 1).replace(/^\s*:\s*/, "");
+  return { name, type: `${rest.slice(0, close + 1)} => ${returned === "" ? "void" : returned}` };
+};
+var parseMembers = (body) => membersText(body).flatMap((one) => memberOf(one) ?? []);
+var escaped = (name) => name.replaceAll("$", String.raw`\$`);
+var bodyAfter = (text, from) => {
+  const open = text.indexOf("{", from);
+  if (open === -1)
+    return;
+  const close = closesAt(text, open);
+  return close === -1 ? undefined : text.slice(open + 1, close);
+};
+var aliasText = (text, from) => {
+  let end = from;
+  for (const { at, char, depth } of scan(text, from)) {
+    if (depth === 0 && (char === ";" || char === `
+`)) {
+      const scanned = text.slice(from, at);
+      if (char === ";" || scanned.trim() !== "" && !CONTINUES_BEFORE.test(scanned) && !CONTINUES_AFTER.test(text.slice(at + 1))) {
+        end = at;
+        break;
+      }
+    }
+    end = at + 1;
+  }
+  return text.slice(from, end);
+};
+var IDENTIFIER_TYPE = /^([A-Za-z_$][\w$]*)(?:<.*>)?$/s;
+var membersIn = (text, name, depth) => {
+  if (depth > DEPTH)
+    return;
+  const interfaced = new RegExp(String.raw`\binterface\s+${escaped(name)}\b`).exec(text);
+  if (interfaced !== null) {
+    const body = bodyAfter(text, interfaced.index + interfaced[0].length);
+    return body === undefined ? undefined : parseMembers(body);
+  }
+  const aliased = new RegExp(String.raw`\btype\s+${escaped(name)}\b[^=]*=\s*`).exec(text);
+  if (aliased === null)
+    return;
+  const parts = splitTop(aliasText(text, aliased.index + aliased[0].length), new Set(["&"]));
+  const found = parts.flatMap((part) => {
+    if (part.startsWith("{") && closesAt(part, 0) === part.length - 1) {
+      return [parseMembers(part.slice(1, -1))];
+    }
+    const named = IDENTIFIER_TYPE.exec(part)?.[1];
+    const inner = named === undefined ? undefined : membersIn(text, named, depth + 1);
+    return inner === undefined ? [] : [inner];
+  });
+  return found.length === 0 ? undefined : found.flat();
+};
+var membersOfNamedType = (file, name) => {
+  const text = readSource(file);
+  return text === undefined ? undefined : membersIn(text, name, 0);
+};
+var STATE_REFERENCE = /^(?:React\.)?(?:Dispatch|SetStateAction)\b|^Function$/;
+var UNDECLARED = new Set(["any", "unknown", "object", "{}"]);
+var unwrapped = (type) => {
+  let current = type.trim();
+  while (current.startsWith("(") && closesAt(current, 0) === current.length - 1) {
+    current = current.slice(1, -1).trim();
+  }
+  return current;
+};
+var isFunctionType = (type) => {
+  const from = type.startsWith("<") ? closesAt(type, 0) + 1 : 0;
+  if (type[from] !== "(")
+    return false;
+  const close = closesAt(type, from);
+  return close !== -1 && /^\s*=>/.test(type.slice(close + 1));
+};
+var callableOrUndeclared = (type) => {
+  const alternatives = splitTop(unwrapped(type), new Set(["|"])).map(unwrapped);
+  if (alternatives.some((one) => isFunctionType(one) || STATE_REFERENCE.test(one)))
+    return "handler";
+  return alternatives.some((one) => UNDECLARED.has(one.replaceAll(/\s+/g, ""))) ? "undeclared" : undefined;
+};
+export {
+  callableOrUndeclared,
+  membersOfNamedType
+};

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

@@ -2,30 +2,8 @@ import { type ModuleNode } from './imports.js';
 export type Visitor = Record<string, ((node: never) => void) | undefined>;
 type ImportHandler = (source: string, node: ModuleNode) => void;
 type ImportOptions = {
-    /**
-     * Whether `import type` and `export type … from` are visited. They are not, by default: a type a
-     * bundler erases is not a dependency, and every direction rule here says so. `no-orm-outside-db`
-     * is the exception that made this an option — a type borrowed from the ORM is still a line a
-     * replacement would have to rewrite, so that rule counts them.
-     */
     typeOnly?: 'skip' | 'visit';
 };
-/**
- * One visitor set for every way a file can name another: `import`, `export … from`, `export * from`,
- * `import()` and `require()`.
- *
- * Eleven rules hand-wrote three of these keys; the ones whose author had met a dynamic import wrote
- * a fourth. Which doors a wall was watched at became an accident of who wrote the rule, and a wall
- * with a door left open is not a wall. The handler takes the source AND the node, because a rule
- * that reports wants the node and a rule like `organelle-single-source` wants its specifiers.
- */
 export declare const onImportSource: (onSource: ImportHandler, { typeOnly }?: ImportOptions) => Visitor;
-/**
- * Two visitor sets as one, with both handlers run for a node type they both name.
- *
- * A rule that watches imports AND something else — `dialect-through-the-seam` also reads
- * `sql.raw(…)` calls, `organelle-single-source` also counts store hooks — would otherwise have to
- * spread one object over the other, and the spread SILENTLY drops the handler underneath it.
- */
 export declare const mergeVisitors: (...visitors: Visitor[]) => Visitor;
 export {};

package/dist/rules/lib/workspace-members.d.ts

@@ -0,0 +1,2 @@
+export declare const workspaceMemberNamed: (from: string, name: string) => string | undefined;
+export declare const hasWorkspaceAbove: (from: string) => boolean;