stimeo-ui 0.1.0.pre.beta.1 → 0.1.0.pre.beta.2

data/dist/cable/index.js

@@ -0,0 +1,563 @@
+import { Controller } from '@hotwired/stimulus';
+import { createConsumer } from '@rails/actioncable';
+
+// src/cable/live_counter_controller.ts
+var sharedConsumer = null;
+function setCableConsumer(consumer) {
+  sharedConsumer = consumer;
+}
+function getCableConsumer() {
+  if (!sharedConsumer) sharedConsumer = createConsumer();
+  return sharedConsumer;
+}
+function createConfirmedSubscription(channel, mixin) {
+  let confirmed = false;
+  let rejected = false;
+  const subscription = getCableConsumer().subscriptions.create(channel, {
+    // A refusal is final: Action Cable never confirms a rejected subscription,
+    // so a late connected/disconnected (only possible from a misbehaving
+    // consumer double) must not reopen the gate `rejected` promised shut.
+    connected: () => {
+      if (rejected) return;
+      confirmed = true;
+      mixin.connected?.();
+    },
+    disconnected: () => {
+      if (rejected) return;
+      confirmed = false;
+      mixin.disconnected?.();
+    },
+    rejected: () => {
+      confirmed = false;
+      rejected = true;
+      mixin.rejected?.();
+    },
+    received: (data) => mixin.received?.(data)
+  });
+  return {
+    perform: (action, data) => subscription.perform(action, data),
+    unsubscribe: () => subscription.unsubscribe(),
+    get confirmed() {
+      return confirmed;
+    },
+    get rejected() {
+      return rejected;
+    }
+  };
+}
+
+// src/cable/live_counter_controller.ts
+var DISABLED_MARKER = "data-live-counter-disabled";
+var LiveCounterController = class extends Controller {
+  static targets = ["value", "trigger"];
+  static values = {
+    channel: { type: String, default: "" },
+    params: { type: Object, default: {} },
+    id: { type: String, default: "" }
+  };
+  static actions = ["increment"];
+  static events = ["change"];
+  #subscription = null;
+  connect() {
+    this.element.removeAttribute("data-live-counter-rejected");
+    if (this.channelValue) {
+      this.#subscription = createConfirmedSubscription(
+        { channel: this.channelValue, ...this.paramsValue },
+        {
+          connected: () => this.#syncTriggers(),
+          // A drop closes the send window (the shared subscription tracks it)
+          // until Action Cable reconnects and re-confirms — an increment during
+          // the outage would bump the display while its perform() is silently
+          // discarded by the closed socket.
+          disconnected: () => this.#syncTriggers(),
+          // The server refused the subscription (auth, bad params): the gate
+          // stays shut for good, and the hook lets the consumer's CSS disable
+          // or hide the trigger instead of leaving a silently dead button.
+          rejected: () => {
+            this.element.setAttribute("data-live-counter-rejected", "true");
+            this.#syncTriggers();
+          },
+          received: (data) => this.#onReceived(data)
+        }
+      );
+    }
+    this.#syncTriggers();
+  }
+  disconnect() {
+    this.#subscription?.unsubscribe();
+    this.#subscription = null;
+    this.element.removeAttribute("data-live-counter-rejected");
+  }
+  /** Late-added triggers (e.g. via a Turbo Stream) pick up the current gate. */
+  triggerTargetConnected(target) {
+    this.#syncTrigger(target);
+  }
+  /**
+   * Optimistic local increment: bumps the display immediately, then asks the
+   * server to persist and broadcast. The step comes from the action param
+   * (`data-stimeo--live-counter-delta-param`), default 1. Bound via `data-action`.
+   */
+  increment(event) {
+    if (this.#subscription && !this.#subscription.confirmed) return;
+    const raw = Number(event?.params?.delta ?? 1);
+    const delta = Number.isFinite(raw) ? raw : 1;
+    if (!this.#subscription || this.idValue !== "") {
+      this.#write(this.#current + delta);
+    }
+    this.#subscription?.perform("increment", { id: this.idValue, delta });
+  }
+  /** Reconciles a broadcast: absolute `count` wins; own-echo deltas are skipped. */
+  #onReceived(data) {
+    const message = data;
+    if (typeof message?.count === "number") {
+      this.#write(message.count);
+      return;
+    }
+    if (typeof message?.delta === "number") {
+      if (typeof message.by === "string" && message.by !== "" && message.by === this.idValue) {
+        return;
+      }
+      this.#write(this.#current + message.delta);
+    }
+  }
+  /** True while an increment would go through (channel-less counters always are). */
+  get #ready() {
+    return !this.#subscription || this.#subscription.confirmed;
+  }
+  /**
+   * Reflects the send gate onto the optional `trigger` targets as the real
+   * `disabled` attribute — the declarative alternative to styling off the
+   * `data-live-counter-rejected` hook (a disabled control is also skipped by
+   * keyboard focus and announced by AT, which CSS alone cannot do).
+   */
+  #syncTriggers() {
+    for (const trigger of this.triggerTargets) this.#syncTrigger(trigger);
+  }
+  /**
+   * `disabled` is a shared attribute: only disable what is currently enabled
+   * (marking it ours), and only lift a disabled carrying our marker — so an
+   * authored-disabled trigger ("disabled until valid", say) is never
+   * re-enabled by the gate. A marked disabled restored from a Turbo cache
+   * snapshot is recognized as ours and lifted once the gate opens.
+   */
+  #syncTrigger(trigger) {
+    if (this.#ready) {
+      if (trigger.hasAttribute(DISABLED_MARKER)) {
+        trigger.removeAttribute("disabled");
+        trigger.removeAttribute(DISABLED_MARKER);
+      }
+    } else if (!trigger.hasAttribute("disabled")) {
+      trigger.setAttribute("disabled", "");
+      trigger.setAttribute(DISABLED_MARKER, "");
+    }
+  }
+  /** The displayed element: the `value` target, else the controller element. */
+  get #display() {
+    return this.hasValueTarget ? this.valueTarget : this.element;
+  }
+  /** The current count, parsed from the DOM (the single source of truth). */
+  get #current() {
+    const parsed = Number.parseInt((this.#display.textContent ?? "").replace(/[^0-9-]/g, ""), 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  #write(count) {
+    if (count === this.#current) return;
+    this.#display.textContent = String(count);
+    this.dispatch("change", { detail: { count } });
+  }
+};
+
+// 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/cable/presence_controller.ts
+var BEACON_THROTTLE_MS = 2e3;
+var PresenceController = class extends Controller {
+  static targets = ["count", "list", "template"];
+  static values = {
+    channel: { type: String, default: "" },
+    params: { type: Object, default: {} },
+    id: { type: String, default: "" },
+    name: { type: String, default: "" },
+    heartbeat: { type: Number, default: 15e3 },
+    timeout: { type: Number, default: 4e4 }
+  };
+  static events = ["join", "leave", "change"];
+  #subscription = null;
+  /** Present peers keyed by id (insertion order = join order). */
+  #peers = /* @__PURE__ */ new Map();
+  #timers = new SafeTimeout();
+  #intervals = new SafeInterval();
+  /** Epoch ms of the last outgoing beacon, for the convergence throttle. */
+  #lastBeaconAt = 0;
+  /** Pending trailing-edge convergence beacon (at most one queued). */
+  #pendingBeacon = null;
+  connect() {
+    this.#reset();
+    this.element.removeAttribute("data-presence-rejected");
+    if (this.hasCountTarget) this.countTarget.textContent = this.#countMessage(0);
+    if (!this.channelValue) return;
+    this.#subscription = createConfirmedSubscription(
+      { channel: this.channelValue, ...this.paramsValue },
+      {
+        // The first beacon must wait for the confirmed subscription — a
+        // perform() before that is silently dropped by Action Cable. Fires
+        // again on every reconnect, so the roster self-heals after an outage.
+        connected: () => this.#beacon(true),
+        // The server refused the subscription: no beacon will ever go through,
+        // and the hook lets the consumer's CSS reflect the dead stream.
+        rejected: () => {
+          this.element.setAttribute("data-presence-rejected", "true");
+        },
+        received: (data) => this.#onReceived(data)
+      }
+    );
+    this.#intervals.set(() => this.#beacon(true), this.heartbeatValue);
+    window.addEventListener("pagehide", this.#onPageHide);
+  }
+  disconnect() {
+    window.removeEventListener("pagehide", this.#onPageHide);
+    this.#sendLeaveNotice();
+    this.#subscription?.unsubscribe();
+    this.#subscription = null;
+    this.#intervals.clearAll();
+    this.#reset();
+    this.element.removeAttribute("data-presence-rejected");
+  }
+  /**
+   * Sends the best-effort leaving notice (skipped without an own `id`, and
+   * outside the confirmed window, where Action Cable would discard it anyway).
+   */
+  #sendLeaveNotice() {
+    if (!this.#subscription?.confirmed || !this.idValue) return;
+    this.#subscription.perform("appear", { id: this.idValue, leaving: true });
+  }
+  /**
+   * `pagehide` covers the leaves `disconnect()` cannot see: closing the tab or
+   * a hard (non-Turbo) navigation destroys the page without running Stimulus
+   * teardown, so this listener is the only chance to announce them. Best-effort
+   * by nature (the socket may close before the frame flushes); peers' expiry
+   * timers stay the safety net. If the page enters the bfcache and is restored
+   * instead, the next heartbeat re-announces this client, so an over-eager
+   * leave self-heals.
+   */
+  #onPageHide = () => {
+    this.#sendLeaveNotice();
+  };
+  /**
+   * Broadcasts this client's beacon (skipped without an own `id`). A throttled
+   * convergence answer is deferred to the trailing edge rather than dropped —
+   * otherwise a peer joining right after a heartbeat would not learn about
+   * this client until the next full heartbeat period.
+   *
+   * Gated on the confirmed subscription: before confirmation and during an
+   * outage Action Cable silently discards perform(), so a beacon sent then is
+   * pure waste — worse, it would burn `#lastBeaconAt` and delay the next real
+   * convergence answer by up to the throttle window. The heartbeat interval
+   * keeps ticking regardless; `connected` re-fires on reconfirm and
+   * force-beacons immediately, so a gated tick is never missed for long.
+   */
+  #beacon(force) {
+    if (!this.#subscription?.confirmed || !this.idValue) return;
+    const now = Date.now();
+    const wait = BEACON_THROTTLE_MS - (now - this.#lastBeaconAt);
+    if (!force && wait > 0) {
+      if (this.#pendingBeacon === null) {
+        this.#pendingBeacon = this.#timers.set(() => {
+          this.#pendingBeacon = null;
+          this.#beacon(true);
+        }, wait);
+      }
+      return;
+    }
+    this.#lastBeaconAt = now;
+    this.#subscription.perform("appear", { id: this.idValue, name: this.nameValue });
+  }
+  /**
+   * Tracks a broadcast beacon: upserts the peer (restarting its expiry timer),
+   * removes it on a `leaving` notice, and re-announces this client when the
+   * peer was unknown (roster convergence — see the class doc).
+   */
+  #onReceived(data) {
+    const beacon = data;
+    const id = beacon?.id;
+    if (typeof id !== "string" || id === "" || id === this.idValue) return;
+    if (beacon?.leaving === true) {
+      this.#drop(id);
+      return;
+    }
+    const name = typeof beacon?.name === "string" ? beacon.name : "";
+    const existing = this.#peers.get(id);
+    if (existing !== void 0) this.#timers.clear(existing.timer);
+    const timer = this.#timers.set(() => this.#drop(id), this.timeoutValue);
+    this.#peers.set(id, { name, timer });
+    if (existing === void 0) {
+      this.#appendClone(id, name);
+      this.#render();
+      this.dispatch("join", { detail: { id, name } });
+      this.#beacon(false);
+    } else if (existing.name !== name) {
+      this.#updateClone(id, name);
+      this.#render();
+    }
+  }
+  /** Removes a peer (expiry or graceful leave) and reflects the change. */
+  #drop(id) {
+    const peer = this.#peers.get(id);
+    if (peer === void 0) return;
+    this.#timers.clear(peer.timer);
+    this.#peers.delete(id);
+    this.#removeClone(id);
+    this.#render();
+    this.dispatch("leave", { detail: { id } });
+  }
+  /** Reflects the roster onto the hooks + count target and emits `change`. */
+  #render() {
+    const users = [...this.#peers.entries()].map(([id, peer]) => ({ id, name: peer.name }));
+    this.element.setAttribute("data-present", users.length > 0 ? "true" : "false");
+    this.element.setAttribute("data-present-count", String(users.length));
+    if (this.hasCountTarget) this.countTarget.textContent = this.#countMessage(users.length);
+    this.dispatch("change", { detail: { users } });
+  }
+  /**
+   * Builds the count copy. Localizable through `data-zero` / `data-one` /
+   * `data-other` templates on the count target (`%{count}`); the bare number is
+   * the fallback (copy-free, so nothing to localize by default).
+   */
+  #countMessage(count) {
+    const templates = this.countTarget.dataset;
+    const template = (count === 0 ? templates.zero : count === 1 ? templates.one : templates.other) ?? templates.other;
+    return template ? template.replace("%{count}", String(count)) : String(count);
+  }
+  /** Appends one template clone for a newly present peer (list + template only). */
+  #appendClone(id, name) {
+    if (!this.hasListTarget || !this.hasTemplateTarget) return;
+    const clone = this.templateTarget.content.cloneNode(true);
+    const root = clone.firstElementChild;
+    if (!root) return;
+    root.setAttribute("data-presence-id", id);
+    this.#fillName(root, name);
+    this.listTarget.appendChild(clone);
+  }
+  #updateClone(id, name) {
+    const root = this.#cloneFor(id);
+    if (root) this.#fillName(root, name);
+  }
+  #removeClone(id) {
+    this.#cloneFor(id)?.remove();
+  }
+  #cloneFor(id) {
+    if (!this.hasListTarget) return null;
+    for (const child of this.listTarget.querySelectorAll("[data-presence-id]")) {
+      if (child.getAttribute("data-presence-id") === id) return child;
+    }
+    return null;
+  }
+  /** Writes the peer's name into the clone's `data-presence-name` slots. */
+  #fillName(root, name) {
+    const slots = root.querySelectorAll("[data-presence-name]");
+    for (const slot of slots) slot.textContent = name;
+    if (slots.length === 0 && root.hasAttribute("data-presence-name")) {
+      root.textContent = name;
+    }
+  }
+  /** Clears the transient roster state (connect reset + disconnect teardown). */
+  #reset() {
+    this.#timers.clearAll();
+    this.#pendingBeacon = null;
+    this.#peers.clear();
+    this.#lastBeaconAt = 0;
+    this.element.removeAttribute("data-present");
+    this.element.removeAttribute("data-present-count");
+    if (this.hasCountTarget) this.countTarget.textContent = "";
+    if (this.hasListTarget) {
+      for (const child of this.listTarget.querySelectorAll("[data-presence-id]")) {
+        child.remove();
+      }
+    }
+  }
+};
+var TypingIndicatorController = class extends Controller {
+  static targets = ["input", "status"];
+  static values = {
+    channel: { type: String, default: "" },
+    params: { type: Object, default: {} },
+    name: { type: String, default: "" },
+    timeout: { type: Number, default: 3e3 },
+    // Must stay below `timeout`: the throttle is leading-edge only (no trailing
+    // send), so a receiver's display survives continuous typing only while a
+    // fresh signal lands within its timeout window.
+    throttle: { type: Number, default: 2e3 }
+  };
+  static events = ["change"];
+  #subscription = null;
+  /** Names currently typing (other clients), each with its auto-clear timer id. */
+  #typers = /* @__PURE__ */ new Map();
+  #timers = new SafeTimeout();
+  /** Epoch ms of the last broadcast, for leading-edge throttling. */
+  #lastSentAt = 0;
+  connect() {
+    this.element.removeAttribute("data-typing");
+    this.element.removeAttribute("data-typing-indicator-rejected");
+    if (this.hasStatusTarget) this.statusTarget.textContent = "";
+    this.element.addEventListener("input", this.#onInput);
+    if (this.channelValue) {
+      this.#subscription = createConfirmedSubscription(
+        { channel: this.channelValue, ...this.paramsValue },
+        {
+          // The server refused the subscription: the send gate stays shut for
+          // good, and the hook lets the consumer's CSS reflect the dead stream.
+          rejected: () => {
+            this.element.setAttribute("data-typing-indicator-rejected", "true");
+          },
+          received: (data) => this.#onReceived(data)
+        }
+      );
+    }
+  }
+  disconnect() {
+    this.element.removeEventListener("input", this.#onInput);
+    this.#subscription?.unsubscribe();
+    this.#subscription = null;
+    this.#timers.clearAll();
+    this.#typers.clear();
+    this.element.removeAttribute("data-typing");
+    this.element.removeAttribute("data-typing-indicator-rejected");
+    if (this.hasStatusTarget) this.statusTarget.textContent = "";
+    this.#lastSentAt = 0;
+  }
+  /** Throttled (leading-edge) broadcast of this client's typing signal. */
+  #onInput = () => {
+    if (!this.#subscription?.confirmed) return;
+    const now = Date.now();
+    if (now - this.#lastSentAt < this.throttleValue) return;
+    this.#lastSentAt = now;
+    this.#subscription.perform("typing", { name: this.nameValue });
+  };
+  /**
+   * Tracks a broadcast typer. The own echo is dropped (same `name`); every
+   * further signal from a name restarts its auto-clear timer, so the indicator
+   * survives continuous typing and clears `timeout` ms after the last signal.
+   */
+  #onReceived(data) {
+    const name = data?.name;
+    if (typeof name !== "string" || name === "" || name === this.nameValue) return;
+    const existing = this.#typers.get(name);
+    if (existing !== void 0) this.#timers.clear(existing);
+    const added = existing === void 0;
+    this.#typers.set(
+      name,
+      this.#timers.set(() => this.#untrack(name), this.timeoutValue)
+    );
+    if (added) this.#render();
+  }
+  #untrack(name) {
+    this.#typers.delete(name);
+    this.#render();
+  }
+  /** Reflects the typer set onto the hook + live region and emits `change`. */
+  #render() {
+    const names = [...this.#typers.keys()];
+    this.element.setAttribute("data-typing", names.length > 0 ? "true" : "false");
+    if (this.hasStatusTarget) {
+      this.statusTarget.textContent = this.#message(names);
+    }
+    this.dispatch("change", { detail: { names } });
+  }
+  /**
+   * Builds the live-region copy. Localizable through `data-one` / `data-many`
+   * templates on the status target (`%{name}` / `%{names}` / `%{count}`); terse
+   * English is the fallback.
+   */
+  #message(names) {
+    if (names.length === 0) return "";
+    const joined = names.join(", ");
+    if (names.length === 1) {
+      const template2 = this.statusTarget.dataset.one;
+      const name = names[0] ?? "";
+      return template2 ? template2.replace("%{name}", name) : `${name} is typing\u2026`;
+    }
+    const template = this.statusTarget.dataset.many;
+    return template ? template.replace("%{names}", joined).replace("%{count}", String(names.length)) : `${joined} are typing\u2026`;
+  }
+};
+
+// src/cable/index.ts
+var cableControllers = {
+  "stimeo--live-counter": LiveCounterController,
+  "stimeo--presence": PresenceController,
+  "stimeo--typing-indicator": TypingIndicatorController
+};
+function registerCable(application) {
+  for (const [identifier, controller] of Object.entries(cableControllers)) {
+    application.register(identifier, controller);
+  }
+}
+
+export { LiveCounterController, PresenceController, TypingIndicatorController, cableControllers, createConfirmedSubscription, getCableConsumer, registerCable, setCableConsumer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

data/dist/controllers/combobox_controller.js

@@ -1,5 +1,19 @@
 import { Controller } from '@hotwired/stimulus';
 
+// src/controllers/combobox_controller.ts
+
+// src/utils/option_scroll.ts
+function scrollOptionIntoView(list, option) {
+  if (list.scrollHeight <= list.clientHeight) return;
+  const listRect = list.getBoundingClientRect();
+  const optionRect = option.getBoundingClientRect();
+  if (optionRect.top < listRect.top) {
+    list.scrollTop -= listRect.top - optionRect.top;
+  } else if (optionRect.bottom > listRect.bottom) {
+    list.scrollTop += optionRect.bottom - listRect.bottom;
+  }
+}
+
 // src/controllers/combobox_controller.ts
 var ComboboxController = class extends Controller {
   static targets = ["input", "list", "option"];
@@ -171,6 +185,7 @@ var ComboboxController = class extends Controller {
     } else {
       this.inputTarget.removeAttribute("aria-activedescendant");
     }
+    if (active && this.hasListTarget) scrollOptionIntoView(this.listTarget, active);
   }
   /** The options currently shown (not filtered out). */
   #visibleOptions() {

data/dist/controllers/count_up_controller.js

@@ -0,0 +1,86 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/count_up_controller.ts
+var CountUpController = class extends Controller {
+  static values = {
+    duration: { type: Number, default: 1200 },
+    from: { type: Number, default: 0 },
+    once: { type: Boolean, default: true }
+  };
+  static actions = ["start"];
+  static events = ["end"];
+  #frame = null;
+  /** The authored final text, restored verbatim when the run settles. */
+  #finalText = "";
+  connect() {
+    if (this.element.hasAttribute("data-count-up-label")) {
+      this.element.textContent = this.element.getAttribute("aria-label") ?? this.element.textContent;
+      this.#restoreLabel();
+      this.element.setAttribute("data-count-up-done", "true");
+    }
+  }
+  disconnect() {
+    if (this.#frame !== null) this.#settle();
+  }
+  /**
+   * Starts the animation (typically from `stimeo--intersection:enter` via
+   * `data-action`). No-ops while running, and after a finished run when `once`.
+   */
+  start() {
+    if (this.#frame !== null) return;
+    if (this.onceValue && this.element.hasAttribute("data-count-up-done")) return;
+    this.#finalText = this.element.textContent ?? "";
+    const target = Number.parseInt(this.#finalText.replace(/[^0-9-]/g, ""), 10);
+    if (Number.isNaN(target)) return;
+    if (window.matchMedia?.("(prefers-reduced-motion: reduce)").matches) {
+      this.element.setAttribute("data-count-up-done", "true");
+      this.dispatch("end", { detail: { value: target } });
+      return;
+    }
+    const authored = this.element.getAttribute("aria-label");
+    if (authored !== null) {
+      this.element.setAttribute("data-count-up-original-label", authored);
+    }
+    this.element.setAttribute("data-count-up-label", "true");
+    this.element.setAttribute("aria-label", this.#finalText);
+    const started = performance.now();
+    const step = (now) => {
+      const t = Math.min((now - started) / this.durationValue, 1);
+      const eased = 1 - (1 - t) ** 3;
+      this.element.textContent = String(
+        Math.round(this.fromValue + (target - this.fromValue) * eased)
+      );
+      if (t < 1) {
+        this.#frame = requestAnimationFrame(step);
+      } else {
+        this.#settle();
+        this.dispatch("end", { detail: { value: target } });
+      }
+    };
+    this.#frame = requestAnimationFrame(step);
+  }
+  /** Ends the run: cancels the frame and restores the authored presentation. */
+  #settle() {
+    if (this.#frame !== null) cancelAnimationFrame(this.#frame);
+    this.#frame = null;
+    this.element.textContent = this.#finalText;
+    this.#restoreLabel();
+    this.element.setAttribute("data-count-up-done", "true");
+  }
+  /** Releases the marker-owned aria-label, restoring any parked authored value. */
+  #restoreLabel() {
+    if (!this.element.hasAttribute("data-count-up-label")) return;
+    const original = this.element.getAttribute("data-count-up-original-label");
+    if (original !== null) {
+      this.element.setAttribute("aria-label", original);
+      this.element.removeAttribute("data-count-up-original-label");
+    } else {
+      this.element.removeAttribute("aria-label");
+    }
+    this.element.removeAttribute("data-count-up-label");
+  }
+};
+
+export { CountUpController };
+//# sourceMappingURL=count_up_controller.js.map
+//# sourceMappingURL=count_up_controller.js.map