@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/viewport/zoomAt.js

@@ -1,31 +1,59 @@
-import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t, normalizeZoom as n } from "./zoomBounds.js";
-import { normalizeView as r } from "./view.js";
+import { DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, normalizeZoom } from "./zoomBounds.js";
+import { normalizeView } from "./view.js";
+
 //#region src/core/viewport/zoomAt.ts
-function i(e, t, r) {
-	let i = n(Math.min(r, Math.max(t, Math.abs(e))));
-	return e < 0 ? -i : i;
+/** Bound a scale's *magnitude*, keeping its direction. `scale.y < 0` is how a
+*  `View` spells a y-up camera, so clamping the signed value against positive
+*  bounds would flip the axis and collapse the zoom rather than limit it. */
+function clampScale(scale, min, max) {
+	const magnitude = normalizeZoom(Math.min(max, Math.max(min, Math.abs(scale))));
+	return scale < 0 ? -magnitude : magnitude;
 }
-function a(e, t) {
-	return t === "x" ? {
-		x: e,
+/** `factor` held to one axis: the other axis's factor is 1, so `zoomAt` leaves
+*  its scale and its translation where they were. */
+function axisZoomFactor(factor, axis) {
+	if (axis === "x") return {
+		x: factor,
 		y: 1
-	} : t === "y" ? {
+	};
+	if (axis === "y") return {
 		x: 1,
-		y: e
-	} : e;
+		y: factor
+	};
+	return factor;
 }
-function o(n, a, o, s) {
-	let c = r(n), l = typeof o == "number" ? o : o.x, u = typeof o == "number" ? o : o.y, d = typeof s?.min == "number" ? s.min : s?.min?.x ?? t, f = typeof s?.min == "number" ? s.min : s?.min?.y ?? t, p = typeof s?.max == "number" ? s.max : s?.max?.x ?? e, m = typeof s?.max == "number" ? s.max : s?.max?.y ?? e, h = i(c.scale.x * l, d, p), g = i(c.scale.y * u, f, m), _ = a.x / c.scale.x + c.x, v = a.y / c.scale.y + c.y;
+/**
+* Pure zoom primitive. Returns a new `View` whose `scale` is multiplied
+* by `factor` (per-axis, clamped) and whose translation is adjusted so
+* that the world point currently under `anchor` (screen coords relative
+* to the canvas top-left) stays under the same screen pixel after the
+* zoom — independently on each axis.
+*
+* `factor: number` means "apply uniformly to both axes". `factor: {x, y}`
+* applies per-axis factors. Likewise for `opts.min` / `opts.max`.
+*/
+function zoomAt(input, anchor, factor, opts) {
+	const view = normalizeView(input);
+	const fx = typeof factor === "number" ? factor : factor.x;
+	const fy = typeof factor === "number" ? factor : factor.y;
+	const minX = typeof opts?.min === "number" ? opts.min : opts?.min?.x ?? DEFAULT_MIN_ZOOM;
+	const minY = typeof opts?.min === "number" ? opts.min : opts?.min?.y ?? DEFAULT_MIN_ZOOM;
+	const maxX = typeof opts?.max === "number" ? opts.max : opts?.max?.x ?? DEFAULT_MAX_ZOOM;
+	const maxY = typeof opts?.max === "number" ? opts.max : opts?.max?.y ?? DEFAULT_MAX_ZOOM;
+	const nextX = clampScale(view.scale.x * fx, minX, maxX);
+	const nextY = clampScale(view.scale.y * fy, minY, maxY);
+	const worldX = anchor.x / view.scale.x + view.x;
+	const worldY = anchor.y / view.scale.y + view.y;
 	return {
 		scale: {
-			x: h,
-			y: g
+			x: nextX,
+			y: nextY
 		},
-		x: _ - a.x / h,
-		y: v - a.y / g
+		x: worldX - anchor.x / nextX,
+		y: worldY - anchor.y / nextY
 	};
 }
-//#endregion
-export { a as axisZoomFactor, o as zoomAt };
 
+//#endregion
+export { axisZoomFactor, zoomAt };
 //# sourceMappingURL=zoomAt.js.map

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

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

package/dist/core/viewport/zoomBounds.js

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

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

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

package/dist/cornerHandles-Camw_yeu.d.ts

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