@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/viewport/fitToBounds.js

@@ -1,18 +1,35 @@
-import { normalizeZoom as e } from "./zoomBounds.js";
+import { normalizeZoom } from "./zoomBounds.js";
+
 //#region src/core/viewport/fitToBounds.ts
-function t(t, n, r, i, a) {
-	let o = Math.min(t / r, n / i), s = a?.min ?? -Infinity, c = a?.max ?? Infinity;
-	return e(Math.min(c, Math.max(s, o)));
+/**
+* Compute the largest uniform zoom (px per content-unit) that fits a content
+* rect of `contentW x contentH` (in content units) into a viewport rect of
+* `availW x availH` (in pixels).
+*
+* `clamp` optionally bounds the resulting zoom to [min, max].
+*/
+function fitZoom(availW, availH, contentW, contentH, clamp) {
+	const raw = Math.min(availW / contentW, availH / contentH);
+	const min = clamp?.min ?? -Infinity;
+	const max = clamp?.max ?? Infinity;
+	return normalizeZoom(Math.min(max, Math.max(min, raw)));
 }
-function n(e, n, r, i, a = 0, o) {
-	let s = t(Math.max(1, e - a * 2), Math.max(1, n - a * 2), r, i, o), c = r * s, l = i * s;
+/**
+* Compute zoom + pan that centers `contentW x contentH` (content units) inside
+* a `viewportW x viewportH` (pixel) rect. `paddingPx` is uniform pixel padding
+* on every side.
+*/
+function fitToBounds(viewportW, viewportH, contentW, contentH, paddingPx = 0, clamp) {
+	const zoom = fitZoom(Math.max(1, viewportW - paddingPx * 2), Math.max(1, viewportH - paddingPx * 2), contentW, contentH, clamp);
+	const contentPxW = contentW * zoom;
+	const contentPxH = contentH * zoom;
 	return {
-		zoom: s,
-		panX: (e - c) / 2,
-		panY: (n - l) / 2
+		zoom,
+		panX: (viewportW - contentPxW) / 2,
+		panY: (viewportH - contentPxH) / 2
 	};
 }
-//#endregion
-export { n as fitToBounds, t as fitZoom };
 
+//#endregion
+export { fitToBounds, fitZoom };
 //# sourceMappingURL=fitToBounds.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"fitToBounds.js","names":["fitZoom","raw","availW","contentW","availH","contentH","min","clamp","max","normalizeZoom","fitToBounds","zoom","viewportW","paddingPx","viewportH","contentPxW","contentPxH"],"sources":["../../../src/core/viewport/fitToBounds.ts"],"sourcesContent":["import { normalizeZoom } from './zoomBounds';\n\n/**\n * Compute the largest uniform zoom (px per content-unit) that fits a content\n * rect of `contentW x contentH` (in content units) into a viewport rect of\n * `availW x availH` (in pixels).\n *\n * `clamp` optionally bounds the resulting zoom to [min, max].\n */\nexport function fitZoom(\n  availW: number,\n  availH: number,\n  contentW: number,\n  contentH: number,\n  clamp?: { min?: number; max?: number },\n): number {\n  const raw = Math.min(availW / contentW, availH / contentH);\n  const min = clamp?.min ?? -Infinity;\n  const max = clamp?.max ?? Infinity;\n  return normalizeZoom(Math.min(max, Math.max(min, raw)));\n}\n\n/**\n * Compute zoom + pan that centers `contentW x contentH` (content units) inside\n * a `viewportW x viewportH` (pixel) rect. `paddingPx` is uniform pixel padding\n * on every side.\n */\nexport function fitToBounds(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  paddingPx = 0,\n  clamp?: { min?: number; max?: number },\n): { zoom: number; panX: number; panY: number } {\n  const availW = Math.max(1, viewportW - paddingPx * 2);\n  const availH = Math.max(1, viewportH - paddingPx * 2);\n  const zoom = fitZoom(availW, availH, contentW, contentH, clamp);\n  const contentPxW = contentW * zoom;\n  const contentPxH = contentH * zoom;\n  return {\n    zoom,\n    panX: (viewportW - contentPxW) / 2,\n    panY: (viewportH - contentPxH) / 2,\n  };\n}\n"],"mappings":";;AASA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACQ;CACR,IAAMC,IAAM,KAAK,IAAIC,IAASC,GAAUC,IAASC,CAAQ,GACnDC,IAAMC,GAAO,OAAO,WACpBC,IAAMD,GAAO,OAAO;CAC1B,OAAOE,EAAc,KAAK,IAAID,GAAK,KAAK,IAAIF,GAAKL,CAAG,CAAC,CAAC;AACxD;AAOA,SAAgBS,EACd,GACA,GACA,GACA,GACA,IAAY,GACZ,GAC8C;CAG9C,IAAMC,IAAOX,EAFE,KAAK,IAAI,GAAGY,IAAYC,IAAY,CAE9B,GADN,KAAK,IAAI,GAAGC,IAAYD,IAAY,CACtB,GAAQV,GAAUE,GAAUE,CAAK,GACxDQ,IAAaZ,IAAWQ,GACxBK,IAAaX,IAAWM;CAC9B,OAAO;EACL;EACA,OAAOC,IAAYG,KAAc;EACjC,OAAOD,IAAYE,KAAc;CACnC;AACF"}
+{"version":3,"file":"fitToBounds.js","names":[],"sources":["../../../src/core/viewport/fitToBounds.ts"],"sourcesContent":["import { normalizeZoom } from './zoomBounds';\n\n/**\n * Compute the largest uniform zoom (px per content-unit) that fits a content\n * rect of `contentW x contentH` (in content units) into a viewport rect of\n * `availW x availH` (in pixels).\n *\n * `clamp` optionally bounds the resulting zoom to [min, max].\n */\nexport function fitZoom(\n  availW: number,\n  availH: number,\n  contentW: number,\n  contentH: number,\n  clamp?: { min?: number; max?: number },\n): number {\n  const raw = Math.min(availW / contentW, availH / contentH);\n  const min = clamp?.min ?? -Infinity;\n  const max = clamp?.max ?? Infinity;\n  return normalizeZoom(Math.min(max, Math.max(min, raw)));\n}\n\n/**\n * Compute zoom + pan that centers `contentW x contentH` (content units) inside\n * a `viewportW x viewportH` (pixel) rect. `paddingPx` is uniform pixel padding\n * on every side.\n */\nexport function fitToBounds(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  paddingPx = 0,\n  clamp?: { min?: number; max?: number },\n): { zoom: number; panX: number; panY: number } {\n  const availW = Math.max(1, viewportW - paddingPx * 2);\n  const availH = Math.max(1, viewportH - paddingPx * 2);\n  const zoom = fitZoom(availW, availH, contentW, contentH, clamp);\n  const contentPxW = contentW * zoom;\n  const contentPxH = contentH * zoom;\n  return {\n    zoom,\n    panX: (viewportW - contentPxW) / 2,\n    panY: (viewportH - contentPxH) / 2,\n  };\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,QACd,QACA,QACA,UACA,UACA,OACQ;CACR,MAAM,MAAM,KAAK,IAAI,SAAS,UAAU,SAAS,QAAQ;CACzD,MAAM,MAAM,OAAO,OAAO;CAC1B,MAAM,MAAM,OAAO,OAAO;CAC1B,OAAO,cAAc,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC,CAAC;AACxD;;;;;;AAOA,SAAgB,YACd,WACA,WACA,UACA,UACA,YAAY,GACZ,OAC8C;CAG9C,MAAM,OAAO,QAFE,KAAK,IAAI,GAAG,YAAY,YAAY,CAE9B,GADN,KAAK,IAAI,GAAG,YAAY,YAAY,CACtB,GAAQ,UAAU,UAAU,KAAK;CAC9D,MAAM,aAAa,WAAW;CAC9B,MAAM,aAAa,WAAW;CAC9B,OAAO;EACL;EACA,OAAO,YAAY,cAAc;EACjC,OAAO,YAAY,cAAc;CACnC;AACF"}

package/dist/core/viewport/fitViewToBounds.js

@@ -1,36 +1,62 @@
-import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t, normalizeZoom as n } from "./zoomBounds.js";
+import { DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, normalizeZoom } from "./zoomBounds.js";
+
 //#region src/core/viewport/fitViewToBounds.ts
-function r(r, i, a, o = {}) {
-	let { padding: s = 16, maxScale: c = e, minScale: l = t } = o;
-	if (r.width <= 0 || r.height <= 0) return console.warn("[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.", r), a;
-	if (i.width <= 0 || i.height <= 0) return console.warn("[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.", i), a;
-	let u = Math.max(1, i.width - s * 2), d = Math.max(1, i.height - s * 2), f = u / r.width, p = d / r.height, m, h;
-	switch (o.mode ?? "contain") {
+/**
+* Compute the target {@link View} that fits `bounds` (world space) inside
+* `viewportDims` (CSS px). The bounds are centered in the viewport with
+* uniform padding on all sides; the resulting scale is clamped to the
+* configured min/max.
+*
+* Empty / zero-sized bounds or viewports cannot be fit — in that case this
+* returns `currentView` unchanged and logs a `console.warn`.
+*/
+function fitViewToBounds(bounds, viewportDims, currentView, opts = {}) {
+	const { padding = 16, maxScale = DEFAULT_MAX_ZOOM, minScale = DEFAULT_MIN_ZOOM } = opts;
+	if (bounds.width <= 0 || bounds.height <= 0) {
+		console.warn("[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.", bounds);
+		return currentView;
+	}
+	if (viewportDims.width <= 0 || viewportDims.height <= 0) {
+		console.warn("[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.", viewportDims);
+		return currentView;
+	}
+	const availW = Math.max(1, viewportDims.width - padding * 2);
+	const availH = Math.max(1, viewportDims.height - padding * 2);
+	const sx = availW / bounds.width;
+	const sy = availH / bounds.height;
+	let rawX;
+	let rawY;
+	switch (opts.mode ?? "contain") {
 		case "fill": {
-			let e = Math.max(f, p);
-			m = e, h = e;
+			const u = Math.max(sx, sy);
+			rawX = u;
+			rawY = u;
 			break;
 		}
 		case "stretch":
-			m = f, h = p;
+			rawX = sx;
+			rawY = sy;
 			break;
 		default: {
-			let e = Math.min(f, p);
-			m = e, h = e;
+			const u = Math.min(sx, sy);
+			rawX = u;
+			rawY = u;
 			break;
 		}
 	}
-	let g = n(Math.min(c, Math.max(l, m))), _ = n(Math.min(c, Math.max(l, h))), v = (e, t, n, r, i) => o.anchor === "start" && t * i > n + 1e-9 ? e - s / i : e + t / 2 - r / (2 * i);
+	const scaleX = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawX)));
+	const scaleY = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawY)));
+	const place = (start, size, avail, viewport, scale) => opts.anchor === "start" && size * scale > avail + 1e-9 ? start - padding / scale : start + size / 2 - viewport / (2 * scale);
 	return {
-		x: v(r.x, r.width, u, i.width, g),
-		y: v(r.y, r.height, d, i.height, _),
+		x: place(bounds.x, bounds.width, availW, viewportDims.width, scaleX),
+		y: place(bounds.y, bounds.height, availH, viewportDims.height, scaleY),
 		scale: {
-			x: g,
-			y: _
+			x: scaleX,
+			y: scaleY
 		}
 	};
 }
