@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/dnd/autoscroll.js

@@ -0,0 +1,123 @@
+import { nearestScrollAncestor as E, isScrollBox as F } from "../dom/scroll-ancestor.js";
+import { reducedMotion as k } from "../motion.js";
+const b = {
+  /* Wide enough to enter deliberately with a card in hand, narrow enough that
+     the middle of a short column is not permanently inside it — below ~48px a
+     trackpad user overshoots the zone entirely between two frames. */
+  threshold: 64,
+  /* Crosses a tall column in well under a second at the very edge, while the
+     quadratic ramp keeps the first two thirds of the zone gentle. */
+  maxSpeed: 800,
+  /* REDUCE MEANS REDUCE, NOT DISABLE (D-18). Zeroing this is the obvious
+     reading and it is wrong twice over: it strands every off-screen drop target
+     behind a scroll the dragging hand cannot perform, and it does so for
+     precisely the users least able to complete a fast repeated gesture instead.
+     The peak speed is capped instead — nothing whips past, everything stays
+     reachable, and the ramp still gives fine control near the boundary. */
+  reducedMaxSpeed: 220
+};
+function g(t, r, n) {
+  if (t >= r) return 0;
+  const i = Math.min(1, Math.max(0, (r - t) / r));
+  return n * i * i;
+}
+const A = { axes: ["y", "x"], mustOverflow: !0 };
+function T(t) {
+  const r = E(document.elementFromPoint(t.x, t.y), {
+    ...A,
+    includeSelf: !0
+  });
+  if (r) return r;
+  const n = document.scrollingElement;
+  return n instanceof HTMLElement && F(n, A) ? n : null;
+}
+function w(t) {
+  if (t === document.scrollingElement)
+    return { top: 0, left: 0, right: window.innerWidth, bottom: window.innerHeight };
+  const r = t.getBoundingClientRect();
+  return { top: r.top, left: r.left, right: r.right, bottom: r.bottom };
+}
+function B(t, r = {}) {
+  const n = {
+    threshold: r.threshold ?? b.threshold,
+    maxSpeed: r.maxSpeed ?? b.maxSpeed,
+    reducedMaxSpeed: r.reducedMaxSpeed ?? b.reducedMaxSpeed
+  };
+  let i = null, u = 0, h = 0, e = 0, s = null, o = n.maxSpeed;
+  function f() {
+    i !== null && cancelAnimationFrame(i), i = null, u = 0, h = 0, e = 0, s = null;
+  }
+  function d(p) {
+    i = requestAnimationFrame(d);
+    const a = u ? Math.min(64, p - u) : 16;
+    u = p;
+    const c = t.getPoint();
+    if (!c) return;
+    const l = T(c);
+    if (!l) return;
+    l !== s && (h = 0, e = 0, s = l);
+    const m = w(l), y = g(c.y - m.top, n.threshold, o) * -1 + g(m.bottom - c.y, n.threshold, o), M = g(c.x - m.left, n.threshold, o) * -1 + g(m.right - c.x, n.threshold, o);
+    if (M === 0 && y === 0) return;
+    e += y * a / 1e3, h += M * a / 1e3;
+    const x = Math.trunc(e), S = Math.trunc(h);
+    if (S === 0 && x === 0) return;
+    e -= x, h -= S;
+    const L = l.scrollTop, v = l.scrollLeft;
+    l.scrollTop = L + x, l.scrollLeft = v + S, !(l.scrollTop === L && l.scrollLeft === v) && t.onScrolled(c);
+  }
+  return o = k() ? n.reducedMaxSpeed : n.maxSpeed, i = requestAnimationFrame(d), f;
+}
+function R(t, r = {}) {
+  function n() {
+    const e = t.getState();
+    if (e.phase !== "dragging" || e.mode !== "keyboard" || !e.over || !e.id) return;
+    const s = t.getLayout();
+    if (!s) return;
+    const o = s.containers.find((m) => m.id === e.over?.container);
+    if (!o) return;
+    const f = s.items.filter((m) => m.container === o.id && m.id !== e.id), d = f.length === 0 ? o.rect : f[Math.min(e.over.index, f.length - 1)].rect, p = T({
+      x: o.rect.left + o.rect.width / 2,
+      y: o.rect.top + o.rect.height / 2
+    });
+    if (!p) return;
+    const a = w(p);
+    let c = 0;
+    d.top < a.top ? c = d.top - a.top : d.bottom > a.bottom && (c = d.bottom - a.bottom);
+    let l = 0;
+    d.left < a.left ? l = d.left - a.left : d.right > a.right && (l = d.right - a.right), !(l === 0 && c === 0) && (p.scrollTop += c, p.scrollLeft += l, t.remeasure());
+  }
+  let i = "", u = null;
+  const h = t.subscribe(() => {
+    const e = t.getState(), s = e.over ? `${e.over.container}:${e.over.index}` : "";
+    s !== i && (i = s, n());
+    const o = e.phase === "dragging";
+    if (o && !u) {
+      u = B(
+        {
+          /* Null for a KEYBOARD drag, which has no cursor to be near an edge —
+             the keyboard moves the insertion point directly and reaches the
+             viewport through `keepKeyboardTargetVisible` instead. */
+          getPoint: () => {
+            const f = t.getState();
+            return f.phase === "dragging" ? f.point : null;
+          },
+          onScrolled: (f) => {
+            t.remeasure(), t.moveTo(f);
+          }
+        },
+        r
+      );
+      return;
+    }
+    !o && u && (u(), u = null);
+  });
+  return () => {
+    h(), u?.();
+  };
+}
+export {
+  R as attachAutoScroll,
+  B as attachEdgeAutoScroll,
+  g as scrollVelocity
+};
+//# sourceMappingURL=autoscroll.js.map

