@weasel-js/core 1.9.4 → 1.10.1

package/dist/core/geometry/poseDescriptor.js

@@ -1,10 +1,10 @@
-import { poseLinearOf as e } from "./poseFrame.js";
-import { axisAlignedBounds as t } from "./unionBounds.js";
+import { axisAlignedBounds as e } from "./unionBounds.js";
+import { multiply as t, poseLinearOf as n, rotate as r } from "@weasel-js/geom";
 //#region src/core/geometry/poseDescriptor.ts
-function n(e, t) {
+function i(e, t) {
 	return e.forNode?.(t) ?? e;
 }
-var r = {
+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;
@@ -34,16 +34,63 @@ var r = {
 		width: e.width + (t.width - e.width) * n,
 		height: e.height + (t.height - e.height) * n
 	}),
+	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
 	})
-}, i = {
-	getBounds: r.getBounds,
-	remapBounds: r.remapBounds,
-	translate: r.translate,
-	lerp: r.lerp,
+}, o = {
+	getBounds: a.getBounds,
+	remapBounds: a.remapBounds,
+	translate: a.translate,
+	lerp: a.lerp,
+	axes: a.axes,
 	fromBounds: (e) => ({
 		x: e.x,
 		y: e.y,
@@ -57,29 +104,55 @@ var r = {
 		rotation: t
 	})
 };
-function a(e, t, n) {
-	let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height, a = e.rotation ?? 0, o = Math.cos(a), s = Math.sin(a), c = r * o, l = i * s, u = -r * s, d = i * o, f = e.width * Math.hypot(c, l), p = e.height * Math.hypot(u, d), m = Math.atan2(l, c), h = n.x + (e.x + e.width / 2 - t.x) * r, g = n.y + (e.y + e.height / 2 - t.y) * i;
-	return {
+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: h - f / 2,
-		y: g - p / 2,
-		width: f,
-		height: p,
-		rotation: m
+		x: b - _ / 2,
+		y: x - v / 2,
+		width: _,
+		height: v,
+		rotation: y
 	};
+	if (h === 0 || g === 0) return S;
+	let [C, w, T, E] = n(e) ?? [
+		1,
+		0,
+		0,
+		1
+	], [D, O, k, A] = t(t(r(-y), [
+		d,
+		f,
+		p,
+		m,
+		0,
+		0
+	]), [
+		C / h,
+		w / h,
+		T / g,
+		E / g,
+		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;
 }
-function o(n, r) {
-	let i = r.getBounds(n), a = r.getRotation?.(n) ?? i.rotation ?? 0, o = e(n) ?? void 0;
-	return t({
-		x: i.x,
-		y: i.y,
-		width: i.width,
-		height: i.height,
-		rotation: a,
-		transform: o
-	});
+function c(t, n) {
+	return e(l(t, n));
+}
+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 } : {}
+	};
 }
-function s(e, t, n, r) {
+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,
@@ -90,6 +163,6 @@ function s(e, t, n, r) {
 	return r.remapBounds(e, i, a);
 }
 //#endregion
-export { r as RECT_POSE_DESCRIPTOR, i as ROTATED_POSE_DESCRIPTOR, n as poseDescriptorForNode, a as remapRotatedLeaf, s as translatePoseViaDescriptor, o as visualBoundsViaDescriptor };
+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 };
 
 //# 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","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","pose","cos","sin","ux","uy","vx","vy","width","height","rotation","cxNew","cyNew","visualBoundsViaDescriptor","geometry","transform","poseLinearOf","axisAlignedBounds","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport { poseLinearOf } from 'core/geometry/poseFrame';\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 resize hook's bounds-driven math.\n * The hook reads bounds via `getBounds`, runs anchor-relative math on those\n * bounds, then asks `remapBounds` to project the result back into TPose.\n *\n * `remapBounds(pose, src, dst)` is a single operation that subsumes both\n * \"set my own AABB to dst\" (single-leaf resize) and \"scale me as a leaf\n * inside parent's src→dst rect\" (group resize) — they're the same affine\n * map. For rect-shaped poses the default geometry interprets the pose as\n * its own bounds; for Path or polygon poses the consumer supplies a\n * projection that knows how to read and rewrite the underlying geometry.\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  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted — descriptor\n   *  declares \"this pose has no rotation.\" When supplied and non-zero,\n   *  `useResize` projects the drag delta into the leaf's local frame,\n   *  runs anchor math there, and translates the resulting pose so the\n   *  diagonally opposite world-space corner is pinned. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation. Consulted by the\n   *  rotation affordance to decide whether to render the rotate cursor /\n   *  drag-band over a selection. When omitted, the kit assumes `true` for\n   *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`\n   *  fields (e.g. polygon Paths) should return `false` so the affordance\n   *  hides instead of exposing a non-functional rotate cursor. */\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 — a sphere and a box both posed by\n   * position/rotation/scale — are indistinguishable to them. Implement this to\n   * read `node.data` once and hand back a descriptor that knows which shape it\n   * is describing.\n   *\n   * Callers reach it through {@link poseDescriptorForNode}, at whichever site\n   * holds the node; the specialized descriptor then travels into the bounds and\n   * hit-test helpers in place of this one. Sites with only an id keep using the\n   * unspecialized descriptor, which is why this is optional on both ends.\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  // `Bounds` carries an optional `rotation`, and `withRotation` writes into\n  // it — so reading it back has to be the same channel, or a pose reports\n  // itself unrotated to `useResize` and to port placement while painting\n  // rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`. Inherits rect-shape projection\n *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends Bounds`\n *  subtype lets the rect descriptor's methods apply directly; `remapBounds`\n *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so\n *  `useResize` knows to take the rotation-aware math path. */\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  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 **rotated** leaf inside a group 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 already expressed in the leaf's own frame — the\n * single-leaf resize path, where the drag delta was projected into that frame\n * before the anchor math ran. In a group resize they are world-frame, so the\n * leaf's local axes do not line up with the axes being scaled: at 90° a\n * horizontal stretch should grow the leaf's `height`, and the naive map grows\n * its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model is `{x, y, width, height, rotation}`\n * and cannot represent the parallelogram a non-uniform scale of a rotated box\n * actually produces. The center moves exactly; each local axis takes the\n * length of its own image; the rotation follows the image of the local x-axis.\n *\n * Degenerates to the naive map at `rotation === 0`, and to a plain uniform\n * scale when `sx === sy`, both exactly.\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\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\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  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\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  const b = geometry.getBounds(pose);\n  const rotation =\n    geometry.getRotation?.(pose) ?? (b as { rotation?: number }).rotation ?? 0;\n  const transform = poseLinearOf(pose) ?? undefined;\n  return axisAlignedBounds({ x: b.x, y: b.y, width: b.width, height: b.height, rotation, 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":["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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"}

package/dist/core/geometry/regionHit.js

@@ -1,7 +1,6 @@
 import { nodeMemo as e } from "../scene/nodeMemo.js";
-import { pathThroughPoseFrame as t, poseFrameOf as n } from "./poseFrame.js";
-import { visualBoundsViaDescriptor as r } from "./poseDescriptor.js";
-import { boxContainsBox as i, pointInPolygon as a, polygonContainsPath as o, polygonIntersectsPath as s } from "@weasel-js/geom";
+import { visualBoundsViaDescriptor as t } from "./poseDescriptor.js";
+import { boxContainsBox as n, pathThroughPoseFrame as r, pointInPolygon as i, polygonContainsPath as a, polygonIntersectsPath as o, poseFrameOf as s } from "@weasel-js/geom";
 //#region src/core/geometry/regionHit.ts
 function c(e) {
 	let { x: t, y: n, width: r, height: i } = e;
@@ -51,49 +50,48 @@ function u(e) {
 function d(e) {
 	return typeof e == "object" && !!e && e.kind === "polygon";
 }
-function f(t, n, i) {
-	return d(n) ? e(t, "aabb", n, () => i.getBounds(n)) : r(n, i);
+function f(n, r, i) {
+	return d(r) ? e(n, "aabb", r, () => i.getBounds(r)) : t(r, i);
 }
-function p(e, r) {
-	if (n(e)) {
-		let n = e;
-		return t({
+function p(e, t) {
+	if (s(e)) {
+		let t = e;
+		return r({
 			kind: "rect",
-			x: n.x,
-			y: n.y,
-			width: n.width,
-			height: n.height
+			x: t.x,
+			y: t.y,
+			width: t.width,
+			height: t.height
 		}, e);
 	}
 	return {
 		kind: "rect",
-		x: r.x,
-		y: r.y,
-		width: r.width,
-		height: r.height
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height
 	};
 }
-function m(e, t, n, r, c) {
-	if (!Number.isFinite(r.x) || !Number.isFinite(r.y) || !Number.isFinite(r.width) || !Number.isFinite(r.height)) return !1;
-	let l = e.bounds;
-	if (r.x >= l.x + l.width || r.x + r.width <= l.x || r.y >= l.y + l.height || r.y + r.height <= l.y) return !1;
-	if (t === "centers") return a(e.coords, r.x + r.width / 2, r.y + r.height / 2);
-	let u = i([
-		l.x,
-		l.y,
-		l.x + l.width,
-		l.y + l.height
+function m(e, t, r, s, c, l = () => !0) {
+	if (!Number.isFinite(s.x) || !Number.isFinite(s.y) || !Number.isFinite(s.width) || !Number.isFinite(s.height)) return !1;
+	let u = e.bounds;
+	if (s.x >= u.x + u.width || s.x + s.width <= u.x || s.y >= u.y + u.height || s.y + s.height <= u.y) return !1;
+	if (t === "centers") return i(e.coords, s.x + s.width / 2, s.y + s.height / 2);
+	let f = n([
+		u.x,
+		u.y,
+		u.x + u.width,
+		u.y + u.height
 	], [
-		r.x,
-		r.y,
-		r.x + r.width,
-		r.y + r.height
-	]), f = d(n);
-	if (t === "enclosed") return u ? o(e.verts, f ? n : c()) : !1;
-	if (e.isRect && u) return !0;
-	if (f) return s(e.verts, n);
-	let p = c();
-	return p.kind === "rect" && e.isRect ? !0 : s(e.verts, p);
+		s.x,
+		s.y,
+		s.x + s.width,
+		s.y + s.height
+	]), p = d(r);
+	if (t === "enclosed") return p && !f ? !1 : a(e.verts, p ? r : c());
+	if (e.isRect && f) return !0;
+	let m = p ? r : c();
+	return l() ? m.kind === "rect" && e.isRect ? m.x < u.x + u.width && m.x + m.width > u.x && m.y < u.y + u.height && m.y + m.height > u.y : o(e.verts, m) : o(e.verts, m, { filled: !1 });
 }
 //#endregion
 export { d as isSilhouettePose, u as polygonRegion, p as poseOutline, c as rectRegion, f as regionBoundsOf, l as regionOf, m as regionTakes };

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

@@ -1 +1 @@
-{"version":3,"file":"regionHit.js","names":["rectRegion","w","h","r","regionOf","x","y","verts","flat","minX","minY","maxX","maxY","i","coords","bounds","polygonRegion","polygon","p","isSilhouettePose","pose","regionBoundsOf","nodeMemo","node","g","visualBoundsViaDescriptor","poseOutline","poseFrameOf","pathThroughPoseFrame","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","polygonIntersectsPath","drawn"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision shared by\n * `sceneToAdapter` (through `canvas/deps/hitTestArea`) and `arrayAdapter`.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { pathThroughPoseFrame, poseFrameOf } from './poseFrame';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './poseDescriptor';\n\n/** A closed selection area: a marquee rect or a lasso polygon. */\nexport interface SelectRegion {\n  /** The area's vertices; the closing edge back to the first is implicit. */\n  readonly verts: readonly Vec2[];\n  /** `verts` interleaved as `[x0, y0, x1, y1, …]`. */\n  readonly coords: readonly number[];\n  readonly bounds: Bounds;\n  /** True when the area is its own bounding rect, so a node inside `bounds`\n   *  is inside the area without further work. Never true for a lasso: a node\n   *  inside the hull's box can still miss the hull. */\n  readonly isRect: boolean;\n}\n\n/** A marquee's region. */\nexport function rectRegion(r: Bounds): SelectRegion {\n  const { x, y, width: w, height: h } = r;\n  return regionOf([x, y, x + w, y, x + w, y + h, x, y + h], { x, y, width: w, height: h }, true)!;\n}\n\n/** A region from interleaved coords. `bounds` is derived when omitted; `null`\n *  when there are no coords to bound. */\nexport function regionOf(\n  coords: ArrayLike<number>,\n  bounds?: Bounds,\n  isRect = false,\n): SelectRegion | null {\n  const verts: Vec2[] = [];\n  const flat: number[] = [];\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    verts.push({ x, y });\n    flat.push(x, y);\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  if (verts.length === 0) return null;\n  return {\n    verts,\n    coords: flat,\n    bounds: bounds ?? { x: minX, y: minY, width: maxX - minX, height: maxY - minY },\n    isRect,\n  };\n}\n\n/** A lasso's region, or `null` for fewer than three vertices. */\nexport function polygonRegion(polygon: ReadonlyArray<Vec2>): SelectRegion | null {\n  if (polygon.length < 3) return null;\n  const coords: number[] = [];\n  for (const p of polygon) coords.push(p.x, p.y);\n  return regionOf(coords);\n}\n\n/** A pose that is its own drawn outline. */\nexport function isSilhouettePose(pose: unknown): pose is PolygonPath {\n  return pose !== null && typeof pose === 'object' && (pose as Path).kind === 'polygon';\n}\n\n/**\n * The box a region fast-rejects a node against: a silhouette pose's own bounds,\n * else the pose's visual bounds — which for a rotated pose is the box of its\n * rotated ink, reaching past the pose box. `g` is the node's descriptor.\n */\nexport function regionBoundsOf(node: object, pose: unknown, g: PoseDescriptor<unknown>): Bounds {\n  // Memo is silhouettes-only: a rect pose's bounds are the pose itself, and\n  // memoizing it costs more than it saves. The result may be shared; never mutate it.\n  return isSilhouettePose(pose)\n    ? nodeMemo(node, 'aabb', pose, () => g.getBounds(pose))\n    : visualBoundsViaDescriptor(pose, g);\n}\n\n/** The outline of a node nothing paints: its pose rect through the pose's\n *  frame, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  if (poseFrameOf(pose)) {\n    const p = pose as Bounds;\n    return pathThroughPoseFrame({ kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height }, pose);\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A node sticking out of the region's box cannot be inside the region.\n    if (!inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  if (silhouette) return polygonIntersectsPath(region.verts, pose);\n  const drawn = outline();\n  // An axis-aligned rect overlapping a marquee's box already meets it.\n  if (drawn.kind === 'rect' && region.isRect) return true;\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":";;;;;AAsCA,SAAgBA,EAAW,GAAyB;CAClD,IAAM,EAAE,MAAG,MAAG,OAAOC,GAAG,QAAQC,MAAMC;CACtC,OAAOC,EAAS;EAACC;EAAGC;EAAGD,IAAIJ;EAAGK;EAAGD,IAAIJ;EAAGK,IAAIJ;EAAGG;EAAGC,IAAIJ;CAAC,GAAG;EAAE;EAAG;EAAG,OAAOD;EAAG,QAAQC;CAAE,GAAG,EAAI;AAC/F;AAIA,SAAgBE,EACd,GACA,GACA,IAAS,IACY;CACrB,IAAMG,IAAgB,CAAC,GACjBC,IAAiB,CAAC,GACpBC,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;CAC/D,KAAK,IAAIC,IAAI,GAAGA,IAAI,IAAIC,EAAO,QAAQ,KAAK,GAAG;EAC7C,IAAMT,IAAIS,EAAOD,IAAIP,IAAIQ,EAAOD,IAAI;EAMpC,AALAN,EAAM,KAAK;GAAE;GAAG;EAAE,CAAC,GACnBC,EAAK,KAAKH,GAAGC,CAAC,GACVD,IAAII,MAAM,IAAOJ,IACjBC,IAAII,MAAM,IAAOJ,IACjBD,IAAIM,MAAM,IAAON,IACjBC,IAAIM,MAAM,IAAON;CACvB;CAEA,OADIC,EAAM,WAAW,IAAU,OACxB;EACL;EACA,QAAQC;EACR,QAAQO,KAAU;GAAE,GAAGN;GAAM,GAAGC;GAAM,OAAOC,IAAOF;GAAM,QAAQG,IAAOF;EAAK;EAC9E;CACF;AACF;AAGA,SAAgBM,EAAc,GAAmD;CAC/E,IAAIC,EAAQ,SAAS,GAAG,OAAO;CAC/B,IAAMH,IAAmB,CAAC;CAC1B,KAAK,IAAMI,KAAKD,GAAS,EAAO,KAAKC,EAAE,GAAGA,EAAE,CAAC;CAC7C,OAAOd,EAASU,CAAM;AACxB;AAGA,SAAgBK,EAAiB,GAAoC;CACnE,OAAwB,OAAOC,KAAS,cAAjCA,KAA8CA,EAAc,SAAS;AAC9E;AAOA,SAAgBC,EAAe,GAAc,GAAe,GAAoC;CAG9F,OAAOF,EAAiBC,CAAI,IACxBE,EAASC,GAAM,QAAQH,SAAYI,EAAE,UAAUJ,CAAI,CAAC,IACpDK,EAA0BL,GAAMI,CAAC;AACvC;AAIA,SAAgBE,EAAY,GAAe,GAAiB;CAC1D,IAAIC,EAAYP,CAAI,GAAG;EACrB,IAAMF,IAAIE;EACV,OAAOQ,EAAqB;GAAE,MAAM;GAAQ,GAAGV,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO,GAAGE,CAAI;CACtG;CACA,OAAO;EAAE,MAAM;EAAQ,GAAGS,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;AAC1E;AAYA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACS;CACT,IACE,CAAC,OAAO,SAASD,EAAE,CAAC,KAAK,CAAC,OAAO,SAASA,EAAE,CAAC,KAC7C,CAAC,OAAO,SAASA,EAAE,KAAK,KAAK,CAAC,OAAO,SAASA,EAAE,MAAM,GAEtD,OAAO;CAET,IAAME,IAAKC,EAAO;CAClB,IACEH,EAAE,KAAKE,EAAG,IAAIA,EAAG,SAASF,EAAE,IAAIA,EAAE,SAASE,EAAG,KAC9CF,EAAE,KAAKE,EAAG,IAAIA,EAAG,UAAUF,EAAE,IAAIA,EAAE,UAAUE,EAAG,GAEhD,OAAO;CAET,IAAIE,MAAS,WACX,OAAOC,EAAeF,EAAO,QAAQH,EAAE,IAAIA,EAAE,QAAQ,GAAGA,EAAE,IAAIA,EAAE,SAAS,CAAC;CAE5E,IAAMM,IAAQC,EACZ;EAACL,EAAG;EAAGA,EAAG;EAAGA,EAAG,IAAIA,EAAG;EAAOA,EAAG,IAAIA,EAAG;CAAM,GAC9C;EAACF,EAAE;EAAGA,EAAE;EAAGA,EAAE,IAAIA,EAAE;EAAOA,EAAE,IAAIA,EAAE;CAAM,CAC1C,GACMQ,IAAalB,EAAiBC,CAAI;CACxC,IAAIa,MAAS,YAGX,OADKE,IACEG,EAAoBN,EAAO,OAAOK,IAAajB,IAAOmB,EAAQ,CAAC,IADnD;CAIrB,IAAIP,EAAO,UAAUG,GAAO,OAAO;CACnC,IAAIE,GAAY,OAAOG,EAAsBR,EAAO,OAAOZ,CAAI;CAC/D,IAAMqB,IAAQF,EAAQ;CAGtB,OADIE,EAAM,SAAS,UAAUT,EAAO,SAAe,KAC5CQ,EAAsBR,EAAO,OAAOS,CAAK;AAClD"}
+{"version":3,"file":"regionHit.js","names":["rectRegion","w","h","r","regionOf","x","y","verts","flat","minX","minY","maxX","maxY","i","coords","bounds","polygonRegion","polygon","p","isSilhouettePose","pose","regionBoundsOf","nodeMemo","node","g","visualBoundsViaDescriptor","poseOutline","poseFrameOf","pathThroughPoseFrame","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","drawn","filled","polygonIntersectsPath"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision the\n * scene's area walk (`canvas/deps/hitTestArea`) makes.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { pathThroughPoseFrame, poseFrameOf } from '@weasel-js/geom';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './poseDescriptor';\n\n/** A closed selection area: a marquee rect or a lasso polygon. */\nexport interface SelectRegion {\n  /** The area's vertices; the closing edge back to the first is implicit. */\n  readonly verts: readonly Vec2[];\n  /** `verts` interleaved as `[x0, y0, x1, y1, …]`. */\n  readonly coords: readonly number[];\n  readonly bounds: Bounds;\n  /** True when the area is its own bounding rect, so a node inside `bounds`\n   *  is inside the area without further work. Never true for a lasso: a node\n   *  inside the hull's box can still miss the hull. */\n  readonly isRect: boolean;\n}\n\n/** A marquee's region. */\nexport function rectRegion(r: Bounds): SelectRegion {\n  const { x, y, width: w, height: h } = r;\n  return regionOf([x, y, x + w, y, x + w, y + h, x, y + h], { x, y, width: w, height: h }, true)!;\n}\n\n/** A region from interleaved coords. `bounds` is derived when omitted; `null`\n *  when there are no coords to bound. */\nexport function regionOf(\n  coords: ArrayLike<number>,\n  bounds?: Bounds,\n  isRect = false,\n): SelectRegion | null {\n  const verts: Vec2[] = [];\n  const flat: number[] = [];\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    verts.push({ x, y });\n    flat.push(x, y);\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  if (verts.length === 0) return null;\n  return {\n    verts,\n    coords: flat,\n    bounds: bounds ?? { x: minX, y: minY, width: maxX - minX, height: maxY - minY },\n    isRect,\n  };\n}\n\n/** A lasso's region, or `null` for fewer than three vertices. */\nexport function polygonRegion(polygon: ReadonlyArray<Vec2>): SelectRegion | null {\n  if (polygon.length < 3) return null;\n  const coords: number[] = [];\n  for (const p of polygon) coords.push(p.x, p.y);\n  return regionOf(coords);\n}\n\n/** A pose that is its own drawn outline. */\nexport function isSilhouettePose(pose: unknown): pose is PolygonPath {\n  return pose !== null && typeof pose === 'object' && (pose as Path).kind === 'polygon';\n}\n\n/**\n * The box a region fast-rejects a node against: a silhouette pose's own bounds,\n * else the pose's visual bounds — which for a rotated pose is the box of its\n * rotated ink, reaching past the pose box. `g` is the node's descriptor.\n */\nexport function regionBoundsOf(node: object, pose: unknown, g: PoseDescriptor<unknown>): Bounds {\n  // Memo is silhouettes-only: a rect pose's bounds are the pose itself, and\n  // memoizing it costs more than it saves. The result may be shared; never mutate it.\n  return isSilhouettePose(pose)\n    ? nodeMemo(node, 'aabb', pose, () => g.getBounds(pose))\n    : visualBoundsViaDescriptor(pose, g);\n}\n\n/** The outline of a node nothing paints: its pose rect through the pose's\n *  frame, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  if (poseFrameOf(pose)) {\n    const p = pose as Bounds;\n    return pathThroughPoseFrame({ kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height }, pose);\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere: its interior too,\n *   unless `filled` says nothing paints it.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * `b` only rejects: it encloses the outline and may reach past it, so a node\n * is taken by the outline alone. A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n  filled: () => boolean = () => true,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A silhouette pose's bounds are its outline's: sticking out of the\n    // region's box, it cannot be inside the region.\n    if (silhouette && !inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  const drawn = silhouette ? pose : outline();\n  if (!filled()) return polygonIntersectsPath(region.verts, drawn, { filled: false });\n  // Two axis-aligned rects meet exactly when their boxes overlap.\n  if (drawn.kind === 'rect' && region.isRect) {\n    return (\n      drawn.x < ab.x + ab.width && drawn.x + drawn.width > ab.x &&\n      drawn.y < ab.y + ab.height && drawn.y + drawn.height > ab.y\n    );\n  }\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":"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"}

package/dist/core/geometry/targetFrame.js

@@ -0,0 +1,94 @@
+import { applyToPoint as e, invert as t, poseFrameOf as n } from "@weasel-js/geom";
+//#region src/core/geometry/targetFrame.ts
+var r = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+], i = {
+	identity: !0,
+	toWorld: r,
+	toLocal: r
+};
+function a(e) {
+	let r = n(e);
+	return r ? {
+		identity: !1,
+		toWorld: r,
+		toLocal: t(r)
+	} : i;
+}
+function o(e) {
+	return e.identity ? 0 : Math.atan2(e.toWorld[1], e.toWorld[0]);
+}
+function s(e) {
+	if (e.identity) return !0;
+	let [t, n, r, i] = e.toWorld;
+	return Math.abs(t - i) < 1e-9 && Math.abs(n + r) < 1e-9 && Math.abs(t * t + n * n - 1) < 1e-9;
+}
+function c(t, n, r) {
+	if (t.identity) return {
+		x: n,
+		y: r
+	};
+	let [i, a] = e(t.toWorld, n, r);
+	return {
+		x: i,
+		y: a
+	};
+}
+function l(t, n, r) {
+	if (t.identity) return {
+		x: n,
+		y: r
+	};
+	if (!t.toLocal) return null;
+	let [i, a] = e(t.toLocal, n, r);
+	return {
+		x: i,
+		y: a
+	};
+}
+function u(e, t, n) {
+	if (e.identity) return {
+		x: t,
+		y: n
+	};
+	let r = e.toLocal;
+	return r && {
+		x: r[0] * t + r[2] * n,
+		y: r[1] * t + r[3] * n
+	};
+}
+function d(e, t) {
+	if (e.identity) return t;
+	let [n, r, i, a] = e.toWorld, o = Math.sign(n * a - r * i) || 1;
+	return {
+		x: (a * t.x - r * t.y) * o,
+		y: (n * t.y - i * t.x) * o
+	};
+}
+function f(e, t, n) {
+	let [r, i, a, o] = n.toWorld, s = r * t.x, c = i * t.y, l = a * t.x, u = o * t.y, d = Math.abs(s * u - c * l);
+	return d === 0 ? {
+		x: 0,
+		y: 0
+	} : {
+		x: e * Math.hypot(l, u) / d,
+		y: e * Math.hypot(s, c) / d
+	};
+}
+function p(e, t) {
+	return [
+		c(t, e.x, e.y),
+		c(t, e.x + e.width, e.y),
+		c(t, e.x + e.width, e.y + e.height),
+		c(t, e.x, e.y + e.height)
+	];
+}
+//#endregion
+export { i as IDENTITY_TARGET, o as angleOf, s as isRigid, c as localToWorld, d as normalToWorld, f as pxExtentIn, p as targetCorners, a as targetTransformOf, u as worldDeltaToLocal, l as worldToLocal };
+
+//# sourceMappingURL=targetFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"targetFrame.js","names":["IDENTITY","IDENTITY_TARGET","targetTransformOf","toWorld","poseFrameOf","bounds","invert","angleOf","xf","isRigid","a","b","c","d","localToWorld","lx","ly","x","y","applyToPoint","worldToLocal","wx","wy","worldDeltaToLocal","dx","dy","m","normalToWorld","n","k","pxExtentIn","ux","scale","uy","vx","vy","det","px","targetCorners"],"sources":["../../../src/core/geometry/targetFrame.ts"],"sourcesContent":["/**\n * The frame selection chrome reads a target in: `poseFrameOf` over the\n * target's bounds, with the helpers the outline, the handles, their hit\n * regions, and the resize and rotate actions all place themselves by.\n */\nimport { applyToPoint, invert, poseFrameOf, type Affine, type Scale2 } from '@weasel-js/geom';\n\n/** Local↔world maps for a chrome target. Local is the target's unrotated box\n *  frame; world is where the node is drawn. */\nexport interface TargetTransform {\n  /** No rotation and no `transform`: local is world. */\n  identity: boolean;\n  /** Target box frame → world. */\n  toWorld: Affine;\n  /** World → target box frame. `null` when the target's `transform` is\n   *  singular: it draws nothing, and no world point maps back. */\n  toLocal: Affine | null;\n}\n\nconst IDENTITY: Affine = [1, 0, 0, 1, 0, 0];\n\nexport const IDENTITY_TARGET: TargetTransform = { identity: true, toWorld: IDENTITY, toLocal: IDENTITY };\n\n/** The frame `bounds` is drawn in: its `rotation`, its `transform`, or both. */\nexport function targetTransformOf(bounds: unknown): TargetTransform {\n  const toWorld = poseFrameOf(bounds);\n  if (!toWorld) return IDENTITY_TARGET;\n  return { identity: false, toWorld, toLocal: invert(toWorld) };\n}\n\n/** How far the target's x axis is turned from world's, radians. */\nexport function angleOf(xf: TargetTransform): number {\n  return xf.identity ? 0 : Math.atan2(xf.toWorld[1], xf.toWorld[0]);\n}\n\n/** Whether the frame only turns the target: no skew, no stretch, no flip. */\nexport function isRigid(xf: TargetTransform): boolean {\n  if (xf.identity) return true;\n  const [a, b, c, d] = xf.toWorld;\n  return Math.abs(a - d) < 1e-9 && Math.abs(b + c) < 1e-9 && Math.abs(a * a + b * b - 1) < 1e-9;\n}\n\n/** local point → world point. */\nexport function localToWorld(xf: TargetTransform, lx: number, ly: number): { x: number; y: number } {\n  if (xf.identity) return { x: lx, y: ly };\n  const [x, y] = applyToPoint(xf.toWorld, lx, ly);\n  return { x, y };\n}\n\n/** world point → local point; `null` where nothing maps back. */\nexport function worldToLocal(xf: TargetTransform, wx: number, wy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: wx, y: wy };\n  if (!xf.toLocal) return null;\n  const [x, y] = applyToPoint(xf.toLocal, wx, wy);\n  return { x, y };\n}\n\n/** A world delta in the target's own axes; `null` where nothing maps back. */\nexport function worldDeltaToLocal(xf: TargetTransform, dx: number, dy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: dx, y: dy };\n  const m = xf.toLocal;\n  return m && { x: m[0] * dx + m[2] * dy, y: m[1] * dx + m[3] * dy };\n}\n\n/** A local edge's outward normal as a world direction, unnormalized. A normal\n *  goes through the inverse transpose, so it stays square to a skewed edge. */\nexport function normalToWorld(xf: TargetTransform, n: { x: number; y: number }): { x: number; y: number } {\n  if (xf.identity) return n;\n  const [a, b, c, d] = xf.toWorld;\n  const k = Math.sign(a * d - b * c) || 1;\n  return { x: (d * n.x - b * n.y) * k, y: (a * n.y - c * n.x) * k };\n}\n\n/** `pxExtent` along the target's own axes: how far along each an edge across\n *  it must move to move `px` on screen. */\nexport function pxExtentIn(px: number, scale: Scale2, xf: TargetTransform): { x: number; y: number } {\n  const [a, b, c, d] = xf.toWorld;\n  const ux = a * scale.x, uy = b * scale.y;\n  const vx = c * scale.x, vy = d * scale.y;\n  const det = Math.abs(ux * vy - uy * vx);\n  if (det === 0) return { x: 0, y: 0 };\n  return { x: (px * Math.hypot(vx, vy)) / det, y: (px * Math.hypot(ux, uy)) / det };\n}\n\n/** The target's box corners in world, TL/TR/BR/BL. */\nexport function targetCorners(\n  b: { x: number; y: number; width: number; height: number },\n  xf: TargetTransform,\n): { x: number; y: number }[] {\n  return [\n    localToWorld(xf, b.x, b.y),\n    localToWorld(xf, b.x + b.width, b.y),\n    localToWorld(xf, b.x + b.width, b.y + b.height),\n    localToWorld(xf, b.x, b.y + b.height),\n  ];\n}\n"],"mappings":"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"}

package/dist/core/geometry/unionBounds.js

@@ -1,5 +1,4 @@
-import { poseFrameOf as e } from "./poseFrame.js";
-import { applyToPoint as t } from "@weasel-js/geom";
+import { applyToPoint as e, poseFrameOf as t } from "@weasel-js/geom";
 //#region src/core/geometry/unionBounds.ts
 function n(e) {
 	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity, a = !1;
@@ -16,7 +15,7 @@ function n(e) {
 	} : null;
 }
 function r(n) {
-	let r = e(n);
+	let r = t(n);
 	if (!r) return {
 		x: n.x,
 		y: n.y,
@@ -29,8 +28,8 @@ function r(n) {
 		[n.x + n.width, n.y + n.height],
 		[n.x, n.y + n.height]
 	];
-	for (let [e, n] of c) {
-		let [c, l] = t(r, e, n);
+	for (let [t, n] of c) {
+		let [c, l] = e(r, t, n);
 		c < i && (i = c), c > o && (o = c), l < a && (a = l), l > s && (s = l);
 	}
 	return {

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

@@ -1 +1 @@
-{"version":3,"file":"unionBounds.js","names":["unionBounds","minX","minY","maxX","maxY","any","p","poses","right","bottom","axisAlignedBounds","frame","poseFrameOf","b","corners","px","py","rx","ry","applyToPoint","unionAABB","part","parts"],"sources":["../../../src/core/geometry/unionBounds.ts"],"sourcesContent":["/**\n * Union math over rect-shaped poses.\n *\n * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*\n * boxes and is what commit-time actions want, because they go on to write\n * poses back in that same frame. `unionAABB` expands each rotated member to\n * the extent of its ink first, and is what anything a user looks at or clicks\n * wants — selection chrome, gesture bounds, an export viewBox. Folding the\n * unrotated box there under-reports the extent of a rotated member exactly\n * when the consumer is watching it move.\n */\n\nimport { applyToPoint } from '@weasel-js/geom';\nimport type { RectPose } from 'core/scene/types';\nimport { poseFrameOf } from './poseFrame';\nexport type { RectPose };\n\n/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any\n *  rotation they carry. See the module docstring before reaching for this\n *  over {@link unionAABB}. */\nexport function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const p of poses) {\n    any = true;\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    const right = p.x + p.width;\n    const bottom = p.y + p.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Axis-align a pose that carries a `rotation` or a `transform`: returns the\n * AABB of the box as drawn, its four corners through `poseFrameOf`, with both\n * fields dropped.\n *\n * A pose with neither is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const frame = poseFrameOf(b);\n  if (!frame) {\n    // Strip an explicit `rotation: 0` so callers can rely on the absence of\n    // the field meaning \"axis-aligned\".\n    return { x: b.x, y: b.y, width: b.width, height: b.height };\n  }\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  const corners: ReadonlyArray<readonly [number, number]> = [\n    [b.x, b.y],\n    [b.x + b.width, b.y],\n    [b.x + b.width, b.y + b.height],\n    [b.x, b.y + b.height],\n  ];\n  for (const [px, py] of corners) {\n    const [rx, ry] = applyToPoint(frame, px, py);\n    if (rx < minX) minX = rx;\n    if (rx > maxX) maxX = rx;\n    if (ry < minY) minY = ry;\n    if (ry > maxY) maxY = ry;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Fold every part into one world-space AABB, skipping `null` / `undefined`\n * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;\n * the result never carries a `rotation` (a union of several oriented boxes\n * has no single orientation to report).\n *\n * Returns `null` when nothing was contributed.\n */\nexport function unionAABB<TPose extends RectPose>(\n  parts: Iterable<TPose | null | undefined>,\n): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const part of parts) {\n    if (!part) continue;\n    const b = axisAlignedBounds(part);\n    any = true;\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":";;;AAoBA,SAAgBA,EAAoC,GAAyC;CAC3F,IAAIC,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMC,KAAKC,GAAO;EAGrB,AAFA,IAAM,IACFD,EAAE,IAAIL,MAAM,IAAOK,EAAE,IACrBA,EAAE,IAAIJ,MAAM,IAAOI,EAAE;EACzB,IAAME,IAAQF,EAAE,IAAIA,EAAE,OAChBG,IAASH,EAAE,IAAIA,EAAE;EAEvB,AADIE,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB;AASA,SAAgBQ,EAA0C,GAAoB;CAC5E,IAAMC,IAAQC,EAAYC,CAAC;CAC3B,IAAI,CAACF,GAGH,OAAO;EAAE,GAAGE,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CAE5D,IAAIZ,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACLU,IAAoD;EACxD,CAACD,EAAE,GAAGA,EAAE,CAAC;EACT,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,CAAC;EACnB,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,IAAIA,EAAE,MAAM;EAC9B,CAACA,EAAE,GAAGA,EAAE,IAAIA,EAAE,MAAM;CACtB;CACA,KAAK,IAAM,CAACE,GAAIC,MAAOF,GAAS;EAC9B,IAAM,CAACG,GAAIC,KAAMC,EAAaR,GAAOI,GAAIC,CAAE;EAI3C,AAHIC,IAAKhB,MAAM,IAAOgB,IAClBA,IAAKd,MAAM,IAAOc,IAClBC,IAAKhB,MAAM,IAAOgB,IAClBA,IAAKd,MAAM,IAAOc;CACxB;CACA,OAAO;EAAE,GAAGjB;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE;AAUA,SAAgBkB,EACd,GACiB;CACjB,IAAInB,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMgB,KAAQC,GAAO;EACxB,IAAI,CAACD,GAAM;EACX,IAAMR,IAAIH,EAAkBW,CAAI;EAGhC,AAFA,IAAM,IACFR,EAAE,IAAIZ,MAAM,IAAOY,EAAE,IACrBA,EAAE,IAAIX,MAAM,IAAOW,EAAE;EACzB,IAAML,IAAQK,EAAE,IAAIA,EAAE,OAChBJ,IAASI,EAAE,IAAIA,EAAE;EAEvB,AADIL,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB"}
+{"version":3,"file":"unionBounds.js","names":["unionBounds","minX","minY","maxX","maxY","any","p","poses","right","bottom","axisAlignedBounds","frame","poseFrameOf","b","corners","px","py","rx","ry","applyToPoint","unionAABB","part","parts"],"sources":["../../../src/core/geometry/unionBounds.ts"],"sourcesContent":["/**\n * Union math over rect-shaped poses.\n *\n * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*\n * boxes and is what commit-time actions want, because they go on to write\n * poses back in that same frame. `unionAABB` expands each rotated member to\n * the extent of its ink first, and is what anything a user looks at or clicks\n * wants — selection chrome, gesture bounds, an export viewBox. Folding the\n * unrotated box there under-reports the extent of a rotated member exactly\n * when the consumer is watching it move.\n */\n\nimport { applyToPoint } from '@weasel-js/geom';\nimport type { RectPose } from 'core/scene/types';\nimport { poseFrameOf } from '@weasel-js/geom';\nexport type { RectPose };\n\n/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any\n *  rotation they carry. See the module docstring before reaching for this\n *  over {@link unionAABB}. */\nexport function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const p of poses) {\n    any = true;\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    const right = p.x + p.width;\n    const bottom = p.y + p.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Axis-align a pose that carries a `rotation` or a `transform`: returns the\n * AABB of the box as drawn, its four corners through `poseFrameOf`, with both\n * fields dropped.\n *\n * A pose with neither is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const frame = poseFrameOf(b);\n  if (!frame) {\n    // Strip an explicit `rotation: 0` so callers can rely on the absence of\n    // the field meaning \"axis-aligned\".\n    return { x: b.x, y: b.y, width: b.width, height: b.height };\n  }\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  const corners: ReadonlyArray<readonly [number, number]> = [\n    [b.x, b.y],\n    [b.x + b.width, b.y],\n    [b.x + b.width, b.y + b.height],\n    [b.x, b.y + b.height],\n  ];\n  for (const [px, py] of corners) {\n    const [rx, ry] = applyToPoint(frame, px, py);\n    if (rx < minX) minX = rx;\n    if (rx > maxX) maxX = rx;\n    if (ry < minY) minY = ry;\n    if (ry > maxY) maxY = ry;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Fold every part into one world-space AABB, skipping `null` / `undefined`\n * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;\n * the result never carries a `rotation` (a union of several oriented boxes\n * has no single orientation to report).\n *\n * Returns `null` when nothing was contributed.\n */\nexport function unionAABB<TPose extends RectPose>(\n  parts: Iterable<TPose | null | undefined>,\n): RectPose | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const part of parts) {\n    if (!part) continue;\n    const b = axisAlignedBounds(part);\n    any = true;\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":";;AAoBA,SAAgBA,EAAoC,GAAyC;CAC3F,IAAIC,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMC,KAAKC,GAAO;EAGrB,AAFA,IAAM,IACFD,EAAE,IAAIL,MAAM,IAAOK,EAAE,IACrBA,EAAE,IAAIJ,MAAM,IAAOI,EAAE;EACzB,IAAME,IAAQF,EAAE,IAAIA,EAAE,OAChBG,IAASH,EAAE,IAAIA,EAAE;EAEvB,AADIE,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB;AASA,SAAgBQ,EAA0C,GAAoB;CAC5E,IAAMC,IAAQC,EAAYC,CAAC;CAC3B,IAAI,CAACF,GAGH,OAAO;EAAE,GAAGE,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CAE5D,IAAIZ,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACLU,IAAoD;EACxD,CAACD,EAAE,GAAGA,EAAE,CAAC;EACT,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,CAAC;EACnB,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,IAAIA,EAAE,MAAM;EAC9B,CAACA,EAAE,GAAGA,EAAE,IAAIA,EAAE,MAAM;CACtB;CACA,KAAK,IAAM,CAACE,GAAIC,MAAOF,GAAS;EAC9B,IAAM,CAACG,GAAIC,KAAMC,EAAaR,GAAOI,GAAIC,CAAE;EAI3C,AAHIC,IAAKhB,MAAM,IAAOgB,IAClBA,IAAKd,MAAM,IAAOc,IAClBC,IAAKhB,MAAM,IAAOgB,IAClBA,IAAKd,MAAM,IAAOc;CACxB;CACA,OAAO;EAAE,GAAGjB;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE;AAUA,SAAgBkB,EACd,GACiB;CACjB,IAAInB,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMgB,KAAQC,GAAO;EACxB,IAAI,CAACD,GAAM;EACX,IAAMR,IAAIH,EAAkBW,CAAI;EAGhC,AAFA,IAAM,IACFR,EAAE,IAAIZ,MAAM,IAAOY,EAAE,IACrBA,EAAE,IAAIX,MAAM,IAAOW,EAAE;EACzB,IAAML,IAAQK,EAAE,IAAIA,EAAE,OAChBJ,IAASI,EAAE,IAAIA,EAAE;EAEvB,AADIL,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB"}

package/dist/core/layers/backgroundFill.js

@@ -0,0 +1,31 @@
+import { commandPaint as e } from "@weasel-js/renderer";
+//#region src/core/layers/backgroundFill.ts
+var t = "scene-background-fill";
+function n(t, n) {
+	let r = {
+		x: 0,
+		y: 0,
+		width: n.width,
+		height: n.height
+	}, i = e(t, r);
+	return i ? [{
+		kind: "path",
+		path: {
+			kind: "rect",
+			...r
+		},
+		fill: { paint: i }
+	}] : [];
+}
+function r(e) {
+	return {
+		id: t,
+		label: "Background fill",
+		space: "screen",
+		draw: (t, r, i) => n(e, i)
+	};
+}
+//#endregion
+export { t as BACKGROUND_FILL_LAYER_ID, n as backgroundFillCommands, r as createBackgroundFillLayer };
+
+//# sourceMappingURL=backgroundFill.js.map

package/dist/core/layers/backgroundFill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backgroundFill.js","names":["BACKGROUND_FILL_LAYER_ID","backgroundFillCommands","rect","size","fill","commandPaint","paint","createBackgroundFillLayer","dims"],"sources":["../../../src/core/layers/backgroundFill.ts"],"sourcesContent":["import { commandPaint, type DrawCommand } from '@weasel-js/renderer';\nimport type { Paint } from '@weasel-js/paint';\nimport type { Dims, RenderLayer } from './render';\n\n/** The id of the layer {@link createBackgroundFillLayer} builds. */\nexport const BACKGROUND_FILL_LAYER_ID = 'scene-background-fill';\n\n/**\n * `paint` filling a `size` rect at the origin, with `'bounds'` units resolved\n * against that rect. Empty when the paint cannot be drawn yet.\n */\nexport function backgroundFillCommands(paint: Paint, size: Dims): DrawCommand[] {\n  const rect = { x: 0, y: 0, width: size.width, height: size.height };\n  const fill = commandPaint(paint, rect);\n  return fill ? [{ kind: 'path', path: { kind: 'rect', ...rect }, fill: { paint: fill } }] : [];\n}\n\n/** A screen-space layer filling the whole surface, whatever the camera. */\nexport function createBackgroundFillLayer(paint: Paint): RenderLayer<unknown> {\n  return {\n    id: BACKGROUND_FILL_LAYER_ID,\n    label: 'Background fill',\n    space: 'screen',\n    draw: (_data, _view, dims) => backgroundFillCommands(paint, dims),\n  };\n}\n"],"mappings":";;AAKA,IAAaA,IAA2B;AAMxC,SAAgBC,EAAuB,GAAc,GAA2B;CAC9E,IAAMC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOC,EAAK;EAAO,QAAQA,EAAK;CAAO,GAC5DC,IAAOC,EAAaC,GAAOJ,CAAI;CACrC,OAAOE,IAAO,CAAC;EAAE,MAAM;EAAQ,MAAM;GAAE,MAAM;GAAQ,GAAGF;EAAK;EAAG,MAAM,EAAE,OAAOE,EAAK;CAAE,CAAC,IAAI,CAAC;AAC9F;AAGA,SAAgBG,EAA0B,GAAoC;CAC5E,OAAO;EACL,IAAIP;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAO,GAAO,MAASC,EAAuBK,GAAOE,CAAI;CAClE;AACF"}

package/dist/{features/groups → core/layers}/children.js

@@ -1,4 +1,4 @@
-//#region src/features/groups/children.ts
+//#region src/core/layers/children.ts
 function e(e) {
 	return {
 		id: e.id ?? "children",
@@ -6,9 +6,7 @@ function e(e) {
 		defaultVisible: e.defaultVisible,
 		alwaysOn: e.alwaysOn,
 		draw: (t, n) => {
-			let r = e.adapter.getChildren;
-			if (!r) return [];
-			let i = r(typeof e.parentId == "function" ? e.parentId() : e.parentId ?? null), a = [];
+			let r = typeof e.parentId == "function" ? e.parentId() : e.parentId ?? null, i = e.adapter.getChildren(r), a = [];
 			for (let r of i) {
 				let i = e.drawChild(r, t, n);
 				for (let e of i) a.push(e);

package/dist/core/layers/children.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"children.js","names":["createChildrenLayer","opts","parent","ids","out","id","sub","data","view","cmd"],"sources":["../../../src/core/layers/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer: a `RenderLayer` factory over an `OrderedAdapter`.\n * Children are drawn in z-order (index 0 = bottom).\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = opts.adapter.getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AA+BA,SAAgBA,EACd,GACoB;CACpB,OAAO;EACL,IAAIC,EAAK,MAAM;EACf,OAAOA,EAAK,SAAS;EACrB,gBAAgBA,EAAK;EACrB,UAAUA,EAAK;EACf,OAAO,GAAM,MAAS;GACpB,IAAMC,IACJ,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,MACjBE,IAAMF,EAAK,QAAQ,YAAYC,CAAM,GACrCE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAMF,GAAK;IACpB,IAAMG,IAAML,EAAK,UAAUI,GAAIE,GAAMC,CAAI;IACzC,KAAK,IAAMC,KAAOH,GAAK,EAAI,KAAKG,CAAG;GACrC;GACA,OAAOL;EACT;CACF;AACF"}

package/dist/{features/focus → core/layers}/gateLayer.js

@@ -1,5 +1,5 @@
-import { subscribeToSources as e } from "../../core/layers/render.js";
-//#region src/features/focus/gateLayer.ts
+import { subscribeToSources as e } from "./render.js";
+//#region src/core/layers/gateLayer.ts
 function t(t) {
 	let { layer: n, visible: r } = t, i = {
 		...n,

package/dist/core/layers/gateLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateLayer.js","names":["gateLayer","opts","wrapped","layer","visible","data","view","dims","deps","hitTest","args","subscribeToSources"],"sources":["../../../src/core/layers/gateLayer.ts"],"sourcesContent":["/**\n * `RenderLayer` wrapper that conditionally emits draw commands based on a\n * predicate.\n *\n * A rule that chrome-caps can express belongs there, since it gates the\n * hit-test as well as the paint. This is for layers outside its vocabulary.\n */\nimport { subscribeToSources, type RenderLayer } from './render';\n\n/** Options for `gateLayer`. */\nexport interface GateLayerOptions<TData> {\n  /** The wrapped layer. Everything but `draw`, `hitTest`, and `deps` flows\n   *  through unchanged. */\n  layer: RenderLayer<TData>;\n  /** Returns `true` to render the layer this frame, `false` to skip. */\n  visible: () => boolean;\n}\n\n/** Wrap a render layer so it only draws, and is only hit, while `visible()`\n *  is true. The predicate is consulted per frame. */\nexport function gateLayer<TData>(opts: GateLayerOptions<TData>): RenderLayer<TData> {\n  const { layer, visible } = opts;\n  const wrapped: RenderLayer<TData> = {\n    ...layer,\n    draw: (data, view, dims) => (visible() ? layer.draw(data, view, dims) : []),\n  };\n  const { deps, hitTest } = layer;\n  if (deps) wrapped.deps = (data, view, dims) => [visible(), ...deps(data, view, dims)];\n  if (hitTest) wrapped.hitTest = (...args) => (visible() ? hitTest(...args) : null);\n  if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);\n  return wrapped;\n}\n"],"mappings":";;AAoBA,SAAgBA,EAAiB,GAAmD;CAClF,IAAM,EAAE,UAAO,eAAYC,GACrBC,IAA8B;EAClC,GAAGC;EACH,OAAO,GAAM,GAAM,MAAUC,EAAQ,IAAID,EAAM,KAAKE,GAAMC,GAAMC,CAAI,IAAI,CAAC;CAC3E,GACM,EAAE,SAAM,eAAYJ;CAI1B,OAHIK,MAAM,EAAQ,QAAQ,GAAM,GAAM,MAAS,CAACJ,EAAQ,GAAG,GAAGI,EAAKH,GAAMC,GAAMC,CAAI,CAAC,IAChFE,MAAS,EAAQ,WAAW,GAAGC,MAAUN,EAAQ,IAAIK,EAAQ,GAAGC,CAAI,IAAI,OACxEP,EAAM,cAAW,EAAQ,YAAYQ,EAAmB,CAACR,CAAK,CAAC,IAC5DD;AACT"}