@weasel-js/core 1.7.0 → 1.7.1

package/dist/affordances/pathAnchors.js

@@ -0,0 +1,66 @@
+import { enumerateAnchors as e } from "../interactions/actions/edit-anchors/geometry.js";
+//#region src/affordances/pathAnchors.ts
+var t = "path-edit.anchors";
+function n(n, r = {}) {
+	let { hitRadius: i = 8, cursor: a = "pointer" } = r, o = (e) => {
+		let t = n();
+		if (!t) return [];
+		let r = [];
+		for (let n of e.selection) {
+			let e = t.getPose(n);
+			e && e.kind === "polygon" && r.push({
+				id: n,
+				path: e
+			});
+		}
+		return r;
+	}, s = (e, t, n, r, o, s) => ({
+		id: e,
+		targetId: null,
+		shape: {
+			kind: "point",
+			x: n,
+			y: r,
+			hitRadiusPx: i
+		},
+		hitKind: s,
+		cursor: a,
+		bind: () => ({ initialScratch: {
+			...o,
+			targetId: t
+		} })
+	});
+	return [{
+		id: t,
+		regions(t) {
+			let r = n()?.editingId ?? null, i = [];
+			for (let { id: n, path: a } of o(t)) if (r === null || n === r) for (let t of e(a)) i.push(s(`${n}:anchor:${t.anchorIndex}`, n, t.x, t.y, {
+				targetId: n,
+				anchorIndex: t.anchorIndex,
+				part: "anchor"
+			}, `anchor:${t.anchorIndex}`));
+			return i;
+		}
+	}, {
+		id: t,
+		regions(t) {
+			let r = n()?.editingId ?? null;
+			if (r === null) return [];
+			let i = [];
+			for (let { id: n, path: a } of o(t)) if (n === r) for (let t of e(a)) t.controlIn && i.push(s(`${n}:controlIn:${t.anchorIndex}`, n, t.controlIn.x, t.controlIn.y, {
+				targetId: n,
+				anchorIndex: t.anchorIndex,
+				part: "controlIn"
+			}, `controlIn:${t.anchorIndex}`)), t.controlOut && i.push(s(`${n}:controlOut:${t.anchorIndex}`, n, t.controlOut.x, t.controlOut.y, {
+				targetId: n,
+				anchorIndex: t.anchorIndex,
+				part: "controlOut"
+			}, `controlOut:${t.anchorIndex}`));
+			return i;
+		}
+	}];
+}
+//#endregion
+export { t as PATH_ANCHOR_CHROME_ID, n as createPathAnchorAffordances };
+
+//# sourceMappingURL=pathAnchors.js.map

