stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/sortable_controller.js

@@ -1,8 +1,12 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/sortable_controller.ts
+function fillTemplate(template, values) {
+  return template.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (match, name) => {
+    const replacement = Object.hasOwn(values, name) ? values[name] : void 0;
+    return replacement === void 0 ? match : String(replacement);
+  });
+}
 
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -12,39 +16,41 @@ function announce(message, options = {}) {
     })
   );
 }
-function fillTemplate(template, values) {
-  return template.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (match, name) => {
-    const replacement = values[name];
-    return replacement === void 0 ? match : String(replacement);
-  });
-}
 
-// src/utils/logical_scroll.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();
+  }
+};
+
 function isRtl(element) {
   return window.getComputedStyle(element).direction === "rtl";
 }
 
-// src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
   #queued = false;
   #active = false;
   #generation = 0;
-  /** @param run - the single reconciliation pass, invoked at most once per batch. */
   constructor(run) {
     this.#run = run;
   }
-  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */
   activate() {
     this.#active = true;
   }
-  /** Closes the window and drops any pending pass; call from `disconnect()`. */
   cancel() {
     this.#active = false;
     this.#queued = false;
     this.#generation += 1;
   }
-  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -57,19 +63,16 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/transient_hooks.ts
 var TransientHooks = class {
   #attributes;
   constructor(options) {
     this.#attributes = options.attributes;
   }
-  /** Drops the declared hooks from `element`; what it carries besides stays. */
   reset(element) {
     for (const attribute of this.#attributes) element.removeAttribute(attribute);
   }
 };
 
-// src/controllers/sortable_controller.ts
 var TRANSIENT = new TransientHooks({ attributes: ["data-sortable-dragging"] });
 var SortableController = class extends Controller {
   static targets = ["list", "item"];
@@ -82,36 +85,22 @@ var SortableController = class extends Controller {
   };
   static events = ["reorder"];
   #session = null;
-  /** Defers the lost-item check to after the mutation batch (see below). */
   #settle = new MicrotaskCoalescer(() => this.#dropLostSession());
+  #listeners = new ListenerSet();
   connect() {
     TRANSIENT.reset(this.element);
     this.#settle.activate();
-    this.element.addEventListener("stimeo--pointer-drag:start", this.#onDragStart);
-    this.element.addEventListener("stimeo--pointer-drag:move", this.#onDragMove);
-    this.element.addEventListener("stimeo--pointer-drag:end", this.#onDragEnd);
-    this.element.addEventListener("stimeo--pointer-drag:cancel", this.#onDragCancel);
+    this.#listeners.add(this.element, "stimeo--pointer-drag:start", this.#onDragStart);
+    this.#listeners.add(this.element, "stimeo--pointer-drag:move", this.#onDragMove);
+    this.#listeners.add(this.element, "stimeo--pointer-drag:end", this.#onDragEnd);
+    this.#listeners.add(this.element, "stimeo--pointer-drag:cancel", this.#onDragCancel);
   }
   disconnect() {
-    this.element.removeEventListener("stimeo--pointer-drag:start", this.#onDragStart);
-    this.element.removeEventListener("stimeo--pointer-drag:move", this.#onDragMove);
-    this.element.removeEventListener("stimeo--pointer-drag:end", this.#onDragEnd);
-    this.element.removeEventListener("stimeo--pointer-drag:cancel", this.#onDragCancel);
+    this.#listeners.dispose();
     this.#settle.cancel();
     this.#session = null;
     this.element.removeAttribute("data-sortable-dragging");
   }
-  /**
-   * Ends a session whose item left the item set.
-   *
-   * The controller's own reorder detaches and reattaches the item inside one
-   * mutation batch, so the loss is only real once the batch has settled — the
-   * check therefore runs a microtask later and asks whether the item is a target
-   * again. Without it a deleted row (a broadcast that drops it from the board)
-   * or a morph that strips the item's target attribute would hold the
-   * one-at-a-time session for the rest of the page's life, with the root hook
-   * stuck on and every later grab refused with no way out.
-   */
   itemTargetDisconnected(item) {
     if (this.#session?.item !== item) return;
     this.#settle.schedule();
@@ -125,7 +114,6 @@ var SortableController = class extends Controller {
     this.element.removeAttribute("data-sortable-dragging");
     if (session.item.isConnected) this.#restore(session, items);
   }
-  /** Picks the item up: remembers its neighbours and announces the grab. */
   #onDragStart = (event) => {
     if (this.#session) return;
     const items = this.#items();
@@ -153,7 +141,6 @@ var SortableController = class extends Controller {
       this.#followPointer(session, detail, items);
     }
   };
-  /** Drops the item: announces, then reports `reorder` if the position changed. */
   #onDragEnd = (event) => {
     const session = this.#session;
     if (!session) return;
@@ -168,7 +155,6 @@ var SortableController = class extends Controller {
       this.dispatch("reorder", { detail: { item: session.item, from, to } });
     }
   };
-  /** Restores the pickup position (Escape / OS `pointercancel`). */
   #onDragCancel = (event) => {
     const session = this.#session;
     if (!session) return;
@@ -179,16 +165,6 @@ var SortableController = class extends Controller {
     this.#restore(session, items);
     this.#announce("canceled", session.item);
   };
-  /**
-   * The slot the item was picked up from, read back through the neighbours it
-   * had then — `null` when neither survives and the item itself is gone.
-   *
-   * The anchor is the item that followed it, so restoring means "before that one
-   * again". When the anchor was deleted mid-drag the predecessor answers the
-   * same question from the other side. With both gone the item's current slot is
-   * the honest answer: nothing is known to have moved, so no reorder is reported
-   * and a cancel leaves the item where it is.
-   */
   #pickupSlot(session, items) {
     const others = items.filter((candidate) => candidate !== session.item);
     if (session.anchor) {
@@ -202,7 +178,6 @@ var SortableController = class extends Controller {
     const here = items.indexOf(session.item);
     return here === -1 ? null : here;
   }
-  /** Puts the item back where it was picked up from. */
   #restore(session, items) {
     const slot = this.#pickupSlot(session, items);
     if (slot === null) return;
@@ -212,17 +187,6 @@ var SortableController = class extends Controller {
       slot
     );
   }
-  /**
-   * Keyboard stepping: `pointer-drag` reports *cumulative* synthetic deltas, so
-   * the difference from the last consumed value is one arrow press — its sign is
-   * the direction. Cross-axis arrows never change the primary delta (no move).
-   *
-   * The sign is physical (`ArrowRight` is always `+dx`), so a right-to-left row
-   * has to invert it: there, moving the item rightward means moving it *earlier*
-   * in the DOM. Skipping this would also split the two halves of one keypress —
-   * `roving` already moves focus logically, so the same arrow would send the
-   * focus and the grabbed item opposite ways.
-   */
   #stepFromKeyboard(session, detail, items) {
     const primary = Number(this.#isVertical ? detail.dy : detail.dx) || 0;
     const delta = primary - session.lastPrimary;
@@ -239,18 +203,6 @@ var SortableController = class extends Controller {
     );
     this.#announce("moved", session.item);
   }
-  /**
-   * Pointer following: the item moves to the slot whose siblings' midpoints the
-   * pointer has passed (per `orientation`).
-   *
-   * Only siblings that occupy space take part. A row with no layout box — a
-   * filtered-out item, a `display: none` ancestor, a collapsed `<details>` — is
-   * reported with an empty rect at the document origin, and its midpoint of `0`
-   * sits below every pointer position: counted, it would read as passed on the
-   * very first move and send the item across a slot the pointer never crossed.
-   * With no laid-out sibling at all there is nothing to compare against and the
-   * move is skipped entirely.
-   */
   #followPointer(session, detail, items) {
     const pointer = Number(this.#isVertical ? detail.y : detail.x) || 0;
     const vertical = this.#isVertical;
@@ -272,18 +224,6 @@ var SortableController = class extends Controller {
     this.#insertAt(session.item, laidOut, target);
     this.#announce("moved", session.item);
   }
-  /**
-   * Reinserts `item` at `index` among `scope`, relative to the sibling already
-   * standing there.
-   *
-   * The reorder is defined against the items, not against a container: the
-   * neighbour's own parent is where the item belongs. A `list` target that is
-   * not the items' parent — or none at all, which the markup contract allows —
-   * therefore still lands the move in the right place instead of throwing, and
-   * the last slot is *after the last item* rather than after whatever else the
-   * container holds (a live region, a footer), which would put the row outside
-   * the reading order the list publishes.
-   */
   #insertAt(item, scope, index) {
     const clamped = Math.max(0, Math.min(index, scope.length));
     const ahead = scope[clamped] ?? null;
@@ -297,20 +237,6 @@ var SortableController = class extends Controller {
     parent.insertBefore(item, ahead ?? neighbour.nextSibling);
     if (hadFocus) active.focus();
   }
-  /**
-   * Hands one step to the page's shared announcer.
-   *
-   * The library carries no live region and no English copy: the wording is the
-   * consumer's, written into `announceGrabbedText` / `announceMovedText` /
-   * `announceDroppedText` / `announceCanceledText` with `{name}` / `{position}` /
-   * `{total}` placeholders, and an unset one announces nothing.
-   *
-   * Only transitions reach here — the pickup, a step that actually changed the
-   * landing slot, and the single end of the session — so a pointer crossing the
-   * same slot twice or an arrow clamped at an end stays silent.
-   *
-   * @stimeoRuntimeOnly The texts word the steps of one reorder, spoken as they happen.
-   */
   #announce(key, item) {
     const template = this.#announceTemplate(key);
     if (template.length === 0) return;
@@ -323,7 +249,6 @@ var SortableController = class extends Controller {
       })
     );
   }
-  /** The consumer's wording for one step, or `""` when they authored none. */
   #announceTemplate(key) {
     switch (key) {
       case "grabbed":
@@ -336,52 +261,28 @@ var SortableController = class extends Controller {
         return this.announceCanceledTextValue;
     }
   }
-  /** The announced item name: the authored override, else its collapsed text. */
   #nameOf(item) {
     const authored = item.getAttribute(`data-${this.identifier}-name`);
     if (authored) return authored;
     return (item.textContent ?? "").replace(/\s+/g, " ").trim();
   }
-  /**
-   * Resolves the sortable item owning a bubbled `pointer-drag` event.
-   *
-   * `pointer-drag` dispatches on its own element, and the markup contract puts
-   * one on each item, so the owner is the item that **is** the target. Matching
-   * an ancestor instead would make a card's own inner draggable — a knob, a
-   * split pane, anything the primitive is composed into — drive the card.
-   */
   #itemFor(target, items) {
     if (!target) return null;
     return items.find((item) => item === target) ?? null;
   }
-  /** The items in live DOM order (targets re-query the DOM on every access). */
   #items() {
     return this.itemTargets;
   }
-  /** The reorder container: the `list` target when present, else the element. */
   get #list() {
     return this.hasListTarget ? this.listTarget : this.element;
   }
   get #isVertical() {
     return this.orientationValue !== "horizontal";
   }
-  /**
-   * Whether DOM order runs opposite to the primary coordinate — true only for a
-   * horizontal row under `dir="rtl"`, where the first item sits at the largest
-   * `x`. Both drag paths reach this controller in physical terms (`pointer-drag`
-   * documents its deltas as physical and hands RTL to its consumer, which is
-   * this controller), so both have to be mapped back onto DOM order here.
-   *
-   * Read from the list, the element that lays the items out — never from the
-   * dragged item, which may carry its own `dir`. The list inherits the computed
-   * direction, so authoring `dir` on the root works too. A vertical list is
-   * unaffected: writing direction does not mirror the block axis.
-   */
   get #isReversed() {
     return !this.#isVertical && isRtl(this.#list);
   }
 };
 
 export { SortableController };
-//# sourceMappingURL=sortable_controller.js.map
 //# sourceMappingURL=sortable_controller.js.map

package/dist/controllers/sortable_controller.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/announce.ts","../../src/utils/logical_scroll.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/transient_hooks.ts","../../src/controllers/sortable_controller.ts"],"names":[],"mappings":"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","file":"sortable_controller.js","sourcesContent":["/**\n * Sends one message to the page's shared `stimeo--announcer`.\n *\n * A component that has to reach assistive tech does not carry a live region of its\n * own: a region only announces what changes *after* assistive tech already knows\n * about it, which a region that appears (or is un-hidden) with its message cannot\n * satisfy. The one region that can is the announcer sitting in the page from the\n * start, so state changes are handed to it as an event and it does the reading.\n *\n * The event goes to `window` because the announcer is usually a sibling high in the\n * document rather than an ancestor of the component dispatching it.\n *\n * Wording comes from the consumer — the library ships no English strings — so an\n * empty message is silently dropped and nothing is announced.\n *\n * @example\n * ```ts\n * announce(this.announceTextValue, { assertive: false });\n * ```\n */\nexport function announce(message: string, options: { assertive?: boolean } = {}): void {\n  const text = message.trim();\n  if (text.length === 0) return;\n  window.dispatchEvent(\n    new CustomEvent(\"stimeo--announcer:announce\", {\n      detail: { message: text, assertive: options.assertive === true },\n    }),\n  );\n}\n\n/**\n * Fills `{name}` placeholders in an announcement template from `values`.\n *\n * The same substitution the value-text templates use, so a consumer writes\n * `\"{percent}% complete\"` in one attribute and gets the same rules everywhere. A\n * placeholder with no matching entry is left as authored rather than blanked, which\n * keeps a typo visible instead of silently swallowing the word.\n */\nexport function fillTemplate(template: string, values: Record<string, string | number>): string {\n  return template.replace(/\\{([a-zA-Z][a-zA-Z0-9]*)\\}/g, (match, name: string) => {\n    const replacement = values[name];\n    return replacement === undefined ? match : String(replacement);\n  });\n}\n","/** Normalized scroll position and maximum distance on one logical axis. */\nexport interface LogicalScrollMetrics {\n  position: number;\n  max: number;\n}\n\n/**\n * Whether horizontal scrolling on `element` follows right-to-left inline flow.\n *\n * Resolved from the **computed** `direction`, so the authoring contract is the\n * usual `dir=\"rtl\"` (or a stylesheet) on the element or any ancestor.\n *\n * Scope: horizontal writing modes. A vertical writing mode (`writing-mode:\n * vertical-rl`) also inverts the horizontal axis, which this check does not\n * model — vertical writing modes are out of scope for the scroll utilities\n * (their consumers describe axes as horizontal/vertical, not inline/block).\n */\nexport function isRtl(element: Element): boolean {\n  return window.getComputedStyle(element).direction === \"rtl\";\n}\n\n/**\n * Returns scroll distance from the logical start edge.\n *\n * CSSOM View exposes standards-mode RTL horizontal offsets as `0` at the inline\n * start (right) and increasingly negative values toward the inline end (left).\n * The normalized position is always clamped to `[0, max]`, which also absorbs\n * Safari's elastic overscroll values.\n */\nexport function logicalScrollMetrics(\n  element: HTMLElement,\n  horizontal: boolean,\n): LogicalScrollMetrics {\n  const max = Math.max(\n    0,\n    horizontal\n      ? element.scrollWidth - element.clientWidth\n      : element.scrollHeight - element.clientHeight,\n  );\n  const raw = horizontal ? element.scrollLeft : element.scrollTop;\n  const position = horizontal && isRtl(element) ? -raw : raw;\n  return { position: Math.min(max, Math.max(0, position)), max };\n}\n\n/**\n * Converts a logical start/end delta to the physical value accepted by\n * `Element.scrollBy`.\n */\nexport function physicalScrollDelta(\n  element: HTMLElement,\n  horizontal: boolean,\n  logicalDelta: number,\n): number {\n  return horizontal && isRtl(element) ? -logicalDelta : logicalDelta;\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 * This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\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  /** 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","/**\n * Drops the transient state hooks a connection inherited, so the cycle it opens\n * starts from a DOM that claims nothing.\n *\n * A transient hook is an attribute a controller writes to say \"this is happening\n * right now\" — a drag in progress, a form with unsaved edits, a refused\n * subscription. Its lifetime belongs to the interaction, not to the element, and\n * the two come apart whenever the element outlives the instance that wrote it: a\n * Turbo cache snapshot taken mid-interaction restores the hook with the markup,\n * and an element re-inserted elsewhere in the page carries it along. Nothing\n * takes such a hook off, because the instance that owned it is gone; consumer\n * CSS then keeps claiming a state no one is in.\n *\n * **`turbo:before-cache` cannot do this job**, which is why the pass belongs in\n * `connect()`: that event fires for a navigation only, so an in-page move — the\n * other half of the population — never reaches it, and a hook that arrived with\n * a moved element would survive. `connect()` covers both, because both end in a\n * connection.\n *\n * Scope is the **drop** only. What the fresh cycle should say instead is the\n * consumer's: a value re-read from the live DOM, a roster refilled by the\n * stream, a measurement retaken from the current scroll position, a slot emptied\n * of the last result. Those answers differ per consumer and none of them is a\n * hook removal, so the pass stops where every consumer agrees.\n *\n * A declaration names one group of hooks and carries no per-instance state, so\n * it belongs at module scope, shared by every instance the page connects. A\n * consumer writes as many as it has groups — hooks it drops under different\n * conditions cannot share one. The exception is a hook whose name is only known\n * at runtime, such as one built from the registered identifier: that\n * declaration is a field, because the name is.\n *\n * **A drop is not always right.** The population splits on one question: can the\n * state a hook describes outlive the instance that wrote it? Where it cannot — a\n * drag ends with the pointer, a subscription dies with its socket — dropping on\n * every connection is correct. Where it can — a submission in flight is not\n * interrupted by an in-page move — only a connection that follows a real restore\n * may drop, and the consumer answers \"did a session survive?\" with the signal it\n * already holds for its own teardown (a live-session field, a `DetachGate`\n * probe). The drop then sits behind that answer, as the second example shows.\n *\n * @example Unconditional — the state cannot outlive the instance.\n * ```ts\n * const TRANSIENT = new TransientHooks({ attributes: [\"data-sortable-dragging\"] });\n *\n * connect(): void {\n *   TRANSIENT.reset(this.element);\n * }\n * ```\n *\n * @example Gated — an in-page move must not drop a live state.\n * ```ts\n * const TRANSIENT = new TransientHooks({ attributes: [\"data-optimistic\"] });\n *\n * connect(): void {\n *   const restored = !this.#connected && !this.#gate.pending;\n *   this.#gate.cancel();\n *   this.#connected = true;\n *   if (restored) TRANSIENT.reset(this.element);\n * }\n * ```\n */\n\n/** What a consumer declares once about the hooks its interaction owns. */\nexport interface TransientHooksOptions {\n  /**\n   * The attribute names a connection may find written by an earlier one. Hooks\n   * a consumer drops under different conditions belong to different\n   * declarations, so each one can be reset on its own.\n   */\n  readonly attributes: readonly string[];\n}\n\n/**\n * One consumer's declaration of the hooks its interaction owns, dropped from an\n * element by {@link TransientHooks.reset}.\n *\n * Every member comment inside this class body is inlined into each consumer\n * bundle (`tsup` builds with `splitting: false`), so rationale belongs in this\n * file's own block, which `dist` drops, and only the contract belongs inside.\n */\nexport class TransientHooks {\n  readonly #attributes: readonly string[];\n\n  constructor(options: TransientHooksOptions) {\n    this.#attributes = options.attributes;\n  }\n\n  /** Drops the declared hooks from `element`; what it carries besides stays. */\n  reset(element: Element): void {\n    for (const attribute of this.#attributes) element.removeAttribute(attribute);\n  }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { announce, fillTemplate } from \"../utils/announce\";\nimport { isRtl } from \"../utils/logical_scroll\";\nimport { MicrotaskCoalescer } from \"../utils/microtask_coalescer\";\nimport { TransientHooks } from \"../utils/transient_hooks\";\n\n/** The hook a connection may find written by an earlier, now-gone one. */\nconst TRANSIENT = new TransientHooks({ attributes: [\"data-sortable-dragging\"] });\n\n/** The four steps a consumer can give wording to. */\ntype AnnounceKey = \"grabbed\" | \"moved\" | \"dropped\" | \"canceled\";\n\n/** A reorder in flight: one item picked up by pointer or keyboard. */\ninterface SortSession {\n  item: HTMLElement;\n  /**\n   * The item that followed it at pickup, and the one that preceded it.\n   *\n   * The pickup slot is remembered as nodes rather than as an index because the\n   * list can change underneath a live drag — a broadcast board inserts and\n   * deletes rows while someone is holding one — and an index taken at pickup\n   * stops pointing at that place the moment a row appears above it.\n   */\n  anchor: HTMLElement | null;\n  predecessor: HTMLElement | null;\n  /** Last primary-axis cumulative delta consumed by keyboard stepping. */\n  lastPrimary: number;\n}\n\n/**\n * Headless, accessible **sortable** (single-list reorder) — the a11y-first\n * drag-and-drop that is the flagship consumer of the\n * `stimeo--pointer-drag` primitive. The composition is markup-level and each\n * layer keeps its job: `pointer-drag` (on every item) emits the normalized drag\n * signal with its built-in keyboard alternative, `roving` (on the list) keeps\n * the handles a single Tab stop, and this controller interprets the signal —\n * live-reordering the DOM, handing each step to the page's shared announcer,\n * and reporting the final `reorder`. No dedicated APG pattern exists for\n * drag-and-drop; the keyboard model (grab → arrows → drop / Escape) comes from\n * `pointer-drag` and the announcements make it non-visually trackable\n * (WCAG 2.1.1 / 2.5.7 / 4.1.3). Core (zero dependencies).\n *\n * Markup contract (identifier: `stimeo--sortable`):\n *   <div data-controller=\"stimeo--sortable\">\n *     <ul data-stimeo--sortable-target=\"list\" data-controller=\"stimeo--roving\"\n *         data-stimeo--roving-orientation-value=\"vertical\">\n *       <li data-stimeo--sortable-target=\"item\" data-stimeo--sortable-name=\"Card A\"\n *           data-controller=\"stimeo--pointer-drag\"\n *           data-stimeo--pointer-drag-axis-value=\"y\">\n *         <span>Card A</span>\n *         <button type=\"button\" aria-label=\"Reorder Card A\"\n *                 data-stimeo--pointer-drag-target=\"handle\"\n *                 data-stimeo--roving-target=\"item\">⠿</button>\n *       </li>\n *       …\n *     </ul>\n *   </div>\n *\n * The composed values must follow the sort axis: roving's `orientation`\n * (which defaults to `horizontal`, so a vertical list has to author\n * `vertical`) and pointer-drag's `axis`. `stimeo check` enforces both\n * alignments as composition rules (`composition-mismatch`).\n *\n * Pointer flow: dragging an item live-moves it whenever the pointer crosses a\n * sibling's midpoint (per `orientation`). Keyboard flow: each synthetic\n * `pointer-drag` move steps the item one position. A horizontal list under\n * `dir=\"rtl\"` reverses both, since DOM order then runs right-to-left while\n * `pointer-drag` reports physical coordinates. Dropping dispatches\n * `reorder` (`{ item, from, to }`, zero-based) when the position changed;\n * Escape / `pointercancel` restores the pickup position. Every step is handed to\n * the page's shared `stimeo--announcer` as the consumer's own wording —\n * `announceGrabbedText` / `announceMovedText` / `announceDroppedText` /\n * `announceCanceledText`, with `{name}` / `{position}` / `{total}` placeholders —\n * and an unset one announces nothing.\n *\n * @remarks\n * Behavior only — the ghost/placeholder/drop-hint visuals are the consumer's\n * CSS, keyed off `pointer-drag`'s `data-dragging`/`data-grabbed` on the item\n * and this controller's `data-sortable-dragging` on the root. Persistence is\n * the consumer's `reorder` listener (post the new position; a Turbo Stream\n * broadcast makes the board collaborative). The DOM order is the single source\n * of truth: items are read live on every event, so rows appended by Turbo need\n * no rewiring, and a Turbo cache restore reconnects idempotently (`connect()`\n * clears the transient root hook; a drag cannot survive a navigation). Only the\n * event listeners are held, and they are removed on `disconnect()`. Multi-list\n * / kanban, nested DnD, auto-scroll at the edges, and virtualized lists are\n * deliberately out of this single-list scope.\n */\nexport class SortableController extends Controller<HTMLElement> {\n  static override targets = [\"list\", \"item\"];\n  static override values = {\n    orientation: { type: String, default: \"vertical\" },\n    announceGrabbedText: { type: String, default: \"\" },\n    announceMovedText: { type: String, default: \"\" },\n    announceDroppedText: { type: String, default: \"\" },\n    announceCanceledText: { type: String, default: \"\" },\n  };\n  static events = [\"reorder\"] as const;\n\n  declare readonly hasListTarget: boolean;\n  declare readonly listTarget: HTMLElement;\n  declare readonly itemTargets: HTMLElement[];\n  declare orientationValue: string;\n  declare announceGrabbedTextValue: string;\n  declare announceMovedTextValue: string;\n  declare announceDroppedTextValue: string;\n  declare announceCanceledTextValue: string;\n\n  #session: SortSession | null = null;\n  /** Defers the lost-item check to after the mutation batch (see below). */\n  readonly #settle = new MicrotaskCoalescer(() => this.#dropLostSession());\n\n  override connect(): void {\n    // A drag cannot survive a navigation: drop the hook a Turbo cache snapshot\n    // may have preserved mid-drag (idempotent reconnect).\n    TRANSIENT.reset(this.element);\n    this.#settle.activate();\n    this.element.addEventListener(\"stimeo--pointer-drag:start\", this.#onDragStart);\n    this.element.addEventListener(\"stimeo--pointer-drag:move\", this.#onDragMove);\n    this.element.addEventListener(\"stimeo--pointer-drag:end\", this.#onDragEnd);\n    this.element.addEventListener(\"stimeo--pointer-drag:cancel\", this.#onDragCancel);\n  }\n\n  override disconnect(): void {\n    this.element.removeEventListener(\"stimeo--pointer-drag:start\", this.#onDragStart);\n    this.element.removeEventListener(\"stimeo--pointer-drag:move\", this.#onDragMove);\n    this.element.removeEventListener(\"stimeo--pointer-drag:end\", this.#onDragEnd);\n    this.element.removeEventListener(\"stimeo--pointer-drag:cancel\", this.#onDragCancel);\n    this.#settle.cancel();\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n  }\n\n  /**\n   * Ends a session whose item left the item set.\n   *\n   * The controller's own reorder detaches and reattaches the item inside one\n   * mutation batch, so the loss is only real once the batch has settled — the\n   * check therefore runs a microtask later and asks whether the item is a target\n   * again. Without it a deleted row (a broadcast that drops it from the board)\n   * or a morph that strips the item's target attribute would hold the\n   * one-at-a-time session for the rest of the page's life, with the root hook\n   * stuck on and every later grab refused with no way out.\n   */\n  itemTargetDisconnected(item: HTMLElement): void {\n    if (this.#session?.item !== item) return;\n    this.#settle.schedule();\n  }\n\n  #dropLostSession(): void {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (items.includes(session.item)) return;\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n    // An element that is still in the document (a morph took only its target\n    // attribute) goes back where it was picked up. Nothing is announced either\n    // way: the row is no longer one of the items, so there is no position to\n    // read out — what matters is that the next grab is not refused.\n    if (session.item.isConnected) this.#restore(session, items);\n  }\n\n  /** Picks the item up: remembers its neighbours and announces the grab. */\n  readonly #onDragStart = (event: Event): void => {\n    // One reorder at a time: a start from another item (each item has its own\n    // pointer-drag instance) must not clobber the live session — its pickup\n    // slot and cancel restore would be lost.\n    if (this.#session) return;\n    const items = this.#items();\n    const item = this.#itemFor(event.target, items);\n    if (!item) return;\n    const index = items.indexOf(item);\n    this.#session = {\n      item,\n      anchor: items[index + 1] ?? null,\n      predecessor: items[index - 1] ?? null,\n      lastPrimary: 0,\n    };\n    this.element.setAttribute(\"data-sortable-dragging\", \"true\");\n    this.#announce(\"grabbed\", item);\n  };\n\n  readonly #onDragMove = (event: Event): void => {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (this.#itemFor(event.target, items) !== session.item) return;\n\n    const detail = (event as CustomEvent<Record<string, number | string>>).detail;\n    if (detail.pointerType === \"keyboard\") {\n      this.#stepFromKeyboard(session, detail, items);\n    } else {\n      this.#followPointer(session, detail, items);\n    }\n  };\n\n  /** Drops the item: announces, then reports `reorder` if the position changed. */\n  readonly #onDragEnd = (event: Event): void => {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (this.#itemFor(event.target, items) !== session.item) return;\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n    this.#announce(\"dropped\", session.item);\n    const to = items.indexOf(session.item);\n    const from = this.#pickupSlot(session, items) ?? to;\n    if (to !== from) {\n      this.dispatch(\"reorder\", { detail: { item: session.item, from, to } });\n    }\n  };\n\n  /** Restores the pickup position (Escape / OS `pointercancel`). */\n  readonly #onDragCancel = (event: Event): void => {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (this.#itemFor(event.target, items) !== session.item) return;\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n    this.#restore(session, items);\n    this.#announce(\"canceled\", session.item);\n  };\n\n  /**\n   * The slot the item was picked up from, read back through the neighbours it\n   * had then — `null` when neither survives and the item itself is gone.\n   *\n   * The anchor is the item that followed it, so restoring means \"before that one\n   * again\". When the anchor was deleted mid-drag the predecessor answers the\n   * same question from the other side. With both gone the item's current slot is\n   * the honest answer: nothing is known to have moved, so no reorder is reported\n   * and a cancel leaves the item where it is.\n   */\n  #pickupSlot(session: SortSession, items: HTMLElement[]): number | null {\n    const others = items.filter((candidate) => candidate !== session.item);\n    if (session.anchor) {\n      const at = others.indexOf(session.anchor);\n      if (at !== -1) return at;\n    }\n    if (session.predecessor) {\n      const at = others.indexOf(session.predecessor);\n      if (at !== -1) return at + 1;\n    }\n    const here = items.indexOf(session.item);\n    return here === -1 ? null : here;\n  }\n\n  /** Puts the item back where it was picked up from. */\n  #restore(session: SortSession, items: HTMLElement[]): void {\n    const slot = this.#pickupSlot(session, items);\n    if (slot === null) return;\n    this.#insertAt(\n      session.item,\n      items.filter((candidate) => candidate !== session.item),\n      slot,\n    );\n  }\n\n  /**\n   * Keyboard stepping: `pointer-drag` reports *cumulative* synthetic deltas, so\n   * the difference from the last consumed value is one arrow press — its sign is\n   * the direction. Cross-axis arrows never change the primary delta (no move).\n   *\n   * The sign is physical (`ArrowRight` is always `+dx`), so a right-to-left row\n   * has to invert it: there, moving the item rightward means moving it *earlier*\n   * in the DOM. Skipping this would also split the two halves of one keypress —\n   * `roving` already moves focus logically, so the same arrow would send the\n   * focus and the grabbed item opposite ways.\n   */\n  #stepFromKeyboard(\n    session: SortSession,\n    detail: Record<string, number | string>,\n    items: HTMLElement[],\n  ): void {\n    const primary = Number(this.#isVertical ? detail.dy : detail.dx) || 0;\n    const delta = primary - session.lastPrimary;\n    session.lastPrimary = primary;\n    if (delta === 0) return;\n\n    const index = items.indexOf(session.item);\n    const step = (delta > 0 ? 1 : -1) * (this.#isReversed ? -1 : 1);\n    const next = Math.max(0, Math.min(index + step, items.length - 1));\n    if (next === index) return;\n    this.#insertAt(\n      session.item,\n      items.filter((candidate) => candidate !== session.item),\n      next,\n    );\n    this.#announce(\"moved\", session.item);\n  }\n\n  /**\n   * Pointer following: the item moves to the slot whose siblings' midpoints the\n   * pointer has passed (per `orientation`).\n   *\n   * Only siblings that occupy space take part. A row with no layout box — a\n   * filtered-out item, a `display: none` ancestor, a collapsed `<details>` — is\n   * reported with an empty rect at the document origin, and its midpoint of `0`\n   * sits below every pointer position: counted, it would read as passed on the\n   * very first move and send the item across a slot the pointer never crossed.\n   * With no laid-out sibling at all there is nothing to compare against and the\n   * move is skipped entirely.\n   */\n  #followPointer(\n    session: SortSession,\n    detail: Record<string, number | string>,\n    items: HTMLElement[],\n  ): void {\n    const pointer = Number(this.#isVertical ? detail.y : detail.x) || 0;\n    const vertical = this.#isVertical;\n    // `target` counts the siblings that precede the pointer *in DOM order*, and\n    // the two agree only while DOM order runs the same way as the coordinate. In\n    // a right-to-left row it runs the other way, so the comparison flips;\n    // leaving it physical would mix two orderings into one number and drop the\n    // item at a slot the pointer never crossed. Resolved once: it cannot change\n    // mid-loop, and reading it per sibling would re-run `getComputedStyle` on\n    // every pointermove.\n    const reversed = this.#isReversed;\n    const here = items.indexOf(session.item);\n    const laidOut: HTMLElement[] = [];\n    let target = 0;\n    // `current` is the item's own slot in that same laid-out space: the number\n    // of laid-out siblings that come before it in DOM order.\n    let current = 0;\n    items.forEach((item, index) => {\n      if (item === session.item) return;\n      const rect = item.getBoundingClientRect();\n      if (rect.width === 0 && rect.height === 0) return;\n      if (index < here) current += 1;\n      laidOut.push(item);\n      const midpoint = vertical ? rect.top + rect.height / 2 : rect.left + rect.width / 2;\n      if (reversed ? pointer < midpoint : pointer > midpoint) target += 1;\n    });\n    if (laidOut.length === 0 || target === current) return;\n\n    this.#insertAt(session.item, laidOut, target);\n    this.#announce(\"moved\", session.item);\n  }\n\n  /**\n   * Reinserts `item` at `index` among `scope`, relative to the sibling already\n   * standing there.\n   *\n   * The reorder is defined against the items, not against a container: the\n   * neighbour's own parent is where the item belongs. A `list` target that is\n   * not the items' parent — or none at all, which the markup contract allows —\n   * therefore still lands the move in the right place instead of throwing, and\n   * the last slot is *after the last item* rather than after whatever else the\n   * container holds (a live region, a footer), which would put the row outside\n   * the reading order the list publishes.\n   */\n  #insertAt(item: HTMLElement, scope: HTMLElement[], index: number): void {\n    const clamped = Math.max(0, Math.min(index, scope.length));\n    const ahead = scope[clamped] ?? null;\n    const behind = ahead ? null : (scope[scope.length - 1] ?? null);\n    const neighbour = ahead ?? behind;\n    if (!neighbour) return;\n    const parent = neighbour.parentNode;\n    if (!parent) return;\n    // Real browsers drop focus when the focused node is re-inserted (the move\n    // is a remove+insert), which would strand the keyboard grab after one\n    // arrow press — restore it so focus rides the moved item.\n    const active = document.activeElement;\n    const hadFocus = active instanceof HTMLElement && item.contains(active);\n    parent.insertBefore(item, ahead ?? neighbour.nextSibling);\n    if (hadFocus) active.focus();\n  }\n\n  /**\n   * Hands one step to the page's shared announcer.\n   *\n   * The library carries no live region and no English copy: the wording is the\n   * consumer's, written into `announceGrabbedText` / `announceMovedText` /\n   * `announceDroppedText` / `announceCanceledText` with `{name}` / `{position}` /\n   * `{total}` placeholders, and an unset one announces nothing.\n   *\n   * Only transitions reach here — the pickup, a step that actually changed the\n   * landing slot, and the single end of the session — so a pointer crossing the\n   * same slot twice or an arrow clamped at an end stays silent.\n   *\n   * @stimeoRuntimeOnly The texts word the steps of one reorder, spoken as they happen.\n   */\n  #announce(key: AnnounceKey, item: HTMLElement): void {\n    const template = this.#announceTemplate(key);\n    if (template.length === 0) return;\n    const items = this.#items();\n    announce(\n      fillTemplate(template, {\n        name: this.#nameOf(item),\n        position: items.indexOf(item) + 1,\n        total: items.length,\n      }),\n    );\n  }\n\n  /** The consumer's wording for one step, or `\"\"` when they authored none. */\n  #announceTemplate(key: AnnounceKey): string {\n    switch (key) {\n      case \"grabbed\":\n        return this.announceGrabbedTextValue;\n      case \"moved\":\n        return this.announceMovedTextValue;\n      case \"dropped\":\n        return this.announceDroppedTextValue;\n      case \"canceled\":\n        return this.announceCanceledTextValue;\n    }\n  }\n\n  /** The announced item name: the authored override, else its collapsed text. */\n  #nameOf(item: HTMLElement): string {\n    const authored = item.getAttribute(`data-${this.identifier}-name`);\n    if (authored) return authored;\n    return (item.textContent ?? \"\").replace(/\\s+/g, \" \").trim();\n  }\n\n  /**\n   * Resolves the sortable item owning a bubbled `pointer-drag` event.\n   *\n   * `pointer-drag` dispatches on its own element, and the markup contract puts\n   * one on each item, so the owner is the item that **is** the target. Matching\n   * an ancestor instead would make a card's own inner draggable — a knob, a\n   * split pane, anything the primitive is composed into — drive the card.\n   */\n  #itemFor(target: EventTarget | null, items: HTMLElement[]): HTMLElement | null {\n    if (!target) return null;\n    return items.find((item) => item === target) ?? null;\n  }\n\n  /** The items in live DOM order (targets re-query the DOM on every access). */\n  #items(): HTMLElement[] {\n    return this.itemTargets;\n  }\n\n  /** The reorder container: the `list` target when present, else the element. */\n  get #list(): HTMLElement {\n    return this.hasListTarget ? this.listTarget : this.element;\n  }\n\n  get #isVertical(): boolean {\n    return this.orientationValue !== \"horizontal\";\n  }\n\n  /**\n   * Whether DOM order runs opposite to the primary coordinate — true only for a\n   * horizontal row under `dir=\"rtl\"`, where the first item sits at the largest\n   * `x`. Both drag paths reach this controller in physical terms (`pointer-drag`\n   * documents its deltas as physical and hands RTL to its consumer, which is\n   * this controller), so both have to be mapped back onto DOM order here.\n   *\n   * Read from the list, the element that lays the items out — never from the\n   * dragged item, which may carry its own `dir`. The list inherits the computed\n   * direction, so authoring `dir` on the root works too. A vertical list is\n   * unaffected: writing direction does not mirror the block axis.\n   */\n  get #isReversed(): boolean {\n    return !this.#isVertical && isRtl(this.#list);\n  }\n}\n"]}
+{"version":3,"sources":["../../src/utils/template.ts","../../src/utils/announce.ts","../../src/utils/listener_set.ts","../../src/utils/logical_scroll.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/transient_hooks.ts","../../src/controllers/sortable_controller.ts"],"names":[],"mappings":"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","file":"sortable_controller.js","sourcesContent":["/**\n * Fills `{name}` placeholders in a localized template from the own entries of `values`.\n *\n * Announcement and value-text templates share this one substitution, so a consumer writes\n * `\"{percent}% complete\"` in one attribute and gets the same rules everywhere. A\n * placeholder with no matching entry is left as authored rather than blanked, which\n * keeps a typo visible instead of silently swallowing the word.\n * Every occurrence is filled in one pass. Inserted strings stay literal, including\n * replacement-pattern characters and text that resembles another placeholder.\n */\nexport function fillTemplate(template: string, values: Record<string, string | number>): string {\n  return template.replace(/\\{([a-zA-Z][a-zA-Z0-9]*)\\}/g, (match, name: string) => {\n    const replacement = Object.hasOwn(values, name) ? values[name] : undefined;\n    return replacement === undefined ? match : String(replacement);\n  });\n}\n","export { fillTemplate } from \"./template\";\n\n/**\n * Sends one message to the page's shared `stimeo--announcer`.\n *\n * A message that has to reach assistive tech is not put into a live region created\n * or un-hidden along with it: a region only announces what changes *after* assistive\n * tech already knows about it, which such a region cannot satisfy. The announcer has\n * to be in the page before any message is handed to it — one sent while no announcer\n * is listening is not read — so state changes reach it as an event and it does the\n * reading.\n *\n * The event goes to `window` because the announcer is usually a sibling high in the\n * document rather than an ancestor of the component dispatching it.\n *\n * Wording comes from the consumer — this helper adds no text of its own — so an\n * empty message is silently dropped and nothing is announced.\n *\n * @example\n * ```ts\n * announce(this.announceTextValue, { assertive: false });\n * ```\n */\nexport function announce(message: string, options: { assertive?: boolean } = {}): void {\n  const text = message.trim();\n  if (text.length === 0) return;\n  window.dispatchEvent(\n    new CustomEvent(\"stimeo--announcer:announce\", {\n      detail: { message: text, assertive: options.assertive === true },\n    }),\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","/** Normalized scroll position and maximum distance on one logical axis. */\nexport interface LogicalScrollMetrics {\n  position: number;\n  max: number;\n}\n\n/**\n * Whether horizontal scrolling on `element` follows right-to-left inline flow.\n *\n * Resolved from the **computed** `direction`, so the authoring contract is the\n * usual `dir=\"rtl\"` (or a stylesheet) on the element or any ancestor.\n *\n * Scope: horizontal writing modes. A vertical writing mode (`writing-mode:\n * vertical-rl`) also inverts the horizontal axis, which this check does not\n * model — vertical writing modes are out of scope for the scroll utilities\n * (their consumers describe axes as horizontal/vertical, not inline/block).\n */\nexport function isRtl(element: Element): boolean {\n  return window.getComputedStyle(element).direction === \"rtl\";\n}\n\n/**\n * Returns scroll distance from the logical start edge.\n *\n * CSSOM View exposes standards-mode RTL horizontal offsets as `0` at the inline\n * start (right) and increasingly negative values toward the inline end (left).\n * The normalized position is always clamped to `[0, max]`, which also absorbs\n * Safari's elastic overscroll values.\n */\nexport function logicalScrollMetrics(\n  element: HTMLElement,\n  horizontal: boolean,\n): LogicalScrollMetrics {\n  const max = Math.max(\n    0,\n    horizontal\n      ? element.scrollWidth - element.clientWidth\n      : element.scrollHeight - element.clientHeight,\n  );\n  const raw = horizontal ? element.scrollLeft : element.scrollTop;\n  const position = horizontal && isRtl(element) ? -raw : raw;\n  return { position: Math.min(max, Math.max(0, position)), max };\n}\n\n/**\n * Converts a logical start/end delta to the physical value accepted by\n * `Element.scrollBy`.\n */\nexport function physicalScrollDelta(\n  element: HTMLElement,\n  horizontal: boolean,\n  logicalDelta: number,\n): number {\n  return horizontal && isRtl(element) ? -logicalDelta : logicalDelta;\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","/**\n * Drops the transient state hooks a connection inherited, so the cycle it opens\n * starts from a DOM that claims nothing.\n *\n * A transient hook is an attribute a controller writes to say \"this is happening\n * right now\" — a drag in progress, a form with unsaved edits, a refused\n * subscription. Its lifetime belongs to the interaction, not to the element, and\n * the two come apart whenever the element outlives the instance that wrote it: a\n * Turbo cache snapshot taken mid-interaction restores the hook with the markup,\n * and an element re-inserted elsewhere in the page carries it along. Nothing\n * takes such a hook off, because the instance that owned it is gone; consumer\n * CSS then keeps claiming a state no one is in.\n *\n * **`turbo:before-cache` cannot do this job**, which is why the pass belongs in\n * `connect()`: Turbo also dispatches that event on pages that stay, where the hook\n * is still true, and an in-page move — the other half of the population — never\n * reaches it, so a hook that arrived with a moved element would survive.\n * `connect()` covers both, because both end in a connection.\n *\n * Scope is the **drop** only. What the fresh cycle should say instead is the\n * consumer's: a value re-read from the live DOM, a roster refilled by the\n * stream, a measurement retaken from the current scroll position, a slot emptied\n * of the last result. Those answers differ per consumer and none of them is a\n * hook removal, so the pass stops where every consumer agrees.\n *\n * A declaration names one group of hooks and carries no per-instance state, so\n * it belongs at module scope, shared by every instance the page connects. A\n * consumer writes as many as it has groups — hooks it drops under different\n * conditions cannot share one. The exception is a hook whose name is only known\n * at runtime, such as one built from the registered identifier: that\n * declaration is a field, because the name is.\n *\n * **A drop is not always right.** The population splits on one question: can the\n * state a hook describes outlive the instance that wrote it? Where it cannot — a\n * drag ends with the pointer, a subscription dies with its socket — dropping on\n * every connection is correct. Where it can — a submission in flight is not\n * interrupted by an in-page move — only a connection that follows a real restore\n * may drop, and the consumer answers \"did a session survive?\" with the signal it\n * already holds for its own teardown (a live-session field, a `DetachGate`\n * probe). The drop then sits behind that answer, as the second example shows.\n *\n * @example Unconditional — the state cannot outlive the instance.\n * ```ts\n * const TRANSIENT = new TransientHooks({ attributes: [\"data-sortable-dragging\"] });\n *\n * connect(): void {\n *   TRANSIENT.reset(this.element);\n * }\n * ```\n *\n * @example Gated — an in-page move must not drop a live state.\n * ```ts\n * const TRANSIENT = new TransientHooks({ attributes: [\"data-optimistic\"] });\n *\n * connect(): void {\n *   const restored = !this.#connected && !this.#gate.pending;\n *   this.#gate.cancel();\n *   this.#connected = true;\n *   if (restored) TRANSIENT.reset(this.element);\n * }\n * ```\n */\n\n/** What a consumer declares once about the hooks its interaction owns. */\nexport interface TransientHooksOptions {\n  /**\n   * The attribute names a connection may find written by an earlier one. Hooks\n   * a consumer drops under different conditions belong to different\n   * declarations, so each one can be reset on its own.\n   */\n  readonly attributes: readonly string[];\n}\n\n/**\n * One consumer's declaration of the hooks its interaction owns, dropped from an\n * element by {@link TransientHooks.reset}.\n */\nexport class TransientHooks {\n  readonly #attributes: readonly string[];\n\n  constructor(options: TransientHooksOptions) {\n    this.#attributes = options.attributes;\n  }\n\n  /** Drops the declared hooks from `element`; what it carries besides stays. */\n  reset(element: Element): void {\n    for (const attribute of this.#attributes) element.removeAttribute(attribute);\n  }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { announce, fillTemplate } from \"../utils/announce\";\nimport { ListenerSet } from \"../utils/listener_set\";\nimport { isRtl } from \"../utils/logical_scroll\";\nimport { MicrotaskCoalescer } from \"../utils/microtask_coalescer\";\nimport { TransientHooks } from \"../utils/transient_hooks\";\n\n/** The hook a connection may find written by an earlier, now-gone one. */\nconst TRANSIENT = new TransientHooks({ attributes: [\"data-sortable-dragging\"] });\n\n/** The four steps a consumer can give wording to. */\ntype AnnounceKey = \"grabbed\" | \"moved\" | \"dropped\" | \"canceled\";\n\n/** A reorder in flight: one item picked up by pointer or keyboard. */\ninterface SortSession {\n  item: HTMLElement;\n  /**\n   * The item that followed it at pickup, and the one that preceded it.\n   *\n   * The pickup slot is remembered as nodes rather than as an index because the\n   * list can change underneath a live drag — a broadcast board inserts and\n   * deletes rows while someone is holding one — and an index taken at pickup\n   * stops pointing at that place the moment a row appears above it.\n   */\n  anchor: HTMLElement | null;\n  predecessor: HTMLElement | null;\n  /** Last primary-axis cumulative delta consumed by keyboard stepping. */\n  lastPrimary: number;\n}\n\n/**\n * Headless, accessible **sortable** (single-list reorder) — the a11y-first\n * drag-and-drop that is the flagship consumer of the\n * `stimeo--pointer-drag` primitive. The composition is markup-level and each\n * layer keeps its job: `pointer-drag` (on every item) emits the normalized drag\n * signal with its built-in keyboard alternative, `roving` (on the list) keeps\n * the handles a single Tab stop, and this controller interprets the signal —\n * live-reordering the DOM, handing each step to the page's shared announcer,\n * and reporting the final `reorder`. No dedicated APG pattern exists for\n * drag-and-drop; the keyboard model (grab → arrows → drop / Escape) comes from\n * `pointer-drag` and the announcements make it non-visually trackable\n * (WCAG 2.1.1 / 2.5.7 / 4.1.3). Core (zero dependencies).\n *\n * Markup contract (identifier: `stimeo--sortable`):\n *   <div data-controller=\"stimeo--sortable\">\n *     <ul data-stimeo--sortable-target=\"list\" data-controller=\"stimeo--roving\"\n *         data-stimeo--roving-orientation-value=\"vertical\">\n *       <li data-stimeo--sortable-target=\"item\" data-stimeo--sortable-name=\"Card A\"\n *           data-controller=\"stimeo--pointer-drag\"\n *           data-stimeo--pointer-drag-axis-value=\"y\">\n *         <span>Card A</span>\n *         <button type=\"button\" aria-label=\"Reorder Card A\"\n *                 data-stimeo--pointer-drag-target=\"handle\"\n *                 data-stimeo--roving-target=\"item\">⠿</button>\n *       </li>\n *       …\n *     </ul>\n *   </div>\n *\n * The composed values must follow the sort axis: roving's `orientation`\n * (which defaults to `horizontal`, so a vertical list has to author\n * `vertical`) and pointer-drag's `axis`. `stimeo check` enforces both\n * alignments as composition rules (`composition-mismatch`).\n *\n * Pointer flow: dragging an item live-moves it whenever the pointer crosses a\n * sibling's midpoint (per `orientation`). Keyboard flow: each synthetic\n * `pointer-drag` move steps the item one position. A horizontal list under\n * `dir=\"rtl\"` reverses both, since DOM order then runs right-to-left while\n * `pointer-drag` reports physical coordinates. Dropping dispatches\n * `reorder` (`{ item, from, to }`, zero-based) when the position changed;\n * Escape / `pointercancel` restores the pickup position. Every step is handed to\n * the page's shared `stimeo--announcer` as the consumer's own wording —\n * `announceGrabbedText` / `announceMovedText` / `announceDroppedText` /\n * `announceCanceledText`, with `{name}` / `{position}` / `{total}` placeholders —\n * and an unset one announces nothing.\n *\n * @remarks\n * Behavior only — the ghost/placeholder/drop-hint visuals are the consumer's\n * CSS, keyed off `pointer-drag`'s `data-dragging`/`data-grabbed` on the item\n * and this controller's `data-sortable-dragging` on the root. Persistence is\n * the consumer's `reorder` listener (post the new position; a Turbo Stream\n * broadcast makes the board collaborative). The DOM order is the single source\n * of truth: items are read live on every event, so rows appended by Turbo need\n * no rewiring, and a Turbo cache restore reconnects idempotently (`connect()`\n * clears the transient root hook; a drag cannot survive a navigation). The event\n * listeners and a pending lost-item check are all it holds, and `disconnect()`\n * releases both. Multi-list / kanban, nested DnD, auto-scroll at the edges, and\n * virtualized lists are deliberately out of this single-list scope.\n */\nexport class SortableController extends Controller<HTMLElement> {\n  static override targets = [\"list\", \"item\"];\n  static override values = {\n    orientation: { type: String, default: \"vertical\" },\n    announceGrabbedText: { type: String, default: \"\" },\n    announceMovedText: { type: String, default: \"\" },\n    announceDroppedText: { type: String, default: \"\" },\n    announceCanceledText: { type: String, default: \"\" },\n  };\n  static events = [\"reorder\"] as const;\n\n  declare readonly hasListTarget: boolean;\n  declare readonly listTarget: HTMLElement;\n  declare readonly itemTargets: HTMLElement[];\n  declare orientationValue: string;\n  declare announceGrabbedTextValue: string;\n  declare announceMovedTextValue: string;\n  declare announceDroppedTextValue: string;\n  declare announceCanceledTextValue: string;\n\n  #session: SortSession | null = null;\n  /** Defers the lost-item check to after the mutation batch (see below). */\n  readonly #settle = new MicrotaskCoalescer(() => this.#dropLostSession());\n\n  /** The listeners of one connection, released together on `disconnect()`. */\n  readonly #listeners = new ListenerSet();\n\n  override connect(): void {\n    // A drag cannot survive a navigation: drop the hook a Turbo cache snapshot\n    // may have preserved mid-drag (idempotent reconnect).\n    TRANSIENT.reset(this.element);\n    this.#settle.activate();\n    this.#listeners.add(this.element, \"stimeo--pointer-drag:start\", this.#onDragStart);\n    this.#listeners.add(this.element, \"stimeo--pointer-drag:move\", this.#onDragMove);\n    this.#listeners.add(this.element, \"stimeo--pointer-drag:end\", this.#onDragEnd);\n    this.#listeners.add(this.element, \"stimeo--pointer-drag:cancel\", this.#onDragCancel);\n  }\n\n  override disconnect(): void {\n    this.#listeners.dispose();\n    this.#settle.cancel();\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n  }\n\n  /**\n   * Ends a session whose item left the item set.\n   *\n   * The controller's own reorder detaches and reattaches the item inside one\n   * mutation batch, so the loss is only real once the batch has settled — the\n   * check therefore runs a microtask later and asks whether the item is a target\n   * again. Without it a deleted row (a broadcast that drops it from the board)\n   * or a morph that strips the item's target attribute would hold the\n   * one-at-a-time session for the rest of the page's life, with the root hook\n   * stuck on and every later grab refused with no way out.\n   */\n  itemTargetDisconnected(item: HTMLElement): void {\n    if (this.#session?.item !== item) return;\n    this.#settle.schedule();\n  }\n\n  #dropLostSession(): void {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (items.includes(session.item)) return;\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n    // An element that is still in the document (a morph took only its target\n    // attribute) goes back where it was picked up. Nothing is announced either\n    // way: the row is no longer one of the items, so there is no position to\n    // read out — what matters is that the next grab is not refused.\n    if (session.item.isConnected) this.#restore(session, items);\n  }\n\n  /** Picks the item up: remembers its neighbours and announces the grab. */\n  readonly #onDragStart = (event: Event): void => {\n    // One reorder at a time: a start from another item (each item has its own\n    // pointer-drag instance) must not clobber the live session — its pickup\n    // slot and cancel restore would be lost.\n    if (this.#session) return;\n    const items = this.#items();\n    const item = this.#itemFor(event.target, items);\n    if (!item) return;\n    const index = items.indexOf(item);\n    this.#session = {\n      item,\n      anchor: items[index + 1] ?? null,\n      predecessor: items[index - 1] ?? null,\n      lastPrimary: 0,\n    };\n    this.element.setAttribute(\"data-sortable-dragging\", \"true\");\n    this.#announce(\"grabbed\", item);\n  };\n\n  readonly #onDragMove = (event: Event): void => {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (this.#itemFor(event.target, items) !== session.item) return;\n\n    const detail = (event as CustomEvent<Record<string, number | string>>).detail;\n    if (detail.pointerType === \"keyboard\") {\n      this.#stepFromKeyboard(session, detail, items);\n    } else {\n      this.#followPointer(session, detail, items);\n    }\n  };\n\n  /** Drops the item: announces, then reports `reorder` if the position changed. */\n  readonly #onDragEnd = (event: Event): void => {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (this.#itemFor(event.target, items) !== session.item) return;\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n    this.#announce(\"dropped\", session.item);\n    const to = items.indexOf(session.item);\n    const from = this.#pickupSlot(session, items) ?? to;\n    if (to !== from) {\n      this.dispatch(\"reorder\", { detail: { item: session.item, from, to } });\n    }\n  };\n\n  /** Restores the pickup position (Escape / OS `pointercancel`). */\n  readonly #onDragCancel = (event: Event): void => {\n    const session = this.#session;\n    if (!session) return;\n    const items = this.#items();\n    if (this.#itemFor(event.target, items) !== session.item) return;\n    this.#session = null;\n    this.element.removeAttribute(\"data-sortable-dragging\");\n    this.#restore(session, items);\n    this.#announce(\"canceled\", session.item);\n  };\n\n  /**\n   * The slot the item was picked up from, read back through the neighbours it\n   * had then — `null` when neither survives and the item itself is gone.\n   *\n   * The anchor is the item that followed it, so restoring means \"before that one\n   * again\". When the anchor was deleted mid-drag the predecessor answers the\n   * same question from the other side. With both gone the item's current slot is\n   * the honest answer: nothing is known to have moved, so no reorder is reported\n   * and a cancel leaves the item where it is.\n   */\n  #pickupSlot(session: SortSession, items: HTMLElement[]): number | null {\n    const others = items.filter((candidate) => candidate !== session.item);\n    if (session.anchor) {\n      const at = others.indexOf(session.anchor);\n      if (at !== -1) return at;\n    }\n    if (session.predecessor) {\n      const at = others.indexOf(session.predecessor);\n      if (at !== -1) return at + 1;\n    }\n    const here = items.indexOf(session.item);\n    return here === -1 ? null : here;\n  }\n\n  /** Puts the item back where it was picked up from. */\n  #restore(session: SortSession, items: HTMLElement[]): void {\n    const slot = this.#pickupSlot(session, items);\n    if (slot === null) return;\n    this.#insertAt(\n      session.item,\n      items.filter((candidate) => candidate !== session.item),\n      slot,\n    );\n  }\n\n  /**\n   * Keyboard stepping: `pointer-drag` reports *cumulative* synthetic deltas, so\n   * the difference from the last consumed value is one arrow press — its sign is\n   * the direction. Cross-axis arrows never change the primary delta (no move).\n   *\n   * The sign is physical (`ArrowRight` is always `+dx`), so a right-to-left row\n   * has to invert it: there, moving the item rightward means moving it *earlier*\n   * in the DOM. Skipping this would also split the two halves of one keypress —\n   * `roving` already moves focus logically, so the same arrow would send the\n   * focus and the grabbed item opposite ways.\n   */\n  #stepFromKeyboard(\n    session: SortSession,\n    detail: Record<string, number | string>,\n    items: HTMLElement[],\n  ): void {\n    const primary = Number(this.#isVertical ? detail.dy : detail.dx) || 0;\n    const delta = primary - session.lastPrimary;\n    session.lastPrimary = primary;\n    if (delta === 0) return;\n\n    const index = items.indexOf(session.item);\n    const step = (delta > 0 ? 1 : -1) * (this.#isReversed ? -1 : 1);\n    const next = Math.max(0, Math.min(index + step, items.length - 1));\n    if (next === index) return;\n    this.#insertAt(\n      session.item,\n      items.filter((candidate) => candidate !== session.item),\n      next,\n    );\n    this.#announce(\"moved\", session.item);\n  }\n\n  /**\n   * Pointer following: the item moves to the slot whose siblings' midpoints the\n   * pointer has passed (per `orientation`).\n   *\n   * Only siblings that occupy space take part. A row with no layout box — a\n   * filtered-out item, a `display: none` ancestor, a collapsed `<details>` — is\n   * reported with an empty rect at the document origin, and its midpoint of `0`\n   * sits below every pointer position: counted, it would read as passed on the\n   * very first move and send the item across a slot the pointer never crossed.\n   * With no laid-out sibling at all there is nothing to compare against and the\n   * move is skipped entirely.\n   */\n  #followPointer(\n    session: SortSession,\n    detail: Record<string, number | string>,\n    items: HTMLElement[],\n  ): void {\n    const pointer = Number(this.#isVertical ? detail.y : detail.x) || 0;\n    const vertical = this.#isVertical;\n    // `target` counts the siblings that precede the pointer *in DOM order*, and\n    // the two agree only while DOM order runs the same way as the coordinate. In\n    // a right-to-left row it runs the other way, so the comparison flips;\n    // leaving it physical would mix two orderings into one number and drop the\n    // item at a slot the pointer never crossed. Resolved once: it cannot change\n    // mid-loop, and reading it per sibling would re-run `getComputedStyle` on\n    // every pointermove.\n    const reversed = this.#isReversed;\n    const here = items.indexOf(session.item);\n    const laidOut: HTMLElement[] = [];\n    let target = 0;\n    // `current` is the item's own slot in that same laid-out space: the number\n    // of laid-out siblings that come before it in DOM order.\n    let current = 0;\n    items.forEach((item, index) => {\n      if (item === session.item) return;\n      const rect = item.getBoundingClientRect();\n      if (rect.width === 0 && rect.height === 0) return;\n      if (index < here) current += 1;\n      laidOut.push(item);\n      const midpoint = vertical ? rect.top + rect.height / 2 : rect.left + rect.width / 2;\n      if (reversed ? pointer < midpoint : pointer > midpoint) target += 1;\n    });\n    if (laidOut.length === 0 || target === current) return;\n\n    this.#insertAt(session.item, laidOut, target);\n    this.#announce(\"moved\", session.item);\n  }\n\n  /**\n   * Reinserts `item` at `index` among `scope`, relative to the sibling already\n   * standing there.\n   *\n   * The reorder is defined against the items, not against a container: the\n   * neighbour's own parent is where the item belongs. A `list` target that is\n   * not the items' parent — or none at all, which the markup contract allows —\n   * therefore still lands the move in the right place instead of throwing, and\n   * the last slot is *after the last item* rather than after whatever else the\n   * container holds (a live region, a footer), which would put the row outside\n   * the reading order the list publishes.\n   */\n  #insertAt(item: HTMLElement, scope: HTMLElement[], index: number): void {\n    const clamped = Math.max(0, Math.min(index, scope.length));\n    const ahead = scope[clamped] ?? null;\n    const behind = ahead ? null : (scope[scope.length - 1] ?? null);\n    const neighbour = ahead ?? behind;\n    if (!neighbour) return;\n    const parent = neighbour.parentNode;\n    if (!parent) return;\n    // Real browsers drop focus when the focused node is re-inserted (the move\n    // is a remove+insert), which would strand the keyboard grab after one\n    // arrow press — restore it so focus rides the moved item.\n    const active = document.activeElement;\n    const hadFocus = active instanceof HTMLElement && item.contains(active);\n    parent.insertBefore(item, ahead ?? neighbour.nextSibling);\n    if (hadFocus) active.focus();\n  }\n\n  /**\n   * Hands one step to the page's shared announcer.\n   *\n   * The library carries no live region and no English copy: the wording is the\n   * consumer's, written into `announceGrabbedText` / `announceMovedText` /\n   * `announceDroppedText` / `announceCanceledText` with `{name}` / `{position}` /\n   * `{total}` placeholders, and an unset one announces nothing.\n   *\n   * Only transitions reach here — the pickup, a step that actually changed the\n   * landing slot, and the single end of the session — so a pointer crossing the\n   * same slot twice or an arrow clamped at an end stays silent.\n   *\n   * @stimeoRuntimeOnly The texts word the steps of one reorder, spoken as they happen.\n   */\n  #announce(key: AnnounceKey, item: HTMLElement): void {\n    const template = this.#announceTemplate(key);\n    if (template.length === 0) return;\n    const items = this.#items();\n    announce(\n      fillTemplate(template, {\n        name: this.#nameOf(item),\n        position: items.indexOf(item) + 1,\n        total: items.length,\n      }),\n    );\n  }\n\n  /** The consumer's wording for one step, or `\"\"` when they authored none. */\n  #announceTemplate(key: AnnounceKey): string {\n    switch (key) {\n      case \"grabbed\":\n        return this.announceGrabbedTextValue;\n      case \"moved\":\n        return this.announceMovedTextValue;\n      case \"dropped\":\n        return this.announceDroppedTextValue;\n      case \"canceled\":\n        return this.announceCanceledTextValue;\n    }\n  }\n\n  /** The announced item name: the authored override, else its collapsed text. */\n  #nameOf(item: HTMLElement): string {\n    const authored = item.getAttribute(`data-${this.identifier}-name`);\n    if (authored) return authored;\n    return (item.textContent ?? \"\").replace(/\\s+/g, \" \").trim();\n  }\n\n  /**\n   * Resolves the sortable item owning a bubbled `pointer-drag` event.\n   *\n   * `pointer-drag` dispatches on its own element, and the markup contract puts\n   * one on each item, so the owner is the item that **is** the target. Matching\n   * an ancestor instead would make a card's own inner draggable — a knob, a\n   * split pane, anything the primitive is composed into — drive the card.\n   */\n  #itemFor(target: EventTarget | null, items: HTMLElement[]): HTMLElement | null {\n    if (!target) return null;\n    return items.find((item) => item === target) ?? null;\n  }\n\n  /** The items in live DOM order (targets re-query the DOM on every access). */\n  #items(): HTMLElement[] {\n    return this.itemTargets;\n  }\n\n  /** The element that lays the items out: the `list` target when present, else the element. */\n  get #list(): HTMLElement {\n    return this.hasListTarget ? this.listTarget : this.element;\n  }\n\n  get #isVertical(): boolean {\n    return this.orientationValue !== \"horizontal\";\n  }\n\n  /**\n   * Whether DOM order runs opposite to the primary coordinate — true only for a\n   * horizontal row under `dir=\"rtl\"`, where the first item sits at the largest\n   * `x`. Both drag paths reach this controller in physical terms (`pointer-drag`\n   * documents its deltas as physical and hands RTL to its consumer, which is\n   * this controller), so both have to be mapped back onto DOM order here.\n   *\n   * Read from the list, the element that lays the items out — never from the\n   * dragged item, which may carry its own `dir`. The list inherits the computed\n   * direction, so authoring `dir` on the root works too. A vertical list is\n   * unaffected: writing direction does not mirror the block axis.\n   */\n  get #isReversed(): boolean {\n    return !this.#isVertical && isRtl(this.#list);\n  }\n}\n"]}

package/dist/controllers/spinner_controller.d.ts

@@ -34,16 +34,20 @@ import { Controller } from '@hotwired/stimulus';
  * - `stimeo--spinner:show` — the indicator became visible, after `delay`.
  * - `stimeo--spinner:hide` — the indicator went away, after `minDuration`.
  * - `stimeo--spinner:timeout` — `timeout` elapsed with the load still running;
- *   the controller then ends it exactly as `stop` would, so a `hide` follows.
+ *   the controller then ends it as `stop` would; `hide` follows only if it was shown.
  *
  * `hide`, `show`, `timeout`, and `reconcile` dispatch `{}`. The last of those
- * reports that the Turbo cache rewind returned a running cycle to idle.
+ * reports that a connection returned to idle a cycle no instance was running — a page
+ * restored from the Turbo cache in the middle of a load.
  *
  * @remarks
  * Behavior only — the visual spinner is the consumer's, alongside the text and
  * `aria-hidden="true"`. Both timers are owned by `SafeTimeout`, kept across
- * an in-page move and dropped on a real detach via `DetachGate`, while the
- * loading state a cached page would freeze is rewound by `BeforeCacheReset`.
+ * an in-page move and dropped on a real detach via `DetachGate`. A load in progress is
+ * never undone on `turbo:before-cache`, which Turbo also dispatches on pages that stay
+ * (a promoted frame navigation, a state-less `popstate`, a refresh of a cached URL, a
+ * `data-turbo-permanent` element carried to the next page): the load is still running
+ * there, and its `stop` still hides the spinner and announces the result.
  */
 declare class SpinnerController extends Controller<HTMLElement> {
     #private;
@@ -70,10 +74,29 @@ declare class SpinnerController extends Controller<HTMLElement> {
             default: number;
         };
     };
+    static valueConstraints: {
+        delay: {
+            readonly finite: true;
+            readonly min: 0;
+            readonly max: 2147483647;
+        };
+        minDuration: {
+            readonly finite: true;
+            readonly min: 0;
+            readonly max: 2147483647;
+        };
+        timeout: {
+            readonly finite: true;
+            readonly min: 0;
+            readonly max: 2147483647;
+        };
+    };
     static actions: readonly ["start", "stop"];
     static events: readonly ["hide", "show", "timeout", "reconcile"];
     readonly indicatorTarget: HTMLElement;
+    readonly indicatorTargets: HTMLElement[];
     readonly regionTarget: HTMLElement;
+    readonly regionTargets: HTMLElement[];
     readonly messageTarget: HTMLElement;
     readonly hasIndicatorTarget: boolean;
     readonly hasRegionTarget: boolean;
@@ -93,6 +116,18 @@ declare class SpinnerController extends Controller<HTMLElement> {
      * bring it back.
      */
     indicatorTargetConnected(target: HTMLElement): void;
+    /**
+     * Gives an indicator that no longer resolves its own `hidden` back, even after
+     * `disconnect()`, and while connected re-applies the current phase to the one that stays.
+     */
+    indicatorTargetDisconnected(indicator: HTMLElement): void;
+    /** Applies the current busy state to a region inserted or replaced after `connect()`. */
+    regionTargetConnected(region: HTMLElement): void;
+    /**
+     * Gives a region that no longer resolves its own `aria-busy` back, even after
+     * `disconnect()`, and while connected resyncs the region that stays.
+     */
+    regionTargetDisconnected(region: HTMLElement): void;
     disconnect(): void;
     /** Begins loading. Honors `delay` before the spinner actually appears. */
     start(): void;