-//#endregion
-export { r as fitViewToBounds };
 
+//#endregion
+export { fitViewToBounds };
 //# sourceMappingURL=fitViewToBounds.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"fitViewToBounds.js","names":["fitViewToBounds","DEFAULT_MAX_ZOOM","DEFAULT_MIN_ZOOM","opts","bounds","currentView","viewportDims","availW","padding","availH","sx","sy","rawX","rawY","u","scaleX","normalizeZoom","maxScale","minScale","scaleY","place","size","scale","avail","start","viewport"],"sources":["../../../src/core/viewport/fitViewToBounds.ts"],"sourcesContent":["import type { View } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\nimport type { Bounds } from '@weasel-js/routing';\nexport type { Bounds };\n\n/** Pixel dimensions of the canvas viewport. */\nexport interface ViewportDims {\n  width: number;\n  height: number;\n}\n\n/** Options for {@link fitViewToBounds}. */\nexport interface FitViewToBoundsOptions {\n  /** Inset (in CSS px) around the bounds. Default 16. */\n  padding?: number;\n  /** Defaults to the kit-wide max zoom (`DEFAULT_MAX_ZOOM`). */\n  maxScale?: number;\n  /** Defaults to the kit-wide min zoom (`DEFAULT_MIN_ZOOM`). */\n  minScale?: number;\n  /**\n   * Fit mode:\n   * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.\n   * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.\n   * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.\n   */\n  mode?: 'contain' | 'fill' | 'stretch';\n  /**\n   * Where bounds that overflow the viewport on an axis sit, which happens when\n   * `minScale` stops the fit or `mode` is `'fill'`. `'center'` (default) shows\n   * their middle; `'start'` shows their left or top edge, inset by `padding`.\n   * An axis that fits is centered either way.\n   */\n  anchor?: 'center' | 'start';\n}\n\n/**\n * Compute the target {@link View} that fits `bounds` (world space) inside\n * `viewportDims` (CSS px). The bounds are centered in the viewport with\n * uniform padding on all sides; the resulting scale is clamped to the\n * configured min/max.\n *\n * Empty / zero-sized bounds or viewports cannot be fit — in that case this\n * returns `currentView` unchanged and logs a `console.warn`.\n */\nexport function fitViewToBounds(\n  bounds: Bounds,\n  viewportDims: ViewportDims,\n  currentView: View,\n  opts: FitViewToBoundsOptions = {},\n): View {\n  const { padding = 16, maxScale = DEFAULT_MAX_ZOOM, minScale = DEFAULT_MIN_ZOOM } = opts;\n\n  if (bounds.width <= 0 || bounds.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.', bounds);\n    return currentView;\n  }\n  if (viewportDims.width <= 0 || viewportDims.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.', viewportDims);\n    return currentView;\n  }\n\n  const availW = Math.max(1, viewportDims.width - padding * 2);\n  const availH = Math.max(1, viewportDims.height - padding * 2);\n  const sx = availW / bounds.width;\n  const sy = availH / bounds.height;\n\n  let rawX: number;\n  let rawY: number;\n  switch (opts.mode ?? 'contain') {\n    case 'fill': {\n      const u = Math.max(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n    case 'stretch':\n      rawX = sx;\n      rawY = sy;\n      break;\n    case 'contain':\n    default: {\n      const u = Math.min(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n  }\n  const scaleX = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawX)));\n  const scaleY = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawY)));\n\n  // screenCenter = (worldCenter - view.x) * scale, solved for view.x.\n  const place = (start: number, size: number, avail: number, viewport: number, scale: number) =>\n    opts.anchor === 'start' && size * scale > avail + 1e-9\n      ? start - padding / scale\n      : start + size / 2 - viewport / (2 * scale);\n  return {\n    x: place(bounds.x, bounds.width, availW, viewportDims.width, scaleX),\n    y: place(bounds.y, bounds.height, availH, viewportDims.height, scaleY),\n    scale: { x: scaleX, y: scaleY },\n  };\n}\n"],"mappings":";;AA6CA,SAAgBA,EACd,GACA,GACA,GACA,IAA+B,CAAC,GAC1B;CACN,IAAM,EAAE,aAAU,IAAI,cAAWC,GAAkB,cAAWC,MAAqBC;CAEnF,IAAIC,EAAO,SAAS,KAAKA,EAAO,UAAU,GAExC,OADA,QAAQ,KAAK,gGAAgGA,CAAM,GAC5GC;CAET,IAAIC,EAAa,SAAS,KAAKA,EAAa,UAAU,GAEpD,OADA,QAAQ,KAAK,kGAAkGA,CAAY,GACpHD;CAGT,IAAME,IAAS,KAAK,IAAI,GAAGD,EAAa,QAAQE,IAAU,CAAC,GACrDC,IAAS,KAAK,IAAI,GAAGH,EAAa,SAASE,IAAU,CAAC,GACtDE,IAAKH,IAASH,EAAO,OACrBO,IAAKF,IAASL,EAAO,QAEvBQ,GACAC;CACJ,QAAQV,EAAK,QAAQ,WAArB;EACE,KAAK,QAAQ;GACX,IAAMW,IAAI,KAAK,IAAIJ,GAAIC,CAAE;GAEzB,AADA,IAAOG,GACP,IAAOA;GACP;EACF;EACA,KAAK;GAEH,AADA,IAAOJ,GACP,IAAOC;GACP;EAEF,SAAS;GACP,IAAMG,IAAI,KAAK,IAAIJ,GAAIC,CAAE;GAEzB,AADA,IAAOG,GACP,IAAOA;GACP;EACF;CACF;CACA,IAAMC,IAASC,EAAc,KAAK,IAAIC,GAAU,KAAK,IAAIC,GAAUN,CAAI,CAAC,CAAC,GACnEO,IAASH,EAAc,KAAK,IAAIC,GAAU,KAAK,IAAIC,GAAUL,CAAI,CAAC,CAAC,GAGnEO,KAAS,GAAe,GAAc,GAAe,GAAkB,MAC3EjB,EAAK,WAAW,WAAWkB,IAAOC,IAAQC,IAAQ,OAC9CC,IAAQhB,IAAUc,IAClBE,IAAQH,IAAO,IAAII,KAAY,IAAIH;CACzC,OAAO;EACL,GAAGF,EAAMhB,EAAO,GAAGA,EAAO,OAAOG,GAAQD,EAAa,OAAOS,CAAM;EACnE,GAAGK,EAAMhB,EAAO,GAAGA,EAAO,QAAQK,GAAQH,EAAa,QAAQa,CAAM;EACrE,OAAO;GAAE,GAAGJ;GAAQ,GAAGI;EAAO;CAChC;AACF"}
