@weasel-js/core 1.10.1 → 1.11.1

package/dist/features/paths/editablePath.js

@@ -1,63 +1,166 @@
-import { isRectPose as e } from "../../core/geometry/autoPoseDescriptor.js";
-import { pathFromPlane as t } from "../../canvas/planeClips.js";
-import { pathInWorld as n, worldEditToStorage as r } from "@weasel-js/geom";
+import { isRectPose } from "../../core/geometry/autoPoseDescriptor.js";
+import { RECT_FALLBACK_PAINTER } from "../../canvas/nodeShapes/rectFallbackPainter.js";
+import { findNodeShape } from "../../canvas/NodeShape.js";
+import { pathFromPlane } from "../../canvas/planeClips.js";
+import { pathFormOf, representationOf, withoutPathForm } from "./pathRepresentation.js";
+import { asPolygonPath, pathInWorld, rectPath, worldEditToStorage } from "@weasel-js/geom";
+
 //#region src/features/paths/editablePath.ts
-function i(t) {
-	if (!t) return null;
-	if (t.pose?.kind === "polygon") return { kind: "pose" };
-	let n = t.data;
-	return n?.path && n.path.kind === "polygon" && e(t.pose) ? {
+/**
+* A node's editable polygon. It lives in one of two places: the pose itself
+* (`pose.kind === 'polygon'`), or `data.path` with a rect pose, stored pose-local.
+* A rect `data.path` is edited as its four corners and is stored as a polygon
+* from the first edit on; reading it changes nothing. A leaf drawn as its rect
+* pose alone reads as a rect `data.path` the size of its pose, and gains one
+* on the first edit.
+*/
+/** Whether `node` is a leaf whose only geometry is its rect pose, drawn by
+*  the kit's rect fallback. */
+function drawsPoseAlone(node) {
+	if (node.kind !== "leaf" || node.data?.path != null) return false;
+	return findNodeShape(node) === RECT_FALLBACK_PAINTER;
+}
+/** Resolve where a node's editable polygon lives. Returns null when the
+*  node has neither a polygon pose nor a polygon or rect on `data.path`.
+*  A rect comes back as the polygon it draws. */
+function classifyPathStorage(node) {
+	if (!node) return null;
+	if (node.pose?.kind === "polygon") return { kind: "pose" };
+	if (isRectPose(node.pose) && drawsPoseAlone(node)) {
+		const { width, height } = node.pose;
+		return {
+			kind: "data",
+			pose: node.pose,
+			data: {
+				...node.data,
+				path: asPolygonPath(rectPath(0, 0, width, height))
+			}
+		};
+	}
+	const data = node.data;
+	const kind = (data?.path)?.kind;
+	if (!data?.path || kind !== "polygon" && kind !== "rect" || !isRectPose(node.pose)) return null;
+	const path = asPolygonPath(data.path);
+	return {
 		kind: "data",
-		pose: t.pose,
-		data: n
-	} : null;
-}
-function a(e) {
-	if (!e) return null;
-	let t = i(e);
-	return t ? t.kind === "pose" ? e.pose : n(t.data.path, t.pose) : null;
-}
-function o(e, t) {
-	let n = i(e);
-	if (!n) return null;
-	if (n.kind === "pose") return {
-		pose: t,
-		data: e.data
+		pose: node.pose,
+		data: path === data.path ? data : {
+			...data,
+			path
+		}
+	};
+}
+/** Whether `node` has a path that path edit can show anchors for. */
+function hasEditablePath(node) {
+	return classifyPathStorage(node) !== null;
+}
+/** A node's editable polygon in world coords. Does NOT consult any preview state —
+*  callers that want live state read in-flight handles themselves. */
+function resolveEditablePathOf(node) {
+	if (!node) return null;
+	const storage = classifyPathStorage(node);
+	if (!storage) return null;
+	if (storage.kind === "pose") return node.pose;
+	return pathInWorld(storage.data.path, storage.pose);
+}
+/**
+* What path edit edits on a node, in world coords: the edit path of the form
+* the node's path was drawn from, where one of `extensions` reads it
+* (`PathRepresentation`), and otherwise its editable polygon. Null when the
+* node has no editable polygon.
+*/
+function pathEditPathOf(node, extensions = []) {
+	const path = resolveEditablePathOf(node);
+	const held = path ? representationOf(extensions, node.data) : null;
+	return (held && held.representation.editPath(path, held.form)) ?? path;
+}
+/**
+* The pose and data that store `worldPath` where `node` stores its editable
+* polygon — the inverse of {@link resolveEditablePathOf}, so a `data.path`
+* node keeps its rotation. On a node whose path was drawn from a form one of
+* `extensions` reads, `worldPath` is an edit of what {@link pathEditPathOf}
+* gave, and the representation turns it into the drawn path; a form none
+* reads, or that no longer describes the path, is dropped. Null when `node`
+* has no editable polygon.
+*/
+function storeEditablePath(node, worldPath, extensions = []) {
+	const storage = classifyPathStorage(node);
+	if (!storage) return null;
+	let path = worldPath;
+	let data = node.data;
+	if (pathFormOf(data)) {
+		const held = representationOf(extensions, data);
+		const solved = held ? held.representation.store(resolveEditablePathOf(node), held.form, worldPath) : null;
+		path = solved?.path ?? worldPath;
+		data = solved ? {
+			...data,
+			representation: solved.form
+		} : withoutPathForm(data);
+	}
+	if (storage.kind === "pose") return {
+		pose: path,
+		data
 	};
-	let { pose: a, path: o } = r(n.pose, t);
+	const stored = worldEditToStorage(storage.pose, path);
 	return {
-		pose: a,
+		pose: stored.pose,
 		data: {
-			...n.data,
-			path: o
+			...data,
+			path: stored.path
 		}
 	};
 }
-function s(e, t, n) {
-	let r = t.pose, i = t.data, a = !1;
-	for (let t of n) {
-		let n = t.previewIds?.();
-		if (!n) continue;
-		let o = !1;
-		for (let t of n) if (t === e) {
-			o = !0;
+/** `node` as the in-flight gestures in `previews` would leave it: a handle
+*  previewing `id` contributes its pose and its data. */
+function previewedShape(id, node, previews) {
+	let pose = node.pose;
+	let data = node.data;
+	let touched = false;
+	const kind = node.kind;
+	for (const source of previews) {
+		const previewIds = source.previewIds?.();
+		if (!previewIds) continue;
+		let owns = false;
+		for (const pid of previewIds) if (pid === id) {
+			owns = true;
 			break;
 		}
-		if (!o) continue;
-		let s = t.previewPose?.(e);
-		s != null && !a && (r = s, a = !0);
-		let c = t.previewData?.(e);
-		c != null && (i = c, a = !0);
+		if (!owns) continue;
+		const p = source.previewPose?.(id);
+		if (p != null && !touched) {
+			pose = p;
+			touched = true;
+		}
+		const d = source.previewData?.(id);
+		if (d != null) {
+			data = d;
+			touched = true;
+		}
 	}
 	return {
-		pose: r,
-		data: i
+		pose,
+		data,
+		kind
 	};
 }
-function c(e, n, r, i) {
-	return n ? t(a(s(e, n, r)), i) : null;
+/**
+* What path edit shows of node `id` right now ({@link pathEditPathOf}): following any
+* in-flight gesture in `previews`, and in the world of the camera whose
+* `plane` this is — a path on a parallax plane is stored in the plane's.
+*/
+function liveEditablePath(id, node, previews, plane, extensions = []) {
+	if (!node) return null;
+	return pathFromPlane(pathEditPathOf(previewedShape(id, node, previews), extensions), plane);
+}
+/** The marker of each anchor {@link liveEditablePath} shows for node `id`, as
+*  the representation reading its form draws them; null for a node it reads
+*  none of. */
+function liveAnchorMarkers(id, node, previews, extensions) {
+	if (!node) return null;
+	const held = representationOf(extensions, previewedShape(id, node, previews).data);
+	return held?.representation.anchorMarkers?.(held.form) ?? null;
 }
-//#endregion
-export { i as classifyPathStorage, c as liveEditablePath, a as resolveEditablePathOf, o as storeEditablePath };
 
+//#endregion
+export { classifyPathStorage, hasEditablePath, liveAnchorMarkers, liveEditablePath, pathEditPathOf, resolveEditablePathOf, 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","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"}
+{"version":3,"file":"editablePath.js","names":[],"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 * A rect `data.path` is edited as its four corners and is stored as a polygon\n * from the first edit on; reading it changes nothing. A leaf drawn as its rect\n * pose alone reads as a rect `data.path` the size of its pose, and gains one\n * on the first edit.\n */\nimport { asPolygonPath, pathInWorld, rectPath, worldEditToStorage, type Path, type PolygonPath } from '@weasel-js/geom';\nimport type { GesturePreviewSource } from 'canvas/gestureBounds';\nimport { findNodeShape } from 'canvas/NodeShape';\nimport { RECT_FALLBACK_PAINTER } from 'canvas/nodeShapes/rectFallbackPainter';\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';\nimport type { PathEditExtension } from './pathEditExtension';\nimport { pathFormOf, representationOf, withoutPathForm, type AnchorMarkerShape } from './pathRepresentation';\n\n/** The fields of a node the editable path is read from. A node's `kind`\n *  says whether a rect pose with no path is a leaf drawn as that rect. */\nexport interface EditableShape {\n  pose: unknown;\n  data: unknown;\n  kind?: string;\n}\n\n/** Whether `node` is a leaf whose only geometry is its rect pose, drawn by\n *  the kit's rect fallback. */\nfunction drawsPoseAlone(node: EditableShape): boolean {\n  if (node.kind !== 'leaf' || (node.data as { path?: unknown } | null)?.path != null) return false;\n  return findNodeShape(node as never) === RECT_FALLBACK_PAINTER;\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 or rect on `data.path`.\n *  A rect comes back as the polygon it draws. */\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  if (isRectPose(node.pose) && drawsPoseAlone(node)) {\n    const { width, height } = node.pose;\n    return { kind: 'data', pose: node.pose, data: { ...(node.data as object), path: asPolygonPath(rectPath(0, 0, width, height)) } };\n  }\n  const data = node.data as { path?: Path } | null;\n  const kind = (data?.path as { kind?: string } | undefined)?.kind;\n  if (!data?.path || (kind !== 'polygon' && kind !== 'rect') || !isRectPose(node.pose)) return null;\n  const path = asPolygonPath(data.path);\n  return {\n    kind: 'data',\n    pose: node.pose,\n    data: (path === data.path ? data : { ...data, path }) as { path: PolygonPath },\n  };\n}\n\n/** Whether `node` has a path that path edit can show anchors for. */\nexport function hasEditablePath(node: EditableShape | undefined | null): boolean {\n  return classifyPathStorage(node) !== 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 * What path edit edits on a node, in world coords: the edit path of the form\n * the node's path was drawn from, where one of `extensions` reads it\n * (`PathRepresentation`), and otherwise its editable polygon. Null when the\n * node has no editable polygon.\n */\nexport function pathEditPathOf(\n  node: EditableShape | undefined | null,\n  extensions: readonly PathEditExtension[] = [],\n): PolygonPath | null {\n  const path = resolveEditablePathOf(node);\n  const held = path ? representationOf(extensions, node!.data) : null;\n  return (held && held.representation.editPath(path!, held.form)) ?? path;\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. On a node whose path was drawn from a form one of\n * `extensions` reads, `worldPath` is an edit of what {@link pathEditPathOf}\n * gave, and the representation turns it into the drawn path; a form none\n * reads, or that no longer describes the path, is dropped. Null when `node`\n * has no editable polygon.\n */\nexport function storeEditablePath(\n  node: EditableShape | undefined | null,\n  worldPath: PolygonPath,\n  extensions: readonly PathEditExtension[] = [],\n): EditableShape | null {\n  const storage = classifyPathStorage(node);\n  if (!storage) return null;\n  let path = worldPath;\n  let data = node!.data;\n  if (pathFormOf(data)) {\n    const held = representationOf(extensions, data);\n    const solved = held ? held.representation.store(resolveEditablePathOf(node)!, held.form, worldPath) : null;\n    path = solved?.path ?? worldPath;\n    data = solved ? { ...(data as object), representation: solved.form } : withoutPathForm(data);\n  }\n  if (storage.kind === 'pose') return { pose: path, data };\n  const stored = worldEditToStorage(storage.pose, path);\n  return { pose: stored.pose, data: { ...(data as object), path: stored.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  const kind = node.kind;\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, kind };\n}\n\n/**\n * What path edit shows of node `id` right now ({@link pathEditPathOf}): 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  extensions: readonly PathEditExtension[] = [],\n): PolygonPath | null {\n  if (!node) return null;\n  return pathFromPlane(pathEditPathOf(previewedShape(id, node, previews), extensions), plane);\n}\n\n/** The marker of each anchor {@link liveEditablePath} shows for node `id`, as\n *  the representation reading its form draws them; null for a node it reads\n *  none of. */\nexport function liveAnchorMarkers(\n  id: string,\n  node: EditableShape | undefined | null,\n  previews: readonly GesturePreviewSource[],\n  extensions: readonly PathEditExtension[],\n): readonly (AnchorMarkerShape | null)[] | null {\n  if (!node) return null;\n  const held = representationOf(extensions, previewedShape(id, node, previews).data);\n  return held?.representation.anchorMarkers?.(held.form) ?? null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA,SAAS,eAAe,MAA8B;CACpD,IAAI,KAAK,SAAS,UAAW,KAAK,MAAoC,QAAQ,MAAM,OAAO;CAC3F,OAAO,cAAc,IAAa,MAAM;AAC1C;;;;AAKA,SAAgB,oBACd,MACyF;CACzF,IAAI,CAAC,MAAM,OAAO;CAElB,IADa,KAAK,MACR,SAAS,WAAW,OAAO,EAAE,MAAM,OAAO;CACpD,IAAI,WAAW,KAAK,IAAI,KAAK,eAAe,IAAI,GAAG;EACjD,MAAM,EAAE,OAAO,WAAW,KAAK;EAC/B,OAAO;GAAE,MAAM;GAAQ,MAAM,KAAK;GAAM,MAAM;IAAE,GAAI,KAAK;IAAiB,MAAM,cAAc,SAAS,GAAG,GAAG,OAAO,MAAM,CAAC;GAAE;EAAE;CACjI;CACA,MAAM,OAAO,KAAK;CAClB,MAAM,QAAQ,MAAM,KAAA,EAAwC;CAC5D,IAAI,CAAC,MAAM,QAAS,SAAS,aAAa,SAAS,UAAW,CAAC,WAAW,KAAK,IAAI,GAAG,OAAO;CAC7F,MAAM,OAAO,cAAc,KAAK,IAAI;CACpC,OAAO;EACL,MAAM;EACN,MAAM,KAAK;EACX,MAAO,SAAS,KAAK,OAAO,OAAO;GAAE,GAAG;GAAM;EAAK;CACrD;AACF;;AAGA,SAAgB,gBAAgB,MAAiD;CAC/E,OAAO,oBAAoB,IAAI,MAAM;AACvC;;;AAIA,SAAgB,sBACd,MACoB;CACpB,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,UAAU,oBAAoB,IAAI;CACxC,IAAI,CAAC,SAAS,OAAO;CAGrB,IAAI,QAAQ,SAAS,QAAQ,OAAQ,KAA+B;CAGpE,OAAO,YAAY,QAAQ,KAAK,MAAM,QAAQ,IAAI;AACpD;;;;;;;AAQA,SAAgB,eACd,MACA,aAA2C,CAAC,GACxB;CACpB,MAAM,OAAO,sBAAsB,IAAI;CACvC,MAAM,OAAO,OAAO,iBAAiB,YAAY,KAAM,IAAI,IAAI;CAC/D,QAAQ,QAAQ,KAAK,eAAe,SAAS,MAAO,KAAK,IAAI,MAAM;AACrE;;;;;;;;;;AAWA,SAAgB,kBACd,MACA,WACA,aAA2C,CAAC,GACtB;CACtB,MAAM,UAAU,oBAAoB,IAAI;CACxC,IAAI,CAAC,SAAS,OAAO;CACrB,IAAI,OAAO;CACX,IAAI,OAAO,KAAM;CACjB,IAAI,WAAW,IAAI,GAAG;EACpB,MAAM,OAAO,iBAAiB,YAAY,IAAI;EAC9C,MAAM,SAAS,OAAO,KAAK,eAAe,MAAM,sBAAsB,IAAI,GAAI,KAAK,MAAM,SAAS,IAAI;EACtG,OAAO,QAAQ,QAAQ;EACvB,OAAO,SAAS;GAAE,GAAI;GAAiB,gBAAgB,OAAO;EAAK,IAAI,gBAAgB,IAAI;CAC7F;CACA,IAAI,QAAQ,SAAS,QAAQ,OAAO;EAAE,MAAM;EAAM;CAAK;CACvD,MAAM,SAAS,mBAAmB,QAAQ,MAAM,IAAI;CACpD,OAAO;EAAE,MAAM,OAAO;EAAM,MAAM;GAAE,GAAI;GAAiB,MAAM,OAAO;EAAK;CAAE;AAC/E;;;AAIA,SAAS,eACP,IACA,MACA,UACe;CACf,IAAI,OAAO,KAAK;CAChB,IAAI,OAAO,KAAK;CAChB,IAAI,UAAU;CACd,MAAM,OAAO,KAAK;CAClB,KAAK,MAAM,UAAU,UAAU;EAC7B,MAAM,aAAa,OAAO,aAAa;EACvC,IAAI,CAAC,YAAY;EACjB,IAAI,OAAO;EACX,KAAK,MAAM,OAAO,YAChB,IAAI,QAAQ,IAAI;GAAE,OAAO;GAAM;EAAO;EAExC,IAAI,CAAC,MAAM;EACX,MAAM,IAAI,OAAO,cAAc,EAAE;EACjC,IAAI,KAAK,QAAQ,CAAC,SAAS;GAAE,OAAO;GAAG,UAAU;EAAM;EACvD,MAAM,IAAI,OAAO,cAAc,EAAE;EACjC,IAAI,KAAK,MAAM;GAAE,OAAO;GAAG,UAAU;EAAM;CAC7C;CACA,OAAO;EAAE;EAAM;EAAM;CAAK;AAC5B;;;;;;AAOA,SAAgB,iBACd,IACA,MACA,UACA,OACA,aAA2C,CAAC,GACxB;CACpB,IAAI,CAAC,MAAM,OAAO;CAClB,OAAO,cAAc,eAAe,eAAe,IAAI,MAAM,QAAQ,GAAG,UAAU,GAAG,KAAK;AAC5F;;;;AAKA,SAAgB,kBACd,IACA,MACA,UACA,YAC8C;CAC9C,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,OAAO,iBAAiB,YAAY,eAAe,IAAI,MAAM,QAAQ,CAAC,CAAC,IAAI;CACjF,OAAO,MAAM,eAAe,gBAAgB,KAAK,IAAI,KAAK;AAC5D"}

package/dist/features/paths/index.js

@@ -1,10 +1,13 @@
-import { pathPoseDescriptor as e } from "../../core/geometry/pathPoseDescriptor.js";
-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, 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 { pathPoseDescriptor } from "../../core/geometry/pathPoseDescriptor.js";
+import { GEOMETRY_BOUND_DATA, withoutGeometryBoundData } from "./pathEditExtension.js";
+import { createPenPreviewLayer } from "./penPreviewLayer.js";
+import { PATH_SNAP_LABELS, pathSnapGlyph } from "./pathSnap/glyphs.js";
+import { createPathEditingOverlayLayer } from "./pathEditingOverlayLayer.js";
+import { createPathLayer } from "./pathLayer.js";
+import { pathOriginProjection } from "./originProjection.js";
+import { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, PATH_C as PATH_C$1, PATH_CMD_LENGTHS, PATH_L as PATH_L$1, PATH_M as PATH_M$1, PATH_Q as PATH_Q$1, PATH_SNAP_KINDS as PATH_SNAP_KINDS$1, PATH_Z as PATH_Z$1, PathBuilder, asPolygonPath as asPolygonPath$1, averageAnchorsAt as averageAnchorsAt$1, bendAlongPath as bendAlongPath$1, blendPaths, boundsOfPath as boundsOfPath$1, circlePath as circlePath$1, composePath, cornerAt, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerSpecAt, countPathAnchors as countPathAnchors$1, createPathSnapIndex as createPathSnapIndex$1, decomposePath, ellipsePath as ellipsePath$1, extendToMeet, findPathSnap as findPathSnap$1, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasCorners, hasOpenSubpath as hasOpenSubpath$1, intersectSegments, isCornerShape, joinAnchorsAt as joinAnchorsAt$1, lengthenOpenEnd, linePath as linePath$1, measurePath as measurePath$1, nextCornerShape, openEndRay, openPathEnds, pathCommandCoordCount, pathContainsPoint as pathContainsPoint$1, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathFromD as pathFromD$1, pathInPoseFrame as pathInPoseFrame$1, pathInWorld as pathInWorld$1, pathIntersectsPolygon, pathIntersectsRect as pathIntersectsRect$1, pathSegments, pathSignedArea, pathThroughPoseFrame as pathThroughPoseFrame$1, pathToAnchors as pathToAnchors$1, pathToD, pointAlongPath, pointInPath as pointInPath$1, polygonFromPoints as polygonFromPoints$1, polylineFromPoints as polylineFromPoints$1, poseFrameInverseOf as poseFrameInverseOf$1, poseFrameOf as poseFrameOf$1, poseLinearOf as poseLinearOf$1, poseRotationOf, prepareBlend as prepareBlend$1, rectMarkerPath as rectMarkerPath$1, rectPath as rectPath$1, regularPolygonPath as regularPolygonPath$1, remapPerAnchor, repeatAlongPath as repeatAlongPath$1, resolveCorners as resolveCorners$1, resolveCornersWithSources, reversePath, rotatePathAround as rotatePathAround$1, roundRectPath, scalePathToBounds, simplifyAnchorsAt, simplifyPath as simplifyPath$1, smudgePath, splitByClosure, splitSubpaths, squarePath as squarePath$1, starPath as starPath$1, stationsAlongPath, transformPath as transformPath$1, translatePath as translatePath$1, trimPathAt, unionBoundsPath, withCorner, withoutCorners, worldEditToStorage as worldEditToStorage$1 } from "@weasel-js/geom";
+import { offsetPath as offsetPath$1, strokeToPath as strokeToPath$1 } from "@weasel-js/stroke";
+import { pathDivide, pathExclude as pathExclude$1, pathIntersect as pathIntersect$1, pathSubtract as pathSubtract$1, pathUnion as pathUnion$1, snipPathByPolyline as snipPathByPolyline$1, snipPathsAtCrossings as snipPathsAtCrossings$1, splitPathByPolyline as splitPathByPolyline$1, splitPathBySegment, trianglesToPath } 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 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 };
+
+export { CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, DEFAULT_FLATTEN_TOLERANCE, GEOMETRY_BOUND_DATA, PATH_C$1 as PATH_C, PATH_CMD_LENGTHS, PATH_L$1 as PATH_L, PATH_M$1 as PATH_M, PATH_Q$1 as PATH_Q, PATH_SNAP_KINDS$1 as PATH_SNAP_KINDS, PATH_SNAP_LABELS, PATH_Z$1 as PATH_Z, PathBuilder, asPolygonPath$1 as asPolygonPath, averageAnchorsAt$1 as averageAnchorsAt, bendAlongPath$1 as bendAlongPath, blendPaths, boundsOfPath$1 as boundsOfPath, circlePath$1 as circlePath, composePath, cornerAt, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerSpecAt, countPathAnchors$1 as countPathAnchors, createPathEditingOverlayLayer, createPathLayer, createPathSnapIndex$1 as createPathSnapIndex, createPenPreviewLayer, decomposePath, ellipsePath$1 as ellipsePath, extendToMeet, findPathSnap$1 as findPathSnap, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasCorners, hasOpenSubpath$1 as hasOpenSubpath, intersectSegments, isCornerShape, joinAnchorsAt$1 as joinAnchorsAt, lengthenOpenEnd, linePath$1 as linePath, measurePath$1 as measurePath, nextCornerShape, offsetPath$1 as offsetPath, openEndRay, openPathEnds, pathCommandCoordCount, pathContainsPoint$1 as pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathDivide, pathExclude$1 as pathExclude, pathFromD$1 as pathFromD, pathInPoseFrame$1 as pathInPoseFrame, pathInWorld$1 as pathInWorld, pathIntersect$1 as pathIntersect, pathIntersectsPolygon, pathIntersectsRect$1 as pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSegments, pathSignedArea, pathSnapGlyph, pathSubtract$1 as pathSubtract, pathThroughPoseFrame$1 as pathThroughPoseFrame, pathToAnchors$1 as pathToAnchors, pathToD, pathUnion$1 as pathUnion, pointAlongPath, pointInPath$1 as pointInPath, polygonFromPoints$1 as polygonFromPoints, polylineFromPoints$1 as polylineFromPoints, poseFrameInverseOf$1 as poseFrameInverseOf, poseFrameOf$1 as poseFrameOf, poseLinearOf$1 as poseLinearOf, poseRotationOf, prepareBlend$1 as prepareBlend, rectMarkerPath$1 as rectMarkerPath, rectPath$1 as rectPath, regularPolygonPath$1 as regularPolygonPath, remapPerAnchor, repeatAlongPath$1 as repeatAlongPath, resolveCorners$1 as resolveCorners, resolveCornersWithSources, reversePath, rotatePathAround$1 as rotatePathAround, roundRectPath, scalePathToBounds, simplifyAnchorsAt, simplifyPath$1 as simplifyPath, smudgePath, snipPathByPolyline$1 as snipPathByPolyline, snipPathsAtCrossings$1 as snipPathsAtCrossings, splitByClosure, splitPathByPolyline$1 as splitPathByPolyline, splitPathBySegment, splitSubpaths, squarePath$1 as squarePath, starPath$1 as starPath, stationsAlongPath, strokeToPath$1 as strokeToPath, transformPath$1 as transformPath, translatePath$1 as translatePath, trianglesToPath, trimPathAt, unionBoundsPath, withCorner, withoutCorners, withoutGeometryBoundData, worldEditToStorage$1 as worldEditToStorage };

package/dist/features/paths/originProjection.js

@@ -1,16 +1,23 @@
-import { boundsOfPath as e, translatePath as t } from "@weasel-js/geom";
+import { boundsOfPath, translatePath } from "@weasel-js/geom";
+
 //#region src/features/paths/originProjection.ts
-var n = {
-	getOrigin: (t) => {
-		let n = e(t);
+/**
+* `OriginProjection` for `Path` poses. The "origin" is the top-left of the
+* path's AABB; `translate` shifts every coord by the requested delta. It is
+* where a snap session puts a Path's `origin` probe, so a grid source snaps a
+* Path's bounds top-left.
+*/
+var pathOriginProjection = {
+	getOrigin: (path) => {
+		const b = boundsOfPath(path);
 		return {
-			x: n.x,
-			y: n.y
+			x: b.x,
+			y: b.y
 		};
 	},
-	translate: t
+	translate: translatePath
 };
-//#endregion
-export { n as pathOriginProjection };
 
+//#endregion
+export { pathOriginProjection };
 //# sourceMappingURL=originProjection.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"originProjection.js","names":["pathOriginProjection","b","boundsOfPath","path","translatePath"],"sources":["../../../src/features/paths/originProjection.ts"],"sourcesContent":["import { boundsOfPath, translatePath, type Path } from '@weasel-js/geom';\nimport type { OriginProjection } from 'interactions/gestures/shared/originProjection';\n\n/**\n * `OriginProjection` for `Path` poses. The \"origin\" is the top-left of the\n * path's AABB; `translate` shifts every coord by the requested delta. Pair\n * with `@weasel-js/guides`' `gridSnapStrategy` to grid-snap a Path's bounds top-left:\n *\n *     gridSnapStrategy<Path>(20, { origin: pathOriginProjection })\n */\nexport const pathOriginProjection: OriginProjection<Path> = {\n  getOrigin: (path) => {\n    const b = boundsOfPath(path);\n    return { x: b.x, y: b.y };\n  },\n  translate: translatePath,\n};\n"],"mappings":";;AAUA,IAAaA,IAA+C;CAC1D,YAAY,MAAS;EACnB,IAAMC,IAAIC,EAAaC,CAAI;EAC3B,OAAO;GAAE,GAAGF,EAAE;GAAG,GAAGA,EAAE;EAAE;CAC1B;CACA,WAAWG;AACb"}
+{"version":3,"file":"originProjection.js","names":[],"sources":["../../../src/features/paths/originProjection.ts"],"sourcesContent":["import { boundsOfPath, translatePath, type Path } from '@weasel-js/geom';\nimport type { OriginProjection } from 'interactions/gestures/shared/originProjection';\n\n/**\n * `OriginProjection` for `Path` poses. The \"origin\" is the top-left of the\n * path's AABB; `translate` shifts every coord by the requested delta. It is\n * where a snap session puts a Path's `origin` probe, so a grid source snaps a\n * Path's bounds top-left.\n */\nexport const pathOriginProjection: OriginProjection<Path> = {\n  getOrigin: (path) => {\n    const b = boundsOfPath(path);\n    return { x: b.x, y: b.y };\n  },\n  translate: translatePath,\n};\n"],"mappings":";;;;;;;;;AASA,IAAa,uBAA+C;CAC1D,YAAY,SAAS;EACnB,MAAM,IAAI,aAAa,IAAI;EAC3B,OAAO;GAAE,GAAG,EAAE;GAAG,GAAG,EAAE;EAAE;CAC1B;CACA,WAAW;AACb"}

package/dist/features/paths/pathEditExtension.js

@@ -0,0 +1,26 @@
+//#region src/features/paths/pathEditExtension.ts
+/**
+* Data fields that describe how a node's geometry was made, or name its
+* anchors, and so mean nothing once the geometry is replaced some other way.
+* A writer replacing a node's path drops them: a held warp, path
+* constraints, a skin, the form a path was drawn from.
+*/
+var GEOMETRY_BOUND_DATA = [
+	"skin",
+	"constraints",
+	"warp",
+	"representation"
+];
+/** `data` without the fields in {@link GEOMETRY_BOUND_DATA}, other than `keep`. */
+function withoutGeometryBoundData(data, keep = []) {
+	if (data === null || typeof data !== "object") return data;
+	const drop = GEOMETRY_BOUND_DATA.filter((k) => k in data && !keep.includes(k));
+	if (drop.length === 0) return data;
+	const out = { ...data };
+	for (const k of drop) delete out[k];
+	return out;
+}
+
+//#endregion
+export { GEOMETRY_BOUND_DATA, withoutGeometryBoundData };
+//# sourceMappingURL=pathEditExtension.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathEditExtension.js","names":[],"sources":["../../../src/features/paths/pathEditExtension.ts"],"sourcesContent":["/**\n * What a feature adds to path edit without path edit knowing it: marks drawn\n * on the open path, parts of it to press, marks a click selects and Delete\n * removes, a share in shaping an anchor or handle drag, what an edit must keep\n * true when it commits, and how a path drawn from another form is edited. A\n * preset carries its extensions as `FeaturePreset.pathEdit`; core consults\n * them in preset order.\n */\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { AnchorSet, PointOrigin, PolygonPath, View } from '@weasel-js/geom';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport type { HandleLocks } from 'interactions/actions/edit-anchors/params';\nimport type { SnapDep } from 'interactions/actions/snapDep';\nimport type { PathRepresentation } from './pathRepresentation';\n\n/** A mark an extension drew that is selected in place of anchors: Delete\n *  acts on it, and selecting anchors clears it. */\nexport interface PathEditMark {\n  /** The extension that drew it. */\n  owner: string;\n  /** Which of its marks, in the extension's own numbering. */\n  index: number;\n}\n\n/** The open path as an extension's marks and parts read it. */\nexport interface PathEditTarget {\n  /** The node being edited. */\n  id: string;\n  /** Its committed pose and data. */\n  node: { pose: unknown; data: unknown };\n  /** The path as drawn now, in-flight edits included, in world space. */\n  path: PolygonPath;\n  /** `path`'s anchors. */\n  anchors: AnchorSet;\n}\n\n/** What {@link PathEditExtension.marks} draws with. */\nexport interface PathEditMarksCtx extends PathEditTarget {\n  view: View;\n  /** World space to the screen space the marks are drawn in. */\n  toScreen(p: { x: number; y: number }): { x: number; y: number };\n  /** Chrome-caps' answer for a chrome id; marks gated by one ask it. */\n  isVisible(chromeId: string): boolean;\n  /** The selected mark's index when this extension owns it, else null. */\n  selected: number | null;\n}\n\n/** A grabbable point an extension adds to the open path. A press on it\n *  routes as an affordance hit of kind `hitKind`. */\nexport interface PathEditPart {\n  x: number;\n  y: number;\n  hitKind: string;\n  /** Chrome-caps id it is hit-tested under, beside `path-edit.anchors`. */\n  chromeId?: string;\n  /** Hit radius in screen px; path edit's anchor radius when left out. */\n  hitRadiusPx?: number;\n  /** Pushes the part `px` screen pixels from (x, y) along the world-space\n   *  `normal`, so it keeps its distance at any zoom. */\n  standoff?: { px: number; normal: { x: number; y: number } };\n}\n\ntype Point = { x: number; y: number };\n\n/** An anchor or handle drag on the open path, as it starts. */\nexport interface PathEditDragStart extends Omit<PathEditTarget, 'node'> {\n  /** The node's committed pose and data; null when it cannot be read. */\n  node: PathEditTarget['node'] | null;\n  /** What the press grabbed: an anchor, or one of its handles. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n  /** The pressed anchor, as a flat index. */\n  anchorIndex: number;\n  /** The anchors an anchor drag moves, as flat indices; empty for a handle\n   *  drag, or when Shift took the pressed anchor out of the selection. */\n  dragging: readonly number[];\n  /** The view's world-to-screen scale at the press, to measure in screen\n   *  pixels by; absent without a view. */\n  scale?: { x: number; y: number };\n  /** The canvas's `snap` dep, to begin a session on; absent without one. */\n  snap?: SnapDep;\n}\n\n/** A handle drag's move, as {@link PathEditDrag.handle} reads it. */\nexport interface PathEditHandleMove {\n  /** The handle locks in force this move, modifiers included. */\n  locks: HandleLocks;\n}\n\n/** One extension's share of a drag in flight. Every member is optional. */\nexport interface PathEditDrag {\n  /**\n   * For an anchor drag, anchors that follow it and the share of its delta\n   * each moves by, keyed by flat index. Read every move. When any extension\n   * gives one, the drag moves its dragged anchors in full and every anchor\n   * named by the largest share given, and moves no symmetric images.\n   */\n  weights?(): ReadonlyMap<number, number>;\n  /** For a handle drag, where the handle goes, given `to`: where the pointer\n   *  and the locks in force put it. Extensions answer in turn, each from the\n   *  last one's answer. */\n  handle?(to: Point, move: PathEditHandleMove): Point;\n  /** A wheel turned while the drag is in flight. Return true to claim it;\n   *  the drag then redoes its last move. */\n  wheel?(wheel: { deltaX: number; deltaY: number; deltaZ: number }): boolean;\n  /** Overlays to draw while the drag is in flight, for `current`, the path\n   *  as the drag has made it. */\n  overlays?(current: AnchorSet): readonly OngoingOverlay[];\n  /** The drag is over, committed or canceled. */\n  end?(): void;\n}\n\n/** Another node an edit changes along with the edited one. */\nexport interface PathEditOther {\n  id: string;\n  /** Its new path, in world space, stored where the node keeps its own. */\n  path?: PolygonPath;\n  /** Data fields to set on it. */\n  data?: Record<string, unknown>;\n  /** Delete it: what it kept true no longer has anything to hold. */\n  remove?: boolean;\n}\n\n/** What an edit commits once an extension has finished it. */\nexport interface FinishedPathEdit {\n  path: PolygonPath;\n  /** Data fields to set beside the path. */\n  data?: Record<string, unknown>;\n  /** Other nodes the edit changes, committed in the same history entry and previewed with it. */\n  others?: readonly PathEditOther[];\n}\n\n/** The scene as {@link PathEditExtension.finishEdit} reads it, for an edit that reaches past one node. */\nexport interface PathEditFinishCtx {\n  /** The edited node's id. */\n  id: string;\n  /** A node's committed pose, data and dependencies; null when there is none. */\n  node(id: string): { pose: unknown; data: unknown; dependsOn?: readonly string[] | 'children' } | null;\n  /** A node's committed editable path, in world space; null when it has none. */\n  path(id: string): PolygonPath | null;\n  /** The nodes that list `id` in their `dependsOn`, directly or through others. */\n  dependents(id: string): readonly string[];\n}\n\n/**\n * The scene as {@link PathEditExtension.finishTransform} reads it: `node` and\n * `path` answer each node as the transform leaves it, `before` as it was.\n */\nexport interface PathTransformFinishCtx extends Omit<PathEditFinishCtx, 'id'> {\n  /** The nodes the transform moves, resizes or turns. */\n  ids: readonly string[];\n  /** A node's committed editable path before the transform, in world space; null when it has none. */\n  before(id: string): PolygonPath | null;\n}\n\n/** One feature's share of path edit. Every member is optional. */\nexport interface PathEditExtension {\n  /** Names it as a {@link PathEditMark}'s owner. Unique per canvas. */\n  readonly id: string;\n  /** Draw commands for the open path, in screen space, under its anchor\n   *  markers. Called every frame the overlay paints. */\n  marks?(ctx: PathEditMarksCtx): DrawCommand[];\n  /** Grabbable points on the open path, pressed ahead of its segments and\n   *  behind its anchors. */\n  parts?(target: PathEditTarget): readonly PathEditPart[];\n  /** The index of this extension's mark a click at `screen` (in the\n   *  overlay's screen space) lands on, or -1. Asked when a click misses\n   *  every anchor. */\n  markAt?(target: PathEditTarget, toScreen: PathEditMarksCtx['toScreen'], screen: { x: number; y: number }): number;\n  /** Remove mark `index` of the node `target` names, committing through\n   *  `store`. Delete in path edit calls it on the selected mark. */\n  deleteMark?(target: PathEditTarget, index: number, store: PathEditStore): void;\n  /** Its share of an anchor or handle drag starting on the open path, or\n   *  null to sit it out. Asked once, at the press. */\n  drag?(start: PathEditDragStart): PathEditDrag | null;\n  /**\n   * `worldPath`, an edit of `node`'s committed path, finished so whatever\n   * this extension keeps true holds — the path, and any data fields that\n   * change with it, and any other nodes it has to move to keep it. Null when\n   * it cannot hold, and the edit should then not happen. Runs on every commit\n   * of an edit and every frame of one in flight. `ctx` reads the rest of the\n   * scene; it is absent where an edit has no scene behind it.\n   */\n  finishEdit?(\n    node: { pose: unknown; data: unknown },\n    worldPath: PolygonPath,\n    origins?: readonly (PointOrigin | null)[],\n    ctx?: PathEditFinishCtx,\n  ): FinishedPathEdit | null;\n  /**\n   * The other nodes a whole-node transform — a move, resize, rotate, flip or\n   * nudge — changes along with the nodes it transforms, so whatever this\n   * extension keeps true across nodes holds; committed in the transform's\n   * history entry. Null when the transform should not happen. An entry\n   * naming a node the transform itself moves is ignored.\n   */\n  finishTransform?(ctx: PathTransformFinishCtx): readonly PathEditOther[] | null;\n  /** How path edit reads and writes the nodes whose `data.representation`\n   *  is of its kind. */\n  representation?: PathRepresentation;\n}\n\n/** Commits a node's new path and data as one history entry, with no\n *  extension finishing it. */\nexport type PathEditStore = (id: string, worldPath: PolygonPath, label: string, data?: Record<string, unknown>) => void;\n\n/**\n * Data fields that describe how a node's geometry was made, or name its\n * anchors, and so mean nothing once the geometry is replaced some other way.\n * A writer replacing a node's path drops them: a held warp, path\n * constraints, a skin, the form a path was drawn from.\n */\nexport const GEOMETRY_BOUND_DATA: readonly string[] = ['skin', 'constraints', 'warp', 'representation'];\n\n/** `data` without the fields in {@link GEOMETRY_BOUND_DATA}, other than `keep`. */\nexport function withoutGeometryBoundData<T>(data: T, keep: readonly string[] = []): T {\n  if (data === null || typeof data !== 'object') return data;\n  const drop = GEOMETRY_BOUND_DATA.filter((k) => k in (data as object) && !keep.includes(k));\n  if (drop.length === 0) return data;\n  const out = { ...(data as Record<string, unknown>) };\n  for (const k of drop) delete out[k];\n  return out as T;\n}\n"],"mappings":";;;;;;;AAmNA,IAAa,sBAAyC;CAAC;CAAQ;CAAe;CAAQ;AAAgB;;AAGtG,SAAgB,yBAA4B,MAAS,OAA0B,CAAC,GAAM;CACpF,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU,OAAO;CACtD,MAAM,OAAO,oBAAoB,QAAQ,MAAM,KAAM,QAAmB,CAAC,KAAK,SAAS,CAAC,CAAC;CACzF,IAAI,KAAK,WAAW,GAAG,OAAO;CAC9B,MAAM,MAAM,EAAE,GAAI,KAAiC;CACnD,KAAK,MAAM,KAAK,MAAM,OAAO,IAAI;CACjC,OAAO;AACT"}

package/dist/features/paths/pathEditState.js

@@ -1,41 +1,122 @@
-import { createEmitter as e } from "@weasel-js/registry";
+import { createEmitter } from "@weasel-js/registry";
+
 //#region src/features/paths/pathEditState.ts
-var t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
-function r(e, t, n) {
-	return e.get(n) != null && t.current.includes(n);
+/**
+* Which path is being anchor-edited, which of its anchors are selected, and
+* the anchor marquee in flight: one object every reader shares — the
+* `editAnchors` dep, the anchor overlay, the selection overlay's suppressed
+* set, the chrome-caps rule context, and the select tool's shift-click lock.
+*/
+var NO_IDS = /* @__PURE__ */ new Set();
+var NO_EXTENSIONS = [];
+var NO_ANCHORS = /* @__PURE__ */ new Set();
+/** Whether `id` names a node `scene` holds and `selection` includes. */
+function isSelectedNode(scene, selection, id) {
+	return scene.get(id) != null && selection.current.includes(id);
 }
-function i(r = {}) {
-	let i = "", a = n, o = null, s = t, c = e(), l = c.emit, u = () => {
-		let e = r.host?.(), t = e ? e.editingId() ?? "" : i;
-		return !t || r.isAllowed && !r.isAllowed() || r.isSelectedNode && !r.isSelectedNode(t) ? "" : t;
+function createPathEditState(source = {}) {
+	let ownId = "";
+	let selectedAnchors = NO_ANCHORS;
+	let marquee = null;
+	let handleLocks = null;
+	let ownTool = null;
+	let idSet = NO_IDS;
+	let selectedMark = null;
+	let extensions = source.extensions ?? NO_EXTENSIONS;
+	const changed = createEmitter();
+	const notify = changed.emit;
+	const next = (id) => id ?? "";
+	const getEditingId = () => {
+		const host = source.host?.();
+		const id = host ? host.editingId() ?? "" : ownId;
+		if (!id) return "";
+		if (source.isAllowed && !source.isAllowed()) return "";
+		if (source.isSelectedNode && !source.isSelectedNode(id)) return "";
+		return id;
 	};
 	return {
-		getEditingId: u,
+		getEditingId,
 		getEditingIds() {
-			let e = u();
-			return e ? (s.has(e) || (s = /* @__PURE__ */ new Set([e])), s) : t;
+			const id = getEditingId();
+			if (!id) return NO_IDS;
+			if (!idSet.has(id)) idSet = /* @__PURE__ */ new Set([id]);
+			return idSet;
 		},
-		setEditingId(e) {
-			let t = r.host?.();
-			if (t) {
-				t.setEditingId(e);
+		setEditingId(id) {
+			const host = source.host?.();
+			if (next(id) !== getEditingId()) ownTool = null;
+			if (host) {
+				host.setEditingId(id);
 				return;
 			}
-			let n = e ?? "";
-			n !== i && (i = n, l());
+			if (next(id) === ownId) return;
+			ownId = next(id);
+			notify();
+		},
+		getSelectedAnchors: () => {
+			const host = source.host?.();
+			return host?.selectedAnchors && host.setSelectedAnchors ? host.selectedAnchors() : selectedAnchors;
+		},
+		setSelectedAnchors(next) {
+			const host = source.host?.();
+			if (host?.selectedAnchors && host.setSelectedAnchors) {
+				host.setSelectedAnchors(next);
+				return;
+			}
+			selectedAnchors = next;
+			notify();
+		},
+		getMarquee: () => marquee,
+		setMarquee(rect) {
+			marquee = rect;
+			notify();
+		},
+		getSelectedMark: () => selectedMark,
+		setSelectedMark(mark) {
+			if (mark?.owner === selectedMark?.owner && mark?.index === selectedMark?.index) return;
+			selectedMark = mark;
+			notify();
 		},
-		getSelectedAnchors: () => a,
-		setSelectedAnchors(e) {
-			a = e, l();
+		getExtensions: () => extensions,
+		setExtensions(next) {
+			if (next === extensions) return;
+			extensions = next;
+			notify();
 		},
-		getMarquee: () => o,
-		setMarquee(e) {
-			o = e, l();
+		getHandleLocks: () => handleLocks,
+		setHandleLocks(next) {
+			handleLocks = {
+				angle: next.angle,
+				length: next.length
+			};
+			notify();
 		},
-		subscribe: c.subscribe
+		getTool() {
+			const on = getEditingId();
+			const host = source.host?.();
+			if (host?.tool) return on ? host.tool() : null;
+			if (ownTool && ownTool.on !== on) ownTool = null;
+			return ownTool?.id ?? null;
+		},
+		setTool(id) {
+			const host = source.host?.();
+			if (host?.tool && host.setTool) {
+				host.setTool(id);
+				return;
+			}
+			const on = getEditingId();
+			const tool = id && on ? {
+				id,
+				on
+			} : null;
+			if (tool?.id === ownTool?.id && tool?.on === ownTool?.on) return;
+			ownTool = tool;
+			notify();
+		},
+		subscribe: changed.subscribe
 	};
 }
-//#endregion
-export { i as createPathEditState, r as isSelectedNode };
 
+//#endregion
+export { createPathEditState, isSelectedNode };
 //# sourceMappingURL=pathEditState.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"pathEditState.js","names":["NO_IDS","NO_ANCHORS","isSelectedNode","scene","id","selection","createPathEditState","ownId","selectedAnchors","marquee","idSet","changed","createEmitter","notify","getEditingId","host","source","next","rect"],"sources":["../../../src/features/paths/pathEditState.ts"],"sourcesContent":["/**\n * Which path is being anchor-edited, which of its anchors are selected, and\n * the anchor marquee in flight: one object every reader shares — the\n * `editAnchors` dep, the anchor overlay, the selection overlay's suppressed\n * set, the chrome-caps rule context, and the select tool's shift-click lock.\n */\nimport { createEmitter } from '@weasel-js/registry';\nimport type { PathEditHost } from 'canvas/SceneCanvas/pathEditHost';\n\n/** A world-coord rect. */\nexport interface AnchorMarquee {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * What decides whether a stored edit target is still one: its node exists and\n * is selected, and the mode permits anchor editing. Each is read at the\n * moment of the question.\n */\nexport interface PathEditSource {\n  /** Whether `id` names a node that exists and is selected. Absent means\n   *  every id does. */\n  isSelectedNode?(id: string): boolean;\n  /** A host that owns the id; the state then keeps none of its own. */\n  host?(): PathEditHost | undefined;\n  /**\n   * Whether anchor editing is permitted right now — whether the active mode\n   * allows the `edits-anchors` capability.\n   *\n   * **Omit this when no mode registry is wired.** Absent means \"no modality,\n   * so nothing revokes edit mode\"; a predicate built from an empty capability\n   * set would revoke edit mode instantly.\n   */\n  isAllowed?(): boolean;\n}\n\nexport interface PathEditState {\n  /**\n   * The node whose anchors are editable now, or `''`: the stored id, or the\n   * host's, while `PathEditSource` still lets it stand. Masked rather than\n   * cleared: a host's mode machine can leave path-edit mode without running\n   * `exitPathEdit`, and nothing re-renders when it does, so there is no\n   * moment to write the id back.\n   */\n  getEditingId(): string;\n  /** `getEditingId()` as the set the selection overlay skips. */\n  getEditingIds(): ReadonlySet<string>;\n  setEditingId(id: string | null): void;\n  /** Selected anchors (flat indices) of the path being edited. */\n  getSelectedAnchors(): ReadonlySet<number>;\n  setSelectedAnchors(next: ReadonlySet<number>): void;\n  /** The in-flight anchor-marquee rect, in the edited path's world. */\n  getMarquee(): AnchorMarquee | null;\n  setMarquee(rect: AnchorMarquee | null): void;\n  /** Notified when a write changes what the anchor overlay paints. A host\n   *  that owns the id announces its own changes. */\n  subscribe(listener: () => void): () => void;\n}\n\nconst NO_IDS: ReadonlySet<string> = new Set();\nconst NO_ANCHORS: ReadonlySet<number> = new Set();\n\n/** Whether `id` names a node `scene` holds and `selection` includes. */\nexport function isSelectedNode(\n  scene: { get(id: never): unknown },\n  selection: { readonly current: readonly string[] },\n  id: string,\n): boolean {\n  return scene.get(id as never) != null && selection.current.includes(id);\n}\n\nexport function createPathEditState(source: PathEditSource = {}): PathEditState {\n  let ownId = '';\n  let selectedAnchors = NO_ANCHORS;\n  let marquee: AnchorMarquee | null = null;\n  let idSet = NO_IDS;\n  const changed = createEmitter();\n  const notify = changed.emit;\n\n  const getEditingId = (): string => {\n    const host = source.host?.();\n    const id = host ? host.editingId() ?? '' : ownId;\n    if (!id) return '';\n    if (source.isAllowed && !source.isAllowed()) return '';\n    if (source.isSelectedNode && !source.isSelectedNode(id)) return '';\n    return id;\n  };\n\n  return {\n    getEditingId,\n    getEditingIds() {\n      const id = getEditingId();\n      if (!id) return NO_IDS;\n      if (!idSet.has(id)) idSet = new Set([id]);\n      return idSet;\n    },\n    setEditingId(id) {\n      const host = source.host?.();\n      if (host) { host.setEditingId(id); return; }\n      const next = id ?? '';\n      if (next === ownId) return;\n      ownId = next;\n      notify();\n    },\n    getSelectedAnchors: () => selectedAnchors,\n    setSelectedAnchors(next) {\n      selectedAnchors = next;\n      notify();\n    },\n    getMarquee: () => marquee,\n    setMarquee(rect) {\n      marquee = rect;\n      notify();\n    },\n    subscribe: changed.subscribe,\n  };\n}\n"],"mappings":";;AA8DA,IAAMA,oBAA8B,IAAI,IAAI,GACtCC,oBAAkC,IAAI,IAAI;AAGhD,SAAgBC,EACd,GACA,GACA,GACS;CACT,OAAOC,EAAM,IAAIC,CAAW,KAAK,QAAQC,EAAU,QAAQ,SAASD,CAAE;AACxE;AAEA,SAAgBE,EAAoB,IAAyB,CAAC,GAAkB;CAC9E,IAAIC,IAAQ,IACRC,IAAkBP,GAClBQ,IAAgC,MAChCC,IAAQV,GACNW,IAAUC,EAAc,GACxBC,IAASF,EAAQ,MAEjBG,UAA6B;EACjC,IAAMC,IAAOC,EAAO,OAAO,GACrBZ,IAAKW,IAAOA,EAAK,UAAU,KAAK,KAAKR;EAI3C,OAHI,CAACH,KACDY,EAAO,aAAa,CAACA,EAAO,UAAU,KACtCA,EAAO,kBAAkB,CAACA,EAAO,eAAeZ,CAAE,IAAU,KACzDA;CACT;CAEA,OAAO;EACL;EACA,gBAAgB;GACd,IAAMA,IAAKU,EAAa;GAGxB,OAFKV,KACAM,EAAM,IAAIN,CAAE,MAAG,oBAAQ,IAAI,IAAI,CAACA,CAAE,CAAC,IACjCM,KAFSV;EAGlB;EACA,aAAa,GAAI;GACf,IAAMe,IAAOC,EAAO,OAAO;GAC3B,IAAID,GAAM;IAAE,EAAK,aAAaX,CAAE;IAAG;GAAQ;GAC3C,IAAMa,IAAOb,KAAM;GACnB,AAAIa,MAASV,MACb,IAAQU,GACRJ,EAAO;EACT;EACA,0BAA0BL;EAC1B,mBAAmB,GAAM;GAEvB,AADA,IAAkBS,GAClBJ,EAAO;EACT;EACA,kBAAkBJ;EAClB,WAAW,GAAM;GAEf,AADA,IAAUS,GACVL,EAAO;EACT;EACA,WAAWF,EAAQ;CACrB;AACF"}
+{"version":3,"file":"pathEditState.js","names":[],"sources":["../../../src/features/paths/pathEditState.ts"],"sourcesContent":["/**\n * Which path is being anchor-edited, which of its anchors are selected, and\n * the anchor marquee in flight: one object every reader shares — the\n * `editAnchors` dep, the anchor overlay, the selection overlay's suppressed\n * set, the chrome-caps rule context, and the select tool's shift-click lock.\n */\nimport { createEmitter } from '@weasel-js/registry';\nimport type { PathEditHost } from 'canvas/SceneCanvas/pathEditHost';\nimport type { HandleLocks } from 'interactions/actions/edit-anchors/params';\nimport type { PathEditExtension, PathEditMark } from './pathEditExtension';\n\n/** A world-coord rect. */\nexport interface AnchorMarquee {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * What decides whether a stored edit target is still one: its node exists and\n * is selected, and the mode permits anchor editing. Each is read at the\n * moment of the question.\n */\nexport interface PathEditSource {\n  /** Whether `id` names a node that exists and is selected. Absent means\n   *  every id does. */\n  isSelectedNode?(id: string): boolean;\n  /** A host that owns the id; the state then keeps none of its own. */\n  host?(): PathEditHost | undefined;\n  /**\n   * Whether anchor editing is permitted right now — whether the active mode\n   * allows the `edits-anchors` capability.\n   *\n   * **Omit this when no mode registry is wired.** Absent means \"no modality,\n   * so nothing revokes edit mode\"; a predicate built from an empty capability\n   * set would revoke edit mode instantly.\n   */\n  isAllowed?(): boolean;\n  /** The extensions it starts with; `setExtensions` replaces them. */\n  extensions?: readonly PathEditExtension[];\n}\n\nexport interface PathEditState {\n  /**\n   * The node whose anchors are editable now, or `''`: the stored id, or the\n   * host's, while `PathEditSource` still lets it stand. Masked rather than\n   * cleared: a host's mode machine can leave path-edit mode without running\n   * `exitPathEdit`, and nothing re-renders when it does, so there is no\n   * moment to write the id back.\n   */\n  getEditingId(): string;\n  /** `getEditingId()` as the set the selection overlay skips. */\n  getEditingIds(): ReadonlySet<string>;\n  setEditingId(id: string | null): void;\n  /** Selected anchors (flat indices) of the path being edited. */\n  getSelectedAnchors(): ReadonlySet<number>;\n  setSelectedAnchors(next: ReadonlySet<number>): void;\n  /** The in-flight anchor-marquee rect, in the edited path's world. */\n  getMarquee(): AnchorMarquee | null;\n  setMarquee(rect: AnchorMarquee | null): void;\n  /** The extension mark selected in place of anchors, or null. */\n  getSelectedMark(): PathEditMark | null;\n  setSelectedMark(mark: PathEditMark | null): void;\n  /** The canvas's path-edit extensions, in order. */\n  getExtensions(): readonly PathEditExtension[];\n  /** Replace the extensions; the overlay repaints when they change. */\n  setExtensions(next: readonly PathEditExtension[]): void;\n  /** The handle locks the `handleLock.*` toggles set; null until one is\n   *  pressed. Not tied to the edited path, so they outlast a change of it. */\n  getHandleLocks(): HandleLocks | null;\n  setHandleLocks(next: HandleLocks): void;\n  /**\n   * The path-edit tool in use, or null for plain anchor editing. Path edit has\n   * a set of named tools, one active at a time, each changing what a plain\n   * drag does: `'simplifyBrush'` brushes the path simpler. A tool belongs to\n   * the open path; with none open, or a different one, there is none.\n   */\n  getTool(): string | null;\n  /** Switch tool, or pass null to go back to plain anchor editing. Ignored\n   *  with no path open. */\n  setTool(id: string | null): void;\n  /** Notified when a write changes what the anchor overlay paints. A host\n   *  that owns the id announces its own changes. */\n  subscribe(listener: () => void): () => void;\n}\n\nconst NO_IDS: ReadonlySet<string> = new Set();\nconst NO_EXTENSIONS: readonly PathEditExtension[] = [];\nconst NO_ANCHORS: ReadonlySet<number> = new Set();\n\n/** Whether `id` names a node `scene` holds and `selection` includes. */\nexport function isSelectedNode(\n  scene: { get(id: never): unknown },\n  selection: { readonly current: readonly string[] },\n  id: string,\n): boolean {\n  return scene.get(id as never) != null && selection.current.includes(id);\n}\n\nexport function createPathEditState(source: PathEditSource = {}): PathEditState {\n  let ownId = '';\n  let selectedAnchors = NO_ANCHORS;\n  let marquee: AnchorMarquee | null = null;\n  let handleLocks: HandleLocks | null = null;\n  let ownTool: { id: string; on: string } | null = null;\n  let idSet = NO_IDS;\n  let selectedMark: PathEditMark | null = null;\n  let extensions = source.extensions ?? NO_EXTENSIONS;\n  const changed = createEmitter();\n  const notify = changed.emit;\n\n  const next = (id: string | null): string => id ?? '';\n  const getEditingId = (): string => {\n    const host = source.host?.();\n    const id = host ? host.editingId() ?? '' : ownId;\n    if (!id) return '';\n    if (source.isAllowed && !source.isAllowed()) return '';\n    if (source.isSelectedNode && !source.isSelectedNode(id)) return '';\n    return id;\n  };\n\n  return {\n    getEditingId,\n    getEditingIds() {\n      const id = getEditingId();\n      if (!id) return NO_IDS;\n      if (!idSet.has(id)) idSet = new Set([id]);\n      return idSet;\n    },\n    setEditingId(id) {\n      const host = source.host?.();\n      if (next(id) !== getEditingId()) ownTool = null;\n      if (host) { host.setEditingId(id); return; }\n      if (next(id) === ownId) return;\n      ownId = next(id);\n      notify();\n    },\n    getSelectedAnchors: () => {\n      const host = source.host?.();\n      return host?.selectedAnchors && host.setSelectedAnchors ? host.selectedAnchors() : selectedAnchors;\n    },\n    setSelectedAnchors(next) {\n      const host = source.host?.();\n      if (host?.selectedAnchors && host.setSelectedAnchors) { host.setSelectedAnchors(next); return; }\n      selectedAnchors = next;\n      notify();\n    },\n    getMarquee: () => marquee,\n    setMarquee(rect) {\n      marquee = rect;\n      notify();\n    },\n    getSelectedMark: () => selectedMark,\n    setSelectedMark(mark) {\n      if (mark?.owner === selectedMark?.owner && mark?.index === selectedMark?.index) return;\n      selectedMark = mark;\n      notify();\n    },\n    getExtensions: () => extensions,\n    setExtensions(next) {\n      if (next === extensions) return;\n      extensions = next;\n      notify();\n    },\n    getHandleLocks: () => handleLocks,\n    setHandleLocks(next) {\n      handleLocks = { angle: next.angle, length: next.length };\n      notify();\n    },\n    getTool() {\n      const on = getEditingId();\n      const host = source.host?.();\n      if (host?.tool) return on ? host.tool() : null;\n      // Dropped on the read that finds its path gone: a host can close the\n      // path without telling this state.\n      if (ownTool && ownTool.on !== on) ownTool = null;\n      return ownTool?.id ?? null;\n    },\n    setTool(id) {\n      const host = source.host?.();\n      if (host?.tool && host.setTool) { host.setTool(id); return; }\n      const on = getEditingId();\n      const tool = id && on ? { id, on } : null;\n      if (tool?.id === ownTool?.id && tool?.on === ownTool?.on) return;\n      ownTool = tool;\n      notify();\n    },\n    subscribe: changed.subscribe,\n  };\n}\n"],"mappings":";;;;;;;;;AAuFA,IAAM,yBAA8B,IAAI,IAAI;AAC5C,IAAM,gBAA8C,CAAC;AACrD,IAAM,6BAAkC,IAAI,IAAI;;AAGhD,SAAgB,eACd,OACA,WACA,IACS;CACT,OAAO,MAAM,IAAI,EAAW,KAAK,QAAQ,UAAU,QAAQ,SAAS,EAAE;AACxE;AAEA,SAAgB,oBAAoB,SAAyB,CAAC,GAAkB;CAC9E,IAAI,QAAQ;CACZ,IAAI,kBAAkB;CACtB,IAAI,UAAgC;CACpC,IAAI,cAAkC;CACtC,IAAI,UAA6C;CACjD,IAAI,QAAQ;CACZ,IAAI,eAAoC;CACxC,IAAI,aAAa,OAAO,cAAc;CACtC,MAAM,UAAU,cAAc;CAC9B,MAAM,SAAS,QAAQ;CAEvB,MAAM,QAAQ,OAA8B,MAAM;CAClD,MAAM,qBAA6B;EACjC,MAAM,OAAO,OAAO,OAAO;EAC3B,MAAM,KAAK,OAAO,KAAK,UAAU,KAAK,KAAK;EAC3C,IAAI,CAAC,IAAI,OAAO;EAChB,IAAI,OAAO,aAAa,CAAC,OAAO,UAAU,GAAG,OAAO;EACpD,IAAI,OAAO,kBAAkB,CAAC,OAAO,eAAe,EAAE,GAAG,OAAO;EAChE,OAAO;CACT;CAEA,OAAO;EACL;EACA,gBAAgB;GACd,MAAM,KAAK,aAAa;GACxB,IAAI,CAAC,IAAI,OAAO;GAChB,IAAI,CAAC,MAAM,IAAI,EAAE,GAAG,wBAAQ,IAAI,IAAI,CAAC,EAAE,CAAC;GACxC,OAAO;EACT;EACA,aAAa,IAAI;GACf,MAAM,OAAO,OAAO,OAAO;GAC3B,IAAI,KAAK,EAAE,MAAM,aAAa,GAAG,UAAU;GAC3C,IAAI,MAAM;IAAE,KAAK,aAAa,EAAE;IAAG;GAAQ;GAC3C,IAAI,KAAK,EAAE,MAAM,OAAO;GACxB,QAAQ,KAAK,EAAE;GACf,OAAO;EACT;EACA,0BAA0B;GACxB,MAAM,OAAO,OAAO,OAAO;GAC3B,OAAO,MAAM,mBAAmB,KAAK,qBAAqB,KAAK,gBAAgB,IAAI;EACrF;EACA,mBAAmB,MAAM;GACvB,MAAM,OAAO,OAAO,OAAO;GAC3B,IAAI,MAAM,mBAAmB,KAAK,oBAAoB;IAAE,KAAK,mBAAmB,IAAI;IAAG;GAAQ;GAC/F,kBAAkB;GAClB,OAAO;EACT;EACA,kBAAkB;EAClB,WAAW,MAAM;GACf,UAAU;GACV,OAAO;EACT;EACA,uBAAuB;EACvB,gBAAgB,MAAM;GACpB,IAAI,MAAM,UAAU,cAAc,SAAS,MAAM,UAAU,cAAc,OAAO;GAChF,eAAe;GACf,OAAO;EACT;EACA,qBAAqB;EACrB,cAAc,MAAM;GAClB,IAAI,SAAS,YAAY;GACzB,aAAa;GACb,OAAO;EACT;EACA,sBAAsB;EACtB,eAAe,MAAM;GACnB,cAAc;IAAE,OAAO,KAAK;IAAO,QAAQ,KAAK;GAAO;GACvD,OAAO;EACT;EACA,UAAU;GACR,MAAM,KAAK,aAAa;GACxB,MAAM,OAAO,OAAO,OAAO;GAC3B,IAAI,MAAM,MAAM,OAAO,KAAK,KAAK,KAAK,IAAI;GAG1C,IAAI,WAAW,QAAQ,OAAO,IAAI,UAAU;GAC5C,OAAO,SAAS,MAAM;EACxB;EACA,QAAQ,IAAI;GACV,MAAM,OAAO,OAAO,OAAO;GAC3B,IAAI,MAAM,QAAQ,KAAK,SAAS;IAAE,KAAK,QAAQ,EAAE;IAAG;GAAQ;GAC5D,MAAM,KAAK,aAAa;GACxB,MAAM,OAAO,MAAM,KAAK;IAAE;IAAI;GAAG,IAAI;GACrC,IAAI,MAAM,OAAO,SAAS,MAAM,MAAM,OAAO,SAAS,IAAI;GAC1D,UAAU;GACV,OAAO;EACT;EACA,WAAW,QAAQ;CACrB;AACF"}