@weasel-js/core 1.10.0 → 1.11.0

package/dist/interactions/actions/edit-anchors/action.js

@@ -1,98 +1,277 @@
-import { editingLayer as e, inPlane as t } from "../planeInput.js";
-import { anchorAt as n, editAnchorSet as r, moveHandleTo as i, pathToAnchors as a, translateAnchorBy as o, worldEditToStorage as s } from "@weasel-js/geom";
-import { isAnchorOrControl as c } from "@weasel-js/routing";
+import { pathOperationTags } from "../pathGestureTags.js";
+import { editingLayer, inPlane } from "../planeInput.js";
+import { SNAP_ROLES, snapMods } from "../../../features/snap/roles.js";
+import { inputSession } from "../../../features/snap/session2d.js";
+import { pathEditToolActive } from "../defaults/pathEditTools.js";
+import { HANDLE_LOCK_ROLES, lockHandle, locksInForce } from "./handleDrag.js";
+import { locksOf } from "./params.js";
+import { pathEditPreview } from "./preview.js";
+import { claimWheel, dragWeights, endExtensionDrags, extensionOverlays, placeHandle, startExtensionDrags, translateWeighted } from "./extensionDrags.js";
+import { editedPathSymmetries } from "./symmetry.js";
+import { anchorAt, editAnchorSetTracked, moveHandleSymmetric, moveHandleTo, pathAwayFromAnchors, pathToAnchors, translateAnchorsSymmetric } from "@weasel-js/geom";
+import { ActionDisabledReason, isAnchorOrControl, resolveParams, roleReader } from "@weasel-js/routing";
+
 //#region src/interactions/actions/edit-anchors/action.ts
