@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/geometry/autoPoseDescriptor.js

@@ -1,32 +1,46 @@
-import { pathPoseDescriptor as e } from "./pathPoseDescriptor.js";
-import { RECT_POSE_DESCRIPTOR as t } from "./poseDescriptor.js";
+import { RECT_POSE_DESCRIPTOR } from "./poseDescriptor.js";
+import { pathPoseDescriptor } from "./pathPoseDescriptor.js";
+
 //#region src/core/geometry/autoPoseDescriptor.ts
-function n(e) {
-	return !!e && typeof e == "object" && "kind" in e && (e.kind === "polygon" || e.kind === "rect");
+/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
+*  callers that need to fork between `pathPoseDescriptor` and
+*  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire
+*  `poseDescriptor` explicitly. */
+function isPathLike(p) {
+	return !!p && typeof p === "object" && "kind" in p && (p.kind === "polygon" || p.kind === "rect");
 }
-function r(e) {
-	if (!e || typeof e != "object") return !1;
-	let t = e;
-	return typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number";
+/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only
+*  shape the rect descriptor and the kit's built-in painters can read. */
+function isRectPose(p) {
+	if (!p || typeof p !== "object") return false;
+	const r = p;
+	return typeof r.x === "number" && typeof r.y === "number" && typeof r.width === "number" && typeof r.height === "number";
 }
-var i = {
-	getBounds: (r) => n(r) ? e.getBounds(r) : t.getBounds(r),
-	remapBounds: (r, i, a) => n(r) ? e.remapBounds(r, i, a) : t.remapBounds(r, i, a),
-	fromBounds: (r, i) => n(i) ? e.fromBounds(r, i) : t.fromBounds(r, i),
-	translate: (r, i, a) => n(r) ? e.translate(r, i, a) : t.translate(r, i, a),
-	axes: (i) => r(i) ? t.axes(i) : n(i) ? e.axes(i) : null,
-	getRotation: (e) => {
-		if (n(e)) return 0;
-		let t = e.rotation;
-		return typeof t == "number" ? t : 0;
+/** Per-call dispatch: if the pose looks like a Path, route to
+*  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing
+*  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`
+*  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses
+*  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to
+*  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated
+*  selection chrome and rotation-aware corner hit-tests. */
+var AUTO_POSE_DESCRIPTOR = {
+	getBounds: (p) => isPathLike(p) ? pathPoseDescriptor.getBounds(p) : RECT_POSE_DESCRIPTOR.getBounds(p),
+	remapBounds: (p, src, dst) => isPathLike(p) ? pathPoseDescriptor.remapBounds(p, src, dst) : RECT_POSE_DESCRIPTOR.remapBounds(p, src, dst),
+	fromBounds: (b, template) => isPathLike(template) ? pathPoseDescriptor.fromBounds(b, template) : RECT_POSE_DESCRIPTOR.fromBounds(b, template),
+	translate: (p, dx, dy) => isPathLike(p) ? pathPoseDescriptor.translate(p, dx, dy) : RECT_POSE_DESCRIPTOR.translate(p, dx, dy),
+	axes: (p) => isRectPose(p) ? RECT_POSE_DESCRIPTOR.axes(p) : isPathLike(p) ? pathPoseDescriptor.axes(p) : null,
+	getRotation: (p) => {
+		if (isPathLike(p)) return 0;
+		const r = p.rotation;
+		return typeof r === "number" ? r : 0;
 	},
-	supportsRotation: (e) => !n(e),
-	withRotation: (e, t) => n(e) ? e : {
-		...e,
-		rotation: t
+	supportsRotation: (p) => !isPathLike(p),
+	withRotation: (p, rotation) => isPathLike(p) ? p : {
+		...p,
+		rotation
 	}
 };
-//#endregion
-export { i as AUTO_POSE_DESCRIPTOR, n as isPathLike, r as isRectPose };
 
+//#endregion
+export { AUTO_POSE_DESCRIPTOR, isPathLike, isRectPose };
 //# sourceMappingURL=autoPoseDescriptor.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"autoPoseDescriptor.js","names":["isPathLike","p","isRectPose","r","AUTO_POSE_DESCRIPTOR","pathPoseDescriptor","RECT_POSE_DESCRIPTOR","src","dst","template","b","dx","dy"],"sources":["../../../src/core/geometry/autoPoseDescriptor.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { pathPoseDescriptor } from './pathPoseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from './poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire\n *  `poseDescriptor` explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only\n *  shape the rect descriptor and the kit's built-in painters can read. */\nexport function isRectPose(p: unknown): p is { x: number; y: number; width: number; height: number; rotation?: number } {\n  if (!p || typeof p !== 'object') return false;\n  const r = p as Record<string, unknown>;\n  return typeof r.x === 'number' && typeof r.y === 'number'\n    && typeof r.width === 'number' && typeof r.height === 'number';\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`\n *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses\n *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to\n *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated\n *  selection chrome and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  fromBounds: (b, template) => isPathLike(template)\n    ? pathPoseDescriptor.fromBounds(b, template)\n    : RECT_POSE_DESCRIPTOR.fromBounds(b, template as Bounds),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  axes: (p) => (isRectPose(p)\n    ? RECT_POSE_DESCRIPTOR.axes!(p) as never\n    : isPathLike(p) ? pathPoseDescriptor.axes!(p) as never : null),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n  withRotation: (p, rotation) => isPathLike(p) ? p : { ...(p as object), rotation },\n};\n"],"mappings":";;;AASA,SAAgBA,EAAW,GAAuB;CAChD,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,UAAUA,MAC1CA,EAAwB,SAAS,aAAcA,EAAwB,SAAS;AACzF;AAIA,SAAgBC,EAAW,GAA6F;CACtH,IAAI,CAACD,KAAK,OAAOA,KAAM,UAAU,OAAO;CACxC,IAAME,IAAIF;CACV,OAAO,OAAOE,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAC5C,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW;AAC1D;AASA,IAAaC,IAAgD;CAC3D,YAAY,MAAMJ,EAAWC,CAAC,IAC1BI,EAAmB,UAAUJ,CAAC,IAC9BK,EAAqB,UAAUL,CAA4D;CAC/F,cAAc,GAAG,GAAK,MAAQD,EAAWC,CAAC,IACtCI,EAAmB,YAAYJ,GAAGM,GAAKC,CAAG,IAC1CF,EAAqB,YAAYL,GAA8DM,GAAKC,CAAG;CAC3G,aAAa,GAAG,MAAaR,EAAWS,CAAQ,IAC5CJ,EAAmB,WAAWK,GAAGD,CAAQ,IACzCH,EAAqB,WAAWI,GAAGD,CAAkB;CACzD,YAAY,GAAG,GAAI,MAAOT,EAAWC,CAAC,IAClCI,EAAmB,UAAWJ,GAAGU,GAAIC,CAAE,IACvCN,EAAqB,UAAWL,GAA8DU,GAAIC,CAAE;CACxG,OAAO,MAAOV,EAAWD,CAAC,IACtBK,EAAqB,KAAML,CAAC,IAC5BD,EAAWC,CAAC,IAAII,EAAmB,KAAMJ,CAAC,IAAa;CAC3D,cAAc,MAAM;EAClB,IAAID,EAAWC,CAAC,GAAG,OAAO;EAC1B,IAAME,IAAKF,EAA6B;EACxC,OAAO,OAAOE,KAAM,WAAWA,IAAI;CACrC;CAKA,mBAAmB,MAAM,CAACH,EAAWC,CAAC;CACtC,eAAe,GAAG,MAAaD,EAAWC,CAAC,IAAIA,IAAI;EAAE,GAAIA;EAAc;CAAS;AAClF"}
+{"version":3,"file":"autoPoseDescriptor.js","names":[],"sources":["../../../src/core/geometry/autoPoseDescriptor.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { pathPoseDescriptor } from './pathPoseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from './poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire\n *  `poseDescriptor` explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only\n *  shape the rect descriptor and the kit's built-in painters can read. */\nexport function isRectPose(p: unknown): p is { x: number; y: number; width: number; height: number; rotation?: number } {\n  if (!p || typeof p !== 'object') return false;\n  const r = p as Record<string, unknown>;\n  return typeof r.x === 'number' && typeof r.y === 'number'\n    && typeof r.width === 'number' && typeof r.height === 'number';\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`\n *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses\n *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to\n *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated\n *  selection chrome and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  fromBounds: (b, template) => isPathLike(template)\n    ? pathPoseDescriptor.fromBounds(b, template)\n    : RECT_POSE_DESCRIPTOR.fromBounds(b, template as Bounds),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  axes: (p) => (isRectPose(p)\n    ? RECT_POSE_DESCRIPTOR.axes!(p) as never\n    : isPathLike(p) ? pathPoseDescriptor.axes!(p) as never : null),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n  withRotation: (p, rotation) => isPathLike(p) ? p : { ...(p as object), rotation },\n};\n"],"mappings":";;;;;;;;AASA,SAAgB,WAAW,GAAuB;CAChD,OAAO,CAAC,CAAC,KAAK,OAAO,MAAM,YAAY,UAAU,MAC1C,EAAwB,SAAS,aAAc,EAAwB,SAAS;AACzF;;;AAIA,SAAgB,WAAW,GAA6F;CACtH,IAAI,CAAC,KAAK,OAAO,MAAM,UAAU,OAAO;CACxC,MAAM,IAAI;CACV,OAAO,OAAO,EAAE,MAAM,YAAY,OAAO,EAAE,MAAM,YAC5C,OAAO,EAAE,UAAU,YAAY,OAAO,EAAE,WAAW;AAC1D;;;;;;;;AASA,IAAa,uBAAgD;CAC3D,YAAY,MAAM,WAAW,CAAC,IAC1B,mBAAmB,UAAU,CAAC,IAC9B,qBAAqB,UAAU,CAA4D;CAC/F,cAAc,GAAG,KAAK,QAAQ,WAAW,CAAC,IACtC,mBAAmB,YAAY,GAAG,KAAK,GAAG,IAC1C,qBAAqB,YAAY,GAA8D,KAAK,GAAG;CAC3G,aAAa,GAAG,aAAa,WAAW,QAAQ,IAC5C,mBAAmB,WAAW,GAAG,QAAQ,IACzC,qBAAqB,WAAW,GAAG,QAAkB;CACzD,YAAY,GAAG,IAAI,OAAO,WAAW,CAAC,IAClC,mBAAmB,UAAW,GAAG,IAAI,EAAE,IACvC,qBAAqB,UAAW,GAA8D,IAAI,EAAE;CACxG,OAAO,MAAO,WAAW,CAAC,IACtB,qBAAqB,KAAM,CAAC,IAC5B,WAAW,CAAC,IAAI,mBAAmB,KAAM,CAAC,IAAa;CAC3D,cAAc,MAAM;EAClB,IAAI,WAAW,CAAC,GAAG,OAAO;EAC1B,MAAM,IAAK,EAA6B;EACxC,OAAO,OAAO,MAAM,WAAW,IAAI;CACrC;CAKA,mBAAmB,MAAM,CAAC,WAAW,CAAC;CACtC,eAAe,GAAG,aAAa,WAAW,CAAC,IAAI,IAAI;EAAE,GAAI;EAAc;CAAS;AAClF"}

package/dist/core/geometry/inkExtents.js

@@ -0,0 +1,60 @@
+import { localToWorld, targetTransformOf } from "./targetFrame.js";
+
+//#region src/core/geometry/inkExtents.ts
+var NO_INK_EXTENTS = Object.freeze({
+	left: 0,
+	top: 0,
+	right: 0,
+	bottom: 0
+});
+function isNoInkExtents(e) {
+	return e.left === 0 && e.top === 0 && e.right === 0 && e.bottom === 0;
+}
+/** The extents that grow `inner` into `outer`, both in one frame; a side where
+*  `outer` does not reach past `inner` adds nothing. */
+function inkExtentsBetween(inner, outer) {
+	return {
+		left: Math.max(0, inner.x - outer.x),
+		top: Math.max(0, inner.y - outer.y),
+		right: Math.max(0, outer.x + outer.width - (inner.x + inner.width)),
+		bottom: Math.max(0, outer.y + outer.height - (inner.y + inner.height))
+	};
+}
+/**
+* `box` grown by `e` in its own frame, still drawn in that frame: the
+* rotation and `transform` ride along. They turn a box about its own center,
+* so a box grown unevenly is moved until its center lands where the frame put
+* that point of the original.
+*/
+function outsetBox(box, e) {
+	if (isNoInkExtents(e)) return box;
+	const grown = {
+		...box,
+		x: box.x - e.left,
+		y: box.y - e.top,
+		width: box.width + e.left + e.right,
+		height: box.height + e.top + e.bottom
+	};
+	const xf = targetTransformOf(box);
+	if (xf.identity || e.left === e.right && e.top === e.bottom) return grown;
+	const c = localToWorld(xf, grown.x + grown.width / 2, grown.y + grown.height / 2);
+	return {
+		...grown,
+		x: c.x - grown.width / 2,
+		y: c.y - grown.height / 2
+	};
+}
+/** `box` with `e` taken back off: the inverse of {@link outsetBox}, frame
+*  included. A box narrower than its extents comes out flipped. */
+function insetBox(box, e) {
+	return outsetBox(box, {
+		left: -e.left,
+		top: -e.top,
+		right: -e.right,
+		bottom: -e.bottom
+	});
+}
+
+//#endregion
+export { NO_INK_EXTENTS, inkExtentsBetween, insetBox, isNoInkExtents, outsetBox };
+//# sourceMappingURL=inkExtents.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inkExtents.js","names":[],"sources":["../../../src/core/geometry/inkExtents.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { localToWorld, targetTransformOf } from './targetFrame';\n\n/** How far a node's ink reaches past its pose box on each side, measured in\n *  the box's own frame: a centered stroke 10 wide reaches 5 on every side. */\nexport interface InkExtents {\n  readonly left: number;\n  readonly top: number;\n  readonly right: number;\n  readonly bottom: number;\n}\n\nexport const NO_INK_EXTENTS: InkExtents = Object.freeze({ left: 0, top: 0, right: 0, bottom: 0 });\n\nexport function isNoInkExtents(e: InkExtents): boolean {\n  return e.left === 0 && e.top === 0 && e.right === 0 && e.bottom === 0;\n}\n\n/** The extents that grow `inner` into `outer`, both in one frame; a side where\n *  `outer` does not reach past `inner` adds nothing. */\nexport function inkExtentsBetween(inner: Bounds, outer: Bounds): InkExtents {\n  return {\n    left: Math.max(0, inner.x - outer.x),\n    top: Math.max(0, inner.y - outer.y),\n    right: Math.max(0, outer.x + outer.width - (inner.x + inner.width)),\n    bottom: Math.max(0, outer.y + outer.height - (inner.y + inner.height)),\n  };\n}\n\n/**\n * `box` grown by `e` in its own frame, still drawn in that frame: the\n * rotation and `transform` ride along. They turn a box about its own center,\n * so a box grown unevenly is moved until its center lands where the frame put\n * that point of the original.\n */\nexport function outsetBox(box: Bounds, e: InkExtents): Bounds {\n  if (isNoInkExtents(e)) return box;\n  const grown = {\n    ...box,\n    x: box.x - e.left,\n    y: box.y - e.top,\n    width: box.width + e.left + e.right,\n    height: box.height + e.top + e.bottom,\n  };\n  const xf = targetTransformOf(box);\n  if (xf.identity || (e.left === e.right && e.top === e.bottom)) return grown;\n  const c = localToWorld(xf, grown.x + grown.width / 2, grown.y + grown.height / 2);\n  return { ...grown, x: c.x - grown.width / 2, y: c.y - grown.height / 2 };\n}\n\n/** `box` with `e` taken back off: the inverse of {@link outsetBox}, frame\n *  included. A box narrower than its extents comes out flipped. */\nexport function insetBox(box: Bounds, e: InkExtents): Bounds {\n  return outsetBox(box, { left: -e.left, top: -e.top, right: -e.right, bottom: -e.bottom });\n}\n"],"mappings":";;;AAYA,IAAa,iBAA6B,OAAO,OAAO;CAAE,MAAM;CAAG,KAAK;CAAG,OAAO;CAAG,QAAQ;AAAE,CAAC;AAEhG,SAAgB,eAAe,GAAwB;CACrD,OAAO,EAAE,SAAS,KAAK,EAAE,QAAQ,KAAK,EAAE,UAAU,KAAK,EAAE,WAAW;AACtE;;;AAIA,SAAgB,kBAAkB,OAAe,OAA2B;CAC1E,OAAO;EACL,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,MAAM,CAAC;EACnC,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI,MAAM,CAAC;EAClC,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,MAAM,SAAS,MAAM,IAAI,MAAM,MAAM;EAClE,QAAQ,KAAK,IAAI,GAAG,MAAM,IAAI,MAAM,UAAU,MAAM,IAAI,MAAM,OAAO;CACvE;AACF;;;;;;;AAQA,SAAgB,UAAU,KAAa,GAAuB;CAC5D,IAAI,eAAe,CAAC,GAAG,OAAO;CAC9B,MAAM,QAAQ;EACZ,GAAG;EACH,GAAG,IAAI,IAAI,EAAE;EACb,GAAG,IAAI,IAAI,EAAE;EACb,OAAO,IAAI,QAAQ,EAAE,OAAO,EAAE;EAC9B,QAAQ,IAAI,SAAS,EAAE,MAAM,EAAE;CACjC;CACA,MAAM,KAAK,kBAAkB,GAAG;CAChC,IAAI,GAAG,YAAa,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAS,OAAO;CACtE,MAAM,IAAI,aAAa,IAAI,MAAM,IAAI,MAAM,QAAQ,GAAG,MAAM,IAAI,MAAM,SAAS,CAAC;CAChF,OAAO;EAAE,GAAG;EAAO,GAAG,EAAE,IAAI,MAAM,QAAQ;EAAG,GAAG,EAAE,IAAI,MAAM,SAAS;CAAE;AACzE;;;AAIA,SAAgB,SAAS,KAAa,GAAuB;CAC3D,OAAO,UAAU,KAAK;EAAE,MAAM,CAAC,EAAE;EAAM,KAAK,CAAC,EAAE;EAAK,OAAO,CAAC,EAAE;EAAO,QAAQ,CAAC,EAAE;CAAO,CAAC;AAC1F"}

package/dist/core/geometry/pathPoseDescriptor.js

@@ -1,88 +1,113 @@
-import { boundsOfPath as e, boxToBox as t, transformPath as n, translatePath as r } from "@weasel-js/geom";
+import { boundsOfPath, boxToBox, lerpCorners, transformPath, translatePath } from "@weasel-js/geom";
+
 //#region src/core/geometry/pathPoseDescriptor.ts
-var i = {
-	getBounds: (t) => e(t),
-	remapBounds: (e, r, i) => n(e, t(r.x, r.y, r.width, r.height, i.x, i.y, i.width, i.height)),
-	fromBounds: (e) => ({
+/**
+* `PoseDescriptor` for `Path` poses — wires `useResize` to operate
+* on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel
+* the rest of the kit uses.
+*
+* `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the
+* resize hook knows the group's origin AABB and uses it for every leaf,
+* instead of each leaf scaling against its own AABB (which would ignore
+* group context).
+*/
+var pathPoseDescriptor = {
+	getBounds: (path) => boundsOfPath(path),
+	remapBounds: (path, src, dst) => transformPath(path, boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height)),
+	fromBounds: (b) => ({
 		kind: "rect",
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
 	}),
-	translate: (e, t, n) => r(e, t, n),
-	lerp: (e, t, n) => {
-		if (e.kind === "rect" && t.kind === "rect") return {
+	translate: (path, dx, dy) => translatePath(path, dx, dy),
+	lerp: (a, b, t) => {
+		if (a.kind === "rect" && b.kind === "rect") return {
 			kind: "rect",
-			x: e.x + (t.x - e.x) * n,
-			y: e.y + (t.y - e.y) * n,
-			width: e.width + (t.width - e.width) * n,
-			height: e.height + (t.height - e.height) * n
+			x: a.x + (b.x - a.x) * t,
+			y: a.y + (b.y - a.y) * t,
+			width: a.width + (b.width - a.width) * t,
+			height: a.height + (b.height - a.height) * t
 		};
-		if (e.kind === "polygon" && t.kind === "polygon" && e.coords.length === t.coords.length) {
-			let r = new Float32Array(e.coords.length);
-			for (let i = 0; i < e.coords.length; i++) r[i] = e.coords[i] + (t.coords[i] - e.coords[i]) * n;
-			return {
-				...e,
-				coords: r
+		if (a.kind === "polygon" && b.kind === "polygon" && a.coords.length === b.coords.length) {
+			const next = new Float32Array(a.coords.length);
+			for (let i = 0; i < a.coords.length; i++) next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;
+			const { corners: _a, ...bare } = a;
+			const corners = lerpCorners(a.corners, b.corners, t);
+			return corners ? {
+				...bare,
+				coords: next,
+				corners
+			} : {
+				...bare,
+				coords: next
 			};
 		}
-		throw Error("pathPoseDescriptor.lerp: incompatible path shapes");
+		throw new Error("pathPoseDescriptor.lerp: incompatible path shapes");
 	},
-	axes: (e) => e.kind === "rect" ? {
-		count: 4,
-		names: [
-			"x",
-			"y",
-			"width",
-			"height"
-		],
-		to: (e) => e.kind === "rect" ? [
-			e.x,
-			e.y,
-			e.width,
-			e.height
-		] : [],
-		from: (e) => ({
-			kind: "rect",
-			x: e[0],
-			y: e[1],
-			width: e[2],
-			height: e[3]
-		}),
-		add: (e, t) => e.kind === "rect" ? {
-			kind: "rect",
-			x: e.x + t[0],
-			y: e.y + t[1],
-			width: e.width + t[2],
-			height: e.height + t[3]
-		} : e,
-		write: (e, t, n) => {
-			e.kind === "rect" && (t[n] = e.x, t[n + 1] = e.y, t[n + 2] = e.width, t[n + 3] = e.height);
-		}
-	} : {
-		count: e.coords.length,
-		to: (e) => e.kind === "polygon" ? Array.from(e.coords) : [],
-		from: (t) => ({
-			...e,
-			coords: Float32Array.from(t)
-		}),
-		add: (t, n) => {
-			if (t.kind !== "polygon") return t;
-			let r = new Float32Array(t.coords.length);
-			for (let e = 0; e < r.length; e++) r[e] = t.coords[e] + n[e];
-			return {
-				...e,
-				coords: r
-			};
-		},
-		write: (e, t, n) => {
-			if (e.kind === "polygon") for (let r = 0; r < e.coords.length; r++) t[n + r] = e.coords[r];
-		}
+	axes: (like) => {
+		if (like.kind === "rect") return {
+			count: 4,
+			names: [
+				"x",
+				"y",
+				"width",
+				"height"
+			],
+			to: (p) => p.kind === "rect" ? [
+				p.x,
+				p.y,
+				p.width,
+				p.height
+			] : [],
+			from: (a) => ({
+				kind: "rect",
+				x: a[0],
+				y: a[1],
+				width: a[2],
+				height: a[3]
+			}),
+			add: (p, d) => p.kind !== "rect" ? p : {
+				kind: "rect",
+				x: p.x + d[0],
+				y: p.y + d[1],
+				width: p.width + d[2],
+				height: p.height + d[3]
+			},
+			write: (p, out, at) => {
+				if (p.kind !== "rect") return;
+				out[at] = p.x;
+				out[at + 1] = p.y;
+				out[at + 2] = p.width;
+				out[at + 3] = p.height;
+			}
+		};
+		return {
+			count: like.coords.length,
+			to: (p) => p.kind === "polygon" ? Array.from(p.coords) : [],
+			from: (a) => ({
+				...like,
+				coords: Float32Array.from(a)
+			}),
+			add: (p, d) => {
+				if (p.kind !== "polygon") return p;
+				const coords = new Float32Array(p.coords.length);
+				for (let i = 0; i < coords.length; i++) coords[i] = p.coords[i] + d[i];
+				return {
+					...like,
+					coords
+				};
+			},
+			write: (p, out, at) => {
+				if (p.kind !== "polygon") return;
+				for (let i = 0; i < p.coords.length; i++) out[at + i] = p.coords[i];
+			}
+		};
 	},
-	supportsRotation: () => !1
+	supportsRotation: () => false
 };
-//#endregion
-export { i as pathPoseDescriptor };
 
+//#endregion
+export { pathPoseDescriptor };
 //# sourceMappingURL=pathPoseDescriptor.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"pathPoseDescriptor.js","names":["pathPoseDescriptor","boundsOfPath","path","transformPath","boxToBox","src","dst","b","translatePath","dx","dy","a","t","next","like","p","d","at","coords","i"],"sources":["../../../src/core/geometry/pathPoseDescriptor.ts"],"sourcesContent":["import {\n  boxToBox,\n  boundsOfPath,\n  translatePath,\n  transformPath,\n  type Path,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { ...a, coords: next };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // A polygon's axes are its coordinates, so a move needs both ends to have as many points.\n  axes: (like) => {\n    if (like.kind === 'rect') {\n      return {\n        count: 4,\n        names: ['x', 'y', 'width', 'height'],\n        to: (p) => (p.kind === 'rect' ? [p.x, p.y, p.width, p.height] : []),\n        from: (a) => ({ kind: 'rect', x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! }),\n        add: (p, d) => (p.kind !== 'rect' ? p : {\n          kind: 'rect', x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]!,\n        }),\n        write: (p, out, at) => {\n          if (p.kind !== 'rect') return;\n          out[at] = p.x;\n          out[at + 1] = p.y;\n          out[at + 2] = p.width;\n          out[at + 3] = p.height;\n        },\n      };\n    }\n    return {\n      count: like.coords.length,\n      to: (p) => (p.kind === 'polygon' ? Array.from(p.coords) : []),\n      from: (a) => ({ ...like, coords: Float32Array.from(a as ArrayLike<number>) }),\n      add: (p, d) => {\n        if (p.kind !== 'polygon') return p;\n        const coords = new Float32Array(p.coords.length);\n        for (let i = 0; i < coords.length; i++) coords[i] = p.coords[i]! + d[i]!;\n        return { ...like, coords };\n      },\n      write: (p, out, at) => {\n        if (p.kind !== 'polygon') return;\n        for (let i = 0; i < p.coords.length; i++) out[at + i] = p.coords[i]!;\n      },\n    };\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n"],"mappings":"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"}
+{"version":3,"file":"pathPoseDescriptor.js","names":[],"sources":["../../../src/core/geometry/pathPoseDescriptor.ts"],"sourcesContent":["import {\n  boxToBox,\n  boundsOfPath,\n  lerpCorners,\n  translatePath,\n  transformPath,\n  type Path,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      const { corners: _a, ...bare } = a;\n      const corners = lerpCorners(a.corners, b.corners, t);\n      return corners ? { ...bare, coords: next, corners } : { ...bare, coords: next };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // A polygon's axes are its coordinates, so a move needs both ends to have as many points.\n  axes: (like) => {\n    if (like.kind === 'rect') {\n      return {\n        count: 4,\n        names: ['x', 'y', 'width', 'height'],\n        to: (p) => (p.kind === 'rect' ? [p.x, p.y, p.width, p.height] : []),\n        from: (a) => ({ kind: 'rect', x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! }),\n        add: (p, d) => (p.kind !== 'rect' ? p : {\n          kind: 'rect', x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]!,\n        }),\n        write: (p, out, at) => {\n          if (p.kind !== 'rect') return;\n          out[at] = p.x;\n          out[at + 1] = p.y;\n          out[at + 2] = p.width;\n          out[at + 3] = p.height;\n        },\n      };\n    }\n    return {\n      count: like.coords.length,\n      to: (p) => (p.kind === 'polygon' ? Array.from(p.coords) : []),\n      from: (a) => ({ ...like, coords: Float32Array.from(a as ArrayLike<number>) }),\n      add: (p, d) => {\n        if (p.kind !== 'polygon') return p;\n        const coords = new Float32Array(p.coords.length);\n        for (let i = 0; i < coords.length; i++) coords[i] = p.coords[i]! + d[i]!;\n        return { ...like, coords };\n      },\n      write: (p, out, at) => {\n        if (p.kind !== 'polygon') return;\n        for (let i = 0; i < p.coords.length; i++) out[at + i] = p.coords[i]!;\n      },\n    };\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n"],"mappings":";;;;;;;;;;;;;AAoBA,IAAa,qBAA2C;CACtD,YAAY,SAAS,aAAa,IAAI;CACtC,cAAc,MAAM,KAAK,QAAQ,cAC/B,MACA,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,OAAO,IAAI,QAAQ,IAAI,GAAG,IAAI,GAAG,IAAI,OAAO,IAAI,MAAM,CACnF;CACA,aAAa,OAAO;EAAE,MAAM;EAAQ,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG,OAAO,EAAE;EAAO,QAAQ,EAAE;CAAO;CACrF,YAAY,MAAM,IAAI,OAAO,cAAc,MAAM,IAAI,EAAE;CACvD,OAAO,GAAG,GAAG,MAAM;EACjB,IAAI,EAAE,SAAS,UAAU,EAAE,SAAS,QAClC,OAAO;GACL,MAAM;GACN,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;GACvB,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;GACvB,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS;GACvC,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU;EAC7C;EAEF,IAAI,EAAE,SAAS,aAAa,EAAE,SAAS,aAAa,EAAE,OAAO,WAAW,EAAE,OAAO,QAAQ;GACvF,MAAM,OAAO,IAAI,aAAa,EAAE,OAAO,MAAM;GAC7C,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,OAAO,QAAQ,KACnC,KAAK,KAAK,EAAE,OAAO,MAAM,EAAE,OAAO,KAAK,EAAE,OAAO,MAAM;GAExD,MAAM,EAAE,SAAS,IAAI,GAAG,SAAS;GACjC,MAAM,UAAU,YAAY,EAAE,SAAS,EAAE,SAAS,CAAC;GACnD,OAAO,UAAU;IAAE,GAAG;IAAM,QAAQ;IAAM;GAAQ,IAAI;IAAE,GAAG;IAAM,QAAQ;GAAK;EAChF;EACA,MAAM,IAAI,MAAM,mDAAmD;CACrE;CAEA,OAAO,SAAS;EACd,IAAI,KAAK,SAAS,QAChB,OAAO;GACL,OAAO;GACP,OAAO;IAAC;IAAK;IAAK;IAAS;GAAQ;GACnC,KAAK,MAAO,EAAE,SAAS,SAAS;IAAC,EAAE;IAAG,EAAE;IAAG,EAAE;IAAO,EAAE;GAAM,IAAI,CAAC;GACjE,OAAO,OAAO;IAAE,MAAM;IAAQ,GAAG,EAAE;IAAK,GAAG,EAAE;IAAK,OAAO,EAAE;IAAK,QAAQ,EAAE;GAAI;GAC9E,MAAM,GAAG,MAAO,EAAE,SAAS,SAAS,IAAI;IACtC,MAAM;IAAQ,GAAG,EAAE,IAAI,EAAE;IAAK,GAAG,EAAE,IAAI,EAAE;IAAK,OAAO,EAAE,QAAQ,EAAE;IAAK,QAAQ,EAAE,SAAS,EAAE;GAC7F;GACA,QAAQ,GAAG,KAAK,OAAO;IACrB,IAAI,EAAE,SAAS,QAAQ;IACvB,IAAI,MAAM,EAAE;IACZ,IAAI,KAAK,KAAK,EAAE;IAChB,IAAI,KAAK,KAAK,EAAE;IAChB,IAAI,KAAK,KAAK,EAAE;GAClB;EACF;EAEF,OAAO;GACL,OAAO,KAAK,OAAO;GACnB,KAAK,MAAO,EAAE,SAAS,YAAY,MAAM,KAAK,EAAE,MAAM,IAAI,CAAC;GAC3D,OAAO,OAAO;IAAE,GAAG;IAAM,QAAQ,aAAa,KAAK,CAAsB;GAAE;GAC3E,MAAM,GAAG,MAAM;IACb,IAAI,EAAE,SAAS,WAAW,OAAO;IACjC,MAAM,SAAS,IAAI,aAAa,EAAE,OAAO,MAAM;IAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,OAAO,KAAK,EAAE,OAAO,KAAM,EAAE;IACrE,OAAO;KAAE,GAAG;KAAM;IAAO;GAC3B;GACA,QAAQ,GAAG,KAAK,OAAO;IACrB,IAAI,EAAE,SAAS,WAAW;IAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,OAAO,QAAQ,KAAK,IAAI,KAAK,KAAK,EAAE,OAAO;GACnE;EACF;CACF;CAMA,wBAAwB;AAC1B"}