@weasel-js/core 1.9.2 → 1.9.4

package/dist/interactions/actions/defaults/setFill.js

@@ -1,13 +1,13 @@
-import { createPaintAction as e } from "./createPaintAction.js";
-import { DEFAULT_FILL_COLOR as t, paintWithColor as n } from "../../../util/paint.js";
+import { DEFAULT_FILL_COLOR as e, paintWithColor as t } from "../../../util/paint.js";
+import { createPaintAction as n } from "./createPaintAction.js";
 //#region src/interactions/actions/defaults/setFill.ts
-var r = e({
+var r = n({
 	id: "setFill",
 	label: "Set fill",
 	dataKey: "fill",
-	initialState: (e) => ({
-		color: e("color") ?? t,
-		paint: e("paint")
+	initialState: (t) => ({
+		color: t("color") ?? e,
+		paint: t("paint")
 	}),
 	readParams: (e, t) => {
 		let n = t?.color, r = t?.paint;
@@ -19,7 +19,7 @@ var r = e({
 			paint: r
 		};
 	},
-	merge: (e, t) => t.paint === void 0 ? n(e ?? void 0, t.color) : t.paint
+	merge: (e, n) => n.paint === void 0 ? t(e ?? void 0, n.color) : n.paint
 });
 //#endregion
 export { r as setFillAction };

package/dist/interactions/actions/defaults/setFillOpacity.js

@@ -1,13 +1,13 @@
-import { createPaintAction as e } from "./createPaintAction.js";
-import { DEFAULT_FILL_COLOR as t, paintWithAlpha as n, solid as r } from "../../../util/paint.js";
+import { DEFAULT_FILL_COLOR as e, paintWithAlpha as t, solid as n } from "../../../util/paint.js";
+import { createPaintAction as r } from "./createPaintAction.js";
 //#region src/interactions/actions/defaults/setFillOpacity.ts
-var i = e({
+var i = r({
 	id: "setFillOpacity",
 	label: "Set fill opacity",
 	dataKey: "fill",
 	initialState: (e) => e("alpha01") ?? 1,
 	readParams: (e, t) => t?.alpha01 ?? null,
-	merge: (e, i) => n(e ?? r(t), i)
+	merge: (r, i) => t(r ?? n(e), i)
 });
 //#endregion
 export { i as setFillOpacityAction };

package/dist/interactions/actions/defaults/setStroke.js

@@ -1,22 +1,22 @@
-import { createPaintAction as e } from "./createPaintAction.js";
-import { DEFAULT_STROKE_COLOR as t, paintWithColor as n, strokeOf as r, strokeWith as i } from "../../../util/paint.js";
+import { DEFAULT_STROKE_COLOR as e, paintWithColor as t, strokeOf as n, strokeWith as r } from "../../../util/paint.js";
+import { createPaintAction as i } from "./createPaintAction.js";
 //#region src/interactions/actions/defaults/setStroke.ts
-function a(e, t) {
-	return t.paint === null ? null : t.paint ? e ? {
+function a(e, i) {
+	return i.paint === null ? null : i.paint ? e ? {
 		...e,
-		paint: t.paint
-	} : i(t.paint) : e ? {
+		paint: i.paint
+	} : r(i.paint) : e ? {
 		...e,
-		paint: n(e.paint, t.color)
-	} : r(t.color);
+		paint: t(e.paint, i.color)
+	} : n(i.color);
 }
-var o = e({
+var o = i({
 	id: "setStroke",
 	label: "Set stroke",
 	dataKey: "stroke",
-	initialState: (e) => ({
-		color: e("color") ?? t,
-		paint: e("paint")
+	initialState: (t) => ({
+		color: t("color") ?? e,
+		paint: t("paint")
 	}),
 	readParams: (e, t) => {
 		let n = t?.color, r = t?.paint;

package/dist/interactions/actions/defaults/setStrokeOpacity.js

@@ -1,17 +1,17 @@
-import { createPaintAction as e } from "./createPaintAction.js";
-import { DEFAULT_STROKE_COLOR as t, paintWithAlpha as n, solid as r, strokeOf as i } from "../../../util/paint.js";
+import { DEFAULT_STROKE_COLOR as e, paintWithAlpha as t, solid as n, strokeOf as r } from "../../../util/paint.js";
+import { createPaintAction as i } from "./createPaintAction.js";
 //#region src/interactions/actions/defaults/setStrokeOpacity.ts
-var a = e({
+var a = i({
 	id: "setStrokeOpacity",
 	label: "Set stroke opacity",
 	dataKey: "stroke",
 	initialState: (e) => e("alpha01") ?? 1,
 	readParams: (e, t) => t?.alpha01 ?? null,
-	merge: (e, a) => {
-		let o = e ?? i(t);
+	merge: (i, a) => {
+		let o = i ?? r(e);
 		return {
 			...o,
-			paint: n(o.paint ?? r(t), a)
+			paint: t(o.paint ?? n(e), a)
 		};
 	}
 });

package/dist/interactions/actions/defaults/sliceOps.js

@@ -1,39 +1,39 @@
-import { createDeleteOp as e } from "../../../core/ops/delete.js";
-import { createInsertOp as t } from "../../../core/ops/create.js";
-import { pathToAnchors as n } from "../../../features/paths/anchors.js";
+import { pathToAnchors as e } from "../../../features/paths/anchors.js";
+import { createDeleteOp as t } from "../../../core/ops/delete.js";
+import { createInsertOp as n } from "../../../core/ops/create.js";
 import { boundsOfPath as r } from "@weasel-js/geom";
 import { snipPathByPolyline as i, splitPathByPolyline as a } from "@weasel-js/geom/booleans";
 //#region src/interactions/actions/defaults/sliceOps.ts
-function o(n) {
-	let { cut: o, nextId: l, selection: u } = n, d = n.placePiece ?? ((e, t) => ({
+function o(e) {
+	let { cut: o, nextId: l, selection: u } = e, d = e.placePiece ?? ((e, t) => ({
 		pose: s(e.node.pose, r(t)),
 		path: t
-	})), f = [], p = new Set(u ?? []), m = /* @__PURE__ */ new Set(), h = [], g = n.leaves.map((e, t) => ({
+	})), f = [], p = new Set(u ?? []), m = /* @__PURE__ */ new Set(), h = [], g = e.leaves.map((e, t) => ({
 		leaf: e,
 		i: t
 	})).sort((e, t) => t.leaf.index - e.leaf.index || e.i - t.i);
-	for (let { leaf: n } of g) {
-		let r = c(n.worldPath) ? i(n.worldPath, o) : a(n.worldPath, o);
+	for (let { leaf: e } of g) {
+		let r = c(e.worldPath) ? i(e.worldPath, o) : a(e.worldPath, o);
 		if (!r) continue;
-		let s = n.node.id;
-		m.add(s), f.push(e({
-			node: n.node,
-			index: n.index,
+		let s = e.node.id;
+		m.add(s), f.push(t({
+			node: e.node,
+			index: e.index,
 			label: "Slice"
 		}));
-		for (let e of r) {
-			let r = d(n, e), i = {
-				...n.node,
+		for (let t of r) {
+			let r = d(e, t), i = {
+				...e.node,
 				id: l(),
 				pose: r.pose,
 				data: {
-					...n.node.data,
+					...e.node.data,
 					path: r.path
 				}
 			};
-			f.push(t({
+			f.push(n({
 				node: i,
-				index: n.index,
+				index: e.index,
 				label: "Slice"
 			})), p.has(s) && h.push(i.id);
 		}
@@ -53,7 +53,7 @@ function s(e, t) {
 		height: t.height
 	};
 }
-var c = (e) => e.kind === "polygon" && n(e).closed.some((e) => !e);
+var c = (t) => t.kind === "polygon" && e(t).closed.some((e) => !e);
 //#endregion
 export { o as computeSliceOps };
 

package/dist/interactions/actions/defaults/viewportDragPan.js

@@ -8,7 +8,10 @@ function n(e, t) {
 		y: (e.current.y - r.y - (e.start.y - n.y)) * n.scale.y
 	};
 }
-var r = {
+function r(e, t) {
+	return e === t || e.x === t.x && e.y === t.y && e.scale.x === t.scale.x && e.scale.y === t.scale.y;
+}
+var i = {
 	id: "viewport.dragPan",
 	label: "Drag to pan viewport",
 	group: "viewport",
@@ -17,43 +20,51 @@ var r = {
 	requires: ["view", "debug"],
 	invoker: {
 		timing: "ongoing",
-		start(r, i) {
-			let a = r.deps.view;
-			if (!a) return {};
-			let o = a.get(), s = t(i?.params) ?? {}, c = s.inertia === !1 ? void 0 : s.inertia, l = {
-				startView: o,
-				view: a,
-				axis: s.axis ?? "both",
-				inertia: c,
-				tracker: c && a.decay ? e() : void 0,
+		start(i, a) {
+			let o = i.deps.view;
+			if (!o) return {};
+			let s = o.get(), c = t(a?.params) ?? {}, l = c.inertia === !1 ? void 0 : c.inertia, u = {
+				startView: s,
+				base: s,
+				baseScreen: {
+					x: 0,
+					y: 0
+				},
+				seen: s,
+				view: o,
+				axis: c.axis ?? "both",
+				inertia: l,
+				tracker: l && o.decay ? e() : void 0,
 				lastScreen: {
 					x: 0,
 					y: 0
 				}
-			}, u = r.deps.debug, d = r.drag?.start;
+			}, d = i.deps.debug, f = i.drag?.start;
 			return {
 				kind: "pan",
 				onMove(e) {
 					if (!e.drag) return;
-					let t = e.drag.screenDelta ?? n(e.drag, l), r = l.axis === "y" ? 0 : t.x, i = l.axis === "x" ? 0 : t.y;
-					l.tracker && (l.tracker.record(r - l.lastScreen.x, i - l.lastScreen.y, performance.now()), l.lastScreen = {
-						x: r,
-						y: i
-					});
-					let a = l.startView, o = {
-						...a,
-						x: a.x - r / a.scale.x,
-						y: a.y - i / a.scale.y
+					let t = e.drag.screenDelta ?? n(e.drag, u), i = u.axis === "y" ? 0 : t.x, a = u.axis === "x" ? 0 : t.y;
+					u.tracker?.record(i - u.lastScreen.x, a - u.lastScreen.y, performance.now());
+					let o = u.view.get();
+					r(o, u.seen) || (u.base = o, u.baseScreen = u.lastScreen), u.lastScreen = {
+						x: i,
+						y: a
+					};
+					let s = u.base, c = {
+						...s,
+						x: s.x - (i - u.baseScreen.x) / s.scale.x,
+						y: s.y - (a - u.baseScreen.y) / s.scale.y
 					};
-					l.view.set(o), u?.recordViewport("pan", a, o, d && {
-						x: d.x,
-						y: d.y
+					u.view.set(c), u.seen = u.view.get(), d?.recordViewport("pan", s, c, f && {
+						x: f.x,
+						y: f.y
 					});
 				},
 				onEnd(e, t) {
-					let { tracker: n, inertia: r, view: i } = l;
+					let { tracker: n, inertia: r, view: i } = u;
 					if (t === "cancel" || !n || !r || !i.decay) return;
-					let { vx: a, vy: o } = n.getVelocity(), s = l.startView.scale;
+					let { vx: a, vy: o } = n.getVelocity(), s = u.base.scale;
 					i.decay({
 						velocity: {
 							vx: -a / s.x,
@@ -83,6 +94,6 @@ var r = {
 	enabled: () => !0
 };
 //#endregion
-export { r as viewportDragPanAction };
+export { i as viewportDragPanAction };
 
 //# sourceMappingURL=viewportDragPan.js.map

package/dist/interactions/actions/defaults/viewportDragPan.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewportDragPan.js","names":["screenDeltaFromWorld","v0","scratch","now","drag","viewportDragPanAction","view","ctx","startView","params","resolveParams","opts","inertia","createVelocityTracker","debug","grab","moveCtx","screen","screenDx","screenDy","sv","next","v","reason","tracker","scale","vx","vy","cur","dx","dy"],"sources":["../../../../src/interactions/actions/defaults/viewportDragPan.ts"],"sourcesContent":["/**\n * `viewportDragPanAction` — ongoing Action descriptor for drag-to-pan the viewport.\n *\n * ## Bindings\n * None of its own. The hand tool binds a drag to it, and a canvas that pans on\n * any unclaimed drag adds `dragPanContribution`.\n *\n * ## Design notes\n * The drag delta from the dispatcher is in screen space (pixels). The pan\n * formula converts screen pixels to world units by dividing by zoom:\n *\n *   newView.x = startView.x - screenDx / startView.scale.x\n *   newView.y = startView.y - screenDy / startView.scale.y\n *\n * where `screenDx` / `screenDy` are the screen-space pixel deltas from the\n * drag origin. This ensures that at any zoom level, the drag behavior is\n * consistent: 1 screen pixel always pans the same amount relative to the\n * viewport's zoom (e.g., at 1x zoom: 100px → 100 world units; at 2x zoom:\n * 100px → 50 world units). The camera moves opposite to the drag direction\n * so that the scene content appears to follow the pointer.\n *\n * The descriptor captures `startView` in its own scratch at `start` time,\n * parallel to `useHandTool`'s `startView` capture in its scratch object.\n *\n * ## Axis locking and inertia\n * Both are read from the binding's `params` at `start`, so any consumer\n * binding this action gets them — not just `useHandTool`. `axis` drops one\n * component of every pan delta. `inertia` coasts the view after release,\n * through the optional `view.decay` dep; with no such dep wired the pan\n * simply lands, which is what an unconfigured consumer already expects.\n *\n * @see useHandTool — the React hook this descriptor parallels.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport { resolveParams, type InvocationCtx, type OngoingHandle, type BindingOpts } from '@weasel-js/routing';\nimport type { View } from 'core/viewport/view';\nimport type { ViewApi } from '../depSchema';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { createVelocityTracker, type VelocityTracker } from 'core/viewport/createVelocityTracker';\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface DragPanScratch {\n  startView: View;\n  view: ViewApi;\n  axis: 'both' | 'x' | 'y';\n  inertia: InertiaConfig | undefined;\n  tracker: VelocityTracker | undefined;\n  lastScreen: { x: number; y: number };\n}\n\n/**\n * Rebuild the client-pixel drag delta from the world one, for an event source\n * that supplied no `clientX`/`clientY`.\n *\n * A world delta is self-referential mid-pan — its two ends were measured under\n * different views — so it cannot simply be scaled. Undoing each end against the\n * view that produced it recovers the client delta exactly, since\n * `world = (client - origin) / scale + view` and neither the canvas origin nor\n * the scale moves during a pan.\n */\nfunction screenDeltaFromWorld(\n  drag: NonNullable<InvocationCtx['drag']>,\n  scratch: DragPanScratch,\n): { x: number; y: number } {\n  const v0 = scratch.startView;\n  const now = scratch.view.get();\n  return {\n    x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,\n    y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y,\n  };\n}\n\n/** Binding params `viewport.dragPan` understands. `useHandTool` supplies both;\n *  a bare binding supplies neither and pans both axes with no coasting. */\nexport interface DragPanParams {\n  axis?: 'both' | 'x' | 'y';\n  inertia?: false | InertiaConfig;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `viewport.dragPan` Action.\n *\n * Requires dep-schema entry: `view`.\n *\n * Translates the viewport by the screen-space drag delta so the canvas content\n * follows the pointer. Produces no scene ops — view changes are not undoable.\n */\n// No `eligible` field → viewport pan is always eligible across all modes.\nexport const viewportDragPanAction: Action & { requires: string[] } = {\n  id: 'viewport.dragPan',\n  label: 'Drag to pan viewport',\n  group: 'viewport',\n  // Hover hint: when this action would win the drag at the hovered point\n  // (e.g. empty canvas with no marquee-capable tool ahead of it), the\n  // hover-cursor pump shows the open hand.\n  cursor: 'grab',\n  // ...and the closed hand once the pan is actually running. This was\n  // `useHandTool`'s `engaged: { cursor: 'grabbing' }` — a phase-table entry\n  // on a tool, which meant a consumer who bound `viewport.dragPan` without\n  // the hand tool got no state cursor at all.\n  activeCursor: 'grabbing',\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const view = ctx.deps.view;\n      if (!view) return {};\n\n      const startView = view.get();\n      // Gesture-driven ongoing actions never see `ctx.params` — the dispatcher\n      // hands the binding's unresolved `opts` here and nowhere else, and pumps\n      // `onMove` / `onEnd` with an empty deps bag. Everything the gesture needs\n      // has to be captured now.\n      const params = (resolveParams(opts?.params) ?? {}) as DragPanParams;\n      const inertia = params.inertia === false ? undefined : params.inertia;\n      const scratch: DragPanScratch = {\n        startView,\n        view,\n        axis: params.axis ?? 'both',\n        inertia,\n        // Only track when a coast could actually happen, so the common\n        // no-inertia drag does no per-move work.\n        tracker: inertia && view.decay ? createVelocityTracker() : undefined,\n        lastScreen: { x: 0, y: 0 },\n      };\n      const debug = ctx.deps.debug;\n      const grab = ctx.drag?.start;\n\n      return {\n        kind: 'pan',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          // Use `screenDelta` (client/CSS pixels), NOT `delta` (world). Pan\n          // mutates the view itself, so world deltas are self-referential —\n          // after the first commit, `toWorld(currentClient)` returns a\n          // position offset by the just-applied pan, halving the apparent\n          // movement on every subsequent pointermove. Screen coords come\n          // straight from the DOM event and don't drift.\n          const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);\n          // An axis lock drops the other component of the *cumulative* delta,\n          // so the locked axis never moves however the pointer wanders.\n          const screenDx = scratch.axis === 'y' ? 0 : screen.x;\n          const screenDy = scratch.axis === 'x' ? 0 : screen.y;\n          if (scratch.tracker) {\n            scratch.tracker.record(\n              screenDx - scratch.lastScreen.x,\n              screenDy - scratch.lastScreen.y,\n              performance.now(),\n            );\n            scratch.lastScreen = { x: screenDx, y: screenDy };\n          }\n          const sv = scratch.startView;\n          // 1 screen px maps to 1/scale world units (at 2x zoom, 100 px →\n          // 50 world units of pan).\n          const next = {\n            ...sv,\n            x: sv.x - screenDx / sv.scale.x,\n            y: sv.y - screenDy / sv.scale.y,\n          };\n          scratch.view.set(next);\n          debug?.recordViewport('pan', sv, next, grab && { x: grab.x, y: grab.y });\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          // No scene ops to commit; the pan itself is already live. What is\n          // left is the coast, and only for a drag that actually ended.\n          const { tracker, inertia, view: v } = scratch;\n          if (reason === 'cancel' || !tracker || !inertia || !v.decay) return;\n          const { vx, vy } = tracker.getVelocity();\n          const scale = scratch.startView.scale;\n          v.decay({\n            // Screen px/ms → world units/ms, matching the onMove conversion.\n            velocity: { vx: -vx / scale.x, vy: -vy / scale.y },\n            friction: inertia.friction,\n            minSpeed: inertia.minSpeed,\n            boundary: inertia.boundary,\n            viewBounds: inertia.bounds,\n            initialPosition: { x: v.get().x, y: v.get().y },\n            onTick: (dx, dy) => {\n              const cur = v.get();\n              v.set({ ...cur, x: cur.x + dx, y: cur.y + dy });\n            },\n          });\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n"],"mappings":";;;AAgEA,SAASA,EACP,GACA,GAC0B;CAC1B,IAAMC,IAAKC,EAAQ,WACbC,IAAMD,EAAQ,KAAK,IAAI;CAC7B,OAAO;EACL,IAAIE,EAAK,QAAQ,IAAID,EAAI,KAAKC,EAAK,MAAM,IAAIH,EAAG,MAAMA,EAAG,MAAM;EAC/D,IAAIG,EAAK,QAAQ,IAAID,EAAI,KAAKC,EAAK,MAAM,IAAIH,EAAG,MAAMA,EAAG,MAAM;CACjE;AACF;AAuBA,IAAaI,IAAyD;CACpE,IAAI;CACJ,OAAO;CACP,OAAO;CAIP,QAAQ;CAKR,cAAc;CACd,UAAU,CAAC,QAAQ,OAAO;CAC1B,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAOC,EAAI,KAAK;GACtB,IAAI,CAACD,GAAM,OAAO,CAAC;GAEnB,IAAME,IAAYF,EAAK,IAAI,GAKrBG,IAAUC,EAAcC,GAAM,MAAM,KAAK,CAAC,GAC1CC,IAAUH,EAAO,YAAY,KAAQ,KAAA,IAAYA,EAAO,SACxDP,IAA0B;IAC9B;IACA;IACA,MAAMO,EAAO,QAAQ;IACrB;IAGA,SAASG,KAAWN,EAAK,QAAQO,EAAsB,IAAI,KAAA;IAC3D,YAAY;KAAE,GAAG;KAAG,GAAG;IAAE;GAC3B,GACMC,IAAQP,EAAI,KAAK,OACjBQ,IAAOR,EAAI,MAAM;GAEvB,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAI,CAACS,EAAQ,MAAM;KAOnB,IAAMC,IAASD,EAAQ,KAAK,eAAehB,EAAqBgB,EAAQ,MAAMd,CAAO,GAG/EgB,IAAWhB,EAAQ,SAAS,MAAM,IAAIe,EAAO,GAC7CE,IAAWjB,EAAQ,SAAS,MAAM,IAAIe,EAAO;KACnD,AAAIf,EAAQ,YACVA,EAAQ,QAAQ,OACdgB,IAAWhB,EAAQ,WAAW,GAC9BiB,IAAWjB,EAAQ,WAAW,GAC9B,YAAY,IAAI,CAClB,GACA,EAAQ,aAAa;MAAE,GAAGgB;MAAU,GAAGC;KAAS;KAElD,IAAMC,IAAKlB,EAAQ,WAGbmB,IAAO;MACX,GAAGD;MACH,GAAGA,EAAG,IAAIF,IAAWE,EAAG,MAAM;MAC9B,GAAGA,EAAG,IAAID,IAAWC,EAAG,MAAM;KAChC;KAEA,AADAlB,EAAQ,KAAK,IAAImB,CAAI,GACrBP,GAAO,eAAe,OAAOM,GAAIC,GAAMN,KAAQ;MAAE,GAAGA,EAAK;MAAG,GAAGA,EAAK;KAAE,CAAC;IACzE;IACA,MAAM,GAAwB,GAAmC;KAG/D,IAAM,EAAE,YAAS,YAAS,MAAMO,MAAMpB;KACtC,IAAIqB,MAAW,YAAY,CAACC,KAAW,CAACZ,KAAW,CAACU,EAAE,OAAO;KAC7D,IAAM,EAAE,OAAI,UAAOE,EAAQ,YAAY,GACjCC,IAAQvB,EAAQ,UAAU;KAChC,EAAE,MAAM;MAEN,UAAU;OAAE,IAAI,CAACwB,IAAKD,EAAM;OAAG,IAAI,CAACE,IAAKF,EAAM;MAAE;MACjD,UAAUb,EAAQ;MAClB,UAAUA,EAAQ;MAClB,UAAUA,EAAQ;MAClB,YAAYA,EAAQ;MACpB,iBAAiB;OAAE,GAAGU,EAAE,IAAI,CAAC,CAAC;OAAG,GAAGA,EAAE,IAAI,CAAC,CAAC;MAAE;MAC9C,SAAS,GAAI,MAAO;OAClB,IAAMM,IAAMN,EAAE,IAAI;OAClB,EAAE,IAAI;QAAE,GAAGM;QAAK,GAAGA,EAAI,IAAIC;QAAI,GAAGD,EAAI,IAAIE;OAAG,CAAC;MAChD;KACF,CAAC;IACH;GACF;EACF;CACF;CACA,eAAe;AACjB"}
+{"version":3,"file":"viewportDragPan.js","names":["screenDeltaFromWorld","v0","scratch","now","drag","sameCamera","a","b","viewportDragPanAction","view","ctx","startView","params","resolveParams","opts","inertia","createVelocityTracker","debug","grab","moveCtx","screen","screenDx","screenDy","sv","next","v","reason","tracker","scale","vx","vy","cur","dx","dy"],"sources":["../../../../src/interactions/actions/defaults/viewportDragPan.ts"],"sourcesContent":["/**\n * `viewportDragPanAction` — ongoing Action descriptor for drag-to-pan the viewport.\n *\n * ## Bindings\n * None of its own. The hand tool binds a drag to it, and a canvas that pans on\n * any unclaimed drag adds `dragPanContribution`.\n *\n * ## Design notes\n * The drag delta from the dispatcher is in screen space (pixels). The pan\n * formula converts screen pixels to world units by dividing by zoom:\n *\n *   newView.x = startView.x - screenDx / startView.scale.x\n *   newView.y = startView.y - screenDy / startView.scale.y\n *\n * where `screenDx` / `screenDy` are the screen-space pixel deltas from the\n * drag origin. This ensures that at any zoom level, the drag behavior is\n * consistent: 1 screen pixel always pans the same amount relative to the\n * viewport's zoom (e.g., at 1x zoom: 100px → 100 world units; at 2x zoom:\n * 100px → 50 world units). The camera moves opposite to the drag direction\n * so that the scene content appears to follow the pointer.\n *\n * The descriptor captures `startView` in its own scratch at `start` time,\n * parallel to `useHandTool`'s `startView` capture in its scratch object.\n *\n * ## Axis locking and inertia\n * Both are read from the binding's `params` at `start`, so any consumer\n * binding this action gets them — not just `useHandTool`. `axis` drops one\n * component of every pan delta. `inertia` coasts the view after release,\n * through the optional `view.decay` dep; with no such dep wired the pan\n * simply lands, which is what an unconfigured consumer already expects.\n *\n * @see useHandTool — the React hook this descriptor parallels.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport { resolveParams, type InvocationCtx, type OngoingHandle, type BindingOpts } from '@weasel-js/routing';\nimport type { View } from 'core/viewport/view';\nimport type { ViewApi } from '../depSchema';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { createVelocityTracker, type VelocityTracker } from 'core/viewport/createVelocityTracker';\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface DragPanScratch {\n  startView: View;\n  /** The view the pan is measured from, and the cumulative screen delta it\n   *  was taken at. The press, until something else moves the camera. */\n  base: View;\n  baseScreen: { x: number; y: number };\n  /** The view as this pan last left it. */\n  seen: View;\n  view: ViewApi;\n  axis: 'both' | 'x' | 'y';\n  inertia: InertiaConfig | undefined;\n  tracker: VelocityTracker | undefined;\n  lastScreen: { x: number; y: number };\n}\n\n/**\n * Rebuild the client-pixel drag delta from the world one, for an event source\n * that supplied no `clientX`/`clientY`.\n *\n * A world delta is self-referential mid-pan — its two ends were measured under\n * different views — so it cannot simply be scaled. Undoing each end against the\n * view that produced it recovers the client delta exactly, since\n * `world = (client - origin) / scale + view` and neither the canvas origin nor\n * the scale moves during a pan.\n */\nfunction screenDeltaFromWorld(\n  drag: NonNullable<InvocationCtx['drag']>,\n  scratch: DragPanScratch,\n): { x: number; y: number } {\n  const v0 = scratch.startView;\n  const now = scratch.view.get();\n  return {\n    x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,\n    y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y,\n  };\n}\n\nfunction sameCamera(a: View, b: View): boolean {\n  return a === b\n    || (a.x === b.x && a.y === b.y && a.scale.x === b.scale.x && a.scale.y === b.scale.y);\n}\n\n/** Binding params `viewport.dragPan` understands. `useHandTool` supplies both;\n *  a bare binding supplies neither and pans both axes with no coasting. */\nexport interface DragPanParams {\n  axis?: 'both' | 'x' | 'y';\n  inertia?: false | InertiaConfig;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `viewport.dragPan` Action.\n *\n * Requires dep-schema entry: `view`.\n *\n * Translates the viewport by the screen-space drag delta so the canvas content\n * follows the pointer. Produces no scene ops — view changes are not undoable.\n */\n// No `eligible` field → viewport pan is always eligible across all modes.\nexport const viewportDragPanAction: Action & { requires: string[] } = {\n  id: 'viewport.dragPan',\n  label: 'Drag to pan viewport',\n  group: 'viewport',\n  // Hover hint: when this action would win the drag at the hovered point\n  // (e.g. empty canvas with no marquee-capable tool ahead of it), the\n  // hover-cursor pump shows the open hand.\n  cursor: 'grab',\n  // ...and the closed hand once the pan is actually running. This was\n  // `useHandTool`'s `engaged: { cursor: 'grabbing' }` — a phase-table entry\n  // on a tool, which meant a consumer who bound `viewport.dragPan` without\n  // the hand tool got no state cursor at all.\n  activeCursor: 'grabbing',\n  requires: ['view', 'debug'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const view = ctx.deps.view;\n      if (!view) return {};\n\n      const startView = view.get();\n      // Gesture-driven ongoing actions never see `ctx.params` — the dispatcher\n      // hands the binding's unresolved `opts` here and nowhere else, and pumps\n      // `onMove` / `onEnd` with an empty deps bag. Everything the gesture needs\n      // has to be captured now.\n      const params = (resolveParams(opts?.params) ?? {}) as DragPanParams;\n      const inertia = params.inertia === false ? undefined : params.inertia;\n      const scratch: DragPanScratch = {\n        startView,\n        base: startView,\n        baseScreen: { x: 0, y: 0 },\n        seen: startView,\n        view,\n        axis: params.axis ?? 'both',\n        inertia,\n        // Only track when a coast could actually happen, so the common\n        // no-inertia drag does no per-move work.\n        tracker: inertia && view.decay ? createVelocityTracker() : undefined,\n        lastScreen: { x: 0, y: 0 },\n      };\n      const debug = ctx.deps.debug;\n      const grab = ctx.drag?.start;\n\n      return {\n        kind: 'pan',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          // Use `screenDelta` (client/CSS pixels), NOT `delta` (world). Pan\n          // mutates the view itself, so world deltas are self-referential —\n          // after the first commit, `toWorld(currentClient)` returns a\n          // position offset by the just-applied pan, halving the apparent\n          // movement on every subsequent pointermove. Screen coords come\n          // straight from the DOM event and don't drift.\n          const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);\n          // An axis lock drops the other component of the *cumulative* delta,\n          // so the locked axis never moves however the pointer wanders.\n          const screenDx = scratch.axis === 'y' ? 0 : screen.x;\n          const screenDy = scratch.axis === 'x' ? 0 : screen.y;\n          scratch.tracker?.record(\n            screenDx - scratch.lastScreen.x,\n            screenDy - scratch.lastScreen.y,\n            performance.now(),\n          );\n          // A zoom or pan from elsewhere while the drag is held (a wheel, a\n          // key) is kept: the pan carries on from where it left the camera.\n          const now = scratch.view.get();\n          if (!sameCamera(now, scratch.seen)) {\n            scratch.base = now;\n            scratch.baseScreen = scratch.lastScreen;\n          }\n          scratch.lastScreen = { x: screenDx, y: screenDy };\n          const sv = scratch.base;\n          // 1 screen px maps to 1/scale world units (at 2x zoom, 100 px →\n          // 50 world units of pan).\n          const next = {\n            ...sv,\n            x: sv.x - (screenDx - scratch.baseScreen.x) / sv.scale.x,\n            y: sv.y - (screenDy - scratch.baseScreen.y) / sv.scale.y,\n          };\n          scratch.view.set(next);\n          scratch.seen = scratch.view.get();\n          debug?.recordViewport('pan', sv, next, grab && { x: grab.x, y: grab.y });\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          // No scene ops to commit; the pan itself is already live. What is\n          // left is the coast, and only for a drag that actually ended.\n          const { tracker, inertia, view: v } = scratch;\n          if (reason === 'cancel' || !tracker || !inertia || !v.decay) return;\n          const { vx, vy } = tracker.getVelocity();\n          const scale = scratch.base.scale;\n          v.decay({\n            // Screen px/ms → world units/ms, matching the onMove conversion.\n            velocity: { vx: -vx / scale.x, vy: -vy / scale.y },\n            friction: inertia.friction,\n            minSpeed: inertia.minSpeed,\n            boundary: inertia.boundary,\n            viewBounds: inertia.bounds,\n            initialPosition: { x: v.get().x, y: v.get().y },\n            onTick: (dx, dy) => {\n              const cur = v.get();\n              v.set({ ...cur, x: cur.x + dx, y: cur.y + dy });\n            },\n          });\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n"],"mappings":";;;AAsEA,SAASA,EACP,GACA,GAC0B;CAC1B,IAAMC,IAAKC,EAAQ,WACbC,IAAMD,EAAQ,KAAK,IAAI;CAC7B,OAAO;EACL,IAAIE,EAAK,QAAQ,IAAID,EAAI,KAAKC,EAAK,MAAM,IAAIH,EAAG,MAAMA,EAAG,MAAM;EAC/D,IAAIG,EAAK,QAAQ,IAAID,EAAI,KAAKC,EAAK,MAAM,IAAIH,EAAG,MAAMA,EAAG,MAAM;CACjE;AACF;AAEA,SAASI,EAAW,GAAS,GAAkB;CAC7C,OAAOC,MAAMC,KACPD,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAM,MAAMC,EAAE,MAAM,KAAKD,EAAE,MAAM,MAAMC,EAAE,MAAM;AACvF;AAuBA,IAAaC,IAAyD;CACpE,IAAI;CACJ,OAAO;CACP,OAAO;CAIP,QAAQ;CAKR,cAAc;CACd,UAAU,CAAC,QAAQ,OAAO;CAC1B,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAOC,EAAI,KAAK;GACtB,IAAI,CAACD,GAAM,OAAO,CAAC;GAEnB,IAAME,IAAYF,EAAK,IAAI,GAKrBG,IAAUC,EAAcC,GAAM,MAAM,KAAK,CAAC,GAC1CC,IAAUH,EAAO,YAAY,KAAQ,KAAA,IAAYA,EAAO,SACxDV,IAA0B;IAC9B;IACA,MAAMS;IACN,YAAY;KAAE,GAAG;KAAG,GAAG;IAAE;IACzB,MAAMA;IACN;IACA,MAAMC,EAAO,QAAQ;IACrB;IAGA,SAASG,KAAWN,EAAK,QAAQO,EAAsB,IAAI,KAAA;IAC3D,YAAY;KAAE,GAAG;KAAG,GAAG;IAAE;GAC3B,GACMC,IAAQP,EAAI,KAAK,OACjBQ,IAAOR,EAAI,MAAM;GAEvB,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAI,CAACS,EAAQ,MAAM;KAOnB,IAAMC,IAASD,EAAQ,KAAK,eAAenB,EAAqBmB,EAAQ,MAAMjB,CAAO,GAG/EmB,IAAWnB,EAAQ,SAAS,MAAM,IAAIkB,EAAO,GAC7CE,IAAWpB,EAAQ,SAAS,MAAM,IAAIkB,EAAO;KACnD,EAAQ,SAAS,OACfC,IAAWnB,EAAQ,WAAW,GAC9BoB,IAAWpB,EAAQ,WAAW,GAC9B,YAAY,IAAI,CAClB;KAGA,IAAMC,IAAMD,EAAQ,KAAK,IAAI;KAK7B,AAJKG,EAAWF,GAAKD,EAAQ,IAAI,MAC/B,EAAQ,OAAOC,GACf,EAAQ,aAAaD,EAAQ,aAE/B,EAAQ,aAAa;MAAE,GAAGmB;MAAU,GAAGC;KAAS;KAChD,IAAMC,IAAKrB,EAAQ,MAGbsB,IAAO;MACX,GAAGD;MACH,GAAGA,EAAG,KAAKF,IAAWnB,EAAQ,WAAW,KAAKqB,EAAG,MAAM;MACvD,GAAGA,EAAG,KAAKD,IAAWpB,EAAQ,WAAW,KAAKqB,EAAG,MAAM;KACzD;KAGA,AAFArB,EAAQ,KAAK,IAAIsB,CAAI,GACrB,EAAQ,OAAOtB,EAAQ,KAAK,IAAI,GAChCe,GAAO,eAAe,OAAOM,GAAIC,GAAMN,KAAQ;MAAE,GAAGA,EAAK;MAAG,GAAGA,EAAK;KAAE,CAAC;IACzE;IACA,MAAM,GAAwB,GAAmC;KAG/D,IAAM,EAAE,YAAS,YAAS,MAAMO,MAAMvB;KACtC,IAAIwB,MAAW,YAAY,CAACC,KAAW,CAACZ,KAAW,CAACU,EAAE,OAAO;KAC7D,IAAM,EAAE,OAAI,UAAOE,EAAQ,YAAY,GACjCC,IAAQ1B,EAAQ,KAAK;KAC3B,EAAE,MAAM;MAEN,UAAU;OAAE,IAAI,CAAC2B,IAAKD,EAAM;OAAG,IAAI,CAACE,IAAKF,EAAM;MAAE;MACjD,UAAUb,EAAQ;MAClB,UAAUA,EAAQ;MAClB,UAAUA,EAAQ;MAClB,YAAYA,EAAQ;MACpB,iBAAiB;OAAE,GAAGU,EAAE,IAAI,CAAC,CAAC;OAAG,GAAGA,EAAE,IAAI,CAAC,CAAC;MAAE;MAC9C,SAAS,GAAI,MAAO;OAClB,IAAMM,IAAMN,EAAE,IAAI;OAClB,EAAE,IAAI;QAAE,GAAGM;QAAK,GAAGA,EAAI,IAAIC;QAAI,GAAGD,EAAI,IAAIE;OAAG,CAAC;MAChD;KACF,CAAC;IACH;GACF;EACF;CACF;CACA,eAAe;AACjB"}

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

@@ -1,52 +1,57 @@
 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";
 //#region src/interactions/actions/edit-anchors/geometry.ts
 function o(o) {
-	let { commands: s, coords: c } = o, l = [], u = null, d = (e, t) => {
+	let { commands: c, coords: l } = o, u = [], d = null, f = null, p = (e, t) => {
 		let n = {
-			anchorIndex: l.length,
-			x: c[e],
-			y: c[e + 1],
+			anchorIndex: u.length,
+			x: l[e],
+			y: l[e + 1],
 			coordIndex: e,
 			...t ? { controlIn: t } : {}
 		};
-		l.push(n), u = n;
+		u.push(n), d = n;
 	};
-	return a(s, c, (a, o) => {
+	return a(c, l, (a, o) => {
 		switch (a) {
 			case n:
+				p(o), f = d;
+				break;
 			case t:
-				d(o);
+				p(o);
 				break;
 			case e:
-				u && (u.controlOut = {
-					x: c[o],
-					y: c[o + 1],
+				d && (d.controlOut = {
+					x: l[o],
+					y: l[o + 1],
 					coordIndex: o
-				}), d(o + 4, {
-					x: c[o + 2],
-					y: c[o + 3],
+				}), p(o + 4, {
+					x: l[o + 2],
+					y: l[o + 3],
 					coordIndex: o + 2
 				});
 				break;
 			case r:
-				u && (u.controlOut = {
-					x: c[o],
-					y: c[o + 1],
+				d && (d.controlOut = {
+					x: l[o],
+					y: l[o + 1],
 					coordIndex: o
-				}), d(o + 2, {
-					x: c[o],
-					y: c[o + 1],
+				}), p(o + 2, {
+					x: l[o],
+					y: l[o + 1],
 					coordIndex: o
 				});
 				break;
 			case i:
-				u = null;
+				s(u, f, d), d = null, f = null;
 				break;
 			default: throw Error(`enumerateAnchors: unknown command ${a}`);
 		}
-	}), l;
+	}), u;
+}
+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 s(e, t, n, r) {
+function c(e, t, n, r) {
 	let i = new Float32Array(e.coords);
 	return i[t] = n, i[t + 1] = r, {
 		kind: "polygon",
@@ -56,6 +61,6 @@ function s(e, t, n, r) {
 	};
 }
 //#endregion
-export { o as enumerateAnchors, s as withCoord };
+export { o as enumerateAnchors, c as 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","push","a","coords","coordIndex","controlIn","forEachSegment","commands","cmd","PATH_M","PATH_L","ci","PATH_C","PATH_Q","PATH_Z","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}\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. */\nexport function enumerateAnchors(path: PolygonPath): PathAnchor[] {\n  const { commands, coords } = path;\n  const anchors: PathAnchor[] = [];\n  let lastAnchor: 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      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        lastAnchor = null;\n        break;\n      default:\n        throw new Error(`enumerateAnchors: unknown command ${cmd}`);\n    }\n  });\n  return anchors;\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 { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\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  // 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 { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n"],"mappings":";;AAwBA,SAAgBA,EAAiB,GAAiC;CAChE,IAAM,EAAE,aAAU,cAAWC,GACvBC,IAAwB,CAAC,GAC3BC,IAAgC,MAE9BC,KAAQ,GAAoB,MAA8C;EAC9E,IAAMC,IAAgB;GACpB,aAAaH,EAAQ;GACrB,GAAGI,EAAOC;GACV,GAAGD,EAAOC,IAAa;GACvB;GACA,GAAIC,IAAY,EAAE,aAAU,IAAI,CAAC;EACnC;EAEA,AADAN,EAAQ,KAAKG,CAAC,GACd,IAAaA;CACf;CA2BA,OAzBAI,EAAeC,GAAUJ,IAAS,GAAK,MAAO;EAC5C,QAAQK,GAAR;GACE,KAAKC;GACL,KAAKC;IACH,EAAKC,CAAE;IACP;GACF,KAAKC;IAIH,AAHIZ,MACF,EAAW,aAAa;KAAE,GAAGG,EAAOQ;KAAK,GAAGR,EAAOQ,IAAK;KAAI,YAAYA;IAAG,IAE7EV,EAAKU,IAAK,GAAG;KAAE,GAAGR,EAAOQ,IAAK;KAAI,GAAGR,EAAOQ,IAAK;KAAI,YAAYA,IAAK;IAAE,CAAC;IACzE;GACF,KAAKE;IAIH,AAHIb,MACF,EAAW,aAAa;KAAE,GAAGG,EAAOQ;KAAK,GAAGR,EAAOQ,IAAK;KAAI,YAAYA;IAAG,IAE7EV,EAAKU,IAAK,GAAG;KAAE,GAAGR,EAAOQ;KAAK,GAAGR,EAAOQ,IAAK;KAAI,YAAYA;IAAG,CAAC;IACjE;GACF,KAAKG;IACH,IAAa;IACb;GACF,SACE,MAAU,MAAM,qCAAqCN,GAAK;EAC9D;CACF,CAAC,GACMT;AACT;AAIA,SAAgBgB,EAAU,GAAmB,GAAoB,GAAW,GAAwB;CAClG,IAAMC,IAAO,IAAI,aAAalB,EAAK,MAAM;CAGzC,OAFA,EAAKM,KAAca,GACnB,EAAKb,IAAa,KAAKc,GAChB;EAAE,MAAM;EAAW,UAAUpB,EAAK;EAAU,QAAQkB;EAAM,UAAUlB,EAAK;CAAS;AAC3F"}
+{"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 { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\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 { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\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,MAAM;EAAW,UAAUxB,EAAK;EAAU,QAAQsB;EAAM,UAAUtB,EAAK;CAAS;AAC3F"}

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

@@ -1,25 +1,26 @@
+import { poseLinearOf as e } from "../../../core/geometry/poseFrame.js";
 //#region src/interactions/actions/flip/helpers.ts
-function e(e, t, i, a) {
-	let o = i.getBounds(e), s = a.x + a.width / 2, c = a.y + a.height / 2, l = t === "x" ? {
-		x: 2 * s - o.x,
-		y: o.y,
-		width: -o.width,
-		height: o.height
+function t(e, t, n, o) {
+	let s = n.getBounds(e), c = o.x + o.width / 2, l = o.y + o.height / 2, u = t === "x" ? {
+		x: 2 * c - s.x,
+		y: s.y,
+		width: -s.width,
+		height: s.height
 	} : {
-		x: o.x,
-		y: 2 * c - o.y,
-		width: o.width,
-		height: -o.height
-	}, u = i.remapBounds(e, o, l), d = i.getRotation?.(e) ?? o.rotation ?? 0;
-	return n(r(u), d, i);
+		x: s.x,
+		y: 2 * l - s.y,
+		width: s.width,
+		height: -s.height
+	}, d = n.remapBounds(e, s, u), f = n.getRotation?.(e) ?? s.rotation ?? 0;
+	return a(r(i(d), f, n));
 }
-function t(t, n, r) {
-	return e(t, n, r, r.getBounds(t));
+function n(e, n, r) {
+	return t(e, n, r, r.getBounds(e));
 }
-function n(e, t, n) {
+function r(e, t, n) {
 	return t === 0 ? e : n.withRotation ? n.withRotation(e, -t) : e;
 }
-function r(e) {
+function i(e) {
 	let t = e, n = !1, r = t.x, i = t.y, a = t.width, o = t.height;
 	return typeof a == "number" && a < 0 && typeof r == "number" && (r += a, a = -a, n = !0), typeof o == "number" && o < 0 && typeof i == "number" && (i += o, o = -o, n = !0), n ? {
 		...e,
@@ -29,7 +30,19 @@ function r(e) {
 		height: o
 	} : e;
 }
+function a(t) {
+	let n = e(t);
+	return !n || n[1] === 0 && n[2] === 0 ? t : {
+		...t,
+		transform: [
+			n[0],
+			-n[1],
+			-n[2],
+			n[3]
+		]
+	};
+}
 //#endregion
-export { e as flipPoseAboutBounds, t as flipPoseViaDescriptor };
+export { t as flipPoseAboutBounds, n as flipPoseViaDescriptor };
 
 //# sourceMappingURL=helpers.js.map

package/dist/interactions/actions/flip/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","names":["flipPoseAboutBounds","src","geometry","pose","cxPivot","pivotBounds","cyPivot","dst","axis","next","rotation","negateRotation","normalizeNegativeExtent","flipPoseViaDescriptor","p","mutated","nx","ny","nw","nh"],"sources":["../../../../src/interactions/actions/flip/helpers.ts"],"sourcesContent":["/**\n * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).\n *\n * These were extracted from the legacy `useFlip` hook when it was removed —\n * they remain because the descriptor-style `flipAction` still needs to reflect\n * arbitrary `TPose` values through a `PoseDescriptor`.\n */\nimport type { PoseDescriptor } from '../resize/geometry';\nimport type { SpatialReference } from '../spatialReference';\n\n/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */\nexport type FlipAxis = 'x' | 'y';\n\n/** How a multi-selection flip chooses its pivot.\n *\n *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the\n *    selection is unchanged, individual items are reflected in place.\n *  - `'union'` — every pose mirrors about the selection's union AABB; items\n *    swap sides as well as reflect, matching Illustrator/Figma defaults.\n *  - a {@link SpatialReference} — every pose mirrors about the center of the\n *    bounds it names: the pointer, a world point or rect, or a key node. */\nexport type FlipPivot = 'each' | 'union' | SpatialReference;\n\n/** Reflect `pose` across the centerline of `pivotBounds` along `axis`, using\n *  `geometry` to read bounds and remap. The pose's own AABB is read once to\n *  compute the reflected destination rect; coords inside the pose are then\n *  remapped through the affine that takes its own bounds → reflected dst.\n *  A rotation the pose carries is negated: a mirror reverses the sense of the\n *  turn, and `remapBounds` carries the original angle through untouched. */\nexport function flipPoseAboutBounds<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n  pivotBounds: { x: number; y: number; width: number; height: number },\n): TPose {\n  const src = geometry.getBounds(pose);\n  const cxPivot = pivotBounds.x + pivotBounds.width / 2;\n  const cyPivot = pivotBounds.y + pivotBounds.height / 2;\n  const dst = axis === 'x'\n    ? { x: 2 * cxPivot - src.x, y: src.y, width: -src.width, height: src.height }\n    : { x: src.x, y: 2 * cyPivot - src.y, width: src.width, height: -src.height };\n  const next = geometry.remapBounds(pose, src, dst);\n  const rotation = geometry.getRotation?.(pose) ?? (src as { rotation?: number }).rotation ?? 0;\n  return negateRotation(normalizeNegativeExtent(next), rotation, geometry);\n}\n\n/** Reflect `pose` across the centerline of its own AABB along `axis`. */\nexport function flipPoseViaDescriptor<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  return flipPoseAboutBounds(pose, axis, geometry, geometry.getBounds(pose));\n}\n\nfunction negateRotation<TPose>(pose: TPose, rotation: number, geometry: PoseDescriptor<TPose>): TPose {\n  if (rotation === 0) return pose;\n  return geometry.withRotation ? geometry.withRotation(pose, -rotation) : pose;\n}\n\nfunction normalizeNegativeExtent<TPose>(pose: TPose): TPose {\n  const p = pose as unknown as { x?: number; y?: number; width?: number; height?: number };\n  let mutated = false;\n  let nx = p.x;\n  let ny = p.y;\n  let nw = p.width;\n  let nh = p.height;\n  if (typeof nw === 'number' && nw < 0 && typeof nx === 'number') {\n    nx = nx + nw;\n    nw = -nw;\n    mutated = true;\n  }\n  if (typeof nh === 'number' && nh < 0 && typeof ny === 'number') {\n    ny = ny + nh;\n    nh = -nh;\n    mutated = true;\n  }\n  if (!mutated) return pose;\n  return { ...(pose as object), x: nx, y: ny, width: nw, height: nh } as TPose;\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAMC,EAAS,UAAUC,CAAI,GAC7BC,IAAUC,EAAY,IAAIA,EAAY,QAAQ,GAC9CC,IAAUD,EAAY,IAAIA,EAAY,SAAS,GAC/CE,IAAMC,MAAS,MACjB;EAAE,GAAG,IAAIJ,IAAUH,EAAI;EAAG,GAAGA,EAAI;EAAG,OAAO,CAACA,EAAI;EAAO,QAAQA,EAAI;CAAO,IAC1E;EAAE,GAAGA,EAAI;EAAG,GAAG,IAAIK,IAAUL,EAAI;EAAG,OAAOA,EAAI;EAAO,QAAQ,CAACA,EAAI;CAAO,GACxEQ,IAAOP,EAAS,YAAYC,GAAMF,GAAKM,CAAG,GAC1CG,IAAWR,EAAS,cAAcC,CAAI,KAAMF,EAA8B,YAAY;CAC5F,OAAOU,EAAeC,EAAwBH,CAAI,GAAGC,GAAUR,CAAQ;AACzE;AAGA,SAAgBW,EACd,GACA,GACA,GACO;CACP,OAAOb,EAAoBG,GAAMK,GAAMN,GAAUA,EAAS,UAAUC,CAAI,CAAC;AAC3E;AAEA,SAASQ,EAAsB,GAAa,GAAkB,GAAwC;CAEpG,OADID,MAAa,IAAUP,IACpBD,EAAS,eAAeA,EAAS,aAAaC,GAAM,CAACO,CAAQ,IAAIP;AAC1E;AAEA,SAASS,EAA+B,GAAoB;CAC1D,IAAME,IAAIX,GACNY,IAAU,IACVC,IAAKF,EAAE,GACPG,IAAKH,EAAE,GACPI,IAAKJ,EAAE,OACPK,IAAKL,EAAE;CAYX,OAXI,OAAOI,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAER,OAAOC,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAEPJ,IACE;EAAE,GAAIZ;EAAiB,GAAGa;EAAI,GAAGC;EAAI,OAAOC;EAAI,QAAQC;CAAG,IAD7ChB;AAEvB"}
+{"version":3,"file":"helpers.js","names":["flipPoseAboutBounds","src","geometry","pose","cxPivot","pivotBounds","cyPivot","dst","axis","next","rotation","mirrorLinear","negateRotation","normalizeNegativeExtent","flipPoseViaDescriptor","p","mutated","nx","ny","nw","nh","l","poseLinearOf"],"sources":["../../../../src/interactions/actions/flip/helpers.ts"],"sourcesContent":["/**\n * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).\n *\n * These were extracted from the legacy `useFlip` hook when it was removed —\n * they remain because the descriptor-style `flipAction` still needs to reflect\n * arbitrary `TPose` values through a `PoseDescriptor`.\n */\nimport type { PoseDescriptor } from '../resize/geometry';\nimport type { SpatialReference } from '../spatialReference';\nimport { poseLinearOf } from 'core/geometry/poseFrame';\n\n/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */\nexport type FlipAxis = 'x' | 'y';\n\n/** How a multi-selection flip chooses its pivot.\n *\n *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the\n *    selection is unchanged, individual items are reflected in place.\n *  - `'union'` — every pose mirrors about the selection's union AABB; items\n *    swap sides as well as reflect, matching Illustrator/Figma defaults.\n *  - a {@link SpatialReference} — every pose mirrors about the center of the\n *    bounds it names: the pointer, a world point or rect, or a key node. */\nexport type FlipPivot = 'each' | 'union' | SpatialReference;\n\n/** Reflect `pose` across the centerline of `pivotBounds` along `axis`, using\n *  `geometry` to read bounds and remap. The pose's own AABB is read once to\n *  compute the reflected destination rect; coords inside the pose are then\n *  remapped through the affine that takes its own bounds → reflected dst.\n *  A rotation the pose carries is negated: a mirror reverses the sense of the\n *  turn, and `remapBounds` carries the original angle through untouched. A\n *  `transform` it carries is mirrored the same way, on either axis. */\nexport function flipPoseAboutBounds<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n  pivotBounds: { x: number; y: number; width: number; height: number },\n): TPose {\n  const src = geometry.getBounds(pose);\n  const cxPivot = pivotBounds.x + pivotBounds.width / 2;\n  const cyPivot = pivotBounds.y + pivotBounds.height / 2;\n  const dst = axis === 'x'\n    ? { x: 2 * cxPivot - src.x, y: src.y, width: -src.width, height: src.height }\n    : { x: src.x, y: 2 * cyPivot - src.y, width: src.width, height: -src.height };\n  const next = geometry.remapBounds(pose, src, dst);\n  const rotation = geometry.getRotation?.(pose) ?? (src as { rotation?: number }).rotation ?? 0;\n  return mirrorLinear(negateRotation(normalizeNegativeExtent(next), rotation, geometry));\n}\n\n/** Reflect `pose` across the centerline of its own AABB along `axis`. */\nexport function flipPoseViaDescriptor<TPose>(\n  pose: TPose,\n  axis: FlipAxis,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  return flipPoseAboutBounds(pose, axis, geometry, geometry.getBounds(pose));\n}\n\nfunction negateRotation<TPose>(pose: TPose, rotation: number, geometry: PoseDescriptor<TPose>): TPose {\n  if (rotation === 0) return pose;\n  return geometry.withRotation ? geometry.withRotation(pose, -rotation) : pose;\n}\n\nfunction normalizeNegativeExtent<TPose>(pose: TPose): TPose {\n  const p = pose as unknown as { x?: number; y?: number; width?: number; height?: number };\n  let mutated = false;\n  let nx = p.x;\n  let ny = p.y;\n  let nw = p.width;\n  let nh = p.height;\n  if (typeof nw === 'number' && nw < 0 && typeof nx === 'number') {\n    nx = nx + nw;\n    nw = -nw;\n    mutated = true;\n  }\n  if (typeof nh === 'number' && nh < 0 && typeof ny === 'number') {\n    ny = ny + nh;\n    nh = -nh;\n    mutated = true;\n  }\n  if (!mutated) return pose;\n  return { ...(pose as object), x: nx, y: ny, width: nw, height: nh } as TPose;\n}\n\n/** `M · L · M` for a mirror `M` on either axis: the off-diagonal terms change sign. */\nfunction mirrorLinear<TPose>(pose: TPose): TPose {\n  const l = poseLinearOf(pose);\n  if (!l || (l[1] === 0 && l[2] === 0)) return pose;\n  return { ...(pose as object), transform: [l[0], -l[1], -l[2], l[3]] } as TPose;\n}\n"],"mappings":";;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAMC,EAAS,UAAUC,CAAI,GAC7BC,IAAUC,EAAY,IAAIA,EAAY,QAAQ,GAC9CC,IAAUD,EAAY,IAAIA,EAAY,SAAS,GAC/CE,IAAMC,MAAS,MACjB;EAAE,GAAG,IAAIJ,IAAUH,EAAI;EAAG,GAAGA,EAAI;EAAG,OAAO,CAACA,EAAI;EAAO,QAAQA,EAAI;CAAO,IAC1E;EAAE,GAAGA,EAAI;EAAG,GAAG,IAAIK,IAAUL,EAAI;EAAG,OAAOA,EAAI;EAAO,QAAQ,CAACA,EAAI;CAAO,GACxEQ,IAAOP,EAAS,YAAYC,GAAMF,GAAKM,CAAG,GAC1CG,IAAWR,EAAS,cAAcC,CAAI,KAAMF,EAA8B,YAAY;CAC5F,OAAOU,EAAaC,EAAeC,EAAwBJ,CAAI,GAAGC,GAAUR,CAAQ,CAAC;AACvF;AAGA,SAAgBY,EACd,GACA,GACA,GACO;CACP,OAAOd,EAAoBG,GAAMK,GAAMN,GAAUA,EAAS,UAAUC,CAAI,CAAC;AAC3E;AAEA,SAASS,EAAsB,GAAa,GAAkB,GAAwC;CAEpG,OADIF,MAAa,IAAUP,IACpBD,EAAS,eAAeA,EAAS,aAAaC,GAAM,CAACO,CAAQ,IAAIP;AAC1E;AAEA,SAASU,EAA+B,GAAoB;CAC1D,IAAME,IAAIZ,GACNa,IAAU,IACVC,IAAKF,EAAE,GACPG,IAAKH,EAAE,GACPI,IAAKJ,EAAE,OACPK,IAAKL,EAAE;CAYX,OAXI,OAAOI,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAER,OAAOC,KAAO,YAAYA,IAAK,KAAK,OAAOF,KAAO,aACpD,KAAUE,GACV,IAAK,CAACA,GACN,IAAU,KAEPJ,IACE;EAAE,GAAIb;EAAiB,GAAGc;EAAI,GAAGC;EAAI,OAAOC;EAAI,QAAQC;CAAG,IAD7CjB;AAEvB;AAGA,SAASQ,EAAoB,GAAoB;CAC/C,IAAMU,IAAIC,EAAanB,CAAI;CAE3B,OADI,CAACkB,KAAMA,EAAE,OAAO,KAAKA,EAAE,OAAO,IAAWlB,IACtC;EAAE,GAAIA;EAAiB,WAAW;GAACkB,EAAE;GAAI,CAACA,EAAE;GAAI,CAACA,EAAE;GAAIA,EAAE;EAAE;CAAE;AACtE"}

package/dist/interactions/actions/hitSelection.js

@@ -0,0 +1,8 @@
+//#region src/interactions/actions/hitSelection.ts
+function e(e, t, n) {
+	return [...new Set(n ? [...e, ...t] : t)];
+}
+//#endregion
+export { e as selectionFromHits };
+
+//# sourceMappingURL=hitSelection.js.map

package/dist/interactions/actions/hitSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitSelection.js","names":["selectionFromHits","extend","current","hits"],"sources":["../../../src/interactions/actions/hitSelection.ts"],"sourcesContent":["/** The selection a hit list leaves behind: the hits alone, or, when the\n *  gesture extends the selection, the current ids with the new hits after them. */\nexport function selectionFromHits<T extends string>(\n  current: readonly T[],\n  hits: readonly T[],\n  extend: boolean,\n): T[] {\n  return [...new Set(extend ? [...current, ...hits] : hits)];\n}\n"],"mappings":";AAEA,SAAgBA,EACd,GACA,GACA,GACK;CACL,OAAO,CAAC,GAAG,IAAI,IAAIC,IAAS,CAAC,GAAGC,GAAS,GAAGC,CAAI,IAAIA,CAAI,CAAC;AAC3D"}

package/dist/interactions/actions/lasso-select/behaviors/selectFromLasso.js

@@ -1,39 +1,35 @@
-import { createSetSelectionOp as e } from "../../../../core/ops/select.js";
-import { getScratch as t, scratchKey as n } from "@weasel-js/routing";
+import { selectionFromHits as e } from "../../hitSelection.js";
+import { createSetSelectionOp as t } from "../../../../core/ops/select.js";
+import { getScratch as n, scratchKey as r } from "@weasel-js/routing";
 //#region src/interactions/actions/lasso-select/behaviors/selectFromLasso.ts
-var r = n("lassoSelect.vertices"), i = 4;
-function a(n) {
-	let a = n?.mode ?? "intersect";
+var i = r("lassoSelect.vertices"), a = 4;
+function o(r) {
+	let o = r?.mode ?? "intersect";
 	return {
 		defaultTransient: !0,
-		onEnd(n) {
-			let c = n.adapter;
+		onEnd(r) {
+			let c = r.adapter;
 			if (!c.getSelection || !c.hitTestLasso) return null;
-			let l = t(n.scratch, r) ?? [], u = n.origin.get("gesture"), d = u ? u.shiftHeld === !0 : !1, f = c.getSelection();
-			if (l.length < 3 || o(l) < i) return [e({
+			let l = n(r.scratch, i) ?? [], u = r.origin.get("gesture"), d = u ? u.shiftHeld === !0 : !1, f = c.getSelection();
+			if (l.length < 3 || s(l) < a) return [t({
 				from: f,
 				to: d ? f : []
 			})];
-			let p = c.hitTestLasso(l, a), m = d ? s(f, p) : p;
-			return [e({
+			let p = c.hitTestLasso(l, o), m = e(f, p, d);
+			return [t({
 				from: f,
 				to: m
 			})];
 		}
 	};
 }
-function o(e) {
+function s(e) {
 	if (e.length === 0) return 0;
 	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity;
 	for (let a of e) a.x < t && (t = a.x), a.y < n && (n = a.y), a.x > r && (r = a.x), a.y > i && (i = a.y);
 	return (r - t) * (i - n);
 }
-function s(e, t) {
-	let n = [...e];
-	for (let e of t) n.includes(e) || n.push(e);
-	return n;
-}
 //#endregion
-export { r as LASSO_VERTICES, a as selectFromLasso };
+export { i as LASSO_VERTICES, o as selectFromLasso };
 
 //# sourceMappingURL=selectFromLasso.js.map