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

package/dist/rules/cells-folder-index-is-barrel.js

@@ -1,46 +1,68 @@
 // src/rules/cells-folder-index-is-barrel.ts
 import { isCellsBarrel } from "./lib/cells-barrel.js";
-import { normalise } from "./lib/paths.js";
-function describeStatement(stmt) {
-  switch (stmt.type) {
-    case "ClassDeclaration":
-      return "a class declaration";
-    case "ExportDefaultDeclaration":
-      return "a default export declaration";
-    case "ExportNamedDeclaration":
-      return "a named export declaration (not a re-export)";
-    case "ExpressionStatement":
-      return "a top-level expression statement";
-    case "FunctionDeclaration":
-      return "a function declaration";
-    case "ImportDeclaration":
-      return "a side-effect import";
-    case "VariableDeclaration":
-      return "a variable declaration";
-    default:
-      return `a ${stmt.type} statement`;
-  }
-}
+import { landingsOf } from "./lib/landing.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { inTier } from "./lib/tiers.js";
+var DESCRIPTIONS = {
+  ClassDeclaration: "a class declaration",
+  ExportDefaultDeclaration: "a default export declaration",
+  ExportNamedDeclaration: "a named export declaration (not a re-export)",
+  ExpressionStatement: "a top-level expression statement",
+  FunctionDeclaration: "a function declaration",
+  ImportDeclaration: "a side-effect import",
+  VariableDeclaration: "a variable declaration"
+};
+var reexportedFrom = (statement) => (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && typeof statement.source?.value === "string" ? statement.source.value : undefined;
+var namesOf = (statement) => statement.type === "ExportAllDeclaration" ? [] : (statement.specifiers ?? []).flatMap((one) => typeof one.exported?.name === "string" ? [one.exported.name] : []);
+var landsInOrganelles = (filename, statement, source) => {
+  const landed = landingsOf(filename, source, namesOf(statement));
+  if (landed.door === undefined)
+    return inTier(`${source}/`, "organelles");
+  return [landed.door, ...landed.homes.values()].some((file) => inTier(file, "organelles"));
+};
 var cellsFolderIndexIsBarrel = {
   create(context) {
     const filename = context.filename;
     const normalized = normalise(filename);
-    if (!isCellsBarrel(normalized))
-      return {};
-    const shortName = normalized.split("/").pop() || normalized;
+    const shortName = fileOf(normalized);
+    if (!isCellsBarrel(normalized)) {
+      if (!inTier(normalized, "cells"))
+        return {};
+      return {
+        Program(node) {
+          const sources = node.body.map(reexportedFrom);
+          if (sources.length === 0 || sources.some((one) => one === undefined))
+            return;
+          const names = node.body.flatMap(namesOf);
+          const organelle = node.body.find((statement) => landsInOrganelles(filename, statement, reexportedFrom(statement) ?? ""));
+          if (organelle === undefined)
+            return;
+          context.report({
+            data: {
+              file: shortName,
+              names: names.length > 0 ? names.join(", ") : "*",
+              source: reexportedFrom(organelle) ?? ""
+            },
+            messageId: "organelleWearingCells",
+            node: organelle
+          });
+        }
+      };
+    }
     return {
       Program(node) {
-        for (const stmt of node.body) {
-          if (stmt.type === "ExportAllDeclaration")
-            continue;
-          if (stmt.type === "ExportNamedDeclaration" && stmt.source)
-            continue;
-          if (stmt.type === "ImportDeclaration" && stmt.importKind === "type")
+        for (const statement of node.body) {
+          const isReexport = reexportedFrom(statement) !== undefined;
+          if (isReexport || statement.type === "ImportDeclaration" && statement.importKind === "type") {
             continue;
+          }
           context.report({
-            data: { file: shortName, kind: describeStatement(stmt) },
+            data: {
+              file: shortName,
+              kind: DESCRIPTIONS[statement.type] ?? `a ${statement.type} statement`
+            },
             messageId: "notBarrel",
-            node: stmt
+            node: statement
           });
         }
       }
@@ -48,16 +70,26 @@ var cellsFolderIndexIsBarrel = {
   },
   fixShape: `\`cells/index.ts\` and \`cells/dynamic.ts\` are barrels: \`export … from\` lines and nothing else. No
 function, class or variable declaration, no side-effect import. Logic that wants to live in the
-barrel belongs in a cell file the barrel re-exports.`,
+barrel belongs in a cell file the barrel re-exports. A file in \`cells/\` that is not a barrel and only
+re-exports an organelle is that organelle wearing the cell folder, and every parent that composes it
+becomes a cell composing a cell: import the organelle where it is used, or write the cell here.`,
   meta: {
     docs: {
-      description: "Barrel files under cells/ (index.ts, dynamic.ts, dynamic.tsx) must contain ONLY re-export statements. Component definitions belong in their own file."
+      description: "Barrel files under cells/ (index.ts, dynamic.ts, dynamic.tsx) must contain ONLY re-export statements. Component definitions belong in their own file. Any other file in cells/ that only re-exports an organelle is an organelle wearing the cell folder."
     },
     messages: {
+      organelleWearingCells: 'File "{{file}}" only re-exports {{names}} from "{{source}}", which is an organelle. A file in cells/ that holds no cell is an organelle wearing the cell folder, and every parent that composes it becomes a cell composing a cell. Import the organelle where it is used, or write the cell here.',
       notBarrel: 'Barrel file "{{file}}" contains {{kind}}. Barrel files under cells/ must be pure re-export manifests (only `export * from` or `export { X } from`). Component definitions belong in their own file.'
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/cells/index.ts",
+      source: `export const geonosisProbe = 1
+`
+    };
   }
 };
 var cells_folder_index_is_barrel_default = cellsFolderIndexIsBarrel;

package/dist/rules/compound-must-be-stateless.d.ts

@@ -1,5 +1,6 @@
 import { type RuleContext } from './lib/context.js';
 import type { AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 interface ImportNode {
     importKind?: string;
     source: {
@@ -35,5 +36,6 @@ declare const compoundMustBeStateless: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default compoundMustBeStateless;

package/dist/rules/compound-must-be-stateless.js

@@ -1,6 +1,7 @@
 // src/rules/compound-must-be-stateless.ts
 import { hookCalledBy } from "./lib/hooks.js";
-import { normalise } from "./lib/paths.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { inTier } from "./lib/tiers.js";
 var reactForbiddenHooks = new Set([
   "useCallback",
   "useEffect",
@@ -12,49 +13,35 @@ var reactForbiddenHooks = new Set([
   "useState"
 ]);
 var CONTEXT_MODULE = /(?:^|\/)(?:providers|contexts)\//;
-var COMPOUND_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?compounds\//;
 var compoundMustBeStateless = {
   create(context) {
-    const filename = context.filename;
-    const normalized = normalise(filename);
-    const isCompound = COMPOUND_FILE_PATTERN.test(normalized);
-    if (!isCompound)
+    const normalized = normalise(context.filename);
+    if (!inTier(normalized, "compounds"))
       return {};
-    const shortName = normalized.split("/").pop() || normalized;
+    const shortName = fileOf(normalized);
     return {
       CallExpression(node) {
-        const name = hookCalledBy(node);
-        if (name === null)
+        const hook = hookCalledBy(node);
+        if (hook === null)
           return;
-        context.report({
-          data: { file: shortName, hook: name },
-          messageId: "forbiddenHookCall",
-          node
-        });
+        context.report({ data: { file: shortName, hook }, messageId: "forbiddenHookCall", node });
       },
       ImportDeclaration(node) {
         if (node.importKind === "type")
           return;
         const source = node.source.value;
         if (source === "react") {
-          const specifiers = node.specifiers ?? [];
-          for (const spec of specifiers) {
-            if (spec.type !== "ImportSpecifier")
-              continue;
-            const importedName = spec.imported?.name;
-            if (!importedName)
-              continue;
-            if (reactForbiddenHooks.has(importedName)) {
+          for (const specifier of node.specifiers ?? []) {
+            const hook = specifier.type === "ImportSpecifier" ? specifier.imported?.name : undefined;
+            if (hook !== undefined && reactForbiddenHooks.has(hook)) {
               context.report({
-                data: { file: shortName, hook: importedName },
+                data: { file: shortName, hook },
                 messageId: "forbiddenReactHook",
                 node
               });
             }
           }
-          return;
-        }
-        if (CONTEXT_MODULE.test(source)) {
+        } else if (CONTEXT_MODULE.test(source)) {
           context.report({
             data: { file: shortName, source },
             messageId: "forbiddenContextImport",
@@ -78,6 +65,17 @@ organelle and holds it; if the file itself needs state, it is not a compound.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/compounds/geonosis-probe.tsx",
+      source: `declare const useGeonosisThing: () => boolean
+
+export function GeonosisProbe() {
+  return useGeonosisThing() ? 'a' : 'b'
+}
+`
+    };
   }
 };
 var compound_must_be_stateless_default = compoundMustBeStateless;

package/dist/rules/compound-no-stores.d.ts

@@ -9,6 +9,7 @@ declare const compoundNoStores: {
         }) => 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/compound-no-stores.js

@@ -1,23 +1,25 @@
 // src/rules/compound-no-stores.ts
 import { directionRule } from "./lib/direction-rule.js";
-var FORBIDDEN_PATTERNS = [
-  /(?:^|\/)stores\//,
-  /(?:^|\/)organelles\//,
-  /(?:^|\/)cells\//,
-  /(?:^|\/)tissues\//,
-  /(?:^|\/)layouts\//,
-  /\/app\//
-];
+import { isTestFile } from "./lib/paths.js";
+import { inTiersAbove, APP_FOLDER, LAYOUTS_FOLDER, STORES_FOLDER } from "./lib/tiers.js";
+var FORBIDDEN_PATTERNS = [STORES_FOLDER, LAYOUTS_FOLDER, APP_FOLDER];
 var compoundNoStores = directionRule({
   description: "Compounds may only import atoms, molecules, and other compounds. They cannot import organelles, cells, tissues, stores, or app routes — direction rule: a parent may only compose children at levels <= its own.",
   fixShape: `A compound may import atoms, molecules and other compounds. Stores, organelles, cells, tissues,
 layouts and app routes are all above it. Take the data as a prop from the cell that reads the store.
 Type-only imports are exempt; \`export … from\` is not.`,
-  forbidden: (target) => FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
+  forbidden: (target) => inTiersAbove(target.path, "compounds") || FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
   messages: {
     forbidden: "Compounds cannot import from {{source}}. Direction violation — compounds are level 3 and can only depend on atoms, molecules, other compounds, and shared libs/domains/types."
   },
-  scope: (importer) => importer.tier === "compounds" && !/__tests__\//.test(importer.path)
+  probe: () => ({
+    path: "src/compounds/geonosis-probe.tsx",
+    source: `import { up } from '../stores/geonosis-up'
+
+export const GeonosisProbe = up
+`
+  }),
+  scope: (importer) => importer.tier === "compounds" && !isTestFile(importer.path)
 });
 var compound_no_stores_default = compoundNoStores;
 export {

package/dist/rules/constants-in-constants-file.d.ts

@@ -1,3 +1,4 @@
+import { type RuleContext } from './lib/context.js';
 type Declarator = {
     type: string;
     id: {
@@ -14,14 +15,7 @@ type ExportNamedDeclaration = {
     } | null;
 };
 declare const constantsInConstantsFile: {
-    create(context: {
-        filename: string;
-        report: (d: {
-            messageId: string;
-            node: unknown;
-            data: Record<string, string>;
-        }) => void;
-    }): {
+    create(context: RuleContext): {
         ExportNamedDeclaration?: undefined;
     } | {
         ExportNamedDeclaration(node: ExportNamedDeclaration): void;

package/dist/rules/constants-in-constants-file.js

@@ -1,21 +1,20 @@
 // src/rules/constants-in-constants-file.ts
-import { normalise } from "./lib/paths.js";
+import { matchesAny, normalise } from "./lib/paths.js";
 var exemptFiles = [/\/constants\.ts$/, /\/__tests__\//, /\/scripts\//, /\/testing\//, /\.d\.ts$/];
 var screamingSnake = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
 var constantsInConstantsFile = {
   create(context) {
-    const normalized = normalise(context.filename);
-    if (exemptFiles.some((file) => file.test(normalized)))
+    if (matchesAny(exemptFiles, normalise(context.filename)))
       return {};
     return {
       ExportNamedDeclaration(node) {
-        const declaration = node.declaration;
-        if (!declaration || declaration.type !== "VariableDeclaration")
+        const { declaration } = node;
+        if (declaration?.type !== "VariableDeclaration")
           return;
         for (const declarator of declaration.declarations ?? []) {
           const name = declarator.id.type === "Identifier" ? declarator.id.name : undefined;
           if (name !== undefined && name.length >= 3 && screamingSnake.test(name)) {
-            context.report({ messageId: "outsideConstantsFile", node, data: { name } });
+            context.report({ data: { name }, messageId: "outsideConstantsFile", node });
           }
         }
       }

package/dist/rules/dialect-through-the-seam.d.ts

@@ -1,15 +1,7 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * Regex sources over the normalised filename: the files the Postgres-word check leaves alone —
-     * test helpers, fixtures. Naming any REPLACES the test-path default.
-     */
     exempt?: string | string[];
-    /**
-     * Regex sources over the normalised filename: the only files that may name a dialect or driver
-     * module — the schema, the dialect module, the client, the drivers, drizzle-kit's configs.
-     */
     seam?: string | string[];
 }
 declare const dialectThroughTheSeam: {
@@ -53,11 +45,6 @@ declare const dialectThroughTheSeam: {
         }[];
         type: 'problem';
     };
-    /**
-     * A file OUTSIDE the seam importing the dialect — the inverse of a probe placed where its option
-     * points. Tried against the repo's own `seam`: a seam broad enough to swallow every candidate has
-     * configured a rule that can never fire, and the probe says so rather than calling it green.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default dialectThroughTheSeam;

package/dist/rules/durable-body-reads-through-steps.d.ts

@@ -2,21 +2,11 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /** The config key that marks a workflow durable. Default: the engine's `execution`. */
     durableKey?: string;
-    /** What that key must say. Default: the engine's `'durable'`. */
     durableValue?: boolean | string;
-    /** The identifiers a body reaches the outside world through — this repo's ports. */
     ports?: string[];
-    /**
-     * The receivers whose calls the ENGINE has already made steps of — `stepsOf`' proxy over a module
-     * of bound queries. A call through one is journalled under its own name and answered from the
-     * record on a replay, so it is exactly what this rule asks for rather than what it forbids.
-     */
     stepProxies?: string[];
-    /** The call names that define a step. Default: `createStep`. */
     stepFactories?: string[];
-    /** The call names that define a workflow. Default: `createWorkflow`. */
     workflowFactories?: string[];
 }
 declare const durableBodyReadsThroughSteps: {
@@ -69,10 +59,6 @@ declare const durableBodyReadsThroughSteps: {
         }[];
         type: 'problem';
     };
-    /**
-     * A durable body with one free read and no step at all: a step would be the remedy, and a probe
-     * that carried one would be claiming a finding from the shape the rule accepts.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default durableBodyReadsThroughSteps;

package/dist/rules/durable-body-reads-through-steps.js

@@ -4,10 +4,15 @@ import { propertiesOf, stringOf, valueOf } from "./lib/objects.js";
 import { requireOption } from "./lib/options.js";
 import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
-import { argumentsOf, isStepCall, stepFactoriesOf } from "./lib/steps.js";
+import {
+  argumentsOf,
+  DEFAULT_WORKFLOW_FACTORIES,
+  isStepCall,
+  stepFactoriesOf,
+  workflowFactoriesOf
+} from "./lib/steps.js";
 var RULE = "durable-body-reads-through-steps";
 var ACCEPTS = "{ ports: string[] (required), durableKey: string, durableValue: boolean | string, workflowFactories: string[], stepFactories: string[], stepProxies: string[] }";
-var DEFAULT_WORKFLOW_FACTORIES = ["createWorkflow"];
 var DEFAULT_DURABLE_KEY = "execution";
 var DEFAULT_DURABLE_VALUE = "durable";
 var declaresDurable = (node, key, value) => argumentsOf(node).some((argument) => {
@@ -44,7 +49,7 @@ var durableBodyReadsThroughSteps = {
     const ports = new Set(requireOption(RULE, bag.ports, "ports", ACCEPTS));
     const proxies = new Set(bag.stepProxies ?? []);
     const steps = stepFactoriesOf(RULE, bag.stepFactories);
-    const workflows = new Set(requireOption(RULE, bag.workflowFactories ?? DEFAULT_WORKFLOW_FACTORIES, "workflowFactories"));
+    const workflows = workflowFactoriesOf(RULE, bag.workflowFactories);
     const durableKey = requireOption(RULE, bag.durableKey ?? DEFAULT_DURABLE_KEY, "durableKey");
     const durableValue = bag.durableValue ?? DEFAULT_DURABLE_VALUE;
     return {

package/dist/rules/effect-hook-naming.d.ts

@@ -1,4 +1,6 @@
 import { type RuleContext } from './lib/context.js';
+import type { AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
 type Declared = {
     declaration?: {
         declarations?: {
@@ -17,20 +19,15 @@ type Declared = {
 };
 declare const effectHookNaming: {
     create(context: RuleContext): {
-        CallExpression?: undefined;
         ExportNamedDeclaration?: undefined;
-        Program?: undefined;
+        ExportDefaultDeclaration?: undefined;
+        CallExpression?: undefined;
         'Program:exit'?: undefined;
     } | {
-        CallExpression(node: {
-            callee: {
-                name?: string;
-                type: string;
-            };
-        }): void;
-        ExportNamedDeclaration(node: Declared): void;
-        Program(node: unknown): void;
-        'Program:exit'(): void;
+        CallExpression(node: AnyNode): void;
+        ExportDefaultDeclaration: (node: Declared) => void;
+        ExportNamedDeclaration: (node: Declared) => void;
+        'Program:exit'(program: unknown): void;
     };
     fixShape: string;
     meta: {
@@ -44,5 +41,6 @@ declare const effectHookNaming: {
         schema: never[];
         type: 'problem';
     };
+    probe(): Probe;
 };
 export default effectHookNaming;

package/dist/rules/effect-hook-naming.js

@@ -1,6 +1,7 @@
 // src/rules/effect-hook-naming.ts
-import { normalise } from "./lib/paths.js";
-var HOOK_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?organelles\/.*\.ts$/;
+import { hookNameOf } from "./lib/hooks.js";
+import { normalise, fileOf } from "./lib/paths.js";
+import { inTier } from "./lib/tiers.js";
 var FUNCTION_VALUES = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
 var exportedFunctionsOf = (node) => {
   const declaration = node.declaration;
@@ -13,48 +14,38 @@ var exportedFunctionsOf = (node) => {
 var effectHookNaming = {
   create(context) {
     const normalized = normalise(context.filename);
-    if (!HOOK_FILE_PATTERN.test(normalized))
+    if (!inTier(normalized, "organelles") || !normalized.endsWith(".ts"))
       return {};
-    const file = normalized.split("/").pop() || "";
-    let usesEffect = false;
-    let effectHookName = "";
-    let programNode = null;
+    const file = fileOf(normalized);
+    let effectHook;
     const exportedFunctions = [];
+    const collect = (node) => {
+      exportedFunctions.push(...exportedFunctionsOf(node));
+    };
     return {
       CallExpression(node) {
-        if (node.callee.type !== "Identifier")
-          return;
-        if (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect") {
-          usesEffect = true;
-          effectHookName = node.callee.name;
-        }
-      },
-      ExportNamedDeclaration(node) {
-        exportedFunctions.push(...exportedFunctionsOf(node));
+        const hook = hookNameOf(node);
+        if (hook === "useEffect" || hook === "useLayoutEffect")
+          effectHook = hook;
       },
-      Program(node) {
-        programNode = node;
-      },
-      "Program:exit"() {
-        if (!usesEffect)
+      ExportDefaultDeclaration: collect,
+      ExportNamedDeclaration: collect,
+      "Program:exit"(program) {
+        if (effectHook === undefined)
           return;
         if (!file.endsWith("-effect.ts")) {
           context.report({
-            data: { file, hook: effectHookName, suggested: file.replace(/\.ts$/, "-effect.ts") },
+            data: { file, hook: effectHook, suggested: file.replace(/\.ts$/, "-effect.ts") },
             messageId: "filenameMissingEffect",
-            node: programNode
+            node: program
           });
         }
-        for (const fn of exportedFunctions) {
-          if (!fn.name.endsWith("Effect")) {
+        for (const { name, node } of exportedFunctions) {
+          if (!name.endsWith("Effect")) {
             context.report({
-              data: {
-                hook: effectHookName,
-                name: fn.name,
-                suggested: fn.name + "Effect"
-              },
+              data: { hook: effectHook, name, suggested: `${name}Effect` },
               messageId: "functionMissingEffect",
-              node: fn.node
+              node
             });
           }
         }
@@ -74,6 +65,17 @@ file and the export together — half the pair still fires.`,
     },
     schema: [],
     type: "problem"
+  },
+  probe() {
+    return {
+      path: "src/organelles/use-geonosis-probe-effect.ts",
+      source: `import { useEffect } from 'react'
+
+export function useGeonosisProbe() {
+  useEffect(() => undefined, [])
+}
+`
+    };
   }
 };
 var effect_hook_naming_default = effectHookNaming;

package/dist/rules/emit-declares-attempts.d.ts

@@ -2,18 +2,7 @@ import { type RuleContextWithOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 import { type Probe } from './lib/probe.js';
 interface Options {
-    /**
-     * The functions this repo builds a retry budget with — a Medusa storefront's `retryableEvent`,
-     * which throws on `attempts <= 1` so a call to it IS a budget.
-     *
-     * Empty by default, and naming one changes what an unreadable options bag means. Measured on a
-     * Medusa storefront: all 54 `emitEventStep` sites spell the bag `options: retryableEvent(…)`,
-     * zero literals and zero missing, so the rule said nothing about any of them and "0 findings"
-     * read as coverage while proving only that no bag was absent. Named, the helper passes and any
-     * other call is a budget nobody can check.
-     */
     budgetHelpers?: string[];
-    /** The call names that emit an event. Default: Medusa's `emitEventStep`. */
     emitters?: string[];
 }
 declare const emitDeclaresAttempts: {
@@ -51,12 +40,6 @@ declare const emitDeclaresAttempts: {
         }[];
         type: 'problem';
     };
-    /**
-     * The emit with no budget at all — the shape the rule speaks about first. `emitters` defaults to
-     * Medusa's spelling, so the probe reads the option the way `create` does, default included: a
-     * repo that wraps the emit under its own name gets a probe naming ITS wrapper, and a repo that
-     * does not gets `emitEventStep`.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default emitDeclaresAttempts;

package/dist/rules/emit-declares-attempts.js

@@ -6,10 +6,6 @@ import { bagOf, firstOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
 var RULE = "emit-declares-attempts";
 var DEFAULT_EMITTERS = ["emitEventStep"];
-var OPTIONS = "options";
-var ATTEMPTS = "attempts";
-var EVENT_NAME = "eventName";
-var NO_RETRY = 1;
 var emitDeclaresAttempts = {
   create(context) {
     const emitters = new Set(requireOption(RULE, context.options?.[0]?.emitters ?? DEFAULT_EMITTERS, "emitters"));
@@ -22,8 +18,8 @@ var emitDeclaresAttempts = {
         const properties = propertiesOf(node.arguments?.[0]);
         if (properties === null)
           return;
-        const site = stringOf(valueOf(properties, EVENT_NAME)) ?? emitter;
-        const options = valueOf(properties, OPTIONS);
+        const site = stringOf(valueOf(properties, "eventName")) ?? emitter;
+        const options = valueOf(properties, "options");
         if (options !== undefined && options.type !== "ObjectExpression") {
           if (budgetHelpers.size === 0) {
             context.report({ data: { emitter, site }, messageId: "undeclaredHelpers", node });
@@ -42,15 +38,14 @@ var emitDeclaresAttempts = {
         const bag = options === undefined ? [] : propertiesOf(options);
         if (bag === null)
           return;
-        const attempts = valueOf(bag, ATTEMPTS);
+        const attempts = valueOf(bag, "attempts");
         if (attempts === undefined) {
           context.report({ data: { emitter, site }, messageId: "noBudget", node });
           return;
         }
-        if (attempts.type !== "Literal" || typeof attempts.value !== "number")
-          return;
-        if (attempts.value > NO_RETRY)
+        if (attempts.type !== "Literal" || typeof attempts.value !== "number" || attempts.value > 1) {
           return;
+        }
         context.report({
           data: { attempts: String(attempts.value), emitter, site },
           messageId: "tooFew",