@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/geometry/poseDescriptor.js

@@ -1,168 +1,231 @@
-import { axisAlignedBounds as e } from "./unionBounds.js";
-import { multiply as t, poseLinearOf as n, rotate as r } from "@weasel-js/geom";
+import { axisAlignedBounds } from "./unionBounds.js";
+import { multiply, poseLinearOf, rotate } from "@weasel-js/geom";
+
 //#region src/core/geometry/poseDescriptor.ts
-function i(e, t) {
-	return e.forNode?.(t) ?? e;
+/** The descriptor `node` should be read through: its own specialization when
+*  it declares one, and otherwise the descriptor unchanged. */
+function poseDescriptorForNode(descriptor, node) {
+	return descriptor.forNode?.(node) ?? descriptor;
 }
-var a = {
-	getBounds: (e) => e,
-	remapBounds: (e, t, n) => {
-		let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height;
+/** Identity geometry for `TPose extends Bounds`. Treats the pose as its
+*  own bounds and remaps via affine scale against `src`/`dst`. */
+var RECT_POSE_DESCRIPTOR = {
+	getBounds: (p) => p,
+	remapBounds: (p, src, dst) => {
+		const sx = src.width === 0 ? 1 : dst.width / src.width;
+		const sy = src.height === 0 ? 1 : dst.height / src.height;
 		return {
-			...e,
-			x: n.x + (e.x - t.x) * r,
-			y: n.y + (e.y - t.y) * i,
-			width: e.width * r,
-			height: e.height * i
+			...p,
+			x: dst.x + (p.x - src.x) * sx,
+			y: dst.y + (p.y - src.y) * sy,
+			width: p.width * sx,
+			height: p.height * sy
 		};
 	},
-	fromBounds: (e) => ({
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height
+	fromBounds: (b) => ({
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
 	}),
-	translate: (e, t, n) => ({
-		...e,
-		x: e.x + t,
-		y: e.y + n
+	translate: (p, dx, dy) => ({
+		...p,
+		x: p.x + dx,
+		y: p.y + dy
 	}),
-	lerp: (e, t, n) => ({
-		...e,
-		x: e.x + (t.x - e.x) * n,
-		y: e.y + (t.y - e.y) * n,
-		width: e.width + (t.width - e.width) * n,
-		height: e.height + (t.height - e.height) * n
+	lerp: (a, b, t) => ({
+		...a,
+		x: a.x + (b.x - a.x) * t,
+		y: a.y + (b.y - a.y) * t,
+		width: a.width + (b.width - a.width) * t,
+		height: a.height + (b.height - a.height) * t
 	}),
-	axes: (e) => [
-		e.x,
-		e.y,
-		e.width,
-		e.height
-	].every((e) => typeof e == "number") ? {
-		count: 5,
-		names: [
-			"x",
-			"y",
-			"width",
-			"height",
-			"rotation"
-		],
-		angles: [4],
-		to: (e) => [
-			e.x,
-			e.y,
-			e.width,
-			e.height,
-			e.rotation ?? 0
-		],
-		from: (t) => {
-			let n = {
-				...e,
-				x: t[0],
-				y: t[1],
-				width: t[2],
-				height: t[3]
-			};
-			return (e.rotation !== void 0 || t[4] !== 0) && (n.rotation = t[4]), n;
-		},
-		add: (e, t) => {
-			let n = {
-				...e,
-				x: e.x + t[0],
-				y: e.y + t[1],
-				width: e.width + t[2],
-				height: e.height + t[3]
-			}, r = (e.rotation ?? 0) + t[4];
-			return (e.rotation !== void 0 || r !== 0) && (n.rotation = r), n;
-		},
-		write: (e, t, n) => {
-			t[n] = e.x, t[n + 1] = e.y, t[n + 2] = e.width, t[n + 3] = e.height, t[n + 4] = e.rotation ?? 0;
-		}
-	} : null,
-	getRotation: (e) => e.rotation ?? 0,
-	withRotation: (e, t) => ({
-		...e,
-		rotation: t
+	axes: (like) => {
+		if (![
+			like.x,
+			like.y,
+			like.width,
+			like.height
+		].every((n) => typeof n === "number")) return null;
+		return {
+			count: 5,
+			names: [
+				"x",
+				"y",
+				"width",
+				"height",
+				"rotation"
+			],
+			angles: [4],
+			to: (p) => [
+				p.x,
+				p.y,
+				p.width,
+				p.height,
+				p.rotation ?? 0
+			],
+			from: (a) => {
+				const pose = {
+					...like,
+					x: a[0],
+					y: a[1],
+					width: a[2],
+					height: a[3]
+				};
+				if (like.rotation !== void 0 || a[4] !== 0) pose.rotation = a[4];
+				return pose;
+			},
+			add: (p, d) => {
+				const pose = {
+					...p,
+					x: p.x + d[0],
+					y: p.y + d[1],
+					width: p.width + d[2],
+					height: p.height + d[3]
+				};
+				const rotation = (p.rotation ?? 0) + d[4];
+				if (p.rotation !== void 0 || rotation !== 0) pose.rotation = rotation;
+				return pose;
+			},
+			write: (p, out, at) => {
+				out[at] = p.x;
+				out[at + 1] = p.y;
+				out[at + 2] = p.width;
+				out[at + 3] = p.height;
+				out[at + 4] = p.rotation ?? 0;
+			}
+		};
+	},
+	getRotation: (p) => p.rotation ?? 0,
+	withRotation: (p, rotation) => ({
+		...p,
+		rotation
 	})
-}, o = {
-	getBounds: a.getBounds,
-	remapBounds: a.remapBounds,
-	translate: a.translate,
-	lerp: a.lerp,
-	axes: a.axes,
-	fromBounds: (e) => ({
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height,
+};
+/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,
+*  with a required `rotation`. */
+var ROTATED_POSE_DESCRIPTOR = {
+	getBounds: RECT_POSE_DESCRIPTOR.getBounds,
+	remapBounds: RECT_POSE_DESCRIPTOR.remapBounds,
+	translate: RECT_POSE_DESCRIPTOR.translate,
+	lerp: RECT_POSE_DESCRIPTOR.lerp,
+	axes: RECT_POSE_DESCRIPTOR.axes,
+	fromBounds: (b) => ({
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height,
 		rotation: 0
 	}),
-	getRotation: (e) => e.rotation,
-	withRotation: (e, t) => ({
-		...e,
-		rotation: t
+	getRotation: (p) => p.rotation,
+	withRotation: (p, rotation) => ({
+		...p,
+		rotation
 	})
 };
-function s(e, i, a) {
-	let o = i.width === 0 ? 1 : a.width / i.width, s = i.height === 0 ? 1 : a.height / i.height, c = e.rotation ?? 0, l = Math.cos(c), u = Math.sin(c), d = o * l, f = s * u, p = -o * u, m = s * l, h = Math.hypot(d, f), g = Math.hypot(p, m), _ = e.width * h, v = e.height * g, y = Math.atan2(f, d), b = a.x + (e.x + e.width / 2 - i.x) * o, x = a.y + (e.y + e.height / 2 - i.y) * s, S = {
-		...e,
-		x: b - _ / 2,
-		y: x - v / 2,
-		width: _,
-		height: v,
-		rotation: y
+/**
+* Remap a leaf drawn in a frame of its own, turned or skewed, inside a group
+* resize.
+*
+* The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the
+* group's per-axis factors and carries `rotation` through untouched. That is
+* right when `src`/`dst` are expressed in the leaf's own frame. In a group
+* resize they are world-frame: at 90° a horizontal stretch should grow the
+* leaf's `height`, and the naive map grows its `width`.
+*
+* What this computes is the group affine applied to the leaf's frame. The
+* center moves exactly; each box axis takes the length of its own image under
+* the turn; the rotation follows the image of the box's x-axis; and the
+* parallelogram a non-uniform scale makes of a turned box, which those cannot
+* hold, is written to the leaf's `transform`.
+*/
+function remapRotatedLeaf(pose, src, dst) {
+	const sx = src.width === 0 ? 1 : dst.width / src.width;
+	const sy = src.height === 0 ? 1 : dst.height / src.height;
+	const theta = pose.rotation ?? 0;
+	const cos = Math.cos(theta);
+	const sin = Math.sin(theta);
+	const ux = sx * cos, uy = sy * sin;
+	const vx = -sx * sin, vy = sy * cos;
+	const kx = Math.hypot(ux, uy);
+	const ky = Math.hypot(vx, vy);
+	const width = pose.width * kx;
+	const height = pose.height * ky;
+	const rotation = Math.atan2(uy, ux);
+	const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;
+	const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;
+	const next = {
+		...pose,
+		x: cxNew - width / 2,
+		y: cyNew - height / 2,
+		width,
+		height,
+		rotation
 	};
-	if (h === 0 || g === 0) return S;
-	let [C, w, T, E] = n(e) ?? [
+	if (kx === 0 || ky === 0) return next;
+	const [ta, tb, tc, td] = poseLinearOf(pose) ?? [
 		1,
 		0,
 		0,
 		1
-	], [D, O, k, A] = t(t(r(-y), [
-		d,
-		f,
-		p,
-		m,
+	];
+	const [a, b, c, d] = multiply(multiply(rotate(-rotation), [
+		ux,
+		uy,
+		vx,
+		vy,
 		0,
 		0
 	]), [
-		C / h,
-		w / h,
-		T / g,
-		E / g,
+		ta / kx,
+		tb / kx,
+		tc / ky,
+		td / ky,
 		0,
 		0
 	]);
-	return Math.abs(D - 1) < 1e-12 && Math.abs(O) < 1e-12 && Math.abs(k) < 1e-12 && Math.abs(A - 1) < 1e-12 ? delete S.transform : S.transform = [
-		D,
-		O,
-		k,
-		A
-	], S;
+	if (Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12) delete next.transform;
+	else next.transform = [
+		a,
+		b,
+		c,
+		d
+	];
+	return next;
 }
-function c(t, n) {
-	return e(l(t, n));
+/** The pose's visual bounds: its box expanded to cover the box as drawn
+*  under its rotation and `transform`, so a turned or skewed shape reports
+*  the extent of its ink. */
+function visualBoundsViaDescriptor(pose, geometry) {
+	return axisAlignedBounds(framedBounds(pose, geometry));
 }
-function l(e, t) {
-	let r = t.getBounds(e), i = t.getRotation?.(e) ?? r.rotation ?? 0, a = n(e) ?? n(r);
-	return !i && !a ? r : {
-		...r,
-		...i ? { rotation: i } : {},
-		...a ? { transform: a } : {}
+/** The pose's box with the rotation and `transform` it is drawn in: what
+*  `poseFrameOf` reads, for a pose only its descriptor can read. */
+function framedBounds(pose, geometry) {
+	const b = geometry.getBounds(pose);
+	const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;
+	const transform = poseLinearOf(pose) ?? poseLinearOf(b);
+	if (!rotation && !transform) return b;
+	return {
+		...b,
+		...rotation ? { rotation } : {},
+		...transform ? { transform } : {}
 	};
 }
-function u(e, t, n, r) {
-	if (r.translate) return r.translate(e, t, n);
-	let i = r.getBounds(e), a = {
-		x: i.x + t,
-		y: i.y + n,
-		width: i.width,
-		height: i.height
+/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted
+*  copy of the pose's own bounds when the descriptor has none. */
+function translatePoseViaDescriptor(pose, dx, dy, geometry) {
+	if (geometry.translate) return geometry.translate(pose, dx, dy);
+	const src = geometry.getBounds(pose);
+	const dst = {
+		x: src.x + dx,
+		y: src.y + dy,
+		width: src.width,
+		height: src.height
 	};
-	return r.remapBounds(e, i, a);
+	return geometry.remapBounds(pose, src, dst);
 }
-//#endregion
-export { a as RECT_POSE_DESCRIPTOR, o as ROTATED_POSE_DESCRIPTOR, l as framedBounds, i as poseDescriptorForNode, s as remapRotatedLeaf, u as translatePoseViaDescriptor, c as visualBoundsViaDescriptor };
 
+//#endregion
+export { RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, framedBounds, poseDescriptorForNode, remapRotatedLeaf, translatePoseViaDescriptor, visualBoundsViaDescriptor };
 //# sourceMappingURL=poseDescriptor.js.map

package/dist/core/geometry/poseDescriptor.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseDescriptor.js","names":["poseDescriptorForNode","descriptor","node","RECT_POSE_DESCRIPTOR","p","sx","src","dst","sy","b","dx","dy","a","t","like","n","pose","d","rotation","at","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","cos","sin","ux","uy","vx","vy","kx","ky","width","height","cxNew","cyNew","next","ta","tb","tc","td","poseLinearOf","c","multiply","rotate","visualBoundsViaDescriptor","axisAlignedBounds","framedBounds","geometry","transform","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport { multiply, poseLinearOf, rotate } from '@weasel-js/geom';\nimport type { TargetAxes } from '@weasel-js/animator';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the kit's bounds-driven math: bounds\n * are read via `getBounds`, and `remapBounds` projects a result back into\n * TPose.\n *\n * `remapBounds(pose, src, dst)` subsumes both \"set my own AABB to dst\"\n * (single-leaf resize) and \"scale me as a leaf inside parent's src→dst rect\"\n * (group resize) — they're the same affine map.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** How a pose of `like`'s kind maps to the flat numbers an animation moves, and which of them\n   *  are angles. `from` keeps the fields of `like` that are not axes. Null for a pose this\n   *  descriptor cannot map; absent, a pose animates by its flat numeric fields. */\n  axes?(like: TPose): TargetAxes<TPose> | null;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation; the rotation affordance\n   *  hides when it is `false`. When omitted, the kit assumes `true`, so a\n   *  descriptor whose poses cannot rotate (e.g. polygon Paths) should\n   *  return `false`. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type are indistinguishable to them.\n   * Implement this to read `node.data` once and hand back a descriptor that\n   * knows which shape it is describing. Callers reach it through\n   * {@link poseDescriptorForNode}; sites with only an id keep using the\n   * unspecialized descriptor.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  axes: (like) => {\n    const flat = [like.x, like.y, like.width, like.height];\n    if (!flat.every((n) => typeof n === 'number')) return null;\n    return {\n      count: 5,\n      names: ['x', 'y', 'width', 'height', 'rotation'],\n      angles: [4],\n      to: (p) => [p.x, p.y, p.width, p.height, p.rotation ?? 0],\n      from: (a) => {\n        const pose = { ...like, x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! };\n        if (like.rotation !== undefined || a[4] !== 0) pose.rotation = a[4]!;\n        return pose;\n      },\n      add: (p, d) => {\n        const pose = { ...p, x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]! };\n        const rotation = (p.rotation ?? 0) + d[4]!;\n        if (p.rotation !== undefined || rotation !== 0) pose.rotation = rotation;\n        return pose;\n      },\n      write: (p, out, at) => {\n        out[at] = p.x;\n        out[at + 1] = p.y;\n        out[at + 2] = p.width;\n        out[at + 3] = p.height;\n        out[at + 4] = p.rotation ?? 0;\n      },\n    };\n  },\n  // `withRotation` writes into `Bounds`' optional `rotation`, so this reads\n  // the same channel, or a pose reports itself unrotated while painting rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,\n *  with a required `rotation`. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  axes: RECT_POSE_DESCRIPTOR.axes as PoseDescriptor<RotatedPose>['axes'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a leaf drawn in a frame of its own, turned or skewed, inside a group\n * resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are expressed in the leaf's own frame. In a group\n * resize they are world-frame: at 90° a horizontal stretch should grow the\n * leaf's `height`, and the naive map grows its `width`.\n *\n * What this computes is the group affine applied to the leaf's frame. The\n * center moves exactly; each box axis takes the length of its own image under\n * the turn; the rotation follows the image of the box's x-axis; and the\n * parallelogram a non-uniform scale makes of a turned box, which those cannot\n * hold, is written to the leaf's `transform`.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n  const kx = Math.hypot(ux, uy);\n  const ky = Math.hypot(vx, vy);\n\n  const width = pose.width * kx;\n  const height = pose.height * ky;\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  const next: RotatedPose = { ...pose, x: cxNew - width / 2, y: cyNew - height / 2, width, height, rotation };\n  // A collapsed axis leaves no frame to solve for; the leaf keeps the transform it had.\n  if (kx === 0 || ky === 0) return next as TPose;\n  const [ta, tb, tc, td] = poseLinearOf(pose) ?? [1, 0, 0, 1];\n  // The linear part the leaf must draw with, less what the new box and rotation already hold.\n  const [a, b, c, d] = multiply(\n    multiply(rotate(-rotation), [ux, uy, vx, vy, 0, 0]),\n    [ta / kx, tb / kx, tc / ky, td / ky, 0, 0],\n  );\n  if (Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12) {\n    delete next.transform;\n  } else {\n    next.transform = [a, b, c, d];\n  }\n  return next as TPose;\n}\n\n/** The pose's visual bounds: its box expanded to cover the box as drawn\n *  under its rotation and `transform`, so a turned or skewed shape reports\n *  the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  return axisAlignedBounds(framedBounds(pose, geometry));\n}\n\n/** The pose's box with the rotation and `transform` it is drawn in: what\n *  `poseFrameOf` reads, for a pose only its descriptor can read. */\nexport function framedBounds<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;\n  const transform = poseLinearOf(pose) ?? poseLinearOf(b);\n  if (!rotation && !transform) return b;\n  return { ...b, ...(rotation ? { rotation } : {}), ...(transform ? { transform } : {}) };\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":"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"}
+{"version":3,"file":"poseDescriptor.js","names":[],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport { multiply, poseLinearOf, rotate } from '@weasel-js/geom';\nimport type { TargetAxes } from '@weasel-js/animator';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the kit's bounds-driven math: bounds\n * are read via `getBounds`, and `remapBounds` projects a result back into\n * TPose.\n *\n * `remapBounds(pose, src, dst)` subsumes both \"set my own AABB to dst\"\n * (single-leaf resize) and \"scale me as a leaf inside parent's src→dst rect\"\n * (group resize) — they're the same affine map.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** How a pose of `like`'s kind maps to the flat numbers an animation moves, and which of them\n   *  are angles. `from` keeps the fields of `like` that are not axes. Null for a pose this\n   *  descriptor cannot map; absent, a pose animates by its flat numeric fields. */\n  axes?(like: TPose): TargetAxes<TPose> | null;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation; the rotation affordance\n   *  hides when it is `false`. When omitted, the kit assumes `true`, so a\n   *  descriptor whose poses cannot rotate (e.g. polygon Paths) should\n   *  return `false`. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type are indistinguishable to them.\n   * Implement this to read `node.data` once and hand back a descriptor that\n   * knows which shape it is describing. Callers reach it through\n   * {@link poseDescriptorForNode}; sites with only an id keep using the\n   * unspecialized descriptor.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  axes: (like) => {\n    const flat = [like.x, like.y, like.width, like.height];\n    if (!flat.every((n) => typeof n === 'number')) return null;\n    return {\n      count: 5,\n      names: ['x', 'y', 'width', 'height', 'rotation'],\n      angles: [4],\n      to: (p) => [p.x, p.y, p.width, p.height, p.rotation ?? 0],\n      from: (a) => {\n        const pose = { ...like, x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! };\n        if (like.rotation !== undefined || a[4] !== 0) pose.rotation = a[4]!;\n        return pose;\n      },\n      add: (p, d) => {\n        const pose = { ...p, x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]! };\n        const rotation = (p.rotation ?? 0) + d[4]!;\n        if (p.rotation !== undefined || rotation !== 0) pose.rotation = rotation;\n        return pose;\n      },\n      write: (p, out, at) => {\n        out[at] = p.x;\n        out[at + 1] = p.y;\n        out[at + 2] = p.width;\n        out[at + 3] = p.height;\n        out[at + 4] = p.rotation ?? 0;\n      },\n    };\n  },\n  // `withRotation` writes into `Bounds`' optional `rotation`, so this reads\n  // the same channel, or a pose reports itself unrotated while painting rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,\n *  with a required `rotation`. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  axes: RECT_POSE_DESCRIPTOR.axes as PoseDescriptor<RotatedPose>['axes'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a leaf drawn in a frame of its own, turned or skewed, inside a group\n * resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are expressed in the leaf's own frame. In a group\n * resize they are world-frame: at 90° a horizontal stretch should grow the\n * leaf's `height`, and the naive map grows its `width`.\n *\n * What this computes is the group affine applied to the leaf's frame. The\n * center moves exactly; each box axis takes the length of its own image under\n * the turn; the rotation follows the image of the box's x-axis; and the\n * parallelogram a non-uniform scale makes of a turned box, which those cannot\n * hold, is written to the leaf's `transform`.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n  const kx = Math.hypot(ux, uy);\n  const ky = Math.hypot(vx, vy);\n\n  const width = pose.width * kx;\n  const height = pose.height * ky;\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  const next: RotatedPose = { ...pose, x: cxNew - width / 2, y: cyNew - height / 2, width, height, rotation };\n  // A collapsed axis leaves no frame to solve for; the leaf keeps the transform it had.\n  if (kx === 0 || ky === 0) return next as TPose;\n  const [ta, tb, tc, td] = poseLinearOf(pose) ?? [1, 0, 0, 1];\n  // The linear part the leaf must draw with, less what the new box and rotation already hold.\n  const [a, b, c, d] = multiply(\n    multiply(rotate(-rotation), [ux, uy, vx, vy, 0, 0]),\n    [ta / kx, tb / kx, tc / ky, td / ky, 0, 0],\n  );\n  if (Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12) {\n    delete next.transform;\n  } else {\n    next.transform = [a, b, c, d];\n  }\n  return next as TPose;\n}\n\n/** The pose's visual bounds: its box expanded to cover the box as drawn\n *  under its rotation and `transform`, so a turned or skewed shape reports\n *  the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  return axisAlignedBounds(framedBounds(pose, geometry));\n}\n\n/** The pose's box with the rotation and `transform` it is drawn in: what\n *  `poseFrameOf` reads, for a pose only its descriptor can read. */\nexport function framedBounds<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;\n  const transform = poseLinearOf(pose) ?? poseLinearOf(b);\n  if (!rotation && !transform) return b;\n  return { ...b, ...(rotation ? { rotation } : {}), ...(transform ? { transform } : {}) };\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":"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"}