@weasel-js/core 1.6.1 → 1.7.1

package/dist/core/device/useDeviceProfile.js

@@ -0,0 +1,75 @@
+import { createContext as e, createElement as t, useContext as n, useEffect as r, useMemo as i, useState as a } from "react";
+import { DEFAULT_DEVICE_PROFILE as o, resolveDeviceProfile as s } from "@weasel-js/routing";
+//#region src/core/device/useDeviceProfile.ts
+var c = "(pointer: coarse)", l = "(hover: hover)";
+function u() {
+	return typeof window < "u" && typeof window.matchMedia == "function";
+}
+function d() {
+	let e = typeof window < "u" && window.devicePixelRatio || 1;
+	return u() ? {
+		coarsePointer: window.matchMedia(c).matches,
+		canHover: window.matchMedia(l).matches,
+		dpr: e
+	} : {
+		coarsePointer: o.coarsePointer,
+		canHover: o.canHover,
+		dpr: e
+	};
+}
+function f() {
+	let [e, t] = a(d);
+	return r(() => {
+		if (!u()) return;
+		let e = window.matchMedia(c), n = window.matchMedia(l), r = (e) => t((t) => ({
+			...t,
+			coarsePointer: e.matches
+		})), i = (e) => t((t) => ({
+			...t,
+			canHover: e.matches
+		}));
+		e.addEventListener("change", r), n.addEventListener("change", i);
+		let a = !1, o = null, s = () => {
+			if (a) return;
+			let e = window.devicePixelRatio || 1;
+			t((t) => t.dpr === e ? t : {
+				...t,
+				dpr: e
+			}), d();
+		};
+		function d() {
+			a || (o?.removeEventListener("change", s), o = window.matchMedia(`(resolution: ${window.devicePixelRatio || 1}dppx)`), o.addEventListener("change", s));
+		}
+		return d(), t({
+			coarsePointer: e.matches,
+			canHover: n.matches,
+			dpr: window.devicePixelRatio || 1
+		}), () => {
+			a = !0, e.removeEventListener("change", r), n.removeEventListener("change", i), o?.removeEventListener("change", s);
+		};
+	}, []), e;
+}
+var p = e(null);
+function m(e) {
+	let t = n(p), r = f(), a = t ?? r, { coarsePointer: o, canHover: c, dpr: l, targetScale: u } = e ?? {};
+	return i(() => s(a, {
+		...o === void 0 ? {} : { coarsePointer: o },
+		...c === void 0 ? {} : { canHover: c },
+		...l === void 0 ? {} : { dpr: l },
+		...u === void 0 ? {} : { targetScale: u }
+	}), [
+		a,
+		o,
+		c,
+		l,
+		u
+	]);
+}
+function h({ value: e, children: n }) {
+	let r = m(e);
+	return t(p.Provider, { value: r }, n);
+}
+//#endregion
+export { h as DeviceProfileProvider, m as useDeviceProfile };
+
+//# sourceMappingURL=useDeviceProfile.js.map

