stimeo-ui 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbc740b1497e7c760dce2eb0207e1e513a64e944aef2d666b8785c1244bd4618
-  data.tar.gz: e687fa19aae7ea8432130228a1bb0bfeb82868f56b18c8d823edb5d6dd1b77c7
+  metadata.gz: 7f691ab87c2a0b5092226d8d319ebff3c7b6d8a658b8a62c42017b7dc3e50807
+  data.tar.gz: e2aebaed7d717a580cbd9af42ae6149e7cda083fbbdd3465488525fdac8ee01e
 SHA512:
-  metadata.gz: eeeef9df2dedeb5aa23da6de1c08bc6921f0c85554de9162999895d48ddd89950dfe5dfa32b895d3fd80a780470966a2ae9f9517e8743b6b7868c9a1e441b2da
-  data.tar.gz: 3a40f5f32596616f06fa52a93a446ddf73ed25421c610c54209d200eb8c631d5b334e1f014852e8331e4fd9b09ad0933929ad1de54d36aaa4d14361e05a2bcc0
+  metadata.gz: 182402ce77c5e8a010e3c6f2229c8865f339ea20447907f776f7e557a3c52de7aa9b3eada614e9c64c2cb4d3a7850a1a1e5b3724e1f836ed666f6cfadf221787
+  data.tar.gz: 7061380101c2b4c7a1ad996e11ba1a6816ed276ba96944b55e1bd5d5efecefb8ee9607c466604f6ad97b7da990c86c1dbd5376256ef29d8c8c7d39dada7fd50b

data/CHANGELOG.md

@@ -7,6 +7,75 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 While the version is `0.x`, the public API (the `stimeo--*` data attributes) may
 change between releases.
 
+## [0.12.0] - 2026-09-06
+
+Minor release with no new components. Six existing ones are reworked — count-up,
+intersection, lazy-frame, reading-progress, smart-sticky-header, and sortable —
+and the number reading count-up gained reaches live-counter too. Most of them
+changed a contract, so read Removed and Changed before upgrading. The Inspector
+manifest stays on schema v12.
+
+### Removed
+
+- sortable: the `status` target, its `data-grabbed` / `data-moved` /
+  `data-dropped` / `data-canceled` templates, and the English fallback wording.
+  Seat a `stimeo--announcer` on the page and set `announceGrabbedText` /
+  `announceMovedText` / `announceDroppedText` / `announceCanceledText`
+  (`{name}` / `{position}` / `{total}`); an unset one announces nothing.
+  `stimeo check` stops asking for the live region and warns when no announcer
+  is seated.
+
+### Changed
+
+- count-up: only the text node holding the number is animated, and while it
+  ticks it is wrapped in a `role="img"` element named with the authored text —
+  the host's own `aria-label` and `role` are never touched, and sibling markup
+  stays where it was.
+- count-up and live-counter read a formatted number by one rule: the first
+  numeric token, group separators dropped, the fraction truncated, and a hyphen
+  a sign only where it opens the token — `"Sign-ups: 1,200"` reads 1200, not
+  -1200.
+- intersection: `0` is always among the observed lines, so a non-zero
+  `threshold` also reports the element leaving for good (one more `change`;
+  `data-passed` and the ratio property follow the departure to its end), and an
+  exit across the start edge reports `position: "before"` while the element
+  still overlaps the root.
+- lazy-frame: a re-fetch needs a genuine re-entry — the frame is seen inside the
+  observed area, leaves it, and comes back; where a connection or a
+  focus-started load first finds it is the baseline. A frame with `once` off is
+  armed again after a cache restore, and `load` names the URL that was fetched.
+- reading-progress: an article with no layout box is not measured, the
+  article's own box is watched so late-settling content re-measures, and the
+  connect frame is the baseline — a restored scroll position does not fire
+  `complete`. Both faces of the custom property are leased: the element's copy
+  is returned on `disconnect()` too, an authored `:root` declaration comes back,
+  and a later writer is left alone.
+- smart-sticky-header: `change` fires on transitions only (connecting is
+  silent), and the `offset` zone is decided ahead of the jitter guard.
+- sortable: insertion is relative to the neighbouring item — the `list`-less
+  markup works and the last slot is after the last item — and a drag signal from
+  a pointer-drag nested inside an item no longer moves the card. The pickup slot
+  is remembered as neighbours, so rows inserted or removed mid-drag shift neither
+  the restore nor `from`; only laid-out siblings take part in pointer following;
+  and a session whose item leaves the item set ends instead of refusing every
+  later grab. pointer-drag consumes `Home` / `End` while grabbed.
+- A declaration that cannot be read falls back to its default: count-up's
+  `duration` / `from`, smart-sticky-header's `offset`, and a `rootSelector` /
+  `containerSelector` that does not parse (intersection, sticky-observer,
+  smart-sticky-header) observes the viewport or the window. Runtime changes to
+  intersection's `threshold`, lazy-frame's `url` / `rootMargin`, and
+  smart-sticky-header's `offset` are followed.
+
+### Fixed
+
+- lazy-frame: focus moving inside a loaded frame no longer re-fetches it, the
+  first intersection after a focus-started load is not a re-entry, and an empty
+  `url` is never written to `src`.
+- intersection: with `once`, a handler calling `refresh()` from `enter` no longer
+  clears the one-shot marker, so a cache restore does not fire `enter` again.
+- reading-progress: hiding a half-read article no longer publishes `1` and
+  `complete`.
+
 ## [0.11.0] - 2026-09-05
 
 Minor release with no new components. Eight existing ones are reworked — the three
