@weasel-js/core 1.9.4 → 1.10.0

package/dist/animation/behaviors/coastOnTargets.js

@@ -0,0 +1,94 @@
+import { translatePoseViaDescriptor as e } from "../../core/geometry/poseDescriptor.js";
+import { createTransformOp as t } from "../../core/ops/transform.js";
+import { poseKey as n } from "../poseHelpers.js";
+import { clampCorner as r, coastKey as i, sameBounds as a } from "./coast.js";
+//#region src/animation/behaviors/coastOnTargets.ts
+function o(t, n, r, i, a) {
+	let o = t.to(r), s = t.to(e(r, 1, 0, n)), c = t.to(e(r, 0, 1, n));
+	return t.from(o.map((e, t) => i * (s[t] - e) + a * (c[t] - e)));
+}
+function s(s, c) {
+	let { animator: l, ctx: u, d, bounds: f, coasts: p } = s, m = u.adapter, h = -Math.log(s.friction), g = i(), _ = /* @__PURE__ */ new Map(), v = (e) => m.getNode(e.id) !== void 0 && a(d.getBounds(e.target.committed()), d.getBounds(e.seen)), y = (e, t, n, r) => {
+		let i = t ?? e.target.committed(), a = o(e.target.axes, d, i, n, r), c = d.getBounds(i);
+		e.startX = c.x, e.startY = c.y, e.vx = n, e.vy = r, e.handle = l.decay({
+			target: e.target,
+			from: t,
+			velocity: a,
+			friction: s.friction,
+			cancelKey: g,
+			interrupt: !1,
+			onTick: (t) => S(e, t),
+			onDone: () => b(e)
+		});
+	}, b = (e) => {
+		e.handle = null, e.seen = e.target.committed();
+		for (let e of _.values()) if (e.handle) return;
+		w();
+	}, x = (e, t) => {
+		let r = e.target.committed();
+		if (_.delete(e.id), e.handle?.cancel(), e.target.commit(r), e.target.active && m.getNode(e.id) !== void 0) {
+			let i = d.getBounds(r), a = d.getBounds(e.seen), s = d.getBounds(t), c = e.vx - h * (s.x - (i.x - a.x) - e.startX), u = e.vy - h * (s.y - (i.y - a.y) - e.startY);
+			l.spring({
+				target: e.target,
+				from: t,
+				to: r,
+				velocity: o(e.target.axes, d, t, c, u),
+				cancelKey: n(e.id),
+				interrupt: !1
+			});
+		}
+		b(e);
+	};
+	function S(t, n) {
+		if (!v(t)) {
+			x(t, n);
+			return;
+		}
+		let i = d.getBounds(n), { nx: a, ny: o, hitX: c, hitY: l } = r(f, i.x, i.y);
+		if (!c && !l) return;
+		let u = c ? 0 : t.vx - h * (i.x - t.startX), p = l ? 0 : t.vy - h * (i.y - t.startY);
+		t.handle?.cancel(), t.target.commit(e(t.target.committed(), a - i.x, o - i.y, d)), t.seen = t.target.committed(), s.boundary === "continue" && Math.hypot(u, p) > 0 ? y(t, void 0, u, p) : b(t);
+	}
+	let C = {
+		ids: u.draggedIds.slice(),
+		stop: () => {
+			if (!l.isActive(g)) {
+				p.delete(C);
+				return;
+			}
+			for (let e of _.values()) e.handle?.cancel(), e.handle = null, e.seen = e.target.committed();
+			w();
+		}
+	};
+	p.add(C);
+	function w() {
+		if (!p.delete(C) || !m.applyOps) return;
+		let e = [];
+		for (let n of _.values()) {
+			if (!v(n)) continue;
+			let r = u.origin.get(n.id) ?? n.seen, i = n.target.committed();
+			n.target.commit(r), e.push(t({
+				id: n.id,
+				from: r,
+				to: i,
+				label: "flick"
+			}));
+		}
+		e.length > 0 && m.applyOps(e, "flick");
+	}
+	for (let [e, t] of c) _.set(e, {
+		id: e,
+		target: t,
+		seen: t.committed(),
+		handle: null,
+		startX: 0,
+		startY: 0,
+		vx: 0,
+		vy: 0
+	});
+	for (let e of [..._.values()]) y(e, u.current.get(e.id), s.vx, s.vy);
+}
+//#endregion
+export { s as coastOnTargets };
+
+//# sourceMappingURL=coastOnTargets.js.map

