@n-uf/motion 26.11.2 → 26.11.4

package/dist/chunk-WQQ2E25M.js

@@ -0,0 +1,212 @@
+// src/shapes.ts
+var SCALAR = 0;
+var VECTOR = 1;
+var POINT = 2;
+var RECT = 3;
+var SCALAR_LAYOUT = { kind: SCALAR, size: 1 };
+var POINT_LAYOUT = { kind: POINT, size: 2 };
+var RECT_LAYOUT = { kind: RECT, size: 4 };
+function layoutOf(value) {
+  if (typeof value === "number") return SCALAR_LAYOUT;
+  if (Array.isArray(value)) return { kind: VECTOR, size: value.length };
+  if ("width" in value) return RECT_LAYOUT;
+  return POINT_LAYOUT;
+}
+function sameLayout(a, b) {
+  return a.kind === b.kind && a.size === b.size;
+}
+function writeComponents(value, out) {
+  if (typeof value === "number") {
+    out[0] = value;
+  } else if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) out[i] = value[i];
+  } else if ("width" in value) {
+    out[0] = value.x;
+    out[1] = value.y;
+    out[2] = value.width;
+    out[3] = value.height;
+  } else {
+    const point = value;
+    out[0] = point.x;
+    out[1] = point.y;
+  }
+}
+function makeValue(layout, components) {
+  switch (layout.kind) {
+    case SCALAR:
+      return components[0];
+    case POINT:
+      return { x: components[0], y: components[1] };
+    case RECT:
+      return { x: components[0], y: components[1], width: components[2], height: components[3] };
+    default:
+      return Array.from(components);
+  }
+}
+function shapeEquals(a, b) {
+  if (typeof a === "number" || typeof b === "number") return a === b;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    const u = a;
+    const v = b;
+    if (u.length !== v.length) return false;
+    for (let i = 0; i < u.length; i++) if (u[i] !== v[i]) return false;
+    return true;
+  }
+  const p = a;
+  const q = b;
+  return p.x === q.x && p.y === q.y && p.width === q.width && p.height === q.height;
+}
+
+// src/values/settle.ts
+var SETTLE_TEMPO = { calm: 20, default: 25, quick: 37 };
+var SETTLE_DEFAULTS = { omega: SETTLE_TEMPO.default, restDelta: 0.1 };
+function positive(name, value) {
+  if (!(value > 0) || !Number.isFinite(value)) throw new RangeError(`settle: ${name} must be a finite number > 0, got ${value}`);
+  return value;
+}
+var SettleAnimator = class {
+  layout;
+  x;
+  v;
+  goal;
+  omega;
+  restDelta;
+  settled = true;
+  cachedValue = null;
+  constructor(initial, config) {
+    this.layout = layoutOf(initial);
+    this.x = new Float64Array(this.layout.size);
+    this.v = new Float64Array(this.layout.size);
+    this.goal = new Float64Array(this.layout.size);
+    writeComponents(initial, this.x);
+    writeComponents(initial, this.goal);
+    this.omega = positive("omega", config.omega ?? SETTLE_DEFAULTS.omega);
+    this.restDelta = positive("restDelta", config.restDelta ?? SETTLE_DEFAULTS.restDelta);
+  }
+  get value() {
+    if (this.cachedValue === null) this.cachedValue = makeValue(this.layout, this.x);
+    return this.cachedValue;
+  }
+  get velocity() {
+    return makeValue(this.layout, this.v);
+  }
+  get target() {
+    return makeValue(this.layout, this.goal);
+  }
+  check(value, what) {
+    if (!sameLayout(layoutOf(value), this.layout)) {
+      throw new TypeError(`settle: ${what} has a different shape than the settle's value`);
+    }
+  }
+  /** The launch/clamp/carry rule on component `i`: `launch` for a new target, else clamp or carry. */
+  rule(i, launch) {
+    const d = this.x[i] - this.goal[i];
+    const v = this.v[i];
+    const limit = d === 0 ? 0 : -this.omega * d;
+    if (launch) {
+      this.v[i] = limit;
+      return;
+    }
+    if (d === 0) return;
+    if (d * v > 0) return;
+    if (Math.abs(v) > Math.abs(limit)) this.v[i] = limit;
+  }
+  updateSettled() {
+    for (let i = 0; i < this.x.length; i++) {
+      if (this.x[i] !== this.goal[i] || this.v[i] !== 0) {
+        this.settled = false;
+        return;
+      }
+    }
+    this.settled = true;
+  }
+  setTarget(target) {
+    this.check(target, "the target");
+    writeComponents(target, this.goal);
+    for (let i = 0; i < this.x.length; i++) this.rule(i, true);
+    this.updateSettled();
+  }
+  setVelocity(velocity) {
+    this.check(velocity, "the velocity");
+    writeComponents(velocity, this.v);
+    for (let i = 0; i < this.x.length; i++) this.rule(i, false);
+    this.updateSettled();
+  }
+  jumpTo(value) {
+    this.check(value, "the value");
+    writeComponents(value, this.x);
+    writeComponents(value, this.goal);
+    this.v.fill(0);
+    this.cachedValue = null;
+    this.settled = true;
+  }
+  hold(value) {
+    this.jumpTo(value);
+  }
+  snap() {
+    this.x.set(this.goal);
+    this.v.fill(0);
+    this.cachedValue = null;
+    this.settled = true;
+  }
+  configure(config) {
+    if (config.omega !== void 0) this.omega = positive("omega", config.omega);
+    if (config.restDelta !== void 0) this.restDelta = positive("restDelta", config.restDelta);
+    for (let i = 0; i < this.x.length; i++) this.rule(i, false);
+  }
+  step(dtMs) {
+    if (this.settled) return false;
+    if (!(dtMs > 0)) return true;
+    const w = this.omega;
+    const t = dtMs / 1e3;
+    const e = Math.exp(-w * t);
+    const { x, v, goal, restDelta } = this;
+    const restSpeed = w * restDelta * 1.000001;
+    let resting = true;
+    for (let i = 0; i < x.length; i++) {
+      const d = x[i] - goal[i];
+      const b = v[i] + w * d;
+      const nd = e * (d + b * t);
+      v[i] = e * (v[i] - w * b * t);
+      x[i] = goal[i] + nd;
+      const near = Math.max(restDelta, 4 * Number.EPSILON * Math.abs(goal[i]));
+      if (resting && (Math.abs(nd) > near || Math.abs(v[i]) > Math.max(restSpeed, w * near))) resting = false;
+    }
+    this.cachedValue = null;
+    if (resting) this.snap();
+    return !this.settled;
+  }
+};
+function createSettle(initial, config = {}) {
+  return new SettleAnimator(initial, config);
+}
+
+// src/values/reveal.ts
+function reveal(drawn, target) {
+  return {
+    dx: drawn.x - target.x,
+    dy: drawn.y - target.y,
+    width: Math.max(0, drawn.width),
+    height: Math.max(0, drawn.height),
+    clipRight: Math.max(0, target.width - drawn.width),
+    clipBottom: Math.max(0, target.height - drawn.height)
+  };
+}
+function popIn(progress, from = 0.87) {
+  const p = Math.min(1, Math.max(0, progress));
+  return { scale: from + (1 - from) * p, opacity: p };
+}
+
+export {
+  layoutOf,
+  sameLayout,
+  writeComponents,
+  makeValue,
+  shapeEquals,
+  SETTLE_TEMPO,
+  SETTLE_DEFAULTS,
+  createSettle,
+  reveal,
+  popIn
+};
+//# sourceMappingURL=chunk-WQQ2E25M.js.map

