stimeo-ui 0.5.0 → 0.7.0

data/dist/controllers/checkbox_controller.js

@@ -1,17 +1,89 @@
 import { Controller } from '@hotwired/stimulus';
 
+// src/controllers/checkbox_controller.ts
+
+// 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. */
+  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/controllers/checkbox_controller.ts
 var CheckboxController = class extends Controller {
   static targets = ["parent", "child"];
   static actions = ["onChildChange", "onParentChange"];
-  static events = ["change"];
-  /** Reflects the initial aggregate (e.g. from server-rendered child states). */
-  connect() {
-    if (this.childTargets.length > 0) {
-      this.#syncFromChildren(false);
-    } else {
-      this.element.setAttribute("data-state", this.#aggregate());
+  static events = ["change", "reconcile"];
+  /** Collapses every lifecycle signal from one DOM update into one derived pass. */
+  #reconcile = new MicrotaskCoalescer(() => this.#reconcileFromChildren());
+  /** 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.#checkedObserver.observe(this.element, {
+      attributes: true,
+      attributeFilter: ["checked"],
+      subtree: true
+    });
+    this.element.addEventListener("turbo:morph-element", this.#onMorph);
+    document.addEventListener("reset", this.#onReset, true);
+  }
+  /** Releases the observer, global reset listener, and every pending reconciliation. */
+  disconnect() {
+    this.#reconcile.cancel();
+    this.#checkedObserver.disconnect();
+    this.element.removeEventListener("turbo:morph-element", this.#onMorph);
+    document.removeEventListener("reset", this.#onReset, true);
+  }
+  /** 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() {
@@ -20,35 +92,74 @@ var CheckboxController = class extends Controller {
     for (const child of this.childTargets) {
       child.checked = checked;
     }
-    this.parentTarget.indeterminate = false;
-    const state = checked ? "all" : "none";
-    this.element.setAttribute("data-state", state);
-    this.dispatch("change", { detail: { checked, indeterminate: false, state } });
+    this.#reflect(checked ? "all" : "none", true);
+    const detail = this.#settledDetail();
+    if (detail) this.dispatch("change", { detail });
   }
   /** Recomputes the parent from its children. Bound via `data-action` (change). */
   onChildChange() {
-    this.#syncFromChildren(true);
+    this.#syncFromChildren();
+    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();
+    if (this.#committedState === previous) return;
+    const detail = this.#settledDetail();
+    if (detail) this.dispatch("reconcile", { detail });
   }
   /**
    * Derives the parent's `checked`/`indeterminate` and the root `data-state` from
-   * the children, optionally dispatching `change`.
+   * 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(dispatch) {
-    const state = this.#aggregate();
-    if (this.hasParentTarget) {
+  #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";
       this.parentTarget.indeterminate = state === "partial";
     }
     this.element.setAttribute("data-state", state);
-    if (dispatch) {
-      this.dispatch("change", {
-        detail: {
-          checked: this.hasParentTarget ? this.parentTarget.checked : state === "all",
-          indeterminate: this.hasParentTarget ? this.parentTarget.indeterminate : false,
-          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();
+  };
+  /** Reconciles after a non-cancelled reset restores any managed checkbox. */
+  #onReset = (event) => {
+    const form = event.target;
+    if (!(form instanceof HTMLFormElement) || !this.#hasCheckboxOwnedBy(form)) return;
+    queueMicrotask(() => {
+      if (!event.defaultPrevented) 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

data/dist/controllers/color_picker_controller.js

@@ -74,7 +74,7 @@ var ColorPickerController = class extends Controller {
     logicalTrack: { type: Boolean, default: false }
   };
   static actions = ["onHexInput", "onKeydown", "onPointerDown"];
-  static events = ["change"];
+  static events = ["change", "reconcile"];
   /** Whether the consumer declared a mirroring track and the direction mirrors it. */
   get #mirrored() {
     return this.logicalTrackValue && isRtl(this.element);
@@ -83,14 +83,14 @@ var ColorPickerController = class extends Controller {
   #color = { hue: 0, saturation: 0, lightness: 0, alpha: 100 };
   /** Aborts in-progress pointer-drag listeners on drag end / teardown. */
   #dragAbort = null;
-  /** Seeds the model from the initial hex value and renders every surface. */
+  /** Color the last repaint settled on, so a configuration-driven move is reported once. */
+  #committedHex = null;
   /**
    * Collapses a morph that swaps render inputs into one repaint, and refuses the
    * pass Stimulus delivers before `connect()`.
    */
-  #repaint = new MicrotaskCoalescer(() => {
-    this.#render();
-  });
+  #repaint = new MicrotaskCoalescer(() => this.#reconcileColor());
+  /** Seeds the model from the initial hex value and renders every surface. */
   connect() {
     this.#repaint.activate();
     const parsed = hexToHsla(this.valueValue);
@@ -181,12 +181,24 @@ var ColorPickerController = class extends Controller {
       return;
     }
     this.#color = this.alphaValue ? parsed : { ...parsed, alpha: 100 };
-    this.#render();
+    this.#commitColor();
   }
   /** Clamps and snaps one channel to an integer, then re-renders + emits change. */
   #setChannel(channel, raw, min, max) {
     this.#color[channel] = Math.round(Math.min(max, Math.max(min, raw)));
+    this.#commitColor();
+  }
+  /**
+   * Renders the model and reports a color the user actually moved. A key pressed
+   * at a bound, a pointer that lands on the step already showing, and a re-confirmed
+   * hex all leave the committed color where it was, so no `change` describes them.
+   */
+  #commitColor() {
+    const previous = this.#committedHex;
     this.#render();
+    if (this.#committedHex !== previous) {
+      this.dispatch("change", { detail: this.#settledDetail() });
+    }
   }
   /**
    * Reflects the model onto sliders, the hex input, preview, and form field.
@@ -202,14 +214,28 @@ var ColorPickerController = class extends Controller {
       slider.setAttribute("aria-valuetext", valueText(channel, value));
     }
     const hex = this.#hexString();
+    this.#committedHex = hex;
     if (this.hasHexTarget) this.hexTarget.value = hex;
     for (const field of this.fieldTargets) field.value = hex;
     for (const preview of this.previewTargets) preview.style.setProperty(COLOR_PROPERTY, hex);
     this.element.style.setProperty(COLOR_PROPERTY, hex);
+  }
+  /**
+   * Repaints after `alpha` changed at runtime and reports a color this controller
+   * settled on. Disabling alpha drops it from the model, so the committed color can
+   * move without a user edit; `change` stays reserved for the picker's own actions.
+   */
+  #reconcileColor() {
+    const previous = this.#committedHex;
+    this.#render();
+    if (previous !== null && this.#committedHex !== previous) {
+      this.dispatch("reconcile", { detail: this.#settledDetail() });
+    }
+  }
+  /** The settled color as event detail, shared by both report paths. */
+  #settledDetail() {
     const rgb = hslToRgb(this.#color.hue, this.#color.saturation, this.#color.lightness);
-    this.dispatch("change", {
-      detail: { value: hex, rgba: { ...rgb, a: this.#color.alpha / 100 } }
-    });
+    return { value: this.#hexString(), rgba: { ...rgb, a: this.#color.alpha / 100 } };
   }
   /** The current color as `#RRGGBB`, or `#RRGGBBAA` when alpha is enabled. */
   #hexString() {

data/dist/controllers/command_palette_controller.js

@@ -180,8 +180,81 @@ var EscapeLayer = class _EscapeLayer {
   }
 };
 
+// src/utils/focus_candidate.ts
+function inheritsFieldsetDisabled(control) {
+  let fieldset = control.closest("fieldset[disabled]");
+  while (fieldset) {
+    const legend = Array.from(fieldset.children).find((child) => child.tagName === "LEGEND");
+    if (!legend?.contains(control)) return true;
+    fieldset = fieldset.parentElement?.closest("fieldset[disabled]") ?? null;
+  }
+  return false;
+}
+function canTakeFocus(element) {
+  if (element.closest("[hidden], [inert]")) return false;
+  if (element instanceof HTMLInputElement && element.type === "hidden") return false;
+  if (!("disabled" in element)) return true;
+  if (element.disabled) return false;
+  return !inheritsFieldsetDisabled(element);
+}
+var TAB_STOP_CANDIDATE_SELECTOR = [
+  "a[href]",
+  "area[href]",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "summary",
+  "iframe",
+  "audio[controls]",
+  "video[controls]",
+  "[tabindex]",
+  "[contenteditable]"
+].join(",");
+function isRenderedForFocus(element) {
+  const check = element.checkVisibility;
+  return typeof check === "function" ? check.call(element, { visibilityProperty: true }) : true;
+}
+function authoredTabindex(element) {
+  const value = element.getAttribute("tabindex");
+  if (value === null || !/^[+-]?\d+$/.test(value.trim())) return null;
+  return Number(value);
+}
+function hasNativeTabStop(element) {
+  if (element instanceof HTMLAnchorElement || element instanceof HTMLAreaElement) {
+    return element.hasAttribute("href");
+  }
+  if (element instanceof HTMLButtonElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement) {
+    return true;
+  }
+  if (element instanceof HTMLInputElement) return element.type !== "hidden";
+  if (element instanceof HTMLIFrameElement) return true;
+  if (element.tagName === "AUDIO" || element.tagName === "VIDEO") {
+    return element.hasAttribute("controls");
+  }
+  if (element instanceof HTMLElement && element.tagName === "SUMMARY") {
+    const details = element.parentElement;
+    return details instanceof HTMLDetailsElement && Array.from(details.children).find((child) => child.tagName === "SUMMARY") === element;
+  }
+  return false;
+}
+function hasEditableTabStop(element) {
+  const value = element.getAttribute("contenteditable")?.toLowerCase();
+  return value === "" || value === "true" || value === "plaintext-only";
+}
+function isTabStop(element) {
+  if (!canTakeFocus(element) || !isRenderedForFocus(element)) return false;
+  const tabindex = authoredTabindex(element);
+  if (tabindex !== null) return tabindex >= 0;
+  return hasNativeTabStop(element) || hasEditableTabStop(element);
+}
+function tabStopsWithin(root) {
+  return Array.from(root.querySelectorAll(TAB_STOP_CANDIDATE_SELECTOR)).filter(
+    isTabStop
+  );
+}
+
 // src/utils/focus_trap.ts
-var FOCUSABLE = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
 var FocusTrap = class {
   /** The element focused before activation, restored on deactivation. */
   #previouslyFocused = null;
@@ -343,9 +416,7 @@ var FocusTrap = class {
   }
   /** Collects the container's currently focusable descendants in DOM order. */
   #focusableElements() {
-    return Array.from(this.#getContainer().querySelectorAll(FOCUSABLE)).filter(
-      (el) => !el.hidden
-    );
+    return tabStopsWithin(this.#getContainer());
   }
 };