stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/conditional_fields_controller.js

@@ -1,14 +1,108 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/conditional_fields_controller.ts
+function setAttributeIfChanged(element, name, value, beforeWrite) {
+  if (element.getAttribute(name) === value) return false;
+  beforeWrite?.();
+  if (value === null) element.removeAttribute(name);
+  else element.setAttribute(name, value);
+  return true;
+}
+
+var AuthoredMutationWatcher = class {
+  #onAuthored;
+  #claims = null;
+  #observer = null;
+  constructor(onAuthored) {
+    this.#onAuthored = onAuthored;
+  }
+  observe(root, options) {
+    this.disconnect();
+    const observer = new MutationObserver((records) => {
+      if (this.#observer !== observer) return;
+      const authored = this.#filter(records);
+      if (authored.length > 0) this.#onAuthored(authored);
+    });
+    this.#observer = observer;
+    this.#claims = { attributes: /* @__PURE__ */ new Map(), children: /* @__PURE__ */ new Map() };
+    observer.observe(root, {
+      attributes: true,
+      attributeFilter: [...options.attributes],
+      subtree: options.subtree ?? false,
+      childList: options.childList ?? false
+    });
+    if (options.ancestorAttributes) {
+      let ancestor = root.parentElement;
+      while (ancestor) {
+        observer.observe(ancestor, {
+          attributes: true,
+          attributeFilter: [...options.ancestorAttributes]
+        });
+        ancestor = ancestor.parentElement;
+      }
+    }
+  }
+  claim(target, name, value) {
+    const claims = this.#claims?.attributes;
+    let attributes = claims?.get(target);
+    if (!attributes) {
+      attributes = /* @__PURE__ */ new Map();
+      claims?.set(target, attributes);
+    }
+    const pending = attributes.get(name);
+    attributes.set(name, { value, count: (pending?.count ?? 0) + 1 });
+  }
+  claimCurrent(target, name) {
+    this.claim(target, name, target.getAttribute(name));
+  }
+  claimChildList(target, added, removed) {
+    const claims = this.#claims?.children;
+    const pending = claims?.get(target) ?? { added: /* @__PURE__ */ new Map(), removed: /* @__PURE__ */ new Map() };
+    for (const node of added) pending.added.set(node, (pending.added.get(node) ?? 0) + 1);
+    for (const node of removed) pending.removed.set(node, (pending.removed.get(node) ?? 0) + 1);
+    claims?.set(target, pending);
+  }
+  take() {
+    return this.#filter(this.#observer?.takeRecords() ?? []);
+  }
+  disconnect() {
+    this.#observer?.disconnect();
+    this.#observer = null;
+    this.#claims = null;
+  }
+  #filter(records) {
+    const authored = records.filter((record) => !this.#consume(record));
+    this.#claims?.attributes.clear();
+    this.#claims?.children.clear();
+    return authored;
+  }
+  #consume(record) {
+    if (record.type === "attributes") {
+      const target = record.target;
+      const pending2 = this.#claims?.attributes.get(target)?.get(record.attributeName);
+      if (!pending2 || pending2.count === 0 || target.getAttribute(record.attributeName) !== pending2.value) {
+        return false;
+      }
+      pending2.count -= 1;
+      return true;
+    }
+    const pending = this.#claims?.children.get(record.target);
+    if (!pending) return false;
+    const added = [...record.addedNodes];
+    const removed = [...record.removedNodes];
+    if (added.some((node) => !pending.added.get(node)) || removed.some((node) => !pending.removed.get(node))) {
+      return false;
+    }
+    for (const node of added) pending.added.set(node, (pending.added.get(node) ?? 0) - 1);
+    for (const node of removed) pending.removed.set(node, (pending.removed.get(node) ?? 0) - 1);
+    return true;
+  }
+};
 
-// src/utils/event_owner.ts
 function ownerIndex(candidates, node) {
   if (!(node instanceof Node)) return -1;
   return candidates.findIndex((candidate) => candidate.contains(node));
 }
 
