@weasel-js/core 1.10.1 → 1.11.1

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

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.js","names":["enumerateAnchors","path","anchors","lastAnchor","firstInSubpath","push","a","coords","coordIndex","controlIn","forEachSegment","commands","cmd","PATH_M","ci","PATH_L","PATH_C","PATH_Q","PATH_Z","foldClosingCurve","first","last","withCoord","next","x","y"],"sources":["../../../../src/interactions/actions/edit-anchors/geometry.ts"],"sourcesContent":["import { forEachSegment, PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type PolygonPath } from '@weasel-js/geom';\n\n/** A single anchor on a `PolygonPath`, with its incoming/outgoing bezier\n *  control points (when present). `coordIndex` points at the anchor's own\n *  on-curve x in the `coords` array. `inCoordIndex` / `outCoordIndex` point\n *  at the corresponding control x. */\nexport interface PathAnchor {\n  /** Sequential anchor index in walk order (0-based). */\n  anchorIndex: number;\n  /** On-curve point. */\n  x: number;\n  y: number;\n  /** Incoming control (from the previous segment, when it was C/Q). */\n  controlIn?: { x: number; y: number; coordIndex: number };\n  /** Outgoing control (from the next segment, when it is C/Q). */\n  controlOut?: { x: number; y: number; coordIndex: number };\n  /** Index of the anchor's on-curve x in `coords`. */\n  coordIndex: number;\n  /** Set on the first anchor of a closed subpath whose last curve ends\n   *  exactly on it: the index of that curve's end x, the same point again. */\n  closeCoordIndex?: number;\n}\n\n/** Walk a PolygonPath's command stream and yield one `PathAnchor` per\n *  on-curve point. Adjacent C/Q control points are attached as\n *  `controlIn`/`controlOut`. Subpath boundaries (M after a previous M or Z)\n *  start fresh — the new M's anchor has no `controlIn` from a Z. A closing\n *  curve that ends exactly on the subpath's first point is not a second\n *  anchor: its control becomes the first anchor's `controlIn`, the way\n *  `pathToAnchors` reads it, so the two walkers count alike. */\nexport function enumerateAnchors(path: PolygonPath): PathAnchor[] {\n  const { commands, coords } = path;\n  const anchors: PathAnchor[] = [];\n  let lastAnchor: PathAnchor | null = null;\n  let firstInSubpath: PathAnchor | null = null;\n\n  const push = (coordIndex: number, controlIn?: PathAnchor['controlIn']): void => {\n    const a: PathAnchor = {\n      anchorIndex: anchors.length,\n      x: coords[coordIndex],\n      y: coords[coordIndex + 1],\n      coordIndex,\n      ...(controlIn ? { controlIn } : {}),\n    };\n    anchors.push(a);\n    lastAnchor = a;\n  };\n\n  forEachSegment(commands, coords, (cmd, ci) => {\n    switch (cmd) {\n      case PATH_M:\n        push(ci);\n        firstInSubpath = lastAnchor;\n        break;\n      case PATH_L:\n        push(ci);\n        break;\n      case PATH_C:\n        if (lastAnchor) {\n          lastAnchor.controlOut = { x: coords[ci], y: coords[ci + 1], coordIndex: ci };\n        }\n        push(ci + 4, { x: coords[ci + 2], y: coords[ci + 3], coordIndex: ci + 2 });\n        break;\n      case PATH_Q:\n        if (lastAnchor) {\n          lastAnchor.controlOut = { x: coords[ci], y: coords[ci + 1], coordIndex: ci };\n        }\n        push(ci + 2, { x: coords[ci], y: coords[ci + 1], coordIndex: ci });\n        break;\n      case PATH_Z:\n        foldClosingCurve(anchors, firstInSubpath, lastAnchor);\n        lastAnchor = null;\n        firstInSubpath = null;\n        break;\n      default:\n        throw new Error(`enumerateAnchors: unknown command ${cmd}`);\n    }\n  });\n  return anchors;\n}\n\nfunction foldClosingCurve(anchors: PathAnchor[], first: PathAnchor | null, last: PathAnchor | null): void {\n  if (!first || !last || first === last) return;\n  if (!last.controlIn || last.x !== first.x || last.y !== first.y) return;\n  anchors.pop();\n  first.closeCoordIndex = last.coordIndex;\n  first.controlIn = last.controlIn;\n}\n\n/** Mutate `coords` in-place: write `(x, y)` at `coordIndex`, return a new\n *  PolygonPath sharing the same commands but with a fresh coords buffer. */\nexport function withCoord(path: PolygonPath, coordIndex: number, x: number, y: number): PolygonPath {\n  const next = new Float32Array(path.coords);\n  next[coordIndex] = x;\n  next[coordIndex + 1] = y;\n  return { ...path, coords: next };\n}\n\n/** Translate anchor `anchorIndex` AND its attached control handles\n *  (`controlIn` / `controlOut`) by `(dx, dy)`. Used by `editAnchorsAction`\n *  when the dragged affordance is the anchor itself — moving the anchor\n *  without its handles would shear the surrounding bezier segments. */\nexport function translateAnchor(\n  path: PolygonPath,\n  anchorIndex: number,\n  dx: number,\n  dy: number,\n): PolygonPath {\n  const anchors = enumerateAnchors(path);\n  const a = anchors[anchorIndex];\n  if (!a) return path;\n  const next = new Float32Array(path.coords);\n  // Anchor itself.\n  next[a.coordIndex] += dx;\n  next[a.coordIndex + 1] += dy;\n  if (a.closeCoordIndex !== undefined) {\n    next[a.closeCoordIndex] += dx;\n    next[a.closeCoordIndex + 1] += dy;\n  }\n  // In-handle of THIS anchor — the trailing pair of the incoming C/Q.\n  if (a.controlIn) {\n    next[a.controlIn.coordIndex] += dx;\n    next[a.controlIn.coordIndex + 1] += dy;\n  }\n  // Out-handle: the leading pair of the OUTGOING C/Q. Owned by this\n  // anchor's segment.\n  if (a.controlOut) {\n    next[a.controlOut.coordIndex] += dx;\n    next[a.controlOut.coordIndex + 1] += dy;\n  }\n  return { ...path, coords: next };\n}\n"],"mappings":";;AA8BA,SAAgBA,EAAiB,GAAiC;CAChE,IAAM,EAAE,aAAU,cAAWC,GACvBC,IAAwB,CAAC,GAC3BC,IAAgC,MAChCC,IAAoC,MAElCC,KAAQ,GAAoB,MAA8C;EAC9E,IAAMC,IAAgB;GACpB,aAAaJ,EAAQ;GACrB,GAAGK,EAAOC;GACV,GAAGD,EAAOC,IAAa;GACvB;GACA,GAAIC,IAAY,EAAE,aAAU,IAAI,CAAC;EACnC;EAEA,AADAP,EAAQ,KAAKI,CAAC,GACd,IAAaA;CACf;CAgCA,OA9BAI,EAAeC,GAAUJ,IAAS,GAAK,MAAO;EAC5C,QAAQK,GAAR;GACE,KAAKC;IAEH,AADAR,EAAKS,CAAE,GACP,IAAiBX;IACjB;GACF,KAAKY;IACH,EAAKD,CAAE;IACP;GACF,KAAKE;IAIH,AAHIb,MACF,EAAW,aAAa;KAAE,GAAGI,EAAOO;KAAK,GAAGP,EAAOO,IAAK;KAAI,YAAYA;IAAG,IAE7ET,EAAKS,IAAK,GAAG;KAAE,GAAGP,EAAOO,IAAK;KAAI,GAAGP,EAAOO,IAAK;KAAI,YAAYA,IAAK;IAAE,CAAC;IACzE;GACF,KAAKG;IAIH,AAHId,MACF,EAAW,aAAa;KAAE,GAAGI,EAAOO;KAAK,GAAGP,EAAOO,IAAK;KAAI,YAAYA;IAAG,IAE7ET,EAAKS,IAAK,GAAG;KAAE,GAAGP,EAAOO;KAAK,GAAGP,EAAOO,IAAK;KAAI,YAAYA;IAAG,CAAC;IACjE;GACF,KAAKI;IAGH,AAFAC,EAAiBjB,GAASE,GAAgBD,CAAU,GACpD,IAAa,MACb,IAAiB;IACjB;GACF,SACE,MAAU,MAAM,qCAAqCS,GAAK;EAC9D;CACF,CAAC,GACMV;AACT;AAEA,SAASiB,EAAiB,GAAuB,GAA0B,GAA+B;CACxG,AAAKC,KAAUC,KAAQD,MAAUC,KAC5BA,EAAK,aAAaA,EAAK,MAAMD,EAAM,KAAKC,EAAK,MAAMD,EAAM,MAC9DlB,EAAQ,IAAI,GACZ,EAAM,kBAAkBmB,EAAK,YAC7B,EAAM,YAAYA,EAAK;AACzB;AAIA,SAAgBC,EAAU,GAAmB,GAAoB,GAAW,GAAwB;CAClG,IAAMC,IAAO,IAAI,aAAatB,EAAK,MAAM;CAGzC,OAFA,EAAKO,KAAcgB,GACnB,EAAKhB,IAAa,KAAKiB,GAChB;EAAE,GAAGxB;EAAM,QAAQsB;CAAK;AACjC"}
+{"version":3,"file":"geometry.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/geometry.ts"],"sourcesContent":["import { forEachSegment, PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type PolygonPath } from '@weasel-js/geom';\n\n/** A single anchor on a `PolygonPath`, with its incoming/outgoing bezier\n *  control points (when present). `coordIndex` points at the anchor's own\n *  on-curve x in the `coords` array. `inCoordIndex` / `outCoordIndex` point\n *  at the corresponding control x. */\nexport interface PathAnchor {\n  /** Sequential anchor index in walk order (0-based). */\n  anchorIndex: number;\n  /** On-curve point. */\n  x: number;\n  y: number;\n  /** Incoming control (from the previous segment, when it was C/Q). */\n  controlIn?: { x: number; y: number; coordIndex: number };\n  /** Outgoing control (from the next segment, when it is C/Q). */\n  controlOut?: { x: number; y: number; coordIndex: number };\n  /** Index of the anchor's on-curve x in `coords`. */\n  coordIndex: number;\n  /** Set on the first anchor of a closed subpath whose last curve ends\n   *  exactly on it: the index of that curve's end x, the same point again. */\n  closeCoordIndex?: number;\n}\n\n/** Walk a PolygonPath's command stream and yield one `PathAnchor` per\n *  on-curve point. Adjacent C/Q control points are attached as\n *  `controlIn`/`controlOut`. Subpath boundaries (M after a previous M or Z)\n *  start fresh — the new M's anchor has no `controlIn` from a Z. A closing\n *  curve that ends exactly on the subpath's first point is not a second\n *  anchor: its control becomes the first anchor's `controlIn`, the way\n *  `pathToAnchors` reads it, so the two walkers count alike. */\nexport function enumerateAnchors(path: PolygonPath): PathAnchor[] {\n  const { commands, coords } = path;\n  const anchors: PathAnchor[] = [];\n  let lastAnchor: PathAnchor | null = null;\n  let firstInSubpath: PathAnchor | null = null;\n\n  const push = (coordIndex: number, controlIn?: PathAnchor['controlIn']): void => {\n    const a: PathAnchor = {\n      anchorIndex: anchors.length,\n      x: coords[coordIndex],\n      y: coords[coordIndex + 1],\n      coordIndex,\n      ...(controlIn ? { controlIn } : {}),\n    };\n    anchors.push(a);\n    lastAnchor = a;\n  };\n\n  forEachSegment(commands, coords, (cmd, ci) => {\n    switch (cmd) {\n      case PATH_M:\n        push(ci);\n        firstInSubpath = lastAnchor;\n        break;\n      case PATH_L:\n        push(ci);\n        break;\n      case PATH_C:\n        if (lastAnchor) {\n          lastAnchor.controlOut = { x: coords[ci], y: coords[ci + 1], coordIndex: ci };\n        }\n        push(ci + 4, { x: coords[ci + 2], y: coords[ci + 3], coordIndex: ci + 2 });\n        break;\n      case PATH_Q:\n        if (lastAnchor) {\n          lastAnchor.controlOut = { x: coords[ci], y: coords[ci + 1], coordIndex: ci };\n        }\n        push(ci + 2, { x: coords[ci], y: coords[ci + 1], coordIndex: ci });\n        break;\n      case PATH_Z:\n        foldClosingCurve(anchors, firstInSubpath, lastAnchor);\n        lastAnchor = null;\n        firstInSubpath = null;\n        break;\n      default:\n        throw new Error(`enumerateAnchors: unknown command ${cmd}`);\n    }\n  });\n  return anchors;\n}\n\nfunction foldClosingCurve(anchors: PathAnchor[], first: PathAnchor | null, last: PathAnchor | null): void {\n  if (!first || !last || first === last) return;\n  if (!last.controlIn || last.x !== first.x || last.y !== first.y) return;\n  anchors.pop();\n  first.closeCoordIndex = last.coordIndex;\n  first.controlIn = last.controlIn;\n}\n\n/** Mutate `coords` in-place: write `(x, y)` at `coordIndex`, return a new\n *  PolygonPath sharing the same commands but with a fresh coords buffer. */\nexport function withCoord(path: PolygonPath, coordIndex: number, x: number, y: number): PolygonPath {\n  const next = new Float32Array(path.coords);\n  next[coordIndex] = x;\n  next[coordIndex + 1] = y;\n  return { ...path, coords: next };\n}\n\n/** Translate anchor `anchorIndex` AND its attached control handles\n *  (`controlIn` / `controlOut`) by `(dx, dy)`. Used by `editAnchorsAction`\n *  when the dragged affordance is the anchor itself — moving the anchor\n *  without its handles would shear the surrounding bezier segments. */\nexport function translateAnchor(\n  path: PolygonPath,\n  anchorIndex: number,\n  dx: number,\n  dy: number,\n): PolygonPath {\n  const anchors = enumerateAnchors(path);\n  const a = anchors[anchorIndex];\n  if (!a) return path;\n  const next = new Float32Array(path.coords);\n  // Anchor itself.\n  next[a.coordIndex] += dx;\n  next[a.coordIndex + 1] += dy;\n  if (a.closeCoordIndex !== undefined) {\n    next[a.closeCoordIndex] += dx;\n    next[a.closeCoordIndex + 1] += dy;\n  }\n  // In-handle of THIS anchor — the trailing pair of the incoming C/Q.\n  if (a.controlIn) {\n    next[a.controlIn.coordIndex] += dx;\n    next[a.controlIn.coordIndex + 1] += dy;\n  }\n  // Out-handle: the leading pair of the OUTGOING C/Q. Owned by this\n  // anchor's segment.\n  if (a.controlOut) {\n    next[a.controlOut.coordIndex] += dx;\n    next[a.controlOut.coordIndex + 1] += dy;\n  }\n  return { ...path, coords: next };\n}\n"],"mappings":";;;;;;;;;;AA8BA,SAAgB,iBAAiB,MAAiC;CAChE,MAAM,EAAE,UAAU,WAAW;CAC7B,MAAM,UAAwB,CAAC;CAC/B,IAAI,aAAgC;CACpC,IAAI,iBAAoC;CAExC,MAAM,QAAQ,YAAoB,cAA8C;EAC9E,MAAM,IAAgB;GACpB,aAAa,QAAQ;GACrB,GAAG,OAAO;GACV,GAAG,OAAO,aAAa;GACvB;GACA,GAAI,YAAY,EAAE,UAAU,IAAI,CAAC;EACnC;EACA,QAAQ,KAAK,CAAC;EACd,aAAa;CACf;CAEA,eAAe,UAAU,SAAS,KAAK,OAAO;EAC5C,QAAQ,KAAR;GACE,KAAK;IACH,KAAK,EAAE;IACP,iBAAiB;IACjB;GACF,KAAK;IACH,KAAK,EAAE;IACP;GACF,KAAK;IACH,IAAI,YACF,WAAW,aAAa;KAAE,GAAG,OAAO;KAAK,GAAG,OAAO,KAAK;KAAI,YAAY;IAAG;IAE7E,KAAK,KAAK,GAAG;KAAE,GAAG,OAAO,KAAK;KAAI,GAAG,OAAO,KAAK;KAAI,YAAY,KAAK;IAAE,CAAC;IACzE;GACF,KAAK;IACH,IAAI,YACF,WAAW,aAAa;KAAE,GAAG,OAAO;KAAK,GAAG,OAAO,KAAK;KAAI,YAAY;IAAG;IAE7E,KAAK,KAAK,GAAG;KAAE,GAAG,OAAO;KAAK,GAAG,OAAO,KAAK;KAAI,YAAY;IAAG,CAAC;IACjE;GACF,KAAK;IACH,iBAAiB,SAAS,gBAAgB,UAAU;IACpD,aAAa;IACb,iBAAiB;IACjB;GACF,SACE,MAAM,IAAI,MAAM,qCAAqC,KAAK;EAC9D;CACF,CAAC;CACD,OAAO;AACT;AAEA,SAAS,iBAAiB,SAAuB,OAA0B,MAA+B;CACxG,IAAI,CAAC,SAAS,CAAC,QAAQ,UAAU,MAAM;CACvC,IAAI,CAAC,KAAK,aAAa,KAAK,MAAM,MAAM,KAAK,KAAK,MAAM,MAAM,GAAG;CACjE,QAAQ,IAAI;CACZ,MAAM,kBAAkB,KAAK;CAC7B,MAAM,YAAY,KAAK;AACzB;;;AAIA,SAAgB,UAAU,MAAmB,YAAoB,GAAW,GAAwB;CAClG,MAAM,OAAO,IAAI,aAAa,KAAK,MAAM;CACzC,KAAK,cAAc;CACnB,KAAK,aAAa,KAAK;CACvB,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAK;AACjC"}

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