package/dist/chunk-WQQ2E25M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shapes.ts","../src/values/settle.ts","../src/values/reveal.ts"],"sourcesContent":["/** A point or a 2D vector. */\nexport interface Point {\n  x: number;\n  y: number;\n}\n\n/** An axis-aligned rectangle. */\nexport interface Rect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Any number of components. */\nexport type Vector = readonly number[];\n\n/** The value shapes springs and tweens move: plain numbers, nothing else. */\nexport type Animatable = number | Point | Rect | Vector;\n\n/** The shape type of an {@link Animatable}: literal numbers widen to `number`. */\nexport type Widen<T> = T extends number\n  ? number\n  : T extends Vector\n    ? Vector\n    : T extends Rect\n      ? Rect\n      : T extends Point\n        ? Point\n        : never;\n\nconst SCALAR = 0;\nconst VECTOR = 1;\nconst POINT = 2;\nconst RECT = 3;\n\n/** How a shape maps onto a flat list of numbers. Internal to values/. */\nexport interface Layout {\n  readonly kind: typeof SCALAR | typeof VECTOR | typeof POINT | typeof RECT;\n  readonly size: number;\n}\n\nconst SCALAR_LAYOUT: Layout = { kind: SCALAR, size: 1 };\nconst POINT_LAYOUT: Layout = { kind: POINT, size: 2 };\nconst RECT_LAYOUT: Layout = { kind: RECT, size: 4 };\n\nexport function layoutOf(value: Animatable): Layout {\n  if (typeof value === \"number\") return SCALAR_LAYOUT;\n  if (Array.isArray(value)) return { kind: VECTOR, size: value.length };\n  if (\"width\" in value) return RECT_LAYOUT;\n  return POINT_LAYOUT;\n}\n\nexport function sameLayout(a: Layout, b: Layout): boolean {\n  return a.kind === b.kind && a.size === b.size;\n}\n\n/** Copy `value`'s components into `out`. */\nexport function writeComponents(value: Animatable, out: Float64Array): void {\n  if (typeof value === \"number\") {\n    out[0] = value;\n  } else if (Array.isArray(value)) {\n    for (let i = 0; i < value.length; i++) out[i] = value[i]!;\n  } else if (\"width\" in value) {\n    out[0] = value.x;\n    out[1] = value.y;\n    out[2] = value.width;\n    out[3] = value.height;\n  } else {\n    const point = value as Point;\n    out[0] = point.x;\n    out[1] = point.y;\n  }\n}\n\n/** A fresh value of `layout`'s shape from `components`. */\nexport function makeValue(layout: Layout, components: Float64Array): Animatable {\n  switch (layout.kind) {\n    case SCALAR:\n      return components[0]!;\n    case POINT:\n      return { x: components[0]!, y: components[1]! };\n    case RECT:\n      return { x: components[0]!, y: components[1]!, width: components[2]!, height: components[3]! };\n    default:\n      return Array.from(components);\n  }\n}\n\n/** Component-wise equality of two values of the same shape. */\nexport function shapeEquals(a: Animatable, b: Animatable): boolean {\n  if (typeof a === \"number\" || typeof b === \"number\") return a === b;\n  if (Array.isArray(a) || Array.isArray(b)) {\n    const u = a as Vector;\n    const v = b as Vector;\n    if (u.length !== v.length) return false;\n    for (let i = 0; i < u.length; i++) if (u[i] !== v[i]) return false;\n    return true;\n  }\n  const p = a as Partial<Rect>;\n  const q = b as Partial<Rect>;\n  return p.x === q.x && p.y === q.y && p.width === q.width && p.height === q.height;\n}\n","import type { Animatable, Layout, Widen } from \"../shapes\";\nimport { layoutOf, makeValue, sameLayout, writeComponents } from \"../shapes\";\nimport type { Animator } from \"./animator\";\n\n/**\n * Tempos for {@link createSettle}, in 1/s: a settle covers 90 % of the way in\n * ln(10)/omega seconds and is within 1 % in twice that.\n *\n * - `calm` 20: 90 % in 115 ms, done in 230 ms.\n * - `default` 25: 90 % in 92 ms, done in 184 ms.\n * - `quick` 37: 90 % in 62 ms, done in 124 ms (a fast Hyprland setup).\n */\nexport const SETTLE_TEMPO = { calm: 20, default: 25, quick: 37 } as const;\n\n/** Settings of {@link createSettle}. */\nexport interface SettleConfig {\n  /** The tempo in 1/s (see {@link SETTLE_TEMPO}). Higher is faster. Default 25. */\n  readonly omega?: number;\n  /** Distance from the target that counts as arrived. Default 0.1 (tuned for pixels). */\n  readonly restDelta?: number;\n}\n\n/**\n * The one curve for things that move to a new place: a window's rect between\n * layout targets, a drawer, a camera. Fast at the start, gentle at the end,\n * and it never passes its target.\n *\n * It is a critically damped spring (stiffness omega², damping 2·omega) with\n * one rule on its velocity, per component:\n *\n * - **Launch.** On a new target, each component gets the velocity\n *   omega · distance toward it, from wherever it is drawn: standing still,\n *   moving toward it, or moving away (it turns at once rather than drifting\n *   further first). From there the spring follows `distance · e^(−omega·t)`\n *   exactly: most of the move happens at once, the rest eases in.\n * - **Clamp.** That speed is also the most it may have toward the target, so a\n *   velocity set by hand (`setVelocity`, a fling) toward the target is capped\n *   there instead of shooting past.\n * - **Carry.** A velocity set by hand away from the target is kept, and the\n *   value turns around; a critically damped spring turning around never\n *   crosses the target either.\n *\n * So after a new target every component goes straight from where it is drawn\n * to the target and never past it: no overshoot on position, no wobble on\n * size, whatever the retargets. A new target starts from the drawn value,\n * never from the old start.\n *\n * Holding (a pointer owns the value): call `hold(value)` on each move. The\n * value sits exactly there, at rest; the next `setTarget` launches from it.\n */\nexport interface Settle<T> extends Animator<T> {\n  /** The tempo in 1/s. */\n  readonly omega: number;\n  /** Put the value at `value`, at rest, with it as the target: a held value follows its owner 1:1. Same as `jumpTo`. */\n  hold(value: T): void;\n  /** Set the velocity (units per second); a component moving toward the target is clamped as in the launch rule. */\n  setVelocity(velocity: T): void;\n  /** Change the tempo or rest distance mid-flight; the value and velocity carry on, re-clamped. */\n  configure(config: SettleConfig): void;\n}\n\n/** Defaults of {@link SettleConfig}. */\nexport const SETTLE_DEFAULTS = { omega: SETTLE_TEMPO.default, restDelta: 0.1 } as const;\n\nfunction positive(name: string, value: number): number {\n  if (!(value > 0) || !Number.isFinite(value)) throw new RangeError(`settle: ${name} must be a finite number > 0, got ${value}`);\n  return value;\n}\n\nclass SettleAnimator implements Settle<Animatable> {\n  readonly layout: Layout;\n  readonly x: Float64Array;\n  readonly v: Float64Array;\n  readonly goal: Float64Array;\n  omega: number;\n  restDelta: number;\n  settled = true;\n  cachedValue: Animatable | null = null;\n\n  constructor(initial: Animatable, config: SettleConfig) {\n    this.layout = layoutOf(initial);\n    this.x = new Float64Array(this.layout.size);\n    this.v = new Float64Array(this.layout.size);\n    this.goal = new Float64Array(this.layout.size);\n    writeComponents(initial, this.x);\n    writeComponents(initial, this.goal);\n    this.omega = positive(\"omega\", config.omega ?? SETTLE_DEFAULTS.omega);\n    this.restDelta = positive(\"restDelta\", config.restDelta ?? SETTLE_DEFAULTS.restDelta);\n  }\n\n  get value(): Animatable {\n    if (this.cachedValue === null) this.cachedValue = makeValue(this.layout, this.x);\n    return this.cachedValue;\n  }\n\n  get velocity(): Animatable {\n    return makeValue(this.layout, this.v);\n  }\n\n  get target(): Animatable {\n    return makeValue(this.layout, this.goal);\n  }\n\n  check(value: Animatable, what: string): void {\n    if (!sameLayout(layoutOf(value), this.layout)) {\n      throw new TypeError(`settle: ${what} has a different shape than the settle's value`);\n    }\n  }\n\n  /** The launch/clamp/carry rule on component `i`: `launch` for a new target, else clamp or carry. */\n  rule(i: number, launch: boolean): void {\n    const d = this.x[i]! - this.goal[i]!;\n    const v = this.v[i]!;\n    const limit = d === 0 ? 0 : -this.omega * d;\n    if (launch) {\n      this.v[i] = limit;\n      return;\n    }\n    if (d === 0) return;\n    // Moving away from the target (d and v the same sign): carry.\n    if (d * v > 0) return;\n    // Moving toward it: no faster than a launch from here.\n    if (Math.abs(v) > Math.abs(limit)) this.v[i] = limit;\n  }\n\n  updateSettled(): void {\n    for (let i = 0; i < this.x.length; i++) {\n      if (this.x[i] !== this.goal[i] || this.v[i] !== 0) {\n        this.settled = false;\n        return;\n      }\n    }\n    this.settled = true;\n  }\n\n  setTarget(target: Animatable): void {\n    this.check(target, \"the target\");\n    writeComponents(target, this.goal);\n    for (let i = 0; i < this.x.length; i++) this.rule(i, true);\n    this.updateSettled();\n  }\n\n  setVelocity(velocity: Animatable): void {\n    this.check(velocity, \"the velocity\");\n    writeComponents(velocity, this.v);\n    for (let i = 0; i < this.x.length; i++) this.rule(i, false);\n    this.updateSettled();\n  }\n\n  jumpTo(value: Animatable): void {\n    this.check(value, \"the value\");\n    writeComponents(value, this.x);\n    writeComponents(value, this.goal);\n    this.v.fill(0);\n    this.cachedValue = null;\n    this.settled = true;\n  }\n\n  hold(value: Animatable): void {\n    this.jumpTo(value);\n  }\n\n  snap(): void {\n    this.x.set(this.goal);\n    this.v.fill(0);\n    this.cachedValue = null;\n    this.settled = true;\n  }\n\n  configure(config: SettleConfig): void {\n    if (config.omega !== undefined) this.omega = positive(\"omega\", config.omega);\n    if (config.restDelta !== undefined) this.restDelta = positive(\"restDelta\", config.restDelta);\n    for (let i = 0; i < this.x.length; i++) this.rule(i, false);\n  }\n\n  step(dtMs: number): boolean {\n    if (this.settled) return false;\n    if (!(dtMs > 0)) return true;\n    const w = this.omega;\n    const t = dtMs / 1000;\n    const e = Math.exp(-w * t);\n    const { x, v, goal, restDelta } = this;\n    // At rest when every component is within restDelta and no faster than a launch from there would be.\n    const restSpeed = w * restDelta * 1.000001;\n    let resting = true;\n    for (let i = 0; i < x.length; i++) {\n      // The exact critically damped step: d(t) = e^(−wt)·(d + b·t), b = v + w·d.\n      const d = x[i]! - goal[i]!;\n      const b = v[i]! + w * d;\n      const nd = e * (d + b * t);\n      v[i] = e * (v[i]! - w * b * t);\n      x[i] = goal[i]! + nd;\n      // Within a few float steps of the goal counts as arrived too: a restDelta finer than that would never be met.\n      const near = Math.max(restDelta, 4 * Number.EPSILON * Math.abs(goal[i]!));\n      if (resting && (Math.abs(nd) > near || Math.abs(v[i]!) > Math.max(restSpeed, w * near))) resting = false;\n    }\n    this.cachedValue = null;\n    if (resting) this.snap();\n    return !this.settled;\n  }\n}\n\n/**\n * A settle starting at rest on `initial` (a number, a vector, a point or a\n * rect; targets and velocities must have the same shape). See {@link Settle}.\n */\nexport function createSettle<T extends Animatable>(initial: T, config: SettleConfig = {}): Settle<Widen<T>> {\n  return new SettleAnimator(initial, config) as unknown as Settle<Widen<T>>;\n}\n","import type { Rect } from \"../shapes\";\n\n/**\n * How to draw a window whose rect is gliding without stretching its content.\n *\n * The content is laid out once at the target size and never scaled. The\n * window's element sits at its target in the layout; to draw it at the\n * gliding rect:\n *\n * - move the element by (`dx`, `dy`), so its top-left corner is the drawn rect's;\n * - draw the frame (background, border, shadow) at `width` × `height`: the drawn size;\n * - clip the content by `clipRight` and `clipBottom` so it fits a frame\n *   smaller than the target (CSS: `clip-path: inset(0 clipRight clipBottom 0)`).\n *\n * A window that shrinks shows a band of its own background closing in at the\n * right and bottom; one that grows reveals content already laid out at its\n * new size. Text is never stretched. One transform and one clip per frame, no\n * layout per frame.\n */\nexport interface RevealFrame {\n  /** Move the element (laid out at the target) right by this much. */\n  readonly dx: number;\n  /** Move the element (laid out at the target) down by this much. */\n  readonly dy: number;\n  /** The frame's width: the drawn rect's. */\n  readonly width: number;\n  /** The frame's height: the drawn rect's. */\n  readonly height: number;\n  /** Clip this much off the content's right edge (0 when the frame is at least as wide as the target). */\n  readonly clipRight: number;\n  /** Clip this much off the content's bottom edge (0 when the frame is at least as tall as the target). */\n  readonly clipBottom: number;\n}\n\n/** The {@link RevealFrame} for content laid out at `target` and drawn at `drawn`. */\nexport function reveal(drawn: Rect, target: Rect): RevealFrame {\n  return {\n    dx: drawn.x - target.x,\n    dy: drawn.y - target.y,\n    width: Math.max(0, drawn.width),\n    height: Math.max(0, drawn.height),\n    clipRight: Math.max(0, target.width - drawn.width),\n    clipBottom: Math.max(0, target.height - drawn.height),\n  };\n}\n\n/** A uniform pop-in (or pop-out, run backwards): scale about the centre and opacity. */\nexport interface PopIn {\n  /** Scale about the window's centre: the same on both axes, so nothing is stretched. */\n  readonly scale: number;\n  readonly opacity: number;\n}\n\n/**\n * Opening and closing: the window grows from `from` of its size to full, about\n * its centre, while fading in. `progress` runs 0 to 1 (take it from a settle\n * on a number with `{ restDelta: 0.001 }`, since the default 0.1 is tuned for\n * pixels and would snap the last 10 %; or from a tween); closing runs it from\n * 1 to 0. Hyprland's default is `popin 87%`.\n */\nexport function popIn(progress: number, from = 0.87): PopIn {\n  const p = Math.min(1, Math.max(0, progress));\n  return { scale: from + (1 - from) * p, opacity: p };\n}\n"],"mappings":"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","names":[]}