@@ -930,6 +999,7 @@ Initial public alpha: 101 behavior-only, accessible Stimulus controllers driven
 by `data-*` attributes, shipping no CSS. Published to npm (with provenance) and
 RubyGems.
 
+[0.12.0]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.12.0
 [0.11.0]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.11.0
 [0.10.0]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.10.0
 [0.9.0]: https://github.com/taiyaky/stimeo-ui/releases/tag/v0.9.0

data/dist/cable/index.js

@@ -2,6 +2,28 @@ import { Controller } from '@hotwired/stimulus';
 import { createConsumer } from '@rails/actioncable';
 
 // src/cable/live_counter_controller.ts
+
+// src/utils/authored_integer.ts
+var TOKEN_BODY = /\d[\d.,'’’    _]*\d|\d/;
+var SIGN_OPENER = /[\s([]/;
+function authoredInteger(text) {
+  const firstDigit = /\d/.exec(text);
+  if (firstDigit === null) return null;
+  const at = firstDigit.index;
+  const signed = at > 0 && text[at - 1] === "-" && (at === 1 || SIGN_OPENER.test(text[at - 2]));
+  const body = TOKEN_BODY.exec(text.slice(at));
+  const runs = body[0].split(/\D+/);
+  const separators = body[0].match(/\D+/g) ?? [];
+  const lead = runs[0];
+  const heads = lead.length <= 3 && !lead.startsWith("0");
+  let digits = lead;
+  for (let i = 1; heads && i < runs.length; i += 1) {
+    if (separators[i - 1]?.length !== 1 || runs[i]?.length !== 3) break;
+    digits += runs[i];
+  }
+  const magnitude = Number.parseInt(digits, 10);
+  return signed ? -magnitude || 0 : magnitude;
+}
 function parseSubscriptionParams(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -229,8 +251,7 @@ var LiveCounterController = class extends Controller {
   }
   /** The current count, parsed from the DOM (the single source of truth). */
   get #current() {
-    const parsed = Number.parseInt((this.#display.textContent ?? "").replace(/[^0-9-]/g, ""), 10);
-    return Number.isNaN(parsed) ? 0 : parsed;
+    return authoredInteger(this.#display.textContent ?? "") ?? 0;
   }
   #write(count) {
     if (count === this.#current) return;

data/dist/controllers/count_up_controller.js

@@ -2,29 +2,58 @@ import { Controller } from '@hotwired/stimulus';
 
 // src/controllers/count_up_controller.ts
 
+// src/utils/authored_integer.ts
+var TOKEN_BODY = /\d[\d.,'’’    _]*\d|\d/;
+var SIGN_OPENER = /[\s([]/;
+function authoredInteger(text) {
+  const firstDigit = /\d/.exec(text);
+  if (firstDigit === null) return null;
+  const at = firstDigit.index;
+  const signed = at > 0 && text[at - 1] === "-" && (at === 1 || SIGN_OPENER.test(text[at - 2]));
+  const body = TOKEN_BODY.exec(text.slice(at));
+  const runs = body[0].split(/\D+/);
+  const separators = body[0].match(/\D+/g) ?? [];
+  const lead = runs[0];
+  const heads = lead.length <= 3 && !lead.startsWith("0");
+  let digits = lead;
+  for (let i = 1; heads && i < runs.length; i += 1) {
+    if (separators[i - 1]?.length !== 1 || runs[i]?.length !== 3) break;
+    digits += runs[i];
+  }
+  const magnitude = Number.parseInt(digits, 10);
+  return signed ? -magnitude || 0 : magnitude;
+}
+
 // src/utils/reduced_motion.ts
 function prefersReducedMotion() {
   return typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 
 // src/controllers/count_up_controller.ts
+var DEFAULT_DURATION = 1200;
 var CountUpController = class extends Controller {
   static values = {
-    duration: { type: Number, default: 1200 },
+    duration: { type: Number, default: DEFAULT_DURATION },
     from: { type: Number, default: 0 },
     once: { type: Boolean, default: true }
   };
   static actions = ["start"];
   static events = ["end"];
   #frame = null;
-  /** The authored final text, restored verbatim when the run settles. */
-  #finalText = "";
+  /** The animation length, with a declaration outside its domain read as the default. */
+  get #duration() {
+    return Number.isFinite(this.durationValue) && this.durationValue > 0 ? this.durationValue : DEFAULT_DURATION;
+  }
+  /** The starting value, with a declaration that is not a finite number read as zero. */
+  get #from() {
+    return Number.isFinite(this.fromValue) ? this.fromValue : 0;
+  }
   connect() {
-    if (this.element.hasAttribute("data-count-up-label")) {
-      this.element.textContent = this.element.getAttribute("aria-label") ?? this.element.textContent;
-      this.#restoreLabel();
-      this.element.setAttribute("data-count-up-done", "true");
-    }
+    const ticker = this.#ownedTicker();
+    if (ticker === null) return;
+    const authored = ticker.getAttribute("aria-label");
+    this.#unwrap(ticker, authored);
+    if (authored !== null) this.element.setAttribute("data-count-up-done", "true");
   }
   disconnect() {
     if (this.#frame !== null) this.#settle();
@@ -36,27 +65,22 @@ var CountUpController = class extends Controller {
   start() {
     if (this.#frame !== null) return;
     if (this.onceValue && this.element.hasAttribute("data-count-up-done")) return;
-    this.#finalText = this.element.textContent ?? "";
-    const target = Number.parseInt(this.#finalText.replace(/[^0-9-]/g, ""), 10);
-    if (Number.isNaN(target)) return;
+    const node = this.#numericNode();
+    if (node === null) return;
+    const authored = node.data;
+    const target = authoredInteger(authored);
     if (prefersReducedMotion()) {
       this.element.setAttribute("data-count-up-done", "true");
       this.dispatch("end", { detail: { value: target } });
       return;
     }
-    const authored = this.element.getAttribute("aria-label");
-    if (authored !== null) {
-      this.element.setAttribute("data-count-up-original-label", authored);
-    }
-    this.element.setAttribute("data-count-up-label", "true");
-    this.element.setAttribute("aria-label", this.#finalText);
+    const ticker = this.#wrap(node, authored);
+    const from = this.#from;
     const started = performance.now();
     const step = (now) => {
-      const t = Math.min((now - started) / this.durationValue, 1);
+      const t = Math.min((now - started) / this.#duration, 1);
       const eased = 1 - (1 - t) ** 3;
-      this.element.textContent = String(
-        Math.round(this.fromValue + (target - this.fromValue) * eased)
-      );
+      ticker.textContent = String(Math.round(from + (target - from) * eased));
       if (t < 1) {
         this.#frame = requestAnimationFrame(step);
       } else {
@@ -66,26 +90,41 @@ var CountUpController = class extends Controller {
     };
     this.#frame = requestAnimationFrame(step);
   }
+  /** The first text node that displays a number, or null when the host has none. */
+  #numericNode() {
+    const walker = document.createTreeWalker(this.element, NodeFilter.SHOW_TEXT);
+    let node = walker.nextNode();
+    while (node !== null && authoredInteger(node.data) === null) {
+      node = walker.nextNode();
+    }
+    return node;
+  }
+  /** The wrapper this controller published, if one outlived its run. */
+  #ownedTicker() {
+    return this.element.querySelector("[data-count-up-label]");
+  }
+  /** Publishes the ticking number inside a named wrapper, replacing `node`. */
+  #wrap(node, authored) {
+    const ticker = document.createElement("span");
+    ticker.setAttribute("data-count-up-label", "true");
+    ticker.setAttribute("role", "img");
+    ticker.setAttribute("aria-label", authored);
+    node.replaceWith(ticker);
+    ticker.append(node);
+    return ticker;
+  }
+  /** Puts `text` back where the wrapper stood, leaving the rest of the host alone. */
+  #unwrap(ticker, text) {
+    ticker.replaceWith(document.createTextNode(text ?? ticker.textContent ?? ""));
+  }
   /** Ends the run: cancels the frame and restores the authored presentation. */
   #settle() {
     if (this.#frame !== null) cancelAnimationFrame(this.#frame);
     this.#frame = null;
-    this.element.textContent = this.#finalText;
-    this.#restoreLabel();
+    const ticker = this.#ownedTicker();
+    if (ticker !== null) this.#unwrap(ticker, ticker.getAttribute("aria-label"));
     this.element.setAttribute("data-count-up-done", "true");
   }
-  /** Releases the marker-owned aria-label, restoring any parked authored value. */
-  #restoreLabel() {
-    if (!this.element.hasAttribute("data-count-up-label")) return;
-    const original = this.element.getAttribute("data-count-up-original-label");
-    if (original !== null) {
-      this.element.setAttribute("aria-label", original);
-      this.element.removeAttribute("data-count-up-original-label");
-    } else {
-      this.element.removeAttribute("aria-label");
-    }
-    this.element.removeAttribute("data-count-up-label");
-  }
 };
 
 export { CountUpController };

data/dist/controllers/intersection_controller.js

@@ -9,6 +9,14 @@ function isBeforeRootStart(entry) {
   const rootTop = entry.rootBounds?.top ?? 0;
   return rect.bottom <= rootTop;
 }
+function queryRoot(selector) {
+  if (!selector) return null;
+  try {
+    return document.querySelector(selector);
+  } catch {
+  }
+  return null;
+}
 var IntersectionWatcher = class {
   #onEntries;
   #observer = null;
@@ -30,7 +38,10 @@ var IntersectionWatcher = class {
    * 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.
+   * 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
@@ -43,7 +54,7 @@ var IntersectionWatcher = class {
     if (typeof IntersectionObserver === "undefined") return false;
     const list = Array.isArray(targets) ? targets : [targets];
     if (list.length === 0) return false;
-    const root = "root" in options ? options.root ?? null : options.rootSelector ? document.querySelector(options.rootSelector) : null;
+    const root = "root" in options ? options.root ?? null : queryRoot(options.rootSelector);
     let observer = null;
     try {
       const onEntries = (entries) => {
@@ -136,6 +147,25 @@ var IntersectionController = class extends Controller {
   }
   connect() {
     if (this.onceValue && this.element.getAttribute("data-intersecting") === "true") return;
+    this.#observe();
+  }
+  disconnect() {
+    this.#watcher.stop();
+  }
+  /**
+   * Re-reads the visibility line and rebuilds the observer. Turbo 8 morphing
+   * rewrites the attribute in place without a reconnect, and the line is what
+   * the intersection callback compares every ratio against, so a value frozen at
+   * connect time would decide `data-intersecting` wrongly for the rest of the
+   * page's life. Nothing to rebuild before the first `connect()`; after a spent
+   * one-shot the watcher is deliberately stopped, and re-observing would deliver
+   * the current state and fire `enter` a second time.
+   */
+  thresholdValueChanged() {
+    if (this.#watcher.active) this.#observe();
+  }
+  /** (Re)installs the observer from the current Values. */
+  #observe() {
     this.#effectiveThreshold = this.#clampedThreshold();
     this.#watcher.start(this.element, {
       rootSelector: this.rootSelectorValue,
@@ -144,9 +174,6 @@ var IntersectionController = class extends Controller {
     });
     if (this.#watcher.usingPlatformDefaults) this.#effectiveThreshold = 0;
   }
-  disconnect() {
-    this.#watcher.stop();
-  }
   /**
    * Re-delivers the current intersection state as a fresh transition. Bound via
    * `data-action` (e.g. `my-feed:appended@window->stimeo--intersection#refresh`).
@@ -177,14 +204,29 @@ var IntersectionController = class extends Controller {
     const previous = this.element.getAttribute("data-intersecting");
     this.element.setAttribute("data-intersecting", intersecting ? "true" : "false");
     if (intersecting && previous !== "true") {
-      this.dispatch("enter", { detail: { ratio } });
       if (this.onceValue) this.#watcher.stop();
+      this.dispatch("enter", { detail: { ratio } });
     } else if (!intersecting && previous === "true") {
       this.dispatch("exit", {
-        detail: { ratio, position: isBeforeRootStart(entry) ? "before" : "after" }
+        detail: { ratio, position: this.#leftViaStartEdge(entry) ? "before" : "after" }
       });
     }
   }
+  /**
+   * Which edge the element left across, for the `exit` detail. A non-zero
+   * `threshold` withdraws visibility while the element still overlaps the root,
+   * so the leaving rect can straddle the start edge — the direction is the
+   * element's own top against that edge, not whether it has cleared the root
+   * entirely (that is what `passed` reports). An element with no layout box
+   * (`display: none`, a collapsed `<details>`) is reported with an empty rect
+   * that carries no position at all, so it is deliberately neither direction
+   * and takes the "still ahead" reading.
+   */
+  #leftViaStartEdge(entry) {
+    const rect = entry.boundingClientRect;
+    if (rect.width === 0 && rect.height === 0) return false;
+    return rect.top < (entry.rootBounds?.top ?? 0);
+  }
   /**
    * Reflects the "scrolled past" state onto `data-passed` and fires `passed` on
    * transitions — the line sticky headers and reading progress key off. Like
@@ -204,9 +246,14 @@ var IntersectionController = class extends Controller {
   /**
    * Observer thresholds: the `threshold` line itself, plus `ratioSteps` evenly
    * spaced steps when fine-grained `change` ratios are wanted (progress bars).
+   *
+   * 0 is always observed. An observer notifies only at the lines it was given,
+   * so a non-zero `threshold` on its own delivers its last callback while the
+   * element is still partly visible: the element leaving for good would never be
+   * reported, freezing the ratio and `data-passed` mid-departure.
    */
   #thresholds() {
-    const thresholds = /* @__PURE__ */ new Set([this.#clampedThreshold()]);
+    const thresholds = /* @__PURE__ */ new Set([0, this.#clampedThreshold()]);
     if (this.ratioStepsValue > 0) {
       for (let i = 0; i <= this.ratioStepsValue; i += 1) {
         thresholds.add(i / this.ratioStepsValue);

data/dist/controllers/lazy_frame_controller.js

@@ -3,6 +3,14 @@ import { Controller } from '@hotwired/stimulus';
 // src/controllers/lazy_frame_controller.ts
 
 // src/utils/intersection_watcher.ts
+function queryRoot(selector) {
+  if (!selector) return null;
+  try {
+    return document.querySelector(selector);
+  } catch {
+  }
+  return null;
+}
 var IntersectionWatcher = class {
   #onEntries;
   #observer = null;
@@ -24,7 +32,10 @@ var IntersectionWatcher = class {
    * 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.
+   * 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
@@ -37,7 +48,7 @@ var IntersectionWatcher = class {
     if (typeof IntersectionObserver === "undefined") return false;
     const list = Array.isArray(targets) ? targets : [targets];
     if (list.length === 0) return false;
-    const root = "root" in options ? options.root ?? null : options.rootSelector ? document.querySelector(options.rootSelector) : null;
+    const root = "root" in options ? options.root ?? null : queryRoot(options.rootSelector);
     let observer = null;
     try {
       const onEntries = (entries) => {
@@ -106,47 +117,98 @@ var LazyFrameController = class extends Controller {
   static events = ["load"];
   /** Shared IO plumbing (support guard, active guard, teardown). */
   #watcher = new IntersectionWatcher((entries) => this.#onIntersect(entries));
+  #connected = false;
   #loaded = false;
-  /** Focus reaching the frame triggers the load before it intersects (keyboard / AT). */
-  #onFocus = () => this.#trigger();
+  /**
+   * 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();
+  }
   connect() {
-    if (this.element.hasAttribute("data-lazy-loaded")) {
-      this.#loaded = true;
-      return;
-    }
-    if (!this.urlValue) return;
-    this.element.addEventListener("focusin", this.#onFocus);
-    this.#watcher.start(this.element, { rootMargin: this.rootMarginValue });
+    this.#loaded = this.element.hasAttribute("data-lazy-loaded");
+    this.#inside = null;
+    this.#connected = true;
+    if (this.#loaded && this.onceValue) return;
+    this.#arm();
   }
   disconnect() {
+    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);
+    this.#observe();
+  }
+  #observe() {
+    this.#watcher.start(this.element, { rootMargin: this.rootMarginValue });
+  }
   #onIntersect(entries) {
     for (const entry of entries) {
       if (entry.isIntersecting) {
-        this.#trigger();
-        return;
+        const returning = this.#inside === false;
+        this.#inside = true;
+        this.#enter(returning);
+      } else if (this.#inside) {
+        this.#inside = false;
       }
     }
   }
-  #trigger() {
-    if (!this.#loaded) this.#load();
-    else if (!this.onceValue) this.#reload();
+  /** Applies an intersecting entry: the first one loads, a return re-fetches. */
+  #enter(returning) {
+    if (!this.#loaded) {
+      this.#load();
+      return;
+    }
+    if (this.onceValue || !returning) return;
+    this.#reload();
   }
   /** Starts the load by writing the held URL to `src`. */
   #load() {
+    if (!this.urlValue) return;
     this.#loaded = true;
     this.element.setAttribute("src", this.urlValue);
     this.element.setAttribute("data-lazy-loaded", "true");
     this.dispatch("load", { detail: { url: this.urlValue } });
-    if (this.onceValue) this.#stopObserving();
+    this.element.removeEventListener("focusin", this.#onFocus);
+    if (this.onceValue) this.#watcher.stop();
   }
-  /** Re-entry while `once` is off: ask Turbo to reload the frame's current `src`. */
+  /** Re-entry while `once` is off: fetch the held URL again. */
   #reload() {
+    const src = this.element.getAttribute("src");
+    if (this.urlValue && this.urlValue !== src) {
+      this.element.setAttribute("src", this.urlValue);
+      this.dispatch("load", { detail: { url: this.urlValue } });
+      return;
+    }
     const frame = this.element;
     if (typeof frame.reload !== "function") return;
     frame.reload();
-    this.dispatch("load", { detail: { url: this.urlValue } });
+    this.dispatch("load", { detail: { url: src ?? "" } });
   }
   #stopObserving() {
     this.#watcher.stop();

data/dist/controllers/pointer_drag_controller.js

@@ -255,6 +255,10 @@ var PointerDragController = class _PointerDragController extends Controller {
       return;
     }
     if (!this.#keyboard) return;
+    if (event.key === "Home" || event.key === "End") {
+      event.preventDefault();
+      return;
+    }
     const step = this.#keyboardDelta(event.key);
     if (!step) return;
     event.preventDefault();