package/dist/lib/dnd/autoscroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoscroll.js","sources":["../../../src/lib/dnd/autoscroll.ts"],"sourcesContent":["import { isScrollBox, nearestScrollAncestor } from \"../dom/scroll-ancestor\";\nimport { reducedMotion } from \"../motion\";\nimport type { DragSession } from \"./session\";\nimport type { Point } from \"./types\";\n\n/**\n * Edge auto-scroll: while a card is being carried, a pointer near the edge of\n * the nearest scrollable ancestor scrolls it.\n *\n * WHY IT IS NOT OPTIONAL. Without it a list is only reorderable within one\n * screenful. The target you want is off-screen, the gesture is already in\n * flight, and there is no way to scroll with the hand that is holding the card\n * — so the drag has to be abandoned, the list scrolled, and the drag restarted\n * from a position that may itself now be off-screen.\n *\n * THREE THINGS THAT MAKE IT WORK RATHER THAN MERELY EXIST:\n *\n *   1. SPEED RAMPS with proximity. A single speed is unusable at both ends: fast\n *      enough to cross a long column overshoots the moment you approach the\n *      edge, slow enough to be controllable never gets anywhere. The ramp is\n *      quadratic, so the outer half of the zone crawls and the last few pixels\n *      are quick.\n *   2. IT RE-MEASURES. Every rect in the snapshot moves when the container\n *      scrolls. Without a remeasure the insertion point keeps pointing at where\n *      the items USED to be, so the marker sits still while the list slides past\n *      it and the card lands somewhere the user never indicated.\n *   3. IT RE-RESOLVES THE TARGET. Re-measuring alone updates the boxes but not\n *      the answer: the pointer has not moved, so nothing recomputes `over`, and\n *      the marker stays frozen on the old index against fresh rects. Feeding the\n *      unchanged point back through `moveTo` is what makes the insertion point\n *      track the content moving beneath a stationary finger.\n *\n * The window `scroll` listener in `sensors/pointer.ts` also remeasures, and is\n * NOT a substitute: scroll events are coalesced and delivered after the frame\n * has been composited, so the hit-test for the frame we just scrolled would\n * still read the pre-scroll snapshot. This loop does it inline, before the next\n * frame is resolved.\n */\n\nexport interface AutoScrollOptions {\n  /** Distance from an edge, in px, at which scrolling begins. */\n  threshold?: number;\n  /** Speed in px/second at the very edge, at full motion. */\n  maxSpeed?: number;\n  /** Speed in px/second at the very edge under reduced motion. See D-18. */\n  reducedMaxSpeed?: number;\n}\n\nconst DEFAULTS: Required<AutoScrollOptions> = {\n  /* Wide enough to enter deliberately with a card in hand, narrow enough that\n     the middle of a short column is not permanently inside it — below ~48px a\n     trackpad user overshoots the zone entirely between two frames. */\n  threshold: 64,\n  /* Crosses a tall column in well under a second at the very edge, while the\n     quadratic ramp keeps the first two thirds of the zone gentle. */\n  maxSpeed: 800,\n  /* REDUCE MEANS REDUCE, NOT DISABLE (D-18). Zeroing this is the obvious\n     reading and it is wrong twice over: it strands every off-screen drop target\n     behind a scroll the dragging hand cannot perform, and it does so for\n     precisely the users least able to complete a fast repeated gesture instead.\n     The peak speed is capped instead — nothing whips past, everything stays\n     reachable, and the ramp still gives fine control near the boundary. */\n  reducedMaxSpeed: 220,\n};\n\n/**\n * Speed at a given distance from the edge. Exported because it is the whole\n * behaviour and it is the one part testable without a browser.\n *\n * Zero outside the zone, `maxSpeed` at the edge, quadratic in between.\n */\nexport function scrollVelocity(\n  distanceFromEdge: number,\n  threshold: number,\n  maxSpeed: number,\n): number {\n  if (distanceFromEdge >= threshold) return 0;\n  /* Negative distance means the pointer is PAST the edge — outside the\n     container entirely, which happens constantly while carrying a card toward\n     a neighbouring column. Clamping to full speed rather than letting the ramp\n     run past 1 keeps it from accelerating without limit the further out it\n     goes. */\n  const proximity = Math.min(1, Math.max(0, (threshold - distanceFromEdge) / threshold));\n  return maxSpeed * proximity * proximity;\n}\n\n/* A box auto-scroll can actually move: it declares scrolling on an axis AND overflows on it. */\nconst SCROLLABLE = { axes: [\"y\", \"x\"], mustOverflow: true } as const;\n\n/**\n * The nearest scrollable ancestor of whatever is under the pointer, falling\n * back to the document.\n *\n * Resolved per frame rather than once at pickup because a card carried from one\n * column to another changes scroller mid-gesture, and a scroller cached at\n * pickup then scrolls the column the card has already left.\n *\n * NOTE FOR THE FLOATING CLONE: `elementFromPoint` returns the TOPMOST element,\n * so a clone rendered under the cursor without `pointer-events: none` is what\n * this finds — and its ancestor chain is the body, not the column, so\n * auto-scroll silently stops working the day the clone lands.\n */\nfunction scrollerAt(point: Point): HTMLElement | null {\n  const found = nearestScrollAncestor(document.elementFromPoint(point.x, point.y), {\n    ...SCROLLABLE,\n    includeSelf: true,\n  });\n  if (found) return found;\n  const root = document.scrollingElement;\n  return root instanceof HTMLElement && isScrollBox(root, SCROLLABLE) ? root : null;\n}\n\n/**\n * The scroller's edges in VIEWPORT coordinates.\n *\n * The document scroller needs its own case: `<html>`'s box is the whole\n * document, hundreds of pixels of which are off-screen, so its \"bottom edge\" is\n * nowhere near the bottom of the screen and page-level auto-scroll would never\n * trigger.\n */\nfunction viewportRect(el: HTMLElement): { top: number; left: number; right: number; bottom: number } {\n  if (el === document.scrollingElement) {\n    return { top: 0, left: 0, right: window.innerWidth, bottom: window.innerHeight };\n  }\n  const r = el.getBoundingClientRect();\n  return { top: r.top, left: r.left, right: r.right, bottom: r.bottom };\n}\n\n/**\n * Start auto-scrolling for the lifetime of every drag on this session.\n * Returns the teardown.\n *\n * Framework-free on purpose, like the rest of the core — a React consumer wraps\n * it in one `useEffect`, and the tests do not need a renderer to drive it.\n */\n/**\n * What the loop needs from whoever is dragging.\n *\n * EXTRACTED SO THE CALENDAR CAN USE IT UNCHANGED. Every hard-won detail below —\n * the carried sub-pixel remainder, the clamped frame delta, the per-scroller\n * reset, the reduced-motion cap — is about SCROLLING, not about lists, and a\n * second copy of it in the calendar would be a second copy of the one thing\n * whose failures are invisible (a ramp that silently loses its outer half is\n * not something anyone notices; it just feels bad).\n */\nexport interface AutoScrollDriver {\n  /** The pointer, or null when the gesture has no pointer (a keyboard drag). */\n  getPoint: () => Point | null;\n  /**\n   * The content moved under a pointer that did not.\n   *\n   * RE-FEEDING THE POINT IS THE WHOLE REASON THIS CALLBACK EXISTS. Remeasuring\n   * alone updates the boxes and not the ANSWER: the pointer has not moved, so\n   * nothing recomputes what it is over, and the drag freezes mid-scroll.\n   * FullCalendar solves the same problem by re-emitting a synthetic\n   * `pointermove` on scroll — the same fix arrived at from the other side.\n   */\n  onScrolled: (point: Point) => void;\n}\n\n/** The loop, driven by anything that can answer those two questions. */\nexport function attachEdgeAutoScroll(\n  driver: AutoScrollDriver,\n  options: AutoScrollOptions = {},\n): () => void {\n  /* PER KEY, NOT A SPREAD. `{...DEFAULTS, ...options}` lets a key that is\n     PRESENT AND UNDEFINED overwrite its default — and `{threshold: undefined}`\n     is what a caller writes without noticing, forwarding an optional prop. The\n     result is not a fallback to the default: every speed becomes NaN, nothing\n     scrolls, and there is no error anywhere to find. It cost the first consumer\n     of this module a debugging round; `??` makes it unreachable. */\n  const cfg: Required<AutoScrollOptions> = {\n    threshold: options.threshold ?? DEFAULTS.threshold,\n    maxSpeed: options.maxSpeed ?? DEFAULTS.maxSpeed,\n    reducedMaxSpeed: options.reducedMaxSpeed ?? DEFAULTS.reducedMaxSpeed,\n  };\n  let frame: number | null = null;\n  let last = 0;\n  /**\n   * Fractional scroll owed but not yet applied.\n   *\n   * MEASURED, NOT DEFENSIVE. Chrome ROUNDS every `scrollTop` assignment to a\n   * whole pixel and discards the remainder: writing `scrollTop + 0.2` five\n   * times leaves the element at 0, and `+ 0.6` five times leaves it at 5.\n   * Without carrying the remainder across frames, every speed below ~30px/s\n   * scrolls NOTHING AT ALL — which is the outer half of a quadratic ramp, so\n   * the zone silently shrinks to its fastest third and the fine control the\n   * ramp exists to provide does not exist. The bug is invisible to arithmetic:\n   * `scrollVelocity` returns the right number and the browser throws it away.\n   */\n  let owedX = 0;\n  let owedY = 0;\n  /* Owed pixels belong to the scroller they were computed against. Carrying\n     them into the next column as a card crosses the board applies one column's\n     remainder to another. */\n  let lastScroller: HTMLElement | null = null;\n  /* Resolved once per drag rather than per frame: a preference cannot\n     meaningfully change mid-gesture, and `getComputedStyle` on the root element\n     every frame is a forced style recalculation inside the one loop that must\n     not drop a frame. */\n  let maxSpeed = cfg.maxSpeed;\n\n  function stop(): void {\n    if (frame !== null) cancelAnimationFrame(frame);\n    frame = null;\n    last = 0;\n    owedX = 0;\n    owedY = 0;\n    lastScroller = null;\n  }\n\n  function tick(now: number): void {\n    frame = requestAnimationFrame(tick);\n    /* Clamped, because a tab restored from the background delivers one frame\n       with a gap of seconds — an unclamped delta then scrolls the column its\n       entire length in a single step. */\n    const dt = last ? Math.min(64, now - last) : 16;\n    last = now;\n\n    /* A gesture with no pointer — a keyboard drag — has no edge to be near, and\n       the driver says so by answering null. */\n    const point = driver.getPoint();\n    if (!point) return;\n\n    const scroller = scrollerAt(point);\n    if (!scroller) return;\n    if (scroller !== lastScroller) {\n      owedX = 0;\n      owedY = 0;\n      lastScroller = scroller;\n    }\n    const box = viewportRect(scroller);\n\n    const dy =\n      scrollVelocity(point.y - box.top, cfg.threshold, maxSpeed) * -1 +\n      scrollVelocity(box.bottom - point.y, cfg.threshold, maxSpeed);\n    const dx =\n      scrollVelocity(point.x - box.left, cfg.threshold, maxSpeed) * -1 +\n      scrollVelocity(box.right - point.x, cfg.threshold, maxSpeed);\n    if (dx === 0 && dy === 0) return;\n\n    owedY += (dy * dt) / 1000;\n    owedX += (dx * dt) / 1000;\n    /* Whole pixels only, remainder carried — see `owedY` above. `trunc` rather\n       than `round` so the carry is always toward zero and a slow ramp never\n       overshoots by half a pixel per frame in the direction of travel. */\n    const stepY = Math.trunc(owedY);\n    const stepX = Math.trunc(owedX);\n    if (stepX === 0 && stepY === 0) return;\n    owedY -= stepY;\n    owedX -= stepX;\n\n    const beforeTop = scroller.scrollTop;\n    const beforeLeft = scroller.scrollLeft;\n    scroller.scrollTop = beforeTop + stepY;\n    scroller.scrollLeft = beforeLeft + stepX;\n    /* Already at the end. Remeasuring here would cost a full layout pass per\n       frame for a snapshot that cannot have changed — and the pointer resting\n       against the bottom of a fully-scrolled column is the steady state, not\n       the exception. */\n    if (scroller.scrollTop === beforeTop && scroller.scrollLeft === beforeLeft) return;\n\n    /* The pointer has not moved; the CONTENT has. See `onScrolled`. */\n    driver.onScrolled(point);\n  }\n\n  /* Started immediately: this function is attached only for the duration of a\n     gesture, by whoever is running that gesture. Resolving the reduced-motion\n     cap ONCE here rather than per frame keeps a forced style recalculation out\n     of the one loop that must not drop a frame. */\n  maxSpeed = reducedMotion() ? cfg.reducedMaxSpeed : cfg.maxSpeed;\n  frame = requestAnimationFrame(tick);\n  return stop;\n}\n\n/**\n * The list engine's adapter: drive the edge loop from a `DragSession`, and add\n * the keyboard-only behaviour the pointer ramp cannot reach.\n */\nexport function attachAutoScroll(\n  session: DragSession,\n  options: AutoScrollOptions = {},\n): () => void {\n  /**\n   * Keep the KEYBOARD insertion point on screen.\n   *\n   * MEASURED, NOT ANTICIPATED: eleven Down presses in a column of twelve left\n   * the insertion marker 324px below the visible area with the column never\n   * scrolling, because nothing in the pointer path applies — there is no cursor\n   * to be near an edge, so the edge ramp above is structurally unreachable from\n   * the keyboard. The result is a mode that works perfectly for the first few\n   * items of a list and then silently moves a card to a position its user\n   * cannot see, which is the exact class of failure the keyboard path exists to\n   * avoid.\n   *\n   * A JUMP, NOT A SMOOTH SCROLL. Each keypress is a discrete step and the user\n   * is waiting on it; a 300ms animated scroll per press falls behind a held\n   * arrow key immediately, and it is unrequested large-scale motion for a user\n   * who may have asked for less of it.\n   */\n  function keepKeyboardTargetVisible(): void {\n    const s = session.getState();\n    if (s.phase !== \"dragging\" || s.mode !== \"keyboard\" || !s.over || !s.id) return;\n    const layout = session.getLayout();\n    if (!layout) return;\n    const container = layout.containers.find((c) => c.id === s.over?.container);\n    if (!container) return;\n\n    /* The box the insertion point sits AGAINST. At the end of the list there is\n       no item at that index, so the anchor is the last one — the marker sits\n       just after it either way. An empty container anchors on itself. */\n    const rest = layout.items.filter((i) => i.container === container.id && i.id !== s.id);\n    const anchor =\n      rest.length === 0\n        ? container.rect\n        : rest[Math.min(s.over.index, rest.length - 1)].rect;\n\n    /* Hit-tested at the CONTAINER's centre, not the anchor's: the anchor is by\n       definition the thing that may be off-screen, and `elementFromPoint`\n       returns null outside the viewport. */\n    const scroller = scrollerAt({\n      x: container.rect.left + container.rect.width / 2,\n      y: container.rect.top + container.rect.height / 2,\n    });\n    if (!scroller) return;\n    const box = viewportRect(scroller);\n\n    let dy = 0;\n    if (anchor.top < box.top) dy = anchor.top - box.top;\n    else if (anchor.bottom > box.bottom) dy = anchor.bottom - box.bottom;\n    let dx = 0;\n    if (anchor.left < box.left) dx = anchor.left - box.left;\n    else if (anchor.right > box.right) dx = anchor.right - box.right;\n    if (dx === 0 && dy === 0) return;\n\n    scroller.scrollTop += dy;\n    scroller.scrollLeft += dx;\n    /* Every rect just moved. `remeasure` does not emit, so this cannot re-enter\n       through the subscription that called it. */\n    session.remeasure();\n  }\n\n  let lastOver = \"\";\n  let detach: (() => void) | null = null;\n\n  const unsubscribe = session.subscribe(() => {\n    const state = session.getState();\n    const overKey = state.over ? `${state.over.container}:${state.over.index}` : \"\";\n    if (overKey !== lastOver) {\n      lastOver = overKey;\n      keepKeyboardTargetVisible();\n    }\n    const dragging = state.phase === \"dragging\";\n    if (dragging && !detach) {\n      detach = attachEdgeAutoScroll(\n        {\n          /* Null for a KEYBOARD drag, which has no cursor to be near an edge —\n             the keyboard moves the insertion point directly and reaches the\n             viewport through `keepKeyboardTargetVisible` instead. */\n          getPoint: () => {\n            const s2 = session.getState();\n            return s2.phase === \"dragging\" ? s2.point : null;\n          },\n          onScrolled: (point) => {\n            session.remeasure();\n            session.moveTo(point);\n          },\n        },\n        options,\n      );\n      return;\n    }\n    /* Covers drop AND cancel: both land the session back in `idle`, and a loop\n       that outlives its gesture goes on scrolling the page under a cursor that\n       is no longer carrying anything. */\n    if (!dragging && detach) {\n      detach();\n      detach = null;\n    }\n  });\n\n  return () => {\n    unsubscribe();\n    detach?.();\n  };\n}\n"],"names":["DEFAULTS","scrollVelocity","distanceFromEdge","threshold","maxSpeed","proximity","SCROLLABLE","scrollerAt","point","found","nearestScrollAncestor","root","isScrollBox","viewportRect","el","attachEdgeAutoScroll","driver","options","cfg","frame","last","owedX","owedY","lastScroller","stop","tick","now","dt","scroller","box","dy","dx","stepY","stepX","beforeTop","beforeLeft","reducedMotion","attachAutoScroll","session","keepKeyboardTargetVisible","s","layout","container","c","rest","i","anchor","lastOver","detach","unsubscribe","state","overKey","dragging","s2"],"mappings":"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"}

