@weasel-js/core 1.10.1 → 1.11.1

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 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,SAAgBA,EACd,GACA,GACA,GACA,IAA6C,CAAC,GACrB;CACzB,IAAM,EAAE,UAAO,cAAWC,EAAcC,CAAY,GAC9C,EAAE,SAAM,eAAYC,GAEpBC,IAAUC,QAAiC;EAC/C,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,EAAsB,IAAI,GAExCC,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,GAAgC;CAClD,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"}

package/dist/core/viewport/useViewAnimation.js

@@ -1,12 +1,20 @@
-import { normalizeView as e } from "./view.js";
-import { fitViewToBounds as t } from "./fitViewToBounds.js";
-import { interpolateView as n } from "./interpolateView.js";
-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";
+import { normalizeView } from "./view.js";
+import { fitViewToBounds } from "./fitViewToBounds.js";
+import { interpolateView } from "./interpolateView.js";
+import { easeOutCubic } from "@weasel-js/geom";
+import { useId, useMemo, useRef } from "react";
+import { useKitSetting, useLatest, usePrefersReducedMotion } from "@weasel-js/react";
+import { useAnimator } from "@weasel-js/animator/react";
+import { createTarget } from "@weasel-js/animator";
+
 //#region src/core/viewport/useViewAnimation.ts