-function l(e) {
-	let t = e.match(/^(anchor|controlIn|controlOut):(\d+)$/);
-	return t ? {
-		anchorIndex: parseInt(t[2], 10),
-		part: t[1]
-	} : null;
+/**
+* Parse an anchor affordance kind — `'anchor:N'` | `'controlIn:N'` |
+* `'controlOut:N'`, where N is the flat anchor index — or `null` when the
+* affordance is not an anchor kind.
+*/
+function parseAnchorAffordance(kind) {
+	const m = kind.match(/^(anchor|controlIn|controlOut):(\d+)$/);
+	if (!m) return null;
+	return {
+		anchorIndex: parseInt(m[2], 10),
+		part: m[1]
+	};
 }
-function u(e, t, n) {
-	if (n) {
-		let n = new Set(e);
-		return n.has(t) ? n.delete(t) : n.add(t), n;
+/**
+* Resolve what a press on `anchorIndex` should leave selected.
+*
+* Shift toggles. A bare press on an anchor that's already part of the
+* selection keeps the selection intact (so the drag moves the whole set);
+* a bare press anywhere else collapses to just that anchor.
+*/
+function selectionAfterAnchorPress(current, anchorIndex, additive) {
+	if (additive) {
+		const next = new Set(current);
+		if (next.has(anchorIndex)) next.delete(anchorIndex);
+		else next.add(anchorIndex);
+		return next;
 	}
-	return e.has(t) && e.size > 1 ? new Set(e) : /* @__PURE__ */ new Set([t]);
+	if (current.has(anchorIndex) && current.size > 1) return new Set(current);
+	return /* @__PURE__ */ new Set([anchorIndex]);
+}
+/**
+* An anchor drag's snap: a `point` session, begun on the first move, for
+* where the pressed anchor goes. The edited path offers no targets but what
+* the drag leaves still of it, and Shift holds the anchor to the axes and
+* diagonals through its press.
+*/
+function anchorDragSnap(snap, press) {
+	let session = null;
+	return {
+		at(world, mods) {
+			if (!session) {
+				const { path, anchors } = pathAwayFromAnchors(press.originPose, press.dragging);
+				const req = {
+					gesture: "point",
+					press: press.origin,
+					ids: [press.id],
+					also: {
+						paths: [path],
+						anchors
+					},
+					constrain: "axis"
+				};
+				session = snap?.begin(req) ?? inputSession(req);
+			}
+			return session.at(world, mods).point;
+		},
+		end() {
+			session?.end();
+			session = null;
+		}
+	};
+}
+var paramsOf = (opts) => resolveParams(opts?.params) ?? {};
+/** Take `next` as the frame to show, finished by the dep. A frame it cannot
+*  finish is dropped, so the path stays at the last one it could. */
+function track(scratch, next) {
+	if (!next) return;
+	const { dep, id } = scratch;
+	const done = dep.finishEdit ? dep.finishEdit(id, next.path, next.origins) : {
+		path: next.path,
+		others: []
+	};
+	if (!done) return;
+	scratch.currentPose = done.path;
+	scratch.others = done.others;
+	scratch.origins = next.origins;
+}
+/** The anchor and the handle a press on `part` grabbed; null for an anchor press. */
+function handlePressOf(origin, part) {
+	const handle = part === "controlIn" ? origin.inHandle : part === "controlOut" ? origin.outHandle : void 0;
+	return handle ? {
+		anchor: {
+			x: origin.x,
+			y: origin.y
+		},
+		handle: { ...handle }
+	} : null;
+}
+/** Move the dragged anchors to follow `to`, and the anchors the extensions
+*  weight by their shares. A weighted drag moves no symmetric images. */
+function moveAnchors(scratch, to) {
+	if (scratch.dragging.length === 0) return;
+	const dx = to.x - scratch.anchorOrigin.x;
+	const dy = to.y - scratch.anchorOrigin.y;
+	const weights = dragWeights(scratch.drags, scratch.dragging);
+	track(scratch, editAnchorSetTracked(scratch.originPose, (set) => {
+		if (weights) translateWeighted(set, weights, dx, dy);
+		else translateAnchorsSymmetric(set, scratch.dragging, dx, dy, scratch.symmetries);
+	}));
+}
+/** The modifiers `editAnchors` reads while it runs: Shift on the press adds
+*  to the anchor selection, Alt breaks a smooth anchor's mirror, the handle
+*  locks, and Shift holds an anchor drag to the axes and diagonals. An anchor
+*  drag also reads `snap.suspend` at its default key, Ctrl, which is not
+*  declared here because on a handle Ctrl holds the length. */
+var EDIT_ANCHORS_ROLES = {
+	"selection.add": {
+		label: "Add to the anchor selection",
+		keys: ["shift"]
+	},
+	"mirror.break": {
+		label: "Break the handles' mirror",
+		keys: ["alt"]
+	},
+	...HANDLE_LOCK_ROLES,
+	"snap.constrain": SNAP_ROLES["snap.constrain"]
+};
+var roleHeld = roleReader(EDIT_ANCHORS_ROLES);
+/** Move the dragged handle toward the pointer, under the locks in force, then
+*  wherever the extensions place it. */
+function moveHandle(scratch, ctx, params) {
+	const side = scratch.part === "controlIn" ? "in" : "out";
+	const held = (ctx.deps.editAnchors ?? scratch.dep).handleLocks ?? locksOf(params.handleLock);
+	const locks = locksInForce(held, ctx);
+	const locked = scratch.handlePress ? lockHandle(scratch.handlePress, ctx.world, locks) : {
+		to: ctx.world,
+		guide: null
+	};
+	scratch.guide = locked.guide;
+	const to = placeHandle(scratch.drags, locked.to, { locks });
+	const alt = roleHeld(ctx, "mirror.break");
+	const move = scratch.symmetries.length > 0 ? (set) => moveHandleSymmetric(set, scratch.anchorIndex, side, to.x, to.y, alt, scratch.symmetries) : (set) => moveHandleTo(set, scratch.anchorIndex, side, to.x, to.y, alt);
+	track(scratch, editAnchorSetTracked(scratch.originPose, move));
+}
+/**
+* What a press drags, the selection updated first, before any move: a handle
+* press drags its anchor's handle; an anchor press selects as
+* {@link selectionAfterAnchorPress} says and drags what it left selected —
+* nothing when Shift took the pressed anchor out of it.
+*/
+function draggedByPress(dep, press, shift) {
+	if (press.part !== "anchor") return [press.anchorIndex];
+	const next = selectionAfterAnchorPress(dep.selectedAnchors, press.anchorIndex, shift);
+	dep.setSelectedAnchors(next);
+	return next.has(press.anchorIndex) ? [...next] : [];
 }
-var d = t({
+/** Static descriptor for the `editAnchors` Action. */
+var editAnchorsAction = inPlane({
 	id: "editAnchors",
 	label: "Edit Anchors",
+	tags: pathOperationTags("drag"),
 	defaultBinding: {
 		kind: "drag",
-		target: { kindOf: c }
+		target: { kindOf: isAnchorOrControl }
 	},
 	eligible: { capability: "edits-anchors" },
-	requires: ["selection", "editAnchors"],
+	modifierRoles: EDIT_ANCHORS_ROLES,
+	requires: [
+		"selection",
+		"editAnchors",
+		"pathSymmetry",
+		"snap"
+	],
 	invoker: {
 		timing: "ongoing",
-		start(e, t) {
-			let c = e.deps.editAnchors;
-			if (!c) return {};
-			let d = e.drag?.affordance;
-			if (!d) return {};
-			let f = l(d.kind);
-			if (!f) return {};
-			let { editingId: p } = c, m = c.getEditablePath(p);
-			if (!m || m.kind !== "polygon") return {};
-			let h = c.getStorageKind(p);
-			if (h !== "pose" && h !== "data") return {};
-			let g = a(m), _ = n(g, f.anchorIndex);
-			if (!_ || f.part === "controlIn" && !_.inHandle || f.part === "controlOut" && !_.outHandle) return {};
-			let v = [f.anchorIndex];
-			if (f.part === "anchor") {
-				let t = u(c.selectedAnchors, f.anchorIndex, e.modifiers.shift);
-				c.setSelectedAnchors(t), v = t.has(f.anchorIndex) ? [...t] : [];
-			}
-			let y = h === "data" ? c.getNodeShape(p) : null, b = y ? y.pose : void 0, x = y ? y.data : void 0, S = {
-				dep: c,
-				id: p,
-				anchorIndex: f.anchorIndex,
-				part: f.part,
-				dragging: v,
+		start(ctx, opts) {
+			const dep = ctx.deps.editAnchors;
+			if (!dep) return {};
+			const affordance = ctx.drag?.affordance;
+			if (!affordance) return {};
+			const anchorInfo = parseAnchorAffordance(affordance.kind);
+			if (!anchorInfo) return {};
+			const { editingId } = dep;
+			const worldPath = dep.getEditablePath(editingId);
+			if (!worldPath || worldPath.kind !== "polygon") return {};
+			const decoded = pathToAnchors(worldPath);
+			const origin = anchorAt(decoded, anchorInfo.anchorIndex);
+			if (!origin) return {};
+			if (anchorInfo.part === "controlIn" && !origin.inHandle) return {};
+			if (anchorInfo.part === "controlOut" && !origin.outHandle) return {};
+			let active = false;
+			const preview = pathEditPreview(dep, editingId, () => active ? scratch.currentPose : null, () => active ? scratch.others : []);
+			if (!preview) return {};
+			const dragging = draggedByPress(dep, anchorInfo, roleHeld(ctx, "selection.add"));
+			const scratch = {
+				dep,
+				id: editingId,
+				anchorIndex: anchorInfo.anchorIndex,
+				part: anchorInfo.part,
+				dragging,
 				anchorOrigin: {
-					x: _.x,
-					y: _.y
+					x: origin.x,
+					y: origin.y
 				},
-				originPose: m,
-				currentPose: m,
-				storageKind: h
-			}, C = !1;
+				handlePress: handlePressOf(origin, anchorInfo.part),
+				guide: null,
+				drags: startExtensionDrags(dep.extensions, {
+					id: editingId,
+					node: dep.getNodeShape(editingId),
+					path: worldPath,
+					anchors: decoded,
+					part: anchorInfo.part,
+					anchorIndex: anchorInfo.anchorIndex,
+					dragging: anchorInfo.part === "anchor" ? dragging : [],
+					scale: ctx.deps.view?.get().scale,
+					...ctx.deps.snap ? { snap: ctx.deps.snap } : {}
+				}),
+				lastMove: null,
+				originPose: worldPath,
+				currentPose: worldPath,
+				symmetries: editedPathSymmetries(ctx.deps.pathSymmetry, editingId, decoded),
+				others: []
+			};
+			const snapAnchor = anchorDragSnap(ctx.deps.snap, {
+				id: editingId,
+				origin: scratch.anchorOrigin,
+				originPose: worldPath,
+				dragging
+			});
+			const move = (moveCtx) => {
+				scratch.lastMove = moveCtx;
+				if (scratch.part !== "anchor") return moveHandle(scratch, moveCtx, paramsOf(opts));
+				moveAnchors(scratch, snapAnchor.at(moveCtx.world, snapMods(moveCtx)));
+			};
 			return {
 				kind: "edit-anchors",
-				onMove(e) {
-					if (S.part === "anchor") {
-						if (S.dragging.length === 0) return;
-						let t = e.world.x - S.anchorOrigin.x, n = e.world.y - S.anchorOrigin.y, i = r(S.originPose, (e) => {
-							for (let r of S.dragging) o(e, r, t, n);
-						});
-						i && (S.currentPose = i);
-					} else {
-						let t = S.part === "controlIn" ? "in" : "out", n = r(S.originPose, (n) => i(n, S.anchorIndex, t, e.world.x, e.world.y, e.modifiers.alt));
-						n && (S.currentPose = n);
-					}
-					C = !0;
+				onMove(moveCtx) {
+					move(moveCtx);
+					active = true;
 				},
-				onEnd(e, t) {
-					C = !1, t !== "cancel" && S.originPose !== S.currentPose && S.dep.applyEdit(S.id, S.currentPose, "Edit anchors");
+				onWheel(wheelCtx) {
+					if (!wheelCtx.wheel || !claimWheel(scratch.drags, wheelCtx.wheel)) return false;
+					if (scratch.lastMove) move(scratch.lastMove);
+					return true;
 				},
-				previewIds: () => C ? [S.id] : null,
-				previewPose: (e) => !C || e !== S.id ? null : S.storageKind === "pose" ? S.currentPose : b ? s(b, S.currentPose).pose : null,
-				previewData: (e) => {
-					if (!C || e !== S.id || S.storageKind !== "data" || !x) return null;
-					let { path: t } = s(b, S.currentPose);
-					return {
-						...x,
-						path: t
-					};
-				}
+				overlay() {
+					if (!active) return null;
+					const extra = scratch.drags.length > 0 ? extensionOverlays(scratch.drags, pathToAnchors(scratch.currentPose)) : [];
+					const all = scratch.guide ? [scratch.guide, ...extra] : extra;
+					return all.length > 0 ? all : null;
+				},
+				onEnd(_endCtx, reason) {
+					active = false;
+					try {
+						if (reason === "cancel" || scratch.originPose === scratch.currentPose) return;
+						scratch.dep.applyEdit(scratch.id, scratch.currentPose, "Edit anchors", scratch.origins);
+					} finally {
+						snapAnchor.end();
+						endExtensionDrags(scratch.drags);
+					}
+				},
+				previewIds: preview.previewIds,
+				previewPose: preview.previewPose,
+				previewData: preview.previewData
 			};
 		}
 	},
-	enabled: () => !0
-}, e);
-//#endregion
-export { d as editAnchorsAction, u as selectionAfterAnchorPress };
+	enabled: (deps) => pathEditToolActive(deps) ? ActionDisabledReason.NotApplicable : true
+}, editingLayer);
 
+//#endregion
+export { EDIT_ANCHORS_ROLES, editAnchorsAction, selectionAfterAnchorPress };
 //# sourceMappingURL=action.js.map

package/dist/interactions/actions/edit-anchors/action.js.map

@@ -1 +1 @@
-{"version":3,"file":"action.js","names":["parseAnchorAffordance","m","kind","selectionAfterAnchorPress","additive","next","current","anchorIndex","editAnchorsAction","inPlane","isAnchorOrControl","dep","ctx","affordance","anchorInfo","worldPath","editingId","storageKind","decoded","pathToAnchors","origin","anchorAt","dragging","nodeShape","originRectPose","originData","scratch","active","dx","moveCtx","dy","editAnchorSet","flat","set","side","moveHandleTo","reason","id","worldEditToStorage","editingLayer"],"sources":["../../../../src/interactions/actions/edit-anchors/action.ts"],"sourcesContent":["/**\n * `editAnchorsAction` — ongoing Action descriptor for editing polygon anchors.\n *\n *   - **Press** selects. Bare press replaces the anchor selection; Shift\n *     toggles the pressed anchor in or out of it. Pressing an anchor that\n *     is already part of a multi-anchor selection leaves the selection\n *     alone, so you can grab a set and move it.\n *   - **Drag** then moves whatever the press left selected — one anchor,\n *     or every selected anchor together.\n *   - **Dragging a control handle** moves just that handle, mirroring the\n *     opposite one while the anchor is smooth. Alt breaks the mirror.\n *\n * Selection lives on the `editAnchors` dep (flat anchor indices) rather\n * than in this handle's scratch, because the keyboard actions\n * (`nudgeAnchors`, `deleteAnchors`) and the overlay all need to read it\n * between gestures.\n *\n * Operational when the consumer wires the `editAnchors` dep, and\n * `buildAffordanceAt` with a `getAnchorState` thunk so the dispatcher\n * classifies anchor/control-handle hits as `anchor:N`, `controlIn:N`, or\n * `controlOut:N` affordances on pointerdown. On any other affordance `start`\n * returns `{}` so other bindings can handle the drag.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\nimport { isAnchorOrControl } from '@weasel-js/routing';\nimport {\n  anchorAt,\n  editAnchorSet,\n  moveHandleTo,\n  translateAnchorBy,\n  type AnchorSet,\n} from '@weasel-js/geom';\nimport { pathToAnchors, type PolygonPath } from '@weasel-js/geom';\nimport { worldEditToStorage } from '@weasel-js/geom';\nimport { inPlane, editingLayer } from '../planeInput';\n\n/**\n * Parse an anchor affordance kind — `'anchor:N'` | `'controlIn:N'` |\n * `'controlOut:N'`, where N is the flat anchor index — or `null` when the\n * affordance is not an anchor kind.\n */\nfunction parseAnchorAffordance(\n  kind: string,\n): { anchorIndex: number; part: 'anchor' | 'controlIn' | 'controlOut' } | null {\n  const m = kind.match(/^(anchor|controlIn|controlOut):(\\d+)$/);\n  if (!m) return null;\n  return {\n    anchorIndex: parseInt(m[2], 10),\n    part: m[1] as 'anchor' | 'controlIn' | 'controlOut',\n  };\n}\n\n/**\n * Resolve what a press on `anchorIndex` should leave selected.\n *\n * Shift toggles. A bare press on an anchor that's already part of the\n * selection keeps the selection intact (so the drag moves the whole set);\n * a bare press anywhere else collapses to just that anchor.\n */\nexport function selectionAfterAnchorPress(\n  current: ReadonlySet<number>,\n  anchorIndex: number,\n  additive: boolean,\n): Set<number> {\n  if (additive) {\n    const next = new Set(current);\n    if (next.has(anchorIndex)) next.delete(anchorIndex);\n    else next.add(anchorIndex);\n    return next;\n  }\n  if (current.has(anchorIndex) && current.size > 1) return new Set(current);\n  return new Set([anchorIndex]);\n}\n\ninterface EditAnchorsScratch {\n  dep: EditAnchorsDep;\n  id: string;\n  anchorIndex: number;\n  /** `'anchor'` drags on-curve points (and their handles) by a delta.\n   *  `'controlIn'` / `'controlOut'` drag one control point to an absolute\n   *  world coord. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n  /** Anchors this drag moves — the pressed one, or the whole anchor\n   *  selection when the press landed inside it. Flat indices. */\n  dragging: readonly number[];\n  /** World position of the pressed anchor at drag start; the drag delta is\n   *  measured from here rather than accumulated per move, so the geometry\n   *  is always derived from `originPose` in one step. */\n  anchorOrigin: { x: number; y: number };\n  originPose: PolygonPath;\n  currentPose: PolygonPath;\n  /** Where the polygon lives on the node — drives which preview-ghost\n   *  axes the handle populates (`previewPose` only for pose-as-polygon,\n   *  `previewPose` + `previewData` for data.path). */\n  storageKind: 'pose' | 'data';\n}\n\n/** Static descriptor for the `editAnchors` Action. */\nexport const editAnchorsAction: Action & { requires: string[] } = inPlane({\n  id: 'editAnchors',\n  label: 'Edit Anchors',\n  defaultBinding: {\n    kind: 'drag',\n    // Only matches drags whose pointerdown hit an anchor or control handle.\n    // Ties moveAction's `selected-body` on specificity and registers after\n    // it, so move declines these presses in `start`.\n    target: { kindOf: isAnchorOrControl },\n  },\n  eligible: { capability: 'edits-anchors' },\n  requires: ['selection', 'editAnchors'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const dep = ctx.deps.editAnchors;\n      if (!dep) return {};\n\n      const affordance = ctx.drag?.affordance;\n      if (!affordance) {\n        // No affordance hit → this drag doesn't target an anchor handle.\n        // Let other bindings handle it (the handle returns {}, dispatcher moves on).\n        return {};\n      }\n\n      const anchorInfo = parseAnchorAffordance(affordance.kind);\n      if (!anchorInfo) {\n        // Affordance is a non-anchor kind (e.g. resize handle, rotate handle).\n        return {};\n      }\n\n      const { editingId } = dep;\n      // World-coord polygon. For pose-as-polygon nodes this equals\n      // node.pose; for data.path nodes it's pathInWorld-projected (translate +\n      // rotation) so the anchor world coords match what the user clicked.\n      const worldPath = dep.getEditablePath(editingId) as PolygonPath | undefined;\n      if (!worldPath || worldPath.kind !== 'polygon') return {};\n      const storageKind = dep.getStorageKind(editingId);\n      if (storageKind !== 'pose' && storageKind !== 'data') return {};\n\n      // Decode once to validate the affordance index against the actual\n      // geometry and to read the press origin. A stale affordance (the\n      // path changed between pointerdown and now) fails here rather than\n      // silently editing whichever anchor now holds that index.\n      const decoded = pathToAnchors(worldPath) as AnchorSet;\n      const origin = anchorAt(decoded, anchorInfo.anchorIndex);\n      if (!origin) return {};\n      if (anchorInfo.part === 'controlIn' && !origin.inHandle) return {};\n      if (anchorInfo.part === 'controlOut' && !origin.outHandle) return {};\n\n      // --- Press semantics: selection updates immediately, before any move.\n      let dragging: readonly number[] = [anchorInfo.anchorIndex];\n      if (anchorInfo.part === 'anchor') {\n        const next = selectionAfterAnchorPress(\n          dep.selectedAnchors,\n          anchorInfo.anchorIndex,\n          ctx.modifiers.shift,\n        );\n        dep.setSelectedAnchors(next);\n        // Shift-pressing an anchor OUT of the selection must not then drag\n        // it; drag whatever the press left selected, intersected with the\n        // pressed anchor's membership.\n        dragging = next.has(anchorInfo.anchorIndex)\n          ? [...next]\n          : [];\n      }\n\n      // For data.path nodes, the original rect pose + data that previewPose /\n      // previewData derive from, captured at start.\n      const nodeShape = storageKind === 'data' ? dep.getNodeShape(editingId) : null;\n      const originRectPose =\n        nodeShape ? (nodeShape.pose as { x: number; y: number; width: number; height: number }) : undefined;\n      const originData = nodeShape ? (nodeShape.data as object) : undefined;\n\n      const scratch: EditAnchorsScratch = {\n        dep,\n        id: editingId,\n        anchorIndex: anchorInfo.anchorIndex,\n        part: anchorInfo.part,\n        dragging,\n        anchorOrigin: { x: origin.x, y: origin.y },\n        originPose: worldPath,\n        currentPose: worldPath,\n        storageKind,\n      };\n\n      let active = false;\n\n      return {\n        kind: 'edit-anchors',\n        onMove(moveCtx: InvocationCtx): void {\n          if (scratch.part === 'anchor') {\n            if (scratch.dragging.length === 0) return;\n            const dx = moveCtx.world.x - scratch.anchorOrigin.x;\n            const dy = moveCtx.world.y - scratch.anchorOrigin.y;\n            const next = editAnchorSet(scratch.originPose, (set) => {\n              for (const flat of scratch.dragging) translateAnchorBy(set, flat, dx, dy);\n            });\n            if (next) scratch.currentPose = next;\n          } else {\n            const side = scratch.part === 'controlIn' ? 'in' : 'out';\n            const next = editAnchorSet(scratch.originPose, (set) =>\n              moveHandleTo(\n                set,\n                scratch.anchorIndex,\n                side,\n                moveCtx.world.x,\n                moveCtx.world.y,\n                // Alt breaks the smooth mirror for this drag — read live so\n                // the user can press or release Alt mid-drag.\n                moveCtx.modifiers.alt,\n              ),\n            );\n            if (next) scratch.currentPose = next;\n          }\n          active = true;\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          active = false;\n          if (reason === 'cancel') return;\n          if (scratch.originPose === scratch.currentPose) return;\n          scratch.dep.applyEdit(scratch.id, scratch.currentPose, 'Edit anchors');\n        },\n        previewIds: () => (active ? [scratch.id] : null),\n        previewPose: (id: string): unknown | null => {\n          if (!active || id !== scratch.id) return null;\n          if (scratch.storageKind === 'pose') {\n            // Pose IS the polygon — preview pose is the polygon itself.\n            return scratch.currentPose;\n          }\n          // data.path: invert the world edit the same way the commit does, so\n          // the preview ghost (which re-applies pose.rotation via the render\n          // wrap) matches the committed result — no double-rotation.\n          if (!originRectPose) return null;\n          return worldEditToStorage(originRectPose, scratch.currentPose).pose;\n        },\n        previewData: (id: string): unknown | null => {\n          if (!active || id !== scratch.id) return null;\n          if (scratch.storageKind !== 'data') return null;\n          if (!originData) return null;\n          // Stored path is the unrotated, origin-aligned contour; the render\n          // invariant `pathInWorld(stored, pose) === world` holds.\n          const { path } = worldEditToStorage(originRectPose!, scratch.currentPose);\n          return { ...originData, path };\n        },\n      };\n    },\n  },\n  enabled: () => true,\n}, editingLayer);\n"],"mappings":"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"}
+{"version":3,"file":"action.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/action.ts"],"sourcesContent":["/**\n * `editAnchorsAction` — ongoing Action descriptor for editing polygon anchors.\n *\n *   - **Press** selects. Bare press replaces the anchor selection; Shift\n *     toggles the pressed anchor in or out of it. Pressing an anchor that\n *     is already part of a multi-anchor selection leaves the selection\n *     alone, so you can grab a set and move it.\n *   - **Drag** then moves whatever the press left selected — one anchor,\n *     or every selected anchor together. The pressed anchor snaps through\n *     the `snap` dep's `point` session, to what the drag leaves still of the\n *     path and to the canvas's targets; Shift holds it to the axes and\n *     diagonals through its press, and Ctrl suspends the snap.\n *   - **Dragging a control handle** moves just that handle, mirroring the\n *     opposite one while the anchor is smooth. Alt breaks the mirror; Shift\n *     holds the handle to the angle it had at the press, changing only its\n *     length; Mod (Cmd or Ctrl) holds its length, changing only its angle;\n *     both freeze it. The `editAnchors` dep's `handleLocks`, or else the\n *     `handleLock` param ({@link EditAnchorsParams}), holds a lock with no\n *     modifier. The lock in force draws its guide as a `polyline` overlay\n *     of role `lock`: the line, or the circle round the anchor.\n *   - **Path-edit extensions shape the drag** through their `drag`: anchors\n *     that follow an anchor drag by a share of it, where a dragged handle\n *     goes after the locks, the wheel mid-drag, and overlays of their own.\n *   - **Every frame is finished** by the dep's `finishEdit`, so what a\n *     path-edit extension keeps true holds while the drag runs.\n *   - **Under a `pathSymmetry` dep**, on a path that is its own image under\n *     some of its transforms, every image of what is dragged follows it.\n *\n * Selection lives on the `editAnchors` dep (flat anchor indices) rather\n * than in this handle's scratch, because the keyboard actions\n * (`nudgeAnchors`, `deleteAnchors`) and the overlay all need to read it\n * between gestures.\n *\n * Operational when the consumer wires the `editAnchors` dep, and\n * `buildAffordanceAt` with a `getAnchorState` thunk so the dispatcher\n * classifies anchor/control-handle hits as `anchor:N`, `controlIn:N`, or\n * `controlOut:N` affordances on pointerdown. On any other affordance `start`\n * returns `{}` so other bindings can handle the drag.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle, OngoingOverlay } from '@weasel-js/routing';\nimport type { EditAnchorsDep, SnapDep } from '../depSchema';\nimport type { SnapBegin, SnapMods, SnapSession } from '../snapDep';\nimport { inputSession } from 'features/snap/session2d';\nimport { SNAP_ROLES, snapMods } from 'features/snap/roles';\nimport { ActionDisabledReason, isAnchorOrControl, resolveParams, roleReader, type ModifierRoles } from '@weasel-js/routing';\nimport {\n  anchorAt,\n  editAnchorSetTracked,\n  moveHandleSymmetric,\n  moveHandleTo,\n  pathAwayFromAnchors,\n  translateAnchorsSymmetric,\n  type AnchorSet,\n  type AnchorSymmetry,\n  type PenAnchor,\n  type PointOrigin,\n} from '@weasel-js/geom';\nimport { pathToAnchors, type PolygonPath } from '@weasel-js/geom';\nimport { inPlane, editingLayer } from '../planeInput';\nimport { HANDLE_LOCK_ROLES, lockHandle, locksInForce, type HandlePress } from './handleDrag';\nimport { locksOf, type EditAnchorsParams } from './params';\nimport { pathEditPreview } from './preview';\nimport {\n  claimWheel, dragWeights, endExtensionDrags, extensionOverlays, placeHandle, startExtensionDrags, translateWeighted,\n} from './extensionDrags';\nimport type { PathEditDrag } from 'features/paths/pathEditExtension';\nimport { pathEditToolActive } from '../defaults/pathEditTools';\nimport { editedPathSymmetries } from './symmetry';\nimport { pathOperationTags } from '../pathGestureTags';\n\n/**\n * Parse an anchor affordance kind — `'anchor:N'` | `'controlIn:N'` |\n * `'controlOut:N'`, where N is the flat anchor index — or `null` when the\n * affordance is not an anchor kind.\n */\nfunction parseAnchorAffordance(\n  kind: string,\n): { anchorIndex: number; part: 'anchor' | 'controlIn' | 'controlOut' } | null {\n  const m = kind.match(/^(anchor|controlIn|controlOut):(\\d+)$/);\n  if (!m) return null;\n  return {\n    anchorIndex: parseInt(m[2], 10),\n    part: m[1] as 'anchor' | 'controlIn' | 'controlOut',\n  };\n}\n\n/**\n * Resolve what a press on `anchorIndex` should leave selected.\n *\n * Shift toggles. A bare press on an anchor that's already part of the\n * selection keeps the selection intact (so the drag moves the whole set);\n * a bare press anywhere else collapses to just that anchor.\n */\nexport function selectionAfterAnchorPress(\n  current: ReadonlySet<number>,\n  anchorIndex: number,\n  additive: boolean,\n): Set<number> {\n  if (additive) {\n    const next = new Set(current);\n    if (next.has(anchorIndex)) next.delete(anchorIndex);\n    else next.add(anchorIndex);\n    return next;\n  }\n  if (current.has(anchorIndex) && current.size > 1) return new Set(current);\n  return new Set([anchorIndex]);\n}\n\ninterface EditAnchorsScratch {\n  dep: EditAnchorsDep;\n  id: string;\n  anchorIndex: number;\n  /** `'anchor'` drags on-curve points (and their handles) by a delta.\n   *  `'controlIn'` / `'controlOut'` drag one control point to an absolute\n   *  world coord. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n  /** Anchors this drag moves — the pressed one, or the whole anchor\n   *  selection when the press landed inside it. Flat indices. */\n  dragging: readonly number[];\n  /** World position of the pressed anchor at drag start; the drag delta is\n   *  measured from here rather than accumulated per move, so the geometry\n   *  is always derived from `originPose` in one step. */\n  anchorOrigin: { x: number; y: number };\n  /** The anchor and the dragged control handle at the press, for a handle drag. */\n  handlePress: HandlePress | null;\n  /** The guide the lock in force drew at the last move. */\n  guide: OngoingOverlay | null;\n  /** The path-edit extensions' shares of this drag. */\n  drags: readonly PathEditDrag[];\n  /** The last move, to redo when an extension claims the wheel. */\n  lastMove: InvocationCtx | null;\n  originPose: PolygonPath;\n  currentPose: PolygonPath;\n  /** The transforms `originPose` is its own image under, read at the press. */\n  symmetries: readonly AnchorSymmetry[];\n  /** Where each point of `currentPose` came from in `originPose`. */\n  origins?: readonly (PointOrigin | null)[];\n  /** Other nodes' world paths the finished edit moves with it. */\n  others: readonly { id: string; path: PolygonPath }[];\n}\n\ntype Point = { x: number; y: number };\n\n/**\n * An anchor drag's snap: a `point` session, begun on the first move, for\n * where the pressed anchor goes. The edited path offers no targets but what\n * the drag leaves still of it, and Shift holds the anchor to the axes and\n * diagonals through its press.\n */\nfunction anchorDragSnap(\n  snap: SnapDep | undefined,\n  press: { id: string; origin: Point; originPose: PolygonPath; dragging: readonly number[] },\n): { at(world: Point, mods: SnapMods): Point; end(): void } {\n  let session: SnapSession | null = null;\n  return {\n    at(world, mods) {\n      if (!session) {\n        const { path, anchors } = pathAwayFromAnchors(press.originPose, press.dragging);\n        const req: SnapBegin = {\n          gesture: 'point', press: press.origin, ids: [press.id],\n          also: { paths: [path], anchors }, constrain: 'axis',\n        };\n        session = snap?.begin(req) ?? inputSession(req);\n      }\n      return session.at(world, mods).point;\n    },\n    end() {\n      session?.end();\n      session = null;\n    },\n  };\n}\n\nconst paramsOf = (opts: BindingOpts | undefined): EditAnchorsParams =>\n  (resolveParams(opts?.params) ?? {}) as EditAnchorsParams;\n\n/** Take `next` as the frame to show, finished by the dep. A frame it cannot\n *  finish is dropped, so the path stays at the last one it could. */\nfunction track(scratch: EditAnchorsScratch, next: ReturnType<typeof editAnchorSetTracked>): void {\n  if (!next) return;\n  const { dep, id } = scratch;\n  const done = dep.finishEdit ? dep.finishEdit(id, next.path, next.origins) : { path: next.path, others: [] };\n  if (!done) return;\n  scratch.currentPose = done.path as PolygonPath;\n  scratch.others = done.others as EditAnchorsScratch['others'];\n  scratch.origins = next.origins;\n}\n\n/** The anchor and the handle a press on `part` grabbed; null for an anchor press. */\nfunction handlePressOf(\n  origin: PenAnchor,\n  part: EditAnchorsScratch['part'],\n): HandlePress | null {\n  const handle = part === 'controlIn' ? origin.inHandle : part === 'controlOut' ? origin.outHandle : undefined;\n  return handle ? { anchor: { x: origin.x, y: origin.y }, handle: { ...handle } } : null;\n}\n\n/** Move the dragged anchors to follow `to`, and the anchors the extensions\n *  weight by their shares. A weighted drag moves no symmetric images. */\nfunction moveAnchors(scratch: EditAnchorsScratch, to: Point): void {\n  if (scratch.dragging.length === 0) return;\n  const dx = to.x - scratch.anchorOrigin.x;\n  const dy = to.y - scratch.anchorOrigin.y;\n  const weights = dragWeights(scratch.drags, scratch.dragging);\n  track(scratch, editAnchorSetTracked(scratch.originPose, (set) => {\n    if (weights) translateWeighted(set, weights, dx, dy);\n    else translateAnchorsSymmetric(set, scratch.dragging, dx, dy, scratch.symmetries);\n  }));\n}\n\n/** The modifiers `editAnchors` reads while it runs: Shift on the press adds\n *  to the anchor selection, Alt breaks a smooth anchor's mirror, the handle\n *  locks, and Shift holds an anchor drag to the axes and diagonals. An anchor\n *  drag also reads `snap.suspend` at its default key, Ctrl, which is not\n *  declared here because on a handle Ctrl holds the length. */\nexport const EDIT_ANCHORS_ROLES = {\n  'selection.add': { label: 'Add to the anchor selection', keys: ['shift'] },\n  'mirror.break': { label: \"Break the handles' mirror\", keys: ['alt'] },\n  ...HANDLE_LOCK_ROLES,\n  'snap.constrain': SNAP_ROLES['snap.constrain'],\n} as const satisfies ModifierRoles;\n\nconst roleHeld = roleReader(EDIT_ANCHORS_ROLES);\n\n/** Move the dragged handle toward the pointer, under the locks in force, then\n *  wherever the extensions place it. */\nfunction moveHandle(scratch: EditAnchorsScratch, ctx: InvocationCtx, params: EditAnchorsParams): void {\n  const side = scratch.part === 'controlIn' ? 'in' : 'out';\n  // Modifiers and held locks are read live, so either can change mid-drag.\n  const held = (ctx.deps.editAnchors ?? scratch.dep).handleLocks ?? locksOf(params.handleLock);\n  const locks = locksInForce(held, ctx);\n  const locked = scratch.handlePress ? lockHandle(scratch.handlePress, ctx.world, locks) : { to: ctx.world, guide: null };\n  scratch.guide = locked.guide;\n  const to = placeHandle(scratch.drags, locked.to, { locks });\n  const alt = roleHeld(ctx, 'mirror.break');\n  const move = scratch.symmetries.length > 0\n    ? (set: AnchorSet) => moveHandleSymmetric(set, scratch.anchorIndex, side, to.x, to.y, alt, scratch.symmetries)\n    : (set: AnchorSet) => moveHandleTo(set, scratch.anchorIndex, side, to.x, to.y, alt);\n  track(scratch, editAnchorSetTracked(scratch.originPose, move));\n}\n\n/**\n * What a press drags, the selection updated first, before any move: a handle\n * press drags its anchor's handle; an anchor press selects as\n * {@link selectionAfterAnchorPress} says and drags what it left selected —\n * nothing when Shift took the pressed anchor out of it.\n */\nfunction draggedByPress(\n  dep: EditAnchorsDep,\n  press: { anchorIndex: number; part: EditAnchorsScratch['part'] },\n  shift: boolean,\n): readonly number[] {\n  if (press.part !== 'anchor') return [press.anchorIndex];\n  const next = selectionAfterAnchorPress(dep.selectedAnchors, press.anchorIndex, shift);\n  dep.setSelectedAnchors(next);\n  return next.has(press.anchorIndex) ? [...next] : [];\n}\n\n/** Static descriptor for the `editAnchors` Action. */\nexport const editAnchorsAction: Action & { requires: string[] } = inPlane({\n  id: 'editAnchors',\n  label: 'Edit Anchors',\n  tags: pathOperationTags('drag'),\n  defaultBinding: {\n    kind: 'drag',\n    // Only matches drags whose pointerdown hit an anchor or control handle.\n    // Ties moveAction's `selected-body` on specificity and registers after\n    // it, so move declines these presses in `start`.\n    target: { kindOf: isAnchorOrControl },\n  },\n  eligible: { capability: 'edits-anchors' },\n  modifierRoles: EDIT_ANCHORS_ROLES,\n  requires: ['selection', 'editAnchors', 'pathSymmetry', 'snap'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts): OngoingHandle {\n      const dep = ctx.deps.editAnchors;\n      if (!dep) return {};\n\n      const affordance = ctx.drag?.affordance;\n      if (!affordance) {\n        // No affordance hit → this drag doesn't target an anchor handle.\n        // Let other bindings handle it (the handle returns {}, dispatcher moves on).\n        return {};\n      }\n\n      const anchorInfo = parseAnchorAffordance(affordance.kind);\n      if (!anchorInfo) {\n        // Affordance is a non-anchor kind (e.g. resize handle, rotate handle).\n        return {};\n      }\n\n      const { editingId } = dep;\n      // World-coord polygon. For pose-as-polygon nodes this equals\n      // node.pose; for data.path nodes it's pathInWorld-projected (translate +\n      // rotation) so the anchor world coords match what the user clicked.\n      const worldPath = dep.getEditablePath(editingId) as PolygonPath | undefined;\n      if (!worldPath || worldPath.kind !== 'polygon') return {};\n\n      // Decode once to validate the affordance index against the actual\n      // geometry and to read the press origin. A stale affordance (the\n      // path changed between pointerdown and now) fails here rather than\n      // silently editing whichever anchor now holds that index.\n      const decoded = pathToAnchors(worldPath) as AnchorSet;\n      const origin = anchorAt(decoded, anchorInfo.anchorIndex);\n      if (!origin) return {};\n      if (anchorInfo.part === 'controlIn' && !origin.inHandle) return {};\n      if (anchorInfo.part === 'controlOut' && !origin.outHandle) return {};\n\n      let active = false;\n      const preview = pathEditPreview(\n        dep, editingId, () => (active ? scratch.currentPose : null), () => (active ? scratch.others : []),\n      );\n      if (!preview) return {};\n\n      const dragging = draggedByPress(dep, anchorInfo, roleHeld(ctx, 'selection.add'));\n\n      const scratch: EditAnchorsScratch = {\n        dep,\n        id: editingId,\n        anchorIndex: anchorInfo.anchorIndex,\n        part: anchorInfo.part,\n        dragging,\n        anchorOrigin: { x: origin.x, y: origin.y },\n        handlePress: handlePressOf(origin, anchorInfo.part),\n        guide: null,\n        drags: startExtensionDrags(dep.extensions, {\n          id: editingId,\n          node: dep.getNodeShape(editingId),\n          path: worldPath,\n          anchors: decoded,\n          part: anchorInfo.part,\n          anchorIndex: anchorInfo.anchorIndex,\n          dragging: anchorInfo.part === 'anchor' ? dragging : [],\n          scale: ctx.deps.view?.get().scale,\n          ...(ctx.deps.snap ? { snap: ctx.deps.snap } : {}),\n        }),\n        lastMove: null,\n        originPose: worldPath,\n        currentPose: worldPath,\n        symmetries: editedPathSymmetries(ctx.deps.pathSymmetry, editingId, decoded),\n        others: [],\n      };\n      const snapAnchor = anchorDragSnap(ctx.deps.snap, {\n        id: editingId, origin: scratch.anchorOrigin, originPose: worldPath, dragging,\n      });\n\n      const move = (moveCtx: InvocationCtx): void => {\n        scratch.lastMove = moveCtx;\n        if (scratch.part !== 'anchor') return moveHandle(scratch, moveCtx, paramsOf(opts));\n        moveAnchors(scratch, snapAnchor.at(moveCtx.world, snapMods(moveCtx)));\n      };\n\n      return {\n        kind: 'edit-anchors',\n        onMove(moveCtx: InvocationCtx): void {\n          move(moveCtx);\n          active = true;\n        },\n        onWheel(wheelCtx: InvocationCtx): boolean {\n          if (!wheelCtx.wheel || !claimWheel(scratch.drags, wheelCtx.wheel)) return false;\n          if (scratch.lastMove) move(scratch.lastMove);\n          return true;\n        },\n        overlay(): readonly OngoingOverlay[] | null {\n          if (!active) return null;\n          const extra = scratch.drags.length > 0\n            ? extensionOverlays(scratch.drags, pathToAnchors(scratch.currentPose) as AnchorSet)\n            : [];\n          const all = scratch.guide ? [scratch.guide, ...extra] : extra;\n          return all.length > 0 ? all : null;\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          active = false;\n          try {\n            if (reason === 'cancel' || scratch.originPose === scratch.currentPose) return;\n            scratch.dep.applyEdit(scratch.id, scratch.currentPose, 'Edit anchors', scratch.origins);\n          } finally {\n            snapAnchor.end();\n            endExtensionDrags(scratch.drags);\n          }\n        },\n        previewIds: preview.previewIds,\n        previewPose: preview.previewPose,\n        previewData: preview.previewData,\n      };\n    },\n  },\n  // A path-edit tool has the drag.\n  enabled: (deps) => (pathEditToolActive(deps) ? ActionDisabledReason.NotApplicable : true),\n}, editingLayer);\n"],"mappings":"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"}

package/dist/interactions/actions/edit-anchors/extensionDrags.js

@@ -0,0 +1,50 @@
+import { translateAnchorBy } from "@weasel-js/geom";
+
+//#region src/interactions/actions/edit-anchors/extensionDrags.ts
+/** Each extension's share of the drag `start` describes, in extension order. */
+function startExtensionDrags(extensions, start) {
+	const out = [];
+	for (const ext of extensions ?? []) {
+		const drag = ext.drag?.(start);
+		if (drag) out.push(drag);
+	}
+	return out;
+}
+/** The anchors an anchor drag of `dragging` moves and each one's share, the
+*  largest any extension gives; null when none gives weights. */
+function dragWeights(drags, dragging) {
+	let out = null;
+	for (const drag of drags) {
+		const weights = drag.weights?.();
+		if (!weights) continue;
+		out ??= new Map(dragging.map((i) => [i, 1]));
+		for (const [flat, w] of weights) if (w > (out.get(flat) ?? 0)) out.set(flat, w);
+	}
+	return out;
+}
+/** Move every anchor of `set` that `weights` names by its share of `(dx, dy)`. */
+function translateWeighted(set, weights, dx, dy) {
+	for (const [flat, w] of weights) translateAnchorBy(set, flat, dx * w, dy * w);
+}
+/** Where a dragged handle goes once every extension has placed it in turn. */
+function placeHandle(drags, to, move) {
+	let at = to;
+	for (const drag of drags) if (drag.handle) at = drag.handle(at, move);
+	return at;
+}
+/** Offer `wheel` to each extension until one claims it. */
+function claimWheel(drags, wheel) {
+	return drags.some((drag) => drag.wheel?.(wheel) === true);
+}
+/** Every extension's overlays for `current`. */
+function extensionOverlays(drags, current) {
+	return drags.flatMap((drag) => drag.overlays?.(current) ?? []);
+}
+/** Tell every extension the drag is over. */
+function endExtensionDrags(drags) {
+	for (const drag of drags) drag.end?.();
+}
+
+//#endregion
+export { claimWheel, dragWeights, endExtensionDrags, extensionOverlays, placeHandle, startExtensionDrags, translateWeighted };
+//# sourceMappingURL=extensionDrags.js.map

package/dist/interactions/actions/edit-anchors/extensionDrags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionDrags.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/extensionDrags.ts"],"sourcesContent":["/**\n * The path-edit extensions' share of an anchor or handle drag: the anchors\n * that follow it, where a dragged handle goes, the wheel, and what they draw.\n */\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { translateAnchorBy, type AnchorSet } from '@weasel-js/geom';\nimport type {\n  PathEditDrag,\n  PathEditDragStart,\n  PathEditExtension,\n  PathEditHandleMove,\n} from 'features/paths/pathEditExtension';\n\ntype Point = { x: number; y: number };\ntype Wheel = { deltaX: number; deltaY: number; deltaZ: number };\n\n/** Each extension's share of the drag `start` describes, in extension order. */\nexport function startExtensionDrags(\n  extensions: readonly PathEditExtension[] | undefined,\n  start: PathEditDragStart,\n): PathEditDrag[] {\n  const out: PathEditDrag[] = [];\n  for (const ext of extensions ?? []) {\n    const drag = ext.drag?.(start);\n    if (drag) out.push(drag);\n  }\n  return out;\n}\n\n/** The anchors an anchor drag of `dragging` moves and each one's share, the\n *  largest any extension gives; null when none gives weights. */\nexport function dragWeights(drags: readonly PathEditDrag[], dragging: readonly number[]): Map<number, number> | null {\n  let out: Map<number, number> | null = null;\n  for (const drag of drags) {\n    const weights = drag.weights?.();\n    if (!weights) continue;\n    out ??= new Map(dragging.map((i) => [i, 1]));\n    for (const [flat, w] of weights) if (w > (out.get(flat) ?? 0)) out.set(flat, w);\n  }\n  return out;\n}\n\n/** Move every anchor of `set` that `weights` names by its share of `(dx, dy)`. */\nexport function translateWeighted(set: AnchorSet, weights: ReadonlyMap<number, number>, dx: number, dy: number): void {\n  for (const [flat, w] of weights) translateAnchorBy(set, flat, dx * w, dy * w);\n}\n\n/** Where a dragged handle goes once every extension has placed it in turn. */\nexport function placeHandle(drags: readonly PathEditDrag[], to: Point, move: PathEditHandleMove): Point {\n  let at = to;\n  for (const drag of drags) if (drag.handle) at = drag.handle(at, move);\n  return at;\n}\n\n/** Offer `wheel` to each extension until one claims it. */\nexport function claimWheel(drags: readonly PathEditDrag[], wheel: Wheel): boolean {\n  return drags.some((drag) => drag.wheel?.(wheel) === true);\n}\n\n/** Every extension's overlays for `current`. */\nexport function extensionOverlays(drags: readonly PathEditDrag[], current: AnchorSet): OngoingOverlay[] {\n  return drags.flatMap((drag) => drag.overlays?.(current) ?? []);\n}\n\n/** Tell every extension the drag is over. */\nexport function endExtensionDrags(drags: readonly PathEditDrag[]): void {\n  for (const drag of drags) drag.end?.();\n}\n"],"mappings":";;;;AAiBA,SAAgB,oBACd,YACA,OACgB;CAChB,MAAM,MAAsB,CAAC;CAC7B,KAAK,MAAM,OAAO,cAAc,CAAC,GAAG;EAClC,MAAM,OAAO,IAAI,OAAO,KAAK;EAC7B,IAAI,MAAM,IAAI,KAAK,IAAI;CACzB;CACA,OAAO;AACT;;;AAIA,SAAgB,YAAY,OAAgC,UAAyD;CACnH,IAAI,MAAkC;CACtC,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,UAAU,KAAK,UAAU;EAC/B,IAAI,CAAC,SAAS;EACd,QAAQ,IAAI,IAAI,SAAS,KAAK,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;EAC3C,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC;CAChF;CACA,OAAO;AACT;;AAGA,SAAgB,kBAAkB,KAAgB,SAAsC,IAAY,IAAkB;CACpH,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS,kBAAkB,KAAK,MAAM,KAAK,GAAG,KAAK,CAAC;AAC9E;;AAGA,SAAgB,YAAY,OAAgC,IAAW,MAAiC;CACtG,IAAI,KAAK;CACT,KAAK,MAAM,QAAQ,OAAO,IAAI,KAAK,QAAQ,KAAK,KAAK,OAAO,IAAI,IAAI;CACpE,OAAO;AACT;;AAGA,SAAgB,WAAW,OAAgC,OAAuB;CAChF,OAAO,MAAM,MAAM,SAAS,KAAK,QAAQ,KAAK,MAAM,IAAI;AAC1D;;AAGA,SAAgB,kBAAkB,OAAgC,SAAsC;CACtG,OAAO,MAAM,SAAS,SAAS,KAAK,WAAW,OAAO,KAAK,CAAC,CAAC;AAC/D;;AAGA,SAAgB,kBAAkB,OAAsC;CACtE,KAAK,MAAM,QAAQ,OAAO,KAAK,MAAM;AACvC"}

package/dist/interactions/actions/edit-anchors/geometry.js

@@ -1,64 +1,91 @@
-import { PATH_C as e, PATH_L as t, PATH_M as n, PATH_Q as r, PATH_Z as i, forEachSegment as a } from "@weasel-js/geom";
+import { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment } from "@weasel-js/geom";
+
 //#region src/interactions/actions/edit-anchors/geometry.ts
-function o(o) {
-	let { commands: c, coords: l } = o, u = [], d = null, f = null, p = (e, t) => {
-		let n = {
-			anchorIndex: u.length,
-			x: l[e],
-			y: l[e + 1],
-			coordIndex: e,
-			...t ? { controlIn: t } : {}
+/** Walk a PolygonPath's command stream and yield one `PathAnchor` per
+*  on-curve point. Adjacent C/Q control points are attached as
+*  `controlIn`/`controlOut`. Subpath boundaries (M after a previous M or Z)
+*  start fresh — the new M's anchor has no `controlIn` from a Z. A closing
+*  curve that ends exactly on the subpath's first point is not a second
+*  anchor: its control becomes the first anchor's `controlIn`, the way
+*  `pathToAnchors` reads it, so the two walkers count alike. */
+function enumerateAnchors(path) {
+	const { commands, coords } = path;
+	const anchors = [];
+	let lastAnchor = null;
+	let firstInSubpath = null;
+	const push = (coordIndex, controlIn) => {
+		const a = {
+			anchorIndex: anchors.length,
+			x: coords[coordIndex],
+			y: coords[coordIndex + 1],
+			coordIndex,
+			...controlIn ? { controlIn } : {}
 		};
-		u.push(n), d = n;
+		anchors.push(a);
+		lastAnchor = a;
 	};
-	return a(c, l, (a, o) => {
-		switch (a) {
-			case n:
-				p(o), f = d;
+	forEachSegment(commands, coords, (cmd, ci) => {
+		switch (cmd) {
+			case PATH_M:
+				push(ci);
+				firstInSubpath = lastAnchor;
 				break;
-			case t:
-				p(o);
+			case PATH_L:
+				push(ci);
 				break;
-			case e:
-				d && (d.controlOut = {
-					x: l[o],
-					y: l[o + 1],
-					coordIndex: o
-				}), p(o + 4, {
-					x: l[o + 2],
-					y: l[o + 3],
-					coordIndex: o + 2
+			case PATH_C:
+				if (lastAnchor) lastAnchor.controlOut = {
+					x: coords[ci],
+					y: coords[ci + 1],
+					coordIndex: ci
+				};
+				push(ci + 4, {
+					x: coords[ci + 2],
+					y: coords[ci + 3],
+					coordIndex: ci + 2
 				});
 				break;
-			case r:
-				d && (d.controlOut = {
-					x: l[o],
-					y: l[o + 1],
-					coordIndex: o
-				}), p(o + 2, {
-					x: l[o],
-					y: l[o + 1],
-					coordIndex: o
+			case PATH_Q:
+				if (lastAnchor) lastAnchor.controlOut = {
+					x: coords[ci],
+					y: coords[ci + 1],
+					coordIndex: ci
+				};
+				push(ci + 2, {
+					x: coords[ci],
+					y: coords[ci + 1],
+					coordIndex: ci
 				});
 				break;
-			case i:
-				s(u, f, d), d = null, f = null;
+			case PATH_Z:
+				foldClosingCurve(anchors, firstInSubpath, lastAnchor);
+				lastAnchor = null;
+				firstInSubpath = null;
 				break;
-			default: throw Error(`enumerateAnchors: unknown command ${a}`);
+			default: throw new Error(`enumerateAnchors: unknown command ${cmd}`);
 		}
-	}), u;
+	});
+	return anchors;
 }
-function s(e, t, n) {
-	t && n && t !== n && n.controlIn && n.x === t.x && n.y === t.y && (e.pop(), t.closeCoordIndex = n.coordIndex, t.controlIn = n.controlIn);
+function foldClosingCurve(anchors, first, last) {
+	if (!first || !last || first === last) return;
+	if (!last.controlIn || last.x !== first.x || last.y !== first.y) return;
+	anchors.pop();
+	first.closeCoordIndex = last.coordIndex;
+	first.controlIn = last.controlIn;
 }
-function c(e, t, n, r) {
-	let i = new Float32Array(e.coords);
-	return i[t] = n, i[t + 1] = r, {
-		...e,
-		coords: i
+/** Mutate `coords` in-place: write `(x, y)` at `coordIndex`, return a new
+*  PolygonPath sharing the same commands but with a fresh coords buffer. */
+function withCoord(path, coordIndex, x, y) {
+	const next = new Float32Array(path.coords);
+	next[coordIndex] = x;
+	next[coordIndex + 1] = y;
+	return {
+		...path,
+		coords: next
 	};
 }
-//#endregion
-export { o as enumerateAnchors, c as withCoord };
 
+//#endregion
+export { enumerateAnchors, withCoord };
 //# sourceMappingURL=geometry.js.map