stimeo-ui 0.15.0 → 0.17.0

data/dist/controllers/flash_controller.js

@@ -1,8 +1,27 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/flash_controller.ts
+var FOCUS_EVENTS = /* @__PURE__ */ new Set(["blur", "focus", "focusin", "focusout"]);
+var POINTER_EVENTS = /* @__PURE__ */ new Set(["mouseenter", "mouseleave", "pointerenter", "pointerleave"]);
+function stateReasonFor(event) {
+  if (!event) return "api";
+  if (FOCUS_EVENTS.has(event.type)) return "focus";
+  if (POINTER_EVENTS.has(event.type)) return "pointer";
+  return "user";
+}
+
+function actionSource(source) {
+  if (source instanceof HTMLElement) {
+    return { event: null, host: source, origin: source, reason: "api" };
+  }
+  const event = source ?? null;
+  return {
+    event,
+    host: event?.currentTarget instanceof Element ? event.currentTarget : null,
+    origin: event?.target instanceof Element ? event.target : null,
+    reason: stateReasonFor(event)
+  };
+}
 
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -13,72 +32,34 @@ function announce(message, options = {}) {
   );
 }
 
-// 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);
-  }
-};
+function ownerIndex(candidates, node) {
+  if (!(node instanceof Node)) return -1;
+  return candidates.findIndex((candidate) => candidate.contains(node));
+}
+function ownerOf(candidates, node) {
+  return candidates[ownerIndex(candidates, node)] ?? null;
+}
+
+var MAX_TIMER_DELAY_MS = 2147483647;
 
