stimeo-ui 0.1.0.pre.alpha.1

data/dist/controllers/number_input_controller.js

@@ -0,0 +1,306 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/number_input_controller.ts
+
+// src/utils/safe_timeout.ts
+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);
+      callback();
+    }, delay);
+    this.ids.add(id);
+    return id;
+  }
+  schedule(callback, delay) {
+    return window.setTimeout(callback, delay);
+  }
+  cancel(id) {
+    window.clearTimeout(id);
+  }
+};
+var SafeInterval = class extends TimerRegistry {
+  /** Schedules a repeating `callback` every `delay` ms and returns the timer id. */
+  set(callback, delay) {
+    const id = this.schedule(callback, delay);
+    this.ids.add(id);
+    return id;
+  }
+  schedule(callback, delay) {
+    return window.setInterval(callback, delay);
+  }
+  cancel(id) {
+    window.clearInterval(id);
+  }
+};
+
+// src/controllers/number_input_controller.ts
+var NumberInputController = class _NumberInputController extends Controller {
+  static targets = ["input", "increment", "decrement"];
+  static values = {
+    min: { type: Number, default: Number.NEGATIVE_INFINITY },
+    max: { type: Number, default: Number.POSITIVE_INFINITY },
+    step: { type: Number, default: 1 },
+    pageStep: { type: Number, default: 0 }
+  };
+  static actions = ["decrement", "increment", "onInput", "onKeydown"];
+  static events = ["change"];
+  /** Delay (ms) a button must be held before auto-repeat starts. */
+  static #HOLD_DELAY_MS = 400;
+  /** Interval (ms) between auto-repeat steps once a hold has started. */
+  static #HOLD_REPEAT_MS = 80;
+  /**
+   * Window (ms) after a hold ends during which the trailing synthetic `click` is
+   * swallowed. A safety net for the (rare) case where that click never arrives
+   * (e.g. the pointer was released off the button): the flag self-clears instead
+   * of poisoning the next legitimate click.
+   */
+  static #SUPPRESS_RESET_MS = 250;
+  /** Aborts the pointer listeners on disconnect so none outlive the element. */
+  #guards = null;
+  /** Timers for the hold delay and the suppress-reset safety net. */
+  #holdTimeouts = new SafeTimeout();
+  /** The running auto-repeat interval (one at a time). */
+  #holdIntervals = new SafeInterval();
+  /** True while a hold is armed/running, making `#stopHold` idempotent. */
+  #holdActive = false;
+  /** True once a hold actually produced a repeated step (vs. a quick click). */
+  #repeatedDuringHold = false;
+  /** True when the next `click` is the trailing one after a hold and must be ignored. */
+  #suppressNextClick = false;
+  /** Normalizes any initial value and wires the focus/hold pointer guards. */
+  connect() {
+    if (!this.hasInputTarget) return;
+    if (this.inputTarget.value.trim() !== "") {
+      this.#write(this.#normalize(this.#currentValue()));
+    } else {
+      this.#updateButtons(this.#currentValue());
+    }
+    this.#guards = new AbortController();
+    const { signal } = this.#guards;
+    if (this.hasIncrementTarget) this.#wireButton(this.incrementTarget, this.stepValue, signal);
+    if (this.hasDecrementTarget) this.#wireButton(this.decrementTarget, -this.stepValue, signal);
+    window.addEventListener("pointerup", this.#stopHold, { signal });
+    window.addEventListener("pointercancel", this.#stopHold, { signal });
+    window.addEventListener("blur", this.#stopHold, { signal });
+  }
+  /** Releases the pointer guards and tears down every pending timer and hold state. */
+  disconnect() {
+    this.#guards?.abort();
+    this.#guards = null;
+    this.#holdActive = false;
+    this.#repeatedDuringHold = false;
+    this.#suppressNextClick = false;
+    this.#holdTimeouts.clearAll();
+    this.#holdIntervals.clearAll();
+  }
+  /** Increases by one step. Bound via `data-action` (click). */
+  increment() {
+    if (this.#consumeSuppressedClick()) return;
+    this.#commit(this.#currentValue() + this.stepValue);
+    this.inputTarget.focus();
+  }
+  /** Decreases by one step. Bound via `data-action` (click). */
+  decrement() {
+    if (this.#consumeSuppressedClick()) return;
+    this.#commit(this.#currentValue() - this.stepValue);
+    this.inputTarget.focus();
+  }
+  /** Clamps and snaps a typed value. Bound via `data-action` (change). */
+  onInput() {
+    if (this.inputTarget.value.trim() === "") return;
+    this.#commit(this.#currentValue());
+  }
+  /** Keyboard stepping per the APG spinbutton model. */
+  onKeydown(event) {
+    const page = this.pageStepValue > 0 ? this.pageStepValue : this.stepValue * 10;
+    let next = null;
+    switch (event.key) {
+      case "ArrowUp":
+        next = this.#currentValue() + this.stepValue;
+        break;
+      case "ArrowDown":
+        next = this.#currentValue() - this.stepValue;
+        break;
+      case "PageUp":
+        next = this.#currentValue() + page;
+        break;
+      case "PageDown":
+        next = this.#currentValue() - page;
+        break;
+      case "Home":
+        if (!Number.isFinite(this.minValue)) return;
+        next = this.minValue;
+        break;
+      case "End":
+        if (!Number.isFinite(this.maxValue)) return;
+        next = this.maxValue;
+        break;
+      default:
+        return;
+    }
+    event.preventDefault();
+    this.#commit(next);
+  }
+  /**
+   * Wires a step button: `pointerdown` keeps focus on the input and arms the
+   * hold; leaving the button while held stops it (the global listeners cover
+   * release/cancel/blur).
+   */
+  #wireButton(button, delta, signal) {
+    button.addEventListener("pointerdown", (event) => this.#armHold(event, button, delta), {
+      signal
+    });
+    button.addEventListener("pointerleave", this.#stopHold, { signal });
+  }
+  /** Starts a hold: focus the input, then schedule the first repeat after a delay. */
+  #armHold(event, button, delta) {
+    const pointerButton = event.button;
+    if (typeof pointerButton === "number" && pointerButton !== 0) return;
+    if (button.disabled) return;
+    event.preventDefault();
+    this.inputTarget.focus();
+    this.#stopHold();
+    this.#holdActive = true;
+    this.#repeatedDuringHold = false;
+    this.#suppressNextClick = false;
+    this.#holdTimeouts.set(() => {
+      if (!this.#commit(this.#currentValue() + delta)) {
+        this.#stopHold();
+        return;
+      }
+      this.#repeatedDuringHold = true;
+      this.#holdIntervals.set(() => {
+        if (!this.#commit(this.#currentValue() + delta)) this.#stopHold();
+      }, _NumberInputController.#HOLD_REPEAT_MS);
+    }, _NumberInputController.#HOLD_DELAY_MS);
+  }
+  /**
+   * Stops the current hold (idempotent). When the hold actually repeated, the
+   * trailing synthetic `click` must be ignored, so it is suppressed until the
+   * click consumes it or a short safety-net timeout clears it.
+   */
+  #stopHold = () => {
+    if (!this.#holdActive) return;
+    this.#holdActive = false;
+    this.#holdTimeouts.clearAll();
+    this.#holdIntervals.clearAll();
+    if (this.#repeatedDuringHold) {
+      this.#suppressNextClick = true;
+      this.#holdTimeouts.set(() => {
+        this.#suppressNextClick = false;
+      }, _NumberInputController.#SUPPRESS_RESET_MS);
+    }
+  };
+  /** Consumes a pending trailing-click suppression; returns true if the click was swallowed. */
+  #consumeSuppressedClick() {
+    if (!this.#suppressNextClick) return false;
+    this.#suppressNextClick = false;
+    this.#holdTimeouts.clearAll();
+    return true;
+  }
+  /**
+   * Normalizes `raw`, reflects it, and dispatches `change` only when the
+   * displayed value actually changes.
+   *
+   * @returns Whether the value changed (drives the auto-repeat's bound stop).
+   */
+  #commit(raw) {
+    const value = this.#normalize(raw);
+    const changed = this.inputTarget.value !== String(value);
+    this.#write(value);
+    if (changed) this.dispatch("change", { detail: { value } });
+    return changed;
+  }
+  /** Reflects `value` on the input (and ARIA for non-native hosts) and the buttons. */
+  #write(value) {
+    this.inputTarget.value = String(value);
+    if (this.inputTarget.getAttribute("role") === "spinbutton") {
+      this.inputTarget.setAttribute("aria-valuenow", String(value));
+      if (Number.isFinite(this.minValue)) {
+        this.inputTarget.setAttribute("aria-valuemin", String(this.minValue));
+      }
+      if (Number.isFinite(this.maxValue)) {
+        this.inputTarget.setAttribute("aria-valuemax", String(this.maxValue));
+      }
+    }
+    this.#updateButtons(value);
+  }
+  /** Disables a step button at its bound, returning focus to the input first. */
+  #updateButtons(value) {
+    if (this.hasIncrementTarget) this.#toggleButton(this.incrementTarget, value < this.maxValue);
+    if (this.hasDecrementTarget) this.#toggleButton(this.decrementTarget, value > this.minValue);
+  }
+  /**
+   * Enables or disables a step button at its bound, never disabling one while it
+   * holds focus. Owns only the `disabled` it sets itself via a marker
+   * (`data-number-input-disabled`, like `conditional-fields`/`submit-once`), so an
+   * author-disabled button (e.g. the whole control disabled) is never re-enabled.
+   */
+  #toggleButton(button, enabled) {
+    if (enabled) {
+      if (button.hasAttribute("data-number-input-disabled")) {
+        button.disabled = false;
+        button.removeAttribute("data-number-input-disabled");
+      }
+      return;
+    }
+    if (button.disabled) return;
+    if (document.activeElement === button) this.inputTarget.focus();
+    button.disabled = true;
+    button.setAttribute("data-number-input-disabled", "");
+  }
+  /** The current numeric value, falling back to a finite min (else 0) when blank. */
+  #currentValue() {
+    const parsed = Number(this.inputTarget.value);
+    if (Number.isFinite(parsed) && this.inputTarget.value.trim() !== "") return parsed;
+    return Number.isFinite(this.minValue) ? this.minValue : 0;
+  }
+  /** Clamps to `[min, max]` and snaps to the step grid anchored at a finite min (else 0). */
+  #normalize(raw) {
+    const clamped = Math.min(this.maxValue, Math.max(this.minValue, raw));
+    if (this.stepValue <= 0) return clamped;
+    const base = Number.isFinite(this.minValue) ? this.minValue : 0;
+    const stepped = Math.round((clamped - base) / this.stepValue) * this.stepValue + base;
+    return Math.min(this.maxValue, Math.max(this.minValue, stepped));
+  }
+};
+
+export { NumberInputController };
+//# sourceMappingURL=number_input_controller.js.map
+//# sourceMappingURL=number_input_controller.js.map

