@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/viewport/useCanvasSize.js

@@ -1,29 +1,50 @@
-import { useDeviceProfile as e } from "../device/useDeviceProfile.js";
-import { useCallback as t, useEffect as n, useState as r } from "react";
+import { useDeviceProfile } from "../device/useDeviceProfile.js";
+import { useCallback, useEffect, useState } from "react";
+
 //#region src/core/viewport/useCanvasSize.ts
-function i(i) {
-	let { dpr: a } = e(), [o, s] = r({
+/** Track a container's content-rect size via `ResizeObserver`, and density via
+*  the ambient `DeviceProfile`.
+*
+*  Density deliberately does NOT come from a `window.devicePixelRatio` read
+*  inside the resize callback: that only refreshes when the element resizes,
+*  so dragging a window to a different-density display without resizing it
+*  leaves the snapshot stale. */
+function useCanvasSize(containerRef) {
+	const { dpr } = useDeviceProfile();
+	const { width, height } = useElementSize(containerRef);
+	return {
+		width,
+		height,
+		dpr
+	};
+}
+/** An element's CSS-pixel size, `0 × 0` until it is mounted and measured.
+*  Re-measured whenever a `ResizeObserver` reports it resized. */
+function useElementSize(containerRef) {
+	const [size, setSize] = useState({
 		width: 0,
 		height: 0
-	}), c = t(() => {
-		if (!i.current) return;
-		let e = i.current.getBoundingClientRect();
-		s((t) => t.width === e.width && t.height === e.height ? t : {
-			width: e.width,
-			height: e.height
+	});
+	const measure = useCallback(() => {
+		if (!containerRef.current) return;
+		const rect = containerRef.current.getBoundingClientRect();
+		setSize((prev) => prev.width === rect.width && prev.height === rect.height ? prev : {
+			width: rect.width,
+			height: rect.height
 		});
-	}, [i]);
-	return n(() => {
-		c();
-		let e = new ResizeObserver(c);
-		return i.current && e.observe(i.current), () => e.disconnect();
-	}, [c, i]), {
-		width: o.width,
-		height: o.height,
-		dpr: a
-	};
+	}, [containerRef]);
+	useEffect(() => {
+		const el = containerRef.current;
+		if (!el) return;
+		measure();
+		if (typeof ResizeObserver === "undefined") return;
+		const observer = new ResizeObserver(measure);
+		observer.observe(el);
+		return () => observer.disconnect();
+	}, [measure, containerRef]);
+	return size;
 }
-//#endregion
-export { i as useCanvasSize };
 
+//#endregion
+export { useCanvasSize, useElementSize };
 //# sourceMappingURL=useCanvasSize.js.map

package/dist/core/viewport/useCanvasSize.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasSize.js","names":["useCanvasSize","useDeviceProfile","size","setSize","useState","measure","useCallback","containerRef","rect","prev","useEffect","observer"],"sources":["../../../src/core/viewport/useCanvasSize.ts"],"sourcesContent":["import { type RefObject, useCallback, useEffect, useState } from 'react';\nimport type { CanvasSize } from './clampView';\nimport { useDeviceProfile } from '../device/useDeviceProfile';\n\n/** Size snapshot returned by `useCanvasSize` — the kit-wide `CanvasSize`\n *  (width × height in CSS pixels) plus the current devicePixelRatio. */\nexport interface CanvasSizeSnapshot extends CanvasSize {\n  dpr: number;\n}\n\n/** Track a container's content-rect size via `ResizeObserver`, and density via\n *  the ambient `DeviceProfile`.\n *\n *  Density deliberately does NOT come from a `window.devicePixelRatio` read\n *  inside the resize callback: that only refreshes when the element resizes,\n *  so dragging a window to a different-density display without resizing it\n *  leaves the snapshot stale. */\nexport function useCanvasSize(containerRef: RefObject<HTMLElement | null>): CanvasSizeSnapshot {\n  const { dpr } = useDeviceProfile();\n  const [size, setSize] = useState<CanvasSize>({ width: 0, height: 0 });\n\n  const measure = useCallback(() => {\n    if (!containerRef.current) return;\n    const rect = containerRef.current.getBoundingClientRect();\n    setSize((prev) =>\n      prev.width === rect.width && prev.height === rect.height\n        ? prev\n        : { width: rect.width, height: rect.height },\n    );\n  }, [containerRef]);\n\n  useEffect(() => {\n    measure();\n    const observer = new ResizeObserver(measure);\n    if (containerRef.current) {\n      observer.observe(containerRef.current);\n    }\n    return () => observer.disconnect();\n  }, [measure, containerRef]);\n\n  return { width: size.width, height: size.height, dpr };\n}\n"],"mappings":";;;AAiBA,SAAgBA,EAAc,GAAiE;CAC7F,IAAM,EAAE,WAAQC,EAAiB,GAC3B,CAACC,GAAMC,KAAWC,EAAqB;EAAE,OAAO;EAAG,QAAQ;CAAE,CAAC,GAE9DC,IAAUC,QAAkB;EAChC,IAAI,CAACC,EAAa,SAAS;EAC3B,IAAMC,IAAOD,EAAa,QAAQ,sBAAsB;EACxD,GAAS,MACPE,EAAK,UAAUD,EAAK,SAASC,EAAK,WAAWD,EAAK,SAC9CC,IACA;GAAE,OAAOD,EAAK;GAAO,QAAQA,EAAK;EAAO,CAC/C;CACF,GAAG,CAACD,CAAY,CAAC;CAWjB,OATAG,QAAgB;EACd,EAAQ;EACR,IAAMC,IAAW,IAAI,eAAeN,CAAO;EAI3C,OAHIE,EAAa,WACfI,EAAS,QAAQJ,EAAa,OAAO,SAE1BI,EAAS,WAAW;CACnC,GAAG,CAACN,GAASE,CAAY,CAAC,GAEnB;EAAE,OAAOL,EAAK;EAAO,QAAQA,EAAK;EAAQ;CAAI;AACvD"}
+{"version":3,"file":"useCanvasSize.js","names":[],"sources":["../../../src/core/viewport/useCanvasSize.ts"],"sourcesContent":["import { type RefObject, useCallback, useEffect, useState } from 'react';\nimport type { CanvasSize } from './clampView';\nimport { useDeviceProfile } from '../device/useDeviceProfile';\n\n/** Size snapshot returned by `useCanvasSize` — the kit-wide `CanvasSize`\n *  (width × height in CSS pixels) plus the current devicePixelRatio. */\nexport interface CanvasSizeSnapshot extends CanvasSize {\n  dpr: number;\n}\n\n/** Track a container's content-rect size via `ResizeObserver`, and density via\n *  the ambient `DeviceProfile`.\n *\n *  Density deliberately does NOT come from a `window.devicePixelRatio` read\n *  inside the resize callback: that only refreshes when the element resizes,\n *  so dragging a window to a different-density display without resizing it\n *  leaves the snapshot stale. */\nexport function useCanvasSize(containerRef: RefObject<HTMLElement | null>): CanvasSizeSnapshot {\n  const { dpr } = useDeviceProfile();\n  const { width, height } = useElementSize(containerRef);\n  return { width, height, dpr };\n}\n\n/** An element's CSS-pixel size, `0 × 0` until it is mounted and measured.\n *  Re-measured whenever a `ResizeObserver` reports it resized. */\nexport function useElementSize(containerRef: RefObject<HTMLElement | null>): CanvasSize {\n  const [size, setSize] = useState<CanvasSize>({ width: 0, height: 0 });\n\n  const measure = useCallback(() => {\n    if (!containerRef.current) return;\n    const rect = containerRef.current.getBoundingClientRect();\n    setSize((prev) =>\n      prev.width === rect.width && prev.height === rect.height\n        ? prev\n        : { width: rect.width, height: rect.height },\n    );\n  }, [containerRef]);\n\n  useEffect(() => {\n    const el = containerRef.current;\n    if (!el) return;\n    measure();\n    // Absent under jsdom and in older embedders: one measurement is all there is.\n    if (typeof ResizeObserver === 'undefined') return;\n    const observer = new ResizeObserver(measure);\n    observer.observe(el);\n    return () => observer.disconnect();\n  }, [measure, containerRef]);\n\n  return size;\n}\n"],"mappings":";;;;;;;;;;;AAiBA,SAAgB,cAAc,cAAiE;CAC7F,MAAM,EAAE,QAAQ,iBAAiB;CACjC,MAAM,EAAE,OAAO,WAAW,eAAe,YAAY;CACrD,OAAO;EAAE;EAAO;EAAQ;CAAI;AAC9B;;;AAIA,SAAgB,eAAe,cAAyD;CACtF,MAAM,CAAC,MAAM,WAAW,SAAqB;EAAE,OAAO;EAAG,QAAQ;CAAE,CAAC;CAEpE,MAAM,UAAU,kBAAkB;EAChC,IAAI,CAAC,aAAa,SAAS;EAC3B,MAAM,OAAO,aAAa,QAAQ,sBAAsB;EACxD,SAAS,SACP,KAAK,UAAU,KAAK,SAAS,KAAK,WAAW,KAAK,SAC9C,OACA;GAAE,OAAO,KAAK;GAAO,QAAQ,KAAK;EAAO,CAC/C;CACF,GAAG,CAAC,YAAY,CAAC;CAEjB,gBAAgB;EACd,MAAM,KAAK,aAAa;EACxB,IAAI,CAAC,IAAI;EACT,QAAQ;EAER,IAAI,OAAO,mBAAmB,aAAa;EAC3C,MAAM,WAAW,IAAI,eAAe,OAAO;EAC3C,SAAS,QAAQ,EAAE;EACnB,aAAa,SAAS,WAAW;CACnC,GAAG,CAAC,SAAS,YAAY,CAAC;CAE1B,OAAO;AACT"}

package/dist/core/viewport/useDecayLoop.js

@@ -1,63 +1,133 @@
-import { useCallback as e, useEffect as t, useRef as n } from "react";
-import { useVisibleRaf as r } from "@weasel-js/react";
+import { useCallback, useEffect, useRef } from "react";
+import { useVisibleRaf } from "@weasel-js/react";
+
 //#region src/core/viewport/useDecayLoop.ts
-var i = .5;
-function a() {
-	let a = n(null), o = r((e) => {
-		c(e);
-	}, { onResume: e(() => {
-		a.current && (a.current.lastTime = null);
-	}, []) }), s = e(() => {
-		o.cancel(), a.current = null;
-	}, [o]), c = e((e) => {
-		let t = a.current;
-		if (!t) return;
-		if (t.lastTime === null) {
-			t.lastTime = e, o.request();
+/**
+* Fraction of velocity preserved per `'spring'` bounce. 0.5 means each bounce
+* loses half its energy, giving a quick visible settle (typically 2–4 bounces
+* before `minSpeed` cuts the loop). Fixed for v1; a future `bounceDamping`
+* config option could expose this if a consumer needs control.
+*/
+var SPRING_DAMPING = .5;
+/** A rAF loop that coasts a value to a stop under friction, reporting the
+*  per-frame delta. What turns a released pan drag into momentum scrolling. */
+function useDecayLoop() {
+	const stateRef = useRef(null);
+	const tick = useCallback((now, frameLoop) => {
+		const s = stateRef.current;
+		if (!s) return;
+		if (s.lastTime === null) {
+			s.lastTime = now;
+			frameLoop.request();
 			return;
 		}
-		let n = Math.min(e - t.lastTime, 64);
-		t.lastTime = e;
-		let r = t.friction ** (n / 16.67);
-		if (t.vx *= r, t.vy *= r, Math.sqrt(t.vx * t.vx + t.vy * t.vy) < t.minSpeed) {
-			a.current = null, o.cancel(), t.onEnd?.();
+		const dt = Math.min(now - s.lastTime, 64);
+		s.lastTime = now;
+		const f = Math.pow(s.friction, dt / 16.67);
+		s.vx *= f;
+		s.vy *= f;
+		if (Math.sqrt(s.vx * s.vx + s.vy * s.vy) < s.minSpeed) {
+			stateRef.current = null;
+			frameLoop.cancel();
+			s.onEnd?.();
 			return;
 		}
-		let s = t.vx * n, c = t.vy * n;
-		if (t.viewBounds && t.boundary) {
-			let { minX: e, maxX: n, minY: r, maxY: a } = t.viewBounds, o = t.posX + s, l = t.posY + c;
-			t.boundary === "stop" ? (e !== void 0 && o < e ? (s = e - t.posX, t.vx = 0) : n !== void 0 && o > n && (s = n - t.posX, t.vx = 0), r !== void 0 && l < r ? (c = r - t.posY, t.vy = 0) : a !== void 0 && l > a && (c = a - t.posY, t.vy = 0)) : t.boundary === "spring" ? (e !== void 0 && o < e ? (s = e - t.posX, t.vx = Math.abs(t.vx) * i) : n !== void 0 && o > n && (s = n - t.posX, t.vx = -Math.abs(t.vx) * i), r !== void 0 && l < r ? (c = r - t.posY, t.vy = Math.abs(t.vy) * i) : a !== void 0 && l > a && (c = a - t.posY, t.vy = -Math.abs(t.vy) * i)) : (e !== void 0 && o < e ? (s = e - t.posX, t.vx = Math.abs(t.vx)) : n !== void 0 && o > n && (s = n - t.posX, t.vx = -Math.abs(t.vx)), r !== void 0 && l < r ? (c = r - t.posY, t.vy = Math.abs(t.vy)) : a !== void 0 && l > a && (c = a - t.posY, t.vy = -Math.abs(t.vy))), t.posX += s, t.posY += c;
+		let dx = s.vx * dt;
+		let dy = s.vy * dt;
+		if (s.viewBounds && s.boundary) {
+			const { minX, maxX, minY, maxY } = s.viewBounds;
+			const newX = s.posX + dx;
+			const newY = s.posY + dy;
+			if (s.boundary === "stop") {
+				if (minX !== void 0 && newX < minX) {
+					dx = minX - s.posX;
+					s.vx = 0;
+				} else if (maxX !== void 0 && newX > maxX) {
+					dx = maxX - s.posX;
+					s.vx = 0;
+				}
+				if (minY !== void 0 && newY < minY) {
+					dy = minY - s.posY;
+					s.vy = 0;
+				} else if (maxY !== void 0 && newY > maxY) {
+					dy = maxY - s.posY;
+					s.vy = 0;
+				}
+			} else if (s.boundary === "spring") {
+				if (minX !== void 0 && newX < minX) {
+					dx = minX - s.posX;
+					s.vx = Math.abs(s.vx) * SPRING_DAMPING;
+				} else if (maxX !== void 0 && newX > maxX) {
+					dx = maxX - s.posX;
+					s.vx = -Math.abs(s.vx) * SPRING_DAMPING;
+				}
+				if (minY !== void 0 && newY < minY) {
+					dy = minY - s.posY;
+					s.vy = Math.abs(s.vy) * SPRING_DAMPING;
+				} else if (maxY !== void 0 && newY > maxY) {
+					dy = maxY - s.posY;
+					s.vy = -Math.abs(s.vy) * SPRING_DAMPING;
+				}
+			} else {
+				if (minX !== void 0 && newX < minX) {
+					dx = minX - s.posX;
+					s.vx = Math.abs(s.vx);
+				} else if (maxX !== void 0 && newX > maxX) {
+					dx = maxX - s.posX;
+					s.vx = -Math.abs(s.vx);
+				}
+				if (minY !== void 0 && newY < minY) {
+					dy = minY - s.posY;
+					s.vy = Math.abs(s.vy);
+				} else if (maxY !== void 0 && newY > maxY) {
+					dy = maxY - s.posY;
+					s.vy = -Math.abs(s.vy);
+				}
+			}
+			s.posX += dx;
+			s.posY += dy;
 		}
-		t.onTick(s, c), o.request();
-	}, [o]), l = e((e) => {
-		s();
-		let { velocity: t, friction: n = .92, minSpeed: r = .01, viewBounds: i, boundary: c, initialPosition: l, onTick: u, onEnd: d } = e;
-		if (Math.sqrt(t.vx ** 2 + t.vy ** 2) < r) {
-			d?.();
+		s.onTick(dx, dy);
+		frameLoop.request();
+	}, []);
+	const frameLoop = useVisibleRaf(tick, { onResume: useCallback(() => {
+		if (stateRef.current) stateRef.current.lastTime = null;
+	}, []) });
+	const cancel = useCallback(() => {
+		frameLoop.cancel();
+		stateRef.current = null;
+	}, [frameLoop]);
+	const start = useCallback((config) => {
+		cancel();
+		const { velocity, friction = .92, minSpeed = .01, viewBounds, boundary, initialPosition, onTick, onEnd } = config;
+		if (Math.sqrt(velocity.vx ** 2 + velocity.vy ** 2) < minSpeed) {
+			onEnd?.();
 			return;
 		}
-		a.current = {
-			vx: t.vx,
-			vy: t.vy,
-			friction: n,
-			minSpeed: r,
+		stateRef.current = {
+			vx: velocity.vx,
+			vy: velocity.vy,
+			friction,
+			minSpeed,
 			lastTime: null,
-			posX: l?.x ?? 0,
-			posY: l?.y ?? 0,
-			viewBounds: i,
-			boundary: c,
-			onTick: u,
-			onEnd: d
-		}, o.request();
-	}, [s, o]);
-	return t(() => () => {
-		s();
-	}, [s]), {
-		start: l,
-		cancel: s
+			posX: initialPosition?.x ?? 0,
+			posY: initialPosition?.y ?? 0,
+			viewBounds,
+			boundary,
+			onTick,
+			onEnd
+		};
+		frameLoop.request();
+	}, [cancel, frameLoop]);
+	useEffect(() => () => {
+		cancel();
+	}, [cancel]);
+	return {
+		start,
+		cancel
 	};
 }
-//#endregion
-export { a as useDecayLoop };
 
+//#endregion
+export { useDecayLoop };
 //# sourceMappingURL=useDecayLoop.js.map

package/dist/core/viewport/useDecayLoop.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDecayLoop.js","names":["SPRING_DAMPING","useDecayLoop","stateRef","useRef","frameLoop","useVisibleRaf","now","useCallback","cancel","tick","s","dt","f","dx","dy","newX","newY","minX","maxX","minY","maxY","start","config","velocity","minSpeed","initialPosition","useEffect"],"sources":["../../../src/core/viewport/useDecayLoop.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nimport { useVisibleRaf } from '@weasel-js/react';\n\n/** Per-axis limits on a view's position. Any side may be left open. */\nexport interface PanBounds {\n  minX?: number;\n  maxX?: number;\n  minY?: number;\n  maxY?: number;\n}\n\n/** Momentum settings for a pan: how quickly a flung view slows, when it stops,\n *  and what happens at the pan limits. The `DecayLoopConfig` fields a caller\n *  chooses up front, without the per-gesture `velocity` / `onTick`. */\nexport interface InertiaConfig {\n  friction?: number;\n  minSpeed?: number;\n  /** What to do when inertial pan reaches `bounds`. Default: no clamping. */\n  boundary?: 'stop' | 'bounce' | 'spring';\n  /** View-coordinate limits for boundary clamping. Requires `boundary` to take effect. */\n  bounds?: PanBounds;\n}\n\n/** How a decay should run: its starting velocity, how fast it slows, and what\n *  happens if it reaches the pan limits. */\nexport interface DecayLoopConfig {\n  velocity: { vx: number; vy: number };\n  friction?: number;\n  minSpeed?: number;\n  /** Bounds for boundary clamping. Requires `boundary` to take effect. */\n  viewBounds?: PanBounds;\n  /**\n   * What to do when the accumulated position hits `viewBounds`. Default: no clamping.\n   * - `'stop'`: clamp at boundary, kill velocity component.\n   * - `'bounce'`: linear reflection — flip velocity sign, magnitude preserved.\n   * - `'spring'`: damped reflection — flip velocity sign and shrink magnitude\n   *   by `SPRING_DAMPING` per bounce so the motion settles naturally.\n   */\n  boundary?: 'stop' | 'bounce' | 'spring';\n  /** Starting position for internal boundary tracking. Required when `viewBounds` is set. */\n  initialPosition?: { x: number; y: number };\n  onTick: (dx: number, dy: number) => void;\n  onEnd?: () => void;\n}\n\n/**\n * Fraction of velocity preserved per `'spring'` bounce. 0.5 means each bounce\n * loses half its energy, giving a quick visible settle (typically 2–4 bounces\n * before `minSpeed` cuts the loop). Fixed for v1; a future `bounceDamping`\n * config option could expose this if a consumer needs control.\n */\nconst SPRING_DAMPING = 0.5;\n\n/** A rAF loop that coasts a value to a stop under friction, reporting the\n *  per-frame delta. What turns a released pan drag into momentum scrolling. */\nexport function useDecayLoop() {\n  const stateRef = useRef<{\n    vx: number; vy: number;\n    friction: number; minSpeed: number;\n    lastTime: number | null;\n    posX: number; posY: number;\n    viewBounds: PanBounds | undefined;\n    boundary: 'stop' | 'bounce' | 'spring' | undefined;\n    onTick: (dx: number, dy: number) => void;\n    onEnd?: () => void;\n  } | null>(null);\n\n  const frameLoop = useVisibleRaf(\n    (now: number) => { tick(now); },\n    {\n      // Coasting does not continue while suspended: dropping `lastTime` makes\n      // the resuming frame seed a fresh interval instead of applying an hour of\n      // friction at once, which would end the decay before it was seen.\n      onResume: useCallback(() => {\n        if (stateRef.current) stateRef.current.lastTime = null;\n      }, []),\n    },\n  );\n\n  const cancel = useCallback(() => {\n    frameLoop.cancel();\n    stateRef.current = null;\n  }, [frameLoop]);\n\n  const tick = useCallback((now: number) => {\n    const s = stateRef.current;\n    if (!s) return;\n    if (s.lastTime === null) {\n      s.lastTime = now;\n      frameLoop.request();\n      return;\n    }\n    const dt = Math.min(now - s.lastTime, 64);  // cap at 64ms to avoid huge jumps\n    s.lastTime = now;\n    // Time-normalize friction to 60fps baseline\n    const f = Math.pow(s.friction, dt / 16.67);\n    s.vx *= f;\n    s.vy *= f;\n    const speed = Math.sqrt(s.vx * s.vx + s.vy * s.vy);\n    if (speed < s.minSpeed) {\n      stateRef.current = null;\n      frameLoop.cancel();\n      s.onEnd?.();\n      return;\n    }\n    let dx = s.vx * dt;\n    let dy = s.vy * dt;\n    if (s.viewBounds && s.boundary) {\n      const { minX, maxX, minY, maxY } = s.viewBounds;\n      const newX = s.posX + dx;\n      const newY = s.posY + dy;\n      if (s.boundary === 'stop') {\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = 0; }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = 0; }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = 0; }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = 0; }\n      } else if (s.boundary === 'spring') {\n        // Damped reflection: flip sign AND scale magnitude by SPRING_DAMPING so\n        // each bounce loses energy. Once |v| < minSpeed the outer loop ends.\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = Math.abs(s.vx) * SPRING_DAMPING; }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = -Math.abs(s.vx) * SPRING_DAMPING; }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = Math.abs(s.vy) * SPRING_DAMPING; }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = -Math.abs(s.vy) * SPRING_DAMPING; }\n      } else {\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = Math.abs(s.vx); }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = -Math.abs(s.vx); }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = Math.abs(s.vy); }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = -Math.abs(s.vy); }\n      }\n      s.posX += dx;\n      s.posY += dy;\n    }\n    s.onTick(dx, dy);\n    frameLoop.request();\n  }, [frameLoop]);\n\n  const start = useCallback((config: DecayLoopConfig) => {\n    cancel();\n    const { velocity, friction = 0.92, minSpeed = 0.01, viewBounds, boundary, initialPosition, onTick, onEnd } = config;\n    const speed = Math.sqrt(velocity.vx ** 2 + velocity.vy ** 2);\n    if (speed < minSpeed) { onEnd?.(); return; }\n    stateRef.current = {\n      vx: velocity.vx, vy: velocity.vy, friction, minSpeed, lastTime: null,\n      posX: initialPosition?.x ?? 0, posY: initialPosition?.y ?? 0,\n      viewBounds, boundary,\n      onTick, onEnd,\n    };\n    frameLoop.request();\n  }, [cancel, frameLoop]);\n\n  useEffect(() => () => { cancel(); }, [cancel]);\n\n  return { start, cancel };\n}\n"],"mappings":"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"}
+{"version":3,"file":"useDecayLoop.js","names":[],"sources":["../../../src/core/viewport/useDecayLoop.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nimport { useVisibleRaf, type VisibleRaf } from '@weasel-js/react';\n\n/** Per-axis limits on a view's position. Any side may be left open. */\nexport interface PanBounds {\n  minX?: number;\n  maxX?: number;\n  minY?: number;\n  maxY?: number;\n}\n\n/** Momentum settings for a pan: how quickly a flung view slows, when it stops,\n *  and what happens at the pan limits. The `DecayLoopConfig` fields a caller\n *  chooses up front, without the per-gesture `velocity` / `onTick`. */\nexport interface InertiaConfig {\n  friction?: number;\n  minSpeed?: number;\n  /** What to do when inertial pan reaches `bounds`. Default: no clamping. */\n  boundary?: 'stop' | 'bounce' | 'spring';\n  /** View-coordinate limits for boundary clamping. Requires `boundary` to take effect. */\n  bounds?: PanBounds;\n}\n\n/** How a decay should run: its starting velocity, how fast it slows, and what\n *  happens if it reaches the pan limits. */\nexport interface DecayLoopConfig {\n  velocity: { vx: number; vy: number };\n  friction?: number;\n  minSpeed?: number;\n  /** Bounds for boundary clamping. Requires `boundary` to take effect. */\n  viewBounds?: PanBounds;\n  /**\n   * What to do when the accumulated position hits `viewBounds`. Default: no clamping.\n   * - `'stop'`: clamp at boundary, kill velocity component.\n   * - `'bounce'`: linear reflection — flip velocity sign, magnitude preserved.\n   * - `'spring'`: damped reflection — flip velocity sign and shrink magnitude\n   *   by `SPRING_DAMPING` per bounce so the motion settles naturally.\n   */\n  boundary?: 'stop' | 'bounce' | 'spring';\n  /** Starting position for internal boundary tracking. Required when `viewBounds` is set. */\n  initialPosition?: { x: number; y: number };\n  onTick: (dx: number, dy: number) => void;\n  onEnd?: () => void;\n}\n\n/**\n * Fraction of velocity preserved per `'spring'` bounce. 0.5 means each bounce\n * loses half its energy, giving a quick visible settle (typically 2–4 bounces\n * before `minSpeed` cuts the loop). Fixed for v1; a future `bounceDamping`\n * config option could expose this if a consumer needs control.\n */\nconst SPRING_DAMPING = 0.5;\n\n/** A rAF loop that coasts a value to a stop under friction, reporting the\n *  per-frame delta. What turns a released pan drag into momentum scrolling. */\nexport function useDecayLoop() {\n  const stateRef = useRef<{\n    vx: number; vy: number;\n    friction: number; minSpeed: number;\n    lastTime: number | null;\n    posX: number; posY: number;\n    viewBounds: PanBounds | undefined;\n    boundary: 'stop' | 'bounce' | 'spring' | undefined;\n    onTick: (dx: number, dy: number) => void;\n    onEnd?: () => void;\n  } | null>(null);\n\n  const tick = useCallback((now: number, frameLoop: VisibleRaf) => {\n    const s = stateRef.current;\n    if (!s) return;\n    if (s.lastTime === null) {\n      s.lastTime = now;\n      frameLoop.request();\n      return;\n    }\n    const dt = Math.min(now - s.lastTime, 64);  // cap at 64ms to avoid huge jumps\n    s.lastTime = now;\n    // Time-normalize friction to 60fps baseline\n    const f = Math.pow(s.friction, dt / 16.67);\n    s.vx *= f;\n    s.vy *= f;\n    const speed = Math.sqrt(s.vx * s.vx + s.vy * s.vy);\n    if (speed < s.minSpeed) {\n      stateRef.current = null;\n      frameLoop.cancel();\n      s.onEnd?.();\n      return;\n    }\n    let dx = s.vx * dt;\n    let dy = s.vy * dt;\n    if (s.viewBounds && s.boundary) {\n      const { minX, maxX, minY, maxY } = s.viewBounds;\n      const newX = s.posX + dx;\n      const newY = s.posY + dy;\n      if (s.boundary === 'stop') {\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = 0; }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = 0; }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = 0; }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = 0; }\n      } else if (s.boundary === 'spring') {\n        // Damped reflection: flip sign AND scale magnitude by SPRING_DAMPING so\n        // each bounce loses energy. Once |v| < minSpeed the outer loop ends.\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = Math.abs(s.vx) * SPRING_DAMPING; }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = -Math.abs(s.vx) * SPRING_DAMPING; }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = Math.abs(s.vy) * SPRING_DAMPING; }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = -Math.abs(s.vy) * SPRING_DAMPING; }\n      } else {\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = Math.abs(s.vx); }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = -Math.abs(s.vx); }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = Math.abs(s.vy); }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = -Math.abs(s.vy); }\n      }\n      s.posX += dx;\n      s.posY += dy;\n    }\n    s.onTick(dx, dy);\n    frameLoop.request();\n  }, []);\n\n  const frameLoop = useVisibleRaf(\n    tick,\n    {\n      // Coasting does not continue while suspended: dropping `lastTime` makes\n      // the resuming frame seed a fresh interval instead of applying an hour of\n      // friction at once, which would end the decay before it was seen.\n      onResume: useCallback(() => {\n        if (stateRef.current) stateRef.current.lastTime = null;\n      }, []),\n    },\n  );\n\n  const cancel = useCallback(() => {\n    frameLoop.cancel();\n    stateRef.current = null;\n  }, [frameLoop]);\n\n  const start = useCallback((config: DecayLoopConfig) => {\n    cancel();\n    const { velocity, friction = 0.92, minSpeed = 0.01, viewBounds, boundary, initialPosition, onTick, onEnd } = config;\n    const speed = Math.sqrt(velocity.vx ** 2 + velocity.vy ** 2);\n    if (speed < minSpeed) { onEnd?.(); return; }\n    stateRef.current = {\n      vx: velocity.vx, vy: velocity.vy, friction, minSpeed, lastTime: null,\n      posX: initialPosition?.x ?? 0, posY: initialPosition?.y ?? 0,\n      viewBounds, boundary,\n      onTick, onEnd,\n    };\n    frameLoop.request();\n  }, [cancel, frameLoop]);\n\n  useEffect(() => () => { cancel(); }, [cancel]);\n\n  return { start, cancel };\n}\n"],"mappings":"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"}

package/dist/core/viewport/useNodeOverlayFrame.js

@@ -1,66 +1,101 @@
-import { useCanvasSize as e } from "./useCanvasSize.js";
-import { composeWorldPose as t } from "../scene/composeFrame.js";
-import { composeRectPose as n } from "../scene/composePose.js";
-import { effectivePose as r } from "../scene/effectivePose.js";
-import { applyToPoint as i, invert as a, multiply as o, poseFrameOf as s } from "@weasel-js/geom";
-import { useCallback as c, useInsertionEffect as l, useRef as u } from "react";
+import { useCanvasSize } from "./useCanvasSize.js";
+import { composeWorldPose } from "../scene/composeFrame.js";
+import { composeRectPose } from "../scene/composePose.js";
+import { effectivePose } from "../scene/effectivePose.js";
+import { applyToPoint, invert, multiply, poseFrameOf } from "@weasel-js/geom";
+import { useCallback, useInsertionEffect, useRef } from "react";
+
 //#region src/core/viewport/useNodeOverlayFrame.ts
-function d(t, n, r, d = {}) {
-	let { width: h, height: g } = e(n), { view: _, compose: v } = d, y = c(() => {
-		let e = p(t, r, v);
-		if (!e) return null;
-		let n = s(e), i = m(f(_));
-		return n ? o(i, n) : i;
+/**
+* `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one
+* scene node needs: the node's world box, the projection from that box's
+* frame into overlay pixels, and the overlay's measured size.
+*
+* `toScreen` maps the node's **unrotated world box** frame, which is the
+* frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the
+* one `pathInPoseFrame` projects geometry into. The pose's rotation and
+* `transform` live in this hook, not in those: a node's stored geometry is
+* in its box by definition.
+*/
+/**
+* Resolve the overlay frame for `nodeId` against `containerRef` — the element
+* the overlay is positioned in, which must be the canvas's own box for the
+* projection to land.
+*
+* Returns `null` when there is no node under `nodeId`, when the container has
+* not been measured, or when the view or the pose's `transform` collapses an
+* axis to zero.
+*/
+function useNodeOverlayFrame(scene, containerRef, nodeId, options = {}) {
+	const { width, height } = useCanvasSize(containerRef);
+	const { view, compose } = options;
+	const project = useCallback(() => {
+		const box = worldBoxOf(scene, nodeId, compose);
+		if (!box) return null;
+		const frame = poseFrameOf(box);
+		const toView = viewMatrix(resolveView(view));
+		return frame ? multiply(toView, frame) : toView;
 	}, [
-		t,
-		r,
-		v,
-		_
-	]), b = c((e) => {
-		let t = y();
-		if (!t) return e;
-		let [n, r] = i(t, e.x, e.y);
+		scene,
+		nodeId,
+		compose,
+		view
+	]);
+	const toScreen = useCallback((p) => {
+		const m = project();
+		if (!m) return p;
+		const [x, y] = applyToPoint(m, p.x, p.y);
 		return {
-			x: n,
-			y: r
+			x,
+			y
 		};
-	}, [y]), x = u(null), S = c((e) => {
-		let t = y(), n = t && a(t);
-		n && (x.current = n);
-		let [r, o] = i(n ?? x.current, e.x, e.y);
+	}, [project]);
+	const lastInverse = useRef(null);
+	const toLocal = useCallback((p) => {
+		const m = project();
+		const inverse = m && invert(m);
+		if (inverse) lastInverse.current = inverse;
+		const [x, y] = applyToPoint(inverse ?? lastInverse.current, p.x, p.y);
 		return {
-			x: r,
-			y: o
+			x,
+			y
 		};
-	}, [y]), C = p(t, r, v), w = C && h !== 0 && g !== 0 ? y() : null, T = w && a(w);
-	return l(() => {
-		T && (x.current = T);
-	}), !C || !T ? null : {
+	}, [project]);
+	const box = worldBoxOf(scene, nodeId, compose);
+	const m = box && width !== 0 && height !== 0 ? project() : null;
+	const inverse = m && invert(m);
+	useInsertionEffect(() => {
+		if (inverse) lastInverse.current = inverse;
+	});
+	if (!box || !inverse) return null;
+	return {
 		box: {
-			x: C.x,
-			y: C.y,
-			width: C.width,
-			height: C.height
+			x: box.x,
+			y: box.y,
+			width: box.width,
+			height: box.height
 		},
-		toScreen: b,
-		toLocal: S,
-		width: h,
-		height: g
+		toScreen,
+		toLocal,
+		width,
+		height
 	};
 }
-function f(e) {
-	return typeof e == "function" ? e() : e;
+function resolveView(view) {
+	return typeof view === "function" ? view() : view;
 }
-function p(e, i, a) {
-	if (i == null) return null;
-	let o = e.nodes;
-	return o.has(i) ? t({
-		getPose: (t) => r(e, o.get(t)),
-		getParent: (e) => o.get(e)?.parent ?? null
-	}, i, a ?? n) : null;
+function worldBoxOf(scene, nodeId, compose) {
+	if (nodeId == null) return null;
+	const nodes = scene.nodes;
+	if (!nodes.has(nodeId)) return null;
+	return composeWorldPose({
+		getPose: (id) => effectivePose(scene, nodes.get(id)),
+		getParent: (id) => nodes.get(id)?.parent ?? null
+	}, nodeId, compose ?? composeRectPose);
 }
-function m(e) {
-	if (!e) return [
+/** World → overlay pixels: `screen = (world − view) × view.scale`. */
+function viewMatrix(view) {
+	if (!view) return [
 		1,
 		0,
 		0,
@@ -68,17 +103,17 @@ function m(e) {
 		0,
 		0
 	];
-	let { x: t, y: n } = e.scale;
+	const { x: sx, y: sy } = view.scale;
 	return [
-		t,
+		sx,
 		0,
 		0,
-		n,
-		-e.x * t,
-		-e.y * n
+		sy,
+		-view.x * sx,
+		-view.y * sy
 	];
 }
-//#endregion
-export { d as useNodeOverlayFrame };
 
+//#endregion
+export { useNodeOverlayFrame };
 //# sourceMappingURL=useNodeOverlayFrame.js.map

package/dist/core/viewport/useNodeOverlayFrame.js.map

@@ -1 +1 @@
-{"version":3,"file":"useNodeOverlayFrame.js","names":["useNodeOverlayFrame","useCanvasSize","containerRef","options","project","useCallback","box","worldBoxOf","scene","nodeId","compose","frame","poseFrameOf","toView","viewMatrix","resolveView","view","multiply","toScreen","m","p","x","y","applyToPoint","lastInverse","useRef","toLocal","inverse","invert","width","height","useInsertionEffect","nodes","composeWorldPose","effectivePose","id","composeRectPose","sx","sy"],"sources":["../../../src/core/viewport/useNodeOverlayFrame.ts"],"sourcesContent":["/**\n * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one\n * scene node needs: the node's world box, the projection from that box's\n * frame into overlay pixels, and the overlay's measured size.\n *\n * `toScreen` maps the node's **unrotated world box** frame, which is the\n * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the\n * one `pathInPoseFrame` projects geometry into. The pose's rotation and\n * `transform` live in this hook, not in those: a node's stored geometry is\n * in its box by definition.\n */\nimport { useCallback, useInsertionEffect, useRef, type RefObject } from 'react';\nimport { applyToPoint, invert, multiply, poseFrameOf, type Mat3 } from '@weasel-js/geom';\nimport type { Node, RectPose, Scene } from '../scene/types';\nimport { useCanvasSize } from './useCanvasSize';\nimport type { View } from './view';\nimport { composeRectPose, composeWorldPose } from 'core/scene/composePose';\nimport { effectivePose } from 'core/scene/effectivePose';\n\n/** Structural point, matching every other `{ x, y }` the kit passes across a\n *  boundary. */\nexport interface OverlayPoint {\n  x: number;\n  y: number;\n}\n\n/** The overlay frame for one node. `null` from the hook means there is no\n *  frame yet — no node, or nothing measured to draw it on. */\nexport interface NodeOverlayFrame {\n  /** The node's composed world box, **unrotated**: the frame `toScreen` maps\n   *  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. */\n  box: { x: number; y: number; width: number; height: number };\n  /** Node box frame → overlay pixels: the pose's rotation and `transform`,\n   *  then the view. */\n  toScreen: (p: OverlayPoint) => OverlayPoint;\n  /** Overlay pixels → node box frame. Inverts `toScreen`; while a live view\n   *  flattens an axis, it keeps the last mapping that had an inverse. */\n  toLocal: (p: OverlayPoint) => OverlayPoint;\n  /** The container's size in CSS pixels — the overlay's own box. */\n  width: number;\n  height: number;\n}\n\n/** Options for `useNodeOverlayFrame`. */\nexport interface UseNodeOverlayFrameOptions<TPose> {\n  /**\n   * Current viewport. A thunk is re-read on every projection, which is what\n   * an uncontrolled `SceneCanvas` needs — its camera moves without a render,\n   * so pass the handle's `getView`. Omit it and world units are handed\n   * through as screen pixels.\n   */\n  view?: View | (() => View);\n  /** Fold a child pose into its parent's frame. Default `composeRectPose`. */\n  compose?: (parent: TPose, child: TPose) => TPose;\n}\n\n/**\n * Resolve the overlay frame for `nodeId` against `containerRef` — the element\n * the overlay is positioned in, which must be the canvas's own box for the\n * projection to land.\n *\n * Returns `null` when there is no node under `nodeId`, when the container has\n * not been measured, or when the view or the pose's `transform` collapses an\n * axis to zero.\n */\nexport function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  containerRef: RefObject<HTMLElement | null>,\n  nodeId: string | null | undefined,\n  options: UseNodeOverlayFrameOptions<TPose> = {},\n): NodeOverlayFrame | null {\n  const { width, height } = useCanvasSize(containerRef);\n  const { view, compose } = options;\n\n  const project = useCallback((): Mat3 | null => {\n    const box = worldBoxOf(scene, nodeId, compose);\n    if (!box) return null;\n    const frame = poseFrameOf(box);\n    const toView = viewMatrix(resolveView(view));\n    return frame ? multiply(toView, frame) : toView;\n  }, [scene, nodeId, compose, view]);\n\n  const toScreen = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    if (!m) return p;\n    const [x, y] = applyToPoint(m, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const lastInverse = useRef<Mat3 | null>(null);\n\n  const toLocal = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    const inverse = m && invert(m);\n    if (inverse) lastInverse.current = inverse;\n    // Published by the commit that handed this toLocal out, so there is one.\n    const [x, y] = applyToPoint(inverse ?? lastInverse.current!, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const box = worldBoxOf(scene, nodeId, compose);\n  const m = box && width !== 0 && height !== 0 ? project() : null;\n  const inverse = m && invert(m);\n  useInsertionEffect(() => {\n    if (inverse) lastInverse.current = inverse;\n  });\n\n  if (!box || !inverse) return null;\n  return { box: { x: box.x, y: box.y, width: box.width, height: box.height }, toScreen, toLocal, width, height };\n}\n\nfunction resolveView(view: View | (() => View) | undefined): View | undefined {\n  return typeof view === 'function' ? view() : view;\n}\n\nfunction worldBoxOf<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  nodeId: string | null | undefined,\n  compose: ((parent: TPose, child: TPose) => TPose) | undefined,\n): TPose | null {\n  if (nodeId == null) return null;\n  const nodes = scene.nodes as ReadonlyMap<string, Node<TData, TLayer, TPose>>;\n  if (!nodes.has(nodeId)) return null;\n  // `effectivePose`, not `node.pose`: an overlay tracks what the renderer\n  // draws, and a gesture override or a derived pose is exactly the difference.\n  const adapter = {\n    getPose: (id: string) => effectivePose(scene, nodes.get(id)!),\n    getParent: (id: string) => nodes.get(id)?.parent ?? null,\n  };\n  return composeWorldPose(adapter, nodeId, compose ?? composeRectPose);\n}\n\n/** World → overlay pixels: `screen = (world − view) × view.scale`. */\nfunction viewMatrix(view: View | undefined): Mat3 {\n  if (!view) return [1, 0, 0, 1, 0, 0];\n  const { x: sx, y: sy } = view.scale;\n  return [sx, 0, 0, sy, -view.x * sx, -view.y * sy];\n}\n"],"mappings":";;;;;;;AAiEA,SAAgBA,EACd,GACA,GACA,GACA,IAA6C,CAAC,GACrB;CACzB,IAAM,EAAE,UAAO,cAAWC,EAAcC,CAAY,GAC9C,EAAE,SAAM,eAAYC,GAEpBC,IAAUC,QAA+B;EAC7C,IAAMC,IAAMC,EAAWC,GAAOC,GAAQC,CAAO;EAC7C,IAAI,CAACJ,GAAK,OAAO;EACjB,IAAMK,IAAQC,EAAYN,CAAG,GACvBO,IAASC,EAAWC,EAAYC,CAAI,CAAC;EAC3C,OAAOL,IAAQM,EAASJ,GAAQF,CAAK,IAAIE;CAC3C,GAAG;EAACL;EAAOC;EAAQC;EAASM;CAAI,CAAC,GAE3BE,IAAWb,GAAa,MAAkC;EAC9D,IAAMc,IAAIf,EAAQ;EAClB,IAAI,CAACe,GAAG,OAAOC;EACf,IAAM,CAACC,GAAGC,KAAKC,EAAaJ,GAAGC,EAAE,GAAGA,EAAE,CAAC;EACvC,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAAChB,CAAO,CAAC,GAENoB,IAAcC,EAAoB,IAAI,GAEtCC,IAAUrB,GAAa,MAAkC;EAC7D,IAAMc,IAAIf,EAAQ,GACZuB,IAAUR,KAAKS,EAAOT,CAAC;EAC7B,AAAIQ,MAAS,EAAY,UAAUA;EAEnC,IAAM,CAACN,GAAGC,KAAKC,EAAaI,KAAWH,EAAY,SAAUJ,EAAE,GAAGA,EAAE,CAAC;EACrE,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAAChB,CAAO,CAAC,GAENE,IAAMC,EAAWC,GAAOC,GAAQC,CAAO,GACvCS,IAAIb,KAAOuB,MAAU,KAAKC,MAAW,IAAI1B,EAAQ,IAAI,MACrDuB,IAAUR,KAAKS,EAAOT,CAAC;CAM7B,OALAY,QAAyB;EACvB,AAAIJ,MAAS,EAAY,UAAUA;CACrC,CAAC,GAEG,CAACrB,KAAO,CAACqB,IAAgB,OACtB;EAAE,KAAK;GAAE,GAAGrB,EAAI;GAAG,GAAGA,EAAI;GAAG,OAAOA,EAAI;GAAO,QAAQA,EAAI;EAAO;EAAG;EAAU;EAAS;EAAO;CAAO;AAC/G;AAEA,SAASS,EAAY,GAAyD;CAC5E,OAAO,OAAOC,KAAS,aAAaA,EAAK,IAAIA;AAC/C;AAEA,SAAST,EACP,GACA,GACA,GACc;CACd,IAAIE,KAAU,MAAM,OAAO;CAC3B,IAAMuB,IAAQxB,EAAM;CAQpB,OAPKwB,EAAM,IAAIvB,CAAM,IAOdwB,EAAiB;EAHtB,UAAU,MAAeC,EAAc1B,GAAOwB,EAAM,IAAIG,CAAE,CAAE;EAC5D,YAAY,MAAeH,EAAM,IAAIG,CAAE,CAAC,EAAE,UAAU;CAE9B,GAAS1B,GAAQC,KAAW0B,CAAe,IAPpC;AAQjC;AAGA,SAAStB,EAAW,GAA8B;CAChD,IAAI,CAACE,GAAM,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CACnC,IAAM,EAAE,GAAGqB,GAAI,GAAGC,MAAOtB,EAAK;CAC9B,OAAO;EAACqB;EAAI;EAAG;EAAGC;EAAI,CAACtB,EAAK,IAAIqB;EAAI,CAACrB,EAAK,IAAIsB;CAAE;AAClD"}
+{"version":3,"file":"useNodeOverlayFrame.js","names":[],"sources":["../../../src/core/viewport/useNodeOverlayFrame.ts"],"sourcesContent":["/**\n * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one\n * scene node needs: the node's world box, the projection from that box's\n * frame into overlay pixels, and the overlay's measured size.\n *\n * `toScreen` maps the node's **unrotated world box** frame, which is the\n * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the\n * one `pathInPoseFrame` projects geometry into. The pose's rotation and\n * `transform` live in this hook, not in those: a node's stored geometry is\n * in its box by definition.\n */\nimport { useCallback, useInsertionEffect, useRef, type RefObject } from 'react';\nimport { applyToPoint, invert, multiply, poseFrameOf, type Affine } from '@weasel-js/geom';\nimport type { Node, RectPose, Scene } from '../scene/types';\nimport { useCanvasSize } from './useCanvasSize';\nimport type { View } from './view';\nimport { composeRectPose, composeWorldPose } from 'core/scene/composePose';\nimport { effectivePose } from 'core/scene/effectivePose';\n\n/** Structural point, matching every other `{ x, y }` the kit passes across a\n *  boundary. */\nexport interface OverlayPoint {\n  x: number;\n  y: number;\n}\n\n/** The overlay frame for one node. `null` from the hook means there is no\n *  frame yet — no node, or nothing measured to draw it on. */\nexport interface NodeOverlayFrame {\n  /** The node's composed world box, **unrotated**: the frame `toScreen` maps\n   *  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. */\n  box: { x: number; y: number; width: number; height: number };\n  /** Node box frame → overlay pixels: the pose's rotation and `transform`,\n   *  then the view. */\n  toScreen: (p: OverlayPoint) => OverlayPoint;\n  /** Overlay pixels → node box frame. Inverts `toScreen`; while a live view\n   *  flattens an axis, it keeps the last mapping that had an inverse. */\n  toLocal: (p: OverlayPoint) => OverlayPoint;\n  /** The container's size in CSS pixels — the overlay's own box. */\n  width: number;\n  height: number;\n}\n\n/** Options for `useNodeOverlayFrame`. */\nexport interface UseNodeOverlayFrameOptions<TPose> {\n  /**\n   * Current viewport. A thunk is re-read on every projection, which is what\n   * an uncontrolled `SceneCanvas` needs — its camera moves without a render,\n   * so pass the handle's `getView`. Omit it and world units are handed\n   * through as screen pixels.\n   */\n  view?: View | (() => View);\n  /** Fold a child pose into its parent's frame. Default `composeRectPose`. */\n  compose?: (parent: TPose, child: TPose) => TPose;\n}\n\n/**\n * Resolve the overlay frame for `nodeId` against `containerRef` — the element\n * the overlay is positioned in, which must be the canvas's own box for the\n * projection to land.\n *\n * Returns `null` when there is no node under `nodeId`, when the container has\n * not been measured, or when the view or the pose's `transform` collapses an\n * axis to zero.\n */\nexport function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  containerRef: RefObject<HTMLElement | null>,\n  nodeId: string | null | undefined,\n  options: UseNodeOverlayFrameOptions<TPose> = {},\n): NodeOverlayFrame | null {\n  const { width, height } = useCanvasSize(containerRef);\n  const { view, compose } = options;\n\n  const project = useCallback((): Affine | null => {\n    const box = worldBoxOf(scene, nodeId, compose);\n    if (!box) return null;\n    const frame = poseFrameOf(box);\n    const toView = viewMatrix(resolveView(view));\n    return frame ? multiply(toView, frame) : toView;\n  }, [scene, nodeId, compose, view]);\n\n  const toScreen = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    if (!m) return p;\n    const [x, y] = applyToPoint(m, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const lastInverse = useRef<Affine | null>(null);\n\n  const toLocal = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    const inverse = m && invert(m);\n    if (inverse) lastInverse.current = inverse;\n    // Published by the commit that handed this toLocal out, so there is one.\n    const [x, y] = applyToPoint(inverse ?? lastInverse.current!, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const box = worldBoxOf(scene, nodeId, compose);\n  const m = box && width !== 0 && height !== 0 ? project() : null;\n  const inverse = m && invert(m);\n  useInsertionEffect(() => {\n    if (inverse) lastInverse.current = inverse;\n  });\n\n  if (!box || !inverse) return null;\n  return { box: { x: box.x, y: box.y, width: box.width, height: box.height }, toScreen, toLocal, width, height };\n}\n\nfunction resolveView(view: View | (() => View) | undefined): View | undefined {\n  return typeof view === 'function' ? view() : view;\n}\n\nfunction worldBoxOf<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  nodeId: string | null | undefined,\n  compose: ((parent: TPose, child: TPose) => TPose) | undefined,\n): TPose | null {\n  if (nodeId == null) return null;\n  const nodes = scene.nodes as ReadonlyMap<string, Node<TData, TLayer, TPose>>;\n  if (!nodes.has(nodeId)) return null;\n  // `effectivePose`, not `node.pose`: an overlay tracks what the renderer\n  // draws, and a gesture override or a derived pose is exactly the difference.\n  const adapter = {\n    getPose: (id: string) => effectivePose(scene, nodes.get(id)!),\n    getParent: (id: string) => nodes.get(id)?.parent ?? null,\n  };\n  return composeWorldPose(adapter, nodeId, compose ?? composeRectPose);\n}\n\n/** World → overlay pixels: `screen = (world − view) × view.scale`. */\nfunction viewMatrix(view: View | undefined): Affine {\n  if (!view) return [1, 0, 0, 1, 0, 0];\n  const { x: sx, y: sy } = view.scale;\n  return [sx, 0, 0, sy, -view.x * sx, -view.y * sy];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,oBACd,OACA,cACA,QACA,UAA6C,CAAC,GACrB;CACzB,MAAM,EAAE,OAAO,WAAW,cAAc,YAAY;CACpD,MAAM,EAAE,MAAM,YAAY;CAE1B,MAAM,UAAU,kBAAiC;EAC/C,MAAM,MAAM,WAAW,OAAO,QAAQ,OAAO;EAC7C,IAAI,CAAC,KAAK,OAAO;EACjB,MAAM,QAAQ,YAAY,GAAG;EAC7B,MAAM,SAAS,WAAW,YAAY,IAAI,CAAC;EAC3C,OAAO,QAAQ,SAAS,QAAQ,KAAK,IAAI;CAC3C,GAAG;EAAC;EAAO;EAAQ;EAAS;CAAI,CAAC;CAEjC,MAAM,WAAW,aAAa,MAAkC;EAC9D,MAAM,IAAI,QAAQ;EAClB,IAAI,CAAC,GAAG,OAAO;EACf,MAAM,CAAC,GAAG,KAAK,aAAa,GAAG,EAAE,GAAG,EAAE,CAAC;EACvC,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAAC,OAAO,CAAC;CAEZ,MAAM,cAAc,OAAsB,IAAI;CAE9C,MAAM,UAAU,aAAa,MAAkC;EAC7D,MAAM,IAAI,QAAQ;EAClB,MAAM,UAAU,KAAK,OAAO,CAAC;EAC7B,IAAI,SAAS,YAAY,UAAU;EAEnC,MAAM,CAAC,GAAG,KAAK,aAAa,WAAW,YAAY,SAAU,EAAE,GAAG,EAAE,CAAC;EACrE,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAAC,OAAO,CAAC;CAEZ,MAAM,MAAM,WAAW,OAAO,QAAQ,OAAO;CAC7C,MAAM,IAAI,OAAO,UAAU,KAAK,WAAW,IAAI,QAAQ,IAAI;CAC3D,MAAM,UAAU,KAAK,OAAO,CAAC;CAC7B,yBAAyB;EACvB,IAAI,SAAS,YAAY,UAAU;CACrC,CAAC;CAED,IAAI,CAAC,OAAO,CAAC,SAAS,OAAO;CAC7B,OAAO;EAAE,KAAK;GAAE,GAAG,IAAI;GAAG,GAAG,IAAI;GAAG,OAAO,IAAI;GAAO,QAAQ,IAAI;EAAO;EAAG;EAAU;EAAS;EAAO;CAAO;AAC/G;AAEA,SAAS,YAAY,MAAyD;CAC5E,OAAO,OAAO,SAAS,aAAa,KAAK,IAAI;AAC/C;AAEA,SAAS,WACP,OACA,QACA,SACc;CACd,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,QAAQ,MAAM;CACpB,IAAI,CAAC,MAAM,IAAI,MAAM,GAAG,OAAO;CAO/B,OAAO,iBAAiB;EAHtB,UAAU,OAAe,cAAc,OAAO,MAAM,IAAI,EAAE,CAAE;EAC5D,YAAY,OAAe,MAAM,IAAI,EAAE,CAAC,EAAE,UAAU;CAE9B,GAAS,QAAQ,WAAW,eAAe;AACrE;;AAGA,SAAS,WAAW,MAAgC;CAClD,IAAI,CAAC,MAAM,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CACnC,MAAM,EAAE,GAAG,IAAI,GAAG,OAAO,KAAK;CAC9B,OAAO;EAAC;EAAI;EAAG;EAAG;EAAI,CAAC,KAAK,IAAI;EAAI,CAAC,KAAK,IAAI;CAAE;AAClD"}

package/dist/core/viewport/useVelocityTracker.js

@@ -1,10 +1,13 @@
-import { createVelocityTracker as e } from "./createVelocityTracker.js";
-import { useMemo as t } from "react";
+import { createVelocityTracker } from "./createVelocityTracker.js";
+import { useMemo } from "react";
+
 //#region src/core/viewport/useVelocityTracker.ts
-function n() {
-	return t(() => e(), []);
+/** Records recent pointer deltas and reports the current velocity, averaged
+*  over the last 100ms — the throw speed a momentum decay starts from. */
+function useVelocityTracker() {
+	return useMemo(() => createVelocityTracker(), []);
 }
-//#endregion
-export { n as useVelocityTracker };
 
+//#endregion
+export { useVelocityTracker };
 //# sourceMappingURL=useVelocityTracker.js.map

package/dist/core/viewport/useVelocityTracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"useVelocityTracker.js","names":["useVelocityTracker","useMemo","createVelocityTracker"],"sources":["../../../src/core/viewport/useVelocityTracker.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { createVelocityTracker, type VelocityTracker } from './createVelocityTracker';\n\nexport type { VelocityTracker };\n\n/** Records recent pointer deltas and reports the current velocity, averaged\n *  over the last 100ms — the throw speed a momentum decay starts from. */\nexport function useVelocityTracker(): VelocityTracker {\n  return useMemo(() => createVelocityTracker(), []);\n}\n"],"mappings":";;;AAOA,SAAgBA,IAAsC;CACpD,OAAOC,QAAcC,EAAsB,GAAG,CAAC,CAAC;AAClD"}
+{"version":3,"file":"useVelocityTracker.js","names":[],"sources":["../../../src/core/viewport/useVelocityTracker.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { createVelocityTracker, type VelocityTracker } from './createVelocityTracker';\n\nexport type { VelocityTracker };\n\n/** Records recent pointer deltas and reports the current velocity, averaged\n *  over the last 100ms — the throw speed a momentum decay starts from. */\nexport function useVelocityTracker(): VelocityTracker {\n  return useMemo(() => createVelocityTracker(), []);\n}\n"],"mappings":";;;;;;AAOA,SAAgB,qBAAsC;CACpD,OAAO,cAAc,sBAAsB,GAAG,CAAC,CAAC;AAClD"}