@weasel-js/core 1.10.0 → 1.11.0

package/dist/features/paths/shapeGenerator.js

@@ -0,0 +1,141 @@
+import { boundsOfPath, boxToBox, poseFrameOf, regularPolygonPath, starPath, transformPath, worldEditToStorage } from "@weasel-js/geom";
+
+//#region src/features/paths/shapeGenerator.ts
+/**
+* The parameters a polygon or star was drawn with, kept on the node beside the
+* geometry they made (`data.generator` beside `data.path`), so the shape stays
+* editable as a polygon or a star after it is drawn.
+*
+* `data.path` stays the geometry every reader uses; the generator only says how
+* to make it again. Editing the path itself turns the shape into plain
+* geometry: the generator is dropped, since it could no longer reproduce what
+* is drawn. A generator whose path no longer matches it (a writer that changed
+* the path without dropping it) is treated the same way.
+*/
+/** The range of a polygon's side count and a star's point count. */
+var SHAPE_COUNT_RANGE = {
+	min: 3,
+	max: 32
+};
+/** The range of a star's `innerRadiusRatio`. */
+var STAR_RATIO_RANGE = {
+	min: .01,
+	max: 1
+};
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+/** Whether `v` is a well-formed {@link ShapeGenerator}. */
+function isShapeGenerator(v) {
+	if (v === null || typeof v !== "object") return false;
+	const g = v;
+	if (!finite(g.rotation)) return false;
+	if (g.kind === "polygon") return finite(g.sides);
+	if (g.kind === "star") return finite(g.points) && finite(g.innerRadiusRatio);
+	return false;
+}
+/** The generator a node's `data` holds, or `null`. */
+function shapeGeneratorOf(data) {
+	const g = data?.generator;
+	return isShapeGenerator(g) ? g : null;
+}
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var count = (v) => clamp(Math.round(v), SHAPE_COUNT_RANGE.min, SHAPE_COUNT_RANGE.max);
+/** `g` with its counts rounded and every field held in range. */
+function clampShapeGenerator(g) {
+	if (g.kind === "polygon") return {
+		kind: "polygon",
+		sides: count(g.sides),
+		rotation: g.rotation
+	};
+	return {
+		kind: "star",
+		points: count(g.points),
+		innerRadiusRatio: clamp(g.innerRadiusRatio, STAR_RATIO_RANGE.min, STAR_RATIO_RANGE.max),
+		rotation: g.rotation
+	};
+}
+/** The shape `g` makes, on a circle of `radius` around `center`. */
+function shapeGeneratorPath(g, center = {
+	x: 0,
+	y: 0
+}, radius = 1) {
+	const c = clampShapeGenerator(g);
+	return c.kind === "polygon" ? regularPolygonPath(center, radius, c.sides, c.rotation) : starPath(center, radius, c.points, radius * c.innerRadiusRatio, c.rotation);
+}
+/** `data` without its generator: the shape as plain geometry. */
+function withoutShapeGenerator(data) {
+	if (data === null || typeof data !== "object" || !("generator" in data)) return data;
+	const { generator: _dropped, ...rest } = data;
+	return rest;
+}
+/** Whether `path` is what `g` makes, up to the box-to-box map storage applies. */
+function pathMatches(path, g) {
+	const p = path;
+	if (p?.kind !== "polygon") return false;
+	const unit = shapeGeneratorPath(g);
+	if (p.coords.length !== unit.coords.length) return false;
+	const u = boundsOfPath(unit);
+	const b = boundsOfPath(p);
+	const m = boxToBox(u.x, u.y, u.width, u.height, b.x, b.y, b.width, b.height);
+	const tol = 1e-4 * Math.max(1, Math.abs(b.x) + b.width, Math.abs(b.y) + b.height);
+	for (let i = 0; i + 1 < unit.coords.length; i += 2) {
+		const x = m[0] * unit.coords[i] + m[4];
+		const y = m[3] * unit.coords[i + 1] + m[5];
+		if (Math.abs(x - p.coords[i]) > tol || Math.abs(y - p.coords[i + 1]) > tol) return false;
+	}
+	return true;
+}
+/**
+* `node` made again from `next`, in place: the new shape takes the box the old
+* one's circle had, under the same rotation and transform, so a star given
+* more points keeps its center and its size. Returns `null` when the node holds
+* no generator, or its path no longer matches the one it holds.
+*/
+function regenerateShape(node, next) {
+	const held = shapeGeneratorOf(node.data);
+	if (!held || !pathMatches(node.data.path, held)) return null;
+	const g = clampShapeGenerator(next);
+	const was = boundsOfPath(shapeGeneratorPath(held));
+	const { pose } = node;
+	const toLocal = boxToBox(was.x, was.y, was.width, was.height, pose.x, pose.y, pose.width, pose.height);
+	const local = transformPath(shapeGeneratorPath(g), toLocal);
+	const frame = poseFrameOf(pose);
+	const world = frame ? transformPath(local, frame) : local;
+	const stored = worldEditToStorage(pose, world);
+	return {
+		pose: stored.pose,
+		data: {
+			...node.data,
+			path: stored.path,
+			generator: g
+		}
+	};
+}
+/**
+* What a write that left a node as `next`, from `prev`, stores: when the write
+* changed the generator, the shape made again from it. A generator written
+* onto a node that held none, or of another kind, or onto one whose path no
+* longer matches, is dropped, leaving the shape as plain geometry. Any other
+* write is stored as written. Fits `NodePropertiesEntry.settle`.
+*/
+function settleShapeGenerator(next, prev) {
+	const data = next.data;
+	if (data === null || typeof data !== "object" || !("generator" in data)) return next;
+	const raw = data.generator;
+	const held = shapeGeneratorOf(prev.data);
+	if (held !== null && JSON.stringify(raw) === JSON.stringify(held)) return next;
+	const regenerated = held !== null && isShapeGenerator(raw) && raw.kind === held.kind ? regenerateShape({
+		pose: next.pose,
+		data: {
+			...data,
+			generator: held
+		}
+	}, raw) : null;
+	return {
+		...next,
+		...regenerated ?? { data: withoutShapeGenerator(next.data) }
+	};
+}
+
+//#endregion
+export { SHAPE_COUNT_RANGE, STAR_RATIO_RANGE, clampShapeGenerator, isShapeGenerator, regenerateShape, settleShapeGenerator, shapeGeneratorOf, shapeGeneratorPath, withoutShapeGenerator };
+//# sourceMappingURL=shapeGenerator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shapeGenerator.js","names":[],"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/strokeOutline.js

