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

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

@@ -1,17 +1,8 @@
 import type { AnyNode } from './nodes.js';
-/** The expression under any `as` / `satisfies` — a retyped value is the value it was. */
 export declare const withoutTypes: (node: unknown) => AnyNode | undefined;
-/**
- * The properties of an object literal, or **null when it cannot be read whole**.
- *
- * A spread hides properties, and the posture this plugin already took for `emit-declares-attempts`
- * is the one that holds here too: a rule that guessed at what a spread contains would fire on every
- * repo that factored its configs out, and people would learn to ignore it. Unreadable is not the
- * same as absent, and only one of the two is a finding.
- */
 export declare const propertiesOf: (node: unknown) => AnyNode[] | null;
-/** The value of the named property, or undefined. `name` and `'name'` are read alike; `[name]` is not. */
 export declare const valueOf: (properties: readonly AnyNode[], name: string) => AnyNode | undefined;
 export declare const hasProperty: (properties: readonly AnyNode[], name: string) => boolean;
-/** The string a node literally is, or null — a constant is a value this cannot read. */
 export declare const stringOf: (node: unknown) => string | null;
+export declare const keyNameOf: (node: AnyNode) => string | null;
+export declare const destructuredNamesOf: (pattern: unknown) => string[] | null;

package/dist/rules/lib/objects.js

@@ -26,8 +26,29 @@ var stringOf = (node) => {
   const literal = node;
   return literal?.type === "Literal" && typeof literal.value === "string" ? literal.value : null;
 };
