stimeo-ui 0.15.0 → 0.17.0

package/dist/controllers/checkbox_controller.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/listener_set.ts","../../src/utils/microtask_coalescer.ts","../../src/controllers/checkbox_controller.ts"],"names":[],"mappings":"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","file":"checkbox_controller.js","sourcesContent":["/**\n * Owns every listener a controller attaches for one connected lifetime and\n * releases them together, so an event name is spelled once and the release\n * cannot drift from the registration.\n *\n * Detaching by hand repeats three things at the release site — the type, the\n * handler reference and the capture flag — and any one of them drifting leaves\n * a listener alive on an element the controller no longer drives. Aborting the\n * signal a registration was created with releases it whatever it was made of,\n * so the release site names nothing.\n *\n * One set per lifetime, held as a field and never rebuilt. {@link\n * ListenerSet.dispose} is the only thing that closes a generation, and it opens\n * the next one in the same step, so the lifecycle hooks can call `add` and\n * `dispose` in any order any number of times, and no `add` ever meets an\n * already aborted signal — a DOM that registers a listener on such a signal\n * would keep it forever. Rebuilding the set instead would leak:\n * `addEventListener` matches an existing registration on target, type, callback\n * and capture alone, so re-adding the same handler while the first registration\n * is live is discarded, and that live registration keeps the signal it was\n * attached with — a set built by a second `connect()` can never release what it\n * appears to own.\n *\n * Scope is the registration only. Timers, observers, leases and the order they\n * are unwound in stay with the controller, so `dispose()` belongs exactly where\n * the `removeEventListener` block stood. A receiver that changes at runtime (a\n * swapped target) is rebound by calling `dispose()` and then `add()` again from\n * the rebind, not by a second set.\n *\n * The set must own every registration of a tuple it holds: a listener the same\n * target already carries for the same type, callback and capture flag keeps the\n * right to remove it, and this set's `add` for that tuple is discarded. A\n * subscription shared between instances behind a participant count, or one that\n * lives for less than the connection, keeps its own pair of calls.\n *\n * This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\n *\n * @example\n * ```ts\n * readonly #listeners = new ListenerSet();\n *\n * connect(): void {\n *   this.#listeners.add(this.element, \"submit\", this.#onNativeSubmit, { capture: true });\n *   this.#listeners.add(this.element, \"turbo:submit-start\", this.#onSubmitStart);\n *   this.#listeners.add(this.element, \"turbo:submit-end\", this.#onSubmitEnd);\n * }\n *\n * disconnect(): void {\n *   this.#listeners.dispose();\n * }\n * ```\n */\nexport class ListenerSet {\n  /** The generation every `add` joins until the next `dispose()`. */\n  #abort = new AbortController();\n\n  /**\n   * Attaches `handler` to the open generation, exactly as the caller spelled it.\n   *\n   * The set supplies the signal, so `options` carries everything else the DOM\n   * accepts — `capture` included, which has to match at release time and no\n   * longer has a second place to drift from.\n   */\n  add(\n    target: EventTarget,\n    type: string,\n    handler: EventListener,\n    options?: Omit<AddEventListenerOptions, \"signal\">,\n  ): void {\n    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });\n  }\n\n  /**\n   * Releases every listener of the open generation, synchronously, and opens the\n   * next one. Idempotent, and safe before anything has been added.\n   */\n  dispose(): void {\n    this.#abort.abort();\n    this.#abort = new AbortController();\n  }\n}\n","/**\n * Collapses many Stimulus lifecycle callbacks from one DOM mutation into a\n * single pass.\n *\n * Stimulus fires `<name>TargetConnected` / `Disconnected` once per element and\n * `<name>ValueChanged` once per changed attribute. Replacing a list of N options\n * or morphing several render Values therefore delivers N callbacks — but the\n * useful unit of work is \"reconcile against the resulting declarative input\",\n * once, after the batch has settled. Every controller with reconcilable targets\n * or render Values needs the same shape: a `queued` flag plus `queueMicrotask`.\n *\n * **A microtask is the right horizon, and the reason is specific.** Stimulus\n * drives these callbacks from a `MutationObserver`, whose own callback already\n * runs as a microtask with the whole batch in hand; scheduling one more lands\n * after the last sibling callback of that batch and still before paint or any\n * event handler. A timer would be later than it needs to be, and reconciling\n * synchronously would run once per element against a half-applied DOM.\n *\n * **The two guards are not the same guard.** Scheduling is refused before the\n * controller connects, and running is refused after it disconnects:\n *\n * - **Before `connect()`** — Stimulus delivers initial target and Value callbacks\n *   ahead of `connect()`. Reconciling there would compute output against a\n *   controller whose own state has not been initialised, and `connect()` is\n *   about to do a full pass anyway.\n * - **After `disconnect()`** — Stimulus fires a callback for **every** target\n *   during teardown, and a microtask queued just before it would otherwise run\n *   against a detached tree. {@link MicrotaskCoalescer.cancel} exists for the\n *   teardown path to drop the pending pass outright.\n *\n * Both guards are part of one contract here rather than something each consumer\n * has to remember separately.\n *\n * Scope is the scheduling only. *What* to reconcile — keep the surviving active\n * option, fall back to the next / previous / first visible one, rebuild derived\n * chips or hidden fields — stays in the controller, because no two consumers\n * answer it the same way.\n *\n * This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\n *\n * @example\n * ```ts\n * readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileOptions());\n *\n * connect()    { this.#reconcile.activate(); }\n * disconnect() { this.#reconcile.cancel(); }\n *\n * optionTargetConnected()    { this.#reconcile.schedule(); }\n * optionTargetDisconnected() { this.#reconcile.schedule(); }\n * ```\n */\nexport class MicrotaskCoalescer {\n  readonly #run: () => void;\n  #queued = false;\n  #active = false;\n  #generation = 0;\n\n  /** @param run - the single reconciliation pass, invoked at most once per batch. */\n  constructor(run: () => void) {\n    this.#run = run;\n  }\n\n  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */\n  activate(): void {\n    this.#active = true;\n  }\n\n  /** Closes the window and drops any pending pass; call from `disconnect()`. */\n  cancel(): void {\n    this.#active = false;\n    this.#queued = false;\n    this.#generation += 1;\n  }\n\n  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */\n  schedule(): void {\n    if (!this.#active || this.#queued) return;\n    this.#queued = true;\n    const generation = this.#generation;\n    queueMicrotask(() => {\n      // A cancelled callback must not consume a pass queued after reconnect.\n      if (generation !== this.#generation || !this.#queued || !this.#active) return;\n      this.#queued = false;\n      this.#run();\n    });\n  }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { ListenerSet } from \"../utils/listener_set\";\nimport { MicrotaskCoalescer } from \"../utils/microtask_coalescer\";\n\n/** Aggregate selection state of a parent/child checkbox group. */\ntype CheckboxState = \"all\" | \"partial\" | \"none\";\n\n/**\n * Headless, accessible checkbox behavior (including the tri-state / parent-child\n * \"select all\" pattern).\n *\n * Markup contract (identifier: `stimeo--checkbox`):\n *   <fieldset data-controller=\"stimeo--checkbox\" role=\"group\" aria-labelledby=\"all-label\">\n *     <label id=\"all-label\">\n *       <input type=\"checkbox\" data-stimeo--checkbox-target=\"parent\"\n *              data-action=\"change->stimeo--checkbox#onParentChange\" /> Select all\n *     </label>\n *     <label><input type=\"checkbox\" data-stimeo--checkbox-target=\"child\"\n *              data-action=\"change->stimeo--checkbox#onChildChange\" /> Item A</label>\n *     <!-- more children -->\n *   </fieldset>\n *\n * Implements the WAI-ARIA APG **Checkbox** pattern. Native `<input type=\"checkbox\">`\n * is used throughout (so Space toggle, focus order, and `mixed` exposure are the\n * browser's); the controller adds what HTML cannot express: the parent's\n * `indeterminate` property (announced as `mixed`) derived from its children, and\n * the cascade from a parent toggle to its children.\n *\n * `change` and `reconcile` dispatch\n * `{ checked: boolean, indeterminate: boolean, state: \"all\" | \"partial\" | \"none\" }`.\n *\n * @remarks\n * Behavior only — the check mark and any \"mixed\" affordance are the consumer's\n * CSS (keyed off `:checked` / `:indeterminate` / `data-state`). The `parent`\n * target is optional: a child-only group still exposes its aggregate on the root,\n * while a lone tri-state checkbox can use just `parent` and drive\n * `indeterminate` externally — with no `child` target the parent's own `checked`\n * and `indeterminate` stay the consumer's, because only children are\n * authoritative over them. At most one `parent` may be present.\n *\n * Behavior provided:\n * - Parent toggle checks/unchecks every child and clears its own `indeterminate`.\n *   All child targets, including disabled ones, participate; omit the target to\n *   exclude an input. The cascade does not synthesize native child `change`\n *   events — one aggregate custom event describes the action.\n * - A child change recomputes the parent: all → checked, none → unchecked,\n *   some → `indeterminate`.\n * - The aggregate (`all` / `partial` / `none`) is mirrored to `data-state` on the\n *   root. Dynamic targets, checked-attribute changes, Turbo morphs, and native\n *   form resets are reconciled from the children. Callers that assign the live\n *   `checked` property directly must dispatch `change`, because property writes\n *   are not observable by a `MutationObserver`.\n * - `stimeo--checkbox:change` is dispatched for the two public change actions;\n *   `stimeo--checkbox:reconcile` is dispatched instead when a reconciliation —\n *   not the user — moves the aggregate. Both carry `{ checked: boolean,\n *   indeterminate: boolean, state: \"all\" | \"partial\" | \"none\" }` and describe\n *   the aggregate even without a parent. Neither fires on connect.\n */\nexport class CheckboxController extends Controller<HTMLElement> {\n  static override targets = [\"parent\", \"child\"];\n  static actions = [\"onChildChange\", \"onParentChange\"] as const;\n  static events = [\"change\", \"reconcile\"] as const;\n\n  declare readonly parentTarget: HTMLInputElement;\n  declare readonly parentTargets: HTMLInputElement[];\n  declare readonly hasParentTarget: boolean;\n  declare readonly childTargets: HTMLInputElement[];\n\n  /** Collapses every lifecycle signal from one DOM update into one derived pass. */\n  readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileFromChildren());\n  readonly #listeners = new ListenerSet();\n  /** Aggregate this root last settled on, so a derived repair is reported once. */\n  #committedState: CheckboxState | null = null;\n  /** Watches authored checked-attribute changes on retained target elements. */\n  readonly #checkedObserver = new MutationObserver((records) => {\n    if (records.some((record) => this.#isManagedCheckbox(record.target))) {\n      this.#reconcile.schedule();\n    }\n  });\n\n  /** Reflects the initial aggregate and starts retained-DOM reconciliation. */\n  override connect(): void {\n    this.#reconcile.activate();\n    this.#syncFromChildren();\n    this.#checkedObserver.observe(this.element, {\n      attributes: true,\n      attributeFilter: [\"checked\"],\n      subtree: true,\n    });\n    this.#listeners.add(this.element, \"turbo:morph-element\", this.#onMorph);\n    document.addEventListener(\"reset\", this.#onReset, true);\n  }\n\n  /** Releases the observer, global reset listener, and every pending reconciliation. */\n  override disconnect(): void {\n    this.#reconcile.cancel();\n    this.#checkedObserver.disconnect();\n    this.#listeners.dispose();\n    document.removeEventListener(\"reset\", this.#onReset, true);\n  }\n\n  /** Reconciles the aggregate for a parent added or replaced at runtime. */\n  parentTargetConnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Reconciles the aggregate after a parent target leaves the group. */\n  parentTargetDisconnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Reconciles the aggregate for a child added at runtime. */\n  childTargetConnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Reconciles the aggregate after a child leaves the group. */\n  childTargetDisconnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Cascades the parent's state to every child. Bound via `data-action` (change). */\n  onParentChange(): void {\n    if (!this.hasParentTarget) return;\n    const checked = this.parentTarget.checked;\n    for (const child of this.childTargets) {\n      child.checked = checked;\n    }\n    this.#reflect(checked ? \"all\" : \"none\", true);\n    const detail = this.#settledDetail();\n    if (detail) this.dispatch(\"change\", { detail });\n  }\n\n  /** Recomputes the parent from its children. Bound via `data-action` (change). */\n  onChildChange(): void {\n    this.#syncFromChildren();\n    const detail = this.#settledDetail();\n    if (detail) this.dispatch(\"change\", { detail });\n  }\n\n  /**\n   * Announces an aggregate this pass derived rather than the user. `change` stays\n   * reserved for the two public actions, so automation never reads a repair as an edit.\n   */\n  #reconcileFromChildren(): void {\n    const previous = this.#committedState;\n    this.#syncFromChildren();\n    if (this.#committedState === previous) return;\n    const detail = this.#settledDetail();\n    if (detail) this.dispatch(\"reconcile\", { detail });\n  }\n\n  /**\n   * Derives the parent's `checked`/`indeterminate` and the root `data-state` from\n   * the children. Writing state and reporting it are separate so the caller — not\n   * a flag threaded through the write — decides which event describes the cause.\n   */\n  #syncFromChildren(): void {\n    // A childless root reads its aggregate off the parent itself, so writing the\n    // derived value back would clear a `checked` the consumer drives alongside\n    // `indeterminate`. Only the children are authoritative over the parent.\n    this.#reflect(this.#aggregate(), this.childTargets.length > 0);\n  }\n\n  /**\n   * Reflects one aggregate state.\n   *\n   * @param writeParent - whether the state is authoritative over the `parent`\n   * target's own `checked` / `indeterminate`.\n   */\n  #reflect(state: CheckboxState, writeParent: boolean): void {\n    if (writeParent && this.hasParentTarget) {\n      this.parentTarget.checked = state === \"all\";\n      this.parentTarget.indeterminate = state === \"partial\";\n    }\n    this.element.setAttribute(\"data-state\", state);\n    this.#committedState = state;\n  }\n\n  /** The settled aggregate as event detail, or `null` before anything has settled. */\n  #settledDetail(): { checked: boolean; indeterminate: boolean; state: CheckboxState } | null {\n    const state = this.#committedState;\n    if (state === null) return null;\n    return { checked: state === \"all\", indeterminate: state === \"partial\", state };\n  }\n\n  /** Reconciles retained targets after Turbo has finished morphing their live state. */\n  readonly #onMorph = (): void => {\n    this.#reconcile.schedule();\n  };\n\n  /** Reconciles after a non-cancelled reset restores any managed checkbox. */\n  readonly #onReset = (event: Event): void => {\n    const form = event.target;\n    if (!(form instanceof HTMLFormElement) || !this.#hasCheckboxOwnedBy(form)) return;\n    queueMicrotask(() => {\n      if (!event.defaultPrevented) this.#reconcile.schedule();\n    });\n  };\n\n  /** Whether a form owns at least one current parent or child target. */\n  #hasCheckboxOwnedBy(form: HTMLFormElement): boolean {\n    return [...this.parentTargets, ...this.childTargets].some((checkbox) => checkbox.form === form);\n  }\n\n  /** Whether an observed attribute mutation belongs to this controller's target set. */\n  #isManagedCheckbox(node: Node): boolean {\n    return (\n      this.parentTargets.some((checkbox) => checkbox === node) ||\n      this.childTargets.some((checkbox) => checkbox === node)\n    );\n  }\n\n  /**\n   * Computes the aggregate state. With children it counts them; with none it\n   * reads the parent so a lone tri-state checkbox still reports a state without\n   * its externally-set `indeterminate` being clobbered.\n   */\n  #aggregate(): CheckboxState {\n    const children = this.childTargets;\n    if (children.length === 0) {\n      if (this.hasParentTarget && this.parentTarget.indeterminate) return \"partial\";\n      return this.hasParentTarget && this.parentTarget.checked ? \"all\" : \"none\";\n    }\n    const checked = children.filter((child) => child.checked).length;\n    if (checked === 0) return \"none\";\n    if (checked === children.length) return \"all\";\n    return \"partial\";\n  }\n}\n"]}
+{"version":3,"sources":["../../src/utils/form_reset_watcher.ts","../../src/utils/listener_set.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/morph_render_watcher.ts","../../src/controllers/checkbox_controller.ts"],"names":[],"mappings":"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","file":"checkbox_controller.js","sourcesContent":["/**\n * Runs a controller's reconciliation pass after a native form reset has\n * restored the form's own controls.\n *\n * **A microtask alone is not \"after the reset\", and the reason is where the\n * dispatch came from.** `form.reset()` fires the event and restores the\n * controls inside one script frame, so a microtask queued from a listener lands\n * after both. A reset the user triggers — activating a `reset` button — is\n * dispatched by the browser with an empty script stack, so the microtask\n * checkpoint runs the moment the listener returns: still inside the dispatch,\n * before the controls are restored and before a later listener has had its\n * chance to cancel. Reconciling there reads the pre-reset values and treats a\n * cancelled reset as a real one.\n *\n * The event itself tells the two origins apart. `eventPhase` returns to\n * `Event.NONE` at the end of dispatch, so a microtask that sees `NONE` is\n * already past the default action and settles on the spot — that is the\n * scripted path, and its timing is exactly a microtask. A microtask\n * that still sees a dispatch phase is the browser-driven path and settles on\n * the next animation frame instead: the default action completes before that\n * frame, and `defaultPrevented` has reached its final value. A frame is only\n * ever reached from a real user interaction, which requires a rendered\n * document, so the frame cannot starve.\n *\n * Pending frames are held per handle rather than collapsed into one slot: a set\n * needs no branch to stay accurate, and every handle in it is cancellable at\n * teardown.\n *\n * Scope is the timing and the ownership test only. *What* to reconcile — an\n * aggregate, a visibility pass, a re-read of every field — stays in the\n * controller, because no two consumers answer it the same way. Ownership stays\n * there too: a control associated through `form=` is reached by the consumer's\n * own `control.form` read.\n *\n * @example\n * ```ts\n * readonly #formReset = new FormResetWatcher(\n *   (form) => this.fieldTargets.some((field) => field.form === form),\n *   () => this.#reconcile.schedule(),\n * );\n *\n * connect()    { this.#formReset.observe(); }\n * disconnect() { this.#formReset.disconnect(); }\n * ```\n */\nexport class FormResetWatcher {\n  readonly #owns: (form: HTMLFormElement) => boolean;\n  readonly #onReset: () => void;\n  readonly #frames = new Set<number>();\n  #generation = 0;\n\n  /**\n   * @param owns - whether `form` owns a control this controller derives from.\n   * @param onReset - the reconciliation pass, run once per honoured reset.\n   */\n  constructor(owns: (form: HTMLFormElement) => boolean, onReset: () => void) {\n    this.#owns = owns;\n    this.#onReset = onReset;\n  }\n\n  /** Subscribes to `reset` at the document; call from `connect()`. Idempotent. */\n  observe(): void {\n    document.addEventListener(\"reset\", this.#handleReset, true);\n  }\n\n  /** Unsubscribes and drops every pending pass; call from `disconnect()`. */\n  disconnect(): void {\n    document.removeEventListener(\"reset\", this.#handleReset, true);\n    this.#generation += 1;\n    for (const frame of this.#frames) cancelAnimationFrame(frame);\n    this.#frames.clear();\n  }\n\n  readonly #handleReset = (event: Event): void => {\n    const form = event.target;\n    if (!(form instanceof HTMLFormElement) || !this.#owns(form)) return;\n    const generation = this.#generation;\n    queueMicrotask(() => {\n      // A pass queued before teardown must not reach a disconnected controller.\n      if (generation !== this.#generation) return;\n      if (event.eventPhase === Event.NONE) {\n        this.#settle(event);\n        return;\n      }\n      const frame = requestAnimationFrame(() => {\n        this.#frames.delete(frame);\n        this.#settle(event);\n      });\n      this.#frames.add(frame);\n    });\n  };\n\n  /** Runs the pass unless a listener cancelled the reset before it landed. */\n  #settle(event: Event): void {\n    if (!event.defaultPrevented) this.#onReset();\n  }\n}\n","/**\n * Owns every listener a controller attaches for one connected lifetime and\n * releases them together, so an event name is spelled once and the release\n * cannot drift from the registration.\n *\n * Detaching by hand repeats three things at the release site — the type, the\n * handler reference and the capture flag — and any one of them drifting leaves\n * a listener alive on an element the controller no longer drives. Aborting the\n * signal a registration was created with releases it whatever it was made of,\n * so the release site names nothing.\n *\n * One set per lifetime, held as a field and never rebuilt. {@link\n * ListenerSet.dispose} is the only thing that closes a generation, and it opens\n * the next one in the same step, so the lifecycle hooks can call `add` and\n * `dispose` in any order any number of times, and no `add` ever meets an\n * already aborted signal — a DOM that registers a listener on such a signal\n * would keep it forever. Rebuilding the set instead would leak:\n * `addEventListener` matches an existing registration on target, type, callback\n * and capture alone, so re-adding the same handler while the first registration\n * is live is discarded, and that live registration keeps the signal it was\n * attached with — a set built by a second `connect()` can never release what it\n * appears to own.\n *\n * Scope is the registration only. Timers, observers, leases and the order they\n * are unwound in stay with the controller, which places `dispose()` in its\n * cleanup sequence. A receiver that changes at runtime (a\n * swapped target) is rebound by calling `dispose()` and then `add()` again from\n * the rebind, not by a second set.\n *\n * The set must own every registration of a tuple it holds: a listener the same\n * target already carries for the same type, callback and capture flag keeps the\n * right to remove it, and this set's `add` for that tuple is discarded. A\n * subscription shared between instances behind a participant count, or one that\n * lives for less than the connection, keeps its own pair of calls.\n *\n * @example\n * ```ts\n * readonly #listeners = new ListenerSet();\n *\n * connect(): void {\n *   this.#listeners.add(this.element, \"submit\", this.#onNativeSubmit, { capture: true });\n *   this.#listeners.add(this.element, \"turbo:submit-start\", this.#onSubmitStart);\n *   this.#listeners.add(this.element, \"turbo:submit-end\", this.#onSubmitEnd);\n * }\n *\n * disconnect(): void {\n *   this.#listeners.dispose();\n * }\n * ```\n */\nexport class ListenerSet {\n  /** The generation every `add` joins until the next `dispose()`. */\n  #abort = new AbortController();\n\n  /**\n   * Attaches `handler` to the open generation, exactly as the caller spelled it.\n   *\n   * The set supplies the signal, so `options` carries everything else the DOM\n   * accepts — `capture` included, which has to match at release time and no\n   * longer has a second place to drift from.\n   */\n  add(\n    target: EventTarget,\n    type: string,\n    handler: EventListener,\n    options?: Omit<AddEventListenerOptions, \"signal\">,\n  ): void {\n    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });\n  }\n\n  /**\n   * Releases every listener of the open generation, synchronously, and opens the\n   * next one. Idempotent, and safe before anything has been added.\n   */\n  dispose(): void {\n    this.#abort.abort();\n    this.#abort = new AbortController();\n  }\n}\n","/**\n * Collapses many Stimulus lifecycle callbacks from one DOM mutation into a\n * single pass.\n *\n * Stimulus fires `<name>TargetConnected` / `Disconnected` once per element and\n * `<name>ValueChanged` once per changed attribute. Replacing a list of N options\n * or morphing several render Values therefore delivers N callbacks — but the\n * useful unit of work is \"reconcile against the resulting declarative input\",\n * once, after the batch has settled. Every controller with reconcilable targets\n * or render Values needs the same shape: a `queued` flag plus `queueMicrotask`.\n *\n * **A microtask is the right horizon, and the reason is specific.** Stimulus\n * drives these callbacks from a `MutationObserver`, whose own callback already\n * runs as a microtask with the whole batch in hand; scheduling one more lands\n * after the last sibling callback of that batch and still before paint or any\n * event handler. A timer would be later than it needs to be, and reconciling\n * synchronously would run once per element against a half-applied DOM.\n *\n * **The two guards are not the same guard.** Scheduling is refused before the\n * controller connects, and running is refused after it disconnects:\n *\n * - **Before `connect()`** — Stimulus delivers initial target and Value callbacks\n *   ahead of `connect()`. Reconciling there would compute output against a\n *   controller whose own state has not been initialised, and `connect()` is\n *   about to do a full pass anyway.\n * - **After `disconnect()`** — Stimulus fires a callback for **every** target\n *   during teardown, and a microtask queued just before it would otherwise run\n *   against a detached tree. {@link MicrotaskCoalescer.cancel} exists for the\n *   teardown path to drop the pending pass outright.\n *\n * Both guards are part of one contract here rather than something each consumer\n * has to remember separately.\n *\n * Scope is the scheduling only. *What* to reconcile — keep the surviving active\n * option, fall back to the next / previous / first visible one, rebuild derived\n * chips or hidden fields — stays in the controller, because no two consumers\n * answer it the same way.\n *\n * @example\n * ```ts\n * readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileOptions());\n *\n * connect()    { this.#reconcile.activate(); }\n * disconnect() { this.#reconcile.cancel(); }\n *\n * optionTargetConnected()    { this.#reconcile.schedule(); }\n * optionTargetDisconnected() { this.#reconcile.schedule(); }\n * ```\n */\nexport class MicrotaskCoalescer {\n  readonly #run: () => void;\n  #queued = false;\n  #active = false;\n  #generation = 0;\n\n  /** @param run - the single reconciliation pass, invoked at most once per batch. */\n  constructor(run: () => void) {\n    this.#run = run;\n  }\n\n  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */\n  activate(): void {\n    this.#active = true;\n  }\n\n  /** Closes the window and drops any pending pass; call from `disconnect()`. */\n  cancel(): void {\n    this.#active = false;\n    this.#queued = false;\n    this.#generation += 1;\n  }\n\n  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */\n  schedule(): void {\n    if (!this.#active || this.#queued) return;\n    this.#queued = true;\n    const generation = this.#generation;\n    queueMicrotask(() => {\n      // A cancelled callback must not consume a pass queued after reconnect.\n      if (generation !== this.#generation || !this.#queued || !this.#active) return;\n      this.#queued = false;\n      this.#run();\n    });\n  }\n}\n","import { ListenerSet } from \"./listener_set\";\nimport { MicrotaskCoalescer } from \"./microtask_coalescer\";\n\n/**\n * Coalesces retained-element morphs and explicit lifecycle requests into one pass.\n *\n * Observe the controller's element after its initial state is settled. Morphs on\n * that element and bubbling morphs on its descendants share the same microtask\n * as {@link schedule}. The callback repairs derived output; the controller owns\n * any logical transition reporting. {@link disconnect} releases the listener and\n * cancels pending work, including work from an earlier connected lifetime.\n */\nexport class MorphRenderWatcher {\n  readonly #listeners = new ListenerSet();\n  readonly #pass: MicrotaskCoalescer;\n  #element: Element | null = null;\n  readonly #onMorph = (): void => this.#pass.schedule();\n\n  /** @param run - the single pass that repairs the settled controller's output. */\n  constructor(run: () => void) {\n    this.#pass = new MicrotaskCoalescer(run);\n  }\n\n  /** Opens observation; observing the same element again preserves queued work. */\n  observe(element: Element): void {\n    if (this.#element === element) return;\n    this.disconnect();\n    this.#element = element;\n    this.#pass.activate();\n    this.#listeners.add(element, \"turbo:morph-element\", this.#onMorph);\n  }\n\n  /** Requests one pass; requests outside an observed lifetime are ignored. */\n  schedule(): void {\n    this.#pass.schedule();\n  }\n\n  /** Releases observation and pending work synchronously; safe to repeat. */\n  disconnect(): void {\n    this.#listeners.dispose();\n    this.#pass.cancel();\n    this.#element = null;\n  }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { FormResetWatcher } from \"../utils/form_reset_watcher\";\nimport { MorphRenderWatcher } from \"../utils/morph_render_watcher\";\n\n/** Aggregate selection state of a parent/child checkbox group. */\ntype CheckboxState = \"all\" | \"partial\" | \"none\";\n\n/**\n * Headless, accessible checkbox behavior (including the tri-state / parent-child\n * \"select all\" pattern).\n *\n * Markup contract (identifier: `stimeo--checkbox`):\n *   <fieldset data-controller=\"stimeo--checkbox\" role=\"group\" aria-labelledby=\"all-label\">\n *     <label id=\"all-label\">\n *       <input type=\"checkbox\" data-stimeo--checkbox-target=\"parent\"\n *              data-action=\"change->stimeo--checkbox#onParentChange\" /> Select all\n *     </label>\n *     <label><input type=\"checkbox\" data-stimeo--checkbox-target=\"child\"\n *              data-action=\"change->stimeo--checkbox#onChildChange\" /> Item A</label>\n *     <!-- more children -->\n *   </fieldset>\n *\n * Implements the WAI-ARIA APG **Checkbox** pattern. Native `<input type=\"checkbox\">`\n * is used throughout (so Space toggle, focus order, and `mixed` exposure are the\n * browser's); the controller adds what HTML cannot express: the parent's\n * `indeterminate` property (announced as `mixed`) derived from its children, and\n * the cascade from a parent toggle to its children.\n *\n * `change` and `reconcile` dispatch\n * `{ checked: boolean, indeterminate: boolean, state: \"all\" | \"partial\" | \"none\" }`.\n *\n * @remarks\n * Behavior only — the check mark and any \"mixed\" affordance are the consumer's\n * CSS (keyed off `:checked` / `:indeterminate` / `data-state`). The `parent`\n * target is optional: a child-only group still exposes its aggregate on the root,\n * while a lone tri-state checkbox can use just `parent` and drive\n * `indeterminate` externally — with no `child` target the parent's own `checked`\n * and `indeterminate` stay the consumer's, because only children are\n * authoritative over them. At most one `parent` may be present.\n *\n * Behavior provided:\n * - Parent toggle checks/unchecks every child and clears its own `indeterminate`.\n *   All child targets, including disabled ones, participate; omit the target to\n *   exclude an input. The cascade does not synthesize native child `change`\n *   events — one aggregate custom event reports a changed aggregate.\n * - A child change recomputes the parent: all → checked, none → unchecked,\n *   some → `indeterminate`.\n * - The aggregate (`all` / `partial` / `none`) is mirrored to `data-state` on the\n *   root. Dynamic targets, checked-attribute changes, Turbo morphs, and native\n *   form resets are reconciled from the children. Callers that assign the live\n *   `checked` property directly must dispatch `change`, because property writes\n *   are not observable by a `MutationObserver`.\n * - `stimeo--checkbox:change` is dispatched by the two public change actions only\n *   when the aggregate differs from the last published one. Pending page writes\n *   are included in that confirmation; returning to the published aggregate is\n *   silent. Browser-dispatched listeners can reconcile a page write before the\n *   action runs, while script dispatch and consecutive Stimulus actions in one\n *   listener include it in the action's `change`.\n *   `stimeo--checkbox:reconcile` is dispatched instead when a reconciliation —\n *   not the user — moves the aggregate. Both carry `{ checked: boolean,\n *   indeterminate: boolean, state: \"all\" | \"partial\" | \"none\" }` and describe\n *   the aggregate even without a parent. Neither fires on connect.\n */\nexport class CheckboxController extends Controller<HTMLElement> {\n  static override targets = [\"parent\", \"child\"];\n  static actions = [\"onChildChange\", \"onParentChange\"] as const;\n  static events = [\"change\", \"reconcile\"] as const;\n\n  declare readonly parentTarget: HTMLInputElement;\n  declare readonly parentTargets: HTMLInputElement[];\n  declare readonly hasParentTarget: boolean;\n  declare readonly childTargets: HTMLInputElement[];\n\n  /** Collapses every lifecycle signal from one DOM update into one derived pass. */\n  readonly #reconcile = new MorphRenderWatcher(() => this.#reconcileFromChildren());\n  readonly #formReset = new FormResetWatcher(\n    (form) => this.#hasCheckboxOwnedBy(form),\n    () => this.#reconcile.schedule(),\n  );\n  /** Aggregate this root last settled on, so a derived repair is reported once. */\n  #committedState: CheckboxState | null = null;\n  /** Watches authored checked-attribute changes on retained target elements. */\n  readonly #checkedObserver = new MutationObserver((records) => {\n    if (records.some((record) => this.#isManagedCheckbox(record.target))) {\n      this.#reconcile.schedule();\n    }\n  });\n\n  /** Reflects the initial aggregate and starts retained-DOM reconciliation. */\n  override connect(): void {\n    this.#syncFromChildren();\n    this.#reconcile.observe(this.element);\n    this.#checkedObserver.observe(this.element, {\n      attributes: true,\n      attributeFilter: [\"checked\"],\n      subtree: true,\n    });\n    this.#formReset.observe();\n  }\n\n  /** Releases the observer, global reset listener, and every pending reconciliation. */\n  override disconnect(): void {\n    this.#reconcile.disconnect();\n    this.#checkedObserver.disconnect();\n    this.#formReset.disconnect();\n  }\n\n  /** Reconciles the aggregate for a parent added or replaced at runtime. */\n  parentTargetConnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Reconciles the aggregate after a parent target leaves the group. */\n  parentTargetDisconnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Reconciles the aggregate for a child added at runtime. */\n  childTargetConnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Reconciles the aggregate after a child leaves the group. */\n  childTargetDisconnected(): void {\n    this.#reconcile.schedule();\n  }\n\n  /** Cascades the parent's state to every child. Bound via `data-action` (change). */\n  onParentChange(): void {\n    if (!this.hasParentTarget) return;\n    const previous = this.#committedState;\n    const checked = this.parentTarget.checked;\n    for (const child of this.childTargets) {\n      child.checked = checked;\n    }\n    this.#reflect(checked ? \"all\" : \"none\", true);\n    if (this.#committedState === previous) return;\n    const detail = this.#settledDetail();\n    if (detail) this.dispatch(\"change\", { detail });\n  }\n\n  /** Recomputes the parent from its children. Bound via `data-action` (change). */\n  onChildChange(): void {\n    const previous = this.#committedState;\n    this.#syncFromChildren();\n    if (this.#committedState === previous) return;\n    const detail = this.#settledDetail();\n    if (detail) this.dispatch(\"change\", { detail });\n  }\n\n  /**\n   * Announces an aggregate this pass derived rather than the user. `change` stays\n   * reserved for the two public actions, so automation never reads a repair as an edit.\n   */\n  #reconcileFromChildren(): void {\n    const previous = this.#committedState;\n    this.#syncFromChildren();\n    if (this.#committedState === previous) return;\n    const detail = this.#settledDetail();\n    if (detail) this.dispatch(\"reconcile\", { detail });\n  }\n\n  /**\n   * Derives the parent's `checked`/`indeterminate` and the root `data-state` from\n   * the children. Writing state and reporting it are separate so the caller — not\n   * a flag threaded through the write — decides which event describes the cause.\n   */\n  #syncFromChildren(): void {\n    // A childless root reads its aggregate off the parent itself, so writing the\n    // derived value back would clear a `checked` the consumer drives alongside\n    // `indeterminate`. Only the children are authoritative over the parent.\n    this.#reflect(this.#aggregate(), this.childTargets.length > 0);\n  }\n\n  /**\n   * Reflects one aggregate state.\n   *\n   * @param writeParent - whether the state is authoritative over the `parent`\n   * target's own `checked` / `indeterminate`.\n   */\n  #reflect(state: CheckboxState, writeParent: boolean): void {\n    if (writeParent && this.hasParentTarget) {\n      this.parentTarget.checked = state === \"all\";\n      this.parentTarget.indeterminate = state === \"partial\";\n    }\n    this.element.setAttribute(\"data-state\", state);\n    this.#committedState = state;\n  }\n\n  /** The settled aggregate as event detail, or `null` before anything has settled. */\n  #settledDetail(): { checked: boolean; indeterminate: boolean; state: CheckboxState } | null {\n    const state = this.#committedState;\n    if (state === null) return null;\n    return { checked: state === \"all\", indeterminate: state === \"partial\", state };\n  }\n\n  /** Whether a form owns at least one current parent or child target. */\n  #hasCheckboxOwnedBy(form: HTMLFormElement): boolean {\n    return [...this.parentTargets, ...this.childTargets].some((checkbox) => checkbox.form === form);\n  }\n\n  /** Whether an observed attribute mutation belongs to this controller's target set. */\n  #isManagedCheckbox(node: Node): boolean {\n    return (\n      this.parentTargets.some((checkbox) => checkbox === node) ||\n      this.childTargets.some((checkbox) => checkbox === node)\n    );\n  }\n\n  /**\n   * Computes the aggregate state. With children it counts them; with none it\n   * reads the parent so a lone tri-state checkbox still reports a state without\n   * its externally-set `indeterminate` being clobbered.\n   */\n  #aggregate(): CheckboxState {\n    const children = this.childTargets;\n    if (children.length === 0) {\n      if (this.hasParentTarget && this.parentTarget.indeterminate) return \"partial\";\n      return this.hasParentTarget && this.parentTarget.checked ? \"all\" : \"none\";\n    }\n    const checked = children.filter((child) => child.checked).length;\n    if (checked === 0) return \"none\";\n    if (checked === children.length) return \"all\";\n    return \"partial\";\n  }\n}\n"]}

package/dist/controllers/clipboard_controller.d.ts

@@ -28,7 +28,7 @@ import { Controller } from '@hotwired/stimulus';
  *
  * Values: `text` (copy this instead of reading `source`), `feedbackDuration` (ms the
  * completion state is held; `0` or less arms no timer, so it stands until the next
- * copy — a reconnect and the before-cache rewind still clear it), `copiedLabel` /
+ * copy — a reconnect still clears it), `copiedLabel` /
  * `errorLabel` (what the visible slot shows), `announceCopiedText` /
  * `announceErrorText` (what assistive tech hears; empty announces nothing).
  *
