@weasel-js/core 1.10.1 → 1.11.0

package/dist/interactions/actions/insert/extras.js

@@ -1,65 +1,87 @@
 //#region src/interactions/actions/insert/extras.ts
-function e(e, t, n, r, i, a) {
-	let o = e?.kind ?? "rect";
-	switch (o) {
+/** Build a typed `InsertExtras` from the static params + gesture context.
+*  Kit-built-in kinds (line / polygon / star / pencil) read kind-specific
+*  fields; unknown kinds pass the raw params through as `{ kind, ... }`. */
+function buildExtras(params, startX, startY, currentX, currentY, points) {
+	const kind = params?.["kind"] ?? "rect";
+	switch (kind) {
 		case "rect":
-		case "ellipse": return { kind: o };
+		case "ellipse": return { kind };
 		case "line": return {
 			kind: "line",
 			a: {
-				x: t,
-				y: n
+				x: startX,
+				y: startY
 			},
 			b: {
-				x: r,
-				y: i
+				x: currentX,
+				y: currentY
 			}
 		};
 		case "polygon": {
-			let a = Number(e?.sides ?? 6), o = r === t && i === n ? 0 : Math.atan2(i - n, r - t), s = {
+			const sides = Number(params?.["sides"] ?? 6);
+			const dragAngle = currentX === startX && currentY === startY ? 0 : Math.atan2(currentY - startY, currentX - startX);
+			const extras = {
 				kind: "polygon",
-				sides: a,
-				rotation: e?.rotation === void 0 ? o : Number(e.rotation)
+				sides,
+				rotation: params?.["rotation"] !== void 0 ? Number(params["rotation"]) : dragAngle
 			};
-			if (e?.originMode === "center") {
-				let e = r - t, a = i - n;
-				s.center = {
-					x: t,
-					y: n
-				}, s.radius = Math.hypot(e, a);
-			} else e?.center !== void 0 && (s.center = e.center), e?.radius !== void 0 && (s.radius = e.radius);
-			return s;
+			if (params?.["originMode"] === "center") {
+				const dx = currentX - startX;
+				const dy = currentY - startY;
+				extras.center = {
+					x: startX,
+					y: startY
+				};
+				extras.radius = Math.hypot(dx, dy);
+			} else {
+				if (params?.["center"] !== void 0) extras.center = params["center"];
+				if (params?.["radius"] !== void 0) extras.radius = params["radius"];
+			}
+			return extras;
 		}
 		case "star": {
-			let a = Number(e?.points ?? 5), o = Number(e?.innerRadiusRatio ?? .5), s = r === t && i === n ? 0 : Math.atan2(i - n, r - t), c = {
+			const pts = Number(params?.["points"] ?? 5);
+			const ir = Number(params?.["innerRadiusRatio"] ?? .5);
+			const dragAngle = currentX === startX && currentY === startY ? 0 : Math.atan2(currentY - startY, currentX - startX);
+			const extras = {
 				kind: "star",
-				points: a,
-				innerRadiusRatio: o,
-				rotation: e?.rotation === void 0 ? s : Number(e.rotation)
+				points: pts,
+				innerRadiusRatio: ir,
+				rotation: params?.["rotation"] !== void 0 ? Number(params["rotation"]) : dragAngle
 			};
-			if (e?.originMode === "center") {
-				let e = r - t, a = i - n;
-				c.center = {
-					x: t,
-					y: n
-				}, c.outerRadius = Math.hypot(e, a);
-			} else e?.center !== void 0 && (c.center = e.center), e?.outerRadius !== void 0 && (c.outerRadius = e.outerRadius);
-			return c;
+			if (params?.["originMode"] === "center") {
+				const dx = currentX - startX;
+				const dy = currentY - startY;
+				extras.center = {
+					x: startX,
+					y: startY
+				};
+				extras.outerRadius = Math.hypot(dx, dy);
+			} else {
+				if (params?.["center"] !== void 0) extras.center = params["center"];
+				if (params?.["outerRadius"] !== void 0) extras.outerRadius = params["outerRadius"];
+			}
+			return extras;
 		}
 		case "pencil": return {
 			kind: "pencil",
-			samples: e?.samples ?? a ?? []
+			samples: params?.["samples"] ?? points ?? []
 		};
 		default: return {
-			...e ?? {},
-			kind: o
+			...params ?? {},
+			kind
 		};
 	}
 }
-function t(e, t) {
-	t !== 0 && (e.kind === "star" || e.kind === "polygon") && (e.rotation += t);
+/** Add a user-driven rotation offset onto kinds that carry rotation. Rect
+*  / ellipse / line / pencil don't expose a rotation field on their
+*  extras today, so they ignore the offset. */
+function applyUserRotation(extras, userRotation) {
+	if (userRotation === 0) return;
+	if (extras.kind === "star" || extras.kind === "polygon") extras.rotation += userRotation;
 }
-//#endregion
-export { t as applyUserRotation, e as buildExtras };
 
+//#endregion
+export { applyUserRotation, buildExtras };
 //# sourceMappingURL=extras.js.map

package/dist/interactions/actions/insert/extras.js.map

@@ -1 +1 @@
-{"version":3,"file":"extras.js","names":["buildExtras","kind","params","\"kind\"","startX","startY","currentX","currentY","sides","\"sides\"","dragAngle","extras","\"rotation\"","\"originMode\"","dx","dy","\"center\"","\"radius\"","pts","\"points\"","ir","\"innerRadiusRatio\"","\"outerRadius\"","\"samples\"","points","applyUserRotation","userRotation"],"sources":["../../../../src/interactions/actions/insert/extras.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertExtras } from '../depSchema';\n\n/** Build a typed `InsertExtras` from the static params + gesture context.\n *  Kit-built-in kinds (line / polygon / star / pencil) read kind-specific\n *  fields; unknown kinds pass the raw params through as `{ kind, ... }`. */\nexport function buildExtras(\n  params: Record<string, unknown> | undefined,\n  startX: number,\n  startY: number,\n  currentX: number,\n  currentY: number,\n  points: ReadonlyArray<DragSample> | null,\n): InsertExtras {\n  const kind = ((params?.['kind'] as string | undefined) ?? 'rect');\n  switch (kind) {\n    case 'rect':\n    case 'ellipse':\n      return { kind } as InsertExtras;\n    case 'line':\n      // Use the live drag endpoints (not AABB) so the line preserves the\n      // user's drag direction — drag from bottom-left to top-right makes a\n      // line that slopes up, not the bounds diagonal.\n      return { kind: 'line', a: { x: startX, y: startY }, b: { x: currentX, y: currentY } };\n    case 'polygon': {\n      const sides = Number(params?.['sides'] ?? 6);\n      // When the tool omits rotation, point the first vertex along the\n      // drag vector so dragging in a direction orients the shape that\n      // way. Sub-pixel drags (no direction yet) fall back to 0.\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'polygon', sides, rotation };\n      // Drag-from-center: tool's Alt binding passes `originMode:'center'`.\n      // Compute polygon center + radius from the drag vector so the shape\n      // anchors on the click point. Without this, the dep falls back to\n      // inscribing in the AABB (drag-from-corner default).\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { radius?: unknown }).radius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['radius'] !== undefined) (extras as { radius?: unknown }).radius = params['radius'];\n      }\n      return extras;\n    }\n    case 'star': {\n      const pts = Number(params?.['points'] ?? 5);\n      const ir = Number(params?.['innerRadiusRatio'] ?? 0.5);\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'star', points: pts, innerRadiusRatio: ir, rotation };\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { outerRadius?: unknown }).outerRadius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['outerRadius'] !== undefined) (extras as { outerRadius?: unknown }).outerRadius = params['outerRadius'];\n      }\n      return extras;\n    }\n    case 'pencil':\n      // Prefer tool-supplied samples (param) when present — pencil tools may\n      // capture richer per-sample data (pressure/tilt). Fall back to the\n      // dispatcher's accumulated pointer trail.\n      return {\n        kind: 'pencil',\n        samples: (params?.['samples'] as ReadonlyArray<DragSample> | undefined)\n          ?? points\n          ?? [],\n      };\n    default:\n      // Consumer-defined kind: pass everything through so a custom insert\n      // dep can read its own fields.\n      return { ...(params ?? {}), kind } as InsertExtras;\n  }\n}\n\n/** Add a user-driven rotation offset onto kinds that carry rotation. Rect\n *  / ellipse / line / pencil don't expose a rotation field on their\n *  extras today, so they ignore the offset. */\nexport function applyUserRotation(extras: InsertExtras, userRotation: number): void {\n  if (userRotation === 0) return;\n  if (extras.kind === 'star' || extras.kind === 'polygon') {\n    (extras as { rotation: number }).rotation += userRotation;\n  }\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACc;CACd,IAAMC,IAASC,GAASC,QAAkC;CAC1D,QAAQF,GAAR;EACE,KAAK;EACL,KAAK,WACH,OAAO,EAAE,QAAK;EAChB,KAAK,QAIH,OAAO;GAAE,MAAM;GAAQ,GAAG;IAAE,GAAGG;IAAQ,GAAGC;GAAO;GAAG,GAAG;IAAE,GAAGC;IAAU,GAAGC;GAAS;EAAE;EACtF,KAAK,WAAW;GACd,IAAMC,IAAQ,OAAON,GAASO,SAAY,CAAC,GAIrCC,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAW;IAAO,UAHtCT,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAEmC;GAKhE,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAiC,SAAS,KAAK,MAAMS,GAAIC,CAAE;GAC7D,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASe,WAAc,KAAA,MAAW,EAAiC,SAASf,EAAOe;GAEzF,OAAON;EACT;EACA,KAAK,QAAQ;GACX,IAAMO,IAAM,OAAOhB,GAASiB,UAAa,CAAC,GACpCC,IAAK,OAAOlB,GAASmB,oBAAuB,EAAG,GAC/CX,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAQ,QAAQO;IAAK,kBAAkBE;IAAI,UAH/DlB,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAE4D;GACzF,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAsC,cAAc,KAAK,MAAMS,GAAIC,CAAE;GACvE,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASoB,gBAAmB,KAAA,MAAW,EAAsC,cAAcpB,EAAOoB;GAExG,OAAOX;EACT;EACA,KAAK,UAIH,OAAO;GACL,MAAM;GACN,SAAUT,GAASqB,WACdC,KACA,CAAC;EACR;EACF,SAGE,OAAO;GAAE,GAAItB,KAAU,CAAC;GAAI;EAAK;CACrC;AACF;AAKA,SAAgBuB,EAAkB,GAAsB,GAA4B;CAClF,AAAIC,MAAiB,MACjBf,EAAO,SAAS,UAAUA,EAAO,SAAS,eAC5C,EAAiC,YAAYe;AAEjD"}
+{"version":3,"file":"extras.js","names":[],"sources":["../../../../src/interactions/actions/insert/extras.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertExtras } from '../depSchema';\n\n/** Build a typed `InsertExtras` from the static params + gesture context.\n *  Kit-built-in kinds (line / polygon / star / pencil) read kind-specific\n *  fields; unknown kinds pass the raw params through as `{ kind, ... }`. */\nexport function buildExtras(\n  params: Record<string, unknown> | undefined,\n  startX: number,\n  startY: number,\n  currentX: number,\n  currentY: number,\n  points: ReadonlyArray<DragSample> | null,\n): InsertExtras {\n  const kind = ((params?.['kind'] as string | undefined) ?? 'rect');\n  switch (kind) {\n    case 'rect':\n    case 'ellipse':\n      return { kind } as InsertExtras;\n    case 'line':\n      // Use the live drag endpoints (not AABB) so the line preserves the\n      // user's drag direction — drag from bottom-left to top-right makes a\n      // line that slopes up, not the bounds diagonal.\n      return { kind: 'line', a: { x: startX, y: startY }, b: { x: currentX, y: currentY } };\n    case 'polygon': {\n      const sides = Number(params?.['sides'] ?? 6);\n      // When the tool omits rotation, point the first vertex along the\n      // drag vector so dragging in a direction orients the shape that\n      // way. Sub-pixel drags (no direction yet) fall back to 0.\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'polygon', sides, rotation };\n      // Drag-from-center: tool's Alt binding passes `originMode:'center'`.\n      // Compute polygon center + radius from the drag vector so the shape\n      // anchors on the click point. Without this, the dep falls back to\n      // inscribing in the AABB (drag-from-corner default).\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { radius?: unknown }).radius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['radius'] !== undefined) (extras as { radius?: unknown }).radius = params['radius'];\n      }\n      return extras;\n    }\n    case 'star': {\n      const pts = Number(params?.['points'] ?? 5);\n      const ir = Number(params?.['innerRadiusRatio'] ?? 0.5);\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'star', points: pts, innerRadiusRatio: ir, rotation };\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { outerRadius?: unknown }).outerRadius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['outerRadius'] !== undefined) (extras as { outerRadius?: unknown }).outerRadius = params['outerRadius'];\n      }\n      return extras;\n    }\n    case 'pencil':\n      // Prefer tool-supplied samples (param) when present — pencil tools may\n      // capture richer per-sample data (pressure/tilt). Fall back to the\n      // dispatcher's accumulated pointer trail.\n      return {\n        kind: 'pencil',\n        samples: (params?.['samples'] as ReadonlyArray<DragSample> | undefined)\n          ?? points\n          ?? [],\n      };\n    default:\n      // Consumer-defined kind: pass everything through so a custom insert\n      // dep can read its own fields.\n      return { ...(params ?? {}), kind } as InsertExtras;\n  }\n}\n\n/** Add a user-driven rotation offset onto kinds that carry rotation. Rect\n *  / ellipse / line / pencil don't expose a rotation field on their\n *  extras today, so they ignore the offset. */\nexport function applyUserRotation(extras: InsertExtras, userRotation: number): void {\n  if (userRotation === 0) return;\n  if (extras.kind === 'star' || extras.kind === 'polygon') {\n    (extras as { rotation: number }).rotation += userRotation;\n  }\n}\n"],"mappings":";;;;AAMA,SAAgB,YACd,QACA,QACA,QACA,UACA,UACA,QACc;CACd,MAAM,OAAS,SAAS,WAAkC;CAC1D,QAAQ,MAAR;EACE,KAAK;EACL,KAAK,WACH,OAAO,EAAE,KAAK;EAChB,KAAK,QAIH,OAAO;GAAE,MAAM;GAAQ,GAAG;IAAE,GAAG;IAAQ,GAAG;GAAO;GAAG,GAAG;IAAE,GAAG;IAAU,GAAG;GAAS;EAAE;EACtF,KAAK,WAAW;GACd,MAAM,QAAQ,OAAO,SAAS,YAAY,CAAC;GAI3C,MAAM,YAAa,aAAa,UAAU,aAAa,SACnD,IACA,KAAK,MAAM,WAAW,QAAQ,WAAW,MAAM;GAInD,MAAM,SAAuB;IAAE,MAAM;IAAW;IAAO,UAHtC,SAAS,gBAAgB,SACtC,OAAO,OAAO,WAAW,IACzB;GAC4D;GAKhE,IAAI,SAAS,kBAAkB,UAAU;IACvC,MAAM,KAAK,WAAW;IACtB,MAAM,KAAK,WAAW;IACtB,OAAiC,SAAS;KAAE,GAAG;KAAQ,GAAG;IAAO;IACjE,OAAiC,SAAS,KAAK,MAAM,IAAI,EAAE;GAC7D,OAAO;IACL,IAAI,SAAS,cAAc,QAAW,OAAiC,SAAS,OAAO;IACvF,IAAI,SAAS,cAAc,QAAW,OAAiC,SAAS,OAAO;GACzF;GACA,OAAO;EACT;EACA,KAAK,QAAQ;GACX,MAAM,MAAM,OAAO,SAAS,aAAa,CAAC;GAC1C,MAAM,KAAK,OAAO,SAAS,uBAAuB,EAAG;GACrD,MAAM,YAAa,aAAa,UAAU,aAAa,SACnD,IACA,KAAK,MAAM,WAAW,QAAQ,WAAW,MAAM;GAInD,MAAM,SAAuB;IAAE,MAAM;IAAQ,QAAQ;IAAK,kBAAkB;IAAI,UAH/D,SAAS,gBAAgB,SACtC,OAAO,OAAO,WAAW,IACzB;GACqF;GACzF,IAAI,SAAS,kBAAkB,UAAU;IACvC,MAAM,KAAK,WAAW;IACtB,MAAM,KAAK,WAAW;IACtB,OAAiC,SAAS;KAAE,GAAG;KAAQ,GAAG;IAAO;IACjE,OAAsC,cAAc,KAAK,MAAM,IAAI,EAAE;GACvE,OAAO;IACL,IAAI,SAAS,cAAc,QAAW,OAAiC,SAAS,OAAO;IACvF,IAAI,SAAS,mBAAmB,QAAW,OAAsC,cAAc,OAAO;GACxG;GACA,OAAO;EACT;EACA,KAAK,UAIH,OAAO;GACL,MAAM;GACN,SAAU,SAAS,cACd,UACA,CAAC;EACR;EACF,SAGE,OAAO;GAAE,GAAI,UAAU,CAAC;GAAI;EAAK;CACrC;AACF;;;;AAKA,SAAgB,kBAAkB,QAAsB,cAA4B;CAClF,IAAI,iBAAiB,GAAG;CACxB,IAAI,OAAO,SAAS,UAAU,OAAO,SAAS,WAC5C,OAAiC,YAAY;AAEjD"}

package/dist/interactions/actions/insert/frame.js

@@ -1,55 +1,74 @@
-import { pointerStateOf as e } from "../pointerState.js";
-import { computeBounds as t, effectiveOriginMode as n, snapTo15Degrees as r } from "./geometry.js";
-import { GESTURE_KEY as i } from "./session.js";
-import { resolveParams as a } from "@weasel-js/routing";
+import { pointerStateOf } from "../pointerState.js";
+import { snapMods } from "../../../features/snap/roles.js";
+import { computeBounds, effectiveOriginMode } from "./geometry.js";
+import { GESTURE_KEY } from "./session.js";
+import { resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/insert/frame.ts
-function o(o, s, c, l) {
-	let u = a(o.opts?.params), d = u?.kind ?? "rect", f = o.gestureCtx, p = f.origin.get(i), m = {
-		x: c.pointer.x,
-		y: c.pointer.y
-	};
-	if (d === "line" && c.shiftHeld && (m = r(p, m)), m = o.snap(m), o.behaviors.length > 0) {
-		f.modifiers = { ...l.modifiers }, f.pointer = e(c.pointer, l), f.view = s.view(), f.plane = s.plane(), f.current.set(i, m);
-		let r = n(u?.originMode, c.altHeld);
-		for (let e of o.behaviors) {
-			let n = t(p.x, p.y, m.x, m.y, r), i = e.onMove?.(f, {
-				start: p,
-				current: m,
-				bounds: n,
-				pose: n
+/**
+* Shape the raw pointer into the drag's endpoints: the snap session (with
+* the line kind's Shift step as its input subspace, about the snapped
+* start), then each behavior's `onMove`, each seeing the points the one
+* before it returned. A point a snap target holds is not moved by a
+* behavior.
+*/
+function shapeEndpoints(session, readers, raw, moveCtx) {
+	const gctx = session.gestureCtx;
+	let start = gctx.origin.get(GESTURE_KEY);
+	const end = session.snap.end(raw.pointer, snapMods(moveCtx));
+	let current = end.point;
+	if (session.behaviors.length > 0) {
+		const resolved = resolveParams(session.opts?.params);
+		const startHeld = session.snap.startHeld();
+		gctx.modifiers = { ...moveCtx.modifiers };
+		gctx.pointer = pointerStateOf(raw.pointer, moveCtx);
+		gctx.view = readers.view();
+		gctx.plane = readers.plane();
+		gctx.current.set(GESTURE_KEY, current);
+		const mode = effectiveOriginMode(resolved?.["originMode"], raw.altHeld);
+		for (const b of session.behaviors) {
+			const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);
+			const r = b.onMove?.(gctx, {
+				start,
+				current,
+				bounds,
+				pose: bounds
 			});
-			i && (i.start && (p = i.start), i.current && (m = i.current));
+			if (!r) continue;
+			if (r.start && !startHeld) start = r.start;
+			if (r.current && !end.held) current = r.current;
 		}
-		f.current.set(i, m);
+		gctx.current.set(GESTURE_KEY, current);
 	}
 	return {
-		start: p,
-		current: m
+		start,
+		current
 	};
 }
-function s(e, t, n) {
-	let r = e.snap(t), a = e.snap(n), o = e.gestureCtx.origin, s = o.get(i);
-	o.set(i, {
-		x: s.x + a.x - r.x,
-		y: s.y + a.y - r.y
-	});
+/** Move the drag's start point by the pointer's step from `from` to `to`, so
+*  the shape travels with the pointer instead of resizing. The start is
+*  carried unsnapped and snapped where it lands. */
+function carryStart(session, from, to, moveCtx) {
+	const landed = session.snap.carry(to.x - from.x, to.y - from.y, snapMods(moveCtx));
+	session.gestureCtx.origin.set(GESTURE_KEY, landed.point);
 }
-function c(e, t, n, r) {
-	let i = {
+/** One pump event's pointer, modifiers, and trail, and the endpoints they
+*  shape to. Each behavior's `onMove` runs once per call. */
+function nextFrame(session, readers, prev, moveCtx) {
+	const raw = {
 		pointer: {
-			x: r.world.x,
-			y: r.world.y
+			x: moveCtx.world.x,
+			y: moveCtx.world.y
 		},
-		altHeld: r.modifiers.alt,
-		shiftHeld: r.modifiers.shift
+		altHeld: moveCtx.modifiers.alt
 	};
 	return {
-		...i,
-		points: r.drag?.points ? r.drag.points : n.points,
-		shaped: o(e, t, i, r)
+		...raw,
+		points: moveCtx.drag?.points ? moveCtx.drag.points : prev.points,
+		shaped: shapeEndpoints(session, readers, raw, moveCtx)
 	};
 }
-//#endregion
-export { s as carryStart, c as nextFrame };
 
+//#endregion
+export { carryStart, nextFrame };
 //# sourceMappingURL=frame.js.map

package/dist/interactions/actions/insert/frame.js.map

@@ -1 +1 @@
-{"version":3,"file":"frame.js","names":["shapeEndpoints","resolved","resolveParams","session","kind","\"kind\"","gctx","start","GESTURE_KEY","current","raw","snapTo15Degrees","moveCtx","pointerStateOf","readers","mode","effectiveOriginMode","\"originMode\"","b","bounds","computeBounds","r","carryStart","a","from","to","origin","nextFrame","prev"],"sources":["../../../../src/interactions/actions/insert/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { InsertPoint } from '../../gestures/types';\nimport { computeBounds, effectiveOriginMode, snapTo15Degrees } from './geometry';\nimport { GESTURE_KEY, type InsertFrame, type InsertSession } from './session';\n\n/**\n * Shape the raw pointer into the drag's endpoints, in order: the line tool's\n * Shift-constrain (on the raw pointer, around the shaped start, so the locked\n * angle survives), the `snap` dep, then each behavior's `onMove`, each seeing\n * the points the one before it returned.\n */\nfunction shapeEndpoints(\n  session: Pick<InsertSession, 'opts' | 'snap' | 'behaviors' | 'gestureCtx'>,\n  readers: GestureReaders,\n  raw: Pick<InsertFrame, 'pointer' | 'altHeld' | 'shiftHeld'>,\n  moveCtx: Pick<InvocationCtx, 'modifiers' | 'screen'>,\n): { start: InsertPoint; current: InsertPoint } {\n  const resolved = resolveParams(session.opts?.params);\n  const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n  const gctx = session.gestureCtx;\n  let start = gctx.origin.get(GESTURE_KEY) as InsertPoint;\n  let current = { x: raw.pointer.x, y: raw.pointer.y };\n  if (kind === 'line' && raw.shiftHeld) {\n    current = snapTo15Degrees(start, current);\n  }\n  current = session.snap(current);\n\n  if (session.behaviors.length > 0) {\n    gctx.modifiers = { ...moveCtx.modifiers };\n    gctx.pointer = pointerStateOf(raw.pointer, moveCtx);\n    gctx.view = readers.view();\n    gctx.plane = readers.plane();\n    gctx.current.set(GESTURE_KEY, current);\n    const mode = effectiveOriginMode(resolved?.['originMode'], raw.altHeld);\n    for (const b of session.behaviors) {\n      const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n      const r = b.onMove?.(gctx, { start, current, bounds, pose: bounds });\n      if (!r) continue;\n      if (r.start) start = r.start;\n      if (r.current) current = r.current;\n    }\n    gctx.current.set(GESTURE_KEY, current);\n  }\n  return { start, current };\n}\n\n/** Move the drag's start point by the pointer's step from `from` to `to`, so\n *  the shape travels with the pointer instead of resizing. The step is taken\n *  between snapped points, keeping a grid-snapped start on the grid. */\nexport function carryStart(\n  session: Pick<InsertSession, 'snap' | 'gestureCtx'>,\n  from: InsertPoint,\n  to: InsertPoint,\n): void {\n  const a = session.snap(from);\n  const b = session.snap(to);\n  const origin = session.gestureCtx.origin;\n  const start = origin.get(GESTURE_KEY) as InsertPoint;\n  origin.set(GESTURE_KEY, { x: start.x + b.x - a.x, y: start.y + b.y - a.y });\n}\n\n/** One pump event's pointer, modifiers, and trail, and the endpoints they\n *  shape to. Each behavior's `onMove` runs once per call. */\nexport function nextFrame(\n  session: InsertSession,\n  readers: GestureReaders,\n  prev: Pick<InsertFrame, 'points'>,\n  moveCtx: InvocationCtx,\n): InsertFrame {\n  const raw = {\n    pointer: { x: moveCtx.world.x, y: moveCtx.world.y },\n    // Each pointermove carries fresh modifier state from the dispatcher;\n    // releasing / pressing a key mid-drag takes effect on the next move tick\n    // (true modifier-only events don't fire without a cursor change).\n    altHeld: moveCtx.modifiers.alt,\n    shiftHeld: moveCtx.modifiers.shift,\n  };\n  return {\n    ...raw,\n    // The dispatcher mutates its own per-gesture trail in place but\n    // attaches the array reference to each InvocationCtx.drag — keep\n    // the latest reference in case the dispatcher swaps it.\n    points: moveCtx.drag?.points ? moveCtx.drag.points : prev.points,\n    shaped: shapeEndpoints(session, readers, raw, moveCtx),\n  };\n}\n"],"mappings":";;;;;AAcA,SAASA,EACP,GACA,GACA,GACA,GAC8C;CAC9C,IAAMC,IAAWC,EAAcC,EAAQ,MAAM,MAAM,GAC7CC,IAAQH,GAAWI,QAAkC,QACrDC,IAAOH,EAAQ,YACjBI,IAAQD,EAAK,OAAO,IAAIE,CAAW,GACnCC,IAAU;EAAE,GAAGC,EAAI,QAAQ;EAAG,GAAGA,EAAI,QAAQ;CAAE;CAMnD,IALIN,MAAS,UAAUM,EAAI,cACzB,IAAUC,EAAgBJ,GAAOE,CAAO,IAE1C,IAAUN,EAAQ,KAAKM,CAAO,GAE1BN,EAAQ,UAAU,SAAS,GAAG;EAKhC,AAJA,EAAK,YAAY,EAAE,GAAGS,EAAQ,UAAU,GACxC,EAAK,UAAUC,EAAeH,EAAI,SAASE,CAAO,GAClD,EAAK,OAAOE,EAAQ,KAAK,GACzB,EAAK,QAAQA,EAAQ,MAAM,GAC3BR,EAAK,QAAQ,IAAIE,GAAaC,CAAO;EACrC,IAAMM,IAAOC,EAAoBf,GAAWgB,YAAeP,EAAI,OAAO;EACtE,KAAK,IAAMQ,KAAKf,EAAQ,WAAW;GACjC,IAAMgB,IAASC,EAAcb,EAAM,GAAGA,EAAM,GAAGE,EAAQ,GAAGA,EAAQ,GAAGM,CAAI,GACnEM,IAAIH,EAAE,SAASZ,GAAM;IAAE;IAAO;IAAS;IAAQ,MAAMa;GAAO,CAAC;GACnE,AAAKE,MACDA,EAAE,UAAO,IAAQA,EAAE,QACnBA,EAAE,YAAS,IAAUA,EAAE;EAC7B;EACA,EAAK,QAAQ,IAAIb,GAAaC,CAAO;CACvC;CACA,OAAO;EAAE;EAAO;CAAQ;AAC1B;AAKA,SAAgBa,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAIpB,EAAQ,KAAKqB,CAAI,GACrBN,IAAIf,EAAQ,KAAKsB,CAAE,GACnBC,IAASvB,EAAQ,WAAW,QAC5BI,IAAQmB,EAAO,IAAIlB,CAAW;CACpC,EAAO,IAAIA,GAAa;EAAE,GAAGD,EAAM,IAAIW,EAAE,IAAIK,EAAE;EAAG,GAAGhB,EAAM,IAAIW,EAAE,IAAIK,EAAE;CAAE,CAAC;AAC5E;AAIA,SAAgBI,EACd,GACA,GACA,GACA,GACa;CACb,IAAMjB,IAAM;EACV,SAAS;GAAE,GAAGE,EAAQ,MAAM;GAAG,GAAGA,EAAQ,MAAM;EAAE;EAIlD,SAASA,EAAQ,UAAU;EAC3B,WAAWA,EAAQ,UAAU;CAC/B;CACA,OAAO;EACL,GAAGF;EAIH,QAAQE,EAAQ,MAAM,SAASA,EAAQ,KAAK,SAASgB,EAAK;EAC1D,QAAQ5B,EAAeG,GAASW,GAASJ,GAAKE,CAAO;CACvD;AACF"}
+{"version":3,"file":"frame.js","names":[],"sources":["../../../../src/interactions/actions/insert/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { resolveParams } from '@weasel-js/routing';\nimport { snapMods } from 'features/snap/roles';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { InsertPoint } from '../../gestures/types';\nimport { computeBounds, effectiveOriginMode } from './geometry';\nimport { GESTURE_KEY, type InsertFrame, type InsertSession } from './session';\n\n/**\n * Shape the raw pointer into the drag's endpoints: the snap session (with\n * the line kind's Shift step as its input subspace, about the snapped\n * start), then each behavior's `onMove`, each seeing the points the one\n * before it returned. A point a snap target holds is not moved by a\n * behavior.\n */\nfunction shapeEndpoints(\n  session: Pick<InsertSession, 'opts' | 'snap' | 'behaviors' | 'gestureCtx'>,\n  readers: GestureReaders,\n  raw: Pick<InsertFrame, 'pointer' | 'altHeld'>,\n  moveCtx: Pick<InvocationCtx, 'modifiers' | 'screen' | 'roles'>,\n): { start: InsertPoint; current: InsertPoint } {\n  const gctx = session.gestureCtx;\n  let start = gctx.origin.get(GESTURE_KEY) as InsertPoint;\n  const end = session.snap.end(raw.pointer, snapMods(moveCtx));\n  let current = end.point;\n\n  if (session.behaviors.length > 0) {\n    const resolved = resolveParams(session.opts?.params);\n    const startHeld = session.snap.startHeld();\n    gctx.modifiers = { ...moveCtx.modifiers };\n    gctx.pointer = pointerStateOf(raw.pointer, moveCtx);\n    gctx.view = readers.view();\n    gctx.plane = readers.plane();\n    gctx.current.set(GESTURE_KEY, current);\n    const mode = effectiveOriginMode(resolved?.['originMode'], raw.altHeld);\n    for (const b of session.behaviors) {\n      const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n      const r = b.onMove?.(gctx, { start, current, bounds, pose: bounds });\n      if (!r) continue;\n      if (r.start && !startHeld) start = r.start;\n      if (r.current && !end.held) current = r.current;\n    }\n    gctx.current.set(GESTURE_KEY, current);\n  }\n  return { start, current };\n}\n\n/** Move the drag's start point by the pointer's step from `from` to `to`, so\n *  the shape travels with the pointer instead of resizing. The start is\n *  carried unsnapped and snapped where it lands. */\nexport function carryStart(\n  session: Pick<InsertSession, 'snap' | 'gestureCtx'>,\n  from: InsertPoint,\n  to: InsertPoint,\n  moveCtx: Pick<InvocationCtx, 'modifiers' | 'roles'>,\n): void {\n  const landed = session.snap.carry(to.x - from.x, to.y - from.y, snapMods(moveCtx));\n  session.gestureCtx.origin.set(GESTURE_KEY, landed.point);\n}\n\n/** One pump event's pointer, modifiers, and trail, and the endpoints they\n *  shape to. Each behavior's `onMove` runs once per call. */\nexport function nextFrame(\n  session: InsertSession,\n  readers: GestureReaders,\n  prev: Pick<InsertFrame, 'points'>,\n  moveCtx: InvocationCtx,\n): InsertFrame {\n  const raw = {\n    pointer: { x: moveCtx.world.x, y: moveCtx.world.y },\n    // Each pointermove carries fresh modifier state from the dispatcher;\n    // releasing / pressing a key mid-drag takes effect on the next move tick\n    // (true modifier-only events don't fire without a cursor change).\n    altHeld: moveCtx.modifiers.alt,\n  };\n  return {\n    ...raw,\n    // The dispatcher mutates its own per-gesture trail in place but\n    // attaches the array reference to each InvocationCtx.drag — keep\n    // the latest reference in case the dispatcher swaps it.\n    points: moveCtx.drag?.points ? moveCtx.drag.points : prev.points,\n    shaped: shapeEndpoints(session, readers, raw, moveCtx),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAS,eACP,SACA,SACA,KACA,SAC8C;CAC9C,MAAM,OAAO,QAAQ;CACrB,IAAI,QAAQ,KAAK,OAAO,IAAI,WAAW;CACvC,MAAM,MAAM,QAAQ,KAAK,IAAI,IAAI,SAAS,SAAS,OAAO,CAAC;CAC3D,IAAI,UAAU,IAAI;CAElB,IAAI,QAAQ,UAAU,SAAS,GAAG;EAChC,MAAM,WAAW,cAAc,QAAQ,MAAM,MAAM;EACnD,MAAM,YAAY,QAAQ,KAAK,UAAU;EACzC,KAAK,YAAY,EAAE,GAAG,QAAQ,UAAU;EACxC,KAAK,UAAU,eAAe,IAAI,SAAS,OAAO;EAClD,KAAK,OAAO,QAAQ,KAAK;EACzB,KAAK,QAAQ,QAAQ,MAAM;EAC3B,KAAK,QAAQ,IAAI,aAAa,OAAO;EACrC,MAAM,OAAO,oBAAoB,WAAW,eAAe,IAAI,OAAO;EACtE,KAAK,MAAM,KAAK,QAAQ,WAAW;GACjC,MAAM,SAAS,cAAc,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI;GACzE,MAAM,IAAI,EAAE,SAAS,MAAM;IAAE;IAAO;IAAS;IAAQ,MAAM;GAAO,CAAC;GACnE,IAAI,CAAC,GAAG;GACR,IAAI,EAAE,SAAS,CAAC,WAAW,QAAQ,EAAE;GACrC,IAAI,EAAE,WAAW,CAAC,IAAI,MAAM,UAAU,EAAE;EAC1C;EACA,KAAK,QAAQ,IAAI,aAAa,OAAO;CACvC;CACA,OAAO;EAAE;EAAO;CAAQ;AAC1B;;;;AAKA,SAAgB,WACd,SACA,MACA,IACA,SACM;CACN,MAAM,SAAS,QAAQ,KAAK,MAAM,GAAG,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,GAAG,SAAS,OAAO,CAAC;CACjF,QAAQ,WAAW,OAAO,IAAI,aAAa,OAAO,KAAK;AACzD;;;AAIA,SAAgB,UACd,SACA,SACA,MACA,SACa;CACb,MAAM,MAAM;EACV,SAAS;GAAE,GAAG,QAAQ,MAAM;GAAG,GAAG,QAAQ,MAAM;EAAE;EAIlD,SAAS,QAAQ,UAAU;CAC7B;CACA,OAAO;EACL,GAAG;EAIH,QAAQ,QAAQ,MAAM,SAAS,QAAQ,KAAK,SAAS,KAAK;EAC1D,QAAQ,eAAe,SAAS,SAAS,KAAK,OAAO;CACvD;AACF"}

package/dist/interactions/actions/insert/geometry.js

@@ -1,35 +1,39 @@
 //#region src/interactions/actions/insert/geometry.ts
-function e(e, t) {
-	let n = e === "center" ? "center" : "corner";
-	return t ? n === "center" ? "corner" : "center" : n;
+/** Resolve the effective origin mode from the binding's nominal opt
+*  and live Alt state. Alt inverts: `corner` ⇄ `center`. Applies to
+*  every shape kind — radial shapes (polygon/star) included; the
+*  overlay paints an `anchorPoint` dot at the click so corner mode
+*  reads as anchored even though no polygon vertex sits there.
+*/
+function effectiveOriginMode(paramsOrigin, altHeld) {
+	const nominal = paramsOrigin === "center" ? "center" : "corner";
+	if (!altHeld) return nominal;
+	return nominal === "center" ? "corner" : "center";
 }
-function t(e, t, n, r, i) {
-	if (i === "center") {
-		let i = Math.abs(n - e), a = Math.abs(r - t);
+/** Compute the insert AABB from drag endpoints.
+*  - `'corner'` (default): bounds = drag rect (top-left → bottom-right of cursor sweep).
+*  - `'center'`: bounds = symmetric AABB anchored on the start point.
+*    Used when the tool's Alt-modifier binding passes
+*    `originMode: 'center'` (Illustrator/Figma convention). */
+function computeBounds(startX, startY, currentX, currentY, originMode) {
+	if (originMode === "center") {
+		const dx = Math.abs(currentX - startX);
+		const dy = Math.abs(currentY - startY);
 		return {
-			x: e - i,
-			y: t - a,
-			width: i * 2,
-			height: a * 2
+			x: startX - dx,
+			y: startY - dy,
+			width: dx * 2,
+			height: dy * 2
 		};
 	}
 	return {
-		x: Math.min(e, n),
-		y: Math.min(t, r),
-		width: Math.abs(n - e),
-		height: Math.abs(r - t)
+		x: Math.min(startX, currentX),
+		y: Math.min(startY, currentY),
+		width: Math.abs(currentX - startX),
+		height: Math.abs(currentY - startY)
 	};
 }
-function n(e, t) {
-	let n = t.x - e.x, r = t.y - e.y, i = Math.hypot(n, r);
-	if (i === 0) return t;
-	let a = Math.PI / 12, o = Math.round(Math.atan2(r, n) / a) * a;
-	return {
-		x: e.x + i * Math.cos(o),
-		y: e.y + i * Math.sin(o)
-	};
-}
-//#endregion
-export { t as computeBounds, e as effectiveOriginMode, n as snapTo15Degrees };
 
+//#endregion
+export { computeBounds, effectiveOriginMode };
 //# sourceMappingURL=geometry.js.map

package/dist/interactions/actions/insert/geometry.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.js","names":["effectiveOriginMode","nominal","paramsOrigin","altHeld","computeBounds","originMode","dx","currentX","startX","dy","currentY","startY","snapTo15Degrees","end","start","len","step","snapped"],"sources":["../../../../src/interactions/actions/insert/geometry.ts"],"sourcesContent":["/** Resolve the effective origin mode from the binding's nominal opt\n *  and live Alt state. Alt inverts: `corner` ⇄ `center`. Applies to\n *  every shape kind — radial shapes (polygon/star) included; the\n *  overlay paints an `anchorPoint` dot at the click so corner mode\n *  reads as anchored even though no polygon vertex sits there.\n */\nexport function effectiveOriginMode(\n  paramsOrigin: unknown,\n  altHeld: boolean,\n): 'corner' | 'center' {\n  const nominal: 'corner' | 'center' = paramsOrigin === 'center' ? 'center' : 'corner';\n  if (!altHeld) return nominal;\n  return nominal === 'center' ? 'corner' : 'center';\n}\n\n/** Compute the insert AABB from drag endpoints.\n *  - `'corner'` (default): bounds = drag rect (top-left → bottom-right of cursor sweep).\n *  - `'center'`: bounds = symmetric AABB anchored on the start point.\n *    Used when the tool's Alt-modifier binding passes\n *    `originMode: 'center'` (Illustrator/Figma convention). */\nexport function computeBounds(\n  startX: number, startY: number,\n  currentX: number, currentY: number,\n  originMode: 'corner' | 'center',\n): { x: number; y: number; width: number; height: number } {\n  if (originMode === 'center') {\n    const dx = Math.abs(currentX - startX);\n    const dy = Math.abs(currentY - startY);\n    return { x: startX - dx, y: startY - dy, width: dx * 2, height: dy * 2 };\n  }\n  return {\n    x: Math.min(startX, currentX),\n    y: Math.min(startY, currentY),\n    width: Math.abs(currentX - startX),\n    height: Math.abs(currentY - startY),\n  };\n}\n\n/** Constrain `end` to the nearest 15° increment around `start`, preserving\n *  the drag length. The line tool's documented Shift behavior. */\nexport function snapTo15Degrees(\n  start: { x: number; y: number },\n  end: { x: number; y: number },\n): { x: number; y: number } {\n  const dx = end.x - start.x;\n  const dy = end.y - start.y;\n  const len = Math.hypot(dx, dy);\n  if (len === 0) return end;\n  const step = Math.PI / 12; // 15°\n  const snapped = Math.round(Math.atan2(dy, dx) / step) * step;\n  return { x: start.x + len * Math.cos(snapped), y: start.y + len * Math.sin(snapped) };\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACqB;CACrB,IAAMC,IAA+BC,MAAiB,WAAW,WAAW;CAE5E,OADKC,IACEF,MAAY,WAAW,WAAW,WADpBA;AAEvB;AAOA,SAAgBG,EACd,GAAgB,GAChB,GAAkB,GAClB,GACyD;CACzD,IAAIC,MAAe,UAAU;EAC3B,IAAMC,IAAK,KAAK,IAAIC,IAAWC,CAAM,GAC/BC,IAAK,KAAK,IAAIC,IAAWC,CAAM;EACrC,OAAO;GAAE,GAAGH,IAASF;GAAI,GAAGK,IAASF;GAAI,OAAOH,IAAK;GAAG,QAAQG,IAAK;EAAE;CACzE;CACA,OAAO;EACL,GAAG,KAAK,IAAID,GAAQD,CAAQ;EAC5B,GAAG,KAAK,IAAII,GAAQD,CAAQ;EAC5B,OAAO,KAAK,IAAIH,IAAWC,CAAM;EACjC,QAAQ,KAAK,IAAIE,IAAWC,CAAM;CACpC;AACF;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,IAAMN,IAAKO,EAAI,IAAIC,EAAM,GACnBL,IAAKI,EAAI,IAAIC,EAAM,GACnBC,IAAM,KAAK,MAAMT,GAAIG,CAAE;CAC7B,IAAIM,MAAQ,GAAG,OAAOF;CACtB,IAAMG,IAAO,KAAK,KAAK,IACjBC,IAAU,KAAK,MAAM,KAAK,MAAMR,GAAIH,CAAE,IAAIU,CAAI,IAAIA;CACxD,OAAO;EAAE,GAAGF,EAAM,IAAIC,IAAM,KAAK,IAAIE,CAAO;EAAG,GAAGH,EAAM,IAAIC,IAAM,KAAK,IAAIE,CAAO;CAAE;AACtF"}
+{"version":3,"file":"geometry.js","names":[],"sources":["../../../../src/interactions/actions/insert/geometry.ts"],"sourcesContent":["/** Resolve the effective origin mode from the binding's nominal opt\n *  and live Alt state. Alt inverts: `corner` ⇄ `center`. Applies to\n *  every shape kind — radial shapes (polygon/star) included; the\n *  overlay paints an `anchorPoint` dot at the click so corner mode\n *  reads as anchored even though no polygon vertex sits there.\n */\nexport function effectiveOriginMode(\n  paramsOrigin: unknown,\n  altHeld: boolean,\n): 'corner' | 'center' {\n  const nominal: 'corner' | 'center' = paramsOrigin === 'center' ? 'center' : 'corner';\n  if (!altHeld) return nominal;\n  return nominal === 'center' ? 'corner' : 'center';\n}\n\n/** Compute the insert AABB from drag endpoints.\n *  - `'corner'` (default): bounds = drag rect (top-left → bottom-right of cursor sweep).\n *  - `'center'`: bounds = symmetric AABB anchored on the start point.\n *    Used when the tool's Alt-modifier binding passes\n *    `originMode: 'center'` (Illustrator/Figma convention). */\nexport function computeBounds(\n  startX: number, startY: number,\n  currentX: number, currentY: number,\n  originMode: 'corner' | 'center',\n): { x: number; y: number; width: number; height: number } {\n  if (originMode === 'center') {\n    const dx = Math.abs(currentX - startX);\n    const dy = Math.abs(currentY - startY);\n    return { x: startX - dx, y: startY - dy, width: dx * 2, height: dy * 2 };\n  }\n  return {\n    x: Math.min(startX, currentX),\n    y: Math.min(startY, currentY),\n    width: Math.abs(currentX - startX),\n    height: Math.abs(currentY - startY),\n  };\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,oBACd,cACA,SACqB;CACrB,MAAM,UAA+B,iBAAiB,WAAW,WAAW;CAC5E,IAAI,CAAC,SAAS,OAAO;CACrB,OAAO,YAAY,WAAW,WAAW;AAC3C;;;;;;AAOA,SAAgB,cACd,QAAgB,QAChB,UAAkB,UAClB,YACyD;CACzD,IAAI,eAAe,UAAU;EAC3B,MAAM,KAAK,KAAK,IAAI,WAAW,MAAM;EACrC,MAAM,KAAK,KAAK,IAAI,WAAW,MAAM;EACrC,OAAO;GAAE,GAAG,SAAS;GAAI,GAAG,SAAS;GAAI,OAAO,KAAK;GAAG,QAAQ,KAAK;EAAE;CACzE;CACA,OAAO;EACL,GAAG,KAAK,IAAI,QAAQ,QAAQ;EAC5B,GAAG,KAAK,IAAI,QAAQ,QAAQ;EAC5B,OAAO,KAAK,IAAI,WAAW,MAAM;EACjC,QAAQ,KAAK,IAAI,WAAW,MAAM;CACpC;AACF"}

package/dist/interactions/actions/insert/placeAction.js

@@ -0,0 +1,108 @@
+import { inPlane, insertLayer } from "../planeInput.js";
+import { SNAP_ROLES, snapMods } from "../../../features/snap/roles.js";
+import { minSizeOf } from "../../../core/scene/minSize.js";
+import { insertKind } from "./shape.js";
+import { enterInsertedText } from "./commit.js";
+
+//#region src/interactions/actions/insert/placeAction.ts
+/** What the dispatcher lays under an immediate action's params for a click. */
+var CLICK_FIELDS = [
+	"worldX",
+	"worldY",
+	"pressX",
+	"pressY",
+	"affordance",
+	"mods"
+];
+var NO_KEYS = {
+	alt: false,
+	ctrl: false,
+	meta: false,
+	shift: false
+};
+/**
+* Click-to-insert: the companion to `insertAction` for a click, which draws
+* no box. It commits a node of `params.kind` at `params.size`, centered on the
+* click, snapped through a `point` session of the `snap` dep unless the
+* click held `snap.suspend` (Ctrl), and commits
+* through the same `insert` dep a drag commits through. The rest of the
+* binding's params are the insert's extras, as a drag's are.
+*
+* A `minSize` in the params floors the size, and goes on to the node.
+*
+* A binding with no `size` places nothing: the kind's extent is the tool's to
+* name, and a click has none of its own.
+*/
+var placeAction = inPlane({
+	id: "place",
+	label: "Place",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	modifierRoles: SNAP_ROLES,
+	requires: [
+		"insert",
+		"selection",
+		"snap",
+		"textEdit"
+	],
+	invoker: {
+		timing: "immediate",
+		run(deps, params) {
+			const dep = deps.insert;
+			const asked = params?.["size"];
+			const min = minSizeOf(params);
+			const size = asked && min ? {
+				width: Math.max(asked.width, min.width),
+				height: Math.max(asked.height, min.height)
+			} : asked;
+			const x = params?.["worldX"];
+			const y = params?.["worldY"];
+			if (!dep || !size || typeof x !== "number" || typeof y !== "number") return;
+			if (!(size.width > 0 && size.height > 0)) return;
+			deps.selection?.clear();
+			const snap = deps.snap?.begin({
+				gesture: "point",
+				press: {
+					x,
+					y
+				}
+			});
+			const mods = snapMods({ modifiers: params?.["mods"] ?? NO_KEYS });
+			const at = snap ? snap.at({
+				x,
+				y
+			}, mods).point : {
+				x,
+				y
+			};
+			snap?.end();
+			const extras = {
+				...params,
+				kind: insertKind(params)
+			};
+			for (const k of [...CLICK_FIELDS, "size"]) delete extras[k];
+			const bounds = {
+				x: at.x - size.width / 2,
+				y: at.y - size.height / 2,
+				width: size.width,
+				height: size.height
+			};
+			const ends = {
+				start: at,
+				end: {
+					x: at.x + size.width / 2,
+					y: at.y + size.height / 2
+				},
+				fromCenter: true
+			};
+			const id = dep.commit(bounds, extras, ends);
+			enterInsertedText(deps.textEdit, id === null ? null : String(id), extras.kind);
+		}
+	},
+	/** Like `insert`, needs no selection. */
+	enabled: () => true
+}, insertLayer);
+
+//#endregion
+export { placeAction };
+//# sourceMappingURL=placeAction.js.map

package/dist/interactions/actions/insert/placeAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeAction.js","names":[],"sources":["../../../../src/interactions/actions/insert/placeAction.ts"],"sourcesContent":["import type { Action, ActionDeps, ModifierState } from '@weasel-js/routing';\nimport { SNAP_ROLES, snapMods } from 'features/snap/roles';\nimport type { InsertExtras } from '../depSchema';\nimport { inPlane, insertLayer } from '../planeInput';\nimport { enterInsertedText } from './commit';\nimport { insertKind } from './shape';\nimport { minSizeOf } from 'core/scene/minSize';\n\n/** What the dispatcher lays under an immediate action's params for a click. */\nconst CLICK_FIELDS = ['worldX', 'worldY', 'pressX', 'pressY', 'affordance', 'mods'] as const;\n\nconst NO_KEYS: ModifierState = { alt: false, ctrl: false, meta: false, shift: false };\n\n/**\n * Click-to-insert: the companion to `insertAction` for a click, which draws\n * no box. It commits a node of `params.kind` at `params.size`, centered on the\n * click, snapped through a `point` session of the `snap` dep unless the\n * click held `snap.suspend` (Ctrl), and commits\n * through the same `insert` dep a drag commits through. The rest of the\n * binding's params are the insert's extras, as a drag's are.\n *\n * A `minSize` in the params floors the size, and goes on to the node.\n *\n * A binding with no `size` places nothing: the kind's extent is the tool's to\n * name, and a click has none of its own.\n */\nexport const placeAction: Action & { requires: string[] } = inPlane({\n  id: 'place',\n  label: 'Place',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  modifierRoles: SNAP_ROLES,\n  requires: ['insert', 'selection', 'snap', 'textEdit'],\n  invoker: {\n    timing: 'immediate',\n    run(deps: ActionDeps, params?: Record<string, unknown>): void {\n      const dep = deps.insert;\n      const asked = params?.['size'] as { width: number; height: number } | undefined;\n      const min = minSizeOf(params);\n      const size = asked && min\n        ? { width: Math.max(asked.width, min.width), height: Math.max(asked.height, min.height) }\n        : asked;\n      const x = params?.['worldX'];\n      const y = params?.['worldY'];\n      if (!dep || !size || typeof x !== 'number' || typeof y !== 'number') return;\n      if (!(size.width > 0 && size.height > 0)) return;\n\n      deps.selection?.clear();\n      const snap = deps.snap?.begin({ gesture: 'point', press: { x, y } });\n      const mods = snapMods({ modifiers: (params?.['mods'] as ModifierState | undefined) ?? NO_KEYS });\n      const at = snap ? snap.at({ x, y }, mods).point : { x, y };\n      snap?.end();\n      const extras: Record<string, unknown> = { ...params, kind: insertKind(params) };\n      for (const k of [...CLICK_FIELDS, 'size']) delete extras[k];\n      const bounds = { x: at.x - size.width / 2, y: at.y - size.height / 2, width: size.width, height: size.height };\n      const ends = { start: at, end: { x: at.x + size.width / 2, y: at.y + size.height / 2 }, fromCenter: true };\n      const id = dep.commit(bounds, extras as InsertExtras, ends);\n      enterInsertedText(deps.textEdit, id === null ? null : String(id), extras.kind as string);\n    },\n  },\n  /** Like `insert`, needs no selection. */\n  enabled: () => true as const,\n}, insertLayer);\n"],"mappings":";;;;;;;;AASA,IAAM,eAAe;CAAC;CAAU;CAAU;CAAU;CAAU;CAAc;AAAM;AAElF,IAAM,UAAyB;CAAE,KAAK;CAAO,MAAM;CAAO,MAAM;CAAO,OAAO;AAAM;;;;;;;;;;;;;;AAepF,IAAa,cAA+C,QAAQ;CAClE,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,eAAe;CACf,UAAU;EAAC;EAAU;EAAa;EAAQ;CAAU;CACpD,SAAS;EACP,QAAQ;EACR,IAAI,MAAkB,QAAwC;GAC5D,MAAM,MAAM,KAAK;GACjB,MAAM,QAAQ,SAAS;GACvB,MAAM,MAAM,UAAU,MAAM;GAC5B,MAAM,OAAO,SAAS,MAClB;IAAE,OAAO,KAAK,IAAI,MAAM,OAAO,IAAI,KAAK;IAAG,QAAQ,KAAK,IAAI,MAAM,QAAQ,IAAI,MAAM;GAAE,IACtF;GACJ,MAAM,IAAI,SAAS;GACnB,MAAM,IAAI,SAAS;GACnB,IAAI,CAAC,OAAO,CAAC,QAAQ,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;GACrE,IAAI,EAAE,KAAK,QAAQ,KAAK,KAAK,SAAS,IAAI;GAE1C,KAAK,WAAW,MAAM;GACtB,MAAM,OAAO,KAAK,MAAM,MAAM;IAAE,SAAS;IAAS,OAAO;KAAE;KAAG;IAAE;GAAE,CAAC;GACnE,MAAM,OAAO,SAAS,EAAE,WAAY,SAAS,WAAyC,QAAQ,CAAC;GAC/F,MAAM,KAAK,OAAO,KAAK,GAAG;IAAE;IAAG;GAAE,GAAG,IAAI,CAAC,CAAC,QAAQ;IAAE;IAAG;GAAE;GACzD,MAAM,IAAI;GACV,MAAM,SAAkC;IAAE,GAAG;IAAQ,MAAM,WAAW,MAAM;GAAE;GAC9E,KAAK,MAAM,KAAK,CAAC,GAAG,cAAc,MAAM,GAAG,OAAO,OAAO;GACzD,MAAM,SAAS;IAAE,GAAG,GAAG,IAAI,KAAK,QAAQ;IAAG,GAAG,GAAG,IAAI,KAAK,SAAS;IAAG,OAAO,KAAK;IAAO,QAAQ,KAAK;GAAO;GAC7G,MAAM,OAAO;IAAE,OAAO;IAAI,KAAK;KAAE,GAAG,GAAG,IAAI,KAAK,QAAQ;KAAG,GAAG,GAAG,IAAI,KAAK,SAAS;IAAE;IAAG,YAAY;GAAK;GACzG,MAAM,KAAK,IAAI,OAAO,QAAQ,QAAwB,IAAI;GAC1D,kBAAkB,KAAK,UAAU,OAAO,OAAO,OAAO,OAAO,EAAE,GAAG,OAAO,IAAc;EACzF;CACF;;CAEA,eAAe;AACjB,GAAG,WAAW"}

package/dist/interactions/actions/insert/repositionAction.js

@@ -1,31 +1,46 @@
-import { heldKeySpec as e } from "@weasel-js/routing";
+import { heldKeySpec } from "@weasel-js/routing";
+
 //#region src/interactions/actions/insert/repositionAction.ts
-var t = {
+/**
+* Companion to `insertAction`: while its key is held, dragging moves the
+* shape being drawn instead of resizing it; letting go resumes resizing from
+* where the shape now sits. No-op when no insert is in flight.
+*/
+var insertRepositionAction = {
 	id: "insert.reposition",
 	label: "Insert — reposition",
 	group: "insert",
 	eligible: { capability: "creates-shapes" },
 	invoker: {
 		timing: "ongoing",
-		start: (e) => {
-			let t = e.deps.insertLive?.gesture;
-			return !t || !t.open ? {} : (t.repositioning = !0, {
+		start: (ctx) => {
+			const gesture = ctx.deps.insertLive?.gesture;
+			if (!gesture || !gesture.open) return {};
+			gesture.repositioning = true;
+			return {
 				kind: "insert.reposition",
 				onEnd: () => {
-					t.repositioning = !1;
+					gesture.repositioning = false;
 				}
-			});
+			};
 		}
 	},
 	requires: ["insertLive"]
-}, n = {
+};
+/**
+* The binding a shape-drawing tool adds so holding Space mid-draw repositions
+* the shape. Gated to the tool's own engaged phase, so Space between drags is
+* left to the offhand hand tool. Shift and Alt may be down with it, so a
+* constrained or from-center draw can be moved without letting go of them.
+*/
+var INSERT_REPOSITION_BINDING = {
 	spec: {
-		...e(" "),
+		...heldKeySpec(" "),
 		phase: "engaged"
 	},
 	actionId: "insert.reposition"
 };
-//#endregion
-export { n as INSERT_REPOSITION_BINDING, t as insertRepositionAction };
 
+//#endregion
+export { INSERT_REPOSITION_BINDING, insertRepositionAction };
 //# sourceMappingURL=repositionAction.js.map

package/dist/interactions/actions/insert/repositionAction.js.map

@@ -1 +1 @@
-{"version":3,"file":"repositionAction.js","names":["insertRepositionAction","gesture","ctx","INSERT_REPOSITION_BINDING","heldKeySpec"],"sources":["../../../../src/interactions/actions/insert/repositionAction.ts"],"sourcesContent":["import { heldKeySpec, type Action, type GestureBinding } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/**\n * @experimental\n * Companion to `insertAction`: while its key is held, dragging moves the\n * shape being drawn instead of resizing it; letting go resumes resizing from\n * where the shape now sits. No-op when no insert is in flight.\n */\nexport const insertRepositionAction: Action = {\n  id: 'insert.reposition',\n  label: 'Insert — reposition',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'ongoing',\n    start: (ctx) => {\n      const gesture = ctx.deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return {};\n      gesture.repositioning = true;\n      return {\n        kind: 'insert.reposition',\n        onEnd: () => { gesture.repositioning = false; },\n      };\n    },\n  },\n  requires: ['insertLive'],\n};\n\n/**\n * The binding a shape-drawing tool adds so holding Space mid-draw repositions\n * the shape. Gated to the tool's own engaged phase, so Space between drags is\n * left to the offhand hand tool. Shift and Alt may be down with it, so a\n * constrained or from-center draw can be moved without letting go of them.\n */\nexport const INSERT_REPOSITION_BINDING: GestureBinding = {\n  spec: { ...heldKeySpec(' '), phase: 'engaged' },\n  actionId: 'insert.reposition',\n};\n"],"mappings":";;AASA,IAAaA,IAAiC;CAC5C,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,QAAQ,MAAQ;GACd,IAAMC,IAAUC,EAAI,KAAK,YAAY;GAGrC,OAFI,CAACD,KAAW,CAACA,EAAQ,OAAa,CAAC,KACvC,EAAQ,gBAAgB,IACjB;IACL,MAAM;IACN,aAAa;KAAE,EAAQ,gBAAgB;IAAO;GAChD;EACF;CACF;CACA,UAAU,CAAC,YAAY;AACzB,GAQaE,IAA4C;CACvD,MAAM;EAAE,GAAGC,EAAY,GAAG;EAAG,OAAO;CAAU;CAC9C,UAAU;AACZ"}
+{"version":3,"file":"repositionAction.js","names":[],"sources":["../../../../src/interactions/actions/insert/repositionAction.ts"],"sourcesContent":["import { heldKeySpec, type Action, type GestureBinding } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/**\n * Companion to `insertAction`: while its key is held, dragging moves the\n * shape being drawn instead of resizing it; letting go resumes resizing from\n * where the shape now sits. No-op when no insert is in flight.\n */\nexport const insertRepositionAction: Action = {\n  id: 'insert.reposition',\n  label: 'Insert — reposition',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'ongoing',\n    start: (ctx) => {\n      const gesture = ctx.deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return {};\n      gesture.repositioning = true;\n      return {\n        kind: 'insert.reposition',\n        onEnd: () => { gesture.repositioning = false; },\n      };\n    },\n  },\n  requires: ['insertLive'],\n};\n\n/**\n * The binding a shape-drawing tool adds so holding Space mid-draw repositions\n * the shape. Gated to the tool's own engaged phase, so Space between drags is\n * left to the offhand hand tool. Shift and Alt may be down with it, so a\n * constrained or from-center draw can be moved without letting go of them.\n */\nexport const INSERT_REPOSITION_BINDING: GestureBinding = {\n  spec: { ...heldKeySpec(' '), phase: 'engaged' },\n  actionId: 'insert.reposition',\n};\n"],"mappings":";;;;;;;;AAQA,IAAa,yBAAiC;CAC5C,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,QAAQ,QAAQ;GACd,MAAM,UAAU,IAAI,KAAK,YAAY;GACrC,IAAI,CAAC,WAAW,CAAC,QAAQ,MAAM,OAAO,CAAC;GACvC,QAAQ,gBAAgB;GACxB,OAAO;IACL,MAAM;IACN,aAAa;KAAE,QAAQ,gBAAgB;IAAO;GAChD;EACF;CACF;CACA,UAAU,CAAC,YAAY;AACzB;;;;;;;AAQA,IAAa,4BAA4C;CACvD,MAAM;EAAE,GAAG,YAAY,GAAG;EAAG,OAAO;CAAU;CAC9C,UAAU;AACZ"}