@geonosis/oxlint-plugin-biological-architecture 2.13.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @geonosis/oxlint-plugin-biological-architecture
 
+## 3.0.0
+
+### Major Changes
+
+- 237a353: `document-sagas-are-generic` and `documents-share-one-table`, retired in 2.7.0 and kept as no-ops until this major, are gone: a config that still names either is refused by oxlint with "rule not found". Remove them from the config. `RETIRED_RULES` is no longer exported.
+
 ## 2.13.0
 
 ## 2.12.0

package/RULES.md

@@ -15,8 +15,7 @@ plus twenty-eight the kit wrote for itself: `layer-walls`, `emit-declares-attemp
 `cell-no-cross-feature-organelles`, the `backend-medusa` ten, `no-unregistered-plugin-dir` +
 `router-schema-parity`, the `themekit` two, `no-mock-db-in-integration`, `todo-names-its-plan`,
 `boundary-time-is-primitive`, `durable-body-reads-through-steps`, `subpath-over-barrel` and the six
-of the W67 batch — **80**. The two retired ids still resolve until the next major, as no-ops that
-say they are retired, so a config naming them parses.
+of the W67 batch — **80**. The two retired ids went in 3.0.0.
 Every one of the twenty-eight is marked **written here** in the inventory, and the table below is
 held against that column rather than kept by hand.
 

package/dist/discover-atoms.d.ts

@@ -17,12 +17,12 @@ interface RestrictedSyntaxEntry {
  * for every native element wrapped by an atom. Apply these entries to
  * molecules, compounds, cells, and tissues (NOT atoms themselves).
  */
-declare function buildAtomRestrictions(atomsDir: string, importPathPrefix?: string): RestrictedSyntaxEntry[];
+export declare function buildAtomRestrictions(atomsDir: string, importPathPrefix?: string): RestrictedSyntaxEntry[];
 /**
  * Build atom restrictions in the format expected by the no-raw-html-atoms rule.
  * This replaces no-restricted-syntax for linters that don't support it (e.g. oxlint).
  */
-declare function buildAtomRuleRestrictions(atomsDir: string, importPathPrefix?: string): AtomRestriction[];
+export declare function buildAtomRuleRestrictions(atomsDir: string, importPathPrefix?: string): AtomRestriction[];
 /**
  * Scan the atoms directory and build a mapping from native HTML element
  * to the atom that wraps it. This is used to generate no-restricted-syntax
@@ -33,7 +33,7 @@ declare function buildAtomRuleRestrictions(atomsDir: string, importPathPrefix?:
  * exactly matches the element name is preferred as the canonical one.
  * Variants are kept as alternatives in the error message.
  */
-declare function scanAtomMappings(atomsDir: string): AtomMapping[];
+export declare function scanAtomMappings(atomsDir: string): AtomMapping[];
 /**
  * The native element an atom wraps, read from the one place every atom says so: its props type.
  *
@@ -46,6 +46,5 @@ declare function scanAtomMappings(atomsDir: string): AtomMapping[];
  *
  * The name is kept because consumers import it.
  */
-declare function detectFirstNativeJsxElement(source: string): null | string;
-
-export { buildAtomRestrictions, buildAtomRuleRestrictions, detectFirstNativeJsxElement, scanAtomMappings };
+export declare function detectFirstNativeJsxElement(source: string): null | string;
+export {};

package/dist/discover-atoms.js

@@ -1,12 +1,9 @@
-import {
-  stripComments
-} from "./chunk-H7UQNDFE.js";
-
 // src/discover-atoms.ts
-import { readdirSync, readFileSync } from "fs";
-import { basename, join } from "path";
-var GENERIC_ELEMENTS = /* @__PURE__ */ new Set(["div", "span"]);
-var HTML_ELEMENTS = /* @__PURE__ */ new Set([
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { stripComments } from "./rules/lib/module-text.js";
+var GENERIC_ELEMENTS = new Set(["div", "span"]);
+var HTML_ELEMENTS = new Set([
   "a",
   "abbr",
   "address",
@@ -181,17 +178,22 @@ function buildAtomRuleRestrictions(atomsDir, importPathPrefix = "@kit/ui/atoms")
 }
 function scanAtomMappings(atomsDir) {
   const entries = readdirSync(atomsDir, { withFileTypes: true });
-  const candidates = /* @__PURE__ */ new Map();
+  const candidates = new Map;
   for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    if (!entry.name.endsWith(".tsx")) continue;
-    if (NOT_AN_ATOM.test(entry.name)) continue;
+    if (!entry.isFile())
+      continue;
+    if (!entry.name.endsWith(".tsx"))
+      continue;
+    if (NOT_AN_ATOM.test(entry.name))
+      continue;
     const atomFile = entry.name;
     const atomName = basename(atomFile, ".tsx");
     const content = readFileSync(join(atomsDir, atomFile), "utf8");
     const nativeElement = detectFirstNativeJsxElement(content);
-    if (!nativeElement) continue;
-    if (GENERIC_ELEMENTS.has(nativeElement)) continue;
+    if (!nativeElement)
+      continue;
+    if (GENERIC_ELEMENTS.has(nativeElement))
+      continue;
     const existing = candidates.get(nativeElement) || [];
     existing.push({ atomFile, atomName, nativeElement });
     candidates.set(nativeElement, existing);
@@ -200,44 +202,51 @@ function scanAtomMappings(atomsDir) {
   for (const [element, list] of candidates) {
     const exact = list.find((m) => m.atomName === element);
     const chosen = exact ?? list[0];
-    if (chosen) mappings.push(chosen);
+    if (chosen)
+      mappings.push(chosen);
   }
   return mappings;
 }
 function detectFirstNativeJsxElement(source) {
   const withoutComments = stripComments(source);
   const declared = elementFromPropsType(withoutComments);
-  if (declared) return declared;
+  if (declared)
+    return declared;
   const slot = SLOT_FALLBACK.exec(withoutComments)?.[1];
-  if (slot && HTML_ELEMENTS.has(slot)) return slot;
+  if (slot && HTML_ELEMENTS.has(slot))
+    return slot;
   return elementFromJsx(withoutComments);
 }
 function elementFromPropsType(source) {
   const found = [];
   for (const match of source.matchAll(COMPONENT_PROPS)) {
     const element = match[1];
-    if (element && HTML_ELEMENTS.has(element)) found.push({ at: match.index, element });
+    if (element && HTML_ELEMENTS.has(element))
+      found.push({ at: match.index, element });
   }
   for (const match of source.matchAll(HTML_ATTRIBUTES)) {
     const element = elementOfAttributes(match[1], match[2]);
-    if (element) found.push({ at: match.index, element });
+    if (element)
+      found.push({ at: match.index, element });
   }
   return found.toSorted((a, b) => a.at - b.at)[0]?.element ?? null;
 }
 function elementOfAttributes(prefix, domInterface) {
-  if (prefix !== void 0) {
+  if (prefix !== undefined) {
     const lower = prefix.toLowerCase();
     const named = TAG_OF_ATTRIBUTES_PREFIX[lower] ?? lower;
-    if (HTML_ELEMENTS.has(named)) return named;
+    if (HTML_ELEMENTS.has(named))
+      return named;
   }
-  const mapped = domInterface === void 0 ? void 0 : TAG_OF_DOM_INTERFACE[domInterface];
-  return mapped !== void 0 && HTML_ELEMENTS.has(mapped) ? mapped : null;
+  const mapped = domInterface === undefined ? undefined : TAG_OF_DOM_INTERFACE[domInterface];
+  return mapped !== undefined && HTML_ELEMENTS.has(mapped) ? mapped : null;
 }
 function elementFromJsx(withoutComments) {
   const cleaned = withoutComments.replaceAll(/(["'`])(?:\\.|(?!\1)[^\\])*\1/g, '""');
   for (const match of cleaned.matchAll(JSX_TAG)) {
     const tag = match[1];
-    if (tag && HTML_ELEMENTS.has(tag)) return tag;
+    if (tag && HTML_ELEMENTS.has(tag))
+      return tag;
   }
   return null;
 }