@@ -43,10 +43,20 @@ import { Controller } from '@hotwired/stimulus';
  * well would say everything twice.
  *
  * `copied` and `error` are transient: the timer that clears them belongs to one
- * connection, so a fresh `connect()` that finds either — a restored snapshot, an
- * in-page move — returns to `idle`, and the state is rewound before Turbo caches
- * the page (`BeforeCacheReset`). The rewind is silent: it discards nothing a
- * reconnect does not derive again.
+ * connection, so a fresh `connect()` that finds either — a page Turbo restores from its
+ * cache, an in-page move — returns to `idle`, silently. `turbo:before-cache` changes
+ * nothing: Turbo also dispatches it on pages that stay (a promoted frame navigation, a
+ * `popstate` without Turbo state, a refresh of a cached URL), where the result is still
+ * on screen and its return to idle still due. Returning to `idle` empties only a slot that
+ * still shows the wording a copy wrote there; a slot the page swapped in, rewrote, or put
+ * an element into keeps what it holds.
+ *
+ * A `copiedLabel` / `errorLabel` changed on the live element while its result is
+ * shown rewrites the slot — only while the slot still reads the label the copy wrote
+ * — without announcing, dispatching or moving the return to idle. Stimulus reports no
+ * change when a label attribute whose value was empty is removed, so the slot keeps
+ * the empty label until the next copy. `feedbackDuration` and the announcement texts
+ * belong to one copy, so a change to them applies from the next.
  */
 declare class ClipboardController extends Controller<HTMLElement> {
     #private;
@@ -77,11 +87,19 @@ declare class ClipboardController extends Controller<HTMLElement> {
             default: string;
         };
     };
