@weasel-js/core 1.9.4 → 1.10.0

package/dist/core/viewport/useNodeOverlayFrame.js

@@ -0,0 +1,84 @@
+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";
+//#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;
+	}, [
+		t,
+		r,
+		v,
+		_
+	]), b = c((e) => {
+		let t = y();
+		if (!t) return e;
+		let [n, r] = i(t, e.x, e.y);
+		return {
+			x: n,
+			y: r
+		};
+	}, [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);
+		return {
+			x: r,
+			y: o
+		};
+	}, [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 : {
+		box: {
+			x: C.x,
+			y: C.y,
+			width: C.width,
+			height: C.height
+		},
+		toScreen: b,
+		toLocal: S,
+		width: h,
+		height: g
+	};
+}
+function f(e) {
+	return typeof e == "function" ? e() : e;
+}
+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 m(e) {
+	if (!e) return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	let { x: t, y: n } = e.scale;
+	return [
+		t,
+		0,
+		0,
+		n,
+		-e.x * t,
+		-e.y * n
+	];
+}
+//#endregion
+export { d as useNodeOverlayFrame };
+
+//# sourceMappingURL=useNodeOverlayFrame.js.map

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

@@ -0,0 +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"}

package/dist/core/viewport/useViewAnimation.js

@@ -1,63 +1,122 @@
 import { normalizeView as e } from "./view.js";
 import { fitViewToBounds as t } from "./fitViewToBounds.js";
 import { interpolateView as n } from "./interpolateView.js";
-import { useAnimator as r } from "../../animation/useAnimator.js";
-import { easeOutCubic as i } from "@weasel-js/geom";
-import { useId as a, useMemo as o, useRef as s } from "react";
-import { useLatest as c } from "@weasel-js/react";
+import { easeOutCubic as r } from "@weasel-js/geom";
+import { useId as i, useMemo as a, useRef as o } from "react";
+import { useLatest as s } from "@weasel-js/react";
+import { createTarget as c, useAnimator as l } from "@weasel-js/animator";
 //#region src/core/viewport/useViewAnimation.ts