package/dist/affordances/pathAnchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathAnchors.js","names":["PATH_ANCHOR_CHROME_ID","createPathAnchorAffordances","opts","editablePaths","anchorState","getAnchorState","out","id","state","pose","point","hitRadius","scratch","editingId","a","enumerateAnchors","path"],"sources":["../../src/affordances/pathAnchors.ts"],"sourcesContent":["/**\n * Path anchor + control-handle affordances.\n *\n * These were the last piece of selection chrome whose geometry lived only\n * inside `canvas/affordanceAt.ts`'s hand-written classifier. Expressing them\n * as regions puts every kit affordance behind one hit-test walk, which is\n * what lets `AffordanceRegion.cursor` and nearest-region picking apply here\n * too rather than only to the chrome that happened to be declarative already.\n */\n\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors } from 'interactions/actions/edit-anchors/geometry';\n\n/**\n * Live anchor-editing state, read fresh on every hit-test.\n *\n * Anchors are not derivable from `ChromeState` — they come off the editable\n * path behind whatever the consumer's `editAnchors` dep exposes — so this\n * thunk is the seam. It's called on every pointer event, so it must be cheap\n * (O(1) field reads); enumeration happens inside `regions()`.\n */\nexport interface AnchorState {\n  /** Id of the path currently in anchor-edit mode, or `null`. Control handles\n   *  are only hittable on the path that is being edited. */\n  editingId: string | null;\n  /** Current editable path for a node id. Non-polygon values are ignored. */\n  getPose(id: string): unknown;\n}\n\n/** Options for the path-anchor affordances. */\nexport interface PathAnchorAffordanceOptions {\n  /** Hit radius (screen-px) for anchor and control points. Default 8. */\n  hitRadius?: number;\n  /** Cursor while hovering an anchor or control. Defaults to `'pointer'`. */\n  cursor?: CursorSpec;\n}\n\n/** What an anchor hit hands to the action that follows: which path, which\n *  anchor, and whether the grab was on the anchor itself or one of its two\n *  control points. */\nexport interface AnchorScratch extends CommonAffordanceScratch {\n  /** Node id of the path the anchor belongs to. */\n  targetId: string;\n  /** Sequential anchor index in path walk order. */\n  anchorIndex: number;\n  /** Which of the anchor's three grabbable points this is. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n}\n\n/** Chrome-caps id gating both returned affordances. */\nexport const PATH_ANCHOR_CHROME_ID = 'path-edit.anchors';\n\n/**\n * Anchor + control affordances for the selected paths, bottom → top.\n *\n * Returns **two** affordances rather than one so that a control handle beats\n * an anchor regardless of which is nearer — the same preference `hitAnchor`\n * encodes, and the same one the rendering has (controls draw on top). Within\n * each of the two, nearest wins. They deliberately share one id: chrome-caps\n * gates anchor editing as a single piece of chrome, and splitting the id\n * would invent a visibility rule nothing asked for.\n *\n * Order matters — spread this into an affordance list in the returned order.\n */\nexport function createPathAnchorAffordances(\n  getAnchorState: () => AnchorState | null,\n  opts: PathAnchorAffordanceOptions = {},\n): Affordance[] {\n  const { hitRadius = 8, cursor = 'pointer' } = opts;\n\n  /** Selected polygon paths, paired with their node id. */\n  const editablePaths = (state: ChromeState): Array<{ id: string; path: PolygonPath }> => {\n    const anchorState = getAnchorState();\n    if (!anchorState) return [];\n    const out: Array<{ id: string; path: PolygonPath }> = [];\n    for (const id of state.selection) {\n      const pose = anchorState.getPose(id);\n      if (!pose || (pose as { kind?: string }).kind !== 'polygon') continue;\n      out.push({ id, path: pose as PolygonPath });\n    }\n    return out;\n  };\n\n  const point = (\n    id: string,\n    targetId: string,\n    x: number,\n    y: number,\n    scratch: AnchorScratch,\n    hitKind: string,\n  ): AffordanceRegion => ({\n    id,\n    // Anchor coordinates are already in the path's own space, which for an\n    // editable path is world space — the pose rotation that `targetId` would\n    // introduce is baked into the coords. Anchoring to `null` keeps the\n    // framework from applying it twice.\n    targetId: null,\n    shape: { kind: 'point', x, y, hitRadiusPx: hitRadius },\n    hitKind,\n    cursor,\n    bind: (): AffordanceBinding => ({ initialScratch: { ...scratch, targetId } }),\n  });\n\n  const anchors: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const editingId = getAnchorState()?.editingId ?? null;\n      const out: AffordanceRegion[] = [];\n      for (const { id, path } of editablePaths(state)) {\n        // `editAnchorsAction` edits whatever path the dep says is in edit\n        // mode, ignoring which one was hit — so once a path IS being edited,\n        // only its own anchors may claim the press. The overlay paints only\n        // that path's anchors too.\n        if (editingId !== null && id !== editingId) continue;\n        for (const a of enumerateAnchors(path)) {\n          out.push(point(\n            `${id}:anchor:${a.anchorIndex}`,\n            id, a.x, a.y,\n            { targetId: id, anchorIndex: a.anchorIndex, part: 'anchor' },\n            `anchor:${a.anchorIndex}`,\n          ));\n        }\n      }\n      return out;\n    },\n  };\n\n  const controls: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const anchorState = getAnchorState();\n      const editingId = anchorState?.editingId ?? null;\n      if (editingId === null) return [];\n      const out: AffordanceRegion[] = [];\n      for (const { id, path } of editablePaths(state)) {\n        // Controls are grabbable only on the path actually in edit mode.\n        if (id !== editingId) continue;\n        for (const a of enumerateAnchors(path)) {\n          if (a.controlIn) {\n            out.push(point(\n              `${id}:controlIn:${a.anchorIndex}`,\n              id, a.controlIn.x, a.controlIn.y,\n              { targetId: id, anchorIndex: a.anchorIndex, part: 'controlIn' },\n              `controlIn:${a.anchorIndex}`,\n            ));\n          }\n          if (a.controlOut) {\n            out.push(point(\n              `${id}:controlOut:${a.anchorIndex}`,\n              id, a.controlOut.x, a.controlOut.y,\n              { targetId: id, anchorIndex: a.anchorIndex, part: 'controlOut' },\n              `controlOut:${a.anchorIndex}`,\n            ));\n          }\n        }\n      }\n      return out;\n    },\n  };\n\n  return [anchors, controls];\n}\n"],"mappings":";;AAqDA,IAAaA,IAAwB;AAcrC,SAAgBC,EACd,GACA,IAAoC,CAAC,GACvB;CACd,IAAM,EAAE,eAAY,GAAG,YAAS,cAAcC,GAGxCC,KAAiB,MAAiE;EACtF,IAAMC,IAAcC,EAAe;EACnC,IAAI,CAACD,GAAa,OAAO,CAAC;EAC1B,IAAME,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAMC,EAAM,WAAW;GAChC,IAAMC,IAAOL,EAAY,QAAQG,CAAE;GACnC,AAAKE,KAASA,EAA2B,SAAS,aAClDH,EAAI,KAAK;IAAE;IAAI,MAAMG;GAAoB,CAAC;EAC5C;EACA,OAAOH;CACT,GAEMI,KACJ,GACA,GACA,GACA,GACA,GACA,OACsB;EACtB;EAKA,UAAU;EACV,OAAO;GAAE,MAAM;GAAS;GAAG;GAAG,aAAaC;EAAU;EACrD;EACA;EACA,aAAgC,EAAE,gBAAgB;GAAE,GAAGC;GAAS;EAAS,EAAE;CAC7E;CA2DA,OAAO,CAAC;EAxDN,IAAIZ;EACJ,QAAQ,GAAO;GACb,IAAMa,IAAYR,EAAe,CAAC,EAAE,aAAa,MAC3CC,IAA0B,CAAC;GACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAK5C,IAAIK,MAAc,QAAQN,MAAOM,GACjC,KAAK,IAAMC,KAAKC,EAAiBC,CAAI,GACnC,EAAI,KAAKN,EACP,GAAGH,EAAG,UAAUO,EAAE,eAClBP,GAAIO,EAAE,GAAGA,EAAE,GACX;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAS,GAC3D,UAAUA,EAAE,aACd,CAAC;GAGL,OAAOR;EACT;CAoCM,GAAS;EAhCf,IAAIN;EACJ,QAAQ,GAAO;GAEb,IAAMa,IADcR,EACF,CAAA,EAAa,aAAa;GAC5C,IAAIQ,MAAc,MAAM,OAAO,CAAC;GAChC,IAAMP,IAA0B,CAAC;GACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAE5C,IAAID,MAAOM,GACX,KAAK,IAAMC,KAAKC,EAAiBC,CAAI,GASnC,AARIF,EAAE,aACJR,EAAI,KAAKI,EACP,GAAGH,EAAG,aAAaO,EAAE,eACrBP,GAAIO,EAAE,UAAU,GAAGA,EAAE,UAAU,GAC/B;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAY,GAC9D,aAAaA,EAAE,aACjB,CAAC,GAECA,EAAE,cACJR,EAAI,KAAKI,EACP,GAAGH,EAAG,cAAcO,EAAE,eACtBP,GAAIO,EAAE,WAAW,GAAGA,EAAE,WAAW,GACjC;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAa,GAC/D,cAAcA,EAAE,aAClB,CAAC;GAIP,OAAOR;EACT;CAGe,CAAQ;AAC3B"}

package/dist/affordances/rotationHandle.js

@@ -0,0 +1,103 @@
+import { MULTI_RESIZE_TARGET_ID as e } from "../core/selection/selectionTarget.js";
+import { angleOf as t, transformOf as n } from "./hitAffordanceRegions.js";
+//#region src/affordances/rotationHandle.ts
+var r = (e) => "fill" in e || "stroke" in e || "insetPx" in e, i = {
+	fill: {
+		fill: "solid",
+		color: "rgba(26, 19, 13, 0.12)"
+	},
+	insetPx: 10
+};
+function a(e = {}) {
+	let { bandPx: a = 24, paint: s = i, cursor: c, handle: l } = e, u = s ? r(s) ? {
+		kind: "annulus",
+		...s.fill ? { fill: s.fill } : {},
+		...s.stroke ? { stroke: s.stroke } : {},
+		...s.insetPx === void 0 ? {} : { insetPx: s.insetPx }
+	} : {
+		kind: "annulus",
+		stroke: s
+	} : null;
+	return {
+		id: "selection.rotation-handle",
+		regions(e) {
+			let r = o(e);
+			if (!r) return [];
+			let i = r.bounds, s = i.width / 2, d = i.height / 2, f = c ?? {
+				glyph: "rotate",
+				angle: t(n(e, r.id)),
+				fallback: "grab"
+			}, p = () => ({ initialScratch: {
+				targetId: r.id,
+				fixedPoint: {
+					x: i.x + s,
+					y: i.y + d
+				}
+			} }), m = {
+				id: "selection.rotation-handle",
+				targetId: r.id,
+				shape: {
+					kind: "annulus",
+					cx: i.x + s,
+					cy: i.y + d,
+					rx: s * Math.SQRT2,
+					ry: d * Math.SQRT2,
+					innerX: i.x,
+					innerY: i.y,
+					innerWidth: i.width,
+					innerHeight: i.height,
+					minBandPx: a
+				},
+				...u ? { paint: u } : {},
+				hitKind: "rotate-handle",
+				cursor: f,
+				bind: p
+			};
+			return l ? [m, {
+				id: "rotation-badge",
+				targetId: r.id,
+				shape: {
+					kind: "point",
+					x: i.x + s,
+					y: i.y,
+					hitRadiusPx: l.hitRadiusPx,
+					standoff: {
+						px: l.distancePx,
+						normal: {
+							x: 0,
+							y: -1
+						}
+					}
+				},
+				hitKind: "rotate-handle",
+				cursor: f,
+				bind: p
+			}] : [m];
+		}
+	};
+}
+function o(t) {
+	if (t.selection.length === 1) {
+		let e = t.selection[0];
+		if (t.canRotate && !t.canRotate(e)) return null;
+		let n = t.boundsOf(e);
+		return n ? {
+			id: e,
+			bounds: n
+		} : null;
+	}
+	if (t.multiActive && t.unionBounds) {
+		if (t.canRotate) {
+			for (let e of t.selection) if (!t.canRotate(e)) return null;
+		}
+		return {
+			id: e,
+			bounds: t.unionBounds
+		};
+	}
+	return null;
+}
+//#endregion
+export { a as createRotationAffordance };
+
+//# sourceMappingURL=rotationHandle.js.map

package/dist/affordances/rotationHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotationHandle.js","names":["isAnnulusForm","paint","DEFAULT_PAINT","createRotationAffordance","opts","annulusPaint","target","pickTarget","state","b","halfW","halfH","regionCursor","cursor","angleOf","transformOf","bind","region","bandPx","handle","id","MULTI_RESIZE_TARGET_ID"],"sources":["../../src/affordances/rotationHandle.ts"],"sourcesContent":["import type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport { angleOf, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\n\n/** Options for `createRotationAffordance` — how thick the rotate band is\n *  outside the selection, and how (or whether) it is painted. */\nexport interface RotationAffordanceOptions {\n  /** Minimum screen-space thickness of the rotate-zone band outside the\n   *  selection AABB. The outer ellipse semi-axes are clamped to\n   *  `max(w/√2, w/2 + bandPx/scale)` so the zone stays hoverable at any\n   *  zoom and any selection size. Default 24. */\n  bandPx?: number;\n  /** Paint for the ring. `null` / `false` = invisible. Default is a\n   *  semi-transparent fill of the band, contracted by `insetPx` screen\n   *  pixels on the outer edge so the visible band sits inside the\n   *  hoverable zone with a clear margin. Pass a `Stroke` (or\n   *  `{ fill, stroke, insetPx }`) to override. */\n  paint?:\n    | Stroke\n    | { fill?: FillStyle; stroke?: Stroke; insetPx?: number }\n    | null\n    | false;\n  /** Cursor while hovering the ring. Defaults to the `rotate` glyph turned\n   *  with the target, falling back to `'grab'` if the browser rejects the\n   *  image. */\n  cursor?: CursorSpec;\n  /** A grab region for a rotate badge painted off the top edge — the one\n   *  the selection overlay's `rotationHandle` draws. `distancePx` is how far\n   *  off the edge it sits and `hitRadiusPx` the half-extent of its square,\n   *  both in screen pixels. Placed by the same `standoff` the painted badge\n   *  is, so the two cannot drift apart. Omitted, only the ring rotates. */\n  handle?: { distancePx: number; hitRadiusPx: number };\n}\n\n/** What a rotation-handle hit hands to the rotate action: what is being\n *  rotated, and the world-space pivot it turns around. */\nexport interface RotationScratch extends CommonAffordanceScratch {\n  /** Id of the rotation target — single selection id, or\n   *  `MULTI_RESIZE_TARGET_ID` for multi-selection. */\n  targetId: string;\n  /** Rotation pivot in world coords — the AABB (or union AABB) center. */\n  fixedPoint: { x: number; y: number };\n}\n\ntype AnnulusPaintForm = { fill?: FillStyle; stroke?: Stroke; insetPx?: number };\n\nconst isAnnulusForm = (paint: Stroke | AnnulusPaintForm): paint is AnnulusPaintForm =>\n  'fill' in paint || 'stroke' in paint || 'insetPx' in paint;\n\nconst DEFAULT_PAINT: AnnulusPaintForm = {\n  fill: { fill: 'solid', color: 'rgba(26, 19, 13, 0.12)' },\n  insetPx: 10,\n};\n\n/**\n * @experimental\n * Rotation affordance for the active selection. Replaces the legacy\n * \"small dot above the AABB\" handle with an invisible elliptical ring\n * that wraps the selection: the smallest ellipse containing the AABB,\n * minus the AABB itself. Hovering the ring sets the cursor (default\n * `'grab'`) and drag-from-ring triggers `rotateAction` via the same\n * binding path the old point-handle used (id stays\n * `'selection.rotation-handle'`).\n *\n * The ring is target-local — under target rotation the ellipse rotates\n * with the AABB so the hoverable band always wraps the rendered shape.\n *\n * Visibility: gated by chrome-caps' `'selection.rotation-handle'` rule.\n * The `paint` option drives optional dev-time ring stroke; production\n * defaults to invisible (the cursor change is the only on-hover cue).\n */\nexport function createRotationAffordance(\n  opts: RotationAffordanceOptions = {},\n): Affordance {\n  const { bandPx = 24, paint = DEFAULT_PAINT, cursor, handle } = opts;\n\n  // Normalize `paint` into the AnnulusPaint shape understood by\n  // `composeAffordanceLayer`. Three input forms are accepted: a bare\n  // `Stroke` (legacy outline form), the `{ fill, stroke, insetPx }`\n  // object form, or `null`/`false` for invisible. The object form is what\n  // carries these three keys; `Stroke` carries none of them, and cannot be\n  // told apart by its own `paint` since that is optional.\n  const annulusPaint:\n    | { kind: 'annulus'; fill?: FillStyle; stroke?: Stroke; insetPx?: number }\n    | null = (() => {\n      if (!paint) return null;\n      if (!isAnnulusForm(paint)) {\n        return { kind: 'annulus' as const, stroke: paint };\n      }\n      return {\n        kind: 'annulus' as const,\n        ...(paint.fill ? { fill: paint.fill } : {}),\n        ...(paint.stroke ? { stroke: paint.stroke } : {}),\n        ...(paint.insetPx !== undefined ? { insetPx: paint.insetPx } : {}),\n      };\n    })();\n\n  return {\n    id: 'selection.rotation-handle',\n    regions(state: ChromeState): readonly AffordanceRegion[] {\n      const target = pickTarget(state);\n      if (!target) return [];\n      const b = target.bounds;\n\n      // The natural ring: the smallest ellipse containing the AABB. For a\n      // small or thin selection that band is too tight to hover, so\n      // `minBandPx` asks the framework to widen it to at least `bandPx`\n      // screen pixels outside the rect. The floor is declared in screen units\n      // rather than applied here because `ChromeState` carries no view scale\n      // — the framework applies it at paint and hit time, where the view is\n      // known, so the ring holds its apparent thickness at any zoom.\n      const halfW = b.width / 2;\n      const halfH = b.height / 2;\n\n      // Turned with the target, so the arc follows the selection it rotates.\n      // Resolved per region rather than defaulted in the option list because\n      // the angle is only known once a target is picked.\n      const regionCursor: CursorSpec = cursor ?? {\n        glyph: 'rotate',\n        angle: angleOf(transformOf(state, target.id)),\n        fallback: 'grab',\n      };\n      const bind = (): AffordanceBinding => ({\n        initialScratch: {\n          targetId: target.id,\n          // Pivot. `rotateAction` recomputes its own union pivot for\n          // multi-selection, but the single-target case reads this.\n          fixedPoint: { x: b.x + halfW, y: b.y + halfH },\n        } satisfies RotationScratch,\n      });\n\n      const region: AffordanceRegion = {\n        id: 'selection.rotation-handle',\n        targetId: target.id,\n        shape: {\n          kind: 'annulus',\n          cx: b.x + halfW,\n          cy: b.y + halfH,\n          rx: halfW * Math.SQRT2,\n          ry: halfH * Math.SQRT2,\n          innerX: b.x,\n          innerY: b.y,\n          innerWidth: b.width,\n          innerHeight: b.height,\n          minBandPx: bandPx,\n        },\n        ...(annulusPaint ? { paint: annulusPaint } : {}),\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      if (!handle) return [region];\n      const badge: AffordanceRegion = {\n        id: 'rotation-badge',\n        targetId: target.id,\n        shape: {\n          kind: 'point',\n          x: b.x + halfW,\n          y: b.y,\n          hitRadiusPx: handle.hitRadiusPx,\n          standoff: { px: handle.distancePx, normal: { x: 0, y: -1 } },\n        },\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      return [region, badge];\n    },\n  };\n}\n\nfunction pickTarget(state: ChromeState): { id: string; bounds: Bounds } | null {\n  if (state.selection.length === 1) {\n    const id = state.selection[0];\n    // Skip when the selected node's pose-descriptor declares it can't\n    // carry a rotation. Without this the rotation affordance would expose\n    // a rotate cursor over (e.g.) polygon-Path selections whose\n    // `rotateAction` write is silently dropped at paint time.\n    if (state.canRotate && !state.canRotate(id)) return null;\n    const b = state.boundsOf(id);\n    return b ? { id, bounds: b } : null;\n  }\n  // Multi-selection: anchor the ring to the union AABB. `rotateAction`\n  // ignores the synthetic id and pivots at its own union center\n  // (`useUnionPivot: ids.length > 1` branch in `defaults/rotate.ts`).\n  // Require every selected id to support rotation — a partial multi-rotate\n  // (some ids rotate, others silently no-op) would feel broken.\n  if (state.multiActive && state.unionBounds) {\n    if (state.canRotate) {\n      for (const id of state.selection) {\n        if (!state.canRotate(id)) return null;\n      }\n    }\n    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };\n  }\n  return null;\n}\n"],"mappings":";;;AAiDA,IAAMA,KAAiB,MACrB,UAAUC,KAAS,YAAYA,KAAS,aAAaA,GAEjDC,IAAkC;CACtC,MAAM;EAAE,MAAM;EAAS,OAAO;CAAyB;CACvD,SAAS;AACX;AAmBA,SAAgBC,EACd,IAAkC,CAAC,GACvB;CACZ,IAAM,EAAE,YAAS,IAAI,WAAQD,GAAe,WAAQ,cAAWE,GAQzDC,IAGGJ,IACAD,EAAcC,CAAK,IAGjB;EACL,MAAM;EACN,GAAIA,EAAM,OAAO,EAAE,MAAMA,EAAM,KAAK,IAAI,CAAC;EACzC,GAAIA,EAAM,SAAS,EAAE,QAAQA,EAAM,OAAO,IAAI,CAAC;EAC/C,GAAIA,EAAM,YAAY,KAAA,IAAyC,CAAC,IAA9B,EAAE,SAASA,EAAM,QAAQ;CAC7D,IAPS;EAAE,MAAM;EAAoB,QAAQA;CAAM,IAFhC;CAYvB,OAAO;EACL,IAAI;EACJ,QAAQ,GAAiD;GACvD,IAAMK,IAASC,EAAWC,CAAK;GAC/B,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAIH,EAAO,QASXI,IAAQD,EAAE,QAAQ,GAClBE,IAAQF,EAAE,SAAS,GAKnBG,IAA2BC,KAAU;IACzC,OAAO;IACP,OAAOC,EAAQC,EAAYP,GAAOF,EAAO,EAAE,CAAC;IAC5C,UAAU;GACZ,GACMU,WAAiC,EACrC,gBAAgB;IACd,UAAUV,EAAO;IAGjB,YAAY;KAAE,GAAGG,EAAE,IAAIC;KAAO,GAAGD,EAAE,IAAIE;IAAM;GAC/C,EACF,IAEMM,IAA2B;IAC/B,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,IAAIG,EAAE,IAAIC;KACV,IAAID,EAAE,IAAIE;KACV,IAAID,IAAQ,KAAK;KACjB,IAAIC,IAAQ,KAAK;KACjB,QAAQF,EAAE;KACV,QAAQA,EAAE;KACV,YAAYA,EAAE;KACd,aAAaA,EAAE;KACf,WAAWS;IACb;IACA,GAAIb,IAAe,EAAE,OAAOA,EAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQO;IACR;GACF;GAgBA,OAfKO,IAeE,CAACF,GAAQ;IAbd,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAGG,EAAE,IAAIC;KACT,GAAGD,EAAE;KACL,aAAaU,EAAO;KACpB,UAAU;MAAE,IAAIA,EAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQP;IACR;GAEc,CAAK,IAfD,CAACK,CAAM;EAgB7B;CACF;AACF;AAEA,SAASV,EAAW,GAA2D;CAC7E,IAAIC,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMY,IAAKZ,EAAM,UAAU;EAK3B,IAAIA,EAAM,aAAa,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EACpD,IAAMX,IAAID,EAAM,SAASY,CAAE;EAC3B,OAAOX,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CAMA,IAAID,EAAM,eAAeA,EAAM,aAAa;EAC1C,IAAIA,EAAM,WACH;QAAA,IAAMY,KAAMZ,EAAM,WACrB,IAAI,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EAAA;EAGrC,OAAO;GAAE,IAAIC;GAAwB,QAAQb,EAAM;EAAY;CACjE;CACA,OAAO;AACT"}

package/dist/animation/behaviors/momentum.js

@@ -0,0 +1,118 @@
+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 { getScratch as r, scratchKey as i, setScratch as a } from "@weasel-js/routing";
+//#region src/animation/behaviors/momentum.ts
+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.bounds, f = i.boundary ?? "stop", p = i.poseDescriptor ?? n, m = (e, t, n, r) => {
+		let i = e + n, a = t + r;
+		if (!d) return {
+			nx: i,
+			ny: a,
+			hit: !1
+		};
+		let o = !1;
+		return i < d.x ? (i = d.x, o = !0) : i > d.x + d.width && (i = d.x + d.width, o = !0), a < d.y ? (a = d.y, o = !0) : a > d.y + d.height && (a = d.y + d.height, o = !0), {
+			nx: i,
+			ny: a,
+			hit: o
+		};
+	}, h = (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 = u() - l * 4;
+		for (; t.length > 1 && t[0].t < n;) t.shift();
+	};
+	return {
+		onStart(e) {
+			a(e.scratch, o, []), h(e);
+		},
+		onMove(e) {
+			h(e);
+		},
+		onEnd(n, a) {
+			if (a.answered) return;
+			let u = r(n.scratch, o) ?? [];
+			if (u.length < 2) return;
+			let h = u[u.length - 1], g = h.t - l, _ = u[0];
+			for (let e of u) if (e.t >= g) {
+				_ = e;
+				break;
+			}
+			let v = (h.t - _.t) / 1e3;
+			if (v <= 0) return;
+			let y = (h.x - _.x) / v, b = (h.y - _.y) / v;
+			if (Math.hypot(y, b) < c) return;
+			let x = new Map(n.current), S = {
+				x: 0,
+				y: 0
+			}, C = n.adapter, w = /* @__PURE__ */ new Map(), T = null;
+			T = i.animator.decay({
+				from: {
+					x: 0,
+					y: 0
+				},
+				velocity: {
+					x: y,
+					y: b
+				},
+				friction: s,
+				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) => {
+					S = e;
+					let r = d !== void 0;
+					for (let i of n.draggedIds) {
+						let n = x.get(i);
+						if (!n) continue;
+						let a = p.getBounds(n), { nx: o, ny: s, hit: c } = m(a.x, a.y, e.x, e.y);
+						c || (r = !1), w.set(i, {
+							x: o,
+							y: s
+						}), C.setPose(i, t(n, o - a.x, s - a.y, p));
+					}
+					f === "stop" && r && T && (T.cancel(), E());
+				},
+				onDone: () => {
+					E();
+				}
+			});
+			function E() {
+				if (!C.applyOps) return;
+				let r = [];
+				for (let i of n.draggedIds) {
+					let n = x.get(i);
+					if (!n) continue;
+					let a = p.getBounds(n), o = w.get(i) ?? {
+						x: a.x + S.x,
+						y: a.y + S.y
+					}, s = t(n, o.x - a.x, o.y - a.y, p);
+					r.push(e({
+						id: i,
+						from: n,
+						to: s,
+						label: "flick"
+					}));
+				}
+				r.length > 0 && C.applyOps(r, "flick");
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+export { s as momentum };
+
+//# sourceMappingURL=momentum.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"momentum.js","names":["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","end","last","first","s","dt","vx","vy","startPoses","lastValue","adapter","finalPositions","decayHandle","a","b","v","k","delta","allHit","id","start","o","translatePoseViaDescriptor","commitFlick","ops","fp","finalPose","createTransformOp"],"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 { 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 px/sec\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 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 travelling, until friction brings it below\n * `threshold`.\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.\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  return {\n    onStart(ctx) {\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 as { setPose(id: string, p: TPose): void; applyOps?(ops: Op[], label: string): void };\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      let decayHandle: { cancel(): void } | null = null;\n      decayHandle = opts.animator.decay<RectLike>({\n        from: { x: 0, y: 0 },\n        velocity: { x: vx, y: vy },\n        friction,\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          for (const id of ctx.draggedIds) {\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            adapter.setPose(id, translatePoseViaDescriptor(start, nx - o.x, ny - o.y, d));\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 && decayHandle) {\n            decayHandle.cancel();\n            // Manually fire onDone since cancel() bypasses it.\n            commitFlick();\n          }\n        },\n        onDone: () => {\n          commitFlick();\n        },\n      });\n\n      function commitFlick(): void {\n        if (!adapter.applyOps) return;\n        const ops: Op[] = [];\n        for (const id of ctx.draggedIds) {\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          ops.push(createTransformOp<TPose>({ id, from: start, to: finalPose, label: 'flick' }));\n        }\n        if (ops.length > 0) adapter.applyOps(ops, 'flick');\n      }\n\n      return null;\n    },\n  };\n}\n"],"mappings":";;;;;AAoDA,IAAMA,IAAUC,EAA4B,kBAAkB;AAW9D,SAAgBC,EAAgB,GAA4C;CAC1E,IAAMC,IAAWC,EAAK,YAAY,KAC5BC,IAAYD,EAAK,aAAa,KAC9BE,IAAWF,EAAK,oBAAoB,IACpCG,IAAMH,EAAK,cAAc,KAAK,IAAI,IAClCI,IAASJ,EAAK,QACdK,IAAiBL,EAAK,YAAY,QAClCM,IAAKN,EAAK,kBAAkBO,GAI5BC,KAAiB,GAAY,GAAY,GAAY,MAAyD;EAClH,IAAIC,IAAKC,IAAKC,GACVC,IAAKC,IAAKC;EACd,IAAI,CAACV,GAAQ,OAAO;GAAE;GAAI;GAAI,KAAK;EAAM;EACzC,IAAIW,IAAM;EAKV,OAJIN,IAAKL,EAAO,KAAK,IAAKA,EAAO,GAAG,IAAM,MACjCK,IAAKL,EAAO,IAAIA,EAAO,UAAS,IAAKA,EAAO,IAAIA,EAAO,OAAO,IAAM,KACzEQ,IAAKR,EAAO,KAAK,IAAKA,EAAO,GAAG,IAAM,MACjCQ,IAAKR,EAAO,IAAIA,EAAO,WAAU,IAAKA,EAAO,IAAIA,EAAO,QAAQ,IAAM,KACxE;GAAE;GAAI;GAAI;EAAI;CACvB,GAEMY,KAAgB,MAAqC;EACzD,IAAIC,IAAUC,EAAWC,EAAI,SAASvB,CAAO;EAK7C,AAJKqB,MACH,IAAU,CAAC,GACXG,EAAWD,EAAI,SAASvB,GAASqB,CAAO,IAE1CA,EAAQ,KAAK;GACX,GAAGd,EAAI;GACP,GAAGgB,EAAI,QAAQ;GACf,GAAGA,EAAI,QAAQ;EACjB,CAAC;EAED,IAAME,IAASlB,EAAI,IAAID,IAAW;EAClC,OAAOe,EAAQ,SAAS,KAAKA,EAAQ,EAAE,CAAC,IAAII,IAAQ,EAAQ,MAAM;CACpE;CAEA,OAAO;EACL,QAAQ,GAAK;GAEX,AADAD,EAAWD,EAAI,SAASvB,GAAS,CAAC,CAAC,GACnCoB,EAAaG,CAAG;EAClB;EACA,OAAO,GAAK;GACV,EAAaA,CAAG;EAClB;EACA,MAAM,GAAK,GAAyB;GAClC,IAAIG,EAAI,UAAU;GAClB,IAAML,IAAUC,EAAWC,EAAI,SAASvB,CAAO,KAAK,CAAC;GACrD,IAAIqB,EAAQ,SAAS,GAAG;GACxB,IAAMM,IAAON,EAAQA,EAAQ,SAAS,IAEhCI,IAASE,EAAK,IAAIrB,GACpBsB,IAAQP,EAAQ;GACpB,KAAK,IAAMQ,KAAKR,GACd,IAAIQ,EAAE,KAAKJ,GAAQ;IAAE,IAAQI;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;GAEhC,IADc,KAAK,MAAMC,GAAIC,CACzB,IAAQ3B,GAAW;GAIvB,IAAM4B,IAAa,IAAI,IAAmBV,EAAI,OAAO,GACjDW,IAAY;IAAE,GAAG;IAAG,GAAG;GAAE,GACvBC,IAAUZ,EAAI,SAIda,oBAAiB,IAAI,IAAsC,GAC7DC,IAAyC;GAC7C,IAAcjC,EAAK,SAAS,MAAgB;IAC1C,MAAM;KAAE,GAAG;KAAG,GAAG;IAAE;IACnB,UAAU;KAAE,GAAG2B;KAAI,GAAGC;IAAG;IACzB;IACA,MAAM,GAAG,OAAO;KAAE,GAAGM,EAAE,IAAIC,EAAE;KAAG,GAAGD,EAAE,IAAIC,EAAE;IAAE;IAC7C,QAAQ,GAAG,OAAO;KAAE,GAAGC,EAAE,IAAIC;KAAG,GAAGD,EAAE,IAAIC;IAAE;IAC3C,YAAY,MAAM,KAAK,MAAMD,EAAE,GAAGA,EAAE,CAAC;IACrC,SAAS,MAAU;KACjB,IAAYE;KACZ,IAAIC,IAASnC,MAAW,KAAA;KACxB,KAAK,IAAMoC,KAAMrB,EAAI,YAAY;MAC/B,IAAMsB,IAAQZ,EAAW,IAAIW,CAAE;MAC/B,IAAI,CAACC,GAAO;MACZ,IAAMC,IAAIpC,EAAE,UAAUmC,CAAK,GACrB,EAAE,OAAI,OAAI,WAAQjC,EAAckC,EAAE,GAAGA,EAAE,GAAGJ,EAAM,GAAGA,EAAM,CAAC;MAGhE,AAFKvB,MAAK,IAAS,KACnBiB,EAAe,IAAIQ,GAAI;OAAE,GAAG/B;OAAI,GAAGG;MAAG,CAAC,GACvCmB,EAAQ,QAAQS,GAAIG,EAA2BF,GAAOhC,IAAKiC,EAAE,GAAG9B,IAAK8B,EAAE,GAAGpC,CAAC,CAAC;KAC9E;KAIA,AAAID,MAAmB,UAAUkC,KAAUN,MACzCA,EAAY,OAAO,GAEnBW,EAAY;IAEhB;IACA,cAAc;KACZ,EAAY;IACd;GACF,CAAC;GAED,SAASA,IAAoB;IAC3B,IAAI,CAACb,EAAQ,UAAU;IACvB,IAAMc,IAAY,CAAC;IACnB,KAAK,IAAML,KAAMrB,EAAI,YAAY;KAC/B,IAAMsB,IAAQZ,EAAW,IAAIW,CAAE;KAC/B,IAAI,CAACC,GAAO;KACZ,IAAMC,IAAIpC,EAAE,UAAUmC,CAAK,GACrBK,IAAKd,EAAe,IAAIQ,CAAE,KAAK;MAAE,GAAGE,EAAE,IAAIZ,EAAU;MAAG,GAAGY,EAAE,IAAIZ,EAAU;KAAE,GAC5EiB,IAAYJ,EAA2BF,GAAOK,EAAG,IAAIJ,EAAE,GAAGI,EAAG,IAAIJ,EAAE,GAAGpC,CAAC;KAC7E,EAAI,KAAK0C,EAAyB;MAAE;MAAI,MAAMP;MAAO,IAAIM;MAAW,OAAO;KAAQ,CAAC,CAAC;IACvF;IACA,AAAIF,EAAI,SAAS,KAAGd,EAAQ,SAASc,GAAK,OAAO;GACnD;GAEA,OAAO;EACT;CACF;AACF"}

package/dist/animation/colorHelpers.js

@@ -0,0 +1,135 @@
+import { hslToRgb as e } from "../renderer/math/color.js";
+import { lerpColorArray as t } from "@weasel-js/paint";
+import { resolveEasing as n } from "@weasel-js/geom";
+//#region src/animation/colorHelpers.ts
+function r(e, t) {
+	if (e.length !== t.length) throw Error(`vertex colors: length mismatch (from=${e.length}, to=${t.length})`);
+	if (e.length === 0 || e.length % 4 != 0) throw Error(`vertex colors: length ${e.length} must be a positive multiple of 4`);
+}
+function i(e) {
+	if (e.interpolate) return e.interpolate;
+	let n = e.interpolation ?? "rgb";
+	return (e, r, i) => t(e, r, i, n);
+}
+var a = (e, t) => `colors:${e}:${t}`;
+function o(e, t) {
+	r(t.from, t.to);
+	let n = i(t), { id: o, channel: s } = t;
+	return e.tween({
+		from: 0,
+		to: 1,
+		ms: t.ms,
+		easing: t.easing,
+		cancelKey: a(o, s),
+		interpolate: (e, t, n) => e + (t - e) * n,
+		onTick: (r) => {
+			e.colorOverrides.set(o, s, n(t.from, t.to, r));
+		},
+		onDone: () => {
+			e.colorOverrides.clear(o, s), t.onDone?.();
+		}
+	});
+}
+function s(e, t) {
+	r(t.from, t.to);
+	let n = i(t), { id: o, channel: s } = t;
+	return e.spring({
+		from: 0,
+		to: 1,
+		preset: t.preset,
+		stiffness: t.stiffness,
+		damping: t.damping,
+		mass: t.mass,
+		cancelKey: a(o, s),
+		interpolate: (e, t, n) => e + (t - e) * n,
+		onTick: (r) => {
+			let i = Math.max(0, Math.min(1, r));
+			e.colorOverrides.set(o, s, n(t.from, t.to, i));
+		},
+		onDone: () => {
+			e.colorOverrides.clear(o, s), t.onDone?.();
+		}
+	});
+}
+function c(e, t) {
+	let r = i(t), { id: a, channel: o } = t, s = t.direction ?? 1, c = n(t.easing);
+	e.colorOverrides.set(a, o, (e, n) => {
+		let i = e.length / 4;
+		if (i === 0) return e.slice();
+		let a = n / t.msPerCycle * i * s / i, o = a - Math.floor(a), l = c(o), u = ((Math.floor(a) + l) * i % i + i) % i, d = Math.floor(u), f = u - d, p = Array(e.length);
+		for (let t = 0; t < i; t++) {
+			let n = (t + d) % i * 4, a = (t + d + 1) % i * 4, o = [
+				e[n],
+				e[n + 1],
+				e[n + 2],
+				e[n + 3]
+			], s = [
+				e[a],
+				e[a + 1],
+				e[a + 2],
+				e[a + 3]
+			], c = r(o, s, f), l = t * 4;
+			p[l] = c[0], p[l + 1] = c[1], p[l + 2] = c[2], p[l + 3] = c[3];
+		}
+		return p;
+	});
+	let l = e.keepAlive();
+	return { cancel() {
+		e.colorOverrides.clear(a, o), l();
+	} };
+}
+function l(e, t) {
+	r(t.from, t.to);
+	let o = i(t), { id: s, channel: c, from: l, to: u, anchorMs: d, perAnchorDelay: f } = t, p = l.length / 4, m = n(t.easing), h = t.origin === "last" ? p - 1 : typeof t.origin == "number" ? Math.max(0, Math.min(p - 1, t.origin)) : 0, g = Math.max(h, p - 1 - h) * f + d, _ = (e) => {
+		let t = Array(l.length);
+		for (let n = 0; n < p; n++) {
+			let r = Math.abs(n - h) * f, i = Math.max(0, Math.min(1, (e - r) / d)), a = m(i), s = n * 4, c = [
+				l[s],
+				l[s + 1],
+				l[s + 2],
+				l[s + 3]
+			], p = [
+				u[s],
+				u[s + 1],
+				u[s + 2],
+				u[s + 3]
+			], g = o(c, p, a);
+			t[s] = g[0], t[s + 1] = g[1], t[s + 2] = g[2], t[s + 3] = g[3];
+		}
+		return t;
+	};
+	return e.colorOverrides.set(s, c, _(0)), e.tween({
+		from: 0,
+		to: 1,
+		ms: g,
+		easing: (e) => e,
+		cancelKey: a(s, c),
+		interpolate: (e, t, n) => e + (t - e) * n,
+		onTick: (t) => {
+			e.colorOverrides.set(s, c, _(t * g));
+		},
+		onDone: () => {
+			e.colorOverrides.clear(s, c), t.onDone?.();
+		}
+	});
+}
+function u(e, t = {}) {
+	let n = t.saturation ?? .8, r = t.lightness ?? .6, i = t.alpha ?? 1, a = [];
+	for (let t = 0; t < e; t++) {
+		let [o, s, c] = f(t * 360 / Math.max(1, e), n, r);
+		a.push(o, s, c, i);
+	}
+	return a;
+}
+function d(e, t, n, r, i = 1) {
+	let a = [];
+	for (let o = 0; o < e; o++) a.push(t, n, r, i);
+	return a;
+}
+function f(t, n, r) {
+	return e(t, n, r);
+}
+//#endregion
+export { c as cycleVertexColors, u as rainbowVertexColors, d as solidVertexColors, s as springVertexColors, l as staggerVertexColors, o as tweenVertexColors };
+
+//# sourceMappingURL=colorHelpers.js.map

package/dist/animation/colorHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorHelpers.js","names":["validateLengths","from","to","resolveInterpolator","opts","space","lerpColorArray","a","b","t","cancelKeyFor","id","channel","tweenVertexColors","interp","animator","springVertexColors","clamped","cycleVertexColors","direction","easing","resolveEasing","n","base","cycles","tMs","cycleFrac","easedFrac","phase","phaseInt","phaseFrac","out","i","aIdx","bIdx","blended","k","releaseKeepAlive","staggerVertexColors","originIndex","totalMs","perAnchorDelay","anchorMs","colorsAt","startMs","localT","elapsedMs","eased","fSlice","tSlice","rainbowVertexColors","saturation","lightness","alpha","r","g","hslToRgbUnit","solidVertexColors","hslToRgb","h","s","l"],"sources":["../../src/animation/colorHelpers.ts"],"sourcesContent":["import { resolveEasing } from '@weasel-js/geom';\nimport type {\n  AnimationHandle,\n  Animator,\n  EasingSpec,\n  SpringPresetName,\n} from './types';\nimport type { VertexColorChannel } from './colorRegistry';\nimport { lerpColorArray, type ColorSpace } from '@weasel-js/paint';\nimport { hslToRgb } from '../renderer/math/color';\n\n/**\n * Color interpolator: receives two flat RGBA float arrays (values in\n * 0..1, the renderer's color space — same shape as\n * `stroke.vertexColors`) and a normalized progress `t` in 0..1.\n * Returns the same-length blended array, also in 0..1 floats. Override\n * the default per-channel lerp via `TweenVertexColorsOptions.interpolate`\n * when a custom color-space or shaping is needed.\n */\nexport type ColorInterpolate = (\n  from: readonly number[],\n  to: readonly number[],\n  t: number,\n) => number[];\n\n/** Options for `tweenVertexColors`. */\nexport interface TweenVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA, flat, in 0..1 floats (matches the renderer's\n   *  `stroke.vertexColors` / `PathDrawCommand.vertexColors` color space).\n   *  Length must equal `from.length`. */\n  to: readonly number[];\n  /** Per-anchor RGBA, flat, in 0..1 floats. Length must equal `to.length`\n   *  and be a positive multiple of 4. */\n  from: readonly number[];\n  ms: number;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\nfunction validateLengths(from: readonly number[], to: readonly number[]): void {\n  if (from.length !== to.length) {\n    throw new Error(\n      `vertex colors: length mismatch (from=${from.length}, to=${to.length})`,\n    );\n  }\n  if (from.length === 0 || from.length % 4 !== 0) {\n    throw new Error(\n      `vertex colors: length ${from.length} must be a positive multiple of 4`,\n    );\n  }\n}\n\nfunction resolveInterpolator(\n  opts: { interpolation?: ColorSpace; interpolate?: ColorInterpolate },\n): ColorInterpolate {\n  if (opts.interpolate) return opts.interpolate;\n  const space: ColorSpace = opts.interpolation ?? 'rgb';\n  return (a, b, t) => lerpColorArray(a, b, t, space);\n}\n\nconst cancelKeyFor = (id: string, channel: VertexColorChannel): string =>\n  `colors:${id}:${channel}`;\n\n/**\n * Animate one node's per-anchor colors from `from` to `to` over `ms`.\n *\n * The colors are published to the animator's `colorOverrides` registry rather\n * than written into the scene, so nothing is recorded in history and the\n * node's own data is untouched; the override is dropped when the animation\n * finishes. Starting another color animation on the same node and channel\n * cancels this one.\n */\nexport function tweenVertexColors(\n  animator: Animator,\n  opts: TweenVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  return animator.tween<number>({\n    from: 0,\n    to: 1,\n    ms: opts.ms,\n    easing: opts.easing,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      animator.colorOverrides.set(id, channel, interp(opts.from, opts.to, t));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n/** Options for `springVertexColors`. */\nexport interface SpringVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.to`. */\n  to: readonly number[];\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.from`. */\n  from: readonly number[];\n  preset?: SpringPresetName;\n  stiffness?: number;\n  damping?: number;\n  mass?: number;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\n/** `tweenVertexColors` driven by a spring instead of a duration. Same override\n *  semantics. */\nexport function springVertexColors(\n  animator: Animator,\n  opts: SpringVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  return animator.spring<number>({\n    from: 0,\n    to: 1,\n    preset: opts.preset,\n    stiffness: opts.stiffness,\n    damping: opts.damping,\n    mass: opts.mass,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      const clamped = Math.max(0, Math.min(1, t));\n      animator.colorOverrides.set(id, channel, interp(opts.from, opts.to, clamped));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n/** Options for `cycleVertexColors`. */\nexport interface CycleVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  msPerCycle: number;\n  direction?: 1 | -1;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  /** Custom interpolator. Receives two RGBA arrays in 0..1 floats and a\n   *  progress `t` in 0..1; returns the blended array in 0..1 floats. */\n  interpolate?: ColorInterpolate;\n}\n\n/** Removes an installed color cycle. Unlike the other color helpers this is\n *  not an `AnimationHandle`, because a cycle has no progress to pause or\n *  scale — it only ends. */\nexport interface CycleHandle {\n  cancel(): void;\n}\n\n/** Register a function override that phase-rotates the base color array\n *  along the path index. Returns a handle whose `cancel()` removes the\n *  override.\n *\n *  The override computes its value purely from `performance.now()`, so\n *  there's no per-frame progress to register with the animator's tick\n *  loop. To keep the loop alive (so `<SceneCanvas animator>`'s onTick\n *  subscription continues firing redraws while the cycle is installed),\n *  cycleVertexColors holds an `animator.keepAlive()` entry for the\n *  lifetime of the cycle; `cancel()` releases it. */\nexport function cycleVertexColors(\n  animator: Animator,\n  opts: CycleVertexColorsOptions,\n): CycleHandle {\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  const direction = opts.direction ?? 1;\n  const easing = resolveEasing(opts.easing);\n\n  const override = (base: readonly number[], tMs: number): number[] => {\n    const n = base.length / 4;\n    if (n === 0) return base.slice();\n    const raw = (tMs / opts.msPerCycle) * n * direction;\n    const cycles = raw / n;\n    const cycleFrac = cycles - Math.floor(cycles);\n    const easedFrac = easing(cycleFrac);\n    const easedRaw = (Math.floor(cycles) + easedFrac) * n;\n    const phase = ((easedRaw % n) + n) % n;\n    const phaseInt = Math.floor(phase);\n    const phaseFrac = phase - phaseInt;\n\n    const out = new Array<number>(base.length);\n    for (let i = 0; i < n; i++) {\n      const aIdx = ((i + phaseInt) % n) * 4;\n      const bIdx = ((i + phaseInt + 1) % n) * 4;\n      const a = [base[aIdx], base[aIdx + 1], base[aIdx + 2], base[aIdx + 3]];\n      const b = [base[bIdx], base[bIdx + 1], base[bIdx + 2], base[bIdx + 3]];\n      const blended = interp(a, b, phaseFrac);\n      const k = i * 4;\n      out[k] = blended[0];\n      out[k + 1] = blended[1];\n      out[k + 2] = blended[2];\n      out[k + 3] = blended[3];\n    }\n    return out;\n  };\n\n  animator.colorOverrides.set(id, channel, override);\n  // Cycle's \"value\" is a function of wall-clock time, not a tween-style\n  // progress. We don't register a per-frame ticking animation, so without\n  // an explicit keep-alive entry the animator's RAF loop would idle and\n  // SceneCanvas's onTick redraw subscription would never fire. Keep the\n  // loop running until cancel().\n  const releaseKeepAlive = animator.keepAlive();\n\n  return {\n    cancel(): void {\n      animator.colorOverrides.clear(id, channel);\n      releaseKeepAlive();\n    },\n  };\n}\n\n/** Options for `staggerVertexColors`. `origin` picks which anchor the wave\n *  starts from and `perAnchorDelay` how far behind each successive anchor\n *  runs. */\nexport interface StaggerVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.to`. */\n  to: readonly number[];\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.from`. */\n  from: readonly number[];\n  anchorMs: number;\n  perAnchorDelay: number;\n  origin?: 'first' | 'last' | number;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\n/** Run the same color change across a node's anchors as a wave, each anchor\n *  starting later than the one before it. Same override semantics as\n *  `tweenVertexColors`. */\nexport function staggerVertexColors(\n  animator: Animator,\n  opts: StaggerVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel, from, to, anchorMs, perAnchorDelay } = opts;\n  const n = from.length / 4;\n  const easing = resolveEasing(opts.easing);\n\n  const originIndex =\n    opts.origin === 'last' ? n - 1 :\n    typeof opts.origin === 'number' ? Math.max(0, Math.min(n - 1, opts.origin)) :\n    0;\n\n  const maxDistance = Math.max(originIndex, n - 1 - originIndex);\n  const totalMs = maxDistance * perAnchorDelay + anchorMs;\n\n  const colorsAt = (elapsedMs: number): number[] => {\n    const out = new Array<number>(from.length);\n    for (let i = 0; i < n; i++) {\n      const distance = Math.abs(i - originIndex);\n      const startMs = distance * perAnchorDelay;\n      const localT = Math.max(0, Math.min(1, (elapsedMs - startMs) / anchorMs));\n      const eased = easing(localT);\n      const k = i * 4;\n      const fSlice = [from[k], from[k + 1], from[k + 2], from[k + 3]];\n      const tSlice = [to[k], to[k + 1], to[k + 2], to[k + 3]];\n      const blended = interp(fSlice, tSlice, eased);\n      out[k] = blended[0];\n      out[k + 1] = blended[1];\n      out[k + 2] = blended[2];\n      out[k + 3] = blended[3];\n    }\n    return out;\n  };\n\n  // A plain array, not a function override: painters call those with their\n  // own clock (`performance.now()`), not time since this stagger began.\n  animator.colorOverrides.set(id, channel, colorsAt(0));\n\n  return animator.tween<number>({\n    from: 0,\n    to: 1,\n    ms: totalMs,\n    easing: (t) => t,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      animator.colorOverrides.set(id, channel, colorsAt(t * totalMs));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n// ─── Color-array constructors ───────────────────────────────────────\n//\n// Helpers that build the per-anchor RGBA arrays the tween/cycle/stagger\n// helpers above (and `stroke.vertexColors` on draw commands) consume.\n// Values are in the 0..1 range the renderer expects — emitting bytes\n// (0..255) clamps every channel to 1.0 on the GPU and renders white.\n\n/** Build an n-anchor rainbow RGBA array sweeping the hue wheel. The\n *  output is suitable to pass directly into `stroke.vertexColors`,\n *  `tweenVertexColors({ from: rainbowVertexColors(n) })`, or any\n *  other API that wants per-anchor color floats. */\nexport function rainbowVertexColors(\n  n: number,\n  opts: { saturation?: number; lightness?: number; alpha?: number } = {},\n): number[] {\n  const saturation = opts.saturation ?? 0.8;\n  const lightness = opts.lightness ?? 0.6;\n  const alpha = opts.alpha ?? 1;\n  const out: number[] = [];\n  for (let i = 0; i < n; i++) {\n    const h = (i * 360) / Math.max(1, n);\n    const [r, g, b] = hslToRgbUnit(h, saturation, lightness);\n    out.push(r, g, b, alpha);\n  }\n  return out;\n}\n\n/** Build an n-anchor solid RGBA array. Shorthand for\n *  `[r, g, b, a, r, g, b, a, …]` — the array a `tweenVertexColors`\n *  `to`-target typically needs. */\nexport function solidVertexColors(\n  n: number,\n  r: number,\n  g: number,\n  b: number,\n  a = 1,\n): number[] {\n  const out: number[] = [];\n  for (let i = 0; i < n; i++) out.push(r, g, b, a);\n  return out;\n}\n\n/** HSL → RGB in 0..1 (hue in degrees). Delegates to the single internal\n *  implementation in `renderer/math/color.ts` so there's only one HSL→RGB\n *  formula in the package. Kept local so consumers building hue-cycled\n *  color arrays via `huesweepVertexColors` don't have to roll their own. */\nfunction hslToRgbUnit(h: number, s: number, l: number): [number, number, number] {\n  return hslToRgb(h, s, l);\n}\n"],"mappings":"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"}

package/dist/animation/colorRegistry.js

@@ -0,0 +1,37 @@
+//#region src/animation/colorRegistry.ts
+var e = class {
+	map = /* @__PURE__ */ new Map();
+	_version = 0;
+	set(e, t, n) {
+		let r = this.map.get(e);
+		r || (r = {}, this.map.set(e, r)), r[t] = n, this._version++;
+	}
+	clear(e, t) {
+		let n = this.map.get(e);
+		n && t in n && (delete n[t], !n.fill && !n.stroke && this.map.delete(e), this._version++);
+	}
+	clearAll() {
+		this.map.size !== 0 && (this.map.clear(), this._version++);
+	}
+	get(e, t) {
+		return this.map.get(e)?.[t];
+	}
+	has(e) {
+		return this.map.has(e);
+	}
+	resolve(e, t, n, r) {
+		let i = this.get(e, t);
+		if (i === void 0) return n;
+		if (typeof i != "function") return i;
+		if (n === void 0) return;
+		let a = i(n, r);
+		return a.length === n.length ? a : n;
+	}
+	version() {
+		return this._version;
+	}
+};
+//#endregion
+export { e as ColorOverrideRegistry };
+
+//# sourceMappingURL=colorRegistry.js.map

package/dist/animation/colorRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorRegistry.js","names":["ColorOverrideRegistry","entry","id","channel","override","base","result","tMs"],"sources":["../../src/animation/colorRegistry.ts"],"sourcesContent":["/** Which of a node's two per-anchor color arrays an override applies to. */\nexport type VertexColorChannel = 'fill' | 'stroke';\n\n/** Function-form override: receives the consumer-supplied base color\n *  array and the current animation timestamp (ms, from the animator's\n *  clock). Returns a flat RGBA float array (values in 0..1, matching\n *  the renderer's `stroke.vertexColors` / `PathDrawCommand.vertexColors`\n *  color space) of the same length as `base`. */\nexport type ColorOverrideFn = (base: readonly number[], tMs: number) => number[];\n\n/** Either a static per-anchor RGBA float array (0..1) or a function-form\n *  override (see {@link ColorOverrideFn}). */\nexport type ColorOverride = readonly number[] | ColorOverrideFn;\n\ninterface NodeOverrides {\n  fill?: ColorOverride;\n  stroke?: ColorOverride;\n}\n\n/** Per-node, per-channel store of color overrides. Attached to `useAnimator` as\n *  `animator.colorOverrides`; painted onto scene nodes by `<SceneCanvas animator>`\n *  and onto a `createPathLayer`'s nodes by its `colorOverrides` option. */\nexport class ColorOverrideRegistry {\n  private readonly map = new Map<string, NodeOverrides>();\n  private _version = 0;\n\n  set(id: string, channel: VertexColorChannel, override: ColorOverride): void {\n    let entry = this.map.get(id);\n    if (!entry) {\n      entry = {};\n      this.map.set(id, entry);\n    }\n    entry[channel] = override;\n    this._version++;\n  }\n\n  clear(id: string, channel: VertexColorChannel): void {\n    const entry = this.map.get(id);\n    if (!entry) return;\n    if (!(channel in entry)) return;\n    delete entry[channel];\n    if (!entry.fill && !entry.stroke) this.map.delete(id);\n    this._version++;\n  }\n\n  clearAll(): void {\n    if (this.map.size === 0) return;\n    this.map.clear();\n    this._version++;\n  }\n\n  get(id: string, channel: VertexColorChannel): ColorOverride | undefined {\n    return this.map.get(id)?.[channel];\n  }\n\n  /** Whether anything overrides `id`, on either channel. */\n  has(id: string): boolean {\n    return this.map.has(id);\n  }\n\n  /**\n   * The colors to paint on `id`'s `channel`, given the colors the painter would\n   * otherwise paint and the frame's timestamp. A function override needs that\n   * `base` and must return an array of its length; failing either, `base`\n   * stands.\n   */\n  resolve(\n    id: string,\n    channel: VertexColorChannel,\n    base: readonly number[] | undefined,\n    tMs: number,\n  ): readonly number[] | undefined {\n    const override = this.get(id, channel);\n    if (override === undefined) return base;\n    if (typeof override !== 'function') return override;\n    if (base === undefined) return undefined;\n    const result = override(base, tMs);\n    return result.length === base.length ? result : base;\n  }\n\n  version(): number {\n    return this._version;\n  }\n}\n"],"mappings":";AAsBA,IAAaA,IAAb,MAAmC;CACjC,sBAAuB,IAAI,IAA2B;CACtD,WAAmB;CAEnB,IAAI,GAAY,GAA6B,GAA+B;EAC1E,IAAIC,IAAQ,KAAK,IAAI,IAAIC,CAAE;EAM3B,AALKD,MACH,IAAQ,CAAC,GACT,KAAK,IAAI,IAAIC,GAAID,CAAK,IAExB,EAAME,KAAWC,GACjB,KAAK;CACP;CAEA,MAAM,GAAY,GAAmC;EACnD,IAAMH,IAAQ,KAAK,IAAI,IAAIC,CAAE;EAC7B,AAAKD,KACCE,KAAWF,MACjB,OAAOA,EAAME,IACT,CAACF,EAAM,QAAQ,CAACA,EAAM,UAAQ,KAAK,IAAI,OAAOC,CAAE,GACpD,KAAK;CACP;CAEA,WAAiB;EACf,AAAI,KAAK,IAAI,SAAS,MACtB,KAAK,IAAI,MAAM,GACf,KAAK;CACP;CAEA,IAAI,GAAY,GAAwD;EACtE,OAAO,KAAK,IAAI,IAAIA,CAAE,CAAC,GAAGC;CAC5B;CAGA,IAAI,GAAqB;EACvB,OAAO,KAAK,IAAI,IAAID,CAAE;CACxB;CAQA,QACE,GACA,GACA,GACA,GAC+B;EAC/B,IAAME,IAAW,KAAK,IAAIF,GAAIC,CAAO;EACrC,IAAIC,MAAa,KAAA,GAAW,OAAOC;EACnC,IAAI,OAAOD,KAAa,YAAY,OAAOA;EAC3C,IAAIC,MAAS,KAAA,GAAW;EACxB,IAAMC,IAASF,EAASC,GAAME,CAAG;EACjC,OAAOD,EAAO,WAAWD,EAAK,SAASC,IAASD;CAClD;CAEA,UAAkB;EAChB,OAAO,KAAK;CACd;AACF"}

package/dist/animation/index.js

@@ -0,0 +1,20 @@
+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 };