+    static valueConstraints: {
+        feedbackDuration: {
+            readonly finite: true;
+            readonly min: 0;
+            readonly max: 2147483647;
+        };
+    };
     static actions: readonly ["copy"];
     static events: readonly ["copy"];
     readonly sourceTarget: HTMLElement;
     readonly buttonTarget: HTMLElement;
     readonly feedbackTarget: HTMLElement;
+    readonly feedbackTargets: HTMLElement[];
     readonly hasSourceTarget: boolean;
     readonly hasButtonTarget: boolean;
     readonly hasFeedbackTarget: boolean;
@@ -93,10 +111,29 @@ declare class ClipboardController extends Controller<HTMLElement> {
     announceErrorTextValue: string;
     connect(): void;
     disconnect(): void;
+    /**
+     * Follows a `copiedLabel` swapped in place while a successful copy is shown.
+     *
+     * Render only: nothing is announced or dispatched, and the return to idle keeps the
+     * deadline the copy set. The slot changes only while `data-state` is `copied` and it
+     * still reads the previous label — the one the copy wrote there — so text someone
+     * else put in the slot stays. Stimulus also runs this ahead of `connect()`, which
+     * settles a result restored with the markup itself, so nothing is written then.
+     */
+    copiedLabelValueChanged(label: string, previous: string | undefined): void;
+    /**
+     * Follows an `errorLabel` swapped in place while a failed copy is shown, on the same
+     * terms as {@link ClipboardController.copiedLabelValueChanged}: only while
+     * `data-state` is `error` and the slot still reads the previous label.
+     */
+    errorLabelValueChanged(label: string, previous: string | undefined): void;
     /**
      * Copies the resolved text and reports the outcome. Bound via `data-action`
-     * (click). Dispatches `stimeo--clipboard:copy` with `{ success, text }` once per
-     * completed attempt — including on failure — so consumers can react either way.
+     * (click). Dispatches `stimeo--clipboard:copy` with `{ success, text, message }`
+     * once per completed attempt — including on failure — so consumers can react
+     * either way. `message` is the authored label for that outcome, so a part that
+     * shows wording — `stimeo--clipboard:copy->stimeo--toast#show` — needs nothing
+     * else; wiring both that and the announcer reads the same result twice.
      * An attempt whose connection ended while it was in flight reports nothing.
      */
     copy(): Promise<void>;

package/dist/controllers/clipboard_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/clipboard_controller.ts
-
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -13,79 +10,140 @@ 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;
+function setDefaultAttribute(element, name, value) {
+  if (element.hasAttribute(name)) return false;
+  element.setAttribute(name, value);
+  return true;
+}
+
+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;
   }