package/dist/animation/behaviors/coastOnTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coastOnTargets.js","names":["poseVelocity","base","ax","at","alongX","translatePoseViaDescriptor","d","alongY","vx","i","b","vy","coastOnTargets","a","adapter","ctx","drag","cancelKey","coastKey","riders","ours","r","sameBounds","launch","from","velocity","corner","animator","tick","own","halted","other","drop","left","moved","was","poseKey","clampCorner","bounds","hitX","hitY","nx","ny","coast","commitFlick","coasts","ops","to","createTransformOp","id","target","targets"],"sources":["../../../src/animation/behaviors/coastOnTargets.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Target, TargetAxes } from '@weasel-js/animator';\nimport type { AnimationHandle } from '@weasel-js/animator';\nimport { poseKey } from '../poseHelpers';\nimport { clampCorner, coastKey, sameBounds, type Coast, type CoastArgs } from './coast';\n\ninterface Rider<TPose> {\n  id: string;\n  target: Target<TPose>;\n  /** The committed pose as the coast last left it. Anything else there is another writer's. */\n  seen: TPose;\n  /** Null once this node has stopped. */\n  handle: AnimationHandle | null;\n  /** The corner and velocity its running decay started with. */\n  startX: number;\n  startY: number;\n  vx: number;\n  vy: number;\n}\n\n/** A world velocity as the rate of change of a pose at `at`. */\nfunction poseVelocity<TPose>(\n  ax: TargetAxes<TPose>,\n  d: PoseDescriptor<TPose>,\n  at: TPose,\n  vx: number,\n  vy: number,\n): TPose {\n  const base = ax.to(at);\n  const alongX = ax.to(translatePoseViaDescriptor(at, 1, 0, d));\n  const alongY = ax.to(translatePoseViaDescriptor(at, 0, 1, d));\n  return ax.from(base.map((b, i) => vx * (alongX[i]! - b) + vy * (alongY[i]! - b)));\n}\n\n/**\n * A coast on each node's own pose target: a decay per node, so anything else animating the\n * node adds to it. The document keeps the pre-drag pose while the node travels, takes the\n * pose it stops at, and the flick is recorded as one transform once every node has stopped.\n */\nexport function coastOnTargets<TPose>(a: CoastArgs<TPose>, targets: ReadonlyMap<string, Target<TPose>>): void {\n  const { animator, ctx, d, bounds, coasts } = a;\n  const adapter = ctx.adapter;\n  // Speed lost per unit traveled: an exponential coast's velocity is its first less this times\n  // how far it has gone, which is how a node stopped at an edge knows what speed it has left.\n  const drag = -Math.log(a.friction);\n  const cancelKey = coastKey();\n  const riders = new Map<string, Rider<TPose>>();\n\n  const ours = (r: Rider<TPose>): boolean =>\n    adapter.getNode(r.id) !== undefined && sameBounds(d.getBounds(r.target.committed()), d.getBounds(r.seen));\n\n  const launch = (r: Rider<TPose>, from: TPose | undefined, vx: number, vy: number): void => {\n    const at = from ?? r.target.committed();\n    const velocity = poseVelocity(r.target.axes, d, at, vx, vy);\n    const corner = d.getBounds(at);\n    r.startX = corner.x;\n    r.startY = corner.y;\n    r.vx = vx;\n    r.vy = vy;\n    r.handle = animator.decay<TPose>({\n      target: r.target,\n      from,\n      velocity,\n      friction: a.friction,\n      cancelKey,\n      interrupt: false,\n      onTick: (own) => tick(r, own),\n      onDone: () => halted(r),\n    });\n  };\n\n  const halted = (r: Rider<TPose>): void => {\n    r.handle = null;\n    r.seen = r.target.committed();\n    for (const other of riders.values()) if (other.handle) return;\n    commitFlick();\n  };\n\n  /**\n   * Takes `r` out of the coast where another writer left its node. Where that writer is another\n   * animation on the node, the node is still short of `left` by what the coast had traveled, at\n   * `own`: a spring carries that to nothing from the coast's speed, joining the node's moves.\n   */\n  const drop = (r: Rider<TPose>, own: TPose): void => {\n    const left = r.target.committed();\n    riders.delete(r.id);\n    r.handle?.cancel();\n    r.target.commit(left);\n    if (r.target.active && adapter.getNode(r.id) !== undefined) {\n      const moved = d.getBounds(left);\n      const was = d.getBounds(r.seen);\n      const corner = d.getBounds(own);\n      const vx = r.vx - drag * (corner.x - (moved.x - was.x) - r.startX);\n      const vy = r.vy - drag * (corner.y - (moved.y - was.y) - r.startY);\n      animator.spring<TPose>({\n        target: r.target,\n        from: own,\n        to: left,\n        velocity: poseVelocity(r.target.axes, d, own, vx, vy),\n        cancelKey: poseKey(r.id),\n        interrupt: false,\n      });\n    }\n    halted(r);\n  };\n\n  function tick(r: Rider<TPose>, own: TPose): void {\n    if (!ours(r)) { drop(r, own); return; }\n    const corner = d.getBounds(own);\n    const { nx, ny, hitX, hitY } = clampCorner(bounds, corner.x, corner.y);\n    if (!hitX && !hitY) return;\n    const vx = hitX ? 0 : r.vx - drag * (corner.x - r.startX);\n    const vy = hitY ? 0 : r.vy - drag * (corner.y - r.startY);\n    // Canceled, it commits the pose it reached; the edge is where it belongs.\n    r.handle?.cancel();\n    r.target.commit(translatePoseViaDescriptor(r.target.committed(), nx - corner.x, ny - corner.y, d));\n    r.seen = r.target.committed();\n    if (a.boundary === 'continue' && Math.hypot(vx, vy) > 0) launch(r, undefined, vx, vy);\n    else halted(r);\n  }\n\n  const coast: Coast = {\n    ids: ctx.draggedIds.slice(),\n    stop: (): void => {\n      // Canceled from outside (cancelAll, unmount), it stopped long ago and somewhere else.\n      if (!animator.isActive(cancelKey)) {\n        coasts.delete(coast);\n        return;\n      }\n      for (const r of riders.values()) {\n        r.handle?.cancel();\n        r.handle = null;\n        r.seen = r.target.committed();\n      }\n      commitFlick();\n    },\n  };\n  coasts.add(coast);\n\n  function commitFlick(): void {\n    if (!coasts.delete(coast) || !adapter.applyOps) return;\n    const ops: Op[] = [];\n    for (const r of riders.values()) {\n      if (!ours(r)) continue;\n      const from = ctx.origin.get(r.id) ?? r.seen;\n      const to = r.target.committed();\n      // A scene records the write it sees, not an op's `from`, so the document goes back first.\n      r.target.commit(from);\n      ops.push(createTransformOp<TPose>({ id: r.id, from, to, label: 'flick' }));\n    }\n    if (ops.length > 0) adapter.applyOps(ops, 'flick');\n  }\n\n  for (const [id, target] of targets) {\n    riders.set(id, { id, target, seen: target.committed(), handle: null, startX: 0, startY: 0, vx: 0, vy: 0 });\n  }\n  // Each starts from its release pose, which the document does not hold: the drag was a preview.\n  for (const r of [...riders.values()]) launch(r, ctx.current.get(r.id), a.vx, a.vy);\n}\n"],"mappings":"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"}

package/dist/animation/behaviors/momentum.js

@@ -1,156 +1,68 @@
-import { createTransformOp as e } from "../../core/ops/transform.js";
-import { translatePoseViaDescriptor as t } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as e } from "../../core/geometry/autoPoseDescriptor.js";
+import { coastByWrite as t } from "./coastByWrite.js";
+import { coastOnTargets as n } from "./coastOnTargets.js";
 import { getScratch as r, scratchKey as i, setScratch as a } from "@weasel-js/routing";
 //#region src/animation/behaviors/momentum.ts
