stimeo-ui 0.1.0.pre.alpha.1

data/dist/controllers/dialog_controller.js

@@ -0,0 +1,207 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/dialog_controller.ts
+
+// src/utils/focus_trap.ts
+var FOCUSABLE = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+var FocusTrap = class {
+  /** The element focused before activation, restored on deactivation. */
+  #previouslyFocused = null;
+  /** The body's inline `overflow` before locking, restored on deactivation. */
+  #previousBodyOverflow = "";
+  /** Whether scroll was locked this activation (so it is only restored if applied). */
+  #scrollLocked = false;
+  /** Background siblings made `inert` while active, restored on deactivation. */
+  #inertedSiblings = [];
+  /** Whether the modal side effects are currently applied. */
+  #activeState = false;
+  /** Returns the trapped element; called on every operation for the live target. */
+  #getContainer;
+  /** Closing/focus hooks; see {@link FocusTrapOptions}. */
+  #options;
+  /**
+   * @param getContainer - Returns the trapped element. Called on every operation
+   *   so the live target is always used.
+   * @param options - Closing/focus hooks; see {@link FocusTrapOptions}.
+   */
+  constructor(getContainer, options = {}) {
+    this.#getContainer = getContainer;
+    this.#options = options;
+  }
+  /** Whether the trap is currently active. */
+  get active() {
+    return this.#activeState;
+  }
+  /**
+   * Applies the trap: records the current focus, optionally locks background scroll
+   * and makes background siblings `inert`, listens for `Tab`/`Escape`, and (unless
+   * `autoFocus` is off) moves focus inside. No-ops if already active.
+   */
+  activate() {
+    if (this.#activeState) return;
+    this.#activeState = true;
+    const active = document.activeElement;
+    this.#previouslyFocused = active instanceof HTMLElement && active !== document.body ? active : null;
+    if (this.#flag(this.#options.lockScroll, true)) {
+      this.#previousBodyOverflow = document.body.style.overflow;
+      document.body.style.overflow = "hidden";
+      this.#scrollLocked = true;
+    }
+    if (this.#flag(this.#options.isolate, true)) this.#isolateBackground();
+    document.addEventListener("keydown", this.#onKeydown);
+    if (this.#flag(this.#options.autoFocus, true)) this.#focusInitial();
+  }
+  /**
+   * Reverts every side effect applied by {@link activate}. No-ops if inactive, so
+   * a controller can call it defensively from both `close()` and `disconnect()`.
+   *
+   * @param restoreFocus - Move focus back to the opener (default `true`). Pass
+   *   `false` on teardown (`disconnect`), where yanking focus is undesirable.
+   */
+  deactivate({ restoreFocus = true } = {}) {
+    if (!this.#activeState) return;
+    this.#activeState = false;
+    document.removeEventListener("keydown", this.#onKeydown);
+    if (this.#scrollLocked) {
+      document.body.style.overflow = this.#previousBodyOverflow;
+      this.#scrollLocked = false;
+    }
+    this.#releaseBackground();
+    if (restoreFocus) {
+      const target = this.#previouslyFocused ?? this.#options.fallbackFocus?.() ?? null;
+      target?.focus();
+    }
+  }
+  /** Resolves a boolean-or-getter option, defaulting when it was not provided. */
+  #flag(option, fallback) {
+    if (option === void 0) return fallback;
+    return typeof option === "function" ? option() : option;
+  }
+  /** Handles `Escape` (delegated) and `Tab` (focus trap) while active. */
+  #onKeydown = (event) => {
+    if (event.key === "Escape") {
+      if (this.#options.onEscape) {
+        event.preventDefault();
+        this.#options.onEscape();
+      }
+      return;
+    }
+    if (event.key === "Tab") this.#trapTab(event);
+  };
+  /** Keeps `Tab` focus cycling within the container's focusable elements. */
+  #trapTab(event) {
+    const focusable = this.#focusableElements();
+    if (focusable.length === 0) {
+      event.preventDefault();
+      return;
+    }
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+    if (!(active instanceof Node) || !this.#getContainer().contains(active)) {
+      event.preventDefault();
+      first?.focus();
+      return;
+    }
+    if (event.shiftKey && active === first) {
+      event.preventDefault();
+      last?.focus();
+    } else if (!event.shiftKey && active === last) {
+      event.preventDefault();
+      first?.focus();
+    }
+  }
+  /**
+   * Marks every element outside the container's subtree as `inert` so background
+   * content cannot be focused or reached by assistive technology, honoring the
+   * `aria-modal="true"` contract. An element that was *already* `inert` is left
+   * untracked so `#releaseBackground` does not wrongly clear it.
+   */
+  #isolateBackground() {
+    const container = this.#getContainer();
+    this.#inertedSiblings = [];
+    for (const sibling of Array.from(document.body.children)) {
+      if (!(sibling instanceof HTMLElement)) continue;
+      if (sibling.contains(container) || sibling.inert) continue;
+      sibling.inert = true;
+      this.#inertedSiblings.push(sibling);
+    }
+  }
+  /** Reverts the `inert` flags applied by `#isolateBackground`. */
+  #releaseBackground() {
+    for (const sibling of this.#inertedSiblings) {
+      sibling.inert = false;
+    }
+    this.#inertedSiblings = [];
+  }
+  /** Moves focus to the initial target, the first focusable, or the container. */
+  #focusInitial() {
+    const preferred = this.#options.initialFocus?.();
+    if (preferred) {
+      preferred.focus();
+      return;
+    }
+    const focusable = this.#focusableElements();
+    if (focusable[0]) {
+      focusable[0].focus();
+      return;
+    }
+    const container = this.#getContainer();
+    container.tabIndex = -1;
+    container.focus();
+  }
+  /** Collects the container's currently focusable descendants in DOM order. */
+  #focusableElements() {
+    return Array.from(this.#getContainer().querySelectorAll(FOCUSABLE)).filter(
+      (el) => !el.hidden
+    );
+  }
+};
+
+// src/controllers/dialog_controller.ts
+var DialogController = class extends Controller {
+  static targets = ["trigger", "dialog"];
+  static actions = ["close", "closeOnBackdrop", "open"];
+  /** Owns the modal side effects; Escape closes, focus falls back to the trigger. */
+  #trap = new FocusTrap(() => this.dialogTarget, {
+    onEscape: () => this.close(),
+    fallbackFocus: () => this.hasTriggerTarget ? this.triggerTarget : null
+  });
+  /** Starts closed (idempotently reflects the closed state on the markup). */
+  connect() {
+    if (this.hasDialogTarget) this.dialogTarget.hidden = true;
+  }
+  /**
+   * Reverts the modal side effects (scroll lock, background `inert`, keydown
+   * listener) if the controller is torn down while open (e.g. a Turbo navigation
+   * replaces the page while the dialog is showing). Focus is not restored on
+   * teardown.
+   */
+  disconnect() {
+    this.#trap.deactivate({ restoreFocus: false });
+  }
+  /** Opens the dialog, traps focus, and locks background scroll. */
+  open() {
+    if (!this.hasDialogTarget || this.#isOpen) return;
+    this.dialogTarget.hidden = false;
+    this.#trap.activate();
+  }
+  /** Closes the dialog, restores scroll, and returns focus to the opener. */
+  close() {
+    if (!this.hasDialogTarget || !this.#isOpen) return;
+    this.dialogTarget.hidden = true;
+    this.#trap.deactivate();
+  }
+  /** Closes when the backdrop (the dialog target itself) is clicked. */
+  closeOnBackdrop(event) {
+    if (event.target === this.dialogTarget) this.close();
+  }
+  /** Whether the dialog is currently visible. */
+  get #isOpen() {
+    return this.hasDialogTarget && !this.dialogTarget.hidden;
+  }
+};
+
+export { DialogController };
+//# sourceMappingURL=dialog_controller.js.map
+//# sourceMappingURL=dialog_controller.js.map

