@weasel-js/core 1.9.4 → 1.10.1

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

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

package/dist/core/viewport/useNodeOverlayFrame.js

@@ -0,0 +1,84 @@
+import { useCanvasSize as e } from "./useCanvasSize.js";
+import { composeWorldPose as t } from "../scene/composeFrame.js";
+import { composeRectPose as n } from "../scene/composePose.js";
+import { effectivePose as r } from "../scene/effectivePose.js";
+import { applyToPoint as i, invert as a, multiply as o, poseFrameOf as s } from "@weasel-js/geom";
+import { useCallback as c, useInsertionEffect as l, useRef as u } from "react";
+//#region src/core/viewport/useNodeOverlayFrame.ts
+function d(t, n, r, d = {}) {
+	let { width: h, height: g } = e(n), { view: _, compose: v } = d, y = c(() => {
+		let e = p(t, r, v);
+		if (!e) return null;
+		let n = s(e), i = m(f(_));
+		return n ? o(i, n) : i;
+	}, [
+		t,
+		r,
+		v,
+		_
+	]), b = c((e) => {
+		let t = y();
+		if (!t) return e;
+		let [n, r] = i(t, e.x, e.y);
+		return {
+			x: n,
+			y: r
+		};
+	}, [y]), x = u(null), S = c((e) => {
+		let t = y(), n = t && a(t);
+		n && (x.current = n);
+		let [r, o] = i(n ?? x.current, e.x, e.y);
+		return {
+			x: r,
+			y: o
+		};
+	}, [y]), C = p(t, r, v), w = C && h !== 0 && g !== 0 ? y() : null, T = w && a(w);
+	return l(() => {
+		T && (x.current = T);
+	}), !C || !T ? null : {
+		box: {
+			x: C.x,
+			y: C.y,
+			width: C.width,
+			height: C.height
+		},
+		toScreen: b,
+		toLocal: S,
+		width: h,
+		height: g
+	};
+}
+function f(e) {
+	return typeof e == "function" ? e() : e;
+}
+function p(e, i, a) {
+	if (i == null) return null;
+	let o = e.nodes;
+	return o.has(i) ? t({
+		getPose: (t) => r(e, o.get(t)),
+		getParent: (e) => o.get(e)?.parent ?? null
+	}, i, a ?? n) : null;
+}
+function m(e) {
+	if (!e) return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	let { x: t, y: n } = e.scale;
+	return [
+		t,
+		0,
+		0,
+		n,
+		-e.x * t,
+		-e.y * n
+	];
+}
+//#endregion
+export { d as useNodeOverlayFrame };
+
+//# sourceMappingURL=useNodeOverlayFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeOverlayFrame.js","names":["useNodeOverlayFrame","useCanvasSize","containerRef","options","project","useCallback","box","worldBoxOf","scene","nodeId","compose","frame","poseFrameOf","toView","viewMatrix","resolveView","view","multiply","toScreen","m","p","x","y","applyToPoint","lastInverse","useRef","toLocal","inverse","invert","width","height","useInsertionEffect","nodes","composeWorldPose","effectivePose","id","composeRectPose","sx","sy"],"sources":["../../../src/core/viewport/useNodeOverlayFrame.ts"],"sourcesContent":["/**\n * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one\n * scene node needs: the node's world box, the projection from that box's\n * frame into overlay pixels, and the overlay's measured size.\n *\n * `toScreen` maps the node's **unrotated world box** frame, which is the\n * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the\n * one `pathInPoseFrame` projects geometry into. The pose's rotation and\n * `transform` live in this hook, not in those: a node's stored geometry is\n * in its box by definition.\n */\nimport { useCallback, useInsertionEffect, useRef, type RefObject } from 'react';\nimport { applyToPoint, invert, multiply, poseFrameOf, type 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"}

package/dist/core/viewport/useViewAnimation.js

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

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

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

package/dist/core/viewport/view.js

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

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

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

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

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

package/dist/core/viewport/zoomAt.js