-// src/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
   while (fieldset) {
@@ -18,33 +112,42 @@ function inheritsFieldsetDisabled(control) {
   }
   return false;
 }
+function unslotted(element) {
+  return element.assignedSlot === null && element.parentElement?.shadowRoot != null;
+}
+function flatTreeParent(element) {
+  if (unslotted(element)) return null;
+  const parent = element.assignedSlot ?? element.parentNode;
+  if (parent instanceof ShadowRoot) return parent.host;
+  return parent instanceof Element ? parent : null;
+}
 function canTakeFocus(element) {
-  if (element.closest("[hidden], [inert]")) return false;
+  for (let node = element; node; node = flatTreeParent(node)) {
+    if (unslotted(node) || node.matches("[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);
 }
+function deepActiveElement(ownerDocument) {
+  let active = ownerDocument.activeElement;
+  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+  return active;
+}
 
-// 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;
@@ -68,57 +171,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;
@@ -131,68 +218,166 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// 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;
+var MorphRenderWatcher = class {
+  #listeners = new ListenerSet();
+  #pass;
+  #element = null;
+  #onMorph = () => this.#pass.schedule();
+  constructor(run) {
+    this.#pass = new MicrotaskCoalescer(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);
-    }
+  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;
   }
-  /** 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);
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
   }
 };
 
-// src/utils/tabindex_loan.ts
-var TabindexLoan = class {
+function queryOpenDescendants(root, selector) {
+  const matches = [];
+  const roots = [root];
+  for (const scope of roots) {
+    matches.push(...scope.querySelectorAll(selector));
+    if (scope.nodeType === Node.ELEMENT_NODE) {
+      const shadow = scope.shadowRoot;
+      if (shadow) roots.push(shadow);
+    }
+    for (const element of scope.querySelectorAll("*")) {
+      if (element.shadowRoot) roots.push(element.shadowRoot);
+    }
+  }
+  return matches;
+}
+
+function sharedRegistry(key, create) {
+  const symbol = Symbol.for(key);
+  const scope = globalThis;
+  const existing = scope[symbol];
+  if (existing !== void 0) return existing;
+  const registry = create();
+  Object.defineProperty(globalThis, symbol, { value: registry });
+  return registry;
+}
+
+function holdsFocus(element) {
+  return element.matches(":focus") || deepActiveElement(element.ownerDocument) === element;
+}
+var TabindexLoan = class _TabindexLoan {
+  static #registry = sharedRegistry(
+    "stimeo-ui.tabindex-loan.registry.v1",
+    () => ({ stacks: /* @__PURE__ */ new WeakMap(), names: /* @__PURE__ */ new Set() })
+  );
   #value;
+  #record;
+  #preserveFocus;
   #lent = /* @__PURE__ */ new Set();
