stimeo-ui 0.16.0 → 0.18.0

data/dist/controllers/optimistic_controller.js

@@ -1,117 +1,98 @@
 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/utils/transient_hooks.ts
+var SubmissionOwner = class {
+  #synthetic = /* @__PURE__ */ Symbol("synthetic submission");
+  #active = null;
+  begin(event) {
+    this.#active = { source: event.target, token: this.#tokenOf(event) };
+  }
+  resolve(event) {
+    if (this.#active === null || this.#active.source !== event.target || this.#active.token !== this.#tokenOf(event)) {
+      return null;
+    }
+    this.clear();
+    return this.#detailOf(event)?.success === true;
+  }
+  clear() {
+    this.#active = null;
+  }
+  #tokenOf(event) {
+    return this.#detailOf(event)?.formSubmission ?? this.#synthetic;
+  }
+  #detailOf(event) {
+    return event.detail;
+  }
+};
+
 var TransientHooks = class {
   #attributes;
   constructor(options) {
     this.#attributes = options.attributes;
   }
-  /** Drops the declared hooks from `element`; what it carries besides stays. */
   reset(element) {
     for (const attribute of this.#attributes) element.removeAttribute(attribute);
   }
 };
 
-// src/controllers/optimistic_controller.ts
 var TRANSIENT = new TransientHooks({ attributes: ["data-optimistic"] });
 var HIDDEN_MARKER = "data-optimistic-toggled";
 var BUSY_MARKER = "data-optimistic-busy";
 var AUTHORED_ABSENT = "absent";
 var AUTHORED_VALUE = "value:";
-var SYNTHETIC_SUBMISSION = {};
-function submissionOf(event) {
-  const detail = event.detail;
-  return detail?.formSubmission ?? SYNTHETIC_SUBMISSION;
-}
 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;
+  #submission = new SubmissionOwner();
   #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;
@@ -125,11 +106,11 @@ var OptimisticController = class extends Controller {
     this.#connected = false;
     this.#listeners.dispose();
     this.#gate.disconnected(this, () => {
-      this.#pending = null;
+      this.#submission.clear();
     });
   }
   #onSubmitStart = (event) => {
-    this.#pending = submissionOf(event);
+    this.#submission.begin(event);
     if (this.element instanceof HTMLFormElement && !this.element.hasAttribute(BUSY_MARKER)) {
       this.element.setAttribute(BUSY_MARKER, AUTHORED_ABSENT);
     }
@@ -139,9 +120,8 @@ var OptimisticController = class extends Controller {
     for (const target of this.hideTargets) this.#setHidden(target, true);
   };
   #onSubmitEnd = (event) => {
-    if (submissionOf(event) !== this.#pending) return;
-    this.#pending = null;
-    const success = event.detail?.success === true;
+    const success = this.#submission.resolve(event);
+    if (success === null) return;
     if (success) {
       this.element.removeAttribute("data-optimistic");
       this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
@@ -154,12 +134,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);
@@ -171,16 +149,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;
@@ -192,15 +160,6 @@ 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() {
     TRANSIENT.reset(this.element);
     this.#restore(this.element, "aria-busy", BUSY_MARKER, "true");
@@ -212,5 +171,4 @@ var OptimisticController = class extends Controller {
 };
 
 export { OptimisticController };
-//# sourceMappingURL=optimistic_controller.js.map
 //# sourceMappingURL=optimistic_controller.js.map