data/dist/controllers/direct_upload_controller.js

@@ -0,0 +1,212 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/direct_upload_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);
+  }
+};
+
+// src/controllers/direct_upload_controller.ts
+var REMOVE_DELAY = 4e3;
+var DirectUploadController = class extends Controller {
+  static targets = ["list", "row", "status"];
+  static values = {
+    announce: { type: Boolean, default: true },
+    removeOnDone: { type: Boolean, default: false },
+    doneLabel: { type: String, default: "" },
+    errorLabel: { type: String, default: "" },
+    scope: { type: String, default: "" }
+  };
+  static events = ["progress", "done", "error"];
+  #timeouts = new SafeTimeout();
+  #rows = /* @__PURE__ */ new Map();
+  #onInitialize = (event) => {
+    if (!this.#inScope(event)) return;
+    const detail = this.#detail(event);
+    this.#rowFor(detail.id, detail.file?.name ?? "");
+  };
+  #onProgress = (event) => {
+    if (!this.#inScope(event)) return;
+    const detail = this.#detail(event);
+    this.#updateProgress(this.#key(detail.id), Math.round(detail.progress ?? 0));
+  };
+  #onError = (event) => {
+    if (!this.#inScope(event)) return;
+    const detail = this.#detail(event);
+    this.#fail(this.#key(detail.id), detail.error ?? "");
+  };
+  #onEnd = (event) => {
+    if (!this.#inScope(event)) return;
+    const detail = this.#detail(event);
+    this.#complete(this.#key(detail.id), detail.file?.name ?? "");
+  };
+  connect() {
+    document.addEventListener("direct-upload:initialize", this.#onInitialize);
+    document.addEventListener("direct-upload:progress", this.#onProgress);
+    document.addEventListener("direct-upload:error", this.#onError);
+    document.addEventListener("direct-upload:end", this.#onEnd);
+  }
+  disconnect() {
+    document.removeEventListener("direct-upload:initialize", this.#onInitialize);
+    document.removeEventListener("direct-upload:progress", this.#onProgress);
+    document.removeEventListener("direct-upload:error", this.#onError);
+    document.removeEventListener("direct-upload:end", this.#onEnd);
+    this.#timeouts.clearAll();
+    this.#rows.clear();
+  }
+  /** Updates a row's progress and the aggregate, emitting `progress`. */
+  #updateProgress(id, percent) {
+    const row = this.#rowFor(id);
+    if (row === null) return;
+    const clamped = Math.max(0, Math.min(100, percent));
+    row.setAttribute("aria-valuenow", String(clamped));
+    row.setAttribute("aria-valuetext", `${clamped}%`);
+    row.style.setProperty("--stimeo-upload-progress", `${clamped}%`);
+    this.#setField(row, "percent", `${clamped}%`);
+    this.#syncAggregate();
+    this.dispatch("progress", { detail: { id, percent: clamped } });
+  }
+  /** Marks a row done, announces it, and emits `done`. */
+  #complete(id, name = "") {
+    const row = this.#rowFor(id, name);
+    if (row === null) return;
+    row.setAttribute("data-upload-state", "done");
+    this.#announce(this.doneLabelValue, row);
+    this.dispatch("done", { detail: { id } });
+    if (this.removeOnDoneValue) {
+      this.#timeouts.set(() => this.#removeRow(id), REMOVE_DELAY);
+    }
+  }
+  /** Marks a row failed, announces it, and emits `error`. */
+  #fail(id, error) {
+    const row = this.#rowFor(id);
+    if (row === null) return;
+    row.setAttribute("data-upload-state", "error");
+    this.#announce(this.errorLabelValue, row);
+    this.dispatch("error", { detail: { id, error } });
+  }
+  /** Returns an existing row or clones one from the template. */
+  #rowFor(id, name) {
+    const key = this.#key(id);
+    const existing = this.#rows.get(key);
+    if (existing !== void 0) return existing;
+    if (!this.hasRowTarget || !this.hasListTarget) return null;
+    const clone = this.rowTarget.content.firstElementChild?.cloneNode(true);
+    if (!(clone instanceof HTMLElement)) return null;
+    if (name !== void 0 && name.length > 0) {
+      this.#setField(clone, "name", name);
+      clone.setAttribute("aria-label", name);
+    }
+    clone.setAttribute("aria-valuenow", "0");
+    clone.setAttribute("data-upload-state", "uploading");
+    clone.style.setProperty("--stimeo-upload-progress", "0%");
+    this.listTarget.appendChild(clone);
+    this.#rows.set(key, clone);
+    return clone;
+  }
+  #removeRow(id) {
+    const row = this.#rows.get(id);
+    if (row === void 0) return;
+    row.remove();
+    this.#rows.delete(id);
+    this.#syncAggregate();
+  }
+  /** Reflects the average progress across rows on the controller element. */
+  #syncAggregate() {
+    if (this.#rows.size === 0) {
+      this.element.removeAttribute("data-upload-progress");
+      return;
+    }
+    let total = 0;
+    for (const row of this.#rows.values()) {
+      total += Number(row.getAttribute("aria-valuenow") ?? "0");
+    }
+    const overall = Math.round(total / this.#rows.size);
+    this.element.setAttribute("data-upload-progress", String(overall));
+    this.element.style.setProperty("--stimeo-upload-progress", `${overall}%`);
+  }
+  /** Writes a consumer label (with `%{name}` substituted) to the status region. */
+  #announce(label, row) {
+    if (!this.announceValue || !this.hasStatusTarget || label.length === 0) return;
+    const name = this.#field(row, "name")?.textContent ?? "";
+    this.statusTarget.textContent = label.replace("%{name}", name);
+  }
+  #field(row, name) {
+    return row.querySelector(`[data-field="${name}"]`);
+  }
+  #setField(row, name, text) {
+    const field = this.#field(row, name);
+    if (field !== null) field.textContent = text;
+  }
+  #detail(event) {
+    return event.detail ?? {};
+  }
+  /**
+   * Whether an event belongs to this controller. With `scope` set, only events
+   * whose target (the file input) sits inside an element matching `scope` are
+   * handled, so several upload widgets on one page do not cross-populate. Resolved
+   * with `closest()` from the target itself, so the chatty `progress` stream never
+   * pays a document-wide query. Empty `scope` handles all.
+   */
+  #inScope(event) {
+    if (this.scopeValue.length === 0) return true;
+    const target = event.target;
+    return target instanceof Element && target.closest(this.scopeValue) !== null;
+  }
+  #key(id) {
+    return String(id ?? "");
+  }
+};
+
+export { DirectUploadController };
+//# sourceMappingURL=direct_upload_controller.js.map
+//# sourceMappingURL=direct_upload_controller.js.map