-var o = (e, t) => e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height, s = 0, c = i("momentum.samples");
-function l(i) {
-	let l = i.friction ?? .92, u = i.threshold ?? 200, d = i.velocitySampleMs ?? 80, f = i.now ?? (() => Date.now()), p = i.bounds, m = i.boundary ?? "stop", h = i.poseDescriptor ?? n, g = (e, t, n, r) => {
-		let i = e + n, a = t + r;
-		if (!p) return {
-			nx: i,
-			ny: a,
-			hit: !1
-		};
-		let o = !1;
-		return i < p.x ? (i = p.x, o = !0) : i > p.x + p.width && (i = p.x + p.width, o = !0), a < p.y ? (a = p.y, o = !0) : a > p.y + p.height && (a = p.y + p.height, o = !0), {
-			nx: i,
-			ny: a,
-			hit: o
-		};
-	}, _ = (e) => {
-		let t = r(e.scratch, c);
-		t || (t = [], a(e.scratch, c, t)), t.push({
-			t: f(),
+var o = i("momentum.samples");
+function s(i) {
+	let s = i.friction ?? .92, c = i.threshold ?? 200, l = i.velocitySampleMs ?? 80, u = i.now ?? (() => Date.now()), d = i.poseDescriptor ?? e, f = (e) => {
+		let t = r(e.scratch, o);
+		t || (t = [], a(e.scratch, o, t)), t.push({
+			t: u(),
 			x: e.pointer.worldX,
 			y: e.pointer.worldY
 		});
-		let n = f() - d * 4;
+		let n = u() - l * 4;
 		for (; t.length > 1 && t[0].t < n;) t.shift();
-	}, v = /* @__PURE__ */ new Set();
+	}, p = /* @__PURE__ */ new Set(), m = (e) => {
+		let { adapter: t } = e;
+		if (!t.poseTarget) return null;
+		let n = /* @__PURE__ */ new Map();
+		for (let r of e.draggedIds) {
+			if (!e.current.has(r)) continue;
+			let a = t.getNode(r) && t.poseTarget(r, i.poseDescriptor);
+			if (!a) return null;
+			n.set(r, a);
+		}
+		return n;
+	};
 	return {
 		onStart(e) {
-			for (let t of [...v]) t.ids.some((t) => e.draggedIds.includes(t)) && t.stop();
-			a(e.scratch, c, []), _(e);
+			for (let t of [...p]) t.ids.some((t) => e.draggedIds.includes(t)) && t.stop();
+			a(e.scratch, o, []), f(e);
 		},
 		onMove(e) {
-			_(e);
+			f(e);
 		},
-		onEnd(n, a) {
+		onEnd(e, a) {
 			if (a.answered) return;
-			let f = r(n.scratch, c) ?? [];
-			if (f.length < 2) return;
-			let _ = f[f.length - 1], y = _.t - d, b = f[0];
-			for (let e of f) if (e.t >= y) {
-				b = e;
+			let u = r(e.scratch, o) ?? [];
+			if (u.length < 2) return;
+			let f = u[u.length - 1], h = f.t - l, g = u[0];
+			for (let e of u) if (e.t >= h) {
+				g = e;
 				break;
 			}
-			let x = (_.t - b.t) / 1e3;
-			if (x <= 0) return;
-			let S = (_.x - b.x) / x, C = (_.y - b.y) / x;
-			if (Math.hypot(S, C) < u) return;
-			let w = new Map(n.current), T = {
-				x: 0,
-				y: 0
-			}, E = n.adapter, D = (e) => {
-				if (E.previewPoses) E.previewPoses(e);
-				else for (let [t, n] of e) n !== null && E.setPose(t, n);
-			}, O = new Set(n.draggedIds), k = /* @__PURE__ */ new Map();
-			for (let e of O) E.getNode(e) && k.set(e, h.getBounds(E.getPose(e)));
-			let A = (e) => {
-				let t = k.get(e);
-				return t !== void 0 && E.getNode(e) !== void 0 && o(h.getBounds(E.getPose(e)), t);
-			}, j = /* @__PURE__ */ new Map(), M = `momentum:${s++}`, N = {
-				ids: n.draggedIds.slice(),
-				stop: () => {
-					if (!i.animator.isActive(M)) {
-						v.delete(N);
-						return;
-					}
-					P.cancel(), F();
-				}
-			};
-			v.add(N), D(new Map([...O].flatMap((e) => {
-				let t = w.get(e);
-				return t === void 0 ? [] : [[e, t]];
-			})));
-			let P = i.animator.decay({
-				from: {
-					x: 0,
-					y: 0
-				},
-				velocity: {
-					x: S,
-					y: C
-				},
-				friction: l,
-				cancelKey: M,
-				add: (e, t) => ({
-					x: e.x + t.x,
-					y: e.y + t.y
-				}),
-				scale: (e, t) => ({
-					x: e.x * t,
-					y: e.y * t
-				}),
-				magnitude: (e) => Math.hypot(e.x, e.y),
-				onTick: (e) => {
-					T = e;
-					let n = p !== void 0, r = /* @__PURE__ */ new Map();
-					for (let i of [...O]) {
-						if (!A(i)) {
-							O.delete(i), r.set(i, null);
-							continue;
-						}
-						let a = w.get(i);
-						if (!a) continue;
-						let o = h.getBounds(a), { nx: s, ny: c, hit: l } = g(o.x, o.y, e.x, e.y);
-						l || (n = !1), j.set(i, {
-							x: s,
-							y: c
-						}), r.set(i, t(a, s - o.x, c - o.y, h));
-					}
-					D(r);
-					for (let e of O) k.set(e, h.getBounds(E.getPose(e)));
-					if (O.size === 0) {
-						v.delete(N), P.cancel();
-						return;
-					}
-					m === "stop" && n && N.stop();
-				},
-				onDone: () => {
-					F();
-				}
-			});
-			function F() {
-				if (!v.delete(N)) return;
-				let r = [], i = /* @__PURE__ */ new Map();
-				for (let a of O) {
-					if (i.set(a, null), !A(a)) continue;
-					let o = w.get(a);
-					if (!o) continue;
-					let s = h.getBounds(o), c = j.get(a) ?? {
-						x: s.x + T.x,
-						y: s.y + T.y
-					}, l = t(o, c.x - s.x, c.y - s.y, h), u = n.origin.get(a) ?? o;
-					r.push(e({
-						id: a,
-						from: u,
-						to: l,
-						label: "flick"
-					}));
-				}
-				if (r.length > 0) {
-					if (E.applyOps) E.applyOps(r, "flick");
-					else if (E.previewPoses) for (let e of r) e.apply(E);
-				}
-				E.previewPoses?.(i);
-			}
-			return null;
+			let _ = (f.t - g.t) / 1e3;
+			if (_ <= 0) return;
+			let v = (f.x - g.x) / _, y = (f.y - g.y) / _;
+			if (Math.hypot(v, y) < c) return;
+			let b = {
+				animator: i.animator,
+				ctx: e,
+				vx: v,
+				vy: y,
+				friction: s,
+				d,
+				coasts: p,
+				bounds: i.bounds,
+				boundary: i.boundary ?? "stop"
+			}, x = m(e);
+			return x ? n(b, x) : t(b), null;
 		}
 	};
 }
 //#endregion
-export { l as momentum };
+export { s as momentum };
 
 //# sourceMappingURL=momentum.js.map

package/dist/animation/behaviors/momentum.js.map

@@ -1 +1 @@
-{"version":3,"file":"momentum.js","names":["sameBounds","a","b","nextCoast","SAMPLES","scratchKey","momentum","friction","opts","threshold","sampleMs","now","bounds","boundaryPolicy","d","AUTO_POSE_DESCRIPTOR","clampToBounds","nx","sx","dx","ny","sy","dy","hit","recordSample","samples","getScratch","ctx","setScratch","cutoff","coasts","coast","id","end","last","first","s","dt","vx","vy","startPoses","lastValue","adapter","show","poses","pose","riding","lastSeen","stillOurs","seen","finalPositions","cancelKey","decayHandle","commitFlick","start","v","k","delta","allHit","frame","translatePoseViaDescriptor","ops","shown","o","fp","finalPose","from","createTransformOp","op"],"sources":["../../../src/animation/behaviors/momentum.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { MoveBehavior, GestureContext } from 'interactions/gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { Animator } from '../types';\n\n/** Options for the `momentum` move behavior. */\nexport interface MomentumOptions {\n  /** Required: the per-Canvas animator that will own the decay. */\n  animator: Animator;\n  friction?: number;     // default 0.92 (per second)\n  threshold?: number;    // default 200 world units/sec; the slowest release that coasts\n  /** Sample window in ms for velocity computation. Default 80ms. */\n  velocitySampleMs?: number;\n  /** Optional clock override for tests. Defaults to `Date.now`. */\n  now?: () => number;\n  /**\n   * Optional bounds for the object's top-left corner (in world units). When\n   * supplied, momentum-driven translation is clamped: each tick's new\n   * position is constrained so the object's `(x, y)` stays inside the rect.\n   * Without bounds, a hard flick carries the object indefinitely until\n   * friction dampens velocity below `threshold`.\n   *\n   * Note: ignores object size for now — the bound is on the top-left, not\n   * the visible edges. A consumer wanting \"object stays fully inside\" should\n   * pass `bounds = { x: canvas.x, y: canvas.y, width: canvas.w - obj.w,\n   * height: canvas.h - obj.h }` (and accept that it doesn't adapt to\n   * variable-sized objects mid-flight).\n   */\n  bounds?: { x: number; y: number; width: number; height: number };\n  /**\n   * Boundary policy when the clamped position hits an edge. 'stop' cancels\n   * the decay (instant settle at the edge). 'continue' keeps decaying but\n   * subsequent ticks stay clamped (object drifts along the edge as friction\n   * decays the velocity). Default 'stop'.\n   */\n  boundary?: 'stop' | 'continue';\n  /** How to translate poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n}\n\ninterface PointerSample {\n  t: number;       // ms timestamp\n  x: number;\n  y: number;\n}\n\ninterface RectLike { x: number; y: number }\n\nconst sameBounds = (a: Bounds, b: Bounds): boolean =>\n  a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n\nlet nextCoast = 0;\n\nconst SAMPLES = scratchKey<PointerSample[]>('momentum.samples');\n\n/**\n * Move behavior that keeps a dragged node coasting after the pointer is\n * released, at the velocity it was traveling, until friction brings it to\n * rest. A release slower than `threshold` does not coast at all.\n *\n * Plugs into the move action rather than replacing it, so the drag itself is\n * unchanged — this only decides what happens after the release. The whole\n * flick, coast included, records as one undoable transform: under an adapter\n * with `previewPoses` the coast is shown without touching the document, and\n * the transform is written once it comes to rest. Dragging a node\n * again while it coasts stops the coast and records it where it stands. A node\n * something else moves or deletes mid-coast, an undo included, drops out of\n * the coast where that left it, and nothing is recorded for it.\n */\nexport function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose> {\n  const friction = opts.friction ?? 0.92;\n  const threshold = opts.threshold ?? 200;\n  const sampleMs = opts.velocitySampleMs ?? 80;\n  const now = opts.now ?? (() => Date.now());\n  const bounds = opts.bounds;\n  const boundaryPolicy = opts.boundary ?? 'stop';\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  /** Apply bounds clamp to (sx + dx, sy + dy). Returns clamped (nx, ny) and\n   *  whether either axis was clamped (signalling boundary hit). */\n  const clampToBounds = (sx: number, sy: number, dx: number, dy: number): { nx: number; ny: number; hit: boolean } => {\n    let nx = sx + dx;\n    let ny = sy + dy;\n    if (!bounds) return { nx, ny, hit: false };\n    let hit = false;\n    if (nx < bounds.x) { nx = bounds.x; hit = true; }\n    else if (nx > bounds.x + bounds.width) { nx = bounds.x + bounds.width; hit = true; }\n    if (ny < bounds.y) { ny = bounds.y; hit = true; }\n    else if (ny > bounds.y + bounds.height) { ny = bounds.y + bounds.height; hit = true; }\n    return { nx, ny, hit };\n  };\n\n  const recordSample = (ctx: GestureContext<TPose>): void => {\n    let samples = getScratch(ctx.scratch, SAMPLES);\n    if (!samples) {\n      samples = [];\n      setScratch(ctx.scratch, SAMPLES, samples);\n    }\n    samples.push({\n      t: now(),\n      x: ctx.pointer.worldX,\n      y: ctx.pointer.worldY,\n    });\n    // Trim anything older than 4× the sample window — bounded memory.\n    const cutoff = now() - sampleMs * 4;\n    while (samples.length > 1 && samples[0].t < cutoff) samples.shift();\n  };\n\n  const coasts = new Set<{ ids: readonly string[]; stop(): void }>();\n\n  return {\n    onStart(ctx) {\n      for (const coast of [...coasts]) {\n        if (coast.ids.some((id) => ctx.draggedIds.includes(id))) coast.stop();\n      }\n      setScratch(ctx.scratch, SAMPLES, []);\n      recordSample(ctx);\n    },\n    onMove(ctx) {\n      recordSample(ctx);\n    },\n    onEnd(ctx, end): Op[] | null | void {\n      if (end.answered) return undefined;\n      const samples = getScratch(ctx.scratch, SAMPLES) ?? [];\n      if (samples.length < 2) return undefined;\n      const last = samples[samples.length - 1];\n      // Find the oldest sample within `sampleMs` of `last`.\n      const cutoff = last.t - sampleMs;\n      let first = samples[0];\n      for (const s of samples) {\n        if (s.t >= cutoff) { first = s; break; }\n      }\n      const dt = (last.t - first.t) / 1000;\n      if (dt <= 0) return undefined;\n      const vx = (last.x - first.x) / dt;\n      const vy = (last.y - first.y) / dt;\n      const speed = Math.hypot(vx, vy);\n      if (speed < threshold) return undefined;\n\n      // Suppress default commit and fire decay. We translate each dragged id\n      // by the per-frame delta and commit one transform op per id when done.\n      const startPoses = new Map<string, TPose>(ctx.current);\n      let lastValue = { x: 0, y: 0 };\n      const adapter = ctx.adapter;\n      const show = (poses: Map<string, TPose | null>): void => {\n        if (adapter.previewPoses) adapter.previewPoses(poses);\n        else for (const [id, pose] of poses) if (pose !== null) adapter.setPose(id, pose);\n      };\n      // What the scene held for each node right after the coast last wrote it.\n      // A node that is gone, or reads back as anything else, has another\n      // writer now, an undo or a delete, and leaves the coast unrecorded.\n      const riding = new Set(ctx.draggedIds);\n      const lastSeen = new Map<string, Bounds>();\n      for (const id of riding) {\n        if (adapter.getNode(id)) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n      }\n      const stillOurs = (id: string): boolean => {\n        const seen = lastSeen.get(id);\n        return seen !== undefined && adapter.getNode(id) !== undefined\n          && sameBounds(d.getBounds(adapter.getPose(id)), seen);\n      };\n      // Track per-id final positions when bounds clamping is active — used\n      // by onDone to compute the correct final transform op (not just\n      // start + decay's last delta, which may overshoot the boundary).\n      const finalPositions = new Map<string, { x: number; y: number }>();\n      const cancelKey = `momentum:${nextCoast++}`;\n      const coast = {\n        ids: ctx.draggedIds.slice(),\n        stop: (): void => {\n          // Canceled from outside (cancelAll, unmount), it stopped long ago and somewhere else.\n          if (!opts.animator.isActive(cancelKey)) {\n            coasts.delete(coast);\n            return;\n          }\n          decayHandle.cancel();\n          commitFlick();\n        },\n      };\n      coasts.add(coast);\n      // Held from the release itself, so no frame paints the pre-drag pose\n      // between the drag's preview going away and the first coast frame.\n      show(new Map([...riding].flatMap((id) => {\n        const start = startPoses.get(id);\n        return start === undefined ? [] : [[id, start] as const];\n      })));\n      const decayHandle = opts.animator.decay<RectLike>({\n        from: { x: 0, y: 0 },\n        velocity: { x: vx, y: vy },\n        friction,\n        cancelKey,\n        add: (a, b) => ({ x: a.x + b.x, y: a.y + b.y }),\n        scale: (v, k) => ({ x: v.x * k, y: v.y * k }),\n        magnitude: (v) => Math.hypot(v.x, v.y),\n        onTick: (delta) => {\n          lastValue = delta;\n          let allHit = bounds !== undefined;\n          const frame = new Map<string, TPose | null>();\n          for (const id of [...riding]) {\n            if (!stillOurs(id)) {\n              riding.delete(id);\n              frame.set(id, null);\n              continue;\n            }\n            const start = startPoses.get(id);\n            if (!start) continue;\n            const o = d.getBounds(start);\n            const { nx, ny, hit } = clampToBounds(o.x, o.y, delta.x, delta.y);\n            if (!hit) allHit = false;\n            finalPositions.set(id, { x: nx, y: ny });\n            frame.set(id, translatePoseViaDescriptor(start, nx - o.x, ny - o.y, d));\n          }\n          show(frame);\n          for (const id of riding) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n          if (riding.size === 0) {\n            coasts.delete(coast);\n            decayHandle.cancel();\n            return;\n          }\n          // If 'stop' policy and every dragged id's clamped position hit\n          // the boundary, cancel the decay so the animation settles instantly\n          // instead of drifting along the edge as friction wears off.\n          if (boundaryPolicy === 'stop' && allHit) coast.stop();\n        },\n        onDone: () => {\n          commitFlick();\n        },\n      });\n\n      function commitFlick(): void {\n        if (!coasts.delete(coast)) return;\n        const ops: Op[] = [];\n        const shown = new Map<string, TPose | null>();\n        for (const id of riding) {\n          shown.set(id, null);\n          if (!stillOurs(id)) continue;\n          const start = startPoses.get(id);\n          if (!start) continue;\n          const o = d.getBounds(start);\n          const fp = finalPositions.get(id) ?? { x: o.x + lastValue.x, y: o.y + lastValue.y };\n          const finalPose = translatePoseViaDescriptor(start, fp.x - o.x, fp.y - o.y, d);\n          const from = ctx.origin.get(id) ?? start;\n          ops.push(createTransformOp<TPose>({ id, from, to: finalPose, label: 'flick' }));\n        }\n        // The document first, so the preview never gives way to the pre-drag pose.\n        if (ops.length > 0) {\n          if (adapter.applyOps) adapter.applyOps(ops, 'flick');\n          else if (adapter.previewPoses) for (const op of ops) op.apply(adapter);\n        }\n        adapter.previewPoses?.(shown);\n      }\n\n      return null;\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"momentum.js","names":["SAMPLES","scratchKey","momentum","friction","opts","threshold","sampleMs","now","AUTO_POSE_DESCRIPTOR","recordSample","samples","getScratch","ctx","setScratch","cutoff","coasts","targetsOf","adapter","targets","id","target","coast","end","last","first","s","dt","vx","vy","args","coastOnTargets","coastByWrite"],"sources":["../../../src/animation/behaviors/momentum.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport type { MoveBehavior, GestureContext } from 'interactions/gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { Target } from '@weasel-js/animator';\nimport type { Animator } from '@weasel-js/animator';\nimport type { Coast, CoastArgs } from './coast';\nimport { coastByWrite } from './coastByWrite';\nimport { coastOnTargets } from './coastOnTargets';\n\n/** Options for the `momentum` move behavior. */\nexport interface MomentumOptions {\n  /** Required: the per-Canvas animator that will own the decay. */\n  animator: Animator;\n  friction?: number;     // default 0.92 (per second)\n  threshold?: number;    // default 200 world units/sec; the slowest release that coasts\n  /** Sample window in ms for velocity computation. Default 80ms. */\n  velocitySampleMs?: number;\n  /** Optional clock override for tests. Defaults to `Date.now`. */\n  now?: () => number;\n  /**\n   * Optional bounds for the object's top-left corner (in world units): each\n   * tick's new position is clamped so the object's `(x, y)` stays inside the\n   * rect. Object size is ignored, so to keep an object fully inside, shrink\n   * the rect by the object's width and height.\n   */\n  bounds?: { x: number; y: number; width: number; height: number };\n  /**\n   * Boundary policy when the clamped position hits an edge. 'stop' settles at\n   * the edge at once. 'continue' keeps decaying, so the object drifts along\n   * the edge. Default 'stop'.\n   */\n  boundary?: 'stop' | 'continue';\n  /** How to translate poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n}\n\ninterface PointerSample {\n  t: number;       // ms timestamp\n  x: number;\n  y: number;\n}\n\nconst SAMPLES = scratchKey<PointerSample[]>('momentum.samples');\n\n/**\n * Move behavior that keeps a dragged node coasting after the pointer is\n * released, at the velocity it was traveling, until friction brings it to\n * rest. A release slower than `threshold` does not coast at all.\n *\n * The whole flick, coast included, records as one undoable transform, written\n * once it comes to rest. Over an adapter with `poseTarget`, which a\n * scene-backed one has, each node coasts on its own pose target, so anything\n * else animating it adds; over one without, the coast is shown through\n * `previewPoses`, or written through `setPose` each frame. Dragging a node\n * again while it coasts stops the coast and records it where it stands. A\n * `tweenPose` or `springPose` of a coasting node ends its coast. A node\n * something else moves or deletes mid-coast, an undo included, drops out of\n * the coast where that left it, and nothing is recorded for it.\n */\nexport function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose> {\n  const friction = opts.friction ?? 0.92;\n  const threshold = opts.threshold ?? 200;\n  const sampleMs = opts.velocitySampleMs ?? 80;\n  const now = opts.now ?? (() => Date.now());\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const recordSample = (ctx: GestureContext<TPose>): void => {\n    let samples = getScratch(ctx.scratch, SAMPLES);\n    if (!samples) {\n      samples = [];\n      setScratch(ctx.scratch, SAMPLES, samples);\n    }\n    samples.push({\n      t: now(),\n      x: ctx.pointer.worldX,\n      y: ctx.pointer.worldY,\n    });\n    // Trim anything older than 4× the sample window — bounded memory.\n    const cutoff = now() - sampleMs * 4;\n    while (samples.length > 1 && samples[0].t < cutoff) samples.shift();\n  };\n\n  const coasts = new Set<Coast>();\n\n  /** Every dragged node's pose target, or null where the adapter has none for one of them. */\n  const targetsOf = (ctx: GestureContext<TPose>): Map<string, Target<TPose>> | null => {\n    const { adapter } = ctx;\n    if (!adapter.poseTarget) return null;\n    const targets = new Map<string, Target<TPose>>();\n    for (const id of ctx.draggedIds) {\n      if (!ctx.current.has(id)) continue;\n      const target = adapter.getNode(id) && adapter.poseTarget(id, opts.poseDescriptor as PoseDescriptor<TPose> | undefined);\n      if (!target) return null;\n      targets.set(id, target);\n    }\n    return targets;\n  };\n\n  return {\n    onStart(ctx) {\n      for (const coast of [...coasts]) {\n        if (coast.ids.some((id) => ctx.draggedIds.includes(id))) coast.stop();\n      }\n      setScratch(ctx.scratch, SAMPLES, []);\n      recordSample(ctx);\n    },\n    onMove(ctx) {\n      recordSample(ctx);\n    },\n    onEnd(ctx, end): Op[] | null | void {\n      if (end.answered) return undefined;\n      const samples = getScratch(ctx.scratch, SAMPLES) ?? [];\n      if (samples.length < 2) return undefined;\n      const last = samples[samples.length - 1];\n      // Find the oldest sample within `sampleMs` of `last`.\n      const cutoff = last.t - sampleMs;\n      let first = samples[0];\n      for (const s of samples) {\n        if (s.t >= cutoff) { first = s; break; }\n      }\n      const dt = (last.t - first.t) / 1000;\n      if (dt <= 0) return undefined;\n      const vx = (last.x - first.x) / dt;\n      const vy = (last.y - first.y) / dt;\n      if (Math.hypot(vx, vy) < threshold) return undefined;\n\n      const args: CoastArgs<TPose> = {\n        animator: opts.animator, ctx, vx, vy, friction, d, coasts,\n        bounds: opts.bounds, boundary: opts.boundary ?? 'stop',\n      };\n      const targets = targetsOf(ctx);\n      if (targets) coastOnTargets(args, targets);\n      else coastByWrite(args);\n      // The coast commits the flick itself, so the move action's own commit is suppressed.\n      return null;\n    },\n  };\n}\n"],"mappings":";;;;;AA4CA,IAAMA,IAAUC,EAA4B,kBAAkB;AAiB9D,SAAgBC,EAAgB,GAA4C;CAC1E,IAAMC,IAAWC,EAAK,YAAY,KAC5BC,IAAYD,EAAK,aAAa,KAC9BE,IAAWF,EAAK,oBAAoB,IACpCG,IAAMH,EAAK,cAAc,KAAK,IAAI,IAClC,IAAKA,EAAK,kBAAkBI,GAE5BC,KAAgB,MAAqC;EACzD,IAAIC,IAAUC,EAAWC,EAAI,SAASZ,CAAO;EAK7C,AAJKU,MACH,IAAU,CAAC,GACXG,EAAWD,EAAI,SAASZ,GAASU,CAAO,IAE1CA,EAAQ,KAAK;GACX,GAAGH,EAAI;GACP,GAAGK,EAAI,QAAQ;GACf,GAAGA,EAAI,QAAQ;EACjB,CAAC;EAED,IAAME,IAASP,EAAI,IAAID,IAAW;EAClC,OAAOI,EAAQ,SAAS,KAAKA,EAAQ,EAAE,CAAC,IAAII,IAAQ,EAAQ,MAAM;CACpE,GAEMC,oBAAS,IAAI,IAAW,GAGxBC,KAAa,MAAkE;EACnF,IAAM,EAAE,eAAYJ;EACpB,IAAI,CAACK,EAAQ,YAAY,OAAO;EAChC,IAAMC,oBAAU,IAAI,IAA2B;EAC/C,KAAK,IAAMC,KAAMP,EAAI,YAAY;GAC/B,IAAI,CAACA,EAAI,QAAQ,IAAIO,CAAE,GAAG;GAC1B,IAAMC,IAASH,EAAQ,QAAQE,CAAE,KAAKF,EAAQ,WAAWE,GAAIf,EAAK,cAAmD;GACrH,IAAI,CAACgB,GAAQ,OAAO;GACpB,EAAQ,IAAID,GAAIC,CAAM;EACxB;EACA,OAAOF;CACT;CAEA,OAAO;EACL,QAAQ,GAAK;GACX,KAAK,IAAMG,KAAS,CAAC,GAAGN,CAAM,GAC5B,AAAIM,EAAM,IAAI,MAAM,MAAOT,EAAI,WAAW,SAASO,CAAE,CAAC,KAAGE,EAAM,KAAK;GAGtE,AADAR,EAAWD,EAAI,SAASZ,GAAS,CAAC,CAAC,GACnCS,EAAaG,CAAG;EAClB;EACA,OAAO,GAAK;GACV,EAAaA,CAAG;EAClB;EACA,MAAM,GAAK,GAAyB;GAClC,IAAIU,EAAI,UAAU;GAClB,IAAMZ,IAAUC,EAAWC,EAAI,SAASZ,CAAO,KAAK,CAAC;GACrD,IAAIU,EAAQ,SAAS,GAAG;GACxB,IAAMa,IAAOb,EAAQA,EAAQ,SAAS,IAEhCI,IAASS,EAAK,IAAIjB,GACpBkB,IAAQd,EAAQ;GACpB,KAAK,IAAMe,KAAKf,GACd,IAAIe,EAAE,KAAKX,GAAQ;IAAE,IAAQW;IAAG;GAAO;GAEzC,IAAMC,KAAMH,EAAK,IAAIC,EAAM,KAAK;GAChC,IAAIE,KAAM,GAAG;GACb,IAAMC,KAAMJ,EAAK,IAAIC,EAAM,KAAKE,GAC1BE,KAAML,EAAK,IAAIC,EAAM,KAAKE;GAChC,IAAI,KAAK,MAAMC,GAAIC,CAAE,IAAIvB,GAAW;GAEpC,IAAMwB,IAAyB;IAC7B,UAAUzB,EAAK;IAAU;IAAK;IAAI;IAAI;IAAU;IAAG;IACnD,QAAQA,EAAK;IAAQ,UAAUA,EAAK,YAAY;GAClD,GACMc,IAAUF,EAAUJ,CAAG;GAI7B,OAHIM,IAASY,EAAeD,GAAMX,CAAO,IACpCa,EAAaF,CAAI,GAEf;EACT;CACF;AACF"}

package/dist/animation/clipTargets.js

@@ -0,0 +1,12 @@
+import { scenePoseTarget as e } from "./poseTarget.js";
+//#region src/animation/clipTargets.ts
+function t(t, n = {}) {
+	return (r) => {
+		if (r.startsWith("pose:")) return e(t, r.slice(5), n.descriptor, n.cascade);
+		if (r.startsWith("rig:")) return n.rigs?.[r.slice(4)]?.target;
+	};
+}
+//#endregion
+export { t as sceneClipTargets };
+
+//# sourceMappingURL=clipTargets.js.map

package/dist/animation/clipTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipTargets.js","names":["sceneClipTargets","name","scenePoseTarget","scene","options"],"sources":["../../src/animation/clipTargets.ts"],"sourcesContent":["import type { ClipBinder, Pose, Target } from '@weasel-js/animator';\nimport type { PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport { scenePoseTarget, type PoseCascade, type PoseTargetScene } from './poseTarget';\n\n/** Options for `sceneClipTargets`. */\nexport interface SceneClipTargetsOptions<TPose> {\n  /** Rigs by the name a clip calls them: a track naming `rig:<name>` moves that rig's pose. */\n  rigs?: Readonly<Record<string, { readonly target: Target<Pose> }>>;\n  /** As `scenePoseTarget` takes them. */\n  descriptor?: PoseDescriptor<TPose>;\n  cascade?: PoseCascade<TPose>;\n}\n\n/**\n * A `ClipBinder.target` over a scene. `pose:<node id>` is that node's pose target, the one\n * `scenePoseTarget` answers, and `rig:<name>` is the target of the rig given under that\n * name. Any other name is `undefined`, for a caller to resolve itself first or after. A track\n * over part of a rig names joints as its `axes`, which the rig's target resolves.\n */\nexport function sceneClipTargets<TPose>(\n  scene: PoseTargetScene<TPose>,\n  options: SceneClipTargetsOptions<TPose> = {},\n): NonNullable<ClipBinder['target']> {\n  return (name) => {\n    if (name.startsWith('pose:')) return scenePoseTarget(scene, name.slice(5), options.descriptor, options.cascade);\n    if (name.startsWith('rig:')) return options.rigs?.[name.slice(4)]?.target;\n    return undefined;\n  };\n}\n"],"mappings":";;AAmBA,SAAgBA,EACd,GACA,IAA0C,CAAC,GACR;CACnC,QAAQ,MAAS;EACf,IAAIC,EAAK,WAAW,OAAO,GAAG,OAAOC,EAAgBC,GAAOF,EAAK,MAAM,CAAC,GAAGG,EAAQ,YAAYA,EAAQ,OAAO;EAC9G,IAAIH,EAAK,WAAW,MAAM,GAAG,OAAOG,EAAQ,OAAOH,EAAK,MAAM,CAAC,EAAE,EAAE;CAErE;AACF"}

package/dist/animation/index.js

@@ -1,20 +1,15 @@
-import { springPose as e, tweenPose as t } from "./poseHelpers.js";
-import { sampleTrack as n } from "./timeline/sampleTrack.js";
-import { ColorOverrideRegistry as r } from "./colorRegistry.js";
-import { useAnimator as i } from "./useAnimator.js";
-import { animateOnSetPose as a } from "./wrappers/animateOnSetPose.js";
-import { animateLifecycle as o } from "./wrappers/animateLifecycle.js";
-import { createReflowTransition as s, useAnimatedReflow as c } from "./reflow.js";
-import { momentum as l } from "./behaviors/momentum.js";
-import { createSlew as u, slewToward as d } from "./slew.js";
-import { cycleVertexColors as f, rainbowVertexColors as p, solidVertexColors as m, springVertexColors as h, staggerVertexColors as g, tweenVertexColors as _ } from "./colorHelpers.js";
-import { IDENTITY_JOINT as v } from "./rig/types.js";
-import { blendPoses as y } from "./rig/blendPoses.js";
-import { mirrorPose as b } from "./rig/mirrorPose.js";
-import { resolveSkeleton as x } from "./rig/resolveSkeleton.js";
-import { bindRig as S, rigidRigApply as C } from "./rig/bindRig.js";
-import { solveIk as w } from "./rig/solveIk.js";
-import { useRig as T } from "./rig/useRig.js";
-import { hexToOklchDeg as E, hslToSrgb as D, interpolateSrgb as O, lerpColorArray as k, lerpOklab as A, lerpOklch as j, linearSrgbToOklab as M, linearToSrgb as N, oklabToLinearSrgb as P, oklabToOklch as F, oklabToSrgbU8 as I, oklchDegToHex as L, oklchToOklab as R, srgbFloatToOklab as z, srgbToHsl as B, srgbToLinear as V, srgbU8ToOklab as H } from "@weasel-js/paint";
-import { EASINGS as U, SPRING_PRESETS as W, cubicBezierEasing as G, easeIn as K, easeInBack as q, easeInBounce as J, easeInCirc as Y, easeInCubic as X, easeInElastic as Z, easeInExpo as Q, easeInOut as $, easeInOutBack as ee, easeInOutBounce as te, easeInOutCirc as ne, easeInOutCubic as re, easeInOutElastic as ie, easeInOutExpo as ae, easeInOutQuad as oe, easeInOutQuart as se, easeInOutQuint as ce, easeInOutSine as le, easeInQuad as ue, easeInQuart as de, easeInQuint as fe, easeInSine as pe, easeOut as me, easeOutBack as he, easeOutBounce as ge, easeOutCirc as _e, easeOutCubic as ve, easeOutElastic as ye, easeOutExpo as be, easeOutQuad as xe, easeOutQuart as Se, easeOutQuint as Ce, easeOutSine as we, linear as Te, resolveEasing as Ee } from "@weasel-js/geom";
-export { r as ColorOverrideRegistry, U as EASINGS, v as IDENTITY_JOINT, W as SPRING_PRESETS, o as animateLifecycle, a as animateOnSetPose, S as bindRig, y as blendPoses, s as createReflowTransition, u as createSlew, G as cubicBezierEasing, f as cycleVertexColors, K as easeIn, q as easeInBack, J as easeInBounce, Y as easeInCirc, X as easeInCubic, Z as easeInElastic, Q as easeInExpo, $ as easeInOut, ee as easeInOutBack, te as easeInOutBounce, ne as easeInOutCirc, re as easeInOutCubic, ie as easeInOutElastic, ae as easeInOutExpo, oe as easeInOutQuad, se as easeInOutQuart, ce as easeInOutQuint, le as easeInOutSine, ue as easeInQuad, de as easeInQuart, fe as easeInQuint, pe as easeInSine, me as easeOut, he as easeOutBack, ge as easeOutBounce, _e as easeOutCirc, ve as easeOutCubic, ye as easeOutElastic, be as easeOutExpo, xe as easeOutQuad, Se as easeOutQuart, Ce as easeOutQuint, we as easeOutSine, E as hexToOklchDeg, D as hslToSrgb, O as interpolateSrgb, k as lerpColorArray, A as lerpOklab, j as lerpOklch, Te as linear, M as linearSrgbToOklab, N as linearToSrgb, b as mirrorPose, l as momentum, P as oklabToLinearSrgb, F as oklabToOklch, I as oklabToSrgbU8, L as oklchDegToHex, R as oklchToOklab, p as rainbowVertexColors, Ee as resolveEasing, x as resolveSkeleton, C as rigidRigApply, n as sampleTrack, d as slewToward, m as solidVertexColors, w as solveIk, e as springPose, h as springVertexColors, z as srgbFloatToOklab, B as srgbToHsl, V as srgbToLinear, H as srgbU8ToOklab, g as staggerVertexColors, t as tweenPose, _ as tweenVertexColors, c as useAnimatedReflow, i as useAnimator, T as useRig };
+import { createPoseTarget as e, poseAxes as t, scenePoseTarget as n } from "./poseTarget.js";
+import { dataRestPath as r } from "./rig/skinBinding.js";
+import { bindRig as i, rigidRigApply as a } from "./rig/bindRig.js";
+import { useRig as o } from "./rig/useRig.js";
+import { placeSkeleton as s, rigFromNode as c, unplaceSkeleton as l, useRigNode as u } from "./rig/rigNode.js";
+import { createWrittenPoseTarget as d } from "./writtenPoseTarget.js";
+import { sceneClipTargets as f } from "./clipTargets.js";
+import { springPose as p, staggerSpringPose as m, tweenPose as h } from "./poseHelpers.js";
+import { animateOnSetPose as g } from "./wrappers/animateOnSetPose.js";
+import { animateLifecycle as _ } from "./wrappers/animateLifecycle.js";
+import { createReflowTransition as v, useAnimatedReflow as y } from "./reflow.js";
+import { momentum as b } from "./behaviors/momentum.js";
+import { EASINGS as x, SPRING_PRESETS as S, cubicBezierEasing as C, easeIn as w, easeInBack as T, easeInBounce as E, easeInCirc as D, easeInCubic as O, easeInElastic as k, easeInExpo as A, easeInOut as j, easeInOutBack as M, easeInOutBounce as N, easeInOutCirc as P, easeInOutCubic as F, easeInOutElastic as I, easeInOutExpo as L, easeInOutQuad as R, easeInOutQuart as z, easeInOutQuint as B, easeInOutSine as V, easeInQuad as H, easeInQuart as U, easeInQuint as W, easeInSine as G, easeOut as K, easeOutBack as q, easeOutBounce as J, easeOutCirc as Y, easeOutCubic as X, easeOutElastic as Z, easeOutExpo as Q, easeOutQuad as $, easeOutQuart as ee, easeOutQuint as te, easeOutSine as ne, linear as re, resolveEasing as ie } from "@weasel-js/geom";
+import { hexToOklchDeg as ae, hslToSrgb as oe, interpolateSrgb as se, lerpColorArray as ce, lerpOklab as le, lerpOklch as ue, linearSrgbToOklab as de, linearToSrgb as fe, oklabToLinearSrgb as pe, oklabToOklch as me, oklabToSrgbU8 as he, oklchDegToHex as ge, oklchToOklab as _e, srgbFloatToOklab as ve, srgbToHsl as ye, srgbToLinear as be, srgbU8ToOklab as xe } from "@weasel-js/paint";
+export { x as EASINGS, S as SPRING_PRESETS, _ as animateLifecycle, g as animateOnSetPose, i as bindRig, e as createPoseTarget, v as createReflowTransition, d as createWrittenPoseTarget, C as cubicBezierEasing, r as dataRestPath, w as easeIn, T as easeInBack, E as easeInBounce, D as easeInCirc, O as easeInCubic, k as easeInElastic, A as easeInExpo, j as easeInOut, M as easeInOutBack, N as easeInOutBounce, P as easeInOutCirc, F as easeInOutCubic, I as easeInOutElastic, L as easeInOutExpo, R as easeInOutQuad, z as easeInOutQuart, B as easeInOutQuint, V as easeInOutSine, H as easeInQuad, U as easeInQuart, W as easeInQuint, G as easeInSine, K as easeOut, q as easeOutBack, J as easeOutBounce, Y as easeOutCirc, X as easeOutCubic, Z as easeOutElastic, Q as easeOutExpo, $ as easeOutQuad, ee as easeOutQuart, te as easeOutQuint, ne as easeOutSine, ae as hexToOklchDeg, oe as hslToSrgb, se as interpolateSrgb, ce as lerpColorArray, le as lerpOklab, ue as lerpOklch, re as linear, de as linearSrgbToOklab, fe as linearToSrgb, b as momentum, pe as oklabToLinearSrgb, me as oklabToOklch, he as oklabToSrgbU8, ge as oklchDegToHex, _e as oklchToOklab, s as placeSkeleton, t as poseAxes, ie as resolveEasing, c as rigFromNode, a as rigidRigApply, f as sceneClipTargets, n as scenePoseTarget, p as springPose, ve as srgbFloatToOklab, ye as srgbToHsl, be as srgbToLinear, xe as srgbU8ToOklab, m as staggerSpringPose, h as tweenPose, l as unplaceSkeleton, y as useAnimatedReflow, o as useRig, u as useRigNode };

package/dist/animation/poseHelpers.js

@@ -1,50 +1,129 @@
-import { createTransformOp as e } from "../core/ops/transform.js";
-import { RECT_POSE_DESCRIPTOR as t } from "../core/geometry/poseDescriptor.js";
+import { RECT_POSE_DESCRIPTOR as e } from "../core/geometry/poseDescriptor.js";
+import { createTransformOp as t } from "../core/ops/transform.js";
+import { rewindingSpring as n, rewindingTween as r } from "./rewind.js";
 //#region src/animation/poseHelpers.ts
-var n = (e) => `pose:${e}`;
-function r(t, n, r, i, a) {
-	if (!t.applyOps) return;
-	let o = e({
+var i = (e) => `pose:${e}`;
+function a(e, n, r, i, a) {
+	if (!e.applyOps) return;
+	let o = t({
 		id: n,
 		from: r,
 		to: i,
 		label: a
 	});
-	t.applyOps([o], a);
+	e.applyOps([o], a);
 }
-function i(e, i, a) {
-	let o = a.geometry ?? t;
-	if (!o.lerp) throw Error("tweenPose: geometry has no lerp; supply geometry: { ..., lerp }");
-	let s = o.lerp, c = i.getPose(a.id), l = a.recordOp ?? !0, u = a.opLabel ?? "animate";
-	return l && r(i, a.id, c, a.to, u), e.tween({
-		from: c,
-		to: a.to,
-		ms: a.ms,
-		easing: a.easing,
-		cancelKey: n(a.id),
-		interpolate: (e, t, n) => s(e, t, n),
-		onTick: (e) => i.setPose(a.id, e),
-		onDone: a.onDone
+function o(t, n, o) {
+	let s = o.recordOp ?? !0, c = o.opLabel ?? "animate", l = i(o.id), u = n.poseTarget?.(o.id, o.geometry);
+	if (u) {
+		let e = u.committed();
+		s && a(n, o.id, e, o.to, c);
+		let i = o.geometry?.lerp;
+		return o.rewind ? r(t, u, {
+			start: e,
+			from: o.from ?? e,
+			to: o.to,
+			ms: o.ms,
+			easing: o.easing,
+			cancelKey: l,
+			interpolate: i && ((e, t, n) => i(e, t, n)),
+			onDone: o.onDone
+		}) : t.tween({
+			target: u,
+			from: o.from ?? e,
+			to: o.to,
+			ms: o.ms,
+			easing: o.easing,
+			cancelKey: l,
+			interrupt: !1,
+			interpolate: i && ((e, t, n) => i(e, t, n)),
+			onDone: o.onDone
+		});
+	}
+	let d = o.geometry ?? e;
+	if (!d.lerp) throw Error("tweenPose: geometry has no lerp; supply geometry: { ..., lerp }");
+	let f = d.lerp, p = n.getPose(o.id);
+	return s && a(n, o.id, p, o.to, c), t.tween({
+		from: o.from ?? p,
+		to: o.to,
+		ms: o.ms,
+		easing: o.easing,
+		cancelKey: l,
+		interpolate: (e, t, n) => f(e, t, n),
+		onTick: (e) => n.setPose(o.id, e),
+		onDone: o.onDone
 	});
 }
-function a(e, i, a) {
-	let o = a.geometry ?? t;
-	if (!o.lerp) throw Error("springPose: geometry has no lerp; supply geometry: { ..., lerp }");
-	let s = o.lerp, c = i.getPose(a.id), l = a.recordOp ?? !0, u = a.opLabel ?? "animate";
-	return l && r(i, a.id, c, a.to, u), e.spring({
+function s(t, r, o) {
+	let s = o.recordOp ?? !0, c = o.opLabel ?? "animate", l = i(o.id), u = r.poseTarget?.(o.id, o.geometry);
+	if (u) {
+		let e = u.read(), i = u.committed();
+		return s && a(r, o.id, i, o.to, c), o.rewind ? n(t, u, {
+			start: i,
+			from: e,
+			to: o.to,
+			cancelKey: l,
+			onDone: o.onDone,
+			tuning: {
+				preset: o.preset,
+				stiffness: o.stiffness,
+				damping: o.damping,
+				mass: o.mass
+			}
+		}) : t.spring({
+			target: u,
+			from: e,
+			to: o.to,
+			preset: o.preset,
+			stiffness: o.stiffness,
+			damping: o.damping,
+			mass: o.mass,
+			cancelKey: l,
+			onDone: o.onDone
+		});
+	}
+	let d = o.geometry ?? e;
+	if (!d.lerp) throw Error("springPose: geometry has no lerp; supply geometry: { ..., lerp }");
+	let f = d.lerp, p = r.getPose(o.id);
+	return s && a(r, o.id, p, o.to, c), t.spring({
 		from: 0,
 		to: 1,
-		preset: a.preset,
-		stiffness: a.stiffness,
-		damping: a.damping,
-		mass: a.mass,
-		cancelKey: n(a.id),
+		preset: o.preset,
+		stiffness: o.stiffness,
+		damping: o.damping,
+		mass: o.mass,
+		cancelKey: l,
 		interpolate: (e, t, n) => e + (t - e) * n,
-		onTick: (e) => i.setPose(a.id, s(c, a.to, e)),
-		onDone: a.onDone
+		onTick: (e) => r.setPose(o.id, f(p, o.to, e)),
+		onDone: o.onDone
+	});
+}
+function c(e) {
+	if (typeof e == "object" && e && "id" in e) {
+		let t = e.id;
+		if (typeof t == "string") return t;
+	}
+	if (typeof e == "string" || typeof e == "number") return String(e);
+	throw Error("staggerSpringPose: each item must either be a primitive (string/number) or have a string `id` field. Otherwise pose ids would collide.");
+}
+function l(e, t, n) {
+	return e.stagger(n.items, n.delay).each((r, i) => s(e, t, {
+		id: c(r),
+		to: n.to(r, i),
+		preset: n.preset,
+		stiffness: n.stiffness,
+		damping: n.damping,
+		mass: n.mass,
+		geometry: n.geometry,
+		recordOp: n.recordOp,
+		opLabel: n.opLabel,
+		rewind: n.rewind
+	}), {
+		cancelKey: n.cancelKey,
+		label: n.label
 	});
 }
 //#endregion
-export { a as springPose, i as tweenPose };
+export { i as poseKey, s as springPose, l as staggerSpringPose, o as tweenPose };
 
 //# sourceMappingURL=poseHelpers.js.map