package/dist/lib/dnd/cross-drop.js

@@ -0,0 +1,11 @@
+function l(n, r, e) {
+  return n === "lane" && r != null && e != null && r !== e;
+}
+function u(n, r) {
+  return n.phase !== "dragging" || n.over?.container !== r ? null : n.from?.container === r ? "own" : "other";
+}
+export {
+  u as heldOver,
+  l as isLaneDrop
+};
+//# sourceMappingURL=cross-drop.js.map

package/dist/lib/dnd/cross-drop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-drop.js","sources":["../../../src/lib/dnd/cross-drop.ts"],"sourcesContent":["/**\n * DX-4583: the one place that says what \"a card dropped on another lane\" means,\n * so the drop, the highlight, the banner, the gap and the keyboard cannot drift\n * into four spellings of the same predicate.\n */\n\nimport type { ContainerId, CrossDrop, DragState } from \"./types\";\n\n/**\n * True when a card carried from `from` into `to` lands there as a whole: the\n * destination takes a lane drop and it is not the card's own container. A card\n * carried inside its own container is always positional.\n */\nexport function isLaneDrop(\n  crossDrop: CrossDrop | undefined,\n  from: ContainerId | null | undefined,\n  to: ContainerId | null | undefined,\n): boolean {\n  return crossDrop === \"lane\" && from != null && to != null && from !== to;\n}\n\n/**\n * Whose card is held over `container` right now: `\"own\"` when it was picked up\n * from there, `\"other\"` when it came from another container, `null` when no card\n * is held over it.\n */\nexport function heldOver(state: DragState, container: ContainerId): \"own\" | \"other\" | null {\n  if (state.phase !== \"dragging\" || state.over?.container !== container) return null;\n  return state.from?.container === container ? \"own\" : \"other\";\n}\n"],"names":["isLaneDrop","crossDrop","from","to","heldOver","state","container"],"mappings":"AAaO,SAASA,EACdC,GACAC,GACAC,GACS;AACT,SAAOF,MAAc,UAAUC,KAAQ,QAAQC,KAAM,QAAQD,MAASC;AACxE;AAOO,SAASC,EAASC,GAAkBC,GAAgD;AACzF,SAAID,EAAM,UAAU,cAAcA,EAAM,MAAM,cAAcC,IAAkB,OACvED,EAAM,MAAM,cAAcC,IAAY,QAAQ;AACvD;"}

package/dist/lib/dnd/geometry.js

@@ -0,0 +1,99 @@
+function M(n, t, r = []) {
+  const e = [...t], o = new Map(e.map((i) => [i.id, i.axis])), c = [];
+  for (const i of n) {
+    const s = {
+      id: i.id,
+      container: i.container,
+      index: i.index,
+      rect: i.element.getBoundingClientRect()
+    };
+    if (i.group !== void 0) {
+      s.group = i.group, s.piece = i.piece;
+      const l = d(i.element, o.get(i.container) ?? "y");
+      l !== null && (s.marginEnd = l);
+    }
+    c.push(s);
+  }
+  c.sort(
+    (i, s) => i.container === s.container ? i.index - s.index : i.container < s.container ? -1 : 1
+  );
+  const u = [];
+  for (const i of e)
+    u.push({
+      id: i.id,
+      axis: i.axis,
+      crossDrop: i.crossDrop,
+      rect: i.element.getBoundingClientRect()
+    });
+  const a = [];
+  for (const i of r)
+    a.push({ id: i.id, piece: i.piece, container: i.container, rect: i.element.getBoundingClientRect() });
+  return { items: c, containers: u, groups: a };
+}
+function d(n, t) {
+  const r = getComputedStyle(n), e = Number.parseFloat(t === "y" ? r.marginBottom : r.marginRight);
+  return Number.isFinite(e) ? e : null;
+}
+function g(n, t) {
+  return t.x >= n.left && t.x <= n.right && t.y >= n.top && t.y <= n.bottom;
+}
+function f(n) {
+  return Math.max(0, n.width) * Math.max(0, n.height);
+}
+function m(n, t) {
+  let r = null;
+  for (const e of n.containers)
+    g(e.rect, t) && (!r || f(e.rect) < f(r.rect)) && (r = e);
+  return r;
+}
+function x(n, t) {
+  const r = Math.max(n.left - t.x, 0, t.x - n.right), e = Math.max(n.top - t.y, 0, t.y - n.bottom);
+  return Math.hypot(r, e);
+}
+function h(n, t) {
+  let r = null, e = 1 / 0;
+  for (const o of n.containers) {
+    const c = x(o.rect, t);
+    c > e + 1e-3 || (c < e - 1e-3 || r === null || f(o.rect) < f(r.rect)) && (r = o, e = c);
+  }
+  return r;
+}
+function p(n, t, r) {
+  return n.items.filter(
+    (e) => e.container === t && e.id !== r
+  );
+}
+function y(n, t, r, e) {
+  const o = p(n, t.id, e), c = t.axis === "x" ? r.x : r.y;
+  for (let u = 0; u < o.length; u++) {
+    const a = o[u].rect, i = t.axis === "x" ? a.left + a.width / 2 : a.top + a.height / 2;
+    if (c < i) return u;
+  }
+  return o.length;
+}
+function C(n, t, r) {
+  const e = m(n, t) ?? h(n, t);
+  return e ? { container: e.id, index: y(n, e, t, r) } : null;
+}
+function v(n, t) {
+  return n === t ? !0 : !n || !t ? !1 : n.container === t.container && n.index === t.index;
+}
+function B(n, t) {
+  return n.container !== t.container ? !1 : t.index === n.index;
+}
+function R(n, t, r) {
+  const e = n.slice(), [o] = e.splice(t, 1);
+  return e.splice(r, 0, o), e;
+}
+export {
+  R as applyMove,
+  m as containerAt,
+  y as indexAt,
+  B as isNoOp,
+  M as measure,
+  h as nearestContainer,
+  p as remainingItems,
+  C as resolveTarget,
+  v as sameTarget
+};
+//# sourceMappingURL=geometry.js.map

