@weasel-js/core 1.9.4 → 1.10.1

package/dist/animation/rig/skinBinding.js

@@ -0,0 +1,64 @@
+import { boundsOfPath as e, pathInWorld as t, remapPointValues as n } from "@weasel-js/geom";
+import { skinPath as r } from "@weasel-js/animator";
+//#region src/animation/rig/skinBinding.ts
+function i(e) {
+	let n = e.data?.path;
+	return n ? t(n, e.pose) : null;
+}
+function a(e, t) {
+	let r = {};
+	for (let i in e) {
+		let a = n(e[i], t);
+		a.some((e) => e > 0) && (r[i] = a);
+	}
+	return r;
+}
+function o(t, n, i, a) {
+	let o = [], s = /* @__PURE__ */ new Set();
+	for (let [e, r] of Object.entries(n)) {
+		let n = t.get(e);
+		if (!n) throw Error(`bindRig: a skin names node "${e}", which the scene lacks.`);
+		let a = i(n);
+		if (!a) throw Error(`bindRig: node "${e}" has no path to skin.`);
+		for (let e in r) s.add(e);
+		o.push({
+			node: e,
+			skin: r,
+			rest: a,
+			restPose: n.pose,
+			entry: {}
+		});
+	}
+	let c = !1;
+	return {
+		joints: [...s],
+		show(n) {
+			for (let i of o) {
+				let o = r(i.rest, i.skin, n);
+				i.entry.path = o, i.entry.pose = a.fromBounds(e(o), i.restPose), c || t.overrides.set(i.node, i.entry);
+			}
+			c = !0;
+		},
+		write() {
+			for (let e of o) {
+				let { path: n, pose: r } = e.entry;
+				if (n === void 0 || r === void 0) continue;
+				let i = t.get(e.node)?.data;
+				t.update(e.node, { data: {
+					...i,
+					path: n
+				} }), t.setPose(e.node, r);
+			}
+		},
+		release() {
+			if (c) {
+				c = !1;
+				for (let e of o) t.overrides.clear(e.node);
+			}
+		}
+	};
+}
+//#endregion
+export { o as bindSkins, i as dataRestPath, a as remapSkin };
+
+//# sourceMappingURL=skinBinding.js.map

