@ponchia/ui 0.5.0 → 0.6.3

package/behaviors/disclosure.js

@@ -1,13 +1,17 @@
-import { hasDom, noop, bindOnce, byIdInHost } from './internal.js';
+import { hasDom, resolveHost, noop, bindOnce, byIdInHost } from './internal.js';
 
 /**
  * Disclosure: a `[data-bronto-disclosure]` trigger toggles the element
  * referenced by its `aria-controls` id, keeping `aria-expanded` and the
  * panel's `hidden` attribute in sync.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
  */
 export function initDisclosure({ root } = {}) {
   if (!hasDom()) return noop;
-  const host = root || document;
+  const host = resolveHost(root);
+  if (!host) return noop;
   const onClick = (e) => {
     const trigger = e.target.closest('[data-bronto-disclosure]');
     if (!trigger || !host.contains(trigger)) return;

package/behaviors/dismissible.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Click on `[data-bronto-dismiss]` removes the nearest ancestor matching
+ * `[data-bronto-dismissible]` (or the selector given as the attribute
+ * value). Emits a cancelable `bronto:dismiss` event first.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
+ */
+export function dismissible({ root }?: import("./internal.js").DelegateOpts): import("./internal.js").Cleanup;
+//# sourceMappingURL=dismissible.d.ts.map

package/behaviors/dismissible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dismissible.d.ts","sourceRoot":"","sources":["dismissible.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uCAHW,OAAO,eAAe,EAAE,YAAY,GAClC,OAAO,eAAe,EAAE,OAAO,CAmB3C"}

package/behaviors/dismissible.js

@@ -1,13 +1,17 @@
-import { hasDom, noop, bindOnce, closestSafe } from './internal.js';
+import { hasDom, resolveHost, noop, bindOnce, closestSafe } from './internal.js';
 
 /**
  * Click on `[data-bronto-dismiss]` removes the nearest ancestor matching
  * `[data-bronto-dismissible]` (or the selector given as the attribute
  * value). Emits a cancelable `bronto:dismiss` event first.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
  */
 export function dismissible({ root } = {}) {
   if (!hasDom()) return noop;
-  const host = root || document;
+  const host = resolveHost(root);
+  if (!host) return noop;
   const onClick = (e) => {
     const btn = e.target.closest('[data-bronto-dismiss]');
     if (!btn || !host.contains(btn)) return;

package/behaviors/forms.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Accessible form validation glue for `<form data-bronto-validate>`.
+ * Progressive enhancement over the native Constraint Validation API —
+ * the framework already ships the `[aria-invalid]` / `.ui-hint--error`
+ * styling; this wires the a11y plumbing every consumer would otherwise
+ * re-implement (and usually get wrong):
+ *
+ *  - suppresses the native error bubbles (`form.noValidate`),
+ *  - on blur and on submit sets `aria-invalid` and writes the browser's
+ *    `validationMessage` into the field's error slot
+ *    (`[data-bronto-error]` inside the `.ui-field`, falling back to a
+ *    `.ui-hint`), linked via `aria-describedby`. When it falls back to a
+ *    `.ui-hint` the original help text is snapshotted and restored once the
+ *    field is valid again (so the error does not eat the help permanently); a
+ *    dedicated empty `[data-bronto-error]` node is still the recommended slot,
+ *  - on an invalid submit, fills the form's
+ *    `[data-bronto-error-summary]` (a `.ui-error-summary`) with
+ *    in-page links to each bad field, focuses it, and blocks submit.
+ *
+ * Pure enhancement: with JS off the form still submits and the browser
+ * validates natively. SSR-safe, idempotent; returns a cleanup function.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
+ */
+export function initFormValidation({ root }?: import("./internal.js").DelegateOpts): import("./internal.js").Cleanup;
+//# sourceMappingURL=forms.d.ts.map

package/behaviors/forms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forms.d.ts","sourceRoot":"","sources":["forms.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,8CAHW,OAAO,eAAe,EAAE,YAAY,GAClC,OAAO,eAAe,EAAE,OAAO,CA6K3C"}

package/behaviors/forms.js

@@ -1,4 +1,4 @@
-import { hasDom, noop, bindOnce, nextFieldUid } from './internal.js';
+import { hasDom, resolveHost, noop, bindOnce, nextFieldUid, collectHosts } from './internal.js';
 
 /**
  * Accessible form validation glue for `<form data-bronto-validate>`.
@@ -11,27 +11,42 @@ import { hasDom, noop, bindOnce, nextFieldUid } from './internal.js';
  *  - on blur and on submit sets `aria-invalid` and writes the browser's
  *    `validationMessage` into the field's error slot
  *    (`[data-bronto-error]` inside the `.ui-field`, falling back to a
- *    `.ui-hint`), linked via `aria-describedby`,
+ *    `.ui-hint`), linked via `aria-describedby`. When it falls back to a
+ *    `.ui-hint` the original help text is snapshotted and restored once the
+ *    field is valid again (so the error does not eat the help permanently); a
+ *    dedicated empty `[data-bronto-error]` node is still the recommended slot,
  *  - on an invalid submit, fills the form's
  *    `[data-bronto-error-summary]` (a `.ui-error-summary`) with
  *    in-page links to each bad field, focuses it, and blocks submit.
  *
  * Pure enhancement: with JS off the form still submits and the browser
  * validates natively. SSR-safe, idempotent; returns a cleanup function.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
  */
 export function initFormValidation({ root } = {}) {
   if (!hasDom()) return noop;
-  const host = root || document;
+  const host = resolveHost(root);
+  if (!host) return noop;
 
   const ensureId = (el, prefix) => {
     if (!el.id) el.id = `${prefix}-${nextFieldUid()}`;
     return el.id;
   };
 
+  // When the field has no dedicated `[data-bronto-error]` node we fall back to
+  // the shared `.ui-hint` help slot. Snapshot its original help text the first
+  // time we overwrite it with an error, so the valid branch can RESTORE the help
+  // rather than blanking it permanently (component-audit C8).
+  const hintHelp = new WeakMap();
+
   const slotFor = (control) => {
     const field = control.closest('.ui-field');
     if (!field) return null;
-    return field.querySelector('[data-bronto-error]') || field.querySelector('.ui-hint');
+    const dedicated = field.querySelector('[data-bronto-error]');
+    if (dedicated) return dedicated;
+    return field.querySelector('.ui-hint');
   };
 
   const link = (control, slot) => {
@@ -43,21 +58,52 @@ export function initFormValidation({ root } = {}) {
     }
   };
 
+  const unlink = (control, slot) => {
+    if (!slot.id) return;
+    const ids = (control.getAttribute('aria-describedby') || '')
+      .split(/\s+/)
+      .filter((id) => id && id !== slot.id);
+    if (ids.length) control.setAttribute('aria-describedby', ids.join(' '));
+    else control.removeAttribute('aria-describedby');
+  };
+
   const validateField = (control) => {
     if (!control.willValidate) return true;
     const ok = control.validity.valid;
     const slot = slotFor(control);
+    // Decide the slot TYPE by the `[data-bronto-error]` attribute, NOT the
+    // `.ui-hint` class: the canonical markup is `<p class="ui-hint"
+    // data-bronto-error>`, which carries BOTH. Keying off `.ui-hint` sent that
+    // dedicated error node down the help-hint branch, which never unlink()s — so
+    // the field kept a dangling aria-describedby to an empty error node after it
+    // was fixed (component-audit C6). Only a *borrowed* plain `.ui-hint` (a help
+    // slot with no dedicated error node) snapshots/restores its help text and
+    // stays linked in the valid state.
+    const dedicated = !!slot?.matches?.('[data-bronto-error]');
+    const hasHintClass = !!slot?.classList.contains('ui-hint');
+    const borrowedHint = hasHintClass && !dedicated;
     if (ok) {
       control.removeAttribute('aria-invalid');
       if (slot) {
-        slot.textContent = '';
-        if (slot.classList.contains('ui-hint')) slot.classList.remove('ui-hint--error');
+        if (hasHintClass) slot.classList.remove('ui-hint--error');
+        if (borrowedHint) {
+          // Restore the snapshotted help text (or clear if there was none); a
+          // help-bearing hint stays linked via aria-describedby (it describes
+          // the field in the valid state too).
+          slot.textContent = hintHelp.get(slot) ?? '';
+        } else {
+          // Dedicated error node: clear it and drop the now-stale describedby
+          // so AT doesn't announce an empty error association.
+          slot.textContent = '';
+          unlink(control, slot);
+        }
       }
     } else {
       control.setAttribute('aria-invalid', 'true');
       if (slot) {
+        if (borrowedHint && !hintHelp.has(slot)) hintHelp.set(slot, slot.textContent);
         slot.textContent = control.validationMessage;
-        if (slot.classList.contains('ui-hint')) slot.classList.add('ui-hint--error');
+        if (hasHintClass) slot.classList.add('ui-hint--error');
         link(control, slot);
       }
     }
@@ -136,12 +182,7 @@ export function initFormValidation({ root } = {}) {
     // otherwise show the native UA bubble instead of the Bronto
     // summary — contradicting the documented contract. (Forms added
     // after init are still covered by the in-handler set.)
-    // Feature-detect rather than `instanceof Element` — `Element` is not
-    // a guaranteed global (SSR / the no-DOM test env), and `host` is
-    // either `document` (no `.matches`) or a root Element.
-    const selfForm =
-      typeof host.matches === 'function' && host.matches('[data-bronto-validate]') ? [host] : [];
-    const forms = [...selfForm, ...(host.querySelectorAll?.('[data-bronto-validate]') ?? [])];
+    const forms = collectHosts(host, '[data-bronto-validate]');
     const priorNoValidate = new Map();
     for (const f of forms) {
       priorNoValidate.set(f, f.noValidate);

package/behaviors/glyph.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Expand `[data-bronto-glyph="name"]` placeholders into a `.ui-dotmatrix`
+ * grid of GLYPH_SIZE² cells — the DOM counterpart to renderGlyph() from
+ * `@ponchia/ui/glyphs`, for when you'd rather drop a placeholder than inline
+ * the markup. Decorative by default (`aria-hidden`); add
+ * `data-bronto-glyph-label` to expose it as `role="img"`. An unknown glyph
+ * name is left untouched. Idempotent (skips an already-expanded host); the
+ * returned cleanup removes the cells and restores the original attributes.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
+ */
+export function initDotGlyph({ root }?: import("./internal.js").DelegateOpts): import("./internal.js").Cleanup;
+//# sourceMappingURL=glyph.d.ts.map

package/behaviors/glyph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyph.d.ts","sourceRoot":"","sources":["glyph.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,wCAHW,OAAO,eAAe,EAAE,YAAY,GAClC,OAAO,eAAe,EAAE,OAAO,CAiH3C"}

package/behaviors/glyph.js

@@ -1,4 +1,4 @@
-import { hasDom, noop } from './internal.js';
+import { hasDom, resolveHost, noop, collectHosts } from './internal.js';
 import { GLYPH_SIZE, glyphCells } from '../glyphs/glyphs.js';
 
 function restoreAttr(el, name, prev) {
@@ -14,13 +14,15 @@ function restoreAttr(el, name, prev) {
  * `data-bronto-glyph-label` to expose it as `role="img"`. An unknown glyph
  * name is left untouched. Idempotent (skips an already-expanded host); the
  * returned cleanup removes the cells and restores the original attributes.
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
  */
 export function initDotGlyph({ root } = {}) {
   if (!hasDom()) return noop;
-  const host = root || document;
-  const els = [];
-  if (host !== document && host.matches?.('[data-bronto-glyph]')) els.push(host);
-  els.push(...(host.querySelectorAll?.('[data-bronto-glyph]') ?? []));
+  const host = resolveHost(root);
+  if (!host) return noop;
+  const els = collectHosts(host, '[data-bronto-glyph]');
   const cleanups = [];
 
   for (const el of els) {
@@ -60,6 +62,25 @@ export function initDotGlyph({ root } = {}) {
       el.style.setProperty('--dotmatrix-dot-radius', '0');
       el.style.setProperty('--dotmatrix-gap', '0');
     }
+    // Without a track size the grid cells default to `1fr`, so the 16×16 matrix
+    // balloons to fill its container (full-bleed) — asymmetric with the mask
+    // path's safe 1em. If the author set no `--dotmatrix-dot` (inline OR via the
+    // cascade), default it to an intrinsic icon scale so a forgotten size
+    // degrades to ~icon, not full-bleed. (component audit C9.)
+    const authoredDot =
+      el.style.getPropertyValue('--dotmatrix-dot') ||
+      (typeof getComputedStyle === 'function'
+        ? getComputedStyle(el).getPropertyValue('--dotmatrix-dot').trim()
+        : '');
+    const setDefaultDot = !authoredDot;
+    let setDefaultGap = false;
+    if (setDefaultDot) {
+      el.style.setProperty('--dotmatrix-dot', '0.08em');
+      if (!solid && !hadGap) {
+        el.style.setProperty('--dotmatrix-gap', '0.02em'); // tight, so it reads as one glyph
+        setDefaultGap = true;
+      }
+    }
     if (label) {
       el.setAttribute('role', 'img');
       el.setAttribute('aria-label', label);
@@ -94,6 +115,8 @@ export function initDotGlyph({ root } = {}) {
         if (hadGap) el.style.setProperty('--dotmatrix-gap', hadGap);
         else el.style.removeProperty('--dotmatrix-gap');
       }
+      if (setDefaultDot) el.style.removeProperty('--dotmatrix-dot');
+      if (setDefaultGap) el.style.removeProperty('--dotmatrix-gap');
       if (hadCols) el.style.setProperty('--dotmatrix-cols', hadCols);
       else el.style.removeProperty('--dotmatrix-cols');
       restoreAttr(el, 'aria-hidden', hadAriaHidden);

package/behaviors/index.d.ts

@@ -1,237 +1,31 @@
-/** @ponchia/ui — optional, framework-agnostic behaviors. */
-
-/** Cleanup function returned by every initializer. */
-export type Cleanup = () => void;
-
-export interface ThemeStorageOpts {
-  /** localStorage key for the persisted theme. Default: "bronto-theme". */
-  storageKey?: string;
-}
-
-export interface ApplyThemeOpts extends ThemeStorageOpts {
-  /** Element to set `data-theme` on. Default: <html>. */
-  root?: Element;
-}
-
-export interface DelegateOpts {
-  /** Event-delegation root; also scopes which controls are queried. Default: document. */
-  root?: Document | Element;
-}
-
-/** `bronto:themechange` CustomEvent detail. */
-export interface ThemeChangeDetail {
-  theme: 'light' | 'dark';
-}
-
-/** Apply the persisted theme to <html data-theme>. Call before paint. */
-export declare function applyStoredTheme(opts?: ApplyThemeOpts): void;
-
-/**
- * Wire `[data-bronto-theme-toggle]` controls. Theme is always applied to
- * <html>; `root` only scopes delegation/queried controls. Dispatches
- * `bronto:themechange` on <html>. Returns a cleanup function.
- */
-export declare function initThemeToggle(opts?: ThemeStorageOpts & DelegateOpts): Cleanup;
-
-/** Wire `[data-bronto-dismiss]` controls. Returns a cleanup function. */
-export declare function dismissible(opts?: DelegateOpts): Cleanup;
-
-/** Wire `[data-bronto-disclosure]` triggers. Returns a cleanup function. */
-export declare function initDisclosure(opts?: DelegateOpts): Cleanup;
-
-/**
- * Close affordances (Escape, outside-click, close-on-activate) for a
- * native `<details data-bronto-menu>` dropdown holding a `.ui-menu`.
- * Not a full ARIA menu by design. Returns a cleanup function.
- */
-export declare function initMenu(opts?: DelegateOpts): Cleanup;
-
-/**
- * Accessible validation glue for `<form data-bronto-validate>`:
- * progressive enhancement over the Constraint Validation API. Sets
- * `aria-invalid`, writes `validationMessage` into the field's
- * `[data-bronto-error]` / `.ui-hint` slot (linked via
- * `aria-describedby`), and on invalid submit fills the form's
- * `[data-bronto-error-summary]` with focusable links and blocks submit.
- * Works without JS (native validation). Returns a cleanup function.
- */
-export declare function initFormValidation(opts?: DelegateOpts): Cleanup;
-
-/**
- * Editable combobox with a filtered listbox popup (WAI-ARIA APG
- * pattern), dependency-free and CSS-anchored. Wires
- * `[data-bronto-combobox]` (input `role=combobox` +
- * `.ui-combobox__list` of `role=option`): ids, `aria-expanded` /
- * `aria-controls` / `aria-activedescendant`, type-to-filter, full
- * keyboard, pointer select, outside-click close. Emits `bronto:change`
- * ({ detail: { value } }) on selection. SSR-safe, idempotent per
- * instance. Returns a cleanup function.
- */
-export declare function initCombobox(opts?: DelegateOpts): Cleanup;
-
-/**
- * Collision-aware popover, dependency-free. A `[data-bronto-popover]`
- * trigger toggles the `.ui-popover` panel it names; the panel flips
- * above when it would overflow the viewport and its inline edge is
- * clamped on-screen. Uses the native top layer when the panel has
- * `popover` and the Popover API exists, else an `.is-open` class.
- * Manages `aria-expanded`/`aria-controls`, Escape + outside-click
- * close, scroll/resize reposition. Returns a cleanup function.
- */
-export declare function initPopover(opts?: DelegateOpts): Cleanup;
-
-/**
- * Client-side sortable + selectable data table for
- * `[data-bronto-sortable]`. Header `.ui-table__sort` / `th[data-sort]`
- * cycles `aria-sort` and reorders the tbody (numeric- or
- * locale-string-aware); `[data-bronto-select-all]` toggles
- * `[data-bronto-select]` rows + `aria-selected` with synced
- * checked/indeterminate state. Emits `bronto:selectionchange`
- * ({ detail: { count } }). SSR-safe, idempotent per table. Returns a
- * cleanup function.
- */
-export declare function initTableSort(opts?: DelegateOpts): Cleanup;
-
-/**
- * Wire `[data-bronto-tabs]` groups with the WAI-ARIA Tabs keyboard
- * pattern (roving tabindex, Arrow/Home/End, aria-selected, panel sync).
- * Returns a cleanup function.
- */
-export declare function initTabs(opts?: DelegateOpts): Cleanup;
-
-/**
- * Wire native <dialog> open/close glue: `[data-bronto-open="id"]`,
- * `[data-bronto-close]`, and backdrop light-dismiss for dialogs marked
- * `[data-bronto-dialog-light]`. `root` scopes delegated controls; dialog ids
- * resolve root-first, then document-wide for body/portal-mounted overlays.
- * Returns a cleanup function.
- */
-export declare function initDialog(opts?: DelegateOpts): Cleanup;
-
-/**
- * Image carousel / gallery built on CSS scroll-snap (touch/trackpad swipe
- * is the browser's). Wires `[data-bronto-carousel]`: prev/next
- * (`[data-bronto-carousel-prev|next]`), keyboard (Arrow/Home/End on the
- * focused `.ui-carousel__viewport`), a `.ui-carousel__thumb` strip with
- * `aria-current` sync, the `.ui-carousel__status` counter, and ARIA. Keeps
- * a JS index in sync with the scroll position both ways (via
- * IntersectionObserver where available). `data-bronto-carousel-loop` wraps
- * at the ends; `data-bronto-carousel-label` names the region. A
- * full-screen lightbox is the same markup inside a native
- * `<dialog class="ui-lightbox">` opened by `initDialog` (focus-trap/Escape
- * come from the dialog). Emits `bronto:change` ({ detail: { index } }).
- * SSR-safe, idempotent per carousel. Returns a cleanup function.
- */
-export declare function initCarousel(opts?: DelegateOpts): Cleanup;
-
-export interface ToastOpts {
-  /** Status tone — maps to `ui-toast--<tone>`. */
-  tone?: 'accent' | 'success' | 'warning' | 'danger' | 'info';
-  /** Optional uppercase label rendered above the message. */
-  title?: string;
-  /** Auto-dismiss delay in ms. 0 keeps it until dismissed. Default: 4000. */
-  duration?: number;
-  /**
-   * Route to the assertive live region so AT interrupts immediately.
-   * Defaults to `true` when `tone === 'danger'`.
-   */
-  assertive?: boolean;
-  /** Render a dismiss button on the toast. */
-  closable?: boolean;
-}
-
-/**
- * Push a transient toast into a shared, body-anchored stack. Returns a
- * function that dismisses it early. No-op (returns noop) without a DOM.
- */
-export declare function toast(message: string, opts?: ToastOpts): Cleanup;
-
-/**
- * Expand `[data-bronto-glyph="name"]` placeholders into a `.ui-dotmatrix`
- * grid of cells — the DOM counterpart to `renderGlyph` from
- * `@ponchia/ui/glyphs`. Decorative by default (`aria-hidden`); add
- * `data-bronto-glyph-label` to expose it as `role="img"`. Unknown glyph names
- * are left untouched. SSR-safe, idempotent (skips an already-expanded host).
- * Returns a cleanup that removes the cells and restores the original
- * attributes.
- */
-export declare function initDotGlyph(opts?: DelegateOpts): Cleanup;
-
-/** `bronto:legend:toggle` CustomEvent detail. `series` is the entry's
- *  `data-series`, or its 0-based index when unset. `active` is the new state
- *  (`true` ⇒ series shown). */
-export interface LegendToggleDetail {
-  series: string | number;
-  active: boolean;
-}
-
-/**
- * Wire `[data-bronto-legend]` interactive legends. Each `.ui-legend__item` is a
- * `<button aria-pressed>`; activating it flips `aria-pressed`, toggles
- * `.is-inactive`, and dispatches `bronto:legend:toggle`
- * ({@link LegendToggleDetail}) on the legend. Bronto owns the control + its
- * state only — the host hides its own series and owns any `aria-live`
- * announcement (`aria-pressed="true"` ⇒ series shown). SSR-safe, idempotent per
- * host. Returns a cleanup function.
- */
-export declare function initLegend(opts?: DelegateOpts): Cleanup;
-
-/**
- * Draw + keep leader lines in sync. Each `[data-bronto-connector]` is a
- * `.ui-connector` SVG overlaying a positioned container; `data-from`/`data-to`
- * are the ids of the elements to connect (with optional `data-shape`,
- * `data-from-side`/`data-to-side`, `data-end`). Computes geometry via the
- * `@ponchia/ui/connectors` helpers and redraws on resize/scroll. Bronto owns no
- * layout. SSR-safe, idempotent per host; returns a cleanup that disconnects
- * observers/listeners. Re-run after adding/removing connectors.
- */
-export declare function initConnectors(opts?: DelegateOpts): Cleanup;
-
-/**
- * Position a spotlight cutout over a target. Each `[data-bronto-spotlight]` is a
- * `.ui-spotlight` overlay; `data-target` is the id of the element to highlight.
- * Sets `--spot-x/y/w/h` and re-places on resize/scroll and when `data-target`
- * changes. NOT a tour engine — the host owns step order/advancing/visibility.
- * SSR-safe, idempotent per host; returns a cleanup function.
- */
-export declare function initSpotlight(opts?: DelegateOpts): Cleanup;
-
-/** `bronto:crosshair:move` CustomEvent detail — pointer position over the plot
- *  in pixels and as 0..1 fractions. Bronto reports where; mapping to data is
- *  the host's. */
-export interface CrosshairMoveDetail {
-  x: number;
-  y: number;
-  fx: number;
-  fy: number;
-}
-
-/**
- * Track the pointer over `[data-bronto-crosshair]` plots and drive a contained
- * `.ui-crosshair` overlay: sets `--crosshair-x/y` (px), marks `.is-active`, and
- * dispatches `bronto:crosshair:move` ({@link CrosshairMoveDetail}) /
- * `bronto:crosshair:leave`. Reports the pointer position only — it does not find
- * the nearest datum or map pixels to data. SSR-safe, idempotent per plot;
- * returns a cleanup function.
- */
-export declare function initCrosshair(opts?: DelegateOpts): Cleanup;
-
-/** `bronto:command:select` CustomEvent detail — the chosen command's value and
- *  visible label. The host executes it; Bronto only filters and navigates. */
-export interface CommandSelectDetail {
-  value: string;
-  label: string;
-}
-
-/**
- * Filter + keyboard-navigate a DOM-authored command list inside
- * `[data-bronto-command]` (the `.ui-command` shell). Owns ids,
- * `role=combobox/listbox/option`, `aria-activedescendant`, a roving active item,
- * substring filtering (hiding empty groups), full keyboard
- * (Down/Up/Home/End/Enter/Escape), and pointer select. Emits
- * `bronto:command:select` ({@link CommandSelectDetail}) on choose and
- * `bronto:command:close` on Escape; the host owns the action registry, routing,
- * and execution. No global Cmd/Ctrl+K. SSR-safe, idempotent per instance;
- * returns a cleanup function.
- */
-export declare function initCommand(opts?: DelegateOpts): Cleanup;
+export { dismissible } from "./dismissible.js";
+export { initDisabledGuard } from "./inert.js";
+export { initTabs } from "./tabs.js";
+export { initDialog } from "./dialog.js";
+export { initModal } from "./modal.js";
+export { toast } from "./toast.js";
+export { initDisclosure } from "./disclosure.js";
+export { initMenu } from "./menu.js";
+export { initFormValidation } from "./forms.js";
+export { initCombobox } from "./combobox.js";
+export { initPopover } from "./popover.js";
+export { initTableSort } from "./table.js";
+export { initCarousel } from "./carousel.js";
+export { initDotGlyph } from "./glyph.js";
+export { initLegend } from "./legend.js";
+export { initConnectors } from "./connectors.js";
+export { initSpotlight } from "./spotlight.js";
+export { initCrosshair } from "./crosshair.js";
+export { initCommand } from "./command.js";
+export type Cleanup = import("./internal.js").Cleanup;
+export type DelegateOpts = import("./internal.js").DelegateOpts;
+export type ThemeStorageOpts = import("./theme.js").ThemeStorageOpts;
+export type ApplyThemeOpts = import("./theme.js").ApplyThemeOpts;
+export type ThemeChangeDetail = import("./theme.js").ThemeChangeDetail;
+export type ToastOpts = import("./toast.js").ToastOpts;
+export type ModalCloseDetail = import("./modal.js").ModalCloseDetail;
+export type LegendToggleDetail = import("./legend.js").LegendToggleDetail;
+export type CrosshairMoveDetail = import("./crosshair.js").CrosshairMoveDetail;
+export type CommandSelectDetail = import("./command.js").CommandSelectDetail;
+export { applyStoredTheme, initThemeToggle } from "./theme.js";
+//# sourceMappingURL=index.d.ts.map

package/behaviors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;sBAmBa,OAAO,eAAe,EAAE,OAAO;2BAC/B,OAAO,eAAe,EAAE,YAAY;+BACpC,OAAO,YAAY,EAAE,gBAAgB;6BACrC,OAAO,YAAY,EAAE,cAAc;gCACnC,OAAO,YAAY,EAAE,iBAAiB;wBACtC,OAAO,YAAY,EAAE,SAAS;+BAC9B,OAAO,YAAY,EAAE,gBAAgB;iCACrC,OAAO,aAAa,EAAE,kBAAkB;kCACxC,OAAO,gBAAgB,EAAE,mBAAmB;kCAC5C,OAAO,cAAc,EAAE,mBAAmB"}

package/behaviors/index.js

@@ -12,11 +12,28 @@
  *   import { applyStoredTheme, initThemeToggle } from '@ponchia/ui/behaviors';
  *   applyStoredTheme();                 // before paint, avoids theme flash
  *   const stop = initThemeToggle();     // wire [data-bronto-theme-toggle]
+ *
+ * The public option/detail types are JSDoc `@typedef`s on the modules below,
+ * re-exported here by name; the shipped `index.d.ts` is generated from this
+ * source by `tsc --emitDeclarationOnly` (so the declarations cannot drift).
+ *
+ * @typedef {import('./internal.js').Cleanup} Cleanup
+ * @typedef {import('./internal.js').DelegateOpts} DelegateOpts
+ * @typedef {import('./theme.js').ThemeStorageOpts} ThemeStorageOpts
+ * @typedef {import('./theme.js').ApplyThemeOpts} ApplyThemeOpts
+ * @typedef {import('./theme.js').ThemeChangeDetail} ThemeChangeDetail
+ * @typedef {import('./toast.js').ToastOpts} ToastOpts
+ * @typedef {import('./modal.js').ModalCloseDetail} ModalCloseDetail
+ * @typedef {import('./legend.js').LegendToggleDetail} LegendToggleDetail
+ * @typedef {import('./crosshair.js').CrosshairMoveDetail} CrosshairMoveDetail
+ * @typedef {import('./command.js').CommandSelectDetail} CommandSelectDetail
  */
 export { applyStoredTheme, initThemeToggle } from './theme.js';
 export { dismissible } from './dismissible.js';
+export { initDisabledGuard } from './inert.js';
 export { initTabs } from './tabs.js';
 export { initDialog } from './dialog.js';
+export { initModal } from './modal.js';
 export { toast } from './toast.js';
 export { initDisclosure } from './disclosure.js';
 export { initMenu } from './menu.js';

package/behaviors/inert.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Make `aria-disabled="true"` controls keyboard-inert, not just pointer-inert.
+ *
+ * CSS can dim an `aria-disabled` control and set `pointer-events: none`, but it
+ * cannot block keyboard activation: a focused `<a aria-disabled>` or
+ * `<button aria-disabled>` still fires on Enter/Space, so a keyboard user can
+ * activate a control that looks dead. (Native `disabled` is already fully inert;
+ * this guard brings the ARIA path up to parity.) The element intentionally stays
+ * focusable and announced — the WAI-ARIA disabled pattern keeps it in the tab
+ * order — but it no longer *acts*.
+ *
+ * Wire once near the root, like {@link applyStoredTheme}. Capturing listeners
+ * intercept activation before any component handler (tabs, pagination, menus)
+ * sees it. (component audit C4.)
+ *
+ * @param {import('./internal.js').DelegateOpts} [opts]
+ * @returns {import('./internal.js').Cleanup}
+ */
+export function initDisabledGuard({ root }?: import("./internal.js").DelegateOpts): import("./internal.js").Cleanup;
+//# sourceMappingURL=inert.d.ts.map

package/behaviors/inert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inert.d.ts","sourceRoot":"","sources":["inert.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,6CAHW,OAAO,eAAe,EAAE,YAAY,GAClC,OAAO,eAAe,EAAE,OAAO,CAyB3C"}