-// src/utils/safe_timeout.ts
 var TimerRegistry = class {
-  /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
   ids = /* @__PURE__ */ new Set();
-  /**
-   * Cancels a single tracked timer.
-   *
-   * No-ops if the id is unknown (already cleared, fired, or never owned by this
-   * registry), so callers can clear defensively without guarding.
-   */
   clear(id) {
     if (this.ids.delete(id)) {
       this.cancel(id);
     }
   }
-  /**
-   * Cancels every tracked timer. Call this from a controller's `disconnect()`
-   * to guarantee no timer outlives the element.
-   */
   clearAll() {
     for (const id of this.ids) {
       this.cancel(id);
     }
     this.ids.clear();
   }
-  /** Number of timers currently tracked (pending). */
   get size() {
     return this.ids.size;
   }
 };
 var SafeTimeout = class extends TimerRegistry {
-  /**
-   * Schedules `callback` after `delay` ms and returns the timer id.
-   *
-   * The id is removed from the registry automatically when the timeout fires,
-   * so {@link TimerRegistry.size | size} reflects only still-pending timers.
-   */
   set(callback, delay) {
     const id = this.schedule(() => {
       this.ids.delete(id);
@@ -95,16 +76,9 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/utils/keyed_timers.ts
 var KeyedTimers = class {
   #timers = new SafeTimeout();
-  /** The pending timer of each key; an entry lives exactly as long as its timer. */
   #pending = /* @__PURE__ */ new Map();
-  /**
-   * Arms `callback` after `delay` ms for `key`, cancelling the timer `key` had
-   * pending. The entry is dropped before the callback runs, so the callback sees
-   * the key unarmed and may arm it again for the next round.
-   */
   set(key, callback, delay) {
     this.clear(key);
     const id = this.#timers.set(() => {
@@ -113,104 +87,193 @@ var KeyedTimers = class {
     }, delay);
     this.#pending.set(key, id);
   }
-  /**
-   * Cancels `key`'s pending timer, if it has one.
-   *
-   * A timer id is a positive integer, so `-1` stands for "nothing pending" and
-   * the registry ignores an id it does not own — the unarmed case needs no
-   * branch of its own, and no other key's timer can be reached from here.
-   */
   clear(key) {
     this.#timers.clear(this.#pending.get(key) ?? -1);
     this.#pending.delete(key);
   }
-  /**
-   * Cancels every pending timer and forgets every key. Call this from a
-   * controller's `disconnect()` so no timer, and no entry, outlives the element.
-   */
   clearAll() {
     this.#timers.clearAll();
     this.#pending.clear();
   }
-  /** Whether `key` has a timer pending. */
   has(key) {
     return this.#pending.has(key);
   }
 };
 
-// src/utils/pausable_timers.ts
+var ListenerSet = class {
+  #abort = new AbortController();
+  add(target, type, handler, options) {
+    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
+  }
+  dispose() {
+    this.#abort.abort();
+    this.#abort = new AbortController();
+  }
+};
+
+var MicrotaskCoalescer = class {
+  #run;
+  #queued = false;
+  #active = false;
+  #generation = 0;
+  constructor(run) {
+    this.#run = run;
+  }
+  activate() {
+    this.#active = true;
+  }
+  cancel() {
+    this.#active = false;
+    this.#queued = false;
+    this.#generation += 1;
+  }
+  schedule() {
+    if (!this.#active || this.#queued) return;
+    this.#queued = true;
+    const generation = this.#generation;
+    queueMicrotask(() => {
+      if (generation !== this.#generation || !this.#queued || !this.#active) return;
+      this.#queued = false;
+      this.#run();
+    });
+  }
+};
+
+var MorphRenderWatcher = class {
+  #listeners = new ListenerSet();
+  #pass;
+  #element = null;
+  #onMorph = () => this.#pass.schedule();
+  constructor(run) {
+    this.#pass = new MicrotaskCoalescer(run);
+  }
+  observe(element) {
+    if (this.#element === element) return;
+    this.disconnect();
+    this.#element = element;
+    this.#pass.activate();
+    this.#listeners.add(element, "turbo:morph-element", this.#onMorph);
+  }
+  schedule() {
+    this.#pass.schedule();
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
+var NUMBER_BOUNDS = {
+  finite: { finite: true },
+  timer: { finite: true, min: 0, max: MAX_TIMER_DELAY_MS }};
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
+
+function readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+var NumberValueReader = class {
+  #lastRejected = /* @__PURE__ */ new Map();
+  read(owner, name, raw, fallback, bounds) {
+    const resolved = readNumber(raw, fallback, bounds);
+    if (matchesNumberBounds(raw, bounds)) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;
+    const literal = owner.element.getAttribute(attribute);
+    if (literal === null) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    if (this.#lastRejected.get(name) !== literal) {
+      this.#lastRejected.set(name, literal);
+      console.warn(
+        `Stimeo UI: "${owner.identifier}" has an invalid number Value "${name}" declaration ${JSON.stringify(literal)}; using ${fallback}.`
+      );
+    }
+    return resolved;
+  }
+};
+
 var PausableTimers = class {
   #timers = new KeyedTimers();
-  /** Every key armed or held; an entry goes as its timer fires, or with the key. */
   #entries = /* @__PURE__ */ new Map();
-  /**
-   * Arms `callback` after `delay` ms for `key`, replacing whatever `key` had.
-   * A held key stays held and banks `delay` for its resume.
-   */
   set(key, callback, delay) {
     const reasons = this.#entries.get(key)?.reasons ?? /* @__PURE__ */ new Set();
     const entry = { callback, startedAt: 0, remaining: delay, reasons };
     this.#entries.set(key, entry);
-    if (reasons.size === 0) this.#arm(key, entry);
+    if (reasons.size === 0) this.#arm(key, entry, callback);
   }
-  /**
-   * Holds `key` for `reason` and banks the time left, with a floor of one
-   * millisecond. Reports whether this call is the one that stopped a running
-   * timer, so the caller can write its held-state hook exactly once.
-   */
   pause(key, reason) {
-    const entry = this.#entries.get(key);
-    if (entry === void 0) return false;
+    let entry = this.#entries.get(key);
+    if (entry === void 0) {
+      entry = { callback: null, startedAt: 0, remaining: 0, reasons: /* @__PURE__ */ new Set() };
+      this.#entries.set(key, entry);
+    }
     entry.reasons.add(reason);
     if (!this.#timers.has(key)) return false;
     this.#timers.clear(key);
     entry.remaining = Math.max(1, entry.remaining - (Date.now() - entry.startedAt));
     return true;
   }
-  /**
-   * Releases `reason` on `key`, arming the banked time again once no reason is
-   * left. Reports whether this call is the one that started the timer again.
-   */
   resume(key, reason) {
     const entry = this.#entries.get(key);
     if (entry === void 0) return false;
     entry.reasons.delete(reason);
     if (entry.reasons.size > 0 || this.#timers.has(key)) return false;
-    this.#arm(key, entry);
+    const { callback } = entry;
+    if (callback === null) {
+      this.#entries.delete(key);
+      return false;
+    }
+    this.#arm(key, entry, callback);
     return true;
   }
-  /** Whether `key` is armed or held — that is, whether this registry drives it at all. */
+  isHeld(key) {
+    return (this.#entries.get(key)?.reasons.size ?? 0) > 0;
+  }
   tracks(key) {
     return this.#entries.has(key);
   }
-  /** Cancels `key`'s timer and drops its hold. */
   clear(key) {
     this.#timers.clear(key);
     this.#entries.delete(key);
   }
-  /**
-   * Cancels every timer and forgets every key. Call this from a controller's
-   * `disconnect()` so neither a timer nor a hold outlives the element.
-   */
   clearAll() {
     this.#timers.clearAll();
     this.#entries.clear();
   }
-  /** Starts `entry`'s banked time running for `key`, and drops it as it fires. */
-  #arm(key, entry) {
+  #arm(key, entry, callback) {
     entry.startedAt = Date.now();
     this.#timers.set(
       key,
       () => {
         this.#entries.delete(key);
-        entry.callback();
+        callback();
       },
       entry.remaining
     );
   }
 };
 
-// src/utils/transition_completion.ts
+function targetSelector(identifier, name) {
+  return `[data-${identifier}-target~="${name}"]`;
+}
+
 function timeMs(value) {
   const trimmed = value.trim();
   const amount = Number.parseFloat(trimmed);
@@ -244,115 +307,115 @@ function maxTransitionTotalMs(style) {
   return maxTotalMs(transitionTimings(style));
 }
 
-// src/controllers/flash_controller.ts
 var ASSERTIVE_TYPES = /* @__PURE__ */ new Set(["alert", "error"]);
-var MESSAGE_SELECTOR = '[data-stimeo--flash-target="message"]';
-var FlashController = class extends Controller {
+var MESSAGE_PART = "message";
+var SHOWN_ATTRIBUTE = "shown";
+var FlashController = class _FlashController extends Controller {
+  #numbers = new NumberValueReader();
+  get #messageSelector() {
+    return targetSelector(this.identifier, MESSAGE_PART);
+  }
   static targets = ["region", "message"];
   static values = {
     duration: { type: Number, default: 5e3 },
     pauseOnHover: { type: Boolean, default: true },
     max: { type: Number, default: 0 }
   };
+  static valueConstraints = {
+    duration: NUMBER_BOUNDS.timer,
+    max: NUMBER_BOUNDS.finite
+  };
   static actions = ["dismiss"];
   static events = ["show", "dismiss", "reconcile"];
-  /** Removal timers for the leaving transition; the auto-dismiss ones live below. */
   #timers = new SafeTimeout();
-  /** Per-message auto-dismiss, held open while the message is hovered or focused. */
   #dismiss = new PausableTimers();
+  #fixedDismiss = new KeyedTimers();
+  #reapply = new MorphRenderWatcher(() => this.#reapplyCap());
+  #spared = [];
+  #pointer = new ListenerSet();
+  #awaitingPointer = /* @__PURE__ */ new Set();
   #observer = null;
-  /** Whether the controller is between `connect()` and `disconnect()`. */
   #connected = false;
-  /** Messages already processed, in insertion order, to enforce `max` and avoid double work. */
+  #arrivals = /* @__PURE__ */ new Set();
+  #appliedMax = null;
   #order = [];
-  /**
-   * Messages between `leaving` and their removal. {@link FlashController.#beginDismiss}
-   * releases the bookkeeping above *before* the transition wait, so for that window the
-   * element is in the DOM but in neither collection — without this set a re-scan would
-   * read it as a brand-new flash and show it a second time.
-   */
   #leaving = /* @__PURE__ */ new Set();
-  #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
+  get #shownAttribute() {
+    return `data-${this.identifier}-${SHOWN_ATTRIBUTE}`;
+  }
   #onEnter = (event) => this.#pause(event.currentTarget, event.type === "focusin" ? "focus" : "hover");
-  #onLeave = (event) => this.#resume(event.currentTarget, event.type === "focusout" ? "focus" : "hover");
+  #onLeave = (event) => {
+    const message = event.currentTarget;
+    const next = ownerOf(this.#order, event.relatedTarget);
+    if (next === message) return;
+    this.#resume(message, event.type === "focusout" ? "focus" : "hover", next);
+  };
   connect() {
     this.#connected = true;
+    const current = this.messageTargets;
+    for (const item of this.#arrivals) {
+      if (!current.includes(item)) this.#arrivals.delete(item);
+    }
+    this.#discardInherited();
+    this.#reapply.observe(this.element);
     for (const message of this.messageTargets) {
       if (this.#owns(message)) this.#process(message, true);
     }
+    if (!Object.is(this.#appliedMax, this.#safeMax)) {
+      this.#appliedMax = this.#safeMax;
+      this.#enforceMax();
+    }
     this.#syncObservation();
-    this.#beforeCache.activate();
   }
   disconnect() {
     this.#connected = false;
-    this.#beforeCache.deactivate();
     this.#stopObserving();
     this.#timers.clearAll();
     this.#dismiss.clearAll();
+    this.#fixedDismiss.clearAll();
+    this.#reapply.disconnect();
+    this.#spared = [];
+    this.#pointer.dispose();
+    this.#awaitingPointer.clear();
     for (const message of this.#order) this.#unbindPause(message);
     this.#order.length = 0;
     this.#leaving.clear();
   }
-  /**
-   * Takes the managed flashes out of the page just before Turbo freezes it, so a
-   * restored snapshot carries no notification the visitor has already received: the
-   * fresh `connect()` there reads a leftover flash as a brand-new one and announces it
-   * a second time. A message that never auto-dismisses (`duration: 0`) is one of these
-   * too — that value governs the timer, not what belongs in a cached page. Removal
-   * only: `dismiss` reports a dismissal, and freezing the page is not one.
-   */
-  #rewindForCache() {
-    const removed = this.#order.length;
-    for (const message of [...this.#order]) {
+  #discardInherited() {
+    let removed = 0;
+    for (const message of this.messageTargets) {
+      if (!message.hasAttribute(this.#shownAttribute) || this.#arrivals.has(message)) continue;
+      if (!this.#owns(message)) continue;
       message.remove();
-      this.#forget(message);
+      removed += 1;
     }
-    for (const message of this.#leaving) message.remove();
-    this.#leaving.clear();
     if (removed > 0) this.dispatch("reconcile", { detail: { removed } });
   }
-  /** Follows a `region` element swapped in — or arriving — at runtime (Turbo Stream). */
   regionTargetConnected() {
     this.#resync();
   }
-  /** Releases the observation when the `region` element leaves the target set. */
   regionTargetDisconnected() {
     this.#resync();
   }
-  /**
-   * Whether this controller owns `message`. Ownership is the current `region`'s
-   * subtree: a message target anywhere else in the controller's scope is the
-   * consumer's, and so is one in a region that has gone away. The initial scan, a
-   * re-scan after a `region` swap, and a departure from the target set all resolve
-   * ownership through this one test; the observation gets it structurally, by watching
-   * that subtree and nothing else.
-   */
+  maxValueChanged() {
+    if (!this.#connected) return;
+    this.#appliedMax = this.#safeMax;
+    this.#enforceMax();
+  }
   #owns(message) {
     return this.hasRegionTarget && this.regionTarget.contains(message);
   }
-  /**
-   * Releases a message that left the target set (a Turbo Stream `remove`, the consumer
-   * detaching the node, or a morph that rewrote the target attribute in place): it
-   * stops occupying a `max` slot, and both its pending auto-dismiss and an already
-   * scheduled removal are cancelled. A move *within* the region keeps all of them —
-   * which is why the element must still be a message to be treated as one: ownership
-   * alone reads an in-place attribute rewrite as a move, and a node outside the target
-   * set belongs to the consumer, so nothing here may dismiss it.
-   */
   messageTargetDisconnected(message) {
     if (!this.#connected) return;
-    const moved = this.#owns(message) && message.matches(MESSAGE_SELECTOR);
-    if (moved) return;
+    const moved = this.#owns(message) && message.matches(this.#messageSelector);
+    if (moved) {
+      this.#afterMove(message);
+      return;
+    }
     this.#forget(message);
+    this.#arrivals.delete(message);
     this.#leaving.delete(message);
   }
-  /**
-   * Re-points the observation after a `region` swap and picks up the messages the
-   * new element brought with it (dynamic inserts, so their own `role` announces
-   * them). The `#connected` guard is load-bearing: Stimulus runs target callbacks
-   * for the initial markup *before* `connect()` and again during teardown *after*
-   * `disconnect()`, and re-observing there would outlive the controller.
-   */
   #resync() {
     if (!this.#connected) return;
     this.#syncObservation();
@@ -360,11 +423,6 @@ var FlashController = class extends Controller {
       if (this.#owns(message)) this.#process(message, false);
     }
   }
-  /**
-   * Points the mutation observation at the current `region` target, re-resolved on
-   * every sync rather than captured at connect, so an element swapped in at runtime
-   * is observed instead of the detached original.
-   */
   #syncObservation() {
     this.#stopObserving();
     if (!this.hasRegionTarget || typeof MutationObserver === "undefined") return;
@@ -375,14 +433,7 @@ var FlashController = class extends Controller {
     this.#observer?.disconnect();
     this.#observer = null;
   }
-  /**
-   * Pause-on-hover/focus listeners, bound and unbound as a pair so the two sides
-   * stay in sync. Binding is gated by `pauseOnHover`; unbinding is unconditional
-   * and idempotent (a no-op when nothing was bound), which keeps teardown correct
-   * even if `pauseOnHover` were ever toggled during a message's life.
-   */
   #bindPause(message) {
-    if (!this.pauseOnHoverValue) return;
     message.addEventListener("mouseenter", this.#onEnter);
     message.addEventListener("mouseleave", this.#onLeave);
     message.addEventListener("focusin", this.#onEnter);
@@ -394,79 +445,128 @@ var FlashController = class extends Controller {
     message.removeEventListener("focusin", this.#onEnter);
     message.removeEventListener("focusout", this.#onLeave);
   }
-  /** Dismisses the flash whose close control fired the event. */
-  dismiss(event) {
-    const target = event.currentTarget || event.target;
-    const message = target?.closest(MESSAGE_SELECTOR);
-    if (message) this.#beginDismiss(message, "user");
+  dismiss(input) {
+    const source = actionSource(input);
+    if (source.origin && source.origin.closest(`[data-controller~="${this.identifier}"]`) !== this.element)
+      return;
+    const message = (source.origin ?? source.host)?.closest(this.#messageSelector);
+    if (message && this.messageTargets.includes(message))
+      this.#beginDismiss(message, source.reason);
   }
-  /** Processes messages added after connect (Turbo Stream); their own role announces them. */
   #onMutations(mutations) {
     for (const mutation of mutations) {
       for (const node of mutation.addedNodes) {
         if (!(node instanceof HTMLElement)) continue;
-        if (node.matches(MESSAGE_SELECTOR)) this.#process(node, false);
-        for (const message of node.querySelectorAll(MESSAGE_SELECTOR)) {
+        if (node.matches(this.#messageSelector)) this.#process(node, false);
+        for (const message of node.querySelectorAll(this.#messageSelector)) {
           this.#process(message, false);
         }
       }
     }
   }
-  /**
-   * Applies role/state, wires pause listeners, schedules auto-dismiss, and either
-   * bridges to the Announcer (`bridge`, for initial flashes) or leaves the message's
-   * own role to do the announcing (dynamic inserts). Idempotent per message.
-   */
-  #process(message, bridge) {
-    if (this.#order.includes(message) || this.#leaving.has(message)) return;
+  #process(message, atConnect) {
+    if (this.#order.includes(message) || this.#leaving.has(message) || !this.#owns(message)) {
+      return;
+    }
     const type = message.getAttribute("data-flash-type") ?? "";
     const assertive = ASSERTIVE_TYPES.has(type);
     if (!message.hasAttribute("role")) {
       message.setAttribute("role", assertive ? "alert" : "status");
     }
     message.setAttribute("data-flash-state", "visible");
+    message.setAttribute(this.#shownAttribute, "");
+    const known = this.#arrivals.has(message);
     this.#order.push(message);
+    this.#arrivals.add(message);
     this.#bindPause(message);
-    const text = message.textContent?.trim() ?? "";
-    this.dispatch("show", { target: message, detail: { type, message: text } });
-    if (bridge) announce(text, { assertive });
+    this.#readHolds(message);
+    if (!known) {
+      const text = message.textContent?.trim() ?? "";
+      this.dispatch("show", { target: message, detail: { type, message: text } });
+      if (atConnect) announce(text, { assertive });
+    }
     this.#startTimer(message);
-    this.#enforceMax();
-  }
-  /** Removes the oldest visible flashes once the count exceeds `max` (0 = unlimited). */
-  #enforceMax() {
-    if (this.maxValue <= 0) return;
-    while (this.#order.length > this.maxValue) {
-      const oldest = this.#order[0];
-      if (!oldest) break;
-      this.#beginDismiss(oldest, "limit");
+    if (!atConnect) this.#enforceMax([message]);
+  }
+  #enforceMax(spared = []) {
+    if (this.#safeMax <= 0) return;
+    for (const message of [...this.#arrivals]) {
+      if (this.#shownCount() <= this.#safeMax) return;
+      if (this.#owns(message) && !spared.includes(message) && !this.#dismiss.isHeld(message)) {
+        this.#beginDismiss(message, "limit");
+      }
     }
   }
-  /** Arms a message's auto-dismiss; a non-positive `duration` means it never expires. */
+  #shownCount() {
+    return this.#order.filter((message) => this.#owns(message)).length;
+  }
   #startTimer(message) {
-    if (this.durationValue <= 0) return;
-    this.#dismiss.set(message, () => this.#beginDismiss(message, "timeout"), this.durationValue);
-  }
-  /**
-   * Holds a message's auto-dismiss open while it is hovered or focused
-   * (WCAG 2.2 2.2.1). Hover and focus are independent reasons, and the registry
-   * banks the time left on the first of them and waits for the last.
-   */
+    if (this.#safeDuration <= 0) return;
+    const dismiss = () => this.#beginDismiss(message, "timeout");
+    if (this.pauseOnHoverValue) this.#dismiss.set(message, dismiss, this.#safeDuration);
+    else this.#fixedDismiss.set(message, dismiss, this.#safeDuration);
+  }
   #pause(message, reason) {
     this.#dismiss.pause(message, reason);
   }
-  /** Releases one reason, resuming the banked time once no reason is left. */
-  #resume(message, reason) {
+  #resume(message, reason, spare) {
+    const held = this.#dismiss.isHeld(message);
     this.#dismiss.resume(message, reason);
-  }
-  /** Releases every per-message resource: timer, stacking slot, pause listeners. */
+    if (held && !this.#dismiss.isHeld(message)) this.#capLater(spare);
+  }
+  #capLater(spare) {
+    if (spare) this.#spared.push(spare);
+    this.#reapply.schedule();
+  }
+  #reapplyCap() {
+    for (const message of [...this.#order, ...this.#leaving]) {
+      if (!this.#owns(message)) continue;
+      message.setAttribute("data-flash-state", this.#leaving.has(message) ? "leaving" : "visible");
+      message.setAttribute(this.#shownAttribute, "");
+      if (!message.hasAttribute("role")) {
+        const assertive = ASSERTIVE_TYPES.has(message.getAttribute("data-flash-type") ?? "");
+        message.setAttribute("role", assertive ? "alert" : "status");
+      }
+    }
+    const spared = this.#spared;
+    this.#spared = [];
+    this.#enforceMax(spared);
+  }
+  #afterMove(message) {
+    if (!message.contains(document.activeElement)) this.#resume(message, "focus", null);
+    if (this.#dismiss.isHeld(message)) this.#awaitPointer(message);
+  }
+  #readHolds(message) {
+    if (message.contains(document.activeElement)) this.#pause(message, "focus");
+    if (!message.matches(":hover")) return;
+    this.#pause(message, "hover");
+    this.#awaitPointer(message);
+  }
+  #awaitPointer(message) {
+    this.#awaitingPointer.add(message);
+    this.#pointer.add(document, "pointermove", this.#onPointerMove, {
+      capture: true,
+      passive: true
+    });
+  }
+  #onPointerMove = () => {
+    this.#pointer.dispose();
+    const waiting = [...this.#awaitingPointer];
+    this.#awaitingPointer.clear();
+    for (const message of waiting) {
+      if (!message.matches(":hover")) this.#resume(message, "hover", null);
+    }
+  };
   #forget(message) {
+    if (this.#dismiss.isHeld(message)) this.#capLater(null);
     this.#dismiss.clear(message);
+    this.#fixedDismiss.clear(message);
     const index = this.#order.indexOf(message);
     if (index !== -1) this.#order.splice(index, 1);
     this.#unbindPause(message);
+    this.#awaitingPointer.delete(message);
+    if (this.#awaitingPointer.size === 0) this.#pointer.dispose();
   }
-  /** Marks a message leaving, then removes it after its CSS transition and emits dismiss. */
   #beginDismiss(message, reason) {
     if (!this.#order.includes(message)) return;
     this.#forget(message);
@@ -475,6 +575,7 @@ var FlashController = class extends Controller {
     const finalize = () => {
       if (!this.#leaving.delete(message)) return;
       message.remove();
+      this.#arrivals.delete(message);
       this.dispatch("dismiss", { detail: { element: message, reason } });
     };
     const transition = this.#transitionMs(message);
@@ -484,13 +585,29 @@ var FlashController = class extends Controller {
       finalize();
     }
   }
-  /** Maximum transition total (duration + delay) of `el` in ms (0 when none / unsupported). */
   #transitionMs(el) {
     if (typeof window.getComputedStyle !== "function") return 0;
     return maxTransitionTotalMs(window.getComputedStyle(el));
   }
+  get #safeDuration() {
+    return this.#numbers.read(
+      this,
+      "duration",
+      this.durationValue,
+      _FlashController.values.duration.default,
+      _FlashController.valueConstraints.duration
+    );
+  }
+  get #safeMax() {
+    return this.#numbers.read(
+      this,
+      "max",
+      this.maxValue,
+      _FlashController.values.max.default,
+      _FlashController.valueConstraints.max
+    );
+  }
 };
 
 export { FlashController };
-//# sourceMappingURL=flash_controller.js.map
 //# sourceMappingURL=flash_controller.js.map