stimeo-ui 0.15.0 → 0.17.0

data/dist/controllers/toast_controller.js

@@ -1,44 +1,164 @@
 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)
+  };
+}
+
+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 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 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;
+  }
+};
 
-// 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);
@@ -55,16 +175,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(() => {
@@ -73,104 +186,89 @@ 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);
+    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 cloneTemplateRoot(template) {
+  const root = template.content.firstElementChild;
+  return root instanceof HTMLElement ? root.cloneNode(true) : null;
+}
+
 function timeMs(value) {
   const trimmed = value.trim();
   const amount = Number.parseFloat(trimmed);
@@ -204,123 +302,136 @@ 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();
-  /**
-   * 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).
-   */
+  #taken = /* @__PURE__ */ new Set();
+  #outside = /* @__PURE__ */ new WeakSet();
+  #phases = /* @__PURE__ */ new WeakMap();
+  #reapply = new MorphRenderWatcher(() => this.#reapplyLimit());
+  #spared = [];
+  #pointer = new ListenerSet();
+  #awaitingPointer = /* @__PURE__ */ new Set();
   #rafHandles = /* @__PURE__ */ new Map();
-  /** The stable list that owns delegated listeners for dynamically added items. */
   #delegatedList = null;
+  #connected = false;
+  #arrivals = /* @__PURE__ */ new Set();
+  #appliedMax = null;
   connect() {
+    this.#connected = true;
+    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();
-    this.enforceMaxLimit();
     for (const item of this.itemTargets) {
       if (!this.#dismiss.tracks(item) && item.dataset.state !== "leaving") {
         this.#startTimer(item);
       }
     }
+    if (!Object.is(this.#appliedMax, this.#safeMax)) {
+      this.#appliedMax = this.#safeMax;
+      this.#enforceMax();
+    }
   }
   disconnect() {
+    this.#connected = false;
     this.#disconnectDelegatedEvents();
     this.#timers.clearAll();
     this.#dismiss.clearAll();
+    this.#taken.clear();
+    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.clear(item);
-        item.removeAttribute("data-paused");
-      } else {
-        this.#startTimer(item);
-      }
+      if (this.#outside.has(item)) this.#takeIn(item);
     }
   }
   maxValueChanged() {
+    if (!this.#connected) return;
+    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. An
-   * item already leaving, or parented outside `list`, is skipped.
-   */
   itemTargetConnected(element) {
-    this.enforceMaxLimit();
-    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);
+    return true;
   }
-  /** Clears any active timer when a toast is removed from the DOM. */
   itemTargetDisconnected(element) {
-    this.#dismiss.clear(element);
+    const moved = this.#isShown(element) && element.matches(targetSelector(this.identifier, "item"));
+    if (moved) {
+      this.#afterMove(element);
+      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-body-param="Saved"
-   *           data-stimeo--toast-type-param="status">Show</button>
-   *
-   *   element.dispatchEvent(new CustomEvent("show", { detail: { body, type } }))
-   *
-   * Clones the template slot, interpolates the body text, and appends to the list.
-   */
   show(event) {
     if (!this.hasTemplateTarget || !this.hasListTarget) return;
-    const body = this.#readField(event, "body");
-    if (!body) return;
-    const clone = this.templateTarget.content.cloneNode(true);
-    const item = clone.querySelector("[data-stimeo--toast-target='item']");
-    if (!item) return;
-    const bodySlot = item.querySelector("[data-toast-slot='body']");
-    if (!bodySlot) return;
-    bodySlot.textContent = body;
-    bodySlot.setAttribute("role", this.#readField(event, "type") === "alert" ? "alert" : "status");
+    const message = this.#readField(event, "message");
+    if (!message) return;
+    const template = this.templateTarget;
+    const item = cloneTemplateRoot(template);
+    if (template.content.children.length !== 1) return;
+    if (!item?.matches(targetSelector(this.identifier, "item"))) return;
+    const messageSlot = item.querySelector("[data-toast-slot='message']");
+    if (!messageSlot) return;
+    messageSlot.textContent = message;
+    messageSlot.setAttribute(
+      "role",
+      this.#readField(event, "type") === "alert" ? "alert" : "status"
+    );
     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];
@@ -332,70 +443,126 @@ 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.
-   */
-  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. */
-  resume(event) {
-    const item = this.#itemFromEvent(event);
-    if (item && this.#dismiss.resume(item, this.#pauseReason(event))) {
-      item.removeAttribute("data-paused");
+  resume(input) {
+    const source = actionSource(input);
+    const item = this.#itemFromSource(source);
+    if (item) {
+      this.#release(
+        item,
+        this.#pauseReason(source.event),
+        ownerOf(this.itemTargets, source.event?.relatedTarget)
+      );
     }
   }
-  /** 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;
-    const item = target.closest("[data-stimeo--toast-target='item']");
-    return item && this.listTarget.contains(item) ? item : null;
+  #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);
+  }
+  #limitLater(spare) {
+    if (spare) this.#spared.push(spare);
+    this.#reapply.schedule();
+  }
+  #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);
+  }
+  #afterMove(item) {
+    if (!item.contains(document.activeElement)) this.#release(item, "focus", null);
+    if (this.#dismiss.isHeld(item)) this.#awaitPointer(item);
+  }
+  #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);
+  }
+  #awaitPointer(item) {
+    this.#awaitingPointer.add(item);
+    this.#pointer.add(document, "pointermove", this.#onPointerMove, {
+      capture: true,
+      passive: true
+    });
+  }
+  #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);
+    }
+  };
+  #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();
+  }
+  #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.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";
+    return event?.type === "focusin" || event?.type === "focusout" ? "focus" : "hover";
   }
-  /** Arms a toast's auto-dismiss; a non-positive `duration` means it never expires. */
   #startTimer(element) {
-    if (this.durationValue <= 0 || element.dataset.state === "leaving" || element.parentNode !== this.listTarget) {
-      return;
+    if (element.dataset.state === "leaving" || element.parentNode !== this.listTarget) return;
+    const armed = this.#safeDuration > 0;
+    if (armed) {
+      this.#dismiss.set(
+        element,
+        () => this.#removeWithTransition(element, "timeout"),
+        this.#safeDuration
+      );
     }
-    this.#dismiss.set(
-      element,
-      () => this.#removeWithTransition(element, "timeout"),
-      this.durationValue
-    );
+    if (armed && this.#dismiss.isHeld(element)) element.setAttribute("data-paused", "true");
+    else element.removeAttribute("data-paused");
   }
   #removeWithTransition(element, reason) {
     if (element.dataset.state === "leaving" || element.parentNode !== this.listTarget) return;
-    this.#dismiss.clear(element);
+    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);
@@ -408,26 +575,24 @@ var ToastController = class extends Controller {
       finalize();
     }
   }
-  /**
-   * Removes the oldest toasts when the list exceeds `maxValue`.
-   *
-   * Public (not `#private`) as a deterministic seam: enforcement normally runs
-   * from `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 is not a user-wired action.
-   */
   enforceMaxLimit() {
-    const currentItems = this.itemTargets;
-    const max = Math.max(0, this.maxValue);
-    if (currentItems.length > max) {
-      const excessCount = currentItems.length - max;
-      for (let i = 0; i < excessCount; i++) {
-        const oldest = currentItems[i];
-        if (oldest) this.#removeWithTransition(oldest, "timeout");
+    this.#enforceMax();
+  }
+  #enforceMax(spared = []) {
+    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");
       }
     }
   }
-  /** Wires stable-container delegation so newly appended items work immediately. */
+  #shownCount() {
+    return this.itemTargets.filter((item) => this.#isShown(item)).length;
+  }
+  #isShown(item) {
+    return this.#taken.has(item) && this.hasListTarget && item.parentNode === this.listTarget && item.dataset.state !== "leaving";
+  }
   #connectDelegatedEvents(list = this.hasListTarget ? this.listTarget : null) {
     this.#disconnectDelegatedEvents();
     if (!list) return;
@@ -436,7 +601,6 @@ var ToastController = class extends Controller {
       this.#delegatedList.addEventListener(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) {
@@ -444,7 +608,6 @@ var ToastController = class extends Controller {
     }
     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;
@@ -457,22 +620,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