stimeo-ui 0.16.0 → 0.18.0

data/dist/controllers/empty_state_controller.js

@@ -1,8 +1,12 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/empty_state_controller.ts
+function fillTemplate(template, values) {
+  return template.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (match, name) => {
+    const replacement = Object.hasOwn(values, name) ? values[name] : void 0;
+    return replacement === void 0 ? match : String(replacement);
+  });
+}
 
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -12,14 +16,77 @@ function announce(message, options = {}) {
     })
   );
 }
-function fillTemplate(template, values) {
-  return template.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (match, name) => {
-    const replacement = values[name];
-    return replacement === void 0 ? match : String(replacement);
-  });
-}
 
-// src/controllers/empty_state_controller.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;
+  constructor(run) {
+    this.#run = run;
+  }
+  activate() {
+    this.#active = true;
+  }
+  cancel() {
+    this.#active = false;
+    this.#queued = false;
+    this.#generation += 1;
+  }
+  get pending() {
+    return this.#queued;
+  }
+  schedule() {
+    if (!this.#active || this.#queued) return;
+    this.#queued = true;
+    const generation = this.#generation;
+    queueMicrotask(() => {
+      if (generation !== this.#generation || !this.#queued || !this.#active) return;
+      this.#queued = false;
+      this.#run();
+    });
+  }
+};
+
+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();
+  }
+  get pending() {
+    return this.#pass.pending;
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
 var EmptyStateController = class extends Controller {
   static targets = ["list", "empty"];
   static values = {
@@ -29,68 +96,40 @@ var EmptyStateController = class extends Controller {
   };
   static events = ["change"];
   #observer = null;
-  /** Whether the controller is between `connect()` and `disconnect()`. */
   #connected = false;
-  /** Last applied empty state; `null` until the first sync so connect emits nothing. */
   #empty = null;
+  #morphRender = new MorphRenderWatcher(() => this.#resync());
   connect() {
+    this.#morphRender.observe(this.element);
     this.#connected = true;
     this.#syncObservation();
     this.#update();
   }
   disconnect() {
+    this.#morphRender.disconnect();
     this.#connected = false;
     this.#stopObserving();
   }
-  /** Follows a `list` element swapped in at runtime (Turbo Stream `replace` / morph). */
   listTargetConnected() {
     this.#resync();
   }
-  /** Releases the observation when the `list` element leaves the target set. */
   listTargetDisconnected() {
     this.#resync();
   }
-  /** Syncs an `empty` element that arrives — or is replaced — at runtime. */
   emptyTargetConnected() {
     this.#resync();
   }
-  /**
-   * Syncs the `empty` element that remains when one leaves the target set. A
-   * single-target getter resolves to the first `empty` element in document order,
-   * so a swap that inserts the replacement *before* removing the original (Turbo
-   * Stream `after` / `before` / `append` followed by `remove`) leaves the
-   * replacement untouched until the original goes — this callback is that moment.
-   */
   emptyTargetDisconnected() {
     this.#resync();
   }
-  /** Re-renders when application code (or a Turbo morph) changes `itemSelector` at runtime. */
   itemSelectorValueChanged() {
     this.#resync();
   }
-  /**
-   * Re-points the observation and re-renders after a target or selector change.
-   * The `#connected` guard is load-bearing: Stimulus runs value and target
-   * callbacks for the initial markup *before* `connect()` and runs target
-   * callbacks during teardown *after* `disconnect()`, and re-observing there
-   * would outlive the controller.
-   */
   #resync() {
     if (!this.#connected) return;
     this.#syncObservation();
     this.#update();
   }
-  /**
-   * Points the mutation observation at the current `list` target — re-resolved on
-   * every sync rather than captured at connect, so an element swapped in at
-   * runtime is observed instead of the detached original.
-   *
-   * The observation covers exactly what the count predicate reads. With no
-   * `itemSelector` the count is the child element count, which only `childList`
-   * can change. With one, the predicate reads the children themselves, so
-   * attribute and descendant mutations are watched too — and the controller's own
-   * writes are filtered back out, or toggling `hidden` would re-enter the render.
-   */
   #syncObservation() {
     this.#stopObserving();
     if (!this.hasListTarget || typeof MutationObserver === "undefined") return;
@@ -108,21 +147,11 @@ var EmptyStateController = class extends Controller {
     this.#observer?.disconnect();
     this.#observer = null;
   }
-  /**
-   * Whether a mutation can change the item count. An attribute written on a
-   * target this controller owns is its own echo — `hidden` on `list` / `empty`,
-   * and the hooks on the controller element when the list *is* that element.
-   */
   #affectsCount(record) {
     if (record.type !== "attributes") return true;
     const own = record.target === this.listTarget || this.hasEmptyTarget && record.target === this.emptyTarget;
     return !own;
   }
-  /**
-   * Renders the count, then reports a crossed boundary. The announcement copy is
-   * read here rather than while rendering: it is the wording of the report, not
-   * an input to what is displayed.
-   */
   #update() {
     const count = this.#render();
     if (count === null) return;
@@ -135,12 +164,6 @@ var EmptyStateController = class extends Controller {
       fillTemplate(empty ? this.announceTextValue : this.announceFilledTextValue, { count })
     );
   }
-  /**
-   * Syncs visibility and the state hooks to the current item count, and returns
-   * it. `null` when there is no `list` target to count.
-   *
-   * @stimeoRenderRoot
-   */
   #render() {
     if (!this.hasListTarget) return null;
     const count = this.#count();
@@ -155,7 +178,6 @@ var EmptyStateController = class extends Controller {
     if (this.hasEmptyTarget) this.emptyTarget.hidden = !empty;
     return count;
   }
-  /** Item count: element children matching `itemSelector`, or all element children. */
   #count() {
     const selector = this.itemSelectorValue;
     if (selector.length === 0) return this.listTarget.childElementCount;
@@ -168,5 +190,4 @@ var EmptyStateController = class extends Controller {
 };
 
 export { EmptyStateController };
-//# sourceMappingURL=empty_state_controller.js.map
 //# sourceMappingURL=empty_state_controller.js.map