@weasel-js/core 1.10.0 → 1.11.0

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","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 * 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 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  const drawn = silhouette ? pose : outline();\n  if (!filled()) return polygonIntersectsPath(region.verts, drawn, { filled: false });\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":"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"}
+{"version":3,"file":"regionHit.js","names":[],"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

@@ -1,94 +1,118 @@
-import { applyToPoint as e, invert as t, poseFrameOf as n } from "@weasel-js/geom";
+import { applyToPoint, invert, poseFrameOf } from "@weasel-js/geom";
+
 //#region src/core/geometry/targetFrame.ts
-var r = [
+/**
+* The frame selection chrome reads a target in: `poseFrameOf` over the
+* target's bounds, with the helpers the outline, the handles, their hit
+* regions, and the resize and rotate actions all place themselves by.
+*/
+var IDENTITY = [
 	1,
 	0,
 	0,
 	1,
 	0,
 	0
-], i = {
-	identity: !0,
-	toWorld: r,
-	toLocal: r
+];
+var IDENTITY_TARGET = {
+	identity: true,
+	toWorld: IDENTITY,
+	toLocal: IDENTITY
 };
-function a(e) {
-	let r = n(e);
-	return r ? {
-		identity: !1,
-		toWorld: r,
-		toLocal: t(r)
-	} : i;
+/** The frame `bounds` is drawn in: its `rotation`, its `transform`, or both. */
+function targetTransformOf(bounds) {
+	const toWorld = poseFrameOf(bounds);
+	if (!toWorld) return IDENTITY_TARGET;
+	return {
+		identity: false,
+		toWorld,
+		toLocal: invert(toWorld)
+	};
 }
-function o(e) {
-	return e.identity ? 0 : Math.atan2(e.toWorld[1], e.toWorld[0]);
+/** How far the target's x axis is turned from world's, radians. */
+function angleOf(xf) {
+	return xf.identity ? 0 : Math.atan2(xf.toWorld[1], xf.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;
+/** Whether the frame only turns the target: no skew, no stretch, no flip. */
+function isRigid(xf) {
+	if (xf.identity) return true;
+	const [a, b, c, d] = xf.toWorld;
+	return Math.abs(a - d) < 1e-9 && Math.abs(b + c) < 1e-9 && Math.abs(a * a + b * b - 1) < 1e-9;
 }
-function c(t, n, r) {
-	if (t.identity) return {
-		x: n,
-		y: r
+/** local point → world point. */
+function localToWorld(xf, lx, ly) {
+	if (xf.identity) return {
+		x: lx,
+		y: ly
 	};
-	let [i, a] = e(t.toWorld, n, r);
+	const [x, y] = applyToPoint(xf.toWorld, lx, ly);
 	return {
-		x: i,
-		y: a
+		x,
+		y
 	};
 }
-function l(t, n, r) {
-	if (t.identity) return {
-		x: n,
-		y: r
+/** world point → local point; `null` where nothing maps back. */
+function worldToLocal(xf, wx, wy) {
+	if (xf.identity) return {
+		x: wx,
+		y: wy
 	};
-	if (!t.toLocal) return null;
-	let [i, a] = e(t.toLocal, n, r);
+	if (!xf.toLocal) return null;
+	const [x, y] = applyToPoint(xf.toLocal, wx, wy);
 	return {
-		x: i,
-		y: a
+		x,
+		y
 	};
 }
-function u(e, t, n) {
-	if (e.identity) return {
-		x: t,
-		y: n
+/** A world delta in the target's own axes; `null` where nothing maps back. */
+function worldDeltaToLocal(xf, dx, dy) {
+	if (xf.identity) return {
+		x: dx,
+		y: dy
 	};
-	let r = e.toLocal;
-	return r && {
-		x: r[0] * t + r[2] * n,
-		y: r[1] * t + r[3] * n
+	const m = xf.toLocal;
+	return m && {
+		x: m[0] * dx + m[2] * dy,
+		y: m[1] * dx + m[3] * dy
 	};
 }
-function d(e, t) {
-	if (e.identity) return t;
-	let [n, r, i, a] = e.toWorld, o = Math.sign(n * a - r * i) || 1;
+/** A local edge's outward normal as a world direction, unnormalized. A normal
+*  goes through the inverse transpose, so it stays square to a skewed edge. */
+function normalToWorld(xf, n) {
+	if (xf.identity) return n;
+	const [a, b, c, d] = xf.toWorld;
+	const k = Math.sign(a * d - b * c) || 1;
 	return {
-		x: (a * t.x - r * t.y) * o,
-		y: (n * t.y - i * t.x) * o
+		x: (d * n.x - b * n.y) * k,
+		y: (a * n.y - c * n.x) * k
 	};
 }
-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 ? {
+/** `pxExtent` along the target's own axes: how far along each an edge across
+*  it must move to move `px` on screen. */
+function pxExtentIn(px, scale, xf) {
+	const [a, b, c, d] = xf.toWorld;
+	const ux = a * scale.x, uy = b * scale.y;
+	const vx = c * scale.x, vy = d * scale.y;
+	const det = Math.abs(ux * vy - uy * vx);
+	if (det === 0) return {
 		x: 0,
 		y: 0
-	} : {
-		x: e * Math.hypot(l, u) / d,
-		y: e * Math.hypot(s, c) / d
+	};
+	return {
+		x: px * Math.hypot(vx, vy) / det,
+		y: px * Math.hypot(ux, uy) / det
 	};
 }
-function p(e, t) {
+/** The target's box corners in world, TL/TR/BR/BL. */
+function targetCorners(b, xf) {
 	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)
+		localToWorld(xf, b.x, b.y),
+		localToWorld(xf, b.x + b.width, b.y),
+		localToWorld(xf, b.x + b.width, b.y + b.height),
+		localToWorld(xf, b.x, b.y + b.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 };
 
+//#endregion
+export { IDENTITY_TARGET, angleOf, isRigid, localToWorld, normalToWorld, pxExtentIn, targetCorners, targetTransformOf, worldDeltaToLocal, worldToLocal };
 //# sourceMappingURL=targetFrame.js.map

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

@@ -1 +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 Mat3, 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: Mat3;\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: Mat3 | null;\n}\n\nconst IDENTITY: Mat3 = [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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"}
+{"version":3,"file":"targetFrame.js","names":[],"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":";;;;;;;;AAmBA,IAAM,WAAmB;CAAC;CAAG;CAAG;CAAG;CAAG;CAAG;AAAC;AAE1C,IAAa,kBAAmC;CAAE,UAAU;CAAM,SAAS;CAAU,SAAS;AAAS;;AAGvG,SAAgB,kBAAkB,QAAkC;CAClE,MAAM,UAAU,YAAY,MAAM;CAClC,IAAI,CAAC,SAAS,OAAO;CACrB,OAAO;EAAE,UAAU;EAAO;EAAS,SAAS,OAAO,OAAO;CAAE;AAC9D;;AAGA,SAAgB,QAAQ,IAA6B;CACnD,OAAO,GAAG,WAAW,IAAI,KAAK,MAAM,GAAG,QAAQ,IAAI,GAAG,QAAQ,EAAE;AAClE;;AAGA,SAAgB,QAAQ,IAA8B;CACpD,IAAI,GAAG,UAAU,OAAO;CACxB,MAAM,CAAC,GAAG,GAAG,GAAG,KAAK,GAAG;CACxB,OAAO,KAAK,IAAI,IAAI,CAAC,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,IAAI,QAAQ,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI;AAC3F;;AAGA,SAAgB,aAAa,IAAqB,IAAY,IAAsC;CAClG,IAAI,GAAG,UAAU,OAAO;EAAE,GAAG;EAAI,GAAG;CAAG;CACvC,MAAM,CAAC,GAAG,KAAK,aAAa,GAAG,SAAS,IAAI,EAAE;CAC9C,OAAO;EAAE;EAAG;CAAE;AAChB;;AAGA,SAAgB,aAAa,IAAqB,IAAY,IAA6C;CACzG,IAAI,GAAG,UAAU,OAAO;EAAE,GAAG;EAAI,GAAG;CAAG;CACvC,IAAI,CAAC,GAAG,SAAS,OAAO;CACxB,MAAM,CAAC,GAAG,KAAK,aAAa,GAAG,SAAS,IAAI,EAAE;CAC9C,OAAO;EAAE;EAAG;CAAE;AAChB;;AAGA,SAAgB,kBAAkB,IAAqB,IAAY,IAA6C;CAC9G,IAAI,GAAG,UAAU,OAAO;EAAE,GAAG;EAAI,GAAG;CAAG;CACvC,MAAM,IAAI,GAAG;CACb,OAAO,KAAK;EAAE,GAAG,EAAE,KAAK,KAAK,EAAE,KAAK;EAAI,GAAG,EAAE,KAAK,KAAK,EAAE,KAAK;CAAG;AACnE;;;AAIA,SAAgB,cAAc,IAAqB,GAAuD;CACxG,IAAI,GAAG,UAAU,OAAO;CACxB,MAAM,CAAC,GAAG,GAAG,GAAG,KAAK,GAAG;CACxB,MAAM,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK;CACtC,OAAO;EAAE,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE,KAAK;EAAG,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE,KAAK;CAAE;AAClE;;;AAIA,SAAgB,WAAW,IAAY,OAAe,IAA+C;CACnG,MAAM,CAAC,GAAG,GAAG,GAAG,KAAK,GAAG;CACxB,MAAM,KAAK,IAAI,MAAM,GAAG,KAAK,IAAI,MAAM;CACvC,MAAM,KAAK,IAAI,MAAM,GAAG,KAAK,IAAI,MAAM;CACvC,MAAM,MAAM,KAAK,IAAI,KAAK,KAAK,KAAK,EAAE;CACtC,IAAI,QAAQ,GAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;CACnC,OAAO;EAAE,GAAI,KAAK,KAAK,MAAM,IAAI,EAAE,IAAK;EAAK,GAAI,KAAK,KAAK,MAAM,IAAI,EAAE,IAAK;CAAI;AAClF;;AAGA,SAAgB,cACd,GACA,IAC4B;CAC5B,OAAO;EACL,aAAa,IAAI,EAAE,GAAG,EAAE,CAAC;EACzB,aAAa,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;EACnC,aAAa,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM;EAC9C,aAAa,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM;CACtC;AACF"}

package/dist/core/geometry/unionBounds.js

@@ -1,61 +1,116 @@
-import { applyToPoint as e, poseFrameOf as t } from "@weasel-js/geom";
+import { applyToPoint, poseFrameOf } from "@weasel-js/geom";
+
 //#region src/core/geometry/unionBounds.ts
-function n(e) {
-	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity, a = !1;
-	for (let o of e) {
-		a = !0, o.x < t && (t = o.x), o.y < n && (n = o.y);
-		let e = o.x + o.width, s = o.y + o.height;
-		e > r && (r = e), s > i && (i = s);
+/**
+* Union math over rect-shaped poses.
+*
+* Two answers, deliberately distinct. `unionBounds` folds the *unrotated*
+* boxes and is what commit-time actions want, because they go on to write
+* poses back in that same frame. `unionAABB` expands each rotated member to
+* the extent of its ink first, and is what anything a user looks at or clicks
+* wants — selection chrome, gesture bounds, an export viewBox. Folding the
+* unrotated box there under-reports the extent of a rotated member exactly
+* when the consumer is watching it move.
+*/
+/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any
+*  rotation they carry. See the module docstring before reaching for this
+*  over {@link unionAABB}. */
+function unionBounds(poses) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let any = false;
+	for (const p of poses) {
+		any = true;
+		if (p.x < minX) minX = p.x;
+		if (p.y < minY) minY = p.y;
+		const right = p.x + p.width;
+		const bottom = p.y + p.height;
+		if (right > maxX) maxX = right;
+		if (bottom > maxY) maxY = bottom;
 	}
-	return a ? {
-		x: t,
-		y: n,
-		width: r - t,
-		height: i - n
-	} : null;
+	if (!any) return null;
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
 }
-function r(n) {
-	let r = t(n);
-	if (!r) return {
-		x: n.x,
-		y: n.y,
-		width: n.width,
-		height: n.height
+/**
+* Axis-align a pose that carries a `rotation` or a `transform`: returns the
+* AABB of the box as drawn, its four corners through `poseFrameOf`, with both
+* fields dropped.
+*
+* A pose with neither is returned as-is.
+*/
+function axisAlignedBounds(b) {
+	const frame = poseFrameOf(b);
+	if (!frame) return {
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
 	};
-	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity, c = [
-		[n.x, n.y],
-		[n.x + n.width, n.y],
-		[n.x + n.width, n.y + n.height],
-		[n.x, n.y + n.height]
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const corners = [
+		[b.x, b.y],
+		[b.x + b.width, b.y],
+		[b.x + b.width, b.y + b.height],
+		[b.x, b.y + b.height]
 	];
-	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);
+	for (const [px, py] of corners) {
+		const [rx, ry] = applyToPoint(frame, px, py);
+		if (rx < minX) minX = rx;
+		if (rx > maxX) maxX = rx;
+		if (ry < minY) minY = ry;
+		if (ry > maxY) maxY = ry;
 	}
 	return {
-		x: i,
-		y: a,
-		width: o - i,
-		height: s - a
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
 	};
 }
-function i(e) {
-	let t = Infinity, n = Infinity, i = -Infinity, a = -Infinity, o = !1;
-	for (let s of e) {
-		if (!s) continue;
-		let e = r(s);
-		o = !0, e.x < t && (t = e.x), e.y < n && (n = e.y);
-		let c = e.x + e.width, l = e.y + e.height;
-		c > i && (i = c), l > a && (a = l);
+/**
+* Fold every part into one world-space AABB, skipping `null` / `undefined`
+* entries. Rotated parts are expanded via {@link axisAlignedBounds} first;
+* the result never carries a `rotation` (a union of several oriented boxes
+* has no single orientation to report).
+*
+* Returns `null` when nothing was contributed.
+*/
+function unionAABB(parts) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let any = false;
+	for (const part of parts) {
+		if (!part) continue;
+		const b = axisAlignedBounds(part);
+		any = true;
+		if (b.x < minX) minX = b.x;
+		if (b.y < minY) minY = b.y;
+		const right = b.x + b.width;
+		const bottom = b.y + b.height;
+		if (right > maxX) maxX = right;
+		if (bottom > maxY) maxY = bottom;
 	}
-	return o ? {
-		x: t,
-		y: n,
-		width: i - t,
-		height: a - n
-	} : null;
+	if (!any) return null;
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
 }
-//#endregion
-export { r as axisAlignedBounds, i as unionAABB, n as unionBounds };
 
+//#endregion
+export { axisAlignedBounds, unionAABB, unionBounds };
 //# sourceMappingURL=unionBounds.js.map

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 '@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"}
+{"version":3,"file":"unionBounds.js","names":[],"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/geometry/rectPose';\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,SAAgB,YAAoC,OAAyC;CAC3F,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,MAAM;CACV,KAAK,MAAM,KAAK,OAAO;EACrB,MAAM;EACN,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,MAAM,QAAQ,EAAE,IAAI,EAAE;EACtB,MAAM,SAAS,EAAE,IAAI,EAAE;EACvB,IAAI,QAAQ,MAAM,OAAO;EACzB,IAAI,SAAS,MAAM,OAAO;CAC5B;CACA,IAAI,CAAC,KAAK,OAAO;CACjB,OAAO;EAAE,GAAG;EAAM,GAAG;EAAM,OAAO,OAAO;EAAM,QAAQ,OAAO;CAAK;AACrE;;;;;;;;AASA,SAAgB,kBAA0C,GAAoB;CAC5E,MAAM,QAAQ,YAAY,CAAC;CAC3B,IAAI,CAAC,OAGH,OAAO;EAAE,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG,OAAO,EAAE;EAAO,QAAQ,EAAE;CAAO;CAE5D,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,MAAM,UAAoD;EACxD,CAAC,EAAE,GAAG,EAAE,CAAC;EACT,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;EACnB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM;EAC9B,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM;CACtB;CACA,KAAK,MAAM,CAAC,IAAI,OAAO,SAAS;EAC9B,MAAM,CAAC,IAAI,MAAM,aAAa,OAAO,IAAI,EAAE;EAC3C,IAAI,KAAK,MAAM,OAAO;EACtB,IAAI,KAAK,MAAM,OAAO;EACtB,IAAI,KAAK,MAAM,OAAO;EACtB,IAAI,KAAK,MAAM,OAAO;CACxB;CACA,OAAO;EAAE,GAAG;EAAM,GAAG;EAAM,OAAO,OAAO;EAAM,QAAQ,OAAO;CAAK;AACrE;;;;;;;;;AAUA,SAAgB,UACd,OACiB;CACjB,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,MAAM;CACV,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,CAAC,MAAM;EACX,MAAM,IAAI,kBAAkB,IAAI;EAChC,MAAM;EACN,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,IAAI,EAAE,IAAI,MAAM,OAAO,EAAE;EACzB,MAAM,QAAQ,EAAE,IAAI,EAAE;EACtB,MAAM,SAAS,EAAE,IAAI,EAAE;EACvB,IAAI,QAAQ,MAAM,OAAO;EACzB,IAAI,SAAS,MAAM,OAAO;CAC5B;CACA,IAAI,CAAC,KAAK,OAAO;CACjB,OAAO;EAAE,GAAG;EAAM,GAAG;EAAM,OAAO,OAAO;EAAM,QAAQ,OAAO;CAAK;AACrE"}

package/dist/core/isPlainObject.js

@@ -1,2 +1,3 @@
-import { isPlainObject as e, isPlainPrototype as t } from "@weasel-js/registry";
-export { e as isPlainObject, t as isPlainPrototype };
+import { isPlainObject, isPlainPrototype } from "@weasel-js/registry";
+
+export { isPlainObject, isPlainPrototype };

package/dist/core/layers/backgroundFill.js

@@ -1,31 +1,39 @@
-import { commandPaint as e } from "@weasel-js/renderer";
+import { commandPaint } from "@weasel-js/renderer";
+
 //#region src/core/layers/backgroundFill.ts
-var t = "scene-background-fill";
-function n(t, n) {
-	let r = {
+/** The id of the layer {@link createBackgroundFillLayer} builds. */
+var BACKGROUND_FILL_LAYER_ID = "scene-background-fill";
+/**
+* `paint` filling a `size` rect at the origin, with `'bounds'` units resolved
+* against that rect. Empty when the paint cannot be drawn yet.
+*/
+function backgroundFillCommands(paint, size) {
+	const rect = {
 		x: 0,
 		y: 0,
-		width: n.width,
-		height: n.height
-	}, i = e(t, r);
-	return i ? [{
+		width: size.width,
+		height: size.height
+	};
+	const fill = commandPaint(paint, rect);
+	return fill ? [{
 		kind: "path",
 		path: {
 			kind: "rect",
-			...r
+			...rect
 		},
-		fill: { paint: i }
+		fill: { paint: fill }
 	}] : [];
 }
-function r(e) {
+/** A screen-space layer filling the whole surface, whatever the camera. */
+function createBackgroundFillLayer(paint) {
 	return {
-		id: t,
+		id: BACKGROUND_FILL_LAYER_ID,
 		label: "Background fill",
 		space: "screen",
-		draw: (t, r, i) => n(e, i)
+		draw: (_data, _view, dims) => backgroundFillCommands(paint, dims)
 	};
 }
-//#endregion
-export { t as BACKGROUND_FILL_LAYER_ID, n as backgroundFillCommands, r as createBackgroundFillLayer };
 
+//#endregion
+export { BACKGROUND_FILL_LAYER_ID, backgroundFillCommands, createBackgroundFillLayer };
 //# sourceMappingURL=backgroundFill.js.map

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

@@ -1 +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"}
+{"version":3,"file":"backgroundFill.js","names":[],"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,IAAa,2BAA2B;;;;;AAMxC,SAAgB,uBAAuB,OAAc,MAA2B;CAC9E,MAAM,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAO,KAAK;EAAO,QAAQ,KAAK;CAAO;CAClE,MAAM,OAAO,aAAa,OAAO,IAAI;CACrC,OAAO,OAAO,CAAC;EAAE,MAAM;EAAQ,MAAM;GAAE,MAAM;GAAQ,GAAG;EAAK;EAAG,MAAM,EAAE,OAAO,KAAK;CAAE,CAAC,IAAI,CAAC;AAC9F;;AAGA,SAAgB,0BAA0B,OAAoC;CAC5E,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,OAAO,OAAO,SAAS,uBAAuB,OAAO,IAAI;CAClE;AACF"}

package/dist/core/layers/children.js

@@ -1,23 +1,24 @@
 //#region src/core/layers/children.ts
-function e(e) {
+/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */
+function createChildrenLayer(opts) {
 	return {
-		id: e.id ?? "children",
-		label: e.label ?? "Children",
-		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 = [];
-			for (let r of i) {
-				let i = e.drawChild(r, t, n);
-				for (let e of i) a.push(e);
+		id: opts.id ?? "children",
+		label: opts.label ?? "Children",
+		defaultVisible: opts.defaultVisible,
+		alwaysOn: opts.alwaysOn,
+		draw: (data, view) => {
+			const parent = typeof opts.parentId === "function" ? opts.parentId() : opts.parentId ?? null;
+			const ids = opts.adapter.getChildren(parent);
+			const out = [];
+			for (const id of ids) {
+				const sub = opts.drawChild(id, data, view);
+				for (const cmd of sub) out.push(cmd);
 			}
-			return a;
+			return out;
 		}
 	};
 }
-//#endregion
-export { e as createChildrenLayer };
 
+//#endregion
+export { createChildrenLayer };
 //# sourceMappingURL=children.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"children.js","names":["createChildrenLayer","opts","getChildren","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). If the adapter doesn't\n * implement `getChildren`, the layer is a silent no-op.\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 getChildren = opts.adapter.getChildren;\n      if (!getChildren) return [];\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = 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":";AAgCA,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,IAAcD,EAAK,QAAQ;GACjC,IAAI,CAACC,GAAa,OAAO,CAAC;GAK1B,IAAMC,IAAMD,EAHV,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,IACO,GACxBG,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"}
+{"version":3,"file":"children.js","names":[],"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,SAAgB,oBACd,MACoB;CACpB,OAAO;EACL,IAAI,KAAK,MAAM;EACf,OAAO,KAAK,SAAS;EACrB,gBAAgB,KAAK;EACrB,UAAU,KAAK;EACf,OAAO,MAAM,SAAS;GACpB,MAAM,SACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,IACd,KAAK,YAAY;GACvB,MAAM,MAAM,KAAK,QAAQ,YAAY,MAAM;GAC3C,MAAM,MAAqB,CAAC;GAC5B,KAAK,MAAM,MAAM,KAAK;IACpB,MAAM,MAAM,KAAK,UAAU,IAAI,MAAM,IAAI;IACzC,KAAK,MAAM,OAAO,KAAK,IAAI,KAAK,GAAG;GACrC;GACA,OAAO;EACT;CACF;AACF"}