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

package/dist/rules/font-roles-only.d.ts

@@ -2,17 +2,9 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 import { type OpeningElement } from './lib/styling.js';
 interface Options {
-    /** Paths where a family literal is the point — the theme file, an `@font-face` sheet. */
     allow?: string[];
-    /**
-     * The modules this rule does not judge, each written out in full — the enumeration a pattern
-     * cannot be. A glob grants its exemption to wherever it stops and nobody counts what accumulates
-     * on the far side; a list of module names is a number a reader can hold.
-     */
     exemptModules?: string[];
-    /** How a themed family variable is spelled. Default `--font-`. */
     prefix?: string;
-    /** The role names this repo's contract declares. */
     roles?: string[];
 }
 declare const fontRolesOnly: {
@@ -23,11 +15,6 @@ declare const fontRolesOnly: {
     };
     fixShape: string;
     meta: {
-        /**
-         * #139: which option grants by PATTERN and which one ENUMERATES. Declared on the rule so the
-         * doctor needs no list of its own — a rule that gains a path grant and forgets to say so is a
-         * grant nothing counts, which is the defect this pair exists to end.
-         */
         grants: {
             modules: string;
             paths: string;
@@ -68,11 +55,6 @@ declare const fontRolesOnly: {
         }[];
         type: 'problem';
     };
-    /**
-     * A family literal, which fires whatever the declared roles are — the question `exercised` asks
-     * is whether the rule RUNS here, and a probe built out of an undeclared role name would be
-     * defeated by a repo that happened to declare one spelled the same.
-     */
     probe(): Probe;
 };
 export default fontRolesOnly;

package/dist/rules/font-roles-only.js

@@ -1,6 +1,6 @@
 // src/rules/font-roles-only.ts
 import { requireOption } from "./lib/options.js";
-import { isModule, normalise } from "./lib/paths.js";
+import { isExempt, normalise } from "./lib/paths.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 import {
   arbitraryValuesOf,
@@ -11,38 +11,35 @@ import {
 var WEIGHT = /^\d+(?:\.\d+)?$/;
 var fontRolesOnly = {
   create(context) {
-    const { allow = [], exemptModules = [], prefix = "--font-", roles } = context.options?.[0] ?? {};
+    const { prefix = "--font-", roles, ...exempt } = context.options?.[0] ?? {};
     const declared = requireOption("font-roles-only", roles, "roles");
-    const filename = normalise(context.filename);
-    if (exemptModules.some((module) => isModule(filename, module)))
-      return {};
-    if (allow.some((path) => filename.includes(path)))
+    if (isExempt(normalise(context.filename), exempt))
       return {};
+    const judge = (value, node) => {
+      const variable = variableOf(value);
+      if (variable === undefined) {
+        context.report({ data: { value }, messageId: "familyLiteral", node });
+        return;
+      }
+      if (!variable.startsWith(prefix))
+        return;
+      const role = variable.slice(prefix.length);
+      if (!declared.includes(role)) {
+        context.report({ data: { role, value }, messageId: "undeclaredRole", node });
+      }
+    };
     return {
       JSXOpeningElement(node) {
-        const judge = (value) => {
-          const variable = variableOf(value);
-          if (variable === undefined) {
-            context.report({ data: { value }, messageId: "familyLiteral", node });
-            return;
-          }
-          if (!variable.startsWith(prefix))
-            return;
-          const role = variable.slice(prefix.length);
-          if (!declared.includes(role)) {
-            context.report({ data: { role, value }, messageId: "undeclaredRole", node });
-          }
-        };
         for (const { property, value } of styleEntriesOf(node)) {
           if (property === "fontFamily" || property === "font")
-            judge(value);
+            judge(value, node);
         }
         const className = classNameOf(node);
         if (className === undefined)
           return;
         for (const [utility, inner] of arbitraryValuesOf(className)) {
-          if (utility.replace(/^.*:/, "") === "font" && !WEIGHT.test(inner))
-            judge(inner);
+          if (utility === "font" && !WEIGHT.test(inner))
+            judge(inner, node);
         }
       }
     };

package/dist/rules/hermetic-e2e-no-wall-clock-waits.d.ts

@@ -0,0 +1,53 @@
+import { type RuleContextWithRawOptions } from './lib/context.js';
+import { type AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
+declare const hermeticE2eNoWallClockWaits: {
+    create(context: RuleContextWithRawOptions): {
+        CallExpression?: undefined;
+    } | {
+        CallExpression(node: AnyNode): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            clockWait: string;
+            listResponseWait: string;
+        };
+        schema: {
+            additionalProperties: boolean;
+            properties: {
+                clockWaits: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                listEndpoints: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                networkWaits: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                specs: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+            };
+            type: 'object';
+        }[];
+        type: 'problem';
+    };
+    probe(options: readonly unknown[]): Probe;
+};
+export default hermeticE2eNoWallClockWaits;

package/dist/rules/hermetic-e2e-no-wall-clock-waits.js

@@ -0,0 +1,100 @@
+// src/rules/hermetic-e2e-no-wall-clock-waits.ts
+import { calleeNameOf, propertyNameOf, walkNode } from "./lib/nodes.js";
+import { normalise } from "./lib/paths.js";
+import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
+import { optionsBag, STRINGS } from "./lib/schema.js";
+var SPECS = [String.raw`(?:^|/)e2e[^/]*/.*\.(?:spec|test)\.[cm]?[jt]sx?$`];
+var CLOCK_WAITS = ["setTimeout", "waitForTimeout"];
+var NETWORK_WAITS = ["waitForResponse"];
+var calledName = (node) => {
+  const callee = node.callee;
+  return calleeNameOf(node) ?? (callee === undefined ? null : propertyNameOf(callee));
+};
+var textsIn = (nodes) => {
+  const found = [];
+  walkNode(nodes, (node) => {
+    if (node.type === "Literal") {
+      const regex = node.regex;
+      if (typeof regex?.pattern === "string")
+        found.push(regex.pattern);
+      else if (typeof node.value === "string")
+        found.push(node.value);
+    }
+    if (node.type === "TemplateLiteral") {
+      for (const quasi of node.quasis ?? []) {
+        found.push(quasi.value?.raw ?? "");
+      }
+    }
+  });
+  return found;
+};
+var hermeticE2eNoWallClockWaits = {
+  create(context) {
+    const options = bagOf(context.options);
+    const specs = options.specs ?? SPECS;
+    if (!specs.some((pattern) => new RegExp(pattern).test(normalise(context.filename))))
+      return {};
+    const clockWaits = new Set(options.clockWaits ?? CLOCK_WAITS);
+    const networkWaits = new Set(options.networkWaits ?? NETWORK_WAITS);
+    const endpoints = (options.listEndpoints ?? []).map((pattern) => new RegExp(pattern));
+    return {
+      CallExpression(node) {
+        const call = calledName(node);
+        if (call === null)
+          return;
+        if (clockWaits.has(call)) {
+          context.report({ data: { call }, messageId: "clockWait", node });
+          return;
+        }
+        if (!networkWaits.has(call) || endpoints.length === 0)
+          return;
+        const endpoint = textsIn(node.arguments).find((text) => endpoints.some((pattern) => pattern.test(text)));
+        if (endpoint !== undefined) {
+          context.report({ data: { call, endpoint }, messageId: "listResponseWait", node });
+        }
+      }
+    };
+  },
+  fixShape: `An end-to-end spec waits for the state it asserts on, never for a time and never for the network
+event that merely precedes it. \`page.waitForTimeout(500)\` or a promise sleep guesses how long the
+page needs; the guess passes on a fast machine and flakes on a slow one. \`waitForResponse\` on a LIST
+endpoint is the same guess with a better alibi: the response arriving says the request finished, not
+that the page merged the rows into what the user sees. Assert on the page instead — a web-first
+assertion on the element the data produces retries until it holds: \`await
+expect(page.getByRole('row', { name })).toBeVisible()\`. The specs are the files \`specs\` names
+(default: spec files under an \`e2e*\` directory), the calls that sleep are \`clockWaits\` (default
+\`waitForTimeout\`, \`setTimeout\`), and the list endpoints whose response may not stand in for the
+page are the regexes in \`listEndpoints\`, with \`networkWaits\` naming the calls that wait on one
+(default \`waitForResponse\`); with no \`listEndpoints\` the response waits are not judged.`,
+  meta: {
+    docs: {
+      description: 'In an end-to-end spec, a fixed-time wait (`waitForTimeout`, a `setTimeout` sleep) guesses how long the page needs, and a `waitForResponse` on a list endpoint stands in for "the live data was merged" when only the page can say so. Assert on the page state instead. The spec files, the sleeping calls, the waiting calls and the list endpoints are options; the response wait is judged only for endpoints the repo names.'
+    },
+    messages: {
+      clockWait: "`{{call}}` waits for a time, not for a state: it passes when the machine is fast and flakes when it is slow. Wait for the state the next step needs — a web-first assertion on the element it produces retries until it holds.",
+      listResponseWait: "`{{call}}` on a list endpoint ({{endpoint}}) treats the response arriving as the data being shown, and the page merges it later: a race. Assert on what the page renders — a web-first assertion on the element the data produces retries until it holds."
+    },
+    schema: optionsBag({
+      clockWaits: STRINGS,
+      listEndpoints: STRINGS,
+      networkWaits: STRINGS,
+      specs: STRINGS
+    }),
+    type: "problem"
+  },
+  probe(options) {
+    const bag = bagOf(options);
+    const call = firstOf(bag.clockWaits, ["waitForTimeout"]);
+    return {
+      path: pathMatching(firstOf(bag.specs, SPECS), "geonosis-probe.spec.ts"),
+      source: `export const geonosisProbe = async (page) => {
+  await page.${call}(500)
+}
+`
+    };
+  }
+};
+var hermetic_e2e_no_wall_clock_waits_default = hermeticE2eNoWallClockWaits;
+export {
+  hermetic_e2e_no_wall_clock_waits_default as default
+};

package/dist/rules/icon-control-has-name.js

@@ -4,8 +4,10 @@ import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
 var NATIVE_CONTROLS = ["button", "a"];
 var ICONS = "Icon$";
 var NAMED_BY = new Set(["aria-label", "aria-labelledby", "title"]);
+var ICON_NAMED_BY = new Set(["aria-label", "aria-labelledby"]);
 var nameOf = (node) => node === undefined ? "" : node.type === "JSXMemberExpression" ? `${nameOf(node.object)}.${nameOf(node.property)}` : node.name ?? "";
 var said = (child) => child.type !== "JSXText" || (child.value ?? "").trim() !== "";
+var namesItself = (icon) => icon.type === "JSXElement" && ((icon.openingElement?.attributes ?? []).some((one) => one.type === "JSXAttribute" && ICON_NAMED_BY.has(nameOf(one.name))) || nameOf(icon.openingElement?.name) === "svg" && (icon.children ?? []).some((one) => nameOf(one.openingElement?.name) === "title"));
 var iconControlHasName = {
   create(context) {
     const options = bagOf(context.options);
@@ -21,6 +23,8 @@ var iconControlHasName = {
           return;
         }
         const shown = (node.children ?? []).filter(said);
+        if (shown.some(namesItself))
+          return;
         const icons = shown.map((one) => one.type === "JSXElement" ? nameOf(one.openingElement?.name) : "");
         if (icons.length === 0 || !icons.every((name) => name === "svg" || icon.test(name)))
           return;
@@ -38,7 +42,9 @@ app's own words — a label prop the caller passes, never a string the component
 beside the icon, visible or \`sr-only\`. \`<button>\` and \`<a>\` are read by default; \`controls\` names the
 repo's control atoms, and \`icons\` is the pattern an icon component's name matches (\`Icon$\` by default);
 an inline \`<svg>\` is always one.
-A spread may carry the name and is left alone.`,
+An icon that carries its own \`aria-label\` or \`aria-labelledby\` (an icon component must forward it to its
+svg), or an \`<svg>\` holding a \`<title>\`, names the control; a \`title\` attribute on an icon does not. A
+spread may carry the name and is left alone.`,
   meta: {
     docs: {
       description: "A button or link whose only content is an icon component, with no `aria-label`, `aria-labelledby` or `title`, has no accessible name — a screen reader announces a control that says nothing."

package/dist/rules/layer-walls.d.ts

@@ -1,30 +1,14 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Layer {
-    /** Layer names this one may import. A layer may always import itself; this lists the others. */
     mayImport?: string[];
     name: string;
-    /** Regex sources, tested against the normalised filename and against an import's source. */
     paths: string[];
-    /** This layer's own answer to the rule-wide `typeOnly`, for the reason written there. */
     typeOnly?: 'count' | 'skip';
 }
 interface Options {
-    /**
-     * Whether a bare package specifier or a `node:` builtin counts as crossing a wall. It does not by
-     * default: a layer that may import no other layer still runs on a machine with a filesystem, and
-     * a rule that called `node:path` a breach would be unusable in every repo that has one.
-     */
     externals?: 'allow' | 'deny';
     layers?: Layer[];
-    /**
-     * D-034's named exception, and the default every layer keeps unless it says otherwise. A type the
-     * bundler erases is not a dependency, and three packages in this repo borrow one across a wall on
-     * purpose so their runtime graph stays clean. `count` is for walls that are about KNOWLEDGE
-     * rather than weight — a package floor, where `import type { Document }` in a foundation is the
-     * upward reach the floors exist to forbid, compiled away or not. One repo has both kinds, so a
-     * layer may override this for its own files.
-     */
     typeOnly?: 'count' | 'skip';
 }
 declare const layerWalls: {
@@ -83,15 +67,6 @@ declare const layerWalls: {
         }[];
         type: 'problem';
     };
-    /**
-     * A file in one declared layer importing a specifier that lands in another it may not reach.
-     *
-     * Both halves come out of the same regex sources the walls are written in — the filename from the
-     * layer it must sit in, the import from the layer it must not reach — and both are re-tested
-     * against the patterns they were built from. A pair the inversion cannot express is a sentence
-     * rather than a silent zero: the walls are a repo's own vocabulary, so there is no fixture
-     * anywhere that could stand in for them.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default layerWalls;

package/dist/rules/layer-walls.js

@@ -8,25 +8,19 @@ import { onImportSource } from "./lib/visitors.js";
 var isExternal = (source) => !isRelative(source) && !source.startsWith("/");
 var PROBE_TARGET = "geonosis-probe-target.ts";
 var PROBE_WALL = "geonosis-probe-wall.ts";
-var inverts = (pattern, leaf) => {
+var invert = (pattern, leaf) => {
   try {
-    pathMatching(pattern, leaf);
-    return true;
+    return pathMatching(pattern, leaf);
   } catch {
-    return false;
+    return;
   }
 };
 var placeIn = (paths, tried) => {
   for (const pattern of paths) {
-    let candidate;
-    try {
-      candidate = pathMatching(pattern, PROBE_WALL);
-    } catch {
-      tried.push(pattern);
-      continue;
-    }
-    if (new RegExp(pattern).test(`/repo-root/${candidate}`))
+    const candidate = invert(pattern, PROBE_WALL);
+    if (candidate !== undefined && new RegExp(pattern).test(`/repo-root/${candidate}`)) {
       return candidate;
+    }
     tried.push(pattern);
   }
   return;
@@ -113,7 +107,7 @@ rule reports that once a run and judges nothing: walls nobody declared are not w
     const tried = [];
     for (const here of layers) {
       const mayImport = new Set(here.mayImport ?? []);
-      const targetPath = layers.filter((other) => other.name !== here.name && !mayImport.has(other.name)).flatMap((other) => other.paths).find((one) => inverts(one, PROBE_TARGET));
+      const targetPath = layers.filter((other) => other.name !== here.name && !mayImport.has(other.name)).flatMap((other) => other.paths).find((one) => invert(one, PROBE_TARGET) !== undefined);
       const path = placeIn(here.paths, tried);
       if (targetPath === undefined || path === undefined)
         continue;

package/dist/rules/lib/atom-map.d.ts

@@ -0,0 +1,24 @@
+export interface Restriction {
+    atom: string;
+    element: string;
+    importPath: string;
+}
+export declare const ATOM_MAP_SCHEMA: {
+    items: {
+        properties: {
+            atom: {
+                type: 'string';
+            };
+            element: {
+                type: 'string';
+            };
+            importPath: {
+                type: 'string';
+            };
+        };
+        required: string[];
+        type: 'object';
+    };
+    type: 'array';
+};
+export declare const atomMapOf: (options: readonly unknown[]) => Restriction[];

package/dist/rules/lib/atom-map.js

@@ -0,0 +1,16 @@
+// src/rules/lib/atom-map.ts
+import { STRING } from "./schema.js";
+var ATOM_MAP_SCHEMA = {
+  items: {
+    properties: { atom: STRING, element: STRING, importPath: STRING },
+    required: ["element", "atom", "importPath"],
+    type: "object"
+  },
+  type: "array"
+};
+var isRestriction = (value) => typeof value === "object" && value !== null && ("atom" in value) && typeof value.atom === "string" && ("element" in value) && typeof value.element === "string" && ("importPath" in value) && typeof value.importPath === "string";
+var atomMapOf = (options) => Array.isArray(options[0]) ? options[0].filter(isRestriction) : [];
+export {
+  ATOM_MAP_SCHEMA,
+  atomMapOf
+};

package/dist/rules/lib/cells-barrel.d.ts

@@ -1,2 +1 @@
-/** Takes a path already normalised to forward slashes. */
 export declare const isCellsBarrel: (path: string) => boolean;

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

@@ -1,23 +1,4 @@
-/**
- * What counts as a colour written out.
- *
- * A CSS fact, not a repo fact, so it lives in code rather than in an option (law 6 is about a
- * repo's brands, features and tables — the notations CSS accepts for a colour are the same
- * everywhere). Every one of them is here because a brand escapes through all of them equally: the
- * component that hardcodes `oklch(0.91 0.17 102)` stops following the theme exactly as completely
- * as the one that hardcodes `#ffe849`.
- */
-/** A whole value that is one written-out colour: `#ff0000`, `rgb(1 2 3)`, `tan`. */
 export declare const isColorLiteral: (value: string) => boolean;
-/**
- * A colour written out ANYWHERE inside a value — for the shorthands.
- *
- * `border: '1px solid #ff0000'` and `boxShadow: '0 1px 2px rgba(0,0,0,.2)'` hardcode a colour just
- * as thoroughly as `color` does, and a check that only looked at whole values would pass both.
- * Named colours are deliberately NOT searched for here: `1px solid tan` is real and so is a
- * `transition` naming a property, and a substring search over 148 English words inside a free-form
- * value is how a rule earns its reputation for false positives.
- */
 export declare const containsColorLiteral: (value: string) => boolean;
 export declare const isColorProperty: (property: string) => boolean;
 export declare const isColorShorthand: (property: string) => boolean;