package/dist/drag.d.ts

@@ -0,0 +1,202 @@
+import { R as Rect, P as Point } from './shapes-EbQlwbCu.js';
+
+/**
+ * The drag intent model's tuning. Distances in px, speeds in px/ms, times in
+ * ms; every value can be overridden per intent (see
+ * {@link DragIntentOptions.tuning}).
+ */
+interface DragTuning {
+    /** A mouse press lifts once the pointer has moved this far. */
+    readonly lift: number;
+    /** A touch press lifts only after it has been held this long… */
+    readonly touchHold: number;
+    /** …and then moved this far (moving that far before the hold is over is not a drag). */
+    readonly touchLift: number;
+    /** The pointer's speed is measured over this window and smoothed. */
+    readonly speedWindow: number;
+    /** Aiming: the smoothed speed is below this… */
+    readonly aimSpeed: number;
+    /** …or the pointer has stayed within `still` px of one spot for `dwell` ms. */
+    readonly still: number;
+    readonly dwell: number;
+    /** The current target holds while the pointer is within this band of its zone. */
+    readonly band: number;
+    /** A higher-priority target takes over at once when the pointer is this far inside it. */
+    readonly breakthrough: number;
+    /** A gap between zones shorter than this keeps the current target (for a pointer that aims). */
+    readonly gapGrace: number;
+    /** Aiming, the shown target moves to another one only once that one has held this long. */
+    readonly switchHold: number;
+    /** Room is made once the shown target, and the place in it, have held this long. */
+    readonly roomAfter: number;
+    /** The pointer has left the item's home once it is outside the home shrunk by this much on every side. */
+    readonly homeInset: number;
+}
+/**
+ * The defaults: a mouse lifts after 5 px, a touch after a 180 ms hold and
+ * 8 px; aiming is slower than 0.45 px/ms over 50 ms, or within 12 px for
+ * 90 ms; a 10 px band, a 4 px breakthrough and a 120 ms gap grace; a switch
+ * waits 150 ms (the shortest an indicator may show); room after 160 ms.
+ */
+declare const DRAG_DEFAULTS: DragTuning;
+/**
+ * A drop target: plain data. `hit` is the zone the pointer can be in;
+ * `priority` how precise it is (1 beats 2 beats 3; equal priorities go to the
+ * smaller zone). `slot` is where the dragged item would land, `label` what to
+ * call it; the model reads neither. A `free` target has no slot (the item
+ * floats where it is dropped): no room is made for it.
+ */
+interface DragTarget {
+    readonly id: string;
+    readonly priority: 1 | 2 | 3;
+    readonly hit: Rect;
+    readonly slot?: Rect;
+    readonly label?: string;
+    readonly free?: boolean;
+}
+/** Whether `point` lies in `rect` grown by `margin` px on every side (shrunk, for a negative margin). */
+declare function inRect(rect: Rect, point: Point, margin?: number): boolean;
+/** The most precise target under `point`: the lowest priority number, then the smallest zone; null when none is. */
+declare function targetAt<T extends DragTarget>(targets: readonly T[], point: Point): T | null;
+/** What a press does so far: not yet a drag (`wait`), a drag (`lift`), or never one (`refuse`: a touch that moved too soon). */
+type LiftDecision = "wait" | "lift" | "refuse";
+/**
+ * The lift rule for a press that has moved `distance` px in `elapsed` ms. A
+ * mouse (or pen) lifts at `lift` px. A touch lifts only after `touchHold` ms,
+ * then at `touchLift` px; moving `touchLift` px before the hold is over
+ * refuses the drag (the finger is scrolling or swiping).
+ */
+declare function liftDecision(press: {
+    readonly touch: boolean;
+    readonly distance: number;
+    readonly elapsed: number;
+}, tuning?: Partial<DragTuning>): LiftDecision;
+/** One update's answer. */
+interface DragFrame<T extends DragTarget> {
+    /** The target the drop indicator shows, or null. */
+    readonly shown: T | null;
+    /** The others make room for the shown target: it, and the place in it, have held `roomAfter` ms. */
+    readonly room: boolean;
+    /**
+     * The place the room is made for, or null. Within one target it stays on
+     * the old place until a new one has held `roomAfter` ms (see
+     * {@link DragIntentOptions.placeOf}).
+     */
+    readonly roomPlace: string | null;
+    /** The pointer is aiming: slow, or nearly still for a moment. */
+    readonly aiming: boolean;
+}
+/** What a drag intent knows now. */
+interface DragIntentState<T extends DragTarget> {
+    /** The pointer's smoothed speed, px/ms. */
+    readonly speed: number;
+    /** The target under the pointer as the hysteresis holds it, or null. */
+    readonly current: T | null;
+    /** The target the indicator shows, or null. */
+    readonly shown: T | null;
+    /** The pointer has left the item's home. */
+    readonly leftHome: boolean;
+}
+interface DragIntentOptions<T extends DragTarget> {
+    /** Where the item was lifted from: the indicator stays off until the pointer leaves it, and a release there does nothing. */
+    readonly home: Rect;
+    /** Overrides of {@link DRAG_DEFAULTS}. */
+    readonly tuning?: Partial<DragTuning>;
+    /**
+     * The place within a target the pointer is at (a tab index, a stack
+     * position), unique across targets; default: the target's id. Moving between places of the
+     * shown target moves the indicator at once but the room only once the new
+     * place has held `roomAfter` ms.
+     */
+    readonly placeOf?: (target: T, point: Point) => string;
+}
+/** A drag's intent: feed it the pointer on every frame; it says what the indicator shows and what a release lands on. */
+interface DragIntent<T extends DragTarget> {
+    /**
+     * A pointer sample at `time` (ms), with the targets as they stand (they may
+     * be rebuilt between calls: the model follows them by id). Call it once a
+     * frame while the item is held, also when the pointer doesn't move: a
+     * dwell is time passing.
+     */
+    update(point: Point, time: number, targets: readonly T[]): DragFrame<T>;
+    /**
+     * What a release at `point` lands on: the shown target whenever one shows
+     * (a drop lands where the indicator was), else the target under the
+     * pointer, else null (the item goes home). A release over home is null: it
+     * does nothing. Feed the release point to `update` first, so a last jump
+     * of the pointer counts.
+     */
+    release(point: Point, targets: readonly T[]): T | null;
+    /**
+     * Hide the indicator (the view is scrolling under the pointer, say). The
+     * aim starts afresh: the next sample never counts as aiming, and a dwell
+     * starts again.
+     */
+    hide(time: number): void;
+    /** The item's home moved with the view (it scrolled) by (dx, dy). */
+    moveHome(dx: number, dy: number): void;
+    readonly state: DragIntentState<T>;
+    readonly tuning: DragTuning;
+}
+/**
+ * The drag intent model: when the drop indicator shows, which target it
+ * shows, when the others make room, and what a release lands on. Pure: fed
+ * pointer samples and plain-data targets, no DOM and no clock of its own.
+ *
+ * - The indicator shows only when the pointer has left the item's home, a
+ *   target is under it, and it is aiming (slow, or nearly still for a
+ *   moment). Time spent crossing a big target at speed doesn't count.
+ * - The most precise target wins (priority, then the smaller zone).
+ * - Hysteresis: the current target holds while the pointer is within `band`
+ *   px of its zone, unless a more precise one is clearly (`breakthrough` px)
+ *   under the pointer; for a pointer that aims, a short gap between zones
+ *   (`gapGrace` ms) keeps it too.
+ * - Leaving the shown target: flying, the indicator hides at once; aiming, it
+ *   moves to the new target once that has held `switchHold` ms (so no
+ *   indicator shows for less than that), at once for a breakthrough. A target
+ *   kept only by the gap grace can keep the indicator, never show it.
+ * - Room is made once the shown target has held `roomAfter` ms, never for a
+ *   free target, and closes at once when it changes.
+ */
+declare function createDragIntent<T extends DragTarget>(options: DragIntentOptions<T>): DragIntent<T>;
+
+/**
+ * How a drag previews its drop, from least to most motion while dragging:
+ *
+ * - `"indicator"`: nothing moves; only the indicator (an outline or an
+ *   insertion marker) shows the target.
+ * - `"gap"`: once the room is made, the others move aside and open the slot;
+ *   the item stays under the pointer.
+ * - `"snap"`: the gap opens and the item itself glides into it (for a target
+ *   with a slot; one without keeps the indicator).
+ *
+ * Every mode follows the same intent: what shows, when, and what a release
+ * lands on are the drag intent's, so a drop always lands where the preview
+ * showed it.
+ */
+type DragPreview = "indicator" | "gap" | "snap";
+/** The preview a drag uses unless the host picks another. */
+declare const DRAG_PREVIEW_DEFAULT: DragPreview;
+/** What to draw for one frame of a drag. */
+interface PreviewPlan {
+    /** Draw the indicator on the shown target. */
+    readonly showIndicator: boolean;
+    /** Lay the others out around the room (the gap is open). */
+    readonly makeRoom: boolean;
+    /** Draw the item in its slot instead of under the pointer. */
+    readonly snapItem: boolean;
+}
+/**
+ * The plan for a frame of the drag intent under `preview`. `slotted` says
+ * whether the shown target's drop has a slot the item can sit in (default: a
+ * target that isn't `free`); only such a target snaps, and in `"snap"` it
+ * previews with the item rather than the indicator.
+ *
+ * - `"indicator"`: the indicator, never room, never a snap.
+ * - `"gap"`: the indicator, and room when the intent makes it.
+ * - `"snap"`: room when the intent makes it, the item snapped into a slotted
+ *   target's room; the indicator only for a target without a slot.
+ */
+declare function previewPlan<T extends DragTarget>(frame: Pick<DragFrame<T>, "shown" | "room">, preview: DragPreview, slotted?: boolean): PreviewPlan;
+
+export { DRAG_DEFAULTS, DRAG_PREVIEW_DEFAULT, type DragFrame, type DragIntent, type DragIntentOptions, type DragIntentState, type DragPreview, type DragTarget, type DragTuning, type LiftDecision, type PreviewPlan, createDragIntent, inRect, liftDecision, previewPlan, targetAt };

