@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/viewport/view.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":["normalizeZoom","normalizeZoom$1","viewToTransform","view","viewZoom","meanScale","sameView","a","b","normalizeView","sx","normalizeAxis","sy","x","finiteTranslation","y","s","v","warnInvalidView"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/routing';\nimport { meanScale } from '@weasel-js/geom';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * Every view the kit keeps is total: each `scale` axis is finite with a\n * magnitude of at least `ZOOM_FLOOR` and `x` / `y` are finite. A negative\n * axis is a flipped one (y-up), not a degenerate one, and keeps its sign.\n * Canvases, views, and animations pass what they are given through\n * {@link normalizeView}, so screen/world conversion never divides by zero.\n */\nexport type { View };\n\n/** A zoom factor: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/** A zoom-clamp bound: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape. The two use opposite\n * sign conventions for the translation half: `view.x` is camera position;\n * `panX` is canvas translation.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n */\nexport function viewZoom(view: View): number {\n  return meanScale(view.scale);\n}\n\n/** Whether two views are the same camera, whatever objects hold them. */\nexport function sameView(a: View, b: View): boolean {\n  return a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;;AAyBA,SAAgBE,EAAgB,GAA2B;CAEzD,OAAO;EACL,MAAM,CAACC,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM,CAACA,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAGA,EAAK,MAAM;GAAG,GAAGA,EAAK,MAAM;EAAE;CAC3C;AACF;AAOA,SAAgBC,EAAS,GAAoB;CAC3C,OAAOC,EAAUF,EAAK,KAAK;AAC7B;AAGA,SAAgBG,EAAS,GAAS,GAAkB;CAClD,OAAOC,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAM,MAAMC,EAAE,MAAM,KAAKD,EAAE,MAAM,MAAMC,EAAE,MAAM;AACxF;AAQA,SAAgBC,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcR,EAAK,MAAM,CAAC,GAC/BS,IAAKD,EAAcR,EAAK,MAAM,CAAC,GAC/BU,IAAIC,EAAkBX,EAAK,CAAC,GAC5BY,IAAID,EAAkBX,EAAK,CAAC;CAElC,OADIO,MAAOP,EAAK,MAAM,KAAKS,MAAOT,EAAK,MAAM,KAAKU,MAAMV,EAAK,KAAKY,MAAMZ,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGO;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOK,IAAI,KAAKA,IAAI,YAAY,CAAChB,EAAc,CAACgB,CAAC,IAAIhB,EAAcgB,CAAC;AACtE;AAEA,SAASF,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASG,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}
+{"version":3,"file":"view.js","names":["normalizeZoom"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/geom';\nimport { meanScale } from '@weasel-js/geom';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * Every view the kit keeps is total: each `scale` axis is finite with a\n * magnitude of at least `ZOOM_FLOOR` and `x` / `y` are finite. A negative\n * axis is a flipped one (y-up), not a degenerate one, and keeps its sign.\n * Canvases, views, and animations pass what they are given through\n * {@link normalizeView}, so screen/world conversion never divides by zero.\n */\nexport type { View };\n\n/** A zoom factor: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/** A zoom-clamp bound: a `number` applies to both axes, a `{x, y}` vector per axis. */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape. The two use opposite\n * sign conventions for the translation half: `view.x` is camera position;\n * `panX` is canvas translation.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n */\nexport function viewZoom(view: View): number {\n  return meanScale(view.scale);\n}\n\n/** Whether two views are the same camera, whatever objects hold them. */\nexport function sameView(a: View, b: View): boolean {\n  return a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y;\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;;;;;;;;AAyBA,SAAgB,gBAAgB,MAA2B;CAEzD,OAAO;EACL,MAAM,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI;EAC/B,MAAM,CAAC,KAAK,IAAI,KAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAG,KAAK,MAAM;GAAG,GAAG,KAAK,MAAM;EAAE;CAC3C;AACF;;;;;;AAOA,SAAgB,SAAS,MAAoB;CAC3C,OAAO,UAAU,KAAK,KAAK;AAC7B;;AAGA,SAAgB,SAAS,GAAS,GAAkB;CAClD,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,MAAM,EAAE,MAAM,KAAK,EAAE,MAAM,MAAM,EAAE,MAAM;AACxF;;;;;;;AAQA,SAAgB,cAAc,MAAkB;CAC9C,MAAM,KAAK,cAAc,KAAK,MAAM,CAAC;CACrC,MAAM,KAAK,cAAc,KAAK,MAAM,CAAC;CACrC,MAAM,IAAI,kBAAkB,KAAK,CAAC;CAClC,MAAM,IAAI,kBAAkB,KAAK,CAAC;CAClC,IAAI,OAAO,KAAK,MAAM,KAAK,OAAO,KAAK,MAAM,KAAK,MAAM,KAAK,KAAK,MAAM,KAAK,GAAG,OAAO;CACvF,OAAO;EAAE;EAAG;EAAG,OAAO;GAAE,GAAG;GAAI,GAAG;EAAG;CAAE;AACzC;AAEA,SAAS,cAAc,GAAmB;CACxC,OAAO,IAAI,KAAK,IAAI,YAAY,CAACA,gBAAc,CAAC,CAAC,IAAIA,gBAAc,CAAC;AACtE;AAEA,SAAS,kBAAkB,GAAmB;CAC5C,IAAI,OAAO,SAAS,CAAC,GAAG,OAAO;CAC/B,gBAAgB,iBAAiB,GAAG;CACpC,OAAO;AACT"}

package/dist/core/viewport/viewTransform.js

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

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

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

package/dist/core/viewport/viewportWorldRect.js

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

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

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

package/dist/core/viewport/wheelHandler.js

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

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

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

package/dist/core/viewport/zoomAt.js

@@ -1,31 +1,59 @@
-import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t, normalizeZoom as n } from "./zoomBounds.js";
-import { normalizeView as r } from "./view.js";
+import { DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, normalizeZoom } from "./zoomBounds.js";
+import { normalizeView } from "./view.js";
+
 //#region src/core/viewport/zoomAt.ts
-function i(e, t, r) {
-	let i = n(Math.min(r, Math.max(t, Math.abs(e))));
-	return e < 0 ? -i : i;
+/** Bound a scale's *magnitude*, keeping its direction. `scale.y < 0` is how a
+*  `View` spells a y-up camera, so clamping the signed value against positive
+*  bounds would flip the axis and collapse the zoom rather than limit it. */
+function clampScale(scale, min, max) {
+	const magnitude = normalizeZoom(Math.min(max, Math.max(min, Math.abs(scale))));
+	return scale < 0 ? -magnitude : magnitude;
 }
-function a(e, t) {
-	return t === "x" ? {
-		x: e,
+/** `factor` held to one axis: the other axis's factor is 1, so `zoomAt` leaves
+*  its scale and its translation where they were. */
+function axisZoomFactor(factor, axis) {
+	if (axis === "x") return {
+		x: factor,
 		y: 1
-	} : t === "y" ? {
+	};
+	if (axis === "y") return {
 		x: 1,
-		y: e
-	} : e;
+		y: factor
+	};
+	return factor;
 }
-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;
+/**
+* Pure zoom primitive. Returns a new `View` whose `scale` is multiplied
+* by `factor` (per-axis, clamped) and whose translation is adjusted so
+* that the world point currently under `anchor` (screen coords relative
+* to the canvas top-left) stays under the same screen pixel after the
+* zoom — independently on each axis.
+*
+* `factor: number` means "apply uniformly to both axes". `factor: {x, y}`
+* applies per-axis factors. Likewise for `opts.min` / `opts.max`.
+*/
+function zoomAt(input, anchor, factor, opts) {
+	const view = normalizeView(input);
+	const fx = typeof factor === "number" ? factor : factor.x;
+	const fy = typeof factor === "number" ? factor : factor.y;
+	const minX = typeof opts?.min === "number" ? opts.min : opts?.min?.x ?? DEFAULT_MIN_ZOOM;
+	const minY = typeof opts?.min === "number" ? opts.min : opts?.min?.y ?? DEFAULT_MIN_ZOOM;
+	const maxX = typeof opts?.max === "number" ? opts.max : opts?.max?.x ?? DEFAULT_MAX_ZOOM;
+	const maxY = typeof opts?.max === "number" ? opts.max : opts?.max?.y ?? DEFAULT_MAX_ZOOM;
+	const nextX = clampScale(view.scale.x * fx, minX, maxX);
+	const nextY = clampScale(view.scale.y * fy, minY, maxY);
+	const worldX = anchor.x / view.scale.x + view.x;
+	const worldY = anchor.y / view.scale.y + view.y;
 	return {
 		scale: {
-			x: h,
-			y: g
+			x: nextX,
+			y: nextY
 		},
-		x: _ - a.x / h,
-		y: v - a.y / g
+		x: worldX - anchor.x / nextX,
+		y: worldY - anchor.y / nextY
 	};
 }
-//#endregion
-export { a as axisZoomFactor, o as zoomAt };
 
+//#endregion
+export { axisZoomFactor, 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","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"}
+{"version":3,"file":"zoomAt.js","names":[],"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,SAAS,WAAW,OAAe,KAAa,KAAqB;CACnE,MAAM,YAAY,cAAc,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC;CAC7E,OAAO,QAAQ,IAAI,CAAC,YAAY;AAClC;;;AAOA,SAAgB,eAAe,QAAgB,MAA4B;CACzE,IAAI,SAAS,KAAK,OAAO;EAAE,GAAG;EAAQ,GAAG;CAAE;CAC3C,IAAI,SAAS,KAAK,OAAO;EAAE,GAAG;EAAG,GAAG;CAAO;CAC3C,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,OACd,OACA,QACA,QACA,MACM;CACN,MAAM,OAAO,cAAc,KAAK;CAChC,MAAM,KAAK,OAAO,WAAW,WAAW,SAAS,OAAO;CACxD,MAAM,KAAK,OAAO,WAAW,WAAW,SAAS,OAAO;CACxD,MAAM,OAAO,OAAO,MAAM,QAAQ,WAAW,KAAK,MAAM,MAAM,KAAK,KAAK;CACxE,MAAM,OAAO,OAAO,MAAM,QAAQ,WAAW,KAAK,MAAM,MAAM,KAAK,KAAK;CACxE,MAAM,OAAO,OAAO,MAAM,QAAQ,WAAW,KAAK,MAAM,MAAM,KAAK,KAAK;CACxE,MAAM,OAAO,OAAO,MAAM,QAAQ,WAAW,KAAK,MAAM,MAAM,KAAK,KAAK;CAExE,MAAM,QAAQ,WAAW,KAAK,MAAM,IAAI,IAAI,MAAM,IAAI;CACtD,MAAM,QAAQ,WAAW,KAAK,MAAM,IAAI,IAAI,MAAM,IAAI;CAEtD,MAAM,SAAS,OAAO,IAAI,KAAK,MAAM,IAAI,KAAK;CAC9C,MAAM,SAAS,OAAO,IAAI,KAAK,MAAM,IAAI,KAAK;CAC9C,OAAO;EACL,OAAO;GAAE,GAAG;GAAO,GAAG;EAAM;EAC5B,GAAG,SAAS,OAAO,IAAI;EACvB,GAAG,SAAS,OAAO,IAAI;CACzB;AACF"}

package/dist/core/viewport/zoomBounds.js

@@ -1,22 +1,38 @@
-import { ZOOM_FLOOR as e, normalizeZoom as t } from "@weasel-js/geom";
+import { ZOOM_FLOOR, normalizeZoom } from "@weasel-js/geom";
+import { isDev } from "@weasel-js/registry";
+
 //#region src/core/viewport/zoomBounds.ts
-var n = .1, r = 8;
-function i(e) {
-	let n = t(e);
-	return n !== e && (!(e > 0) || e === Infinity) && o(`a zoom of ${e}`), n;
+/**
+* The kit's system-wide zoom clamp, in `View.scale` units (pixels per world
+* unit): `1` is 100%, `0.1` is 10%, `8` is 800%.
+*
+* Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and
+* pinch actions, `fitViewToBounds`, `computeWheelAction`. They
+* used to carry two disagreeing pairs, so a fit could legally land at 10x
+* and the next pinch frame would clamp it back to 8x.
+*/
+var DEFAULT_MIN_ZOOM = .1;
+/** Upper end of the kit's default zoom clamp — 800%. See {@link DEFAULT_MIN_ZOOM}. */
+var DEFAULT_MAX_ZOOM = 8;
+/**
+* The one rule for a zoom magnitude: a finite number no smaller than
+* {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the
+* floor. Dev builds warn once when a zoom that was never valid arrives; a
+* positive zoom that merely undershoots the floor clamps silently.
+*/
+function normalizeZoom$1(zoom) {
+	const held = normalizeZoom(zoom);
+	if (held !== zoom && (!(zoom > 0) || zoom === Infinity)) warnInvalidView(`a zoom of ${zoom}`);
+	return held;
 }
-var a = !1;
-function o(e) {
-	!a && s && (a = !0, console.warn(`[weasel] a view was given ${e} and has been clamped. A view's zoom is always positive and finite, and its position finite; see ZOOM_FLOOR.`));
+var warned = false;
+/** @internal Once per session, in dev builds only. */
+function warnInvalidView(what) {
+	if (warned || !isDev()) return;
+	warned = true;
+	console.warn(`[weasel] a view was given ${what} and has been clamped. A view's zoom is always positive and finite, and its position finite; see ZOOM_FLOOR.`);
 }
-var s = (() => {
-	try {
-		return !1;
-	} catch {
-		return !1;
-	}
-})();
-//#endregion
-export { r as DEFAULT_MAX_ZOOM, n as DEFAULT_MIN_ZOOM, e as ZOOM_FLOOR, i as normalizeZoom, o as warnInvalidView };
 
+//#endregion
+export { DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, ZOOM_FLOOR, normalizeZoom$1 as normalizeZoom, warnInvalidView };
 //# sourceMappingURL=zoomBounds.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"zoomBounds.js","names":["normalizeZoom","clampToFloor","DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","normalizeZoom$1","held","normalizeZoom","zoom","warnInvalidView","warned","IS_DEV","what","ZOOM_FLOOR"],"sources":["../../../src/core/viewport/zoomBounds.ts"],"sourcesContent":["import { normalizeZoom as clampToFloor, ZOOM_FLOOR } from '@weasel-js/geom';\n\n/**\n * The kit's system-wide zoom clamp, in `View.scale` units (pixels per world\n * unit): `1` is 100%, `0.1` is 10%, `8` is 800%.\n *\n * Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and\n * pinch actions, `fitViewToBounds`, `computeWheelAction`. They\n * used to carry two disagreeing pairs, so a fit could legally land at 10x\n * and the next pinch frame would clamp it back to 8x.\n */\nexport const DEFAULT_MIN_ZOOM = 0.1;\n/** Upper end of the kit's default zoom clamp — 800%. See {@link DEFAULT_MIN_ZOOM}. */\nexport const DEFAULT_MAX_ZOOM = 8;\n\nexport { ZOOM_FLOOR };\n\n/**\n * The one rule for a zoom magnitude: a finite number no smaller than\n * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the\n * floor. Dev builds warn once when a zoom that was never valid arrives; a\n * positive zoom that merely undershoots the floor clamps silently.\n */\nexport function normalizeZoom(zoom: number): number {\n  const held = clampToFloor(zoom);\n  if (held !== zoom && (!(zoom > 0) || zoom === Infinity)) warnInvalidView(`a zoom of ${zoom}`);\n  return held;\n}\n\nlet warned = false;\n\n/** @internal Once per session, in dev builds only. */\nexport function warnInvalidView(what: string): void {\n  if (warned || !IS_DEV) return;\n  warned = true;\n  console.warn(\n    `[weasel] a view was given ${what} and has been clamped. A view's zoom is ` +\n    'always positive and finite, and its position finite; see ZOOM_FLOOR.',\n  );\n}\n\n/** `import.meta.env.DEV` read through a cast, as in SceneCanvas.tsx. */\nconst IS_DEV: boolean = (() => {\n  try {\n    return Boolean((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV);\n  } catch {\n    return false;\n  }\n})();\n"],"mappings":";;AAWA,IAAaE,IAAmB,IAEnBC,IAAmB;AAUhC,SAAgBH,EAAc,GAAsB;CAClD,IAAMK,IAAOJ,EAAaM,CAAI;CAE9B,OADIF,MAASE,MAAS,EAAEA,IAAO,MAAMA,MAAS,aAAWC,EAAgB,aAAaD,GAAM,GACrFF;AACT;AAEA,IAAII,IAAS;AAGb,SAAgBD,EAAgB,GAAoB;CAClD,AAAI,MAAWE,MACf,IAAS,IACT,QAAQ,KACN,6BAA6BC,EAAK,6GAEpC;AACF;AAGA,IAAMD,WAAyB;CAC7B,IAAI;EACF,OAAO,CAAA;CACT,QAAQ;EACN,OAAO;CACT;AACF,EAAA,CAAG"}
+{"version":3,"file":"zoomBounds.js","names":["normalizeZoom","clampToFloor"],"sources":["../../../src/core/viewport/zoomBounds.ts"],"sourcesContent":["import { normalizeZoom as clampToFloor, ZOOM_FLOOR } from '@weasel-js/geom';\nimport { isDev } from '@weasel-js/registry';\n\n/**\n * The kit's system-wide zoom clamp, in `View.scale` units (pixels per world\n * unit): `1` is 100%, `0.1` is 10%, `8` is 800%.\n *\n * Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and\n * pinch actions, `fitViewToBounds`, `computeWheelAction`. They\n * used to carry two disagreeing pairs, so a fit could legally land at 10x\n * and the next pinch frame would clamp it back to 8x.\n */\nexport const DEFAULT_MIN_ZOOM = 0.1;\n/** Upper end of the kit's default zoom clamp — 800%. See {@link DEFAULT_MIN_ZOOM}. */\nexport const DEFAULT_MAX_ZOOM = 8;\n\nexport { ZOOM_FLOOR };\n\n/**\n * The one rule for a zoom magnitude: a finite number no smaller than\n * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the\n * floor. Dev builds warn once when a zoom that was never valid arrives; a\n * positive zoom that merely undershoots the floor clamps silently.\n */\nexport function normalizeZoom(zoom: number): number {\n  const held = clampToFloor(zoom);\n  if (held !== zoom && (!(zoom > 0) || zoom === Infinity)) warnInvalidView(`a zoom of ${zoom}`);\n  return held;\n}\n\nlet warned = false;\n\n/** @internal Once per session, in dev builds only. */\nexport function warnInvalidView(what: string): void {\n  if (warned || !isDev()) return;\n  warned = true;\n  console.warn(\n    `[weasel] a view was given ${what} and has been clamped. A view's zoom is ` +\n    'always positive and finite, and its position finite; see ZOOM_FLOOR.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,IAAa,mBAAmB;;AAEhC,IAAa,mBAAmB;;;;;;;AAUhC,SAAgBA,gBAAc,MAAsB;CAClD,MAAM,OAAOC,cAAa,IAAI;CAC9B,IAAI,SAAS,SAAS,EAAE,OAAO,MAAM,SAAS,WAAW,gBAAgB,aAAa,MAAM;CAC5F,OAAO;AACT;AAEA,IAAI,SAAS;;AAGb,SAAgB,gBAAgB,MAAoB;CAClD,IAAI,UAAU,CAAC,MAAM,GAAG;CACxB,SAAS;CACT,QAAQ,KACN,6BAA6B,KAAK,6GAEpC;AACF"}

package/dist/cornerHandles-BHuoMs1o.d.ts

@@ -0,0 +1,169 @@
+import { B as BoundsConstraint } from './clone-C3e0OTuF.js';
+import { FramedBox, Affine } from '@weasel-js/geom';
+import { ResizeAnchor } from '@weasel-js/routing';
+
+/** Option surface for the `resize` action. */
+
+/** Options for the `resize` action: the constraints applied to the dragged
+ *  bounding box, how a gesture expands a group into its leaves, and its
+ *  history and lifecycle. `<SceneCanvas>` publishes them as the
+ *  `resizePolicy` dep (`resizePolicyOptions`). */
+interface UseResizeOptions<TPose> {
+    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. For a
+     *  non-rect `TPose`, constraints are typed `never`; the pose descriptor
+     *  comes from `<SceneCanvas poseDescriptor>`. */
+    behaviors?: TPose extends FramedBox ? BoundsConstraint<TPose>[] : never;
+    /** History label for the committed resize. Default `'Resize'`. */
+    resizeLabel?: string;
+    /** Commit without an undo entry (`scene.untracked`), bypassing the
+     *  consumer `applyOps` hook. Unset, a behavior's `defaultTransient` decides. */
+    transient?: boolean;
+    /** Fired when the resize starts, with the ids it writes. */
+    onGestureStart?: (ids: string[]) => void;
+    /** 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;
+    /** 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[];
+    /** Per-node resizability predicate. Returns `false` for nodes that should
+     *  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;
+    /** Give the selection a resize handle at the middle of each edge, as well
+     *  as each corner: it resizes along one axis with the opposite edge pinned.
+     *  A side too short on screen for one (`EDGE_HANDLE_MIN_RADII` handle
+     *  radii) shows none. Read by `<SceneCanvas>` for its overlay and hit-test.
+     *  Default true. */
+    edgeHandles?: boolean;
+}
+
+/**
+ * The frame selection chrome reads a target in: `poseFrameOf` over the
+ * target's bounds, with the helpers the outline, the handles, their hit
+ * regions, and the resize and rotate actions all place themselves by.
+ */
+
+/** Local↔world maps for a chrome target. Local is the target's unrotated box
+ *  frame; world is where the node is drawn. */
+interface TargetTransform {
+    /** No rotation and no `transform`: local is world. */
+    identity: boolean;
+    /** Target box frame → world. */
+    toWorld: Affine;
+    /** World → target box frame. `null` when the target's `transform` is
+     *  singular: it draws nothing, and no world point maps back. */
+    toLocal: Affine | null;
+}
+
+/** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
+interface CornerHandle {
+    cx: number;
+    cy: number;
+    anchor: ResizeAnchor;
+}
+/** Which AABB edge a corner sits on, per axis. `'min'` = the x/y origin
+ *  edge; `'max'` = the origin + extent edge. */
+type CornerEdge = 'min' | 'max';
+/** Where a resize handle sits on one axis: on an edge (`CornerEdge`), or
+ *  `'mid'`way between them, which is what makes a handle an edge handle. */
+type HandleEdge = CornerEdge | 'mid';
+/** One entry of the canonical resize-handle layout: where the handle sits,
+ *  which edges it pins, and what a press on it reports. */
+interface ResizeHandleAnchor {
+    /** Where the handle sits on x (`'min'` = left, `'mid'` = centered, `'max'` = right). */
+    xEdge: HandleEdge;
+    /** Where the handle sits on y (`'min'` = top, `'mid'` = centered, `'max'` = bottom). */
+    yEdge: HandleEdge;
+    /** Anchor that pins the opposite side: the axis-wise opposite of each
+     *  edge the handle sits on, and `'free'` on an axis it sits mid-way along,
+     *  which the drag leaves alone. */
+    anchor: ResizeAnchor;
+    /** Affordance/handle discriminator string for this handle. */
+    kind: string;
+    /** Short positional tag (`'<xEdge>-<yEdge>'`), e.g. `'min-max'`. */
+    tag: string;
+}
+/** A corner entry of {@link RESIZE_HANDLE_ANCHORS}. */
+interface CornerAnchor extends ResizeHandleAnchor {
+    /** Which x-edge the corner sits on (`'min'` = left, `'max'` = right). */
+    xEdge: CornerEdge;
+    /** Which y-edge the corner sits on (`'min'` = top, `'max'` = bottom). */
+    yEdge: CornerEdge;
+}
+/**
+ * The single ordered resize-handle table: the four corners (TL, TR, BL, BR),
+ * then the four edge midpoints (top, right, bottom, left). Order is
+ * **load-bearing**: the resize-handle affordance, the selection overlay and
+ * `cornerResizeHandles` all iterate it in this sequence, so the i-th handle
+ * means the same thing to each. A corner pins the diagonally opposite corner;
+ * an edge pins the opposite edge and leaves the other axis free.
+ */
+declare const RESIZE_HANDLE_ANCHORS: readonly ResizeHandleAnchor[];
+/** True for a corner entry of {@link RESIZE_HANDLE_ANCHORS}. */
+declare function isCornerHandle(entry: ResizeHandleAnchor): entry is CornerAnchor;
+/** The corner entries of {@link RESIZE_HANDLE_ANCHORS}, in its order. */
+declare const CORNER_ANCHORS: readonly CornerAnchor[];
+/** An edge handle sits this many hit radii on screen from each corner of the
+ *  side it is on, at least: under that, it would crowd the corners and leave
+ *  the body too little room to be grabbed. At the default 8 px radius, a
+ *  side must span 48 px. */
+declare const EDGE_HANDLE_MIN_RADII = 6;
+/** How a canvas lays out its resize handles. `hitRadiusPx` is the one size
+ *  the edge-handle decision keys on, because a handle exists to be grabbed:
+ *  paint and hit-test both read it, so no handle is drawn that cannot be
+ *  grabbed or grabbable where none is drawn. */
+interface ResizeHandleLayout {
+    /** Whether the edge midpoints get handles at all. */
+    edges: boolean;
+    /** The handles' hit radius, screen px. */
+    hitRadiusPx: number;
+}
+/** The handles a body gets in `layout`: every corner, then the edge
+ *  midpoints when the layout has them and {@link edgeHandlesFit} at its hit
+ *  radius. The answer the selection overlay paints; the hit-test reaches the
+ *  same one through the regions' `edgeOf`. */
+declare function resizeHandlesFor(layout: ResizeHandleLayout, body: {
+    width: number;
+    height: number;
+}, xf: TargetTransform, scale: {
+    x: number;
+    y: number;
+}): readonly ResizeHandleAnchor[];
+/** Resolve a handle's position for the given bounds, in the bounds' frame:
+ *  `'min'` → the origin edge, `'max'` → origin + extent, `'mid'` → between. */
+declare function handlePoint(bounds: FramedBox, entry: Pick<ResizeHandleAnchor, 'xEdge' | 'yEdge'>): {
+    x: number;
+    y: number;
+};
+/** @deprecated Use {@link handlePoint}, which also places edge handles. */
+declare const cornerPoint: (bounds: FramedBox, entry: Pick<CornerAnchor, 'xEdge' | 'yEdge'>) => {
+    x: number;
+    y: number;
+};
+/** Standard 4-corner resize-handle layout: each corner pins the opposite
+ *  corner via an anchor of `{x: 'min'|'max', y: 'min'|'max'}` so dragging it
+ *  scales the box from the fixed opposite corner. Decodes {@link CORNER_ANCHORS}
+ *  against `bounds`; edge handles are the affordance's, which knows the view. */
+declare function cornerResizeHandles(bounds: FramedBox): CornerHandle[];
+/** Square hit-test for a handle: returns true if `(px, py)` is within
+ *  `radius` of the handle center on both axes. */
+declare function hitCornerHandle(handle: CornerHandle, px: number, py: number, radius: number): boolean;
+/** The corner that does NOT move under a resize gesture with the given
+ *  anchor. Used by the rotated-resize math to pin a world-space invariant.
+ *
+ *  Convention: `anchor.x === 'min'` means the min-x (left) edge is the
+ *  fixed anchor, so the fixed corner sits at `x = bounds.x` (min-x).
+ *  `anchor.x === 'max'` means the max-x (right) edge is fixed, so the
+ *  fixed corner sits at `x = bounds.x + bounds.width`. `'free'` on an
+ *  axis (an edge handle's other axis) pins the bounds' center on it: a drag
+ *  leaves that extent alone, and an aspect lock grows it about the center. */
+declare function fixedCornerOf(bounds: FramedBox, anchor: ResizeAnchor): {
+    x: number;
+    y: number;
+};
+
+export { CORNER_ANCHORS as C, EDGE_HANDLE_MIN_RADII as E, type HandleEdge as H, RESIZE_HANDLE_ANCHORS as R, type TargetTransform as T, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, type ResizeHandleAnchor as c, type ResizeHandleLayout as d, cornerPoint as e, cornerResizeHandles as f, fixedCornerOf as g, handlePoint as h, hitCornerHandle as i, isCornerHandle as j, type CornerEdge as k, resizeHandlesFor as r };