package/dist/core/device/useDeviceProfile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeviceProfile.js","names":["COARSE_QUERY","HOVER_QUERY","hasMatchMedia","detectOnce","dpr","DEFAULT_DEVICE_PROFILE","useDetectedFacts","facts","setFacts","useState","useEffect","coarseMq","hoverMq","onCoarse","f","onHover","disposed","densityMq","onDensity","next","arm","DeviceProfileContext","createContext","useDeviceProfile","provided","useContext","detected","base","overrides","useMemo","resolveDeviceProfile","coarsePointer","canHover","targetScale","DeviceProfileProvider","profile","value","createElement","children"],"sources":["../../../src/core/device/useDeviceProfile.ts"],"sourcesContent":["import {\n  createContext,\n  createElement,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n  type ReactNode,\n} from 'react';\nimport type { DetectedDeviceFacts, DeviceProfile } from './types';\nimport { DEFAULT_DEVICE_PROFILE, resolveDeviceProfile } from '@weasel-js/routing';\n\nconst COARSE_QUERY = '(pointer: coarse)';\nconst HOVER_QUERY = '(hover: hover)';\n\nfunction hasMatchMedia(): boolean {\n  return typeof window !== 'undefined' && typeof window.matchMedia === 'function';\n}\n\nfunction detectOnce(): DetectedDeviceFacts {\n  // Density is read unconditionally: `devicePixelRatio` does not depend on\n  // `matchMedia` existing. Only *watching* density needs a media query.\n  // Gating this read behind `hasMatchMedia()` would report density 1 under\n  // any environment without matchMedia — including jsdom, which would\n  // silently break `useCanvasSize`'s existing DPR assertions.\n  const dpr = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n  if (!hasMatchMedia()) {\n    return {\n      coarsePointer: DEFAULT_DEVICE_PROFILE.coarsePointer,\n      canHover: DEFAULT_DEVICE_PROFILE.canHover,\n      dpr,\n    };\n  }\n  return {\n    coarsePointer: window.matchMedia(COARSE_QUERY).matches,\n    canHover: window.matchMedia(HOVER_QUERY).matches,\n    dpr,\n  };\n}\n\n/**\n * Detect device facts and keep them live.\n *\n * Three subscriptions: pointer coarseness, hover capability, and pixel\n * density. The density one is special — `(resolution: Ndppx)` stops matching\n * as soon as density changes, so a single listener fires once and goes dead.\n * We re-arm a fresh query at the new density on every change.\n */\nfunction useDetectedFacts(): DetectedDeviceFacts {\n  const [facts, setFacts] = useState<DetectedDeviceFacts>(detectOnce);\n\n  useEffect(() => {\n    if (!hasMatchMedia()) return;\n\n    const coarseMq = window.matchMedia(COARSE_QUERY);\n    const hoverMq = window.matchMedia(HOVER_QUERY);\n\n    const onCoarse = (e: MediaQueryListEvent | { matches: boolean }) =>\n      setFacts((f) => ({ ...f, coarsePointer: e.matches }));\n    const onHover = (e: MediaQueryListEvent | { matches: boolean }) =>\n      setFacts((f) => ({ ...f, canHover: e.matches }));\n\n    coarseMq.addEventListener('change', onCoarse as EventListener);\n    hoverMq.addEventListener('change', onHover as EventListener);\n\n    // Re-arming density watcher.\n    let disposed = false;\n    let densityMq: MediaQueryList | null = null;\n    const onDensity = () => {\n      if (disposed) return;\n      const next = window.devicePixelRatio || 1;\n      setFacts((f) => (f.dpr === next ? f : { ...f, dpr: next }));\n      arm();\n    };\n    function arm(): void {\n      if (disposed) return;\n      densityMq?.removeEventListener('change', onDensity as EventListener);\n      densityMq = window.matchMedia(\n        `(resolution: ${window.devicePixelRatio || 1}dppx)`,\n      );\n      densityMq.addEventListener('change', onDensity as EventListener);\n    }\n    arm();\n\n    // Re-sync once on mount: a query could have changed between the\n    // useState initializer and the effect running.\n    setFacts({\n      coarsePointer: coarseMq.matches,\n      canHover: hoverMq.matches,\n      dpr: window.devicePixelRatio || 1,\n    });\n\n    return () => {\n      disposed = true;\n      coarseMq.removeEventListener('change', onCoarse as EventListener);\n      hoverMq.removeEventListener('change', onHover as EventListener);\n      densityMq?.removeEventListener('change', onDensity as EventListener);\n    };\n  }, []);\n\n  return facts;\n}\n\nconst DeviceProfileContext = createContext<DeviceProfile | null>(null);\n\n/**\n * Read the ambient device profile.\n *\n * Uses the nearest {@link DeviceProfileProvider} when one exists, and\n * otherwise detects for itself — so a standalone overlay or a labkit panel\n * rendered outside a `<SceneCanvas>` still gets correct facts.\n *\n * `overrides` always wins over both, which is what makes tests and\n * force-touch-chrome demos possible without stubbing `matchMedia`.\n */\nexport function useDeviceProfile(overrides?: Partial<DeviceProfile>): DeviceProfile {\n  const provided = useContext(DeviceProfileContext);\n  const detected = useDetectedFacts();\n  const base: DetectedDeviceFacts = provided ?? detected;\n  const { coarsePointer, canHover, dpr, targetScale } = overrides ?? {};\n  return useMemo(\n    () =>\n      resolveDeviceProfile(base, {\n        ...(coarsePointer !== undefined ? { coarsePointer } : {}),\n        ...(canHover !== undefined ? { canHover } : {}),\n        ...(dpr !== undefined ? { dpr } : {}),\n        ...(targetScale !== undefined ? { targetScale } : {}),\n      }),\n    [base, coarsePointer, canHover, dpr, targetScale],\n  );\n}\n\n/** Props for `<DeviceProfileProvider>`. */\nexport interface DeviceProfileProviderProps {\n  /** Partial override folded over detected facts. */\n  value?: Partial<DeviceProfile>;\n  children: ReactNode;\n}\n\n/**\n * Publish one resolved profile to a subtree. `<SceneCanvas>` renders this so\n * overlays, affordances, and consumer chrome all read the same object.\n */\nexport function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps) {\n  const profile = useDeviceProfile(value);\n  return createElement(DeviceProfileContext.Provider, { value: profile }, children);\n}\n"],"mappings":";;;AAYA,IAAMA,IAAe,qBACfC,IAAc;AAEpB,SAASC,IAAyB;CAChC,OAAO,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe;AACvE;AAEA,SAASC,IAAkC;CAMzC,IAAMC,IAAO,OAAO,SAAW,OAAe,OAAO,oBAAqB;CAQ1E,OAPKF,EAAc,IAOZ;EACL,eAAe,OAAO,WAAWF,CAAY,CAAC,CAAC;EAC/C,UAAU,OAAO,WAAWC,CAAW,CAAC,CAAC;EACzC;CACF,IAVS;EACL,eAAeI,EAAuB;EACtC,UAAUA,EAAuB;EACjC;CACF;AAOJ;AAUA,SAASC,IAAwC;CAC/C,IAAM,CAACC,GAAOC,KAAYC,EAA8BN,CAAU;CAmDlE,OAjDAO,QAAgB;EACd,IAAI,CAACR,EAAc,GAAG;EAEtB,IAAMS,IAAW,OAAO,WAAWX,CAAY,GACzCY,IAAU,OAAO,WAAWX,CAAW,GAEvCY,KAAY,MAChBL,GAAU,OAAO;GAAE,GAAGM;GAAG,eAAe,EAAE;EAAQ,EAAE,GAChDC,KAAW,MACfP,GAAU,OAAO;GAAE,GAAGM;GAAG,UAAU,EAAE;EAAQ,EAAE;EAGjD,AADAH,EAAS,iBAAiB,UAAUE,CAAyB,GAC7DD,EAAQ,iBAAiB,UAAUG,CAAwB;EAG3D,IAAIC,IAAW,IACXC,IAAmC,MACjCC,UAAkB;GACtB,IAAIF,GAAU;GACd,IAAMG,IAAO,OAAO,oBAAoB;GAExC,AADAX,GAAU,MAAOM,EAAE,QAAQK,IAAOL,IAAI;IAAE,GAAGA;IAAG,KAAKK;GAAK,CAAE,GAC1DC,EAAI;EACN;EACA,SAASA,IAAY;GACnB,AAAIJ,MACJC,GAAW,oBAAoB,UAAUC,CAA0B,GACnE,IAAY,OAAO,WACjB,gBAAgB,OAAO,oBAAoB,EAAE,MAC/C,GACAD,EAAU,iBAAiB,UAAUC,CAA0B;EACjE;EAWA,OAVAE,EAAI,GAIJZ,EAAS;GACP,eAAeG,EAAS;GACxB,UAAUC,EAAQ;GAClB,KAAK,OAAO,oBAAoB;EAClC,CAAC,SAEY;GAIX,AAHA,IAAW,IACXD,EAAS,oBAAoB,UAAUE,CAAyB,GAChED,EAAQ,oBAAoB,UAAUG,CAAwB,GAC9DE,GAAW,oBAAoB,UAAUC,CAA0B;EACrE;CACF,GAAG,CAAC,CAAC,GAEEX;AACT;AAEA,IAAMc,IAAuBC,EAAoC,IAAI;AAYrE,SAAgBC,EAAiB,GAAmD;CAClF,IAAMC,IAAWC,EAAWJ,CAAoB,GAC1CK,IAAWpB,EAAiB,GAC5BqB,IAA4BH,KAAYE,GACxC,EAAE,kBAAe,aAAU,QAAK,mBAAgBE,KAAa,CAAC;CACpE,OAAOC,QAEHC,EAAqBH,GAAM;EACzB,GAAII,MAAkB,KAAA,IAAgC,CAAC,IAArB,EAAE,iBAAc;EAClD,GAAIC,MAAa,KAAA,IAA2B,CAAC,IAAhB,EAAE,YAAS;EACxC,GAAI5B,MAAQ,KAAA,IAAsB,CAAC,IAAX,EAAE,OAAI;EAC9B,GAAI6B,MAAgB,KAAA,IAA8B,CAAC,IAAnB,EAAE,eAAY;CAChD,CAAC,GACH;EAACN;EAAMI;EAAeC;EAAU5B;EAAK6B;CAAW,CAClD;AACF;AAaA,SAAgBC,EAAsB,EAAE,UAAO,eAAwC;CACrF,IAAMC,IAAUZ,EAAiBa,CAAK;CACtC,OAAOC,EAAchB,EAAqB,UAAU,EAAE,OAAOc,EAAQ,GAAGG,CAAQ;AAClF"}

package/dist/core/fillInPoseFrame.js

@@ -0,0 +1,102 @@
+import { getPaintKind as e } from "./paintKinds.js";
+//#region src/core/fillInPoseFrame.ts
+function t(t, n) {
+	if (!a(t)) return e(t.fill)?.inPoseFrame?.(t, n) ?? t;
+	if (r(t)) {
+		let e = t.origin ?? {
+			x: 0,
+			y: 0
+		};
+		return {
+			...t,
+			origin: {
+				x: n.x + e.x,
+				y: n.y + e.y
+			},
+			units: "local"
+		};
+	}
+	if (!i(t)) return t;
+	let o = (e) => ({
+		x: n.x + e.x * n.width,
+		y: n.y + e.y * n.height
+	});
+	if (t.fill === "linear-gradient") return {
+		...t,
+		from: o(t.from),
+		to: o(t.to),
+		units: "local"
+	};
+	if (t.fill === "radial-gradient") {
+		let e = Math.hypot(n.width, n.height) / Math.SQRT2;
+		return {
+			...t,
+			center: o(t.center),
+			radius: t.radius * e,
+			units: "local"
+		};
+	}
+	return {
+		...t,
+		center: o(t.center),
+		units: "local"
+	};
+}
+function n(t, n) {
+	if (!a(t)) return e(t.fill)?.toBoundsFrame?.(t, n) ?? t;
+	if (t.fill === "pattern") {
+		let e = t.origin ?? {
+			x: 0,
+			y: 0
+		};
+		return {
+			...t,
+			origin: {
+				x: e.x - n.x,
+				y: e.y - n.y
+			},
+			units: "bounds"
+		};
+	}
+	if (t.fill !== "linear-gradient" && t.fill !== "radial-gradient" && t.fill !== "conic-gradient" || n.width === 0 || n.height === 0) return t;
+	let r = (e) => ({
+		x: (e.x - n.x) / n.width,
+		y: (e.y - n.y) / n.height
+	});
+	if (t.fill === "linear-gradient") return {
+		...t,
+		from: r(t.from),
+		to: r(t.to),
+		units: "bounds"
+	};
+	if (t.fill === "radial-gradient") {
+		let e = Math.hypot(n.width, n.height) / Math.SQRT2;
+		return {
+			...t,
+			center: r(t.center),
+			radius: t.radius / e,
+			units: "bounds"
+		};
+	}
+	return {
+		...t,
+		center: r(t.center),
+		units: "bounds"
+	};
+}
+function r(e) {
+	return e.fill === "pattern" && e.units === "bounds";
+}
+function i(e) {
+	if (e === void 0) return !1;
+	let t = e.fill;
+	return t !== "linear-gradient" && t !== "radial-gradient" && t !== "conic-gradient" ? !1 : e.units === "bounds";
+}
+function a(e) {
+	let t = e.fill ?? "solid";
+	return t === "solid" || t === "pattern" || t === "linear-gradient" || t === "radial-gradient" || t === "conic-gradient";
+}
+//#endregion
+export { t as fillInPoseFrame, n as fillToBoundsFrame };
+
+//# sourceMappingURL=fillInPoseFrame.js.map

package/dist/core/fillInPoseFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillInPoseFrame.js","names":["fillInPoseFrame","isBuiltinKind","fill","getPaintKind","box","isBoundsPattern","o","isBoundsGradient","toBox","p","scale","fillToBoundsFrame","fromBox","kind"],"sources":["../../src/core/fillInPoseFrame.ts"],"sourcesContent":["/**\n * Resolve a `units: 'bounds'` gradient into the frame its node is painted in.\n *\n * Node painters bake the pose into their geometry (`pathInPoseFrame`) rather\n * than emitting a per-node transform, so by the time the renderer sees a\n * scene node there is no node-local space left for a gradient to refer to.\n * This is the paint-side counterpart: it maps box-relative gradient geometry\n * onto the same box the path was just projected into, so the two arrive in\n * the renderer in one frame.\n */\n\nimport type { FillStyle, GradientFill } from '@weasel-js/paint';\nimport { getPaintKind } from './paintKinds';\n\n/** The box a `'bounds'` gradient's normalized geometry is mapped onto —\n *  usually a node's bounds. */\nexport interface FillPoseBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Map a `'bounds'` gradient's `0..1` geometry onto `box`, returning it in the\n * box's own frame (`units: 'local'`). Any other fill — solid, pattern, or a\n * gradient in another space — is returned untouched.\n *\n * Radii scale by the box's normalized diagonal, SVG's rule for a percentage\n * radius against `objectBoundingBox`: `sqrt(w² + h²) / sqrt(2)`, which is\n * exactly `w` for a square box. The renderer's radial gradient is circular,\n * so a non-square box cannot make it the ellipse SVG would — this keeps the\n * radius proportionate instead.\n */\nexport function fillInPoseFrame(fill: FillStyle, box: FillPoseBox): FillStyle {\n  if (!isBuiltinKind(fill)) {\n    return getPaintKind(fill.fill)?.inPoseFrame?.(fill, box) ?? fill;\n  }\n  if (isBoundsPattern(fill)) {\n    const o = fill.origin ?? { x: 0, y: 0 };\n    return { ...fill, origin: { x: box.x + o.x, y: box.y + o.y }, units: 'local' as const };\n  }\n  if (!isBoundsGradient(fill)) return fill;\n\n  const toBox = (p: { x: number; y: number }): { x: number; y: number } => ({\n    x: box.x + p.x * box.width,\n    y: box.y + p.y * box.height,\n  });\n\n  if (fill.fill === 'linear-gradient') {\n    return { ...fill, from: toBox(fill.from), to: toBox(fill.to), units: 'local' as const };\n  }\n  if (fill.fill === 'radial-gradient') {\n    const scale = Math.hypot(box.width, box.height) / Math.SQRT2;\n    return { ...fill, center: toBox(fill.center), radius: fill.radius * scale, units: 'local' as const };\n  }\n  return { ...fill, center: toBox(fill.center), units: 'local' as const };\n}\n\n/**\n * Inverse of {@link fillInPoseFrame}: express a gradient already positioned\n * in `box`'s frame as `0..1` fractions of that box (`units: 'bounds'`), so\n * it follows the node when moved or resized.\n *\n * The importer's counterpart — SVG `userSpaceOnUse` coordinates arrive in\n * page space, and normalizing them here makes an imported gradient behave\n * exactly like one drawn in the app.\n *\n * A zero-width or zero-height box has no frame to normalize against; the\n * fill is returned untouched rather than divided by zero.\n */\nexport function fillToBoundsFrame(fill: FillStyle, box: FillPoseBox): FillStyle {\n  if (!isBuiltinKind(fill)) {\n    return getPaintKind(fill.fill)?.toBoundsFrame?.(fill, box) ?? fill;\n  }\n  if (fill.fill === 'pattern') {\n    const o = fill.origin ?? { x: 0, y: 0 };\n    return { ...fill, origin: { x: o.x - box.x, y: o.y - box.y }, units: 'bounds' as const };\n  }\n  const isGradient = fill.fill === 'linear-gradient'\n    || fill.fill === 'radial-gradient'\n    || fill.fill === 'conic-gradient';\n  if (!isGradient) return fill;\n  if (box.width === 0 || box.height === 0) return fill;\n\n  const fromBox = (p: { x: number; y: number }): { x: number; y: number } => ({\n    x: (p.x - box.x) / box.width,\n    y: (p.y - box.y) / box.height,\n  });\n\n  if (fill.fill === 'linear-gradient') {\n    return { ...fill, from: fromBox(fill.from), to: fromBox(fill.to), units: 'bounds' as const };\n  }\n  if (fill.fill === 'radial-gradient') {\n    const scale = Math.hypot(box.width, box.height) / Math.SQRT2;\n    return { ...fill, center: fromBox(fill.center), radius: fill.radius / scale, units: 'bounds' as const };\n  }\n  return { ...fill, center: fromBox(fill.center), units: 'bounds' as const };\n}\n\n/** True when this fill is a pattern anchored to the painted node's box.\n *  Rebasing it is a translation only — a resize must reveal more tiles, not\n *  stretch them, which is the whole reason patterns get their own branch. */\nfunction isBoundsPattern(\n  fill: FillStyle,\n): fill is Extract<FillStyle, { fill: 'pattern' }> {\n  return fill.fill === 'pattern' && fill.units === 'bounds';\n}\n\n/** True when this fill is a gradient declaring box-relative geometry. */\nfunction isBoundsGradient(fill: FillStyle | undefined): fill is GradientFill {\n  if (fill === undefined) return false;\n  const kind = fill.fill;\n  if (kind !== 'linear-gradient' && kind !== 'radial-gradient' && kind !== 'conic-gradient') {\n    return false;\n  }\n  return fill.units === 'bounds';\n}\n\n/** The five kinds whose frame conversion is written above. Anything else is a\n *  registered kind and converts through its own entry. */\nfunction isBuiltinKind(fill: FillStyle): boolean {\n  const kind = fill.fill ?? 'solid';\n  return kind === 'solid' || kind === 'pattern'\n    || kind === 'linear-gradient' || kind === 'radial-gradient' || kind === 'conic-gradient';\n}\n"],"mappings":"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"}

package/dist/core/geometry/poseDescriptor.js

@@ -0,0 +1,98 @@
+import { axisAlignedBounds as e } from "./unionBounds.js";
+//#region src/core/geometry/poseDescriptor.ts
+function t(e, t) {
+	return e.forNode?.(t) ?? e;
+}
+function n(e, t) {
+	return e.x < t.x + t.width && e.x + e.width > t.x && e.y < t.y + t.height && e.y + e.height > t.y;
+}
+var r = {
+	getBounds: (e) => e,
+	remapBounds: (e, t, n) => {
+		let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height;
+		return {
+			...e,
+			x: n.x + (e.x - t.x) * r,
+			y: n.y + (e.y - t.y) * i,
+			width: e.width * r,
+			height: e.height * i
+		};
+	},
+	fromBounds: (e) => ({
+		x: e.x,
+		y: e.y,
+		width: e.width,
+		height: e.height
+	}),
+	translate: (e, t, n) => ({
+		...e,
+		x: e.x + t,
+		y: e.y + n
+	}),
+	intersectsRect: (e, t) => n(e, t),
+	lerp: (e, t, n) => ({
+		...e,
+		x: e.x + (t.x - e.x) * n,
+		y: e.y + (t.y - e.y) * n,
+		width: e.width + (t.width - e.width) * n,
+		height: e.height + (t.height - e.height) * n
+	}),
+	getRotation: (e) => e.rotation ?? 0,
+	withRotation: (e, t) => ({
+		...e,
+		rotation: t
+	})
+}, i = {
+	getBounds: r.getBounds,
+	remapBounds: r.remapBounds,
+	translate: r.translate,
+	intersectsRect: r.intersectsRect,
+	lerp: r.lerp,
+	fromBounds: (e) => ({
+		x: e.x,
+		y: e.y,
+		width: e.width,
+		height: e.height,
+		rotation: 0
+	}),
+	getRotation: (e) => e.rotation,
+	withRotation: (e, t) => ({
+		...e,
+		rotation: t
+	})
+};
+function a(e, t, n) {
+	let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height, a = e.rotation ?? 0, o = Math.cos(a), s = Math.sin(a), c = r * o, l = i * s, u = -r * s, d = i * o, f = e.width * Math.hypot(c, l), p = e.height * Math.hypot(u, d), m = Math.atan2(l, c), h = n.x + (e.x + e.width / 2 - t.x) * r, g = n.y + (e.y + e.height / 2 - t.y) * i;
+	return {
+		...e,
+		x: h - f / 2,
+		y: g - p / 2,
+		width: f,
+		height: p,
+		rotation: m
+	};
+}
+function o(t, n) {
+	let r = n.getBounds(t), i = n.getRotation?.(t) ?? r.rotation ?? 0;
+	return e({
+		x: r.x,
+		y: r.y,
+		width: r.width,
+		height: r.height,
+		rotation: i
+	});
+}
+function s(e, t, n, r) {
+	if (r.translate) return r.translate(e, t, n);
+	let i = r.getBounds(e), a = {
+		x: i.x + t,
+		y: i.y + n,
+		width: i.width,
+		height: i.height
+	};
+	return r.remapBounds(e, i, a);
+}
+//#endregion
+export { r as RECT_POSE_DESCRIPTOR, i as ROTATED_POSE_DESCRIPTOR, n as aabbIntersectsRect, t as poseDescriptorForNode, a as remapRotatedLeaf, s as translatePoseViaDescriptor, o as visualBoundsViaDescriptor };
+
+//# sourceMappingURL=poseDescriptor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseDescriptor.js","names":["poseDescriptorForNode","descriptor","node","aabbIntersectsRect","b","r","RECT_POSE_DESCRIPTOR","p","sx","src","dst","sy","dx","dy","a","t","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","pose","cos","sin","ux","uy","vx","vy","width","height","rotation","cxNew","cyNew","visualBoundsViaDescriptor","geometry","axisAlignedBounds","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.\n * The hook reads bounds via `getBounds`, runs anchor-relative math on those\n * bounds, then asks `remapBounds` to project the result back into TPose.\n *\n * `remapBounds(pose, src, dst)` is a single operation that subsumes both\n * \"set my own AABB to dst\" (single-leaf resize) and \"scale me as a leaf\n * inside parent's src→dst rect\" (group resize) — they're the same affine\n * map. For rect-shaped poses the default geometry interprets the pose as\n * its own bounds; for Path or polygon poses the consumer supplies a\n * projection that knows how to read and rewrite the underlying geometry.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** True iff any portion of the pose's geometry intersects `rect`. Optional.\n   *  Marquee and lasso do not read it: both test the node's drawn outline\n   *  (`core/geometry/regionHit`). */\n  intersectsRect?(pose: TPose, rect: Bounds): boolean;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted — descriptor\n   *  declares \"this pose has no rotation.\" When supplied and non-zero,\n   *  `useResize` projects the drag delta into the leaf's local frame,\n   *  runs anchor math there, and translates the resulting pose so the\n   *  diagonally opposite world-space corner is pinned. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation. Consulted by the\n   *  rotation affordance to decide whether to render the rotate cursor /\n   *  drag-band over a selection. When omitted, the kit assumes `true` for\n   *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`\n   *  fields (e.g. polygon Paths) should return `false` so the affordance\n   *  hides instead of exposing a non-functional rotate cursor. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type — a sphere and a box both posed by\n   * position/rotation/scale — are indistinguishable to them. Implement this to\n   * read `node.data` once and hand back a descriptor that knows which shape it\n   * is describing.\n   *\n   * Callers reach it through {@link poseDescriptorForNode}, at whichever site\n   * holds the node; the specialized descriptor then travels into the bounds and\n   * hit-test helpers in place of this one. Sites with only an id keep using the\n   * unspecialized descriptor, which is why this is optional on both ends.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** AABB-vs-AABB overlap. Exported for callers building a default\n *  `intersectsRect` from `getBounds`. */\nexport function aabbIntersectsRect(b: Bounds, r: Bounds): boolean {\n  return b.x < r.x + r.width && b.x + b.width > r.x && b.y < r.y + r.height && b.y + b.height > r.y;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  intersectsRect: (p, r) => aabbIntersectsRect(p, r),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  // `Bounds` carries an optional `rotation`, and `withRotation` writes into\n  // it — so reading it back has to be the same channel, or a pose reports\n  // itself unrotated to `useResize` and to port placement while painting\n  // rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`. Inherits rect-shape projection\n *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends Bounds`\n *  subtype lets the rect descriptor's methods apply directly; `remapBounds`\n *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so\n *  `useResize` knows to take the rotation-aware math path. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect as PoseDescriptor<RotatedPose>['intersectsRect'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are already expressed in the leaf's own frame — the\n * single-leaf resize path, where the drag delta was projected into that frame\n * before the anchor math ran. In a group resize they are world-frame, so the\n * leaf's local axes do not line up with the axes being scaled: at 90° a\n * horizontal stretch should grow the leaf's `height`, and the naive map grows\n * its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model is `{x, y, width, height, rotation}`\n * and cannot represent the parallelogram a non-uniform scale of a rotated box\n * actually produces. The center moves exactly; each local axis takes the\n * length of its own image; the rotation follows the image of the local x-axis.\n *\n * Degenerates to the naive map at `rotation === 0`, and to a plain uniform\n * scale when `sx === sy`, both exactly.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n\n/** The pose's visual bounds: its frame expanded to cover the rotated\n *  rectangle, so a turned shape reports the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation =\n    geometry.getRotation?.(pose) ?? (b as { rotation?: number }).rotation ?? 0;\n  return axisAlignedBounds({ x: b.x, y: b.y, width: b.width, height: b.height, rotation });\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":"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"}

package/dist/core/geometry/poseRotation.js

@@ -0,0 +1,58 @@
+import { PATH_L as e, PATH_M as t, PATH_Z as n, forEachSegment as r, pathCommandCoordCount as i } from "@weasel-js/geom";
+//#region src/core/geometry/poseRotation.ts
+function a(e) {
+	let t = e;
+	return t.rotation && t.x != null && t.y != null && t.width != null && t.height != null ? {
+		cx: t.x + t.width / 2,
+		cy: t.y + t.height / 2,
+		rotation: t.rotation
+	} : null;
+}
+function o(e, t, n, r) {
+	return e.kind === "rect" ? c(e.x, e.y, e.width, e.height, t, n, r) : s(e, t, n, r);
+}
+function s(e, t, n, a) {
+	let o = Math.cos(a), s = Math.sin(a), { commands: c, coords: l } = e, u = new Float32Array(l.length);
+	return r(c, l, (e, r) => {
+		for (let a = 0, c = i(e); a < c; a += 2) {
+			let e = l[r + a] - t, i = l[r + a + 1] - n;
+			u[r + a] = t + e * o - i * s, u[r + a + 1] = n + e * s + i * o;
+		}
+	}), {
+		kind: "polygon",
+		commands: e.commands,
+		coords: u,
+		fillRule: e.fillRule
+	};
+}
+function c(r, i, a, o, s, c, l) {
+	let u = Math.cos(l), d = Math.sin(l), f = (e, t) => {
+		let n = e - s, r = t - c;
+		return [s + n * u - r * d, c + n * d + r * u];
+	}, [p, m] = f(r, i), [h, g] = f(r + a, i), [_, v] = f(r + a, i + o), [y, b] = f(r, i + o);
+	return {
+		kind: "polygon",
+		commands: new Uint8Array([
+			t,
+			e,
+			e,
+			e,
+			n
+		]),
+		coords: new Float32Array([
+			p,
+			m,
+			h,
+			g,
+			_,
+			v,
+			y,
+			b
+		]),
+		fillRule: "nonzero"
+	};
+}
+//#endregion
+export { a as poseRotationOf, o as rotatePathAround };
+
+//# sourceMappingURL=poseRotation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseRotation.js","names":["poseRotationOf","p","pose","rotatePathAround","path","rotateRectCorners","cx","cy","rotation","rotatePolygon","cos","sin","next","coords","forEachSegment","commands","k","len","pathCommandCoordCount","cmd","dx","ci","dy","rotate","px","py","x0","y0","x","y","x1","y1","w","x2","y2","h","x3","y3","PATH_M","PATH_L","PATH_Z"],"sources":["../../../src/core/geometry/poseRotation.ts"],"sourcesContent":["/**\n * The kit's single encoding of the pose-rotation convention: \"rotate about the\n * pose's unrotated AABB center by `pose.rotation` (radians).\"\n *\n * Every consumer that needs to apply rotation — the render-tree wrap\n * (`canvas/poseRotation.ts`), the world coordinate bake (`pathInWorld`), the\n * silhouette/clip bake (`findShapeSilhouette`), the hit-test inverse\n * (`poseContainsRotated`), and selection chrome — derives its pivot + angle\n * from `poseRotationOf` rather than re-inlining the `if (rotation && x != null\n * …)` gate. If the convention ever changes (different pivot, a transform\n * field, etc.), it changes here.\n *\n * Lives in `core/geometry` so `core/`'s own adapters can bake rotation too.\n */\nimport {\n  forEachSegment,\n  pathCommandCoordCount,\n  PATH_L,\n  PATH_M,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\n\n/** Pivot (`cx`, `cy`) and angle resolved from a pose's rotation convention. */\nexport interface PoseRotation {\n  cx: number;\n  cy: number;\n  rotation: number;\n}\n\n/**\n * Resolve a pose's rotation transform, or `null` when the pose carries no\n * effective rotation. Non-null requires a nonzero `rotation` **and** all four\n * AABB fields (`x`, `y`, `width`, `height`) — the pivot is the unrotated AABB\n * center. Poses missing any AABB field (e.g. a bare polygon pose) or with\n * zero/absent rotation return `null`, so callers can treat `null` as \"draw /\n * hit / clip in the local frame, no rotation step.\"\n */\nexport function poseRotationOf(pose: unknown): PoseRotation | null {\n  const p = pose as Partial<{ x: number; y: number; width: number; height: number; rotation: number }>;\n  if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {\n    return { cx: p.x + p.width / 2, cy: p.y + p.height / 2, rotation: p.rotation };\n  }\n  return null;\n}\n\n/**\n * Rotate every coordinate of `path` about `(cx, cy)` by `rotation` radians.\n * A `rect` promotes to a four-corner polygon (axis-aligned rects can't encode\n * rotation); a polygon keeps its command list and rotates each coord. Returns\n * a fresh `PolygonPath`; never mutates the input. This is the coordinate-baking\n * companion to `poseRotationOf` — `pathInWorld` and `findShapeSilhouette` both\n * apply it so they share one rotation implementation.\n */\nexport function rotatePathAround(path: Path, cx: number, cy: number, rotation: number): PolygonPath {\n  if (path.kind === 'rect') {\n    return rotateRectCorners(path.x, path.y, path.width, path.height, cx, cy, rotation);\n  }\n  return rotatePolygon(path, cx, cy, rotation);\n}\n\nfunction rotatePolygon(path: PolygonPath, cx: number, cy: number, rotation: number): PolygonPath {\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const { commands, coords } = path;\n  const next = new Float32Array(coords.length);\n  forEachSegment(commands, coords, (cmd, ci) => {\n    for (let k = 0, len = pathCommandCoordCount(cmd); k < len; k += 2) {\n      const dx = coords[ci + k] - cx;\n      const dy = coords[ci + k + 1] - cy;\n      next[ci + k] = cx + dx * cos - dy * sin;\n      next[ci + k + 1] = cy + dx * sin + dy * cos;\n    }\n  });\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\nfunction rotateRectCorners(\n  x: number, y: number, w: number, h: number,\n  cx: number, cy: number, rotation: number,\n): PolygonPath {\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const rotate = (px: number, py: number): [number, number] => {\n    const dx = px - cx;\n    const dy = py - cy;\n    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];\n  };\n  const [x0, y0] = rotate(x, y);\n  const [x1, y1] = rotate(x + w, y);\n  const [x2, y2] = rotate(x + w, y + h);\n  const [x3, y3] = rotate(x, y + h);\n  // M, L, L, L, Z\n  const commands = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);\n  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;AAuCA,SAAgBA,EAAe,GAAoC;CACjE,IAAMC,IAAIC;CAIV,OAHID,EAAE,YAAYA,EAAE,KAAK,QAAQA,EAAE,KAAK,QAAQA,EAAE,SAAS,QAAQA,EAAE,UAAU,OACtE;EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ;EAAG,IAAIA,EAAE,IAAIA,EAAE,SAAS;EAAG,UAAUA,EAAE;CAAS,IAExE;AACT;AAUA,SAAgBE,EAAiB,GAAY,GAAY,GAAY,GAA+B;CAIlG,OAHIC,EAAK,SAAS,SACTC,EAAkBD,EAAK,GAAGA,EAAK,GAAGA,EAAK,OAAOA,EAAK,QAAQE,GAAIC,GAAIC,CAAQ,IAE7EC,EAAcL,GAAME,GAAIC,GAAIC,CAAQ;AAC7C;AAEA,SAASC,EAAc,GAAmB,GAAY,GAAY,GAA+B;CAC/F,IAAMC,IAAM,KAAK,IAAIF,CAAQ,GACvBG,IAAM,KAAK,IAAIH,CAAQ,GACvB,EAAE,aAAU,cAAWJ,GACvBQ,IAAO,IAAI,aAAaC,EAAO,MAAM;CAS3C,OARAC,EAAeC,GAAUF,IAAS,GAAK,MAAO;EAC5C,KAAK,IAAIG,IAAI,GAAGC,IAAMC,EAAsBC,CAAG,GAAGH,IAAIC,GAAK,KAAK,GAAG;GACjE,IAAMG,IAAKP,EAAOQ,IAAKL,KAAKV,GACtBgB,IAAKT,EAAOQ,IAAKL,IAAI,KAAKT;GAEhC,AADA,EAAKc,IAAKL,KAAKV,IAAKc,IAAKV,IAAMY,IAAKX,GACpC,EAAKU,IAAKL,IAAI,KAAKT,IAAKa,IAAKT,IAAMW,IAAKZ;EAC1C;CACF,CAAC,GACM;EAAE,MAAM;EAAW,UAAUN,EAAK;EAAU,QAAQQ;EAAM,UAAUR,EAAK;CAAS;AAC3F;AAEA,SAASC,EACP,GAAW,GAAW,GAAW,GACjC,GAAY,GAAY,GACX;CACb,IAAMK,IAAM,KAAK,IAAIF,CAAQ,GACvBG,IAAM,KAAK,IAAIH,CAAQ,GACvBe,KAAU,GAAY,MAAiC;EAC3D,IAAMH,IAAKI,IAAKlB,GACVgB,IAAKG,IAAKlB;EAChB,OAAO,CAACD,IAAKc,IAAKV,IAAMY,IAAKX,GAAKJ,IAAKa,IAAKT,IAAMW,IAAKZ,CAAG;CAC5D,GACM,CAACgB,GAAIC,KAAMJ,EAAOK,GAAGC,CAAC,GACtB,CAACC,GAAIC,KAAMR,EAAOK,IAAII,GAAGH,CAAC,GAC1B,CAACI,GAAIC,KAAMX,EAAOK,IAAII,GAAGH,IAAIM,CAAC,GAC9B,CAACC,GAAIC,KAAMd,EAAOK,GAAGC,IAAIM,CAAC;CAIhC,OAAO;EAAE,MAAM;EAAW,UAAA,IAFL,WAAW;GAACG;GAAQC;GAAQA;GAAQA;GAAQC;EAAM,CAE7C;EAAU,QAAA,IADjB,aAAa;GAACd;GAAIC;GAAIG;GAAIC;GAAIE;GAAIC;GAAIE;GAAIC;EAAE,CAC3B;EAAQ,UAAU;CAAU;AAClE"}

package/dist/core/geometry/regionHit.js

@@ -0,0 +1,102 @@
+import { nodeMemo as e } from "../scene/nodeMemo.js";
+import { poseRotationOf as t, rotatePathAround as n } from "./poseRotation.js";
+import { visualBoundsViaDescriptor as r } from "./poseDescriptor.js";
+import { boxContainsBox as i, pointInPolygon as a, polygonContainsPath as o, polygonIntersectsPath as s } from "@weasel-js/geom";
+//#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
+	], {
+		x: t,
+		y: n,
+		width: r,
+		height: i
+	}, !0);
+}
+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);
+	}
+	return r.length === 0 ? null : {
+		verts: r,
+		coords: i,
+		bounds: t ?? {
+			x: a,
+			y: o,
+			width: s - a,
+			height: c - o
+		},
+		isRect: n
+	};
+}
+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);
+}
+function d(e) {
+	return typeof e == "object" && !!e && e.kind === "polygon";
+}
+function f(t, n, i) {
+	return d(n) ? e(t, "aabb", n, () => i.getBounds(n)) : r(n, i);
+}
+function p(e, r) {
+	let i = t(e);
+	if (i) {
+		let t = e;
+		return n({
+			kind: "rect",
+			x: t.x,
+			y: t.y,
+			width: t.width,
+			height: t.height
+		}, i.cx, i.cy, i.rotation);
+	}
+	return {
+		kind: "rect",
+		x: r.x,
+		y: r.y,
+		width: r.width,
+		height: r.height
+	};
+}
+function m(e, t, n, r, c) {
+	if (!Number.isFinite(r.x) || !Number.isFinite(r.y) || !Number.isFinite(r.width) || !Number.isFinite(r.height)) return !1;
+	let l = e.bounds;
+	if (r.x >= l.x + l.width || r.x + r.width <= l.x || r.y >= l.y + l.height || r.y + r.height <= l.y) return !1;
+	if (t === "centers") return a(e.coords, r.x + r.width / 2, r.y + r.height / 2);
+	let u = i([
+		l.x,
+		l.y,
+		l.x + l.width,
+		l.y + l.height
+	], [
+		r.x,
+		r.y,
+		r.x + r.width,
+		r.y + r.height
+	]), f = d(n);
+	if (t === "enclosed") return u ? o(e.verts, f ? n : c()) : !1;
+	if (e.isRect && u) return !0;
+	if (f) return s(e.verts, n);
+	let p = c();
+	return p.kind === "rect" && e.isRect ? !0 : s(e.verts, p);
+}
+//#endregion
+export { d as isSilhouettePose, u as polygonRegion, p as poseOutline, c as rectRegion, f as regionBoundsOf, l as regionOf, m as regionTakes };
+
+//# sourceMappingURL=regionHit.js.map

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

