stimeo-ui 0.16.0 → 0.18.0

data/dist/controllers/checkbox_controller.js

@@ -1,26 +1,17 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/checkbox_controller.ts
-
-// src/utils/form_reset_watcher.ts
 var FormResetWatcher = class {
   #owns;
   #onReset;
   #frames = /* @__PURE__ */ new Set();
   #generation = 0;
-  /**
-   * @param owns - whether `form` owns a control this controller derives from.
-   * @param onReset - the reconciliation pass, run once per honoured reset.
-   */
   constructor(owns, onReset) {
     this.#owns = owns;
     this.#onReset = onReset;
   }
-  /** Subscribes to `reset` at the document; call from `connect()`. Idempotent. */
   observe() {
     document.addEventListener("reset", this.#handleReset, true);
   }
-  /** Unsubscribes and drops every pending pass; call from `disconnect()`. */
   disconnect() {
     document.removeEventListener("reset", this.#handleReset, true);
     this.#generation += 1;
@@ -44,57 +35,41 @@ var FormResetWatcher = class {
       this.#frames.add(frame);
     });
   };
-  /** Runs the pass unless a listener cancelled the reset before it landed. */
   #settle(event) {
     if (!event.defaultPrevented) this.#onReset();
   }
 };
 
-// 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 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;
@@ -107,82 +82,95 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/controllers/checkbox_controller.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 CheckboxController = class extends Controller {
   static targets = ["parent", "child"];
   static actions = ["onChildChange", "onParentChange"];
   static events = ["change", "reconcile"];
-  /** Collapses every lifecycle signal from one DOM update into one derived pass. */
-  #reconcile = new MicrotaskCoalescer(() => this.#reconcileFromChildren());
-  #listeners = new ListenerSet();
+  #reconcile = new MorphRenderWatcher(() => this.#reconcileFromChildren());
   #formReset = new FormResetWatcher(
     (form) => this.#hasCheckboxOwnedBy(form),
     () => this.#reconcile.schedule()
   );
-  /** Aggregate this root last settled on, so a derived repair is reported once. */
   #committedState = null;
-  /** Watches authored checked-attribute changes on retained target elements. */
   #checkedObserver = new MutationObserver((records) => {
     if (records.some((record) => this.#isManagedCheckbox(record.target))) {
       this.#reconcile.schedule();
     }
   });
-  /** Reflects the initial aggregate and starts retained-DOM reconciliation. */
   connect() {
-    this.#reconcile.activate();
     this.#syncFromChildren();
+    this.#reconcile.observe(this.element);
     this.#checkedObserver.observe(this.element, {
       attributes: true,
       attributeFilter: ["checked"],
       subtree: true
     });
-    this.#listeners.add(this.element, "turbo:morph-element", this.#onMorph);
     this.#formReset.observe();
   }
-  /** Releases the observer, global reset listener, and every pending reconciliation. */
   disconnect() {
-    this.#reconcile.cancel();
+    this.#reconcile.disconnect();
     this.#checkedObserver.disconnect();
-    this.#listeners.dispose();
     this.#formReset.disconnect();
   }
-  /** Reconciles the aggregate for a parent added or replaced at runtime. */
   parentTargetConnected() {
     this.#reconcile.schedule();
   }
-  /** Reconciles the aggregate after a parent target leaves the group. */
   parentTargetDisconnected() {
     this.#reconcile.schedule();
   }
-  /** Reconciles the aggregate for a child added at runtime. */
   childTargetConnected() {
     this.#reconcile.schedule();
   }
-  /** Reconciles the aggregate after a child leaves the group. */
   childTargetDisconnected() {
     this.#reconcile.schedule();
   }
-  /** Cascades the parent's state to every child. Bound via `data-action` (change). */
   onParentChange() {
     if (!this.hasParentTarget) return;
+    const previous = this.#committedState;
     const checked = this.parentTarget.checked;
     for (const child of this.childTargets) {
       child.checked = checked;
     }
     this.#reflect(checked ? "all" : "none", true);
+    if (this.#committedState === previous) return;
     const detail = this.#settledDetail();
     if (detail) this.dispatch("change", { detail });
   }
-  /** Recomputes the parent from its children. Bound via `data-action` (change). */
   onChildChange() {
+    const previous = this.#committedState;
     this.#syncFromChildren();
+    if (this.#committedState === previous) return;
     const detail = this.#settledDetail();
     if (detail) this.dispatch("change", { detail });
   }
-  /**
-   * Announces an aggregate this pass derived rather than the user. `change` stays
-   * reserved for the two public actions, so automation never reads a repair as an edit.
-   */
   #reconcileFromChildren() {
     const previous = this.#committedState;
     this.#syncFromChildren();
@@ -190,20 +178,9 @@ var CheckboxController = class extends Controller {
     const detail = this.#settledDetail();
     if (detail) this.dispatch("reconcile", { detail });
   }
-  /**
-   * Derives the parent's `checked`/`indeterminate` and the root `data-state` from
-   * the children. Writing state and reporting it are separate so the caller — not
-   * a flag threaded through the write — decides which event describes the cause.
-   */
   #syncFromChildren() {
     this.#reflect(this.#aggregate(), this.childTargets.length > 0);
   }
-  /**
-   * Reflects one aggregate state.
-   *
-   * @param writeParent - whether the state is authoritative over the `parent`
-   * target's own `checked` / `indeterminate`.
-   */
   #reflect(state, writeParent) {
     if (writeParent && this.hasParentTarget) {
       this.parentTarget.checked = state === "all";
@@ -212,29 +189,17 @@ var CheckboxController = class extends Controller {
     this.element.setAttribute("data-state", state);
     this.#committedState = state;
   }
-  /** The settled aggregate as event detail, or `null` before anything has settled. */
   #settledDetail() {
     const state = this.#committedState;
     if (state === null) return null;
     return { checked: state === "all", indeterminate: state === "partial", state };
   }
-  /** Reconciles retained targets after Turbo has finished morphing their live state. */
-  #onMorph = () => {
-    this.#reconcile.schedule();
-  };
-  /** Whether a form owns at least one current parent or child target. */
   #hasCheckboxOwnedBy(form) {
     return [...this.parentTargets, ...this.childTargets].some((checkbox) => checkbox.form === form);
   }
-  /** Whether an observed attribute mutation belongs to this controller's target set. */
   #isManagedCheckbox(node) {
     return this.parentTargets.some((checkbox) => checkbox === node) || this.childTargets.some((checkbox) => checkbox === node);
   }
-  /**
-   * Computes the aggregate state. With children it counts them; with none it
-   * reads the parent so a lone tri-state checkbox still reports a state without
-   * its externally-set `indeterminate` being clobbered.
-   */
   #aggregate() {
     const children = this.childTargets;
     if (children.length === 0) {
@@ -249,5 +214,4 @@ var CheckboxController = class extends Controller {
 };
 
 export { CheckboxController };
-//# sourceMappingURL=checkbox_controller.js.map
 //# sourceMappingURL=checkbox_controller.js.map