@weasel-js/core 1.10.0 → 1.11.0

package/dist/interactions/actions/defaults/viewportDragPan.js

@@ -1,17 +1,35 @@
-import { createVelocityTracker as e } from "../../../core/viewport/createVelocityTracker.js";
-import { resolveParams as t } from "@weasel-js/routing";
+import { createVelocityTracker } from "../../../core/viewport/createVelocityTracker.js";
+import { resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/defaults/viewportDragPan.ts
-function n(e, t) {
-	let n = t.startView, r = t.view.get();
+/**
+* Rebuild the client-pixel drag delta from the world one, for an event source
+* that supplied no `clientX`/`clientY`.
+*
+* A world delta is self-referential mid-pan — its two ends were measured under
+* different views — so it cannot simply be scaled. Undoing each end against the
+* view that produced it recovers the client delta exactly, since
+* `world = (client - origin) / scale + view` and neither the canvas origin nor
+* the scale moves during a pan.
+*/
+function screenDeltaFromWorld(drag, scratch) {
+	const v0 = scratch.startView;
+	const now = scratch.view.get();
 	return {
-		x: (e.current.x - r.x - (e.start.x - n.x)) * n.scale.x,
-		y: (e.current.y - r.y - (e.start.y - n.y)) * n.scale.y
+		x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,
+		y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y
 	};
 }
-function r(e, t) {
-	return e === t || e.x === t.x && e.y === t.y && e.scale.x === t.scale.x && e.scale.y === t.scale.y;
+function sameCamera(a, b) {
+	return a === b || a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;
 }
-var i = {
+/**
+* Translates the viewport by the screen-space drag delta so the canvas content
+* follows the pointer. Produces no scene ops — view changes are not undoable.
+* It has no binding of its own: the hand tool binds a drag to it, and a canvas
+* that pans on any unclaimed drag adds `dragPanContribution`.
+*/
+var viewportDragPanAction = {
 	id: "viewport.dragPan",
 	label: "Drag to pan viewport",
 	group: "viewport",
@@ -20,70 +38,85 @@ var i = {
 	requires: ["view", "debug"],
 	invoker: {
 		timing: "ongoing",
-		start(i, a) {
-			let o = i.deps.view;
-			if (!o) return {};
-			let s = o.get(), c = t(a?.params) ?? {}, l = c.inertia === !0 ? {} : c.inertia || void 0, u = {
-				startView: s,
-				base: s,
+		start(ctx, opts) {
+			const view = ctx.deps.view;
+			if (!view) return {};
+			const startView = view.get();
+			const params = resolveParams(opts?.params) ?? {};
+			const inertia = params.inertia === true ? {} : params.inertia || void 0;
+			const scratch = {
+				startView,
+				base: startView,
 				baseScreen: {
 					x: 0,
 					y: 0
 				},
-				seen: s,
-				view: o,
-				axis: c.axis ?? "both",
-				inertia: l,
-				tracker: l && o.decay ? e() : void 0,
+				seen: startView,
+				view,
+				axis: params.axis ?? "both",
+				inertia,
+				tracker: inertia && view.decay ? createVelocityTracker() : void 0,
 				lastScreen: {
 					x: 0,
 					y: 0
 				}
-			}, d = i.deps.debug, f = i.drag?.start;
+			};
+			const debug = ctx.deps.debug;
+			const grab = ctx.drag?.start;
 			return {
 				kind: "pan",
-				onMove(e) {
-					if (!e.drag) return;
-					let t = e.drag.screenDelta ?? n(e.drag, u), i = u.axis === "y" ? 0 : t.x, a = u.axis === "x" ? 0 : t.y;
-					u.tracker?.record(i - u.lastScreen.x, a - u.lastScreen.y, performance.now());
-					let o = u.view.get();
-					r(o, u.seen) || (u.base = o, u.baseScreen = u.lastScreen), u.lastScreen = {
-						x: i,
-						y: a
+				onMove(moveCtx) {
+					if (!moveCtx.drag) return;
+					const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);
+					const screenDx = scratch.axis === "y" ? 0 : screen.x;
+					const screenDy = scratch.axis === "x" ? 0 : screen.y;
+					scratch.tracker?.record(screenDx - scratch.lastScreen.x, screenDy - scratch.lastScreen.y, performance.now());
+					const now = scratch.view.get();
+					if (!sameCamera(now, scratch.seen)) {
+						scratch.base = now;
+						scratch.baseScreen = scratch.lastScreen;
+					}
+					scratch.lastScreen = {
+						x: screenDx,
+						y: screenDy
 					};
-					let s = u.base, c = {
-						...s,
-						x: s.x - (i - u.baseScreen.x) / s.scale.x,
-						y: s.y - (a - u.baseScreen.y) / s.scale.y
+					const sv = scratch.base;
+					const next = {
+						...sv,
+						x: sv.x - (screenDx - scratch.baseScreen.x) / sv.scale.x,
+						y: sv.y - (screenDy - scratch.baseScreen.y) / sv.scale.y
 					};
-					u.view.set(c), u.seen = u.view.get(), d?.recordViewport("pan", s, c, f && {
-						x: f.x,
-						y: f.y
+					scratch.view.set(next);
+					scratch.seen = scratch.view.get();
+					debug?.recordViewport("pan", sv, next, grab && {
+						x: grab.x,
+						y: grab.y
 					});
 				},
-				onEnd(e, t) {
-					let { tracker: n, inertia: r, view: i } = u;
-					if (t === "cancel" || !n || !r || !i.decay) return;
-					let { vx: a, vy: o } = n.getVelocity(), s = u.base.scale;
-					i.decay({
+				onEnd(_endCtx, reason) {
+					const { tracker, inertia, view: v } = scratch;
+					if (reason === "cancel" || !tracker || !inertia || !v.decay) return;
+					const { vx, vy } = tracker.getVelocity();
+					const scale = scratch.base.scale;
+					v.decay({
 						velocity: {
-							vx: -a / s.x,
-							vy: -o / s.y
+							vx: -vx / scale.x,
+							vy: -vy / scale.y
 						},
-						friction: r.friction,
-						minSpeed: r.minSpeed,
-						boundary: r.boundary,
-						viewBounds: r.bounds,
+						friction: inertia.friction,
+						minSpeed: inertia.minSpeed,
+						boundary: inertia.boundary,
+						viewBounds: inertia.bounds,
 						initialPosition: {
-							x: i.get().x,
-							y: i.get().y
+							x: v.get().x,
+							y: v.get().y
 						},
-						onTick: (e, t) => {
-							let n = i.get();
-							i.set({
-								...n,
-								x: n.x + e,
-								y: n.y + t
+						onTick: (dx, dy) => {
+							const cur = v.get();
+							v.set({
+								...cur,
+								x: cur.x + dx,
+								y: cur.y + dy
 							});
 						}
 					});
@@ -91,9 +124,9 @@ var i = {
 			};
 		}
 	},
-	enabled: () => !0
+	enabled: () => true
 };
-//#endregion
-export { i as viewportDragPanAction };
 
+//#endregion
+export { viewportDragPanAction };
 //# sourceMappingURL=viewportDragPan.js.map

package/dist/interactions/actions/defaults/viewportDragPan.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewportDragPan.js","names":["screenDeltaFromWorld","v0","scratch","now","drag","sameCamera","a","b","viewportDragPanAction","view","ctx","startView","params","resolveParams","opts","inertia","createVelocityTracker","debug","grab","moveCtx","screen","screenDx","screenDy","sv","next","v","reason","tracker","scale","vx","vy","cur","dx","dy"],"sources":["../../../../src/interactions/actions/defaults/viewportDragPan.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { resolveParams, type InvocationCtx, type OngoingHandle, type BindingOpts } from '@weasel-js/routing';\nimport type { View } from 'core/viewport/view';\nimport type { ViewApi } from '../depSchema';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { createVelocityTracker, type VelocityTracker } from 'core/viewport/createVelocityTracker';\n\ninterface DragPanScratch {\n  startView: View;\n  /** The view the pan is measured from, and the cumulative screen delta it\n   *  was taken at. The press, until something else moves the camera. */\n  base: View;\n  baseScreen: { x: number; y: number };\n  /** The view as this pan last left it. */\n  seen: View;\n  view: ViewApi;\n  axis: 'both' | 'x' | 'y';\n  inertia: InertiaConfig | undefined;\n  tracker: VelocityTracker | undefined;\n  lastScreen: { x: number; y: number };\n}\n\n/**\n * Rebuild the client-pixel drag delta from the world one, for an event source\n * that supplied no `clientX`/`clientY`.\n *\n * A world delta is self-referential mid-pan — its two ends were measured under\n * different views — so it cannot simply be scaled. Undoing each end against the\n * view that produced it recovers the client delta exactly, since\n * `world = (client - origin) / scale + view` and neither the canvas origin nor\n * the scale moves during a pan.\n */\nfunction screenDeltaFromWorld(\n  drag: NonNullable<InvocationCtx['drag']>,\n  scratch: DragPanScratch,\n): { x: number; y: number } {\n  const v0 = scratch.startView;\n  const now = scratch.view.get();\n  return {\n    x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,\n    y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y,\n  };\n}\n\nfunction sameCamera(a: View, b: View): boolean {\n  return a === b\n    || (a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y);\n}\n\n/** Binding params `viewport.dragPan` understands, read at `start`. A bare\n *  binding pans both axes with no coasting. `inertia` coasts the view after\n *  release through the optional `view.decay` dep; with none wired the pan\n *  simply lands. `true` coasts with the kit defaults. */\nexport interface DragPanParams {\n  axis?: 'both' | 'x' | 'y';\n  inertia?: boolean | InertiaConfig;\n}\n\n/**\n * @experimental\n * Translates the viewport by the screen-space drag delta so the canvas content\n * follows the pointer. Produces no scene ops — view changes are not undoable.\n * It has no binding of its own: the hand tool binds a drag to it, and a canvas\n * that pans on any unclaimed drag adds `dragPanContribution`.\n */\n// No `eligible` field → viewport pan is always eligible across all modes.\nexport const viewportDragPanAction: Action & { requires: string[] } = {\n  id: 'viewport.dragPan',\n  label: 'Drag to pan viewport',\n  group: 'viewport',\n  cursor: 'grab',\n  activeCursor: 'grabbing',\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const view = ctx.deps.view;\n      if (!view) return {};\n\n      const startView = view.get();\n      // The dispatcher hands the binding's unresolved `opts` here and nowhere\n      // else, and pumps `onMove` / `onEnd` with an empty deps bag. Everything\n      // the gesture needs has to be captured now.\n      const params = (resolveParams(opts?.params) ?? {}) as DragPanParams;\n      const inertia = params.inertia === true ? {} : params.inertia || undefined;\n      const scratch: DragPanScratch = {\n        startView,\n        base: startView,\n        baseScreen: { x: 0, y: 0 },\n        seen: startView,\n        view,\n        axis: params.axis ?? 'both',\n        inertia,\n        // Only track when a coast could actually happen, so the common\n        // no-inertia drag does no per-move work.\n        tracker: inertia && view.decay ? createVelocityTracker() : undefined,\n        lastScreen: { x: 0, y: 0 },\n      };\n      const debug = ctx.deps.debug;\n      const grab = ctx.drag?.start;\n\n      return {\n        kind: 'pan',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          // Use `screenDelta` (client/CSS pixels), NOT `delta` (world). Pan\n          // mutates the view itself, so world deltas are self-referential and\n          // halve the apparent movement on every pointermove after the first.\n          const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);\n          // An axis lock drops the other component of the *cumulative* delta,\n          // so the locked axis never moves however the pointer wanders.\n          const screenDx = scratch.axis === 'y' ? 0 : screen.x;\n          const screenDy = scratch.axis === 'x' ? 0 : screen.y;\n          scratch.tracker?.record(\n            screenDx - scratch.lastScreen.x,\n            screenDy - scratch.lastScreen.y,\n            performance.now(),\n          );\n          // A zoom or pan from elsewhere while the drag is held (a wheel, a\n          // key) is kept: the pan carries on from where it left the camera.\n          const now = scratch.view.get();\n          if (!sameCamera(now, scratch.seen)) {\n            scratch.base = now;\n            scratch.baseScreen = scratch.lastScreen;\n          }\n          scratch.lastScreen = { x: screenDx, y: screenDy };\n          const sv = scratch.base;\n          const next = {\n            ...sv,\n            x: sv.x - (screenDx - scratch.baseScreen.x) / sv.scale.x,\n            y: sv.y - (screenDy - scratch.baseScreen.y) / sv.scale.y,\n          };\n          scratch.view.set(next);\n          scratch.seen = scratch.view.get();\n          debug?.recordViewport('pan', sv, next, grab && { x: grab.x, y: grab.y });\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          // No scene ops to commit; the pan itself is already live. What is\n          // left is the coast, and only for a drag that actually ended.\n          const { tracker, inertia, view: v } = scratch;\n          if (reason === 'cancel' || !tracker || !inertia || !v.decay) return;\n          const { vx, vy } = tracker.getVelocity();\n          const scale = scratch.base.scale;\n          v.decay({\n            // Screen px/ms → world units/ms, matching the onMove conversion.\n            velocity: { vx: -vx / scale.x, vy: -vy / scale.y },\n            friction: inertia.friction,\n            minSpeed: inertia.minSpeed,\n            boundary: inertia.boundary,\n            viewBounds: inertia.bounds,\n            initialPosition: { x: v.get().x, y: v.get().y },\n            onTick: (dx, dy) => {\n              const cur = v.get();\n              v.set({ ...cur, x: cur.x + dx, y: cur.y + dy });\n            },\n          });\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n"],"mappings":"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"}
+{"version":3,"file":"viewportDragPan.js","names":[],"sources":["../../../../src/interactions/actions/defaults/viewportDragPan.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { resolveParams, type InvocationCtx, type OngoingHandle, type BindingOpts } from '@weasel-js/routing';\nimport type { View } from 'core/viewport/view';\nimport type { ViewApi } from '../depSchema';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { createVelocityTracker, type VelocityTracker } from 'core/viewport/createVelocityTracker';\n\ninterface DragPanScratch {\n  startView: View;\n  /** The view the pan is measured from, and the cumulative screen delta it\n   *  was taken at. The press, until something else moves the camera. */\n  base: View;\n  baseScreen: { x: number; y: number };\n  /** The view as this pan last left it. */\n  seen: View;\n  view: ViewApi;\n  axis: 'both' | 'x' | 'y';\n  inertia: InertiaConfig | undefined;\n  tracker: VelocityTracker | undefined;\n  lastScreen: { x: number; y: number };\n}\n\n/**\n * Rebuild the client-pixel drag delta from the world one, for an event source\n * that supplied no `clientX`/`clientY`.\n *\n * A world delta is self-referential mid-pan — its two ends were measured under\n * different views — so it cannot simply be scaled. Undoing each end against the\n * view that produced it recovers the client delta exactly, since\n * `world = (client - origin) / scale + view` and neither the canvas origin nor\n * the scale moves during a pan.\n */\nfunction screenDeltaFromWorld(\n  drag: NonNullable<InvocationCtx['drag']>,\n  scratch: DragPanScratch,\n): { x: number; y: number } {\n  const v0 = scratch.startView;\n  const now = scratch.view.get();\n  return {\n    x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,\n    y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y,\n  };\n}\n\nfunction sameCamera(a: View, b: View): boolean {\n  return a === b\n    || (a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y);\n}\n\n/** Binding params `viewport.dragPan` understands, read at `start`. A bare\n *  binding pans both axes with no coasting. `inertia` coasts the view after\n *  release through the optional `view.decay` dep; with none wired the pan\n *  simply lands. `true` coasts with the kit defaults. */\nexport interface DragPanParams {\n  axis?: 'both' | 'x' | 'y';\n  inertia?: boolean | InertiaConfig;\n}\n\n/**\n * Translates the viewport by the screen-space drag delta so the canvas content\n * follows the pointer. Produces no scene ops — view changes are not undoable.\n * It has no binding of its own: the hand tool binds a drag to it, and a canvas\n * that pans on any unclaimed drag adds `dragPanContribution`.\n */\n// No `eligible` field → viewport pan is always eligible across all modes.\nexport const viewportDragPanAction: Action & { requires: string[] } = {\n  id: 'viewport.dragPan',\n  label: 'Drag to pan viewport',\n  group: 'viewport',\n  cursor: 'grab',\n  activeCursor: 'grabbing',\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const view = ctx.deps.view;\n      if (!view) return {};\n\n      const startView = view.get();\n      // The dispatcher hands the binding's unresolved `opts` here and nowhere\n      // else, and pumps `onMove` / `onEnd` with an empty deps bag. Everything\n      // the gesture needs has to be captured now.\n      const params = (resolveParams(opts?.params) ?? {}) as DragPanParams;\n      const inertia = params.inertia === true ? {} : params.inertia || undefined;\n      const scratch: DragPanScratch = {\n        startView,\n        base: startView,\n        baseScreen: { x: 0, y: 0 },\n        seen: startView,\n        view,\n        axis: params.axis ?? 'both',\n        inertia,\n        // Only track when a coast could actually happen, so the common\n        // no-inertia drag does no per-move work.\n        tracker: inertia && view.decay ? createVelocityTracker() : undefined,\n        lastScreen: { x: 0, y: 0 },\n      };\n      const debug = ctx.deps.debug;\n      const grab = ctx.drag?.start;\n\n      return {\n        kind: 'pan',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          // Use `screenDelta` (client/CSS pixels), NOT `delta` (world). Pan\n          // mutates the view itself, so world deltas are self-referential and\n          // halve the apparent movement on every pointermove after the first.\n          const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);\n          // An axis lock drops the other component of the *cumulative* delta,\n          // so the locked axis never moves however the pointer wanders.\n          const screenDx = scratch.axis === 'y' ? 0 : screen.x;\n          const screenDy = scratch.axis === 'x' ? 0 : screen.y;\n          scratch.tracker?.record(\n            screenDx - scratch.lastScreen.x,\n            screenDy - scratch.lastScreen.y,\n            performance.now(),\n          );\n          // A zoom or pan from elsewhere while the drag is held (a wheel, a\n          // key) is kept: the pan carries on from where it left the camera.\n          const now = scratch.view.get();\n          if (!sameCamera(now, scratch.seen)) {\n            scratch.base = now;\n            scratch.baseScreen = scratch.lastScreen;\n          }\n          scratch.lastScreen = { x: screenDx, y: screenDy };\n          const sv = scratch.base;\n          const next = {\n            ...sv,\n            x: sv.x - (screenDx - scratch.baseScreen.x) / sv.scale.x,\n            y: sv.y - (screenDy - scratch.baseScreen.y) / sv.scale.y,\n          };\n          scratch.view.set(next);\n          scratch.seen = scratch.view.get();\n          debug?.recordViewport('pan', sv, next, grab && { x: grab.x, y: grab.y });\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          // No scene ops to commit; the pan itself is already live. What is\n          // left is the coast, and only for a drag that actually ended.\n          const { tracker, inertia, view: v } = scratch;\n          if (reason === 'cancel' || !tracker || !inertia || !v.decay) return;\n          const { vx, vy } = tracker.getVelocity();\n          const scale = scratch.base.scale;\n          v.decay({\n            // Screen px/ms → world units/ms, matching the onMove conversion.\n            velocity: { vx: -vx / scale.x, vy: -vy / scale.y },\n            friction: inertia.friction,\n            minSpeed: inertia.minSpeed,\n            boundary: inertia.boundary,\n            viewBounds: inertia.bounds,\n            initialPosition: { x: v.get().x, y: v.get().y },\n            onTick: (dx, dy) => {\n              const cur = v.get();\n              v.set({ ...cur, x: cur.x + dx, y: cur.y + dy });\n            },\n          });\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n"],"mappings":"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"}

package/dist/interactions/actions/defaults/viewportWheelPan.js

@@ -1,57 +1,76 @@
-import { wheelPan as e } from "../../../core/viewport/wheelHandler.js";
+import { wheelPan } from "../../../core/viewport/wheelHandler.js";
+
 //#region src/interactions/actions/defaults/viewportWheelPan.ts
-var t = {
+/**
+* Wheel and trackpad pan. Shift+wheel pans horizontally, by routing deltaY
+* into the x axis (`params.swapAxis`). `params.axis` locks the pan to one
+* axis, and outranks `swapAxis`: a shift-wheel routed into a barred axis
+* moves nothing.
+*/
+var viewportWheelPanAction = {
 	id: "viewport.wheelPan",
 	label: "Pan (wheel)",
 	group: "viewport",
+	/**
+	* The matcher's strict modifier check keeps the bindings exclusive, and
+	* leaves Cmd+wheel to `viewportZoomAction`: omitting `mods` forbids any
+	* modifier, and `mods: { shift: true }` forbids the others.
+	*/
 	defaultBinding: [{
 		spec: { kind: "wheel" },
 		opts: {}
 	}, {
 		spec: {
 			kind: "wheel",
-			mods: { shift: !0 }
+			mods: { shift: true }
 		},
-		opts: { params: { swapAxis: !0 } }
+		opts: { params: { swapAxis: true } }
 	}],
 	requires: ["view", "debug"],
 	invoker: {
 		timing: "immediate",
-		run(t, n) {
-			let r = t.view;
-			if (!r) return;
-			let i = n?.axis ?? "both", a = n?.deltaX ?? 0, o = n?.deltaY ?? 0, s = r.get(), c = e(s, {
-				deltaX: a,
-				deltaY: o
+		run(deps, params) {
+			const view = deps.view;
+			if (!view) return;
+			const axis = params?.axis ?? "both";
+			const deltaX = params?.deltaX ?? 0;
+			const deltaY = params?.deltaY ?? 0;
+			const from = view.get();
+			const next = wheelPan(from, {
+				deltaX,
+				deltaY
 			}, {
-				axis: i,
-				swapAxis: n?.swapAxis === !0
+				axis,
+				swapAxis: params?.swapAxis === true
 			});
-			r.set(c), t.debug?.recordViewport("pan", s, c);
+			view.set(next);
+			deps.debug?.recordViewport("pan", from, next);
 		}
 	},
-	enabled: () => !0
+	enabled: () => true
 };
-function n(e = {}) {
-	let n = e.axis ?? "both";
+/** Builds a `viewport.wheelPan` descriptor with `opts` baked into both of its
+*  default bindings. `viewportWheelPanAction` is the unconfigured one. */
+function makeViewportWheelPanAction(opts = {}) {
+	const axis = opts.axis ?? "both";
 	return {
-		...t,
+		...viewportWheelPanAction,
 		defaultBinding: [{
 			spec: { kind: "wheel" },
-			opts: { params: { axis: n } }
+			opts: { params: { axis } }
 		}, {
 			spec: {
 				kind: "wheel",
-				mods: { shift: !0 }
+				mods: { shift: true }
 			},
 			opts: { params: {
-				swapAxis: !0,
-				axis: n
+				swapAxis: true,
+				axis
 			} }
 		}]
 	};
 }
-//#endregion
-export { n as makeViewportWheelPanAction, t as viewportWheelPanAction };
 
+//#endregion
+export { makeViewportWheelPanAction, viewportWheelPanAction };
 //# sourceMappingURL=viewportWheelPan.js.map

package/dist/interactions/actions/defaults/viewportWheelPan.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewportWheelPan.js","names":["viewportWheelPanAction","view","deps","axis","params","deltaX","deltaY","from","next","wheelPan","makeViewportWheelPanAction","opts"],"sources":["../../../../src/interactions/actions/defaults/viewportWheelPan.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { wheelPan } from 'core/viewport/wheelHandler';\n\n/**\n * @experimental\n * Wheel and trackpad pan. Shift+wheel pans horizontally, by routing deltaY\n * into the x axis (`params.swapAxis`). `params.axis` locks the pan to one\n * axis, and outranks `swapAxis`: a shift-wheel routed into a barred axis\n * moves nothing.\n */\nexport const viewportWheelPanAction: Action & { requires: string[] } = {\n  id: 'viewport.wheelPan',\n  label: 'Pan (wheel)',\n  group: 'viewport',\n  /**\n   * The matcher's strict modifier check keeps the bindings exclusive, and\n   * leaves Cmd+wheel to `viewportZoomAction`: omitting `mods` forbids any\n   * modifier, and `mods: { shift: true }` forbids the others.\n   */\n  defaultBinding: [\n    { spec: { kind: 'wheel' }, opts: {} },\n    { spec: { kind: 'wheel', mods: { shift: true } }, opts: { params: { swapAxis: true } } },\n  ],\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'immediate',\n    run(deps, params) {\n      const view = deps.view;\n      if (!view) return;\n      const axis = (params?.axis as 'both' | 'x' | 'y' | undefined) ?? 'both';\n      const deltaX = (params?.deltaX as number | undefined) ?? 0;\n      const deltaY = (params?.deltaY as number | undefined) ?? 0;\n      const from = view.get();\n      const next = wheelPan(from, { deltaX, deltaY }, { axis, swapAxis: params?.swapAxis === true });\n      view.set(next);\n      deps.debug?.recordViewport('pan', from, next);\n    },\n  },\n  enabled: () => true,\n};\n\n/** Tuning for {@link makeViewportWheelPanAction}. */\nexport interface WheelPanOptions {\n  /** Lock the pan to one axis. Default `'both'`. */\n  axis?: 'both' | 'x' | 'y';\n}\n\n/** Builds a `viewport.wheelPan` descriptor with `opts` baked into both of its\n *  default bindings. `viewportWheelPanAction` is the unconfigured one. */\nexport function makeViewportWheelPanAction(\n  opts: WheelPanOptions = {},\n): Action & { requires: string[] } {\n  const axis = opts.axis ?? 'both';\n  return {\n    ...viewportWheelPanAction,\n    defaultBinding: [\n      { spec: { kind: 'wheel' }, opts: { params: { axis } } },\n      { spec: { kind: 'wheel', mods: { shift: true } }, opts: { params: { swapAxis: true, axis } } },\n    ],\n  };\n}\n"],"mappings":";;AAUA,IAAaA,IAA0D;CACrE,IAAI;CACJ,OAAO;CACP,OAAO;CAMP,gBAAgB,CACd;EAAE,MAAM,EAAE,MAAM,QAAQ;EAAG,MAAM,CAAC;CAAE,GACpC;EAAE,MAAM;GAAE,MAAM;GAAS,MAAM,EAAE,OAAO,GAAK;EAAE;EAAG,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAK,EAAE;CAAE,CACzF;CACA,UAAU,CAAC,QAAQ,OAAO;CAC1B,SAAS;EACP,QAAQ;EACR,IAAI,GAAM,GAAQ;GAChB,IAAMC,IAAOC,EAAK;GAClB,IAAI,CAACD,GAAM;GACX,IAAME,IAAQC,GAAQ,QAA2C,QAC3DC,IAAUD,GAAQ,UAAiC,GACnDE,IAAUF,GAAQ,UAAiC,GACnDG,IAAON,EAAK,IAAI,GAChBO,IAAOC,EAASF,GAAM;IAAE;IAAQ;GAAO,GAAG;IAAE;IAAM,UAAUH,GAAQ,aAAa;GAAK,CAAC;GAE7F,AADAH,EAAK,IAAIO,CAAI,GACbN,EAAK,OAAO,eAAe,OAAOK,GAAMC,CAAI;EAC9C;CACF;CACA,eAAe;AACjB;AAUA,SAAgBE,EACd,IAAwB,CAAC,GACQ;CACjC,IAAMP,IAAOQ,EAAK,QAAQ;CAC1B,OAAO;EACL,GAAGX;EACH,gBAAgB,CACd;GAAE,MAAM,EAAE,MAAM,QAAQ;GAAG,MAAM,EAAE,QAAQ,EAAE,QAAK,EAAE;EAAE,GACtD;GAAE,MAAM;IAAE,MAAM;IAAS,MAAM,EAAE,OAAO,GAAK;GAAE;GAAG,MAAM,EAAE,QAAQ;IAAE,UAAU;IAAM;GAAK,EAAE;EAAE,CAC/F;CACF;AACF"}
+{"version":3,"file":"viewportWheelPan.js","names":[],"sources":["../../../../src/interactions/actions/defaults/viewportWheelPan.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { wheelPan } from 'core/viewport/wheelHandler';\n\n/**\n * Wheel and trackpad pan. Shift+wheel pans horizontally, by routing deltaY\n * into the x axis (`params.swapAxis`). `params.axis` locks the pan to one\n * axis, and outranks `swapAxis`: a shift-wheel routed into a barred axis\n * moves nothing.\n */\nexport const viewportWheelPanAction: Action & { requires: string[] } = {\n  id: 'viewport.wheelPan',\n  label: 'Pan (wheel)',\n  group: 'viewport',\n  /**\n   * The matcher's strict modifier check keeps the bindings exclusive, and\n   * leaves Cmd+wheel to `viewportZoomAction`: omitting `mods` forbids any\n   * modifier, and `mods: { shift: true }` forbids the others.\n   */\n  defaultBinding: [\n    { spec: { kind: 'wheel' }, opts: {} },\n    { spec: { kind: 'wheel', mods: { shift: true } }, opts: { params: { swapAxis: true } } },\n  ],\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'immediate',\n    run(deps, params) {\n      const view = deps.view;\n      if (!view) return;\n      const axis = (params?.axis as 'both' | 'x' | 'y' | undefined) ?? 'both';\n      const deltaX = (params?.deltaX as number | undefined) ?? 0;\n      const deltaY = (params?.deltaY as number | undefined) ?? 0;\n      const from = view.get();\n      const next = wheelPan(from, { deltaX, deltaY }, { axis, swapAxis: params?.swapAxis === true });\n      view.set(next);\n      deps.debug?.recordViewport('pan', from, next);\n    },\n  },\n  enabled: () => true,\n};\n\n/** Tuning for {@link makeViewportWheelPanAction}. */\nexport interface WheelPanOptions {\n  /** Lock the pan to one axis. Default `'both'`. */\n  axis?: 'both' | 'x' | 'y';\n}\n\n/** Builds a `viewport.wheelPan` descriptor with `opts` baked into both of its\n *  default bindings. `viewportWheelPanAction` is the unconfigured one. */\nexport function makeViewportWheelPanAction(\n  opts: WheelPanOptions = {},\n): Action & { requires: string[] } {\n  const axis = opts.axis ?? 'both';\n  return {\n    ...viewportWheelPanAction,\n    defaultBinding: [\n      { spec: { kind: 'wheel' }, opts: { params: { axis } } },\n      { spec: { kind: 'wheel', mods: { shift: true } }, opts: { params: { swapAxis: true, axis } } },\n    ],\n  };\n}\n"],"mappings":";;;;;;;;;AASA,IAAa,yBAA0D;CACrE,IAAI;CACJ,OAAO;CACP,OAAO;;;;;;CAMP,gBAAgB,CACd;EAAE,MAAM,EAAE,MAAM,QAAQ;EAAG,MAAM,CAAC;CAAE,GACpC;EAAE,MAAM;GAAE,MAAM;GAAS,MAAM,EAAE,OAAO,KAAK;EAAE;EAAG,MAAM,EAAE,QAAQ,EAAE,UAAU,KAAK,EAAE;CAAE,CACzF;CACA,UAAU,CAAC,QAAQ,OAAO;CAC1B,SAAS;EACP,QAAQ;EACR,IAAI,MAAM,QAAQ;GAChB,MAAM,OAAO,KAAK;GAClB,IAAI,CAAC,MAAM;GACX,MAAM,OAAQ,QAAQ,QAA2C;GACjE,MAAM,SAAU,QAAQ,UAAiC;GACzD,MAAM,SAAU,QAAQ,UAAiC;GACzD,MAAM,OAAO,KAAK,IAAI;GACtB,MAAM,OAAO,SAAS,MAAM;IAAE;IAAQ;GAAO,GAAG;IAAE;IAAM,UAAU,QAAQ,aAAa;GAAK,CAAC;GAC7F,KAAK,IAAI,IAAI;GACb,KAAK,OAAO,eAAe,OAAO,MAAM,IAAI;EAC9C;CACF;CACA,eAAe;AACjB;;;AAUA,SAAgB,2BACd,OAAwB,CAAC,GACQ;CACjC,MAAM,OAAO,KAAK,QAAQ;CAC1B,OAAO;EACL,GAAG;EACH,gBAAgB,CACd;GAAE,MAAM,EAAE,MAAM,QAAQ;GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE;EAAE,GACtD;GAAE,MAAM;IAAE,MAAM;IAAS,MAAM,EAAE,OAAO,KAAK;GAAE;GAAG,MAAM,EAAE,QAAQ;IAAE,UAAU;IAAM;GAAK,EAAE;EAAE,CAC/F;CACF;AACF"}

package/dist/interactions/actions/defaults/viewportZoom.js

@@ -1,121 +1,168 @@
-import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t } from "../../../core/viewport/zoomBounds.js";
-import { viewToTransform as n } from "../../../core/viewport/view.js";
-import { screenToWorld as r } from "../../../core/viewport/viewTransform.js";
-import { zoomAt as i } from "../../../core/viewport/zoomAt.js";
-import { wheelZoomFactor as a } from "../../../core/viewport/wheelHandler.js";
+import { DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM } from "../../../core/viewport/zoomBounds.js";
+import { viewToTransform } from "../../../core/viewport/view.js";
+import { screenToWorld } from "../../../core/viewport/viewTransform.js";
+import { axisZoomFactor, zoomAt } from "../../../core/viewport/zoomAt.js";
+import { wheelZoomFactor } from "../../../core/viewport/wheelHandler.js";
+
 //#region src/interactions/actions/defaults/viewportZoom.ts
-var o = 1.25;
-function s(e) {
-	let t = e.hostSize?.();
-	return t ? {
-		x: t.width / 2,
-		y: t.height / 2
+var KEY_STEP = 1.25;
+/** Keyboard-zoom anchor: the host center when the view dep can measure it,
+*  else the canvas top-left origin. */
+function keyAnchor(view) {
+	const size = view.hostSize?.();
+	return size ? {
+		x: size.width / 2,
+		y: size.height / 2
 	} : {
 		x: 0,
 		y: 0
 	};
 }
-function c(c = {}) {
-	let l = {
-		min: c.min ?? t,
-		max: c.max ?? e
-	}, u = c.wheel === "plain" ? { kind: "wheel" } : {
-		kind: "wheel",
-		mods: { mod: !0 }
-	}, d = c.animate === !0 ? {} : c.animate || null, { resetMs: f, ...p } = d ?? {}, m = d ? p : null;
+/** The gestures `viewport.zoom` answers: the configurable wheel trigger, then
+*  the fixed pinch and key bindings. */
+function zoomBindings(wheel) {
+	return [
+		{
+			spec: wheel === "plain" ? { kind: "wheel" } : {
+				kind: "wheel",
+				mods: { mod: true }
+			},
+			opts: { params: { kind: "wheel" } }
+		},
+		{
+			spec: {
+				kind: "wheel",
+				mods: { ctrl: true }
+			},
+			opts: { params: { kind: "wheel" } }
+		},
+		{
+			spec: { kind: "pinch" },
+			opts: { params: { kind: "pinch" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: "=",
+				mods: {
+					mod: true,
+					shift: "optional"
+				}
+			},
+			opts: { params: { kind: "in" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: "-",
+				mods: { mod: true }
+			},
+			opts: { params: { kind: "out" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: "0",
+				mods: { mod: true }
+			},
+			opts: { params: { kind: "reset" } }
+		}
+	];
+}
+/**
+* Build a `viewport.zoom` Action descriptor with a configurable wheel trigger
+* and scale clamp. The keyboard bindings (Cmd+=/-/0) and the two trackpad
+* pinch bindings are fixed. A wheel or pinch sample zooms about its focal
+* point, which `zoomAt` expects in canvas-local pixels.
+*/
+function makeViewportZoomAction(opts = {}) {
+	const clamp = {
+		min: opts.min ?? DEFAULT_MIN_ZOOM,
+		max: opts.max ?? DEFAULT_MAX_ZOOM
+	};
+	const axis = opts.axis ?? "both";
+	const rawAnimate = opts.animate === true ? {} : opts.animate || null;
+	const { resetMs, ...animateRest } = rawAnimate ?? {};
+	const tweenOpts = rawAnimate ? animateRest : null;
 	return {
 		id: "viewport.zoom",
 		label: "Zoom",
 		group: "viewport",
-		defaultBinding: [
-			{
-				spec: u,
-				opts: { params: { kind: "wheel" } }
-			},
-			{
-				spec: {
-					kind: "wheel",
-					mods: { ctrl: !0 }
-				},
-				opts: { params: { kind: "wheel" } }
-			},
-			{
-				spec: { kind: "pinch" },
-				opts: { params: { kind: "pinch" } }
-			},
+		variants: [
 			{
-				spec: {
-					kind: "key",
-					key: "=",
-					mods: {
-						mod: !0,
-						shift: "optional"
-					}
-				},
-				opts: { params: { kind: "in" } }
+				key: "in",
+				label: "Zoom In",
+				params: { kind: "in" }
 			},
 			{
-				spec: {
-					kind: "key",
-					key: "-",
-					mods: { mod: !0 }
-				},
-				opts: { params: { kind: "out" } }
+				key: "out",
+				label: "Zoom Out",
+				params: { kind: "out" }
 			},
 			{
-				spec: {
-					kind: "key",
-					key: "0",
-					mods: { mod: !0 }
-				},
-				opts: { params: { kind: "reset" } }
+				key: "reset",
+				label: "Reset Zoom",
+				params: { kind: "reset" }
 			}
 		],
+		defaultBinding: zoomBindings(opts.wheel),
 		requires: ["view", "debug"],
 		invoker: {
 			timing: "immediate",
-			run(e, t) {
-				let c = e.view;
-				if (!c) return;
-				let u = e.debug, d = c.get(), p = (e, t, i) => {
-					if (!u) return;
-					let [a, o] = r(i.x, i.y, n(e));
-					u.recordViewport("zoom", e, t, {
-						x: a,
-						y: o
+			run(deps, params) {
+				const view = deps.view;
+				if (!view) return;
+				const debug = deps.debug;
+				const current = view.get();
+				const record = (from, to, anchor) => {
+					if (!debug) return;
+					const [wx, wy] = screenToWorld(anchor.x, anchor.y, viewToTransform(from));
+					debug.recordViewport("zoom", from, to, {
+						x: wx,
+						y: wy
 					});
-				}, h = t?.kind, g = m !== null && typeof c.animate == "function", _ = (e, t) => {
-					if (!g) {
-						c.set(e);
+				};
+				const kind = params?.kind;
+				const canAnimate = tweenOpts !== null && typeof view.animate === "function";
+				const stepTo = (target, ms) => {
+					if (!canAnimate) {
+						view.set(target);
 						return;
 					}
-					c.animate(e, {
-						...m,
-						ms: t ?? m.ms
+					view.animate(target, {
+						...tweenOpts,
+						ms: ms ?? tweenOpts.ms
 					});
-				}, v = () => g && c.animationTarget?.() || d, y = () => ({
-					x: t?.clientX ?? 0,
-					y: t?.clientY ?? 0
-				}), b = (e) => {
-					if (!(e > 0) || !Number.isFinite(e)) return;
-					let t = i(d, y(), e, l);
-					c.set(t), p(d, t, y());
 				};
-				switch (h) {
+				const stepFrom = () => canAnimate && view.animationTarget?.() || current;
+				const focal = () => ({
+					x: params?.clientX ?? 0,
+					y: params?.clientY ?? 0
+				});
+				const scaleBy = (factor) => {
+					if (!(factor > 0) || !Number.isFinite(factor)) return;
+					const next = zoomAt(current, focal(), axisZoomFactor(factor, axis), clamp);
+					view.set(next);
+					record(current, next, focal());
+				};
+				switch (kind) {
 					case "wheel":
-						b(a(t?.deltaY ?? 0));
+						scaleBy(wheelZoomFactor(params?.deltaY ?? 0));
 						break;
 					case "pinch":
-						b(t?.scale ?? NaN);
+						scaleBy(params?.scale ?? NaN);
 						break;
 					case "in":
 					case "out": {
-						let e = v(), t = i(e, s(c), h === "in" ? o : 1 / o, l);
-						_(t), p(e, t, s(c));
+						const from = stepFrom();
+						const step = axisZoomFactor(kind === "in" ? KEY_STEP : 1 / KEY_STEP, axis);
+						const target = zoomAt(from, keyAnchor(view), step, clamp);
+						stepTo(target);
+						record(from, target, keyAnchor(view));
 						break;
 					}
 					case "reset": {
-						let e = c.recenter ? c.recenter() : {
+						const target = view.recenter ? view.recenter() : {
 							x: 0,
 							y: 0,
 							scale: {
@@ -123,21 +170,25 @@ function c(c = {}) {
 								y: 1
 							}
 						};
-						e && _(e, f);
+						if (target) stepTo(target, resetMs);
 						break;
 					}
-					default: t === void 0 && c.set(i(d, {
+					default: if (params === void 0) view.set(zoomAt(current, {
 						x: 0,
 						y: 0
-					}, o, l));
+					}, axisZoomFactor(KEY_STEP, axis), clamp));
 				}
 			}
 		},
-		enabled: () => !0
+		enabled: () => true
 	};
 }
-var l = c();
-//#endregion
-export { c as makeViewportZoomAction, l as viewportZoomAction };
+/**
+* Default `viewport.zoom` descriptor: Cmd/Ctrl+wheel zoom with the kit's
+* default 0.1–8 scale clamp. Equivalent to `makeViewportZoomAction()`.
+*/
+var viewportZoomAction = makeViewportZoomAction();
 
+//#endregion
+export { makeViewportZoomAction, viewportZoomAction };
 //# sourceMappingURL=viewportZoom.js.map