@@ -0,0 +1,15 @@
+import { findShapeSilhouette } from "../../canvas/NodeShape.js";
+import { isSilhouettePose } from "../../core/geometry/regionHit.js";
+
+//#region src/features/paths/strokeOutline.ts
+/** The outline `node` is drawn with, in world coords: its pose when the pose
+*  is a polygon, else its painter's silhouette. Null for a node with neither. */
+function nodeOutline(node) {
+	const pose = node.pose;
+	if (isSilhouettePose(pose)) return pose;
+	return findShapeSilhouette(node, pose);
+}
+
+//#endregion
+export { nodeOutline };
+//# sourceMappingURL=strokeOutline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strokeOutline.js","names":[],"sources":["../../../src/features/paths/strokeOutline.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { isSilhouettePose } from 'core/geometry/regionHit';\nimport type { Node } from 'core/scene/types';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\n\n/** The outline `node` is drawn with, in world coords: its pose when the pose\n *  is a polygon, else its painter's silhouette. Null for a node with neither. */\nexport function nodeOutline(node: Node<unknown, string, unknown>): Path | null {\n  const pose = node.pose;\n  if (isSilhouettePose(pose)) return pose;\n  return findShapeSilhouette(node, pose);\n}\n"],"mappings":";;;;;;AAOA,SAAgB,YAAY,MAAmD;CAC7E,MAAM,OAAO,KAAK;CAClB,IAAI,iBAAiB,IAAI,GAAG,OAAO;CACnC,OAAO,oBAAoB,MAAM,IAAI;AACvC"}

package/dist/features/paths/useAnchorFields.js