package/dist/drag.js

@@ -0,0 +1,151 @@
+// src/drag/intent.ts
+var DRAG_DEFAULTS = {
+  lift: 5,
+  touchHold: 180,
+  touchLift: 8,
+  speedWindow: 50,
+  aimSpeed: 0.45,
+  still: 12,
+  dwell: 90,
+  band: 10,
+  breakthrough: 4,
+  gapGrace: 120,
+  switchHold: 150,
+  roomAfter: 160,
+  homeInset: 6
+};
+function inRect(rect, point, margin = 0) {
+  return point.x >= rect.x - margin && point.x <= rect.x + rect.width + margin && point.y >= rect.y - margin && point.y <= rect.y + rect.height + margin;
+}
+var area = (r) => r.width * r.height;
+function targetAt(targets, point) {
+  let best = null;
+  for (const t of targets) {
+    if (!inRect(t.hit, point)) continue;
+    if (!best || t.priority < best.priority || t.priority === best.priority && area(t.hit) < area(best.hit)) best = t;
+  }
+  return best;
+}
+function liftDecision(press, tuning = {}) {
+  const t = { ...DRAG_DEFAULTS, ...tuning };
+  if (!press.touch) return press.distance >= t.lift ? "lift" : "wait";
+  if (press.elapsed < t.touchHold) return press.distance >= t.touchLift ? "refuse" : "wait";
+  return press.distance >= t.touchLift ? "lift" : "wait";
+}
+function createDragIntent(options) {
+  const tuning = { ...DRAG_DEFAULTS, ...options.tuning };
+  const placeOf = options.placeOf ?? ((t) => t.id);
+  let home = { ...options.home };
+  let samples = [];
+  let cur = null;
+  let curSince = 0;
+  let lastInside = 0;
+  let shown = null;
+  let shownSince = 0;
+  let place = null;
+  let placeSince = 0;
+  let roomPlace = null;
+  let leftHome = false;
+  let speed = 0;
+  let anchor = null;
+  let stillSince = 0;
+  let restart = false;
+  const same = (a, b) => a === null || b === null ? a === b : a.id === b.id;
+  const follow = (t, targets) => t ? targets.find((x) => x.id === t.id) ?? t : null;
+  return {
+    tuning,
+    get state() {
+      return { speed, current: cur, shown, leftHome };
+    },
+    update(point, time, targets) {
+      const p = point;
+      const t = time;
+      samples.push({ x: p.x, y: p.y, t });
+      while (samples.length > 2 && t - samples[0].t > tuning.speedWindow) samples.shift();
+      const a = samples[0];
+      speed = speed * 0.5 + Math.hypot(p.x - a.x, p.y - a.y) / Math.max(1, t - a.t) * 0.5;
+      if (!anchor || Math.hypot(p.x - anchor.x, p.y - anchor.y) > tuning.still) {
+        anchor = { x: p.x, y: p.y };
+        stillSince = t;
+      }
+      if (!inRect(home, p, -tuning.homeInset)) leftHome = true;
+      const atHome = inRect(home, p);
+      const raw = atHome ? null : targetAt(targets, p);
+      cur = follow(cur, targets);
+      shown = follow(shown, targets);
+      let next = raw;
+      if (cur && !atHome && inRect(cur.hit, p, tuning.band)) {
+        const breaks = raw !== null && !same(raw, cur) && raw.priority < cur.priority && inRect(raw.hit, p, -tuning.breakthrough);
+        next = breaks ? raw : cur;
+      }
+      if (!next && cur && !atHome && t - lastInside < tuning.gapGrace) next = cur;
+      if (next && inRect(next.hit, p)) lastInside = t;
+      if (!same(next, cur)) curSince = t;
+      cur = next;
+      const aiming = !restart && (speed < tuning.aimSpeed || t - stillSince >= tuning.dwell);
+      restart = false;
+      const show = (s) => {
+        if (!same(s, shown)) shownSince = t;
+        shown = s;
+      };
+      const under = !!cur && inRect(cur.hit, p, tuning.band);
+      if (!shown) {
+        if (cur && under && leftHome && aiming) show(cur);
+      } else if (same(cur, shown)) {
+        if (!aiming && !under) show(null);
+        else shown = cur;
+      } else if (!cur || !aiming) {
+        show(null);
+      } else if (cur.priority < shown.priority && inRect(cur.hit, p, -tuning.breakthrough) || under && t - curSince >= tuning.switchHold) {
+        show(cur);
+      }
+      const at = shown ? placeOf(shown, p) : null;
+      if (at !== place) {
+        place = at;
+        placeSince = t;
+      }
+      if (!shown || shown.free) roomPlace = null;
+      else if (t - shownSince >= tuning.roomAfter && t - placeSince >= tuning.roomAfter) roomPlace = place;
+      else if (shownSince === t) roomPlace = null;
+      return { shown, room: roomPlace !== null, roomPlace, aiming };
+    },
+    release(point, targets) {
+      if (inRect(home, point)) return null;
+      const s = follow(shown, targets);
+      if (s) return s;
+      return targetAt(targets, point);
+    },
+    hide(time) {
+      shown = null;
+      cur = null;
+      shownSince = time;
+      place = null;
+      roomPlace = null;
+      samples = [];
+      anchor = null;
+      restart = true;
+    },
+    moveHome(dx, dy) {
+      home = { ...home, x: home.x + dx, y: home.y + dy };
+    }
+  };
+}
+
+// src/drag/preview.ts
+var DRAG_PREVIEW_DEFAULT = "snap";
+function previewPlan(frame, preview, slotted = !!frame.shown && !frame.shown.free) {
+  const shown = !!frame.shown;
+  if (preview === "indicator") return { showIndicator: shown, makeRoom: false, snapItem: false };
+  if (preview === "gap") return { showIndicator: shown, makeRoom: frame.room, snapItem: false };
+  return { showIndicator: shown && !slotted, makeRoom: frame.room, snapItem: frame.room && shown && slotted };
+}
+export {
+  DRAG_DEFAULTS,
+  DRAG_PREVIEW_DEFAULT,
+  createDragIntent,
+  inRect,
+  liftDecision,
+  previewPlan,
+  targetAt
+};
+//# sourceMappingURL=drag.js.map