package/dist/lib/dnd/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sources":["../../../src/lib/dnd/geometry.ts"],"sourcesContent":["import type {\n  ContainerRect,\n  ContainerRegistration,\n  DragId,\n  DropTarget,\n  GroupRect,\n  GroupRegistration,\n  ItemRect,\n  ItemRegistration,\n  LayoutSnapshot,\n  Point,\n} from \"./types\";\n\n/**\n * Measuring and hit-testing. Pure functions over a snapshot — no DOM reads\n * except in `measure`, and no state at all, so every rule here is testable\n * against hand-written rectangles rather than a browser.\n */\n\n/**\n * Take every box at once.\n *\n * Items are emitted in container-then-index order so `resolveTarget` can walk\n * them without re-sorting on every move. Registration order is whatever React\n * mounted in, which is not the reading order once a list re-renders.\n */\nexport function measure(\n  items: Iterable<ItemRegistration>,\n  containers: Iterable<ContainerRegistration>,\n  groups: Iterable<GroupRegistration> = [],\n): LayoutSnapshot {\n  const registered = [...containers];\n  const axisOf = new Map(registered.map((c) => [c.id, c.axis]));\n  const measuredItems: ItemRect[] = [];\n  for (const it of items) {\n    const measured: ItemRect = {\n      id: it.id,\n      container: it.container,\n      index: it.index,\n      rect: it.element.getBoundingClientRect(),\n    };\n    /* Only a grouped item is read for its trailing margin: a loose item's is the container's usual spacing. */\n    if (it.group !== undefined) {\n      measured.group = it.group;\n      measured.piece = it.piece;\n      const marginEnd = trailingMargin(it.element, axisOf.get(it.container) ?? \"y\");\n      if (marginEnd !== null) measured.marginEnd = marginEnd;\n    }\n    measuredItems.push(measured);\n  }\n  measuredItems.sort((a, b) =>\n    a.container === b.container\n      ? a.index - b.index\n      : a.container < b.container\n        ? -1\n        : 1,\n  );\n\n  const measuredContainers: ContainerRect[] = [];\n  for (const c of registered) {\n    measuredContainers.push({\n      id: c.id,\n      axis: c.axis,\n      crossDrop: c.crossDrop,\n      rect: c.element.getBoundingClientRect(),\n    });\n  }\n  const measuredGroups: GroupRect[] = [];\n  for (const g of groups) {\n    measuredGroups.push({ id: g.id, piece: g.piece, container: g.container, rect: g.element.getBoundingClientRect() });\n  }\n  return { items: measuredItems, containers: measuredContainers, groups: measuredGroups };\n}\n\n/**\n * DX-5522: the margin an item leaves after itself on its container's axis, in px, or null when the engine cannot read one\n * (no layout engine). The first item of a pair is followed by the container's usual spacing; the last item of a group box\n * is followed by none, and a marker drawn after it is placed by the difference.\n */\nfunction trailingMargin(element: HTMLElement, axis: \"x\" | \"y\"): number | null {\n  const style = getComputedStyle(element);\n  const value = Number.parseFloat(axis === \"y\" ? style.marginBottom : style.marginRight);\n  return Number.isFinite(value) ? value : null;\n}\n\nfunction contains(rect: DOMRect, p: Point): boolean {\n  return (\n    p.x >= rect.left && p.x <= rect.right && p.y >= rect.top && p.y <= rect.bottom\n  );\n}\n\nfunction area(rect: DOMRect): number {\n  return Math.max(0, rect.width) * Math.max(0, rect.height);\n}\n\n/**\n * The container under the pointer.\n *\n * SMALLEST AREA WINS, because containers nest: a board is a horizontal\n * container of columns, and each column is a vertical container of cards. The\n * pointer is inside both at all times, and the answer that is useful is always\n * the innermost one.\n */\nexport function containerAt(\n  snapshot: LayoutSnapshot,\n  point: Point,\n): ContainerRect | null {\n  let best: ContainerRect | null = null;\n  for (const c of snapshot.containers) {\n    if (!contains(c.rect, point)) continue;\n    if (!best || area(c.rect) < area(best.rect)) best = c;\n  }\n  return best;\n}\n\n/** Shortest distance from a point to a rectangle. Zero when inside it. */\nfunction distanceTo(rect: DOMRect, p: Point): number {\n  const dx = Math.max(rect.left - p.x, 0, p.x - rect.right);\n  const dy = Math.max(rect.top - p.y, 0, p.y - rect.bottom);\n  return Math.hypot(dx, dy);\n}\n\n/**\n * The container CLOSEST to the pointer, for a pointer that is inside none of\n * them.\n *\n * THE DEAD ZONE IS THE BUG THIS EXISTS FOR, AND IT IS MOST OF A BOARD. The\n * registered container is the SCROLLER — it has to be, so auto-scroll can find\n * its edges — and on a kanban lane the scroller is only the card list. The lane\n * header above it, the lane's own border, the gutter between two lanes and the\n * board's bottom padding are all outside every registered rect, so a pointer\n * there is \"over no container\" while being unmistakably over a lane to the\n * person holding the card.\n *\n * What used to happen there was `resolveTarget` returning null and the session\n * keeping the PREVIOUS target — so a card dragged from lane 1 and released on\n * lane 3's header landed in lane 2, the lane the pointer had last crossed on\n * its way. Measured in the demo before this change: released at (1022, 419),\n * visually the middle of \"Review\" whose lane box is 878–1166 × 407–939, the\n * card landed in \"Building\". Not an edge case — the header is 60px of every\n * lane's top, and a person aiming at an empty lane aims at its label.\n *\n * SCOPED, so \"nearest\" cannot mean \"somewhere else entirely\": the snapshot\n * holds one `DragDrop` root's own containers and nothing else — every root\n * builds its own `DragSession` (`use-drag.ts`) with its own registry. The\n * nearest container to a point over the sidebar is still a lane of the board\n * being dragged, which is the only answer a release can sensibly have.\n *\n * TIES GO TO THE SMALLER BOX, matching `containerAt` — a point in the gutter\n * between two lanes is equidistant from both, and a nested container is the\n * more specific answer for the same reason it is there.\n */\nexport function nearestContainer(\n  snapshot: LayoutSnapshot,\n  point: Point,\n): ContainerRect | null {\n  let best: ContainerRect | null = null;\n  let bestDistance = Infinity;\n  for (const c of snapshot.containers) {\n    const distance = distanceTo(c.rect, point);\n    if (distance > bestDistance + 0.001) continue;\n    if (\n      distance < bestDistance - 0.001 ||\n      best === null ||\n      area(c.rect) < area(best.rect)\n    ) {\n      best = c;\n      bestDistance = distance;\n    }\n  }\n  return best;\n}\n\n/** A container's items in reading order, excluding the one being carried. */\nexport function remainingItems(\n  snapshot: LayoutSnapshot,\n  container: string,\n  dragged: DragId | null,\n): ItemRect[] {\n  return snapshot.items.filter(\n    (i) => i.container === container && i.id !== dragged,\n  );\n}\n\n/**\n * Insertion index for a point within one container.\n *\n * THE MIDPOINT RULE: insert before the first remaining item whose centre lies\n * beyond the pointer on the container's axis; after all of them otherwise. This\n * is the rule the dashboard's implementation already uses and it is the right\n * one for lists — the insertion point tracks the cursor rather than the item's\n * leading edge, so a card released halfway over a neighbour lands on the side\n * the user is actually pointing at.\n *\n * The returned index counts the list WITHOUT the dragged item, which is what\n * makes same-container and cross-container drops identical arithmetic. See the\n * header of `types.ts`.\n */\nexport function indexAt(\n  snapshot: LayoutSnapshot,\n  container: ContainerRect,\n  point: Point,\n  dragged: DragId | null,\n): number {\n  const rest = remainingItems(snapshot, container.id, dragged);\n  const along = container.axis === \"x\" ? point.x : point.y;\n  for (let i = 0; i < rest.length; i++) {\n    const r = rest[i].rect;\n    const mid = container.axis === \"x\" ? r.left + r.width / 2 : r.top + r.height / 2;\n    if (along < mid) return i;\n  }\n  return rest.length;\n}\n\n/**\n * Where the dragged item would land if released at `point`.\n *\n * THE POINTER IS OVER THE CONTAINER IT IS NEAREST TO, not only the one whose\n * rectangle happens to hold it. Both halves of that matter and the second one\n * is the fix:\n *\n * The goal has always been that dragging a card briefly outside the board must\n * not make the insertion marker vanish, and that a release outside every\n * container still lands somewhere rather than reading as a silently failed\n * drag. That was served by returning null here and having the session keep the\n * PREVIOUS target — which achieves \"the marker does not blink out\" and gets\n * \"lands where you are pointing\" exactly backwards. The gap between two lanes,\n * a lane's header, a lane's border and the board's own bottom padding are all\n * outside every registered rect; a release in any of them landed the card in\n * the last lane the pointer had crossed, which for a drag from lane 1 to lane 3\n * is lane 2. See `nearestContainer` for the measurement.\n *\n * Nearest keeps the marker alive for the same reason last-target did, and puts\n * it where the person is aiming rather than where they have been.\n *\n * STILL NULL FOR A BOARD WITH NO CONTAINERS AT ALL — there is no nearest one,\n * and the session's `?? s.over` remains the guard for that.\n *\n * The index then falls out of `indexAt` without a special case: a point above a\n * lane is before every card in it, a point below is after all of them.\n */\nexport function resolveTarget(\n  snapshot: LayoutSnapshot,\n  point: Point,\n  dragged: DragId | null,\n): DropTarget | null {\n  const container = containerAt(snapshot, point) ?? nearestContainer(snapshot, point);\n  if (!container) return null;\n  return { container: container.id, index: indexAt(snapshot, container, point, dragged) };\n}\n\n/** Value equality — targets are recreated on every move, so `===` is useless. */\nexport function sameTarget(a: DropTarget | null, b: DropTarget | null): boolean {\n  if (a === b) return true;\n  if (!a || !b) return false;\n  return a.container === b.container && a.index === b.index;\n}\n\n/**\n * Would releasing at `to` leave the item exactly where it started?\n *\n * Worth stating rather than inlining, because the two indices are counted\n * against DIFFERENT lists: `from.index` is the item's position with itself\n * present, `to.index` an insertion point with itself removed. They coincide at\n * exactly one value. For `[A, B, C, D]` carrying `C` (`from.index` 2), the\n * remaining list is `[A, B, D]` and inserting at 2 rebuilds `[A, B, C, D]` —\n * so equality of the two numbers IS the no-op, and every other pair moves\n * something.\n *\n * A consumer that skips this writes on every release, including the ones that\n * change nothing. That is not free: the dashboard's board reordered by writing\n * a priority decimal, so a no-op release still cost a request, a re-render and\n * a row in the audit log.\n */\nexport function isNoOp(from: DropTarget, to: DropTarget): boolean {\n  if (from.container !== to.container) return false;\n  return to.index === from.index;\n}\n\n/**\n * Convert a `DropTarget` into the array operation a consumer performs.\n *\n * Exported because every consumer needs it and each one getting it subtly wrong\n * is the entire off-by-one bug class this module exists to remove. Returns a\n * NEW array; the input is untouched.\n */\nexport function applyMove<T>(\n  list: readonly T[],\n  fromIndex: number,\n  toIndex: number,\n): T[] {\n  const next = list.slice();\n  const [moved] = next.splice(fromIndex, 1);\n  next.splice(toIndex, 0, moved);\n  return next;\n}\n"],"names":["measure","items","containers","groups","registered","axisOf","c","measuredItems","it","measured","marginEnd","trailingMargin","a","b","measuredContainers","measuredGroups","g","element","axis","style","value","contains","rect","p","area","containerAt","snapshot","point","best","distanceTo","dx","dy","nearestContainer","bestDistance","distance","remainingItems","container","dragged","i","indexAt","rest","along","r","mid","resolveTarget","sameTarget","isNoOp","from","to","applyMove","list","fromIndex","toIndex","next","moved"],"mappings":"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"}