@@ -0,0 +1,35 @@
+import { anchorFieldsOf } from "../../interactions/actions/defaults/anchorFields.js";
+import { useMemo, useSyncExternalStore } from "react";
+import { useActionsRegistry, useOptionalDepRegistry } from "@weasel-js/routing/react";
+
+//#region src/features/paths/useAnchorFields.ts
+/**
+* The anchor fields of the path being edited, for chrome beside the canvas:
+* a panel showing the selected anchors' numbers and writing typed ones back.
+*/
+var noSubscribe = () => () => {};
+/**
+* The selected anchors' fields in the canvas in scope — the one last pressed
+* in, from chrome above several — kept current as the path, the anchor
+* selection, or the edited path changes. Outside any canvas it answers `{}`
+* and writes nothing.
+*/
+function useAnchorFields() {
+	const deps = useOptionalDepRegistry();
+	const actions = useActionsRegistry();
+	const snapshot = () => JSON.stringify(anchorFieldsOf(deps ? { editAnchors: deps.get("editAnchors") } : void 0));
+	const json = useSyncExternalStore(deps?.subscribe ?? noSubscribe, snapshot, snapshot);
+	return useMemo(() => ({
+		values: JSON.parse(json),
+		write: (field, entry) => {
+			actions?.trigger("setAnchorField", {
+				field,
+				...entry
+			});
+		}
+	}), [json, actions]);
+}
+
+//#endregion
+export { useAnchorFields };
+//# sourceMappingURL=useAnchorFields.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAnchorFields.js","names":[],"sources":["../../../src/features/paths/useAnchorFields.ts"],"sourcesContent":["/**\n * The anchor fields of the path being edited, for chrome beside the canvas:\n * a panel showing the selected anchors' numbers and writing typed ones back.\n */\nimport { useMemo, useSyncExternalStore } from 'react';\nimport type { AnchorField, AnchorFieldValues, NumberEntry } from '@weasel-js/geom';\nimport { useActionsRegistry, useOptionalDepRegistry } from '@weasel-js/routing/react';\nimport { anchorFieldsOf } from 'interactions/actions/defaults/anchorFields';\n\n/** What {@link useAnchorFields} answers. */\nexport interface AnchorFieldsApi {\n  /** Each field's value: a number, `null` where the selected anchors differ,\n   *  no key where the field does not apply. Empty outside path edit or with no\n   *  anchor selected. */\n  values: AnchorFieldValues;\n  /** Write `entry` into `field` of every selected anchor, as one undo step,\n   *  through the `setAnchorField` action. */\n  write(field: AnchorField, entry: NumberEntry): void;\n}\n\nconst noSubscribe = (): (() => void) => () => {};\n\n/**\n * The selected anchors' fields in the canvas in scope — the one last pressed\n * in, from chrome above several — kept current as the path, the anchor\n * selection, or the edited path changes. Outside any canvas it answers `{}`\n * and writes nothing.\n */\nexport function useAnchorFields(): AnchorFieldsApi {\n  const deps = useOptionalDepRegistry();\n  const actions = useActionsRegistry();\n  const snapshot = (): string => JSON.stringify(anchorFieldsOf(deps ? { editAnchors: deps.get('editAnchors') } : undefined));\n  const json = useSyncExternalStore(deps?.subscribe ?? noSubscribe, snapshot, snapshot);\n  return useMemo(() => ({\n    values: JSON.parse(json) as AnchorFieldValues,\n    write: (field, entry) => { actions?.trigger('setAnchorField', { field, ...entry }); },\n  }), [json, actions]);\n}\n"],"mappings":";;;;;;;;;AAoBA,IAAM,0BAAwC,CAAC;;;;;;;AAQ/C,SAAgB,kBAAmC;CACjD,MAAM,OAAO,uBAAuB;CACpC,MAAM,UAAU,mBAAmB;CACnC,MAAM,iBAAyB,KAAK,UAAU,eAAe,OAAO,EAAE,aAAa,KAAK,IAAI,aAAa,EAAE,IAAI,MAAS,CAAC;CACzH,MAAM,OAAO,qBAAqB,MAAM,aAAa,aAAa,UAAU,QAAQ;CACpF,OAAO,eAAe;EACpB,QAAQ,KAAK,MAAM,IAAI;EACvB,QAAQ,OAAO,UAAU;GAAE,SAAS,QAAQ,kBAAkB;IAAE;IAAO,GAAG;GAAM,CAAC;EAAG;CACtF,IAAI,CAAC,MAAM,OAAO,CAAC;AACrB"}

package/dist/features/paths/usePathEdit.js

@@ -1,34 +1,64 @@
-import { rectFromPlane as e } from "../../core/viewport/parallax.js";
-import { createPathEditState as t } from "./pathEditState.js";
-import { liveEditablePath as n } from "./editablePath.js";
-import { createPathEditingOverlayLayer as r } from "./pathEditingOverlayLayer.js";
-import { useState as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
+import { rectFromPlane } from "../../core/viewport/parallax.js";
+import { liveAnchorMarkers, liveEditablePath } from "./editablePath.js";
+import { createPathEditState } from "./pathEditState.js";
+import { createPathEditingOverlayLayer } from "./pathEditingOverlayLayer.js";
+import { useEffect, useMemo, useState } from "react";
+import { useLatest } 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)
-	}));
-	return r;
+/**
+* The path-edit state and its anchor overlay for one canvas surface.
+*/
+/** One state object for the life of the component, answering from the
+*  options of the last committed render. */
+function usePathEditState(options) {
+	const live = useLatest(options);
+	const [state] = useState(() => {
+		const made = createPathEditState({
+			host: () => live.current.host,
+			isAllowed: () => live.current.isAllowed?.() ?? true,
+			isSelectedNode: (id) => live.current.isSelectedNode(id),
+			extensions: options.extensions
+		});
+		const { opening } = options;
+		if (opening) {
+			made.setEditingId(opening.id);
+			made.setSelectedAnchors(new Set(opening.anchors ?? []));
+		}
+		return made;
+	});
+	useEffect(() => state.setExtensions(options.extensions), [state, options.extensions]);
+	return state;
 }