package/dist/drag.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/drag/intent.ts","../src/drag/preview.ts"],"sourcesContent":["import type { Point, Rect } from \"../shapes\";\n\n/**\n * The drag intent model's tuning. Distances in px, speeds in px/ms, times in\n * ms; every value can be overridden per intent (see\n * {@link DragIntentOptions.tuning}).\n */\nexport interface DragTuning {\n  /** A mouse press lifts once the pointer has moved this far. */\n  readonly lift: number;\n  /** A touch press lifts only after it has been held this long… */\n  readonly touchHold: number;\n  /** …and then moved this far (moving that far before the hold is over is not a drag). */\n  readonly touchLift: number;\n  /** The pointer's speed is measured over this window and smoothed. */\n  readonly speedWindow: number;\n  /** Aiming: the smoothed speed is below this… */\n  readonly aimSpeed: number;\n  /** …or the pointer has stayed within `still` px of one spot for `dwell` ms. */\n  readonly still: number;\n  readonly dwell: number;\n  /** The current target holds while the pointer is within this band of its zone. */\n  readonly band: number;\n  /** A higher-priority target takes over at once when the pointer is this far inside it. */\n  readonly breakthrough: number;\n  /** A gap between zones shorter than this keeps the current target (for a pointer that aims). */\n  readonly gapGrace: number;\n  /** Aiming, the shown target moves to another one only once that one has held this long. */\n  readonly switchHold: number;\n  /** Room is made once the shown target, and the place in it, have held this long. */\n  readonly roomAfter: number;\n  /** The pointer has left the item's home once it is outside the home shrunk by this much on every side. */\n  readonly homeInset: number;\n}\n\n/**\n * The defaults: a mouse lifts after 5 px, a touch after a 180 ms hold and\n * 8 px; aiming is slower than 0.45 px/ms over 50 ms, or within 12 px for\n * 90 ms; a 10 px band, a 4 px breakthrough and a 120 ms gap grace; a switch\n * waits 150 ms (the shortest an indicator may show); room after 160 ms.\n */\nexport const DRAG_DEFAULTS: DragTuning = {\n  lift: 5,\n  touchHold: 180,\n  touchLift: 8,\n  speedWindow: 50,\n  aimSpeed: 0.45,\n  still: 12,\n  dwell: 90,\n  band: 10,\n  breakthrough: 4,\n  gapGrace: 120,\n  switchHold: 150,\n  roomAfter: 160,\n  homeInset: 6,\n};\n\n/**\n * A drop target: plain data. `hit` is the zone the pointer can be in;\n * `priority` how precise it is (1 beats 2 beats 3; equal priorities go to the\n * smaller zone). `slot` is where the dragged item would land, `label` what to\n * call it; the model reads neither. A `free` target has no slot (the item\n * floats where it is dropped): no room is made for it.\n */\nexport interface DragTarget {\n  readonly id: string;\n  readonly priority: 1 | 2 | 3;\n  readonly hit: Rect;\n  readonly slot?: Rect;\n  readonly label?: string;\n  readonly free?: boolean;\n}\n\n/** Whether `point` lies in `rect` grown by `margin` px on every side (shrunk, for a negative margin). */\nexport function inRect(rect: Rect, point: Point, margin = 0): boolean {\n  return point.x >= rect.x - margin && point.x <= rect.x + rect.width + margin && point.y >= rect.y - margin && point.y <= rect.y + rect.height + margin;\n}\n\nconst area = (r: Rect): number => r.width * r.height;\n\n/** The most precise target under `point`: the lowest priority number, then the smallest zone; null when none is. */\nexport function targetAt<T extends DragTarget>(targets: readonly T[], point: Point): T | null {\n  let best: T | null = null;\n  for (const t of targets) {\n    if (!inRect(t.hit, point)) continue;\n    if (!best || t.priority < best.priority || (t.priority === best.priority && area(t.hit) < area(best.hit))) best = t;\n  }\n  return best;\n}\n\n/** What a press does so far: not yet a drag (`wait`), a drag (`lift`), or never one (`refuse`: a touch that moved too soon). */\nexport type LiftDecision = \"wait\" | \"lift\" | \"refuse\";\n\n/**\n * The lift rule for a press that has moved `distance` px in `elapsed` ms. A\n * mouse (or pen) lifts at `lift` px. A touch lifts only after `touchHold` ms,\n * then at `touchLift` px; moving `touchLift` px before the hold is over\n * refuses the drag (the finger is scrolling or swiping).\n */\nexport function liftDecision(press: { readonly touch: boolean; readonly distance: number; readonly elapsed: number }, tuning: Partial<DragTuning> = {}): LiftDecision {\n  const t = { ...DRAG_DEFAULTS, ...tuning };\n  if (!press.touch) return press.distance >= t.lift ? \"lift\" : \"wait\";\n  if (press.elapsed < t.touchHold) return press.distance >= t.touchLift ? \"refuse\" : \"wait\";\n  return press.distance >= t.touchLift ? \"lift\" : \"wait\";\n}\n\n/** One update's answer. */\nexport interface DragFrame<T extends DragTarget> {\n  /** The target the drop indicator shows, or null. */\n  readonly shown: T | null;\n  /** The others make room for the shown target: it, and the place in it, have held `roomAfter` ms. */\n  readonly room: boolean;\n  /**\n   * The place the room is made for, or null. Within one target it stays on\n   * the old place until a new one has held `roomAfter` ms (see\n   * {@link DragIntentOptions.placeOf}).\n   */\n  readonly roomPlace: string | null;\n  /** The pointer is aiming: slow, or nearly still for a moment. */\n  readonly aiming: boolean;\n}\n\n/** What a drag intent knows now. */\nexport interface DragIntentState<T extends DragTarget> {\n  /** The pointer's smoothed speed, px/ms. */\n  readonly speed: number;\n  /** The target under the pointer as the hysteresis holds it, or null. */\n  readonly current: T | null;\n  /** The target the indicator shows, or null. */\n  readonly shown: T | null;\n  /** The pointer has left the item's home. */\n  readonly leftHome: boolean;\n}\n\nexport interface DragIntentOptions<T extends DragTarget> {\n  /** Where the item was lifted from: the indicator stays off until the pointer leaves it, and a release there does nothing. */\n  readonly home: Rect;\n  /** Overrides of {@link DRAG_DEFAULTS}. */\n  readonly tuning?: Partial<DragTuning>;\n  /**\n   * The place within a target the pointer is at (a tab index, a stack\n   * position), unique across targets; default: the target's id. Moving between places of the\n   * shown target moves the indicator at once but the room only once the new\n   * place has held `roomAfter` ms.\n   */\n  readonly placeOf?: (target: T, point: Point) => string;\n}\n\n/** A drag's intent: feed it the pointer on every frame; it says what the indicator shows and what a release lands on. */\nexport interface DragIntent<T extends DragTarget> {\n  /**\n   * A pointer sample at `time` (ms), with the targets as they stand (they may\n   * be rebuilt between calls: the model follows them by id). Call it once a\n   * frame while the item is held, also when the pointer doesn't move: a\n   * dwell is time passing.\n   */\n  update(point: Point, time: number, targets: readonly T[]): DragFrame<T>;\n  /**\n   * What a release at `point` lands on: the shown target whenever one shows\n   * (a drop lands where the indicator was), else the target under the\n   * pointer, else null (the item goes home). A release over home is null: it\n   * does nothing. Feed the release point to `update` first, so a last jump\n   * of the pointer counts.\n   */\n  release(point: Point, targets: readonly T[]): T | null;\n  /**\n   * Hide the indicator (the view is scrolling under the pointer, say). The\n   * aim starts afresh: the next sample never counts as aiming, and a dwell\n   * starts again.\n   */\n  hide(time: number): void;\n  /** The item's home moved with the view (it scrolled) by (dx, dy). */\n  moveHome(dx: number, dy: number): void;\n  readonly state: DragIntentState<T>;\n  readonly tuning: DragTuning;\n}\n\n/**\n * The drag intent model: when the drop indicator shows, which target it\n * shows, when the others make room, and what a release lands on. Pure: fed\n * pointer samples and plain-data targets, no DOM and no clock of its own.\n *\n * - The indicator shows only when the pointer has left the item's home, a\n *   target is under it, and it is aiming (slow, or nearly still for a\n *   moment). Time spent crossing a big target at speed doesn't count.\n * - The most precise target wins (priority, then the smaller zone).\n * - Hysteresis: the current target holds while the pointer is within `band`\n *   px of its zone, unless a more precise one is clearly (`breakthrough` px)\n *   under the pointer; for a pointer that aims, a short gap between zones\n *   (`gapGrace` ms) keeps it too.\n * - Leaving the shown target: flying, the indicator hides at once; aiming, it\n *   moves to the new target once that has held `switchHold` ms (so no\n *   indicator shows for less than that), at once for a breakthrough. A target\n *   kept only by the gap grace can keep the indicator, never show it.\n * - Room is made once the shown target has held `roomAfter` ms, never for a\n *   free target, and closes at once when it changes.\n */\nexport function createDragIntent<T extends DragTarget>(options: DragIntentOptions<T>): DragIntent<T> {\n  const tuning: DragTuning = { ...DRAG_DEFAULTS, ...options.tuning };\n  const placeOf = options.placeOf ?? ((t: T) => t.id);\n  let home: Rect = { ...options.home };\n  let samples: { x: number; y: number; t: number }[] = [];\n  let cur: T | null = null;\n  let curSince = 0;\n  let lastInside = 0;\n  let shown: T | null = null;\n  let shownSince = 0;\n  let place: string | null = null;\n  let placeSince = 0;\n  let roomPlace: string | null = null;\n  let leftHome = false;\n  let speed = 0;\n  let anchor: Point | null = null;\n  let stillSince = 0;\n  let restart = false;\n  const same = (a: T | null, b: T | null): boolean => (a === null || b === null ? a === b : a.id === b.id);\n  // Targets may be rebuilt between calls: follow the ones held by id.\n  const follow = (t: T | null, targets: readonly T[]): T | null => (t ? (targets.find((x) => x.id === t.id) ?? t) : null);\n\n  return {\n    tuning,\n    get state(): DragIntentState<T> {\n      return { speed, current: cur, shown, leftHome };\n    },\n    update(point, time, targets) {\n      const p = point;\n      const t = time;\n      samples.push({ x: p.x, y: p.y, t });\n      while (samples.length > 2 && t - samples[0]!.t > tuning.speedWindow) samples.shift();\n      const a = samples[0]!;\n      speed = speed * 0.5 + (Math.hypot(p.x - a.x, p.y - a.y) / Math.max(1, t - a.t)) * 0.5;\n      if (!anchor || Math.hypot(p.x - anchor.x, p.y - anchor.y) > tuning.still) {\n        anchor = { x: p.x, y: p.y };\n        stillSince = t;\n      }\n      if (!inRect(home, p, -tuning.homeInset)) leftHome = true;\n      const atHome = inRect(home, p);\n      const raw = atHome ? null : targetAt(targets, p);\n      cur = follow(cur, targets);\n      shown = follow(shown, targets);\n      let next = raw;\n      if (cur && !atHome && inRect(cur.hit, p, tuning.band)) {\n        const breaks = raw !== null && !same(raw, cur) && raw.priority < cur.priority && inRect(raw.hit, p, -tuning.breakthrough);\n        next = breaks ? raw : cur;\n      }\n      if (!next && cur && !atHome && t - lastInside < tuning.gapGrace) next = cur;\n      if (next && inRect(next.hit, p)) lastInside = t;\n      if (!same(next, cur)) curSince = t;\n      cur = next;\n      const aiming = !restart && (speed < tuning.aimSpeed || t - stillSince >= tuning.dwell);\n      restart = false;\n      const show = (s: T | null): void => {\n        if (!same(s, shown)) shownSince = t;\n        shown = s;\n      };\n      // Under the pointer (within its band), not just kept by the gap grace.\n      const under = !!cur && inRect(cur.hit, p, tuning.band);\n      if (!shown) {\n        if (cur && under && leftHome && aiming) show(cur);\n      } else if (same(cur, shown)) {\n        // It stays while its target holds; but a pointer flying out past the band hides it at once.\n        if (!aiming && !under) show(null);\n        else shown = cur;\n      } else if (!cur || !aiming) {\n        show(null);\n      } else if ((cur.priority < shown.priority && inRect(cur.hit, p, -tuning.breakthrough)) || (under && t - curSince >= tuning.switchHold)) {\n        show(cur);\n      }\n      // The place within the shown target, and the room: after the target and the place have both held.\n      const at = shown ? placeOf(shown, p) : null;\n      if (at !== place) {\n        place = at;\n        placeSince = t;\n      }\n      if (!shown || shown.free) roomPlace = null;\n      else if (t - shownSince >= tuning.roomAfter && t - placeSince >= tuning.roomAfter) roomPlace = place;\n      else if (shownSince === t) roomPlace = null;\n      return { shown, room: roomPlace !== null, roomPlace, aiming };\n    },\n    release(point, targets) {\n      if (inRect(home, point)) return null;\n      // Drop = shown: a shown target is kept until it hides (flying out past its band hides it at once).\n      const s = follow(shown, targets);\n      if (s) return s;\n      return targetAt(targets, point);\n    },\n    hide(time) {\n      shown = null;\n      cur = null;\n      shownSince = time;\n      place = null;\n      roomPlace = null;\n      samples = [];\n      anchor = null;\n      restart = true;\n    },\n    moveHome(dx, dy) {\n      home = { ...home, x: home.x + dx, y: home.y + dy };\n    },\n  };\n}\n","import type { DragFrame, DragTarget } from \"./intent\";\n\n/**\n * How a drag previews its drop, from least to most motion while dragging:\n *\n * - `\"indicator\"`: nothing moves; only the indicator (an outline or an\n *   insertion marker) shows the target.\n * - `\"gap\"`: once the room is made, the others move aside and open the slot;\n *   the item stays under the pointer.\n * - `\"snap\"`: the gap opens and the item itself glides into it (for a target\n *   with a slot; one without keeps the indicator).\n *\n * Every mode follows the same intent: what shows, when, and what a release\n * lands on are the drag intent's, so a drop always lands where the preview\n * showed it.\n */\nexport type DragPreview = \"indicator\" | \"gap\" | \"snap\";\n\n/** The preview a drag uses unless the host picks another. */\nexport const DRAG_PREVIEW_DEFAULT: DragPreview = \"snap\";\n\n/** What to draw for one frame of a drag. */\nexport interface PreviewPlan {\n  /** Draw the indicator on the shown target. */\n  readonly showIndicator: boolean;\n  /** Lay the others out around the room (the gap is open). */\n  readonly makeRoom: boolean;\n  /** Draw the item in its slot instead of under the pointer. */\n  readonly snapItem: boolean;\n}\n\n/**\n * The plan for a frame of the drag intent under `preview`. `slotted` says\n * whether the shown target's drop has a slot the item can sit in (default: a\n * target that isn't `free`); only such a target snaps, and in `\"snap\"` it\n * previews with the item rather than the indicator.\n *\n * - `\"indicator\"`: the indicator, never room, never a snap.\n * - `\"gap\"`: the indicator, and room when the intent makes it.\n * - `\"snap\"`: room when the intent makes it, the item snapped into a slotted\n *   target's room; the indicator only for a target without a slot.\n */\nexport function previewPlan<T extends DragTarget>(\n  frame: Pick<DragFrame<T>, \"shown\" | \"room\">,\n  preview: DragPreview,\n  slotted: boolean = !!frame.shown && !frame.shown.free,\n): PreviewPlan {\n  const shown = !!frame.shown;\n  if (preview === \"indicator\") return { showIndicator: shown, makeRoom: false, snapItem: false };\n  if (preview === \"gap\") return { showIndicator: shown, makeRoom: frame.room, snapItem: false };\n  // By design a slotted target draws nothing until the room opens (`roomAfter`); a release then still lands on it.\n  return { showIndicator: shown && !slotted, makeRoom: frame.room, snapItem: frame.room && shown && slotted };\n}\n"],"mappings":"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","names":[]}

package/dist/gestures.d.ts

@@ -6,7 +6,7 @@ import { C as ClockPort, F as FrameSource, T as TimerSource } from './port-CmlUc
  * touches the DOM; the host copies the fields it needs out of PointerEvent /
  * WheelEvent / Safari's GestureEvent.
  *
- * Ported from the pdfized surface's input layer, whose recogniser this is.
+ * Ported from a host app's input layer, whose recogniser this is.
  * Hit testing and routing (what is under a point, who gets a gesture) stay
  * with the host.
  */