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

package/dist/rules/subpath-over-barrel.js

@@ -1,7 +1,9 @@
 // src/rules/subpath-over-barrel.ts
 import { statSync } from "node:fs";
 import { doorsOf, nodeModulesAbove, resolvePackage } from "./lib/doors.js";
+import { onceFor } from "./lib/options.js";
 import { bagOf } from "./lib/probe.js";
+import { designatedFile } from "./lib/run-files.js";
 import { optionsBag, STRING } from "./lib/schema.js";
 import { hasWorkspaceAbove } from "./lib/workspace-members.js";
 var homesOf = (declared) => new Map(Object.entries(declared.subpaths ?? {}).flatMap(([subpath, names]) => names.map((name) => [name, subpath])));
@@ -21,13 +23,6 @@ var doorsFor = (manifest) => {
   return doors?.homes;
 };
 var PACKAGE_ROOT = /^(?:@[^/]+\/)?[^/]+$/;
-var told = new Set;
-var firstTime = (key) => {
-  if (told.has(key))
-    return false;
-  told.add(key);
-  return true;
-};
 var namesTakenBy = (node) => {
   if (node.importKind === "type" || node.exportKind === "type")
     return [];
@@ -48,14 +43,20 @@ var namesTakenBy = (node) => {
   }
   return names;
 };