+{"version":3,"file":"fitViewToBounds.js","names":[],"sources":["../../../src/core/viewport/fitViewToBounds.ts"],"sourcesContent":["import type { View } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\nimport type { FramedBox as Bounds } from '@weasel-js/geom';\nexport type { Bounds };\n\n/** Pixel dimensions of the canvas viewport. */\nexport interface ViewportDims {\n  width: number;\n  height: number;\n}\n\n/** Options for {@link fitViewToBounds}. */\nexport interface FitViewToBoundsOptions {\n  /** Inset (in CSS px) around the bounds. Default 16. */\n  padding?: number;\n  /** Defaults to the kit-wide max zoom (`DEFAULT_MAX_ZOOM`). */\n  maxScale?: number;\n  /** Defaults to the kit-wide min zoom (`DEFAULT_MIN_ZOOM`). */\n  minScale?: number;\n  /**\n   * Fit mode:\n   * - `'contain'` (default): uniform scale = `min(availW/w, availH/h)`. Bounds fit entirely; one axis has letterboxing.\n   * - `'fill'`: uniform scale = `max(...)`. Bounds overflow viewport on one axis.\n   * - `'stretch'`: per-axis scale. Bounds match viewport exactly; scale is non-uniform.\n   */\n  mode?: 'contain' | 'fill' | 'stretch';\n  /**\n   * Where bounds that overflow the viewport on an axis sit, which happens when\n   * `minScale` stops the fit or `mode` is `'fill'`. `'center'` (default) shows\n   * their middle; `'start'` shows their left or top edge, inset by `padding`.\n   * An axis that fits is centered either way.\n   */\n  anchor?: 'center' | 'start';\n}\n\n/**\n * Compute the target {@link View} that fits `bounds` (world space) inside\n * `viewportDims` (CSS px). The bounds are centered in the viewport with\n * uniform padding on all sides; the resulting scale is clamped to the\n * configured min/max.\n *\n * Empty / zero-sized bounds or viewports cannot be fit — in that case this\n * returns `currentView` unchanged and logs a `console.warn`.\n */\nexport function fitViewToBounds(\n  bounds: Bounds,\n  viewportDims: ViewportDims,\n  currentView: View,\n  opts: FitViewToBoundsOptions = {},\n): View {\n  const { padding = 16, maxScale = DEFAULT_MAX_ZOOM, minScale = DEFAULT_MIN_ZOOM } = opts;\n\n  if (bounds.width <= 0 || bounds.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: bounds has zero or negative area; returning currentView unchanged.', bounds);\n    return currentView;\n  }\n  if (viewportDims.width <= 0 || viewportDims.height <= 0) {\n    console.warn('[weasel] fitViewToBounds: viewport has zero or negative area; returning currentView unchanged.', viewportDims);\n    return currentView;\n  }\n\n  const availW = Math.max(1, viewportDims.width - padding * 2);\n  const availH = Math.max(1, viewportDims.height - padding * 2);\n  const sx = availW / bounds.width;\n  const sy = availH / bounds.height;\n\n  let rawX: number;\n  let rawY: number;\n  switch (opts.mode ?? 'contain') {\n    case 'fill': {\n      const u = Math.max(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n    case 'stretch':\n      rawX = sx;\n      rawY = sy;\n      break;\n    case 'contain':\n    default: {\n      const u = Math.min(sx, sy);\n      rawX = u;\n      rawY = u;\n      break;\n    }\n  }\n  const scaleX = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawX)));\n  const scaleY = normalizeZoom(Math.min(maxScale, Math.max(minScale, rawY)));\n\n  // screenCenter = (worldCenter - view.x) * scale, solved for view.x.\n  const place = (start: number, size: number, avail: number, viewport: number, scale: number) =>\n    opts.anchor === 'start' && size * scale > avail + 1e-9\n      ? start - padding / scale\n      : start + size / 2 - viewport / (2 * scale);\n  return {\n    x: place(bounds.x, bounds.width, availW, viewportDims.width, scaleX),\n    y: place(bounds.y, bounds.height, availH, viewportDims.height, scaleY),\n    scale: { x: scaleX, y: scaleY },\n  };\n}\n"],"mappings":";;;;;;;;;;;;AA6CA,SAAgB,gBACd,QACA,cACA,aACA,OAA+B,CAAC,GAC1B;CACN,MAAM,EAAE,UAAU,IAAI,WAAW,kBAAkB,WAAW,qBAAqB;CAEnF,IAAI,OAAO,SAAS,KAAK,OAAO,UAAU,GAAG;EAC3C,QAAQ,KAAK,gGAAgG,MAAM;EACnH,OAAO;CACT;CACA,IAAI,aAAa,SAAS,KAAK,aAAa,UAAU,GAAG;EACvD,QAAQ,KAAK,kGAAkG,YAAY;EAC3H,OAAO;CACT;CAEA,MAAM,SAAS,KAAK,IAAI,GAAG,aAAa,QAAQ,UAAU,CAAC;CAC3D,MAAM,SAAS,KAAK,IAAI,GAAG,aAAa,SAAS,UAAU,CAAC;CAC5D,MAAM,KAAK,SAAS,OAAO;CAC3B,MAAM,KAAK,SAAS,OAAO;CAE3B,IAAI;CACJ,IAAI;CACJ,QAAQ,KAAK,QAAQ,WAArB;EACE,KAAK,QAAQ;GACX,MAAM,IAAI,KAAK,IAAI,IAAI,EAAE;GACzB,OAAO;GACP,OAAO;GACP;EACF;EACA,KAAK;GACH,OAAO;GACP,OAAO;GACP;EAEF,SAAS;GACP,MAAM,IAAI,KAAK,IAAI,IAAI,EAAE;GACzB,OAAO;GACP,OAAO;GACP;EACF;CACF;CACA,MAAM,SAAS,cAAc,KAAK,IAAI,UAAU,KAAK,IAAI,UAAU,IAAI,CAAC,CAAC;CACzE,MAAM,SAAS,cAAc,KAAK,IAAI,UAAU,KAAK,IAAI,UAAU,IAAI,CAAC,CAAC;CAGzE,MAAM,SAAS,OAAe,MAAc,OAAe,UAAkB,UAC3E,KAAK,WAAW,WAAW,OAAO,QAAQ,QAAQ,OAC9C,QAAQ,UAAU,QAClB,QAAQ,OAAO,IAAI,YAAY,IAAI;CACzC,OAAO;EACL,GAAG,MAAM,OAAO,GAAG,OAAO,OAAO,QAAQ,aAAa,OAAO,MAAM;EACnE,GAAG,MAAM,OAAO,GAAG,OAAO,QAAQ,QAAQ,aAAa,QAAQ,MAAM;EACrE,OAAO;GAAE,GAAG;GAAQ,GAAG;EAAO;CAChC;AACF"}

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