@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/viewport/interpolateView.js

@@ -1,34 +1,54 @@
 //#region src/core/viewport/interpolateView.ts
-function e(e, t, n, r) {
-	let i = (i) => ({
-		x: e + (n - e) * i,
-		s: t + (r - t) * i
+/**
+* Per-axis camera curve. Two views that differ in scale agree at exactly one
+* screen point; holding the world point under it fixed is what makes a zoom
+* read as anchored rather than drifting. Scale moves geometrically between
+* positive endpoints, so each frame changes the view by the same ratio and an
+* easing that overshoots past 1 still cannot cross zero.
+*
+* Endpoints that are not both positive get the linear branch: `(s1/s0)^t` is
+* NaN for a negative ratio and `1/s0` is infinite at zero, and there is no
+* geometric path across a sign change to be had anyway.
+*/
+function axisCurve(x0, s0, x1, s1) {
+	const linear = (t) => ({
+		x: x0 + (x1 - x0) * t,
+		s: s0 + (s1 - s0) * t
 	});
-	if (!(t > 0) || !(r > 0) || Math.abs(r - t) <= 1e-12 * Math.max(Math.abs(t), Math.abs(r), 1)) return i;
-	let a = (n - e) / (1 / t - 1 / r), o = a / t + e, s = r / t;
-	return (e) => {
-		let n = t * s ** +e;
+	if (!(s0 > 0) || !(s1 > 0)) return linear;
+	if (Math.abs(s1 - s0) <= 1e-12 * Math.max(Math.abs(s0), Math.abs(s1), 1)) return linear;
+	const p = (x1 - x0) / (1 / s0 - 1 / s1);
+	const w = p / s0 + x0;
+	const ratio = s1 / s0;
+	return (t) => {
+		const s = s0 * Math.pow(ratio, t);
 		return {
-			x: o - a / n,
-			s: n
+			x: w - p / s,
+			s
 		};
 	};
 }
-function t(t, n) {
-	let r = e(t.x, t.scale.x, n.x, n.scale.x), i = e(t.y, t.scale.y, n.y, n.scale.y);
-	return (e) => {
-		let t = r(e), n = i(e);
+/**
+* `InterpolatorFactory<View>` for camera animation — built once per animation,
+* called with eased `t` each frame. Pass to `Animator.tween`'s `interpolator`.
+*/
+function interpolateView(from, to) {
+	const fx = axisCurve(from.x, from.scale.x, to.x, to.scale.x);
+	const fy = axisCurve(from.y, from.scale.y, to.y, to.scale.y);
+	return (t) => {
+		const a = fx(t);
+		const b = fy(t);
 		return {
-			x: t.x,
-			y: n.x,
+			x: a.x,
+			y: b.x,
 			scale: {
-				x: t.s,
-				y: n.s
+				x: a.s,
+				y: b.s
 			}
 		};
 	};
 }
-//#endregion
-export { t as interpolateView };
 
+//#endregion
+export { interpolateView };
 //# sourceMappingURL=interpolateView.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"interpolateView.js","names":["axisCurve","linear","x0","x1","t","s0","s1","p","w","ratio","s","interpolateView","fx","from","to","fy","a","b"],"sources":["../../../src/core/viewport/interpolateView.ts"],"sourcesContent":["import type { View } from './view';\n\n/**\n * Per-axis camera curve. Two views that differ in scale agree at exactly one\n * screen point; holding the world point under it fixed is what makes a zoom\n * read as anchored rather than drifting. Scale moves geometrically between\n * positive endpoints, so each frame changes the view by the same ratio and an\n * easing that overshoots past 1 still cannot cross zero.\n *\n * Endpoints that are not both positive get the linear branch: `(s1/s0)^t` is\n * NaN for a negative ratio and `1/s0` is infinite at zero, and there is no\n * geometric path across a sign change to be had anyway.\n */\nfunction axisCurve(x0: number, s0: number, x1: number, s1: number): (t: number) => { x: number; s: number } {\n  const linear = (t: number) => ({ x: x0 + (x1 - x0) * t, s: s0 + (s1 - s0) * t });\n  if (!(s0 > 0) || !(s1 > 0)) return linear;\n  // Equal scales: no fixed point exists on this axis. That is a pure pan.\n  if (Math.abs(s1 - s0) <= 1e-12 * Math.max(Math.abs(s0), Math.abs(s1), 1)) return linear;\n  const p = (x1 - x0) / (1 / s0 - 1 / s1); // screen px where the two views agree\n  const w = p / s0 + x0;                   // the world point under it\n  const ratio = s1 / s0;\n  return (t) => {\n    const s = s0 * Math.pow(ratio, t);\n    return { x: w - p / s, s };\n  };\n}\n\n/**\n * `InterpolatorFactory<View>` for camera animation — built once per animation,\n * called with eased `t` each frame. Pass to `Animator.tween`'s `interpolator`.\n */\nexport function interpolateView(from: View, to: View): (t: number) => View {\n  const fx = axisCurve(from.x, from.scale.x, to.x, to.scale.x);\n  const fy = axisCurve(from.y, from.scale.y, to.y, to.scale.y);\n  return (t: number): View => {\n    const a = fx(t);\n    const b = fy(t);\n    return { x: a.x, y: b.x, scale: { x: a.s, y: b.s } };\n  };\n}\n"],"mappings":";AAaA,SAASA,EAAU,GAAY,GAAY,GAAY,GAAqD;CAC1G,IAAMC,KAAU,OAAe;EAAE,GAAGC,KAAMC,IAAKD,KAAME;EAAG,GAAGC,KAAMC,IAAKD,KAAMD;CAAE;CAG9E,IAFI,EAAEC,IAAK,MAAM,EAAEC,IAAK,MAEpB,KAAK,IAAIA,IAAKD,CAAE,KAAK,QAAQ,KAAK,IAAI,KAAK,IAAIA,CAAE,GAAG,KAAK,IAAIC,CAAE,GAAG,CAAC,GAAG,OAAOL;CACjF,IAAMM,KAAKJ,IAAKD,MAAO,IAAIG,IAAK,IAAIC,IAC9BE,IAAID,IAAIF,IAAKH,GACbO,IAAQH,IAAKD;CACnB,QAAQ,MAAM;EACZ,IAAMK,IAAIL,IAAcI,MAAOL;EAC/B,OAAO;GAAE,GAAGI,IAAID,IAAIG;GAAG;EAAE;CAC3B;AACF;AAMA,SAAgBC,EAAgB,GAAY,GAA+B;CACzE,IAAMC,IAAKZ,EAAUa,EAAK,GAAGA,EAAK,MAAM,GAAGC,EAAG,GAAGA,EAAG,MAAM,CAAC,GACrDC,IAAKf,EAAUa,EAAK,GAAGA,EAAK,MAAM,GAAGC,EAAG,GAAGA,EAAG,MAAM,CAAC;CAC3D,QAAQ,MAAoB;EAC1B,IAAME,IAAIJ,EAAGR,CAAC,GACRa,IAAIF,EAAGX,CAAC;EACd,OAAO;GAAE,GAAGY,EAAE;GAAG,GAAGC,EAAE;GAAG,OAAO;IAAE,GAAGD,EAAE;IAAG,GAAGC,EAAE;GAAE;EAAE;CACrD;AACF"}
+{"version":3,"file":"interpolateView.js","names":[],"sources":["../../../src/core/viewport/interpolateView.ts"],"sourcesContent":["import type { View } from './view';\n\n/**\n * Per-axis camera curve. Two views that differ in scale agree at exactly one\n * screen point; holding the world point under it fixed is what makes a zoom\n * read as anchored rather than drifting. Scale moves geometrically between\n * positive endpoints, so each frame changes the view by the same ratio and an\n * easing that overshoots past 1 still cannot cross zero.\n *\n * Endpoints that are not both positive get the linear branch: `(s1/s0)^t` is\n * NaN for a negative ratio and `1/s0` is infinite at zero, and there is no\n * geometric path across a sign change to be had anyway.\n */\nfunction axisCurve(x0: number, s0: number, x1: number, s1: number): (t: number) => { x: number; s: number } {\n  const linear = (t: number) => ({ x: x0 + (x1 - x0) * t, s: s0 + (s1 - s0) * t });\n  if (!(s0 > 0) || !(s1 > 0)) return linear;\n  // Equal scales: no fixed point exists on this axis. That is a pure pan.\n  if (Math.abs(s1 - s0) <= 1e-12 * Math.max(Math.abs(s0), Math.abs(s1), 1)) return linear;\n  const p = (x1 - x0) / (1 / s0 - 1 / s1); // screen px where the two views agree\n  const w = p / s0 + x0;                   // the world point under it\n  const ratio = s1 / s0;\n  return (t) => {\n    const s = s0 * Math.pow(ratio, t);\n    return { x: w - p / s, s };\n  };\n}\n\n/**\n * `InterpolatorFactory<View>` for camera animation — built once per animation,\n * called with eased `t` each frame. Pass to `Animator.tween`'s `interpolator`.\n */\nexport function interpolateView(from: View, to: View): (t: number) => View {\n  const fx = axisCurve(from.x, from.scale.x, to.x, to.scale.x);\n  const fy = axisCurve(from.y, from.scale.y, to.y, to.scale.y);\n  return (t: number): View => {\n    const a = fx(t);\n    const b = fy(t);\n    return { x: a.x, y: b.x, scale: { x: a.s, y: b.s } };\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAS,UAAU,IAAY,IAAY,IAAY,IAAqD;CAC1G,MAAM,UAAU,OAAe;EAAE,GAAG,MAAM,KAAK,MAAM;EAAG,GAAG,MAAM,KAAK,MAAM;CAAE;CAC9E,IAAI,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,OAAO;CAEnC,IAAI,KAAK,IAAI,KAAK,EAAE,KAAK,QAAQ,KAAK,IAAI,KAAK,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,GAAG,CAAC,GAAG,OAAO;CACjF,MAAM,KAAK,KAAK,OAAO,IAAI,KAAK,IAAI;CACpC,MAAM,IAAI,IAAI,KAAK;CACnB,MAAM,QAAQ,KAAK;CACnB,QAAQ,MAAM;EACZ,MAAM,IAAI,KAAK,KAAK,IAAI,OAAO,CAAC;EAChC,OAAO;GAAE,GAAG,IAAI,IAAI;GAAG;EAAE;CAC3B;AACF;;;;;AAMA,SAAgB,gBAAgB,MAAY,IAA+B;CACzE,MAAM,KAAK,UAAU,KAAK,GAAG,KAAK,MAAM,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;CAC3D,MAAM,KAAK,UAAU,KAAK,GAAG,KAAK,MAAM,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;CAC3D,QAAQ,MAAoB;EAC1B,MAAM,IAAI,GAAG,CAAC;EACd,MAAM,IAAI,GAAG,CAAC;EACd,OAAO;GAAE,GAAG,EAAE;GAAG,GAAG,EAAE;GAAG,OAAO;IAAE,GAAG,EAAE;IAAG,GAAG,EAAE;GAAE;EAAE;CACrD;AACF"}

package/dist/core/viewport/parallax.js

@@ -1,91 +1,122 @@
 //#region src/core/viewport/parallax.ts
-function e(e) {
-	return typeof e == "number" ? {
-		x: e,
-		y: e
-	} : e;
+function asXY(v) {
+	return typeof v === "number" ? {
+		x: v,
+		y: v
+	} : v;
 }
-function t(t, n) {
-	let r = e(n.pan), i = e(n.zoom ?? 1), a = n.anchor ?? {
+/**
+* Pure derivation of a parallax plane's inner `View` from the camera view
+* plus per-plane factors.
+*
+* `pan` controls how much the plane translates with the camera (1 = normal,
+* 0 = locked to `anchor`, >1 = leads). `zoom` controls how much it scales
+* with camera zoom (1 = normal, 0 = fixed at identity scale). `anchor`
+* (default origin) is the camera position at which all planes agree.
+*
+* Identity holds: `pan=1, zoom=1` returns a view equal to `outer`.
+*/
+function deriveParallaxView(outer, opts) {
+	const p = asXY(opts.pan);
+	const z = asXY(opts.zoom ?? 1);
+	const a = opts.anchor ?? {
 		x: 0,
 		y: 0
 	};
 	return {
-		x: a.x + (t.x - a.x) * r.x,
-		y: a.y + (t.y - a.y) * r.y,
+		x: a.x + (outer.x - a.x) * p.x,
+		y: a.y + (outer.y - a.y) * p.y,
 		scale: {
-			x: 1 + (t.scale.x - 1) * i.x,
-			y: 1 + (t.scale.y - 1) * i.y
+			x: 1 + (outer.scale.x - 1) * z.x,
+			y: 1 + (outer.scale.y - 1) * z.y
 		}
 	};
 }
-function n(e, n) {
-	let r = t(e, n), i = e.scale.x / r.scale.x, a = e.scale.y / r.scale.y;
+/** The map from `outer`'s world into the world of a plane drawn through
+*  `deriveParallaxView(outer, opts)` — the one that puts both points under the
+*  same pixel. */
+function planeMap(outer, opts) {
+	const inner = deriveParallaxView(outer, opts);
+	const kx = outer.scale.x / inner.scale.x;
+	const ky = outer.scale.y / inner.scale.y;
 	return {
 		scale: {
-			x: i,
-			y: a
+			x: kx,
+			y: ky
 		},
 		offset: {
-			x: r.x - i * e.x,
-			y: r.y - a * e.y
+			x: inner.x - kx * outer.x,
+			y: inner.y - ky * outer.y
 		}
 	};
 }
-function r(e, t) {
+/** Map a point from the outer view's world into the plane's world. */
+function toPlane(m, p) {
 	return {
-		x: t.x * e.scale.x + e.offset.x,
-		y: t.y * e.scale.y + e.offset.y
+		x: p.x * m.scale.x + m.offset.x,
+		y: p.y * m.scale.y + m.offset.y
 	};
 }
-function i(e, t) {
+/** Map a point from the plane's world back into the outer view's world. */
+function fromPlane(m, p) {
 	return {
-		x: (t.x - e.offset.x) / e.scale.x,
-		y: (t.y - e.offset.y) / e.scale.y
+		x: (p.x - m.offset.x) / m.scale.x,
+		y: (p.y - m.offset.y) / m.scale.y
 	};
 }
-function a(e, t) {
-	let n = t({
-		x: e.x,
-		y: e.y
-	}), r = t({
-		x: e.x + e.width,
-		y: e.y + e.height
+function mapRect(r, map) {
+	const a = map({
+		x: r.x,
+		y: r.y
+	});
+	const b = map({
+		x: r.x + r.width,
+		y: r.y + r.height
 	});
 	return {
-		x: Math.min(n.x, r.x),
-		y: Math.min(n.y, r.y),
-		width: Math.abs(r.x - n.x),
-		height: Math.abs(r.y - n.y)
+		x: Math.min(a.x, b.x),
+		y: Math.min(a.y, b.y),
+		width: Math.abs(b.x - a.x),
+		height: Math.abs(b.y - a.y)
 	};
 }
-function o(e, t) {
+/** A camera-world rect in the plane's world. The map is axis-aligned, so a
+*  rect stays a rect; a flipped axis is normalized back to a positive size. */
+function rectToPlane(m, r) {
 	return {
-		...t,
-		...a(t, (t) => r(e, t))
+		...r,
+		...mapRect(r, (p) => toPlane(m, p))
 	};
 }
-function s(e, t) {
+/** A plane-world rect in the camera's world — see {@link rectToPlane}. */
+function rectFromPlane(m, r) {
 	return {
-		...t,
-		...a(t, (t) => i(e, t))
+		...r,
+		...mapRect(r, (p) => fromPlane(m, p))
 	};
 }
-function c(e, t) {
-	if (e === t) return null;
-	let n = e ?? l, r = t ?? l, i = r.scale.x / n.scale.x, a = r.scale.y / n.scale.y, o = {
+/** The map from one world into another, where `null` is the camera's own:
+*  `fromPlane(from)`, then `toPlane(to)`. Null when the two are the same
+*  world, so a caller can skip the work. */
+function planeToPlane(from, to) {
+	if (from === to) return null;
+	const f = from ?? IDENTITY_MAP;
+	const t = to ?? IDENTITY_MAP;
+	const sx = t.scale.x / f.scale.x;
+	const sy = t.scale.y / f.scale.y;
+	const m = {
 		scale: {
-			x: i,
-			y: a
+			x: sx,
+			y: sy
 		},
 		offset: {
-			x: r.offset.x - n.offset.x * i,
-			y: r.offset.y - n.offset.y * a
+			x: t.offset.x - f.offset.x * sx,
+			y: t.offset.y - f.offset.y * sy
 		}
 	};
-	return o.scale.x === 1 && o.scale.y === 1 && o.offset.x === 0 && o.offset.y === 0 ? null : o;
+	return m.scale.x === 1 && m.scale.y === 1 && m.offset.x === 0 && m.offset.y === 0 ? null : m;
 }
-var l = {
+var IDENTITY_MAP = {
 	scale: {
 		x: 1,
 		y: 1
@@ -95,17 +126,19 @@ var l = {
 		y: 0
 	}
 };
-function u(e) {
+/** The map as an affine matrix in `@weasel-js/geom`'s `[a, b, c, d, e, f]`
+*  order, for `transformPath` and friends. */
+function planeMatrix(m) {
 	return [
-		e.scale.x,
+		m.scale.x,
 		0,
 		0,
-		e.scale.y,
-		e.offset.x,
-		e.offset.y
+		m.scale.y,
+		m.offset.x,
+		m.offset.y
 	];
 }
-//#endregion
-export { t as deriveParallaxView, i as fromPlane, n as planeMap, u as planeMatrix, c as planeToPlane, s as rectFromPlane, o as rectToPlane, r as toPlane };
 
+//#endregion
+export { deriveParallaxView, fromPlane, planeMap, planeMatrix, planeToPlane, rectFromPlane, rectToPlane, toPlane };
 //# sourceMappingURL=parallax.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"parallax.js","names":["asXY","v","deriveParallaxView","p","opts","z","outer","planeMap","inner","kx","ky","toPlane","m","fromPlane","mapRect","a","map","r","b","rectToPlane","rectFromPlane","planeToPlane","from","to","f","IDENTITY_MAP","t","sx","sy","planeMatrix"],"sources":["../../../src/core/viewport/parallax.ts"],"sourcesContent":["import type { Rect } from '@weasel-js/geom';\nimport type { View } from './view';\n\n/** One value for both axes, or a separate value per axis. */\nexport type ScalarOrXY = number | { x: number; y: number };\n\n/** How a parallax plane tracks the camera: `pan` is the fraction of the\n *  camera's translation it follows (1 = locked to the scene, 0 = fixed to the\n *  screen), `zoom` the same for scale, and `anchor` the camera position\n *  (`view.x` / `view.y`) the translation is measured from — every plane lines\n *  up when the camera sits there. */\nexport interface ParallaxOpts {\n  pan: ScalarOrXY;\n  zoom?: ScalarOrXY;\n  anchor?: { x: number; y: number };\n}\n\nfunction asXY(v: ScalarOrXY): { x: number; y: number } {\n  return typeof v === 'number' ? { x: v, y: v } : v;\n}\n\n/**\n * Pure derivation of a parallax plane's inner `View` from the camera view\n * plus per-plane factors.\n *\n * `pan` controls how much the plane translates with the camera (1 = normal,\n * 0 = locked to `anchor`, >1 = leads). `zoom` controls how much it scales\n * with camera zoom (1 = normal, 0 = fixed at identity scale). `anchor`\n * (default origin) is the camera position at which all planes agree.\n *\n * Identity holds: `pan=1, zoom=1` returns a view equal to `outer`.\n */\nexport function deriveParallaxView(outer: View, opts: ParallaxOpts): View {\n  const p = asXY(opts.pan);\n  const z = asXY(opts.zoom ?? 1);\n  const a = opts.anchor ?? { x: 0, y: 0 };\n  return {\n    x: a.x + (outer.x - a.x) * p.x,\n    y: a.y + (outer.y - a.y) * p.y,\n    scale: {\n      x: 1 + (outer.scale.x - 1) * z.x,\n      y: 1 + (outer.scale.y - 1) * z.y,\n    },\n  };\n}\n\n/** How a point of the camera's world lands in a plane's world, per axis:\n *  `plane = world * scale + offset`. A plane draws its content through its\n *  own view; this is what lets a pointer, a marquee or a selection box cross\n *  between that view and the camera's. */\nexport interface PlaneMap {\n  scale: { x: number; y: number };\n  offset: { x: number; y: number };\n}\n\n/** The map from `outer`'s world into the world of a plane drawn through\n *  `deriveParallaxView(outer, opts)` — the one that puts both points under the\n *  same pixel. */\nexport function planeMap(outer: View, opts: ParallaxOpts): PlaneMap {\n  const inner = deriveParallaxView(outer, opts);\n  const kx = outer.scale.x / inner.scale.x;\n  const ky = outer.scale.y / inner.scale.y;\n  return {\n    scale: { x: kx, y: ky },\n    offset: { x: inner.x - kx * outer.x, y: inner.y - ky * outer.y },\n  };\n}\n\n/** Map a point from the outer view's world into the plane's world. */\nexport function toPlane(m: PlaneMap, p: { x: number; y: number }): { x: number; y: number } {\n  return { x: p.x * m.scale.x + m.offset.x, y: p.y * m.scale.y + m.offset.y };\n}\n\n/** Map a point from the plane's world back into the outer view's world. */\nexport function fromPlane(m: PlaneMap, p: { x: number; y: number }): { x: number; y: number } {\n  return { x: (p.x - m.offset.x) / m.scale.x, y: (p.y - m.offset.y) / m.scale.y };\n}\n\nfunction mapRect(r: Rect, map: (p: { x: number; y: number }) => { x: number; y: number }): Rect {\n  const a = map({ x: r.x, y: r.y });\n  const b = map({ x: r.x + r.width, y: r.y + r.height });\n  return {\n    x: Math.min(a.x, b.x),\n    y: Math.min(a.y, b.y),\n    width: Math.abs(b.x - a.x),\n    height: Math.abs(b.y - a.y),\n  };\n}\n\n/** A camera-world rect in the plane's world. The map is axis-aligned, so a\n *  rect stays a rect; a flipped axis is normalized back to a positive size. */\nexport function rectToPlane<R extends Rect>(m: PlaneMap, r: R): R {\n  return { ...r, ...mapRect(r, (p) => toPlane(m, p)) };\n}\n\n/** A plane-world rect in the camera's world — see {@link rectToPlane}. */\nexport function rectFromPlane<R extends Rect>(m: PlaneMap, r: R): R {\n  return { ...r, ...mapRect(r, (p) => fromPlane(m, p)) };\n}\n\n/** The map from one world into another, where `null` is the camera's own:\n *  `fromPlane(from)`, then `toPlane(to)`. Null when the two are the same\n *  world, so a caller can skip the work. */\nexport function planeToPlane(from: PlaneMap | null, to: PlaneMap | null): PlaneMap | null {\n  if (from === to) return null;\n  const f = from ?? IDENTITY_MAP;\n  const t = to ?? IDENTITY_MAP;\n  const sx = t.scale.x / f.scale.x;\n  const sy = t.scale.y / f.scale.y;\n  const m = {\n    scale: { x: sx, y: sy },\n    offset: { x: t.offset.x - f.offset.x * sx, y: t.offset.y - f.offset.y * sy },\n  };\n  return m.scale.x === 1 && m.scale.y === 1 && m.offset.x === 0 && m.offset.y === 0 ? null : m;\n}\n\nconst IDENTITY_MAP: PlaneMap = { scale: { x: 1, y: 1 }, offset: { x: 0, y: 0 } };\n\n/** The map as an affine matrix in `@weasel-js/geom`'s `[a, b, c, d, e, f]`\n *  order, for `transformPath` and friends. */\nexport function planeMatrix(m: PlaneMap): [number, number, number, number, number, number] {\n  return [m.scale.x, 0, 0, m.scale.y, m.offset.x, m.offset.y];\n}\n"],"mappings":"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"}
+{"version":3,"file":"parallax.js","names":[],"sources":["../../../src/core/viewport/parallax.ts"],"sourcesContent":["import type { Rect } from '@weasel-js/geom';\nimport type { View } from './view';\n\n/** One value for both axes, or a separate value per axis. */\nexport type ScalarOrXY = number | { x: number; y: number };\n\n/** How a parallax plane tracks the camera: `pan` is the fraction of the\n *  camera's translation it follows (1 = locked to the scene, 0 = fixed to the\n *  screen), `zoom` the same for scale, and `anchor` the camera position\n *  (`view.x` / `view.y`) the translation is measured from — every plane lines\n *  up when the camera sits there. */\nexport interface ParallaxOpts {\n  pan: ScalarOrXY;\n  zoom?: ScalarOrXY;\n  anchor?: { x: number; y: number };\n}\n\nfunction asXY(v: ScalarOrXY): { x: number; y: number } {\n  return typeof v === 'number' ? { x: v, y: v } : v;\n}\n\n/**\n * Pure derivation of a parallax plane's inner `View` from the camera view\n * plus per-plane factors.\n *\n * `pan` controls how much the plane translates with the camera (1 = normal,\n * 0 = locked to `anchor`, >1 = leads). `zoom` controls how much it scales\n * with camera zoom (1 = normal, 0 = fixed at identity scale). `anchor`\n * (default origin) is the camera position at which all planes agree.\n *\n * Identity holds: `pan=1, zoom=1` returns a view equal to `outer`.\n */\nexport function deriveParallaxView(outer: View, opts: ParallaxOpts): View {\n  const p = asXY(opts.pan);\n  const z = asXY(opts.zoom ?? 1);\n  const a = opts.anchor ?? { x: 0, y: 0 };\n  return {\n    x: a.x + (outer.x - a.x) * p.x,\n    y: a.y + (outer.y - a.y) * p.y,\n    scale: {\n      x: 1 + (outer.scale.x - 1) * z.x,\n      y: 1 + (outer.scale.y - 1) * z.y,\n    },\n  };\n}\n\n/** How a point of the camera's world lands in a plane's world, per axis:\n *  `plane = world * scale + offset`. A plane draws its content through its\n *  own view; this is what lets a pointer, a marquee or a selection box cross\n *  between that view and the camera's. */\nexport interface PlaneMap {\n  scale: { x: number; y: number };\n  offset: { x: number; y: number };\n}\n\n/** The map from `outer`'s world into the world of a plane drawn through\n *  `deriveParallaxView(outer, opts)` — the one that puts both points under the\n *  same pixel. */\nexport function planeMap(outer: View, opts: ParallaxOpts): PlaneMap {\n  const inner = deriveParallaxView(outer, opts);\n  const kx = outer.scale.x / inner.scale.x;\n  const ky = outer.scale.y / inner.scale.y;\n  return {\n    scale: { x: kx, y: ky },\n    offset: { x: inner.x - kx * outer.x, y: inner.y - ky * outer.y },\n  };\n}\n\n/** Map a point from the outer view's world into the plane's world. */\nexport function toPlane(m: PlaneMap, p: { x: number; y: number }): { x: number; y: number } {\n  return { x: p.x * m.scale.x + m.offset.x, y: p.y * m.scale.y + m.offset.y };\n}\n\n/** Map a point from the plane's world back into the outer view's world. */\nexport function fromPlane(m: PlaneMap, p: { x: number; y: number }): { x: number; y: number } {\n  return { x: (p.x - m.offset.x) / m.scale.x, y: (p.y - m.offset.y) / m.scale.y };\n}\n\nfunction mapRect(r: Rect, map: (p: { x: number; y: number }) => { x: number; y: number }): Rect {\n  const a = map({ x: r.x, y: r.y });\n  const b = map({ x: r.x + r.width, y: r.y + r.height });\n  return {\n    x: Math.min(a.x, b.x),\n    y: Math.min(a.y, b.y),\n    width: Math.abs(b.x - a.x),\n    height: Math.abs(b.y - a.y),\n  };\n}\n\n/** A camera-world rect in the plane's world. The map is axis-aligned, so a\n *  rect stays a rect; a flipped axis is normalized back to a positive size. */\nexport function rectToPlane<R extends Rect>(m: PlaneMap, r: R): R {\n  return { ...r, ...mapRect(r, (p) => toPlane(m, p)) };\n}\n\n/** A plane-world rect in the camera's world — see {@link rectToPlane}. */\nexport function rectFromPlane<R extends Rect>(m: PlaneMap, r: R): R {\n  return { ...r, ...mapRect(r, (p) => fromPlane(m, p)) };\n}\n\n/** The map from one world into another, where `null` is the camera's own:\n *  `fromPlane(from)`, then `toPlane(to)`. Null when the two are the same\n *  world, so a caller can skip the work. */\nexport function planeToPlane(from: PlaneMap | null, to: PlaneMap | null): PlaneMap | null {\n  if (from === to) return null;\n  const f = from ?? IDENTITY_MAP;\n  const t = to ?? IDENTITY_MAP;\n  const sx = t.scale.x / f.scale.x;\n  const sy = t.scale.y / f.scale.y;\n  const m = {\n    scale: { x: sx, y: sy },\n    offset: { x: t.offset.x - f.offset.x * sx, y: t.offset.y - f.offset.y * sy },\n  };\n  return m.scale.x === 1 && m.scale.y === 1 && m.offset.x === 0 && m.offset.y === 0 ? null : m;\n}\n\nconst IDENTITY_MAP: PlaneMap = { scale: { x: 1, y: 1 }, offset: { x: 0, y: 0 } };\n\n/** The map as an affine matrix in `@weasel-js/geom`'s `[a, b, c, d, e, f]`\n *  order, for `transformPath` and friends. */\nexport function planeMatrix(m: PlaneMap): [number, number, number, number, number, number] {\n  return [m.scale.x, 0, 0, m.scale.y, m.offset.x, m.offset.y];\n}\n"],"mappings":"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"}

package/dist/core/viewport/sceneNodeClientRect.js

@@ -1,18 +1,27 @@
-import { viewToTransform as e } from "./view.js";
-import { worldToScreen as t } from "./viewTransform.js";
+import { viewToTransform } from "./view.js";
+import { worldToScreen } from "./viewTransform.js";
+
 //#region src/core/viewport/sceneNodeClientRect.ts
-function n(n) {
-	let r = n.getWorldBounds(n.id);
-	if (r === null) return null;
-	let i = e(n.view), [a, o] = t(r.x, r.y, i), s = n.canvas.getBoundingClientRect();
+/**
+* Project a scene node's world AABB to client (viewport) coordinates,
+* e.g. to anchor a `Callout` at a canvas-drawn object. Snapshot
+* semantics: the rect is where the node is *now* — it does not track
+* subsequent pan/zoom or scene mutations.
+*/
+function sceneNodeClientRect(opts) {
+	const bounds = opts.getWorldBounds(opts.id);
+	if (bounds === null) return null;
+	const t = viewToTransform(opts.view);
+	const [sx, sy] = worldToScreen(bounds.x, bounds.y, t);
+	const canvasRect = opts.canvas.getBoundingClientRect();
 	return {
-		x: s.left + a,
-		y: s.top + o,
-		width: r.width * n.view.scale.x,
-		height: r.height * n.view.scale.y
+		x: canvasRect.left + sx,
+		y: canvasRect.top + sy,
+		width: bounds.width * opts.view.scale.x,
+		height: bounds.height * opts.view.scale.y
 	};
 }
-//#endregion
-export { n as sceneNodeClientRect };
 
+//#endregion
+export { sceneNodeClientRect };
 //# sourceMappingURL=sceneNodeClientRect.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"sceneNodeClientRect.js","names":["sceneNodeClientRect","bounds","opts","t","viewToTransform","sx","sy","worldToScreen","canvasRect"],"sources":["../../../src/core/viewport/sceneNodeClientRect.ts"],"sourcesContent":["import type { Bounds } from './fitViewToBounds';\nimport type { View } from './view';\nimport { viewToTransform } from './view';\nimport { worldToScreen } from './viewTransform';\n\n/** Options for {@link sceneNodeClientRect}. */\nexport interface SceneNodeClientRectOpts {\n  /** Node (or container) id to locate. */\n  id: string;\n  /**\n   * Resolve an id to its world-space AABB, or null when unknown.\n   * Typically adapts a pose resolver (e.g. from `composeSelectionPose`):\n   * `(id) => { const p = resolvePose(id); return p ? boundsOfPath(p) : null; }`\n   * — for rect poses the pose is its own AABB and can be returned directly.\n   */\n  getWorldBounds: (id: string) => Bounds | null;\n  /** Current viewport. */\n  view: View;\n  /** The canvas element — supplies the client-coordinate origin. */\n  canvas: Element;\n}\n\n/** Client-coordinate rect (viewport space) — the shape `Callout`'s `anchorRect` expects. */\nexport interface NodeClientRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Project a scene node's world AABB to client (viewport) coordinates,\n * e.g. to anchor a `Callout` at a canvas-drawn object. Snapshot\n * semantics: the rect is where the node is *now* — it does not track\n * subsequent pan/zoom or scene mutations.\n */\nexport function sceneNodeClientRect(opts: SceneNodeClientRectOpts): NodeClientRect | null {\n  const bounds = opts.getWorldBounds(opts.id);\n  if (bounds === null) return null;\n  const t = viewToTransform(opts.view);\n  const [sx, sy] = worldToScreen(bounds.x, bounds.y, t);\n  const canvasRect = opts.canvas.getBoundingClientRect();\n  return {\n    x: canvasRect.left + sx,\n    y: canvasRect.top + sy,\n    width: bounds.width * opts.view.scale.x,\n    height: bounds.height * opts.view.scale.y,\n  };\n}\n"],"mappings":";;;AAoCA,SAAgBA,EAAoB,GAAsD;CACxF,IAAMC,IAASC,EAAK,eAAeA,EAAK,EAAE;CAC1C,IAAID,MAAW,MAAM,OAAO;CAC5B,IAAME,IAAIC,EAAgBF,EAAK,IAAI,GAC7B,CAACG,GAAIC,KAAMC,EAAcN,EAAO,GAAGA,EAAO,GAAGE,CAAC,GAC9CK,IAAaN,EAAK,OAAO,sBAAsB;CACrD,OAAO;EACL,GAAGM,EAAW,OAAOH;EACrB,GAAGG,EAAW,MAAMF;EACpB,OAAOL,EAAO,QAAQC,EAAK,KAAK,MAAM;EACtC,QAAQD,EAAO,SAASC,EAAK,KAAK,MAAM;CAC1C;AACF"}
+{"version":3,"file":"sceneNodeClientRect.js","names":[],"sources":["../../../src/core/viewport/sceneNodeClientRect.ts"],"sourcesContent":["import type { Bounds } from './fitViewToBounds';\nimport type { View } from './view';\nimport { viewToTransform } from './view';\nimport { worldToScreen } from './viewTransform';\n\n/** Options for {@link sceneNodeClientRect}. */\nexport interface SceneNodeClientRectOpts {\n  /** Node (or container) id to locate. */\n  id: string;\n  /**\n   * Resolve an id to its world-space AABB, or null when unknown.\n   * Typically adapts a pose resolver (e.g. from `composeSelectionPose`):\n   * `(id) => { const p = resolvePose(id); return p ? boundsOfPath(p) : null; }`\n   * — for rect poses the pose is its own AABB and can be returned directly.\n   */\n  getWorldBounds: (id: string) => Bounds | null;\n  /** Current viewport. */\n  view: View;\n  /** The canvas element — supplies the client-coordinate origin. */\n  canvas: Element;\n}\n\n/** Client-coordinate rect (viewport space) — the shape `Callout`'s `anchorRect` expects. */\nexport interface NodeClientRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Project a scene node's world AABB to client (viewport) coordinates,\n * e.g. to anchor a `Callout` at a canvas-drawn object. Snapshot\n * semantics: the rect is where the node is *now* — it does not track\n * subsequent pan/zoom or scene mutations.\n */\nexport function sceneNodeClientRect(opts: SceneNodeClientRectOpts): NodeClientRect | null {\n  const bounds = opts.getWorldBounds(opts.id);\n  if (bounds === null) return null;\n  const t = viewToTransform(opts.view);\n  const [sx, sy] = worldToScreen(bounds.x, bounds.y, t);\n  const canvasRect = opts.canvas.getBoundingClientRect();\n  return {\n    x: canvasRect.left + sx,\n    y: canvasRect.top + sy,\n    width: bounds.width * opts.view.scale.x,\n    height: bounds.height * opts.view.scale.y,\n  };\n}\n"],"mappings":";;;;;;;;;;AAoCA,SAAgB,oBAAoB,MAAsD;CACxF,MAAM,SAAS,KAAK,eAAe,KAAK,EAAE;CAC1C,IAAI,WAAW,MAAM,OAAO;CAC5B,MAAM,IAAI,gBAAgB,KAAK,IAAI;CACnC,MAAM,CAAC,IAAI,MAAM,cAAc,OAAO,GAAG,OAAO,GAAG,CAAC;CACpD,MAAM,aAAa,KAAK,OAAO,sBAAsB;CACrD,OAAO;EACL,GAAG,WAAW,OAAO;EACrB,GAAG,WAAW,MAAM;EACpB,OAAO,OAAO,QAAQ,KAAK,KAAK,MAAM;EACtC,QAAQ,OAAO,SAAS,KAAK,KAAK,MAAM;CAC1C;AACF"}

package/dist/core/viewport/screenSlop.js

@@ -1,33 +1,56 @@
-import { multiply as e, scale as t } from "@weasel-js/geom";
+import { multiply, scale } from "@weasel-js/geom";
+
 //#region src/core/viewport/screenSlop.ts
-function n(n, r) {
-	if (n === void 0) return {
+/**
+* Pointer forgiveness measured on screen.
+*
+* A pick slop is a screen distance: "within 4px of the outline". Converting it
+* to a world distance — per axis or as one scalar — is exact only when the
+* frame the geometry lives in reaches the screen by a similarity. A rotated
+* node under non-uniform zoom does not: a screen circle pulled back into its
+* frame is a tilted ellipse, so the test is run against the geometry's screen
+* image instead (`strokeHitTest`'s `slop`).
+*/
+/**
+* How `strokeHitTest` should apply a slop to geometry in a frame that
+* reaches world by `frame` (`poseFrameOf`; only its linear part is read): a
+* world slop adds to the threshold, a screen slop is handed over with the
+* frame's map to the screen.
+*/
+function slopForStrokeHit(slop, frame) {
+	if (slop === void 0) return {
 		extra: 0,
 		opts: {}
 	};
-	if (typeof n == "number") return {
-		extra: n,
+	if (typeof slop === "number") return {
+		extra: slop,
 		opts: {}
 	};
-	let i = t(n.scale.x, n.scale.y);
+	const s = scale(slop.scale.x, slop.scale.y);
 	return {
 		extra: 0,
 		opts: { slop: {
-			px: n.px,
-			transform: r ? e(i, r) : i
+			px: slop.px,
+			transform: frame ? multiply(s, frame) : s
 		} }
 	};
 }
-function r(e, t, n = 1) {
-	return t > 0 ? typeof e == "object" ? {
-		...e,
-		px: e.px + t
-	} : (e ?? 0) + t / (n > 0 ? n : 1) : e;
+/** `slop` widened by `px` screen pixels — kept on screen when it is measured
+*  there, and read at `scale` when it is a world distance. */
+function widenSlop(slop, px, scale = 1) {
+	if (!(px > 0)) return slop;
+	if (typeof slop === "object") return {
+		...slop,
+		px: slop.px + px
+	};
+	return (slop ?? 0) + px / (scale > 0 ? scale : 1);
 }
-function i(e) {
-	return e === void 0 ? !1 : typeof e == "number" ? e > 0 : e.px > 0;
+/** Is any slop set at all? A zero reach plus a zero slop hits nothing. */
+function hasSlop(slop) {
+	if (slop === void 0) return false;
+	return typeof slop === "number" ? slop > 0 : slop.px > 0;
 }
-//#endregion
-export { i as hasSlop, n as slopForStrokeHit, r as widenSlop };
 
+//#endregion
+export { hasSlop, slopForStrokeHit, widenSlop };
 //# sourceMappingURL=screenSlop.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"screenSlop.js","names":["scaleMat","slopForStrokeHit","slop","s","scale","frame","multiply","widenSlop","px","hasSlop"],"sources":["../../../src/core/viewport/screenSlop.ts"],"sourcesContent":["/**\n * Pointer forgiveness measured on screen.\n *\n * A pick slop is a screen distance: \"within 4px of the outline\". Converting it\n * to a world distance — per axis or as one scalar — is exact only when the\n * frame the geometry lives in reaches the screen by a similarity. A rotated\n * node under non-uniform zoom does not: a screen circle pulled back into its\n * frame is a tilted ellipse, so the test is run against the geometry's screen\n * image instead (`strokeHitTest`'s `slop`).\n */\nimport { multiply, scale as scaleMat, type Affine } from '@weasel-js/geom';\nimport type { Scale2 } from '@weasel-js/geom';\n\n/** `px` screen pixels under a view whose per-axis scale is `scale`. */\nexport interface ScreenSlop {\n  px: number;\n  scale: Scale2;\n}\n\n/** A slop in world units (a number, the view-less form) or on screen. */\nexport type PickSlop = number | ScreenSlop;\n\n/**\n * How `strokeHitTest` should apply a slop to geometry in a frame that\n * reaches world by `frame` (`poseFrameOf`; only its linear part is read): a\n * world slop adds to the threshold, a screen slop is handed over with the\n * frame's map to the screen.\n */\nexport function slopForStrokeHit(\n  slop: PickSlop | undefined,\n  frame?: Affine | null,\n): { extra: number; opts: { slop?: { px: number; transform: Affine } } } {\n  if (slop === undefined) return { extra: 0, opts: {} };\n  if (typeof slop === 'number') return { extra: slop, opts: {} };\n  const s = scaleMat(slop.scale.x, slop.scale.y);\n  return {\n    extra: 0,\n    opts: { slop: { px: slop.px, transform: frame ? multiply(s, frame) : s } },\n  };\n}\n\n/** `slop` widened by `px` screen pixels — kept on screen when it is measured\n *  there, and read at `scale` when it is a world distance. */\nexport function widenSlop(slop: PickSlop | undefined, px: number, scale = 1): PickSlop | undefined {\n  if (!(px > 0)) return slop;\n  if (typeof slop === 'object') return { ...slop, px: slop.px + px };\n  return (slop ?? 0) + px / (scale > 0 ? scale : 1);\n}\n\n/** Is any slop set at all? A zero reach plus a zero slop hits nothing. */\nexport function hasSlop(slop: PickSlop | undefined): boolean {\n  if (slop === undefined) return false;\n  return typeof slop === 'number' ? slop > 0 : slop.px > 0;\n}\n"],"mappings":";;AA4BA,SAAgBC,EACd,GACA,GACuE;CACvE,IAAIC,MAAS,KAAA,GAAW,OAAO;EAAE,OAAO;EAAG,MAAM,CAAC;CAAE;CACpD,IAAI,OAAOA,KAAS,UAAU,OAAO;EAAE,OAAOA;EAAM,MAAM,CAAC;CAAE;CAC7D,IAAMC,IAAIH,EAASE,EAAK,MAAM,GAAGA,EAAK,MAAM,CAAC;CAC7C,OAAO;EACL,OAAO;EACP,MAAM,EAAE,MAAM;GAAE,IAAIA,EAAK;GAAI,WAAWG,IAAQC,EAASH,GAAGE,CAAK,IAAIF;EAAE,EAAE;CAC3E;AACF;AAIA,SAAgBI,EAAU,GAA4B,GAAY,IAAQ,GAAyB;CAGjG,OAFMC,IAAK,IACP,OAAON,KAAS,WAAiB;EAAE,GAAGA;EAAM,IAAIA,EAAK,KAAKM;CAAG,KACzDN,KAAQ,KAAKM,KAAMJ,IAAQ,IAAIA,IAAQ,KAFzBF;AAGxB;AAGA,SAAgBO,EAAQ,GAAqC;CAE3D,OADIP,MAAS,KAAA,IAAkB,KACxB,OAAOA,KAAS,WAAWA,IAAO,IAAIA,EAAK,KAAK;AACzD"}
+{"version":3,"file":"screenSlop.js","names":["scaleMat"],"sources":["../../../src/core/viewport/screenSlop.ts"],"sourcesContent":["/**\n * Pointer forgiveness measured on screen.\n *\n * A pick slop is a screen distance: \"within 4px of the outline\". Converting it\n * to a world distance — per axis or as one scalar — is exact only when the\n * frame the geometry lives in reaches the screen by a similarity. A rotated\n * node under non-uniform zoom does not: a screen circle pulled back into its\n * frame is a tilted ellipse, so the test is run against the geometry's screen\n * image instead (`strokeHitTest`'s `slop`).\n */\nimport { multiply, scale as scaleMat, type Affine } from '@weasel-js/geom';\nimport type { Scale2 } from '@weasel-js/geom';\n\n/** `px` screen pixels under a view whose per-axis scale is `scale`. */\nexport interface ScreenSlop {\n  px: number;\n  scale: Scale2;\n}\n\n/** A slop in world units (a number, the view-less form) or on screen. */\nexport type PickSlop = number | ScreenSlop;\n\n/**\n * How `strokeHitTest` should apply a slop to geometry in a frame that\n * reaches world by `frame` (`poseFrameOf`; only its linear part is read): a\n * world slop adds to the threshold, a screen slop is handed over with the\n * frame's map to the screen.\n */\nexport function slopForStrokeHit(\n  slop: PickSlop | undefined,\n  frame?: Affine | null,\n): { extra: number; opts: { slop?: { px: number; transform: Affine } } } {\n  if (slop === undefined) return { extra: 0, opts: {} };\n  if (typeof slop === 'number') return { extra: slop, opts: {} };\n  const s = scaleMat(slop.scale.x, slop.scale.y);\n  return {\n    extra: 0,\n    opts: { slop: { px: slop.px, transform: frame ? multiply(s, frame) : s } },\n  };\n}\n\n/** `slop` widened by `px` screen pixels — kept on screen when it is measured\n *  there, and read at `scale` when it is a world distance. */\nexport function widenSlop(slop: PickSlop | undefined, px: number, scale = 1): PickSlop | undefined {\n  if (!(px > 0)) return slop;\n  if (typeof slop === 'object') return { ...slop, px: slop.px + px };\n  return (slop ?? 0) + px / (scale > 0 ? scale : 1);\n}\n\n/** Is any slop set at all? A zero reach plus a zero slop hits nothing. */\nexport function hasSlop(slop: PickSlop | undefined): boolean {\n  if (slop === undefined) return false;\n  return typeof slop === 'number' ? slop > 0 : slop.px > 0;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,iBACd,MACA,OACuE;CACvE,IAAI,SAAS,QAAW,OAAO;EAAE,OAAO;EAAG,MAAM,CAAC;CAAE;CACpD,IAAI,OAAO,SAAS,UAAU,OAAO;EAAE,OAAO;EAAM,MAAM,CAAC;CAAE;CAC7D,MAAM,IAAIA,MAAS,KAAK,MAAM,GAAG,KAAK,MAAM,CAAC;CAC7C,OAAO;EACL,OAAO;EACP,MAAM,EAAE,MAAM;GAAE,IAAI,KAAK;GAAI,WAAW,QAAQ,SAAS,GAAG,KAAK,IAAI;EAAE,EAAE;CAC3E;AACF;;;AAIA,SAAgB,UAAU,MAA4B,IAAY,QAAQ,GAAyB;CACjG,IAAI,EAAE,KAAK,IAAI,OAAO;CACtB,IAAI,OAAO,SAAS,UAAU,OAAO;EAAE,GAAG;EAAM,IAAI,KAAK,KAAK;CAAG;CACjE,QAAQ,QAAQ,KAAK,MAAM,QAAQ,IAAI,QAAQ;AACjD;;AAGA,SAAgB,QAAQ,MAAqC;CAC3D,IAAI,SAAS,QAAW,OAAO;CAC/B,OAAO,OAAO,SAAS,WAAW,OAAO,IAAI,KAAK,KAAK;AACzD"}

package/dist/core/viewport/useAutoCenter.js

@@ -1,32 +1,46 @@
-import { fitZoom as e } from "./fitToBounds.js";
-import { useEffect as t, useRef as n } from "react";
+import { fitZoom } from "./fitToBounds.js";
+import { useEffect, useRef } from "react";
+
 //#region src/core/viewport/useAutoCenter.ts
-function r(t, n, r, i, a = .85) {
-	let o = e(t * a, n * a, r, i), s = r * o, c = i * o;
+/**
+* Compute zoom and pan that fit `contentW x contentH` (in content units)
+* inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of
+* each axis to fill (default 0.85 — leaves a uniform 15% margin).
+*/
+function computeFitViewport(viewportW, viewportH, contentW, contentH, padRatio = .85) {
+	const zoom = fitZoom(viewportW * padRatio, viewportH * padRatio, contentW, contentH);
+	const cw = contentW * zoom;
+	const ch = contentH * zoom;
 	return {
-		zoom: o,
-		panX: (t - s) / 2,
-		panY: (n - c) / 2
+		zoom,
+		panX: (viewportW - cw) / 2,
+		panY: (viewportH - ch) / 2
 	};
 }
-function i(e, i, a, o, s, c) {
-	let l = n(!1);
-	t(() => {
-		if (e > 0 && i > 0 && !l.current) {
-			l.current = !0;
-			let t = r(e, i, a, o);
-			s(t.zoom), c(t.panX, t.panY);
+/**
+* Run `computeFitViewport` once when the viewport first has non-zero size, and
+* apply the result via the supplied setters. Subsequent size changes are
+* ignored — this hook centers exactly once.
+*/
+function useAutoCenter(width, height, contentW, contentH, setZoom, setPan) {
+	const hasCentered = useRef(false);
+	useEffect(() => {
+		if (width > 0 && height > 0 && !hasCentered.current) {
+			hasCentered.current = true;
+			const fit = computeFitViewport(width, height, contentW, contentH);
+			setZoom(fit.zoom);
+			setPan(fit.panX, fit.panY);
 		}
 	}, [
-		e,
-		i,
-		a,
-		o,
-		s,
-		c
+		width,
+		height,
+		contentW,
+		contentH,
+		setZoom,
+		setPan
 	]);
 }
-//#endregion
-export { r as computeFitViewport, i as useAutoCenter };
 
+//#endregion
+export { computeFitViewport, useAutoCenter };
 //# sourceMappingURL=useAutoCenter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAutoCenter.js","names":["computeFitViewport","zoom","fitZoom","viewportW","padRatio","viewportH","contentW","contentH","cw","ch","useAutoCenter","hasCentered","useRef","width","height","fit","setZoom","setPan"],"sources":["../../../src/core/viewport/useAutoCenter.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\nimport { fitZoom } from './fitToBounds';\n\n/**\n * Compute zoom and pan that fit `contentW x contentH` (in content units)\n * inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of\n * each axis to fill (default 0.85 — leaves a uniform 15% margin).\n */\nexport function computeFitViewport(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  padRatio = 0.85,\n): { zoom: number; panX: number; panY: number } {\n  const zoom = fitZoom(viewportW * padRatio, viewportH * padRatio, contentW, contentH);\n  const cw = contentW * zoom;\n  const ch = contentH * zoom;\n  return { zoom, panX: (viewportW - cw) / 2, panY: (viewportH - ch) / 2 };\n}\n\n/**\n * Run `computeFitViewport` once when the viewport first has non-zero size, and\n * apply the result via the supplied setters. Subsequent size changes are\n * ignored — this hook centers exactly once.\n */\nexport function useAutoCenter(\n  width: number,\n  height: number,\n  contentW: number,\n  contentH: number,\n  setZoom: (z: number) => void,\n  setPan: (x: number, y: number) => void,\n) {\n  const hasCentered = useRef(false);\n\n  useEffect(() => {\n    if (width > 0 && height > 0 && !hasCentered.current) {\n      hasCentered.current = true;\n      const fit = computeFitViewport(width, height, contentW, contentH);\n      setZoom(fit.zoom);\n      setPan(fit.panX, fit.panY);\n    }\n  }, [width, height, contentW, contentH, setZoom, setPan]);\n}\n"],"mappings":";;;AAQA,SAAgBA,EACd,GACA,GACA,GACA,GACA,IAAW,KACmC;CAC9C,IAAMC,IAAOC,EAAQC,IAAYC,GAAUC,IAAYD,GAAUE,GAAUC,CAAQ,GAC7EC,IAAKF,IAAWL,GAChBQ,IAAKF,IAAWN;CACtB,OAAO;EAAE;EAAM,OAAOE,IAAYK,KAAM;EAAG,OAAOH,IAAYI,KAAM;CAAE;AACxE;AAOA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,GACA;CACA,IAAMC,IAAcC,EAAO,EAAK;CAEhC,QAAgB;EACd,IAAIC,IAAQ,KAAKC,IAAS,KAAK,CAACH,EAAY,SAAS;GACnD,EAAY,UAAU;GACtB,IAAMI,IAAMf,EAAmBa,GAAOC,GAAQR,GAAUC,CAAQ;GAEhE,AADAS,EAAQD,EAAI,IAAI,GAChBE,EAAOF,EAAI,MAAMA,EAAI,IAAI;EAC3B;CACF,GAAG;EAACF;EAAOC;EAAQR;EAAUC;EAAUS;EAASC;CAAM,CAAC;AACzD"}
+{"version":3,"file":"useAutoCenter.js","names":[],"sources":["../../../src/core/viewport/useAutoCenter.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\nimport { fitZoom } from './fitToBounds';\n\n/**\n * Compute zoom and pan that fit `contentW x contentH` (in content units)\n * inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of\n * each axis to fill (default 0.85 — leaves a uniform 15% margin).\n */\nexport function computeFitViewport(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  padRatio = 0.85,\n): { zoom: number; panX: number; panY: number } {\n  const zoom = fitZoom(viewportW * padRatio, viewportH * padRatio, contentW, contentH);\n  const cw = contentW * zoom;\n  const ch = contentH * zoom;\n  return { zoom, panX: (viewportW - cw) / 2, panY: (viewportH - ch) / 2 };\n}\n\n/**\n * Run `computeFitViewport` once when the viewport first has non-zero size, and\n * apply the result via the supplied setters. Subsequent size changes are\n * ignored — this hook centers exactly once.\n */\nexport function useAutoCenter(\n  width: number,\n  height: number,\n  contentW: number,\n  contentH: number,\n  setZoom: (z: number) => void,\n  setPan: (x: number, y: number) => void,\n) {\n  const hasCentered = useRef(false);\n\n  useEffect(() => {\n    if (width > 0 && height > 0 && !hasCentered.current) {\n      hasCentered.current = true;\n      const fit = computeFitViewport(width, height, contentW, contentH);\n      setZoom(fit.zoom);\n      setPan(fit.panX, fit.panY);\n    }\n  }, [width, height, contentW, contentH, setZoom, setPan]);\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,mBACd,WACA,WACA,UACA,UACA,WAAW,KACmC;CAC9C,MAAM,OAAO,QAAQ,YAAY,UAAU,YAAY,UAAU,UAAU,QAAQ;CACnF,MAAM,KAAK,WAAW;CACtB,MAAM,KAAK,WAAW;CACtB,OAAO;EAAE;EAAM,OAAO,YAAY,MAAM;EAAG,OAAO,YAAY,MAAM;CAAE;AACxE;;;;;;AAOA,SAAgB,cACd,OACA,QACA,UACA,UACA,SACA,QACA;CACA,MAAM,cAAc,OAAO,KAAK;CAEhC,gBAAgB;EACd,IAAI,QAAQ,KAAK,SAAS,KAAK,CAAC,YAAY,SAAS;GACnD,YAAY,UAAU;GACtB,MAAM,MAAM,mBAAmB,OAAO,QAAQ,UAAU,QAAQ;GAChE,QAAQ,IAAI,IAAI;GAChB,OAAO,IAAI,MAAM,IAAI,IAAI;EAC3B;CACF,GAAG;EAAC;EAAO;EAAQ;EAAU;EAAU;EAAS;CAAM,CAAC;AACzD"}