package/dist/lib/dnd/sensors/gesture.js

@@ -0,0 +1,86 @@
+const g = {
+  /* 5px is below the travel of a deliberate click on every pointing device
+     tested by the platforms that publish a figure, and above the jitter of a
+     hand resting on a trackpad. */
+  distance: 5,
+  /* 250ms is the shortest dwell that reads as deliberate. Below ~200ms it fires
+     during fast scrolling; above ~400ms the control feels broken before it
+     responds. FullCalendar's 1000ms is widely complained about. */
+  delay: 250,
+  /* 8px of finger travel during the press is unavoidable and must not cancel;
+     more than that is a scroll. */
+  tolerance: 8
+};
+function x(u, i, E = {}) {
+  const d = { ...g, ...E.activation };
+  let r = null, t = null, l = null, c = null, a = !1;
+  const f = (e) => ({ x: e.clientX, y: e.clientY });
+  function P() {
+    l !== null && (window.clearTimeout(l), l = null);
+  }
+  function T() {
+    c || (c = (e) => {
+      e.cancelable && e.preventDefault();
+    }, document.addEventListener("touchmove", c, { passive: !1 }));
+  }
+  function y() {
+    c && (document.removeEventListener("touchmove", c), c = null);
+  }
+  function C() {
+    document.addEventListener("pointermove", m), document.addEventListener("pointerup", w), document.addEventListener("pointercancel", L);
+  }
+  function h() {
+    document.removeEventListener("pointermove", m), document.removeEventListener("pointerup", w), document.removeEventListener("pointercancel", L);
+  }
+  function s() {
+    P(), y(), h(), t !== null && u.hasPointerCapture(t) && u.releasePointerCapture(t), t = null, r = null, a = !1;
+  }
+  function p(e) {
+    a = !0, t !== null && u.setPointerCapture(t), i.onActivate(e);
+  }
+  function I() {
+    const e = (o) => {
+      o.stopPropagation(), o.preventDefault(), n();
+    }, n = () => {
+      document.removeEventListener("click", e, { capture: !0 }), document.removeEventListener("pointerdown", n, { capture: !0 });
+    };
+    document.addEventListener("click", e, { capture: !0 }), document.addEventListener("pointerdown", n, { capture: !0 }), window.setTimeout(n, 0);
+  }
+  function v(e) {
+    if (e.button !== 0 || t !== null) return;
+    const n = f(e);
+    i.onPress && i.onPress(n, e) === !1 || (t = e.pointerId, r = n, a = !1, C(), e.pointerType === "touch" && (l = window.setTimeout(() => {
+      l = null, T(), r && p(r);
+    }, d.delay)));
+  }
+  function m(e) {
+    if (e.pointerId !== t || !r) return;
+    const n = f(e);
+    if (!a) {
+      const o = Math.hypot(n.x - r.x, n.y - r.y);
+      if (e.pointerType === "touch") {
+        o > d.tolerance && (s(), i.onCancel());
+        return;
+      }
+      if (o < d.distance) return;
+      p(n);
+    }
+    e.cancelable && e.preventDefault(), i.onMove(n);
+  }
+  function w(e) {
+    if (e.pointerId !== t) return;
+    const n = f(e), o = a;
+    s(), o && I(), i.onRelease(n, o);
+  }
+  function L(e) {
+    e.pointerId === t && (s(), i.onCancel());
+  }
+  return u.addEventListener("pointerdown", v), () => {
+    s(), u.removeEventListener("pointerdown", v);
+  };
+}
+export {
+  g as ACTIVATION_DEFAULTS,
+  x as attachPointerGesture
+};
+//# sourceMappingURL=gesture.js.map

