@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/scene/composeFrame.js.map

@@ -1 +1 @@
-{"version":3,"file":"composeFrame.js","names":["IDENTITY_POSE_COMPOSITION","child","world","composesFrames","composition","composeWorldPose","chain","id","seen","cursor","adapter","i","compose","rebaseLocalPose","frame","frameAtOrAbove","newParentId","worldPose","decompose"],"sources":["../../../src/core/scene/composeFrame.ts"],"sourcesContent":["/** Folding a node's pose up its parent chain to world, and back down. */\n\n/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */\nexport interface PoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  getParent(id: string): string | null;\n  /** Whether `id`'s pose is a frame its children are expressed in. Absent\n   *  means every node is one. A container whose pose derives from its children\n   *  is not: its children share its frame, so the fold passes over it. */\n  definesFrame?(id: string): boolean;\n}\n\n/**\n * What a container's pose does to its children under a `compose`: nothing,\n * an offset, or a whole frame. `'rigid'` is the frame: a container's rotation\n * and its `transform` both reach its children, and a child's `transform`\n * holds the skew or stretch its box and rotation cannot.\n */\nexport type PoseClosure = 'identity' | 'translation' | 'rigid';\n\n/** Consumer's pose-composition strategy for hierarchical scenes. `compose`\n *  folds a child's pose (in parent's frame) up to the next frame; `decompose`\n *  is its inverse. Default is IDENTITY — an absolute-pose scene where every\n *  node already stores world coords (parent is grouping-only, no transform). */\nexport interface PoseComposition<TPose> {\n  compose(parent: TPose, child: TPose): TPose;\n  decompose(parent: TPose, world: TPose): TPose;\n  closure: PoseClosure;\n}\n\n/** Default pose-composition strategy: IDENTITY, an absolute-pose scene. */\nexport const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown> = {\n  compose: (_parent, child) => child,\n  decompose: (_parent, world) => world,\n  closure: 'identity',\n};\n\n/** Whether `composition` makes a container's pose a frame, so a stored pose\n *  is local to it. False for the absolute-pose model. */\nexport function composesFrames(composition: { closure: PoseClosure }): boolean {\n  return composition.closure !== 'identity';\n}\n\n/**\n * Walk `id`'s parent chain and fold local poses into a world pose via\n * `compose`. Cycle-safe.\n *\n * `compose(parent, child)` interprets `child` as expressed *in `parent`'s\n * local frame* and returns the equivalent pose in the next frame up.\n */\nexport function composeWorldPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string,\n  compose: (parent: TPose, child: TPose) => TPose,\n): TPose {\n  const chain: string[] = [id];\n  const seen = new Set<string>([id]);\n  let cursor: string | null = adapter.getParent(id);\n  while (cursor !== null) {\n    if (seen.has(cursor)) break;\n    seen.add(cursor);\n    if (adapter.definesFrame?.(cursor) ?? true) chain.push(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  // chain is [id, parent, grandparent, ..., root]; fold from the root down.\n  let world = adapter.getPose(chain[chain.length - 1]);\n  for (let i = chain.length - 2; i >= 0; i--) {\n    world = compose(world, adapter.getPose(chain[i]));\n  }\n  return world;\n}\n\n/**\n * Convert `worldPose` into a local pose expressed under `newParentId`'s\n * frame, so a reparented child keeps its visual world position.\n *\n * `decompose(parent, world)` returns the local pose `child` such that\n * `compose(parent, child) === world`. Pass `newParentId === null` for the\n * root frame; the function returns `worldPose` unchanged.\n */\nexport function rebaseLocalPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  worldPose: TPose,\n  newParentId: string | null,\n  compose: (parent: TPose, child: TPose) => TPose,\n  decompose: (parent: TPose, world: TPose) => TPose,\n): TPose {\n  const frame = frameAtOrAbove(adapter, newParentId);\n  if (frame === null) return worldPose;\n  return decompose(composeWorldPose(adapter, frame, compose), worldPose);\n}\n\n/** The nearest node at or above `id` whose pose is a frame, or `null` for the\n *  root frame. Cycle-safe, like `composeWorldPose`. */\nexport function frameAtOrAbove<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string | null,\n): string | null {\n  const seen = new Set<string>();\n  let cursor = id;\n  while (cursor !== null && !seen.has(cursor)) {\n    if (adapter.definesFrame?.(cursor) ?? true) return cursor;\n    seen.add(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  return null;\n}\n"],"mappings":";AA+BA,IAAaA,IAAsD;CACjE,UAAU,GAAS,MAAUC;CAC7B,YAAY,GAAS,MAAUC;CAC/B,SAAS;AACX;AAIA,SAAgBC,EAAe,GAAgD;CAC7E,OAAOC,EAAY,YAAY;AACjC;AASA,SAAgBC,EACd,GACA,GACA,GACO;CACP,IAAMC,IAAkB,CAACC,CAAE,GACrBC,oBAAO,IAAI,IAAY,CAACD,CAAE,CAAC,GAC7BE,IAAwBC,EAAQ,UAAUH,CAAE;CAChD,OAAOE,MAAW,QACZ,GAAK,IAAIA,CAAM,IAGnB,AAFAD,EAAK,IAAIC,CAAM,IACXC,EAAQ,eAAeD,CAAM,KAAK,OAAMH,EAAM,KAAKG,CAAM,GAC7D,IAASC,EAAQ,UAAUD,CAAM;CAGnC,IAAIP,IAAQQ,EAAQ,QAAQJ,EAAMA,EAAM,SAAS,EAAE;CACnD,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAQC,EAAQV,GAAOQ,EAAQ,QAAQJ,EAAMK,EAAE,CAAC;CAElD,OAAOT;AACT;AAUA,SAAgBW,EACd,GACA,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAQC,EAAeL,GAASM,CAAW;CAEjD,OADIF,MAAU,OAAaG,IACpBC,EAAUb,EAAiBK,GAASI,GAAOF,CAAO,GAAGK,CAAS;AACvE;AAIA,SAAgBF,EACd,GACA,GACe;CACf,IAAMP,oBAAO,IAAI,IAAY,GACzBC,IAASF;CACb,OAAOE,MAAW,QAAQ,CAACD,EAAK,IAAIC,CAAM,IAAG;EAC3C,IAAIC,EAAQ,eAAeD,CAAM,KAAK,IAAM,OAAOA;EAEnD,AADAD,EAAK,IAAIC,CAAM,GACf,IAASC,EAAQ,UAAUD,CAAM;CACnC;CACA,OAAO;AACT"}
+{"version":3,"file":"composeFrame.js","names":[],"sources":["../../../src/core/scene/composeFrame.ts"],"sourcesContent":["/** Folding a node's pose up its parent chain to world, and back down. */\n\n/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */\nexport interface PoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  getParent(id: string): string | null;\n  /** Whether `id`'s pose is a frame its children are expressed in. Absent\n   *  means every node is one. A container whose pose derives from its children\n   *  is not: its children share its frame, so the fold passes over it. */\n  definesFrame?(id: string): boolean;\n}\n\n/**\n * What a container's pose does to its children under a `compose`: nothing,\n * an offset, or a whole frame. `'rigid'` is the frame: a container's rotation\n * and its `transform` both reach its children, and a child's `transform`\n * holds the skew or stretch its box and rotation cannot.\n */\nexport type PoseClosure = 'identity' | 'translation' | 'rigid';\n\n/** Consumer's pose-composition strategy for hierarchical scenes. `compose`\n *  folds a child's pose (in parent's frame) up to the next frame; `decompose`\n *  is its inverse. Default is IDENTITY — an absolute-pose scene where every\n *  node already stores world coords (parent is grouping-only, no transform). */\nexport interface PoseComposition<TPose> {\n  compose(parent: TPose, child: TPose): TPose;\n  decompose(parent: TPose, world: TPose): TPose;\n  closure: PoseClosure;\n}\n\n/** Default pose-composition strategy: IDENTITY, an absolute-pose scene. */\nexport const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown> = {\n  compose: (_parent, child) => child,\n  decompose: (_parent, world) => world,\n  closure: 'identity',\n};\n\n/** Whether `composition` makes a container's pose a frame, so a stored pose\n *  is local to it. False for the absolute-pose model. */\nexport function composesFrames(composition: { closure: PoseClosure }): boolean {\n  return composition.closure !== 'identity';\n}\n\n/**\n * Walk `id`'s parent chain and fold local poses into a world pose via\n * `compose`. Cycle-safe.\n *\n * `compose(parent, child)` interprets `child` as expressed *in `parent`'s\n * local frame* and returns the equivalent pose in the next frame up.\n */\nexport function composeWorldPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string,\n  compose: (parent: TPose, child: TPose) => TPose,\n): TPose {\n  const chain: string[] = [id];\n  const seen = new Set<string>([id]);\n  let cursor: string | null = adapter.getParent(id);\n  while (cursor !== null) {\n    if (seen.has(cursor)) break;\n    seen.add(cursor);\n    if (adapter.definesFrame?.(cursor) ?? true) chain.push(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  // chain is [id, parent, grandparent, ..., root]; fold from the root down.\n  let world = adapter.getPose(chain[chain.length - 1]);\n  for (let i = chain.length - 2; i >= 0; i--) {\n    world = compose(world, adapter.getPose(chain[i]));\n  }\n  return world;\n}\n\n/**\n * Convert `worldPose` into a local pose expressed under `newParentId`'s\n * frame, so a reparented child keeps its visual world position.\n *\n * `decompose(parent, world)` returns the local pose `child` such that\n * `compose(parent, child) === world`. Pass `newParentId === null` for the\n * root frame; the function returns `worldPose` unchanged.\n */\nexport function rebaseLocalPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  worldPose: TPose,\n  newParentId: string | null,\n  compose: (parent: TPose, child: TPose) => TPose,\n  decompose: (parent: TPose, world: TPose) => TPose,\n): TPose {\n  const frame = frameAtOrAbove(adapter, newParentId);\n  if (frame === null) return worldPose;\n  return decompose(composeWorldPose(adapter, frame, compose), worldPose);\n}\n\n/** The nearest node at or above `id` whose pose is a frame, or `null` for the\n *  root frame. Cycle-safe, like `composeWorldPose`. */\nexport function frameAtOrAbove<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string | null,\n): string | null {\n  const seen = new Set<string>();\n  let cursor = id;\n  while (cursor !== null && !seen.has(cursor)) {\n    if (adapter.definesFrame?.(cursor) ?? true) return cursor;\n    seen.add(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  return null;\n}\n"],"mappings":";;AA+BA,IAAa,4BAAsD;CACjE,UAAU,SAAS,UAAU;CAC7B,YAAY,SAAS,UAAU;CAC/B,SAAS;AACX;;;AAIA,SAAgB,eAAe,aAAgD;CAC7E,OAAO,YAAY,YAAY;AACjC;;;;;;;;AASA,SAAgB,iBACd,SACA,IACA,SACO;CACP,MAAM,QAAkB,CAAC,EAAE;CAC3B,MAAM,uBAAO,IAAI,IAAY,CAAC,EAAE,CAAC;CACjC,IAAI,SAAwB,QAAQ,UAAU,EAAE;CAChD,OAAO,WAAW,MAAM;EACtB,IAAI,KAAK,IAAI,MAAM,GAAG;EACtB,KAAK,IAAI,MAAM;EACf,IAAI,QAAQ,eAAe,MAAM,KAAK,MAAM,MAAM,KAAK,MAAM;EAC7D,SAAS,QAAQ,UAAU,MAAM;CACnC;CAEA,IAAI,QAAQ,QAAQ,QAAQ,MAAM,MAAM,SAAS,EAAE;CACnD,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KACrC,QAAQ,QAAQ,OAAO,QAAQ,QAAQ,MAAM,EAAE,CAAC;CAElD,OAAO;AACT;;;;;;;;;AAUA,SAAgB,gBACd,SACA,WACA,aACA,SACA,WACO;CACP,MAAM,QAAQ,eAAe,SAAS,WAAW;CACjD,IAAI,UAAU,MAAM,OAAO;CAC3B,OAAO,UAAU,iBAAiB,SAAS,OAAO,OAAO,GAAG,SAAS;AACvE;;;AAIA,SAAgB,eACd,SACA,IACe;CACf,MAAM,uBAAO,IAAI,IAAY;CAC7B,IAAI,SAAS;CACb,OAAO,WAAW,QAAQ,CAAC,KAAK,IAAI,MAAM,GAAG;EAC3C,IAAI,QAAQ,eAAe,MAAM,KAAK,MAAM,OAAO;EACnD,KAAK,IAAI,MAAM;EACf,SAAS,QAAQ,UAAU,MAAM;CACnC;CACA,OAAO;AACT"}

