stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/smart_sticky_header_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/smart_sticky_header_controller.ts
-
-// src/utils/declared_value.ts
 function parseDeclared(raw, parse, fallback) {
   try {
     return parse(raw);
@@ -22,14 +19,8 @@ function validSelector(element, raw, fallback) {
   );
 }
 
-// src/utils/frame_coalescer.ts
 var FrameCoalescer = class {
   #frame = null;
-  /**
-   * Runs `run` on the next frame, unless a frame is already pending — the first
-   * request of a burst wins and the rest are dropped. The pending frame is
-   * released before `run`, so `run` may request the next one.
-   */
   schedule(run) {
     if (this.#frame !== null) return;
     this.#frame = requestAnimationFrame(() => {
@@ -37,14 +28,6 @@ var FrameCoalescer = class {
       run();
     });
   }
-  /**
-   * Drops the pending frame, and reaches the platform only when there is one.
-   *
-   * There is no handle value that stands for "nothing pending":
-   * `cancelAnimationFrame` takes an `unsigned long`, so a negative placeholder
-   * arrives as a large positive number that the same allocator can hand out, and
-   * an idle cancel would then drop a frame belonging to someone else.
-   */
   cancel() {
     if (this.#frame === null) return;
     cancelAnimationFrame(this.#frame);
@@ -52,7 +35,121 @@ var FrameCoalescer = class {
   }
 };
 
-// src/utils/scroll_source.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 NUMBER_BOUNDS = {
+  finite: { finite: true },
+  nonNegative: { finite: true, min: 0 }};
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
+
+function readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+var NumberValueReader = class {
+  #lastRejected = /* @__PURE__ */ new Map();
+  read(owner, name, raw, fallback, bounds) {
+    const resolved = readNumber(raw, fallback, bounds);
+    if (matchesNumberBounds(raw, bounds)) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;
+    const literal = owner.element.getAttribute(attribute);
+    if (literal === null) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    if (this.#lastRejected.get(name) !== literal) {
+      this.#lastRejected.set(name, literal);
+      console.warn(
+        `Stimeo UI: "${owner.identifier}" has an invalid number Value "${name}" declaration ${JSON.stringify(literal)}; using ${fallback}.`
+      );
+    }
+    return resolved;
+  }
+};
+
 function resolveScrollContainer(selector) {
   const match = selector ? document.querySelector(selector) : null;
   return match instanceof HTMLElement ? match : null;
@@ -64,64 +161,66 @@ function scrollOffset(source) {
   return source === window ? window.scrollY ?? window.pageYOffset ?? 0 : source.scrollTop;
 }
 
-// src/controllers/smart_sticky_header_controller.ts
 var DEFAULT_OFFSET = 80;
-var SmartStickyHeaderController = class extends Controller {
+var SmartStickyHeaderController = class _SmartStickyHeaderController extends Controller {
+  #numbers = new NumberValueReader();
   static values = {
     containerSelector: { type: String, default: "" },
     offset: { type: Number, default: DEFAULT_OFFSET },
     tolerance: { type: Number, default: 4 }
   };
+  static valueConstraints = {
+    offset: NUMBER_BOUNDS.finite,
+    tolerance: NUMBER_BOUNDS.nonNegative
+  };
   static events = ["change"];
-  #connected = false;
-  /** Coalesces scroll bursts into one measurement per frame. */
   #frames = new FrameCoalescer();
-  /** The scroll source resolved at connect — disconnect must unbind the SAME node. */
   #scrollerEl = window;
-  /** The validated `containerSelector`, or `""` when the declaration cannot be parsed. */
+  #scrollListeners = new ListenerSet();
+  #listeners = new ListenerSet();
   #containerSelector = "";
   #lastY = 0;
-  /** Last published state, so `change` fires only on transitions. */
   #hidden = null;
-  /**
-   * The depth that never hides. A declaration that is not a finite number reads
-   * as the default, so the comparison path never sees `NaN` — which would
-   * answer `false` to every comparison and hide the header inside the very
-   * zone the value exists to protect.
-   */
   get #offset() {
-    return Number.isFinite(this.offsetValue) ? this.offsetValue : DEFAULT_OFFSET;
+    return this.#safeOffset;
   }
   #onScroll = () => this.#frames.schedule(() => this.#measure());
-  /**
-   * Focus inside a hidden header must reveal it (WCAG 2.4.7 / 2.4.11); the
-   * hold while focus *stays* inside is the `#apply` hide invariant.
-   */
   #onFocusin = () => this.#apply(false);
-  /** Validates `containerSelector` once so connect never parses a selector that throws. */
   containerSelectorValueChanged() {
     this.#containerSelector = validSelector(this.element, this.containerSelectorValue, "");
+    this.#morphRender.schedule();
   }
-  /** Re-decides when application code (or a Turbo morph) changes `offset` at runtime. */
   offsetValueChanged() {
-    if (this.#connected) this.#measure();
+    this.#morphRender.schedule();
   }
+  #morphRender = new MorphRenderWatcher(() => {
+    this.#followSource();
+    this.#measure();
+  });
   connect() {
+    this.#morphRender.observe(this.element);
     this.#hidden = null;
-    this.#scrollerEl = resolveScrollSource(this.#containerSelector);
-    this.#lastY = scrollOffset(this.#scrollerEl);
-    this.#scrollerEl.addEventListener("scroll", this.#onScroll, { passive: true });
-    this.element.addEventListener("focusin", this.#onFocusin);
+    this.#listenTo(resolveScrollSource(this.#containerSelector));
+    this.#listeners.add(this.element, "focusin", this.#onFocusin);
     this.#apply(false, false);
-    this.#connected = true;
   }
   disconnect() {
-    this.#connected = false;
-    this.#scrollerEl.removeEventListener("scroll", this.#onScroll);
-    this.element.removeEventListener("focusin", this.#onFocusin);
+    this.#morphRender.disconnect();
+    this.#scrollListeners.dispose();
+    this.#listeners.dispose();
     this.#frames.cancel();
   }
-  /** @stimeoRenderRoot */
+  #followSource() {
+    const source = resolveScrollSource(this.#containerSelector);
+    if (source === this.#scrollerEl) return;
+    this.#scrollListeners.dispose();
+    this.#listenTo(source);
+  }
+  #listenTo(source) {
+    this.#scrollerEl = source;
+    this.#lastY = scrollOffset(source);
+    this.#scrollListeners.add(source, "scroll", this.#onScroll, { passive: true });
+  }
   #measure() {
     const y = scrollOffset(this.#scrollerEl);
     if (y <= this.#offset) {
@@ -130,34 +229,42 @@ var SmartStickyHeaderController = class extends Controller {
       return;
     }
     const delta = y - this.#lastY;
-    if (this.#isJitter(delta)) return;
+    if (this.#isJitter(delta)) {
+      this.#apply(this.#hidden ?? false);
+      return;
+    }
     this.#lastY = y;
     this.#apply(delta > 0);
   }
-  /**
-   * Whether one scroll step is too small to act on.
-   *
-   * @stimeoRuntimeOnly `tolerance` is the allowance one scroll step is compared against; the
-   *   header's state at rest does not depend on it.
-   */
   #isJitter(delta) {
-    return Math.abs(delta) < this.toleranceValue;
-  }
-  /**
-   * Reflects the state onto the hook and emits `change` on transitions.
-   *
-   * @param notify - whether a transition announces itself. The reflection
-   *   `connect()` performs is the current state, not a change.
-   */
+    return Math.abs(delta) < this.#safeTolerance;
+  }
   #apply(hidden, notify = true) {
     if (hidden && this.element.contains(document.activeElement)) return;
-    if (hidden === this.#hidden) return;
+    const changed = hidden !== this.#hidden;
     this.#hidden = hidden;
     this.element.setAttribute("data-header-hidden", hidden ? "true" : "false");
-    if (notify) this.dispatch("change", { detail: { hidden } });
+    if (notify && changed) this.dispatch("change", { detail: { hidden } });
+  }
+  get #safeOffset() {
+    return this.#numbers.read(
+      this,
+      "offset",
+      this.offsetValue,
+      _SmartStickyHeaderController.values.offset.default,
+      _SmartStickyHeaderController.valueConstraints.offset
+    );
+  }
+  get #safeTolerance() {
+    return this.#numbers.read(
+      this,
+      "tolerance",
+      this.toleranceValue,
+      _SmartStickyHeaderController.values.tolerance.default,
+      _SmartStickyHeaderController.valueConstraints.tolerance
+    );
   }
 };
 
 export { SmartStickyHeaderController };
-//# sourceMappingURL=smart_sticky_header_controller.js.map
 //# sourceMappingURL=smart_sticky_header_controller.js.map

package/dist/controllers/smart_sticky_header_controller.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/declared_value.ts","../../src/utils/frame_coalescer.ts","../../src/utils/scroll_source.ts","../../src/controllers/smart_sticky_header_controller.ts"],"names":[],"mappings":"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","file":"smart_sticky_header_controller.js","sourcesContent":["/**\n * Readers for the String Values whose text can only be checked by handing it to\n * a parser: a CSS selector, a regular-expression source, a JSON object.\n *\n * Stimulus reads each of them as an ordinary string, so the controller connects\n * and the flaw surfaces later, inside the first handler that consumes the value\n * (a `SyntaxError` from `new RegExp`, a `DOMException` from the selector engine),\n * where it takes the whole handler down on every event. Parsing here, once, in\n * the `<name>ValueChanged` callback keeps the failure local to the declaration:\n * an unreadable value falls back to its default, the element stays alive, and\n * the hot path only ever receives a value that parsed.\n *\n * Which default a broken declaration falls back to is the caller's contract, so\n * every reader takes (or returns) the fallback rather than choosing one.\n */\n\n/**\n * The result of `parse(raw)`, or `fallback` when `parse` throws.\n *\n * Any exception counts as \"does not parse\": the parsers these Values feed\n * (`RegExp`, `JSON.parse`, the selector engine) all report a malformed input by\n * throwing, and none of them throws for another reason.\n */\nexport function parseDeclared<T>(raw: string, parse: (raw: string) => T, fallback: T): T {\n  try {\n    return parse(raw);\n  } catch {\n    return fallback;\n  }\n}\n\n/** What {@link validSelector} needs of the element it probes with. */\nexport interface SelectorProbe {\n  matches(selector: string): boolean;\n}\n\n/**\n * `raw` when it is a non-empty selector the DOM accepts, otherwise `fallback`.\n *\n * `element.matches` is the probe: the engine parses the selector and throws for\n * one it cannot read. Whether the selector actually matches `element` plays no\n * part, so a selector aimed at another element still passes.\n *\n * The parameter names the one method the probe uses rather than `Element`, so\n * this module carries no DOM type and the readers below stay importable from\n * the Node-side Inspector, which checks the same declarations statically.\n */\nexport function validSelector(element: SelectorProbe, raw: string, fallback: string): string {\n  if (raw.length === 0) return fallback;\n  return parseDeclared(\n    raw,\n    (selector) => {\n      element.matches(selector);\n      return selector;\n    },\n    fallback,\n  );\n}\n\n/** How `compileRegExp` wraps a source before compiling it. */\nexport type RegExpAnchor = \"none\" | \"exact\";\n\n/**\n * `source` compiled as a `RegExp`, or `null` when it does not compile.\n *\n * `\"exact\"` wraps the source as `^(?:source)$`, so the whole input has to match\n * and an alternation inside the source cannot escape the anchors. The source is\n * compiled on its own first, because an unbalanced source can be made to parse\n * by the wrapper's own parentheses — `0)|(1` becomes `^(?:0)|(1)$` — which would\n * accept a declaration that is not a regular expression and leave half of it\n * outside the anchors. The default that replaces a broken source is the\n * caller's, so `null` is returned rather than a fallback pattern.\n */\nexport function compileRegExp(source: string, anchor: RegExpAnchor = \"none\"): RegExp | null {\n  return parseDeclared(\n    source,\n    (text) => {\n      const bare = new RegExp(text);\n      return anchor === \"exact\" ? new RegExp(`^(?:${text})$`) : bare;\n    },\n    null,\n  );\n}\n\n/**\n * The JSON object `raw` declares, or `null` when the text does not parse or\n * parses to something other than a plain object (`null`, an array, a scalar).\n * Values are returned as parsed; narrowing them is the caller's contract.\n */\nexport function parseJsonObject(raw: string): Record<string, unknown> | null {\n  const parsed = parseDeclared<unknown>(raw, (text) => JSON.parse(text), null);\n  if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n","/**\n * Runs one piece of scroll-driven work per animation frame.\n *\n * A `scroll` listener fires many times between two paints, and each firing would\n * measure the same layout. Requesting a frame on the first firing and ignoring\n * the rest until it runs keeps the reads to one per frame; running on the frame\n * — rather than on a timer — keeps the measurement in step with what the reader\n * sees.\n *\n * **The first request of a burst wins.** Work handed in while a frame is already\n * pending is dropped, so a caller that queues a special first pass and then\n * receives scrolls gets that first pass, not the last scroll's.\n *\n * Cancelling drops the pending frame outright, and does nothing at all when none\n * is pending. A frame really is cancelled, so nothing needs a generation to tell\n * a stale callback from a fresh one, and nothing has to be refused before the\n * caller starts listening.\n *\n * Scope is the scheduling only. What to measure stays with the caller.\n *\n * @example\n * ```ts\n * readonly #frames = new FrameCoalescer();\n *\n * readonly #onScroll = (): void => this.#frames.schedule(() => this.#measure());\n *\n * disconnect(): void {\n *   this.#frames.cancel();\n * }\n * ```\n */\nexport class FrameCoalescer {\n  #frame: number | null = null;\n\n  /**\n   * Runs `run` on the next frame, unless a frame is already pending — the first\n   * request of a burst wins and the rest are dropped. The pending frame is\n   * released before `run`, so `run` may request the next one.\n   */\n  schedule(run: () => void): void {\n    if (this.#frame !== null) return;\n    this.#frame = requestAnimationFrame(() => {\n      this.#frame = null;\n      run();\n    });\n  }\n\n  /**\n   * Drops the pending frame, and reaches the platform only when there is one.\n   *\n   * There is no handle value that stands for \"nothing pending\":\n   * `cancelAnimationFrame` takes an `unsigned long`, so a negative placeholder\n   * arrives as a large positive number that the same allocator can hand out, and\n   * an idle cancel would then drop a frame belonging to someone else.\n   */\n  cancel(): void {\n    if (this.#frame === null) return;\n    cancelAnimationFrame(this.#frame);\n    this.#frame = null;\n  }\n}\n","/**\n * What a scroll-driven component listens to and measures: a scroll container\n * somewhere in the page, or the window when nothing names one.\n *\n * A component that reacts to scrolling takes a selector for the container it\n * lives in and falls back to the viewport. Resolving that, and reading how far\n * the result has scrolled, are the same two steps everywhere — and the read is\n * the one that drifts, because the window and an element expose the offset under\n * different names.\n *\n * Resolution only. A selector reaches here already validated, or empty; whether\n * a declaration parses is decided once where it is declared, not on every\n * resolve.\n */\n\n/** A scroll container, or the window. */\nexport type ScrollSource = HTMLElement | Window;\n\n/**\n * The scroll container `selector` names, or `null` for the viewport.\n *\n * `null` covers every way a container can fail to be one: an empty selector, a\n * selector that matches nothing, and a match that is not an `HTMLElement` — an\n * SVG node answers a query but does not scroll.\n *\n * `selector` must be empty or already validated: an unparsable one makes the\n * query throw rather than fall back.\n */\nexport function resolveScrollContainer(selector: string): HTMLElement | null {\n  const match = selector ? document.querySelector(selector) : null;\n  return match instanceof HTMLElement ? match : null;\n}\n\n/** The scroll source `selector` names: its container, else the window. */\nexport function resolveScrollSource(selector: string): ScrollSource {\n  return resolveScrollContainer(selector) ?? window;\n}\n\n/**\n * How far `source` has scrolled vertically.\n *\n * The window is compared by identity rather than with `instanceof`, which a\n * cross-realm or synthetic DOM fails. Its offset is read through the modern name\n * first and the legacy one after, so a runtime that exposes only one still gives\n * a number.\n */\nexport function scrollOffset(source: ScrollSource): number {\n  return source === window\n    ? (window.scrollY ?? window.pageYOffset ?? 0)\n    : (source as HTMLElement).scrollTop;\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { validSelector } from \"../utils/declared_value\";\nimport { FrameCoalescer } from \"../utils/frame_coalescer\";\nimport { resolveScrollSource, scrollOffset } from \"../utils/scroll_source\";\n\n/** The depth that never hides, used when `offset` is not a finite number. */\nconst DEFAULT_OFFSET = 80;\n\n/**\n * Headless **smart sticky header**: hides the header on scroll-down and\n * reveals it on scroll-up, published as a `data-header-hidden` hook the\n * consumer's CSS translates away (`stimeo--sticky-observer` detects *stuck*,\n * but has no direction sense; this adds it). Core (zero dependencies).\n *\n * Markup contract (identifier: `stimeo--smart-sticky-header`):\n *   <header data-controller=\"stimeo--smart-sticky-header\"\n *           style=\"position: sticky; top: 0;\">…</header>\n *\n * The scroll source is the window by default; inside an overflow container,\n * point `containerSelector` at it (the header usually sits inside it too). A\n * declaration that cannot be parsed as a selector reads as the window, so a\n * typo costs the container binding rather than the whole header.\n *   <!-- [data-header-hidden=\"true\"] { transform: translateY(-100%); } -->\n *\n * Scrolling down past `offset` px sets `data-header-hidden=\"true\"`, and a\n * scroll-up beyond the `tolerance` jitter guard reveals it again. Within the\n * `offset` zone the header is always revealed, decided ahead of that jitter\n * guard: a header stranded off-screen near the top cannot be scrolled back\n * into view. Focus reaching the header always reveals it, and while focus\n * stays inside the header a scroll-down never hides it — a keyboard user must\n * be able to see where focus went AND keep seeing the element that owns it\n * (WCAG 2.4.7 / 2.4.11).\n *\n * `change` dispatches `{ hidden }` on transitions only: the reflection\n * `connect()` performs is the current state rather than a change.\n *\n * @remarks\n * Behavior only — `position: sticky`, the translate animation, and\n * reduced-motion handling are the consumer's CSS (`prefers-reduced-motion`\n * should disable the transition, not the behavior). Scroll work is\n * rAF-throttled; listeners and any pending frame are released on\n * `disconnect()`, and `connect()` resets the transient hook (a Turbo cache\n * snapshot must not restore a hidden header at scroll top).\n */\nexport class SmartStickyHeaderController extends Controller<HTMLElement> {\n  static override values = {\n    containerSelector: { type: String, default: \"\" },\n    offset: { type: Number, default: DEFAULT_OFFSET },\n    tolerance: { type: Number, default: 4 },\n  };\n  static events = [\"change\"] as const;\n\n  declare containerSelectorValue: string;\n  declare offsetValue: number;\n  declare toleranceValue: number;\n\n  #connected = false;\n  /** Coalesces scroll bursts into one measurement per frame. */\n  readonly #frames = new FrameCoalescer();\n  /** The scroll source resolved at connect — disconnect must unbind the SAME node. */\n  #scrollerEl: HTMLElement | Window = window;\n  /** The validated `containerSelector`, or `\"\"` when the declaration cannot be parsed. */\n  #containerSelector = \"\";\n  #lastY = 0;\n  /** Last published state, so `change` fires only on transitions. */\n  #hidden: boolean | null = null;\n\n  /**\n   * The depth that never hides. A declaration that is not a finite number reads\n   * as the default, so the comparison path never sees `NaN` — which would\n   * answer `false` to every comparison and hide the header inside the very\n   * zone the value exists to protect.\n   */\n  get #offset(): number {\n    return Number.isFinite(this.offsetValue) ? this.offsetValue : DEFAULT_OFFSET;\n  }\n\n  readonly #onScroll = (): void => this.#frames.schedule(() => this.#measure());\n\n  /**\n   * Focus inside a hidden header must reveal it (WCAG 2.4.7 / 2.4.11); the\n   * hold while focus *stays* inside is the `#apply` hide invariant.\n   */\n  readonly #onFocusin = (): void => this.#apply(false);\n\n  /** Validates `containerSelector` once so connect never parses a selector that throws. */\n  containerSelectorValueChanged(): void {\n    this.#containerSelector = validSelector(this.element, this.containerSelectorValue, \"\");\n  }\n\n  /** Re-decides when application code (or a Turbo morph) changes `offset` at runtime. */\n  offsetValueChanged(): void {\n    if (this.#connected) this.#measure();\n  }\n\n  override connect(): void {\n    // The hook is scroll-derived: recompute from the live scroll position\n    // instead of trusting a cached snapshot (which may say hidden at y=0).\n    this.#hidden = null;\n    this.#scrollerEl = resolveScrollSource(this.#containerSelector);\n    this.#lastY = scrollOffset(this.#scrollerEl);\n    this.#scrollerEl.addEventListener(\"scroll\", this.#onScroll, { passive: true });\n    this.element.addEventListener(\"focusin\", this.#onFocusin);\n    this.#apply(false, false);\n    this.#connected = true;\n  }\n\n  override disconnect(): void {\n    this.#connected = false;\n    this.#scrollerEl.removeEventListener(\"scroll\", this.#onScroll);\n    this.element.removeEventListener(\"focusin\", this.#onFocusin);\n    this.#frames.cancel();\n  }\n\n  /** @stimeoRenderRoot */\n  #measure(): void {\n    const y = scrollOffset(this.#scrollerEl);\n    // The offset zone decides before the jitter guard: a move small enough to\n    // be jitter can still be the one that re-enters the zone, and a header\n    // left hidden there cannot be scrolled back into view.\n    if (y <= this.#offset) {\n      this.#lastY = y;\n      this.#apply(false);\n      return;\n    }\n\n    const delta = y - this.#lastY;\n    if (this.#isJitter(delta)) return;\n    this.#lastY = y;\n    this.#apply(delta > 0);\n  }\n\n  /**\n   * Whether one scroll step is too small to act on.\n   *\n   * @stimeoRuntimeOnly `tolerance` is the allowance one scroll step is compared against; the\n   *   header's state at rest does not depend on it.\n   */\n  #isJitter(delta: number): boolean {\n    return Math.abs(delta) < this.toleranceValue;\n  }\n\n  /**\n   * Reflects the state onto the hook and emits `change` on transitions.\n   *\n   * @param notify - whether a transition announces itself. The reflection\n   *   `connect()` performs is the current state, not a change.\n   */\n  #apply(hidden: boolean, notify = true): void {\n    // Invariant: a header holding focus is never hidden — `focusin` revealed\n    // it, and no transition may slide the focus owner away mid-interaction\n    // (WCAG 2.4.7 / 2.4.11). Vetoed here at the single state-transition choke\n    // point (not in each caller), so any future hide path — a timer, an\n    // action — cannot bypass it. Reveals are never vetoed.\n    if (hidden && this.element.contains(document.activeElement)) return;\n    if (hidden === this.#hidden) return;\n    this.#hidden = hidden;\n    this.element.setAttribute(\"data-header-hidden\", hidden ? \"true\" : \"false\");\n    if (notify) this.dispatch(\"change\", { detail: { hidden } });\n  }\n}\n"]}
+{"version":3,"sources":["../../src/utils/declared_value.ts","../../src/utils/frame_coalescer.ts","../../src/utils/listener_set.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/morph_render_watcher.ts","../../src/utils/number_bounds.ts","../../src/utils/coerce.ts","../../src/utils/number_value.ts","../../src/utils/scroll_source.ts","../../src/controllers/smart_sticky_header_controller.ts"],"names":[],"mappings":"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","file":"smart_sticky_header_controller.js","sourcesContent":["/**\n * Readers for the String Values whose text can only be checked by handing it to\n * a parser: a CSS selector, a regular-expression source, a JSON object.\n *\n * Stimulus reads each of them as an ordinary string, so the controller connects\n * and the flaw surfaces later, inside the first handler that consumes the value\n * (a `SyntaxError` from `new RegExp`, a `DOMException` from the selector engine),\n * where it takes the whole handler down on every event. Parsing here, once, in\n * the `<name>ValueChanged` callback keeps the failure local to the declaration:\n * an unreadable value falls back to its default, the element stays alive, and\n * the hot path only ever receives a value that parsed.\n *\n * Which default a broken declaration falls back to is the caller's contract, so\n * every reader takes (or returns) the fallback rather than choosing one.\n */\n\n/**\n * The result of `parse(raw)`, or `fallback` when `parse` throws.\n *\n * Any exception counts as \"does not parse\": the parsers these Values feed\n * (`RegExp`, `JSON.parse`, the selector engine) all report a malformed input by\n * throwing, and none of them throws for another reason.\n */\nexport function parseDeclared<T>(raw: string, parse: (raw: string) => T, fallback: T): T {\n  try {\n    return parse(raw);\n  } catch {\n    return fallback;\n  }\n}\n\n/** What {@link validSelector} needs of the element it probes with. */\nexport interface SelectorProbe {\n  matches(selector: string): boolean;\n}\n\n/**\n * `raw` when it is a non-empty selector the DOM accepts, otherwise `fallback`.\n *\n * `element.matches` is the probe: the engine parses the selector and throws for\n * one it cannot read. Whether the selector actually matches `element` plays no\n * part, so a selector aimed at another element still passes.\n *\n * The parameter names the one method the probe uses rather than `Element`, so\n * this module carries no DOM type and the readers below stay importable from\n * the Node-side Inspector, which checks the same declarations statically.\n */\nexport function validSelector(element: SelectorProbe, raw: string, fallback: string): string {\n  if (raw.length === 0) return fallback;\n  return parseDeclared(\n    raw,\n    (selector) => {\n      element.matches(selector);\n      return selector;\n    },\n    fallback,\n  );\n}\n\n/** How `compileRegExp` wraps a source before compiling it. */\nexport type RegExpAnchor = \"none\" | \"exact\";\n\n/**\n * `source` compiled as a `RegExp`, or `null` when it does not compile.\n *\n * `\"exact\"` wraps the source as `^(?:source)$`, so the whole input has to match\n * and an alternation inside the source cannot escape the anchors. The source is\n * compiled on its own first, because an unbalanced source can be made to parse\n * by the wrapper's own parentheses — `0)|(1` becomes `^(?:0)|(1)$` — which would\n * accept a declaration that is not a regular expression and leave half of it\n * outside the anchors. The default that replaces a broken source is the\n * caller's, so `null` is returned rather than a fallback pattern.\n */\nexport function compileRegExp(source: string, anchor: RegExpAnchor = \"none\"): RegExp | null {\n  return parseDeclared(\n    source,\n    (text) => {\n      const bare = new RegExp(text);\n      return anchor === \"exact\" ? new RegExp(`^(?:${text})$`) : bare;\n    },\n    null,\n  );\n}\n\n/**\n * The JSON object `raw` declares, or `null` when the text does not parse or\n * parses to something other than a plain object (`null`, an array, a scalar).\n * Values are returned as parsed; narrowing them is the caller's contract.\n */\nexport function parseJsonObject(raw: string): Record<string, unknown> | null {\n  const parsed = parseDeclared<unknown>(raw, (text) => JSON.parse(text), null);\n  if (parsed === null || typeof parsed !== \"object\" || Array.isArray(parsed)) return null;\n  return parsed as Record<string, unknown>;\n}\n","/**\n * Runs one piece of scroll-driven work per animation frame.\n *\n * A `scroll` listener fires many times between two paints, and each firing would\n * measure the same layout. Requesting a frame on the first firing and ignoring\n * the rest until it runs keeps the reads to one per frame; running on the frame\n * — rather than on a timer — keeps the measurement in step with what the reader\n * sees.\n *\n * **The first request of a burst wins.** Work handed in while a frame is already\n * pending is dropped, so a caller that queues a special first pass and then\n * receives scrolls gets that first pass, not the last scroll's.\n *\n * Cancelling drops the pending frame outright, and does nothing at all when none\n * is pending. A frame really is cancelled, so nothing needs a generation to tell\n * a stale callback from a fresh one, and nothing has to be refused before the\n * caller starts listening.\n *\n * Scope is the scheduling only. What to measure stays with the caller.\n *\n * @example\n * ```ts\n * readonly #frames = new FrameCoalescer();\n *\n * readonly #onScroll = (): void => this.#frames.schedule(() => this.#measure());\n *\n * disconnect(): void {\n *   this.#frames.cancel();\n * }\n * ```\n */\nexport class FrameCoalescer {\n  #frame: number | null = null;\n\n  /**\n   * Runs `run` on the next frame, unless a frame is already pending — the first\n   * request of a burst wins and the rest are dropped. The pending frame is\n   * released before `run`, so `run` may request the next one.\n   */\n  schedule(run: () => void): void {\n    if (this.#frame !== null) return;\n    this.#frame = requestAnimationFrame(() => {\n      this.#frame = null;\n      run();\n    });\n  }\n\n  /**\n   * Drops the pending frame, and reaches the platform only when there is one.\n   *\n   * There is no handle value that stands for \"nothing pending\":\n   * `cancelAnimationFrame` takes an `unsigned long`, so a negative placeholder\n   * arrives as a large positive number that the same allocator can hand out, and\n   * an idle cancel would then drop a frame belonging to someone else.\n   */\n  cancel(): void {\n    if (this.#frame === null) return;\n    cancelAnimationFrame(this.#frame);\n    this.#frame = null;\n  }\n}\n","/** What {@link ListenerSet.add} passes on besides the signal it supplies itself. */\nexport type ListenerOptions = Omit<AddEventListenerOptions, \"signal\">;\n\n/**\n * The event map a target's own `addEventListener` types its handlers with: the\n * window's, a document's, an HTML or SVG element's, any other element's, or a\n * media query list's. Other targets name none.\n */\ntype EventMapOf<T extends EventTarget> = T extends Window\n  ? WindowEventMap\n  : T extends Document\n    ? DocumentEventMap\n    : T extends HTMLElement\n      ? HTMLElementEventMap\n      : T extends SVGElement\n        ? SVGElementEventMap\n        : T extends Element\n          ? ElementEventMap\n          : T extends MediaQueryList\n            ? MediaQueryListEventMap\n            : Record<never, never>;\n\n/**\n * Owns every listener a controller attaches for one connected lifetime and\n * releases them together, so an event name is spelled once and the release\n * cannot drift from the registration.\n *\n * Detaching by hand repeats three things at the release site — the type, the\n * handler reference and the capture flag — and any one of them drifting leaves\n * a listener alive on an element the controller no longer drives. Aborting the\n * signal a registration was created with releases it whatever it was made of,\n * so the release site names nothing.\n *\n * One set per lifetime, held as a field and never rebuilt.\n * {@link ListenerSet.dispose} is the only thing that closes a generation, and it opens\n * the next one in the same step, so the lifecycle hooks can call `add` and\n * `dispose` in any order any number of times, and no `add` ever meets an\n * already aborted signal — a DOM that registers a listener on such a signal\n * would keep it forever. Rebuilding the set instead would leak:\n * `addEventListener` matches an existing registration on target, type, callback\n * and capture alone, so re-adding the same handler while the first registration\n * is live is discarded, and that live registration keeps the signal it was\n * attached with — a set built by a second `connect()` can never release what it\n * appears to own.\n *\n * Scope is the registration only. Timers, observers, leases and the order they\n * are unwound in stay with the controller, which places `dispose()` in its\n * cleanup sequence. A receiver that changes at runtime (a\n * swapped target) is rebound by calling `dispose()` and then `add()` again from\n * the rebind, not by a second set.\n *\n * A lifetime shorter than the connection — while a Value holds, until a first\n * load, while a subscription is open — gets a set of its own, which the end of\n * that lifetime disposes. A controller therefore holds one set per lifetime: the\n * connection's, and one for each swapped receiver or shorter span.\n *\n * The set must own every registration of a tuple it holds: a listener the same\n * target already carries for the same type, callback and capture flag keeps the\n * right to remove it, and this set's `add` for that tuple is discarded. A\n * subscription shared between instances behind a participant count, listeners of\n * several elements that come and go one at a time, and those one gesture holds\n * keep their own pair of calls or a signal of their own.\n *\n * @example\n * ```ts\n * readonly #listeners = new ListenerSet();\n *\n * connect(): void {\n *   this.#listeners.add(this.element, \"submit\", this.#onNativeSubmit, { capture: true });\n *   this.#listeners.add(this.element, \"turbo:submit-start\", this.#onSubmitStart);\n *   this.#listeners.add(this.element, \"turbo:submit-end\", this.#onSubmitEnd);\n * }\n *\n * disconnect(): void {\n *   this.#listeners.dispose();\n * }\n * ```\n */\nexport class ListenerSet {\n  /** The generation every `add` joins until the next `dispose()`. */\n  #abort = new AbortController();\n\n  /**\n   * Attaches `handler` to the open generation, exactly as the caller spelled it.\n   *\n   * The set supplies the signal, so `options` carries everything else the DOM\n   * accepts — `capture` included. A removal by hand would have to repeat that\n   * flag; aborting the signal releases the listener without it.\n   *\n   * A `type` the target's own event map names types `handler` with that event,\n   * as the target's `addEventListener` does, so a handler written for a\n   * `KeyboardEvent` is passed as it is; any other `type` takes an\n   * `EventListener`.\n   */\n  add<T extends EventTarget, K extends keyof EventMapOf<T> & string>(\n    target: T,\n    type: K,\n    handler: (event: EventMapOf<T>[K]) => void,\n    options?: ListenerOptions,\n  ): void;\n  add(target: EventTarget, type: string, handler: EventListener, options?: ListenerOptions): void;\n  add(target: EventTarget, type: string, handler: EventListener, options?: ListenerOptions): void {\n    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });\n  }\n\n  /**\n   * Releases every listener of the open generation, synchronously, and opens the\n   * next one. Idempotent, and safe before anything has been added.\n   */\n  dispose(): void {\n    this.#abort.abort();\n    this.#abort = new AbortController();\n  }\n}\n","/**\n * Collapses many Stimulus lifecycle callbacks from one DOM mutation into a\n * single pass.\n *\n * Stimulus fires `<name>TargetConnected` / `Disconnected` once per element and\n * `<name>ValueChanged` once per changed attribute. Replacing a list of N options\n * or morphing several render Values therefore delivers N callbacks — but the\n * useful unit of work is \"reconcile against the resulting declarative input\",\n * once, after the batch has settled. Every controller with reconcilable targets\n * or render Values needs the same shape: a `queued` flag plus `queueMicrotask`.\n *\n * **A microtask is the right horizon, and the reason is specific.** Stimulus\n * drives these callbacks from a `MutationObserver`, whose own callback already\n * runs as a microtask with the whole batch in hand; scheduling one more lands\n * after the last sibling callback of that batch and still before paint or any\n * event handler. A timer would be later than it needs to be, and reconciling\n * synchronously would run once per element against a half-applied DOM.\n *\n * **The two guards are not the same guard.** Scheduling is refused before the\n * controller connects, and running is refused after it disconnects:\n *\n * - **Before `connect()`** — Stimulus delivers initial target and Value callbacks\n *   ahead of `connect()`. Reconciling there would compute output against a\n *   controller whose own state has not been initialised, and `connect()` is\n *   about to do a full pass anyway.\n * - **After `disconnect()`** — Stimulus fires a callback for **every** target\n *   during teardown, and a microtask queued just before it would otherwise run\n *   against a detached tree. {@link MicrotaskCoalescer.cancel} exists for the\n *   teardown path to drop the pending pass outright.\n *\n * Both guards are part of one contract here rather than something each consumer\n * has to remember separately.\n *\n * Scope is the scheduling only. *What* to reconcile — keep the surviving active\n * option, fall back to the next / previous / first visible one, rebuild derived\n * chips or hidden fields — stays in the controller, because no two consumers\n * answer it the same way.\n *\n * @example\n * ```ts\n * readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileOptions());\n *\n * connect()    { this.#reconcile.activate(); }\n * disconnect() { this.#reconcile.cancel(); }\n *\n * optionTargetConnected()    { this.#reconcile.schedule(); }\n * optionTargetDisconnected() { this.#reconcile.schedule(); }\n * ```\n */\nexport class MicrotaskCoalescer {\n  readonly #run: () => void;\n  #queued = false;\n  #active = false;\n  #generation = 0;\n\n  /** @param run - the single reconciliation pass, invoked at most once per batch. */\n  constructor(run: () => void) {\n    this.#run = run;\n  }\n\n  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */\n  activate(): void {\n    this.#active = true;\n  }\n\n  /** Closes the window and drops any pending pass; call from `disconnect()`. */\n  cancel(): void {\n    this.#active = false;\n    this.#queued = false;\n    this.#generation += 1;\n  }\n\n  /** Whether a requested pass has yet to run. */\n  get pending(): boolean {\n    return this.#queued;\n  }\n\n  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */\n  schedule(): void {\n    if (!this.#active || this.#queued) return;\n    this.#queued = true;\n    const generation = this.#generation;\n    queueMicrotask(() => {\n      // A cancelled callback must not consume a pass queued after reconnect.\n      if (generation !== this.#generation || !this.#queued || !this.#active) return;\n      this.#queued = false;\n      this.#run();\n    });\n  }\n}\n","import { ListenerSet } from \"./listener_set\";\nimport { MicrotaskCoalescer } from \"./microtask_coalescer\";\n\n/**\n * Coalesces retained-element morphs and explicit lifecycle requests into one pass.\n *\n * Observe the controller's element after its initial state is settled. Morphs on\n * that element and bubbling morphs on its descendants share the same microtask\n * as {@link schedule}. The callback repairs derived output; the controller owns\n * any logical transition reporting. {@link disconnect} releases the listener and\n * cancels pending work, including work from an earlier connected lifetime.\n */\nexport class MorphRenderWatcher {\n  readonly #listeners = new ListenerSet();\n  readonly #pass: MicrotaskCoalescer;\n  #element: Element | null = null;\n  readonly #onMorph = (): void => this.#pass.schedule();\n\n  /** @param run - the single pass that repairs the settled controller's output. */\n  constructor(run: () => void) {\n    this.#pass = new MicrotaskCoalescer(run);\n  }\n\n  /** Opens observation; observing the same element again preserves queued work. */\n  observe(element: Element): void {\n    if (this.#element === element) return;\n    this.disconnect();\n    this.#element = element;\n    this.#pass.activate();\n    this.#listeners.add(element, \"turbo:morph-element\", this.#onMorph);\n  }\n\n  /** Requests one pass; requests outside an observed lifetime are ignored. */\n  schedule(): void {\n    this.#pass.schedule();\n  }\n\n  /** Whether a pass requested by a morph or {@link schedule} has yet to run. */\n  get pending(): boolean {\n    return this.#pass.pending;\n  }\n\n  /** Releases observation and pending work synchronously; safe to repeat. */\n  disconnect(): void {\n    this.#listeners.dispose();\n    this.#pass.cancel();\n    this.#element = null;\n  }\n}\n","import { MAX_TIMER_DELAY_MS } from \"./timer_bounds\";\n\n/** Semantic constraints on an already decoded number, independent of the DOM. */\nexport interface NumberBounds {\n  /** Finite numbers are required, including when this field is omitted. */\n  readonly finite?: true;\n  /** Inclusive lower endpoint. */\n  readonly min?: number;\n  /** Inclusive upper endpoint. */\n  readonly max?: number;\n  /** Exclusive lower endpoint. */\n  readonly exclusiveMin?: number;\n  /** Require a number without a fractional part. */\n  readonly integer?: boolean;\n  /** Exact decoded numbers accepted by a discrete contract. */\n  readonly allowedValues?: readonly number[];\n  /** JSON-safe exceptions to finite-number checking for unbounded endpoints. */\n  readonly allowInfinity?: \"negative\" | \"positive\" | \"both\";\n}\n\n/** One constraint for each Number Value, including shorthand declarations. */\nexport type NumberValueConstraints<Values> = {\n  readonly [Key in keyof Values as Values[Key] extends\n    | NumberConstructor\n    | { type: NumberConstructor }\n    ? Key\n    : never]: NumberBounds;\n};\n\n/** Reusable semantic domains; fractional inputs remain fractional unless excluded. */\nexport const NUMBER_BOUNDS = {\n  finite: { finite: true },\n  nonNegative: { finite: true, min: 0 },\n  positive: { finite: true, exclusiveMin: 0 },\n  nonNegativeInteger: { finite: true, min: 0, integer: true },\n  positiveInteger: { finite: true, exclusiveMin: 0, integer: true },\n  lowerBound: { finite: true, allowInfinity: \"negative\" },\n  upperBound: { finite: true, allowInfinity: \"positive\" },\n  timer: { finite: true, min: 0, max: MAX_TIMER_DELAY_MS },\n  positiveTimer: { finite: true, exclusiveMin: 0, max: MAX_TIMER_DELAY_MS },\n} as const satisfies Record<string, NumberBounds>;\n\n/**\n * Checks all declared bounds without rounding, clamping, or coercing the input.\n * Infinity exceptions relax only finite checking; every other bound still applies.\n */\nexport function matchesNumberBounds(value: number, bounds: NumberBounds): boolean {\n  if (!Number.isFinite(value)) {\n    const direction = value === Infinity ? \"positive\" : value === -Infinity ? \"negative\" : null;\n    if (direction === null) return false;\n    if (bounds.allowInfinity !== \"both\" && bounds.allowInfinity !== direction) return false;\n  }\n  if (bounds.min !== undefined && value < bounds.min) return false;\n  if (bounds.max !== undefined && value > bounds.max) return false;\n  if (bounds.exclusiveMin !== undefined && value <= bounds.exclusiveMin) return false;\n  if (bounds.integer && !Number.isInteger(value)) return false;\n  if (bounds.allowedValues !== undefined && !bounds.allowedValues.includes(value)) return false;\n  return true;\n}\n\n/** Decodes a Number Value literal; action params use their own JSON decoder. */\nexport function decodeNumberValue(raw: string): number {\n  return Number(raw.replace(/_/g, \"\"));\n}\n","/**\n * Numeric coercion for controllers that accept a number through a Value, an action\n * param, or an event detail.\n *\n * Stimulus decodes action params as JSON when possible and leaves other text\n * untouched. CustomEvent detail can also supply a number or numeric string.\n * The reader accepts those two types while rejecting blank and non-finite input.\n */\n\nimport { matchesNumberBounds, type NumberBounds } from \"./number_bounds\";\n\n/** Numeric update input, accepting decoded action params before CustomEvent detail. */\nexport type NumericValueEvent = Event & {\n  params?: { amount?: unknown };\n  detail?: { value?: unknown };\n};\n\n/** Reads the nullish action-param/detail precedence without falling back from invalid input. */\nexport function eventNumber(event: NumericValueEvent): number | null {\n  return toFiniteNumber(event.params?.amount ?? event.detail?.value);\n}\n\n/**\n * Reads a finite number or nonblank numeric string; other input returns `null`.\n * Blank strings cannot silently reset a value to zero.\n */\nexport function toFiniteNumber(raw: unknown): number | null {\n  if (typeof raw !== \"number\" && typeof raw !== \"string\") return null;\n  if (typeof raw === \"string\" && raw.trim().length === 0) return null;\n  const value = Number(raw);\n  return Number.isFinite(value) ? value : null;\n}\n\n/**\n * Returns an accepted decoded Number Value or the caller's fallback unchanged.\n * The caller owns the fallback contract; this reader does not parse or write a Value.\n */\nexport function readNumber(raw: number, fallback: number, bounds: NumberBounds): number {\n  return matchesNumberBounds(raw, bounds) ? raw : fallback;\n}\n","import { readNumber } from \"./coerce\";\nimport { matchesNumberBounds, type NumberBounds } from \"./number_bounds\";\n\n/** The instance identity carried by a Number Value read. */\nexport interface NumberValueOwner {\n  readonly identifier: string;\n  readonly element: Element;\n}\n\n/** Reads current declarations at the point of use without rewriting their attributes. */\nexport class NumberValueReader {\n  /** The last rejected literal per Value; no history grows for an unchanged instance. */\n  readonly #lastRejected = new Map<string, string>();\n\n  /** Resolves the declared number using its own fallback and shared class contract. */\n  read(\n    owner: NumberValueOwner,\n    name: string,\n    raw: number,\n    fallback: number,\n    bounds: NumberBounds,\n  ): number {\n    const resolved = readNumber(raw, fallback, bounds);\n    if (matchesNumberBounds(raw, bounds)) {\n      this.#lastRejected.delete(name);\n      return resolved;\n    }\n    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;\n    const literal = owner.element.getAttribute(attribute);\n    if (literal === null) {\n      this.#lastRejected.delete(name);\n      return resolved;\n    }\n    if (this.#lastRejected.get(name) !== literal) {\n      this.#lastRejected.set(name, literal);\n      console.warn(\n        `Stimeo UI: \"${owner.identifier}\" has an invalid number Value \"${name}\" declaration ${JSON.stringify(literal)}; using ${fallback}.`,\n      );\n    }\n    return resolved;\n  }\n}\n","/**\n * What a scroll-driven component listens to and measures: a scroll container\n * somewhere in the page, or the window when nothing names one.\n *\n * A component that reacts to scrolling takes a selector for the container it\n * lives in and falls back to the viewport. Resolving that, and reading how far\n * the result has scrolled, are the same two steps everywhere — and the read is\n * the one that drifts, because the window and an element expose the offset under\n * different names.\n *\n * Resolution only. A selector reaches here already validated, or empty; whether\n * a declaration parses is decided once where it is declared, not on every\n * resolve.\n */\n\n/** A scroll container, or the window. */\nexport type ScrollSource = HTMLElement | Window;\n\n/**\n * The scroll container `selector` names, or `null` for the viewport.\n *\n * `null` covers every way a container can fail to be one: an empty selector, a\n * selector that matches nothing, and a match that is not an `HTMLElement` — an\n * SVG node answers a query but does not scroll.\n *\n * `selector` must be empty or already validated: an unparsable one makes the\n * query throw rather than fall back.\n */\nexport function resolveScrollContainer(selector: string): HTMLElement | null {\n  const match = selector ? document.querySelector(selector) : null;\n  return match instanceof HTMLElement ? match : null;\n}\n\n/** The scroll source `selector` names: its container, else the window. */\nexport function resolveScrollSource(selector: string): ScrollSource {\n  return resolveScrollContainer(selector) ?? window;\n}\n\n/**\n * How far `source` has scrolled vertically.\n *\n * The window is compared by identity rather than with `instanceof`, which a\n * cross-realm or synthetic DOM fails. Its offset is read through the modern name\n * first and the legacy one after, so a runtime that exposes only one still gives\n * a number.\n */\nexport function scrollOffset(source: ScrollSource): number {\n  return source === window\n    ? (window.scrollY ?? window.pageYOffset ?? 0)\n    : (source as HTMLElement).scrollTop;\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { validSelector } from \"../utils/declared_value\";\nimport { FrameCoalescer } from \"../utils/frame_coalescer\";\nimport { ListenerSet } from \"../utils/listener_set\";\nimport { MorphRenderWatcher } from \"../utils/morph_render_watcher\";\nimport { NUMBER_BOUNDS, type NumberValueConstraints } from \"../utils/number_bounds\";\nimport { NumberValueReader } from \"../utils/number_value\";\nimport { resolveScrollSource, type ScrollSource, scrollOffset } from \"../utils/scroll_source\";\n\n/** The depth that never hides, used when `offset` is not a finite number. */\nconst DEFAULT_OFFSET = 80;\n\n/**\n * Headless **smart sticky header**: hides the header on scroll-down and\n * reveals it on scroll-up, published as a `data-header-hidden` hook the\n * consumer's CSS translates away (`stimeo--sticky-observer` detects *stuck*,\n * but has no direction sense; this adds it). Core (zero dependencies).\n *\n * Markup contract (identifier: `stimeo--smart-sticky-header`):\n *   <header data-controller=\"stimeo--smart-sticky-header\"\n *           style=\"position: sticky; top: 0;\">…</header>\n *   <!-- [data-header-hidden=\"true\"] { transform: translateY(-100%); } -->\n *\n * The scroll source is the window by default; inside an overflow container,\n * point `containerSelector` at it (the header usually sits inside it too). A\n * declaration that cannot be parsed as a selector reads as the window, so a\n * typo costs the container binding rather than the whole header.\n *\n * Scrolling down past `offset` px sets `data-header-hidden=\"true\"`, and a\n * scroll-up beyond the `tolerance` jitter guard reveals it again. Within the\n * `offset` zone the header is always revealed, decided ahead of that jitter\n * guard: a header stranded off-screen near the top cannot be scrolled back\n * into view. Focus reaching the header always reveals it, and while focus\n * stays inside the header a scroll-down never hides it — a keyboard user must\n * be able to see where focus went AND keep seeing the element that owns it\n * (WCAG 2.4.7 / 2.4.11).\n *\n * `change` dispatches `{ hidden }` on transitions only: the reflection\n * `connect()` performs is the current state rather than a change.\n *\n * @remarks\n * Behavior only — `position: sticky`, the translate animation, and\n * reduced-motion handling are the consumer's CSS (`prefers-reduced-motion`\n * should disable the transition, not the behavior). Scroll work is\n * rAF-throttled; listeners and any pending frame are released on\n * `disconnect()`, and `connect()` resets the transient hook (a Turbo cache\n * snapshot must not restore a hidden header at scroll top). The scroll source\n * follows a runtime change: a `containerSelector` that names another container,\n * or a morph that reaches the header after replacing the container its selector\n * names, moves the listener to the container resolved now, and the position\n * found there is a baseline rather than a scroll in either direction.\n * `containerSelector` and `offset` changed in one batch are applied in a single\n * pass after it.\n */\nexport class SmartStickyHeaderController extends Controller<HTMLElement> {\n  /** Numeric read boundaries share one reader for this controller instance. */\n  readonly #numbers = new NumberValueReader();\n\n  static override values = {\n    containerSelector: { type: String, default: \"\" },\n    offset: { type: Number, default: DEFAULT_OFFSET },\n    tolerance: { type: Number, default: 4 },\n  };\n\n  static valueConstraints = {\n    offset: NUMBER_BOUNDS.finite,\n    tolerance: NUMBER_BOUNDS.nonNegative,\n  } satisfies NumberValueConstraints<typeof SmartStickyHeaderController.values>;\n  static events = [\"change\"] as const;\n\n  declare containerSelectorValue: string;\n  declare offsetValue: number;\n  declare toleranceValue: number;\n\n  /** Coalesces scroll bursts into one measurement per frame. */\n  readonly #frames = new FrameCoalescer();\n  /** The scroll source the listener is on, read for the offset and the next move's comparison. */\n  #scrollerEl: ScrollSource = window;\n  /** The scroll listener on the current source; a move to another source releases it first. */\n  readonly #scrollListeners = new ListenerSet();\n  /** The element's focus listener of one connection. */\n  readonly #listeners = new ListenerSet();\n  /** The validated `containerSelector`, or `\"\"` when the declaration cannot be parsed. */\n  #containerSelector = \"\";\n  #lastY = 0;\n  /** Last published state, so `change` fires only on transitions. */\n  #hidden: boolean | null = null;\n\n  /**\n   * The depth that never hides. A declaration that is not a finite number reads\n   * as the default, so the comparison path never sees `NaN` — which would\n   * answer `false` to every comparison and hide the header inside the very\n   * zone the value exists to protect.\n   */\n  get #offset(): number {\n    return this.#safeOffset;\n  }\n\n  readonly #onScroll = (): void => this.#frames.schedule(() => this.#measure());\n\n  /**\n   * Focus inside a hidden header must reveal it (WCAG 2.4.7 / 2.4.11); the\n   * hold while focus *stays* inside is the `#apply` hide invariant.\n   */\n  readonly #onFocusin = (): void => this.#apply(false);\n\n  /**\n   * Validates `containerSelector` once, so no resolve parses a selector that\n   * throws, then asks for a pass that follows the container it names.\n   */\n  containerSelectorValueChanged(): void {\n    this.#containerSelector = validSelector(this.element, this.containerSelectorValue, \"\");\n    this.#morphRender.schedule();\n  }\n\n  /** Asks for a pass when application code (or a Turbo morph) changes `offset`. */\n  offsetValueChanged(): void {\n    this.#morphRender.schedule();\n  }\n\n  /**\n   * One pass for a retained-element morph and for the Values a batch changes:\n   * follow the scroll source the declaration names now, then decide again.\n   */\n  readonly #morphRender = new MorphRenderWatcher(() => {\n    this.#followSource();\n    this.#measure();\n  });\n\n  override connect(): void {\n    this.#morphRender.observe(this.element);\n    // The hook is scroll-derived: recompute from the live scroll position\n    // instead of trusting a cached snapshot (which may say hidden at y=0).\n    this.#hidden = null;\n    this.#listenTo(resolveScrollSource(this.#containerSelector));\n    this.#listeners.add(this.element, \"focusin\", this.#onFocusin);\n    this.#apply(false, false);\n  }\n\n  override disconnect(): void {\n    this.#morphRender.disconnect();\n    this.#scrollListeners.dispose();\n    this.#listeners.dispose();\n    this.#frames.cancel();\n  }\n\n  /**\n   * Moves the listener to the scroll source the declaration resolves to now,\n   * when that is another node: released from the old one first, then added once\n   * to the new one. A pass that resolves to the source already held keeps it,\n   * and with it the position a pending scroll is measured from.\n   */\n  #followSource(): void {\n    const source = resolveScrollSource(this.#containerSelector);\n    if (source === this.#scrollerEl) return;\n    this.#scrollListeners.dispose();\n    this.#listenTo(source);\n  }\n\n  /**\n   * Listens to `source`, taking its current position as the baseline: a\n   * position on a source not listened to before is where it is, not a scroll.\n   */\n  #listenTo(source: ScrollSource): void {\n    this.#scrollerEl = source;\n    this.#lastY = scrollOffset(source);\n    this.#scrollListeners.add(source, \"scroll\", this.#onScroll, { passive: true });\n  }\n\n  /** @stimeoRenderRoot */\n  #measure(): void {\n    const y = scrollOffset(this.#scrollerEl);\n    // The offset zone decides before the jitter guard: a move small enough to\n    // be jitter can still be the one that re-enters the zone, and a header\n    // left hidden there cannot be scrolled back into view.\n    if (y <= this.#offset) {\n      this.#lastY = y;\n      this.#apply(false);\n      return;\n    }\n\n    const delta = y - this.#lastY;\n    if (this.#isJitter(delta)) {\n      this.#apply(this.#hidden ?? false);\n      return;\n    }\n    this.#lastY = y;\n    this.#apply(delta > 0);\n  }\n\n  /**\n   * Whether one scroll step is too small to act on.\n   *\n   * @stimeoRuntimeOnly `tolerance` is the allowance one scroll step is compared against; the\n   *   header's state at rest does not depend on it.\n   */\n  #isJitter(delta: number): boolean {\n    return Math.abs(delta) < this.#safeTolerance;\n  }\n\n  /**\n   * Reflects the state onto the hook and emits `change` on transitions.\n   *\n   * @param notify - whether a transition announces itself. The reflection\n   *   `connect()` performs is the current state, not a change.\n   */\n  #apply(hidden: boolean, notify = true): void {\n    // Invariant: a header holding focus is never hidden — `focusin` revealed\n    // it, and no transition may slide the focus owner away mid-interaction\n    // (WCAG 2.4.7 / 2.4.11). Vetoed here at the single state-transition choke\n    // point (not in each caller), so any future hide path — a timer, an\n    // action — cannot bypass it. Reveals are never vetoed.\n    if (hidden && this.element.contains(document.activeElement)) return;\n    const changed = hidden !== this.#hidden;\n    this.#hidden = hidden;\n    this.element.setAttribute(\"data-header-hidden\", hidden ? \"true\" : \"false\");\n    if (notify && changed) this.dispatch(\"change\", { detail: { hidden } });\n  }\n  /** Current `offset` declaration resolved against its numeric contract. */\n  get #safeOffset(): number {\n    return this.#numbers.read(\n      this,\n      \"offset\",\n      this.offsetValue,\n      SmartStickyHeaderController.values.offset.default,\n      SmartStickyHeaderController.valueConstraints.offset,\n    );\n  }\n\n  /** Current `tolerance` declaration resolved against its numeric contract. */\n  get #safeTolerance(): number {\n    return this.#numbers.read(\n      this,\n      \"tolerance\",\n      this.toleranceValue,\n      SmartStickyHeaderController.values.tolerance.default,\n      SmartStickyHeaderController.valueConstraints.tolerance,\n    );\n  }\n}\n"]}

package/dist/controllers/sortable_controller.d.ts

@@ -54,10 +54,10 @@ import { Controller } from '@hotwired/stimulus';
  * broadcast makes the board collaborative). The DOM order is the single source
  * of truth: items are read live on every event, so rows appended by Turbo need
  * no rewiring, and a Turbo cache restore reconnects idempotently (`connect()`
- * clears the transient root hook; a drag cannot survive a navigation). Only the
- * event listeners are held, and they are removed on `disconnect()`. Multi-list
- * / kanban, nested DnD, auto-scroll at the edges, and virtualized lists are
- * deliberately out of this single-list scope.
+ * clears the transient root hook; a drag cannot survive a navigation). The event
+ * listeners and a pending lost-item check are all it holds, and `disconnect()`
+ * releases both. Multi-list / kanban, nested DnD, auto-scroll at the edges, and
+ * virtualized lists are deliberately out of this single-list scope.
  */
 declare class SortableController extends Controller<HTMLElement> {
     #private;