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

package/dist/rules/next-route-segment-is-thin-delegate.js

@@ -1,15 +1,15 @@
 // src/rules/next-route-segment-is-thin-delegate.ts
-import { walkOwnFunctionBody } from "./lib/nodes.js";
-import { isTestFile, normalise } from "./lib/paths.js";
-var DELEGATE_BASENAMES = new Set(["layout.tsx", "page.tsx", "template.tsx"]);
-var FUNCTIONS = new Set(["ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression"]);
-var FALLBACK_BASENAMES = new Set([
-  "default.tsx",
-  "error.tsx",
-  "global-error.tsx",
-  "loading.tsx",
-  "not-found.tsx"
-]);
+import { sourceOf } from "./lib/imports.js";
+import { isCapitalised, meaningfulChildren } from "./lib/jsx.js";
+import { FUNCTION_BOUNDARY_TYPES, walkOwnFunctionBody } from "./lib/nodes.js";
+import {
+  fileOf,
+  isTestFile,
+  normalise,
+  ROUTE_BODY_BASENAMES,
+  ROUTE_FALLBACK_BASENAMES
+} from "./lib/paths.js";
+import { APP_FOLDER, folderOf, TIERS } from "./lib/tiers.js";
 function collectReturnStatements(body) {
   const out = [];
   walkOwnFunctionBody(body, (node) => {
@@ -41,47 +41,42 @@ function describeReturn(arg) {
   return a.type ?? "unknown";
 }
 function bioFolderOf(source) {
-  const m = source.match(/\/(atoms|molecules|compounds|organelles|cells|tissues|lib|stores)(?:\/|$)/);
-  return m?.[1] ?? "unknown";
+  return folderOf(source, [...TIERS, "lib", "stores"]) ?? "unknown";
 }
 function isTissueSource(source) {
   if (!source)
     return false;
-  return /\/tissues(?:\/|$)/.test(source);
+  return folderOf(source, ["tissues"]) !== undefined;
 }
 var nextRouteSegmentIsThinDelegate = {
   create(context) {
     const normalized = normalise(context.filename);
     if (isTestFile(normalized))
       return {};
-    if (!/(?:^|\/)app\//.test(normalized))
+    if (!APP_FOLDER.test(normalized))
       return {};
-    const basename = normalized.split("/").pop() ?? "";
-    if (!DELEGATE_BASENAMES.has(basename))
+    const basename = fileOf(normalized);
+    if (!ROUTE_BODY_BASENAMES.has(basename))
       return {};
-    if (FALLBACK_BASENAMES.has(basename))
+    if (ROUTE_FALLBACK_BASENAMES.has(basename))
       return {};
     const importSources = new Map;
-    function isImportedPascalCase(tag) {
-      if (!tag)
-        return false;
-      if (!/^[A-Z]/.test(tag))
-        return false;
-      return importSources.has(tag);
-    }
-    function reportNonTissueDelegate(tag, ret) {
-      const source = importSources.get(tag) ?? "";
-      context.report({
-        data: {
-          bio: bioFolderOf(source),
-          file: basename,
-          source,
-          tag
-        },
-        messageId: "delegateMustBeTissue",
-        node: ret
-      });
-    }
+    const delegate = (tag, found, ret) => {
+      const source = tag === null ? undefined : importSources.get(tag);
+      if (tag === null || source === undefined || !isCapitalised(tag)) {
+        context.report({
+          data: { file: basename, found },
+          messageId: "mustBeThinDelegate",
+          node: ret
+        });
+      } else if (!isTissueSource(source)) {
+        context.report({
+          data: { bio: bioFolderOf(source), file: basename, source, tag },
+          messageId: "delegateMustBeTissue",
+          node: ret
+        });
+      }
+    };
     function checkReturn(arg, ret) {
       if (!arg || typeof arg !== "object")
         return;
@@ -89,28 +84,11 @@ var nextRouteSegmentIsThinDelegate = {
       if (a.type === "Literal" && a.value === null)
         return;
       if (a.type === "JSXElement") {
-        const tag = tagOf(arg);
-        if (!isImportedPascalCase(tag)) {
-          context.report({
-            data: { file: basename, found: describeReturn(arg) },
-            messageId: "mustBeThinDelegate",
-            node: ret
-          });
-          return;
-        }
-        const source = importSources.get(tag);
-        if (!isTissueSource(source)) {
-          reportNonTissueDelegate(tag, ret);
-        }
+        delegate(tagOf(arg), describeReturn(arg), ret);
         return;
       }
       if (a.type === "JSXFragment") {
-        const kids = arg.children ?? [];
-        const meaningful = kids.filter((c) => {
-          if (c.type === "JSXText")
-            return (c.value ?? "").trim().length > 0;
-          return true;
-        });
+        const meaningful = meaningfulChildren(arg.children);
         if (meaningful.length !== 1) {
           context.report({
             data: { count: String(meaningful.length), file: basename },
@@ -129,18 +107,7 @@ var nextRouteSegmentIsThinDelegate = {
           return;
         }
         const tagName = child.openingElement?.name?.type === "JSXIdentifier" ? child.openingElement.name.name ?? null : null;
-        if (!isImportedPascalCase(tagName)) {
-          context.report({
-            data: { file: basename, found: `fragment><${tagName ?? "?"}/></fragment` },
-            messageId: "mustBeThinDelegate",
-            node: ret
-          });
-          return;
-        }
-        const source = importSources.get(tagName);
-        if (!isTissueSource(source)) {
-          reportNonTissueDelegate(tagName, ret);
-        }
+        delegate(tagName, `fragment><${tagName ?? "?"}/></fragment`, ret);
         return;
       }
       context.report({
@@ -152,7 +119,7 @@ var nextRouteSegmentIsThinDelegate = {
     return {
       ExportDefaultDeclaration(node) {
         const decl = node.declaration;
-        if (!decl || !FUNCTIONS.has(decl.type))
+        if (!decl || !FUNCTION_BOUNDARY_TYPES.has(decl.type))
           return;
         if (decl.body !== undefined && decl.body.type !== "BlockStatement") {
           checkReturn(decl.body, decl.body);
@@ -162,7 +129,7 @@ var nextRouteSegmentIsThinDelegate = {
           checkReturn(ret.argument, ret);
       },
       ImportDeclaration(node) {
-        const source = node.source?.value ?? "";
+        const source = sourceOf(node) ?? "";
         for (const spec of node.specifiers ?? []) {
           const local = spec.local?.name;
           if (local)
@@ -186,6 +153,15 @@ returns is a tissue — a route that renders a cell directly wraps it in a tissu
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/app/geonosis-probe/page.tsx",
+      source: `export default function Page() {
+  return <div>inline markup</div>
+}
+`
+    };
   }
 };
 var next_route_segment_is_thin_delegate_default = nextRouteSegmentIsThinDelegate;

package/dist/rules/no-brand-names.d.ts

@@ -1,8 +1,6 @@
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** Substrings stripped before the scan — a real demo-asset host, so a CDN URL never trips. */
     allowedSubstrings?: string[];
-    /** Brand names, matched case-insensitively on a word boundary. */
     brands?: string[];
 }
 declare const noBrandNames: {
@@ -52,13 +50,6 @@ declare const noBrandNames: {
         }[];
         type: 'problem';
     };
-    /**
-     * The brand list is a Medusa storefront's and the corpus says `acme`, so this rule reads as
-     * firing nowhere in the repo whose brands it was configured with — one of the two findings that
-     * opened this. The brand goes on a line of its own so no `allowedSubstrings` entry can strip it
-     * away: a CDN host is stripped before the scan, and a probe hiding inside one would prove the
-     * opposite of what it claims.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default noBrandNames;

package/dist/rules/no-brand-names.js

@@ -2,10 +2,10 @@
 import * as fs from "node:fs";
 import { requireOption } from "./lib/options.js";
 import { normalise } from "./lib/paths.js";
+import { escapeForRegex } from "./lib/pattern-match.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var EXEMPT_PATH = /\/examples\//;
-var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var noBrandNames = {
   create(context) {
     const { allowedSubstrings = [], brands = [] } = context.options?.[0] ?? {};

package/dist/rules/no-card-shaped-div.d.ts

@@ -1,44 +1,5 @@
-interface BinaryExpression {
-    left: ClassNameExpression | null;
-    operator: string;
-    right: ClassNameExpression | null;
-    type: 'BinaryExpression';
-}
-type ClassNameExpression = {
-    type: string;
-} | BinaryExpression | JSXExpressionContainer | Literal | TemplateLiteral;
-interface JSXAttribute {
-    name?: {
-        name?: string;
-        type: string;
-    };
-    type: string;
-    value?: ClassNameExpression | null;
-}
-interface JSXExpressionContainer {
-    expression: ClassNameExpression | null;
-    type: 'JSXExpressionContainer';
-}
-interface JSXOpeningElement {
-    attributes: JSXAttribute[];
-    name: {
-        name?: string;
-        type: string;
-    };
-    type: 'JSXOpeningElement';
-}
-interface Literal {
-    type: 'Literal';
-    value: unknown;
-}
-interface TemplateLiteral {
-    quasis: {
-        value?: {
-            raw?: string;
-        };
-    }[];
-    type: 'TemplateLiteral';
-}
+import { type JsxOpeningElement } from './lib/jsx.js';
+import { type Probe } from './lib/probe.js';
 declare const noCardShapedDiv: {
     create(context: {
         filename: string;
@@ -50,7 +11,7 @@ declare const noCardShapedDiv: {
     }): {
         JSXOpeningElement?: undefined;
     } | {
-        JSXOpeningElement(node: JSXOpeningElement): void;
+        JSXOpeningElement(node: JsxOpeningElement): void;
     };
     fixShape: string;
     meta: {
@@ -63,5 +24,6 @@ declare const noCardShapedDiv: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noCardShapedDiv;

package/dist/rules/no-card-shaped-div.js

@@ -1,6 +1,7 @@
 // src/rules/no-card-shaped-div.ts
+import { attributeNamed, tagNameOf } from "./lib/jsx.js";
 import { normalise } from "./lib/paths.js";
-var biologicalHierarchyPattern = /\/(molecules|compounds|organelles|cells|layouts)\//;
+import { ABOVE_ATOMS_FOLDER } from "./lib/tiers.js";
 var MODIFIER_PREFIX = "(?:(?:dark|print|sm|md|lg|xl|2xl|first|last|odd|even):)?";
 var BORDER_PATTERN = new RegExp(`(?:^|\\s)${MODIFIER_PREFIX}border(?:\\s|$|-[1-9]\\d*(?:\\s|$))`);
 var BG_PATTERN = new RegExp(`(?:^|\\s)${MODIFIER_PREFIX}bg-(?:white|black|container|page|neutral-\\d+|gray-\\d+|zinc-\\d+|stone-\\d+|slate-\\d+)`);
@@ -35,13 +36,13 @@ function isCardLikeClassName(className) {
 var noCardShapedDiv = {
   create(context) {
     const filename = normalise(context.filename);
-    if (!biologicalHierarchyPattern.test(filename))
+    if (!ABOVE_ATOMS_FOLDER.test(filename))
       return {};
     return {
       JSXOpeningElement(node) {
-        if (node?.name?.type !== "JSXIdentifier" || node.name.name !== "div")
+        if (tagNameOf(node) !== "div")
           return;
-        const classAttr = node.attributes?.find((a) => a?.type === "JSXAttribute" && a?.name?.type === "JSXIdentifier" && a?.name?.name === "className");
+        const classAttr = attributeNamed(node, "className");
         if (!classAttr)
           return;
         const cls = extractClassNameString(classAttr.value ?? null);
@@ -65,6 +66,13 @@ styling into an atom that owns it.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.tsx",
+      source: `export const GeonosisProbe = () => <div className="border bg-white" />
+`
+    };
   }
 };
 var no_card_shaped_div_default = noCardShapedDiv;

package/dist/rules/no-cross-feature-stores.d.ts

@@ -9,6 +9,7 @@ declare const noCrossFeatureStores: {
         }) => void;
     }): import('./lib/visitors.js').Visitor;
     fixShape: string;
+    probe?: ((options: readonly unknown[]) => import('./lib/probe.js').Probe | import('./lib/probe.js').ProbeTree) | undefined;
     meta: {
         docs: {
             description: string;

package/dist/rules/no-cross-feature-stores.js

@@ -1,8 +1,8 @@
 // src/rules/no-cross-feature-stores.ts
 import { directionRule } from "./lib/direction-rule.js";
+import { crossesFeatureBoundary } from "./lib/shared-features.js";
 var BIO_FILE_PATTERN = /(?:^|\/)features\/([^/]+)\/(cells|organelles)\/.*\.(tsx?|ts)$/;
 var STORE_IMPORT_PATTERN = /(?:^|\/|@\/)features\/([^/]+)\/stores\//;
-var SHARED_FEATURE = "shared";
 var storeFeatureOf = (source) => STORE_IMPORT_PATTERN.exec(source)?.[1];
 var noCrossFeatureStores = directionRule({
   data: (target, importer) => ({
@@ -15,14 +15,18 @@ var noCrossFeatureStores = directionRule({
   fixShape: `A cell or organelle in \`features/X/\` reads only \`features/X/stores/*\` and \`features/shared/stores/*\`.
 Another feature's store is a hidden coupling: let the data flow through the parent tissue as props
 instead. Type-only imports are exempt; \`export … from\` is not.`,
-  forbidden: (target, importer) => {
-    const importedFeature = storeFeatureOf(target.path);
-    return importedFeature !== undefined && importedFeature !== importer.feature && importedFeature !== SHARED_FEATURE;
-  },
+  forbidden: (target, importer) => crossesFeatureBoundary(storeFeatureOf(target.path), importer.feature, {}),
   messages: {
     crossFeatureStore: `"{{file}}" in feature "{{ownFeature}}" imports from another feature's store: "{{source}}" (feature: "{{importedFeature}}"). Cross-feature data must flow through the parent as props. Only features/{{ownFeature}}/stores/* and features/shared/stores/* are allowed here.`
   },
   messageId: "crossFeatureStore",
+  probe: () => ({
+    path: "src/features/geonosis/cells/geonosis-probe.tsx",
+    source: `import { other } from '@/features/geonosis-neighbour/stores/other'
+
+export const GeonosisProbe = other
+`
+  }),
   scope: (importer) => BIO_FILE_PATTERN.test(importer.path)
 });
 var no_cross_feature_stores_default = noCrossFeatureStores;

package/dist/rules/no-d1-transaction.d.ts

@@ -1,11 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
+import type { Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * Regex sources over the normalised filename: files inside `transacts` whose handle is still D1
-     * — the control plane's own modules, its schema.
-     */
     except?: string | string[];
-    /** Regex sources over the normalised filename: the files whose database transacts (a Postgres cell). */
     transacts?: string | string[];
 }
 type Node = {
@@ -65,5 +61,6 @@ declare const noD1Transaction: {
         }[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noD1Transaction;

package/dist/rules/no-d1-transaction.js

@@ -82,6 +82,13 @@ judged until the repo says which of its handles may transact.`,
       transacts: PATTERNS
     }),
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "geonosis-probe-d1.ts",
+      source: `export const geonosisProbe = (db) => db.transaction(async () => 1)
+`
+    };
   }
 };
 var no_d1_transaction_default = noD1Transaction;

package/dist/rules/no-date-string-compare.d.ts

@@ -1,5 +1,6 @@
 import { type RuleContextWithRawOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 declare const noDateStringCompare: {
     create(context: RuleContextWithRawOptions): {
         BinaryExpression(node: AnyNode): void;
@@ -24,5 +25,6 @@ declare const noDateStringCompare: {
         }[];
         type: 'problem';
     };
+    probe(options: readonly unknown[]): Probe;
 };
 export default noDateStringCompare;

package/dist/rules/no-date-string-compare.js

@@ -1,7 +1,7 @@
 // src/rules/no-date-string-compare.ts
 import { calleeNameOf, propertyNameOf } from "./lib/nodes.js";
 import { bagOf } from "./lib/probe.js";
-import { STRING } from "./lib/schema.js";
+import { optionsBag, STRING } from "./lib/schema.js";
 var FIELD_PATTERN = "(?:_at|[a-z]At)$";
 var RELATIONAL = new Set(["<", "<=", ">", ">="]);
 var COMPARE = "localeCompare";
@@ -84,14 +84,20 @@ and a template with copy in it are both left alone. Which names hold a timestamp
     messages: {
       textOrder: 'Ordering "{{field}}" by {{ordering}} on a string compares the TEXT of a timestamp: a Date stringifies to "Fri Aug 30 2026 …", so this sorts by weekday name. Compare `.getTime()` or `Date.parse()`, or order on the ISO string the API returned.'
     },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: { fieldPattern: STRING },
-        type: "object"
-      }
-    ],
+    schema: optionsBag({ fieldPattern: STRING }),
     type: "problem"
+  },
+  probe(options) {
+    const field = "created_at";
+    const pattern = bagOf(options).fieldPattern ?? FIELD_PATTERN;
+    if (!new RegExp(pattern).test(field)) {
+      throw new Error(`no probe can be built: \`${field}\` is not a field the pattern ${pattern} holds a time in`);
+    }
+    return {
+      path: "geonosis-probe-order.ts",
+      source: `export const geonosisProbe = (left, right) => String(left.${field}).localeCompare(String(right.${field}))
+`
+    };
   }
 };
 var no_date_string_compare_default = noDateStringCompare;

package/dist/rules/no-duplicate-jsx-patterns.d.ts

@@ -1,4 +1,5 @@
 import { type RuleContext } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
 interface JSXNode {
     attributes: {
         name?: {
@@ -33,8 +34,8 @@ interface AnyNode {
 }
 declare const noDuplicateJsxPatterns: {
     create(context: RuleContext): {
-        'Program:exit'?: undefined;
         JSXOpeningElement?: undefined;
+        'Program:exit'?: undefined;
     } | {
         JSXOpeningElement(node: JSXNode): void;
         'Program:exit'(): void;
@@ -51,5 +52,6 @@ declare const noDuplicateJsxPatterns: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default noDuplicateJsxPatterns;

package/dist/rules/no-duplicate-jsx-patterns.js

@@ -1,6 +1,6 @@
 // src/rules/no-duplicate-jsx-patterns.ts
 import { normalise } from "./lib/paths.js";
-var COMPONENT_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+import { COMPONENT_FILE_PATTERN } from "./lib/tiers.js";
 var MIN_CLASS_LENGTH = 30;
 var MIN_DUPLICATES = 3;
 var ITERATORS = new Set(["map", "flatMap", "forEach", "filter", "reduce"]);
@@ -95,6 +95,21 @@ their text are one component with a prop.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/geonosis-probe.tsx",
+      source: `export function GeonosisProbe() {
+  return (
+    <div>
+      <p className="mb-[4px] text-[12px] leading-[16px] font-bold">a</p>
+      <p className="mb-[4px] text-[12px] leading-[16px] font-bold">b</p>
+      <p className="mb-[4px] text-[12px] leading-[16px] font-bold">c</p>
+    </div>
+  )
+}
+`
+    };
   }
 };
 var no_duplicate_jsx_patterns_default = noDuplicateJsxPatterns;

package/dist/rules/no-generic-utility-package.d.ts

@@ -1,8 +1,35 @@
 import { type RuleContextWithRawOptions } from './lib/context.js';
 import { type ProbeTree } from './lib/probe.js';
+interface Declared {
+    declarations?: {
+        id?: {
+            name?: string;
+        };
+    }[];
+    id?: {
+        name?: string;
+    };
+}
+interface Statement {
+    declaration?: Declared | null;
+    exported?: {
+        name?: string;
+        value?: string;
+    } | null;
+    source?: unknown;
+    specifiers?: {
+        exported?: {
+            name?: string;
+            value?: string;
+        };
+    }[];
+    type?: string;
+}
 declare const noGenericUtilityPackage: {
     create(context: RuleContextWithRawOptions): {
-        Program(node: unknown): void;
+        Program(node: {
+            body?: Statement[];
+        }): void;
     };
     fixShape: string;
     meta: {
@@ -10,11 +37,31 @@ declare const noGenericUtilityPackage: {
             description: string;
         };
         messages: {
+            beyondTheDoor: string;
             generic: string;
         };
         schema: {
             additionalProperties: boolean;
             properties: {
+                allow: {
+                    items: {
+                        additionalProperties: boolean;
+                        properties: {
+                            exports: {
+                                items: {
+                                    type: 'string';
+                                };
+                                type: 'array';
+                            };
+                            package: {
+                                type: 'string';
+                            };
+                        };
+                        required: string[];
+                        type: 'object';
+                    };
+                    type: 'array';
+                };
                 entries: {
                     items: {
                         type: 'string';
@@ -32,7 +79,6 @@ declare const noGenericUtilityPackage: {
         }[];
         type: 'problem';
     };
-    /** The manifest AND the entry: the name is in the manifest, and the finding lands on the entry. */
     probe(options: readonly unknown[]): ProbeTree;
 };
 export default noGenericUtilityPackage;