+var keyNameOf = (node) => {
+  const key = node.key;
+  if (key?.type === "Identifier" && typeof key.name === "string")
+    return key.name;
+  return stringOf(key);
+};
+var destructuredNamesOf = (pattern) => {
+  const at = pattern;
+  if (at?.type !== "ObjectPattern")
+    return null;
+  const names = [];
+  for (const one of at.properties ?? []) {
+    const name = one.type === "Property" && one.computed !== true ? keyNameOf(one) : null;
+    if (name === null)
+      return null;
+    names.push(name);
+  }
+  return names;
+};
 export {
+  destructuredNamesOf,
   hasProperty,
+  keyNameOf,
   propertiesOf,
   stringOf,
   valueOf,

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

@@ -1,34 +1,10 @@
-/**
- * #199: the rule and the option it REQUIRES, in one fixed position at the front of the finding.
- *
- * The prose after it quotes every option the rule accepts, which is what a consumer with a
- * half-written config needs — and is exactly why a reader matching the option name anywhere in the
- * message cannot tell a required option from a mentioned one. `refuses-bare.bin.test.ts` asserted
- * that way and passed for a release over an entry claiming `engine` for a rule that requires
- * `within`. The doctor and the cli read the pair out of this header and nowhere else.
- */
 export declare const refusalHeader: (rule: string, option: string) => string;
-/**
- * The signal a rule raises when an option it cannot run without is missing. Carries the pair a
- * reader would otherwise parse back out of the sentence. Caught by `reportingOncePerRun` in the
- * registry; a `create` reached WITHOUT the registry (a unit test on the rule module) sees it thrown,
- * which is the rule saying what it requires, not the plugin's behaviour.
- */
 export declare class OptionMissing extends Error {
     readonly option: string;
     readonly rule: string;
     constructor(rule: string, option: string, message: string);
 }
-/**
- * A regex-source option in either shape: a bare string is a one-element list.
- *
- * The seven tree options #12 added in one commit shipped as three strings and four lists. A
- * consumer wrote `seam` as a string, oxlint refused the config at options validation, and every
- * rule in it read 0 with exit 1 — a config mistake presenting as a clean zero. One shape rule for
- * all of them, read here and declared by `PATTERNS` below, so the reader never has to know which.
- */
 export declare const patternsOf: (value: string | readonly string[] | null | undefined) => string[];
-/** The JSON schema for an option `patternsOf` reads: `string | string[]`. */
 export declare const PATTERNS: {
     anyOf: ({
         type: 'string';
@@ -40,35 +16,9 @@ export declare const PATTERNS: {
         type: 'array';
     })[];
 };
-/**
- * #203: a test file is not a door/seam rule's business anywhere, so the default says so — the
- * fallback for an `exempt` option a repo has not configured.
- *
- * `time-through-the-door` 1.4.0 had `__tests__` compiled in; making every path an option (law 6)
- * emptied it, and the reach GREW — a Workers + D1 app's first RC run reported six findings in test
- * files that had never been in scope. Test paths are not consumer vocabulary the way a door is:
- * every repo spells them these three ways, and a repo with a fourth spelling names its own list and
- * replaces this one. `dialect-through-the-seam` held the identical array as its own copy; one now.
- */
+export declare const DEFAULT_TENANT_KEY = "orgId";
 export declare const DEFAULT_TEST_EXEMPT: string[];
-/**
- * The value, or the requirement raised, naming the rule and the option. Read by the rule, judged
- * here: some of these options are keyed and one is positional, and what they have in common is not
- * their shape but that the rule cannot fire without them.
- *
- * `accepts` is the whole option bag written out — `{ roots: string[], registry: string | string[] }`
- * — appended so the accepted shape comes back WITH the finding. Without it the only way to learn
- * what a rule takes is to read the dist bundle, which is how a consumer whose registry is split
- * reached for a list, was told `should be string`, and could not tell from the refusal whether a
- * list was a shape the rule had or a shape it lacked. Optional, so a rule that has not written its
- * shape down is reported exactly as it always was.
- *
- * #205 is history now: a `requireOptionHere` once waited for a file a tree-scoped rule would judge
- * and named it in the refusal, because a refusal thrown over every package the preset reached was
- * noise a consumer learned to route around. Reported once a run, a refusal has no per-package
- * noise to wait out, and no rule was calling it, so it is gone.
- */
 export declare const requireOption: <Value>(rule: string, value: Value | null | undefined, option: string, accepts?: string) => Value;
 type Create<Context> = (context: Context) => Record<string, unknown>;
-export declare const reportingOncePerRun: <Context>(create: Create<Context>) => Create<Context>;
+export declare const reportingOncePerRun: <Context>(create: Create<Context>, rule?: string) => Create<Context>;
 export {};

package/dist/rules/lib/options.js

@@ -1,5 +1,4 @@
 // src/rules/lib/options.ts
-var NOTHING = "nothing";
 var isMissing = (value) => value === undefined || value === null || value === "" || Array.isArray(value) && value.length === 0;
 var refusalHeader = (rule, option) => `biological-architecture/${rule} requires option \`${option}\`.`;
 
@@ -20,40 +19,67 @@ var PATTERNS = {
     { items: { type: "string" }, type: "array" }
   ]
 };
+var DEFAULT_TENANT_KEY = "orgId";
 var DEFAULT_TEST_EXEMPT = ["__tests__/", String.raw`\.test\.`, String.raw`\.spec\.`];
 var requireOption = (rule, value, option, accepts) => {
   if (isMissing(value)) {
-    throw new OptionMissing(rule, option, `${refusalHeader(rule, option)} It is enabled but its \`${option}\` option is ${NOTHING}, so it judges no file — this finding stands in for every file it did not read, once a run. Configure \`${option}\`, or turn the rule off: an enabled rule that judges nothing would otherwise read exactly like a rule that found nothing.${accepts === undefined ? "" : ` It accepts ${accepts}.`}`);
+    throw new OptionMissing(rule, option, `${refusalHeader(rule, option)} It is enabled but its \`${option}\` option is nothing, so it judges no file — this finding stands in for every file it did not read, once a run. Configure \`${option}\`, or turn the rule off: an enabled rule that judges nothing would otherwise read exactly like a rule that found nothing.${accepts === undefined ? "" : ` It accepts ${accepts}.`}`);
   }
   return value;
 };
 var raisedOver = new Map;
-var fileOf = (context) => {
+var filenameOf = (context) => {
   const named = context?.filename;
   return typeof named === "string" ? named : "";
 };
-var reportingOncePerRun = (create) => (context) => {
+var badPatternMessage = (rule, error) => `biological-architecture/${rule} threw a SyntaxError — ${error.message}. An option of this rule holds a pattern that is not a regular expression. This finding stands in for every file it could not judge, once a run; fix the pattern, or turn the rule off.`;
+var onceFor = (key, file) => {
+  if (file === "")
+    return true;
+  const first = raisedOver.get(key);
+  if (first !== undefined && first !== file)
+    return false;
+  raisedOver.set(key, file);
+  return true;
+};
+var refusalVisitor = (context, key, finding) => onceFor(key, filenameOf(context)) ? {
+  Program(node) {
+    context.report({ ...finding, node });
+  }
+} : {};
+var reportedAtVisit = (visitor, rule, context) => Object.fromEntries(Object.entries(visitor).map(([name, handler]) => [
+  name,
+  typeof handler === "function" ? (node) => {
+    try {
+      handler(node);
+    } catch (error) {
+      if (!(error instanceof SyntaxError))
+        throw error;
+      if (!onceFor(`${rule}/pattern`, filenameOf(context)))
+        return;
+      context.report({ message: badPatternMessage(rule, error), node });
+    }
+  } : handler
+]));
+var reportingOncePerRun = (create, rule = "") => (context) => {
   try {
-    return create(context);
+    return reportedAtVisit(create(context), rule, context);
   } catch (error) {
+    if (error instanceof SyntaxError) {
+      return refusalVisitor(context, `${rule}/pattern`, {
+        message: badPatternMessage(rule, error)
+      });
+    }
     if (!(error instanceof OptionMissing))
       throw error;
-    const file = fileOf(context);
-    if (file !== "") {
-      const key = `${error.rule}/${error.option}`;
-      const first = raisedOver.get(key);
-      if (first !== undefined && first !== file)
-        return {};
-      raisedOver.set(key, file);
-    }
-    return {
-      Program(node) {
-        context.report({ message: error.message, node });
-      }
-    };
+    return refusalVisitor(context, `${error.rule}/${error.option}`, {
+      data: { option: error.option, rule: error.rule },
+      message: error.message
+    });
   }
 };
 export {
+  DEFAULT_TENANT_KEY,
   DEFAULT_TEST_EXEMPT,
   OptionMissing,
   PATTERNS,

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

@@ -1,6 +1 @@
-/**
- * The places the manifest says a `#` specifier may be, best match first — as bases without
- * extensions, for the caller to find the file at. A target that is not relative names a package,
- * which is not a file in this repo, and is left out. Empty when no manifest maps it.
- */
 export declare const importCandidates: (importer: string, source: string) => string[];

package/dist/rules/lib/package-imports.js

@@ -1,18 +1,12 @@
 // src/rules/lib/package-imports.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { conditionTargetOf } from "./module-text.js";
+import { conditionTargetOf, readManifest, recordOf } from "./module-text.js";
 import { longestMatch } from "./pattern-match.js";
 var manifests = new Map;
 var readImports = (file) => {
-  try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
-    if (typeof parsed.imports !== "object" || parsed.imports === null)
-      return null;
-    return { dir: dirname(file), imports: parsed.imports };
-  } catch {
-    return null;
-  }
+  const imports = recordOf(readManifest(file)?.imports);
+  return imports === undefined ? null : { dir: dirname(file), imports };
 };
 var importsFor = (dir) => {
   const known = manifests.get(dir);

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

@@ -1,47 +1,21 @@
-/**
- * The one place a filename becomes a path.
- *
- * oxlint hands a rule the name the platform gave it, so on Windows it arrives with backslashes and
- * every pattern in this plugin — which is written with `/` — misses. Thirty-seven rules carried
- * their own copy of the conversion, spelled three different ways, and one of them fixed only the
- * first separator. A single fix to how a path is read had to be found rule by rule; now there is
- * one line to find.
- */
 export declare const normalise: (filename: string) => string;
-/**
- * The last segment of a path — what a diagnostic calls the file. An empty last segment is not a
- * name, so a path that ends in a separator answers with itself rather than with `""`.
- */
 export declare const fileOf: (path: string) => string;
-/**
- * Whether a file IS a door a repo named — one grammar for every rule that has doors (#204).
- *
- * A repo writes its time module down once and enables two rules with it. `time-through-the-door`
- * took a REGEX over the filename; `boundary-time-is-primitive` compared a plain path, so the same
- * spelling — `packages/utils/src/time\.ts$`, or the specifier callers import it by — made the
- * second rule report the door's own signatures. All three spellings are accepted here: the exact
- * path, a path the filename ends with (a specifier is one), and a regex over the filename.
- */
 export declare const isDoor: (filename: string, door: string) => boolean;
-/**
- * Whether a file IS one of an ENUMERATED list of modules — never a pattern.
- *
- * The counterpart to a path grant, and deliberately not `isDoor`: a door accepts a regex, and a
- * regex is exactly the glob whose exemption stops wherever it happens to stop. An entry here names
- * one module, by its full path or by the tail a repo writes it as, so the count of exemptions is a
- * number a reader can hold.
- */
 export declare const isModule: (filename: string, module: string) => boolean;
-/**
- * Whether a NORMALISED path sits inside a `__tests__/` directory — the exemption five rules
- * (tissue-no-data-props, next-route-segment-is-thin-delegate, no-inert-hidden-jsx,
- * no-hook-in-component-disguise, no-trivial-wrapper-component) each spelled as their own
- * `/__tests__\//` literal. Takes an already-`normalise`d path, the shape every call site already
- * held in a local before testing it.
- */
+export declare const isExempt: (filename: string, { allow, exemptModules }: {
+    allow?: string[];
+    exemptModules?: string[];
+}) => boolean;
 export declare const isTestFile: (path: string) => boolean;
-/**
- * Whether a NORMALISED path matches any of a list of regex sources — `dialect-through-the-seam`
- * and `no-d1-transaction` each carried this loop by hand, over the same shape of option.
- */
 export declare const anyOf: (patterns: readonly string[], path: string) => boolean;
+export declare const matchesAny: (patterns: readonly RegExp[], path: string) => boolean;
+export declare const trimSlashes: (path: string) => string;
+export declare const rootedAt: (filename: string, directory: string) => {
+    after: string;
+    repoRoot: string;
+} | null;
+export declare const HARNESS_PATHS: string[];
+export declare const ROUTE_FALLBACK_BASENAMES: Set<string>;
+export declare const LAYOUT_BASENAMES: Set<string>;
+export declare const ROUTE_BODY_BASENAMES: Set<string>;
+export declare const ROUTE_BASENAMES: Set<string>;

package/dist/rules/lib/paths.js

@@ -16,13 +16,46 @@ var isModule = (filename, module) => {
   const named = module.replace(/^\.?\//, "");
   return path === named || path.endsWith(`/${named}`);
 };
+var isExempt = (filename, { allow = [], exemptModules = [] }) => exemptModules.some((module) => isModule(filename, module)) || allow.some((path) => filename.includes(path));
 var isTestFile = (path) => /__tests__\//.test(path);
 var anyOf = (patterns, path) => patterns.some((pattern) => new RegExp(pattern).test(path));
+var matchesAny = (patterns, path) => patterns.some((pattern) => pattern.test(path));
+var trimSlashes = (path) => path.replace(/^\/+/, "").replace(/\/+$/, "");
+var rootedAt = (filename, directory) => {
+  const marker = `/${directory}/`;
+  const at = filename.indexOf(marker);
+  return at < 0 ? null : { after: filename.slice(at + marker.length), repoRoot: filename.slice(0, at) };
+};
+var HARNESS_PATHS = [
+  String.raw`/__tests__/`,
+  String.raw`/scripts/`,
+  String.raw`/testing/`,
+  String.raw`/seeds/`
+];
+var ROUTE_FALLBACK_BASENAMES = new Set([
+  "default.tsx",
+  "error.tsx",
+  "global-error.tsx",
+  "loading.tsx",
+  "not-found.tsx"
+]);
+var LAYOUT_BASENAMES = new Set(["layout.tsx", "template.tsx"]);
+var ROUTE_BODY_BASENAMES = new Set([...LAYOUT_BASENAMES, "page.tsx"]);
+var ROUTE_BASENAMES = new Set([...ROUTE_FALLBACK_BASENAMES, ...ROUTE_BODY_BASENAMES]);
 export {
+  HARNESS_PATHS,
+  LAYOUT_BASENAMES,
+  ROUTE_BASENAMES,
+  ROUTE_BODY_BASENAMES,
+  ROUTE_FALLBACK_BASENAMES,
   anyOf,
   fileOf,
   isDoor,
+  isExempt,
   isModule,
   isTestFile,
-  normalise
+  matchesAny,
+  normalise,
+  rootedAt,
+  trimSlashes
 };

package/dist/rules/lib/pattern-match.d.ts

@@ -1,16 +1,6 @@
-/**
- * The longest match for a wildcard pattern against a source string — tsc's own rule for
- * `tsconfig.json` `paths`, and the same rule Node uses for `package.json` `imports`. An exact key
- * wins outright; a pattern with one `*` matches when the source starts with what comes before it
- * and ends with what comes after, and among those the longest fixed (non-star) part wins.
- *
- * `tsconfig-paths.ts` and `package-imports.ts` each carried this loop by hand, spelled identically
- * down to the variable names — one truth about how a wildcard map is searched, read for two
- * different maps. What each caller does with the match (a `paths` entry names several targets and
- * takes `target.replace`; an `imports` value is one target read through `conditionTargetOf` and
- * takes `target.replaceAll`) is NOT unified here, because those two shapes are not the same truth.
- */
 export declare const longestMatch: <Value>(entries: Iterable<[string, Value]>, source: string) => {
     matched: string;
     value: Value;
 } | undefined;
+export declare const escapeForRegex: (value: string) => string;
+export declare const readableSource: (pattern: string) => string;

package/dist/rules/lib/pattern-match.js

@@ -24,6 +24,10 @@ var longestMatch = (entries, source) => {
   }
   return best === undefined ? undefined : { matched: best.matched, value: best.value };
 };
+var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var readableSource = (pattern) => pattern.replaceAll("\\", "").replace(/\$$/, "");
 export {
-  longestMatch
+  escapeForRegex,
+  longestMatch,
+  readableSource
 };

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

@@ -1,55 +1,12 @@
-/**
- * The file a rule says MUST fire it, given the options it was handed.
- *
- * `requireOption` closed one hole: an enabled rule with no option reports that, once a run,
- * instead of reading as a clean tree. It leaves the next one open. A rule CONFIGURED with a repo's own
- * vocabulary — its own brand, `packages/workflows/src/`, `@repo/db` — cannot be exercised by a corpus
- * that ships fixtures saying `acme` and `corpus/workflows/`, so "fires nowhere" is what an
- * adoption's doctor reports about a rule the repo is enforcing perfectly well. Both consumers filed
- * exactly that on 2026-08-30, and both were right about the fact and wrong about whose defect it is.
- *
- * A probe is the answer the rule itself can give: hand it the options and it writes the smallest
- * source that must fire it under THOSE options, at a path that lands where it looks. It is a claim,
- * so it is tested through the real binary — a probe that does not fire is a rule that cannot be
- * exercised, and the honest thing then is to say so rather than to widen the probe until it does.
- */
 export type Probe = {
-    /** Repo-root-relative, `/`-separated. It must satisfy every PATH option the rule reads. */
     path: string;
     source: string;
 };
-/**
- * A probe that needs a TREE rather than a file.
- *
- * A rule that reads a sibling off disk — a registry, a schema's twin — cannot be exercised by one
- * file however right its source is: `no-unregistered-plugin-dir` returns silently when the registry
- * its options name is not there, so the single-file probe fired nothing and every consumer
- * enforcing the rule over a real registry read as a permanent FAIL. The answer is not a widened
- * probe, which would be the rule claiming evidence it does not have; it is a probe that may declare
- * the sibling too, and a reader that mounts all of them.
- */
 export type ProbeTree = {
     files: readonly Probe[];
 };
 export type ProbeFn = (options: readonly unknown[]) => Probe | ProbeTree;
-/** The files a probe declares, whichever of the two forms it answered in. */
 export declare const filesOf: (answer: Probe | ProbeTree) => readonly Probe[];
-/** The bag a rule reads its keyed options out of, whatever the caller passed. */
 export declare const bagOf: <Options>(options: readonly unknown[]) => Partial<Options>;
-/**
- * The first configured value, or the first default. A probe reads the option the same way `create`
- * does, defaults included — otherwise a repo keeping a default would get a probe built for a value
- * its rule is not using, which fires nowhere and blames the repo for it.
- */
 export declare const firstOf: (configured: readonly string[] | undefined, fallback: readonly string[]) => string;
-/**
- * A path a regex option would match, built back out of the regex.
- *
- * The path options in this plugin are regex SOURCES — `within`, `paths`, `directories`, a layer's
- * `paths` — so a probe cannot be written against them without inverting one. This inverts the
- * subset those options are actually written in: anchors, non-capturing groups, one-segment
- * wildcards and escaped separators. It is deliberately not a general inverse, and it never has to
- * be trusted: the caller tests the result against the pattern it came from and refuses when it
- * does not match, which turns a wrong guess into a sentence rather than into a silent zero.
- */
 export declare const pathMatching: (pattern: string, leaf: string) => string;

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

@@ -1,20 +1,2 @@
-/**
- * A pure re-export shim (only `export … from`, no component) is a compatibility alias left behind
- * when a component moves to a feature folder — not the tier it sits in. Three rules read this off
- * the file, each with its own copy.
- */
 export declare function isReexportOnly(file: string): boolean;
-/**
- * Where a shim's code LIVES, when that is not the shim's own tier — or undefined when the file is
- * not a pure re-export shim at all.
- *
- * The three "must" rules exempted every shim outright, and that was #11's hole surviving in three
- * rules the direction rules' fix did not reach (row 594): `cells/laundered.tsx` re-exporting a
- * stateless compound is a cell that holds no state, and `tissues/alias.tsx` re-exporting a compound
- * is a tissue that composes nothing. Each name the shim hands on is followed to the file that
- * declares it, as the direction rules follow it; an `export *` is judged at the module it hands
- * through. A home in the shim's own tier is the alias the exemption was written for and is not
- * named. A re-export nothing on disk answers — a bare package — is not named either: unresolved
- * stays exempt, exactly as before.
- */
 export declare const launderedHomesOf: (file: string) => string[] | undefined;

package/dist/rules/lib/render-tracking.d.ts

@@ -1,8 +1,3 @@
-/**
- * Whether a file RENDERS one of the tiers it imports, not merely names it — a gate satisfied by an
- * import nobody renders was not satisfied. `molecule-must-compose` and `tissue-must-compose` both
- * read this off the import list and the JSX tree; each had its own copy of the reader.
- */
 type ImportSpecifierNode = {
     imported?: {
         name?: string;
@@ -45,10 +40,7 @@ export type JsxOpeningElementNode = {
     };
     type: 'JSXOpeningElement';
 };
-/** The identifier a JSX tag renders under — `<Foo/>`'s own name, or `<NS.Foo/>`'s namespace root. */
 export declare const rootTagNameOf: (name: JsxOpeningElementNode['name'] | undefined) => string | undefined;
-/** The local names an import brings in, added to `into` when its source composes and it is a value. */
 export declare const collectCompositionLocals: (node: CompositionImportNode, isComposition: (source: string) => boolean, into: Set<string>) => void;
-/** Whether any of the imported locals was actually rendered as a JSX tag. */
 export declare const rendersAnyOf: (locals: ReadonlySet<string>, renderedTagNames: ReadonlySet<string>) => boolean;
 export {};

package/dist/rules/lib/shared-features.d.ts

@@ -1,13 +1,6 @@
-/**
- * Which features may be reached ACROSS feature boundaries is one repo's layout, so it is an
- * option — `organelle-dependency` and `cell-no-cross-feature-organelles` draw the same boundary
- * from two sides, on the same option, with the same default: the one name every feature-sliced
- * repo agrees on.
- */
 export type SharedFeaturesOptions = {
     sharedFeatures?: string[];
 };
-/** The JSON schema for `{ sharedFeatures?: string[] }`, read by both rules that take it. */
 export declare const SHARED_FEATURES_SCHEMA: {
     additionalProperties: boolean;
     properties: {
@@ -20,5 +13,4 @@ export declare const SHARED_FEATURES_SCHEMA: {
     };
     type: 'object';
 }[];
-/** Whether `importedFeature` is a DIFFERENT feature the options have not named as shared. */
 export declare const crossesFeatureBoundary: (importedFeature: string | undefined, ownFeature: string | undefined, options: SharedFeaturesOptions) => boolean;

package/dist/rules/lib/shared-features.js

@@ -1,14 +1,7 @@
 // src/rules/lib/shared-features.ts
+import { optionsBag, STRINGS } from "./schema.js";
 var DEFAULT_SHARED_FEATURES = ["shared"];
-var SHARED_FEATURES_SCHEMA = [
-  {
-    additionalProperties: false,
-    properties: {
-      sharedFeatures: { items: { type: "string" }, type: "array" }
-    },
-    type: "object"
-  }
-];
+var SHARED_FEATURES_SCHEMA = optionsBag({ sharedFeatures: STRINGS });
 var crossesFeatureBoundary = (importedFeature, ownFeature, options) => importedFeature !== undefined && importedFeature !== ownFeature && !new Set(options.sharedFeatures ?? DEFAULT_SHARED_FEATURES).has(importedFeature);
 export {
   SHARED_FEATURES_SCHEMA,

package/dist/rules/lib/state-sources.d.ts

@@ -0,0 +1,8 @@
+export declare const FORM_SOURCES: Set<string>;
+export declare const FORM_CONTEXT_IMPORT_PATTERN: RegExp;
+export declare const isProvidersSource: (source: string) => boolean;
+export interface StateSources {
+    forms: Set<string>;
+    stores: Set<string>;
+}
+export declare const stateSourcesOf: (file: string, seen?: Set<string>) => StateSources;

package/dist/rules/lib/state-sources.js

@@ -0,0 +1,55 @@
+// src/rules/lib/state-sources.ts
+import { STORE_HOOK_NAME } from "./hooks.js";
+import { isRelative } from "./imports.js";
+import { fileFor, readSource } from "./module-text.js";
+import { inTier } from "./tiers.js";
+var FORM_SOURCES = new Set(["react-hook-form"]);
+var FORM_CONTEXT_IMPORT_PATTERN = /FormContext$/;
+var isProvidersSource = (source) => /(?:^|\/)providers(?:\/|$)/.test(source);
+var IMPORT = /\bimport\s+(type\s+)?([^'";]*?)\s*from\s*['"]([^'"]+)['"]/g;
+var STORE_CALL = /(?<!function\s)\b(use\w+Store)\s*\(/g;
+var DEPTH = 4;
+var localsOf = (clause) => {
+  const named = /\{([^}]*)\}/.exec(clause)?.[1] ?? "";
+  const bare = clause.replace(/\{[^}]*\}/, "").replaceAll(",", " ").trim();
+  const fromBare = /^[A-Za-z_$][\w$]*$/.test(bare) ? [bare] : [];
+  const fromNamed = named.split(",").map((one) => one.trim()).filter((one) => one !== "" && !one.startsWith("type ")).map((one) => one.split(/\s+as\s+/).at(-1) ?? "");
+  return [...fromBare, ...fromNamed].filter((one) => one !== "");
+};
+var importsOf = (text) => [...text.matchAll(IMPORT)].flatMap((found) => found[1] === undefined ? [{ locals: localsOf(found[2] ?? ""), source: found[3] ?? "" }] : []);
+var isCalled = (text, name) => new RegExp(String.raw`(?<![\w$.])${name.replaceAll("$", String.raw`\$`)}\s*\(`).test(text);
+var gather = (file, seen, depth, into) => {
+  if (seen.has(file) || depth > DEPTH)
+    return;
+  seen.add(file);
+  const text = readSource(file);
+  if (text === undefined)
+    return;
+  for (const found of text.matchAll(STORE_CALL)) {
+    const name = found[1] ?? "";
+    if (STORE_HOOK_NAME.test(name))
+      into.stores.add(name);
+  }
+  for (const one of importsOf(text)) {
+    if (FORM_SOURCES.has(one.source))
+      into.forms.add(one.source);
+    else if (isProvidersSource(one.source) && one.locals.some((local) => FORM_CONTEXT_IMPORT_PATTERN.test(local))) {
+      into.forms.add(one.source);
+    } else if (isRelative(one.source) && one.locals.some((local) => isCalled(text, local))) {
+      const next = fileFor(file, one.source);
+      if (next !== undefined && inTier(next, "organelles"))
+        gather(next, seen, depth + 1, into);
+    }
+  }
+};
+var stateSourcesOf = (file, seen = new Set) => {
+  const into = { forms: new Set, stores: new Set };
+  gather(file, seen, 0, into);
+  return into;
+};
+export {
+  FORM_CONTEXT_IMPORT_PATTERN,
+  FORM_SOURCES,
+  isProvidersSource,
+  stateSourcesOf
+};

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

@@ -1,11 +1,10 @@
 import { type AnyNode } from './nodes.js';
+export declare const DEFAULT_STEP_FACTORIES: string[];
+export declare const DEFAULT_WORKFLOW_FACTORIES: string[];
+export declare const workflowFactoriesOf: (rule: string, configured: string[] | undefined) => Set<string>;
 export declare const stepFactoriesOf: (rule: string, configured: string[] | undefined) => Set<string>;
 export declare const isStepCall: (node: AnyNode, factories: ReadonlySet<string>) => boolean;
 export declare const argumentsOf: (node: AnyNode) => AnyNode[];
-/**
- * The step's config, told apart three ways: a bare string name (a call that can carry no config at
- * all), an object this rule can read, and an object it cannot — a spread, or a variable.
- */
 export type StepConfig = {
     kind: 'bare';
 } | {
@@ -15,5 +14,4 @@ export type StepConfig = {
     kind: 'unreadable';
 };
 export declare const configOf: (node: AnyNode) => StepConfig;
-/** Whatever names the step in a message: its literal name, its config's `name`, or the factory. */
 export declare const stepNameOf: (node: AnyNode, config: StepConfig) => string;

package/dist/rules/lib/steps.js

@@ -3,6 +3,8 @@ import { calleeNameOf } from "./nodes.js";
 import { propertiesOf, stringOf, valueOf } from "./objects.js";
 import { requireOption } from "./options.js";
 var DEFAULT_STEP_FACTORIES = ["createStep"];
+var DEFAULT_WORKFLOW_FACTORIES = ["createWorkflow"];
+var workflowFactoriesOf = (rule, configured) => new Set(requireOption(rule, configured ?? DEFAULT_WORKFLOW_FACTORIES, "workflowFactories"));
 var stepFactoriesOf = (rule, configured) => new Set(requireOption(rule, configured ?? DEFAULT_STEP_FACTORIES, "stepFactories"));
 var isStepCall = (node, factories) => {
   const callee = calleeNameOf(node);
@@ -29,9 +31,12 @@ var stepNameOf = (node, config) => {
   return calleeNameOf(node) ?? "a step";
 };
 export {
+  DEFAULT_STEP_FACTORIES,
+  DEFAULT_WORKFLOW_FACTORIES,
   argumentsOf,
   configOf,
   isStepCall,
   stepFactoriesOf,
-  stepNameOf
+  stepNameOf,
+  workflowFactoriesOf
 };