@@ -0,0 +1,101 @@
+import { handleAlongItsAngle, handleAtItsLength } from "@weasel-js/geom";
+import { roleReader } from "@weasel-js/routing";
+
+//#region src/interactions/actions/edit-anchors/handleDrag.ts
+/**
+* The locks on a control-handle drag — its angle, its length, or both — and
+* the guide that shows which one is holding.
+*/
+var CIRCLE_SEGMENTS = 64;
+/** How far past the handle the angle guide reaches, as a share of its length. */
+var LINE_OVERSHOOT = 1.25;
+/** The modifier roles a handle drag reads: Shift holds its angle, Cmd or
+*  Ctrl its length. */
+var HANDLE_LOCK_ROLES = {
+	"handle.holdAngle": {
+		label: "Hold the handle angle",
+		keys: ["shift"]
+	},
+	"handle.holdLength": {
+		label: "Hold the handle length",
+		keys: ["meta", "ctrl"]
+	}
+};
+var lockHeld = roleReader(HANDLE_LOCK_ROLES);
+/** The locks in force: those `held` names, plus those the event's
+*  {@link HANDLE_LOCK_ROLES} hold. */
+function locksInForce(held, ctx) {
+	return {
+		angle: held.angle || lockHeld(ctx, "handle.holdAngle"),
+		length: held.length || lockHeld(ctx, "handle.holdLength")
+	};
+}
+/** The handle dragged toward `pointer` under `locks`. */
+function lockHandle(press, pointer, locks) {
+	const { anchor, handle } = press;
+	const len = dist(anchor, handle);
+	if (locks.angle && locks.length) return {
+		to: { ...handle },
+		guide: lineGuide(anchor, handle, len)
+	};
+	if (locks.angle) {
+		const to = handleAlongItsAngle(anchor, handle, pointer);
+		return {
+			to,
+			guide: lineGuide(anchor, handle, Math.max(len, dist(anchor, to)))
+		};
+	}
+	if (locks.length) return {
+		to: handleAtItsLength(anchor, handle, pointer),
+		guide: circleGuide(anchor, len)
+	};
+	return {
+		to: pointer,
+		guide: null
+	};
+}
+/** The line through `anchor` toward `toward`, reaching past `reach` on both sides. */
+function lineGuide(anchor, toward, reach) {
+	const d = dist(anchor, toward);
+	if (d === 0) return {
+		kind: "polyline",
+		points: [anchor, anchor],
+		role: "lock"
+	};
+	const span = reach * LINE_OVERSHOOT;
+	const ux = (toward.x - anchor.x) / d * span;
+	const uy = (toward.y - anchor.y) / d * span;
+	return {
+		kind: "polyline",
+		points: [{
+			x: anchor.x - ux,
+			y: anchor.y - uy
+		}, {
+			x: anchor.x + ux,
+			y: anchor.y + uy
+		}],
+		role: "lock"
+	};
+}
+function circleGuide(center, r) {
+	const points = [];
+	for (let i = 0; i <= CIRCLE_SEGMENTS; i++) {
+		const a = i / CIRCLE_SEGMENTS * Math.PI * 2;
+		points.push({
+			x: center.x + Math.cos(a) * r,
+			y: center.y + Math.sin(a) * r
+		});
+	}
+	return {
+		kind: "polyline",
+		points,
+		role: "lock"
+	};
+}
+function dist(a, b) {
+	return Math.hypot(b.x - a.x, b.y - a.y);
+}
+
+//#endregion
+export { HANDLE_LOCK_ROLES, lockHandle, locksInForce };
+//# sourceMappingURL=handleDrag.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleDrag.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/handleDrag.ts"],"sourcesContent":["/**\n * The locks on a control-handle drag — its angle, its length, or both — and\n * the guide that shows which one is holding.\n */\nimport { roleReader, type ModifierRoles, type ModifierState, type OngoingOverlay } from '@weasel-js/routing';\nimport { handleAlongItsAngle, handleAtItsLength } from '@weasel-js/geom';\nimport type { HandleLocks } from './params';\n\ntype Point = { x: number; y: number };\n\n/** Where a handle drag's anchor and handle sat at the press. */\nexport interface HandlePress {\n  anchor: Point;\n  handle: Point;\n}\n\n/** Where the handle goes this move, and the guide its lock draws. */\nexport interface LockedHandle {\n  to: Point;\n  /** The line or circle the handle is held to; null with no lock held. */\n  guide: OngoingOverlay | null;\n}\n\nconst CIRCLE_SEGMENTS = 64;\n/** How far past the handle the angle guide reaches, as a share of its length. */\nconst LINE_OVERSHOOT = 1.25;\n\n/** The modifier roles a handle drag reads: Shift holds its angle, Cmd or\n *  Ctrl its length. */\nexport const HANDLE_LOCK_ROLES = {\n  'handle.holdAngle': { label: 'Hold the handle angle', keys: ['shift'] },\n  'handle.holdLength': { label: 'Hold the handle length', keys: ['meta', 'ctrl'] },\n} as const satisfies ModifierRoles;\n\nconst lockHeld = roleReader(HANDLE_LOCK_ROLES);\n\n/** The locks in force: those `held` names, plus those the event's\n *  {@link HANDLE_LOCK_ROLES} hold. */\nexport function locksInForce(\n  held: HandleLocks,\n  ctx: { roles?: Readonly<Record<string, boolean>>; modifiers: ModifierState },\n): HandleLocks {\n  return {\n    angle: held.angle || lockHeld(ctx, 'handle.holdAngle'),\n    length: held.length || lockHeld(ctx, 'handle.holdLength'),\n  };\n}\n\n/** The handle dragged toward `pointer` under `locks`. */\nexport function lockHandle(press: HandlePress, pointer: Point, locks: HandleLocks): LockedHandle {\n  const { anchor, handle } = press;\n  const len = dist(anchor, handle);\n  if (locks.angle && locks.length) return { to: { ...handle }, guide: lineGuide(anchor, handle, len) };\n  if (locks.angle) {\n    const to = handleAlongItsAngle(anchor, handle, pointer);\n    return { to, guide: lineGuide(anchor, handle, Math.max(len, dist(anchor, to))) };\n  }\n  if (locks.length) return { to: handleAtItsLength(anchor, handle, pointer), guide: circleGuide(anchor, len) };\n  return { to: pointer, guide: null };\n}\n\n/** The line through `anchor` toward `toward`, reaching past `reach` on both sides. */\nfunction lineGuide(anchor: Point, toward: Point, reach: number): OngoingOverlay {\n  const d = dist(anchor, toward);\n  if (d === 0) return { kind: 'polyline', points: [anchor, anchor], role: 'lock' };\n  const span = reach * LINE_OVERSHOOT;\n  const ux = ((toward.x - anchor.x) / d) * span;\n  const uy = ((toward.y - anchor.y) / d) * span;\n  return {\n    kind: 'polyline',\n    points: [{ x: anchor.x - ux, y: anchor.y - uy }, { x: anchor.x + ux, y: anchor.y + uy }],\n    role: 'lock',\n  };\n}\n\nfunction circleGuide(center: Point, r: number): OngoingOverlay {\n  const points: Point[] = [];\n  for (let i = 0; i <= CIRCLE_SEGMENTS; i++) {\n    const a = (i / CIRCLE_SEGMENTS) * Math.PI * 2;\n    points.push({ x: center.x + Math.cos(a) * r, y: center.y + Math.sin(a) * r });\n  }\n  return { kind: 'polyline', points, role: 'lock' };\n}\n\nfunction dist(a: Point, b: Point): number {\n  return Math.hypot(b.x - a.x, b.y - a.y);\n}\n"],"mappings":";;;;;;;;AAuBA,IAAM,kBAAkB;;AAExB,IAAM,iBAAiB;;;AAIvB,IAAa,oBAAoB;CAC/B,oBAAoB;EAAE,OAAO;EAAyB,MAAM,CAAC,OAAO;CAAE;CACtE,qBAAqB;EAAE,OAAO;EAA0B,MAAM,CAAC,QAAQ,MAAM;CAAE;AACjF;AAEA,IAAM,WAAW,WAAW,iBAAiB;;;AAI7C,SAAgB,aACd,MACA,KACa;CACb,OAAO;EACL,OAAO,KAAK,SAAS,SAAS,KAAK,kBAAkB;EACrD,QAAQ,KAAK,UAAU,SAAS,KAAK,mBAAmB;CAC1D;AACF;;AAGA,SAAgB,WAAW,OAAoB,SAAgB,OAAkC;CAC/F,MAAM,EAAE,QAAQ,WAAW;CAC3B,MAAM,MAAM,KAAK,QAAQ,MAAM;CAC/B,IAAI,MAAM,SAAS,MAAM,QAAQ,OAAO;EAAE,IAAI,EAAE,GAAG,OAAO;EAAG,OAAO,UAAU,QAAQ,QAAQ,GAAG;CAAE;CACnG,IAAI,MAAM,OAAO;EACf,MAAM,KAAK,oBAAoB,QAAQ,QAAQ,OAAO;EACtD,OAAO;GAAE;GAAI,OAAO,UAAU,QAAQ,QAAQ,KAAK,IAAI,KAAK,KAAK,QAAQ,EAAE,CAAC,CAAC;EAAE;CACjF;CACA,IAAI,MAAM,QAAQ,OAAO;EAAE,IAAI,kBAAkB,QAAQ,QAAQ,OAAO;EAAG,OAAO,YAAY,QAAQ,GAAG;CAAE;CAC3G,OAAO;EAAE,IAAI;EAAS,OAAO;CAAK;AACpC;;AAGA,SAAS,UAAU,QAAe,QAAe,OAA+B;CAC9E,MAAM,IAAI,KAAK,QAAQ,MAAM;CAC7B,IAAI,MAAM,GAAG,OAAO;EAAE,MAAM;EAAY,QAAQ,CAAC,QAAQ,MAAM;EAAG,MAAM;CAAO;CAC/E,MAAM,OAAO,QAAQ;CACrB,MAAM,MAAO,OAAO,IAAI,OAAO,KAAK,IAAK;CACzC,MAAM,MAAO,OAAO,IAAI,OAAO,KAAK,IAAK;CACzC,OAAO;EACL,MAAM;EACN,QAAQ,CAAC;GAAE,GAAG,OAAO,IAAI;GAAI,GAAG,OAAO,IAAI;EAAG,GAAG;GAAE,GAAG,OAAO,IAAI;GAAI,GAAG,OAAO,IAAI;EAAG,CAAC;EACvF,MAAM;CACR;AACF;AAEA,SAAS,YAAY,QAAe,GAA2B;CAC7D,MAAM,SAAkB,CAAC;CACzB,KAAK,IAAI,IAAI,GAAG,KAAK,iBAAiB,KAAK;EACzC,MAAM,IAAK,IAAI,kBAAmB,KAAK,KAAK;EAC5C,OAAO,KAAK;GAAE,GAAG,OAAO,IAAI,KAAK,IAAI,CAAC,IAAI;GAAG,GAAG,OAAO,IAAI,KAAK,IAAI,CAAC,IAAI;EAAE,CAAC;CAC9E;CACA,OAAO;EAAE,MAAM;EAAY;EAAQ,MAAM;CAAO;AAClD;AAEA,SAAS,KAAK,GAAU,GAAkB;CACxC,OAAO,KAAK,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;AACxC"}

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