-function s(t, 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;
-				return r && i ? e(i, r) : r;
-			}
+/** The anchor overlay for `state`, drawn as `config` says. Rebuilt when
+*  `config` changes, so pass a stable one; otherwise it reads `inputs` as of
+*  the last commit and repaints itself when the state changes. */
+function usePathEditOverlayLayer(state, inputs, config) {
+	const live = useLatest(inputs);
+	return useMemo(() => ({
+		...createPathEditingOverlayLayer({
+			getEditingId: () => state.getEditingId() || null,
+			getPose: (id, previews, view) => liveEditablePath(id, live.current.nodeOf(id), previews, live.current.planeOfNode(id, view), state.getExtensions()),
+			getAnchorMarkers: (id, previews) => liveAnchorMarkers(id, live.current.nodeOf(id), previews, state.getExtensions()),
+			getSelectedAnchors: state.getSelectedAnchors,
+			getSelectedMark: state.getSelectedMark,
+			getExtensions: state.getExtensions,
+			getNode: (id) => live.current.nodeOf(id) ?? null,
+			getMarquee: (view) => {
+				const rect = state.getMarquee();
+				const plane = rect ? live.current.planeOfNode(state.getEditingId(), view) : null;
+				return rect && plane ? rectFromPlane(plane, rect) : rect;
+			},
+			...config?.style ? { style: config.style } : {}
 		}),
-		subscribe: t.subscribe
-	}));
-	return c;
+		subscribe: state.subscribe
+	}), [
+		state,
+		live,
+		config
+	]);
 }
-//#endregion
-export { s as usePathEditOverlayLayer, o as usePathEditState };
 
+//#endregion
+export { usePathEditOverlayLayer, usePathEditState };
 //# sourceMappingURL=usePathEdit.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePathEdit.js","names":["usePathEditState","live","useLatest","options","state","useState","createPathEditState","id","usePathEditOverlayLayer","inputs","layer","createPathEditingOverlayLayer","liveEditablePath","previews","view","rect","plane","rectFromPlane"],"sources":["../../../src/features/paths/usePathEdit.ts"],"sourcesContent":["/**\n * The path-edit state and its anchor overlay for one canvas surface.\n */\nimport { useLatest } from '@weasel-js/react';\nimport { useState } from 'react';\nimport type { PathEditHost } from 'canvas/SceneCanvas/pathEditHost';\nimport type { RenderLayer } from 'core/layers/render';\nimport { rectFromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { liveEditablePath, type EditableShape } from './editablePath';\nimport { createPathEditingOverlayLayer } from './pathEditingOverlayLayer';\nimport { createPathEditState, type PathEditState } from './pathEditState';\n\nexport interface UsePathEditStateOptions {\n  /** `<SceneCanvas pathEdit>`. */\n  host: PathEditHost | undefined;\n  /** See `PathEditSource.isAllowed`; absent when no mode registry is wired. */\n  isAllowed: (() => boolean) | undefined;\n  isSelectedNode: (id: string) => boolean;\n}\n\n/** One state object for the life of the component, answering from the\n *  options of the last committed render. */\nexport function usePathEditState(options: UsePathEditStateOptions): PathEditState {\n  const live = useLatest(options);\n  const [state] = useState(() => createPathEditState({\n    host: () => live.current.host,\n    isAllowed: () => live.current.isAllowed?.() ?? true,\n    isSelectedNode: (id) => live.current.isSelectedNode(id),\n  }));\n  return state;\n}\n\nexport interface PathEditOverlayInputs {\n  /** The committed node for an id, or nothing once it is gone. */\n  nodeOf: (id: string) => EditableShape | null | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through. */\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n}\n\n/** The anchor overlay for `state`. Built once: it reads `inputs` as of the\n *  last commit and repaints itself when the state changes. */\nexport function usePathEditOverlayLayer(\n  state: PathEditState,\n  inputs: PathEditOverlayInputs,\n): RenderLayer<unknown> {\n  const live = useLatest(inputs);\n  const [layer] = useState<RenderLayer<unknown>>(() => ({\n    ...createPathEditingOverlayLayer({\n      getEditingId: () => state.getEditingId() || null,\n      getPose: (id, previews, view) =>\n        liveEditablePath(id, live.current.nodeOf(id), previews, live.current.planeOfNode(id, view)),\n      getSelectedAnchors: state.getSelectedAnchors,\n      // Drawn by an action that ran in the edited path's plane.\n      getMarquee: (view) => {\n        const rect = state.getMarquee();\n        const plane = rect ? live.current.planeOfNode(state.getEditingId(), view) : null;\n        return rect && plane ? rectFromPlane(plane, rect) : rect;\n      },\n    }),\n    subscribe: state.subscribe,\n  }));\n  return layer;\n}\n"],"mappings":";;;;;;;AAuBA,SAAgBA,EAAiB,GAAiD;CAChF,IAAMC,IAAOC,EAAUC,CAAO,GACxB,CAACC,KAASC,QAAeC,EAAoB;EACjD,YAAYL,EAAK,QAAQ;EACzB,iBAAiBA,EAAK,QAAQ,YAAY,KAAK;EAC/C,iBAAiB,MAAOA,EAAK,QAAQ,eAAeM,CAAE;CACxD,CAAC,CAAC;CACF,OAAOH;AACT;AAWA,SAAgBI,EACd,GACA,GACsB;CACtB,IAAMP,IAAOC,EAAUO,CAAM,GACvB,CAACC,KAASL,SAAsC;EACpD,GAAGM,EAA8B;GAC/B,oBAAoBP,EAAM,aAAa,KAAK;GAC5C,UAAU,GAAI,GAAU,MACtBQ,EAAiBL,GAAIN,EAAK,QAAQ,OAAOM,CAAE,GAAGM,GAAUZ,EAAK,QAAQ,YAAYM,GAAIO,CAAI,CAAC;GAC5F,oBAAoBV,EAAM;GAE1B,aAAa,MAAS;IACpB,IAAMW,IAAOX,EAAM,WAAW,GACxBY,IAAQD,IAAOd,EAAK,QAAQ,YAAYG,EAAM,aAAa,GAAGU,CAAI,IAAI;IAC5E,OAAOC,KAAQC,IAAQC,EAAcD,GAAOD,CAAI,IAAIA;GACtD;EACF,CAAC;EACD,WAAWX,EAAM;CACnB,EAAE;CACF,OAAOM;AACT"}