data/dist/controllers/dirty_form_controller.js

@@ -0,0 +1,128 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/dirty_form_controller.ts
+var DirtyFormController = class extends Controller {
+  static values = {
+    message: { type: String, default: "You have unsaved changes that will be lost." },
+    confirmBridge: { type: Boolean, default: false }
+  };
+  static actions = ["markClean"];
+  static events = ["dirty", "guard"];
+  #baseline = "";
+  #dirty = false;
+  #beforeunloadBound = false;
+  /** True between a form `submit` and its `turbo:submit-end`, suppressing the guard. */
+  #submitting = false;
+  #onFieldChange = () => {
+    this.#submitting = false;
+    this.#evaluate();
+  };
+  #onSubmit = () => {
+    this.#submitting = true;
+  };
+  #onBeforeVisit = (event) => {
+    this.#guardVisit(event);
+  };
+  #onSubmitEnd = (event) => {
+    this.#submitting = false;
+    const success = event.detail?.success;
+    if (success !== false) this.markClean();
+  };
+  #onBeforeUnload = (event) => {
+    if (!this.#dirty || this.#submitting) return;
+    event.preventDefault();
+    event.returnValue = this.messageValue;
+  };
+  connect() {
+    this.#baseline = this.#serialize();
+    this.element.removeAttribute("data-dirty");
+    this.element.addEventListener("input", this.#onFieldChange);
+    this.element.addEventListener("change", this.#onFieldChange);
+    this.element.addEventListener("submit", this.#onSubmit);
+    this.element.addEventListener("turbo:submit-end", this.#onSubmitEnd);
+    document.addEventListener("turbo:before-visit", this.#onBeforeVisit);
+  }
+  disconnect() {
+    this.element.removeEventListener("input", this.#onFieldChange);
+    this.element.removeEventListener("change", this.#onFieldChange);
+    this.element.removeEventListener("submit", this.#onSubmit);
+    this.element.removeEventListener("turbo:submit-end", this.#onSubmitEnd);
+    document.removeEventListener("turbo:before-visit", this.#onBeforeVisit);
+    this.#unbindBeforeUnload();
+  }
+  /** Re-baselines to the current values and clears the dirty state (e.g. after a save). */
+  markClean() {
+    this.#baseline = this.#serialize();
+    this.#setDirty(false);
+  }
+  /** Recomputes dirty against the baseline and flips state when it changes. */
+  #evaluate() {
+    this.#setDirty(this.#serialize() !== this.#baseline);
+  }
+  #setDirty(dirty) {
+    if (dirty === this.#dirty) return;
+    this.#dirty = dirty;
+    if (dirty) {
+      this.element.setAttribute("data-dirty", "true");
+      this.#bindBeforeUnload();
+    } else {
+      this.element.removeAttribute("data-dirty");
+      this.#unbindBeforeUnload();
+    }
+    this.dispatch("dirty", { detail: { dirty } });
+  }
+  /** Guards a Turbo visit while dirty: consumer cancel → confirmBridge → confirm. */
+  #guardVisit(event) {
+    if (!this.#dirty || this.#submitting) return;
+    const guard = this.dispatch("guard", { detail: { event }, cancelable: true });
+    if (guard.defaultPrevented) {
+      event.preventDefault();
+      return;
+    }
+    if (this.confirmBridgeValue) {
+      event.preventDefault();
+      return;
+    }
+    if (!window.confirm(this.messageValue)) {
+      event.preventDefault();
+    }
+  }
+  #bindBeforeUnload() {
+    if (this.#beforeunloadBound) return;
+    window.addEventListener("beforeunload", this.#onBeforeUnload);
+    this.#beforeunloadBound = true;
+  }
+  #unbindBeforeUnload() {
+    if (!this.#beforeunloadBound) return;
+    window.removeEventListener("beforeunload", this.#onBeforeUnload);
+    this.#beforeunloadBound = false;
+  }
+  /** Stable serialization of the form's controls for change detection. */
+  #serialize() {
+    const parts = [];
+    for (const el of Array.from(this.element.elements)) {
+      const name = this.#nameOf(el);
+      if (name === null) continue;
+      if (el instanceof HTMLInputElement && (el.type === "checkbox" || el.type === "radio")) {
+        parts.push(`${name}:${el.checked ? 1 : 0}`);
+      } else if (el instanceof HTMLSelectElement) {
+        const value = el.multiple ? Array.from(el.selectedOptions).map((o) => o.value).join(",") : el.value;
+        parts.push(`${name}:${value}`);
+      } else if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+        parts.push(`${name}:${el.value}`);
+      }
+    }
+    return parts.join("|");
+  }
+  /** A stable key for a control, or null for elements without value semantics. */
+  #nameOf(el) {
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+      return el.name || el.id || "";
+    }
+    return null;
+  }
+};
+
+export { DirtyFormController };
+//# sourceMappingURL=dirty_form_controller.js.map
+//# sourceMappingURL=dirty_form_controller.js.map

data/dist/controllers/dropdown_controller.js

@@ -0,0 +1,66 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/dropdown_controller.ts
+var DropdownController = class extends Controller {
+  static targets = ["trigger", "menu"];
+  static actions = ["close", "open", "toggle"];
+  /** Closes the menu when a click lands outside the controller's element. */
+  #onOutsideClick = (event) => {
+    if (!this.element.contains(event.target)) {
+      this.close();
+    }
+  };
+  /** Closes the menu on `Escape` and restores focus to the trigger. */
+  #onKeydown = (event) => {
+    if (event.key === "Escape" && this.#isOpen) {
+      this.close();
+      if (this.hasTriggerTarget) this.triggerTarget.focus();
+    }
+  };
+  /**
+   * Starts in the closed state and registers the document-level listeners that
+   * power outside-click and `Escape` handling.
+   */
+  connect() {
+    this.close();
+    document.addEventListener("click", this.#onOutsideClick);
+    document.addEventListener("keydown", this.#onKeydown);
+  }
+  /** Removes the document-level listeners registered in {@link connect}. */
+  disconnect() {
+    document.removeEventListener("click", this.#onOutsideClick);
+    document.removeEventListener("keydown", this.#onKeydown);
+  }
+  /** Toggles the menu between open and closed. Bound via `data-action`. */
+  toggle() {
+    if (this.#isOpen) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+  /** Reveals the menu and reflects the open state on the trigger. */
+  open() {
+    if (!this.hasMenuTarget) return;
+    this.menuTarget.hidden = false;
+    if (this.hasTriggerTarget) {
+      this.triggerTarget.setAttribute("aria-expanded", "true");
+    }
+  }
+  /** Hides the menu and reflects the closed state on the trigger. */
+  close() {
+    if (!this.hasMenuTarget) return;
+    this.menuTarget.hidden = true;
+    if (this.hasTriggerTarget) {
+      this.triggerTarget.setAttribute("aria-expanded", "false");
+    }
+  }
+  /** Whether the menu is currently visible. */
+  get #isOpen() {
+    return this.hasMenuTarget && !this.menuTarget.hidden;
+  }
+};
+
+export { DropdownController };
+//# sourceMappingURL=dropdown_controller.js.map
+//# sourceMappingURL=dropdown_controller.js.map

data/dist/controllers/empty_state_controller.js

@@ -0,0 +1,67 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/empty_state_controller.ts
+var EmptyStateController = class extends Controller {
+  static targets = ["list", "empty"];
+  static values = {
+    itemSelector: { type: String, default: "" },
+    announce: { type: Boolean, default: false }
+  };
+  static events = ["change"];
+  #observer = null;
+  /** Last applied empty state; `null` until the first sync so connect emits nothing. */
+  #empty = null;
+  connect() {
+    if (!this.hasListTarget) return;
+    if (this.announceValue && this.hasEmptyTarget && !this.#isLiveRegion(this.emptyTarget)) {
+      this.emptyTarget.setAttribute("role", "status");
+      this.emptyTarget.setAttribute("aria-live", "polite");
+    }
+    if (typeof MutationObserver !== "undefined") {
+      this.#observer = new MutationObserver(() => this.#apply());
+      this.#observer.observe(this.listTarget, { childList: true });
+    }
+    this.#apply();
+  }
+  disconnect() {
+    this.#observer?.disconnect();
+    this.#observer = null;
+  }
+  /** Recomputes the count and syncs visibility, hooks, and the change event. */
+  #apply() {
+    if (!this.hasListTarget) return;
+    const count = this.#count();
+    const empty = count === 0;
+    this.element.setAttribute("data-count", String(count));
+    if (empty) {
+      this.element.setAttribute("data-empty", "true");
+    } else {
+      this.element.removeAttribute("data-empty");
+    }
+    this.listTarget.hidden = empty;
+    if (this.hasEmptyTarget) this.emptyTarget.hidden = !empty;
+    if (this.#empty !== null && empty !== this.#empty) {
+      this.dispatch("change", { detail: { count, empty } });
+    }
+    this.#empty = empty;
+  }
+  /** Item count: element children matching `itemSelector`, or all element children. */
+  #count() {
+    const selector = this.itemSelectorValue;
+    if (selector.length === 0) return this.listTarget.childElementCount;
+    try {
+      return Array.from(this.listTarget.children).filter((child) => child.matches(selector)).length;
+    } catch {
+      return this.listTarget.childElementCount;
+    }
+  }
+  #isLiveRegion(el) {
+    if (el.hasAttribute("aria-live")) return true;
+    const role = el.getAttribute("role");
+    return role === "status" || role === "alert";
+  }
+};
+
+export { EmptyStateController };
+//# sourceMappingURL=empty_state_controller.js.map
+//# sourceMappingURL=empty_state_controller.js.map