package/dist/lib/dnd/sensors/gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gesture.js","sources":["../../../../src/lib/dnd/sensors/gesture.ts"],"sourcesContent":["import type { Point } from \"../types\";\n\n/* ============================================================================\n   THE POINTER GESTURE, WITH NO OPINION ABOUT WHAT IT IS DRAGGING.\n\n   WHY THIS IS ITS OWN FILE. Two consumers now need the same input handling —\n   the list engine, which drops an item between siblings, and the calendar,\n   which moves an event to a time. Their TARGET MODELS have nothing in common: a\n   list target is `{container, index}` resolved from the midpoints of sibling\n   items; a calendar target is `{day, minutes}` read off a fixed grid and\n   dependent on no other event at all.\n\n   Their INPUT handling is identical, and it is the part that was expensive to\n   get right: activation constants tuned against real devices, pointer capture,\n   and the touch mechanism below. Duplicating that would leave two copies of the\n   one thing most likely to rot — and the touch guard in particular is invisible\n   until someone tries the calendar on a phone, which is exactly when nobody is\n   watching.\n\n   So: ONE input layer, two target models. This file is the input layer. It\n   knows about pointers, timers and capture; it does not know what a drop is.\n   ========================================================================= */\n\nexport interface PointerActivation {\n  /** Mouse and pen: travel in px before the drag starts. */\n  distance?: number;\n  /** Touch: press duration in ms before the drag starts. */\n  delay?: number;\n  /** Touch: travel in px that abandons the press as a scroll instead. */\n  tolerance?: number;\n}\n\nexport const ACTIVATION_DEFAULTS: Required<PointerActivation> = {\n  /* 5px is below the travel of a deliberate click on every pointing device\n     tested by the platforms that publish a figure, and above the jitter of a\n     hand resting on a trackpad. */\n  distance: 5,\n  /* 250ms is the shortest dwell that reads as deliberate. Below ~200ms it fires\n     during fast scrolling; above ~400ms the control feels broken before it\n     responds. FullCalendar's 1000ms is widely complained about. */\n  delay: 250,\n  /* 8px of finger travel during the press is unavoidable and must not cancel;\n     more than that is a scroll. */\n  tolerance: 8,\n};\n\nexport interface GestureHandlers {\n  /**\n   * The pointer went down. Return false to refuse the gesture outright — a\n   * disabled row, a click on a button inside the card.\n   */\n  onPress?: (point: Point, event: PointerEvent) => boolean | void;\n  /** The activation constraint was satisfied. The drag is now live. */\n  onActivate: (point: Point) => void;\n  /** Only ever called between `onActivate` and one of the two enders. */\n  onMove: (point: Point) => void;\n  /** Released. `activated` distinguishes a drop from a plain click. */\n  onRelease: (point: Point, activated: boolean) => void;\n  /** The gesture was abandoned — a `pointercancel`, or a touch that scrolled. */\n  onCancel: () => void;\n}\n\nexport interface GestureOptions {\n  activation?: PointerActivation;\n}\n\n/**\n * Wire an element as a drag handle. Returns the teardown.\n *\n * The listeners live on the ELEMENT, not the document, and the element takes\n * pointer capture at `pointerdown` — so every subsequent move and the release\n * are delivered here even when the pointer leaves the element, which it does\n * immediately and for the entire gesture.\n */\nexport function attachPointerGesture(\n  element: HTMLElement,\n  handlers: GestureHandlers,\n  options: GestureOptions = {},\n): () => void {\n  const cfg = { ...ACTIVATION_DEFAULTS, ...options.activation };\n\n  let origin: Point | null = null;\n  let activePointer: number | null = null;\n  let delayTimer: number | null = null;\n  let scrollGuard: ((e: TouchEvent) => void) | null = null;\n  let activated = false;\n\n  const pointOf = (e: PointerEvent): Point => ({ x: e.clientX, y: e.clientY });\n\n  function clearTimer(): void {\n    if (delayTimer !== null) {\n      window.clearTimeout(delayTimer);\n      delayTimer = null;\n    }\n  }\n\n  /**\n   * Take the gesture back from the browser for the rest of this touch.\n   *\n   * `preventDefault` on `pointermove` cannot do this: a pointer event for touch\n   * is non-cancelable once `touch-action` has permitted the pan, which is why\n   * an `e.cancelable` test silently does nothing on a phone. The cancelable\n   * event is `touchmove`, and it must be registered NON-PASSIVELY — Chrome\n   * makes touch listeners passive by default on document and window, and a\n   * passive listener's `preventDefault` is ignored with only a console warning.\n   *\n   * Installed at ACTIVATION, never at `pointerdown`. The finger has been still\n   * for the whole dwell, so the browser has not begun scrolling and the next\n   * `touchmove` is still cancelable. Installing it earlier would suppress the\n   * scroll for every press that never becomes a drag — which is most of them.\n   */\n  function beginTouchScrollGuard(): void {\n    if (scrollGuard) return;\n    scrollGuard = (e: TouchEvent) => {\n      if (e.cancelable) e.preventDefault();\n    };\n    document.addEventListener(\"touchmove\", scrollGuard, { passive: false });\n  }\n\n  function endTouchScrollGuard(): void {\n    if (!scrollGuard) return;\n    document.removeEventListener(\"touchmove\", scrollGuard);\n    scrollGuard = null;\n  }\n\n  /**\n   * WHILE A PRESS IS IN FLIGHT, THE MOVES COME FROM THE DOCUMENT.\n   *\n   * They used to come from the element, because the element took pointer\n   * capture at `pointerdown` — which delivers every move and the release to\n   * the handle wherever the pointer goes, and is exactly right for a grip.\n   *\n   * IT IS WRONG FOR A DRAG SOURCE THAT IS ALSO A CONTROL, and the reason is\n   * that capture retargets the COMPATIBILITY MOUSE EVENTS too. Measured on a\n   * kanban card, pressing and releasing on the card's own button with capture\n   * taken at `pointerdown`:\n   *\n   *     pointerdown -> SPAN (inside the card)\n   *     pointerup   -> DIV[data-dnd-surface]\n   *     mouseup     -> DIV[data-dnd-surface]\n   *     click       -> DIV[data-dnd-surface]\n   *\n   * The click lands on the drag source instead of the button inside it, so it\n   * never reaches the button's handler at all and the record never opens — a\n   * card that could be dragged and could not be clicked, with nothing thrown\n   * and nothing to see.\n   *\n   * So capture is taken at ACTIVATION instead, when the gesture really is a\n   * drag and the trailing click is being swallowed anyway. Up to that moment\n   * the press is indistinguishable from an ordinary click and the browser's own\n   * targeting is left alone. Document listeners are what make that safe: without\n   * capture there is nothing keeping the moves and the release coming to the\n   * element, and a pointer that leaves it before activating would strand the\n   * gesture with no release to end it.\n   */\n  function listenWhilePressed(): void {\n    document.addEventListener(\"pointermove\", onPointerMove);\n    document.addEventListener(\"pointerup\", onPointerUp);\n    document.addEventListener(\"pointercancel\", onPointerCancel);\n  }\n\n  function stopListeningWhilePressed(): void {\n    document.removeEventListener(\"pointermove\", onPointerMove);\n    document.removeEventListener(\"pointerup\", onPointerUp);\n    document.removeEventListener(\"pointercancel\", onPointerCancel);\n  }\n\n  function release(): void {\n    clearTimer();\n    endTouchScrollGuard();\n    stopListeningWhilePressed();\n    if (activePointer !== null && element.hasPointerCapture(activePointer)) {\n      element.releasePointerCapture(activePointer);\n    }\n    activePointer = null;\n    origin = null;\n    activated = false;\n  }\n\n  function activate(point: Point): void {\n    activated = true;\n    /* NOW the gesture is ours, so take the pointer with it. Capture keeps the\n       moves and the release coming to this element even across an iframe or a\n       cross-origin subframe, which document listeners alone cannot promise. */\n    if (activePointer !== null) element.setPointerCapture(activePointer);\n    handlers.onActivate(point);\n  }\n\n  /**\n   * A GESTURE THAT BECAME A DRAG MUST NOT ALSO BE A CLICK.\n   *\n   * The browser dispatches `click` after `pointerup` from the same press,\n   * whatever happened in between — so on a surface where the drag source IS the\n   * thing that opens something (a card you can drag and also click into), every\n   * completed drag would land the card in its new lane AND open it. That is not\n   * a cosmetic defect: the reorder is written, the route changes, and the board\n   * the user was arranging is gone.\n   *\n   * `preventDefault` on the `pointerdown` would stop it and takes focus with\n   * it, which is worse — the card stops being reachable by clicking. So the\n   * click is swallowed instead, once, in the CAPTURE phase on the document, so\n   * it is cancelled before it reaches the card's own handler however deep the\n   * release landed.\n   *\n   * IT IS DISARMED TWO WAYS, and both are needed. A drag that ends with the\n   * pointer somewhere that produces no click at all — off the element, over a\n   * scrollbar — would otherwise leave the listener armed and eat the user's\n   * NEXT click.\n   *\n   *   A TASK-QUEUE TIMEOUT covers the ordinary case: `click` is dispatched from\n   *   the same input task as the `pointerup` that caused it, so a timeout\n   *   always runs after it when there is one, and immediately when there is not.\n   *\n   *   A NEW `pointerdown` covers the case the timeout cannot, which is any\n   *   sequence that presses again inside the SAME task — programmatic input,\n   *   and every test written that way. A fresh press means the previous\n   *   gesture's trailing click is never coming; continuing to wait for it eats\n   *   a click that belongs to somebody else. Found by a node-canvas test that\n   *   dragged one node and then tapped another in the same tick, and lost the\n   *   tap.\n   */\n  function swallowNextClick(): void {\n    const swallow = (e: MouseEvent) => {\n      e.stopPropagation();\n      e.preventDefault();\n      disarm();\n    };\n    const disarm = () => {\n      document.removeEventListener(\"click\", swallow, { capture: true });\n      document.removeEventListener(\"pointerdown\", disarm, { capture: true });\n    };\n    document.addEventListener(\"click\", swallow, { capture: true });\n    document.addEventListener(\"pointerdown\", disarm, { capture: true });\n    window.setTimeout(disarm, 0);\n  }\n\n  function onPointerDown(e: PointerEvent): void {\n    /* Secondary buttons open context menus; a right-drag is not a drag. */\n    if (e.button !== 0) return;\n    if (activePointer !== null) return;\n\n    const point = pointOf(e);\n    if (handlers.onPress && handlers.onPress(point, e) === false) return;\n\n    activePointer = e.pointerId;\n    origin = point;\n    activated = false;\n    /* NO CAPTURE YET — see `listenWhilePressed`. Until this press proves itself\n       a drag it is an ordinary click, and taking capture here would retarget\n       that click away from whatever is inside the drag source. */\n    listenWhilePressed();\n\n    /* Touch dwells; mouse and pen travel. `pointerType` is the only reliable\n       discriminator — a touch device reports `\"touch\"` even when a stylus is in\n       use, and that is the behaviour we want either way, because what decides\n       the constraint is whether the input can SCROLL, not what is held. */\n    if (e.pointerType === \"touch\") {\n      delayTimer = window.setTimeout(() => {\n        delayTimer = null;\n        /* Guard FIRST. `onActivate` runs synchronously and a consumer's render\n           can happen before the next line, so installing the listener\n           afterwards leaves a window in which a `touchmove` scrolls the surface\n           the event is being lifted out of. */\n        beginTouchScrollGuard();\n        if (origin) activate(origin);\n      }, cfg.delay);\n    }\n  }\n\n  function onPointerMove(e: PointerEvent): void {\n    if (e.pointerId !== activePointer || !origin) return;\n    const point = pointOf(e);\n\n    if (!activated) {\n      const travelled = Math.hypot(point.x - origin.x, point.y - origin.y);\n      if (e.pointerType === \"touch\") {\n        /* Travelled too far before the timer: the finger was scrolling. Abandon\n           the gesture rather than starting a drag the user did not ask for. */\n        if (travelled > cfg.tolerance) {\n          release();\n          handlers.onCancel();\n        }\n        return;\n      }\n      if (travelled < cfg.distance) return;\n      activate(point);\n    }\n\n    /* Once dragging, the gesture belongs to us. Without this the page pans\n       under the finger while the event is being carried. */\n    if (e.cancelable) e.preventDefault();\n    handlers.onMove(point);\n  }\n\n  function onPointerUp(e: PointerEvent): void {\n    if (e.pointerId !== activePointer) return;\n    const point = pointOf(e);\n    const wasActive = activated;\n    release();\n    if (wasActive) swallowNextClick();\n    handlers.onRelease(point, wasActive);\n  }\n\n  function onPointerCancel(e: PointerEvent): void {\n    if (e.pointerId !== activePointer) return;\n    release();\n    handlers.onCancel();\n  }\n\n  /* ONLY the press is bound to the element — everything after it is bound to\n     the document for the life of that press, and unbound again by `release`.\n     See `listenWhilePressed`. */\n  element.addEventListener(\"pointerdown\", onPointerDown);\n\n  return () => {\n    release();\n    element.removeEventListener(\"pointerdown\", onPointerDown);\n  };\n}\n"],"names":["ACTIVATION_DEFAULTS","attachPointerGesture","element","handlers","options","cfg","origin","activePointer","delayTimer","scrollGuard","activated","pointOf","clearTimer","beginTouchScrollGuard","endTouchScrollGuard","listenWhilePressed","onPointerMove","onPointerUp","onPointerCancel","stopListeningWhilePressed","release","activate","point","swallowNextClick","swallow","e","disarm","onPointerDown","travelled","wasActive"],"mappings":"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"}

package/dist/lib/dnd/sensors/keyboard.js

@@ -0,0 +1,47 @@
+const d = {
+  y: { ArrowUp: -1, ArrowDown: 1 },
+  x: { ArrowLeft: -1, ArrowRight: 1 }
+}, y = {
+  y: { ArrowLeft: -1, ArrowRight: 1 },
+  x: { ArrowUp: -1, ArrowDown: 1 }
+};
+function v(t, e, n) {
+  const i = n.axis ?? "y";
+  function a() {
+    const r = t.getState();
+    return r.phase === "dragging" && r.mode === "keyboard" && r.id === n.id;
+  }
+  function u(r) {
+    if (r.altKey || r.ctrlKey || r.metaKey) return;
+    if (r.key === " " || r.key === "Enter") {
+      if (r.repeat) return;
+      if (a()) {
+        r.preventDefault(), t.commit();
+        return;
+      }
+      if (t.getState().phase !== "idle" || r.key === "Enter" && r.target !== e || n.canStart && !n.canStart(r) || !t.start({ id: n.id, mode: "keyboard" })) return;
+      r.preventDefault();
+      return;
+    }
+    if (!a()) return;
+    const o = d[i][r.key];
+    if (o !== void 0) {
+      r.preventDefault(), t.moveIndex(o);
+      return;
+    }
+    const c = y[i][r.key];
+    c !== void 0 && (r.preventDefault(), t.moveContainer(c));
+  }
+  function f(r) {
+    if (!a()) return;
+    const o = r.relatedTarget;
+    o instanceof Node && e.contains(o) || t.cancel();
+  }
+  return e.addEventListener("keydown", u), e.addEventListener("focusout", f), () => {
+    e.removeEventListener("keydown", u), e.removeEventListener("focusout", f);
+  };
+}
+export {
+  v as attachKeyboardSensor
+};
+//# sourceMappingURL=keyboard.js.map