+{"version":3,"file":"usePathEdit.js","names":[],"sources":["../../../src/features/paths/usePathEdit.ts"],"sourcesContent":["/**\n * The path-edit state and its anchor overlay for one canvas surface.\n */\nimport { useLatest } from '@weasel-js/react';\nimport { useEffect, useMemo, useState } from 'react';\nimport type { PathEditHost, PathEditOpening } from 'canvas/SceneCanvas/pathEditHost';\nimport type { RenderLayer } from 'core/layers/render';\nimport { rectFromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { liveAnchorMarkers, liveEditablePath, type EditableShape } from './editablePath';\nimport { createPathEditingOverlayLayer } from './pathEditingOverlayLayer';\nimport type { PathEditingOverlaySlotConfig } from 'canvas/layerSlots';\nimport { createPathEditState, type PathEditState } from './pathEditState';\nimport type { PathEditExtension } from './pathEditExtension';\n\nexport interface UsePathEditStateOptions {\n  /** `<SceneCanvas pathEdit>`. */\n  host: PathEditHost | undefined;\n  /** `<SceneCanvas defaultPathEdit>`: what the state starts holding. */\n  opening?: PathEditOpening;\n  /** See `PathEditSource.isAllowed`; absent when no mode registry is wired. */\n  isAllowed: (() => boolean) | undefined;\n  isSelectedNode: (id: string) => boolean;\n  /** The path-edit extensions the canvas's presets bring. */\n  extensions: readonly PathEditExtension[];\n}\n\n/** One state object for the life of the component, answering from the\n *  options of the last committed render. */\nexport function usePathEditState(options: UsePathEditStateOptions): PathEditState {\n  const live = useLatest(options);\n  const [state] = useState(() => {\n    const made = createPathEditState({\n      host: () => live.current.host,\n      isAllowed: () => live.current.isAllowed?.() ?? true,\n      isSelectedNode: (id) => live.current.isSelectedNode(id),\n      extensions: options.extensions,\n    });\n    const { opening } = options;\n    if (opening) {\n      made.setEditingId(opening.id);\n      made.setSelectedAnchors(new Set(opening.anchors ?? []));\n    }\n    return made;\n  });\n  useEffect(() => state.setExtensions(options.extensions), [state, options.extensions]);\n  return state;\n}\n\nexport interface PathEditOverlayInputs {\n  /** The committed node for an id, or nothing once it is gone. */\n  nodeOf: (id: string) => EditableShape | null | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through. */\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n}\n\n/** The anchor overlay for `state`, drawn as `config` says. Rebuilt when\n *  `config` changes, so pass a stable one; otherwise it reads `inputs` as of\n *  the last commit and repaints itself when the state changes. */\nexport function usePathEditOverlayLayer(\n  state: PathEditState,\n  inputs: PathEditOverlayInputs,\n  config?: PathEditingOverlaySlotConfig,\n): RenderLayer<unknown> {\n  const live = useLatest(inputs);\n  return useMemo<RenderLayer<unknown>>(() => ({\n    ...createPathEditingOverlayLayer({\n      getEditingId: () => state.getEditingId() || null,\n      getPose: (id, previews, view) =>\n        liveEditablePath(id, live.current.nodeOf(id), previews, live.current.planeOfNode(id, view), state.getExtensions()),\n      getAnchorMarkers: (id, previews) => liveAnchorMarkers(id, live.current.nodeOf(id), previews, state.getExtensions()),\n      getSelectedAnchors: state.getSelectedAnchors,\n      getSelectedMark: state.getSelectedMark,\n      getExtensions: state.getExtensions,\n      getNode: (id) => live.current.nodeOf(id) ?? null,\n      // Drawn by an action that ran in the edited path's plane.\n      getMarquee: (view) => {\n        const rect = state.getMarquee();\n        const plane = rect ? live.current.planeOfNode(state.getEditingId(), view) : null;\n        return rect && plane ? rectFromPlane(plane, rect) : rect;\n      },\n      ...(config?.style ? { style: config.style } : {}),\n    }),\n    subscribe: state.subscribe,\n  }), [state, live, config]);\n}\n"],"mappings":";;;;;;;;;;;;;AA6BA,SAAgB,iBAAiB,SAAiD;CAChF,MAAM,OAAO,UAAU,OAAO;CAC9B,MAAM,CAAC,SAAS,eAAe;EAC7B,MAAM,OAAO,oBAAoB;GAC/B,YAAY,KAAK,QAAQ;GACzB,iBAAiB,KAAK,QAAQ,YAAY,KAAK;GAC/C,iBAAiB,OAAO,KAAK,QAAQ,eAAe,EAAE;GACtD,YAAY,QAAQ;EACtB,CAAC;EACD,MAAM,EAAE,YAAY;EACpB,IAAI,SAAS;GACX,KAAK,aAAa,QAAQ,EAAE;GAC5B,KAAK,mBAAmB,IAAI,IAAI,QAAQ,WAAW,CAAC,CAAC,CAAC;EACxD;EACA,OAAO;CACT,CAAC;CACD,gBAAgB,MAAM,cAAc,QAAQ,UAAU,GAAG,CAAC,OAAO,QAAQ,UAAU,CAAC;CACpF,OAAO;AACT;;;;AAYA,SAAgB,wBACd,OACA,QACA,QACsB;CACtB,MAAM,OAAO,UAAU,MAAM;CAC7B,OAAO,eAAqC;EAC1C,GAAG,8BAA8B;GAC/B,oBAAoB,MAAM,aAAa,KAAK;GAC5C,UAAU,IAAI,UAAU,SACtB,iBAAiB,IAAI,KAAK,QAAQ,OAAO,EAAE,GAAG,UAAU,KAAK,QAAQ,YAAY,IAAI,IAAI,GAAG,MAAM,cAAc,CAAC;GACnH,mBAAmB,IAAI,aAAa,kBAAkB,IAAI,KAAK,QAAQ,OAAO,EAAE,GAAG,UAAU,MAAM,cAAc,CAAC;GAClH,oBAAoB,MAAM;GAC1B,iBAAiB,MAAM;GACvB,eAAe,MAAM;GACrB,UAAU,OAAO,KAAK,QAAQ,OAAO,EAAE,KAAK;GAE5C,aAAa,SAAS;IACpB,MAAM,OAAO,MAAM,WAAW;IAC9B,MAAM,QAAQ,OAAO,KAAK,QAAQ,YAAY,MAAM,aAAa,GAAG,IAAI,IAAI;IAC5E,OAAO,QAAQ,QAAQ,cAAc,OAAO,IAAI,IAAI;GACtD;GACA,GAAI,QAAQ,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;EACjD,CAAC;EACD,WAAW,MAAM;CACnB,IAAI;EAAC;EAAO;EAAM;CAAM,CAAC;AAC3B"}