@@ -0,0 +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","poseRotationOf","rotatePathAround","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","polygonIntersectsPath","drawn"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision shared by\n * `sceneToAdapter` (through `canvas/deps/hitTestArea`) and `arrayAdapter`.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { poseRotationOf, rotatePathAround } from './poseRotation';\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, turned by the pose's\n *  rotation, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  const r = poseRotationOf(pose);\n  if (r) {\n    const p = pose as Bounds;\n    return rotatePathAround(\n      { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      r.cx, r.cy, r.rotation,\n    );\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A node sticking out of the region's box cannot be inside the region.\n    if (!inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  if (silhouette) return polygonIntersectsPath(region.verts, pose);\n  const drawn = outline();\n  // An axis-aligned rect overlapping a marquee's box already meets it.\n  if (drawn.kind === 'rect' && region.isRect) return true;\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":"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"}

package/dist/core/geometry/unionBounds.js

@@ -0,0 +1,60 @@
+//#region src/core/geometry/unionBounds.ts
+function e(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);
+	}
+	return a ? {
+		x: t,
+		y: n,
+		width: r - t,
+		height: i - n
+	} : null;
+}
+function t(e) {
+	let t = e.rotation;
+	if (!t) return {
+		x: e.x,
+		y: e.y,
+		width: e.width,
+		height: e.height
+	};
+	let n = Math.cos(t), r = Math.sin(t), i = e.x + e.width / 2, a = e.y + e.height / 2, o = Infinity, s = Infinity, c = -Infinity, l = -Infinity, u = [
+		[e.x, e.y],
+		[e.x + e.width, e.y],
+		[e.x + e.width, e.y + e.height],
+		[e.x, e.y + e.height]
+	];
+	for (let [e, t] of u) {
+		let u = e - i, d = t - a, f = i + u * n - d * r, p = a + u * r + d * n;
+		f < o && (o = f), f > c && (c = f), p < s && (s = p), p > l && (l = p);
+	}
+	return {
+		x: o,
+		y: s,
+		width: c - o,
+		height: l - s
+	};
+}
+function n(e) {
+	let n = Infinity, r = Infinity, i = -Infinity, a = -Infinity, o = !1;
+	for (let s of e) {
+		if (!s) continue;
+		let e = t(s);
+		o = !0, e.x < n && (n = e.x), e.y < r && (r = e.y);
+		let c = e.x + e.width, l = e.y + e.height;
+		c > i && (i = c), l > a && (a = l);
+	}
+	return o ? {
+		x: n,
+		y: r,
+		width: i - n,
+		height: a - r
+	} : null;
+}
+//#endregion
+export { t as axisAlignedBounds, n as unionAABB, e as unionBounds };
+
+//# sourceMappingURL=unionBounds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unionBounds.js","names":["unionBounds","minX","minY","maxX","maxY","any","p","poses","right","bottom","axisAlignedBounds","rotation","b","cos","sin","cx","cy","corners","px","py","dx","dy","rx","ry","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 type { RectPose } from 'core/scene/types';\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`: returns the AABB of the\n * rotated rectangle, with `rotation` dropped. Follows the kit's rotation\n * convention (`poseRotationOf`): rotate about the unrotated AABB center.\n *\n * Unrotated input is returned as-is.\n */\nexport function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose {\n  const rotation = b.rotation;\n  if (!rotation) {\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  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const cx = b.x + b.width / 2;\n  const cy = b.y + b.height / 2;\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 dx = px - cx;\n    const dy = py - cy;\n    const rx = cx + dx * cos - dy * sin;\n    const ry = cy + dx * sin + dy * cos;\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":";AAkBA,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,IAAWC,EAAE;CACnB,IAAI,CAACD,GAGH,OAAO;EAAE,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CAE5D,IAAMC,IAAM,KAAK,IAAIF,CAAQ,GACvBG,IAAM,KAAK,IAAIH,CAAQ,GACvBI,IAAKH,EAAE,IAAIA,EAAE,QAAQ,GACrBI,IAAKJ,EAAE,IAAIA,EAAE,SAAS,GACxBX,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACLa,IAAoD;EACxD,CAACL,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,CAACM,GAAIC,MAAOF,GAAS;EAC9B,IAAMG,IAAKF,IAAKH,GACVM,IAAKF,IAAKH,GACVM,IAAKP,IAAKK,IAAKP,IAAMQ,IAAKP,GAC1BS,IAAKP,IAAKI,IAAKN,IAAMO,IAAKR;EAIhC,AAHIS,IAAKrB,MAAM,IAAOqB,IAClBA,IAAKnB,MAAM,IAAOmB,IAClBC,IAAKrB,MAAM,IAAOqB,IAClBA,IAAKnB,MAAM,IAAOmB;CACxB;CACA,OAAO;EAAE,GAAGtB;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE;AAUA,SAAgBsB,EACd,GACiB;CACjB,IAAIvB,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMoB,KAAQC,GAAO;EACxB,IAAI,CAACD,GAAM;EACX,IAAMb,IAAIF,EAAkBe,CAAI;EAGhC,AAFA,IAAM,IACFb,EAAE,IAAIX,MAAM,IAAOW,EAAE,IACrBA,EAAE,IAAIV,MAAM,IAAOU,EAAE;EACzB,IAAMJ,IAAQI,EAAE,IAAIA,EAAE,OAChBH,IAASG,EAAE,IAAIA,EAAE;EAEvB,AADIJ,IAAQL,MAAM,IAAOK,IACrBC,IAASL,MAAM,IAAOK;CAC5B;CAEA,OADKJ,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB"}