package/dist/index.d.ts

@@ -1,52 +1,5 @@
-import { Preset } from './presets.js';
-export { PRESETS, PresetName, RENAMED_TO, rulesOfPreset } from './presets.js';
-
-/**
- * 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.
- */
-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.
- */
-type ProbeTree = {
-    files: readonly Probe[];
-};
-type ProbeFn = (options: readonly unknown[]) => Probe | ProbeTree;
-
-type RetiredRule = Rule & {
-    meta: Rule['meta'] & {
-        retired: {
-            reason: string;
-            since: string;
-        };
-    };
-};
-declare const RETIRED_RULES: Record<'document-sagas-are-generic' | 'documents-share-one-table', RetiredRule>;
-
-type Rule = {
+import type { ProbeFn } from './rules/lib/probe.js';
+export type Rule = {
     create: (context: never) => Record<string, unknown>;
     fixShape: string;
     meta: {
@@ -74,8 +27,9 @@ type Rule = {
         packages: readonly string[];
     };
 };
-declare const rules: Record<string, Rule>;
-
+export declare const rules: Record<string, Rule>;
+export { PRESETS, RENAMED_TO, rulesOfPreset } from './presets.js';
+export type { Preset, PresetName } from './presets.js';
 declare const plugin: {
     configs: {
         'backend-d1': {
@@ -96,7 +50,7 @@ declare const plugin: {
         'backend-workflows-cf': {
             rules: Record<string, "error">;
         };
-        'comment-ceiling': Preset;
+        'comment-ceiling': import('./presets.js').Preset;
         'failure-paths': {
             rules: Record<string, "error">;
         };
@@ -131,5 +85,4 @@ declare const plugin: {
     };
     rules: Record<string, Rule>;
 };
-
-export { Preset, RETIRED_RULES, type Rule, plugin as default, rules };
+export default plugin;