stimeo-ui 0.16.0 → 0.17.0

data/dist/controllers/lazy_frame_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/lazy_frame_controller.ts
-
-// src/utils/declared_value.ts
 function parseDeclared(raw, parse, fallback) {
   try {
     return parse(raw);
@@ -11,7 +8,6 @@ function parseDeclared(raw, parse, fallback) {
   }
 }
 
-// src/utils/intersection_watcher.ts
 function queryRoot(selector) {
   if (!selector) return null;
   return parseDeclared(selector, (raw) => document.querySelector(raw), null);
@@ -24,30 +20,12 @@ var IntersectionWatcher = class {
   constructor(onEntries) {
     this.#onEntries = onEntries;
   }
-  /** Whether an observer is live (started, `IntersectionObserver` supported). */
   get active() {
     return this.#active;
   }
-  /** Whether the live observer discarded configured options after construction failed. */
   get usingPlatformDefaults() {
     return this.#usingPlatformDefaults;
   }
-  /**
-   * (Re)creates the observer and observes `targets`. Returns `false` — leaving
-   * the watcher inert — without `IntersectionObserver` support (very old
-   * browsers; the caller's no-JS fallback stays in charge) or with no targets.
-   * If initial construction with the configured options fails, the watcher
-   * warns and retries once with the same root and platform defaults. A
-   * `rootSelector` that does not parse resolves to the viewport (see
-   * {@link IntersectionWatchOptions.rootSelector}), so a typo never fails the
-   * call.
-   *
-   * @throws The fallback constructor error if both construction attempts fail,
-   *   or whatever the platform throws from `observe()`. The exception is passed
-   *   through unchanged, but the watcher rolls back first: every target observed
-   *   so far is released and `active` stays `false`, so a caller that retries
-   *   starts from a clean slate.
-   */
   start(targets, options = {}) {
     this.stop();
     if (typeof IntersectionObserver === "undefined") return false;
@@ -85,14 +63,6 @@ var IntersectionWatcher = class {
       throw error;
     }
   }
-  /**
-   * Re-delivers `target`'s CURRENT intersection state: `IntersectionObserver`
-   * only reports *changes*, but `observe()` always reports the present state,
-   * so unobserve→observe turns "still intersecting" into a fresh callback.
-   *
-   * @throws Whatever `unobserve()`/`observe()` throws. The watcher is stopped
-   *   first, so it never stays live with a half-rearmed target.
-   */
   rearm(target) {
     if (!this.#observer) return;
     try {
@@ -103,7 +73,6 @@ var IntersectionWatcher = class {
       throw error;
     }
   }
-  /** Severs the observer; late queued callbacks become no-ops via the guard. */
   stop() {
     this.#active = false;
     this.#observer?.disconnect();
@@ -112,7 +81,6 @@ var IntersectionWatcher = class {
   }
 };
 
-// src/controllers/lazy_frame_controller.ts
 var LazyFrameController = class extends Controller {
   static values = {
     url: { type: String, default: "" },
@@ -120,38 +88,28 @@ var LazyFrameController = class extends Controller {
     once: { type: Boolean, default: true }
   };
   static events = ["load"];
-  /** Shared IO plumbing (support guard, active guard, teardown). */
   #watcher = new IntersectionWatcher((entries) => this.#onIntersect(entries));
   #connected = false;
   #loaded = false;
-  /**
-   * Whether the observer last saw the frame inside the observed area — `null`
-   * until it has reported. A re-entry needs a frame that was seen inside and
-   * then left, so an unknown position is never a departure.
-   */
   #inside = null;
-  /**
-   * Focus reaching the frame starts the FIRST load before it intersects (keyboard / AT).
-   * `#load` releases this listener, so focus never reaches an already-loaded frame.
-   */
   #onFocus = () => this.#load();
-  /**
-   * Follows the held URL at runtime: one that arrives arms the frame, one that is
-   * taken away disarms it, so an empty `url` holds no triggers either way.
-   *
-   * Stimulus runs value callbacks before `connect()`, so the connected guard keeps
-   * arming in one place. A frame that already loaded keeps its held URL for the next
-   * re-entry instead of fetching on the spot.
-   */
   urlValueChanged() {
     if (!this.#connected || this.#loaded) return;
     if (this.urlValue) this.#arm();
     else this.#stopObserving();
   }
-  /** Rebuilds the observer when the early-load margin changes at runtime. */
   rootMarginValueChanged() {
     if (this.#connected && this.#watcher.active) this.#observe();
   }
+  onceValueChanged() {
+    if (!this.#connected || !this.#loaded) return;
+    if (this.onceValue) {
+      this.#watcher.stop();
+    } else if (!this.#watcher.active) {
+      this.#inside = null;
+      this.#arm();
+    }
+  }
   connect() {
     this.#loaded = this.element.hasAttribute("data-lazy-loaded");
     this.#inside = null;
@@ -163,7 +121,6 @@ var LazyFrameController = class extends Controller {
     this.#connected = false;
     this.#stopObserving();
   }
-  /** Attaches the triggers that still have a job to do. */
   #arm() {
     if (!this.urlValue) return;
     if (!this.#loaded) this.element.addEventListener("focusin", this.#onFocus);
@@ -183,7 +140,6 @@ var LazyFrameController = class extends Controller {
       }
     }
   }
-  /** Applies an intersecting entry: the first one loads, a return re-fetches. */
   #enter(returning) {
     if (!this.#loaded) {
       this.#load();
@@ -192,12 +148,6 @@ var LazyFrameController = class extends Controller {
     if (this.onceValue || !returning) return;
     this.#reload();
   }
-  /**
-   * Starts the load by writing the held URL to `src`.
-   *
-   * @stimeoRuntimeOnly `url` is the address this one load fetches and `once` decides whether it
-   *   stops the watcher.
-   */
   #load() {
     if (!this.urlValue) return;
     this.#loaded = true;
@@ -207,11 +157,6 @@ var LazyFrameController = class extends Controller {
     this.element.removeEventListener("focusin", this.#onFocus);
     if (this.onceValue) this.#watcher.stop();
   }
-  /**
-   * Re-entry while `once` is off: fetch the held URL again.
-   *
-   * @stimeoRuntimeOnly `url` is the address this one re-entry reloads.
-   */
   #reload() {
     const src = this.element.getAttribute("src");
     if (this.urlValue && this.urlValue !== src) {
@@ -231,5 +176,4 @@ var LazyFrameController = class extends Controller {
 };
 
 export { LazyFrameController };
-//# sourceMappingURL=lazy_frame_controller.js.map
 //# sourceMappingURL=lazy_frame_controller.js.map