-  /** 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);
-    }
+    this.#active = true;
+  }
+  cancel() {
+    this.#active = false;
+    this.#queued = false;
+    this.#generation += 1;
   }
-  /** 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);
+  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();
+    });
   }
 };
 
-// src/utils/default_attribute.ts
-function setDefaultAttribute(element, name, value) {
-  if (element.hasAttribute(name)) return false;
-  element.setAttribute(name, value);
+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 = {
+  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;
 }
 
-// src/utils/safe_timeout.ts
+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);
@@ -102,9 +160,9 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/controllers/clipboard_controller.ts
 var TRANSIENT_STATES = /* @__PURE__ */ new Set(["copied", "error"]);
-var ClipboardController = class extends Controller {
+var ClipboardController = class _ClipboardController extends Controller {
+  #numbers = new NumberValueReader();
   static targets = ["source", "button", "feedback"];
   static values = {
     text: { type: String, default: "" },
@@ -114,38 +172,39 @@ var ClipboardController = class extends Controller {
     announceCopiedText: { type: String, default: "" },
     announceErrorText: { type: String, default: "" }
   };
+  static valueConstraints = {
+    feedbackDuration: NUMBER_BOUNDS.timer
+  };
   static actions = ["copy"];
   static events = ["copy"];
-  /**
-   * The pending return to idle — the only timer this controller schedules, so
-   * `clearAll()` is exactly "drop the auto-clear" and needs no id of its own.
-   */
   #timers = new SafeTimeout();
-  /** Returns the completion state to idle for the snapshot Turbo takes. */
-  #beforeCache = new BeforeCacheReset(() => this.#rewind());
-  /**
-   * Whether this connection is still live. `copy()` suspends on the Clipboard API,
-   * and a teardown that lands while it is suspended must win: the continuation
-   * would otherwise write to an element nobody owns and arm a timer past the
-   * `clearAll()` that was supposed to be the last word.
-   */
   #connected = false;
+  #result = null;
+  #feedback = null;
+  #written = /* @__PURE__ */ new Map();
+  #morphRender = new MorphRenderWatcher(() => this.#renderResult());
   connect() {
     this.#connected = true;
     this.#adopt();
-    this.#beforeCache.activate();
+    this.#result = null;
+    this.#feedback = this.hasFeedbackTarget ? {
+      element: this.feedbackTarget,
+      original: this.feedbackTarget.textContent ?? "",
+      text: this.feedbackTarget.textContent ?? ""
+    } : null;
+    this.#morphRender.observe(this.element);
   }
   disconnect() {
     this.#connected = false;
-    this.#beforeCache.deactivate();
+    this.#morphRender.disconnect();
     this.#timers.clearAll();
   }
-  /**
-   * Copies the resolved text and reports the outcome. Bound via `data-action`
-   * (click). Dispatches `stimeo--clipboard:copy` with `{ success, text }` once per
-   * completed attempt — including on failure — so consumers can react either way.
-   * An attempt whose connection ended while it was in flight reports nothing.
-   */
+  copiedLabelValueChanged(label, previous) {
+    this.#followLabel("copied", label, previous);
+  }
+  errorLabelValueChanged(label, previous) {
+    this.#followLabel("error", label, previous);
+  }
   async copy() {
     const text = this.#resolveText();
     let success = false;
@@ -157,12 +216,9 @@ var ClipboardController = class extends Controller {
     }
     if (!this.#connected) return;
     this.#reportResult(success);
-    this.dispatch("copy", { detail: { success, text } });
+    const message = success ? this.copiedLabelValue : this.errorLabelValue;
+    this.dispatch("copy", { detail: { success, text, message } });
   }
-  /**
-   * The text to copy: the explicit `text` value when set, otherwise the source
-   * target's current value (inputs/textareas) or text content.
-   */
   #resolveText() {
     if (this.textValue.length > 0) return this.textValue;
     if (!this.hasSourceTarget) return "";
@@ -172,60 +228,83 @@ var ClipboardController = class extends Controller {
     }
     return source.textContent ?? "";
   }
-  /**
-   * Reads the current state back from the DOM.
-   *
-   * A `copied` or `error` found at connect time is this controller's own output
-   * from a connection that is gone, and so is the timer that would have cleared it
-   * — nothing else would ever return the element to `idle`. Any other authored
-   * value belongs to the consumer and only a missing attribute takes the default.
-   */
   #adopt() {
     if (this.#inTransientState()) {
+      const restored = this.#written.size === 0;
       this.#reset();
+      if (restored && this.hasFeedbackTarget) this.feedbackTarget.textContent = "";
       return;
     }
     setDefaultAttribute(this.element, "data-state", "idle");
   }
-  /** Whether `data-state` currently holds one of the values this controller writes. */
   #inTransientState() {
     const state = this.element.getAttribute("data-state");
     return state !== null && TRANSIENT_STATES.has(state);
   }