@@ -1,43 +1,57 @@
-import { enumerateAnchors as e } from "./geometry.js";
+import { enumerateAnchors } from "./geometry.js";
+
 //#region src/interactions/actions/edit-anchors/handles.ts
-function t(t, n, r, i) {
-	let a = e(t), o = null, s = null, c = i * i;
-	for (let e of a) {
-		if (e.controlIn) {
-			let t = e.controlIn.x - n, i = e.controlIn.y - r, a = t * t + i * i;
-			a <= c && (!o || a < o.d2) && (o = {
-				d2: a,
+/** Hit-test anchors and control handles. Controls win over anchors when both
+*  are within `threshold` (controls are smaller and rendered on top). */
+function hitAnchor(path, worldX, worldY, threshold) {
+	const anchors = enumerateAnchors(path);
+	let bestControl = null;
+	let bestAnchor = null;
+	const t2 = threshold * threshold;
+	for (const a of anchors) {
+		if (a.controlIn) {
+			const dx = a.controlIn.x - worldX;
+			const dy = a.controlIn.y - worldY;
+			const d2 = dx * dx + dy * dy;
+			if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) bestControl = {
+				d2,
 				hit: {
-					anchorIndex: e.anchorIndex,
+					anchorIndex: a.anchorIndex,
 					kind: "controlIn",
-					coordIndex: e.controlIn.coordIndex
+					coordIndex: a.controlIn.coordIndex
 				}
-			});
+			};
 		}
-		if (e.controlOut) {
-			let t = e.controlOut.x - n, i = e.controlOut.y - r, a = t * t + i * i;
-			a <= c && (!o || a < o.d2) && (o = {
-				d2: a,
+		if (a.controlOut) {
+			const dx = a.controlOut.x - worldX;
+			const dy = a.controlOut.y - worldY;
+			const d2 = dx * dx + dy * dy;
+			if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) bestControl = {
+				d2,
 				hit: {
-					anchorIndex: e.anchorIndex,
+					anchorIndex: a.anchorIndex,
 					kind: "controlOut",
-					coordIndex: e.controlOut.coordIndex
+					coordIndex: a.controlOut.coordIndex
 				}
-			});
+			};
 		}
-		let t = e.x - n, i = e.y - r, a = t * t + i * i;
-		a <= c && (!s || a < s.d2) && (s = {
-			d2: a,
+		const dx = a.x - worldX;
+		const dy = a.y - worldY;
+		const d2 = dx * dx + dy * dy;
+		if (d2 <= t2 && (!bestAnchor || d2 < bestAnchor.d2)) bestAnchor = {
+			d2,
 			hit: {
-				anchorIndex: e.anchorIndex,
+				anchorIndex: a.anchorIndex,
 				kind: "anchor",
-				coordIndex: e.coordIndex
+				coordIndex: a.coordIndex
 			}
-		});
+		};
 	}
-	return o ? o.hit : s ? s.hit : null;
+	if (bestControl) return bestControl.hit;
+	if (bestAnchor) return bestAnchor.hit;
+	return null;
 }
-//#endregion
-export { t as hitAnchor };
 
+//#endregion
+export { hitAnchor };
 //# sourceMappingURL=handles.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"handles.js","names":["hitAnchor","anchors","enumerateAnchors","path","bestControl","bestAnchor","t2","threshold","a","dx","worldX","dy","worldY","d2"],"sources":["../../../../src/interactions/actions/edit-anchors/handles.ts"],"sourcesContent":["import type { PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors, type PathAnchor } from './geometry';\n\n/** Result of a hit-test against a path's anchors / control handles. */\nexport interface AnchorHit {\n  anchorIndex: number;\n  kind: 'anchor' | 'controlIn' | 'controlOut';\n  /** Index in `coords` of the hit point's x. */\n  coordIndex: number;\n}\n\n/** Hit-test anchors and control handles. Controls win over anchors when both\n *  are within `threshold` (controls are smaller and rendered on top). */\nexport function hitAnchor(\n  path: PolygonPath,\n  worldX: number,\n  worldY: number,\n  threshold: number,\n): AnchorHit | null {\n  const anchors = enumerateAnchors(path);\n  let bestControl: { d2: number; hit: AnchorHit } | null = null;\n  let bestAnchor: { d2: number; hit: AnchorHit } | null = null;\n  const t2 = threshold * threshold;\n\n  for (const a of anchors) {\n    if (a.controlIn) {\n      const dx = a.controlIn.x - worldX;\n      const dy = a.controlIn.y - worldY;\n      const d2 = dx * dx + dy * dy;\n      if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) {\n        bestControl = {\n          d2,\n          hit: { anchorIndex: a.anchorIndex, kind: 'controlIn', coordIndex: a.controlIn.coordIndex },\n        };\n      }\n    }\n    if (a.controlOut) {\n      const dx = a.controlOut.x - worldX;\n      const dy = a.controlOut.y - worldY;\n      const d2 = dx * dx + dy * dy;\n      if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) {\n        bestControl = {\n          d2,\n          hit: { anchorIndex: a.anchorIndex, kind: 'controlOut', coordIndex: a.controlOut.coordIndex },\n        };\n      }\n    }\n    const dx = a.x - worldX;\n    const dy = a.y - worldY;\n    const d2 = dx * dx + dy * dy;\n    if (d2 <= t2 && (!bestAnchor || d2 < bestAnchor.d2)) {\n      bestAnchor = {\n        d2,\n        hit: { anchorIndex: a.anchorIndex, kind: 'anchor', coordIndex: a.coordIndex },\n      };\n    }\n  }\n  if (bestControl) return bestControl.hit;\n  if (bestAnchor) return bestAnchor.hit;\n  return null;\n}\n\nexport type { PathAnchor };\n"],"mappings":";;AAaA,SAAgBA,EACd,GACA,GACA,GACA,GACkB;CAClB,IAAMC,IAAUC,EAAiBC,CAAI,GACjCC,IAAqD,MACrDC,IAAoD,MAClDC,IAAKC,IAAYA;CAEvB,KAAK,IAAMC,KAAKP,GAAS;EACvB,IAAIO,EAAE,WAAW;GACf,IAAMC,IAAKD,EAAE,UAAU,IAAIE,GACrBC,IAAKH,EAAE,UAAU,IAAII,GACrBC,IAAKJ,IAAKA,IAAKE,IAAKA;GAC1B,AAAIE,KAAMP,MAAO,CAACF,KAAeS,IAAKT,EAAY,QAChD,IAAc;IACZ;IACA,KAAK;KAAE,aAAaI,EAAE;KAAa,MAAM;KAAa,YAAYA,EAAE,UAAU;IAAW;GAC3F;EAEJ;EACA,IAAIA,EAAE,YAAY;GAChB,IAAMC,IAAKD,EAAE,WAAW,IAAIE,GACtBC,IAAKH,EAAE,WAAW,IAAII,GACtBC,IAAKJ,IAAKA,IAAKE,IAAKA;GAC1B,AAAIE,KAAMP,MAAO,CAACF,KAAeS,IAAKT,EAAY,QAChD,IAAc;IACZ;IACA,KAAK;KAAE,aAAaI,EAAE;KAAa,MAAM;KAAc,YAAYA,EAAE,WAAW;IAAW;GAC7F;EAEJ;EACA,IAAMC,IAAKD,EAAE,IAAIE,GACXC,IAAKH,EAAE,IAAII,GACXC,IAAKJ,IAAKA,IAAKE,IAAKA;EAC1B,AAAIE,KAAMP,MAAO,CAACD,KAAcQ,IAAKR,EAAW,QAC9C,IAAa;GACX;GACA,KAAK;IAAE,aAAaG,EAAE;IAAa,MAAM;IAAU,YAAYA,EAAE;GAAW;EAC9E;CAEJ;CAGA,OAFIJ,IAAoBA,EAAY,MAChCC,IAAmBA,EAAW,MAC3B;AACT"}
+{"version":3,"file":"handles.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/handles.ts"],"sourcesContent":["import type { PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors, type PathAnchor } from './geometry';\n\n/** Result of a hit-test against a path's anchors / control handles. */\nexport interface AnchorHit {\n  anchorIndex: number;\n  kind: 'anchor' | 'controlIn' | 'controlOut';\n  /** Index in `coords` of the hit point's x. */\n  coordIndex: number;\n}\n\n/** Hit-test anchors and control handles. Controls win over anchors when both\n *  are within `threshold` (controls are smaller and rendered on top). */\nexport function hitAnchor(\n  path: PolygonPath,\n  worldX: number,\n  worldY: number,\n  threshold: number,\n): AnchorHit | null {\n  const anchors = enumerateAnchors(path);\n  let bestControl: { d2: number; hit: AnchorHit } | null = null;\n  let bestAnchor: { d2: number; hit: AnchorHit } | null = null;\n  const t2 = threshold * threshold;\n\n  for (const a of anchors) {\n    if (a.controlIn) {\n      const dx = a.controlIn.x - worldX;\n      const dy = a.controlIn.y - worldY;\n      const d2 = dx * dx + dy * dy;\n      if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) {\n        bestControl = {\n          d2,\n          hit: { anchorIndex: a.anchorIndex, kind: 'controlIn', coordIndex: a.controlIn.coordIndex },\n        };\n      }\n    }\n    if (a.controlOut) {\n      const dx = a.controlOut.x - worldX;\n      const dy = a.controlOut.y - worldY;\n      const d2 = dx * dx + dy * dy;\n      if (d2 <= t2 && (!bestControl || d2 < bestControl.d2)) {\n        bestControl = {\n          d2,\n          hit: { anchorIndex: a.anchorIndex, kind: 'controlOut', coordIndex: a.controlOut.coordIndex },\n        };\n      }\n    }\n    const dx = a.x - worldX;\n    const dy = a.y - worldY;\n    const d2 = dx * dx + dy * dy;\n    if (d2 <= t2 && (!bestAnchor || d2 < bestAnchor.d2)) {\n      bestAnchor = {\n        d2,\n        hit: { anchorIndex: a.anchorIndex, kind: 'anchor', coordIndex: a.coordIndex },\n      };\n    }\n  }\n  if (bestControl) return bestControl.hit;\n  if (bestAnchor) return bestAnchor.hit;\n  return null;\n}\n\nexport type { PathAnchor };\n"],"mappings":";;;;;AAaA,SAAgB,UACd,MACA,QACA,QACA,WACkB;CAClB,MAAM,UAAU,iBAAiB,IAAI;CACrC,IAAI,cAAqD;CACzD,IAAI,aAAoD;CACxD,MAAM,KAAK,YAAY;CAEvB,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,EAAE,WAAW;GACf,MAAM,KAAK,EAAE,UAAU,IAAI;GAC3B,MAAM,KAAK,EAAE,UAAU,IAAI;GAC3B,MAAM,KAAK,KAAK,KAAK,KAAK;GAC1B,IAAI,MAAM,OAAO,CAAC,eAAe,KAAK,YAAY,KAChD,cAAc;IACZ;IACA,KAAK;KAAE,aAAa,EAAE;KAAa,MAAM;KAAa,YAAY,EAAE,UAAU;IAAW;GAC3F;EAEJ;EACA,IAAI,EAAE,YAAY;GAChB,MAAM,KAAK,EAAE,WAAW,IAAI;GAC5B,MAAM,KAAK,EAAE,WAAW,IAAI;GAC5B,MAAM,KAAK,KAAK,KAAK,KAAK;GAC1B,IAAI,MAAM,OAAO,CAAC,eAAe,KAAK,YAAY,KAChD,cAAc;IACZ;IACA,KAAK;KAAE,aAAa,EAAE;KAAa,MAAM;KAAc,YAAY,EAAE,WAAW;IAAW;GAC7F;EAEJ;EACA,MAAM,KAAK,EAAE,IAAI;EACjB,MAAM,KAAK,EAAE,IAAI;EACjB,MAAM,KAAK,KAAK,KAAK,KAAK;EAC1B,IAAI,MAAM,OAAO,CAAC,cAAc,KAAK,WAAW,KAC9C,aAAa;GACX;GACA,KAAK;IAAE,aAAa,EAAE;IAAa,MAAM;IAAU,YAAY,EAAE;GAAW;EAC9E;CAEJ;CACA,IAAI,aAAa,OAAO,YAAY;CACpC,IAAI,YAAY,OAAO,WAAW;CAClC,OAAO;AACT"}

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

@@ -0,0 +1,12 @@
+//#region src/interactions/actions/edit-anchors/params.ts
+/** The locks a single {@link HandleLock}, or none, holds. */
+function locksOf(lock) {
+	return {
+		angle: lock === "angle",
+		length: lock === "length"
+	};
+}
+
+//#endregion
+export { locksOf };
+//# sourceMappingURL=params.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"params.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/params.ts"],"sourcesContent":["/** What a handle drag holds fixed: its direction from the anchor, or its length. */\nexport type HandleLock = 'angle' | 'length';\n\n/** Which handle locks are held for every handle drag, on top of the modifiers.\n *  Both together freeze the handle. */\nexport interface HandleLocks {\n  angle: boolean;\n  length: boolean;\n}\n\n/** The locks a single {@link HandleLock}, or none, holds. */\nexport function locksOf(lock: HandleLock | null | undefined): HandleLocks {\n  return { angle: lock === 'angle', length: lock === 'length' };\n}\n\n/**\n * The params `editAnchors` reads, through `<SceneCanvas tune>` or a binding.\n * Read on every move, so a change mid-drag reaches the drag.\n */\nexport type EditAnchorsParams = {\n  /** A lock held for every handle drag without a modifier: Shift holds the\n   *  angle, Mod (Cmd or Ctrl) the length. Under `<SceneCanvas>` this is where\n   *  the `handleLock.angle` and `handleLock.length` toggles start from; once\n   *  one is pressed, the locks the `editAnchors` dep holds decide. */\n  handleLock?: HandleLock | null;\n};\n"],"mappings":";;AAWA,SAAgB,QAAQ,MAAkD;CACxE,OAAO;EAAE,OAAO,SAAS;EAAS,QAAQ,SAAS;CAAS;AAC9D"}

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

@@ -1,26 +1,101 @@
-import { worldEditToStorage as e } from "@weasel-js/geom";
+import { storeEditablePath } from "../../../features/paths/editablePath.js";
+
 //#region src/interactions/actions/edit-anchors/preview.ts
-function t(t, n, r) {
-	let i = t.getStorageKind(n);
-	if (i !== "pose" && i !== "data") return null;
-	let a = i === "data" ? t.getNodeShape(n) : null, o = a ? a.pose : void 0, s = a ? a.data : void 0;
+/** `path`, a frame of an edit of `id`, finished by the dep's `finishEdit` as
+*  committing it would be: its path and the other nodes' that move with it.
+*  Null when an extension cannot finish it. */
+function finishPathEditFrame(dep, id, path, origins) {
+	return dep.finishEdit ? dep.finishEdit(id, path, origins) : {
+		path,
+		others: []
+	};
+}
+/**
+* Preview ghosts for a drag that reshapes the path in edit mode. `current`
+* answers the frame to show, or null while there is nothing to preview yet.
+* Each frame is finished as committing it would be
+* ({@link finishPathEditFrame}), so the node's constraints and the nodes
+* linked to it show as they will commit; a frame that cannot be finished
+* commits nothing, and shows nothing. A drag that finishes its own frames
+* passes `finished`, the world-space paths of the other nodes its frame
+* moves, and its frames are shown as they are. Null when the node stores its
+* path in neither supported place.
+*
+* The ghost is what committing the frame would store (`storeEditablePath`),
+* so a path drawn from a form is drawn again from the edited form on every
+* move.
+*/
+function pathEditPreview(dep, id, current, finished) {
+	const storageKind = dep.getStorageKind(id);
+	if (storageKind !== "pose" && storageKind !== "data") return null;
+	const origin = dep.getNodeShape(id) ?? (storageKind === "pose" ? {
+		pose: dep.getEditablePath(id),
+		data: void 0
+	} : null);
+	if (!origin) return null;
+	let lastFrame = null;
+	let lastFinished = null;
+	const shown = () => {
+		const frame = current();
+		if (!frame) return null;
+		if (finished) return {
+			path: frame.path,
+			others: finished()
+		};
+		if (frame.path !== lastFrame) {
+			lastFrame = frame.path;
+			lastFinished = finishPathEditFrame(dep, id, frame.path, frame.origins);
+		}
+		return lastFinished;
+	};
+	const others = () => shown()?.others ?? [];
+	let lastPath = null;
+	let lastStored = null;
+	const stored = (pid) => {
+		const path = pid === id ? shown()?.path : null;
+		if (!path) return null;
+		if (path !== lastPath) {
+			lastPath = path;
+			lastStored = storeEditablePath(origin, path, dep.extensions);
+		}
+		return lastStored;
+	};
+	const otherOrigins = /* @__PURE__ */ new Map();
+	const otherStored = /* @__PURE__ */ new Map();
+	const storedOther = (pid) => {
+		const path = others().find((o) => o.id === pid)?.path;
+		if (!path) return null;
+		if (!otherOrigins.has(pid)) otherOrigins.set(pid, dep.getNodeShape(pid));
+		const from = otherOrigins.get(pid);
+		if (!from) return null;
+		let hit = otherStored.get(pid);
+		if (hit?.path !== path) otherStored.set(pid, hit = {
+			path,
+			stored: storeEditablePath(from, path, dep.extensions)
+		});
+		return hit.stored ? {
+			from,
+			to: hit.stored
+		} : null;
+	};
 	return {
-		storageKind: i,
-		previewIds: () => r() ? [n] : null,
-		previewPose: (t) => {
-			let a = t === n ? r() : null;
-			return a ? i === "pose" ? a : o ? e(o, a).pose : null : null;
+		storageKind,
+		previewIds: () => {
+			const frame = shown();
+			return frame ? [id, ...frame.others.map((o) => o.id)] : null;
 		},
-		previewData: (t) => {
-			let a = t === n ? r() : null;
-			return !a || i !== "data" || !s ? null : {
-				...s,
-				path: e(o, a).path
-			};
+		previewPose: (pid) => (pid === id ? stored(pid)?.pose : storedOther(pid)?.to.pose) ?? null,
+		previewData: (pid) => {
+			if (pid !== id) {
+				const o = storedOther(pid);
+				return o && o.to.data !== o.from.data ? o.to.data : null;
+			}
+			const next = stored(pid);
+			return next && next.data !== origin.data ? next.data : null;
 		}
 	};
 }
-//#endregion
-export { t as pathEditPreview };
 
+//#endregion
+export { finishPathEditFrame, pathEditPreview };
 //# sourceMappingURL=preview.js.map