@@ -5,7 +5,16 @@ function i(e, t, r) {
 	let i = n(Math.min(r, Math.max(t, Math.abs(e))));
 	return e < 0 ? -i : i;
 }
-function a(n, a, o, s) {
+function a(e, t) {
+	return t === "x" ? {
+		x: e,
+		y: 1
+	} : t === "y" ? {
+		x: 1,
+		y: e
+	} : e;
+}
+function o(n, a, o, s) {
 	let c = r(n), l = typeof o == "number" ? o : o.x, u = typeof o == "number" ? o : o.y, d = typeof s?.min == "number" ? s.min : s?.min?.x ?? t, f = typeof s?.min == "number" ? s.min : s?.min?.y ?? t, p = typeof s?.max == "number" ? s.max : s?.max?.x ?? e, m = typeof s?.max == "number" ? s.max : s?.max?.y ?? e, h = i(c.scale.x * l, d, p), g = i(c.scale.y * u, f, m), _ = a.x / c.scale.x + c.x, v = a.y / c.scale.y + c.y;
 	return {
 		scale: {
@@ -17,6 +26,6 @@ function a(n, a, o, s) {
 	};
 }
 //#endregion
-export { a as zoomAt };
+export { a as axisZoomFactor, o as zoomAt };
 
 //# sourceMappingURL=zoomAt.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"zoomAt.js","names":["clampScale","magnitude","normalizeZoom","max","min","scale","zoomAt","view","normalizeView","input","fx","factor","fy","minX","opts","DEFAULT_MIN_ZOOM","minY","maxX","DEFAULT_MAX_ZOOM","maxY","nextX","nextY","worldX","anchor","worldY"],"sources":["../../../src/core/viewport/zoomAt.ts"],"sourcesContent":["import { normalizeView, type View, type ZoomFactor, type ZoomBound } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\n/** Optional clamp bounds for `zoomAt`. Defaults: {@link DEFAULT_MIN_ZOOM} /\n *  {@link DEFAULT_MAX_ZOOM} (per axis). */\nexport interface ZoomClampOpts {\n  min?: ZoomBound;\n  max?: ZoomBound;\n}\n\n/** Bound a scale's *magnitude*, keeping its direction. `scale.y < 0` is how a\n *  `View` spells a y-up camera, so clamping the signed value against positive\n *  bounds would flip the axis and collapse the zoom rather than limit it. */\nfunction clampScale(scale: number, min: number, max: number): number {\n  const magnitude = normalizeZoom(Math.min(max, Math.max(min, Math.abs(scale))));\n  return scale < 0 ? -magnitude : magnitude;\n}\n\n/**\n * Pure zoom primitive. Returns a new `View` whose `scale` is multiplied\n * by `factor` (per-axis, clamped) and whose translation is adjusted so\n * that the world point currently under `anchor` (screen coords relative\n * to the canvas top-left) stays under the same screen pixel after the\n * zoom — independently on each axis.\n *\n * `factor: number` means \"apply uniformly to both axes\". `factor: {x, y}`\n * applies per-axis factors. Likewise for `opts.min` / `opts.max`.\n */\nexport function zoomAt(\n  input: View,\n  anchor: { x: number; y: number },\n  factor: ZoomFactor,\n  opts?: ZoomClampOpts,\n): View {\n  const view = normalizeView(input);\n  const fx = typeof factor === 'number' ? factor : factor.x;\n  const fy = typeof factor === 'number' ? factor : factor.y;\n  const minX = typeof opts?.min === 'number' ? opts.min : opts?.min?.x ?? DEFAULT_MIN_ZOOM;\n  const minY = typeof opts?.min === 'number' ? opts.min : opts?.min?.y ?? DEFAULT_MIN_ZOOM;\n  const maxX = typeof opts?.max === 'number' ? opts.max : opts?.max?.x ?? DEFAULT_MAX_ZOOM;\n  const maxY = typeof opts?.max === 'number' ? opts.max : opts?.max?.y ?? DEFAULT_MAX_ZOOM;\n\n  const nextX = clampScale(view.scale.x * fx, minX, maxX);\n  const nextY = clampScale(view.scale.y * fy, minY, maxY);\n\n  const worldX = anchor.x / view.scale.x + view.x;\n  const worldY = anchor.y / view.scale.y + view.y;\n  return {\n    scale: { x: nextX, y: nextY },\n    x: worldX - anchor.x / nextX,\n    y: worldY - anchor.y / nextY,\n  };\n}\n"],"mappings":";;;AAaA,SAASA,EAAW,GAAe,GAAa,GAAqB;CACnE,IAAMC,IAAYC,EAAc,KAAK,IAAIC,GAAK,KAAK,IAAIC,GAAK,KAAK,IAAIC,CAAK,CAAC,CAAC,CAAC;CAC7E,OAAOA,IAAQ,IAAI,CAACJ,IAAYA;AAClC;AAYA,SAAgBK,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAOC,EAAcC,CAAK,GAC1BC,IAAK,OAAOC,KAAW,WAAWA,IAASA,EAAO,GAClDC,IAAK,OAAOD,KAAW,WAAWA,IAASA,EAAO,GAClDE,IAAO,OAAOC,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKC,GAClEC,IAAO,OAAOF,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKC,GAClEE,IAAO,OAAOH,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKI,GAClEC,IAAO,OAAOL,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKI,GAElEE,IAAQpB,EAAWO,EAAK,MAAM,IAAIG,GAAIG,GAAMI,CAAI,GAChDI,IAAQrB,EAAWO,EAAK,MAAM,IAAIK,GAAII,GAAMG,CAAI,GAEhDG,IAASC,EAAO,IAAIhB,EAAK,MAAM,IAAIA,EAAK,GACxCiB,IAASD,EAAO,IAAIhB,EAAK,MAAM,IAAIA,EAAK;CAC9C,OAAO;EACL,OAAO;GAAE,GAAGa;GAAO,GAAGC;EAAM;EAC5B,GAAGC,IAASC,EAAO,IAAIH;EACvB,GAAGI,IAASD,EAAO,IAAIF;CACzB;AACF"}
+{"version":3,"file":"zoomAt.js","names":["clampScale","magnitude","normalizeZoom","max","min","scale","axisZoomFactor","axis","factor","zoomAt","view","normalizeView","input","fx","fy","minX","opts","DEFAULT_MIN_ZOOM","minY","maxX","DEFAULT_MAX_ZOOM","maxY","nextX","nextY","worldX","anchor","worldY"],"sources":["../../../src/core/viewport/zoomAt.ts"],"sourcesContent":["import { normalizeView, type View, type ZoomFactor, type ZoomBound } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\n/** Optional clamp bounds for `zoomAt`. Defaults: {@link DEFAULT_MIN_ZOOM} /\n *  {@link DEFAULT_MAX_ZOOM} (per axis). */\nexport interface ZoomClampOpts {\n  min?: ZoomBound;\n  max?: ZoomBound;\n}\n\n/** Bound a scale's *magnitude*, keeping its direction. `scale.y < 0` is how a\n *  `View` spells a y-up camera, so clamping the signed value against positive\n *  bounds would flip the axis and collapse the zoom rather than limit it. */\nfunction clampScale(scale: number, min: number, max: number): number {\n  const magnitude = normalizeZoom(Math.min(max, Math.max(min, Math.abs(scale))));\n  return scale < 0 ? -magnitude : magnitude;\n}\n\n/** Which axes a zoom scales. */\nexport type ZoomAxis = 'both' | 'x' | 'y';\n\n/** `factor` held to one axis: the other axis's factor is 1, so `zoomAt` leaves\n *  its scale and its translation where they were. */\nexport function axisZoomFactor(factor: number, axis: ZoomAxis): ZoomFactor {\n  if (axis === 'x') return { x: factor, y: 1 };\n  if (axis === 'y') return { x: 1, y: factor };\n  return factor;\n}\n\n/**\n * Pure zoom primitive. Returns a new `View` whose `scale` is multiplied\n * by `factor` (per-axis, clamped) and whose translation is adjusted so\n * that the world point currently under `anchor` (screen coords relative\n * to the canvas top-left) stays under the same screen pixel after the\n * zoom — independently on each axis.\n *\n * `factor: number` means \"apply uniformly to both axes\". `factor: {x, y}`\n * applies per-axis factors. Likewise for `opts.min` / `opts.max`.\n */\nexport function zoomAt(\n  input: View,\n  anchor: { x: number; y: number },\n  factor: ZoomFactor,\n  opts?: ZoomClampOpts,\n): View {\n  const view = normalizeView(input);\n  const fx = typeof factor === 'number' ? factor : factor.x;\n  const fy = typeof factor === 'number' ? factor : factor.y;\n  const minX = typeof opts?.min === 'number' ? opts.min : opts?.min?.x ?? DEFAULT_MIN_ZOOM;\n  const minY = typeof opts?.min === 'number' ? opts.min : opts?.min?.y ?? DEFAULT_MIN_ZOOM;\n  const maxX = typeof opts?.max === 'number' ? opts.max : opts?.max?.x ?? DEFAULT_MAX_ZOOM;\n  const maxY = typeof opts?.max === 'number' ? opts.max : opts?.max?.y ?? DEFAULT_MAX_ZOOM;\n\n  const nextX = clampScale(view.scale.x * fx, minX, maxX);\n  const nextY = clampScale(view.scale.y * fy, minY, maxY);\n\n  const worldX = anchor.x / view.scale.x + view.x;\n  const worldY = anchor.y / view.scale.y + view.y;\n  return {\n    scale: { x: nextX, y: nextY },\n    x: worldX - anchor.x / nextX,\n    y: worldY - anchor.y / nextY,\n  };\n}\n"],"mappings":";;;AAaA,SAASA,EAAW,GAAe,GAAa,GAAqB;CACnE,IAAMC,IAAYC,EAAc,KAAK,IAAIC,GAAK,KAAK,IAAIC,GAAK,KAAK,IAAIC,CAAK,CAAC,CAAC,CAAC;CAC7E,OAAOA,IAAQ,IAAI,CAACJ,IAAYA;AAClC;AAOA,SAAgBK,EAAe,GAAgB,GAA4B;CAGzE,OAFIC,MAAS,MAAY;EAAE,GAAGC;EAAQ,GAAG;CAAE,IACvCD,MAAS,MAAY;EAAE,GAAG;EAAG,GAAGC;CAAO,IACpCA;AACT;AAYA,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAOC,EAAcC,CAAK,GAC1BC,IAAK,OAAOL,KAAW,WAAWA,IAASA,EAAO,GAClDM,IAAK,OAAON,KAAW,WAAWA,IAASA,EAAO,GAClDO,IAAO,OAAOC,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKC,GAClEC,IAAO,OAAOF,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKC,GAClEE,IAAO,OAAOH,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKI,GAClEC,IAAO,OAAOL,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKI,GAElEE,IAAQtB,EAAWU,EAAK,MAAM,IAAIG,GAAIE,GAAMI,CAAI,GAChDI,IAAQvB,EAAWU,EAAK,MAAM,IAAII,GAAII,GAAMG,CAAI,GAEhDG,IAASC,EAAO,IAAIf,EAAK,MAAM,IAAIA,EAAK,GACxCgB,IAASD,EAAO,IAAIf,EAAK,MAAM,IAAIA,EAAK;CAC9C,OAAO;EACL,OAAO;GAAE,GAAGY;GAAO,GAAGC;EAAM;EAC5B,GAAGC,IAASC,EAAO,IAAIH;EACvB,GAAGI,IAASD,EAAO,IAAIF;CACzB;AACF"}

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

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