@weasel-js/core 1.10.1 → 1.11.0

package/dist/animation/rig/useRig.js

@@ -1,38 +1,52 @@
-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";
+import { createRigSeat, seatBinding } from "./rigSeat.js";
+import { bindRigOn } from "./bindRig.js";
+import { useEffect, useMemo } from "react";
+
 //#region src/animation/rig/useRig.ts
-function a(e) {
-	return o(e, null);
+/**
+* A {@link Rig} bound for the component's lifetime, its overrides dropped on
+* unmount. Rebinds — re-reading every node's rest pose — whenever an option's
+* identity changes, so hoist or memoize `skeleton`, `bindings`, and `skins`.
+*/
+function useRig(options) {
+	return useSeatedRig(options, 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
+/** {@link useRig} on a seat that outlives a rebind; `null` makes a seat for each binding. */
+function useSeatedRig(options, kept) {
+	const { scene, skeleton, bindings, skins, restPath, apply, descriptor } = options;
+	const made = useMemo(() => {
+		const seat = kept ?? createRigSeat(skeleton);
+		const bound = bindRigOn({
+			scene,
+			skeleton,
+			bindings,
+			skins,
+			restPath,
+			apply,
+			descriptor
+		}, seat);
+		seat.binding ??= bound.binding;
+		return {
+			seat,
+			...bound
 		};
 	}, [
-		s,
-		c,
-		l,
-		u,
-		d,
-		f,
-		p,
-		o
+		scene,
+		skeleton,
+		bindings,
+		skins,
+		restPath,
+		apply,
+		descriptor,
+		kept
 	]);
-	return r(() => (t(m.seat, m.binding), () => m.binding.drop()), [m]), m.rig;
+	useEffect(() => {
+		seatBinding(made.seat, made.binding);
+		return () => made.binding.drop();
+	}, [made]);
+	return made.rig;
 }
-//#endregion
-export { a as useRig, o as useSeatedRig };
 
+//#endregion
+export { useRig, useSeatedRig };
 //# sourceMappingURL=useRig.js.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"useRig.js","names":[],"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,SAAgB,OAAc,SAAqC;CACjE,OAAO,aAAa,SAAS,IAAI;AACnC;;AAGA,SAAgB,aAAoB,SAAgC,MAA2B;CAC7F,MAAM,EAAE,OAAO,UAAU,UAAU,OAAO,UAAU,OAAO,eAAe;CAC1E,MAAM,OAAO,cAAc;EACzB,MAAM,OAAO,QAAQ,cAAc,QAAQ;EAC3C,MAAM,QAAQ,UAAU;GAAE;GAAO;GAAU;GAAU;GAAO;GAAU;GAAO;EAAW,GAAG,IAAI;EAC/F,KAAK,YAAY,MAAM;EACvB,OAAO;GAAE;GAAM,GAAG;EAAM;CAC1B,GAAG;EAAC;EAAO;EAAU;EAAU;EAAO;EAAU;EAAO;EAAY;CAAI,CAAC;CACxE,gBAAgB;EACd,YAAY,KAAK,MAAM,KAAK,OAAO;EACnC,aAAa,KAAK,QAAQ,KAAK;CACjC,GAAG,CAAC,IAAI,CAAC;CACT,OAAO,KAAK;AACd"}

package/dist/animation/wrappers/animateLifecycle.js

@@ -1,48 +1,64 @@
-import { tweenPose as e } from "../poseHelpers.js";
-import { setPoseInstant as t } from "./instantPose.js";
+import { tweenPose } from "../poseHelpers.js";
+import { setPoseInstant } from "./instantPose.js";
+
 //#region src/animation/wrappers/animateLifecycle.ts
-function n(n, r, i) {
-	let a = i.ms ?? 200, o = /* @__PURE__ */ new Set();
+/** Wrap an adapter so inserts and removals animate — the scene-graph
+*  equivalent of CSS enter/leave transitions. The result is the adapter it
+*  was given, with `insertNode` and `removeNode` replaced. */
+function animateLifecycle(adapter, animator, opts) {
+	const ms = opts.ms ?? 200;
+	const leaving = /* @__PURE__ */ new Set();
 	return {
-		...n,
-		insertNode(o, s) {
-			if (n.insertNode(o, s), !i.enterFrom) return;
-			let c = n.getPose(o.id), l = i.enterFrom(c);
-			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,
-				geometry: i.geometry,
-				recordOp: !1
+		...adapter,
+		insertNode(object, index) {
+			adapter.insertNode(object, index);
+			if (!opts.enterFrom) return;
+			const final = adapter.getPose(object.id);
+			const start = opts.enterFrom(final);
+			if (!adapter.poseTarget?.(object.id, opts.geometry)) setPoseInstant(adapter, object.id, start);
+			tweenPose(animator, adapter, {
+				id: object.id,
+				from: start,
+				to: final,
+				ms,
+				easing: opts.easing,
+				geometry: opts.geometry,
+				recordOp: false
 			});
 		},
-		removeNode(t) {
-			if (!i.exitTo) {
-				n.removeNode(t);
+		removeNode(id) {
+			if (!opts.exitTo) {
+				adapter.removeNode(id);
 				return;
 			}
-			if (o.has(t)) return;
-			o.add(t);
-			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(d),
-				ms: a,
-				easing: i.easing,
-				geometry: i.geometry,
-				recordOp: !1,
-				onDone: u
+			if (leaving.has(id)) return;
+			leaving.add(id);
+			let unwatch = () => {};
+			const target = adapter.poseTarget?.(id, opts.geometry);
+			const home = target?.committed();
+			const remove = () => {
+				if (!leaving.delete(id)) return;
+				unwatch();
+				if (target) target.commit(home);
+				adapter.removeNode(id);
+			};
+			const current = adapter.getPose(id);
+			const handle = tweenPose(animator, adapter, {
+				id,
+				to: opts.exitTo(current),
+				ms,
+				easing: opts.easing,
+				geometry: opts.geometry,
+				recordOp: false,
+				onDone: remove
 			});
-			s = r.watch((e) => {
-				(e.type === "cancel" || e.type === "interrupt") && e.animation.id === f.id && u();
+			unwatch = animator.watch((event) => {
+				if ((event.type === "cancel" || event.type === "interrupt") && event.animation.id === handle.id) remove();
 			});
 		}
 	};
 }
-//#endregion
-export { n as animateLifecycle };
 
+//#endregion
+export { animateLifecycle };
 //# sourceMappingURL=animateLifecycle.js.map

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","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"}
+{"version":3,"file":"animateLifecycle.js","names":[],"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,SAAgB,iBAKd,SACA,UACA,MACG;CACH,MAAM,KAAK,KAAK,MAAM;CACtB,MAAM,0BAAU,IAAI,IAAY;CAEhC,OAAO;EACL,GAAG;EACH,WAAW,QAAe,OAAsB;GAC9C,QAAQ,WAAW,QAAQ,KAAK;GAChC,IAAI,CAAC,KAAK,WAAW;GACrB,MAAM,QAAQ,QAAQ,QAAQ,OAAO,EAAE;GACvC,MAAM,QAAQ,KAAK,UAAU,KAAK;GAElC,IAAI,CAAC,QAAQ,aAAa,OAAO,IAAI,KAAK,QAAQ,GAAG,eAAe,SAAS,OAAO,IAAI,KAAK;GAC7F,UAAU,UAAU,SAAS;IAC3B,IAAI,OAAO;IACX,MAAM;IACN,IAAI;IACJ;IACA,QAAQ,KAAK;IACb,UAAU,KAAK;IACf,UAAU;GACZ,CAAC;EACH;EACA,WAAW,IAAkB;GAC3B,IAAI,CAAC,KAAK,QAAQ;IAChB,QAAQ,WAAW,EAAE;IACrB;GACF;GACA,IAAI,QAAQ,IAAI,EAAE,GAAG;GACrB,QAAQ,IAAI,EAAE;GACd,IAAI,gBAAsB,CAAC;GAC3B,MAAM,SAAS,QAAQ,aAAa,IAAI,KAAK,QAAQ;GACrD,MAAM,OAAO,QAAQ,UAAU;GAC/B,MAAM,eAAqB;IACzB,IAAI,CAAC,QAAQ,OAAO,EAAE,GAAG;IACzB,QAAQ;IAER,IAAI,QAAQ,OAAO,OAAO,IAAa;IACvC,QAAQ,WAAW,EAAE;GACvB;GACA,MAAM,UAAU,QAAQ,QAAQ,EAAE;GAClC,MAAM,SAAS,UAAU,UAAU,SAAS;IAC1C;IACA,IAAI,KAAK,OAAO,OAAO;IACvB;IACA,QAAQ,KAAK;IACb,UAAU,KAAK;IACf,UAAU;IACV,QAAQ;GACV,CAAC;GAED,UAAU,SAAS,OAAO,UAAU;IAClC,KAAK,MAAM,SAAS,YAAY,MAAM,SAAS,gBAAgB,MAAM,UAAU,OAAO,OAAO,IAAI,OAAO;GAC1G,CAAC;EACH;CACF;AACF"}

package/dist/animation/wrappers/animateOnSetPose.js

@@ -1,46 +1,69 @@
-import { poseKey as e, springPose as t, tweenPose as n } from "../poseHelpers.js";
-import { instantPoseWrite as r } from "./instantPose.js";
+import { poseKey, springPose, tweenPose } from "../poseHelpers.js";
+import { instantPoseWrite } from "./instantPose.js";
+
 //#region src/animation/wrappers/animateOnSetPose.ts
-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));
+/**
+* Wrap an adapter so every `setPose` animates to the new pose instead of
+* jumping to it. The result is the adapter it was given, with that one method
+* replaced.
+*
+* Poses written from inside another animation's tick, and (optionally) poses
+* written for a node currently under a gesture, are passed straight through.
+*
+* Over a scene-backed adapter the document takes each pose as it is written
+* and only the node on screen glides; a store behind `createWrittenPoseTarget`
+* holds the pose on screen, and takes the written one as the glide ends. Writing a node again while it glides
+* bends the glide toward the new pose, or under `spring` carries its velocity
+* into the new one. Over an adapter with no `poseTarget`, a second write ends
+* the glide: the new pose is written at once and stands.
+*/
+function animateOnSetPose(adapter, animator, opts = {}) {
+	const ms = opts.ms ?? 200;
+	const skipPredicate = (id, from, to) => {
+		if (opts.shouldAnimate) return !opts.shouldAnimate(id, from, to);
+		if (opts.skipDuringGesture && opts.gestureScope?.has(id)) return true;
+		return false;
+	};
 	return {
-		...i,
-		...r(i),
-		setPose(r, l) {
-			let u = i.getPose(r);
-			if (c(r, u, l)) {
-				i.setPose(r, l);
+		...adapter,
+		...instantPoseWrite(adapter),
+		setPose(id, pose) {
+			const from = adapter.getPose(id);
+			if (skipPredicate(id, from, pose)) {
+				adapter.setPose(id, pose);
 				return;
 			}
-			if (a.isTicking()) {
-				i.setPose(r, l);
+			if (animator.isTicking()) {
+				adapter.setPose(id, pose);
 				return;
 			}
-			if (!i.poseTarget?.(r, o.geometry) && a.isActive(e(r))) {
-				a.cancelKey(e(r)), i.setPose(r, l);
+			if (!adapter.poseTarget?.(id, opts.geometry) && animator.isActive(poseKey(id))) {
+				animator.cancelKey(poseKey(id));
+				adapter.setPose(id, pose);
 				return;
 			}
-			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
+			if (opts.spring) springPose(animator, adapter, {
+				id,
+				to: pose,
+				preset: opts.spring.preset,
+				stiffness: opts.spring.stiffness,
+				damping: opts.spring.damping,
+				mass: opts.spring.mass,
+				geometry: opts.geometry,
+				opLabel: opts.opLabel
+			});
+			else tweenPose(animator, adapter, {
+				id,
+				to: pose,
+				ms,
+				easing: opts.easing,
+				geometry: opts.geometry,
+				opLabel: opts.opLabel
 			});
 		}
 	};
 }
-//#endregion
-export { i as animateOnSetPose };
 
+//#endregion
+export { 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","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"}
+{"version":3,"file":"animateOnSetPose.js","names":[],"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,SAAgB,iBACd,SACA,UACA,OAAuC,CAAC,GACrC;CACH,MAAM,KAAK,KAAK,MAAM;CACtB,MAAM,iBAAiB,IAAY,MAAa,OAAuB;EACrE,IAAI,KAAK,eAAe,OAAO,CAAC,KAAK,cAAc,IAAI,MAAM,EAAE;EAC/D,IAAI,KAAK,qBAAqB,KAAK,cAAc,IAAI,EAAE,GAAG,OAAO;EACjE,OAAO;CACT;CAEA,OAAO;EACL,GAAG;EACH,GAAG,iBAAiB,OAAO;EAC3B,QAAQ,IAAY,MAAmB;GACrC,MAAM,OAAO,QAAQ,QAAQ,EAAE;GAC/B,IAAI,cAAc,IAAI,MAAM,IAAI,GAAG;IACjC,QAAQ,QAAQ,IAAI,IAAI;IACxB;GACF;GAIA,IAAI,SAAS,UAAU,GAAG;IACxB,QAAQ,QAAQ,IAAI,IAAI;IACxB;GACF;GAEA,IAAI,CAAC,QAAQ,aAAa,IAAI,KAAK,QAAQ,KAAK,SAAS,SAAS,QAAQ,EAAE,CAAC,GAAG;IAC9E,SAAS,UAAU,QAAQ,EAAE,CAAC;IAC9B,QAAQ,QAAQ,IAAI,IAAI;IACxB;GACF;GACA,IAAI,KAAK,QACP,WAAW,UAAU,SAAS;IAC5B;IACA,IAAI;IACJ,QAAQ,KAAK,OAAO;IACpB,WAAW,KAAK,OAAO;IACvB,SAAS,KAAK,OAAO;IACrB,MAAM,KAAK,OAAO;IAClB,UAAU,KAAK;IACf,SAAS,KAAK;GAChB,CAAC;QAED,UAAU,UAAU,SAAS;IAC3B;IACA,IAAI;IACJ;IACA,QAAQ,KAAK;IACb,UAAU,KAAK;IACf,SAAS,KAAK;GAChB,CAAC;EAEL;CACF;AACF"}

package/dist/animation/wrappers/instantPose.js

@@ -1,13 +1,18 @@
 //#region src/animation/wrappers/instantPose.ts
-var e = Symbol("weasel.setPoseInstant");
-function t(t) {
-	return { [e]: (e, r) => n(t, e, r) };
+var INSTANT = Symbol("weasel.setPoseInstant");
+/** The member an adapter wrapper that animates `setPose` spreads into what it
+*  returns, so the write that does not animate survives any wrapper above it
+*  that copies the adapter. */
+function instantPoseWrite(inner) {
+	return { [INSTANT]: (id, pose) => setPoseInstant(inner, id, pose) };
 }
-function n(t, n, r) {
-	let i = t[e];
-	i ? i(n, r) : t.setPose(n, r);
+/** Write a pose at once, past every wrapper that would animate it. */
+function setPoseInstant(adapter, id, pose) {
+	const instant = adapter[INSTANT];
+	if (instant) instant(id, pose);
+	else adapter.setPose(id, pose);
 }
-//#endregion
-export { t as instantPoseWrite, n as setPoseInstant };
 
+//#endregion
+export { instantPoseWrite, setPoseInstant };
 //# sourceMappingURL=instantPose.js.map

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":["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"}
+{"version":3,"file":"instantPose.js","names":[],"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,IAAM,UAAU,OAAO,uBAAuB;;;;AAQ9C,SAAgB,iBAAwB,OAA8C;CACpF,OAAO,GAAG,WAAW,IAAY,SAAgB,eAAe,OAAO,IAAI,IAAI,EAAE;AACnF;;AAGA,SAAgB,eAAsB,SAAwC,IAAY,MAAmB;CAC3G,MAAM,UAAW,QAA+B;CAChD,IAAI,SAAS,QAAQ,IAAI,IAAI;MACxB,QAAQ,QAAQ,IAAI,IAAI;AAC/B"}

package/dist/animation/writtenPoseTarget.js

@@ -1,33 +1,55 @@
-import { liveAxes as e } from "./poseTarget.js";
-import { createTarget as t } from "@weasel-js/animator";
+import { liveAxes } from "./poseTarget.js";
+import { createTarget } 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;
+/**
+* A {@link Target} over a pose whose store holds one value and has no overrides table to show a
+* moving pose through: an array in React state, a plain record. While the node moves, the
+* committed pose is kept here and the store is written the pose on screen each frame; at rest
+* the store holds the committed pose again.
+*
+* Something else writing the store mid-flight is not seen, and the next frame writes over it.
+* Null for a node the store does not hold, or a pose with no axes.
+*/
+function createWrittenPoseTarget(opts) {
+	const first = opts.read();
+	if (first === void 0) return null;
+	let last = first;
+	/** The committed pose while it is apart from the store's; null while the store holds it. */
+	let committed = null;
+	const get = () => {
+		if (committed !== null) return committed;
+		last = opts.read() ?? last;
+		return last;
+	};
+	const axes = liveAxes(opts.descriptor, get);
+	if (!axes) return null;
+	const target = createTarget({
+		axes,
+		get,
+		set(pose) {
+			if (target.active) {
+				committed = pose;
 				return;
 			}
-			a = null, n.write(e);
+			committed = null;
+			opts.write(pose);
 		},
-		show(e) {
-			if (c.active) {
-				a === null && (a = o()), n.write(e);
+		show(pose) {
+			if (target.active) {
+				if (committed === null) committed = get();
+				opts.write(pose);
 				return;
 			}
-			let t = a;
-			a = null, t !== null && n.write(t), n.onRest?.();
+			const landed = committed;
+			committed = null;
+			if (landed !== null) opts.write(landed);
+			opts.onRest?.();
 		}
 	});
-	return c;
+	return target;
 }
-//#endregion
-export { n as createWrittenPoseTarget };
 
+//#endregion
+export { createWrittenPoseTarget };
 //# sourceMappingURL=writtenPoseTarget.js.map

package/dist/animation/writtenPoseTarget.js.map

@@ -1 +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"}
+{"version":3,"file":"writtenPoseTarget.js","names":[],"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,SAAgB,wBAA+B,MAA6D;CAC1G,MAAM,QAAQ,KAAK,KAAK;CACxB,IAAI,UAAU,QAAW,OAAO;CAChC,IAAI,OAAO;;CAEX,IAAI,YAA0B;CAC9B,MAAM,YAAmB;EACvB,IAAI,cAAc,MAAM,OAAO;EAC/B,OAAO,KAAK,KAAK,KAAK;EACtB,OAAO;CACT;CACA,MAAM,OAAO,SAAS,KAAK,YAAY,GAAG;CAC1C,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,SAAwB,aAAoB;EAChD;EACA;EACA,IAAI,MAAM;GACR,IAAI,OAAO,QAAQ;IACjB,YAAY;IACZ;GACF;GACA,YAAY;GACZ,KAAK,MAAM,IAAI;EACjB;EACA,KAAK,MAAM;GACT,IAAI,OAAO,QAAQ;IACjB,IAAI,cAAc,MAAM,YAAY,IAAI;IACxC,KAAK,MAAM,IAAI;IACf;GACF;GACA,MAAM,SAAS;GACf,YAAY;GACZ,IAAI,WAAW,MAAM,KAAK,MAAM,MAAM;GACtC,KAAK,SAAS;EAChB;CACF,CAAC;CACD,OAAO;AACT"}

package/dist/{autoPoseDescriptor-DHg5KqaJ.d.ts → autoPoseDescriptor-CZ1eXbzY.d.ts}

@@ -1,5 +1,5 @@
 import { Path } from '@weasel-js/geom';
-import { P as PoseDescriptor } from './poseDescriptor-Bqk-11Rl.js';
+import { P as PoseDescriptor } from './poseDescriptor-DN2yfnq_.js';
 
 /** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
  *  callers that need to fork between `pathPoseDescriptor` and

package/dist/barrel/canvas.js

@@ -1,32 +1,41 @@
-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 };
+import { DEFAULT_LAYER_RETAIN } from "../core/layers/retain.js";
+import { subscribeToSources } from "../core/layers/redrawSource.js";
+import { depsUnchanged, drawLayers, drawOneLayer, isLayerPainted, isLayerVisible, paintedLayers } from "../core/layers/render.js";
+import { dlog, dwarn, isDebugEnabled } from "../debug/flag.js";
+import { OVERLAY_ROLE_STROKES } from "../canvas/overlayRoleStrokes.js";
+import { DEFAULT_INK, findNodeShape, findShapeBounds, findShapeInk, findShapeSilhouette, getNodeShapes, registerNodeShape, shapeCoversPoint } from "../canvas/NodeShape.js";
+import { drawnAABBOf, drawnBoundsOf, findShapeDrawnBounds, inkExtentsOf } from "../canvas/drawnBounds.js";
+import { insertPreviewExtent } from "../canvas/insertPreviewExtent.js";
+import { isOverChildren, overChildren, splitOverChildren } from "../canvas/overChildren.js";
+import { sceneToAdapter } from "../canvas/sceneAdapter.js";
+import { defaultDrawOne, defaultPaintBounds } from "../canvas/defaultDrawOne.js";
+import { DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME } from "../debug/defaultTheme.js";
+import { buildDebugOverlayCommands, createDebugOverlayLayer } from "../debug/createDebugOverlayLayer.js";
+import { minSizeOf } from "../core/scene/minSize.js";
+import { parseDebugFlags } from "../debug/parseDebugFlags.js";
+import { createDebugSink } from "../debug/createDebugSink.js";
+import { registerContentHandler } from "../features/ingestion/contentHandlers.js";
+import { hostAnchorCss, hostAnchorRect } from "../canvas/hostAnchor.js";
+import { useHostAnchor } from "../canvas/useHostAnchor.js";
+import { CursorCoordsHud } from "../canvas/CursorCoordsHud.js";
+import { PickHud } from "../canvas/PickHud.js";
+import { PATH_OVERLAY_ROLES, createPathOverlay } from "../canvas/pathOverlay.js";
+import { DEFAULT_HANDLE_SIZE } from "../canvas/SceneCanvas/props.js";
+import { resolveOverlays } from "../interactions/actions/resolveOverlays.js";
+import { flattenPreviews, resolvePreviews } from "../interactions/actions/resolvePreviews.js";
+import { useSceneAdapter } from "../canvas/useSceneAdapter.js";
+import { createNodeRouting } from "../core/scene/NodeRouting.js";
+import { defaultNodeRouting, groupNodeRouting, inferredNodeRouting } from "../canvas/SceneCanvas/defaultNodeRouting.js";
+import { SceneCanvas } from "../canvas/SceneCanvas.js";
+import { LeanSceneCanvas } from "../canvas/LeanSceneCanvas.js";
+import { createNodeProperties } from "../core/scene/NodeProperties.js";
+import { defaultNodeProperties, inferredNodeProperties, rotationDegreesUnit } from "../canvas/SceneCanvas/defaultNodeProperties.js";
+import { kitTextHandler } from "../features/ingestion/textHandler.js";
+import { openFilePicker } from "../features/ingestion/openFilePicker.js";
+import { WeaselProvider } from "../WeaselProvider.js";
+import { modeDecorationLayer, workspaceTintLayer } from "../features/modes/modeLayers.js";
+import { modeTriggers } from "../features/modes/modeTriggers.js";
+import { createChildrenLayer } from "../core/layers/children.js";
+import { bitmapSrc, getImageBitmap as getImageBitmap$1, imageStatus as imageStatus$1, isVectorImageSrc, releaseImage, retryImage, setImageCacheBudget, subscribeImageReady as subscribeImageReady$1 } from "@weasel-js/renderer";
+
+export { CursorCoordsHud, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_LAYER_RETAIN, LeanSceneCanvas, OVERLAY_ROLE_STROKES, PATH_OVERLAY_ROLES, PickHud, SceneCanvas, WeaselProvider, bitmapSrc, buildDebugOverlayCommands, createChildrenLayer, createDebugOverlayLayer, createDebugSink, createNodeProperties, createNodeRouting, createPathOverlay, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, depsUnchanged, dlog, drawLayers, drawOneLayer, drawnAABBOf, drawnBoundsOf, dwarn, findNodeShape, findShapeBounds, findShapeDrawnBounds, findShapeInk, findShapeSilhouette, flattenPreviews, getImageBitmap$1 as getImageBitmap, getNodeShapes, groupNodeRouting, hostAnchorCss, hostAnchorRect, imageStatus$1 as imageStatus, inferredNodeProperties, inferredNodeRouting, inkExtentsOf, insertPreviewExtent, isDebugEnabled, isLayerPainted, isLayerVisible, isOverChildren, isVectorImageSrc, kitTextHandler, minSizeOf, modeDecorationLayer, modeTriggers, openFilePicker, overChildren, paintedLayers, parseDebugFlags, registerContentHandler, registerNodeShape, releaseImage, resolveOverlays, resolvePreviews, retryImage, rotationDegreesUnit, sceneToAdapter, setImageCacheBudget, shapeCoversPoint, splitOverChildren, subscribeImageReady$1 as subscribeImageReady, subscribeToSources, useHostAnchor, useSceneAdapter, workspaceTintLayer };