@weasel-js/core 1.10.1 → 1.11.0

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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"}

package/dist/core/viewport/view.js

@@ -1,40 +1,64 @@
-import { normalizeZoom as e, warnInvalidView as t } from "./zoomBounds.js";
-import { meanScale as n } from "@weasel-js/geom";
+import { normalizeZoom as normalizeZoom$1, warnInvalidView } from "./zoomBounds.js";
+import { meanScale } from "@weasel-js/geom";
+
 //#region src/core/viewport/view.ts
-function r(e) {
+/**
+* Bridge `View` into the legacy `ViewTransform` shape. The two use opposite
+* sign conventions for the translation half: `view.x` is camera position;
+* `panX` is canvas translation.
+*/
+function viewToTransform(view) {
 	return {
-		panX: -e.x * e.scale.x + 0,
-		panY: -e.y * e.scale.y + 0,
+		panX: -view.x * view.scale.x + 0,
+		panY: -view.y * view.scale.y + 0,
 		zoom: {
-			x: e.scale.x,
-			y: e.scale.y
+			x: view.scale.x,
+			y: view.scale.y
 		}
 	};
 }
-function i(e) {
-	return n(e.scale);
+/**
+* How far `view` is zoomed in, as one number — the geometric mean of its two
+* axes, so a uniform view reports its own scale and a stretched one reports
+* the scale that covers the same area.
+*/
+function viewZoom(view) {
+	return meanScale(view.scale);
 }
-function a(e, t) {
-	return e.x === t.x && e.y === t.y && e.scale.x === t.scale.x && e.scale.y === t.scale.y;
+/** Whether two views are the same camera, whatever objects hold them. */
+function sameView(a, b) {
+	return a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;
 }
-function o(e) {
-	let t = s(e.scale.x), n = s(e.scale.y), r = c(e.x), i = c(e.y);
-	return t === e.scale.x && n === e.scale.y && r === e.x && i === e.y ? e : {
-		x: r,
-		y: i,
+/**
+* `view` inside the invariant {@link View} documents: a zero or non-finite
+* scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a
+* non-finite translation becomes 0. Returns `view` itself when it already
+* holds, so a valid view keeps its identity.
+*/
+function normalizeView(view) {
+	const sx = normalizeAxis(view.scale.x);
+	const sy = normalizeAxis(view.scale.y);
+	const x = finiteTranslation(view.x);
+	const y = finiteTranslation(view.y);
+	if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;
+	return {
+		x,
+		y,
 		scale: {
-			x: t,
-			y: n
+			x: sx,
+			y: sy
 		}
 	};
 }
-function s(t) {
-	return t < 0 && t > -Infinity ? -e(-t) : e(t);
+function normalizeAxis(s) {
+	return s < 0 && s > -Infinity ? -normalizeZoom$1(-s) : normalizeZoom$1(s);
 }
-function c(e) {
-	return Number.isFinite(e) ? e : (t(`a position of ${e}`), 0);
+function finiteTranslation(v) {
+	if (Number.isFinite(v)) return v;
+	warnInvalidView(`a position of ${v}`);
+	return 0;
 }
-//#endregion
-export { o as normalizeView, a as sameView, r as viewToTransform, i as viewZoom };
 
+//#endregion
+export { normalizeView, sameView, viewToTransform, viewZoom };
 //# sourceMappingURL=view.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":["normalizeZoom","normalizeZoom$1","viewToTransform","view","viewZoom","meanScale","sameView","a","b","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/** Whether two views are the same camera, whatever objects hold them. */\nexport function sameView(a: View, b: View): boolean {\n  return a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;\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;AAGA,SAAgBG,EAAS,GAAS,GAAkB;CAClD,OAAOC,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAM,MAAMC,EAAE,MAAM,KAAKD,EAAE,MAAM,MAAMC,EAAE,MAAM;AACxF;AAQA,SAAgBC,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcR,EAAK,MAAM,CAAC,GAC/BS,IAAKD,EAAcR,EAAK,MAAM,CAAC,GAC/BU,IAAIC,EAAkBX,EAAK,CAAC,GAC5BY,IAAID,EAAkBX,EAAK,CAAC;CAElC,OADIO,MAAOP,EAAK,MAAM,KAAKS,MAAOT,EAAK,MAAM,KAAKU,MAAMV,EAAK,KAAKY,MAAMZ,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGO;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOK,IAAI,KAAKA,IAAI,YAAY,CAAChB,EAAc,CAACgB,CAAC,IAAIhB,EAAcgB,CAAC;AACtE;AAEA,SAASF,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASG,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}
+{"version":3,"file":"view.js","names":["normalizeZoom"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/geom';\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/** Whether two views are the same camera, whatever objects hold them. */\nexport function sameView(a: View, b: View): boolean {\n  return a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;\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,SAAgB,gBAAgB,MAA2B;CAEzD,OAAO;EACL,MAAM,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI;EAC/B,MAAM,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAG,KAAK,MAAM;GAAG,GAAG,KAAK,MAAM;EAAE;CAC3C;AACF;;;;;;AAOA,SAAgB,SAAS,MAAoB;CAC3C,OAAO,UAAU,KAAK,KAAK;AAC7B;;AAGA,SAAgB,SAAS,GAAS,GAAkB;CAClD,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,MAAM,EAAE,MAAM,KAAK,EAAE,MAAM,MAAM,EAAE,MAAM;AACxF;;;;;;;AAQA,SAAgB,cAAc,MAAkB;CAC9C,MAAM,KAAK,cAAc,KAAK,MAAM,CAAC;CACrC,MAAM,KAAK,cAAc,KAAK,MAAM,CAAC;CACrC,MAAM,IAAI,kBAAkB,KAAK,CAAC;CAClC,MAAM,IAAI,kBAAkB,KAAK,CAAC;CAClC,IAAI,OAAO,KAAK,MAAM,KAAK,OAAO,KAAK,MAAM,KAAK,MAAM,KAAK,KAAK,MAAM,KAAK,GAAG,OAAO;CACvF,OAAO;EAAE;EAAG;EAAG,OAAO;GAAE,GAAG;GAAI,GAAG;EAAG;CAAE;AACzC;AAEA,SAAS,cAAc,GAAmB;CACxC,OAAO,IAAI,KAAK,IAAI,YAAY,CAACA,gBAAc,CAAC,CAAC,IAAIA,gBAAc,CAAC;AACtE;AAEA,SAAS,kBAAkB,GAAmB;CAC5C,IAAI,OAAO,SAAS,CAAC,GAAG,OAAO;CAC/B,gBAAgB,iBAAiB,GAAG;CACpC,OAAO;AACT"}

package/dist/core/viewport/viewTransform.js

@@ -1,11 +1,13 @@
 //#region src/core/viewport/viewTransform.ts
-function e(e, t, n) {
-	return [n.panX + e * n.zoom.x, n.panY + t * n.zoom.y];
+/** Project a world-space point to screen-space pixels through a `ViewTransform`. */
+function worldToScreen(worldX, worldY, view) {
+	return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];
 }
-function t(e, t, n) {
-	return [(e - n.panX) / n.zoom.x, (t - n.panY) / n.zoom.y];
+/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */
+function screenToWorld(screenX, screenY, view) {
+	return [(screenX - view.panX) / view.zoom.x, (screenY - view.panY) / view.zoom.y];
 }
-//#endregion
-export { t as screenToWorld, e as worldToScreen };
 
+//#endregion
+export { screenToWorld, worldToScreen };
 //# sourceMappingURL=viewTransform.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"viewTransform.js","names":["worldToScreen","view","worldX","worldY","screenToWorld","screenX","screenY"],"sources":["../../../src/core/viewport/viewTransform.ts"],"sourcesContent":["/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */\nexport interface ViewTransform {\n  panX: number;\n  panY: number;\n  zoom: { x: number; y: number };\n}\n\n/** Project a world-space point to screen-space pixels through a `ViewTransform`. */\nexport function worldToScreen(\n  worldX: number,\n  worldY: number,\n  view: ViewTransform,\n): [number, number] {\n  return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];\n}\n\n/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */\nexport function screenToWorld(\n  screenX: number,\n  screenY: number,\n  view: ViewTransform,\n): [number, number] {\n  return [(screenX - view.panX) / view.zoom.x, (screenY - view.panY) / view.zoom.y];\n}\n"],"mappings":";AAQA,SAAgBA,EACd,GACA,GACA,GACkB;CAClB,OAAO,CAACC,EAAK,OAAOC,IAASD,EAAK,KAAK,GAAGA,EAAK,OAAOE,IAASF,EAAK,KAAK,CAAC;AAC5E;AAGA,SAAgBG,EACd,GACA,GACA,GACkB;CAClB,OAAO,EAAEC,IAAUJ,EAAK,QAAQA,EAAK,KAAK,IAAIK,IAAUL,EAAK,QAAQA,EAAK,KAAK,CAAC;AAClF"}
+{"version":3,"file":"viewTransform.js","names":[],"sources":["../../../src/core/viewport/viewTransform.ts"],"sourcesContent":["/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */\nexport interface ViewTransform {\n  panX: number;\n  panY: number;\n  zoom: { x: number; y: number };\n}\n\n/** Project a world-space point to screen-space pixels through a `ViewTransform`. */\nexport function worldToScreen(\n  worldX: number,\n  worldY: number,\n  view: ViewTransform,\n): [number, number] {\n  return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];\n}\n\n/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */\nexport function screenToWorld(\n  screenX: number,\n  screenY: number,\n  view: ViewTransform,\n): [number, number] {\n  return [(screenX - view.panX) / view.zoom.x, (screenY - view.panY) / view.zoom.y];\n}\n"],"mappings":";;AAQA,SAAgB,cACd,QACA,QACA,MACkB;CAClB,OAAO,CAAC,KAAK,OAAO,SAAS,KAAK,KAAK,GAAG,KAAK,OAAO,SAAS,KAAK,KAAK,CAAC;AAC5E;;AAGA,SAAgB,cACd,SACA,SACA,MACkB;CAClB,OAAO,EAAE,UAAU,KAAK,QAAQ,KAAK,KAAK,IAAI,UAAU,KAAK,QAAQ,KAAK,KAAK,CAAC;AAClF"}

package/dist/core/viewport/viewportWorldRect.js

@@ -1,13 +1,21 @@
 //#region src/core/viewport/viewportWorldRect.ts
-function e(e, t) {
+/**
+* The world-space rectangle a camera shows in a host `size` CSS pixels across.
+*
+* One formula, because two callers need it against different hosts: the
+* canvas element for view zero, and a view's own rect for a panel. Paste
+* placement centers on it, so the two disagreeing puts pasted content in a
+* view the user is not looking at.
+*/
+function viewportWorldRect(view, size) {
 	return {
-		x: e.x,
-		y: e.y,
-		width: t.width / e.scale.x,
-		height: t.height / e.scale.y
+		x: view.x,
+		y: view.y,
+		width: size.width / view.scale.x,
+		height: size.height / view.scale.y
 	};
 }
-//#endregion
-export { e as viewportWorldRect };
 
+//#endregion
+export { viewportWorldRect };
 //# sourceMappingURL=viewportWorldRect.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"viewportWorldRect.js","names":["viewportWorldRect","view","size"],"sources":["../../../src/core/viewport/viewportWorldRect.ts"],"sourcesContent":["import type { View } from './view';\n\n/**\n * The world-space rectangle a camera shows in a host `size` CSS pixels across.\n *\n * One formula, because two callers need it against different hosts: the\n * canvas element for view zero, and a view's own rect for a panel. Paste\n * placement centers on it, so the two disagreeing puts pasted content in a\n * view the user is not looking at.\n */\nexport function viewportWorldRect(\n  view: View,\n  size: { width: number; height: number },\n): { x: number; y: number; width: number; height: number } {\n  return {\n    x: view.x,\n    y: view.y,\n    width: size.width / view.scale.x,\n    height: size.height / view.scale.y,\n  };\n}\n"],"mappings":";AAUA,SAAgBA,EACd,GACA,GACyD;CACzD,OAAO;EACL,GAAGC,EAAK;EACR,GAAGA,EAAK;EACR,OAAOC,EAAK,QAAQD,EAAK,MAAM;EAC/B,QAAQC,EAAK,SAASD,EAAK,MAAM;CACnC;AACF"}
+{"version":3,"file":"viewportWorldRect.js","names":[],"sources":["../../../src/core/viewport/viewportWorldRect.ts"],"sourcesContent":["import type { View } from './view';\n\n/**\n * The world-space rectangle a camera shows in a host `size` CSS pixels across.\n *\n * One formula, because two callers need it against different hosts: the\n * canvas element for view zero, and a view's own rect for a panel. Paste\n * placement centers on it, so the two disagreeing puts pasted content in a\n * view the user is not looking at.\n */\nexport function viewportWorldRect(\n  view: View,\n  size: { width: number; height: number },\n): { x: number; y: number; width: number; height: number } {\n  return {\n    x: view.x,\n    y: view.y,\n    width: size.width / view.scale.x,\n    height: size.height / view.scale.y,\n  };\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,kBACd,MACA,MACyD;CACzD,OAAO;EACL,GAAG,KAAK;EACR,GAAG,KAAK;EACR,OAAO,KAAK,QAAQ,KAAK,MAAM;EAC/B,QAAQ,KAAK,SAAS,KAAK,MAAM;CACnC;AACF"}

package/dist/core/viewport/wheelHandler.js

@@ -1,30 +1,41 @@
-import { zoomAt as e } from "./zoomAt.js";
+import { zoomAt } from "./zoomAt.js";
+
 //#region src/core/viewport/wheelHandler.ts
-var t = 1.1;
-function n(e) {
-	return t ** (-e / 100);
+/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */
+var WHEEL_ZOOM_STEP = 1.1;
+/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling
+*  a distance and back returns to the scale you started from. */
+function wheelZoomFactor(deltaY) {
+	return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);
 }
-function r(t, r, i, a) {
-	return e(t, r, n(i), a);
+/** Zoom one wheel sample about `anchor` (canvas-local pixels). */
+function wheelZoom(view, anchor, deltaY, clamp) {
+	return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);
 }
-function i(e, t, n = {}) {
-	let r = n.axis ?? "both", i = n.swapAxis === !0, a = i && t.deltaX === 0 ? t.deltaY : t.deltaX, o = i ? 0 : t.deltaY;
+/** Pan by one wheel sample. `delta` is in screen pixels. */
+function wheelPan(view, delta, opts = {}) {
+	const axis = opts.axis ?? "both";
+	const swapped = opts.swapAxis === true;
+	const screenX = swapped ? delta.deltaX !== 0 ? delta.deltaX : delta.deltaY : delta.deltaX;
+	const screenY = swapped ? 0 : delta.deltaY;
 	return {
-		scale: e.scale,
-		x: e.x + (r === "y" ? 0 : a / e.scale.x),
-		y: e.y + (r === "x" ? 0 : o / e.scale.y)
+		scale: view.scale,
+		x: view.x + (axis === "y" ? 0 : screenX / view.scale.x),
+		y: view.y + (axis === "x" ? 0 : screenY / view.scale.y)
 	};
 }
-function a(e, t, n, a = {}) {
-	return t.ctrlKey || t.metaKey ? r(e, {
-		x: t.x,
-		y: t.y
-	}, t.deltaY, n) : i(e, t, {
-		axis: a.axis,
-		swapAxis: t.shiftKey === !0
+/** Pure reducer: the whole wheel convention in one call. */
+function computeWheelAction(view, input, clamp, opts = {}) {
+	if (input.ctrlKey || input.metaKey) return wheelZoom(view, {
+		x: input.x,
+		y: input.y
+	}, input.deltaY, clamp);
+	return wheelPan(view, input, {
+		axis: opts.axis,
+		swapAxis: input.shiftKey === true
 	});
 }
-//#endregion
-export { t as WHEEL_ZOOM_STEP, a as computeWheelAction, i as wheelPan, r as wheelZoom, n as wheelZoomFactor };
 
+//#endregion
+export { WHEEL_ZOOM_STEP, computeWheelAction, wheelPan, wheelZoom, wheelZoomFactor };
 //# sourceMappingURL=wheelHandler.js.map

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\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"}
+{"version":3,"file":"wheelHandler.js","names":[],"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,IAAa,kBAAkB;;;AAuB/B,SAAgB,gBAAgB,QAAwB;CACtD,OAAO,KAAK,IAAI,iBAAiB,CAAC,SAAS,GAAG;AAChD;;AAGA,SAAgB,UACd,MACA,QACA,QACA,OACM;CACN,OAAO,OAAO,MAAM,QAAQ,gBAAgB,MAAM,GAAG,KAAK;AAC5D;;AAGA,SAAgB,SACd,MACA,OACA,OAAqB,CAAC,GAChB;CACN,MAAM,OAAO,KAAK,QAAQ;CAC1B,MAAM,UAAU,KAAK,aAAa;CAElC,MAAM,UAAU,UAAW,MAAM,WAAW,IAAI,MAAM,SAAS,MAAM,SAAU,MAAM;CACrF,MAAM,UAAU,UAAU,IAAI,MAAM;CACpC,OAAO;EACL,OAAO,KAAK;EACZ,GAAG,KAAK,KAAK,SAAS,MAAM,IAAI,UAAU,KAAK,MAAM;EACrD,GAAG,KAAK,KAAK,SAAS,MAAM,IAAI,UAAU,KAAK,MAAM;CACvD;AACF;;AAGA,SAAgB,mBACd,MACA,OACA,OACA,OAAmC,CAAC,GAC9B;CACN,IAAI,MAAM,WAAW,MAAM,SACzB,OAAO,UAAU,MAAM;EAAE,GAAG,MAAM;EAAG,GAAG,MAAM;CAAE,GAAG,MAAM,QAAQ,KAAK;CAExE,OAAO,SAAS,MAAM,OAAO;EAAE,MAAM,KAAK;EAAM,UAAU,MAAM,aAAa;CAAK,CAAC;AACrF"}