@weasel-js/core 1.10.0 → 1.10.1

package/dist/core/viewport/view.js

@@ -14,8 +14,11 @@ function r(e) {
 function i(e) {
 	return n(e.scale);
 }
-function a(e) {
-	let t = o(e.scale.x), n = o(e.scale.y), r = s(e.x), i = s(e.y);
+function a(e, t) {
+	return e.x === t.x && e.y === t.y && e.scale.x === t.scale.x && e.scale.y === t.scale.y;
+}
+function o(e) {
+	let t = s(e.scale.x), n = s(e.scale.y), r = c(e.x), i = c(e.y);
 	return t === e.scale.x && n === e.scale.y && r === e.x && i === e.y ? e : {
 		x: r,
 		y: i,
@@ -25,13 +28,13 @@ function a(e) {
 		}
 	};
 }
-function o(t) {
+function s(t) {
 	return t < 0 && t > -Infinity ? -e(-t) : e(t);
 }
-function s(e) {
+function c(e) {
 	return Number.isFinite(e) ? e : (t(`a position of ${e}`), 0);
 }
 //#endregion
-export { a as normalizeView, r as viewToTransform, i as viewZoom };
+export { o as normalizeView, a as sameView, r as viewToTransform, i as viewZoom };
 
 //# sourceMappingURL=view.js.map

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

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

package/dist/core/viewport/zoomAt.js

@@ -5,7 +5,16 @@ function i(e, t, r) {
 	let i = n(Math.min(r, Math.max(t, Math.abs(e))));
 	return e < 0 ? -i : i;
 }
-function a(n, a, o, s) {
+function a(e, t) {
+	return t === "x" ? {
+		x: e,
+		y: 1
+	} : t === "y" ? {
+		x: 1,
+		y: e
+	} : e;
+}
+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;
 	return {
 		scale: {
@@ -17,6 +26,6 @@ function a(n, a, o, s) {
 	};
 }
 //#endregion
-export { a as zoomAt };
+export { a as axisZoomFactor, o as 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","zoomAt","view","normalizeView","input","fx","factor","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/**\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;AAYA,SAAgBK,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAOC,EAAcC,CAAK,GAC1BC,IAAK,OAAOC,KAAW,WAAWA,IAASA,EAAO,GAClDC,IAAK,OAAOD,KAAW,WAAWA,IAASA,EAAO,GAClDE,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,IAAQpB,EAAWO,EAAK,MAAM,IAAIG,GAAIG,GAAMI,CAAI,GAChDI,IAAQrB,EAAWO,EAAK,MAAM,IAAIK,GAAII,GAAMG,CAAI,GAEhDG,IAASC,EAAO,IAAIhB,EAAK,MAAM,IAAIA,EAAK,GACxCiB,IAASD,EAAO,IAAIhB,EAAK,MAAM,IAAIA,EAAK;CAC9C,OAAO;EACL,OAAO;GAAE,GAAGa;GAAO,GAAGC;EAAM;EAC5B,GAAGC,IAASC,EAAO,IAAIH;EACvB,GAAGI,IAASD,EAAO,IAAIF;CACzB;AACF"}
+{"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"}

package/dist/{cornerHandles-BEshc4z3.d.ts → cornerHandles-BSKbyuvQ.d.ts}

@@ -1,4 +1,4 @@
-import { B as BoundsConstraint, P as PointSnapBehavior } from './clone-2a5hVbBd.js';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './clone-C0eADtS0.js';
 import { Bounds, ResizeAnchor } from '@weasel-js/routing';
 
 /** Option surface for the `resize` action. */

package/dist/features/paths/editablePath.js

@@ -1,8 +1,8 @@
 import { isRectPose as e } from "../../core/geometry/autoPoseDescriptor.js";
 import { pathFromPlane as t } from "../../canvas/planeClips.js";
-import { pathInWorld as n } from "@weasel-js/geom";
+import { pathInWorld as n, worldEditToStorage as r } from "@weasel-js/geom";
 //#region src/features/paths/editablePath.ts
-function r(t) {
+function i(t) {
 	if (!t) return null;
 	if (t.pose?.kind === "polygon") return { kind: "pose" };
 	let n = t.data;
@@ -12,12 +12,28 @@ function r(t) {
 		data: n
 	} : null;
 }
-function i(e) {
+function a(e) {
 	if (!e) return null;
-	let t = r(e);
+	let t = i(e);
 	return t ? t.kind === "pose" ? e.pose : n(t.data.path, t.pose) : null;
 }
-function a(e, t, n) {
+function o(e, t) {
+	let n = i(e);
+	if (!n) return null;
+	if (n.kind === "pose") return {
+		pose: t,
+		data: e.data
+	};
+	let { pose: a, path: o } = r(n.pose, t);
+	return {
+		pose: a,
+		data: {
+			...n.data,
+			path: o
+		}
+	};
+}
+function s(e, t, n) {
 	let r = t.pose, i = t.data, a = !1;
 	for (let t of n) {
 		let n = t.previewIds?.();
@@ -38,10 +54,10 @@ function a(e, t, n) {
 		data: i
 	};
 }
-function o(e, n, r, o) {
-	return n ? t(i(a(e, n, r)), o) : null;
+function c(e, n, r, i) {
+	return n ? t(a(s(e, n, r)), i) : null;
 }
 //#endregion
-export { r as classifyPathStorage, o as liveEditablePath, i as resolveEditablePathOf };
+export { i as classifyPathStorage, c as liveEditablePath, a as resolveEditablePathOf, o as storeEditablePath };
 
 //# sourceMappingURL=editablePath.js.map

package/dist/features/paths/editablePath.js.map

@@ -1 +1 @@
-{"version":3,"file":"editablePath.js","names":["classifyPathStorage","node","data","isRectPose","resolveEditablePathOf","storage","pathInWorld","previewedShape","pose","touched","source","previews","previewIds","owns","pid","id","p","d","liveEditablePath","pathFromPlane","plane"],"sources":["../../../src/features/paths/editablePath.ts"],"sourcesContent":["/**\n * A node's editable polygon. It lives in one of two places: the pose itself\n * (`pose.kind === 'polygon'`), or `data.path` with a rect pose, stored pose-local.\n */\nimport { pathInWorld, type Path, type PolygonPath } from '@weasel-js/geom';\nimport type { GesturePreviewSource } from 'canvas/gestureBounds';\nimport { pathFromPlane } from 'canvas/planeClips';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { RectPose } from 'core/scene/types';\nimport type { PlaneMap } from 'core/viewport/parallax';\n\n/** The two fields of a node the editable path is read from. */\nexport interface EditableShape {\n  pose: unknown;\n  data: unknown;\n}\n\n/** Resolve where a node's editable polygon lives. Returns null when the\n *  node has neither a polygon pose nor a polygon on `data.path`. */\nexport function classifyPathStorage(\n  node: EditableShape | undefined | null,\n): { kind: 'pose' } | { kind: 'data'; pose: RectPose; data: { path: PolygonPath } } | null {\n  if (!node) return null;\n  const pose = node.pose as { kind?: string } | undefined;\n  if (pose?.kind === 'polygon') return { kind: 'pose' };\n  const data = node.data as { path?: Path } | null;\n  if (data?.path && (data.path as { kind?: string }).kind === 'polygon' && isRectPose(node.pose)) {\n    return {\n      kind: 'data',\n      pose: node.pose,\n      data: data as { path: PolygonPath },\n    };\n  }\n  return null;\n}\n\n/** A node's editable polygon in world coords. Does NOT consult any preview state —\n *  callers that want live state read in-flight handles themselves. */\nexport function resolveEditablePathOf(\n  node: EditableShape | undefined | null,\n): PolygonPath | null {\n  if (!node) return null;\n  const storage = classifyPathStorage(node);\n  if (!storage) return null;\n  // Pose-as-polygon: the pose IS the polygon (polygon poses can't carry\n  // rotation), so it's already world.\n  if (storage.kind === 'pose') return (node as { pose: PolygonPath }).pose;\n  // data.path: translate to the pose origin AND bake `pose.rotation`, so anchors render on\n  // the rotated contour the renderer draws.\n  return pathInWorld(storage.data.path, storage.pose) as PolygonPath;\n}\n\n/** `node` as the in-flight gestures in `previews` would leave it: a handle\n *  previewing `id` contributes its pose and its data. */\nfunction previewedShape(\n  id: string,\n  node: EditableShape,\n  previews: readonly GesturePreviewSource[],\n): EditableShape {\n  let pose = node.pose;\n  let data = node.data;\n  let touched = false;\n  for (const source of previews) {\n    const previewIds = source.previewIds?.();\n    if (!previewIds) continue;\n    let owns = false;\n    for (const pid of previewIds) {\n      if (pid === id) { owns = true; break; }\n    }\n    if (!owns) continue;\n    const p = source.previewPose?.(id);\n    if (p != null && !touched) { pose = p; touched = true; }\n    const d = source.previewData?.(id);\n    if (d != null) { data = d; touched = true; }\n  }\n  return { pose, data };\n}\n\n/**\n * The editable polygon of node `id` as it is drawn right now: following any\n * in-flight gesture in `previews`, and in the world of the camera whose\n * `plane` this is — a path on a parallax plane is stored in the plane's.\n */\nexport function liveEditablePath(\n  id: string,\n  node: EditableShape | undefined | null,\n  previews: readonly GesturePreviewSource[],\n  plane: PlaneMap | null,\n): PolygonPath | null {\n  if (!node) return null;\n  return pathFromPlane(resolveEditablePathOf(previewedShape(id, node, previews)), plane);\n}\n"],"mappings":";;;;AAmBA,SAAgBA,EACd,GACyF;CACzF,IAAI,CAACC,GAAM,OAAO;CAElB,IADaA,EAAK,MACR,SAAS,WAAW,OAAO,EAAE,MAAM,OAAO;CACpD,IAAMC,IAAOD,EAAK;CAQlB,OAPIC,GAAM,QAASA,EAAK,KAA2B,SAAS,aAAaC,EAAWF,EAAK,IAAI,IACpF;EACL,MAAM;EACN,MAAMA,EAAK;EACL;CACR,IAEK;AACT;AAIA,SAAgBG,EACd,GACoB;CACpB,IAAI,CAACH,GAAM,OAAO;CAClB,IAAMI,IAAUL,EAAoBC,CAAI;CAOxC,OANKI,IAGDA,EAAQ,SAAS,SAAgBJ,EAA+B,OAG7DK,EAAYD,EAAQ,KAAK,MAAMA,EAAQ,IAAI,IAN7B;AAOvB;AAIA,SAASE,EACP,GACA,GACA,GACe;CACf,IAAIC,IAAOP,EAAK,MACZC,IAAOD,EAAK,MACZQ,IAAU;CACd,KAAK,IAAMC,KAAUC,GAAU;EAC7B,IAAMC,IAAaF,EAAO,aAAa;EACvC,IAAI,CAACE,GAAY;EACjB,IAAIC,IAAO;EACX,KAAK,IAAMC,KAAOF,GAChB,IAAIE,MAAQC,GAAI;GAAE,IAAO;GAAM;EAAO;EAExC,IAAI,CAACF,GAAM;EACX,IAAMG,IAAIN,EAAO,cAAcK,CAAE;EACjC,AAAIC,KAAK,QAAQ,CAACP,MAAW,IAAOO,GAAG,IAAU;EACjD,IAAMC,IAAIP,EAAO,cAAcK,CAAE;EACjC,AAAIE,KAAK,SAAQ,IAAOA,GAAG,IAAU;CACvC;CACA,OAAO;EAAE;EAAM;CAAK;AACtB;AAOA,SAAgBC,EACd,GACA,GACA,GACA,GACoB;CAEpB,OADKjB,IACEkB,EAAcf,EAAsBG,EAAeQ,GAAId,GAAMU,CAAQ,CAAC,GAAGS,CAAK,IADnE;AAEpB"}
+{"version":3,"file":"editablePath.js","names":["classifyPathStorage","node","data","isRectPose","resolveEditablePathOf","storage","pathInWorld","storeEditablePath","worldPath","worldEditToStorage","previewedShape","pose","touched","source","previews","previewIds","owns","pid","id","p","d","liveEditablePath","pathFromPlane","plane"],"sources":["../../../src/features/paths/editablePath.ts"],"sourcesContent":["/**\n * A node's editable polygon. It lives in one of two places: the pose itself\n * (`pose.kind === 'polygon'`), or `data.path` with a rect pose, stored pose-local.\n */\nimport { pathInWorld, worldEditToStorage, type Path, type PolygonPath } from '@weasel-js/geom';\nimport type { GesturePreviewSource } from 'canvas/gestureBounds';\nimport { pathFromPlane } from 'canvas/planeClips';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { RectPose } from 'core/scene/types';\nimport type { PlaneMap } from 'core/viewport/parallax';\n\n/** The two fields of a node the editable path is read from. */\nexport interface EditableShape {\n  pose: unknown;\n  data: unknown;\n}\n\n/** Resolve where a node's editable polygon lives. Returns null when the\n *  node has neither a polygon pose nor a polygon on `data.path`. */\nexport function classifyPathStorage(\n  node: EditableShape | undefined | null,\n): { kind: 'pose' } | { kind: 'data'; pose: RectPose; data: { path: PolygonPath } } | null {\n  if (!node) return null;\n  const pose = node.pose as { kind?: string } | undefined;\n  if (pose?.kind === 'polygon') return { kind: 'pose' };\n  const data = node.data as { path?: Path } | null;\n  if (data?.path && (data.path as { kind?: string }).kind === 'polygon' && isRectPose(node.pose)) {\n    return {\n      kind: 'data',\n      pose: node.pose,\n      data: data as { path: PolygonPath },\n    };\n  }\n  return null;\n}\n\n/** A node's editable polygon in world coords. Does NOT consult any preview state —\n *  callers that want live state read in-flight handles themselves. */\nexport function resolveEditablePathOf(\n  node: EditableShape | undefined | null,\n): PolygonPath | null {\n  if (!node) return null;\n  const storage = classifyPathStorage(node);\n  if (!storage) return null;\n  // Pose-as-polygon: the pose IS the polygon (polygon poses can't carry\n  // rotation), so it's already world.\n  if (storage.kind === 'pose') return (node as { pose: PolygonPath }).pose;\n  // data.path: translate to the pose origin AND bake `pose.rotation`, so anchors render on\n  // the rotated contour the renderer draws.\n  return pathInWorld(storage.data.path, storage.pose) as PolygonPath;\n}\n\n/**\n * The pose and data that store `worldPath` where `node` stores its editable\n * polygon — the inverse of {@link resolveEditablePathOf}, so a `data.path`\n * node keeps its rotation. Null when `node` has no editable polygon.\n */\nexport function storeEditablePath(\n  node: EditableShape | undefined | null,\n  worldPath: PolygonPath,\n): EditableShape | null {\n  const storage = classifyPathStorage(node);\n  if (!storage) return null;\n  if (storage.kind === 'pose') return { pose: worldPath, data: node!.data };\n  const { pose, path } = worldEditToStorage(storage.pose, worldPath);\n  return { pose, data: { ...storage.data, path } };\n}\n\n/** `node` as the in-flight gestures in `previews` would leave it: a handle\n *  previewing `id` contributes its pose and its data. */\nfunction previewedShape(\n  id: string,\n  node: EditableShape,\n  previews: readonly GesturePreviewSource[],\n): EditableShape {\n  let pose = node.pose;\n  let data = node.data;\n  let touched = false;\n  for (const source of previews) {\n    const previewIds = source.previewIds?.();\n    if (!previewIds) continue;\n    let owns = false;\n    for (const pid of previewIds) {\n      if (pid === id) { owns = true; break; }\n    }\n    if (!owns) continue;\n    const p = source.previewPose?.(id);\n    if (p != null && !touched) { pose = p; touched = true; }\n    const d = source.previewData?.(id);\n    if (d != null) { data = d; touched = true; }\n  }\n  return { pose, data };\n}\n\n/**\n * The editable polygon of node `id` as it is drawn right now: following any\n * in-flight gesture in `previews`, and in the world of the camera whose\n * `plane` this is — a path on a parallax plane is stored in the plane's.\n */\nexport function liveEditablePath(\n  id: string,\n  node: EditableShape | undefined | null,\n  previews: readonly GesturePreviewSource[],\n  plane: PlaneMap | null,\n): PolygonPath | null {\n  if (!node) return null;\n  return pathFromPlane(resolveEditablePathOf(previewedShape(id, node, previews)), plane);\n}\n"],"mappings":";;;;AAmBA,SAAgBA,EACd,GACyF;CACzF,IAAI,CAACC,GAAM,OAAO;CAElB,IADaA,EAAK,MACR,SAAS,WAAW,OAAO,EAAE,MAAM,OAAO;CACpD,IAAMC,IAAOD,EAAK;CAQlB,OAPIC,GAAM,QAASA,EAAK,KAA2B,SAAS,aAAaC,EAAWF,EAAK,IAAI,IACpF;EACL,MAAM;EACN,MAAMA,EAAK;EACL;CACR,IAEK;AACT;AAIA,SAAgBG,EACd,GACoB;CACpB,IAAI,CAACH,GAAM,OAAO;CAClB,IAAMI,IAAUL,EAAoBC,CAAI;CAOxC,OANKI,IAGDA,EAAQ,SAAS,SAAgBJ,EAA+B,OAG7DK,EAAYD,EAAQ,KAAK,MAAMA,EAAQ,IAAI,IAN7B;AAOvB;AAOA,SAAgBE,EACd,GACA,GACsB;CACtB,IAAMF,IAAUL,EAAoBC,CAAI;CACxC,IAAI,CAACI,GAAS,OAAO;CACrB,IAAIA,EAAQ,SAAS,QAAQ,OAAO;EAAE,MAAMG;EAAW,MAAMP,EAAM;CAAK;CACxE,IAAM,EAAE,SAAM,YAASQ,EAAmBJ,EAAQ,MAAMG,CAAS;CACjE,OAAO;EAAE;EAAM,MAAM;GAAE,GAAGH,EAAQ;GAAM;EAAK;CAAE;AACjD;AAIA,SAASK,EACP,GACA,GACA,GACe;CACf,IAAIC,IAAOV,EAAK,MACZC,IAAOD,EAAK,MACZW,IAAU;CACd,KAAK,IAAMC,KAAUC,GAAU;EAC7B,IAAMC,IAAaF,EAAO,aAAa;EACvC,IAAI,CAACE,GAAY;EACjB,IAAIC,IAAO;EACX,KAAK,IAAMC,KAAOF,GAChB,IAAIE,MAAQC,GAAI;GAAE,IAAO;GAAM;EAAO;EAExC,IAAI,CAACF,GAAM;EACX,IAAMG,IAAIN,EAAO,cAAcK,CAAE;EACjC,AAAIC,KAAK,QAAQ,CAACP,MAAW,IAAOO,GAAG,IAAU;EACjD,IAAMC,IAAIP,EAAO,cAAcK,CAAE;EACjC,AAAIE,KAAK,SAAQ,IAAOA,GAAG,IAAU;CACvC;CACA,OAAO;EAAE;EAAM;CAAK;AACtB;AAOA,SAAgBC,EACd,GACA,GACA,GACA,GACoB;CAEpB,OADKpB,IACEqB,EAAclB,EAAsBM,EAAeQ,GAAIjB,GAAMa,CAAQ,CAAC,GAAGS,CAAK,IADnE;AAEpB"}

package/dist/features/paths/index.js

@@ -3,8 +3,8 @@ import { createPenPreviewLayer as t } from "./penPreviewLayer.js";
 import { createPathEditingOverlayLayer as n } from "./pathEditingOverlayLayer.js";
 import { createPathLayer as r } from "./pathLayer.js";
 import { pathOriginProjection as i } from "./originProjection.js";
-import { DEFAULT_FLATTEN_TOLERANCE as a, PATH_C as o, PATH_CMD_LENGTHS as s, PATH_L as c, PATH_M as l, PATH_Q as u, PATH_Z as d, PathBuilder as f, boundsOfPath as p, circlePath as m, composePath as h, countPathAnchors as g, decomposePath as _, ellipsePath as v, flattenCubic as y, flattenCubicWithArcLen as b, flattenQuadratic as x, flattenQuadraticWithArcLen as S, hasOpenSubpath as C, linePath as w, pathCommandCoordCount as T, pathContainsPoint as E, pathContainsPolygon as D, pathContainsRect as O, pathDistanceToPoint as k, pathFromD as A, pathInPoseFrame as j, pathInWorld as M, pathIntersectsPolygon as N, pathIntersectsRect as P, pathSignedArea as F, pathThroughPoseFrame as I, pathToAnchors as L, pointAlongPath as R, pointInPath as z, polygonFromPoints as B, polylineFromPoints as V, poseFrameInverseOf as H, poseFrameOf as U, poseLinearOf as W, poseRotationOf as G, rectMarkerPath as K, rectPath as q, regularPolygonPath as J, reversePath as Y, rotatePathAround as X, roundRectPath as Z, scalePathToBounds as Q, splitByClosure as $, splitSubpaths as ee, squarePath as te, starPath as ne, transformPath as re, translatePath as ie, unionBoundsPath as ae, worldEditToStorage as oe } from "@weasel-js/geom";
-import { strokeToPath as se } from "@weasel-js/stroke";
-import { pathDivide as ce, pathExclude as le, pathIntersect as ue, pathSubtract as de, pathUnion as fe, snipPathByPolyline as pe, splitPathByPolyline as me, splitPathBySegment as he, trianglesToPath as ge } from "@weasel-js/geom/booleans";
+import { DEFAULT_FLATTEN_TOLERANCE as a, PATH_C as o, PATH_CMD_LENGTHS as s, PATH_L as c, PATH_M as l, PATH_Q as u, PATH_Z as d, PathBuilder as f, averageAnchorsAt as p, boundsOfPath as m, circlePath as h, composePath as g, countPathAnchors as _, decomposePath as v, ellipsePath as y, flattenCubic as b, flattenCubicWithArcLen as x, flattenQuadratic as S, flattenQuadraticWithArcLen as C, hasOpenSubpath as w, joinAnchorsAt as T, linePath as E, pathCommandCoordCount as D, pathContainsPoint as O, pathContainsPolygon as k, pathContainsRect as A, pathDistanceToPoint as j, pathFromD as M, pathInPoseFrame as N, pathInWorld as P, pathIntersectsPolygon as F, pathIntersectsRect as I, pathSignedArea as L, pathThroughPoseFrame as R, pathToAnchors as z, pointAlongPath as B, pointInPath as V, polygonFromPoints as H, polylineFromPoints as U, poseFrameInverseOf as W, poseFrameOf as G, poseLinearOf as K, poseRotationOf as q, rectMarkerPath as J, rectPath as Y, regularPolygonPath as X, reversePath as Z, rotatePathAround as Q, roundRectPath as $, scalePathToBounds as ee, simplifyPath as te, splitByClosure as ne, splitSubpaths as re, squarePath as ie, starPath as ae, transformPath as oe, translatePath as se, unionBoundsPath as ce, worldEditToStorage as le } from "@weasel-js/geom";
+import { offsetPath as ue, strokeToPath as de } from "@weasel-js/stroke";
+import { pathDivide as fe, pathExclude as pe, pathIntersect as me, pathSubtract as he, pathUnion as ge, snipPathByPolyline as _e, snipPathsAtCrossings as ve, splitPathByPolyline as ye, splitPathBySegment as be, trianglesToPath as xe } from "@weasel-js/geom/booleans";
 import "@weasel-js/geom/curves";
-export { a as DEFAULT_FLATTEN_TOLERANCE, o as PATH_C, s as PATH_CMD_LENGTHS, c as PATH_L, l as PATH_M, u as PATH_Q, d as PATH_Z, f as PathBuilder, p as boundsOfPath, m as circlePath, h as composePath, g as countPathAnchors, n as createPathEditingOverlayLayer, r as createPathLayer, t as createPenPreviewLayer, _ as decomposePath, v as ellipsePath, y as flattenCubic, b as flattenCubicWithArcLen, x as flattenQuadratic, S as flattenQuadraticWithArcLen, C as hasOpenSubpath, w as linePath, T as pathCommandCoordCount, E as pathContainsPoint, D as pathContainsPolygon, O as pathContainsRect, k as pathDistanceToPoint, ce as pathDivide, le as pathExclude, A as pathFromD, j as pathInPoseFrame, M as pathInWorld, ue as pathIntersect, N as pathIntersectsPolygon, P as pathIntersectsRect, i as pathOriginProjection, e as pathPoseDescriptor, F as pathSignedArea, de as pathSubtract, I as pathThroughPoseFrame, L as pathToAnchors, fe as pathUnion, R as pointAlongPath, z as pointInPath, B as polygonFromPoints, V as polylineFromPoints, H as poseFrameInverseOf, U as poseFrameOf, W as poseLinearOf, G as poseRotationOf, K as rectMarkerPath, q as rectPath, J as regularPolygonPath, Y as reversePath, X as rotatePathAround, Z as roundRectPath, Q as scalePathToBounds, pe as snipPathByPolyline, $ as splitByClosure, me as splitPathByPolyline, he as splitPathBySegment, ee as splitSubpaths, te as squarePath, ne as starPath, se as strokeToPath, re as transformPath, ie as translatePath, ge as trianglesToPath, ae as unionBoundsPath, oe as worldEditToStorage };
+export { a as DEFAULT_FLATTEN_TOLERANCE, o as PATH_C, s as PATH_CMD_LENGTHS, c as PATH_L, l as PATH_M, u as PATH_Q, d as PATH_Z, f as PathBuilder, p as averageAnchorsAt, m as boundsOfPath, h as circlePath, g as composePath, _ as countPathAnchors, n as createPathEditingOverlayLayer, r as createPathLayer, t as createPenPreviewLayer, v as decomposePath, y as ellipsePath, b as flattenCubic, x as flattenCubicWithArcLen, S as flattenQuadratic, C as flattenQuadraticWithArcLen, w as hasOpenSubpath, T as joinAnchorsAt, E as linePath, ue as offsetPath, D as pathCommandCoordCount, O as pathContainsPoint, k as pathContainsPolygon, A as pathContainsRect, j as pathDistanceToPoint, fe as pathDivide, pe as pathExclude, M as pathFromD, N as pathInPoseFrame, P as pathInWorld, me as pathIntersect, F as pathIntersectsPolygon, I as pathIntersectsRect, i as pathOriginProjection, e as pathPoseDescriptor, L as pathSignedArea, he as pathSubtract, R as pathThroughPoseFrame, z as pathToAnchors, ge as pathUnion, B as pointAlongPath, V as pointInPath, H as polygonFromPoints, U as polylineFromPoints, W as poseFrameInverseOf, G as poseFrameOf, K as poseLinearOf, q as poseRotationOf, J as rectMarkerPath, Y as rectPath, X as regularPolygonPath, Z as reversePath, Q as rotatePathAround, $ as roundRectPath, ee as scalePathToBounds, te as simplifyPath, _e as snipPathByPolyline, ve as snipPathsAtCrossings, ne as splitByClosure, ye as splitPathByPolyline, be as splitPathBySegment, re as splitSubpaths, ie as squarePath, ae as starPath, de as strokeToPath, oe as transformPath, se as translatePath, xe as trianglesToPath, ce as unionBoundsPath, le as worldEditToStorage };

package/dist/features/paths/shapeGenerator.js

@@ -0,0 +1,89 @@
+import { boundsOfPath as e, boxToBox as t, poseFrameOf as n, regularPolygonPath as r, starPath as i, transformPath as a, worldEditToStorage as o } from "@weasel-js/geom";
+//#region src/features/paths/shapeGenerator.ts
+var s = {
+	min: 3,
+	max: 32
+}, c = {
+	min: .01,
+	max: 1
+}, l = (e) => typeof e == "number" && Number.isFinite(e);
+function u(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return l(t.rotation) ? t.kind === "polygon" ? l(t.sides) : t.kind === "star" && l(t.points) && l(t.innerRadiusRatio) : !1;
+}
+function d(e) {
+	let t = e?.generator;
+	return u(t) ? t : null;
+}
+var f = (e, t, n) => Math.min(n, Math.max(t, e)), p = (e) => f(Math.round(e), s.min, s.max);
+function m(e) {
+	return e.kind === "polygon" ? {
+		kind: "polygon",
+		sides: p(e.sides),
+		rotation: e.rotation
+	} : {
+		kind: "star",
+		points: p(e.points),
+		innerRadiusRatio: f(e.innerRadiusRatio, c.min, c.max),
+		rotation: e.rotation
+	};
+}
+function h(e, t = {
+	x: 0,
+	y: 0
+}, n = 1) {
+	let a = m(e);
+	return a.kind === "polygon" ? r(t, n, a.sides, a.rotation) : i(t, n, a.points, n * a.innerRadiusRatio, a.rotation);
+}
+function g(e) {
+	if (typeof e != "object" || !e || !("generator" in e)) return e;
+	let { generator: t, ...n } = e;
+	return n;
+}
+function _(n, r) {
+	let i = n;
+	if (i?.kind !== "polygon") return !1;
+	let a = h(r);
+	if (i.coords.length !== a.coords.length) return !1;
+	let o = e(a), s = e(i), c = t(o.x, o.y, o.width, o.height, s.x, s.y, s.width, s.height), l = 1e-4 * Math.max(1, Math.abs(s.x) + s.width, Math.abs(s.y) + s.height);
+	for (let e = 0; e + 1 < a.coords.length; e += 2) {
+		let t = c[0] * a.coords[e] + c[4], n = c[3] * a.coords[e + 1] + c[5];
+		if (Math.abs(t - i.coords[e]) > l || Math.abs(n - i.coords[e + 1]) > l) return !1;
+	}
+	return !0;
+}
+function v(r, i) {
+	let s = d(r.data);
+	if (!s || !_(r.data.path, s)) return null;
+	let c = m(i), l = e(h(s)), { pose: u } = r, f = t(l.x, l.y, l.width, l.height, u.x, u.y, u.width, u.height), p = a(h(c), f), g = n(u), v = g ? a(p, g) : p, y = o(u, v);
+	return {
+		pose: y.pose,
+		data: {
+			...r.data,
+			path: y.path,
+			generator: c
+		}
+	};
+}
+function y(e, t) {
+	let n = e.data;
+	if (typeof n != "object" || !n || !("generator" in n)) return e;
+	let r = n.generator, i = d(t.data);
+	if (i !== null && JSON.stringify(r) === JSON.stringify(i)) return e;
+	let a = i !== null && u(r) && r.kind === i.kind ? v({
+		pose: e.pose,
+		data: {
+			...n,
+			generator: i
+		}
+	}, r) : null;
+	return {
+		...e,
+		...a ?? { data: g(e.data) }
+	};
+}
+//#endregion
+export { s as SHAPE_COUNT_RANGE, c as STAR_RATIO_RANGE, m as clampShapeGenerator, u as isShapeGenerator, v as regenerateShape, y as settleShapeGenerator, d as shapeGeneratorOf, h as shapeGeneratorPath, g as withoutShapeGenerator };
+
+//# sourceMappingURL=shapeGenerator.js.map

package/dist/features/paths/shapeGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeGenerator.js","names":["SHAPE_COUNT_RANGE","STAR_RATIO_RANGE","finite","v","isShapeGenerator","g","shapeGeneratorOf","data","clamp","hi","lo","count","clampShapeGenerator","shapeGeneratorPath","c","regularPolygonPath","center","radius","starPath","withoutShapeGenerator","_dropped","rest","pathMatches","p","path","unit","u","boundsOfPath","b","m","boxToBox","tol","i","x","y","regenerateShape","held","node","next","was","toLocal","pose","local","transformPath","frame","poseFrameOf","world","stored","worldEditToStorage","settleShapeGenerator","raw","prev","regenerated"],"sources":["../../../src/features/paths/shapeGenerator.ts"],"sourcesContent":["/**\n * The parameters a polygon or star was drawn with, kept on the node beside the\n * geometry they made (`data.generator` beside `data.path`), so the shape stays\n * editable as a polygon or a star after it is drawn.\n *\n * `data.path` stays the geometry every reader uses; the generator only says how\n * to make it again. Editing the path itself turns the shape into plain\n * geometry: the generator is dropped, since it could no longer reproduce what\n * is drawn. A generator whose path no longer matches it (a writer that changed\n * the path without dropping it) is treated the same way.\n */\nimport {\n  boundsOfPath,\n  boxToBox,\n  poseFrameOf,\n  regularPolygonPath,\n  starPath,\n  transformPath,\n  worldEditToStorage,\n  type PathInWorldPose,\n  type PolygonPath,\n} from '@weasel-js/geom';\n\n/** A regular polygon's parameters. `rotation` is the angle of its first\n *  vertex, in radians, inside the pose's own rotation. */\nexport interface PolygonGenerator {\n  kind: 'polygon';\n  sides: number;\n  rotation: number;\n}\n\n/** A star's parameters. `innerRadiusRatio` is the inner radius over the outer\n *  one; `rotation` is the angle of its first point, in radians, inside the\n *  pose's own rotation. */\nexport interface StarGenerator {\n  kind: 'star';\n  points: number;\n  innerRadiusRatio: number;\n  rotation: number;\n}\n\n/** The parameters a node's `data.path` was generated from. */\nexport type ShapeGenerator = PolygonGenerator | StarGenerator;\n\n/** The range of a polygon's side count and a star's point count. */\nexport const SHAPE_COUNT_RANGE = { min: 3, max: 32 } as const;\n\n/** The range of a star's `innerRadiusRatio`. */\nexport const STAR_RATIO_RANGE = { min: 0.01, max: 1 } as const;\n\nconst finite = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);\n\n/** Whether `v` is a well-formed {@link ShapeGenerator}. */\nexport function isShapeGenerator(v: unknown): v is ShapeGenerator {\n  if (v === null || typeof v !== 'object') return false;\n  const g = v as Record<string, unknown>;\n  if (!finite(g.rotation)) return false;\n  if (g.kind === 'polygon') return finite(g.sides);\n  if (g.kind === 'star') return finite(g.points) && finite(g.innerRadiusRatio);\n  return false;\n}\n\n/** The generator a node's `data` holds, or `null`. */\nexport function shapeGeneratorOf(data: unknown): ShapeGenerator | null {\n  const g = (data as { generator?: unknown } | null | undefined)?.generator;\n  return isShapeGenerator(g) ? g : null;\n}\n\nconst clamp = (v: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, v));\nconst count = (v: number): number => clamp(Math.round(v), SHAPE_COUNT_RANGE.min, SHAPE_COUNT_RANGE.max);\n\n/** `g` with its counts rounded and every field held in range. */\nexport function clampShapeGenerator(g: ShapeGenerator): ShapeGenerator {\n  if (g.kind === 'polygon') return { kind: 'polygon', sides: count(g.sides), rotation: g.rotation };\n  return {\n    kind: 'star',\n    points: count(g.points),\n    innerRadiusRatio: clamp(g.innerRadiusRatio, STAR_RATIO_RANGE.min, STAR_RATIO_RANGE.max),\n    rotation: g.rotation,\n  };\n}\n\n/** The shape `g` makes, on a circle of `radius` around `center`. */\nexport function shapeGeneratorPath(\n  g: ShapeGenerator,\n  center: { x: number; y: number } = { x: 0, y: 0 },\n  radius = 1,\n): PolygonPath {\n  const c = clampShapeGenerator(g);\n  return c.kind === 'polygon'\n    ? regularPolygonPath(center, radius, c.sides, c.rotation)\n    : starPath(center, radius, c.points, radius * c.innerRadiusRatio, c.rotation);\n}\n\n/** `data` without its generator: the shape as plain geometry. */\nexport function withoutShapeGenerator<T>(data: T): T {\n  if (data === null || typeof data !== 'object' || !('generator' in data)) return data;\n  const { generator: _dropped, ...rest } = data as Record<string, unknown>;\n  void _dropped;\n  return rest as T;\n}\n\n/** Whether `path` is what `g` makes, up to the box-to-box map storage applies. */\nfunction pathMatches(path: unknown, g: ShapeGenerator): boolean {\n  const p = path as PolygonPath | undefined;\n  if (p?.kind !== 'polygon') return false;\n  const unit = shapeGeneratorPath(g);\n  if (p.coords.length !== unit.coords.length) return false;\n  const u = boundsOfPath(unit);\n  const b = boundsOfPath(p);\n  const m = boxToBox(u.x, u.y, u.width, u.height, b.x, b.y, b.width, b.height);\n  // Paths store float32 coordinates, so the slack scales with how far they are from the origin.\n  const tol = 1e-4 * Math.max(1, Math.abs(b.x) + b.width, Math.abs(b.y) + b.height);\n  for (let i = 0; i + 1 < unit.coords.length; i += 2) {\n    const x = m[0] * unit.coords[i] + m[4];\n    const y = m[3] * unit.coords[i + 1] + m[5];\n    if (Math.abs(x - p.coords[i]) > tol || Math.abs(y - p.coords[i + 1]) > tol) return false;\n  }\n  return true;\n}\n\n/** A node's two halves, as a regeneration reads and writes them. */\nexport interface GeneratedShape<P extends PathInWorldPose = PathInWorldPose> {\n  pose: P;\n  data: unknown;\n}\n\n/**\n * `node` made again from `next`, in place: the new shape takes the box the old\n * one's circle had, under the same rotation and transform, so a star given\n * more points keeps its center and its size. Returns `null` when the node holds\n * no generator, or its path no longer matches the one it holds.\n */\nexport function regenerateShape<P extends PathInWorldPose>(\n  node: GeneratedShape<P>,\n  next: ShapeGenerator,\n): GeneratedShape<P> | null {\n  const held = shapeGeneratorOf(node.data);\n  if (!held || !pathMatches((node.data as { path?: unknown }).path, held)) return null;\n  const g = clampShapeGenerator(next);\n  const was = boundsOfPath(shapeGeneratorPath(held));\n  const { pose } = node;\n  // Where the unit circle of the held generator lands in the pose's local frame.\n  const toLocal = boxToBox(was.x, was.y, was.width, was.height, pose.x, pose.y, pose.width, pose.height);\n  const local = transformPath(shapeGeneratorPath(g), toLocal) as PolygonPath;\n  const frame = poseFrameOf(pose);\n  const world = frame ? (transformPath(local, frame) as PolygonPath) : local;\n  const stored = worldEditToStorage(pose, world);\n  return { pose: stored.pose, data: { ...(node.data as object), path: stored.path, generator: g } };\n}\n\n/**\n * What a write that left a node as `next`, from `prev`, stores: when the write\n * changed the generator, the shape made again from it. A generator written\n * onto a node that held none, or of another kind, or onto one whose path no\n * longer matches, is dropped, leaving the shape as plain geometry. Any other\n * write is stored as written. Fits `NodePropertiesEntry.settle`.\n */\nexport function settleShapeGenerator<N extends { pose: unknown; data: unknown }>(next: N, prev: N): N {\n  const data = next.data as Record<string, unknown> | null;\n  if (data === null || typeof data !== 'object' || !('generator' in data)) return next;\n  const raw = data.generator;\n  const held = shapeGeneratorOf(prev.data);\n  if (held !== null && JSON.stringify(raw) === JSON.stringify(held)) return next;\n  const regenerated = held !== null && isShapeGenerator(raw) && raw.kind === held.kind\n    ? regenerateShape({ pose: next.pose as PathInWorldPose, data: { ...data, generator: held } }, raw)\n    : null;\n  return { ...next, ...(regenerated ?? { data: withoutShapeGenerator(next.data) }) };\n}\n"],"mappings":"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"}

package/dist/features/paths/usePathEdit.js

@@ -1,30 +1,30 @@
 import { rectFromPlane as e } from "../../core/viewport/parallax.js";
-import { createPathEditState as t } from "./pathEditState.js";
-import { liveEditablePath as n } from "./editablePath.js";
+import { liveEditablePath as t } from "./editablePath.js";
+import { createPathEditState as n } from "./pathEditState.js";
 import { createPathEditingOverlayLayer as r } from "./pathEditingOverlayLayer.js";
 import { useState as i } from "react";
 import { useLatest as a } from "@weasel-js/react";
 //#region src/features/paths/usePathEdit.ts
 function o(e) {
-	let n = a(e), [r] = i(() => t({
-		host: () => n.current.host,
-		isAllowed: () => n.current.isAllowed?.() ?? !0,
-		isSelectedNode: (e) => n.current.isSelectedNode(e)
+	let t = a(e), [r] = i(() => n({
+		host: () => t.current.host,
+		isAllowed: () => t.current.isAllowed?.() ?? !0,
+		isSelectedNode: (e) => t.current.isSelectedNode(e)
 	}));
 	return r;
 }
-function s(t, o) {
+function s(n, o) {
 	let s = a(o), [c] = i(() => ({
 		...r({
-			getEditingId: () => t.getEditingId() || null,
-			getPose: (e, t, r) => n(e, s.current.nodeOf(e), t, s.current.planeOfNode(e, r)),
-			getSelectedAnchors: t.getSelectedAnchors,
-			getMarquee: (n) => {
-				let r = t.getMarquee(), i = r ? s.current.planeOfNode(t.getEditingId(), n) : null;
+			getEditingId: () => n.getEditingId() || null,
+			getPose: (e, n, r) => t(e, s.current.nodeOf(e), n, s.current.planeOfNode(e, r)),
+			getSelectedAnchors: n.getSelectedAnchors,
+			getMarquee: (t) => {
+				let r = n.getMarquee(), i = r ? s.current.planeOfNode(n.getEditingId(), t) : null;
 				return r && i ? e(i, r) : r;
 			}
 		}),
-		subscribe: t.subscribe
+		subscribe: n.subscribe
 	}));
 	return c;
 }

package/dist/features/poseRun/usePoseRun.js

@@ -2,59 +2,59 @@ import { useCallback as e, useEffect as t, useMemo as n, useRef as r } from "rea
 import { useLatest as i, useVisibleRaf as a } from "@weasel-js/react";
 //#region src/features/poseRun/usePoseRun.ts
 function o(o) {
-	let s = i(o), c = r(/* @__PURE__ */ new Map()), l = r(null), u = r(!1), d = r(0), f = r(!0), p = a(() => {
-		v();
-	}, {
-		requestFrame: o.requestFrame,
-		cancelFrame: o.cancelFrame
-	}), m = e(() => {
+	let s = i(o), c = r(/* @__PURE__ */ new Map()), l = r(null), u = r(!1), d = r(0), f = r(!0), p = e(() => {
 		let { scene: e } = s.current;
 		return l.current?.scene !== e && (l.current?.hold.drop(), l.current = {
 			scene: e,
 			hold: e.overrides.hold()
 		}), l.current.hold;
-	}, [s]), h = e(() => {
+	}, [s]), m = e(() => {
 		l.current?.hold.drop(), c.current.clear();
-	}, []), g = () => {
+	}, []), h = () => {
 		let e = s.current.scene, t = 0;
 		try {
 			c.current.size > 0 && e.batch(s.current.label ?? "Layout", () => {
 				for (let [n, r] of c.current) e.get(n) === void 0 || e.isLocked(n) || (e.setPose(n, r), t++);
 			});
 		} finally {
-			h();
+			m();
 		}
 		s.current.onCommit?.(t);
-	}, _ = () => {
-		u.current = !1, p.cancel();
-	}, v = () => {
+	}, g = (e) => {
+		u.current = !1, e.cancel();
+	}, _ = (e) => {
 		if (!f.current || !u.current) return;
-		let e = m(), t = e.others(), { poses: n, done: r } = s.current.step({
-			pinned: t,
+		let t = p(), n = t.others(), { poses: r, done: i } = s.current.step({
+			pinned: n,
 			frame: d.current
 		});
 		d.current++, c.current.clear();
-		for (let [e, r] of n) t.has(e) || c.current.set(e, r);
-		if (e.set(c.current), r) {
-			_(), g();
+		for (let [e, t] of r) n.has(e) || c.current.set(e, t);
+		if (t.set(c.current), i) {
+			g(e), h();
 			return;
 		}
-		p.request();
-	};
+		e.request();
+	}, v = a((e, t) => {
+		_(t);
+	}, {
+		requestFrame: o.requestFrame,
+		cancelFrame: o.cancelFrame
+	});
 	return t(() => (f.current = !0, () => {
-		f.current = !1, p.cancel(), h();
-	}), [p, h]), n(() => ({
+		f.current = !1, v.cancel(), m();
+	}), [v, m]), n(() => ({
 		start() {
-			!u.current && f.current && (u.current = !0, d.current = 0, p.request());
+			!u.current && f.current && (u.current = !0, d.current = 0, v.request());
 		},
 		stop() {
-			u.current && (_(), g());
+			u.current && (g(v), h());
 		},
 		cancel() {
-			_(), h();
+			g(v), m();
 		},
 		isRunning: () => u.current
-	}), [p]);
+	}), [v]);
 }
 //#endregion
 export { o as usePoseRun };

package/dist/features/poseRun/usePoseRun.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePoseRun.js","names":["usePoseRun","optsRef","useLatest","opts","previews","useRef","held","running","frame","mounted","loop","useVisibleRaf","holdNow","useCallback","scene","release","commit","moved","id","pose","halt","tick","hold","pinned","poses","done","useEffect","useMemo"],"sources":["../../../src/features/poseRun/usePoseRun.ts"],"sourcesContent":["/**\n * A pose run: poses published per frame, committed once.\n *\n * The frames go to `scene.overrides` — the ephemeral table a drag publishes\n * to — so an edge follows a node the run is moving, and the whole run lands as\n * one undo entry when it settles.\n *\n * **A node another gesture owns is pinned, not driven.** The run publishes\n * through a hold of its own, so an override it did not put there belongs to\n * somebody else — a drag, a resize. It never writes that id, never commits it,\n * and hands it to `step` as pinned so the producer can hold its neighbors\n * against it.\n */\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest, useVisibleRaf } from '@weasel-js/react';\nimport type { NodeId, PoseHold, Scene } from '../../core/scene/types';\n\n/** What a producer is told before it is asked for a frame. */\nexport interface PoseRunCtx<TPose> {\n  /** Nodes another gesture is moving, and the pose each is drawn at. The run\n   *  will not write these, so a producer holds them fixed. */\n  pinned: ReadonlyMap<NodeId, TPose>;\n  /** Frames this run has produced, starting at 0. */\n  frame: number;\n}\n\n/** One frame of a run. */\nexport interface PoseRunStep<TPose> {\n  /** Where the nodes it drives are this frame — the whole picture, not a\n   *  delta. An id the frame omits stops being published, which is how a node\n   *  leaves the run's hands. */\n  poses: Iterable<readonly [NodeId, TPose]>;\n  /** Whether the run is finished. The frame is published either way, and a\n   *  finished run commits. */\n  done: boolean;\n}\n\n/** Options for `usePoseRun`. Read fresh each frame, so they may change mid-run. */\nexport interface UsePoseRunOptions<TPose> {\n  scene: Scene<unknown, string, TPose>;\n  /** Called once per frame while running, for that frame's poses. */\n  step: (ctx: PoseRunCtx<TPose>) => PoseRunStep<TPose>;\n  /** The undo entry's name. Default `'Layout'`. */\n  label?: string;\n  /** How many nodes the commit wrote. Fires after the ops land. */\n  onCommit?: (moved: number) => void;\n  /** Clock injection, for tests. Defaults to `requestAnimationFrame`. */\n  requestFrame?: (cb: (t: number) => void) => number;\n  cancelFrame?: (handle: number) => void;\n}\n\n/** Controls for a pose run. Stable for the life of the component. */\nexport interface PoseRun {\n  /** Begin a new run, counting frames from 0. Idempotent while running. */\n  start(): void;\n  /** Finish now: commit what is published, then drop the overrides. */\n  stop(): void;\n  /** Abandon: drop the overrides and write nothing, like a canceled drag. */\n  cancel(): void;\n  isRunning(): boolean;\n}\n\n/**\n * Drive node poses frame by frame through `scene.overrides`, committing them as\n * one undo entry when `step` reports done or `stop` is called. Idle until\n * `start`; unmounting abandons the run without writing.\n */\nexport function usePoseRun<TPose>(opts: UsePoseRunOptions<TPose>): PoseRun {\n  const optsRef = useLatest(opts);\n\n  /** This frame's poses. */\n  const previews = useRef(new Map<NodeId, TPose>());\n  /** The hold the run publishes through, and the scene it was taken from. */\n  const held = useRef<{ scene: Scene<unknown, string, TPose>; hold: PoseHold<TPose> } | null>(null);\n  const running = useRef(false);\n  const frame = useRef(0);\n  const mounted = useRef(true);\n\n  // The gate defaults an absent clock to `requestAnimationFrame` itself, so\n  // these pass straight through rather than being defaulted twice.\n  const loop = useVisibleRaf(() => { tick(); }, {\n    requestFrame: opts.requestFrame,\n    cancelFrame: opts.cancelFrame,\n  });\n\n  /** The hold on the scene the options name now. A run handed a different\n   *  scene mid-flight lets go of the old one's nodes. */\n  const holdNow = useCallback((): PoseHold<TPose> => {\n    const { scene } = optsRef.current;\n    if (held.current?.scene !== scene) {\n      held.current?.hold.drop();\n      held.current = { scene, hold: scene.overrides.hold() };\n    }\n    return held.current.hold;\n  }, [optsRef]);\n\n  const release = useCallback((): void => {\n    held.current?.hold.drop();\n    previews.current.clear();\n  }, []);\n\n  const commit = (): void => {\n    const scene = optsRef.current.scene;\n    let moved = 0;\n    try {\n      if (previews.current.size > 0) {\n        scene.batch(optsRef.current.label ?? 'Layout', () => {\n          for (const [id, pose] of previews.current) {\n            if (scene.get(id) === undefined || scene.isLocked(id)) continue;\n            scene.setPose(id, pose);\n            moved++;\n          }\n        });\n      }\n    } finally {\n      release();\n    }\n    optsRef.current.onCommit?.(moved);\n  };\n\n  const halt = (): void => {\n    running.current = false;\n    loop.cancel();\n  };\n\n  const tick = (): void => {\n    if (!mounted.current || !running.current) return;\n    const hold = holdNow();\n    const pinned = hold.others();\n    const { poses, done } = optsRef.current.step({ pinned, frame: frame.current });\n    frame.current++;\n    previews.current.clear();\n    for (const [id, pose] of poses) {\n      if (pinned.has(id)) continue;\n      previews.current.set(id, pose);\n    }\n    hold.set(previews.current);\n    if (done) {\n      halt();\n      commit();\n      return;\n    }\n    loop.request();\n  };\n\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n      loop.cancel();\n      // Teardown is not a decision: an unmounted run abandons its frames\n      // rather than writing them.\n      release();\n    };\n  }, [loop, release]);\n\n  return useMemo<PoseRun>(() => ({\n    start() {\n      if (running.current || !mounted.current) return;\n      running.current = true;\n      frame.current = 0;\n      loop.request();\n    },\n    stop() {\n      if (!running.current) return;\n      halt();\n      commit();\n    },\n    cancel() {\n      halt();\n      release();\n    },\n    isRunning: () => running.current,\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }), [loop]);\n}\n"],"mappings":";;;AAmEA,SAAgBA,EAAkB,GAAyC;CACzE,IAAMC,IAAUC,EAAUC,CAAI,GAGxBC,IAAWC,kBAAO,IAAI,IAAmB,CAAC,GAE1CC,IAAOD,EAA+E,IAAI,GAC1FE,IAAUF,EAAO,EAAK,GACtBG,IAAQH,EAAO,CAAC,GAChBI,IAAUJ,EAAO,EAAI,GAIrBK,IAAOC,QAAoB;EAAE,EAAK;CAAG,GAAG;EAC5C,cAAcR,EAAK;EACnB,aAAaA,EAAK;CACpB,CAAC,GAIKS,IAAUC,QAAmC;EACjD,IAAM,EAAE,aAAUZ,EAAQ;EAK1B,OAJIK,EAAK,SAAS,UAAUQ,MAC1BR,EAAK,SAAS,KAAK,KAAK,GACxB,EAAK,UAAU;GAAE;GAAO,MAAMQ,EAAM,UAAU,KAAK;EAAE,IAEhDR,EAAK,QAAQ;CACtB,GAAG,CAACL,CAAO,CAAC,GAENc,IAAUF,QAAwB;EAEtC,AADAP,EAAK,SAAS,KAAK,KAAK,GACxBF,EAAS,QAAQ,MAAM;CACzB,GAAG,CAAC,CAAC,GAECY,UAAqB;EACzB,IAAMF,IAAQb,EAAQ,QAAQ,OAC1BgB,IAAQ;EACZ,IAAI;GACF,AAAIb,EAAS,QAAQ,OAAO,KAC1BU,EAAM,MAAMb,EAAQ,QAAQ,SAAS,gBAAgB;IACnD,KAAK,IAAM,CAACiB,GAAIC,MAASf,EAAS,SAChC,AAAIU,EAAM,IAAII,CAAE,MAAM,KAAA,KAAaJ,EAAM,SAASI,CAAE,MACpDJ,EAAM,QAAQI,GAAIC,CAAI,GACtB;GAEJ,CAAC;EAEL,UAAU;GACR,EAAQ;EACV;EACA,EAAQ,QAAQ,WAAWF,CAAK;CAClC,GAEMG,UAAmB;EAEvB,AADA,EAAQ,UAAU,IAClBV,EAAK,OAAO;CACd,GAEMW,UAAmB;EACvB,IAAI,CAACZ,EAAQ,WAAW,CAACF,EAAQ,SAAS;EAC1C,IAAMe,IAAOV,EAAQ,GACfW,IAASD,EAAK,OAAO,GACrB,EAAE,UAAO,YAASrB,EAAQ,QAAQ,KAAK;GAAE;GAAQ,OAAOO,EAAM;EAAQ,CAAC;EAE7E,AADA,EAAM,WACNJ,EAAS,QAAQ,MAAM;EACvB,KAAK,IAAM,CAACc,GAAIC,MAASK,GACvB,AAAID,EAAO,IAAIL,CAAE,KACjBd,EAAS,QAAQ,IAAIc,GAAIC,CAAI;EAG/B,IADAG,EAAK,IAAIlB,EAAS,OAAO,GACrBqB,GAAM;GAER,AADAL,EAAK,GACLJ,EAAO;GACP;EACF;EACA,EAAK,QAAQ;CACf;CAaA,OAXAU,SACE,EAAQ,UAAU,UACL;EAKX,AAJA,EAAQ,UAAU,IAClBhB,EAAK,OAAO,GAGZK,EAAQ;CACV,IACC,CAACL,GAAMK,CAAO,CAAC,GAEXY,SAAwB;EAC7B,QAAQ;GACN,AAAI,GAAQ,WAAYlB,EAAQ,YAChC,EAAQ,UAAU,IAClB,EAAM,UAAU,GAChBC,EAAK,QAAQ;EACf;EACA,OAAO;GACL,AAAKH,EAAQ,YACba,EAAK,GACLJ,EAAO;EACT;EACA,SAAS;GAEP,AADAI,EAAK,GACLL,EAAQ;EACV;EACA,iBAAiBR,EAAQ;CAE3B,IAAI,CAACG,CAAI,CAAC;AACZ"}
+{"version":3,"file":"usePoseRun.js","names":["usePoseRun","optsRef","useLatest","opts","previews","useRef","held","running","frame","mounted","holdNow","useCallback","scene","release","commit","moved","id","pose","halt","loop","tick","hold","pinned","poses","done","useVisibleRaf","useEffect","useMemo"],"sources":["../../../src/features/poseRun/usePoseRun.ts"],"sourcesContent":["/**\n * A pose run: poses published per frame, committed once.\n *\n * The frames go to `scene.overrides` — the ephemeral table a drag publishes\n * to — so an edge follows a node the run is moving, and the whole run lands as\n * one undo entry when it settles.\n *\n * **A node another gesture owns is pinned, not driven.** The run publishes\n * through a hold of its own, so an override it did not put there belongs to\n * somebody else — a drag, a resize. It never writes that id, never commits it,\n * and hands it to `step` as pinned so the producer can hold its neighbors\n * against it.\n */\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest, useVisibleRaf, type VisibleRaf } from '@weasel-js/react';\nimport type { NodeId, PoseHold, Scene } from '../../core/scene/types';\n\n/** What a producer is told before it is asked for a frame. */\nexport interface PoseRunCtx<TPose> {\n  /** Nodes another gesture is moving, and the pose each is drawn at. The run\n   *  will not write these, so a producer holds them fixed. */\n  pinned: ReadonlyMap<NodeId, TPose>;\n  /** Frames this run has produced, starting at 0. */\n  frame: number;\n}\n\n/** One frame of a run. */\nexport interface PoseRunStep<TPose> {\n  /** Where the nodes it drives are this frame — the whole picture, not a\n   *  delta. An id the frame omits stops being published, which is how a node\n   *  leaves the run's hands. */\n  poses: Iterable<readonly [NodeId, TPose]>;\n  /** Whether the run is finished. The frame is published either way, and a\n   *  finished run commits. */\n  done: boolean;\n}\n\n/** Options for `usePoseRun`. Read fresh each frame, so they may change mid-run. */\nexport interface UsePoseRunOptions<TPose> {\n  scene: Scene<unknown, string, TPose>;\n  /** Called once per frame while running, for that frame's poses. */\n  step: (ctx: PoseRunCtx<TPose>) => PoseRunStep<TPose>;\n  /** The undo entry's name. Default `'Layout'`. */\n  label?: string;\n  /** How many nodes the commit wrote. Fires after the ops land. */\n  onCommit?: (moved: number) => void;\n  /** Clock injection, for tests. Defaults to `requestAnimationFrame`. */\n  requestFrame?: (cb: (t: number) => void) => number;\n  cancelFrame?: (handle: number) => void;\n}\n\n/** Controls for a pose run. Stable for the life of the component. */\nexport interface PoseRun {\n  /** Begin a new run, counting frames from 0. Idempotent while running. */\n  start(): void;\n  /** Finish now: commit what is published, then drop the overrides. */\n  stop(): void;\n  /** Abandon: drop the overrides and write nothing, like a canceled drag. */\n  cancel(): void;\n  isRunning(): boolean;\n}\n\n/**\n * Drive node poses frame by frame through `scene.overrides`, committing them as\n * one undo entry when `step` reports done or `stop` is called. Idle until\n * `start`; unmounting abandons the run without writing.\n */\nexport function usePoseRun<TPose>(opts: UsePoseRunOptions<TPose>): PoseRun {\n  const optsRef = useLatest(opts);\n\n  /** This frame's poses. */\n  const previews = useRef(new Map<NodeId, TPose>());\n  /** The hold the run publishes through, and the scene it was taken from. */\n  const held = useRef<{ scene: Scene<unknown, string, TPose>; hold: PoseHold<TPose> } | null>(null);\n  const running = useRef(false);\n  const frame = useRef(0);\n  const mounted = useRef(true);\n\n  /** The hold on the scene the options name now. A run handed a different\n   *  scene mid-flight lets go of the old one's nodes. */\n  const holdNow = useCallback((): PoseHold<TPose> => {\n    const { scene } = optsRef.current;\n    if (held.current?.scene !== scene) {\n      held.current?.hold.drop();\n      held.current = { scene, hold: scene.overrides.hold() };\n    }\n    return held.current.hold;\n  }, [optsRef]);\n\n  const release = useCallback((): void => {\n    held.current?.hold.drop();\n    previews.current.clear();\n  }, []);\n\n  const commit = (): void => {\n    const scene = optsRef.current.scene;\n    let moved = 0;\n    try {\n      if (previews.current.size > 0) {\n        scene.batch(optsRef.current.label ?? 'Layout', () => {\n          for (const [id, pose] of previews.current) {\n            if (scene.get(id) === undefined || scene.isLocked(id)) continue;\n            scene.setPose(id, pose);\n            moved++;\n          }\n        });\n      }\n    } finally {\n      release();\n    }\n    optsRef.current.onCommit?.(moved);\n  };\n\n  const halt = (loop: VisibleRaf): void => {\n    running.current = false;\n    loop.cancel();\n  };\n\n  const tick = (loop: VisibleRaf): void => {\n    if (!mounted.current || !running.current) return;\n    const hold = holdNow();\n    const pinned = hold.others();\n    const { poses, done } = optsRef.current.step({ pinned, frame: frame.current });\n    frame.current++;\n    previews.current.clear();\n    for (const [id, pose] of poses) {\n      if (pinned.has(id)) continue;\n      previews.current.set(id, pose);\n    }\n    hold.set(previews.current);\n    if (done) {\n      halt(loop);\n      commit();\n      return;\n    }\n    loop.request();\n  };\n\n  // The gate defaults an absent clock to `requestAnimationFrame` itself, so\n  // these pass straight through rather than being defaulted twice.\n  const loop = useVisibleRaf((_time, loop) => { tick(loop); }, {\n    requestFrame: opts.requestFrame,\n    cancelFrame: opts.cancelFrame,\n  });\n\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n      loop.cancel();\n      // Teardown is not a decision: an unmounted run abandons its frames\n      // rather than writing them.\n      release();\n    };\n  }, [loop, release]);\n\n  return useMemo<PoseRun>(() => ({\n    start() {\n      if (running.current || !mounted.current) return;\n      running.current = true;\n      frame.current = 0;\n      loop.request();\n    },\n    stop() {\n      if (!running.current) return;\n      halt(loop);\n      commit();\n    },\n    cancel() {\n      halt(loop);\n      release();\n    },\n    isRunning: () => running.current,\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }), [loop]);\n}\n"],"mappings":";;;AAmEA,SAAgBA,EAAkB,GAAyC;CACzE,IAAMC,IAAUC,EAAUC,CAAI,GAGxBC,IAAWC,kBAAO,IAAI,IAAmB,CAAC,GAE1CC,IAAOD,EAA+E,IAAI,GAC1FE,IAAUF,EAAO,EAAK,GACtBG,IAAQH,EAAO,CAAC,GAChBI,IAAUJ,EAAO,EAAI,GAIrBK,IAAUC,QAAmC;EACjD,IAAM,EAAE,aAAUV,EAAQ;EAK1B,OAJIK,EAAK,SAAS,UAAUM,MAC1BN,EAAK,SAAS,KAAK,KAAK,GACxB,EAAK,UAAU;GAAE;GAAO,MAAMM,EAAM,UAAU,KAAK;EAAE,IAEhDN,EAAK,QAAQ;CACtB,GAAG,CAACL,CAAO,CAAC,GAENY,IAAUF,QAAwB;EAEtC,AADAL,EAAK,SAAS,KAAK,KAAK,GACxBF,EAAS,QAAQ,MAAM;CACzB,GAAG,CAAC,CAAC,GAECU,UAAqB;EACzB,IAAMF,IAAQX,EAAQ,QAAQ,OAC1Bc,IAAQ;EACZ,IAAI;GACF,AAAIX,EAAS,QAAQ,OAAO,KAC1BQ,EAAM,MAAMX,EAAQ,QAAQ,SAAS,gBAAgB;IACnD,KAAK,IAAM,CAACe,GAAIC,MAASb,EAAS,SAChC,AAAIQ,EAAM,IAAII,CAAE,MAAM,KAAA,KAAaJ,EAAM,SAASI,CAAE,MACpDJ,EAAM,QAAQI,GAAIC,CAAI,GACtB;GAEJ,CAAC;EAEL,UAAU;GACR,EAAQ;EACV;EACA,EAAQ,QAAQ,WAAWF,CAAK;CAClC,GAEMG,KAAQ,MAA2B;EAEvC,AADA,EAAQ,UAAU,IAClBC,EAAK,OAAO;CACd,GAEMC,KAAQ,MAA2B;EACvC,IAAI,CAACX,EAAQ,WAAW,CAACF,EAAQ,SAAS;EAC1C,IAAMc,IAAOX,EAAQ,GACfY,IAASD,EAAK,OAAO,GACrB,EAAE,UAAO,YAASpB,EAAQ,QAAQ,KAAK;GAAE;GAAQ,OAAOO,EAAM;EAAQ,CAAC;EAE7E,AADA,EAAM,WACNJ,EAAS,QAAQ,MAAM;EACvB,KAAK,IAAM,CAACY,GAAIC,MAASM,GACvB,AAAID,EAAO,IAAIN,CAAE,KACjBZ,EAAS,QAAQ,IAAIY,GAAIC,CAAI;EAG/B,IADAI,EAAK,IAAIjB,EAAS,OAAO,GACrBoB,GAAM;GAER,AADAN,EAAKC,CAAI,GACTL,EAAO;GACP;EACF;EACA,EAAK,QAAQ;CACf,GAIMK,IAAOM,GAAe,GAAO,MAAS;EAAE,EAAKN,CAAI;CAAG,GAAG;EAC3D,cAAchB,EAAK;EACnB,aAAaA,EAAK;CACpB,CAAC;CAaD,OAXAuB,SACE,EAAQ,UAAU,UACL;EAKX,AAJA,EAAQ,UAAU,IAClBP,EAAK,OAAO,GAGZN,EAAQ;CACV,IACC,CAACM,GAAMN,CAAO,CAAC,GAEXc,SAAwB;EAC7B,QAAQ;GACN,AAAI,GAAQ,WAAYlB,EAAQ,YAChC,EAAQ,UAAU,IAClB,EAAM,UAAU,GAChBU,EAAK,QAAQ;EACf;EACA,OAAO;GACL,AAAKZ,EAAQ,YACbW,EAAKC,CAAI,GACTL,EAAO;EACT;EACA,SAAS;GAEP,AADAI,EAAKC,CAAI,GACTN,EAAQ;EACV;EACA,iBAAiBN,EAAQ;CAE3B,IAAI,CAACY,CAAI,CAAC;AACZ"}