package/dist/animation/rig/skinBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skinBinding.js","names":["dataRestPath","path","node","pathInWorld","remapSkin","next","joint","skin","weights","remapPointValues","origins","w","bindSkins","skinned","joints","id","skins","scene","rest","restPath","installed","s","skinPath","motions","descriptor","boundsOfPath","pose","data"],"sources":["../../../src/animation/rig/skinBinding.ts"],"sourcesContent":["import {\n  boundsOfPath, pathInWorld, remapPointValues,\n  type GlMat3, type Path, type PathInWorldPose, type PointOrigin,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from '../../core/geometry/poseDescriptor';\nimport type { NodeId, PoseOverride, PoseOverrides } from '../../core/scene/types';\nimport { skinPath, type Skin } from '@weasel-js/animator';\n\n/** The part of a scene a rig's skins read and write. */\nexport interface SkinScene<TPose> {\n  get(id: NodeId): { pose: TPose; data?: unknown } | undefined;\n  readonly overrides: PoseOverrides<TPose>;\n  setPose(id: NodeId, pose: TPose): void;\n  update(id: NodeId, patch: { data: never }): void;\n}\n\n/** Where a node's path is drawn, for a skin to bend: `null` for a node with none. */\nexport type RestPath<TPose> = (node: { pose: TPose; data?: unknown }) => Path | null;\n\n/** The path in a node's `data.path`, carried through its pose as `kit:path` paints it. */\nexport function dataRestPath<TPose>(node: { pose: TPose; data?: unknown }): Path | null {\n  const path = (node.data as { path?: Path } | null | undefined)?.path;\n  return path ? pathInWorld(path, node.pose as PathInWorldPose) : null;\n}\n\n/**\n * `skin` after an edit to the points of the path it weighs: `origins` says where each point\n * of the new path came from, as `editAnchorSetTracked` answers. A point the edit made takes\n * weights between those of the points it lies between, and a joint left weighing nothing is\n * dropped.\n */\nexport function remapSkin(skin: Skin, origins: readonly (PointOrigin | null)[]): Skin {\n  const next: Record<string, number[]> = {};\n  for (const joint in skin) {\n    const weights = remapPointValues(skin[joint], origins);\n    if (weights.some((w) => w > 0)) next[joint] = weights;\n  }\n  return next;\n}\n\ninterface Skinned<TPose> {\n  node: NodeId;\n  skin: Skin;\n  rest: Path;\n  restPose: TPose;\n  entry: PoseOverride<TPose>;\n}\n\n/** A rig's skinned nodes, as `bindSkins` returns them. */\nexport interface SkinBinding {\n  /** Every joint a skin weighs. */\n  readonly joints: readonly string[];\n  /** Bend each skinned path by `motions`, which holds every one of `joints`, into its node's\n   *  pose override. The caller commits the overrides. */\n  show(motions: ReadonlyMap<string, GlMat3>): void;\n  /** Write each bent path and its bounds into the document. */\n  write(): void;\n  release(): void;\n}\n\n/** Read each skinned node's rest path and ready an override for it. */\nexport function bindSkins<TPose>(\n  scene: SkinScene<TPose>,\n  skins: Readonly<Record<NodeId, Skin>>,\n  restPath: RestPath<TPose>,\n  descriptor: PoseDescriptor<TPose>,\n): SkinBinding {\n  const skinned: Skinned<TPose>[] = [];\n  const joints = new Set<string>();\n  for (const [id, skin] of Object.entries(skins) as [NodeId, Skin][]) {\n    const node = scene.get(id);\n    if (!node) throw new Error(`bindRig: a skin names node \"${id}\", which the scene lacks.`);\n    const rest = restPath(node);\n    if (!rest) throw new Error(`bindRig: node \"${id}\" has no path to skin.`);\n    for (const joint in skin) joints.add(joint);\n    skinned.push({ node: id, skin, rest, restPose: node.pose, entry: {} });\n  }\n  let installed = false;\n  return {\n    joints: [...joints],\n    show(motions) {\n      for (const s of skinned) {\n        const path = skinPath(s.rest, s.skin, motions);\n        s.entry.path = path;\n        s.entry.pose = descriptor.fromBounds(boundsOfPath(path), s.restPose);\n        if (!installed) scene.overrides.set(s.node, s.entry);\n      }\n      installed = true;\n    },\n    write() {\n      for (const s of skinned) {\n        const { path, pose } = s.entry;\n        if (path === undefined || pose === undefined) continue;\n        const data = scene.get(s.node)?.data;\n        scene.update(s.node, { data: { ...(data as object), path } as never });\n        scene.setPose(s.node, pose);\n      }\n    },\n    release() {\n      if (!installed) return;\n      installed = false;\n      for (const s of skinned) scene.overrides.clear(s.node);\n    },\n  };\n}\n"],"mappings":";;;AAoBA,SAAgBA,EAAoB,GAAoD;CACtF,IAAMC,IAAQC,EAAK,MAA6C;CAChE,OAAOD,IAAOE,EAAYF,GAAMC,EAAK,IAAuB,IAAI;AAClE;AAQA,SAAgBE,EAAU,GAAY,GAAgD;CACpF,IAAMC,IAAiC,CAAC;CACxC,KAAK,IAAMC,KAASC,GAAM;EACxB,IAAMC,IAAUC,EAAiBF,EAAKD,IAAQI,CAAO;EACrD,AAAIF,EAAQ,MAAM,MAAMG,IAAI,CAAC,MAAG,EAAKL,KAASE;CAChD;CACA,OAAOH;AACT;AAuBA,SAAgBO,EACd,GACA,GACA,GACA,GACa;CACb,IAAMC,IAA4B,CAAC,GAC7BC,oBAAS,IAAI,IAAY;CAC/B,KAAK,IAAM,CAACC,GAAIR,MAAS,OAAO,QAAQS,CAAK,GAAuB;EAClE,IAAMd,IAAOe,EAAM,IAAIF,CAAE;EACzB,IAAI,CAACb,GAAM,MAAU,MAAM,+BAA+Ba,EAAG,0BAA0B;EACvF,IAAMG,IAAOC,EAASjB,CAAI;EAC1B,IAAI,CAACgB,GAAM,MAAU,MAAM,kBAAkBH,EAAG,uBAAuB;EACvE,KAAK,IAAMT,KAASC,GAAM,EAAO,IAAID,CAAK;EAC1C,EAAQ,KAAK;GAAE,MAAMS;GAAI;GAAM;GAAM,UAAUb,EAAK;GAAM,OAAO,CAAC;EAAE,CAAC;CACvE;CACA,IAAIkB,IAAY;CAChB,OAAO;EACL,QAAQ,CAAC,GAAGN,CAAM;EAClB,KAAK,GAAS;GACZ,KAAK,IAAMO,KAAKR,GAAS;IACvB,IAAMZ,IAAOqB,EAASD,EAAE,MAAMA,EAAE,MAAME,CAAO;IAG7C,AAFA,EAAE,MAAM,OAAOtB,GACf,EAAE,MAAM,OAAOuB,EAAW,WAAWC,EAAaxB,CAAI,GAAGoB,EAAE,QAAQ,GAC9DD,KAAWH,EAAM,UAAU,IAAII,EAAE,MAAMA,EAAE,KAAK;GACrD;GACA,IAAY;EACd;EACA,QAAQ;GACN,KAAK,IAAMA,KAAKR,GAAS;IACvB,IAAM,EAAE,SAAM,YAASQ,EAAE;IACzB,IAAIpB,MAAS,KAAA,KAAayB,MAAS,KAAA,GAAW;IAC9C,IAAMC,IAAOV,EAAM,IAAII,EAAE,IAAI,CAAC,EAAE;IAEhC,AADAJ,EAAM,OAAOI,EAAE,MAAM,EAAE,MAAM;KAAE,GAAIM;KAAiB;IAAK,EAAW,CAAC,GACrEV,EAAM,QAAQI,EAAE,MAAMK,CAAI;GAC5B;EACF;EACA,UAAU;GACR,IAAKN,GACL;QAAY;IACZ,KAAK,IAAMC,KAAKR,GAAS,EAAM,UAAU,MAAMQ,EAAE,IAAI;GADzC;EAEd;CACF;AACF"}

package/dist/animation/rig/useRig.js

@@ -1,23 +1,38 @@
-import { bindRig as e } from "./bindRig.js";
-import { useEffect as t, useMemo as n } from "react";
+import { createRigSeat as e, seatBinding as t } from "./rigSeat.js";
+import { bindRigOn as n } from "./bindRig.js";
+import { useEffect as r, useMemo as i } from "react";
 //#region src/animation/rig/useRig.ts
-function r(r) {
-	let { scene: i, skeleton: a, bindings: o, apply: s, descriptor: c } = r, l = n(() => e({
-		scene: i,
-		skeleton: a,
-		bindings: o,
-		apply: s,
-		descriptor: c
-	}), [
-		i,
-		a,
-		o,
+function a(e) {
+	return o(e, null);
+}
+function o(a, o) {
+	let { scene: s, skeleton: c, bindings: l, skins: u, restPath: d, apply: f, descriptor: p } = a, m = i(() => {
+		let t = o ?? e(c), r = n({
+			scene: s,
+			skeleton: c,
+			bindings: l,
+			skins: u,
+			restPath: d,
+			apply: f,
+			descriptor: p
+		}, t);
+		return t.binding ??= r.binding, {
+			seat: t,
+			...r
+		};
+	}, [
 		s,
-		c
+		c,
+		l,
+		u,
+		d,
+		f,
+		p,
+		o
 	]);
-	return t(() => () => l.release(), [l]), l;
+	return r(() => (t(m.seat, m.binding), () => m.binding.drop()), [m]), m.rig;
 }
 //#endregion
-export { r as useRig };
+export { a as useRig, o as useSeatedRig };
 
 //# sourceMappingURL=useRig.js.map

package/dist/animation/rig/useRig.js.map

@@ -1 +1 @@
-{"version":3,"file":"useRig.js","names":["useRig","options","rig","useMemo","bindRig","scene","skeleton","bindings","apply","descriptor","useEffect"],"sources":["../../../src/animation/rig/useRig.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { bindRig, type BindRigOptions, type Rig } from './bindRig';\n\n/**\n * A {@link Rig} bound for the component's lifetime, its overrides dropped on\n * unmount. Rebinds — re-reading every node's rest pose — whenever an option's\n * identity changes, so hoist or memoize `skeleton` and `bindings`.\n */\nexport function useRig<TPose>(options: BindRigOptions<TPose>): Rig {\n  const { scene, skeleton, bindings, apply, descriptor } = options;\n  const rig = useMemo(\n    () => bindRig({ scene, skeleton, bindings, apply, descriptor }),\n    [scene, skeleton, bindings, apply, descriptor],\n  );\n  useEffect(() => () => rig.release(), [rig]);\n  return rig;\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAc,GAAqC;CACjE,IAAM,EAAE,UAAO,aAAU,aAAU,UAAO,kBAAeC,GACnDC,IAAMC,QACJC,EAAQ;EAAE;EAAO;EAAU;EAAU;EAAO;CAAW,CAAC,GAC9D;EAACC;EAAOC;EAAUC;EAAUC;EAAOC;CAAU,CAC/C;CAEA,OADAC,cAAsBR,EAAI,QAAQ,GAAG,CAACA,CAAG,CAAC,GACnCA;AACT"}
+{"version":3,"file":"useRig.js","names":["useRig","useSeatedRig","options","made","useMemo","seat","kept","createRigSeat","skeleton","bound","bindRigOn","scene","bindings","skins","restPath","apply","descriptor","useEffect","seatBinding"],"sources":["../../../src/animation/rig/useRig.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { bindRigOn, type BindRigOptions, type Rig } from './bindRig';\nimport { createRigSeat, seatBinding, type RigSeat } from './rigSeat';\n\n/**\n * A {@link Rig} bound for the component's lifetime, its overrides dropped on\n * unmount. Rebinds — re-reading every node's rest pose — whenever an option's\n * identity changes, so hoist or memoize `skeleton`, `bindings`, and `skins`.\n */\nexport function useRig<TPose>(options: BindRigOptions<TPose>): Rig {\n  return useSeatedRig(options, null);\n}\n\n/** {@link useRig} on a seat that outlives a rebind; `null` makes a seat for each binding. */\nexport function useSeatedRig<TPose>(options: BindRigOptions<TPose>, kept: RigSeat | null): Rig {\n  const { scene, skeleton, bindings, skins, restPath, apply, descriptor } = options;\n  const made = useMemo(() => {\n    const seat = kept ?? createRigSeat(skeleton);\n    const bound = bindRigOn({ scene, skeleton, bindings, skins, restPath, apply, descriptor }, seat);\n    seat.binding ??= bound.binding;\n    return { seat, ...bound };\n  }, [scene, skeleton, bindings, skins, restPath, apply, descriptor, kept]);\n  useEffect(() => {\n    seatBinding(made.seat, made.binding);\n    return () => made.binding.drop();\n  }, [made]);\n  return made.rig;\n}\n"],"mappings":";;;;AASA,SAAgBA,EAAc,GAAqC;CACjE,OAAOC,EAAaC,GAAS,IAAI;AACnC;AAGA,SAAgBD,EAAoB,GAAgC,GAA2B;CAC7F,IAAM,EAAE,UAAO,aAAU,aAAU,UAAO,aAAU,UAAO,kBAAeC,GACpEC,IAAOC,QAAc;EACzB,IAAMC,IAAOC,KAAQC,EAAcC,CAAQ,GACrCC,IAAQC,EAAU;GAAE;GAAO;GAAU;GAAU;GAAO;GAAU;GAAO;EAAW,GAAGL,CAAI;EAE/F,OADA,EAAK,YAAYI,EAAM,SAChB;GAAE;GAAM,GAAGA;EAAM;CAC1B,GAAG;EAACE;EAAOH;EAAUI;EAAUC;EAAOC;EAAUC;EAAOC;EAAYV;CAAI,CAAC;CAKxE,OAJAW,SACEC,EAAYf,EAAK,MAAMA,EAAK,OAAO,SACtBA,EAAK,QAAQ,KAAK,IAC9B,CAACA,CAAI,CAAC,GACFA,EAAK;AACd"}

package/dist/animation/wrappers/animateLifecycle.js

@@ -8,8 +8,9 @@ function n(n, r, i) {
 		insertNode(o, s) {
 			if (n.insertNode(o, s), !i.enterFrom) return;
 			let c = n.getPose(o.id), l = i.enterFrom(c);
-			t(n, o.id, l), e(r, n, {
+			n.poseTarget?.(o.id, i.geometry) || t(n, o.id, l), e(r, n, {
 				id: o.id,
+				from: l,
 				to: c,
 				ms: a,
 				easing: i.easing,
@@ -24,19 +25,19 @@ function n(n, r, i) {
 			}
 			if (o.has(t)) return;
 			o.add(t);
-			let s = () => {}, c = () => {
-				o.delete(t) && (s(), n.removeNode(t));
-			}, l = n.getPose(t), u = e(r, n, {
+			let s = () => {}, c = n.poseTarget?.(t, i.geometry), l = c?.committed(), u = () => {
+				o.delete(t) && (s(), c && c.commit(l), n.removeNode(t));
+			}, d = n.getPose(t), f = e(r, n, {
 				id: t,
-				to: i.exitTo(l),
+				to: i.exitTo(d),
 				ms: a,
 				easing: i.easing,
 				geometry: i.geometry,
 				recordOp: !1,
-				onDone: c
+				onDone: u
 			});
 			s = r.watch((e) => {
-				(e.type === "cancel" || e.type === "interrupt") && e.animation.id === u.id && c();
+				(e.type === "cancel" || e.type === "interrupt") && e.animation.id === f.id && u();
 			});
 		}
 	};

package/dist/animation/wrappers/animateLifecycle.js.map

@@ -1 +1 @@
-{"version":3,"file":"animateLifecycle.js","names":["animateLifecycle","ms","opts","leaving","adapter","object","index","final","start","setPoseInstant","tweenPose","animator","id","unwatch","remove","current","handle","event"],"sources":["../../../src/animation/wrappers/animateLifecycle.ts"],"sourcesContent":["import { tweenPose } from '../poseHelpers';\nimport { setPoseInstant } from './instantPose';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { SceneAdapter } from 'core/adapters/types';\nimport type { Animator, EasingSpec } from '../types';\n\n/** How nodes enter and leave. `enterFrom` derives the pose a new node starts\n *  at, given where it belongs; `exitTo` derives the pose a departing node\n *  animates to before it is actually removed. Omit either to leave that\n *  transition instant. */\nexport interface LifecycleAnimation<TPose> {\n  /** Pose to animate the new object FROM at insert. */\n  enterFrom?: (final: TPose) => TPose;\n  /** Pose to animate the existing object TO at remove. */\n  exitTo?: (current: TPose) => TPose;\n  ms?: number;\n  easing?: EasingSpec;\n  geometry?: PoseDescriptor<TPose>;\n}\n\n/** Wrap an adapter so inserts and removals animate — the scene-graph\n *  equivalent of CSS enter/leave transitions. */\nexport function animateLifecycle<TNode extends { id: string; pose?: TPose }, TPose>(\n  adapter: SceneAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: LifecycleAnimation<TPose>,\n): SceneAdapter<TNode, TPose> {\n  const ms = opts.ms ?? 200;\n  const leaving = new Set<string>();\n\n  return {\n    ...adapter,\n    insertNode(object: TNode, index?: number): void {\n      adapter.insertNode(object, index);\n      if (!opts.enterFrom) return;\n      const final = adapter.getPose(object.id);\n      const start = opts.enterFrom(final);\n      setPoseInstant(adapter, object.id, start);\n      tweenPose(animator, adapter as never, {\n        id: object.id,\n        to: final,\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n      });\n    },\n    removeNode(id: string): void {\n      if (!opts.exitTo) {\n        adapter.removeNode(id);\n        return;\n      }\n      if (leaving.has(id)) return;\n      leaving.add(id);\n      let unwatch = (): void => {};\n      const remove = (): void => {\n        if (!leaving.delete(id)) return;\n        unwatch();\n        adapter.removeNode(id);\n      };\n      const current = adapter.getPose(id);\n      const handle = tweenPose(animator, adapter as never, {\n        id,\n        to: opts.exitTo(current),\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n        onDone: remove,\n      });\n      // A canceled tween never calls onDone, and the node still has to go.\n      unwatch = animator.watch((event) => {\n        if ((event.type === 'cancel' || event.type === 'interrupt') && event.animation.id === handle.id) remove();\n      });\n    },\n  };\n}\n"],"mappings":";;;AAsBA,SAAgBA,EACd,GACA,GACA,GAC4B;CAC5B,IAAMC,IAAKC,EAAK,MAAM,KAChBC,oBAAU,IAAI,IAAY;CAEhC,OAAO;EACL,GAAGC;EACH,WAAW,GAAe,GAAsB;GAE9C,IADAA,EAAQ,WAAWC,GAAQC,CAAK,GAC5B,CAACJ,EAAK,WAAW;GACrB,IAAMK,IAAQH,EAAQ,QAAQC,EAAO,EAAE,GACjCG,IAAQN,EAAK,UAAUK,CAAK;GAElC,AADAE,EAAeL,GAASC,EAAO,IAAIG,CAAK,GACxCE,EAAUC,GAAUP,GAAkB;IACpC,IAAIC,EAAO;IACX,IAAIE;IACJ;IACA,QAAQL,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;GACZ,CAAC;EACH;EACA,WAAW,GAAkB;GAC3B,IAAI,CAACA,EAAK,QAAQ;IAChB,EAAQ,WAAWU,CAAE;IACrB;GACF;GACA,IAAIT,EAAQ,IAAIS,CAAE,GAAG;GACrB,EAAQ,IAAIA,CAAE;GACd,IAAIC,UAAsB,CAAC,GACrBC,UAAqB;IACzB,AAAKX,EAAQ,OAAOS,CAAE,MACtBC,EAAQ,GACRT,EAAQ,WAAWQ,CAAE;GACvB,GACMG,IAAUX,EAAQ,QAAQQ,CAAE,GAC5BI,IAASN,EAAUC,GAAUP,GAAkB;IACnD;IACA,IAAIF,EAAK,OAAOa,CAAO;IACvB;IACA,QAAQb,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;IACV,QAAQY;GACV,CAAC;GAED,IAAUH,EAAS,OAAO,MAAU;IAClC,CAAKM,EAAM,SAAS,YAAYA,EAAM,SAAS,gBAAgBA,EAAM,UAAU,OAAOD,EAAO,MAAIF,EAAO;GAC1G,CAAC;EACH;CACF;AACF"}
+{"version":3,"file":"animateLifecycle.js","names":["animateLifecycle","ms","opts","leaving","adapter","object","index","final","start","setPoseInstant","tweenPose","animator","id","unwatch","target","home","remove","current","handle","event"],"sources":["../../../src/animation/wrappers/animateLifecycle.ts"],"sourcesContent":["import { tweenPose, type PoseAnimationAdapter } from '../poseHelpers';\nimport { setPoseInstant } from './instantPose';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { Animator, EasingSpec } from '@weasel-js/animator';\n\n/** How nodes enter and leave. `enterFrom` derives the pose a new node starts\n *  at, given where it belongs; `exitTo` derives the pose a departing node\n *  animates to before it is actually removed. Omit either to leave that\n *  transition instant. */\nexport interface LifecycleAnimation<TPose> {\n  /** Pose to animate the new object FROM at insert. */\n  enterFrom?: (final: TPose) => TPose;\n  /** Pose to animate the existing object TO at remove. */\n  exitTo?: (current: TPose) => TPose;\n  ms?: number;\n  easing?: EasingSpec;\n  geometry?: PoseDescriptor<TPose>;\n}\n\n/** The part of an adapter `animateLifecycle` reads and wraps. The adapter `sceneToAdapter` and\n *  `useSceneAdapter` build is one. */\nexport interface LifecycleAdapter<TNode extends { id: string }, TPose> extends PoseAnimationAdapter<TPose> {\n  insertNode(node: TNode, index?: number): void;\n  removeNode(id: string): void;\n}\n\n/** Wrap an adapter so inserts and removals animate — the scene-graph\n *  equivalent of CSS enter/leave transitions. The result is the adapter it\n *  was given, with `insertNode` and `removeNode` replaced. */\nexport function animateLifecycle<\n  TNode extends { id: string },\n  TPose,\n  A extends LifecycleAdapter<TNode, TPose> = LifecycleAdapter<TNode, TPose>,\n>(\n  adapter: A & LifecycleAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: LifecycleAnimation<TPose>,\n): A {\n  const ms = opts.ms ?? 200;\n  const leaving = new Set<string>();\n\n  return {\n    ...adapter,\n    insertNode(object: TNode, index?: number): void {\n      adapter.insertNode(object, index);\n      if (!opts.enterFrom) return;\n      const final = adapter.getPose(object.id);\n      const start = opts.enterFrom(final);\n      // A pose target shows the start pose itself; without one it has to be written.\n      if (!adapter.poseTarget?.(object.id, opts.geometry)) setPoseInstant(adapter, object.id, start);\n      tweenPose(animator, adapter, {\n        id: object.id,\n        from: start,\n        to: final,\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n      });\n    },\n    removeNode(id: string): void {\n      if (!opts.exitTo) {\n        adapter.removeNode(id);\n        return;\n      }\n      if (leaving.has(id)) return;\n      leaving.add(id);\n      let unwatch = (): void => {};\n      const target = adapter.poseTarget?.(id, opts.geometry);\n      const home = target?.committed();\n      const remove = (): void => {\n        if (!leaving.delete(id)) return;\n        unwatch();\n        // The exit pose was only for show: the node is removed as it stood, so undo restores that.\n        if (target) target.commit(home as TPose);\n        adapter.removeNode(id);\n      };\n      const current = adapter.getPose(id);\n      const handle = tweenPose(animator, adapter, {\n        id,\n        to: opts.exitTo(current),\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n        onDone: remove,\n      });\n      // A canceled tween never calls onDone, and the node still has to go.\n      unwatch = animator.watch((event) => {\n        if ((event.type === 'cancel' || event.type === 'interrupt') && event.animation.id === handle.id) remove();\n      });\n    },\n  } as A;\n}\n"],"mappings":";;;AA6BA,SAAgBA,EAKd,GACA,GACA,GACG;CACH,IAAMC,IAAKC,EAAK,MAAM,KAChBC,oBAAU,IAAI,IAAY;CAEhC,OAAO;EACL,GAAGC;EACH,WAAW,GAAe,GAAsB;GAE9C,IADAA,EAAQ,WAAWC,GAAQC,CAAK,GAC5B,CAACJ,EAAK,WAAW;GACrB,IAAMK,IAAQH,EAAQ,QAAQC,EAAO,EAAE,GACjCG,IAAQN,EAAK,UAAUK,CAAK;GAGlC,AADKH,EAAQ,aAAaC,EAAO,IAAIH,EAAK,QAAQ,KAAGO,EAAeL,GAASC,EAAO,IAAIG,CAAK,GAC7FE,EAAUC,GAAUP,GAAS;IAC3B,IAAIC,EAAO;IACX,MAAMG;IACN,IAAID;IACJ;IACA,QAAQL,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;GACZ,CAAC;EACH;EACA,WAAW,GAAkB;GAC3B,IAAI,CAACA,EAAK,QAAQ;IAChB,EAAQ,WAAWU,CAAE;IACrB;GACF;GACA,IAAIT,EAAQ,IAAIS,CAAE,GAAG;GACrB,EAAQ,IAAIA,CAAE;GACd,IAAIC,UAAsB,CAAC,GACrBC,IAASV,EAAQ,aAAaQ,GAAIV,EAAK,QAAQ,GAC/Ca,IAAOD,GAAQ,UAAU,GACzBE,UAAqB;IACzB,AAAKb,EAAQ,OAAOS,CAAE,MACtBC,EAAQ,GAEJC,KAAQA,EAAO,OAAOC,CAAa,GACvCX,EAAQ,WAAWQ,CAAE;GACvB,GACMK,IAAUb,EAAQ,QAAQQ,CAAE,GAC5BM,IAASR,EAAUC,GAAUP,GAAS;IAC1C;IACA,IAAIF,EAAK,OAAOe,CAAO;IACvB;IACA,QAAQf,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;IACV,QAAQc;GACV,CAAC;GAED,IAAUL,EAAS,OAAO,MAAU;IAClC,CAAKQ,EAAM,SAAS,YAAYA,EAAM,SAAS,gBAAgBA,EAAM,UAAU,OAAOD,EAAO,MAAIF,EAAO;GAC1G,CAAC;EACH;CACF;AACF"}

package/dist/animation/wrappers/animateOnSetPose.js

@@ -1,46 +1,46 @@
-import { springPose as e, tweenPose as t } from "../poseHelpers.js";
-import { instantPoseWrite as n } from "./instantPose.js";
+import { poseKey as e, springPose as t, tweenPose as n } from "../poseHelpers.js";
+import { instantPoseWrite as r } from "./instantPose.js";
 //#region src/animation/wrappers/animateOnSetPose.ts
-function r(r, i, a = {}) {
-	let o = a.ms ?? 200, s = (e, t, n) => a.shouldAnimate ? !a.shouldAnimate(e, t, n) : !!(a.skipDuringGesture && a.gestureScope?.has(e));
+function i(i, a, o = {}) {
+	let s = o.ms ?? 200, c = (e, t, n) => o.shouldAnimate ? !o.shouldAnimate(e, t, n) : !!(o.skipDuringGesture && o.gestureScope?.has(e));
 	return {
-		...r,
-		...n(r),
-		setPose(n, c) {
-			let l = r.getPose(n);
-			if (s(n, l, c)) {
-				r.setPose(n, c);
+		...i,
+		...r(i),
+		setPose(r, l) {
+			let u = i.getPose(r);
+			if (c(r, u, l)) {
+				i.setPose(r, l);
 				return;
 			}
-			if (i.isTicking()) {
-				r.setPose(n, c);
+			if (a.isTicking()) {
+				i.setPose(r, l);
 				return;
 			}
-			if (i.isActive("pose:" + n)) {
-				i.cancelKey("pose:" + n), r.setPose(n, c);
+			if (!i.poseTarget?.(r, o.geometry) && a.isActive(e(r))) {
+				a.cancelKey(e(r)), i.setPose(r, l);
 				return;
 			}
-			a.spring ? e(i, r, {
-				id: n,
-				to: c,
-				preset: a.spring.preset,
-				stiffness: a.spring.stiffness,
-				damping: a.spring.damping,
-				mass: a.spring.mass,
-				geometry: a.geometry,
-				opLabel: a.opLabel
-			}) : t(i, r, {
-				id: n,
-				to: c,
-				ms: o,
-				easing: a.easing,
-				geometry: a.geometry,
-				opLabel: a.opLabel
+			o.spring ? t(a, i, {
+				id: r,
+				to: l,
+				preset: o.spring.preset,
+				stiffness: o.spring.stiffness,
+				damping: o.spring.damping,
+				mass: o.spring.mass,
+				geometry: o.geometry,
+				opLabel: o.opLabel
+			}) : n(a, i, {
+				id: r,
+				to: l,
+				ms: s,
+				easing: o.easing,
+				geometry: o.geometry,
+				opLabel: o.opLabel
 			});
 		}
 	};
 }
 //#endregion
-export { r as animateOnSetPose };
+export { i as animateOnSetPose };
 
 //# sourceMappingURL=animateOnSetPose.js.map

package/dist/animation/wrappers/animateOnSetPose.js.map

@@ -1 +1 @@
-{"version":3,"file":"animateOnSetPose.js","names":["animateOnSetPose","ms","opts","skipPredicate","id","from","to","adapter","instantPoseWrite","pose","animator","springPose","tweenPose"],"sources":["../../../src/animation/wrappers/animateOnSetPose.ts"],"sourcesContent":["import { tweenPose, springPose } from '../poseHelpers';\nimport { instantPoseWrite } from './instantPose';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { SceneAdapter } from 'core/adapters/types';\nimport type { Animator, EasingSpec, SpringPresetName } from '../types';\n\n/** Options for `animateOnSetPose`. */\nexport interface AnimateOnSetPoseOptions<TPose> {\n  /** Default: 200ms tween with easeOut. */\n  ms?: number;\n  easing?: EasingSpec;\n  /** Use a spring instead of a duration tween. Mutually exclusive with ms/easing. */\n  spring?: {\n    preset?: SpringPresetName;\n    stiffness?: number;\n    damping?: number;\n    mass?: number;\n  };\n  geometry?: PoseDescriptor<TPose>;\n  /** Predicate: return false to skip animation and write through immediately. */\n  shouldAnimate?: (id: string, from: TPose, to: TPose) => boolean;\n  /** Convenience: when true, auto-skip animation if the id is currently being\n   *  manipulated by an active gesture. Implementation: see `gestureScope` —\n   *  the wrapper consults a shared \"in-flight ids\" Set if one is provided,\n   *  otherwise this option is a no-op (treat as `shouldAnimate` returning true).\n   *  Mutually exclusive with `shouldAnimate`. */\n  skipDuringGesture?: boolean;\n  /** Optional: a Set the kit (or app) populates with ids currently being\n   *  manipulated by a gesture. When `skipDuringGesture` is true and the id\n   *  is in this Set, the wrapper writes through immediately. */\n  gestureScope?: ReadonlySet<string>;\n  /** Op label for the recorded transform op. Default: `'animate'`. */\n  opLabel?: string;\n}\n\n/**\n * Wrap an adapter so every `setPose` animates to the new pose instead of\n * jumping to it. Anything that moves a node — a layout strategy, an action, a\n * consumer's own code — is animated without knowing it, since the adapter is\n * the single write path.\n *\n * Poses written from inside another animation's tick, and (optionally) poses\n * written for a node currently under a gesture, are passed straight through:\n * animating those would fight whatever is already driving the node.\n *\n * Writing a node again while its glide is still running ends the glide: the\n * new pose is written at once and stands.\n */\nexport function animateOnSetPose<TNode extends { id: string }, TPose>(\n  adapter: SceneAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: AnimateOnSetPoseOptions<TPose> = {},\n): SceneAdapter<TNode, TPose> {\n  const ms = opts.ms ?? 200;\n  const skipPredicate = (id: string, from: TPose, to: TPose): boolean => {\n    if (opts.shouldAnimate) return !opts.shouldAnimate(id, from, to);\n    if (opts.skipDuringGesture && opts.gestureScope?.has(id)) return true;\n    return false;\n  };\n\n  return {\n    ...adapter,\n    ...instantPoseWrite(adapter),\n    setPose(id: string, pose: TPose): void {\n      const from = adapter.getPose(id);\n      if (skipPredicate(id, from, pose)) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      // Re-entrant short-circuit (a): the caller IS another animation's tick\n      // (momentum decay, in-flight tween, spring) writing setPose ~60×/sec.\n      // Wrapping each call in a fresh 250ms tween fights the caller — the\n      // new tween's t=0 sample writes back the previous `from`, undoing\n      // this onTick — and when each wrap-tween settles, the very next\n      // caller-tick spawns another, looping visibly forever (cards never\n      // stop after a flick). Detect via animator.isTicking() and write\n      // through.\n      if (animator.isTicking()) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      if (animator.isActive('pose:' + id)) {\n        animator.cancelKey('pose:' + id);\n        adapter.setPose(id, pose);\n        return;\n      }\n      if (opts.spring) {\n        springPose(animator, adapter as never, {\n          id,\n          to: pose,\n          preset: opts.spring.preset,\n          stiffness: opts.spring.stiffness,\n          damping: opts.spring.damping,\n          mass: opts.spring.mass,\n          geometry: opts.geometry,\n          opLabel: opts.opLabel,\n        });\n      } else {\n        tweenPose(animator, adapter as never, {\n          id,\n          to: pose,\n          ms,\n          easing: opts.easing,\n          geometry: opts.geometry,\n          opLabel: opts.opLabel,\n        });\n      }\n    },\n  };\n}\n"],"mappings":";;;AAgDA,SAAgBA,EACd,GACA,GACA,IAAuC,CAAC,GACZ;CAC5B,IAAMC,IAAKC,EAAK,MAAM,KAChBC,KAAiB,GAAY,GAAa,MAC1CD,EAAK,gBAAsB,CAACA,EAAK,cAAcE,GAAIC,GAAMC,CAAE,IAC/D,GAAIJ,EAAK,qBAAqBA,EAAK,cAAc,IAAIE,CAAE;CAIzD,OAAO;EACL,GAAGG;EACH,GAAGC,EAAiBD,CAAO;EAC3B,QAAQ,GAAY,GAAmB;GACrC,IAAMF,IAAOE,EAAQ,QAAQH,CAAE;GAC/B,IAAID,EAAcC,GAAIC,GAAMI,CAAI,GAAG;IACjC,EAAQ,QAAQL,GAAIK,CAAI;IACxB;GACF;GASA,IAAIC,EAAS,UAAU,GAAG;IACxB,EAAQ,QAAQN,GAAIK,CAAI;IACxB;GACF;GACA,IAAIC,EAAS,SAAS,UAAUN,CAAE,GAAG;IAEnC,AADAM,EAAS,UAAU,UAAUN,CAAE,GAC/BG,EAAQ,QAAQH,GAAIK,CAAI;IACxB;GACF;GACA,AAAIP,EAAK,SACPS,EAAWD,GAAUH,GAAkB;IACrC;IACA,IAAIE;IACJ,QAAQP,EAAK,OAAO;IACpB,WAAWA,EAAK,OAAO;IACvB,SAASA,EAAK,OAAO;IACrB,MAAMA,EAAK,OAAO;IAClB,UAAUA,EAAK;IACf,SAASA,EAAK;GAChB,CAAC,IAEDU,EAAUF,GAAUH,GAAkB;IACpC;IACA,IAAIE;IACJ;IACA,QAAQP,EAAK;IACb,UAAUA,EAAK;IACf,SAASA,EAAK;GAChB,CAAC;EAEL;CACF;AACF"}
+{"version":3,"file":"animateOnSetPose.js","names":["animateOnSetPose","ms","opts","skipPredicate","id","from","to","adapter","instantPoseWrite","pose","animator","poseKey","springPose","tweenPose"],"sources":["../../../src/animation/wrappers/animateOnSetPose.ts"],"sourcesContent":["import { poseKey, tweenPose, springPose, type PoseAnimationAdapter } from '../poseHelpers';\nimport { instantPoseWrite } from './instantPose';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { Animator, EasingSpec, SpringPresetName } from '@weasel-js/animator';\n\n/** Options for `animateOnSetPose`. */\nexport interface AnimateOnSetPoseOptions<TPose> {\n  /** Default: 200ms tween with easeOut. */\n  ms?: number;\n  easing?: EasingSpec;\n  /** Use a spring instead of a duration tween. Mutually exclusive with ms/easing. */\n  spring?: {\n    preset?: SpringPresetName;\n    stiffness?: number;\n    damping?: number;\n    mass?: number;\n  };\n  geometry?: PoseDescriptor<TPose>;\n  /** Predicate: return false to skip animation and write through immediately. */\n  shouldAnimate?: (id: string, from: TPose, to: TPose) => boolean;\n  /** When true, write through immediately for an id in `gestureScope`. A no-op\n   *  without `gestureScope`, and ignored when `shouldAnimate` is set. */\n  skipDuringGesture?: boolean;\n  /** The ids currently being manipulated by a gesture, for `skipDuringGesture`. */\n  gestureScope?: ReadonlySet<string>;\n  /** Op label for the recorded transform op. Default: `'animate'`. */\n  opLabel?: string;\n}\n\n/**\n * Wrap an adapter so every `setPose` animates to the new pose instead of\n * jumping to it. The result is the adapter it was given, with that one method\n * replaced.\n *\n * Poses written from inside another animation's tick, and (optionally) poses\n * written for a node currently under a gesture, are passed straight through.\n *\n * Over a scene-backed adapter the document takes each pose as it is written\n * and only the node on screen glides; a store behind `createWrittenPoseTarget`\n * holds the pose on screen, and takes the written one as the glide ends. Writing a node again while it glides\n * bends the glide toward the new pose, or under `spring` carries its velocity\n * into the new one. Over an adapter with no `poseTarget`, a second write ends\n * the glide: the new pose is written at once and stands.\n */\nexport function animateOnSetPose<TPose, A extends PoseAnimationAdapter<TPose> = PoseAnimationAdapter<TPose>>(\n  adapter: A & PoseAnimationAdapter<TPose>,\n  animator: Animator,\n  opts: AnimateOnSetPoseOptions<TPose> = {},\n): A {\n  const ms = opts.ms ?? 200;\n  const skipPredicate = (id: string, from: TPose, to: TPose): boolean => {\n    if (opts.shouldAnimate) return !opts.shouldAnimate(id, from, to);\n    if (opts.skipDuringGesture && opts.gestureScope?.has(id)) return true;\n    return false;\n  };\n\n  return {\n    ...adapter,\n    ...instantPoseWrite(adapter),\n    setPose(id: string, pose: TPose): void {\n      const from = adapter.getPose(id);\n      if (skipPredicate(id, from, pose)) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      // The caller is another animation's tick writing setPose every frame.\n      // Wrapping each call in a fresh tween fights it — the new tween's t=0\n      // sample writes back the previous `from` — and never settles.\n      if (animator.isTicking()) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      // Without a pose target a second glide would fight the first, so the write ends it.\n      if (!adapter.poseTarget?.(id, opts.geometry) && animator.isActive(poseKey(id))) {\n        animator.cancelKey(poseKey(id));\n        adapter.setPose(id, pose);\n        return;\n      }\n      if (opts.spring) {\n        springPose(animator, adapter, {\n          id,\n          to: pose,\n          preset: opts.spring.preset,\n          stiffness: opts.spring.stiffness,\n          damping: opts.spring.damping,\n          mass: opts.spring.mass,\n          geometry: opts.geometry,\n          opLabel: opts.opLabel,\n        });\n      } else {\n        tweenPose(animator, adapter, {\n          id,\n          to: pose,\n          ms,\n          easing: opts.easing,\n          geometry: opts.geometry,\n          opLabel: opts.opLabel,\n        });\n      }\n    },\n  } as A;\n}\n"],"mappings":";;;AA4CA,SAAgBA,EACd,GACA,GACA,IAAuC,CAAC,GACrC;CACH,IAAMC,IAAKC,EAAK,MAAM,KAChBC,KAAiB,GAAY,GAAa,MAC1CD,EAAK,gBAAsB,CAACA,EAAK,cAAcE,GAAIC,GAAMC,CAAE,IAC/D,GAAIJ,EAAK,qBAAqBA,EAAK,cAAc,IAAIE,CAAE;CAIzD,OAAO;EACL,GAAGG;EACH,GAAGC,EAAiBD,CAAO;EAC3B,QAAQ,GAAY,GAAmB;GACrC,IAAMF,IAAOE,EAAQ,QAAQH,CAAE;GAC/B,IAAID,EAAcC,GAAIC,GAAMI,CAAI,GAAG;IACjC,EAAQ,QAAQL,GAAIK,CAAI;IACxB;GACF;GAIA,IAAIC,EAAS,UAAU,GAAG;IACxB,EAAQ,QAAQN,GAAIK,CAAI;IACxB;GACF;GAEA,IAAI,CAACF,EAAQ,aAAaH,GAAIF,EAAK,QAAQ,KAAKQ,EAAS,SAASC,EAAQP,CAAE,CAAC,GAAG;IAE9E,AADAM,EAAS,UAAUC,EAAQP,CAAE,CAAC,GAC9BG,EAAQ,QAAQH,GAAIK,CAAI;IACxB;GACF;GACA,AAAIP,EAAK,SACPU,EAAWF,GAAUH,GAAS;IAC5B;IACA,IAAIE;IACJ,QAAQP,EAAK,OAAO;IACpB,WAAWA,EAAK,OAAO;IACvB,SAASA,EAAK,OAAO;IACrB,MAAMA,EAAK,OAAO;IAClB,UAAUA,EAAK;IACf,SAASA,EAAK;GAChB,CAAC,IAEDW,EAAUH,GAAUH,GAAS;IAC3B;IACA,IAAIE;IACJ;IACA,QAAQP,EAAK;IACb,UAAUA,EAAK;IACf,SAASA,EAAK;GAChB,CAAC;EAEL;CACF;AACF"}

package/dist/animation/wrappers/instantPose.js.map

@@ -1 +1 @@
-{"version":3,"file":"instantPose.js","names":["INSTANT","instantPoseWrite","setPoseInstant","inner","id","pose","instant","adapter"],"sources":["../../../src/animation/wrappers/instantPose.ts"],"sourcesContent":["import type { SceneAdapter } from 'core/adapters/types';\n\nconst INSTANT = Symbol('weasel.setPoseInstant');\n\ntype PoseWrite<TPose> = (id: string, pose: TPose) => void;\ntype WithInstant<TPose> = { [INSTANT]?: PoseWrite<TPose> };\n\n/** The member an adapter wrapper that animates `setPose` spreads into what it\n *  returns, so the write that does not animate survives any wrapper above it\n *  that copies the adapter. */\nexport function instantPoseWrite<TNode extends { id: string }, TPose>(\n  inner: SceneAdapter<TNode, TPose>,\n): object {\n  return { [INSTANT]: (id: string, pose: TPose) => setPoseInstant(inner, id, pose) };\n}\n\n/** Write a pose at once, past every wrapper that would animate it. */\nexport function setPoseInstant<TNode extends { id: string }, TPose>(\n  adapter: SceneAdapter<TNode, TPose>,\n  id: string,\n  pose: TPose,\n): void {\n  const instant = (adapter as WithInstant<TPose>)[INSTANT];\n  if (instant) instant(id, pose);\n  else adapter.setPose(id, pose);\n}\n"],"mappings":";AAEA,IAAMA,IAAU,OAAO,uBAAuB;AAQ9C,SAAgBC,EACd,GACQ;CACR,OAAO,GAAGD,KAAW,GAAY,MAAgBE,EAAeC,GAAOC,GAAIC,CAAI,EAAE;AACnF;AAGA,SAAgBH,EACd,GACA,GACA,GACM;CACN,IAAMI,IAAWC,EAA+BP;CAChD,AAAIM,IAASA,EAAQF,GAAIC,CAAI,IACxBE,EAAQ,QAAQH,GAAIC,CAAI;AAC/B"}
+{"version":3,"file":"instantPose.js","names":["INSTANT","instantPoseWrite","setPoseInstant","inner","id","pose","instant","adapter"],"sources":["../../../src/animation/wrappers/instantPose.ts"],"sourcesContent":["const INSTANT = Symbol('weasel.setPoseInstant');\n\ntype PoseWrite<TPose> = (id: string, pose: TPose) => void;\ntype WithInstant<TPose> = { [INSTANT]?: PoseWrite<TPose> };\n\n/** The member an adapter wrapper that animates `setPose` spreads into what it\n *  returns, so the write that does not animate survives any wrapper above it\n *  that copies the adapter. */\nexport function instantPoseWrite<TPose>(inner: { setPose: PoseWrite<TPose> }): object {\n  return { [INSTANT]: (id: string, pose: TPose) => setPoseInstant(inner, id, pose) };\n}\n\n/** Write a pose at once, past every wrapper that would animate it. */\nexport function setPoseInstant<TPose>(adapter: { setPose: PoseWrite<TPose> }, id: string, pose: TPose): void {\n  const instant = (adapter as WithInstant<TPose>)[INSTANT];\n  if (instant) instant(id, pose);\n  else adapter.setPose(id, pose);\n}\n"],"mappings":";AAAA,IAAMA,IAAU,OAAO,uBAAuB;AAQ9C,SAAgBC,EAAwB,GAA8C;CACpF,OAAO,GAAGD,KAAW,GAAY,MAAgBE,EAAeC,GAAOC,GAAIC,CAAI,EAAE;AACnF;AAGA,SAAgBH,EAAsB,GAAwC,GAAY,GAAmB;CAC3G,IAAMI,IAAWC,EAA+BP;CAChD,AAAIM,IAASA,EAAQF,GAAIC,CAAI,IACxBE,EAAQ,QAAQH,GAAIC,CAAI;AAC/B"}

package/dist/animation/writtenPoseTarget.js

@@ -0,0 +1,33 @@
+import { liveAxes as e } from "./poseTarget.js";
+import { createTarget as t } from "@weasel-js/animator";
+//#region src/animation/writtenPoseTarget.ts
+function n(n) {
+	let r = n.read();
+	if (r === void 0) return null;
+	let i = r, a = null, o = () => a === null ? (i = n.read() ?? i, i) : a, s = e(n.descriptor, o);
+	if (!s) return null;
+	let c = t({
+		axes: s,
+		get: o,
+		set(e) {
+			if (c.active) {
+				a = e;
+				return;
+			}
+			a = null, n.write(e);
+		},
+		show(e) {
+			if (c.active) {
+				a === null && (a = o()), n.write(e);
+				return;
+			}
+			let t = a;
+			a = null, t !== null && n.write(t), n.onRest?.();
+		}
+	});
+	return c;
+}
+//#endregion
+export { n as createWrittenPoseTarget };
+
+//# sourceMappingURL=writtenPoseTarget.js.map

package/dist/animation/writtenPoseTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writtenPoseTarget.js","names":["createWrittenPoseTarget","first","opts","last","committed","get","axes","liveAxes","target","createTarget","pose","landed"],"sources":["../../src/animation/writtenPoseTarget.ts"],"sourcesContent":["import type { PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport { liveAxes } from './poseTarget';\nimport { createTarget, type Target } from '@weasel-js/animator';\n\n/** What {@link createWrittenPoseTarget} takes. */\nexport interface WrittenPoseTargetOptions<TPose> {\n  /** The pose the store holds for the node, or undefined once the node is gone. */\n  read(): TPose | undefined;\n  /** Writes the node's pose to the store. */\n  write(pose: TPose): void;\n  /** Supplies the pose's axes, as for `createPoseTarget`. */\n  descriptor?: PoseDescriptor<TPose>;\n  /** Called each time the node comes to rest. */\n  onRest?(): void;\n}\n\n/**\n * A {@link Target} over a pose whose store holds one value and has no overrides table to show a\n * moving pose through: an array in React state, a plain record. While the node moves, the\n * committed pose is kept here and the store is written the pose on screen each frame; at rest\n * the store holds the committed pose again.\n *\n * Something else writing the store mid-flight is not seen, and the next frame writes over it.\n * Null for a node the store does not hold, or a pose with no axes.\n */\nexport function createWrittenPoseTarget<TPose>(opts: WrittenPoseTargetOptions<TPose>): Target<TPose> | null {\n  const first = opts.read();\n  if (first === undefined) return null;\n  let last = first;\n  /** The committed pose while it is apart from the store's; null while the store holds it. */\n  let committed: TPose | null = null;\n  const get = (): TPose => {\n    if (committed !== null) return committed;\n    last = opts.read() ?? last;\n    return last;\n  };\n  const axes = liveAxes(opts.descriptor, get);\n  if (!axes) return null;\n  const target: Target<TPose> = createTarget<TPose>({\n    axes,\n    get,\n    set(pose) {\n      if (target.active) {\n        committed = pose;\n        return;\n      }\n      committed = null;\n      opts.write(pose);\n    },\n    show(pose) {\n      if (target.active) {\n        if (committed === null) committed = get();\n        opts.write(pose);\n        return;\n      }\n      const landed = committed;\n      committed = null;\n      if (landed !== null) opts.write(landed);\n      opts.onRest?.();\n    },\n  });\n  return target;\n}\n"],"mappings":";;;AAyBA,SAAgBA,EAA+B,GAA6D;CAC1G,IAAMC,IAAQC,EAAK,KAAK;CACxB,IAAID,MAAU,KAAA,GAAW,OAAO;CAChC,IAAIE,IAAOF,GAEPG,IAA0B,MACxBC,UACAD,MAAc,QAClB,IAAOF,EAAK,KAAK,KAAKC,GACfA,KAFwBC,GAI3BE,IAAOC,EAASL,EAAK,YAAYG,CAAG;CAC1C,IAAI,CAACC,GAAM,OAAO;CAClB,IAAME,IAAwBC,EAAoB;EAChD;EACA;EACA,IAAI,GAAM;GACR,IAAID,EAAO,QAAQ;IACjB,IAAYE;IACZ;GACF;GAEA,AADA,IAAY,MACZR,EAAK,MAAMQ,CAAI;EACjB;EACA,KAAK,GAAM;GACT,IAAIF,EAAO,QAAQ;IAEjB,AADIJ,MAAc,SAAM,IAAYC,EAAI,IACxCH,EAAK,MAAMQ,CAAI;IACf;GACF;GACA,IAAMC,IAASP;GAGf,AAFA,IAAY,MACRO,MAAW,QAAMT,EAAK,MAAMS,CAAM,GACtCT,EAAK,SAAS;EAChB;CACF,CAAC;CACD,OAAOM;AACT"}

package/dist/autoPoseDescriptor-DHg5KqaJ.d.ts

@@ -0,0 +1,27 @@
+import { Path } from '@weasel-js/geom';
+import { P as PoseDescriptor } from './poseDescriptor-Bqk-11Rl.js';
+
+/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
+ *  callers that need to fork between `pathPoseDescriptor` and
+ *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire
+ *  `poseDescriptor` explicitly. */
+declare function isPathLike(p: unknown): p is Path;
+/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only
+ *  shape the rect descriptor and the kit's built-in painters can read. */
+declare function isRectPose(p: unknown): p is {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+};
+/** Per-call dispatch: if the pose looks like a Path, route to
+ *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing
+ *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`
+ *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses
+ *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to
+ *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated
+ *  selection chrome and rotation-aware corner hit-tests. */
+declare const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown>;
+
+export { AUTO_POSE_DESCRIPTOR as A, isRectPose as a, isPathLike as i };

package/dist/barrel/canvas.js

@@ -0,0 +1,32 @@
+import { depsUnchanged as e, drawLayers as t, drawOneLayer as n, isLayerPainted as r, isLayerVisible as i, paintedLayers as a, subscribeToSources as o } from "../core/layers/render.js";
+import { dlog as s, dwarn as c, isDebugEnabled as l } from "../debug/flag.js";
+import { insertPreviewExtent as u } from "../canvas/insertPreviewExtent.js";
+import { isOverChildren as d, overChildren as f, splitOverChildren as p } from "../canvas/overChildren.js";
+import { DEFAULT_INK as m, findNodeShape as h, findShapeBounds as g, findShapeInk as _, findShapeSilhouette as v, getNodeShapes as y, registerNodeShape as b, shapeCoversPoint as x } from "../canvas/NodeShape.js";
+import { sceneToAdapter as S } from "../canvas/sceneAdapter.js";
+import { defaultDrawOne as C, defaultPaintBounds as w } from "../canvas/defaultDrawOne.js";
+import { DEFAULT_DEBUG_STROKES as T, DEFAULT_DEBUG_THEME as E } from "../debug/defaultTheme.js";
+import { buildDebugOverlayCommands as D, createDebugOverlayLayer as O } from "../debug/createDebugOverlayLayer.js";
+import { parseDebugFlags as k } from "../debug/parseDebugFlags.js";
+import { createDebugSink as A } from "../debug/createDebugSink.js";
+import { registerContentHandler as j } from "../features/ingestion/contentHandlers.js";
+import { hostAnchorCss as M, hostAnchorRect as N } from "../canvas/hostAnchor.js";
+import { useHostAnchor as P } from "../canvas/useHostAnchor.js";
+import { CursorCoordsHud as F } from "../canvas/CursorCoordsHud.js";
+import { PickHud as I } from "../canvas/PickHud.js";
+import { DEFAULT_HANDLE_SIZE as L } from "../canvas/SceneCanvas/props.js";
+import { createNodeRouting as R } from "../core/scene/NodeRouting.js";
+import { defaultNodeRouting as z, inferredNodeRouting as B } from "../canvas/SceneCanvas/defaultNodeRouting.js";
+import { resolveOverlays as V } from "../interactions/actions/resolveOverlays.js";
+import { flattenPreviews as H, resolvePreviews as U } from "../interactions/actions/resolvePreviews.js";
+import { useSceneAdapter as W } from "../canvas/useSceneAdapter.js";
+import { SceneCanvas as G } from "../canvas/SceneCanvas.js";
+import { createNodeProperties as K } from "../core/scene/NodeProperties.js";
+import { defaultNodeProperties as q, inferredNodeProperties as J, rotationDegreesUnit as Y } from "../canvas/SceneCanvas/defaultNodeProperties.js";
+import { kitTextHandler as X } from "../features/ingestion/textHandler.js";
+import { openFilePicker as Z } from "../features/ingestion/openFilePicker.js";
+import { WeaselProvider as Q } from "../WeaselProvider.js";
+import { modeDecorationLayer as $, workspaceTintLayer as ee } from "../features/modes/modeLayers.js";
+import { createChildrenLayer as te } from "../core/layers/children.js";
+import { getImageBitmap as ne, imageStatus as re, isVectorImageSrc as ie, releaseImage as ae, retryImage as oe, setImageCacheBudget as se, subscribeImageReady as ce } from "@weasel-js/renderer";
+export { F as CursorCoordsHud, T as DEFAULT_DEBUG_STROKES, E as DEFAULT_DEBUG_THEME, L as DEFAULT_HANDLE_SIZE, m as DEFAULT_INK, I as PickHud, G as SceneCanvas, Q as WeaselProvider, D as buildDebugOverlayCommands, te as createChildrenLayer, O as createDebugOverlayLayer, A as createDebugSink, K as createNodeProperties, R as createNodeRouting, C as defaultDrawOne, q as defaultNodeProperties, z as defaultNodeRouting, w as defaultPaintBounds, e as depsUnchanged, s as dlog, t as drawLayers, n as drawOneLayer, c as dwarn, h as findNodeShape, g as findShapeBounds, _ as findShapeInk, v as findShapeSilhouette, H as flattenPreviews, ne as getImageBitmap, y as getNodeShapes, M as hostAnchorCss, N as hostAnchorRect, re as imageStatus, J as inferredNodeProperties, B as inferredNodeRouting, u as insertPreviewExtent, l as isDebugEnabled, r as isLayerPainted, i as isLayerVisible, d as isOverChildren, ie as isVectorImageSrc, X as kitTextHandler, $ as modeDecorationLayer, Z as openFilePicker, f as overChildren, a as paintedLayers, k as parseDebugFlags, j as registerContentHandler, b as registerNodeShape, ae as releaseImage, V as resolveOverlays, U as resolvePreviews, oe as retryImage, Y as rotationDegreesUnit, S as sceneToAdapter, se as setImageCacheBudget, x as shapeCoversPoint, p as splitOverChildren, ce as subscribeImageReady, o as subscribeToSources, P as useHostAnchor, W as useSceneAdapter, ee as workspaceTintLayer };

package/dist/barrel/chrome.js

@@ -4,13 +4,13 @@ import { createCornerResizeAffordance as i } from "../affordances/cornerResize.j
 import { createRotationAffordance as a } from "../affordances/rotationHandle.js";
 import { PATH_ANCHOR_CHROME_ID as o, createPathAnchorAffordances as s } from "../affordances/pathAnchors.js";
 import { actionIs as c, always as l, and as u, canHover as d, capabilityAll as f, capabilityIn as p, capabilityIs as m, capabilityNot as h, coarsePointer as g, cond as _, focused as v, gesturing as y, hovering as b, hoveringSelected as x, modeIn as S, modeIs as C, modeNot as w, modifierHeld as T, multiActive as E, never as D, not as O, or as k, selectionAtLeast as A, selectionEmpty as j, selectionIs as M, when as N, zoomAtLeast as P } from "../features/chrome-caps/conditions.js";
-import { defaultVisibilityRules as F } from "../features/chrome-caps/defaults.js";
-import { resolveVisibility as I } from "../features/chrome-caps/resolve.js";
-import { buildChromeCtx as L } from "../features/chrome-caps/buildChromeCtx.js";
-import { useHoverTracking as R } from "../features/chrome-caps/useHoverTracking.js";
-import { ALWAYS as z, DEFAULT_ALLOWED_CAPABILITIES as B, NEVER as V, buildRuleCtx as H, describeRule as U, evaluate as W } from "../features/chrome-caps/index.js";
-import { SelectionContextProvider as G, SelectionContextProviderIfRoot as K, usePublishSelection as q, useSelectionContext as J } from "../features/selection/SelectionContext.js";
-import { composeSelectionPose as Y, createSelectionHandlesLayer as X, createSelectionOutlineLayer as Z, createSelectionOverlayLayer as Q } from "../features/selection/overlay.js";
-import { composeAffordanceLayer as $ } from "../affordances/composeAffordanceLayer.js";
-import { ANGLE_RADIANS as ee, IMPERIAL_INCHES as te, METRIC_MM as ne, PIXELS as re, formatUnit as ie, resolveUnit as ae, unitScale as oe } from "@weasel-js/quantity";
-export { z as ALWAYS, ee as ANGLE_RADIANS, B as DEFAULT_ALLOWED_CAPABILITIES, te as IMPERIAL_INCHES, ne as METRIC_MM, V as NEVER, o as PATH_ANCHOR_CHROME_ID, re as PIXELS, G as SelectionContextProvider, K as SelectionContextProviderIfRoot, c as actionIs, l as always, u as and, t as annulusSemiAxes, L as buildChromeCtx, H as buildRuleCtx, d as canHover, f as capabilityAll, p as capabilityIn, m as capabilityIs, h as capabilityNot, g as coarsePointer, $ as composeAffordanceLayer, Y as composeSelectionPose, _ as cond, i as createCornerResizeAffordance, s as createPathAnchorAffordances, a as createRotationAffordance, X as createSelectionHandlesLayer, Z as createSelectionOutlineLayer, Q as createSelectionOverlayLayer, F as defaultVisibilityRules, U as describeRule, W as evaluate, v as focused, ie as formatUnit, y as gesturing, n as hitAffordanceRegions, b as hovering, x as hoveringSelected, S as modeIn, C as modeIs, w as modeNot, T as modifierHeld, E as multiActive, D as never, O as not, k as or, r as pointRegionFrame, ae as resolveUnit, I as resolveVisibility, A as selectionAtLeast, j as selectionEmpty, M as selectionIs, oe as unitScale, R as useHoverTracking, q as usePublishSelection, e as useSelection, J as useSelectionContext, N as when, P as zoomAtLeast };
+import { composeSelectionPose as F, createSelectionHandlesLayer as I, createSelectionOutlineLayer as L, createSelectionOverlayLayer as R } from "../features/selection/overlay.js";
+import { defaultVisibilityRules as z } from "../features/chrome-caps/defaults.js";
+import { resolveVisibility as B } from "../features/chrome-caps/resolve.js";
+import { buildChromeCtx as V } from "../features/chrome-caps/buildChromeCtx.js";
+import { useHoverTracking as H } from "../features/chrome-caps/useHoverTracking.js";
+import { ALWAYS as U, DEFAULT_ALLOWED_CAPABILITIES as W, NEVER as G, buildRuleCtx as K, describeRule as q, evaluate as J } from "../features/chrome-caps/index.js";
+import { composeAffordanceLayer as Y } from "../affordances/composeAffordanceLayer.js";
+import { SelectionContextProvider as X, SelectionContextProviderIfRoot as Z, usePublishSelection as Q, useSelectionContext as $ } from "@weasel-js/routing/react";
+import { ANGLE_RADIANS as ee, IMPERIAL_INCHES as te, METRIC_MM as ne, PIXELS as re, axisUnits as ie, formatAxes as ae, formatScoped as oe, formatUnit as se, fromRoot as ce, parseUnitExpr as le, resolveAxes as ue, resolveScoped as de, resolveUnit as fe, resolveUnitExpr as pe, scopesOf as me, toRoot as he, unitScale as ge } from "@weasel-js/quantity";
+export { U as ALWAYS, ee as ANGLE_RADIANS, W as DEFAULT_ALLOWED_CAPABILITIES, te as IMPERIAL_INCHES, ne as METRIC_MM, G as NEVER, o as PATH_ANCHOR_CHROME_ID, re as PIXELS, X as SelectionContextProvider, Z as SelectionContextProviderIfRoot, c as actionIs, l as always, u as and, t as annulusSemiAxes, ie as axisUnits, V as buildChromeCtx, K as buildRuleCtx, d as canHover, f as capabilityAll, p as capabilityIn, m as capabilityIs, h as capabilityNot, g as coarsePointer, Y as composeAffordanceLayer, F as composeSelectionPose, _ as cond, i as createCornerResizeAffordance, s as createPathAnchorAffordances, a as createRotationAffordance, I as createSelectionHandlesLayer, L as createSelectionOutlineLayer, R as createSelectionOverlayLayer, z as defaultVisibilityRules, q as describeRule, J as evaluate, v as focused, ae as formatAxes, oe as formatScoped, se as formatUnit, ce as fromRoot, y as gesturing, n as hitAffordanceRegions, b as hovering, x as hoveringSelected, S as modeIn, C as modeIs, w as modeNot, T as modifierHeld, E as multiActive, D as never, O as not, k as or, le as parseUnitExpr, r as pointRegionFrame, ue as resolveAxes, de as resolveScoped, fe as resolveUnit, pe as resolveUnitExpr, B as resolveVisibility, me as scopesOf, A as selectionAtLeast, j as selectionEmpty, M as selectionIs, he as toRoot, ge as unitScale, H as useHoverTracking, Q as usePublishSelection, e as useSelection, $ as useSelectionContext, N as when, P as zoomAtLeast };

package/dist/barrel/input.js

@@ -1,19 +1,18 @@
 import { releaseCanvasRenderer as e } from "../canvas/canvasRenderer.js";
 import { buildSceneViewCommands as t, renderSceneToCanvas as n } from "../canvas/sceneViewRender.js";
-import { PointerContextProvider as r, createPointerStore as i, usePointerContext as a, usePointerPosition as o } from "../features/pointer/PointerContext.js";
-import { PointerProviderIfRoot as s } from "../canvas/SceneCanvas/PointerProviderIfRoot.js";
-import { FALLBACK_FIT_VIEW as c, computeFitView as l, computeIndicatorCommand as u } from "../canvas/minimapMath.js";
-import { forEachCoalesced as d, getStylusData as f, pressureToWidth as p } from "../core/stylus/stylus.js";
-import { usePointerStylus as m } from "../core/stylus/usePointerStylus.js";
-import { createKeyState as h } from "../input/keyState.js";
-import { useKeyState as g } from "../input/useKeyState.js";
-import { useKeyModifiers as _ } from "../input/useKeyModifiers.js";
-import { LONG_PRESS_FEEDBACK_ID as v, createLongPressFeedbackContribution as y } from "../features/longPress/longPressFeedback.js";
-import { renderNeeds as b } from "../canvas/renderNeeds.js";
-import { createRasterSession as x, planPixelRender as S, renderSceneToPixels as C, warmRender as w } from "../canvas/renderSceneToPixels.js";
-import { debugSnapshotArgs as T, renderDebugSnapshot as E } from "../canvas/renderDebugSnapshot.js";
-import { rasterToPng as D } from "../canvas/rasterToPng.js";
-import { ActionsProviderIfRoot as O } from "../canvas/SceneCanvas/ActionsProviderIfRoot.js";
-import { DepRegistryProviderIfRoot as k } from "../canvas/SceneCanvas/DepRegistryProviderIfRoot.js";
-import { LONG_PRESS_MS as A, activatesFocusedControl as j, createLongPressStore as M, historyKey as N, isEditableTarget as P, matchesKeyBinding as F } from "@weasel-js/routing";
-export { O as ActionsProviderIfRoot, k as DepRegistryProviderIfRoot, c as FALLBACK_FIT_VIEW, v as LONG_PRESS_FEEDBACK_ID, A as LONG_PRESS_MS, r as PointerContextProvider, s as PointerProviderIfRoot, j as activatesFocusedControl, t as buildSceneViewCommands, l as computeFitView, u as computeIndicatorCommand, h as createKeyState, y as createLongPressFeedbackContribution, M as createLongPressStore, i as createPointerStore, x as createRasterSession, T as debugSnapshotArgs, d as forEachCoalesced, f as getStylusData, N as historyKey, P as isEditableTarget, F as matchesKeyBinding, S as planPixelRender, p as pressureToWidth, D as rasterToPng, e as releaseCanvasRenderer, E as renderDebugSnapshot, b as renderNeeds, n as renderSceneToCanvas, C as renderSceneToPixels, _ as useKeyModifiers, g as useKeyState, a as usePointerContext, o as usePointerPosition, m as usePointerStylus, w as warmRender };
+import { forEachCoalesced as r, getStylusData as i, pressureToWidth as a } from "../core/stylus/stylus.js";
+import { usePointerStylus as o } from "../core/stylus/usePointerStylus.js";
+import { createKeyState as s } from "../input/keyState.js";
+import { useKeyState as c } from "../input/useKeyState.js";
+import { useKeyModifiers as l } from "../input/useKeyModifiers.js";
+import { LONG_PRESS_FEEDBACK_ID as u, createLongPressFeedbackContribution as d } from "../features/longPress/longPressFeedback.js";
+import { renderNeeds as f } from "../canvas/renderNeeds.js";
+import { createRasterSession as p, planPixelRender as m, renderSceneToPixels as h, warmRender as g } from "../canvas/renderSceneToPixels.js";
+import { debugSnapshotArgs as _, renderDebugSnapshot as v } from "../canvas/renderDebugSnapshot.js";
+import { rasterToPng as y } from "../canvas/rasterToPng.js";
+import { PointerProviderIfRoot as b } from "../canvas/SceneCanvas/PointerProviderIfRoot.js";
+import { ActionsProviderIfRoot as x } from "../canvas/SceneCanvas/ActionsProviderIfRoot.js";
+import { DepRegistryProviderIfRoot as S } from "../canvas/SceneCanvas/DepRegistryProviderIfRoot.js";
+import { LONG_PRESS_MS as C, activatesFocusedControl as w, createLongPressStore as T, focusedControlOwnsKey as E, historyKey as D, isEditableTarget as O, matchesKeyBinding as k } from "@weasel-js/routing";
+import { PointerContextProvider as A, createPointerStore as j, usePointerContext as M, usePointerPosition as N } from "@weasel-js/routing/react";
+export { x as ActionsProviderIfRoot, S as DepRegistryProviderIfRoot, u as LONG_PRESS_FEEDBACK_ID, C as LONG_PRESS_MS, A as PointerContextProvider, b as PointerProviderIfRoot, w as activatesFocusedControl, t as buildSceneViewCommands, s as createKeyState, d as createLongPressFeedbackContribution, T as createLongPressStore, j as createPointerStore, p as createRasterSession, _ as debugSnapshotArgs, E as focusedControlOwnsKey, r as forEachCoalesced, i as getStylusData, D as historyKey, O as isEditableTarget, k as matchesKeyBinding, m as planPixelRender, a as pressureToWidth, y as rasterToPng, e as releaseCanvasRenderer, v as renderDebugSnapshot, f as renderNeeds, n as renderSceneToCanvas, h as renderSceneToPixels, l as useKeyModifiers, c as useKeyState, M as usePointerContext, N as usePointerPosition, o as usePointerStylus, g as warmRender };