-var l = "view", u = 250;
-function d(e, t) {
-	let n = r();
-	return f(e, t ?? n);
+var u = "view", d = 250, f = {
+	count: 4,
+	names: [
+		"x",
+		"y",
+		"scale.x",
+		"scale.y"
+	],
+	to: (e) => [
+		e.x,
+		e.y,
+		e.scale.x,
+		e.scale.y
+	],
+	from: (e) => ({
+		x: e[0],
+		y: e[1],
+		scale: {
+			x: e[2],
+			y: e[3]
+		}
+	}),
+	add: (e, t) => ({
+		x: e.x + t[0],
+		y: e.y + t[1],
+		scale: {
+			x: e.scale.x + t[2],
+			y: e.scale.y + t[3]
+		}
+	}),
+	write: (e, t, n) => {
+		t[n] = e.x, t[n + 1] = e.y, t[n + 2] = e.scale.x, t[n + 3] = e.scale.y;
+	}
+};
+function p(e, t) {
+	let n = l();
+	return m(e, t ?? n);
 }
-function f(r, d) {
-	let f = `${l}:${a()}`, p = c(r), m = c(d), h = s(null), g = s(!1);
-	return o(() => {
-		let r = () => m.current.isActive(f), a = () => r() ? h.current : null, o = () => {
-			m.current.cancelKey(f), h.current = null;
-		}, s = (t, r = {}) => {
-			let s = p.current.get(), c = e(typeof t == "function" ? t(a() ?? s) : t);
-			o(), h.current = c, m.current.tween({
-				from: s,
-				to: c,
-				ms: r.ms ?? u,
-				easing: r.easing ?? i,
-				interpolator: r.interpolator ?? n,
-				cancelKey: f,
-				onTick: (e) => {
-					g.current = !0;
-					try {
-						p.current.set(e);
-					} finally {
-						g.current = !1;
-					}
-				},
+function m(l, p) {
+	let m = `${u}:${i()}`, h = s(l), g = s(p), _ = o(null), v = o(!1);
+	return a(() => {
+		let i = null, a = null, o = () => {
+			if (i) return i;
+			let e = h.current.get();
+			return a ? f.from(f.to(e).map((e, t) => e - a[t])) : e;
+		}, s = (t) => {
+			v.current = !0;
+			try {
+				h.current.set(e(t));
+			} finally {
+				v.current = !1;
+			}
+		}, l = c({
+			axes: f,
+			get: o,
+			set: (e) => {
+				i = e, a = null;
+			},
+			show: (e) => {
+				if (l.active) {
+					i || (i = o(), a = null), s(e);
+					return;
+				}
+				let t = i;
+				i = a = null, t && s(t);
+			}
+		}), u = () => g.current.isActive(m), p = () => u() ? _.current : null, y = () => {
+			g.current.cancelKey(m), _.current = null;
+		}, b = () => {
+			y(), l.active || (i = a = null);
+		}, x = (t, c = {}) => {
+			let u = e(typeof t == "function" ? t(p() ?? o()) : t);
+			_.current = u, g.current.tween({
+				target: l,
+				to: u,
+				ms: c.ms ?? d,
+				easing: c.easing ?? r,
+				interpolator: c.interpolator ?? n,
+				cancelKey: m,
 				onDone: () => {
-					h.current = null, r.onDone?.();
+					_.current = null, s(l.read()), l.active || (i = a = null), c.onDone?.();
 				}
 			});
 		};
 		return {
-			animate: s,
+			animate: x,
 			animateToBounds: (e, n, r = {}) => {
-				let i = p.current.get(), a = t(e, n, i, r);
-				a !== i && s(a, r);
+				let i = h.current.get(), a = t(e, n, i, r);
+				a !== i && x(a, r);
 			},
-			stop: o,
-			isAnimating: r,
-			target: a,
+			stop: b,
+			isAnimating: u,
+			target: p,
 			stopIfExternal: () => {
-				g.current || o();
-			}
+				if (!v.current) {
+					if (y(), l.active) {
+						let e = f.to(l.read()), t = f.to(o());
+						a = e.map((e, n) => e - t[n]);
+					} else a = null;
+					i = null;
+				}
+			},
+			viewTarget: l
 		};
 	}, [
-		f,
-		p,
-		m
+		m,
+		h,
+		g
 	]);
 }
 //#endregion
-export { l as VIEW_ANIMATION_KEY, d as useViewAnimation, f as useViewAnimationOn };
+export { u as VIEW_ANIMATION_KEY, p as useViewAnimation, m as useViewAnimationOn, f as viewAxes };
 
 //# sourceMappingURL=useViewAnimation.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useViewAnimation.js","names":["VIEW_ANIMATION_KEY","DEFAULT_MS","useViewAnimation","own","useAnimator","useViewAnimationOn","view","animator","key","useId","viewRef","useLatest","animatorRef","targetRef","useRef","writingRef","useMemo","isAnimating","target","stop","animate","from","resolved","normalizeView","to","opts","easeOutCubic","interpolateView","v","current","fitted","fitViewToBounds","bounds","dims"],"sources":["../../../src/core/viewport/useViewAnimation.ts"],"sourcesContent":["import { useId, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useAnimator } from '../../animation/useAnimator';\nimport { easeOutCubic } from '@weasel-js/geom';\nimport type { Animator, EasingSpec, InterpolatorFactory } from '../../animation/types';\nimport { interpolateView } from './interpolateView';\nimport { fitViewToBounds } from './fitViewToBounds';\nimport type { Bounds, FitViewToBoundsOptions, ViewportDims } from './fitViewToBounds';\nimport { normalizeView, type View } from './view';\n\n/** Cancel-key prefix. Each hook instance appends its own id, so two runners\n *  sharing an animator do not cancel each other. */\nexport const VIEW_ANIMATION_KEY = 'view';\n\nconst DEFAULT_MS = 250;\n\n/** How the camera should move. */\nexport interface ViewAnimationOptions {\n  /** Duration in ms. Default 250. */\n  ms?: number;\n  /** Easing curve. Default `easeOutCubic`. */\n  easing?: EasingSpec;\n  /** Replace the kit's log-scale / fixed-anchor curve. */\n  interpolator?: InterpolatorFactory<View>;\n  /** Fires when the target is reached. Not called on cancel. */\n  onDone?: () => void;\n}\n\n/** Options accepted by {@link ViewAnimationApi.animateToBounds}. */\nexport interface AnimateToBoundsOptions extends FitViewToBoundsOptions, ViewAnimationOptions {}\n\n/** What the runner reads and writes. On `<SceneCanvas>` this is the same\n *  channel `view.set` uses, so a camera animation on an uncontrolled canvas\n *  costs no React render. */\nexport interface ViewChannel {\n  get(): View;\n  set(v: View): void;\n}\n\n/** The camera animation surface. One animation at a time. */\nexport interface ViewAnimationApi {\n  /** Glide from the live view to `to`. A thunk receives the pending target when\n   *  one is in flight, so successive discrete steps compound. */\n  animate(to: View | ((base: View) => View), opts?: ViewAnimationOptions): void;\n  /** `fitViewToBounds` composed with `animate`. */\n  animateToBounds(bounds: Bounds, dims: ViewportDims, opts?: AnimateToBoundsOptions): void;\n  /** Cancel. The view stays where it is — no jump to the target. */\n  stop(): void;\n  isAnimating(): boolean;\n  /** Where the in-flight animation is heading, or null when none is. */\n  target(): View | null;\n  /** Cancel unless the write that prompted this came from the runner's own\n   *  per-frame write. Feed it from every channel that can move the camera. */\n  stopIfExternal(): void;\n}\n\n/**\n * Animate the viewport `View`. Runs on the kit's {@link Animator} — pass one to\n * share a canvas's animator, or omit it and the hook makes its own. A caller\n * that always has one should use {@link useViewAnimationOn}, which builds none.\n *\n * Every animation from one instance registers under that instance's cancel key,\n * so starting one cancels whatever *it* had in flight, and each starts from the\n * *live* view rather than a captured value — an interrupted camera never jumps.\n * Two instances on one animator are independent.\n */\nexport function useViewAnimation(view: ViewChannel, animator?: Animator): ViewAnimationApi {\n  const own = useAnimator();\n  return useViewAnimationOn(view, animator ?? own);\n}\n\n/** {@link useViewAnimation} on an animator the caller owns. Constructs no\n *  animator of its own, so the camera runs on exactly the one passed. */\nexport function useViewAnimationOn(view: ViewChannel, animator: Animator): ViewAnimationApi {\n  const key = `${VIEW_ANIMATION_KEY}:${useId()}`;\n  const viewRef = useLatest(view);\n  const animatorRef = useLatest(animator);\n  const targetRef = useRef<View | null>(null);\n  const writingRef = useRef(false);\n\n  return useMemo<ViewAnimationApi>(() => {\n    const isAnimating = () => animatorRef.current.isActive(key);\n    const target = () => (isAnimating() ? targetRef.current : null);\n    const stop = () => {\n      animatorRef.current.cancelKey(key);\n      targetRef.current = null;\n    };\n\n    const animate: ViewAnimationApi['animate'] = (to, opts = {}) => {\n      const from = viewRef.current.get();\n      const resolved = normalizeView(typeof to === 'function' ? to(target() ?? from) : to);\n      stop();\n      targetRef.current = resolved;\n      animatorRef.current.tween<View>({\n        from,\n        to: resolved,\n        ms: opts.ms ?? DEFAULT_MS,\n        easing: opts.easing ?? easeOutCubic,\n        interpolator: opts.interpolator ?? interpolateView,\n        cancelKey: key,\n        onTick: (v) => {\n          writingRef.current = true;\n          try { viewRef.current.set(v); } finally { writingRef.current = false; }\n        },\n        onDone: () => {\n          targetRef.current = null;\n          opts.onDone?.();\n        },\n      });\n    };\n\n    return {\n      animate,\n      animateToBounds: (bounds, dims, opts = {}) => {\n        const current = viewRef.current.get();\n        const fitted = fitViewToBounds(bounds, dims, current, opts);\n        if (fitted === current) return; // helper bailed (zero-area bounds/viewport)\n        animate(fitted, opts);\n      },\n      stop,\n      isAnimating,\n      target,\n      stopIfExternal: () => { if (!writingRef.current) stop(); },\n    };\n  }, [key, viewRef, animatorRef]);\n}\n"],"mappings":";;;;;;;;AAYA,IAAaA,IAAqB,QAE5BC,IAAa;AAoDnB,SAAgBC,EAAiB,GAAmB,GAAuC;CACzF,IAAMC,IAAMC,EAAY;CACxB,OAAOC,EAAmBC,GAAMC,KAAYJ,CAAG;AACjD;AAIA,SAAgBE,EAAmB,GAAmB,GAAsC;CAC1F,IAAMG,IAAM,GAAGR,EAAmB,GAAGS,EAAM,KACrCC,IAAUC,EAAUL,CAAI,GACxBM,IAAcD,EAAUJ,CAAQ,GAChCM,IAAYC,EAAoB,IAAI,GACpCC,IAAaD,EAAO,EAAK;CAE/B,OAAOE,QAAgC;EACrC,IAAMC,UAAoBL,EAAY,QAAQ,SAASJ,CAAG,GACpDU,UAAgBD,EAAY,IAAIJ,EAAU,UAAU,MACpDM,UAAa;GAEjB,AADAP,EAAY,QAAQ,UAAUJ,CAAG,GACjC,EAAU,UAAU;EACtB,GAEMY,KAAwC,GAAI,IAAO,CAAC,MAAM;GAC9D,IAAMC,IAAOX,EAAQ,QAAQ,IAAI,GAC3BY,IAAWC,EAAc,OAAOC,KAAO,aAAaA,EAAGN,EAAO,KAAKG,CAAI,IAAIG,CAAE;GAGnF,AAFAL,EAAK,GACL,EAAU,UAAUG,GACpBV,EAAY,QAAQ,MAAY;IAC9B;IACA,IAAIU;IACJ,IAAIG,EAAK,MAAMxB;IACf,QAAQwB,EAAK,UAAUC;IACvB,cAAcD,EAAK,gBAAgBE;IACnC,WAAWnB;IACX,SAAS,MAAM;KACb,EAAW,UAAU;KACrB,IAAI;MAAE,EAAQ,QAAQ,IAAIoB,CAAC;KAAG,UAAU;MAAE,EAAW,UAAU;KAAO;IACxE;IACA,cAAc;KAEZ,AADA,EAAU,UAAU,MACpBH,EAAK,SAAS;IAChB;GACF,CAAC;EACH;EAEA,OAAO;GACL;GACA,kBAAkB,GAAQ,GAAM,IAAO,CAAC,MAAM;IAC5C,IAAMI,IAAUnB,EAAQ,QAAQ,IAAI,GAC9BoB,IAASC,EAAgBC,GAAQC,GAAMJ,GAASJ,CAAI;IAC1D,AAAIK,MAAWD,KACfT,EAAQU,GAAQL,CAAI;GACtB;GACA;GACA;GACA;GACA,sBAAsB;IAAE,AAAKV,EAAW,WAASI,EAAK;GAAG;EAC3D;CACF,GAAG;EAACX;EAAKE;EAASE;CAAW,CAAC;AAChC"}
+{"version":3,"file":"useViewAnimation.js","names":["VIEW_ANIMATION_KEY","DEFAULT_MS","viewAxes","v","a","d","at","useViewAnimation","own","useAnimator","useViewAnimationOn","view","animator","key","useId","viewRef","useLatest","animatorRef","targetRef","useRef","writingRef","useMemo","committed","offset","base","live","n","i","write","normalizeView","viewTarget","createTarget","landed","isAnimating","target","cancel","stop","animate","resolved","to","opts","easeOutCubic","interpolateView","current","fitted","fitViewToBounds","bounds","dims","shown","under"],"sources":["../../../src/core/viewport/useViewAnimation.ts"],"sourcesContent":["import { useId, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useAnimator } from '@weasel-js/animator';\nimport { easeOutCubic } from '@weasel-js/geom';\nimport type { Animator, EasingSpec, InterpolatorFactory } from '@weasel-js/animator';\nimport { createTarget, type Target, type TargetAxes } from '@weasel-js/animator';\nimport { interpolateView } from './interpolateView';\nimport { fitViewToBounds } from './fitViewToBounds';\nimport type { Bounds, FitViewToBoundsOptions, ViewportDims } from './fitViewToBounds';\nimport { normalizeView, type View } from './view';\n\n/** Cancel-key prefix. Each hook instance appends its own id, so two runners\n *  sharing an animator do not cancel each other. */\nexport const VIEW_ANIMATION_KEY = 'view';\n\nconst DEFAULT_MS = 250;\n\n/** How the camera should move. */\nexport interface ViewAnimationOptions {\n  /** Duration in ms. Default 250. */\n  ms?: number;\n  /** Easing curve. Default `easeOutCubic`. */\n  easing?: EasingSpec;\n  /** Replace the kit's log-scale / fixed-anchor curve. */\n  interpolator?: InterpolatorFactory<View>;\n  /** Fires when the target is reached. Not called on cancel. */\n  onDone?: () => void;\n}\n\n/** Options accepted by {@link ViewAnimationApi.animateToBounds}. */\nexport interface AnimateToBoundsOptions extends FitViewToBoundsOptions, ViewAnimationOptions {}\n\n/** What the runner reads and writes. On `<SceneCanvas>` this is the same\n *  channel `view.set` uses, so a camera animation on an uncontrolled canvas\n *  costs no React render. */\nexport interface ViewChannel {\n  get(): View;\n  set(v: View): void;\n}\n\n/** The camera animation surface. Its own animations run one at a time. */\nexport interface ViewAnimationApi {\n  /** Glide from the live view to `to`. A thunk receives the pending target when\n   *  one is in flight, so successive discrete steps compound. */\n  animate(to: View | ((base: View) => View), opts?: ViewAnimationOptions): void;\n  /** `fitViewToBounds` composed with `animate`. */\n  animateToBounds(bounds: Bounds, dims: ViewportDims, opts?: AnimateToBoundsOptions): void;\n  /** Cancel. The view stays where it is — no jump to the target. */\n  stop(): void;\n  isAnimating(): boolean;\n  /** Where the in-flight animation is heading, or null when none is. */\n  target(): View | null;\n  /** Cancel unless the write that prompted this came from the runner's own\n   *  per-frame write. Feed it from every channel that can move the camera. */\n  stopIfExternal(): void;\n  /**\n   * The view as a {@link Target}, for running another animation on it: a shake\n   * or a nudge adds to a camera animation in flight, and neither cancels the\n   * other. Move it with the animator this runner was given, and without this\n   * runner's cancel key. `stop` and an outside write leave such an animation\n   * running.\n   */\n  readonly viewTarget: Target<View>;\n}\n\n/** A `View` as the four numbers an animation moves: `x`, `y`, `scale.x`, `scale.y`. */\nexport const viewAxes: TargetAxes<View> = {\n  count: 4,\n  names: ['x', 'y', 'scale.x', 'scale.y'],\n  to: (v) => [v.x, v.y, v.scale.x, v.scale.y],\n  from: (a) => ({ x: a[0]!, y: a[1]!, scale: { x: a[2]!, y: a[3]! } }),\n  add: (v, d) => ({ x: v.x + d[0]!, y: v.y + d[1]!, scale: { x: v.scale.x + d[2]!, y: v.scale.y + d[3]! } }),\n  write: (v, out, at) => {\n    out[at] = v.x;\n    out[at + 1] = v.y;\n    out[at + 2] = v.scale.x;\n    out[at + 3] = v.scale.y;\n  },\n};\n\n/**\n * Animate the viewport `View`. Runs on the kit's {@link Animator} — pass one to\n * share a canvas's animator, or omit it and the hook makes its own. A caller\n * that always has one should use {@link useViewAnimationOn}, which builds none.\n *\n * Every animation from one instance registers under that instance's cancel key,\n * so starting one cancels whatever *it* had in flight, and each starts from where\n * the last one was rather than a captured value — an interrupted camera never jumps.\n * Two instances on one animator are independent. The view is a target\n * ({@link ViewAnimationApi.viewTarget}), so other animations can add to the camera's.\n */\nexport function useViewAnimation(view: ViewChannel, animator?: Animator): ViewAnimationApi {\n  const own = useAnimator();\n  return useViewAnimationOn(view, animator ?? own);\n}\n\n/** {@link useViewAnimation} on an animator the caller owns. Constructs no\n *  animator of its own, so the camera runs on exactly the one passed. */\nexport function useViewAnimationOn(view: ViewChannel, animator: Animator): ViewAnimationApi {\n  const key = `${VIEW_ANIMATION_KEY}:${useId()}`;\n  const viewRef = useLatest(view);\n  const animatorRef = useLatest(animator);\n  /** Where this runner's own animation is heading. */\n  const targetRef = useRef<View | null>(null);\n  const writingRef = useRef(false);\n\n  return useMemo<ViewAnimationApi>(() => {\n    // The value the target's animations add to. While any is in flight it is kept here, apart\n    // from the channel, which holds the folded view; null says to work it out from the channel.\n    let committed: View | null = null;\n    /** What the animations in flight added to the channel's view when `committed` was dropped. */\n    let offset: number[] | null = null;\n    const base = (): View => {\n      if (committed) return committed;\n      const live = viewRef.current.get();\n      return offset ? viewAxes.from(viewAxes.to(live).map((n, i) => n - offset![i]!)) : live;\n    };\n    const write = (v: View): void => {\n      writingRef.current = true;\n      try { viewRef.current.set(normalizeView(v)); } finally { writingRef.current = false; }\n    };\n    const viewTarget: Target<View> = createTarget<View>({\n      axes: viewAxes,\n      get: base,\n      set: (v) => { committed = v; offset = null; },\n      show: (v) => {\n        if (viewTarget.active) {\n          if (!committed) { committed = base(); offset = null; }\n          write(v);\n          return;\n        }\n        // At rest. A stop or an outside write left the view as it stands; a finish lands it.\n        const landed = committed;\n        committed = offset = null;\n        if (landed) write(landed);\n      },\n    });\n\n    const isAnimating = () => animatorRef.current.isActive(key);\n    const target = () => (isAnimating() ? targetRef.current : null);\n    /** Cancels this runner's animation; whatever else moves the view goes on from where it was. */\n    const cancel = (): void => {\n      animatorRef.current.cancelKey(key);\n      targetRef.current = null;\n    };\n    const stop = () => {\n      cancel();\n      if (!viewTarget.active) committed = offset = null;\n    };\n\n    const animate: ViewAnimationApi['animate'] = (to, opts = {}) => {\n      const resolved = normalizeView(typeof to === 'function' ? to(target() ?? base()) : to);\n      targetRef.current = resolved;\n      animatorRef.current.tween<View>({\n        target: viewTarget,\n        to: resolved,\n        ms: opts.ms ?? DEFAULT_MS,\n        easing: opts.easing ?? easeOutCubic,\n        interpolator: opts.interpolator ?? interpolateView,\n        cancelKey: key,\n        onDone: () => {\n          targetRef.current = null;\n          // Ahead of the frame's own write, so `onDone` reads the view it finished on.\n          write(viewTarget.read());\n          if (!viewTarget.active) committed = offset = null;\n          opts.onDone?.();\n        },\n      });\n    };\n\n    return {\n      animate,\n      animateToBounds: (bounds, dims, opts = {}) => {\n        const current = viewRef.current.get();\n        const fitted = fitViewToBounds(bounds, dims, current, opts);\n        if (fitted === current) return; // helper bailed (zero-area bounds/viewport)\n        animate(fitted, opts);\n      },\n      stop,\n      isAnimating,\n      target,\n      stopIfExternal: () => {\n        if (writingRef.current) return;\n        cancel();\n        // The writer read the folded view, so what is still in flight stays on top of its write.\n        if (viewTarget.active) {\n          const shown = viewAxes.to(viewTarget.read());\n          const under = viewAxes.to(base());\n          offset = shown.map((n, i) => n - under[i]!);\n        } else {\n          offset = null;\n        }\n        committed = null;\n      },\n      viewTarget,\n    };\n  }, [key, viewRef, animatorRef]);\n}\n"],"mappings":"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"}

package/dist/core/viewport/view.js

@@ -1,5 +1,5 @@
-import { meanScale as e } from "./meanScale.js";
-import { normalizeZoom as t, warnInvalidView as n } from "./zoomBounds.js";
+import { normalizeZoom as e, warnInvalidView as t } from "./zoomBounds.js";
+import { meanScale as n } from "@weasel-js/geom";
 //#region src/core/viewport/view.ts
 function r(e) {
 	return {
@@ -11,8 +11,8 @@ function r(e) {
 		}
 	};
 }
-function i(t) {
-	return e(t.scale);
+function i(e) {
+	return n(e.scale);
 }
 function a(e) {
 	let t = o(e.scale.x), n = o(e.scale.y), r = s(e.x), i = s(e.y);
@@ -25,11 +25,11 @@ function a(e) {
 		}
 	};
 }
-function o(e) {
-	return e < 0 && e > -Infinity ? -t(-e) : t(e);
+function o(t) {
+	return t < 0 && t > -Infinity ? -e(-t) : e(t);
 }
 function s(e) {
-	return Number.isFinite(e) ? e : (n(`a position of ${e}`), 0);
+	return Number.isFinite(e) ? e : (t(`a position of ${e}`), 0);
 }
 //#endregion
 export { a as normalizeView, r as viewToTransform, i as viewZoom };

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

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":["viewToTransform","view","viewZoom","meanScale","normalizeView","sx","normalizeAxis","sy","x","finiteTranslation","y","s","normalizeZoom","v","warnInvalidView"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/routing';\nimport { meanScale } from './meanScale';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * `View` is declared in `@weasel-js/routing` — the dispatcher and every\n * viewport action are typed in it. Re-exported here, where core's own call\n * sites have always named it.\n *\n * Core holds the invariant behind the shape: every view the kit keeps is\n * total, so each `scale` axis is finite with a magnitude of at least\n * `ZOOM_FLOOR` and `x` / `y` are finite. A negative axis is a flipped one\n * (y-up), not a degenerate one, and keeps its sign. Canvases, views and\n * animations pass what they are given through {@link normalizeView}, so\n * screen/world conversion never divides by zero.\n *\n * `scale` is always a 2-vector. Input convenience types {@link ZoomFactor}\n * and {@link ZoomBound} let callers pass a scalar when they want both axes\n * treated the same.\n */\nexport type { View };\n\n/**\n * Input convenience for zoom primitives. A `number` is treated as a\n * uniform factor applied to both axes; a `{x, y}` vector applies\n * per-axis factors.\n */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/**\n * Input convenience for zoom-clamp ranges. A `number` is applied as the\n * same bound on both axes; a `{x, y}` vector applies per-axis bounds.\n */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep\n * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`\n * use opposite sign conventions for the translation half (`view.x` is\n * camera position; `panX` is canvas translation), so the adapter flips\n * the sign and multiplies by per-axis scale.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n *\n * What a `RuleCtx` carries, because the only rule that asks about the\n * viewport asks for a threshold rather than a camera.\n */\nexport function viewZoom(view: View): number {\n  return meanScale(view.scale);\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;;AA2CA,SAAgBA,EAAgB,GAA2B;CAEzD,OAAO;EACL,MAAM,CAACC,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM,CAACA,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAGA,EAAK,MAAM;GAAG,GAAGA,EAAK,MAAM;EAAE;CAC3C;AACF;AAUA,SAAgBC,EAAS,GAAoB;CAC3C,OAAOC,EAAUF,EAAK,KAAK;AAC7B;AAQA,SAAgBG,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcL,EAAK,MAAM,CAAC,GAC/BM,IAAKD,EAAcL,EAAK,MAAM,CAAC,GAC/BO,IAAIC,EAAkBR,EAAK,CAAC,GAC5BS,IAAID,EAAkBR,EAAK,CAAC;CAElC,OADII,MAAOJ,EAAK,MAAM,KAAKM,MAAON,EAAK,MAAM,KAAKO,MAAMP,EAAK,KAAKS,MAAMT,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGI;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOK,IAAI,KAAKA,IAAI,YAAY,CAACC,EAAc,CAACD,CAAC,IAAIC,EAAcD,CAAC;AACtE;AAEA,SAASF,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASI,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}
+{"version":3,"file":"view.js","names":["normalizeZoom","normalizeZoom$1","viewToTransform","view","viewZoom","meanScale","normalizeView","sx","normalizeAxis","sy","x","finiteTranslation","y","s","v","warnInvalidView"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/routing';\nimport { meanScale } from '@weasel-js/geom';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * Every view the kit keeps is total: each `scale` axis is finite with a\n * magnitude of at least `ZOOM_FLOOR` and `x` / `y` are finite. A negative\n * axis is a flipped one (y-up), not a degenerate one, and keeps its sign.\n * Canvases, views, and animations pass what they are given through\n * {@link normalizeView}, so screen/world conversion never divides by zero.\n */\nexport type { View };\n\n/** A zoom factor: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/** A zoom-clamp bound: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape. The two use opposite\n * sign conventions for the translation half: `view.x` is camera position;\n * `panX` is canvas translation.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n */\nexport function viewZoom(view: View): number {\n  return meanScale(view.scale);\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;;AAyBA,SAAgBE,EAAgB,GAA2B;CAEzD,OAAO;EACL,MAAM,CAACC,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM,CAACA,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAGA,EAAK,MAAM;GAAG,GAAGA,EAAK,MAAM;EAAE;CAC3C;AACF;AAOA,SAAgBC,EAAS,GAAoB;CAC3C,OAAOC,EAAUF,EAAK,KAAK;AAC7B;AAQA,SAAgBG,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcL,EAAK,MAAM,CAAC,GAC/BM,IAAKD,EAAcL,EAAK,MAAM,CAAC,GAC/BO,IAAIC,EAAkBR,EAAK,CAAC,GAC5BS,IAAID,EAAkBR,EAAK,CAAC;CAElC,OADII,MAAOJ,EAAK,MAAM,KAAKM,MAAON,EAAK,MAAM,KAAKO,MAAMP,EAAK,KAAKS,MAAMT,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGI;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOK,IAAI,KAAKA,IAAI,YAAY,CAACb,EAAc,CAACa,CAAC,IAAIb,EAAca,CAAC;AACtE;AAEA,SAASF,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASG,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"wheelHandler.js","names":["WHEEL_ZOOM_STEP","wheelZoomFactor","deltaY","wheelZoom","zoomAt","view","anchor","clamp","wheelPan","axis","opts","swapped","screenX","delta","screenY","computeWheelAction","input"],"sources":["../../../src/core/viewport/wheelHandler.ts"],"sourcesContent":["/**\n * The kit's one wheel convention, as pure functions over `View`.\n *\n * ## Modifiers\n * - bare wheel → pan\n * - shift+wheel → horizontal pan (mouse wheels emit only `deltaY`)\n * - Cmd/Ctrl+wheel → zoom, anchored under the pointer. Ctrl also covers the\n *   trackpad pinch, which browsers deliver as ctrl+wheel.\n *\n * ## Coordinates\n * `View.x` / `View.y` are world-space, so a pan delta — screen pixels, as the\n * DOM reports them — is divided by `View.scale` before it lands. The zoom\n * anchor is canvas-local: client coords minus the canvas's bounding rect.\n *\n * `viewport.wheelPan` and `viewport.zoom` are the wired form of these, and\n * call them rather than restating the math.\n */\n\nimport type { View } from './view';\nimport { zoomAt, type ZoomClampOpts } from './zoomAt';\n\n/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */\nexport const WHEEL_ZOOM_STEP = 1.1;\n\n/** A wheel event, decoupled from the DOM `WheelEvent` shape for testability. */\nexport interface WheelInput {\n  deltaX: number;\n  deltaY: number;\n  /** Zoom anchor, canvas-local: client coords minus the canvas's rect. */\n  x: number;\n  y: number;\n  shiftKey?: boolean;\n  ctrlKey?: boolean;\n  metaKey?: boolean;\n}\n\n/** Which axes a wheel pan is allowed to move, and whether `deltaY` is routed\n *  into the x axis (shift+wheel). An axis lock outranks `swapAxis`. */\nexport interface WheelPanOpts {\n  axis?: 'both' | 'x' | 'y';\n  swapAxis?: boolean;\n}\n\n/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling\n *  a distance and back returns to the scale you started from. */\nexport function wheelZoomFactor(deltaY: number): number {\n  return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);\n}\n\n/** Zoom one wheel sample about `anchor` (canvas-local pixels). */\nexport function wheelZoom(\n  view: View,\n  anchor: { x: number; y: number },\n  deltaY: number,\n  clamp?: ZoomClampOpts,\n): View {\n  return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);\n}\n\n/** Pan by one wheel sample. `delta` is in screen pixels. */\nexport function wheelPan(\n  view: View,\n  delta: { deltaX: number; deltaY: number },\n  opts: WheelPanOpts = {},\n): View {\n  const axis = opts.axis ?? 'both';\n  const swapped = opts.swapAxis === true;\n  // Shift+wheel wants a horizontal pan, but a mouse wheel only emits deltaY.\n  const screenX = swapped ? (delta.deltaX !== 0 ? delta.deltaX : delta.deltaY) : delta.deltaX;\n  const screenY = swapped ? 0 : delta.deltaY;\n  return {\n    scale: view.scale,\n    x: view.x + (axis === 'y' ? 0 : screenX / view.scale.x),\n    y: view.y + (axis === 'x' ? 0 : screenY / view.scale.y),\n  };\n}\n\n/** Pure reducer: the whole wheel convention in one call. */\nexport function computeWheelAction(\n  view: View,\n  input: WheelInput,\n  clamp?: ZoomClampOpts,\n  opts: Pick<WheelPanOpts, 'axis'> = {},\n): View {\n  if (input.ctrlKey || input.metaKey) {\n    return wheelZoom(view, { x: input.x, y: input.y }, input.deltaY, clamp);\n  }\n  return wheelPan(view, input, { axis: opts.axis, swapAxis: input.shiftKey === true });\n}\n"],"mappings":";;AAsBA,IAAaA,IAAkB;AAuB/B,SAAgBC,EAAgB,GAAwB;CACtD,OAAgBD,MAAiB,CAACE,IAAS;AAC7C;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,OAAOC,EAAOC,GAAMC,GAAQL,EAAgBC,CAAM,GAAGK,CAAK;AAC5D;AAGA,SAAgBC,EACd,GACA,GACA,IAAqB,CAAC,GAChB;CACN,IAAMC,IAAOC,EAAK,QAAQ,QACpBC,IAAUD,EAAK,aAAa,IAE5BE,IAAUD,KAAWE,EAAM,WAAW,IAAmBA,EAAM,SAArBA,EAAM,QAChDC,IAAUH,IAAU,IAAIE,EAAM;CACpC,OAAO;EACL,OAAOR,EAAK;EACZ,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIG,IAAUP,EAAK,MAAM;EACrD,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIK,IAAUT,EAAK,MAAM;CACvD;AACF;AAGA,SAAgBU,EACd,GACA,GACA,GACA,IAAmC,CAAC,GAC9B;CAIN,OAHIC,EAAM,WAAWA,EAAM,UAClBb,EAAUE,GAAM;EAAE,GAAGW,EAAM;EAAG,GAAGA,EAAM;CAAE,GAAGA,EAAM,QAAQT,CAAK,IAEjEC,EAASH,GAAMW,GAAO;EAAE,MAAMN,EAAK;EAAM,UAAUM,EAAM,aAAa;CAAK,CAAC;AACrF"}
+{"version":3,"file":"wheelHandler.js","names":["WHEEL_ZOOM_STEP","wheelZoomFactor","deltaY","wheelZoom","zoomAt","view","anchor","clamp","wheelPan","axis","opts","swapped","screenX","delta","screenY","computeWheelAction","input"],"sources":["../../../src/core/viewport/wheelHandler.ts"],"sourcesContent":["/**\n * The kit's one wheel convention, as pure functions over `View`.\n *\n * ## Modifiers\n * - bare wheel → pan\n * - shift+wheel → horizontal pan (mouse wheels emit only `deltaY`)\n * - Cmd/Ctrl+wheel → zoom, anchored under the pointer. Ctrl also covers the\n *   trackpad pinch, which browsers deliver as ctrl+wheel.\n *\n * ## Coordinates\n * `View.x` / `View.y` are world-space, so a pan delta — screen pixels, as the\n * DOM reports them — is divided by `View.scale` before it lands. The zoom\n * anchor is canvas-local: client coords minus the canvas's bounding rect.\n */\n\nimport type { View } from './view';\nimport { zoomAt, type ZoomClampOpts } from './zoomAt';\n\n/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */\nexport const WHEEL_ZOOM_STEP = 1.1;\n\n/** A wheel event, decoupled from the DOM `WheelEvent` shape for testability. */\nexport interface WheelInput {\n  deltaX: number;\n  deltaY: number;\n  /** Zoom anchor, canvas-local: client coords minus the canvas's rect. */\n  x: number;\n  y: number;\n  shiftKey?: boolean;\n  ctrlKey?: boolean;\n  metaKey?: boolean;\n}\n\n/** Which axes a wheel pan is allowed to move, and whether `deltaY` is routed\n *  into the x axis (shift+wheel). An axis lock outranks `swapAxis`. */\nexport interface WheelPanOpts {\n  axis?: 'both' | 'x' | 'y';\n  swapAxis?: boolean;\n}\n\n/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling\n *  a distance and back returns to the scale you started from. */\nexport function wheelZoomFactor(deltaY: number): number {\n  return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);\n}\n\n/** Zoom one wheel sample about `anchor` (canvas-local pixels). */\nexport function wheelZoom(\n  view: View,\n  anchor: { x: number; y: number },\n  deltaY: number,\n  clamp?: ZoomClampOpts,\n): View {\n  return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);\n}\n\n/** Pan by one wheel sample. `delta` is in screen pixels. */\nexport function wheelPan(\n  view: View,\n  delta: { deltaX: number; deltaY: number },\n  opts: WheelPanOpts = {},\n): View {\n  const axis = opts.axis ?? 'both';\n  const swapped = opts.swapAxis === true;\n  // Shift+wheel wants a horizontal pan, but a mouse wheel only emits deltaY.\n  const screenX = swapped ? (delta.deltaX !== 0 ? delta.deltaX : delta.deltaY) : delta.deltaX;\n  const screenY = swapped ? 0 : delta.deltaY;\n  return {\n    scale: view.scale,\n    x: view.x + (axis === 'y' ? 0 : screenX / view.scale.x),\n    y: view.y + (axis === 'x' ? 0 : screenY / view.scale.y),\n  };\n}\n\n/** Pure reducer: the whole wheel convention in one call. */\nexport function computeWheelAction(\n  view: View,\n  input: WheelInput,\n  clamp?: ZoomClampOpts,\n  opts: Pick<WheelPanOpts, 'axis'> = {},\n): View {\n  if (input.ctrlKey || input.metaKey) {\n    return wheelZoom(view, { x: input.x, y: input.y }, input.deltaY, clamp);\n  }\n  return wheelPan(view, input, { axis: opts.axis, swapAxis: input.shiftKey === true });\n}\n"],"mappings":";;AAmBA,IAAaA,IAAkB;AAuB/B,SAAgBC,EAAgB,GAAwB;CACtD,OAAgBD,MAAiB,CAACE,IAAS;AAC7C;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,OAAOC,EAAOC,GAAMC,GAAQL,EAAgBC,CAAM,GAAGK,CAAK;AAC5D;AAGA,SAAgBC,EACd,GACA,GACA,IAAqB,CAAC,GAChB;CACN,IAAMC,IAAOC,EAAK,QAAQ,QACpBC,IAAUD,EAAK,aAAa,IAE5BE,IAAUD,KAAWE,EAAM,WAAW,IAAmBA,EAAM,SAArBA,EAAM,QAChDC,IAAUH,IAAU,IAAIE,EAAM;CACpC,OAAO;EACL,OAAOR,EAAK;EACZ,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIG,IAAUP,EAAK,MAAM;EACrD,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIK,IAAUT,EAAK,MAAM;CACvD;AACF;AAGA,SAAgBU,EACd,GACA,GACA,GACA,IAAmC,CAAC,GAC9B;CAIN,OAHIC,EAAM,WAAWA,EAAM,UAClBb,EAAUE,GAAM;EAAE,GAAGW,EAAM;EAAG,GAAGA,EAAM;CAAE,GAAGA,EAAM,QAAQT,CAAK,IAEjEC,EAASH,GAAMW,GAAO;EAAE,MAAMN,EAAK;EAAM,UAAUM,EAAM,aAAa;CAAK,CAAC;AACrF"}

package/dist/{cornerHandles-CtCb8a3G.d.ts → cornerHandles-BEshc4z3.d.ts}

@@ -1,4 +1,4 @@
-import { B as BoundsConstraint, P as PointSnapBehavior } from './types-B4iJRHC3.js';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './clone-2a5hVbBd.js';
 import { Bounds, ResizeAnchor } from '@weasel-js/routing';
 
 /** Option surface for the `resize` action. */
@@ -22,33 +22,20 @@ interface UseResizeOptions<TPose> {
     /** Fired once per `onGestureStart`: `true` when the resize wrote to the
      *  document, `false` on cancel, a behavior abort, or no change. */
     onGestureEnd?: (committed: boolean) => void;
-    /** Optional: expand the incoming id into leaf ids before pose lookups.
-     *  Used for group expansion: when the
-     *  gesture is started against a group id, the kit
-     *  resizes by computing the union AABB of the leaves' origin bounds,
-     *  running the compute pipeline on that union rect (group bounds), and
-     *  remapping each leaf via `geometry.remapBounds(leaf, originGroupBounds,
-     *  proposedGroupBounds)`.
-     *
-     *  When `expandIds` is omitted or returns the original single id, the
-     *  gesture takes the single-leaf path (the leaf's own bounds become both
-     *  the origin and the target of the same `remapBounds` call).
-     *
-     *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
+    /** Expand the incoming id into leaf ids, for resizing a group: the kit
+     *  resizes the union AABB of the leaves' bounds and remaps each leaf into
+     *  the result. Called once at `start()`. Returning `[]` aborts the gesture
+     *  cleanly. */
     expandIds?: (ids: string[]) => string[];
     /** Behaviors that operate on world-space anchor points. Fire after
-     *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
-     *  with world-space frame points and returns at most one `PointSnapResult`;
-     *  the hook back-solves the local pose so the chosen frame's world point
-     *  lands on the snap target. First non-null result wins. */
+     *  `behaviors[]`. The first non-null `PointSnapResult` wins, and the pose
+     *  is back-solved so the chosen frame's world point lands on the snap
+     *  target. */
     pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
     /** Per-node resizability predicate. Returns `false` for nodes that should
-     *  never show resize handles (and thus can't start a resize gesture) — e.g.
-     *  fixed-footprint icons, locked layers. `<SceneCanvas>` folds this over the
-     *  current selection into the `selectionResizable` rule-ctx flag, so the
-     *  default `selection.resize-handles` chrome rule hides handles whenever any
-     *  selected node is non-resizable (which also disables the affordance, since
-     *  visible==hittable). Default: every node resizable. */
+     *  never show resize handles (and thus can't start a resize gesture). The
+     *  handles hide whenever any selected node is non-resizable. Default: every
+     *  node resizable. */
     resizable?: (id: string) => boolean;
 }