+var nothingResolves = (file) => !nodeModulesAbove(file) && !hasWorkspaceAbove(file);
+var ROOT_IMPORT = /\b(?:import|export)\s*\{\s*(?!type\s)[\w$][^}]*\}\s*from\s*['"](?:@[^/'"]+\/)?[^./'"@][^'"]*['"]/;
+var toldWithoutCarrier = new Set;
 var subpathOverBarrel = {
   create(context) {
     const declared = new Map((context.options?.[0]?.packages ?? []).filter((one) => typeof one.name === "string").map((one) => [one.name, one]));
     const writtenByHand = [...declared.values()].some((one) => one.subpaths !== undefined);
+    const told = new Set;
+    const carrier = writtenByHand ? null : designatedFile("subpath-over-barrel", "nothingResolves", (file, text) => ROOT_IMPORT.test(text) && nothingResolves(file));
     const tell = (messageId, source, node) => {
-      if (firstTime(`${messageId}/${source}`)) {
-        context.report({ data: { package: source }, messageId, node });
-      }
+      if (told.has(`${messageId}/${source}`))
+        return;
+      told.add(`${messageId}/${source}`);
+      context.report({ data: { package: source }, messageId, node });
     };
     const homesFor = (source, node) => {
       const written = declared.get(source);
@@ -65,7 +66,8 @@ var subpathOverBarrel = {
       if (found === undefined) {
         if (written !== undefined)
           tell("unresolvedPackage", source, node);
-        else if (!writtenByHand && PACKAGE_ROOT.test(source) && !nodeModulesAbove(context.filename) && !hasWorkspaceAbove(context.filename)) {
+        else if (carrier === null && !writtenByHand && PACKAGE_ROOT.test(source) && nothingResolves(context.filename) && !toldWithoutCarrier.has("nothingResolves") && onceFor("nothingResolves", context.filename)) {
+          toldWithoutCarrier.add("nothingResolves");
           tell("nothingResolves", "", node);
         }
         return;
@@ -100,7 +102,11 @@ var subpathOverBarrel = {
     };
     return {
       ExportNamedDeclaration: fromRoot,
-      ImportDeclaration: fromRoot
+      ImportDeclaration: fromRoot,
+      Program(node) {
+        if (carrier === context.filename)
+          tell("nothingResolves", "", node);
+      }
     };
   },
   fixShape: `Import from the SUBPATH that owns the names, not from the package root:

package/dist/rules/test-no-clock-polling-for-promise-flips.d.ts

@@ -2,7 +2,11 @@ import { type RuleContextWithRawOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 declare const testNoClockPollingForPromiseFlips: {
-    create(context: RuleContextWithRawOptions): {
+    create(context: RuleContextWithRawOptions & {
+        sourceCode?: {
+            text?: string;
+        };
+    }): {
         ArrowFunctionExpression?: undefined;
         FunctionDeclaration?: undefined;
         FunctionExpression?: undefined;

package/dist/rules/test-no-clock-polling-for-promise-flips.js

@@ -76,6 +76,9 @@ var testNoClockPollingForPromiseFlips = {
     const filename = normalise(context.filename);
     if (!globs.some((pattern) => new RegExp(pattern).test(filename)))
       return {};
+    const text = context.sourceCode?.text;
+    if (text !== undefined && !pollers.some((poller) => text.includes(poller)))
+      return {};
     const inScope = (node) => {
       const held = promisesIn(node);
       if (held.size === 0)

package/dist/rules/tissue-must-compose.d.ts

@@ -4,9 +4,9 @@ import { type CompositionImportNode, type JsxOpeningElementNode } from './lib/re
 declare const tissueMustCompose: {
     create(context: RuleContext): {
         ImportDeclaration?: undefined;
-        JSXOpeningElement?: undefined;
         'Program:exit'?: undefined;
         ExportNamedDeclaration?: undefined;
+        JSXOpeningElement?: undefined;
     } | {
         ExportNamedDeclaration(node: {
             declaration?: {

package/dist/rules/tissue-no-data-props.d.ts

@@ -48,12 +48,12 @@ interface DeclarationNode {
 }
 declare const tissueNoDataProps: {
     create(context: RuleContext): {
-        'Program:exit'?: undefined;
         ExportNamedDeclaration?: undefined;
         ExportDefaultDeclaration?: undefined;
+        'Program:exit'?: undefined;
+        ImportDeclaration?: undefined;
         TSInterfaceDeclaration?: undefined;
         TSTypeAliasDeclaration?: undefined;
-        ImportDeclaration?: undefined;
     } | {
         ImportDeclaration(node: ModuleNode): void;
         TSInterfaceDeclaration(node: DeclarationNode): void;

package/dist/rules/tokens-only-colors.d.ts

@@ -1,22 +1,13 @@
 import { type RuleContextWithOptions } from './lib/context.js';
-import type { AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
-import { type OpeningElement } from './lib/styling.js';
 interface Options {
     allow?: string[];
     exemptModules?: string[];
+    ignoreKeys?: string[];
     tokenPrefix?: string | string[];
 }
 declare const tokensOnlyColors: {
-    create(context: RuleContextWithOptions<Options>): {
-        JSXOpeningElement?: undefined;
-        Property?: undefined;
-        AssignmentPattern?: undefined;
-    } | {
-        JSXOpeningElement(node: OpeningElement): void;
-        Property(node: AnyNode): void;
-        AssignmentPattern(node: AnyNode): void;
-    };
+    create(context: RuleContextWithOptions<Options>): {};
     fixShape: string;
     meta: {
         grants: {
@@ -45,6 +36,12 @@ declare const tokensOnlyColors: {
                     };
                     type: 'array';
                 };
+                ignoreKeys: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
                 tokenPrefix: {
                     anyOf: ({
                         items: {

package/dist/rules/tokens-only-colors.js

@@ -18,6 +18,7 @@ import {
   styleObjectOf,
   variableOf
 } from "./lib/styling.js";
+import { tokenLayerOf } from "./lib/token-layer.js";
 var defaultedName = (node) => {
   const left = node.left;
   return left?.type === "Identifier" ? left.name ?? "default" : "default";
@@ -34,22 +35,32 @@ var tokenOffence = (value, prefixes, local) => {
 };
 var tokensOnlyColors = {
   create(context) {
-    const { tokenPrefix, ...exempt } = context.options?.[0] ?? {};
+    const { ignoreKeys = [], tokenPrefix, ...exempt } = context.options?.[0] ?? {};
     const prefixes = [requireOption("tokens-only-colors", tokenPrefix, "tokenPrefix")].flat();
     const filename = normalise(context.filename);
     if (isExempt(filename, exempt))
       return {};
     const readByAnElement = new WeakSet;
-    const reportDefault = (node, property, value) => {
+    const tokenLayer = tokenLayerOf();
+    const pending = [];
+    const offenceIn = (property, value) => {
+      if (ignoreKeys.includes(property))
+        return;
       const offence = tokenOffence(value, prefixes, new Set);
-      if (offence === undefined || offence === "colorLiteral" && isNamedOnly(value))
+      if (offence === "colorLiteral" && isNamedOnly(value))
         return;
       if (offence === "foreignVariable" && !isColorProperty(property))
         return;
-      context.report({ data: { property, value }, messageId: offence, node });
+      return offence;
+    };
+    const reportDefault = (node, property, value) => {
+      const messageId = offenceIn(property, value);
+      if (messageId !== undefined)
+        context.report({ data: { property, value }, messageId, node });
     };
     const isTest = anyOf([...DEFAULT_TEST_EXEMPT, "__fixtures__/", "__visual__/"], filename);
     return {
+      ...tokenLayer.visitor,
       JSXOpeningElement(node) {
         const styled = styleObjectOf(node);
         for (const entry of styled?.properties ?? []) {
@@ -91,7 +102,16 @@ var tokensOnlyColors = {
         const name = keyOf(node);
         if (name === undefined)
           return;
-        reportDefault(node, name, value.value);
+        if (offenceIn(name, value.value) === undefined)
+          return;
+        pending.push({ chain: tokenLayer.enclosing(), node, property: name, value: value.value });
+      },
+      "Program:exit"() {
+        tokenLayer.resolve();
+        for (const one of pending) {
+          if (!tokenLayer.covers(one.chain))
+            reportDefault(one.node, one.property, one.value);
+        }
       },
       AssignmentPattern(node) {
         const right = node.right;
@@ -109,13 +129,21 @@ the brand switches and the component does not — add the value to the theme and
 Configure \`tokenPrefix\` with the prefixes your themed properties use, and NAME the token layer's
 modules in \`exemptModules\`, one per entry, because that is the one place a literal belongs —
 \`allow\` still takes patterns and still grants its exemption to wherever the pattern stops, which is
-a boundary nobody decided and nobody counts. Enabled with no \`tokenPrefix\` the rule
+a boundary nobody decided and nobody counts. An object literal passed to \`defineTheme\`,
+\`compile\`, \`toDtcg\`, \`emitVariables\` or \`valueAt\` from \`@geonosis/themekit\` — directly, or by a
+single \`const\` in the same file — is the token layer itself and is not judged, and so is an object
+literal typed as a themekit palette type (\`Theme\`, \`ThemeColors\`, \`ThemeMode\` …) imported from
+\`@geonosis/themekit\`, by a \`const\` annotation, \`satisfies\` or \`as\`, which covers a theme
+defined in its own module; a same-named local type does not count. Neither needs an
+\`exemptModules\` entry. A key whose value looks like a colour but is data (a shader's mask channels,
+a PDF spec) is named in \`ignoreKeys\`, one key per entry, and every object with that key is left
+alone; the default is empty. Enabled with no \`tokenPrefix\` the rule
 reports that once a run and judges nothing: it cannot tell a token from a foreign variable, and a rule that cannot tell reads
 exactly like a clean tree.`,
   meta: {
     grants: { modules: "exemptModules", paths: "allow" },
     docs: {
-      description: "Colours in a component come from the token layer. A colour literal in a className or an inline style fires, and so does a var() naming a custom property outside the configured token prefixes. Configure `tokenPrefix`; put the token layer in `allow`. Enabled without `tokenPrefix` it reports that once a run and judges nothing."
+      description: "Colours in a component come from the token layer. A colour literal in a className or an inline style fires, and so does a var() naming a custom property outside the configured token prefixes. Configure `tokenPrefix`; put the token layer in `allow`; name data keys that only look like colours in `ignoreKeys`. An object passed to a themekit function that takes a palette, or typed as a themekit palette type, is the token layer and is not judged. Enabled without `tokenPrefix` it reports that once a run and judges nothing."
     },
     messages: {
       colorLiteral: 'Hardcoded colour "{{value}}" on `{{property}}`. Colours come from the token layer — use the themed variable or the utility that reads it, or the brand switches and this does not.',
@@ -124,6 +152,7 @@ exactly like a clean tree.`,
     schema: optionsBag({
       allow: STRINGS,
       exemptModules: STRINGS,
+      ignoreKeys: STRINGS,
       tokenPrefix: {
         anyOf: [{ type: "string" }, STRINGS]
       }

package/dist/rules/worker-handles-are-scoped.d.ts

@@ -15,9 +15,9 @@ interface Callee {
 }
 declare const cellHandlesAreScoped: {
     create(context: RuleContextWithOptions<Options>): {
-        ExportDefaultDeclaration?: undefined;
         CallExpression?: undefined;
         'Program:exit'?: undefined;
+        ExportDefaultDeclaration?: undefined;
         ClassDeclaration?: undefined;
     } | {
         ExportDefaultDeclaration(node: {

package/dist/timing.d.ts

@@ -0,0 +1,18 @@
+type Create<Context> = (context: Context) => Record<string, unknown>;
+export type RuleTiming = {
+    createMs: number;
+    files: number;
+    rule: string;
+    totalMs: number;
+    visitMs: number;
+};
+export type TimingReport = {
+    files: number;
+    rules: RuleTiming[];
+    totalMs: number;
+};
+export declare const timingRequested: (env?: NodeJS.ProcessEnv) => boolean;
+export declare const timingReport: () => TimingReport;
+export declare const timingText: (report: TimingReport, top: number) => string;
+export declare const withTiming: <Context>(create: Create<Context>, rule: string) => Create<Context>;
+export {};

package/dist/timing.js

@@ -0,0 +1,75 @@
+// src/timing.ts
+import { writeFileSync, writeSync } from "node:fs";
+var DEFAULT_TOP = 10;
+var spent = new Map;
+var listening = false;
+var timingRequested = (env = process.env) => {
+  const asked = env["GEONOSIS_LINT_TIMING"] ?? "";
+  return asked !== "" && asked !== "0" && asked !== "false";
+};
+var entryOf = (rule) => {
+  const known = spent.get(rule);
+  if (known !== undefined)
+    return known;
+  const created = { createMs: 0, files: 0, visitMs: 0 };
+  spent.set(rule, created);
+  return created;
+};
+var timingReport = () => {
+  const rules = [...spent.entries()].map(([rule, one]) => ({ ...one, rule, totalMs: one.createMs + one.visitMs })).toSorted((a, b) => b.totalMs - a.totalMs);
+  return {
+    files: rules.reduce((most, one) => Math.max(most, one.files), 0),
+    rules,
+    totalMs: rules.reduce((sum, one) => sum + one.totalMs, 0)
+  };
+};
+var ms = (value) => `${value.toFixed(1)} ms`;
+var timingText = (report, top) => {
+  const shown = report.rules.slice(0, top);
+  const width = Math.max(0, ...shown.map((one) => one.rule.length));
+  const create = report.rules.reduce((sum, one) => sum + one.createMs, 0);
+  return [
+    `geonosis-lint-timing: ${report.rules.length} rule(s) took ${ms(report.totalMs)} in this plugin over ${report.files} file(s) (create ${ms(create)}, visit ${ms(report.totalMs - create)}); the slowest ${shown.length}:`,
+    ...shown.map((one) => `  ${one.rule.padEnd(width)}  ${ms(one.totalMs).padStart(10)} (create ${ms(one.createMs)}, visit ${ms(one.visitMs)}, ${one.files} files)`),
+    ""
+  ].join(`
+`);
+};
+var flush = () => {
+  const report = timingReport();
+  const top = Number(process.env["GEONOSIS_LINT_TIMING_TOP"]);
+  writeSync(2, timingText(report, Number.isInteger(top) && top > 0 ? top : DEFAULT_TOP));
+  const into = process.env["GEONOSIS_LINT_TIMING_FILE"];
+  if (into !== undefined && into !== "") {
+    writeFileSync(into, `${JSON.stringify(report, null, 2)}
+`);
+  }
+};
+var withTiming = (create, rule) => (context) => {
+  if (!listening) {
+    listening = true;
+    process.on("exit", flush);
+  }
+  const entry = entryOf(rule);
+  const began = performance.now();
+  const visitor = create(context);
+  entry.createMs += performance.now() - began;
+  entry.files += 1;
+  return Object.fromEntries(Object.entries(visitor).map(([name, handler]) => [
+    name,
+    typeof handler === "function" ? (node) => {
+      const started = performance.now();
+      try {
+        return handler(node);
+      } finally {
+        entry.visitMs += performance.now() - started;
+      }
+    } : handler
+  ]));
+};
+export {
+  timingReport,
+  timingRequested,
+  timingText,
+  withTiming
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/oxlint-plugin-biological-architecture",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "types": "./dist/index.d.ts",
   "description": "Biological tier architecture as lint — the union of a Medusa storefront's and a Workers + D1 app's rule sets, shipped as presets.",
   "keywords": [
@@ -45,7 +45,7 @@
     "oxlint": ">=1.77"
   },
   "devDependencies": {
-    "@geonosis/lint-parity": "3.2.0"
+    "@geonosis/lint-parity": "3.3.0"
   },
   "engines": {
     "node": ">=22"