-  /** Returns live loans before Turbo can copy them into its page snapshot. */
-  #beforeCache = new BeforeCacheReset(() => this.returnAll());
-  /**
-   * @param value - the `tabindex` to lend. `"-1"` (the default) is
-   *   programmatically focusable but not a Tab stop; `"0"` is a real Tab stop,
-   *   which a scroll region with no focusable content of its own needs.
-   */
-  constructor(value = "-1") {
+  constructor(value, owner, options = {}) {
     this.#value = value;
-  }
-  /** Lends `element` the value; no-ops when it already carries a `tabindex`. */
-  lend(element) {
-    if (element.hasAttribute("tabindex")) return;
-    element.setAttribute("tabindex", this.#value);
+    this.#record = `data-${owner}-tabindex-loan`;
+    this.#preserveFocus = options.preserveFocus === true;
+    _TabindexLoan.#registry.names.add(this.#record);
+  }
+  lend(element, options = {}) {
+    const stack = this.#stack(element);
+    const current = element.getAttribute("tabindex");
+    const held = stack.find((hold) => hold.loan === this) ?? stack.find(
+      (hold) => hold.loan === null && hold.record === this.#record && hold.value === this.#value
+    );
+    const linked = stack.at(-1)?.value === current;
+    if (!held && options.onlyIfUnfocusable && (current !== null || element.tabIndex >= 0)) return;
+    if (!held && current !== null && !linked) return;
     this.#lent.add(element);
-    this.#beforeCache.activate();
+    if (held) held.loan = this;
+    else stack.push({ loan: this, record: this.#record, value: this.#value, linked });
+    this.#mark(element, stack);
+    if (current === null || !held && current !== this.#value) {
+      element.setAttribute("tabindex", this.#value);
+    }
+  }
+  return(element) {
+    const stack = this.#stack(element);
+    const hold = stack.find((held) => held.loan === this) ?? stack.find(
+      (held) => held.loan === null && held.record === this.#record && held.value === this.#value
+    );
+    if (!hold) return false;
+    if (!this.#release(element, stack, hold, this.#preserveFocus)) {
+      hold.loan = this;
+      this.#lent.add(element);
+      return false;
+    }
+    this.#lent.delete(element);
+    return true;
   }
-  /** Takes back every loan whose value is still the one that was lent. */
   returnAll() {
-    for (const element of this.#lent) {
-      if (element.getAttribute("tabindex") === this.#value) element.removeAttribute("tabindex");
+    for (const element of Array.from(this.#lent)) this.return(element);
+  }
+  reclaim(element) {
+    if (element.getAttribute(this.#record) !== this.#value) return;
+    const stack = this.#stack(element);
+    const hold = stack.find((held) => held.loan === null && held.record === this.#record);
+    if (hold && !holdsFocus(element)) this.#release(element, stack, hold);
+  }
+  reclaimWithin(root) {
+    for (const element of queryOpenDescendants(root, `[${this.#record}]`)) {
+      this.reclaim(element);
+    }
+  }
+  #stack(element) {
+    const stacks = _TabindexLoan.#registry.stacks;
+    const stack = stacks.get(element) ?? this.#seed(element);
+    stacks.set(element, stack);
+    return stack;
+  }
+  #seed(element) {
+    const current = element.getAttribute("tabindex");
+    const holds = [];
+    for (const record of _TabindexLoan.#registry.names) {
+      const value = element.getAttribute(record);
+      if (value !== null) holds.push({ loan: null, record, value, linked: true });
+    }
+    holds.sort((one, other) => Number(one.value === current) - Number(other.value === current));
+    for (const [index, hold] of holds.entries()) hold.linked = index > 0;
+    return holds;
+  }
+  #release(element, stack, hold, preserveFocus = false) {
+    const current = element.getAttribute("tabindex");
+    const index = stack.indexOf(hold);
+    const owns = current === hold.value && !stack.slice(index + 1).some((above2) => above2.value === current);
+    if (owns && preserveFocus && holdsFocus(element)) return false;
+    stack.splice(index, 1);
+    const above = stack[index];
+    if (above) above.linked &&= hold.linked;
+    this.#mark(element, stack);
+    if (!owns) return true;
+    const below = hold.linked ? stack[index - 1] : void 0;
+    if (!below) element.removeAttribute("tabindex");
+    else if (below.value !== current) element.setAttribute("tabindex", below.value);
+    return true;
+  }
+  #mark(element, stack) {
+    const records = /* @__PURE__ */ new Map([[this.#record, null]]);
+    for (const hold of stack) records.set(hold.record, hold.value);
+    for (const [name, recorded] of records) {
+      setAttributeIfChanged(element, name, recorded);
     }
-    this.#lent.clear();
-    this.#beforeCache.deactivate();
   }
 };
 
-// src/controllers/conditional_fields_controller.ts
 var DISABLED_MARKER = "data-conditional-disabled";
+var CONTROLS = "input, textarea, select, button";
 var OBSERVED_ATTRIBUTES = [
   "hidden",
   "aria-hidden",
@@ -215,23 +400,17 @@ var ConditionalFieldsController = class extends Controller {
   };
   static actions = ["evaluate"];
   static events = ["change", "reconcile"];
-  /** Logical state last committed for each current region; rebuilt on every connect. */
   #lastVisible = /* @__PURE__ */ new WeakMap();
-  /** Controller writes awaiting an observer callback, separated from authored morphs. */
-  #internalWrites = /* @__PURE__ */ new WeakMap();
-  #observing = false;
-  /** Coalesces one target/morph/mutation batch into one full DOM reconciliation. */
-  #reconcile = new MicrotaskCoalescer(() => this.#reconcileDom());
+  #departed = /* @__PURE__ */ new Set();
+  #concealed = /* @__PURE__ */ new WeakSet();
+  #reconcile = new MorphRenderWatcher(() => this.#reconcileDom());
   #listeners = new ListenerSet();
   #formReset = new FormResetWatcher(
     (form) => this.#hasTriggerOwnedBy(form),
     () => this.#reconcile.schedule()
   );
-  /** Provides the last-resort focus landmark without claiming an authored tabindex. */
-  #rootTabindex = new TabindexLoan();
-  /** Watches retained targets and controls whose declarative or reflected state changed. */
-  #observer = new MutationObserver((records) => this.#onMutations(records));
-  /** Evaluates only events whose source is one of this instance's live trigger targets. */
+  #rootTabindex = new TabindexLoan("-1", this.identifier);
+  #observer = new AuthoredMutationWatcher((records) => this.#onMutations(records));
   #onTriggerInput = (event) => {
     const target = event.target;
     const triggers = this.triggerTargets;
@@ -239,75 +418,57 @@ var ConditionalFieldsController = class extends Controller {
       this.#commitChange(triggers);
     }
   };
-  /** Reconciles property-only retained-element changes after Turbo morphs. */
-  #onMorph = () => {
-    this.#reconcile.schedule();
-  };
-  /** Reflects initial live state and opens every retained-DOM reconciliation path. */
   connect() {
+    this.#rootTabindex.reclaim(this.element);
     this.#lastVisible = /* @__PURE__ */ new WeakMap();
-    this.#internalWrites = /* @__PURE__ */ new WeakMap();
-    this.#reconcile.activate();
     this.#settle();
+    this.#reconcile.observe(this.element);
     this.#observer.observe(this.element, {
-      attributes: true,
-      attributeFilter: OBSERVED_ATTRIBUTES,
+      attributes: OBSERVED_ATTRIBUTES,
       childList: true,
       subtree: true
     });
-    this.#observing = true;
     this.#listeners.add(this.element, "change", this.#onTriggerInput);
     this.#listeners.add(this.element, "input", this.#onTriggerInput);
-    this.#listeners.add(this.element, "turbo:morph-element", this.#onMorph);
     this.#formReset.observe();
   }
-  /** Releases all external resources and returns the temporary focus landmark loan. */
   disconnect() {
-    this.#reconcile.cancel();
-    this.#observing = false;
+    this.#reconcile.disconnect();
     this.#observer.disconnect();
     this.#listeners.dispose();
     this.#formReset.disconnect();
     this.#rootTabindex.returnAll();
   }
-  /** Reconciles after a trigger target is inserted or restored. */
   triggerTargetConnected() {
     this.#reconcile.schedule();
   }
-  /** Reconciles after a trigger target is removed or replaced. */
   triggerTargetDisconnected() {
     this.#reconcile.schedule();
   }
-  /** Initializes a region target inserted or restored at runtime. */
   regionTargetConnected() {
     this.#reconcile.schedule();
   }
-  /** Reconciles the remaining region set after a target leaves. */
-  regionTargetDisconnected() {
+  regionTargetDisconnected(region) {
+    this.#departed.add(region);
     this.#reconcile.schedule();
   }
-  /** Reconciles when application code or a morph changes the match policy. */
   matchValueChanged() {
     this.#reconcile.schedule();
   }
-  /** Reconciles control ownership when hidden controls become enabled or excluded. */
   disableHiddenValueChanged() {
     this.#reconcile.schedule();
   }
-  /** Re-evaluates every region and repairs all reflected DOM state. */
   evaluate() {
     this.#commitChange();
   }
-  /**
-   * Computes one settled plan, shows destinations before hiding sources, and then
-   * returns logical transitions in DOM order after every region is internally coherent.
-   *
-   * @stimeoRenderRoot
-   */
   #settle(triggers = this.triggerTargets) {
     const regions = this.regionTargets;
     const plan = /* @__PURE__ */ new Map();
     for (const region of regions) plan.set(region, this.#isVisible(region, triggers));
+    for (const departed of this.#departed) {
+      if (!plan.has(departed)) this.#release(departed, plan);
+    }
+    this.#departed.clear();
     const changed = /* @__PURE__ */ new Set();
     const applicationOrder = [
       ...regions.filter((region) => plan.get(region) === true),
@@ -321,19 +482,16 @@ var ConditionalFieldsController = class extends Controller {
     }
     return regions.filter((region) => changed.has(region)).map((region) => ({ region, visible: plan.get(region) === true }));
   }
-  /** Reports logical transitions caused by user input or the public action. */
   #commitChange(triggers = this.triggerTargets) {
     for (const detail of this.#settle(triggers)) {
       this.dispatch("change", { detail });
     }
   }
-  /** Reports logical transitions derived from DOM, lifecycle, reset, or Value state. */
   #reconcileDom() {
     for (const detail of this.#settle()) {
       this.dispatch("reconcile", { detail });
     }
   }
-  /** Applies one planned state while keeping event history separate from DOM repair. */
   #applyRegion(region, visible, plan) {
     const previous = this.#lastVisible.get(region) ?? !region.hidden;
     const changed = visible !== previous;
@@ -343,17 +501,16 @@ var ConditionalFieldsController = class extends Controller {
     this.#syncRegionControls(region, visible);
     return changed;
   }
-  /** Reflects visibility idempotently, recording writes so the observer ignores its own work. */
   #syncRegionState(region, visible) {
+    if (!visible && this.#predicateFor(region) !== null) this.#concealed.add(region);
+    else this.#concealed.delete(region);
     this.#writeAttribute(region, "hidden", visible ? null : "");
     this.#writeAttribute(region, "aria-hidden", visible ? null : "true");
     this.#writeAttribute(region, "data-visible", visible ? "true" : null);
   }
-  /** Enables/disables descendant controls, touching only state carrying our marker. */
   #syncRegionControls(region, visible) {
     const shouldDisable = !visible && this.disableHiddenValue;
-    const controls = region.querySelectorAll("input, textarea, select, button");
-    for (const control of controls) {
+    for (const control of region.querySelectorAll(CONTROLS)) {
       const marked = control.hasAttribute(DISABLED_MARKER);
       if (shouldDisable) {
         if (!control.disabled) {
@@ -363,18 +520,30 @@ var ConditionalFieldsController = class extends Controller {
           this.#writeAttribute(control, DISABLED_MARKER, "true");
         }
       } else if (marked) {
-        this.#writeAttribute(control, "disabled", null);
-        this.#writeAttribute(control, DISABLED_MARKER, null);
+        this.#enable(control);
+      }
+    }
+  }
+  #enable(control) {
+    this.#writeAttribute(control, "disabled", null);
+    this.#writeAttribute(control, DISABLED_MARKER, null);
+  }
+  #release(element, plan) {
+    this.#lastVisible.delete(element);
+    if (this.#concealed.delete(element)) this.#writeAttribute(element, "hidden", null);
+    this.#writeAttribute(element, "aria-hidden", null);
+    this.#writeAttribute(element, "data-visible", null);
+    for (const control of element.querySelectorAll(CONTROLS)) {
+      if (control.hasAttribute(DISABLED_MARKER) && this.#survivesPlan(control, plan)) {
+        this.#enable(control);
       }
     }
   }
-  /** Whether a region's declared condition holds across `triggers` per `match`. */
   #isVisible(region, triggers) {
     const predicate = this.#predicateFor(region);
     if (predicate === null) return !region.hidden;
     return triggers.length > 0 && (this.matchValue === "all" ? triggers.every(predicate) : triggers.some(predicate));
   }
-  /** Builds the deterministic per-trigger predicate from the region's condition. */
   #predicateFor(region) {
     if (region.hasAttribute("data-when-checked")) {
       return (trigger) => this.#isChecked(trigger);
@@ -391,19 +560,16 @@ var ConditionalFieldsController = class extends Controller {
   #isChecked(trigger) {
     return trigger instanceof HTMLInputElement && trigger.checked;
   }
-  /** A trigger has a value when a radio/checkbox is selected, or its control value matches. */
   #matchesValue(trigger, wanted) {
     if (trigger instanceof HTMLInputElement && (trigger.type === "checkbox" || trigger.type === "radio")) {
       return trigger.checked && trigger.value === wanted;
     }
     return trigger.value === wanted;
   }
-  /** Moves focus to the first safe trigger, or to the controller landmark as a fallback. */
   #retreatFocus(region, plan) {
     const active = document.activeElement;
     if (active && region.contains(active)) this.#moveFocus(plan);
   }
-  /** Moves focus after the caller establishes that the active node is being hidden. */
   #moveFocus(plan) {
     const destination = this.triggerTargets.find(
       (trigger) => canTakeFocus(trigger) && this.#survivesPlan(trigger, plan)
@@ -416,65 +582,28 @@ var ConditionalFieldsController = class extends Controller {
     this.#rootTabindex.lend(this.element);
     this.element.focus();
   }
-  /** Whether a focus candidate sits outside every region this pass will hide. */
   #survivesPlan(candidate, plan) {
     return [...plan].every(([region, visible]) => visible || !region.contains(candidate));
   }
-  /** Records one idempotent attribute write before MutationObserver sees it. */
   #writeAttribute(element, name, value) {
-    if (element.getAttribute(name) !== value) {
-      if (this.#observing) {
-        let writes = this.#internalWrites.get(element);
-        if (!writes) {
-          writes = /* @__PURE__ */ new Map();
-          this.#internalWrites.set(element, writes);
-        }
-        writes.set(name, value);
-      }
-      if (value === null) element.removeAttribute(name);
-      else element.setAttribute(name, value);
-    }
+    setAttributeIfChanged(element, name, value, () => this.#observer.claim(element, name, value));
   }
-  /** Separates authored records from controller writes and queues one relevant repair. */
   #onMutations(records) {
     const triggers = this.triggerTargets;
     const regions = this.regionTargets;
-    const touchedWrites = /* @__PURE__ */ new Map();
-    let needsReconcile = false;
-    for (const record of records) {
-      if (record.type === "attributes" && record.target instanceof Element) {
-        const name = record.attributeName;
-        const writes = this.#internalWrites.get(record.target);
-        if (name && writes?.has(name)) {
-          let names = touchedWrites.get(record.target);
-          if (!names) {
-            names = /* @__PURE__ */ new Set();
-            touchedWrites.set(record.target, names);
-          }
-          names.add(name);
-          if (record.target.getAttribute(name) === writes.get(name)) continue;
-        }
-      }
-      if (record.target instanceof Element && this.#elementAffectsState(record.target, triggers, regions)) {
-        needsReconcile = true;
-      }
-    }
-    for (const [element, names] of touchedWrites) {
-      const writes = this.#internalWrites.get(element);
-      for (const name of names) writes?.delete(name);
+    if (records.some(
+      (record) => record.target instanceof Element && this.#elementAffectsState(record.target, triggers, regions)
+    )) {
+      this.#reconcile.schedule();
     }
-    if (needsReconcile) this.#reconcile.schedule();
   }
-  /** Whether an authored mutation target belongs to a trigger, region, or managed control. */
   #elementAffectsState(target, triggers, regions) {
     return ownerIndex(triggers, target) !== -1 || ownerIndex(regions, target) !== -1;
   }
-  /** Whether a form owns at least one current trigger, including `form=` associations. */
   #hasTriggerOwnedBy(form) {
     return this.triggerTargets.some((trigger) => trigger.form === form);
   }
 };
 
 export { ConditionalFieldsController };
-//# sourceMappingURL=conditional_fields_controller.js.map
 //# sourceMappingURL=conditional_fields_controller.js.map