@geonosis/oxlint-plugin-biological-architecture 0.2.1 → 0.4.0

package/corpus/.oxlintrc.json

@@ -35,6 +35,7 @@
       }
     ],
     "biological-architecture/effect-hook-naming": "error",
+    "biological-architecture/emit-declares-attempts": "error",
     "biological-architecture/layer-walls": [
       "error",
       {

package/corpus/admin/order-widget.tsx

@@ -0,0 +1,13 @@
+// A file in no tier folder at all — a Medusa admin widget, a Next route, a one-off surface. The
+// atom exists there too, so no-raw-html-atoms still has something to say.
+import { Card } from '@kit/ui/atoms/card'
+
+export function OrderWidget({ onRefresh }: { onRefresh: () => void }) {
+  return (
+    <Card>
+      <button onClick={onRefresh} type="button">
+        Refresh
+      </button>
+    </Card>
+  )
+}

package/corpus/atoms-discovery/generic-only.tsx

@@ -0,0 +1,9 @@
+import { useMemo } from 'react'
+
+const weights: Record<string, number> = { bold: 700, regular: 400 }
+
+export function Spacer({ weight = 'regular' }: { weight?: string }) {
+  const value = useMemo<number>(() => weights[weight] ?? 400, [weight])
+
+  return <div style={{ fontWeight: value }} />
+}

package/corpus/atoms-discovery/html-attributes-select.tsx

@@ -0,0 +1,15 @@
+import type { HTMLAttributes } from 'react'
+
+interface NativeSelectProps extends Omit<HTMLAttributes<HTMLSelectElement>, 'onChange'> {
+  onPick?: (value: string) => void
+}
+
+export function NativeSelect({ onPick, children, ...props }: NativeSelectProps) {
+  return (
+    <div className="relative">
+      <select onChange={(event) => onPick?.(event.target.value)} {...props}>
+        {children}
+      </select>
+    </div>
+  )
+}

package/corpus/atoms-discovery/icon-check.tsx

@@ -0,0 +1,7 @@
+export function CheckIcon({ size = 16 }: { size?: number }) {
+  return (
+    <svg fill="none" height={size} viewBox="0 0 24 24" width={size}>
+      <path d="M20 6 9 17l-5-5" stroke="currentColor" strokeWidth="2" />
+    </svg>
+  )
+}

package/corpus/atoms-discovery/label.tsx

@@ -0,0 +1,3 @@
+export function Label({ children }: { children?: unknown }) {
+  return <label className="text-sm">{children}</label>
+}

package/corpus/atoms-discovery/props-button.tsx

@@ -0,0 +1,27 @@
+import { cva, type VariantProps } from 'class-variance-authority'
+import { Slot } from 'radix-ui'
+import type { ComponentProps, Ref } from 'react'
+
+const buttonVariants = cva('inline-flex', {
+  variants: { size: { medium: 'px-7', small: 'px-5' } },
+})
+
+type ButtonSize = NonNullable<VariantProps<typeof buttonVariants>['size']>
+
+const labels: Record<string, string> = { medium: 'Medium', small: 'Small' }
+
+interface ButtonProps extends ComponentProps<'button'>, VariantProps<typeof buttonVariants> {
+  asChild?: boolean
+  ref?: Ref<HTMLButtonElement>
+}
+
+export function Button({ asChild = false, size, children, ...props }: ButtonProps) {
+  const Comp = asChild ? Slot.Root : 'button'
+  const resolved: ButtonSize = size ?? 'medium'
+
+  return (
+    <Comp aria-label={labels[resolved]} {...props}>
+      {children}
+    </Comp>
+  )
+}

package/corpus/atoms-discovery/props-without-ref-textarea.tsx

@@ -0,0 +1,11 @@
+import type { ComponentPropsWithoutRef } from 'react'
+
+type TextAreaProps = ComponentPropsWithoutRef<'textarea'> & { invalid?: boolean }
+
+export function TextArea({ invalid = false, ...props }: TextAreaProps) {
+  return (
+    <div className="relative">
+      <textarea data-invalid={invalid} {...props} />
+    </div>
+  )
+}

package/corpus/atoms-discovery/react-namespaced-input.tsx

@@ -0,0 +1,13 @@
+import * as React from 'react'
+
+interface TextInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+  invalid?: boolean
+}
+
+export function TextInput({ invalid = false, ...props }: TextInputProps) {
+  return (
+    <div className="relative">
+      <input data-invalid={invalid} {...props} />
+    </div>
+  )
+}

package/corpus/atoms-discovery/slot-anchor.stories.tsx

@@ -0,0 +1,9 @@
+import { LinkAtom } from './slot-anchor'
+
+export default { component: LinkAtom, title: 'Atoms/LinkAtom' }
+
+export const Loading = () => (
+  <figure>
+    <progress max={100} value={40} />
+  </figure>
+)

package/corpus/atoms-discovery/slot-anchor.tsx

@@ -0,0 +1,15 @@
+import { Slot } from 'radix-ui'
+
+import { cn } from '#lib/utils'
+
+interface LinkAtomProps {
+  asChild?: boolean
+  children?: unknown
+  className?: string
+}
+
+export function LinkAtom({ asChild = false, children, className }: LinkAtomProps) {
+  const Comp = asChild ? Slot.Root : 'a'
+
+  return <Comp className={cn('underline', className)}>{children}</Comp>
+}

package/corpus/emits/bad-no-options.ts

@@ -0,0 +1,7 @@
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+export const emitMilestone = (data: { tracking_number: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'shipment.milestone',
+  })

package/corpus/emits/bad-priority-only.ts

@@ -0,0 +1,11 @@
+import { EventPriority } from '@medusajs/framework/utils'
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+// An options bag that names a priority and no attempts: configured to the eye, droppable to the
+// worker, which reads only `attempts > 1` as "a retry was asked for".
+export const emitSampleRequested = (data: { order_id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'sample.requested',
+    options: { priority: EventPriority.CRITICAL },
+  }).config({ name: 'emit-sample-requested' })

package/corpus/emits/bad-single-attempt.ts

@@ -0,0 +1,8 @@
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+export const emitConverted = (data: { order_id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'sample.converted',
+    options: { attempts: 1 },
+  })

package/corpus/emits/good-retry-budget.ts

@@ -0,0 +1,9 @@
+import { EventPriority } from '@medusajs/framework/utils'
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+export const emitOrderPlaced = (data: { id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'order.placed',
+    options: { attempts: 3, priority: EventPriority.CRITICAL },
+  }).config({ name: 'emit-order-placed' })

package/corpus/emits/good-shared-constant.ts

@@ -0,0 +1,10 @@
+import { emitEventStep } from '@medusajs/medusa/core-flows'
+
+import { RETRY_BACKGROUND } from './retry'
+
+export const emitProofReady = (data: { proof_id: string }) =>
+  emitEventStep({
+    data,
+    eventName: 'proof.ready',
+    options: { attempts: RETRY_BACKGROUND.attempts },
+  })

package/corpus/emits/retry.ts

@@ -0,0 +1,3 @@
+// The shared retry budgets. One place, so a change to what "background" means reaches every emit.
+export const RETRY_BACKGROUND = { attempts: 5, backoff: 2000 }
+export const RETRY_CRITICAL = { attempts: 9, backoff: 500 }

package/corpus/features/invoice/cells/bad-relative-cross-feature-store.tsx

@@ -0,0 +1,9 @@
+// The same breach as bad-cross-feature-store.tsx, written the way a file two directories away
+// writes it. The source names no feature until it is resolved against THIS file — which is exactly
+// what no-cross-feature-stores used to be blind to.
+import { useBillingStore } from '../../billing/stores/billing-store'
+
+export function BadRelativeCrossFeatureStore() {
+  const total = useBillingStore((state) => state.total)
+  return <span>{total}</span>
+}

package/corpus/features/invoice/cells/good-relative-own-store.tsx

@@ -0,0 +1,8 @@
+// A relative import of this feature's OWN store — allowed, and it must stay allowed once relative
+// sources are resolved.
+import { useInvoiceStore } from '../stores/invoice-store'
+
+export function GoodRelativeOwnStore() {
+  const total = useInvoiceStore((state) => state.total)
+  return <span>{total}</span>
+}

package/corpus/features/invoice/organelles/bad-relative-cross-feature-organelle.tsx

@@ -0,0 +1,11 @@
+// A relative climb out of this feature into ANOTHER feature's organelle. organelle-dependency must
+// fire: where the import LANDS is the fact, not how it was spelled.
+import { BillingTotals } from '../../billing/organelles/billing-totals'
+
+export function BadRelativeCrossFeatureOrganelle() {
+  return (
+    <section>
+      <BillingTotals />
+    </section>
+  )
+}

package/corpus/features/invoice/organelles/good-relative-same-feature-organelle.tsx

@@ -0,0 +1,11 @@
+// A sub-organelle in the SAME feature — the nucleolus in the nucleus. Allowed, and it must stay
+// allowed once relative sources are resolved.
+import { InvoiceLines } from './invoice-lines'
+
+export function GoodRelativeSameFeatureOrganelle() {
+  return (
+    <section>
+      <InvoiceLines />
+    </section>
+  )
+}

package/corpus/manifest.json

@@ -13,6 +13,7 @@
     "biological-architecture/document-sagas-are-generic",
     "biological-architecture/documents-share-one-table",
     "biological-architecture/effect-hook-naming",
+    "biological-architecture/emit-declares-attempts",
     "biological-architecture/layer-walls",
     "biological-architecture/max-comment-density",
     "biological-architecture/molecule-atoms-only",

package/corpus/molecules/raw-button.tsx

@@ -0,0 +1,10 @@
+// A molecule hand-rolling the element an atom already wraps: level 2, where the rule bites.
+import { Icon } from '../atoms/icon'
+
+export function IconAction({ onPress }: { onPress: () => void }) {
+  return (
+    <button onClick={onPress} type="button">
+      <Icon name="plus" />
+    </button>
+  )
+}

package/dist/{chunk-HXBZSOIU.js → chunk-55NK7NJN.js}

@@ -52,7 +52,7 @@ var BACKEND_WORKFLOWS = [
 ];
 var BACKEND_D1 = ["no-d1-transaction", "worker-handles-are-scoped"];
 var BACKEND_SAGAFLOW_CF = ["step-opens-its-own-cell"];
-var BACKEND_MEDUSA = ["store-route-scopes-tenant-data"];
+var BACKEND_MEDUSA = ["emit-declares-attempts", "store-route-scopes-tenant-data"];
 var TENANT_SCOPING = [
   "queries-require-org-scope",
   "store-route-scopes-tenant-data",

package/dist/discover-atoms.d.ts

@@ -34,6 +34,18 @@ declare function buildAtomRuleRestrictions(atomsDir: string, importPathPrefix?:
  * Variants are kept as alternatives in the error message.
  */
 declare function scanAtomMappings(atomsDir: string): AtomMapping[];
+/**
+ * The native element an atom wraps, read from the one place every atom says so: its props type.
+ *
+ * `ComponentProps<'button'>`, `ComponentPropsWithoutRef<'textarea'>`,
+ * `HTMLAttributes<HTMLSelectElement>` and `React.ButtonHTMLAttributes<HTMLButtonElement>` all name
+ * the element outright, and an atom that types its props any other way is an atom nobody can
+ * compose. The Radix `asChild ? Slot.Root : 'button'` form comes next, and the JSX-tag scan is
+ * only the fallback — it was the whole detector once, and on a real tree it returned `string`,
+ * `typeof` and `path` while missing every shadcn button in the repo.
+ *
+ * The name is kept because consumers import it.
+ */
 declare function detectFirstNativeJsxElement(source: string): null | string;
 
 export { buildAtomRestrictions, buildAtomRuleRestrictions, detectFirstNativeJsxElement, scanAtomMappings };

package/dist/discover-atoms.js

@@ -2,6 +2,164 @@
 import { readdirSync, readFileSync } from "fs";
 import { basename, join } from "path";
 var GENERIC_ELEMENTS = /* @__PURE__ */ new Set(["div", "span"]);
+var HTML_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "main",
+  "map",
+  "mark",
+  "menu",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "search",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+]);
+var TAG_OF_DOM_INTERFACE = {
+  HTMLAnchorElement: "a",
+  HTMLAreaElement: "area",
+  HTMLAudioElement: "audio",
+  HTMLBRElement: "br",
+  HTMLButtonElement: "button",
+  HTMLCanvasElement: "canvas",
+  HTMLDListElement: "dl",
+  HTMLDataElement: "data",
+  HTMLDataListElement: "datalist",
+  HTMLDetailsElement: "details",
+  HTMLDialogElement: "dialog",
+  HTMLDivElement: "div",
+  HTMLEmbedElement: "embed",
+  HTMLFieldSetElement: "fieldset",
+  HTMLFormElement: "form",
+  HTMLHRElement: "hr",
+  HTMLIFrameElement: "iframe",
+  HTMLImageElement: "img",
+  HTMLInputElement: "input",
+  HTMLLIElement: "li",
+  HTMLLabelElement: "label",
+  HTMLLegendElement: "legend",
+  HTMLMapElement: "map",
+  HTMLMenuElement: "menu",
+  HTMLMeterElement: "meter",
+  HTMLOListElement: "ol",
+  HTMLObjectElement: "object",
+  HTMLOptGroupElement: "optgroup",
+  HTMLOptionElement: "option",
+  HTMLOutputElement: "output",
+  HTMLParagraphElement: "p",
+  HTMLPictureElement: "picture",
+  HTMLPreElement: "pre",
+  HTMLProgressElement: "progress",
+  HTMLSelectElement: "select",
+  HTMLSourceElement: "source",
+  HTMLSpanElement: "span",
+  HTMLTableCaptionElement: "caption",
+  HTMLTableColElement: "col",
+  HTMLTableElement: "table",
+  HTMLTableRowElement: "tr",
+  HTMLTextAreaElement: "textarea",
+  HTMLTimeElement: "time",
+  HTMLTrackElement: "track",
+  HTMLUListElement: "ul",
+  HTMLVideoElement: "video"
+};
+var TAG_OF_ATTRIBUTES_PREFIX = { anchor: "a" };
+var NOT_AN_ATOM = /\.(?:stories|test|spec)\.tsx$/;
+var COMPONENT_PROPS = /(?:React\.)?ComponentProps(?:WithoutRef|WithRef)?\s*<\s*['"]([a-z][a-z0-9]*)['"]\s*>/g;
+var HTML_ATTRIBUTES = /(?:React\.)?([A-Z][A-Za-z]*?)?HTMLAttributes\s*<\s*(HTML[A-Za-z]*Element)\s*>/g;
+var SLOT_FALLBACK = /Slot(?:\.Root)?\s*:\s*['"]([a-z][a-z0-9]*)['"]/;
+var JSX_TAG = /(?<![A-Za-z0-9_$])<([a-z][a-z0-9]*)(?=[\s/>])/g;
 function buildAtomRestrictions(atomsDir, importPathPrefix = "@kit/ui/atoms") {
   const mappings = scanAtomMappings(atomsDir);
   return mappings.map(({ atomName, nativeElement }) => ({
@@ -23,6 +181,7 @@ function scanAtomMappings(atomsDir) {
   for (const entry of entries) {
     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");
@@ -42,11 +201,44 @@ function scanAtomMappings(atomsDir) {
   return mappings;
 }
 function detectFirstNativeJsxElement(source) {
-  const slotMatch = source.match(/Slot\s*:\s*['"]([a-z][a-z0-9]*)['"]/);
-  if (slotMatch?.[1]) return slotMatch[1];
-  const cleaned = source.replaceAll(/\/\/.*$/gm, "").replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/(["'`])(?:\\.|(?!\1)[^\\])*\1/g, '""');
-  const match = cleaned.match(/<([a-z][a-z0-9]*)\b/);
-  return match?.[1] ?? null;
+  const withoutComments = stripComments(source);
+  const declared = elementFromPropsType(withoutComments);
+  if (declared) return declared;
+  const slot = SLOT_FALLBACK.exec(withoutComments)?.[1];
+  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 });
+  }
+  for (const match of source.matchAll(HTML_ATTRIBUTES)) {
+    const element = elementOfAttributes(match[1], match[2]);
+    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) {
+    const lower = prefix.toLowerCase();
+    const named = TAG_OF_ATTRIBUTES_PREFIX[lower] ?? lower;
+    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;
+}
+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;
+  }
+  return null;
+}
+function stripComments(source) {
+  return source.replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/(?<!:)\/\/.*$/gm, "");
 }
 function toPascalCase(kebab) {
   return kebab.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");