package/dist/lib/dnd/sensors/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","sources":["../../../../src/lib/dnd/sensors/keyboard.ts"],"sourcesContent":["import type { DragSession } from \"../session\";\nimport type { DragAxis, DragId } from \"../types\";\n\n/**\n * The keyboard sensor. Drives the SAME session the pointer does.\n *\n * WHY A SENSOR AND NOT A KEYBOARD IMPLEMENTATION. The usual shape is a pointer\n * drag with keyboard \"support\" bolted on, which is two codebases computing the\n * same answer — and the accessible one is the one nobody looks at, so it is the\n * one that rots. Here the keyboard can only `start`, `moveIndex`,\n * `moveContainer`, `commit` and `cancel`, exactly like the pointer, so the two\n * cannot disagree about where a card lands. `dnd-sensors.test.ts` asserts they\n * reach an identical target for the same intent.\n *\n * THE KEY MAP IS FIXED BY THE PROJECT CONTRACT, not by this file:\n *\n *   Space          pick up; drop when already carrying\n *   Enter          the same, but ONLY when the drag source is itself the\n *                  focused control. On a whole-card source the key arrives by\n *                  bubbling from the card's own button, and Enter is that\n *                  button's — see the note at the check.\n *   Escape         cancel — handled by `attachSessionWindowListeners`, NOT here\n *   Along the axis step the insertion point inside the current container\n *   Across it      move to the previous / next container\n *\n * \"Along\" and \"across\" swap with the container's axis: a vertical list steps\n * with Up/Down and changes column with Left/Right; a horizontal one is the\n * mirror. Hard-coding Up/Down as \"within\" makes a horizontal list unusable in\n * the one input mode that has no alternative.\n *\n * NO `aria-grabbed`, NO `aria-dropeffect`. They are the attributes the name\n * suggests and they were removed in ARIA 1.2 because assistive-technology\n * support never arrived — an implementation using them announces nothing at\n * all. Ordinary focus, an `aria-describedby` instruction and a live region are\n * the working pattern; the live region is `announce.tsx`'s.\n */\n\nexport interface KeyboardSensorOptions {\n  id: DragId;\n  /**\n   * The reorder axis of the container this item currently lives in. Decides\n   * which arrow pair steps within the container and which moves between them.\n   */\n  axis?: DragAxis;\n  /** Return false to refuse pickup — a disabled row. Mirrors the pointer sensor. */\n  canStart?: (e: KeyboardEvent) => boolean;\n}\n\n/** Arrow deltas ALONG each axis: stepping the insertion point in place. */\nconst ALONG: Record<DragAxis, Record<string, number>> = {\n  y: { ArrowUp: -1, ArrowDown: 1 },\n  x: { ArrowLeft: -1, ArrowRight: 1 },\n};\n\n/** Arrow deltas ACROSS each axis: moving to the previous / next container. */\nconst ACROSS: Record<DragAxis, Record<string, number>> = {\n  y: { ArrowLeft: -1, ArrowRight: 1 },\n  x: { ArrowUp: -1, ArrowDown: 1 },\n};\n\n/**\n * Wire an element as a keyboard drag handle. Returns the teardown.\n *\n * The element must be focusable and reachable — `tabIndex={0}` and\n * `role=\"button\"` — or none of this is ever delivered. A handle that is a\n * `<span>` with a listener is invisible to the keyboard and to every screen\n * reader, and looks completely correct on a desktop.\n */\nexport function attachKeyboardSensor(\n  session: DragSession,\n  element: HTMLElement,\n  options: KeyboardSensorOptions,\n): () => void {\n  const axis = options.axis ?? \"y\";\n\n  /** Is the live session OURS — this item, started by this sensor? */\n  function carrying(): boolean {\n    const s = session.getState();\n    return s.phase === \"dragging\" && s.mode === \"keyboard\" && s.id === options.id;\n  }\n\n  function onKeyDown(e: KeyboardEvent): void {\n    /* A modified arrow is a browser or OS command — Alt+Left is Back, and\n       Cmd+Down is End on macOS. Stealing those breaks navigation for the users\n       most likely to be driving this by keyboard in the first place. */\n    if (e.altKey || e.ctrlKey || e.metaKey) return;\n\n    if (e.key === \" \" || e.key === \"Enter\") {\n      /* Held keys auto-repeat. Without this the second repeat of the Space that\n         DROPPED a card immediately picks it up again, so a normal-length press\n         leaves the user carrying the card they just put down. */\n      if (e.repeat) return;\n      if (carrying()) {\n        e.preventDefault();\n        session.commit();\n        return;\n      }\n      if (session.getState().phase !== \"idle\") return;\n      /* ENTER BELONGS TO WHATEVER HAS FOCUS; SPACE PICKS UP EITHER WAY.\n         Both keys pick up when the drag source IS the focused control — a grip,\n         which does nothing else. When the source is a whole CARD wrapping its\n         own button, the key arrives here by bubbling and `e.target` is that\n         button: Enter is then the button's, and stealing it would mean a record\n         card could be dragged by keyboard and never opened by one. Space still\n         picks up, because a button's Space is an alias for its Enter and the\n         card has no second action to lose.\n\n         Read off the event rather than configured, so a surface and a grip get\n         the right rule without either of them — or the consumer between them —\n         having to say which they are. */\n      if (e.key === \"Enter\" && e.target !== element) return;\n      if (options.canStart && !options.canStart(e)) return;\n      if (!session.start({ id: options.id, mode: \"keyboard\" })) return;\n      /* Only once the pickup has actually happened. Space scrolls the page by\n         default, and suppressing it on a handle that refused the drag takes\n         away paging from a control that did nothing in exchange. */\n      e.preventDefault();\n      return;\n    }\n\n    /* EVERYTHING BELOW REQUIRES A LIVE SESSION OF OURS — and the early return\n       is the reason arrow keys still scroll the page. `preventDefault` on an\n       arrow key outside a drag would disable scrolling for every user on every\n       page carrying one of these handles, which is a far larger regression\n       than the feature is worth. */\n    if (!carrying()) return;\n\n    const along = ALONG[axis][e.key];\n    if (along !== undefined) {\n      e.preventDefault();\n      session.moveIndex(along);\n      return;\n    }\n    const across = ACROSS[axis][e.key];\n    if (across !== undefined) {\n      e.preventDefault();\n      session.moveContainer(across);\n    }\n  }\n\n  /**\n   * A keyboard drag is a MODE, and a mode whose owner has lost focus is a trap:\n   * the arrows have gone back to scrolling the page, nothing on screen explains\n   * why, and the only remaining exit is an Escape the user has no reason to\n   * guess at. Tabbing away therefore cancels — which restores the card and,\n   * because cancel is a first-class session outcome, gets announced.\n   */\n  /**\n   * `focusout`, NOT `blur`, and the difference is the whole whole-card case.\n   *\n   * `blur` does not bubble, so an element that is a drag SOURCE without being\n   * the focused control — a card whose own button holds focus — never hears\n   * about focus leaving it. The keyboard drag would then survive a Tab away,\n   * which is the trap this handler exists to prevent, on exactly the surface\n   * where the trap is easiest to fall into.\n   *\n   * `focusout` bubbles, so it covers both shapes. `relatedTarget` is where\n   * focus WENT: still inside this element means focus moved between the card's\n   * own controls and the drag is not over.\n   */\n  function onFocusOut(e: FocusEvent): void {\n    if (!carrying()) return;\n    const next = e.relatedTarget;\n    if (next instanceof Node && element.contains(next)) return;\n    session.cancel();\n  }\n\n  element.addEventListener(\"keydown\", onKeyDown);\n  element.addEventListener(\"focusout\", onFocusOut);\n\n  return () => {\n    element.removeEventListener(\"keydown\", onKeyDown);\n    element.removeEventListener(\"focusout\", onFocusOut);\n  };\n}\n"],"names":["ALONG","ACROSS","attachKeyboardSensor","session","element","options","axis","carrying","s","onKeyDown","e","along","across","onFocusOut","next"],"mappings":"AAiDA,MAAMA,IAAkD;AAAA,EACtD,GAAG,EAAE,SAAS,IAAI,WAAW,EAAA;AAAA,EAC7B,GAAG,EAAE,WAAW,IAAI,YAAY,EAAA;AAClC,GAGMC,IAAmD;AAAA,EACvD,GAAG,EAAE,WAAW,IAAI,YAAY,EAAA;AAAA,EAChC,GAAG,EAAE,SAAS,IAAI,WAAW,EAAA;AAC/B;AAUO,SAASC,EACdC,GACAC,GACAC,GACY;AACZ,QAAMC,IAAOD,EAAQ,QAAQ;AAG7B,WAASE,IAAoB;AAC3B,UAAMC,IAAIL,EAAQ,SAAA;AAClB,WAAOK,EAAE,UAAU,cAAcA,EAAE,SAAS,cAAcA,EAAE,OAAOH,EAAQ;AAAA,EAC7E;AAEA,WAASI,EAAUC,GAAwB;AAIzC,QAAIA,EAAE,UAAUA,EAAE,WAAWA,EAAE,QAAS;AAExC,QAAIA,EAAE,QAAQ,OAAOA,EAAE,QAAQ,SAAS;AAItC,UAAIA,EAAE,OAAQ;AACd,UAAIH,KAAY;AACd,QAAAG,EAAE,eAAA,GACFP,EAAQ,OAAA;AACR;AAAA,MACF;AAgBA,UAfIA,EAAQ,WAAW,UAAU,UAa7BO,EAAE,QAAQ,WAAWA,EAAE,WAAWN,KAClCC,EAAQ,YAAY,CAACA,EAAQ,SAASK,CAAC,KACvC,CAACP,EAAQ,MAAM,EAAE,IAAIE,EAAQ,IAAI,MAAM,WAAA,CAAY,EAAG;AAI1D,MAAAK,EAAE,eAAA;AACF;AAAA,IACF;AAOA,QAAI,CAACH,IAAY;AAEjB,UAAMI,IAAQX,EAAMM,CAAI,EAAEI,EAAE,GAAG;AAC/B,QAAIC,MAAU,QAAW;AACvB,MAAAD,EAAE,eAAA,GACFP,EAAQ,UAAUQ,CAAK;AACvB;AAAA,IACF;AACA,UAAMC,IAASX,EAAOK,CAAI,EAAEI,EAAE,GAAG;AACjC,IAAIE,MAAW,WACbF,EAAE,eAAA,GACFP,EAAQ,cAAcS,CAAM;AAAA,EAEhC;AAsBA,WAASC,EAAWH,GAAqB;AACvC,QAAI,CAACH,IAAY;AACjB,UAAMO,IAAOJ,EAAE;AACf,IAAII,aAAgB,QAAQV,EAAQ,SAASU,CAAI,KACjDX,EAAQ,OAAA;AAAA,EACV;AAEA,SAAAC,EAAQ,iBAAiB,WAAWK,CAAS,GAC7CL,EAAQ,iBAAiB,YAAYS,CAAU,GAExC,MAAM;AACX,IAAAT,EAAQ,oBAAoB,WAAWK,CAAS,GAChDL,EAAQ,oBAAoB,YAAYS,CAAU;AAAA,EACpD;AACF;"}