-  /**
-   * Returns the completion state to idle for the snapshot Turbo is about to take,
-   * so a page reached with the Back button does not report a copy that happened
-   * before the navigation. Only a state this controller wrote is rewound — an
-   * authored one is the consumer's and has to survive into the snapshot, exactly as
-   * `connect()` leaves it alone. State only — no `copy` is dispatched, which would
-   * claim a fresh copy ran.
-   */
-  #rewind() {
-    if (!this.#inTransientState()) return;
-    this.#timers.clearAll();
-    this.#reset();
-  }
-  /** Reflects the result, announces it, and schedules the return to idle. */
   #reportResult(success) {
-    this.element.setAttribute("data-state", success ? "copied" : "error");
-    if (this.hasFeedbackTarget) {
-      this.feedbackTarget.textContent = success ? this.copiedLabelValue : this.errorLabelValue;
+    this.#result = success;
+    this.#renderResult(true);
+    this.#announceResult(success);
+    this.#scheduleReset();
+  }
+  #renderResult(force = false) {
+    if (this.#result === null) {
+      setDefaultAttribute(this.element, "data-state", "idle");
+      return;
     }
+    this.element.setAttribute("data-state", this.#result ? "copied" : "error");
+    if (!this.hasFeedbackTarget) return;
+    const element = this.feedbackTarget;
+    const held = this.#feedback;
+    if (!force && (!held || element !== held.element || element.firstElementChild !== null || element.textContent !== held.text && element.textContent !== held.original))
+      return;
+    const text = this.#result ? this.copiedLabelValue : this.errorLabelValue;
+    this.#feedback = {
+      element,
+      original: held?.element === element ? held.original : element.textContent ?? "",
+      text
+    };
+    element.textContent = text;
+    this.#written.set(element, text);
+  }
+  #announceResult(success) {
     announce(success ? this.announceCopiedTextValue : this.announceErrorTextValue);