data/dist/controllers/otp_controller.js

@@ -0,0 +1,201 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/otp_controller.ts
+var OtpController = class extends Controller {
+  static targets = ["field", "value", "error"];
+  static values = {
+    length: { type: Number, default: 6 },
+    pattern: { type: String, default: "[0-9]" }
+  };
+  static actions = ["onInput", "onKeydown", "onPaste"];
+  static events = ["change", "complete", "invalid"];
+  #isComposing = /* @__PURE__ */ new Map();
+  connect() {
+    for (const field of this.fieldTargets) {
+      field.addEventListener("focus", this.#onFieldFocus);
+      field.addEventListener("compositionstart", this.#onCompositionStart);
+      field.addEventListener("compositionend", this.#onCompositionEnd);
+    }
+  }
+  disconnect() {
+    for (const field of this.fieldTargets) {
+      field.removeEventListener("focus", this.#onFieldFocus);
+      field.removeEventListener("compositionstart", this.#onCompositionStart);
+      field.removeEventListener("compositionend", this.#onCompositionEnd);
+    }
+    this.#isComposing.clear();
+  }
+  /**
+   * Stimulus lifecycle callback when a new field target enters the DOM.
+   * Ensures new additions are also wired with overwriting support.
+   */
+  fieldTargetConnected(element) {
+    element.addEventListener("focus", this.#onFieldFocus);
+    element.addEventListener("compositionstart", this.#onCompositionStart);
+    element.addEventListener("compositionend", this.#onCompositionEnd);
+  }
+  /** Removes focus listeners when fields are dropped. */
+  fieldTargetDisconnected(element) {
+    element.removeEventListener("focus", this.#onFieldFocus);
+    element.removeEventListener("compositionstart", this.#onCompositionStart);
+    element.removeEventListener("compositionend", this.#onCompositionEnd);
+    this.#isComposing.delete(element);
+  }
+  /** Handles keystroke inputs and advances focus to the next field. */
+  onInput(event) {
+    const input = event.currentTarget;
+    if (!input) return;
+    if (this.#isComposing.get(input)) return;
+    this.#handleInputValidation(input);
+  }
+  /** Handles Backspace retreating, arrows, and home/end navigation. */
+  onKeydown(event) {
+    const input = event.currentTarget;
+    if (!input) return;
+    const index = this.fieldTargets.indexOf(input);
+    if (index === -1) return;
+    if (this.#isComposing.get(input)) return;
+    switch (event.key) {
+      case "Backspace":
+        if (!input.value) {
+          if (index > 0) {
+            event.preventDefault();
+            const prevField = this.fieldTargets[index - 1];
+            if (prevField) {
+              prevField.value = "";
+              prevField.removeAttribute("data-filled");
+              prevField.focus();
+              this.#clearError();
+              this.#syncAndDispatch();
+            }
+          }
+        } else {
+          input.value = "";
+          input.removeAttribute("data-filled");
+          this.#clearError();
+          this.#syncAndDispatch();
+        }
+        break;
+      case "ArrowLeft":
+        if (index > 0) {
+          event.preventDefault();
+          this.fieldTargets[index - 1]?.focus();
+        }
+        break;
+      case "ArrowRight":
+        if (index < this.lengthValue - 1) {
+          event.preventDefault();
+          this.fieldTargets[index + 1]?.focus();
+        }
+        break;
+      case "Home":
+        event.preventDefault();
+        this.fieldTargets[0]?.focus();
+        break;
+      case "End":
+        event.preventDefault();
+        this.fieldTargets[this.lengthValue - 1]?.focus();
+        break;
+    }
+  }
+  /** Divides pasted string characters across available input fields. */
+  onPaste(event) {
+    const input = event.currentTarget;
+    if (!input) return;
+    const startIndex = this.fieldTargets.indexOf(input);
+    if (startIndex === -1) return;
+    event.preventDefault();
+    const rawText = event.clipboardData?.getData("text") || "";
+    const text = this.#normalizeValue(rawText);
+    const regex = new RegExp(`^${this.patternValue}$`);
+    const validChars = Array.from(text).filter((char) => regex.test(char));
+    if (validChars.length === 0) {
+      this.#showError();
+      return;
+    }
+    const limit = Math.min(validChars.length, this.lengthValue - startIndex);
+    let lastFocusedIndex = startIndex;
+    for (let i = 0; i < limit; i++) {
+      const fieldIndex = startIndex + i;
+      const field = this.fieldTargets[fieldIndex];
+      const char = validChars[i];
+      if (field && char) {
+        field.value = char;
+        field.setAttribute("data-filled", "true");
+        lastFocusedIndex = fieldIndex;
+      }
+    }
+    this.#clearError();
+    const focusTargetIndex = lastFocusedIndex < this.lengthValue - 1 ? lastFocusedIndex + 1 : lastFocusedIndex;
+    this.fieldTargets[focusTargetIndex]?.focus();
+    this.#syncAndDispatch();
+  }
+  #onFieldFocus = (event) => {
+    const input = event.currentTarget;
+    if (input) {
+      input.select();
+    }
+  };
+  #onCompositionStart = (event) => {
+    const input = event.currentTarget;
+    this.#isComposing.set(input, true);
+  };
+  #onCompositionEnd = (event) => {
+    const input = event.currentTarget;
+    this.#isComposing.set(input, false);
+    this.#handleInputValidation(input);
+  };
+  #handleInputValidation(input) {
+    const index = this.fieldTargets.indexOf(input);
+    if (index === -1) return;
+    const rawValue = input.value;
+    const normalized = this.#normalizeValue(rawValue);
+    const regex = new RegExp(`^${this.patternValue}$`);
+    if (normalized && regex.test(normalized)) {
+      input.value = normalized;
+      input.setAttribute("data-filled", "true");
+      this.#clearError();
+      if (index < this.lengthValue - 1) {
+        const nextField = this.fieldTargets[index + 1];
+        nextField?.focus();
+      }
+    } else if (normalized) {
+      input.value = "";
+      input.removeAttribute("data-filled");
+      this.#showError();
+    } else {
+      input.removeAttribute("data-filled");
+    }
+    this.#syncAndDispatch();
+  }
+  #normalizeValue(val) {
+    return val.replace(/[０-９]/g, (s) => String.fromCharCode(s.charCodeAt(0) - 65248));
+  }
+  #showError() {
+    if (this.hasErrorTarget) {
+      this.errorTarget.removeAttribute("hidden");
+    }
+    this.dispatch("invalid", { detail: { pattern: this.patternValue } });
+  }
+  #clearError() {
+    if (this.hasErrorTarget) {
+      this.errorTarget.setAttribute("hidden", "true");
+    }
+  }
+  #syncAndDispatch() {
+    const fields = this.fieldTargets;
+    const combinedValue = fields.map((f) => f.value).join("");
+    if (this.hasValueTarget) {
+      this.valueTarget.value = combinedValue;
+    }
+    this.dispatch("change", { detail: { value: combinedValue } });
+    const isCompleted = fields.every((f) => f.value.length > 0) && combinedValue.length === this.lengthValue;
+    if (isCompleted) {
+      this.dispatch("complete", { detail: { value: combinedValue } });
+    }
+  }
+};
+
+export { OtpController };
+//# sourceMappingURL=otp_controller.js.map
+//# sourceMappingURL=otp_controller.js.map

data/dist/controllers/overflow_indicator_controller.js

@@ -0,0 +1,169 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/overflow_indicator_controller.ts
+
+// src/utils/layout_observer.ts
+var LayoutObserver = class {
+  #callback;
+  #resizeObserverFactory;
+  #resizeObserver = null;
+  #observingViewport = false;
+  /** Stable bound handler so add/removeEventListener target the same reference. */
+  #handleViewportResize = () => {
+    this.#callback();
+  };
+  constructor(callback, options = {}) {
+    this.#callback = callback;
+    this.#resizeObserverFactory = options.resizeObserverFactory ?? (typeof ResizeObserver === "undefined" ? null : (cb) => new ResizeObserver(cb));
+  }
+  /**
+   * Starts observing an element's size. Repeated calls observe additional
+   * elements through the same shared observer. No-ops when no
+   * `ResizeObserver` implementation is available.
+   */
+  observe(element) {
+    if (!this.#resizeObserverFactory) return;
+    if (!this.#resizeObserver) {
+      this.#resizeObserver = this.#resizeObserverFactory(() => {
+        this.#callback();
+      });
+    }
+    this.#resizeObserver.observe(element);
+  }
+  /** Stops observing a single element while leaving any others in place. */
+  unobserve(element) {
+    this.#resizeObserver?.unobserve(element);
+  }
+  /** Starts observing viewport resizes. Idempotent: the listener is added once. */
+  observeViewport() {
+    if (this.#observingViewport) return;
+    this.#observingViewport = true;
+    window.addEventListener("resize", this.#handleViewportResize);
+  }
+  /** Stops observing viewport resizes without affecting element observation. */
+  unobserveViewport() {
+    if (!this.#observingViewport) return;
+    this.#observingViewport = false;
+    window.removeEventListener("resize", this.#handleViewportResize);
+  }
+  /**
+   * Releases every observation: disconnects the {@link ResizeObserver} and
+   * removes the viewport listener. Safe to call multiple times. Call this from a
+   * controller's `disconnect()`.
+   */
+  disconnect() {
+    this.#resizeObserver?.disconnect();
+    this.#resizeObserver = null;
+    this.unobserveViewport();
+  }
+};
+
+// src/controllers/overflow_indicator_controller.ts
+var OverflowIndicatorController = class extends Controller {
+  static targets = ["viewport"];
+  static values = {
+    orientation: { type: String, default: "horizontal" },
+    threshold: { type: Number, default: 1 }
+  };
+  static actions = ["scrollByPage", "update"];
+  static events = ["change"];
+  #layout = new LayoutObserver(() => this.update());
+  #mutationObserver = null;
+  /** Last reported room, so `change` fires only on transitions. */
+  #state = null;
+  connect() {
+    if (!this.hasViewportTarget) return;
+    this.#layout.observe(this.viewportTarget);
+    this.#layout.observeViewport();
+    if (typeof MutationObserver !== "undefined") {
+      this.#mutationObserver = new MutationObserver(() => this.update());
+      this.#mutationObserver.observe(this.viewportTarget, {
+        childList: true,
+        subtree: true,
+        characterData: true
+      });
+    }
+    this.update();
+  }
+  disconnect() {
+    this.#layout.disconnect();
+    this.#mutationObserver?.disconnect();
+    this.#mutationObserver = null;
+    this.#state = null;
+  }
+  /** Re-measures remaining scroll room and reflects the state hooks. Public so it can be wired to the viewport's `scroll`. */
+  update() {
+    if (!this.hasViewportTarget) return;
+    const vp = this.viewportTarget;
+    const horizontal = this.orientationValue !== "vertical";
+    const t = this.thresholdValue;
+    const scrollPos = horizontal ? vp.scrollLeft : vp.scrollTop;
+    const maxScroll = horizontal ? vp.scrollWidth - vp.clientWidth : vp.scrollHeight - vp.clientHeight;
+    const start = scrollPos > t;
+    const end = scrollPos < maxScroll - t;
+    vp.setAttribute("data-overflow-start", start ? "true" : "false");
+    vp.setAttribute("data-overflow-end", end ? "true" : "false");
+    this.#syncButtons(start, end);
+    if (!this.#state || this.#state.start !== start || this.#state.end !== end) {
+      this.#state = { start, end };
+      this.dispatch("change", { detail: { start, end } });
+    }
+  }
+  /** Scrolls one viewport page toward the `direction` param (`start`/`end`). */
+  scrollByPage(event) {
+    if (!this.hasViewportTarget) return;
+    const direction = this.#directionFromEvent(event);
+    if (!direction) return;
+    const vp = this.viewportTarget;
+    const horizontal = this.orientationValue !== "vertical";
+    const page = horizontal ? vp.clientWidth : vp.clientHeight;
+    const delta = direction === "start" ? -page : page;
+    const behavior = this.#prefersReducedMotion() ? "auto" : "smooth";
+    if (horizontal) {
+      vp.scrollBy({ left: delta, behavior });
+    } else {
+      vp.scrollBy({ top: delta, behavior });
+    }
+  }
+  /** Mirrors remaining room onto any direction buttons by toggling `disabled`. */
+  #syncButtons(start, end) {
+    const buttons = this.element.querySelectorAll(
+      "[data-stimeo--overflow-indicator-direction-param]"
+    );
+    for (const button of buttons) {
+      const direction = button.getAttribute("data-stimeo--overflow-indicator-direction-param");
+      if (direction === "start") this.#toggleButton(button, start);
+      else if (direction === "end") this.#toggleButton(button, end);
+    }
+  }
+  /**
+   * Reflects the remaining room onto a page button's `disabled`, owning only the
+   * `disabled` it sets itself via a marker (`data-overflow-indicator-disabled`,
+   * like `number-input`/`conditional-fields`). An author-disabled button (e.g. the
+   * whole control disabled) is therefore never blindly re-enabled.
+   */
+  #toggleButton(button, hasRoom) {
+    if (hasRoom) {
+      if (button.hasAttribute("data-overflow-indicator-disabled")) {
+        button.disabled = false;
+        button.removeAttribute("data-overflow-indicator-disabled");
+      }
+      return;
+    }
+    if (button.disabled) return;
+    button.disabled = true;
+    button.setAttribute("data-overflow-indicator-disabled", "");
+  }
+  #directionFromEvent(event) {
+    const params = event.params;
+    const direction = params?.direction;
+    return direction === "start" || direction === "end" ? direction : null;
+  }
+  #prefersReducedMotion() {
+    return typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  }
+};
+
+export { OverflowIndicatorController };
+//# sourceMappingURL=overflow_indicator_controller.js.map
+//# sourceMappingURL=overflow_indicator_controller.js.map