package/dist/lib/dnd/sensors/pointer.js

@@ -0,0 +1,32 @@
+import { attachPointerGesture as i } from "./gesture.js";
+function c(e, r, t) {
+  return i(
+    r,
+    {
+      onPress: (n, a) => t.canStart && !t.canStart(a) ? !1 : e.start({ id: t.id, mode: "pointer", point: n, pending: !0 }),
+      onActivate: () => e.activate(),
+      onMove: (n) => e.moveTo(n),
+      onRelease: (n, a) => {
+        e.getState().phase !== "idle" && (e.moveTo(n), e.commit());
+      },
+      onCancel: () => e.cancel()
+    },
+    { activation: t.activation }
+  );
+}
+function d(e) {
+  function r(n) {
+    n.key === "Escape" && e.getState().phase !== "idle" && (n.preventDefault(), e.cancel());
+  }
+  function t() {
+    e.getState().phase === "dragging" && e.remeasure();
+  }
+  return window.addEventListener("keydown", r), window.addEventListener("scroll", t, !0), window.addEventListener("resize", t), () => {
+    window.removeEventListener("keydown", r), window.removeEventListener("scroll", t, !0), window.removeEventListener("resize", t);
+  };
+}
+export {
+  c as attachPointerSensor,
+  d as attachSessionWindowListeners
+};
+//# sourceMappingURL=pointer.js.map

package/dist/lib/dnd/sensors/pointer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.js","sources":["../../../../src/lib/dnd/sensors/pointer.ts"],"sourcesContent":["import type { DragSession } from \"../session\";\nimport type { DragId } from \"../types\";\nimport { attachPointerGesture, type PointerActivation } from \"./gesture\";\n\n/**\n * The pointer sensor. One listener set for mouse, touch and pen.\n *\n * ACTIVATION IS THE WHOLE PROBLEM. Starting the drag on `pointerdown` is what\n * makes a drag list unusable: a tap becomes a drag, and on a phone a swipe that\n * was meant to scroll the column picks a card up instead. So a pointer is held\n * in `pending` until it proves itself, and the proof differs by input type:\n *\n *   - MOUSE and PEN have a cursor, so intent is expressed by MOVING. A few\n *     pixels of travel is unambiguous and instant, and a click never reaches it.\n *   - TOUCH has no cursor and movement is how you scroll, so movement cannot be\n *     the signal. Intent is expressed by DWELLING — the long press — and any\n *     travel beyond a small tolerance before the timer fires means the finger\n *     was scrolling and the session must be abandoned.\n *\n * Getting that backwards is the single most common defect in drag lists, and it\n * only shows up on a device the author was not testing on.\n *\n * AND THE DWELL IS ONLY HALF OF THE TOUCH ANSWER. The activation constraint\n * decides whether WE start a drag; it says nothing about whether the BROWSER\n * starts a scroll, and the browser decides that from `touch-action` alone,\n * before any of this code runs. `touch-action: none` on the handle is therefore\n * the tempting fix and it re-creates the failure it was meant to prevent, just\n * on a smaller target: every swipe that happens to begin on the grip is eaten,\n * the column does not move, and the list feels stuck at random.\n *\n * The handle is `touch-action: pan-y` instead (`pan-x` for a horizontal list),\n * so the browser scrolls exactly as it would on any other element, and the\n * drag takes the gesture back at the moment it activates by cancelling\n * `touchmove` — see `beginTouchScrollGuard`. That ordering is what makes both\n * true on the SAME element: a swipe scrolls, a press picks up.\n */\n\n/* The activation constants and every line of DOM handling now live in\n   `gesture.ts`, because the calendar needs exactly the same input layer with a\n   completely different target model. See that file's header for the split; what\n   remains here is the adapter that turns a gesture into a `DragSession`. */\nexport type { PointerActivation } from \"./gesture\";\n\nexport interface PointerSensorOptions {\n  id: DragId;\n  activation?: PointerActivation;\n  /** Return false to refuse the gesture — a disabled row, or a click on a button inside the card. */\n  canStart?: (e: PointerEvent) => boolean;\n}\n\n/**\n * Wire an element as a drag handle for a list `DragSession`.\n *\n * A THIN ADAPTER, deliberately. The session's four verbs map one-to-one onto\n * the gesture's callbacks, and the only real logic left is the `pending`\n * start — the session is told about the press immediately so it can refuse the\n * item, and only activated once the constraint is met.\n */\nexport function attachPointerSensor(\n  session: DragSession,\n  element: HTMLElement,\n  options: PointerSensorOptions,\n): () => void {\n  return attachPointerGesture(\n    element,\n    {\n      onPress: (point, event) => {\n        if (options.canStart && !options.canStart(event)) return false;\n        /* `pending` — the session knows a press is in flight and may refuse\n           the item outright, but nothing has moved yet. */\n        return session.start({ id: options.id, mode: \"pointer\", point, pending: true });\n      },\n      onActivate: () => session.activate(),\n      onMove: (point) => session.moveTo(point),\n      onRelease: (point, activated) => {\n        /* A release without activation is a click. `commit` is called either\n           way — it knows to discard a no-op — so a consumer counting sessions\n           sees one ENDING rather than one aborting. */\n        void activated;\n        if (session.getState().phase === \"idle\") return;\n        /* THE RELEASE POINT IS FED IN BEFORE THE COMMIT, and it used to be\n           discarded. `commit()` takes no point: it lands the card wherever the\n           last `moveTo` left `over`, on the reasonable assumption that a\n           `pointermove` arrived at the release position first. That assumption\n           is not free. `pointerup` can carry a position no `pointermove`\n           reported — a touch that lifts while travelling, a coalesced burst\n           truncated at the end, a synthesised release — and the card then lands\n           where the pointer WAS rather than where it was let go. Cheap to\n           remove as a class of doubt: one more resolve against a snapshot that\n           is already current, and `moveTo` is a no-op when the target has not\n           changed, which is the usual case. */\n        session.moveTo(point);\n        session.commit();\n      },\n      onCancel: () => session.cancel(),\n    },\n    { activation: options.activation },\n  );\n}\n\n/**\n * Esc, and the two things that move a box while a drag is in flight.\n *\n * Window-level because a keypress during a drag does not go to the handle — the\n * handle has pointer capture, not focus — and because a scroll of an ancestor\n * invalidates every rect in the snapshot at once.\n */\nexport function attachSessionWindowListeners(session: DragSession): () => void {\n  function onKeyDown(e: KeyboardEvent): void {\n    if (e.key !== \"Escape\") return;\n    if (session.getState().phase === \"idle\") return;\n    e.preventDefault();\n    session.cancel();\n  }\n  function onLayoutShift(): void {\n    if (session.getState().phase !== \"dragging\") return;\n    session.remeasure();\n  }\n  window.addEventListener(\"keydown\", onKeyDown);\n  /* Capture, because a scroll inside a column does not bubble to the window. */\n  window.addEventListener(\"scroll\", onLayoutShift, true);\n  window.addEventListener(\"resize\", onLayoutShift);\n  return () => {\n    window.removeEventListener(\"keydown\", onKeyDown);\n    window.removeEventListener(\"scroll\", onLayoutShift, true);\n    window.removeEventListener(\"resize\", onLayoutShift);\n  };\n}\n"],"names":["attachPointerSensor","session","element","options","attachPointerGesture","point","event","activated","attachSessionWindowListeners","onKeyDown","e","onLayoutShift"],"mappings":";AA0DO,SAASA,EACdC,GACAC,GACAC,GACY;AACZ,SAAOC;AAAA,IACLF;AAAA,IACA;AAAA,MACE,SAAS,CAACG,GAAOC,MACXH,EAAQ,YAAY,CAACA,EAAQ,SAASG,CAAK,IAAU,KAGlDL,EAAQ,MAAM,EAAE,IAAIE,EAAQ,IAAI,MAAM,WAAW,OAAAE,GAAO,SAAS,GAAA,CAAM;AAAA,MAEhF,YAAY,MAAMJ,EAAQ,SAAA;AAAA,MAC1B,QAAQ,CAACI,MAAUJ,EAAQ,OAAOI,CAAK;AAAA,MACvC,WAAW,CAACA,GAAOE,MAAc;AAK/B,QAAIN,EAAQ,WAAW,UAAU,WAYjCA,EAAQ,OAAOI,CAAK,GACpBJ,EAAQ,OAAA;AAAA,MACV;AAAA,MACA,UAAU,MAAMA,EAAQ,OAAA;AAAA,IAAO;AAAA,IAEjC,EAAE,YAAYE,EAAQ,WAAA;AAAA,EAAW;AAErC;AASO,SAASK,EAA6BP,GAAkC;AAC7E,WAASQ,EAAUC,GAAwB;AACzC,IAAIA,EAAE,QAAQ,YACVT,EAAQ,WAAW,UAAU,WACjCS,EAAE,eAAA,GACFT,EAAQ,OAAA;AAAA,EACV;AACA,WAASU,IAAsB;AAC7B,IAAIV,EAAQ,WAAW,UAAU,cACjCA,EAAQ,UAAA;AAAA,EACV;AACA,gBAAO,iBAAiB,WAAWQ,CAAS,GAE5C,OAAO,iBAAiB,UAAUE,GAAe,EAAI,GACrD,OAAO,iBAAiB,UAAUA,CAAa,GACxC,MAAM;AACX,WAAO,oBAAoB,WAAWF,CAAS,GAC/C,OAAO,oBAAoB,UAAUE,GAAe,EAAI,GACxD,OAAO,oBAAoB,UAAUA,CAAa;AAAA,EACpD;AACF;"}