-var u = "view", d = 250, f = {
+/** Cancel-key prefix. Each hook instance appends its own id, so two runners
+*  sharing an animator do not cancel each other. */
+var VIEW_ANIMATION_KEY = "view";
+/** How long an animated camera move takes, in ms, where nothing says otherwise. */
+var DEFAULT_VIEW_ANIMATION_MS = 250;
+/** A `View` as the four numbers an animation moves: `x`, `y`, `scale.x`, `scale.y`. */
+var viewAxes = {
 	count: 4,
 	names: [
 		"x",
@@ -14,110 +22,161 @@ var u = "view", d = 250, f = {
 		"scale.x",
 		"scale.y"
 	],
-	to: (e) => [
-		e.x,
-		e.y,
-		e.scale.x,
-		e.scale.y
+	to: (v) => [
+		v.x,
+		v.y,
+		v.scale.x,
+		v.scale.y
 	],
-	from: (e) => ({
-		x: e[0],
-		y: e[1],
+	from: (a) => ({
+		x: a[0],
+		y: a[1],
 		scale: {
-			x: e[2],
-			y: e[3]
+			x: a[2],
+			y: a[3]
 		}
 	}),
-	add: (e, t) => ({
-		x: e.x + t[0],
-		y: e.y + t[1],
+	add: (v, d) => ({
+		x: v.x + d[0],
+		y: v.y + d[1],
 		scale: {
-			x: e.scale.x + t[2],
-			y: e.scale.y + t[3]
+			x: v.scale.x + d[2],
+			y: v.scale.y + d[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;
+	write: (v, out, at) => {
+		out[at] = v.x;
+		out[at + 1] = v.y;
+		out[at + 2] = v.scale.x;
+		out[at + 3] = v.scale.y;
 	}
 };
-function p(e, t) {
-	let n = l();
-	return m(e, t ?? n);
+/**
+* Animate the viewport `View`. Runs on the kit's {@link Animator} — pass one to
+* share a canvas's animator, or omit it and the hook makes its own. A caller
+* that always has one should use {@link useViewAnimationOn}, which builds none.
+*
+* Every animation from one instance registers under that instance's cancel key,
+* so starting one cancels whatever *it* had in flight, and each starts from where
+* the last one was rather than a captured value — an interrupted camera never jumps.
+* Two instances on one animator are independent. The view is a target
+* ({@link ViewAnimationApi.viewTarget}), so other animations can add to the camera's.
+*/
+function useViewAnimation(view, animator) {
+	const own = useAnimator();
+	return useViewAnimationOn(view, animator ?? own);
 }
-function m(e, t) {
-	let n = `${u}:${i()}`, r = s(e), c = s(t), l = o(null), d = o(!1);
-	return a(() => h(n, r, c, l, d), [
-		n,
-		r,
-		c
+/** {@link useViewAnimation} on an animator the caller owns. Constructs no
+*  animator of its own, so the camera runs on exactly the one passed. */
+function useViewAnimationOn(view, animator) {
+	const key = `${VIEW_ANIMATION_KEY}:${useId()}`;
+	const viewRef = useLatest(view);
+	const animatorRef = useLatest(animator);
+	/** Where this runner's own animation is heading. */
+	const targetRef = useRef(null);
+	const writingRef = useRef(false);
+	const setting = useKitSetting("view.animationMs") ?? DEFAULT_VIEW_ANIMATION_MS;
+	const msRef = useLatest(usePrefersReducedMotion() ? 0 : setting);
+	return useMemo(() => createViewAnimation(key, viewRef, animatorRef, targetRef, writingRef, msRef), [
+		key,
+		viewRef,
+		animatorRef,
+		msRef
 	]);
 }
-function h(i, a, o, s, l) {
-	let u = null, p = null, m = () => {
-		if (u) return u;
-		let e = a.current.get();
-		return p ? f.from(f.to(e).map((e, t) => e - p[t])) : e;
-	}, h = (t) => {
-		l.current = !0;
+/** The runner behind {@link useViewAnimationOn}. */
+function createViewAnimation(key, viewRef, animatorRef, targetRef, writingRef, msRef) {
+	let committed = null;
+	/** What the animations in flight added to the channel's view when `committed` was dropped. */
+	let offset = null;
+	const base = () => {
+		if (committed) return committed;
+		const live = viewRef.current.get();
+		return offset ? viewAxes.from(viewAxes.to(live).map((n, i) => n - offset[i])) : live;
+	};
+	const write = (v) => {
+		writingRef.current = true;
 		try {
-			a.current.set(e(t));
+			viewRef.current.set(normalizeView(v));
 		} finally {
-			l.current = !1;
+			writingRef.current = false;
 		}
-	}, g = c({
-		axes: f,
-		get: m,
-		set: (e) => {
-			u = e, p = null;
+	};
+	const viewTarget = createTarget({
+		axes: viewAxes,
+		get: base,
+		set: (v) => {
+			committed = v;
+			offset = null;
 		},
-		show: (e) => {
-			if (g.active) {
-				u || (u = m(), p = null), h(e);
+		show: (v) => {
+			if (viewTarget.active) {
+				if (!committed) {
+					committed = base();
+					offset = null;
+				}
+				write(v);
 				return;
 			}
-			let t = u;
-			u = p = null, t && h(t);
+			const landed = committed;
+			committed = offset = null;
+			if (landed) write(landed);
 		}
-	}), _ = () => o.current.isActive(i), v = () => _() ? s.current : null, y = () => {
-		o.current.cancelKey(i), s.current = null;
-	}, b = () => {
-		y(), g.active || (u = p = null);
-	}, x = (t, a = {}) => {
-		let c = e(typeof t == "function" ? t(v() ?? m()) : t);
-		s.current = c, o.current.tween({
-			target: g,
-			to: c,
-			ms: a.ms ?? d,
-			easing: a.easing ?? r,
-			interpolator: a.interpolator ?? n,
-			cancelKey: i,
+	});
+	const isAnimating = () => animatorRef.current.isActive(key);
+	const target = () => isAnimating() ? targetRef.current : null;
+	/** Cancels this runner's animation; whatever else moves the view goes on from where it was. */
+	const cancel = () => {
+		animatorRef.current.cancelKey(key);
+		targetRef.current = null;
+	};
+	const stop = () => {
+		cancel();
+		if (!viewTarget.active) committed = offset = null;
+	};
+	const animate = (to, opts = {}) => {
+		const resolved = normalizeView(typeof to === "function" ? to(target() ?? base()) : to);
+		targetRef.current = resolved;
+		animatorRef.current.tween({
+			target: viewTarget,
+			to: resolved,
+			ms: opts.ms ?? msRef.current,
+			easing: opts.easing ?? easeOutCubic,
+			interpolator: opts.interpolator ?? interpolateView,
+			cancelKey: key,
 			onDone: () => {
-				s.current = null, h(g.read()), g.active || (u = p = null), a.onDone?.();
+				targetRef.current = null;
+				write(viewTarget.read());
+				if (!viewTarget.active) committed = offset = null;
+				opts.onDone?.();
 			}
 		});
 	};
 	return {
-		animate: x,
-		animateToBounds: (e, n, r = {}) => {
-			let i = a.current.get(), o = t(e, n, i, r);
-			o !== i && x(o, r);
+		animate,
+		animateToBounds: (bounds, dims, opts = {}) => {
+			const current = viewRef.current.get();
+			const fitted = fitViewToBounds(bounds, dims, current, opts);
+			if (fitted === current) return;
+			animate(fitted, opts);
 		},
-		stop: b,
-		isAnimating: _,
-		target: v,
+		stop,
+		isAnimating,
+		target,
 		stopIfExternal: () => {
-			if (!l.current) {
-				if (y(), g.active) {
-					let e = f.to(g.read()), t = f.to(m());
-					p = e.map((e, n) => e - t[n]);
-				} else p = null;
-				u = null;
-			}
+			if (writingRef.current) return;
+			cancel();
+			if (viewTarget.active) {
+				const shown = viewAxes.to(viewTarget.read());
+				const under = viewAxes.to(base());
+				offset = shown.map((n, i) => n - under[i]);
+			} else offset = null;
+			committed = null;
 		},
-		viewTarget: g
+		viewTarget
 	};
 }
-//#endregion
-export { u as VIEW_ANIMATION_KEY, p as useViewAnimation, m as useViewAnimationOn, f as viewAxes };
 
+//#endregion
+export { DEFAULT_VIEW_ANIMATION_MS, VIEW_ANIMATION_KEY, useViewAnimation, useViewAnimationOn, 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","viewAxes","v","a","d","at","useViewAnimation","own","useAnimator","useViewAnimationOn","view","animator","key","useId","viewRef","useLatest","animatorRef","targetRef","useRef","writingRef","useMemo","createViewAnimation","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(\n    () => createViewAnimation(key, viewRef, animatorRef, targetRef, writingRef),\n    [key, viewRef, animatorRef],\n  );\n}\n\n/** The runner behind {@link useViewAnimationOn}. */\nfunction createViewAnimation(\n  key: string,\n  viewRef: { readonly current: ViewChannel },\n  animatorRef: { readonly current: Animator },\n  targetRef: { current: View | null },\n  writingRef: { current: boolean },\n): 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}\n"],"mappings":"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"}
+{"version":3,"file":"useViewAnimation.js","names":[],"sources":["../../../src/core/viewport/useViewAnimation.ts"],"sourcesContent":["import { useId, useMemo, useRef } from 'react';\nimport { useKitSetting, useLatest, usePrefersReducedMotion } from '@weasel-js/react';\nimport { useAnimator } from '@weasel-js/animator/react';\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\n/** How long an animated camera move takes, in ms, where nothing says otherwise. */\nexport const DEFAULT_VIEW_ANIMATION_MS = 250;\n\n/** How the camera should move. */\nexport interface ViewAnimationOptions {\n  /** Duration in ms. Default the `view.animationMs` kit setting, else `DEFAULT_VIEW_ANIMATION_MS`;\n   *  0 under `prefers-reduced-motion`. */\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  const setting = useKitSetting('view.animationMs') ?? DEFAULT_VIEW_ANIMATION_MS;\n  const msRef = useLatest(usePrefersReducedMotion() ? 0 : setting);\n\n  return useMemo(\n    () => createViewAnimation(key, viewRef, animatorRef, targetRef, writingRef, msRef),\n    [key, viewRef, animatorRef, msRef],\n  );\n}\n\n/** The runner behind {@link useViewAnimationOn}. */\nfunction createViewAnimation(\n  key: string,\n  viewRef: { readonly current: ViewChannel },\n  animatorRef: { readonly current: Animator },\n  targetRef: { current: View | null },\n  writingRef: { current: boolean },\n  /** The duration a move takes when its own options name none. */\n  msRef: { readonly current: number },\n): 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 ?? msRef.current,\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}\n"],"mappings":"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"}