package/dist/core/scene/composePose.js

@@ -1,47 +1,69 @@
-import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, composesFrames as n, frameAtOrAbove as r, rebaseLocalPose as i } from "./composeFrame.js";
-import { applyToPoint as a, multiply as o, poseFrameInverseOf as s, poseFrameOf as c, poseLinearOf as l, rotate as u } from "@weasel-js/geom";
+import { IDENTITY_POSE_COMPOSITION, composeWorldPose, composesFrames, frameAtOrAbove, rebaseLocalPose } from "./composeFrame.js";
+import { applyToPoint, multiply, poseFrameInverseOf, poseFrameOf, poseLinearOf, rotate } from "@weasel-js/geom";
+
 //#region src/core/scene/composePose.ts
-function d(e, t) {
+/**
+* Pose composition for hierarchical scene graphs.
+*
+* `getPose(id)` on adapters returns the **local** pose — relative to the
+* object's direct parent. Anything in the kit that needs world coordinates
+* routes through `composeWorldPose`, which folds local poses together via a
+* consumer-supplied `compose`.
+*/
+/**
+* `compose` for axis-aligned rectangles under a translation-only hierarchy.
+* Adds translation; every other field is taken from the child unchanged.
+*/
+function composeRectPose(parent, child) {
 	return {
-		...t,
-		x: e.x + t.x,
-		y: e.y + t.y
+		...child,
+		x: parent.x + child.x,
+		y: parent.y + child.y
 	};
 }
-function f(e, t, n) {
+/** Translate a `RectPose`-shaped pose by `(dx, dy)`; other fields are preserved. */
+function translateRectPose(pose, dx, dy) {
 	return {
-		...e,
-		x: e.x + t,
-		y: e.y + n
+		...pose,
+		x: pose.x + dx,
+		y: pose.y + dy
 	};
 }
-function p(e, t) {
+/** Inverse of `composeRectPose` — subtracts parent translation. */
+function decomposeRectPose(parent, world) {
 	return {
-		...t,
-		x: t.x - e.x,
-		y: t.y - e.y
+		...world,
+		x: world.x - parent.x,
+		y: world.y - parent.y
 	};
 }
-function m(e, t, n) {
-	let [r, i, a, s] = o(u(-t), n), c = Math.abs(r - 1) < 1e-12 && Math.abs(i) < 1e-12 && Math.abs(a) < 1e-12 && Math.abs(s - 1) < 1e-12, l = {
-		...e,
-		rotation: t
+/** `pose` with the linear part `linear` held as `rotation` and whatever is
+*  left over as `transform`, which is dropped when nothing is. */
+function withLinear(pose, rotation, linear) {
+	const [a, b, c, d] = multiply(rotate(-rotation), linear);
+	const plain = Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12;
+	const next = {
+		...pose,
+		rotation
 	};
-	return c ? delete l.transform : l.transform = [
-		r,
-		i,
+	if (plain) delete next.transform;
+	else next.transform = [
 		a,
-		s
-	], l;
+		b,
+		c,
+		d
+	];
+	return next;
 }
-function h(e, t, n) {
+/** `pose` moved so its box center is at `(cx, cy)`. */
+function centeredAt(pose, cx, cy) {
 	return {
-		...e,
-		x: t - e.width / 2,
-		y: n - e.height / 2
+		...pose,
+		x: cx - pose.width / 2,
+		y: cy - pose.height / 2
 	};
 }
-var g = [
+var NO_FRAME = [
 	1,
 	0,
 	0,
@@ -49,57 +71,87 @@ var g = [
 	0,
 	0
 ];
-function _(e, t, n, r, i) {
-	let a = Math.cos(n), o = Math.sin(n);
-	return [e + (r - e) * a - (i - t) * o, t + (r - e) * o + (i - t) * a];
+/** Turn `(x, y)` about `(cx, cy)` by `r` radians. */
+function turn(cx, cy, r, x, y) {
+	const c = Math.cos(r);
+	const s = Math.sin(r);
+	return [cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c];
 }
-function v(e, t) {
-	let n = e.rotation ?? 0, r = l(e) && c(e);
-	if (r) {
-		let [i, s] = a(r, e.x + t.x + t.width / 2, e.y + t.y + t.height / 2), l = o(r, c(t) ?? g);
-		return m(h(t, i, s), (t.rotation ?? 0) + n, l);
+/**
+* `compose` for a container whose pose defines a **frame**: the child's local
+* pose is offset into the parent's unrotated box, then the whole thing is
+* turned about the parent's center. Rotations add; the child keeps its size.
+*
+* Reduces to `composeRectPose` when the parent is upright. A parent's
+* `transform` composes too, and what the child's box and rotation cannot hold
+* of the result lands in the child's own `transform`.
+*/
+function composeRigidPose(parent, child) {
+	const pr = parent.rotation ?? 0;
+	const frame = poseLinearOf(parent) && poseFrameOf(parent);
+	if (frame) {
+		const [cx, cy] = applyToPoint(frame, parent.x + child.x + child.width / 2, parent.y + child.y + child.height / 2);
+		const linear = multiply(frame, poseFrameOf(child) ?? NO_FRAME);
+		return withLinear(centeredAt(child, cx, cy), (child.rotation ?? 0) + pr, linear);
 	}
-	let [i, s] = _(e.x + e.width / 2, e.y + e.height / 2, n, e.x + t.x + t.width / 2, e.y + t.y + t.height / 2);
+	const [wcx, wcy] = turn(parent.x + parent.width / 2, parent.y + parent.height / 2, pr, parent.x + child.x + child.width / 2, parent.y + child.y + child.height / 2);
 	return {
-		...t,
-		x: i - t.width / 2,
-		y: s - t.height / 2,
-		rotation: (t.rotation ?? 0) + n
+		...child,
+		x: wcx - child.width / 2,
+		y: wcy - child.height / 2,
+		rotation: (child.rotation ?? 0) + pr
 	};
 }
-function y(e, t) {
-	let n = e.rotation ?? 0, r = l(e) && s(e);
-	if (r) {
-		let [i, s] = a(r, t.x + t.width / 2, t.y + t.height / 2), l = o(r, c(t) ?? g);
-		return m(h(t, i - e.x, s - e.y), (t.rotation ?? 0) - n, l);
+/** Inverse of `composeRigidPose` — un-turns about the parent's center, then
+*  subtracts the parent's offset. */
+function decomposeRigidPose(parent, world) {
+	const pr = parent.rotation ?? 0;
+	const back = poseLinearOf(parent) && poseFrameInverseOf(parent);
+	if (back) {
+		const [ux, uy] = applyToPoint(back, world.x + world.width / 2, world.y + world.height / 2);
+		const linear = multiply(back, poseFrameOf(world) ?? NO_FRAME);
+		return withLinear(centeredAt(world, ux - parent.x, uy - parent.y), (world.rotation ?? 0) - pr, linear);
 	}
-	let [i, u] = _(e.x + e.width / 2, e.y + e.height / 2, -n, t.x + t.width / 2, t.y + t.height / 2);
+	const [ux, uy] = turn(parent.x + parent.width / 2, parent.y + parent.height / 2, -pr, world.x + world.width / 2, world.y + world.height / 2);
 	return {
-		...t,
-		x: i - e.x - t.width / 2,
-		y: u - e.y - t.height / 2,
-		rotation: (t.rotation ?? 0) - n
+		...world,
+		x: ux - parent.x - world.width / 2,
+		y: uy - parent.y - world.height / 2,
+		rotation: (world.rotation ?? 0) - pr
 	};
 }
-var b = {
-	compose: d,
-	decompose: p,
+/** Translation-only composition over `RectPose`. What a scene wants when a
+*  container groups its children but never turns them. */
+var RECT_POSE_COMPOSITION = {
+	compose: composeRectPose,
+	decompose: decomposeRectPose,
 	closure: "translation"
-}, x = {
-	compose: v,
-	decompose: y,
+};
+/** Composition over `RectPose` where a container's pose is a frame: rotating
+*  the container rotates its contents. */
+var RIGID_POSE_COMPOSITION = {
+	compose: composeRigidPose,
+	decompose: decomposeRigidPose,
 	closure: "rigid"
 };
-function S(e, n) {
-	return (r) => {
+/**
+* Build a `(id) => world pose | null` callback over a `PoseAdapter`, for
+* RenderLayers that take a `getPose` callback.
+*
+* Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the
+* common case is an id removed mid-render between selection state and the
+* next paint. Layers should treat `null` as "skip this id."
+*/
+function worldPoseLookup(adapter, compose) {
+	return (id) => {
 		try {
-			return t(e, r, n);
+			return composeWorldPose(adapter, id, compose);
 		} catch {
 			return null;
 		}
 	};
 }
-//#endregion
-export { e as IDENTITY_POSE_COMPOSITION, b as RECT_POSE_COMPOSITION, x as RIGID_POSE_COMPOSITION, d as composeRectPose, v as composeRigidPose, t as composeWorldPose, n as composesFrames, p as decomposeRectPose, y as decomposeRigidPose, r as frameAtOrAbove, i as rebaseLocalPose, f as translateRectPose, S as worldPoseLookup };
 
+//#endregion
+export { IDENTITY_POSE_COMPOSITION, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, composeRectPose, composeRigidPose, composeWorldPose, composesFrames, decomposeRectPose, decomposeRigidPose, frameAtOrAbove, rebaseLocalPose, translateRectPose, worldPoseLookup };
 //# sourceMappingURL=composePose.js.map

package/dist/core/scene/composePose.js.map

@@ -1 +1 @@
-{"version":3,"file":"composePose.js","names":["composeRectPose","child","parent","translateRectPose","pose","dx","dy","decomposeRectPose","world","withLinear","a","b","c","d","multiply","rotate","rotation","linear","plain","next","centeredAt","cx","cy","NO_FRAME","turn","r","s","x","y","composeRigidPose","pr","frame","poseLinearOf","poseFrameOf","applyToPoint","wcx","wcy","decomposeRigidPose","back","poseFrameInverseOf","ux","uy","RECT_POSE_COMPOSITION","RIGID_POSE_COMPOSITION","worldPoseLookup","composeWorldPose","adapter","id","compose","IDENTITY_POSE_COMPOSITION","composesFrames","frameAtOrAbove","rebaseLocalPose"],"sources":["../../../src/core/scene/composePose.ts"],"sourcesContent":["/**\n * Pose composition for hierarchical scene graphs.\n *\n * `getPose(id)` on adapters returns the **local** pose — relative to the\n * object's direct parent. Anything in the kit that needs world coordinates\n * routes through `composeWorldPose`, which folds local poses together via a\n * consumer-supplied `compose`.\n */\n\nimport { applyToPoint, multiply, poseFrameInverseOf, poseFrameOf, poseLinearOf, rotate, type Affine } from '@weasel-js/geom';\nimport type { RectPose } from 'core/scene/types';\nexport type { RectPose };\n\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composesFrames,\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseClosure,\n  type PoseComposition,\n} from 'core/scene/composeFrame';\nexport { IDENTITY_POSE_COMPOSITION, composesFrames, composeWorldPose, frameAtOrAbove, rebaseLocalPose };\nexport type { PoseAdapter, PoseClosure, PoseComposition };\n\n/**\n * `compose` for axis-aligned rectangles under a translation-only hierarchy.\n * Adds translation; every other field is taken from the child unchanged.\n */\nexport function composeRectPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  return {\n    ...child,\n    x: parent.x + child.x,\n    y: parent.y + child.y,\n  };\n}\n\n/** Translate a `RectPose`-shaped pose by `(dx, dy)`; other fields are preserved. */\nexport function translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): TPose {\n  return { ...pose, x: pose.x + dx, y: pose.y + dy };\n}\n\n/** Inverse of `composeRectPose` — subtracts parent translation. */\nexport function decomposeRectPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  return {\n    ...world,\n    x: world.x - parent.x,\n    y: world.y - parent.y,\n  };\n}\n\n/** `pose` with the linear part `linear` held as `rotation` and whatever is\n *  left over as `transform`, which is dropped when nothing is. */\nfunction withLinear<TPose extends RectPose>(pose: TPose, rotation: number, linear: Affine): TPose {\n  const [a, b, c, d] = multiply(rotate(-rotation), linear);\n  const plain = Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12;\n  const next: RectPose = { ...pose, rotation };\n  if (plain) delete next.transform;\n  else next.transform = [a, b, c, d];\n  return next as TPose;\n}\n\n/** `pose` moved so its box center is at `(cx, cy)`. */\nfunction centeredAt<TPose extends RectPose>(pose: TPose, cx: number, cy: number): TPose {\n  return { ...pose, x: cx - pose.width / 2, y: cy - pose.height / 2 };\n}\n\nconst NO_FRAME: Affine = [1, 0, 0, 1, 0, 0];\n\n/** Turn `(x, y)` about `(cx, cy)` by `r` radians. */\nfunction turn(cx: number, cy: number, r: number, x: number, y: number): [number, number] {\n  const c = Math.cos(r);\n  const s = Math.sin(r);\n  return [cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c];\n}\n\n/**\n * `compose` for a container whose pose defines a **frame**: the child's local\n * pose is offset into the parent's unrotated box, then the whole thing is\n * turned about the parent's center. Rotations add; the child keeps its size.\n *\n * Reduces to `composeRectPose` when the parent is upright. A parent's\n * `transform` composes too, and what the child's box and rotation cannot hold\n * of the result lands in the child's own `transform`.\n */\nexport function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const frame = poseLinearOf(parent) && poseFrameOf(parent);\n  if (frame) {\n    const [cx, cy] = applyToPoint(frame, parent.x + child.x + child.width / 2, parent.y + child.y + child.height / 2);\n    const linear = multiply(frame, poseFrameOf(child) ?? NO_FRAME);\n    return withLinear(centeredAt(child, cx, cy), (child.rotation ?? 0) + pr, linear);\n  }\n  const [wcx, wcy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    pr,\n    parent.x + child.x + child.width / 2,\n    parent.y + child.y + child.height / 2,\n  );\n  return {\n    ...child,\n    x: wcx - child.width / 2,\n    y: wcy - child.height / 2,\n    rotation: (child.rotation ?? 0) + pr,\n  };\n}\n\n/** Inverse of `composeRigidPose` — un-turns about the parent's center, then\n *  subtracts the parent's offset. */\nexport function decomposeRigidPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  // A singular transform has no inverse: the container draws nothing, and the turn alone is undone.\n  const back = poseLinearOf(parent) && poseFrameInverseOf(parent);\n  if (back) {\n    const [ux, uy] = applyToPoint(back, world.x + world.width / 2, world.y + world.height / 2);\n    const linear = multiply(back, poseFrameOf(world) ?? NO_FRAME);\n    return withLinear(centeredAt(world, ux - parent.x, uy - parent.y), (world.rotation ?? 0) - pr, linear);\n  }\n  const [ux, uy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    -pr,\n    world.x + world.width / 2,\n    world.y + world.height / 2,\n  );\n  return {\n    ...world,\n    x: ux - parent.x - world.width / 2,\n    y: uy - parent.y - world.height / 2,\n    rotation: (world.rotation ?? 0) - pr,\n  };\n}\n\n/** Translation-only composition over `RectPose`. What a scene wants when a\n *  container groups its children but never turns them. */\nexport const RECT_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRectPose,\n  decompose: decomposeRectPose,\n  closure: 'translation',\n};\n\n/** Composition over `RectPose` where a container's pose is a frame: rotating\n *  the container rotates its contents. */\nexport const RIGID_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRigidPose,\n  decompose: decomposeRigidPose,\n  closure: 'rigid',\n};\n\n/**\n * Build a `(id) => world pose | null` callback over a `PoseAdapter`, for\n * RenderLayers that take a `getPose` callback.\n *\n * Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the\n * common case is an id removed mid-render between selection state and the\n * next paint. Layers should treat `null` as \"skip this id.\"\n */\nexport function worldPoseLookup<TPose>(\n  adapter: PoseAdapter<TPose>,\n  compose: (parent: TPose, child: TPose) => TPose,\n): (id: string) => TPose | null {\n  return (id: string) => {\n    try {\n      return composeWorldPose(adapter, id, compose);\n    } catch {\n      return null;\n    }\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"composePose.js","names":[],"sources":["../../../src/core/scene/composePose.ts"],"sourcesContent":["/**\n * Pose composition for hierarchical scene graphs.\n *\n * `getPose(id)` on adapters returns the **local** pose — relative to the\n * object's direct parent. Anything in the kit that needs world coordinates\n * routes through `composeWorldPose`, which folds local poses together via a\n * consumer-supplied `compose`.\n */\n\nimport { applyToPoint, multiply, poseFrameInverseOf, poseFrameOf, poseLinearOf, rotate, type Affine } from '@weasel-js/geom';\nimport type { RectPose } from 'core/scene/types';\nexport type { RectPose };\n\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composesFrames,\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseClosure,\n  type PoseComposition,\n} from 'core/scene/composeFrame';\nexport { IDENTITY_POSE_COMPOSITION, composesFrames, composeWorldPose, frameAtOrAbove, rebaseLocalPose };\nexport type { PoseAdapter, PoseClosure, PoseComposition };\n\n/**\n * `compose` for axis-aligned rectangles under a translation-only hierarchy.\n * Adds translation; every other field is taken from the child unchanged.\n */\nexport function composeRectPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  return {\n    ...child,\n    x: parent.x + child.x,\n    y: parent.y + child.y,\n  };\n}\n\n/** Translate a `RectPose`-shaped pose by `(dx, dy)`; other fields are preserved. */\nexport function translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): TPose {\n  return { ...pose, x: pose.x + dx, y: pose.y + dy };\n}\n\n/** Inverse of `composeRectPose` — subtracts parent translation. */\nexport function decomposeRectPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  return {\n    ...world,\n    x: world.x - parent.x,\n    y: world.y - parent.y,\n  };\n}\n\n/** `pose` with the linear part `linear` held as `rotation` and whatever is\n *  left over as `transform`, which is dropped when nothing is. */\nfunction withLinear<TPose extends RectPose>(pose: TPose, rotation: number, linear: Affine): TPose {\n  const [a, b, c, d] = multiply(rotate(-rotation), linear);\n  const plain = Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12;\n  const next: RectPose = { ...pose, rotation };\n  if (plain) delete next.transform;\n  else next.transform = [a, b, c, d];\n  return next as TPose;\n}\n\n/** `pose` moved so its box center is at `(cx, cy)`. */\nfunction centeredAt<TPose extends RectPose>(pose: TPose, cx: number, cy: number): TPose {\n  return { ...pose, x: cx - pose.width / 2, y: cy - pose.height / 2 };\n}\n\nconst NO_FRAME: Affine = [1, 0, 0, 1, 0, 0];\n\n/** Turn `(x, y)` about `(cx, cy)` by `r` radians. */\nfunction turn(cx: number, cy: number, r: number, x: number, y: number): [number, number] {\n  const c = Math.cos(r);\n  const s = Math.sin(r);\n  return [cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c];\n}\n\n/**\n * `compose` for a container whose pose defines a **frame**: the child's local\n * pose is offset into the parent's unrotated box, then the whole thing is\n * turned about the parent's center. Rotations add; the child keeps its size.\n *\n * Reduces to `composeRectPose` when the parent is upright. A parent's\n * `transform` composes too, and what the child's box and rotation cannot hold\n * of the result lands in the child's own `transform`.\n */\nexport function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const frame = poseLinearOf(parent) && poseFrameOf(parent);\n  if (frame) {\n    const [cx, cy] = applyToPoint(frame, parent.x + child.x + child.width / 2, parent.y + child.y + child.height / 2);\n    const linear = multiply(frame, poseFrameOf(child) ?? NO_FRAME);\n    return withLinear(centeredAt(child, cx, cy), (child.rotation ?? 0) + pr, linear);\n  }\n  const [wcx, wcy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    pr,\n    parent.x + child.x + child.width / 2,\n    parent.y + child.y + child.height / 2,\n  );\n  return {\n    ...child,\n    x: wcx - child.width / 2,\n    y: wcy - child.height / 2,\n    rotation: (child.rotation ?? 0) + pr,\n  };\n}\n\n/** Inverse of `composeRigidPose` — un-turns about the parent's center, then\n *  subtracts the parent's offset. */\nexport function decomposeRigidPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  // A singular transform has no inverse: the container draws nothing, and the turn alone is undone.\n  const back = poseLinearOf(parent) && poseFrameInverseOf(parent);\n  if (back) {\n    const [ux, uy] = applyToPoint(back, world.x + world.width / 2, world.y + world.height / 2);\n    const linear = multiply(back, poseFrameOf(world) ?? NO_FRAME);\n    return withLinear(centeredAt(world, ux - parent.x, uy - parent.y), (world.rotation ?? 0) - pr, linear);\n  }\n  const [ux, uy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    -pr,\n    world.x + world.width / 2,\n    world.y + world.height / 2,\n  );\n  return {\n    ...world,\n    x: ux - parent.x - world.width / 2,\n    y: uy - parent.y - world.height / 2,\n    rotation: (world.rotation ?? 0) - pr,\n  };\n}\n\n/** Translation-only composition over `RectPose`. What a scene wants when a\n *  container groups its children but never turns them. */\nexport const RECT_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRectPose,\n  decompose: decomposeRectPose,\n  closure: 'translation',\n};\n\n/** Composition over `RectPose` where a container's pose is a frame: rotating\n *  the container rotates its contents. */\nexport const RIGID_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRigidPose,\n  decompose: decomposeRigidPose,\n  closure: 'rigid',\n};\n\n/**\n * Build a `(id) => world pose | null` callback over a `PoseAdapter`, for\n * RenderLayers that take a `getPose` callback.\n *\n * Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the\n * common case is an id removed mid-render between selection state and the\n * next paint. Layers should treat `null` as \"skip this id.\"\n */\nexport function worldPoseLookup<TPose>(\n  adapter: PoseAdapter<TPose>,\n  compose: (parent: TPose, child: TPose) => TPose,\n): (id: string) => TPose | null {\n  return (id: string) => {\n    try {\n      return composeWorldPose(adapter, id, compose);\n    } catch {\n      return null;\n    }\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/depFrame.js

@@ -0,0 +1,94 @@
+import { composeWorldPose, composesFrames, frameAtOrAbove } from "./composeFrame.js";
+import { derivedPartsOf, pathFromParts } from "./derivedParts.js";
+import { boxToBox, multiply, poseFrameInverseOf, poseFrameOf, transformPath } from "@weasel-js/geom";
+
+//#region src/core/scene/depFrame.ts
+/**
+* A dependency's pose in the frame of the node reading it. Under a composing
+* strategy a stored pose is local to its container, so a node deriving from
+* something in another container would otherwise read it in that
+* container's frame and place itself as though the two frames were one.
+*/
+/** `(depId, pose) => that pose in `reader`'s frame`, or `null` when every
+*  pose is already in one frame — the absolute-pose model. `poseOf` answers
+*  each node's own, local pose. */
+function depFrameRebase(composition, reader, get, poseOf, definesFrame) {
+	if (composition === void 0 || !composesFrames(composition)) return null;
+	const adapter = {
+		getPose: (id) => poseOf(id),
+		getParent: (id) => get(id)?.parent ?? null,
+		definesFrame: (id) => definesFrame(id)
+	};
+	const frame = frameAtOrAbove(adapter, reader.parent ?? null);
+	return (depId, pose) => {
+		const own = frameAtOrAbove(adapter, get(depId)?.parent ?? null);
+		if (own === frame) return pose;
+		const world = own === null ? pose : composition.compose(composeWorldPose(adapter, own, composition.compose), pose);
+		return frame === null ? world : composition.decompose(composeWorldPose(adapter, frame, composition.compose), world);
+	};
+}
+function isBox(pose) {
+	const p = pose;
+	return typeof p === "object" && p !== null && typeof p.x === "number" && typeof p.y === "number" && typeof p.width === "number" && typeof p.height === "number";
+}
+/**
+* `path`, drawn in the unturned box of a node posed at `from`, as it is drawn
+* in the box of `to`. Whatever turns the box is applied after, by whoever
+* paints it. A pose that is not a box leaves the path where it is.
+*/
+function carryBoxPath(path, from, to) {
+	if (!isBox(from) || !isBox(to)) return path;
+	if (from.x === to.x && from.y === to.y && from.width === to.width && from.height === to.height) return path;
+	return carryPathBy(path, boxToBox(from.x, from.y, from.width, from.height, to.x, to.y, to.width, to.height));
+}
+/**
+* A dependency's derived `path`, drawn in its own frame, carried into the
+* reader's — the frame change that took its pose `from` to `to`: out of
+* `from`'s turn, {@link carryBoxPath}'s box to box, into `to`'s turn.
+*/
+function carryDepPath(path, from, to) {
+	if (!isBox(from) || !isBox(to)) return path;
+	const back = poseFrameInverseOf(from);
+	const fwd = poseFrameOf(to);
+	let m = boxToBox(from.x, from.y, from.width, from.height, to.x, to.y, to.width, to.height);
+	if (back !== null) m = multiply(m, back);
+	if (fwd !== null) m = multiply(fwd, m);
+	return carryPathBy(path, m);
+}
+/**
+* `path`, drawn in the unturned box of a node posed at `box` — where a painter
+* draws, and where a pose override's path is given — as that node is painted
+* posed at `at`: carried box to box, then turned by `at`. Where a derivation
+* reads it, beside `at` as the dependency's pose.
+*/
+function pathAsPainted(path, box, at) {
+	if (!isBox(box) || !isBox(at)) return path;
+	const fwd = poseFrameOf(at);
+	const same = box.x === at.x && box.y === at.y && box.width === at.width && box.height === at.height;
+	if (fwd === null && same) return path;
+	const m = boxToBox(box.x, box.y, box.width, box.height, at.x, at.y, at.width, at.height);
+	return carryPathBy(path, fwd === null ? m : multiply(fwd, m));
+}
+/** `path` through `m`, keeping its parts. Painted and read every frame, and a
+*  derivation's memo compares the path it read by reference, so the copy is
+*  kept against it. */
+function carryPathBy(path, m) {
+	const key = m.join(",");
+	const held = carried.get(path);
+	if (held?.key === key) return held.path;
+	const parts = derivedPartsOf(path);
+	const out = parts === void 0 ? transformPath(path, m) : pathFromParts(parts.map((part) => ({
+		...part,
+		path: transformPath(part.path, m)
+	})));
+	carried.set(path, {
+		key,
+		path: out
+	});
+	return out;
+}
+var carried = /* @__PURE__ */ new WeakMap();
+
+//#endregion
+export { carryBoxPath, carryDepPath, carryPathBy, depFrameRebase, pathAsPainted };
+//# sourceMappingURL=depFrame.js.map

package/dist/core/scene/depFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depFrame.js","names":[],"sources":["../../../src/core/scene/depFrame.ts"],"sourcesContent":["/**\n * A dependency's pose in the frame of the node reading it. Under a composing\n * strategy a stored pose is local to its container, so a node deriving from\n * something in another container would otherwise read it in that\n * container's frame and place itself as though the two frames were one.\n */\nimport { boxToBox, multiply, poseFrameInverseOf, poseFrameOf, transformPath, type Affine, type Path } from '@weasel-js/geom';\nimport { composeWorldPose, composesFrames, frameAtOrAbove, type PoseAdapter, type PoseComposition } from './composeFrame';\nimport { derivedPartsOf, pathFromParts } from './derivedParts';\nimport type { NodeId } from './types';\n\n/** The parts of a node the rebase reads. */\ninterface FramedNode {\n  id: NodeId;\n  parent?: NodeId | null;\n}\n\n/** `(depId, pose) => that pose in `reader`'s frame`, or `null` when every\n *  pose is already in one frame — the absolute-pose model. `poseOf` answers\n *  each node's own, local pose. */\nexport function depFrameRebase<TPose>(\n  composition: PoseComposition<TPose> | undefined,\n  reader: FramedNode,\n  get: (id: NodeId) => FramedNode | undefined,\n  poseOf: (id: NodeId) => TPose,\n  definesFrame: (id: NodeId) => boolean,\n): ((depId: NodeId, pose: TPose) => TPose) | null {\n  if (composition === undefined || !composesFrames(composition)) return null;\n  const adapter: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => definesFrame(id as NodeId),\n  };\n  const frame = frameAtOrAbove(adapter, reader.parent ?? null);\n  return (depId, pose) => {\n    const own = frameAtOrAbove(adapter, get(depId)?.parent ?? null);\n    if (own === frame) return pose;\n    const world = own === null ? pose : composition.compose(composeWorldPose(adapter, own, composition.compose), pose);\n    return frame === null ? world : composition.decompose(composeWorldPose(adapter, frame, composition.compose), world);\n  };\n}\n\ninterface Box {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nfunction isBox(pose: unknown): pose is Box {\n  const p = pose as Partial<Box> | null;\n  return typeof p === 'object' && p !== null\n    && typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number';\n}\n\n/**\n * `path`, drawn in the unturned box of a node posed at `from`, as it is drawn\n * in the box of `to`. Whatever turns the box is applied after, by whoever\n * paints it. A pose that is not a box leaves the path where it is.\n */\nexport function carryBoxPath(path: Path, from: unknown, to: unknown): Path {\n  if (!isBox(from) || !isBox(to)) return path;\n  if (from.x === to.x && from.y === to.y && from.width === to.width && from.height === to.height) return path;\n  return carryPathBy(path, boxToBox(from.x, from.y, from.width, from.height, to.x, to.y, to.width, to.height));\n}\n\n/**\n * A dependency's derived `path`, drawn in its own frame, carried into the\n * reader's — the frame change that took its pose `from` to `to`: out of\n * `from`'s turn, {@link carryBoxPath}'s box to box, into `to`'s turn.\n */\nexport function carryDepPath(path: Path, from: unknown, to: unknown): Path {\n  if (!isBox(from) || !isBox(to)) return path;\n  const back = poseFrameInverseOf(from);\n  const fwd = poseFrameOf(to);\n  let m: Affine = boxToBox(from.x, from.y, from.width, from.height, to.x, to.y, to.width, to.height);\n  if (back !== null) m = multiply(m, back);\n  if (fwd !== null) m = multiply(fwd, m);\n  return carryPathBy(path, m);\n}\n\n/**\n * `path`, drawn in the unturned box of a node posed at `box` — where a painter\n * draws, and where a pose override's path is given — as that node is painted\n * posed at `at`: carried box to box, then turned by `at`. Where a derivation\n * reads it, beside `at` as the dependency's pose.\n */\nexport function pathAsPainted(path: Path, box: unknown, at: unknown): Path {\n  if (!isBox(box) || !isBox(at)) return path;\n  const fwd = poseFrameOf(at);\n  const same = box.x === at.x && box.y === at.y && box.width === at.width && box.height === at.height;\n  if (fwd === null && same) return path;\n  const m = boxToBox(box.x, box.y, box.width, box.height, at.x, at.y, at.width, at.height);\n  return carryPathBy(path, fwd === null ? m : multiply(fwd, m));\n}\n\n/** `path` through `m`, keeping its parts. Painted and read every frame, and a\n *  derivation's memo compares the path it read by reference, so the copy is\n *  kept against it. */\nexport function carryPathBy(path: Path, m: Affine): Path {\n  const key = m.join(',');\n  const held = carried.get(path);\n  if (held?.key === key) return held.path;\n  const parts = derivedPartsOf(path);\n  const out = parts === undefined\n    ? transformPath(path, m)\n    : pathFromParts(parts.map((part) => ({ ...part, path: transformPath(part.path, m) })))!;\n  carried.set(path, { key, path: out });\n  return out;\n}\n\nconst carried = new WeakMap<Path, { key: string; path: Path }>();\n"],"mappings":"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"}

package/dist/core/scene/depMemo.js

@@ -1,6 +1,7 @@
-import { samePoseValue as e, snapshotPose as t } from "./poseSnapshot.js";
+import { samePoseValue, snapshotPose } from "./poseSnapshot.js";
+
 //#region src/core/scene/depMemo.ts
-function n() {
+function emptyDepRecord() {
 	return {
 		nodes: [],
 		poses: [],
@@ -9,35 +10,59 @@ function n() {
 		paths: []
 	};
 }
-var r = class {
+/** A dependency as the derivation is handed it, noting a read of its path. A
+*  class for the reason `SceneDep` is one: a prototype accessor is cheap. */
+var RecordedDep = class {
 	dep;
 	paths;
 	index;
 	node;
 	pose;
-	constructor(e, t, n) {
-		this.dep = e, this.paths = t, this.index = n, this.node = e.node, this.pose = e.pose;
+	constructor(dep, paths, index) {
+		this.dep = dep;
+		this.paths = paths;
+		this.index = index;
+		this.node = dep.node;
+		this.pose = dep.pose;
 	}
 	get path() {
 		return this.paths[this.index] = this.dep.path;
 	}
 };
-function i(e, n, i) {
-	return e.nodes.length = 0, e.poses.length = 0, e.data.length = 0, e.layers.length = 0, e.paths.length = 0, i(n.map((n, i) => (e.nodes.push(n?.node), e.poses.push(n === void 0 ? void 0 : t(n.pose)), e.data.push(n?.node.data), e.layers.push(n?.node.layer), e.paths.push(void 0), n === void 0 ? void 0 : new r(n, e.paths, i))));
+/** Run `derive` against `deps`, recording in place what it was run against.
+*  Mutating the record is what updates the memo slot, which holds this object. */
+function deriveRecorded(into, deps, derive) {
+	into.nodes.length = 0;
+	into.poses.length = 0;
+	into.data.length = 0;
+	into.layers.length = 0;
+	into.paths.length = 0;
+	return derive(deps.map((dep, i) => {
+		into.nodes.push(dep?.node);
+		into.poses.push(dep === void 0 ? void 0 : snapshotPose(dep.pose));
+		into.data.push(dep?.node.data);
+		into.layers.push(dep?.node.layer);
+		into.paths.push(void 0);
+		return dep === void 0 ? void 0 : new RecordedDep(dep, into.paths, i);
+	}));
 }
-function a(t, n, r) {
-	if (t.nodes.length !== n.length) return !1;
-	for (let i = 0; i < n.length; i++) {
-		let a = r(n[i]);
-		if (t.nodes[i] !== (a === void 0 ? void 0 : a.node)) return !1;
-		if (a === void 0) continue;
-		if (t.data[i] !== a.node.data || t.layers[i] !== a.node.layer || !e(t.poses[i], a.pose)) return !1;
-		let o = t.paths[i];
-		if (o !== void 0 && o !== a.path) return !1;
+/** Whether the dependencies still resolve to what the record was taken from.
+*  Resolves them one at a time rather than taking an array: this is the hit
+*  path, and it walks every derived node's every dependency on every frame. */
+function sameDeps(record, ids, depOf) {
+	if (record.nodes.length !== ids.length) return false;
+	for (let i = 0; i < ids.length; i++) {
+		const dep = depOf(ids[i]);
+		if (record.nodes[i] !== (dep === void 0 ? void 0 : dep.node)) return false;
+		if (dep === void 0) continue;
+		if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;
+		if (!samePoseValue(record.poses[i], dep.pose)) return false;
+		const path = record.paths[i];
+		if (path !== void 0 && path !== dep.path) return false;
 	}
-	return !0;
+	return true;
 }
-//#endregion
-export { i as deriveRecorded, n as emptyDepRecord, a as sameDeps };
 
+//#endregion
+export { deriveRecorded, emptyDepRecord, sameDeps };
 //# sourceMappingURL=depMemo.js.map

package/dist/core/scene/depMemo.js.map

@@ -1 +1 @@
-{"version":3,"file":"depMemo.js","names":["emptyDepRecord","RecordedDep","dep","paths","index","deriveRecorded","derive","deps","into","snapshotPose","sameDeps","record","ids","depOf","samePoseValue","path"],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that changed with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing, a lookup\n * answering nodes no scene edits — is invisible to that key. Recording what\n * the derivation was handed and comparing it on the hit path is what notices\n * it without a trigger.\n *\n * What is recorded is what a derivation may read of a dependency: its node (an\n * identity), its pose (by value), its `data` (a reference, which every edit\n * replaces), its `layer`, and its path where the derivation read it. Anything\n * else on the node — its parent, its children — still needs a push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, Node, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — with a copy of the pose it resolved to, its `data` and `layer`, and\n *  the path it answered, `undefined` where the derivation never asked. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n  data: unknown[];\n  layers: (string | undefined)[];\n  paths: (Path | null | undefined)[];\n}\n\nexport function emptyDepRecord<TPose>(): DepRecord<TPose> {\n  return { nodes: [], poses: [], data: [], layers: [], paths: [] };\n}\n\n/** A dependency as the derivation is handed it, noting a read of its path. A\n *  class for the reason `SceneDep` is one: a prototype accessor is cheap. */\nclass RecordedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly dep: DerivedDep<TPose>,\n    private readonly paths: (Path | null | undefined)[],\n    private readonly index: number,\n  ) {\n    this.node = dep.node;\n    this.pose = dep.pose;\n  }\n\n  get path(): Path | null {\n    return (this.paths[this.index] = this.dep.path);\n  }\n}\n\n/** Run `derive` against `deps`, recording in place what it was run against.\n *  Mutating the record is what updates the memo slot, which holds this object. */\nexport function deriveRecorded<TPose, T>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  derive: (deps: readonly (DerivedDep<TPose> | undefined)[]) => T,\n): T {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  into.data.length = 0;\n  into.layers.length = 0;\n  into.paths.length = 0;\n  const handed = deps.map((dep, i) => {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n    into.data.push(dep?.node.data);\n    into.layers.push(dep?.node.layer);\n    into.paths.push(undefined);\n    return dep === undefined ? undefined : new RecordedDep(dep, into.paths, i);\n  });\n  return derive(handed);\n}\n\n/** Whether the dependencies still resolve to what the record was taken from.\n *  Resolves them one at a time rather than taking an array: this is the hit\n *  path, and it walks every derived node's every dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep === undefined) continue;\n    if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;\n    if (!samePoseValue(record.poses[i], dep.pose)) return false;\n    const path = record.paths[i];\n    if (path !== undefined && path !== dep.path) return false;\n  }\n  return true;\n}\n"],"mappings":";;AA8BA,SAAgBA,IAA0C;CACxD,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO,CAAC;EAAG,MAAM,CAAC;EAAG,QAAQ,CAAC;EAAG,OAAO,CAAC;CAAE;AACjE;AAIA,IAAMC,IAAN,MAAsD;CAKjC;CACA;CACA;CANnB;CACA;CAEA,YACE,GACA,GACA,GACA;EAEA,AALiB,KAAA,MAAAC,GACA,KAAA,QAAAC,GACA,KAAA,QAAAC,GAEjB,KAAK,OAAOF,EAAI,MAChB,KAAK,OAAOA,EAAI;CAClB;CAEA,IAAI,OAAoB;EACtB,OAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI;CAC5C;AACF;AAIA,SAAgBG,EACd,GACA,GACA,GACG;CAcH,OAbA,EAAK,MAAM,SAAS,GACpB,EAAK,MAAM,SAAS,GACpB,EAAK,KAAK,SAAS,GACnB,EAAK,OAAO,SAAS,GACrB,EAAK,MAAM,SAAS,GASbC,EARQC,EAAK,KAAK,GAAK,OAC5BC,EAAK,MAAM,KAAKN,GAAK,IAAI,GACzBM,EAAK,MAAM,KAAKN,MAAQ,KAAA,IAAY,KAAA,IAAYO,EAAaP,EAAI,IAAI,CAAC,GACtEM,EAAK,KAAK,KAAKN,GAAK,KAAK,IAAI,GAC7BM,EAAK,OAAO,KAAKN,GAAK,KAAK,KAAK,GAChCM,EAAK,MAAM,KAAK,KAAA,CAAS,GAClBN,MAAQ,KAAA,IAAY,KAAA,IAAY,IAAID,EAAYC,GAAKM,EAAK,OAAO,CAAC,EAE7D,CAAM;AACtB;AAKA,SAAgBE,EACd,GACA,GACA,GACS;CACT,IAAIC,EAAO,MAAM,WAAWC,EAAI,QAAQ,OAAO;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAIA,EAAI,QAAQ,KAAK;EACnC,IAAMV,IAAMW,EAAMD,EAAI,EAAE;EACxB,IAAID,EAAO,MAAM,QAAQT,MAAQ,KAAA,IAAY,KAAA,IAAYA,EAAI,OAAO,OAAO;EAC3E,IAAIA,MAAQ,KAAA,GAAW;EAEvB,IADIS,EAAO,KAAK,OAAOT,EAAI,KAAK,QAAQS,EAAO,OAAO,OAAOT,EAAI,KAAK,SAClE,CAACY,EAAcH,EAAO,MAAM,IAAIT,EAAI,IAAI,GAAG,OAAO;EACtD,IAAMa,IAAOJ,EAAO,MAAM;EAC1B,IAAII,MAAS,KAAA,KAAaA,MAASb,EAAI,MAAM,OAAO;CACtD;CACA,OAAO;AACT"}
+{"version":3,"file":"depMemo.js","names":[],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that changed with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing, a lookup\n * answering nodes no scene edits — is invisible to that key. Recording what\n * the derivation was handed and comparing it on the hit path is what notices\n * it without a trigger.\n *\n * What is recorded is what a derivation may read of a dependency: its node (an\n * identity), its pose (by value), its `data` (a reference, which every edit\n * replaces), its `layer`, and its path where the derivation read it. Anything\n * else on the node — its parent, its children — still needs a push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, Node, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — with a copy of the pose it resolved to, its `data` and `layer`, and\n *  the path it answered, `undefined` where the derivation never asked. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n  data: unknown[];\n  layers: (string | undefined)[];\n  paths: (Path | null | undefined)[];\n}\n\nexport function emptyDepRecord<TPose>(): DepRecord<TPose> {\n  return { nodes: [], poses: [], data: [], layers: [], paths: [] };\n}\n\n/** A dependency as the derivation is handed it, noting a read of its path. A\n *  class for the reason `SceneDep` is one: a prototype accessor is cheap. */\nclass RecordedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly dep: DerivedDep<TPose>,\n    private readonly paths: (Path | null | undefined)[],\n    private readonly index: number,\n  ) {\n    this.node = dep.node;\n    this.pose = dep.pose;\n  }\n\n  get path(): Path | null {\n    return (this.paths[this.index] = this.dep.path);\n  }\n}\n\n/** Run `derive` against `deps`, recording in place what it was run against.\n *  Mutating the record is what updates the memo slot, which holds this object. */\nexport function deriveRecorded<TPose, T>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  derive: (deps: readonly (DerivedDep<TPose> | undefined)[]) => T,\n): T {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  into.data.length = 0;\n  into.layers.length = 0;\n  into.paths.length = 0;\n  const handed = deps.map((dep, i) => {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n    into.data.push(dep?.node.data);\n    into.layers.push(dep?.node.layer);\n    into.paths.push(undefined);\n    return dep === undefined ? undefined : new RecordedDep(dep, into.paths, i);\n  });\n  return derive(handed);\n}\n\n/** Whether the dependencies still resolve to what the record was taken from.\n *  Resolves them one at a time rather than taking an array: this is the hit\n *  path, and it walks every derived node's every dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep === undefined) continue;\n    if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;\n    if (!samePoseValue(record.poses[i], dep.pose)) return false;\n    const path = record.paths[i];\n    if (path !== undefined && path !== dep.path) return false;\n  }\n  return true;\n}\n"],"mappings":";;;AA8BA,SAAgB,iBAA0C;CACxD,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO,CAAC;EAAG,MAAM,CAAC;EAAG,QAAQ,CAAC;EAAG,OAAO,CAAC;CAAE;AACjE;;;AAIA,IAAM,cAAN,MAAsD;CAKjC;CACA;CACA;CANnB;CACA;CAEA,YACE,KACA,OACA,OACA;EAHiB,KAAA,MAAA;EACA,KAAA,QAAA;EACA,KAAA,QAAA;EAEjB,KAAK,OAAO,IAAI;EAChB,KAAK,OAAO,IAAI;CAClB;CAEA,IAAI,OAAoB;EACtB,OAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI;CAC5C;AACF;;;AAIA,SAAgB,eACd,MACA,MACA,QACG;CACH,KAAK,MAAM,SAAS;CACpB,KAAK,MAAM,SAAS;CACpB,KAAK,KAAK,SAAS;CACnB,KAAK,OAAO,SAAS;CACrB,KAAK,MAAM,SAAS;CASpB,OAAO,OARQ,KAAK,KAAK,KAAK,MAAM;EAClC,KAAK,MAAM,KAAK,KAAK,IAAI;EACzB,KAAK,MAAM,KAAK,QAAQ,SAAY,SAAY,aAAa,IAAI,IAAI,CAAC;EACtE,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI;EAC7B,KAAK,OAAO,KAAK,KAAK,KAAK,KAAK;EAChC,KAAK,MAAM,KAAK,MAAS;EACzB,OAAO,QAAQ,SAAY,SAAY,IAAI,YAAY,KAAK,KAAK,OAAO,CAAC;CAC3E,CACc,CAAM;AACtB;;;;AAKA,SAAgB,SACd,QACA,KACA,OACS;CACT,IAAI,OAAO,MAAM,WAAW,IAAI,QAAQ,OAAO;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,MAAM,MAAM,IAAI,EAAE;EACxB,IAAI,OAAO,MAAM,QAAQ,QAAQ,SAAY,SAAY,IAAI,OAAO,OAAO;EAC3E,IAAI,QAAQ,QAAW;EACvB,IAAI,OAAO,KAAK,OAAO,IAAI,KAAK,QAAQ,OAAO,OAAO,OAAO,IAAI,KAAK,OAAO,OAAO;EACpF,IAAI,CAAC,cAAc,OAAO,MAAM,IAAI,IAAI,IAAI,GAAG,OAAO;EACtD,MAAM,OAAO,OAAO,MAAM;EAC1B,IAAI,SAAS,UAAa,SAAS,IAAI,MAAM,OAAO;CACtD;CACA,OAAO;AACT"}