@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/geometry/regionHit.js

@@ -1,99 +1,147 @@
-import { nodeMemo as e } from "../scene/nodeMemo.js";
-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";
+import { nodeMemo } from "../scene/nodeMemo.js";
+import { visualBoundsViaDescriptor } from "./poseDescriptor.js";
+import { boxContainsBox, pathThroughPoseFrame, pointInPolygon, polygonContainsPath, polygonIntersectsPath, poseFrameOf } from "@weasel-js/geom";
+
 //#region src/core/geometry/regionHit.ts
-function c(e) {
-	let { x: t, y: n, width: r, height: i } = e;
-	return l([
-		t,
-		n,
-		t + r,
-		n,
-		t + r,
-		n + i,
-		t,
-		n + i
+/**
+* Whether a marquee or a lasso takes one node: the per-node decision the
+* scene's area walk (`canvas/deps/hitTestArea`) makes.
+*
+* What a node draws is not knowable here — the painters sit above `core/` — so
+* the caller hands in the node's outline as a thunk, asked for only when the
+* bounds cannot decide. A pose that is itself a polygon path is its own
+* outline and never asks.
+*/
+/** A marquee's region. */
+function rectRegion(r) {
+	const { x, y, width: w, height: h } = r;
+	return regionOf([
+		x,
+		y,
+		x + w,
+		y,
+		x + w,
+		y + h,
+		x,
+		y + h
 	], {
-		x: t,
-		y: n,
-		width: r,
-		height: i
-	}, !0);
+		x,
+		y,
+		width: w,
+		height: h
+	}, true);
 }
-function l(e, t, n = !1) {
-	let r = [], i = [], a = Infinity, o = Infinity, s = -Infinity, c = -Infinity;
-	for (let t = 0; t + 1 < e.length; t += 2) {
-		let n = e[t], l = e[t + 1];
-		r.push({
-			x: n,
-			y: l
-		}), i.push(n, l), n < a && (a = n), l < o && (o = l), n > s && (s = n), l > c && (c = l);
+/** A region from interleaved coords. `bounds` is derived when omitted; `null`
+*  when there are no coords to bound. */
+function regionOf(coords, bounds, isRect = false) {
+	const verts = [];
+	const flat = [];
+	let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+	for (let i = 0; i + 1 < coords.length; i += 2) {
+		const x = coords[i], y = coords[i + 1];
+		verts.push({
+			x,
+			y
+		});
+		flat.push(x, y);
+		if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		if (x > maxX) maxX = x;
+		if (y > maxY) maxY = y;
 	}
-	return r.length === 0 ? null : {
-		verts: r,
-		coords: i,
-		bounds: t ?? {
-			x: a,
-			y: o,
-			width: s - a,
-			height: c - o
+	if (verts.length === 0) return null;
+	return {
+		verts,
+		coords: flat,
+		bounds: bounds ?? {
+			x: minX,
+			y: minY,
+			width: maxX - minX,
+			height: maxY - minY
 		},
-		isRect: n
+		isRect
 	};
 }
-function u(e) {
-	if (e.length < 3) return null;
-	let t = [];
-	for (let n of e) t.push(n.x, n.y);
-	return l(t);
+/** A lasso's region, or `null` for fewer than three vertices. */
+function polygonRegion(polygon) {
+	if (polygon.length < 3) return null;
+	const coords = [];
+	for (const p of polygon) coords.push(p.x, p.y);
+	return regionOf(coords);
 }
-function d(e) {
-	return typeof e == "object" && !!e && e.kind === "polygon";
+/** A pose that is its own drawn outline. */
+function isSilhouettePose(pose) {
+	return pose !== null && typeof pose === "object" && pose.kind === "polygon";
 }
-function f(n, r, i) {
-	return d(r) ? e(n, "aabb", r, () => i.getBounds(r)) : t(r, i);
+/**
+* The box a region fast-rejects a node against: a silhouette pose's own bounds,
+* else the pose's visual bounds — which for a rotated pose is the box of its
+* rotated ink, reaching past the pose box. `g` is the node's descriptor.
+*/
+function regionBoundsOf(node, pose, g) {
+	return isSilhouettePose(pose) ? nodeMemo(node, "aabb", pose, () => g.getBounds(pose)) : visualBoundsViaDescriptor(pose, g);
 }
-function p(e, t) {
-	if (s(e)) {
-		let t = e;
-		return r({
+/** The outline of a node nothing paints: its pose rect through the pose's
+*  frame, else its visual bounds `b`. */
+function poseOutline(pose, b) {
+	if (poseFrameOf(pose)) {
+		const p = pose;
+		return pathThroughPoseFrame({
 			kind: "rect",
-			x: t.x,
-			y: t.y,
-			width: t.width,
-			height: t.height
-		}, e);
+			x: p.x,
+			y: p.y,
+			width: p.width,
+			height: p.height
+		}, pose);
 	}
 	return {
 		kind: "rect",
-		x: t.x,
-		y: t.y,
-		width: t.width,
-		height: t.height
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.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
+/**
+* Whether `region` takes a node under `mode`, given its pose, its bounds `b`
+* from {@link regionBoundsOf}, and its drawn outline on demand.
+*
+* - `intersect` — the outline meets the region anywhere: its interior too,
+*   unless `filled` says nothing paints it.
+* - `enclosed` — the whole outline lies inside it.
+* - `centers` — the center of `b` lies inside it.
+*
+* `b` only rejects: it encloses the outline and may reach past it, so a node
+* is taken by the outline alone. A node without finite bounds is never taken.
+*/
+function regionTakes(region, mode, pose, b, outline, filled = () => true) {
+	if (!Number.isFinite(b.x) || !Number.isFinite(b.y) || !Number.isFinite(b.width) || !Number.isFinite(b.height)) return false;
+	const ab = region.bounds;
+	if (b.x >= ab.x + ab.width || b.x + b.width <= ab.x || b.y >= ab.y + ab.height || b.y + b.height <= ab.y) return false;
+	if (mode === "centers") return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);
+	const inBox = boxContainsBox([
+		ab.x,
+		ab.y,
+		ab.x + ab.width,
+		ab.y + ab.height
 	], [
-		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 });
+		b.x,
+		b.y,
+		b.x + b.width,
+		b.y + b.height
+	]);
+	const silhouette = isSilhouettePose(pose);
+	if (mode === "enclosed") {
+		if (silhouette && !inBox) return false;
+		return polygonContainsPath(region.verts, silhouette ? pose : outline());
+	}
+	if (region.isRect && inBox) return true;
+	const drawn = silhouette ? pose : outline();
+	if (!filled()) return polygonIntersectsPath(region.verts, drawn, { filled: false });
+	if (drawn.kind === "rect" && region.isRect) return drawn.x < ab.x + ab.width && drawn.x + drawn.width > ab.x && drawn.y < ab.y + ab.height && drawn.y + drawn.height > ab.y;
+	return polygonIntersectsPath(region.verts, drawn);
 }
-//#endregion
-export { d as isSilhouettePose, u as polygonRegion, p as poseOutline, c as rectRegion, f as regionBoundsOf, l as regionOf, m as regionTakes };
 
+//#endregion
+export { isSilhouettePose, polygonRegion, poseOutline, rectRegion, regionBoundsOf, regionOf, regionTakes };
 //# sourceMappingURL=regionHit.js.map

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 * `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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"}
+{"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 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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"}
+{"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"}