stimeo-ui 0.16.0 → 0.17.0

data/dist/controllers/radio_group_controller.js

@@ -1,13 +1,31 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/radio_group_controller.ts
+var FOCUS_EVENTS = /* @__PURE__ */ new Set(["blur", "focus", "focusin", "focusout"]);
+var POINTER_EVENTS = /* @__PURE__ */ new Set(["mouseenter", "mouseleave", "pointerenter", "pointerleave"]);
+function stateReasonFor(event) {
+  if (!event) return "api";
+  if (FOCUS_EVENTS.has(event.type)) return "focus";
+  if (POINTER_EVENTS.has(event.type)) return "pointer";
+  return "user";
+}
+
+function actionSource(source) {
+  if (source instanceof HTMLElement) {
+    return { event: null, host: source, origin: source, reason: "api" };
+  }
+  const event = source ?? null;
+  return {
+    event,
+    host: event?.currentTarget instanceof Element ? event.currentTarget : null,
+    origin: event?.target instanceof Element ? event.target : null,
+    reason: stateReasonFor(event)
+  };
+}
 
-// src/utils/logical_scroll.ts
 function isRtl(element) {
   return window.getComputedStyle(element).direction === "rtl";
 }
 
-// src/utils/arrow_step.ts
 function logicalArrowStep(key, element) {
   if (key === "ArrowDown") return 1;
   if (key === "ArrowUp") return -1;
@@ -20,7 +38,6 @@ function isReservedArrowChord(event, allow = []) {
   return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
 }
 
-// src/utils/event_owner.ts
 function ownerIndex(candidates, node) {
   if (!(node instanceof Node)) return -1;
   return candidates.findIndex((candidate) => candidate.contains(node));
@@ -29,7 +46,6 @@ function ownerOf(candidates, node) {
   return candidates[ownerIndex(candidates, node)] ?? null;
 }
 
-// src/utils/field_mirror.ts
 function writeField(field, value) {
   if (field.value === value) return false;
   field.value = value;
@@ -39,7 +55,6 @@ function commitField(target) {
   target.dispatchEvent(new Event("change", { bubbles: true }));
 }
 
-// src/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
   while (fieldset) {
@@ -50,7 +65,6 @@ function inheritsFieldsetDisabled(control) {
   return false;
 }
 
-// src/utils/interactive_host.ts
 var INTERACTIVE_HOST_SELECTOR = "button, input, select, textarea, label, a[href], area[href], summary, details, audio[controls], video[controls], iframe, object, embed";
 function isInteractiveHost(element) {
   if (element.matches(INTERACTIVE_HOST_SELECTOR)) return true;
@@ -67,27 +81,33 @@ function isInteractiveHost(element) {
   return false;
 }
 
-// src/utils/microtask_coalescer.ts
+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;
-  /** @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;
@@ -100,31 +120,50 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/roving_tabindex.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();
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
+var MoveCounter = class {
+  #sequence = 0;
+  record() {
+    this.#sequence += 1;
+    return this.#sequence;
+  }
+  isLatest(token) {
+    return token === this.#sequence;
+  }
+};
+
 var RovingTabindex = class {
-  /** Returns the current ordered item elements; called on every operation. */
   #getItems;
-  /**
-   * @param getItems - Returns the current ordered item elements. Called on every
-   *   operation so the live target list is always used.
-   */
   constructor(getItems) {
     this.#getItems = getItems;
   }
-  /** Index of the currently tabbable item (`tabindex="0"`), or `-1` if none. */
   get activeIndex() {
     return this.#getItems().findIndex((item) => item.tabIndex === 0);
   }
-  /**
-   * Makes exactly the item at `index` tabbable (`tabindex="0"`) and removes every
-   * other item from the Tab sequence (`tabindex="-1"`). An out-of-range `index`
-   * (e.g. `-1`) leaves all items at `-1`, which a controller can use to express
-   * "nothing is currently tabbable".
-   *
-   * @param index - Position of the item to make tabbable.
-   * @param options - Pass `{ focus: true }` to also move DOM focus to that item,
-   *   and `items` to reuse an event-scoped collection snapshot.
-   */
   setActive(index, options = {}) {
     const { focus = false } = options;
     const items = options.items ?? this.#getItems();
@@ -140,7 +179,10 @@ function rovingMove(current, length, delta, wrap) {
   return (next + length) % length;
 }
 
-// src/controllers/radio_group_controller.ts
+function targetSelector(identifier, name) {
+  return `[data-${identifier}-target~="${name}"]`;
+}
+
 var NO_SELECTION = { radio: null, value: "" };
 var OBSERVED_ATTRIBUTES = [
   "aria-checked",
@@ -157,11 +199,13 @@ var OBSERVED_ATTRIBUTES = [
 ];
 var hasModifier = (event) => event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
 var RadioGroupController = class extends Controller {
+  #moves = new MoveCounter();
+  #moveToken = 0;
   static targets = ["radio", "field"];
   static actions = ["onKeydown", "select"];
   static events = ["change", "reconcile"];
   #roving = new RovingTabindex(() => this.#managedTargets);
-  #reconcile = new MicrotaskCoalescer(() => this.#reconcileDom());
+  #reconcile = new MorphRenderWatcher(() => this.#reconcileDom());
   #handledEvents = /* @__PURE__ */ new WeakSet();
   #managedRadios = /* @__PURE__ */ new Set();
   #originalTabindex = /* @__PURE__ */ new Map();
@@ -169,17 +213,12 @@ var RadioGroupController = class extends Controller {
   #internalCheckedValues = /* @__PURE__ */ new Map();
   #internalTabindexValues = /* @__PURE__ */ new Map();
   #observer = null;
-  /** The selection last published: read on connect, then committed or reported. */
   #committed = NO_SELECTION;
   #connected = false;
   #lastOrder = [];
   #focusedRadio = null;
   #pendingFocusIndex = null;
   #preferChecked = false;
-  /**
-   * Normalizes authored selection, establishes the APG Tab entry point, and
-   * reflects derived form state without reporting a user edit.
-   */
   connect() {
     const currentRadios = new Set(this.radioTargets);
     for (const radio of this.#managedRadios) {
@@ -188,7 +227,7 @@ var RadioGroupController = class extends Controller {
     for (const radio of this.radioTargets) this.#reconcileHost(radio, false);
     this.#normalizeSelection();
     this.#ensureTabStop(true);
-    this.#reflectField(this.#selectedRadio, { silent: true });
+    this.#reflectField(this.#selectedRadio);
     this.#committed = this.#settled;
     this.#lastOrder = this.#managedTargets;
     this.element.addEventListener("click", this.#onClickCapture, true);
@@ -201,13 +240,12 @@ var RadioGroupController = class extends Controller {
     this.#preferChecked = false;
     this.#internalCheckedValues.clear();
     this.#internalTabindexValues.clear();
-    this.#reconcile.activate();
+    this.#reconcile.observe(this.element);
     this.#observeMutations();
   }
-  /** Releases every listener, observer, and queued pass while retaining live DOM state. */
   disconnect() {
     this.#connected = false;
-    this.#reconcile.cancel();
+    this.#reconcile.disconnect();
     this.element.removeEventListener("click", this.#onClickCapture, true);
     this.element.removeEventListener("keydown", this.#onKeydownCapture, true);
     this.element.removeEventListener("click", this.#onClick);
@@ -216,21 +254,17 @@ var RadioGroupController = class extends Controller {
     this.element.removeEventListener("focusout", this.#onFocusout);
     this.#observer?.disconnect();
     this.#observer = null;
-    this.#internalCheckedValues.clear();
-    this.#internalTabindexValues.clear();
     this.#focusedRadio = null;
     this.#pendingFocusIndex = null;
     this.#committed = NO_SELECTION;
     this.#preferChecked = false;
   }
-  /** Removes a newly connected radio from the Tab sequence before batch reconciliation. */
   radioTargetConnected(radio) {
     if (this.#connected === false) return;
     this.#reconcileHost(radio, true);
     this.#preferChecked = true;
     this.#reconcile.schedule();
   }
-  /** Releases target-only attributes and repairs selection, form state, focus, and roving. */
   radioTargetDisconnected(radio) {
     if (!this.#connected) return;
     if (this.#focusedRadio === radio) {
@@ -241,36 +275,33 @@ var RadioGroupController = class extends Controller {
     this.#preferChecked = true;
     this.#reconcile.schedule();
   }
-  /** Reflects the current selection into a field added or replaced at runtime. */
   fieldTargetConnected() {
     this.#reconcile.schedule();
   }
-  /** Reconciles after a field target is removed from a retained group. */
   fieldTargetDisconnected() {
     this.#reconcile.schedule();
   }
-  /** Selects the action's radio. Per-radio action wiring is optional. */
-  select(event) {
-    if (event.defaultPrevented || !this.#ownsEventTarget(event.target)) return;
-    const radio = event.currentTarget;
+  select(source) {
+    const { event, host, origin, reason } = actionSource(source);
+    const radio = host?.closest(targetSelector(this.identifier, "radio"));
     if (!radio || !this.radioTargets.includes(radio)) return;
-    this.#handledEvents.add(event);
-    this.#selectRadio(radio, { focus: false });
+    if (origin && origin.closest(`[data-controller~="${this.identifier}"]`) !== this.element)
+      return;
+    if (event?.defaultPrevented || event && !this.#ownsEventTarget(origin)) return;
+    if (event) this.#handledEvents.add(event);
+    this.#selectRadio(radio, { focus: false }, reason);
   }
-  /** Applies the APG key map to the action's radio. Per-radio action wiring is optional. */
   onKeydown(event) {
     const radio = event.currentTarget;
     if (!radio || !this.radioTargets.includes(radio)) return;
     this.#handleKeydown(event, radio);
   }
-  /** Blocks disabled pointer activation before per-radio and consumer handlers run. */
   #onClickCapture = (event) => {
     const radio = this.#radioForEventTarget(event.target);
     if (!radio || !this.#isSupportedHost(radio) || !this.#isActivationDisabled(radio)) return;
     event.preventDefault();
     event.stopImmediatePropagation();
   };
-  /** Blocks disabled activation and suppresses a button's non-APG Enter activation. */
   #onKeydownCapture = (event) => {
     if (event.key !== " " && event.key !== "Enter") return;
     const radio = this.#radioForEventTarget(event.target);
@@ -280,25 +311,21 @@ var RadioGroupController = class extends Controller {
       event.stopImmediatePropagation();
     }
   };
-  /** Delegated click path for static and runtime-added radios without actions. */
   #onClick = (event) => {
     if (this.#handledEvents.delete(event) || event.defaultPrevented) return;
     const radio = this.#radioForEventTarget(event.target);
     if (radio) this.#selectRadio(radio, { focus: false });
   };
-  /** Delegated keydown path for static and runtime-added radios without actions. */
   #onKeydown = (event) => {
     const radio = this.#radioForEventTarget(event.target);
     if (radio) this.#handleKeydown(event, radio);
   };
-  /** Keeps programmatic and pointer focus as the group's current roving position. */
   #onFocusin = (event) => {
     const radio = this.#radioForEventTarget(event.target);
     if (!radio || !this.#isNavigable(radio)) return;
     this.#focusedRadio = radio;
     this.#setActive(radio);
   };
-  /** Distinguishes ordinary focus departure from focus lost because its radio was removed. */
   #onFocusout = (event) => {
     const radio = this.#radioForEventTarget(event.target);
     if (!radio) return;
@@ -308,7 +335,6 @@ var RadioGroupController = class extends Controller {
       if (!(active instanceof Node) || !radio.contains(active)) this.#focusedRadio = null;
     });
   };
-  /** Applies navigation and Space activation to one supported radio. */
   #handleKeydown(event, radio) {
     if (event.defaultPrevented || !this.#isSupportedHost(radio)) return;
     if (event.isComposing || isReservedArrowChord(event)) return;
@@ -346,65 +372,54 @@ var RadioGroupController = class extends Controller {
     if (this.#isActivationDisabled(destination)) this.#setActive(destination, true);
     else this.#selectRadio(destination, { focus: true });
   }
-  /**
-   * Applies one user selection and emits only when selected identity changes. A
-   * new selection is taken as published before either report goes out, so a
-   * listener that selects again is measured from it. Activating the radio that is
-   * already checked publishes nothing: if the page checked it, the next pass
-   * reports that move.
-   */
-  #selectRadio(radio, { focus }) {
+  #selectRadio(radio, { focus }, reason = "user") {
     if (!this.#isSupportedHost(radio) || this.#isActivationDisabled(radio)) return;
-    const previous = this.#selectedRadio;
-    const changed = previous !== radio;
-    if (changed) {
-      for (const item of this.#managedTargets) this.#setChecked(item, item === radio);
-      this.#committed = { radio, value: this.#radioValue(radio) };
-    }
-    this.#setActive(radio, focus);
-    this.#reflectField(radio, { silent: !changed });
-    if (changed) {
-      this.dispatch("change", { detail: { value: this.#radioValue(radio), radio } });
+    const value = this.#radioValue(radio);
+    const changed = this.#committed.radio !== radio || this.#committed.value !== value;
+    for (const item of this.#managedTargets) this.#setChecked(item, item === radio);
+    this.#committed = { radio, value };
+    if (changed) this.#moveToken = this.#moves.record();
+    const token = this.#moveToken;
+    this.#setActive(radio);
+    const fieldChanged = this.hasFieldTarget && writeField(this.fieldTarget, value);
+    if (focus) radio.focus();
+    if (!this.#connected || !this.#moves.isLatest(token)) return;
+    if (changed && fieldChanged) commitField(this.fieldTarget);
+    if (changed && this.#moves.isLatest(token)) {
+      this.dispatch("change", { detail: { value, radio, reason } });
     }
   }
-  /** Reconciles target ownership, selection, roving, focus continuity, and form state. */
   #reconcileDom() {
     const observer = this.#observer;
-    observer?.disconnect();
+    this.#handleMutationRecords(observer?.takeRecords() ?? []);
     for (const radio of this.radioTargets) this.#reconcileHost(radio, true);
     this.#normalizeSelection();
     const pendingFocusIndex = this.#pendingFocusIndex;
     this.#pendingFocusIndex = null;
+    let destination = null;
     if (pendingFocusIndex !== null) {
-      const destination = this.#nearestNavigable(pendingFocusIndex);
-      this.#setActive(destination, destination !== null);
+      destination = this.#nearestNavigable(pendingFocusIndex);
+      this.#setActive(destination);
     } else {
       this.#ensureTabStop(this.#preferChecked);
     }
-    this.#reflectField(this.#selectedRadio, { silent: true });
+    this.#reflectField(this.#selectedRadio);
     this.#lastOrder = this.#managedTargets;
     this.#preferChecked = false;
+    observer?.takeRecords();
     this.#internalCheckedValues.clear();
     this.#internalTabindexValues.clear();
-    if (this.#connected && observer) this.#observeWith(observer);
-    this.#reportReconciledSelection();
-  }
-  /**
-   * Announces a selection that moved since the one this group last published —
-   * another radio, or the same radio submitting another value. Dispatched after
-   * observation resumes so a consumer's own DOM edits are seen by the next pass,
-   * and only while connected: moving focus inside the pass runs listeners that
-   * can disconnect the group.
-   */
-  #reportReconciledSelection() {
-    if (!this.#connected) return;
     const settled = this.#settled;
     const committed = this.#committed;
-    if (settled.radio === committed.radio && settled.value === committed.value) return;
+    const changed = settled.radio !== committed.radio || settled.value !== committed.value;
     this.#committed = settled;
-    this.dispatch("reconcile", { detail: { value: settled.value, radio: settled.radio } });
+    const token = this.#moveToken;
+    destination?.focus();
+    if (!this.#connected || !this.#moves.isLatest(token)) return;
+    if (changed) {
+      this.dispatch("reconcile", { detail: { value: settled.value, radio: settled.radio } });
+    }
   }
-  /** Begins or ends ownership according to a radio's current host semantics. */
   #reconcileHost(radio, dropFromTabSequence) {
     if (!this.#isSupportedHost(radio)) {
       this.#releaseRadio(radio);
@@ -417,7 +432,6 @@ var RadioGroupController = class extends Controller {
     }
     this.#normalizeChecked(radio);
   }
-  /** Restores only defaults owned while an element belonged to this group. */
   #releaseRadio(radio) {
     this.#managedRadios.delete(radio);
     const original = this.#originalTabindex.get(radio);
@@ -434,7 +448,6 @@ var RadioGroupController = class extends Controller {
       radio.removeAttribute("aria-checked");
     }
   }
-  /** Supplies a missing checked state and normalizes invalid ARIA tokens. */
   #normalizeChecked(radio) {
     const value = radio.getAttribute("aria-checked");
     if (value === null) {
@@ -444,17 +457,14 @@ var RadioGroupController = class extends Controller {
       this.#setChecked(radio, false);
     }
   }
-  /** Makes the first DOM-ordered checked radio the sole checked radio. */
   #normalizeSelection() {
     let found = false;
     for (const radio of this.#managedTargets) {
-      this.#normalizeChecked(radio);
       if (!this.#isChecked(radio)) continue;
       if (!found) found = true;
       else this.#setChecked(radio, false);
     }
   }
-  /** Keeps one navigable Tab stop, preferring checked state when selection changed externally. */
   #ensureTabStop(preferChecked) {
     const navigable = this.#navigableRadios;
     let active;
@@ -469,12 +479,6 @@ var RadioGroupController = class extends Controller {
     active ??= navigable[0];
     this.#setActive(active ?? null);
   }
-  /**
-   * The surviving navigable radio closest to a position in the order captured
-   * before the removal: the first one at or after it, else the last one before it.
-   * The saved position and this search read the same population, so a `hidden` or
-   * natively disabled sibling never shifts the destination past its neighbor.
-   */
   #nearestNavigable(index) {
     const navigable = new Set(this.#navigableRadios);
     for (let i = index; i < this.#lastOrder.length; i++) {
@@ -487,7 +491,6 @@ var RadioGroupController = class extends Controller {
     }
     return this.#navigableRadios[0] ?? null;
   }
-  /** Moves through full DOM order until a navigable radio is found. */
   #nextNavigable(fromIndex, delta) {
     const items = this.#managedTargets;
     let index = fromIndex;
@@ -498,36 +501,31 @@ var RadioGroupController = class extends Controller {
     }
     return void 0;
   }
-  /** Assigns the single roving Tab stop and optionally moves DOM focus. */
   #setActive(radio, focus = false) {
     const items = this.#managedTargets;
     const index = items.indexOf(radio);
-    this.#roving.setActive(index, { focus });
+    this.#roving.setActive(index);
     for (const item of items) {
       this.#markInternal(this.#internalTabindexValues, item, item.getAttribute("tabindex"));
     }
+    if (focus) radio?.focus();
   }
-  /** Finds this group's radio containing an event target, excluding nested groups. */
   #radioForEventTarget(target) {
     if (!this.#ownsEventTarget(target)) return null;
     return ownerOf(this.radioTargets, target);
   }
-  /** Whether the closest Radio Group scope around a target is this instance. */
   #ownsEventTarget(target) {
     return target instanceof Element && target.closest(`[data-controller~="${this.identifier}"]`) === this.element;
   }
-  /** Hosts whose activation model can be owned without conflicting native behavior. */
   #isSupportedHost(radio) {
     if (radio instanceof HTMLButtonElement) return radio.type === "button";
     return !isInteractiveHost(radio);
   }
-  /** Radios eligible for roving focus; ARIA-disabled deliberately remains eligible. */
   #isNavigable(radio) {
     if (!this.#isSupportedHost(radio) || this.#isHidden(radio)) return false;
     if (!(radio instanceof HTMLButtonElement)) return true;
     return !radio.disabled && !inheritsFieldsetDisabled(radio);
   }
-  /** Whether hidden applies on the path from a radio up to the group root. */
   #isHidden(radio) {
     let current = radio;
     while (current && current !== this.element) {
@@ -536,7 +534,6 @@ var RadioGroupController = class extends Controller {
     }
     return false;
   }
-  /** Whether ARIA, visibility, or native HTML semantics suppress selection. */
   #isActivationDisabled(radio) {
     if (!this.#isNavigable(radio)) return true;
     let current = radio;
@@ -546,7 +543,6 @@ var RadioGroupController = class extends Controller {
     }
     return false;
   }
-  /** Distinguishes external retained-element changes from this controller's own writes. */
   #handleMutationRecords(records) {
     let external = false;
     for (const record of records) {
@@ -567,11 +563,9 @@ var RadioGroupController = class extends Controller {
         external = true;
       }
     }
-    this.#internalCheckedValues.clear();
     this.#internalTabindexValues.clear();
     if (external) this.#reconcile.schedule();
   }
-  /** Records an attribute write this pass made, keeping one claim per record it will produce. */
   #markInternal(values, target, value) {
     const pending = values.get(target);
     if (pending) {
@@ -581,7 +575,6 @@ var RadioGroupController = class extends Controller {
       values.set(target, { value, count: 1 });
     }
   }
-  /** Consumes one claim on a record whose value this pass wrote. */
   #matchesInternal(values, target, value) {
     const pending = values.get(target);
     if (!pending || pending.value !== value) return false;
@@ -589,13 +582,11 @@ var RadioGroupController = class extends Controller {
     if (pending.count === 0) values.delete(target);
     return true;
   }
-  /** Watches target membership, retained state/hosts, form state, and fieldset ancestry. */
   #observeMutations() {
     const observer = new MutationObserver((records) => this.#handleMutationRecords(records));
     this.#observer = observer;
     this.#observeWith(observer);
   }
-  /** Registers root and ancestor observation on one observer instance. */
   #observeWith(observer) {
     observer.observe(this.element, {
       subtree: true,
@@ -612,53 +603,42 @@ var RadioGroupController = class extends Controller {
       ancestor = ancestor.parentElement;
     }
   }
-  /** Supported targets currently managed by the roving primitive. */
   get #managedTargets() {
     return this.radioTargets.filter((radio) => this.#managedRadios.has(radio));
   }
-  /** Managed radios eligible for the roving Tab stop. */
   get #navigableRadios() {
     return this.#managedTargets.filter((radio) => this.#isNavigable(radio));
   }
-  /** The currently checked managed radio, if any. */
   get #selectedRadio() {
     return this.#managedTargets.find((radio) => this.#isChecked(radio));
   }
-  /** The current selection as the group publishes it. */
   get #settled() {
     const radio = this.#selectedRadio;
     return radio ? { radio, value: this.#radioValue(radio) } : NO_SELECTION;
   }
-  /** Whether a radio is currently checked. */
   #isChecked(radio) {
     return radio.getAttribute("aria-checked") === "true";
   }
-  /** Reflects checked state while distinguishing controller writes from authored morphs. */
   #setChecked(radio, checked) {
     const value = checked ? "true" : "false";
     if (radio.getAttribute("aria-checked") === value) return;
     this.#markInternal(this.#internalCheckedValues, radio, value);
     radio.setAttribute("aria-checked", value);
   }
-  /** Writes a roving value before the radio is visible to the shared primitive. */
   #writeTabindex(radio, value) {
     const serialized = String(value);
     this.#markInternal(this.#internalTabindexValues, radio, serialized);
     radio.tabIndex = value;
   }
-  /** Mirrors the selected value or the empty state to the optional hidden field. */
-  #reflectField(radio, { silent = false } = {}) {
+  #reflectField(radio) {
     if (!this.hasFieldTarget) return;
     const value = radio ? this.#radioValue(radio) : "";
-    if (!writeField(this.fieldTarget, value)) return;
-    if (!silent) commitField(this.fieldTarget);
+    writeField(this.fieldTarget, value);
   }
-  /** A radio's submitted value (`data-value`, defaulting to empty). */
   #radioValue(radio) {
     return radio.getAttribute("data-value") ?? "";
   }
 };
 
 export { RadioGroupController };
-//# sourceMappingURL=radio_group_controller.js.map
 //# sourceMappingURL=radio_group_controller.js.map