+  }
+  #scheduleReset() {
     this.#timers.clearAll();
-    if (this.feedbackDurationValue > 0) {
-      this.#timers.set(() => this.#reset(), this.feedbackDurationValue);
+    if (this.#safeFeedbackDuration > 0) {
+      this.#timers.set(() => this.#reset(), this.#safeFeedbackDuration);
     }
   }
-  /** Returns to the idle state and empties the completion slot. */
+  #followLabel(state, label, previous) {
+    if (!this.#connected) return;
+    if (this.element.getAttribute("data-state") !== state || !this.hasFeedbackTarget) return;
+    if (this.feedbackTarget.textContent !== previous) return;
+    this.feedbackTarget.textContent = label;
+    this.#written.set(this.feedbackTarget, label);
+    if (this.#feedback?.element === this.feedbackTarget) this.#feedback.text = label;
+  }
   #reset() {
+    this.#result = null;
     this.element.setAttribute("data-state", "idle");
-    if (this.hasFeedbackTarget) {
-      this.feedbackTarget.textContent = "";
+    for (const [element, text] of this.#written) {
+      if (!this.feedbackTargets.includes(element)) continue;
+      if (element.firstElementChild === null && element.textContent === text) {
+        element.textContent = "";
+      }
     }
+    this.#written.clear();
+  }
+  get #safeFeedbackDuration() {
+    return this.#numbers.read(
+      this,
+      "feedbackDuration",
+      this.feedbackDurationValue,
+      _ClipboardController.values.feedbackDuration.default,
+      _ClipboardController.valueConstraints.feedbackDuration
+    );
   }
 };
 
 export { ClipboardController };
-//# sourceMappingURL=clipboard_controller.js.map
 //# sourceMappingURL=clipboard_controller.js.map