stimeo-ui 0.15.0 → 0.17.0

data/dist/controllers/optimistic_controller.js

@@ -1,87 +1,64 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/optimistic_controller.ts
-
-// src/utils/detach_gate.ts
 var DetachGate = class _DetachGate {
-  /** Set while a probe is queued, waiting for a reconnect to cancel it. */
   #pending = false;
-  /**
-   * True while a probe is queued — the last disconnect was ambiguous and no
-   * reconnect has cancelled it yet. Read it from `connect()` to tell the
-   * reconnect half of an in-page move from a first connect: a controller whose
-   * initialisation restarts a measurement (a min-duration floor, an elapsed
-   * counter) must skip it for the move, where nothing actually restarted.
-   */
   get pending() {
     return this.#pending;
   }
-  /**
-   * True when the disconnect is definitely a real detach — the element left
-   * the document, or `data-controller` no longer lists the identifier. False
-   * means ambiguous (in-page move or observed-root exit), NOT "alive".
-   */
   static isDetached(host) {
-    if (!host.element.isConnected) return true;
-    const tokens = (host.element.getAttribute("data-controller") ?? "").split(/\s+/);
-    return !tokens.includes(host.identifier);
-  }
-  /**
-   * Call from `disconnect()`: runs `teardown` synchronously on a definite
-   * detach (fast path), otherwise defers it one microtask — a reconnect
-   * ({@link cancel} from `connect()`) keeps the state, no reconnect runs it.
-   * One microtask is the whole probe window: Stimulus reconnects a moved
-   * element within the same mutation batch, before the checkpoint drains.
-   */
+    return !host.element.isConnected || !_DetachGate.#listed(host);
+  }
   disconnected(host, teardown) {
-    if (_DetachGate.isDetached(host)) {
+    const carried = _DetachGate.#carried(host);
+    if (!carried && _DetachGate.isDetached(host)) {
       this.#pending = false;
       teardown();
       return;
     }
     this.#pending = true;
-    queueMicrotask(() => {
+    const probe = () => {
       if (!this.#pending) return;
       this.#pending = false;
       teardown();
-    });
+    };
+    if (carried) setTimeout(probe, 0);
+    else queueMicrotask(probe);
+  }
+  static #carried(host) {
+    const element = host.element;
+    return !element.isConnected && element.closest("[data-turbo-permanent]") !== null && _DetachGate.#listed(host);
+  }
+  static #listed(host) {
+    const tokens = (host.element.getAttribute("data-controller") ?? "").split(/\s+/);
+    return tokens.includes(host.identifier);
   }
-  /**
-   * Disarms a pending probe. Call from `connect()` (the reconnect that proves
-   * an in-page move) and from the head of any teardown path not routed through
-   * {@link disconnected} (disabled-toggle, Escape), so an orphaned probe can
-   * never run the teardown a second time.
-   */
   cancel() {
     this.#pending = false;
   }
 };
 
-// src/utils/listener_set.ts
 var ListenerSet = class {
-  /** The generation every `add` joins until the next `dispose()`. */
   #abort = new AbortController();
-  /**
-   * Attaches `handler` to the open generation, exactly as the caller spelled it.
-   *
-   * The set supplies the signal, so `options` carries everything else the DOM
-   * accepts — `capture` included, which has to match at release time and no
-   * longer has a second place to drift from.
-   */
   add(target, type, handler, options) {
     target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
   }
-  /**
-   * Releases every listener of the open generation, synchronously, and opens the
-   * next one. Idempotent, and safe before anything has been added.
-   */
   dispose() {
     this.#abort.abort();
     this.#abort = new AbortController();
   }
 };
 
-// src/controllers/optimistic_controller.ts
+var TransientHooks = class {
+  #attributes;
+  constructor(options) {
+    this.#attributes = options.attributes;
+  }
+  reset(element) {
+    for (const attribute of this.#attributes) element.removeAttribute(attribute);
+  }
+};
+
+var TRANSIENT = new TransientHooks({ attributes: ["data-optimistic"] });
 var HIDDEN_MARKER = "data-optimistic-toggled";
 var BUSY_MARKER = "data-optimistic-busy";
 var AUTHORED_ABSENT = "absent";
@@ -94,11 +71,9 @@ function submissionOf(event) {
 var OptimisticController = class extends Controller {
   static targets = ["show", "hide"];
   static events = ["commit", "rollback"];
-  /** The submission that owns the applied optimistic state, if any. */
   #pending = null;
   #gate = new DetachGate();
   #listeners = new ListenerSet();
-  /** True between `connect()` and `disconnect()`, so a repeat connect rewinds nothing. */
   #connected = false;
   connect() {
     const restored = !this.#connected && !this.#gate.pending;
@@ -141,12 +116,10 @@ var OptimisticController = class extends Controller {
       this.dispatch("rollback");
     }
   };
-  /** Hides or reveals a target, recording the authored `hidden` on first write. */
   #setHidden(target, hidden) {
     if (target.hasAttribute("hidden") === hidden) return;
     this.#write(target, "hidden", hidden ? "" : null, HIDDEN_MARKER);
   }
-  /** Writes an attribute, recording what it displaced under `marker` once. */
   #write(element, attribute, value, marker) {
     if (!element.hasAttribute(marker)) {
       const authored = element.getAttribute(attribute);
@@ -158,16 +131,6 @@ var OptimisticController = class extends Controller {
     if (value === null) element.removeAttribute(attribute);
     else element.setAttribute(attribute, value);
   }
-  /**
-   * Puts back the value `marker` recorded and drops the record.
-   *
-   * `written` is what this controller last put in the attribute. Anything else
-   * there now belongs to whoever wrote it — Turbo owns `aria-busy` on a form and
-   * clears it before the terminal arrives, and a consumer may have moved a face
-   * mid-flight — so the record is dropped without touching the attribute. A
-   * marker this build did not write names no authored value, so the attribute
-   * goes back to being absent.
-   */
   #restore(element, attribute, marker, written) {
     const recorded = element.getAttribute(marker);
     if (recorded === null) return;
@@ -179,17 +142,8 @@ var OptimisticController = class extends Controller {
     }
     element.removeAttribute(attribute);
   }
-  /**
-   * Puts back exactly the markup this controller displaced (record-owned only).
-   *
-   * A face can be registered on both sides, and the hide pass runs last, so what
-   * this controller wrote there is `hidden` — matching it against the reveal's
-   * absent value instead would read as someone else's write and leave the face
-   * hidden. Each target is therefore restored once, against the write it last
-   * received.
-   */
   #revert() {
-    this.element.removeAttribute("data-optimistic");
+    TRANSIENT.reset(this.element);
     this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
     const hidden = new Set(this.hideTargets);
     for (const target of /* @__PURE__ */ new Set([...this.showTargets, ...this.hideTargets])) {
@@ -199,5 +153,4 @@ var OptimisticController = class extends Controller {
 };
 
 export { OptimisticController };
-//# sourceMappingURL=optimistic_controller.js.map
 //# sourceMappingURL=optimistic_controller.js.map