package/dist/features/poseRun/usePoseRun.js

@@ -1,62 +1,129 @@
-import { useCallback as e, useEffect as t, useMemo as n, useRef as r } from "react";
-import { useLatest as i, useVisibleRaf as a } from "@weasel-js/react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useLatest, useVisibleRaf } 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 { 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(() => {
-		l.current?.hold.drop(), c.current.clear();
-	}, []), g = () => {
-		let e = s.current.scene, t = 0;
+/**
+* A pose run: poses published per frame, committed once.
+*
+* The frames go to `scene.overrides` — the ephemeral table a drag publishes
+* to — so an edge follows a node the run is moving, and the whole run lands as
+* one undo entry when it settles.
+*
+* **A node another gesture owns is pinned, not driven.** The run publishes
+* through a hold of its own, so an override it did not put there belongs to
+* somebody else — a drag, a resize. It never writes that id, never commits it,
+* and hands it to `step` as pinned so the producer can hold its neighbors
+* against it.
+*/
+/**
+* Drive node poses frame by frame through `scene.overrides`, committing them as
+* one undo entry when `step` reports done or `stop` is called. Idle until
+* `start`; unmounting abandons the run without writing.
+*/
+function usePoseRun(opts) {
+	const optsRef = useLatest(opts);
+	/** This frame's poses. */
+	const previews = useRef(/* @__PURE__ */ new Map());
+	/** The hold the run publishes through, and the scene it was taken from. */
+	const held = useRef(null);
+	const running = useRef(false);
+	const frame = useRef(0);
+	const mounted = useRef(true);
+	/** The hold on the scene the options name now. A run handed a different
+	*  scene mid-flight lets go of the old one's nodes. */
+	const holdNow = useCallback(() => {
+		const { scene } = optsRef.current;
+		if (held.current?.scene !== scene) {
+			held.current?.hold.drop();
+			held.current = {
+				scene,
+				hold: scene.overrides.hold()
+			};
+		}
+		return held.current.hold;
+	}, [optsRef]);
+	const release = useCallback(() => {
+		held.current?.hold.drop();
+		previews.current.clear();
+	}, []);
+	const commit = (finished) => {
+		const scene = optsRef.current.scene;
+		const also = optsRef.current.commitWith;
+		let moved = 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++);
+			if (previews.current.size > 0 || also !== void 0) scene.batch(optsRef.current.label ?? "Layout", () => {
+				for (const [id, pose] of previews.current) {
+					if (scene.get(id) === void 0 || scene.isLocked(id)) continue;
+					scene.setPose(id, pose);
+					moved++;
+				}
+				also?.(finished);
 			});
 		} finally {
-			h();
+			release();
 		}
-		s.current.onCommit?.(t);
-	}, _ = () => {
-		u.current = !1, p.cancel();
-	}, v = () => {
-		if (!f.current || !u.current) return;
-		let e = m(), t = e.others(), { poses: n, done: r } = s.current.step({
-			pinned: t,
-			frame: d.current
+		optsRef.current.onCommit?.(moved);
+	};
+	const halt = (loop) => {
+		running.current = false;
+		loop.cancel();
+	};
+	const tick = (loop) => {
+		if (!mounted.current || !running.current) return;
+		const hold = holdNow();
+		const pinned = hold.others();
+		const { poses, done } = optsRef.current.step({
+			pinned,
+			frame: frame.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();
+		frame.current++;
+		previews.current.clear();
+		for (const [id, pose] of poses) {
+			if (pinned.has(id)) continue;
+			previews.current.set(id, pose);
+		}
+		hold.set(previews.current);
+		if (done) {
+			halt(loop);
+			commit(true);
 			return;
 		}
-		p.request();
+		loop.request();
 	};
-	return t(() => (f.current = !0, () => {
-		f.current = !1, p.cancel(), h();
-	}), [p, h]), n(() => ({
+	const loop = useVisibleRaf((_time, loop) => {
+		tick(loop);
+	}, {
+		requestFrame: opts.requestFrame,
+		cancelFrame: opts.cancelFrame
+	});
+	useEffect(() => {
+		mounted.current = true;
+		return () => {
+			mounted.current = false;
+			loop.cancel();
+			release();
+		};
+	}, [loop, release]);
+	return useMemo(() => ({
 		start() {
-			!u.current && f.current && (u.current = !0, d.current = 0, p.request());
+			if (running.current || !mounted.current) return;
+			running.current = true;
+			frame.current = 0;
+			loop.request();
 		},
 		stop() {
-			u.current && (_(), g());
+			if (!running.current) return;
+			halt(loop);
+			commit(false);
 		},
 		cancel() {
-			_(), h();
+			halt(loop);
+			release();
 		},
-		isRunning: () => u.current
-	}), [p]);
+		isRunning: () => running.current
+	}), [loop]);
 }
-//#endregion
-export { o as usePoseRun };
 
+//#endregion
+export { usePoseRun };
 //# sourceMappingURL=usePoseRun.js.map

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":[],"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  /** Writes of the caller's own, made inside the commit's batch so they\n   *  share its undo entry. `finished` is false when `stop` cut the run short\n   *  of where `step` was taking it. */\n  commitWith?: (finished: boolean) => 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 = (finished: boolean): void => {\n    const scene = optsRef.current.scene;\n    const also = optsRef.current.commitWith;\n    let moved = 0;\n    try {\n      if (previews.current.size > 0 || also !== undefined) {\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          also?.(finished);\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(true);\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(false);\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":";;;;;;;;;;;;;;;;;;;;;;AAuEA,SAAgB,WAAkB,MAAyC;CACzE,MAAM,UAAU,UAAU,IAAI;;CAG9B,MAAM,WAAW,uBAAO,IAAI,IAAmB,CAAC;;CAEhD,MAAM,OAAO,OAA+E,IAAI;CAChG,MAAM,UAAU,OAAO,KAAK;CAC5B,MAAM,QAAQ,OAAO,CAAC;CACtB,MAAM,UAAU,OAAO,IAAI;;;CAI3B,MAAM,UAAU,kBAAmC;EACjD,MAAM,EAAE,UAAU,QAAQ;EAC1B,IAAI,KAAK,SAAS,UAAU,OAAO;GACjC,KAAK,SAAS,KAAK,KAAK;GACxB,KAAK,UAAU;IAAE;IAAO,MAAM,MAAM,UAAU,KAAK;GAAE;EACvD;EACA,OAAO,KAAK,QAAQ;CACtB,GAAG,CAAC,OAAO,CAAC;CAEZ,MAAM,UAAU,kBAAwB;EACtC,KAAK,SAAS,KAAK,KAAK;EACxB,SAAS,QAAQ,MAAM;CACzB,GAAG,CAAC,CAAC;CAEL,MAAM,UAAU,aAA4B;EAC1C,MAAM,QAAQ,QAAQ,QAAQ;EAC9B,MAAM,OAAO,QAAQ,QAAQ;EAC7B,IAAI,QAAQ;EACZ,IAAI;GACF,IAAI,SAAS,QAAQ,OAAO,KAAK,SAAS,QACxC,MAAM,MAAM,QAAQ,QAAQ,SAAS,gBAAgB;IACnD,KAAK,MAAM,CAAC,IAAI,SAAS,SAAS,SAAS;KACzC,IAAI,MAAM,IAAI,EAAE,MAAM,UAAa,MAAM,SAAS,EAAE,GAAG;KACvD,MAAM,QAAQ,IAAI,IAAI;KACtB;IACF;IACA,OAAO,QAAQ;GACjB,CAAC;EAEL,UAAU;GACR,QAAQ;EACV;EACA,QAAQ,QAAQ,WAAW,KAAK;CAClC;CAEA,MAAM,QAAQ,SAA2B;EACvC,QAAQ,UAAU;EAClB,KAAK,OAAO;CACd;CAEA,MAAM,QAAQ,SAA2B;EACvC,IAAI,CAAC,QAAQ,WAAW,CAAC,QAAQ,SAAS;EAC1C,MAAM,OAAO,QAAQ;EACrB,MAAM,SAAS,KAAK,OAAO;EAC3B,MAAM,EAAE,OAAO,SAAS,QAAQ,QAAQ,KAAK;GAAE;GAAQ,OAAO,MAAM;EAAQ,CAAC;EAC7E,MAAM;EACN,SAAS,QAAQ,MAAM;EACvB,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO;GAC9B,IAAI,OAAO,IAAI,EAAE,GAAG;GACpB,SAAS,QAAQ,IAAI,IAAI,IAAI;EAC/B;EACA,KAAK,IAAI,SAAS,OAAO;EACzB,IAAI,MAAM;GACR,KAAK,IAAI;GACT,OAAO,IAAI;GACX;EACF;EACA,KAAK,QAAQ;CACf;CAIA,MAAM,OAAO,eAAe,OAAO,SAAS;EAAE,KAAK,IAAI;CAAG,GAAG;EAC3D,cAAc,KAAK;EACnB,aAAa,KAAK;CACpB,CAAC;CAED,gBAAgB;EACd,QAAQ,UAAU;EAClB,aAAa;GACX,QAAQ,UAAU;GAClB,KAAK,OAAO;GAGZ,QAAQ;EACV;CACF,GAAG,CAAC,MAAM,OAAO,CAAC;CAElB,OAAO,eAAwB;EAC7B,QAAQ;GACN,IAAI,QAAQ,WAAW,CAAC,QAAQ,SAAS;GACzC,QAAQ,UAAU;GAClB,MAAM,UAAU;GAChB,KAAK,QAAQ;EACf;EACA,OAAO;GACL,IAAI,CAAC,QAAQ,SAAS;GACtB,KAAK,IAAI;GACT,OAAO,KAAK;EACd;EACA,SAAS;GACP,KAAK,IAAI;GACT,QAAQ;EACV;EACA,iBAAiB,QAAQ;CAE3B,IAAI,CAAC,IAAI,CAAC;AACZ"}