stimeo-ui 0.9.0 → 0.11.0

data/dist/controllers/command_palette_controller.js

@@ -380,15 +380,25 @@ var FocusTrap = class {
    * content cannot be focused or reached by assistive technology, honoring the
    * `aria-modal="true"` contract. An element that was *already* `inert` is left
    * untracked so `#releaseBackground` does not wrongly clear it.
+   *
+   * The walk climbs from the container to `body` and inerts each ancestor's other
+   * children. Scanning only `body`'s children would skip the branch the container
+   * sits in — everything beside it inside that branch is background too, and a
+   * nested container is the ordinary case.
    */
   #isolateBackground() {
     const container = this.#getContainer();
     this.#inertedSiblings = [];
-    for (const sibling of Array.from(document.body.children)) {
-      if (!(sibling instanceof HTMLElement)) continue;
-      if (sibling.contains(container) || sibling.inert) continue;
-      sibling.inert = true;
-      this.#inertedSiblings.push(sibling);
+    for (let node = container; node !== document.body; ) {
+      const parent = node.parentElement;
+      if (!parent) break;
+      for (const sibling of Array.from(parent.children)) {
+        if (!(sibling instanceof HTMLElement)) continue;
+        if (sibling === node || sibling.inert) continue;
+        sibling.inert = true;
+        this.#inertedSiblings.push(sibling);
+      }
+      node = parent;
     }
   }
   /** Reverts the `inert` flags applied by `#isolateBackground`. */

data/dist/controllers/confirm_controller.js

@@ -315,15 +315,25 @@ var FocusTrap = class {
    * content cannot be focused or reached by assistive technology, honoring the
    * `aria-modal="true"` contract. An element that was *already* `inert` is left
    * untracked so `#releaseBackground` does not wrongly clear it.
+   *
+   * The walk climbs from the container to `body` and inerts each ancestor's other
+   * children. Scanning only `body`'s children would skip the branch the container
+   * sits in — everything beside it inside that branch is background too, and a
+   * nested container is the ordinary case.
    */
   #isolateBackground() {
     const container = this.#getContainer();
     this.#inertedSiblings = [];
-    for (const sibling of Array.from(document.body.children)) {
-      if (!(sibling instanceof HTMLElement)) continue;
-      if (sibling.contains(container) || sibling.inert) continue;
-      sibling.inert = true;
-      this.#inertedSiblings.push(sibling);
+    for (let node = container; node !== document.body; ) {
+      const parent = node.parentElement;
+      if (!parent) break;
+      for (const sibling of Array.from(parent.children)) {
+        if (!(sibling instanceof HTMLElement)) continue;
+        if (sibling === node || sibling.inert) continue;
+        sibling.inert = true;
+        this.#inertedSiblings.push(sibling);
+      }
+      node = parent;
     }
   }
   /** Reverts the `inert` flags applied by `#isolateBackground`. */

data/dist/controllers/countdown_controller.js

@@ -121,7 +121,7 @@ var CountdownController = class extends Controller {
   #pausedAmount = 0;
   /**
    * The amount the slots are currently showing, floored to the second they render.
-   * It lags {@link currentAmount} by up to one tick, and it — not the live reading —
+   * It lags {@link #currentAmount} by up to one tick, and it — not the live reading —
    * is what a pause has to preserve: storing the fraction behind the display instead
    * makes the first tick after a resume step by two units.
    */

data/dist/controllers/data_grid_controller.js

@@ -298,7 +298,7 @@ var DataGridController = class extends Controller {
     const row = cell.closest("[role='row']");
     if (row && this.rowTargets.includes(row)) this.#toggleRow(row);
   }
-  /** Shared sort logic for both click and keyboard activation. */
+  /** Cycles a header's sort on keyboard activation and emits `sort`. */
   #cycleSort(header) {
     const direction = nextSortDirection(header.getAttribute("aria-sort") ?? "none");
     for (const other of this.columnHeaderTargets) {

data/dist/controllers/dialog_controller.js

@@ -315,15 +315,25 @@ var FocusTrap = class {
    * content cannot be focused or reached by assistive technology, honoring the
    * `aria-modal="true"` contract. An element that was *already* `inert` is left
    * untracked so `#releaseBackground` does not wrongly clear it.
+   *
+   * The walk climbs from the container to `body` and inerts each ancestor's other
+   * children. Scanning only `body`'s children would skip the branch the container
+   * sits in — everything beside it inside that branch is background too, and a
+   * nested container is the ordinary case.
    */
   #isolateBackground() {
     const container = this.#getContainer();
     this.#inertedSiblings = [];
-    for (const sibling of Array.from(document.body.children)) {
-      if (!(sibling instanceof HTMLElement)) continue;
-      if (sibling.contains(container) || sibling.inert) continue;
-      sibling.inert = true;
-      this.#inertedSiblings.push(sibling);
+    for (let node = container; node !== document.body; ) {
+      const parent = node.parentElement;
+      if (!parent) break;
+      for (const sibling of Array.from(parent.children)) {
+        if (!(sibling instanceof HTMLElement)) continue;
+        if (sibling === node || sibling.inert) continue;
+        sibling.inert = true;
+        this.#inertedSiblings.push(sibling);
+      }
+      node = parent;
     }
   }
   /** Reverts the `inert` flags applied by `#isolateBackground`. */

data/dist/controllers/direct_upload_controller.js

@@ -310,10 +310,6 @@ var DirectUploadController = class extends Controller {
       this.#rows.delete(id);
     }
   }
-  /**
-   * Returns the widget to its pre-upload state just before Turbo caches the
-   * page, so the snapshot never replays rows for uploads that cannot resume.
-   */
   /**
    * Rewinds for the snapshot and reports what that discarded. An upload in flight
    * cannot survive the navigation, so a consumer mirroring the rows would keep a
@@ -352,7 +348,7 @@ var DirectUploadController = class extends Controller {
   #detail(event) {
     return event.detail ?? {};
   }
-  /** The file name every ActiveStorage `direct-upload:*` event carries. */
+  /** The event's file name, or `""` when it carries none. */
   #name(detail) {
     return detail.file?.name ?? "";
   }

data/dist/controllers/drawer_controller.js

@@ -315,15 +315,25 @@ var FocusTrap = class {
    * content cannot be focused or reached by assistive technology, honoring the
    * `aria-modal="true"` contract. An element that was *already* `inert` is left
    * untracked so `#releaseBackground` does not wrongly clear it.
+   *
+   * The walk climbs from the container to `body` and inerts each ancestor's other
+   * children. Scanning only `body`'s children would skip the branch the container
+   * sits in — everything beside it inside that branch is background too, and a
+   * nested container is the ordinary case.
    */
   #isolateBackground() {
     const container = this.#getContainer();
     this.#inertedSiblings = [];
-    for (const sibling of Array.from(document.body.children)) {
-      if (!(sibling instanceof HTMLElement)) continue;
-      if (sibling.contains(container) || sibling.inert) continue;
-      sibling.inert = true;
-      this.#inertedSiblings.push(sibling);
+    for (let node = container; node !== document.body; ) {
+      const parent = node.parentElement;
+      if (!parent) break;
+      for (const sibling of Array.from(parent.children)) {
+        if (!(sibling instanceof HTMLElement)) continue;
+        if (sibling === node || sibling.inert) continue;
+        sibling.inert = true;
+        this.#inertedSiblings.push(sibling);
+      }
+      node = parent;
     }
   }
   /** Reverts the `inert` flags applied by `#isolateBackground`. */
@@ -576,8 +586,8 @@ var DrawerController = class extends Controller {
    * rather than being re-derived from the declarative `open` Value (which would
    * close a user-opened drawer). The `open` Value only seeds a genuinely fresh
    * render. We normalize to a clean closed baseline first so {@link open} runs its
-   * full reveal + trap activation — the {@link FocusTrap} is a fresh instance
-   * after a reconnect and must be re-activated.
+   * full reveal + trap activation — the {@link FocusTrap} is inactive after a
+   * disconnect and must be re-activated.
    */
   connect() {
     this.#connected = true;

data/dist/controllers/focus_controller.js

@@ -315,15 +315,25 @@ var FocusTrap = class {
    * content cannot be focused or reached by assistive technology, honoring the
    * `aria-modal="true"` contract. An element that was *already* `inert` is left
    * untracked so `#releaseBackground` does not wrongly clear it.
+   *
+   * The walk climbs from the container to `body` and inerts each ancestor's other
+   * children. Scanning only `body`'s children would skip the branch the container
+   * sits in — everything beside it inside that branch is background too, and a
+   * nested container is the ordinary case.
    */
   #isolateBackground() {
     const container = this.#getContainer();
     this.#inertedSiblings = [];
-    for (const sibling of Array.from(document.body.children)) {
-      if (!(sibling instanceof HTMLElement)) continue;
-      if (sibling.contains(container) || sibling.inert) continue;
-      sibling.inert = true;
-      this.#inertedSiblings.push(sibling);
+    for (let node = container; node !== document.body; ) {
+      const parent = node.parentElement;
+      if (!parent) break;
+      for (const sibling of Array.from(parent.children)) {
+        if (!(sibling instanceof HTMLElement)) continue;
+        if (sibling === node || sibling.inert) continue;
+        sibling.inert = true;
+        this.#inertedSiblings.push(sibling);
+      }
+      node = parent;
     }
   }
   /** Reverts the `inert` flags applied by `#isolateBackground`. */
@@ -375,13 +385,39 @@ var FocusController = class extends Controller {
     initialFocus: () => this.hasInitialTarget ? this.initialTarget : null,
     onEscape: () => this.deactivate()
   });
+  /**
+   * Whether this scope is currently trapping.
+   *
+   * Held here rather than read back from the trap: the trap releases itself
+   * before Turbo caches the page, so its own flag stops answering for the state
+   * this controller publishes on the element and in its events.
+   */
+  #active = false;
+  /**
+   * Returns the element to its untrapped form before Turbo copies the page. The
+   * trap performs its own release on the same event, so what is left is the hook
+   * this controller owns — carried into the snapshot it would describe a scope
+   * that is no longer trapping.
+   *
+   * Silent, like `disconnect()`: the page is about to be frozen, and a release
+   * nobody asked for is not a close to report.
+   */
+  #beforeCache = new BeforeCacheReset(() => {
+    this.#active = false;
+    this.element.removeAttribute("data-focus-trapped");
+  });
   /** Stimulus drives activation from the `trap` value (also fires on connect). */
   trapValueChanged() {
     if (this.trapValue) this.#activate();
     else this.#deactivate();
   }
+  connect() {
+    this.#beforeCache.activate();
+  }
   disconnect() {
     this.#trap.deactivate({ restoreFocus: false });
+    this.#beforeCache.deactivate();
+    this.#active = false;
     this.element.removeAttribute("data-focus-trapped");
   }
   /** Turns the trap on. Acts synchronously and keeps the `trap` value in sync. */
@@ -395,13 +431,15 @@ var FocusController = class extends Controller {
     this.#deactivate();
   }
   #activate() {
-    if (this.#trap.active) return;
+    if (this.#active) return;
+    this.#active = true;
     this.#trap.activate();
     this.element.setAttribute("data-focus-trapped", "true");
     this.dispatch("activate", { detail: {} });
   }
   #deactivate() {
-    if (!this.#trap.active) return;
+    if (!this.#active) return;
+    this.#active = false;
     this.#trap.deactivate({ restoreFocus: this.restoreValue });
     this.element.removeAttribute("data-focus-trapped");
     this.dispatch("deactivate", { detail: {} });

data/dist/controllers/form_field_controller.js

@@ -146,7 +146,7 @@ var FormFieldController = class _FormFieldController extends Controller {
   static #INVALID_ATTR = "data-stimeo--form-field-invalid";
   /** Collapses one target/morph batch into one silent ARIA reconciliation. */
   #reconcile = new MicrotaskCoalescer(() => this.#reconcileDom());
-  /** ARIA ownership is scoped to the current singular control target. */
+  /** Returns borrowed control ARIA before Turbo snapshots the page. */
   #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
   #ariaDescribedBy = new AttributeLease("aria-describedby");
   #ariaErrorMessage = new AttributeLease("aria-errormessage");

data/dist/controllers/menubar_controller.js

@@ -629,8 +629,8 @@ var MenubarController = class extends Controller {
    * being hidden itself, a menu can stay visible after its owning top was removed,
    * an open pair can appear from a morph with no layer registered for it, and the
    * Tab stop can end up on a now-inert top, on a runtime-added one, or on none at
-   * all. Nothing is remembered between calls (except which side of the Escape stack
-   * this layer is on, which the stack itself does not expose), so the outcome is the
+   * all. The only state carried between calls is the tracked focus record and which side
+   * of the Escape stack this layer is on (which the stack itself does not expose), so the outcome is the
    * same whichever mutation arrived and calling it more often than needed is free.
    */
   #reconcile() {

data/dist/controllers/multi_select_controller.js

@@ -1048,7 +1048,7 @@ var MultiSelectController = class extends Controller {
   get #values() {
     return this.#selectedOptions.map((option) => this.#optionValue(option));
   }
-  /** Normalized cardinality cap: zero is unlimited and positive fractions round down. */
+  /** Normalized cardinality cap: zero and below are unlimited; a positive value floors, never below 1. */
   get #selectionLimit() {
     if (!Number.isFinite(this.maxValue) || this.maxValue <= 0) return 0;
     return Math.max(1, Math.floor(this.maxValue));

data/dist/controllers/overflow_menu_controller.js

@@ -382,8 +382,8 @@ var OverflowMenuController = class extends Controller {
    *
    * With no known child at all (a fresh instance connecting to markup that already
    * holds banked items), a fully-banked snapshot's inert boundary preserves whether an
-   * unindexed run was prepended or appended before connect. Older or server-rendered
-   * markup has no boundary; for that compatibility path the saved index is used as the
+   * unindexed run was prepended or appended before connect. Markup that holds banked items but no boundary —
+   * server-rendered or hand-authored — uses the saved index as the
    * offset, the inverse of the move that banked it.
    */
   #merge(bar, banked, boundaryAt) {

data/dist/controllers/password_reveal_controller.js

@@ -2,6 +2,35 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/password_reveal_controller.ts
 
+// src/utils/before_cache_reset.ts
+var BeforeCacheReset = class _BeforeCacheReset {
+  /** Every subscribed instance, iterated by the one shared document listener. */
+  static #subscribers = /* @__PURE__ */ new Set();
+  /** The shared listener; installed while at least one instance is subscribed. */
+  static #onBeforeCache = () => {
+    for (const subscriber of _BeforeCacheReset.#subscribers) subscriber.#rewind();
+  };
+  #rewind;
+  /** @param rewind - the pass that returns this controller's state to its initial form. */
+  constructor(rewind) {
+    this.#rewind = rewind;
+  }
+  /** Subscribes to `turbo:before-cache`; call from `connect()`. Idempotent. */
+  activate() {
+    const first = _BeforeCacheReset.#subscribers.size === 0;
+    _BeforeCacheReset.#subscribers.add(this);
+    if (first) {
+      document.addEventListener("turbo:before-cache", _BeforeCacheReset.#onBeforeCache);
+    }
+  }
+  /** Unsubscribes; call from `disconnect()`. Safe when never subscribed. */
+  deactivate() {
+    _BeforeCacheReset.#subscribers.delete(this);
+    if (_BeforeCacheReset.#subscribers.size > 0) return;
+    document.removeEventListener("turbo:before-cache", _BeforeCacheReset.#onBeforeCache);
+  }
+};
+
 // src/utils/safe_timeout.ts
 var TimerRegistry = class {
   /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
@@ -56,6 +85,7 @@ var SafeTimeout = class extends TimerRegistry {
 };
 
 // src/controllers/password_reveal_controller.ts
+var MAX_DELAY = 2 ** 31 - 1;
 var PasswordRevealController = class extends Controller {
   static targets = ["input", "toggle"];
   static values = {
@@ -65,11 +95,54 @@ var PasswordRevealController = class extends Controller {
   static events = ["toggle"];
   /** Auto re-mask timer; torn down on disconnect. */
   #timers = new SafeTimeout();
+  /**
+   * Whether this controller is between `connect()` and `disconnect()`.
+   *
+   * Target callbacks outlive the controller: Stimulus stops the target observer
+   * after `disconnect()`, so a field leaving after teardown still reaches
+   * {@link PasswordRevealController.inputTargetDisconnected}. Arming from there
+   * would put a timer back that nothing will clear. The element staying in the
+   * document does not answer this — unloading the controller leaves it there.
+   */
+  #connected = false;
+  /** Masks the field before Turbo copies the page into its snapshot. */
+  #beforeCache = new BeforeCacheReset(() => this.#rewindToMasked());
   connect() {
-    this.#reflect(this.#isVisible);
+    this.#connected = true;
+    const visible = this.#isVisible;
+    this.#reflect(visible);
+    this.#beforeCache.activate();
+    this.#arm(visible);
   }
   disconnect() {
+    this.#connected = false;
     this.#timers.clearAll();
+    this.#beforeCache.deactivate();
+  }
+  /** Re-derives the hooks and the re-mask for a field swapped in after connect. */
+  inputTargetConnected() {
+    const visible = this.#connected && this.#isVisible;
+    this.#reflect(visible);
+    this.#arm(visible);
+  }
+  /**
+   * Re-derives from whatever field is left rather than assuming none is. A swap
+   * delivers this callback next to the arrival in either order, so a revealed
+   * replacement that answered "masked" here would be described as hidden while
+   * showing the password, and would carry no re-mask.
+   *
+   * Teardown is the one case with nothing to derive: target callbacks run after
+   * `disconnect()`, so the field is still revealed and re-arming from it would
+   * outlive the controller. A detached root is the signal to stand down.
+   */
+  inputTargetDisconnected() {
+    const visible = this.#connected && this.element.isConnected && this.#isVisible;
+    this.#reflect(visible);
+    this.#arm(visible);
+  }
+  /** Re-derives the pressed state for a button swapped in after connect. */
+  toggleTargetConnected() {
+    this.#reflect(this.#isVisible);
   }
   /** Toggles the input between masked and revealed. Bound via `data-action`. */
   toggle() {
@@ -98,11 +171,37 @@ var PasswordRevealController = class extends Controller {
     }
     this.#reflect(visible);
     this.dispatch("toggle", { detail: { visible } });
+    this.#arm(visible);
+  }
+  /** Schedules the auto re-mask for a revealed field, replacing any pending one. */
+  #arm(visible) {
     this.#timers.clearAll();
-    if (visible && this.autoHideValue > 0) {
-      this.#timers.set(() => this.#setVisible(false), this.autoHideValue);
+    const delay = this.#autoHideDelay;
+    if (visible && delay > 0) {
+      this.#timers.set(() => this.#setVisible(false), delay);
     }
   }
+  /**
+   * The auto re-mask delay, held to what `setTimeout` can carry. Past that limit
+   * a delay folds to zero, turning "keep it showing" into "hide it at once" —
+   * the opposite of what the declaration asked for. A value that is no delay at
+   * all stays out of the positive range {@link PasswordRevealController.#arm}
+   * requires, so it schedules nothing.
+   */
+  get #autoHideDelay() {
+    return Math.min(this.autoHideValue, MAX_DELAY);
+  }
+  /**
+   * Returns the field to masked before Turbo copies the page. Silent and
+   * focus-free: the page is about to be frozen, so there is no one to tell and
+   * nowhere for focus to go.
+   */
+  #rewindToMasked() {
+    this.#timers.clearAll();
+    if (!this.hasInputTarget) return;
+    this.inputTarget.type = "password";
+    this.#reflect(false);
+  }
   /** Reflects the visible state onto `aria-pressed` and `data-state`. */
   #reflect(visible) {
     if (this.hasToggleTarget) {