@weasel-js/core 1.10.0 → 1.11.0

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

@@ -0,0 +1,68 @@
+import { storeEditablePath } from "../../../features/paths/editablePath.js";
+
+//#region src/interactions/actions/edit-anchors/preview.ts
+/**
+* Preview ghosts for a drag that reshapes the path in edit mode. `current`
+* answers the world-space polygon to show, or null while there is nothing to
+* preview yet; `others`, the world-space paths of other nodes the edit moves
+* with it. Null when the node stores its path in neither supported place.
+*
+* The ghost is what committing `current` 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, others = () => []) {
+	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 lastPath = null;
+	let lastStored = null;
+	const stored = (pid) => {
+		const path = pid === id ? current() : 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,
+		previewIds: () => current() ? [id, ...others().map((o) => o.id)] : null,
+		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 { pathEditPreview };
+//# sourceMappingURL=preview.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/preview.ts"],"sourcesContent":["import type { OngoingHandle } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { storeEditablePath, type EditableShape } from 'features/paths/editablePath';\n\n/** Where the edited polygon lives on its node: the pose itself, or `data.path`\n *  under a rect pose. */\nexport type PathStorageKind = 'pose' | 'data';\n\n/** The preview half of an ongoing path edit, captured at press. */\nexport interface PathEditPreview {\n  storageKind: PathStorageKind;\n  previewIds: NonNullable<OngoingHandle['previewIds']>;\n  previewPose: NonNullable<OngoingHandle['previewPose']>;\n  previewData: NonNullable<OngoingHandle['previewData']>;\n}\n\n/**\n * Preview ghosts for a drag that reshapes the path in edit mode. `current`\n * answers the world-space polygon to show, or null while there is nothing to\n * preview yet; `others`, the world-space paths of other nodes the edit moves\n * with it. Null when the node stores its path in neither supported place.\n *\n * The ghost is what committing `current` would store (`storeEditablePath`),\n * so a path drawn from a form is drawn again from the edited form on every\n * move.\n */\nexport function pathEditPreview(\n  dep: EditAnchorsDep,\n  id: string,\n  current: () => PolygonPath | null,\n  others: () => readonly { id: string; path: PolygonPath }[] = () => [],\n): PathEditPreview | null {\n  const storageKind = dep.getStorageKind(id);\n  if (storageKind !== 'pose' && storageKind !== 'data') return null;\n  // The node as it was at the press, which every ghost is stored from. A dep\n  // that hands out no shape still says a pose-stored polygon is the pose.\n  const origin = dep.getNodeShape(id)\n    ?? (storageKind === 'pose' ? { pose: dep.getEditablePath(id), data: undefined } : null);\n  if (!origin) return null;\n\n  // previewPose and previewData are both asked each frame; store once per path.\n  let lastPath: PolygonPath | null = null;\n  let lastStored: EditableShape | null = null;\n  const stored = (pid: string): EditableShape | null => {\n    const path = pid === id ? current() : null;\n    if (!path) return null;\n    if (path !== lastPath) {\n      lastPath = path;\n      lastStored = storeEditablePath(origin, path, dep.extensions);\n    }\n    return lastStored;\n  };\n\n  // Another node's ghost, stored from that node as the press found it, once per path.\n  const otherOrigins = new Map<string, EditableShape | null>();\n  const otherStored = new Map<string, { path: PolygonPath; stored: EditableShape | null }>();\n  const storedOther = (pid: string): { from: EditableShape; to: EditableShape } | null => {\n    const path = others().find((o) => o.id === pid)?.path;\n    if (!path) return null;\n    if (!otherOrigins.has(pid)) otherOrigins.set(pid, dep.getNodeShape(pid));\n    const from = otherOrigins.get(pid);\n    if (!from) return null;\n    let hit = otherStored.get(pid);\n    if (hit?.path !== path) otherStored.set(pid, (hit = { path, stored: storeEditablePath(from, path, dep.extensions) }));\n    return hit.stored ? { from, to: hit.stored } : null;\n  };\n\n  return {\n    storageKind,\n    previewIds: () => (current() ? [id, ...others().map((o) => o.id)] : null),\n    previewPose: (pid: string): unknown | null =>\n      (pid === id ? stored(pid)?.pose : storedOther(pid)?.to.pose) ?? null,\n    previewData: (pid: string): unknown | null => {\n      if (pid !== id) {\n        const o = storedOther(pid);\n        return o && o.to.data !== o.from.data ? o.to.data : null;\n      }\n      const next = stored(pid);\n      return next && next.data !== origin.data ? next.data : null;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AA2BA,SAAgB,gBACd,KACA,IACA,SACA,eAAmE,CAAC,GAC5C;CACxB,MAAM,cAAc,IAAI,eAAe,EAAE;CACzC,IAAI,gBAAgB,UAAU,gBAAgB,QAAQ,OAAO;CAG7D,MAAM,SAAS,IAAI,aAAa,EAAE,MAC5B,gBAAgB,SAAS;EAAE,MAAM,IAAI,gBAAgB,EAAE;EAAG,MAAM;CAAU,IAAI;CACpF,IAAI,CAAC,QAAQ,OAAO;CAGpB,IAAI,WAA+B;CACnC,IAAI,aAAmC;CACvC,MAAM,UAAU,QAAsC;EACpD,MAAM,OAAO,QAAQ,KAAK,QAAQ,IAAI;EACtC,IAAI,CAAC,MAAM,OAAO;EAClB,IAAI,SAAS,UAAU;GACrB,WAAW;GACX,aAAa,kBAAkB,QAAQ,MAAM,IAAI,UAAU;EAC7D;EACA,OAAO;CACT;CAGA,MAAM,+BAAe,IAAI,IAAkC;CAC3D,MAAM,8BAAc,IAAI,IAAiE;CACzF,MAAM,eAAe,QAAmE;EACtF,MAAM,OAAO,OAAO,CAAC,CAAC,MAAM,MAAM,EAAE,OAAO,GAAG,CAAC,EAAE;EACjD,IAAI,CAAC,MAAM,OAAO;EAClB,IAAI,CAAC,aAAa,IAAI,GAAG,GAAG,aAAa,IAAI,KAAK,IAAI,aAAa,GAAG,CAAC;EACvE,MAAM,OAAO,aAAa,IAAI,GAAG;EACjC,IAAI,CAAC,MAAM,OAAO;EAClB,IAAI,MAAM,YAAY,IAAI,GAAG;EAC7B,IAAI,KAAK,SAAS,MAAM,YAAY,IAAI,KAAM,MAAM;GAAE;GAAM,QAAQ,kBAAkB,MAAM,MAAM,IAAI,UAAU;EAAE,CAAE;EACpH,OAAO,IAAI,SAAS;GAAE;GAAM,IAAI,IAAI;EAAO,IAAI;CACjD;CAEA,OAAO;EACL;EACA,kBAAmB,QAAQ,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE,CAAC,IAAI;EACpE,cAAc,SACX,QAAQ,KAAK,OAAO,GAAG,CAAC,EAAE,OAAO,YAAY,GAAG,CAAC,EAAE,GAAG,SAAS;EAClE,cAAc,QAAgC;GAC5C,IAAI,QAAQ,IAAI;IACd,MAAM,IAAI,YAAY,GAAG;IACzB,OAAO,KAAK,EAAE,GAAG,SAAS,EAAE,KAAK,OAAO,EAAE,GAAG,OAAO;GACtD;GACA,MAAM,OAAO,OAAO,GAAG;GACvB,OAAO,QAAQ,KAAK,SAAS,OAAO,OAAO,KAAK,OAAO;EACzD;CACF;AACF"}

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

@@ -0,0 +1,16 @@
+import { anchorSymmetries } from "@weasel-js/geom";
+
+//#region src/interactions/actions/edit-anchors/symmetry.ts
+/** World-unit slack for "this anchor is the image of that one": enough to
+*  absorb a path's float32 coordinates, far under anything drawn by hand. */
+var SYMMETRY_TOLERANCE = .001;
+/** The transforms the path `id`, decoded as `set`, is already its own image
+*  under, of those the `pathSymmetry` dep names. Empty without the dep. */
+function editedPathSymmetries(dep, id, set) {
+	const transforms = dep?.transforms(id) ?? [];
+	return transforms.length === 0 ? [] : anchorSymmetries(set, transforms, SYMMETRY_TOLERANCE);
+}
+
+//#endregion
+export { editedPathSymmetries };
+//# sourceMappingURL=symmetry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symmetry.js","names":[],"sources":["../../../../src/interactions/actions/edit-anchors/symmetry.ts"],"sourcesContent":["import { anchorSymmetries, type AnchorSet, type AnchorSymmetry } from '@weasel-js/geom';\nimport type { PathSymmetryDep } from '../depSchema';\n\n/** World-unit slack for \"this anchor is the image of that one\": enough to\n *  absorb a path's float32 coordinates, far under anything drawn by hand. */\nconst SYMMETRY_TOLERANCE = 1e-3;\n\n/** The transforms the path `id`, decoded as `set`, is already its own image\n *  under, of those the `pathSymmetry` dep names. Empty without the dep. */\nexport function editedPathSymmetries(\n  dep: PathSymmetryDep | undefined,\n  id: string,\n  set: AnchorSet,\n): AnchorSymmetry[] {\n  const transforms = dep?.transforms(id) ?? [];\n  return transforms.length === 0 ? [] : anchorSymmetries(set, transforms, SYMMETRY_TOLERANCE);\n}\n"],"mappings":";;;;;AAKA,IAAM,qBAAqB;;;AAI3B,SAAgB,qBACd,KACA,IACA,KACkB;CAClB,MAAM,aAAa,KAAK,WAAW,EAAE,KAAK,CAAC;CAC3C,OAAO,WAAW,WAAW,IAAI,CAAC,IAAI,iBAAiB,KAAK,YAAY,kBAAkB;AAC5F"}

package/dist/interactions/actions/flip/action.js

@@ -1,26 +1,38 @@
-import { unionAABB as e } from "../../../core/geometry/unionBounds.js";
-import { visualBoundsViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
-import { poseDescriptorOf as n } from "../poseDescriptorDep.js";
-import { shapeSources as r } from "../selectionSubtree.js";
-import { createTransformOp as i } from "../../../core/ops/transform.js";
-import { geometryDataOp as a } from "../geometryProjection.js";
-import { scenePoseFrame as o } from "../poseFrame.js";
-import { defaultCommitAdapter as s } from "../defaultCommitAdapter.js";
-import { FlipXIcon as c, FlipYIcon as l } from "../defaults/icons/editIcons.js";
-import { requiresSelection as u } from "../defaults/requiresSelection.js";
-import { flipPoseAboutBounds as d, flipPoseViaDescriptor as f } from "./helpers.js";
-import { actionReferenceSources as p, resolveSpatialReference as m } from "../spatialReference.js";
-import { multiply as h, rotate as g, translate as _ } from "@weasel-js/geom";
-import { createElement as v } from "react";
+import { unionAABB } from "../../../core/geometry/unionBounds.js";
+import { isNoInkExtents } from "../../../core/geometry/inkExtents.js";
+import { scenePoseFrame } from "../poseFrame.js";
+import { poseDescriptorOf } from "../poseDescriptorDep.js";
+import { shapeSources } from "../selectionSubtree.js";
+import { createTransformOp } from "../../../core/ops/transform.js";
+import { geometryDataOp } from "../geometryProjection.js";
+import { drawnBoxes } from "../drawnBoxes.js";
+import { defaultCommitAdapter } from "../defaultCommitAdapter.js";
+import { flipPoseAboutBounds, flipPoseViaDescriptor } from "./helpers.js";
+import { actionReferenceSources, resolveSpatialReference } from "../spatialReference.js";
+import { requiresSelection } from "../defaults/requiresSelection.js";
+import { multiply, rotate, translate } from "@weasel-js/geom";
+
 //#region src/interactions/actions/flip/action.ts
-function y(e, t, n, r) {
-	let i = t.local(n, {
-		x: r.x + r.width / 2,
-		y: r.y + r.height / 2,
+/**
+* The world mirror about `axis` through the center of `pivotWorld`, written in
+* the frame `id` stores its data in. `geometryProjection.transform` is given
+* the affine the node's own pose underwent, and data-held geometry is local —
+* so a world mirror has to be conjugated by the frame or an asymmetric shape
+* reflects across the wrong line while its pose lands correctly.
+*
+* The frame's turn comes back as the rotation on a rebased zero-size pose at
+* the pivot point, so no composition strategy has to expose one.
+*/
+function localMirror(axis, frame, id, pivotWorld) {
+	const at = frame.local(id, {
+		x: pivotWorld.x + pivotWorld.width / 2,
+		y: pivotWorld.y + pivotWorld.height / 2,
 		width: 0,
 		height: 0,
 		rotation: 0
-	}), a = i.rotation ?? 0, o = e === "x" ? [
+	});
+	const theta = at.rotation ?? 0;
+	const mirror = axis === "x" ? [
 		-1,
 		0,
 		0,
@@ -34,69 +46,107 @@ function y(e, t, n, r) {
 		-1,
 		0,
 		0
-	], s = h(h(g(a), o), g(-a));
-	return h(_(i.x, i.y), h(s, _(-i.x, -i.y)));
+	];
+	const turned = multiply(multiply(rotate(theta), mirror), rotate(-theta));
+	return multiply(translate(at.x, at.y), multiply(turned, translate(-at.x, -at.y)));
 }
-function b(n, c, l, u, h, g, _, v, b) {
-	let x = n.get();
-	if (x.length === 0) return;
-	let S = o(c), C = [], w = /* @__PURE__ */ new Map();
-	for (let e of x) {
-		let n = r(c, [e]), i = n.length !== 1 || n[0] !== e ? t(S.world(e), _) : null;
-		for (let e of n) C.includes(e) || (C.push(e), i && w.set(e, i));
+/**
+* Flip the current selection in `scene` along `axis`, as one undo entry.
+*
+* Pivot: `'each'` (per-item own AABB) unless the caller passes `'union'`,
+* which mirrors every pose about the selection's *visual* union AABB — the
+* rotated ink extents — so items swap sides as well as reflect, or a
+* `SpatialReference`, which mirrors about the center of what it names. A rotated
+* member's own mirrored position needs no expansion: `axisAlignedBounds`
+* keeps the stored box's center, so mirroring either box lands the same place.
+*/
+function flipSelection(selection, scene, axis, pivot, applyOps, geometryProjection, geom, params, pointer, boxesOver) {
+	const selected = selection.get();
+	if (selected.length === 0) return;
+	const frame = scenePoseFrame(scene);
+	const boxes = boxesOver(frame);
+	const ids = [];
+	const ownPivot = /* @__PURE__ */ new Map();
+	for (const id of selected) {
+		const members = shapeSources(scene, [id]);
+		const box = members.length !== 1 || members[0] !== id ? boxes.aabb(id, frame.world(id)) : null;
+		for (const member of members) {
+			if (ids.includes(member)) continue;
+			ids.push(member);
+			if (box) ownPivot.set(member, box);
+		}
+	}
+	const worlds = /* @__PURE__ */ new Map();
+	for (const id of ids) {
+		if (scene.get(id) === void 0) continue;
+		const world = frame.world(id);
+		worlds.set(id, world);
+		if (!ownPivot.has(id) && !isNoInkExtents(boxes.extents(id, world))) ownPivot.set(id, boxes.aabb(id, world));
 	}
-	let T = /* @__PURE__ */ new Map();
-	for (let e of C) c.get(e) !== void 0 && T.set(e, S.world(e));
-	let E = null;
-	if (u === "union") E = e([...T.values()].map((e) => t(e, _)));
-	else if (u !== "each" && (E = m(u, p(v, b, c, S, _)), E === null)) return;
-	let D = [];
-	for (let e of C) {
-		let t = c.get(e);
-		if (!t) continue;
-		let n = T.get(e), r = E ?? w.get(e) ?? null, o = r ? d(n, l, _, r) : f(n, l, _);
-		D.push(i({
-			id: e,
-			from: t.pose,
-			to: S.local(e, o),
+	let sharedPivot = null;
+	if (pivot === "union") sharedPivot = unionAABB([...worlds].map(([id, p]) => boxes.aabb(id, p)));
+	else if (pivot !== "each") {
+		sharedPivot = resolveSpatialReference(pivot, actionReferenceSources(params, pointer, scene, frame, boxes));
+		if (sharedPivot === null) return;
+	}
+	const ops = [];
+	for (const id of ids) {
+		const node = scene.get(id);
+		if (!node) continue;
+		const world = worlds.get(id);
+		const about = sharedPivot ?? ownPivot.get(id) ?? null;
+		const flipped = about ? flipPoseAboutBounds(world, axis, geom, about) : flipPoseViaDescriptor(world, axis, geom);
+		ops.push(createTransformOp({
+			id,
+			from: node.pose,
+			to: frame.local(id, flipped),
 			label: "Flip"
 		}));
-		let s = r ?? _.getBounds(n), u = a(g, {
-			id: e,
-			data: t.data,
-			pose: t.pose
-		}, y(l, S, e, s), "Flip");
-		u && D.push(u);
+		const g = about ?? geom.getBounds(world);
+		const dataOp = geometryDataOp(geometryProjection, {
+			id,
+			data: node.data,
+			pose: node.pose
+		}, localMirror(axis, frame, id, g), "Flip");
+		if (dataOp) ops.push(dataOp);
 	}
-	D.length !== 0 && (h ? h(D, "Flip") : c.applyBatch(D, "Flip", s(c, n.adapterMethods)));
+	if (ops.length === 0) return;
+	if (applyOps) applyOps(ops, "Flip");
+	else scene.applyBatch(ops, "Flip", defaultCommitAdapter(scene, selection.adapterMethods));
 }
-var x = {
+/**
+* Flips the selection. `params.axis` (`'x'` | `'y'`, default `'x'`) picks the
+* direction, and the optional `params.pivot` (a `FlipPivot`, default `'each'`)
+* picks what it mirrors about.
+*/
+var flipAction = {
 	id: "flip",
 	label: "Flip",
 	group: "flip",
+	tags: ["mirror"],
 	variants: [{
 		key: "x",
 		label: "Flip Horizontal",
-		icon: v(c),
+		icon: /* @icon */ "core:flipX",
 		params: { axis: "x" }
 	}, {
 		key: "y",
 		label: "Flip Vertical",
-		icon: v(l),
+		icon: /* @icon */ "core:flipY",
 		params: { axis: "y" }
 	}],
 	defaultBinding: [{
 		spec: {
 			kind: "key",
 			key: ["h", "H"],
-			mods: { shift: !0 }
+			mods: { shift: true }
 		},
 		opts: { params: { axis: "x" } }
 	}, {
 		spec: {
 			kind: "key",
 			key: ["v", "V"],
-			mods: { shift: !0 }
+			mods: { shift: true }
 		},
 		opts: { params: { axis: "y" } }
 	}],
@@ -107,18 +157,26 @@ var x = {
 		"applyOps",
 		"geometryProjection",
 		"poseDescriptor",
-		"pointer"
+		"pointer",
+		"view",
+		"boundsIncludeStroke"
 	],
 	invoker: {
 		timing: "immediate",
-		run: (e, t) => {
-			let r = t?.axis ?? "x", i = t?.pivot ?? "each", a = e.selection, o = e.scene, s = e.applyOps, c = e.geometryProjection;
-			a && o && b(a, o, r, i, s, c, n(e.poseDescriptor), t, e.pointer);
+		run: (deps, params) => {
+			const axis = params?.axis ?? "x";
+			const pivot = params?.pivot ?? "each";
+			const selection = deps.selection;
+			const scene = deps.scene;
+			const applyOps = deps.applyOps;
+			const geometryProjection = deps.geometryProjection;
+			if (!selection || !scene) return;
+			flipSelection(selection, scene, axis, pivot, applyOps, geometryProjection, poseDescriptorOf(deps.poseDescriptor), params, deps.pointer, (frame) => drawnBoxes(deps, frame));
 		}
 	},
-	enabled: u
+	enabled: requiresSelection
 };
-//#endregion
-export { x as flipAction };
 
+//#endregion
+export { flipAction };
 //# sourceMappingURL=action.js.map