stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/toast_controller.js

@@ -1,8 +1,27 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/toast_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/event_owner.ts
 function ownerIndex(candidates, node) {
   if (!(node instanceof Node)) return -1;
   return candidates.findIndex((candidate) => candidate.contains(node));
@@ -11,51 +30,78 @@ function ownerOf(candidates, node) {
   return candidates[ownerIndex(candidates, node)] ?? null;
 }
 
-// src/utils/listener_set.ts
 var ListenerSet = class {
-  /** The generation every `add` joins until the next `dispose()`. */
   #abort = new AbortController();
-  /**
-   * Attaches `handler` to the open generation, exactly as the caller spelled it.
-   *
-   * The set supplies the signal, so `options` carries everything else the DOM
-   * accepts — `capture` included, which has to match at release time and no
-   * longer has a second place to drift from.
-   */
   add(target, type, handler, options) {
     target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
   }
-  /**
-   * Releases every listener of the open generation, synchronously, and opens the
-   * next one. Idempotent, and safe before anything has been added.
-   */
   dispose() {
     this.#abort.abort();
     this.#abort = new AbortController();
   }
 };
 
-// src/utils/microtask_coalescer.ts
+var HoverRecheck = class {
+  #document;
+  #release;
+  #listeners = new ListenerSet();
+  #pending = /* @__PURE__ */ new Set();
+  #tickets = /* @__PURE__ */ new WeakMap();
+  constructor(document2, release) {
+    this.#document = document2;
+    this.#release = release;
+  }
+  wait(element) {
+    this.#pending.add(element);
+    this.#tickets.set(element, /* @__PURE__ */ Symbol());
+    this.#listeners.add(this.#document, "pointermove", this.#onPointerMove, {
+      capture: true,
+      passive: true
+    });
+  }
+  cancel(element) {
+    this.#tickets.delete(element);
+    this.#pending.delete(element);
+    if (this.#pending.size === 0) this.#listeners.dispose();
+  }
+  dispose() {
+    this.#listeners.dispose();
+    this.#pending.clear();
+    this.#tickets = /* @__PURE__ */ new WeakMap();
+  }
+  #onPointerMove = () => {
+    this.#listeners.dispose();
+    const waiting = [...this.#pending].map(
+      (element) => [element, this.#tickets.get(element)]
+    );
+    this.#pending.clear();
+    for (const [element, ticket] of waiting) {
+      if (this.#tickets.get(element) !== ticket) continue;
+      if (element.matches(":hover")) continue;
+      this.#release(element);
+    }
+  };
+};
+
 var MicrotaskCoalescer = class {
   #run;
   #queued = false;
   #active = false;
   #generation = 0;
-  /** @param run - the single reconciliation pass, invoked at most once per batch. */
   constructor(run) {
     this.#run = run;
   }
-  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */
   activate() {
     this.#active = true;
   }
-  /** Closes the window and drops any pending pass; call from `disconnect()`. */
   cancel() {
     this.#active = false;
     this.#queued = false;
     this.#generation += 1;
   }
-  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -68,43 +114,99 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/safe_timeout.ts
+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();
+  }
+  get pending() {
+    return this.#pass.pending;
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
+var MAX_TIMER_DELAY_MS = 2147483647;
+
+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 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);
@@ -121,16 +223,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(() => {
@@ -139,52 +234,28 @@ 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 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, callback);
   }
-  /**
-   * Holds `key` for `reason` and banks the time left, with a floor of one
-   * millisecond. A key with no timer is held all the same. 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) {
     let entry = this.#entries.get(key);
     if (entry === void 0) {
@@ -197,11 +268,6 @@ var PausableTimers = class {
     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; a key released with no timer is forgotten. 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;
@@ -215,38 +281,20 @@ var PausableTimers = class {
     this.#arm(key, entry, callback);
     return true;
   }
-  /** Whether any reason holds `key`, with or without a timer. */
   isHeld(key) {
     return (this.#entries.get(key)?.reasons.size ?? 0) > 0;
   }
-  /** Whether `key` is armed or held — that is, whether this registry drives it at all. */
   tracks(key) {
     return this.#entries.has(key);
   }
-  /**
-   * Cancels `key`'s timer and keeps its hold, so a release arms nothing; a key
-   * nothing holds is forgotten.
-   */
-  disarm(key) {
-    this.#timers.clear(key);
-    const entry = this.#entries.get(key);
-    if (entry?.reasons.size) entry.callback = null;
-    else this.#entries.delete(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 `callback` fires. */
   #arm(key, entry, callback) {
     entry.startedAt = Date.now();
     this.#timers.set(
@@ -260,18 +308,15 @@ var PausableTimers = class {
   }
 };
 
-// src/utils/target_selector.ts
 function targetSelector(identifier, name) {
   return `[data-${identifier}-target~="${name}"]`;
 }
 
-// src/utils/template_row.ts
 function cloneTemplateRoot(template) {
   const root = template.content.firstElementChild;
   return root instanceof HTMLElement ? root.cloneNode(true) : null;
 }
 
-// src/utils/transition_completion.ts
 function timeMs(value) {
   const trimmed = value.trim();
   const amount = Number.parseFloat(trimmed);
@@ -305,62 +350,52 @@ function maxTransitionTotalMs(style) {
   return maxTotalMs(transitionTimings(style));
 }
 
-// src/controllers/toast_controller.ts
 var DELEGATED_EVENTS = ["click", "focusin", "focusout", "keydown", "mouseover", "mouseout"];
-var ToastController = class extends Controller {
+var ToastController = class _ToastController extends Controller {
+  #numbers = new NumberValueReader();
   static targets = ["list", "template", "item"];
   static values = {
     duration: { type: Number, default: 0 },
     max: { type: Number, default: 3 }
   };
+  static valueConstraints = {
+    duration: NUMBER_BOUNDS.timer,
+    max: NUMBER_BOUNDS.finite
+  };
   static actions = ["dismiss", "onKeydown", "pause", "resume", "show"];
   static events = ["dismiss", "show"];
-  /** Removal timers for the leaving transition; the auto-dismiss ones live below. */
   #timers = new SafeTimeout();
-  /** Per-toast auto-dismiss, held open while the toast is hovered or focused. */
   #dismiss = new PausableTimers();
-  /** Toasts taken on and not let go; a move within the list keeps a toast here. */
   #taken = /* @__PURE__ */ new Set();
-  /** Applies the `max` limit again once the event that released a hold has run its course. */
-  #reapply = new MicrotaskCoalescer(() => this.#reapplyLimit());
-  /** Toasts the pointer or focus moved into since the limit was last applied again. */
+  #outside = /* @__PURE__ */ new WeakSet();
+  #phases = /* @__PURE__ */ new WeakMap();
+  #reapply = new MorphRenderWatcher(() => this.#reapplyLimit());
   #spared = [];
-  /** The next pointer movement, listened for while a hover hold waits on it. */
-  #pointer = new ListenerSet();
-  /** Toasts whose hover hold waits for the next pointer movement to be confirmed. */
-  #awaitingPointer = /* @__PURE__ */ new Set();
-  /**
-   * Pending one-shot `requestAnimationFrame` handles (the entering→visible flip).
-   * Tracked so {@link disconnect} can cancel any that have not fired, preventing a
-   * detached element from being mutated after it leaves the DOM (Turbo).
-   */
+  #pointer = new HoverRecheck(
+    this.element.ownerDocument,
+    (item) => this.#release(item, "hover", null)
+  );
   #rafHandles = /* @__PURE__ */ new Map();
-  /** The stable list that owns delegated listeners for dynamically added items. */
   #delegatedList = null;
-  /** Whether the controller is between `connect()` and `disconnect()`. */
+  #listListeners = new ListenerSet();
   #connected = false;
-  /**
-   * The `max` the list was last held to, or `null` before the first time. `connect()`
-   * applies the limit only when `max` is not that one, so a reconnect of the same instance
-   * leaves the list as it was unless `max` changed while it was away.
-   */
+  #arrivals = /* @__PURE__ */ new Set();
   #appliedMax = null;
-  /**
-   * Stimulus reports every toast the list already holds before this runs, and each is
-   * taken on then with its holds, meeting no limit. The limit is applied here once, over
-   * all of them, unless the list was already held to the current `max`.
-   */
   connect() {
     this.#connected = true;
-    this.#reapply.activate();
+    const current = this.itemTargets;
+    for (const item of this.#arrivals) {
+      if (!current.includes(item)) this.#arrivals.delete(item);
+    }
+    this.#reapply.observe(this.element);
     this.#connectDelegatedEvents();
     for (const item of this.itemTargets) {
       if (!this.#dismiss.tracks(item) && item.dataset.state !== "leaving") {
         this.#startTimer(item);
       }
     }
-    if (!Object.is(this.#appliedMax, this.maxValue)) {
-      this.#appliedMax = this.maxValue;
+    if (!Object.is(this.#appliedMax, this.#safeMax)) {
+      this.#appliedMax = this.#safeMax;
       this.#enforceMax();
     }
   }
@@ -370,75 +405,52 @@ var ToastController = class extends Controller {
     this.#timers.clearAll();
     this.#dismiss.clearAll();
     this.#taken.clear();
-    this.#reapply.cancel();
+    this.#reapply.disconnect();
     this.#spared = [];
     this.#pointer.dispose();
-    this.#awaitingPointer.clear();
     for (const handle of this.#rafHandles.values()) {
       window.cancelAnimationFrame(handle);
     }
     this.#rafHandles.clear();
   }
-  /** Rebinds delegated interaction when Turbo replaces the list target in place. */
-  listTargetConnected(element) {
-    if (this.#delegatedList !== element) this.#connectDelegatedEvents(element);
+  listTargetConnected() {
+    if (this.#delegatedList !== this.listTarget) this.#connectDelegatedEvents();
   }
-  /** Releases delegation only when the removed target is its current owner. */
   listTargetDisconnected(element) {
     if (this.#delegatedList === element) this.#disconnectDelegatedEvents();
-  }
-  durationValueChanged() {
+    if (!this.#connected || !this.hasListTarget || this.listTarget === element) return;
+    if (this.#delegatedList !== this.listTarget) this.#connectDelegatedEvents();
     for (const item of this.itemTargets) {
-      if (item.dataset.state === "leaving") continue;
-      if (this.durationValue <= 0) {
-        this.#dismiss.disarm(item);
-        item.removeAttribute("data-paused");
-      } else {
-        this.#startTimer(item);
-      }
+      if (this.#outside.has(item)) this.#takeIn(item);
     }
   }
-  /**
-   * Holds the list to a changed `max`. Stimulus can also call this ahead of `connect()` —
-   * for an attribute that changed while the controller was away, and on every connect
-   * for an undeclared `max`, with its default; `connect()` decides then.
-   */
   maxValueChanged() {
     if (!this.#connected) return;
-    this.#appliedMax = this.maxValue;
+    this.#appliedMax = this.#safeMax;
     this.enforceMaxLimit();
   }
-  /**
-   * Stimulus lifecycle callback triggered automatically when a new item target
-   * enters the DOM, from a client-side injection or a Turbo Stream append alike, and for
-   * every toast the list already holds ahead of `connect()`. An item already leaving,
-   * parented outside `list`, or already taken on (a move within the list) is skipped; any
-   * other is taken on with the holds it already has. On a connected controller the `max`
-   * limit is then applied, never to the arrival itself; the toasts reported ahead of
-   * `connect()` are left to it.
-   */
   itemTargetConnected(element) {
-    if (this.#taken.has(element)) return;
-    if (element.dataset.state === "leaving" || element.parentNode !== this.listTarget) return;
+    if (this.#takeIn(element) && this.#connected) this.#enforceMax([element]);
+  }
+  #takeIn(element) {
+    if (this.#taken.has(element) || element.dataset.state === "leaving") return false;
+    if (element.parentNode !== this.listTarget) {
+      this.#outside.add(element);
+      return false;
+    }
     this.#taken.add(element);
+    this.#arrivals.add(element);
     this.#readHolds(element);
     this.#startTimer(element);
-    element.setAttribute("data-state", "entering");
-    this.#cancelAnimation(element);
+    this.#setPhase(element, "entering");
     const handle = window.requestAnimationFrame(() => {
       this.#rafHandles.delete(element);
       if (element.parentNode !== this.listTarget || element.dataset.state === "leaving") return;
-      element.setAttribute("data-state", "visible");
+      this.#setPhase(element, "visible");
     });
     this.#rafHandles.set(element, handle);
-    if (this.#connected) this.#enforceMax([element]);
-  }
-  /**
-   * Lets go of a toast that left the list or stopped being an item: its timer, holds,
-   * `data-paused` and pending frame. After a move within the list the node is already
-   * back, still an item, when Stimulus reports it, so it keeps all of those, and only the
-   * holds the move may have ended are read again.
-   */
+    return true;
+  }
   itemTargetDisconnected(element) {
     const moved = this.#isShown(element) && element.matches(targetSelector(this.identifier, "item"));
     if (moved) {
@@ -446,26 +458,12 @@ var ToastController = class extends Controller {
       return;
     }
     this.#taken.delete(element);
+    this.#phases.delete(element);
+    if (this.#connected) this.#arrivals.delete(element);
     element.removeAttribute("data-paused");
     this.#letGo(element);
     this.#cancelAnimation(element);
   }
-  /**
-   * Shows a new toast. Accepts its content from either a Stimulus action param
-   * (attribute-only trigger) or a programmatic `show` CustomEvent `detail`
-   * (remote / Turbo trigger); the action param wins when both are present.
-   *
-   *   <button data-action="click->stimeo--toast#show"
-   *           data-stimeo--toast-message-param="Saved"
-   *           data-stimeo--toast-type-param="status">Show</button>
-   *
-   *   element.dispatchEvent(new CustomEvent("show", { detail: { message, type } }))
-   *
-   * Clones the template slot, interpolates the message, and appends to the list.
-   * `message` is the wording key the rest of the library dispatches under, so a
-   * part that already carries its own wording — `stimeo--clipboard:copy`,
-   * `stimeo--auto-submit:done` — wires straight into this action.
-   */
   show(event) {
     if (!this.hasTemplateTarget || !this.hasListTarget) return;
     const message = this.#readField(event, "message");
@@ -484,11 +482,6 @@ var ToastController = class extends Controller {
     this.listTarget.appendChild(item);
     this.dispatch("show", { detail: { item } });
   }
-  /**
-   * Reads a string field from a Stimulus action param or a CustomEvent `detail`,
-   * preferring the action param. Returns null unless a non-empty string is found,
-   * so untrusted runtime payloads cannot inject non-string values.
-   */
   #readField(event, key) {
     const params = event.params;
     const fromParams = params?.[key];
@@ -500,153 +493,100 @@ var ToastController = class extends Controller {
     }
     return null;
   }
-  /** Dismisses the toast that contained the trigger. */
-  dismiss(event) {
-    const item = this.#itemFromEvent(event);
+  dismiss(input) {
+    const source = actionSource(input);
+    const item = this.#itemFromSource(source);
     if (!item) return;
-    this.#removeWithTransition(item, "user");
+    this.#removeWithTransition(item, source.reason);
   }
-  /** Dismisses the focused toast when Escape is pressed. */
   onKeydown(event) {
     if (event.key === "Escape") {
       if (event.defaultPrevented || event.isComposing) return;
-      const item = this.#itemFromEvent(event);
+      const item = this.#itemFromSource(actionSource(event));
       if (!item) return;
       event.preventDefault();
       this.#removeWithTransition(item, "user");
     }
   }
-  /**
-   * Pauses the auto-dismiss timer on mouse entry or keyboard focus.
-   *
-   * Hover and focus are tracked as independent reasons: the timer is only
-   * snapshotted on the first active reason, and only resumed once *every*
-   * reason has been released (see {@link resume}). This keeps a toast paused
-   * while it is still hovered *or* focused, per WCAG 2.2.1. The hold is recorded
-   * whether or not a timer runs, so the `max` limit passes over the toast either
-   * way; `data-paused` marks a timer that stopped, and only that.
-   */
-  pause(event) {
-    const item = this.#itemFromEvent(event);
-    if (item && this.#dismiss.pause(item, this.#pauseReason(event))) {
+  pause(input) {
+    const source = actionSource(input);
+    const item = this.#itemFromSource(source);
+    if (item && this.#dismiss.pause(item, this.#pauseReason(source.event))) {
       item.setAttribute("data-paused", "true");
     }
   }
-  /**
-   * Resumes the auto-dismiss timer once both hover and focus have been released,
-   * and then applies the `max` limit again, sparing the toast the pointer or focus is
-   * moving into: its own hold only arrives after this event.
-   */
-  resume(event) {
-    const item = this.#itemFromEvent(event);
+  resume(input) {
+    const source = actionSource(input);
+    const item = this.#itemFromSource(source);
     if (item) {
       this.#release(
         item,
-        this.#pauseReason(event),
-        ownerOf(this.itemTargets, event.relatedTarget)
+        this.#pauseReason(source.event),
+        ownerOf(this.itemTargets, source.event?.relatedTarget)
       );
     }
   }
-  /** Releases one reason on `item`; releasing the last one applies the limit again. */
   #release(item, reason, spare) {
     const held = this.#dismiss.isHeld(item);
     if (this.#dismiss.resume(item, reason)) item.removeAttribute("data-paused");
     if (held && !this.#dismiss.isHeld(item)) this.#limitLater(spare);
   }
-  /**
-   * Applies the limit again once the current event is over, sparing `spare`. A hold can
-   * end in a `focusout` the engine fires while it is itself taking the node out for a
-   * script's move or removal, and taking the toast away inside that event would pull
-   * the node from under the caller's own call.
-   */
   #limitLater(spare) {
     if (spare) this.#spared.push(spare);
     this.#reapply.schedule();
   }
-  /** Applies the limit again, sparing every toast gathered since the last pass. */
+  #setPhase(item, phase) {
+    this.#phases.set(item, phase);
+    item.setAttribute("data-state", phase);
+  }
   #reapplyLimit() {
+    for (const item of this.itemTargets) {
+      if (!this.#taken.has(item) || !this.hasListTarget || item.parentNode !== this.listTarget)
+        continue;
+      const phase = this.#phases.get(item);
+      if (item.dataset.state === "leaving") this.#phases.set(item, "leaving");
+      else if (phase) item.setAttribute("data-state", phase);
+      if (this.#dismiss.isHeld(item) && this.#dismiss.tracks(item))
+        item.setAttribute("data-paused", "true");
+      else item.removeAttribute("data-paused");
+    }
     const spared = this.#spared;
     this.#spared = [];
     this.#enforceMax(spared);
   }
-  /**
-   * Reads the holds of a toast that moved within the list. Focus is read at once: an
-   * ordinary move ends it with a `focusout` and `moveBefore` keeps it. Where the pointer
-   * is, nothing says until it moves again: no `mouseout` reaches a moved node, and
-   * `:hover` can answer from before the move. A toast still held waits for that movement.
-   */
   #afterMove(item) {
     if (!item.contains(document.activeElement)) this.#release(item, "focus", null);
-    if (this.#dismiss.isHeld(item)) this.#awaitPointer(item);
+    if (this.#dismiss.isHeld(item)) this.#pointer.wait(item);
   }
-  /**
-   * Takes the holds a toast already has as it is taken on: focus inside it, and the pointer
-   * over it by `:hover`. That answer can date from before the toast came here, so a hover
-   * hold taken on it waits for the next pointer movement to be confirmed.
-   */
   #readHolds(item) {
     if (item.contains(document.activeElement)) this.#dismiss.pause(item, "focus");
     if (!item.matches(":hover")) return;
     this.#dismiss.pause(item, "hover");
-    this.#awaitPointer(item);
+    this.#pointer.wait(item);
   }
-  /** Leaves `item`'s hover hold to be confirmed or let go on the next pointer movement. */
-  #awaitPointer(item) {
-    this.#awaitingPointer.add(item);
-    this.#pointer.add(document, "pointermove", this.#onPointerMove, {
-      capture: true,
-      passive: true
-    });
-  }
-  /**
-   * Reads `:hover` once the pointer has moved, when the answer is current, and lets go of
-   * the hover hold of every waiting toast the pointer is not over. Listens once.
-   */
-  #onPointerMove = () => {
-    this.#pointer.dispose();
-    const waiting = [...this.#awaitingPointer];
-    this.#awaitingPointer.clear();
-    for (const item of waiting) {
-      if (!item.matches(":hover")) this.#release(item, "hover", null);
-    }
-  };
-  /**
-   * Drops a toast's timer and holds as it leaves, and stops waiting on the pointer for it.
-   * A toast something still held counts as released: the limit is applied again.
-   */
   #letGo(item) {
     if (this.#dismiss.isHeld(item)) this.#limitLater(null);
     this.#dismiss.clear(item);
-    this.#awaitingPointer.delete(item);
-    if (this.#awaitingPointer.size === 0) this.#pointer.dispose();
+    this.#pointer.cancel(item);
   }
-  /** Resolves the toast item element a pause/resume event targets. */
-  #itemFromEvent(event) {
-    const target = event.target instanceof Element ? event.target : event.currentTarget;
-    if (!(target instanceof Element) || !this.hasListTarget) return null;
+  #itemFromSource(source) {
+    const target = source.origin ?? source.host;
+    if (!target || !this.hasListTarget) return null;
+    if (target.closest(`[data-controller~="${this.identifier}"]`) !== this.element) return null;
     const item = target.closest(targetSelector(this.identifier, "item"));
-    return item && this.listTarget.contains(item) ? item : null;
+    return item && this.itemTargets.includes(item) && this.listTarget.contains(item) ? item : null;
   }
-  /** Classifies a pause/resume event as a hover or focus reason. */
   #pauseReason(event) {
-    return event.type === "focusin" || event.type === "focusout" ? "focus" : "hover";
-  }
-  /**
-   * Arms a toast's auto-dismiss; a non-positive `duration` means it never expires.
-   * On a toast hover or focus already holds, the timer waits for the release.
-   * `data-paused` is written from that state, so a mark the toast carried in with it,
-   * from a restored page, does not outlive it.
-   *
-   * @stimeoRuntimeOnly `duration` is the delay of the one dismissal timer this call arms.
-   */
+    return event?.type === "focusin" || event?.type === "focusout" ? "focus" : "hover";
+  }
   #startTimer(element) {
     if (element.dataset.state === "leaving" || element.parentNode !== this.listTarget) return;
-    const armed = this.durationValue > 0;
+    const armed = this.#safeDuration > 0;
     if (armed) {
       this.#dismiss.set(
         element,
         () => this.#removeWithTransition(element, "timeout"),
-        this.durationValue
+        this.#safeDuration
       );
     }
     if (armed && this.#dismiss.isHeld(element)) element.setAttribute("data-paused", "true");
@@ -656,7 +596,7 @@ var ToastController = class extends Controller {
     if (element.dataset.state === "leaving" || element.parentNode !== this.listTarget) return;
     this.#letGo(element);
     this.#cancelAnimation(element);
-    element.setAttribute("data-state", "leaving");
+    this.#setPhase(element, "leaving");
     const finalize = () => {
       if (element.parentNode !== this.listTarget) return;
       this.listTarget.removeChild(element);
@@ -669,65 +609,36 @@ var ToastController = class extends Controller {
       finalize();
     }
   }
-  /**
-   * Removes the oldest toasts while the list shows more than `maxValue`, passing
-   * over every toast hover or focus holds.
-   *
-   * Public (not `#private`) as a deterministic seam: enforcement normally runs
-   * as each toast is taken on in `itemTargetConnected`, a Stimulus callback delivered
-   * through a MutationObserver, which a DOM-only environment does not reliably fire —
-   * so it can also be invoked directly. It counts only the toasts taken on. It is not a
-   * user-wired action.
-   */
   enforceMaxLimit() {
     this.#enforceMax();
   }
-  /**
-   * Removes the oldest toasts with reason `limit` while the list shows more than `max`
-   * (`0` or less, or not a finite number, means no limit), passing over every toast hover
-   * or focus holds and those in `spared` — the toast just taken on, or the ones the
-   * pointer or focus moved into. Only toasts taken on count or go, so one Stimulus has
-   * yet to report is neither; a toast already leaving does not count. With nothing else
-   * left to go the list stays over the limit. The count is read again on every step,
-   * because a `dismiss` listener may already have changed it.
-   *
-   * @stimeoRenderRoot
-   */
   #enforceMax(spared = []) {
-    if (!Number.isFinite(this.maxValue) || this.maxValue <= 0) return;
-    for (const item of this.itemTargets) {
-      if (this.#shownCount() <= this.maxValue) return;
+    if (this.#safeMax <= 0) return;
+    for (const item of [...this.#arrivals]) {
+      if (this.#shownCount() <= this.#safeMax) return;
       if (this.#isShown(item) && !spared.includes(item) && !this.#dismiss.isHeld(item)) {
         this.#removeWithTransition(item, "limit");
       }
     }
   }
-  /** How many toasts the list shows: the ones taken on that are still shown. */
   #shownCount() {
     return this.itemTargets.filter((item) => this.#isShown(item)).length;
   }
-  /** Whether the list shows `item`: a toast taken on, a child of `list`, not leaving. */
   #isShown(item) {
     return this.#taken.has(item) && this.hasListTarget && item.parentNode === this.listTarget && item.dataset.state !== "leaving";
   }
-  /** Wires stable-container delegation so newly appended items work immediately. */
   #connectDelegatedEvents(list = this.hasListTarget ? this.listTarget : null) {
     this.#disconnectDelegatedEvents();
     if (!list) return;
     this.#delegatedList = list;
     for (const type of DELEGATED_EVENTS) {
-      this.#delegatedList.addEventListener(type, this.#onListEvent);
+      this.#listListeners.add(list, type, this.#onListEvent);
     }
   }
-  /** Releases every delegated listener from the exact list that owns it. */
   #disconnectDelegatedEvents() {
-    if (!this.#delegatedList) return;
-    for (const type of DELEGATED_EVENTS) {
-      this.#delegatedList.removeEventListener(type, this.#onListEvent);
-    }
+    this.#listListeners.dispose();
     this.#delegatedList = null;
   }
-  /** Routes every delegated item interaction from the stable list. */
   #onListEvent = (event) => {
     if (event.type === "click") {
       const target = event.target instanceof Element ? event.target : null;
@@ -740,22 +651,31 @@ var ToastController = class extends Controller {
       else this.resume(event);
     }
   };
-  /** Whether a bubbling focus/pointer event enters or leaves a toast boundary. */
   #crossesItemBoundary(event) {
-    const item = this.#itemFromEvent(event);
+    const item = this.#itemFromSource(actionSource(event));
     if (!item) return false;
     const related = "relatedTarget" in event ? event.relatedTarget : null;
     return !(related instanceof Node && item.contains(related));
   }
-  /** Cancels the pending entering-to-visible frame owned by one item. */
   #cancelAnimation(element) {
     const handle = this.#rafHandles.get(element);
     if (handle === void 0) return;
     window.cancelAnimationFrame(handle);
     this.#rafHandles.delete(element);
   }
+  get #safeDuration() {
+    return this.#numbers.read(
+      this,
+      "duration",
+      this.durationValue,
+      _ToastController.values.duration.default,
+      _ToastController.valueConstraints.duration
+    );
+  }
+  get #safeMax() {
+    return this.#numbers.read(this, "max", this.maxValue, 0, _ToastController.valueConstraints.max);
+  }
 };
 
 export { ToastController };
-//# sourceMappingURL=toast_controller.js.map
 //# sourceMappingURL=toast_controller.js.map