@weasel-js/core 1.10.0 → 1.11.0

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

@@ -0,0 +1,46 @@
+import { heldKeySpec } from "@weasel-js/routing";
+
+//#region src/interactions/actions/insert/repositionAction.ts
+/**
+* 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: (ctx) => {
+			const gesture = ctx.deps.insertLive?.gesture;
+			if (!gesture || !gesture.open) return {};
+			gesture.repositioning = true;
+			return {
+				kind: "insert.reposition",
+				onEnd: () => {
+					gesture.repositioning = false;
+				}
+			};
+		}
+	},
+	requires: ["insertLive"]
+};
+/**
+* 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: {
+		...heldKeySpec(" "),
+		phase: "engaged"
+	},
+	actionId: "insert.reposition"
+};
+
+//#endregion
+export { INSERT_REPOSITION_BINDING, insertRepositionAction };
+//# sourceMappingURL=repositionAction.js.map

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

@@ -0,0 +1 @@
+{"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"}

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

@@ -1,21 +1,32 @@
 //#region src/interactions/actions/insert/rotateAction.ts
-var e = Math.PI / 720, t = {
+/** Radians per unit of wheel deltaY. Tuned so a typical mouse-wheel click
+*  (deltaY ≈ 100) yields ~25°, while a trackpad event (deltaY ≈ 1–10)
+*  yields a smooth 0.25–2.5° increment. */
+var ROTATION_SENSITIVITY = Math.PI / 720;
+/**
+* Companion to `insertAction` — adjusts the live insert gesture's
+* `userRotation` based on wheel deltaY. Intended to be bound to
+* Shift+wheel during the insert tool's engaged phase. No-op when no
+* insert is in flight.
+*/
+var insertRotateAction = {
 	id: "insert.adjustRotation",
 	label: "Insert — rotate",
 	group: "insert",
 	eligible: { capability: "creates-shapes" },
 	invoker: {
 		timing: "immediate",
-		run: (t, n) => {
-			let r = t.insertLive?.gesture;
-			if (!r || !r.open) return;
-			let i = n?.deltaY ?? 0;
-			i !== 0 && (r.userRotation += i * e);
+		run: (deps, params) => {
+			const gesture = deps.insertLive?.gesture;
+			if (!gesture || !gesture.open) return;
+			const deltaY = params?.deltaY ?? 0;
+			if (deltaY === 0) return;
+			gesture.userRotation += deltaY * ROTATION_SENSITIVITY;
 		}
 	},
 	requires: ["insertLive"]
 };
-//#endregion
-export { t as insertRotateAction };
 
+//#endregion
+export { insertRotateAction };
 //# sourceMappingURL=rotateAction.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"rotateAction.js","names":["ROTATION_SENSITIVITY","insertRotateAction","gesture","deps","deltaY","params"],"sources":["../../../../src/interactions/actions/insert/rotateAction.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/** Radians per unit of wheel deltaY. Tuned so a typical mouse-wheel click\n *  (deltaY ≈ 100) yields ~25°, while a trackpad event (deltaY ≈ 1–10)\n *  yields a smooth 0.25–2.5° increment. */\nconst ROTATION_SENSITIVITY = Math.PI / 720;\n\n/**\n * @experimental\n * Companion to `insertAction` — adjusts the live insert gesture's\n * `userRotation` based on wheel deltaY. Intended to be bound to\n * Shift+wheel during the insert tool's engaged phase. No-op when no\n * insert is in flight.\n */\nexport const insertRotateAction: Action = {\n  id: 'insert.adjustRotation',\n  label: 'Insert — rotate',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'immediate' as const,\n    run: (deps, params) => {\n      const gesture = deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return;\n      const deltaY = (params as { deltaY?: number } | undefined)?.deltaY ?? 0;\n      if (deltaY === 0) return;\n      gesture.userRotation += deltaY * ROTATION_SENSITIVITY;\n    },\n  },\n  requires: ['insertLive'],\n};\n"],"mappings":";AAMA,IAAMA,IAAuB,KAAK,KAAK,KAS1BC,IAA6B;CACxC,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,MAAM,GAAM,MAAW;GACrB,IAAMC,IAAUC,EAAK,YAAY;GACjC,IAAI,CAACD,KAAW,CAACA,EAAQ,MAAM;GAC/B,IAAME,IAAUC,GAA4C,UAAU;GACtE,AAAID,MAAW,MACf,EAAQ,gBAAgBA,IAASJ;EACnC;CACF;CACA,UAAU,CAAC,YAAY;AACzB"}
+{"version":3,"file":"rotateAction.js","names":[],"sources":["../../../../src/interactions/actions/insert/rotateAction.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/** Radians per unit of wheel deltaY. Tuned so a typical mouse-wheel click\n *  (deltaY ≈ 100) yields ~25°, while a trackpad event (deltaY ≈ 1–10)\n *  yields a smooth 0.25–2.5° increment. */\nconst ROTATION_SENSITIVITY = Math.PI / 720;\n\n/**\n * Companion to `insertAction` — adjusts the live insert gesture's\n * `userRotation` based on wheel deltaY. Intended to be bound to\n * Shift+wheel during the insert tool's engaged phase. No-op when no\n * insert is in flight.\n */\nexport const insertRotateAction: Action = {\n  id: 'insert.adjustRotation',\n  label: 'Insert — rotate',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'immediate' as const,\n    run: (deps, params) => {\n      const gesture = deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return;\n      const deltaY = (params as { deltaY?: number } | undefined)?.deltaY ?? 0;\n      if (deltaY === 0) return;\n      gesture.userRotation += deltaY * ROTATION_SENSITIVITY;\n    },\n  },\n  requires: ['insertLive'],\n};\n"],"mappings":";;;;AAMA,IAAM,uBAAuB,KAAK,KAAK;;;;;;;AAQvC,IAAa,qBAA6B;CACxC,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,MAAM,MAAM,WAAW;GACrB,MAAM,UAAU,KAAK,YAAY;GACjC,IAAI,CAAC,WAAW,CAAC,QAAQ,MAAM;GAC/B,MAAM,SAAU,QAA4C,UAAU;GACtE,IAAI,WAAW,GAAG;GAClB,QAAQ,gBAAgB,SAAS;EACnC;CACF;CACA,UAAU,CAAC,YAAY;AACzB"}

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

@@ -1,59 +1,75 @@
-import { gestureReaders as e } from "../../gestures/shared/screenTolerance.js";
-import { pointerStateOf as t } from "../pointerState.js";
+import { gestureReaders } from "../../gestures/shared/screenTolerance.js";
+import { pointerStateOf } from "../pointerState.js";
+import { SNAP_ANGLE_STEP, snapMods } from "../../../features/snap/roles.js";
+import { insertKind } from "./shape.js";
+import { spanSnap } from "../../../features/snap/spanSnap.js";
+import { resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/insert/session.ts
-var n = "gesture";
-function r(r, i) {
-	let a = r.deps.insert;
-	if (!a) return null;
-	let o = r.deps.selection, s = o ? [...o.get()] : [];
-	o && s.length > 0 && o.clear();
-	let c = r.deps.snap, l = c ? (e) => c.point(e) : (e) => e, u = i?.behaviors ?? [], d = e(r.deps), f = l({
-		x: r.world.x,
-		y: r.world.y
-	}), p = {
-		draggedIds: [n],
-		origin: /* @__PURE__ */ new Map([[n, f]]),
-		current: /* @__PURE__ */ new Map([[n, f]]),
+/** The key an insert's single gesture point rides under in the behaviors'
+*  `draggedIds` / `origin` / `current` — insert has no node id yet. */
+var GESTURE_KEY = "gesture";
+/** Capture an insert at press. Null with no `insert` dep. Clears the
+*  selection and runs each behavior's `onStart`. */
+function beginInsert(ctx, opts) {
+	const dep = ctx.deps.insert;
+	if (!dep) return null;
+	const selection = ctx.deps.selection;
+	const priorSelection = selection ? [...selection.get()] : [];
+	if (selection && priorSelection.length > 0) selection.clear();
+	const snap = spanSnap(ctx.deps.snap, () => insertKind(resolveParams(opts?.params)) === "line" ? { step: SNAP_ANGLE_STEP } : void 0);
+	const behaviors = opts?.behaviors ?? [];
+	const readers = gestureReaders(ctx.deps);
+	const origin = snap.start({
+		x: ctx.world.x,
+		y: ctx.world.y
+	}, snapMods(ctx)).point;
+	const gestureCtx = {
+		draggedIds: [GESTURE_KEY],
+		origin: /* @__PURE__ */ new Map([[GESTURE_KEY, origin]]),
+		current: /* @__PURE__ */ new Map([[GESTURE_KEY, origin]]),
 		snap: null,
-		modifiers: { ...r.modifiers },
-		pointer: t(r.world, r),
-		view: d.view(),
-		plane: d.plane(),
+		modifiers: { ...ctx.modifiers },
+		pointer: pointerStateOf(ctx.world, ctx),
+		view: readers.view(),
+		plane: readers.plane(),
+		kitSettings: readers.kitSettings,
 		adapter: void 0,
 		scratch: {}
 	};
-	for (let e of u) e.onStart?.(p);
-	let m = p.origin.get(n);
+	for (const b of behaviors) b.onStart?.(gestureCtx);
+	if (snap.startHeld()) gestureCtx.origin.set(GESTURE_KEY, origin);
+	const startPoint = gestureCtx.origin.get(GESTURE_KEY);
+	snap.anchor(startPoint);
 	return {
 		session: {
-			dep: a,
-			textEdit: r.deps.textEdit,
-			snap: l,
-			opts: i,
-			priorSelection: s,
-			behaviors: u,
-			gestureCtx: p,
-			scene: r.deps.scene,
-			applyOps: r.deps.applyOps,
-			selection: o
+			dep,
+			textEdit: ctx.deps.textEdit,
+			snap,
+			opts,
+			priorSelection,
+			behaviors,
+			gestureCtx,
+			scene: ctx.deps.scene,
+			applyOps: ctx.deps.applyOps,
+			selection
 		},
-		readers: d,
+		readers,
 		frame: {
 			pointer: {
-				x: r.world.x,
-				y: r.world.y
+				x: ctx.world.x,
+				y: ctx.world.y
 			},
-			points: r.drag?.points ?? null,
-			altHeld: r.modifiers.alt,
-			shiftHeld: r.modifiers.shift,
+			points: ctx.drag?.points ?? null,
+			altHeld: ctx.modifiers.alt,
 			shaped: {
-				start: m,
-				current: m
+				start: startPoint,
+				current: startPoint
 			}
 		}
 	};
 }
-//#endregion
-export { n as GESTURE_KEY, r as beginInsert };
 
+//#endregion
+export { GESTURE_KEY, beginInsert };
 //# sourceMappingURL=session.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"session.js","names":["GESTURE_KEY","beginInsert","dep","ctx","selection","priorSelection","snapDep","snap","p","behaviors","opts","readers","gestureReaders","origin","gestureCtx","pointerStateOf","b","startPoint"],"sources":["../../../../src/interactions/actions/insert/session.ts"],"sourcesContent":["import type { BindingOpts, DragSample, InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, InsertBehavior, InsertPoint } from '../../gestures/types';\nimport type { InsertDep, TextEditDep } from '../depSchema';\n\n/** The key an insert's single gesture point rides under in the behaviors'\n *  `draggedIds` / `origin` / `current` — insert has no node id yet. */\nexport const GESTURE_KEY = 'gesture';\n\n/** What an insert captured at press. Nothing here changes during the drag.\n *  The deps are captured because the dispatcher builds the deps bag once, on\n *  `start`: every later pump event carries `deps: {}`. */\nexport interface InsertSession {\n  readonly dep: InsertDep;\n  /** For the text kind's drop-into-the-caret step. */\n  readonly textEdit: TextEditDep | undefined;\n  /** World-space point snapper from the `snap` dep, or identity when the\n   *  dep isn't registered. Applied to the drag's start and current point so\n   *  the live preview and the committed geometry agree. Freehand pencil\n   *  samples are deliberately NOT snapped — a grid-quantized freehand trail\n   *  is a staircase, not a stroke. */\n  readonly snap: (p: { x: number; y: number }) => { x: number; y: number };\n  /** The active binding's opts — re-resolved on every read so thunked\n   *  params see the latest tool state (e.g. polygon `sides` after ArrowUp). */\n  readonly opts: BindingOpts | undefined;\n  /** What was selected before the draw cleared it, to put back on cancel. */\n  readonly priorSelection: readonly NodeId[];\n  /** Behaviors from `opts.behaviors`; empty when none were bound. */\n  readonly behaviors: readonly InsertBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors. Its `origin` holds the\n   *  start point under {@link GESTURE_KEY}, after `onStart` shaped it. */\n  readonly gestureCtx: GestureContext<unknown>;\n  /** For committing a behavior's `Op[]`. */\n  readonly scene: Scene<unknown, string, unknown> | undefined;\n  readonly applyOps: ((ops: Op[], label: string) => void) | undefined;\n  readonly selection: SelectionApi | undefined;\n}\n\n/** What the latest pump event left. Replaced, not mutated, by the next. */\nexport interface InsertFrame {\n  /** The raw (unsnapped) pointer in world space. */\n  readonly pointer: InsertPoint;\n  /** Pointer trail accumulated by the dispatcher in world space; pencil-kind\n   *  commits read it. */\n  readonly points: ReadonlyArray<DragSample> | null;\n  /** Alt inverts the binding's nominal `originMode` (corner ⇄ center), so\n   *  pressing or releasing it mid-drag flips the preview and the commit\n   *  without the dispatcher re-routing to another binding. */\n  readonly altHeld: boolean;\n  /** Shift constrains the `line` kind to 15° increments. */\n  readonly shiftHeld: boolean;\n  /** The endpoints after Shift-constrain, the `snap` dep, and the behaviors. */\n  readonly shaped: { start: InsertPoint; current: InsertPoint };\n}\n\n/** Capture an insert at press. Null with no `insert` dep. Clears the\n *  selection and runs each behavior's `onStart`. */\nexport function beginInsert(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n): { session: InsertSession; readers: GestureReaders; frame: InsertFrame } | null {\n  const dep = ctx.deps.insert;\n  if (!dep) return null;\n\n  // Starting a draw retires any prior selection — the lingering halo\n  // around an unrelated node while the user is drawing a new shape is\n  // just visual noise, and it primes the UX bug where a drag that\n  // continues over the selected node would otherwise drive the move\n  // action via fall-through. The clear is unconditional: the user has\n  // committed to \"I'm making a new thing\" by engaging a creation tool.\n  const selection = ctx.deps.selection;\n  const priorSelection = selection ? [...selection.get()] : [];\n  if (selection && priorSelection.length > 0) {\n    selection.clear();\n  }\n\n  const snapDep = ctx.deps.snap;\n  const snap = snapDep\n    ? (p: { x: number; y: number }) => snapDep.point(p)\n    : (p: { x: number; y: number }) => p;\n  const behaviors = (opts?.behaviors ?? []) as InsertBehavior<unknown>[];\n  const readers = gestureReaders(ctx.deps);\n  const origin = snap({ x: ctx.world.x, y: ctx.world.y });\n  const gestureCtx: GestureContext<unknown> = {\n    draggedIds: [GESTURE_KEY],\n    origin: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    current: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(ctx.world, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    // No node exists to adapt until commit; insert behaviors read points.\n    adapter: undefined as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n  const startPoint = gestureCtx.origin.get(GESTURE_KEY) as InsertPoint;\n\n  const session: InsertSession = {\n    dep,\n    textEdit: ctx.deps.textEdit,\n    snap,\n    opts,\n    priorSelection,\n    behaviors,\n    gestureCtx,\n    scene: ctx.deps.scene,\n    applyOps: ctx.deps.applyOps,\n    selection,\n  };\n  const frame: InsertFrame = {\n    pointer: { x: ctx.world.x, y: ctx.world.y },\n    points: ctx.drag?.points ?? null,\n    altHeld: ctx.modifiers.alt,\n    shiftHeld: ctx.modifiers.shift,\n    shaped: { start: startPoint, current: startPoint },\n  };\n  return { session, readers, frame };\n}\n"],"mappings":";;;AAWA,IAAaA,IAAc;AAkD3B,SAAgBC,EACd,GACA,GACgF;CAChF,IAAMC,IAAMC,EAAI,KAAK;CACrB,IAAI,CAACD,GAAK,OAAO;CAQjB,IAAME,IAAYD,EAAI,KAAK,WACrBE,IAAiBD,IAAY,CAAC,GAAGA,EAAU,IAAI,CAAC,IAAI,CAAC;CAC3D,AAAIA,KAAaC,EAAe,SAAS,KACvCD,EAAU,MAAM;CAGlB,IAAME,IAAUH,EAAI,KAAK,MACnBI,IAAOD,KACR,MAAgCA,EAAQ,MAAME,CAAC,KAC/C,MAAgCA,GAC/BC,IAAaC,GAAM,aAAa,CAAC,GACjCC,IAAUC,EAAeT,EAAI,IAAI,GACjCU,IAASN,EAAK;EAAE,GAAGJ,EAAI,MAAM;EAAG,GAAGA,EAAI,MAAM;CAAE,CAAC,GAChDW,IAAsC;EAC1C,YAAY,CAACd,CAAW;EACxB,wBAAQ,IAAI,IAAqB,CAAC,CAACA,GAAaa,CAAM,CAAC,CAAC;EACxD,yBAAS,IAAI,IAAqB,CAAC,CAACb,GAAaa,CAAM,CAAC,CAAC;EACzD,MAAM;EACN,WAAW,EAAE,GAAGV,EAAI,UAAU;EAC9B,SAASY,EAAeZ,EAAI,OAAOA,CAAG;EACtC,MAAMQ,EAAQ,KAAK;EACnB,OAAOA,EAAQ,MAAM;EAErB,SAAS,KAAA;EACT,SAAS,CAAC;CACZ;CACA,KAAK,IAAMK,KAAKP,GAAW,EAAE,UAAUK,CAAU;CACjD,IAAMG,IAAaH,EAAW,OAAO,IAAId,CAAW;CAqBpD,OAAO;EAAE,SAAA;GAlBP;GACA,UAAUG,EAAI,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA,OAAOA,EAAI,KAAK;GAChB,UAAUA,EAAI,KAAK;GACnB;EASO;EAAS;EAAS,OAAA;GANzB,SAAS;IAAE,GAAGA,EAAI,MAAM;IAAG,GAAGA,EAAI,MAAM;GAAE;GAC1C,QAAQA,EAAI,MAAM,UAAU;GAC5B,SAASA,EAAI,UAAU;GACvB,WAAWA,EAAI,UAAU;GACzB,QAAQ;IAAE,OAAOc;IAAY,SAASA;GAAW;EAExB;CAAM;AACnC"}
+{"version":3,"file":"session.js","names":[],"sources":["../../../../src/interactions/actions/insert/session.ts"],"sourcesContent":["import type { BindingOpts, DragSample, InvocationCtx } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { SNAP_ANGLE_STEP, snapMods } from 'features/snap/roles';\nimport { spanSnap, type SpanSnap } from 'features/snap/spanSnap';\nimport { pointerStateOf } from '../pointerState';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, InsertBehavior, InsertPoint } from '../../gestures/types';\nimport type { InsertDep, TextEditDep } from '../depSchema';\nimport { insertKind } from './shape';\n\n/** The key an insert's single gesture point rides under in the behaviors'\n *  `draggedIds` / `origin` / `current` — insert has no node id yet. */\nexport const GESTURE_KEY = 'gesture';\n\n/** What an insert captured at press. Nothing here changes during the drag.\n *  The deps are captured because the dispatcher builds the deps bag once, on\n *  `start`: every later pump event carries `deps: {}`. */\nexport interface InsertSession {\n  readonly dep: InsertDep;\n  /** For the text kind's drop-into-the-caret step. */\n  readonly textEdit: TextEditDep | undefined;\n  /** Snaps the drag's start and current point, so the live preview and the\n   *  committed geometry agree. Freehand pencil samples are deliberately NOT\n   *  snapped — a grid-quantized freehand trail is a staircase, not a stroke. */\n  readonly snap: SpanSnap;\n  /** The active binding's opts — re-resolved on every read so thunked\n   *  params see the latest tool state (e.g. polygon `sides` after ArrowUp). */\n  readonly opts: BindingOpts | undefined;\n  /** What was selected before the draw cleared it, to put back on cancel. */\n  readonly priorSelection: readonly NodeId[];\n  /** Behaviors from `opts.behaviors`; empty when none were bound. */\n  readonly behaviors: readonly InsertBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors. Its `origin` holds the\n   *  start point under {@link GESTURE_KEY}, after `onStart` shaped it. */\n  readonly gestureCtx: GestureContext<unknown>;\n  /** For committing a behavior's `Op[]`. */\n  readonly scene: Scene<unknown, string, unknown> | undefined;\n  readonly applyOps: ((ops: Op[], label: string) => void) | undefined;\n  readonly selection: SelectionApi | undefined;\n}\n\n/** What the latest pump event left. Replaced, not mutated, by the next. */\nexport interface InsertFrame {\n  /** The raw (unsnapped) pointer in world space. */\n  readonly pointer: InsertPoint;\n  /** Pointer trail accumulated by the dispatcher in world space; pencil-kind\n   *  commits read it. */\n  readonly points: ReadonlyArray<DragSample> | null;\n  /** Alt inverts the binding's nominal `originMode` (corner ⇄ center), so\n   *  pressing or releasing it mid-drag flips the preview and the commit\n   *  without the dispatcher re-routing to another binding. */\n  readonly altHeld: boolean;\n  /** The endpoints after the snap session and the behaviors. */\n  readonly shaped: { start: InsertPoint; current: InsertPoint };\n}\n\n/** Capture an insert at press. Null with no `insert` dep. Clears the\n *  selection and runs each behavior's `onStart`. */\nexport function beginInsert(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n): { session: InsertSession; readers: GestureReaders; frame: InsertFrame } | null {\n  const dep = ctx.deps.insert;\n  if (!dep) return null;\n\n  // Starting a draw retires any prior selection — the lingering halo\n  // around an unrelated node while the user is drawing a new shape is\n  // just visual noise, and it primes the UX bug where a drag that\n  // continues over the selected node would otherwise drive the move\n  // action via fall-through. The clear is unconditional: the user has\n  // committed to \"I'm making a new thing\" by engaging a creation tool.\n  const selection = ctx.deps.selection;\n  const priorSelection = selection ? [...selection.get()] : [];\n  if (selection && priorSelection.length > 0) {\n    selection.clear();\n  }\n\n  const snap = spanSnap(ctx.deps.snap, () =>\n    insertKind(resolveParams(opts?.params)) === 'line' ? { step: SNAP_ANGLE_STEP } : undefined);\n  const behaviors = (opts?.behaviors ?? []) as InsertBehavior<unknown>[];\n  const readers = gestureReaders(ctx.deps);\n  const origin = snap.start({ x: ctx.world.x, y: ctx.world.y }, snapMods(ctx)).point;\n  const gestureCtx: GestureContext<unknown> = {\n    draggedIds: [GESTURE_KEY],\n    origin: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    current: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(ctx.world, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    kitSettings: readers.kitSettings,\n    // No node exists to adapt until commit; insert behaviors read points.\n    adapter: undefined as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n  // A snap target in range outranks a behavior's own snapping.\n  if (snap.startHeld()) gestureCtx.origin.set(GESTURE_KEY, origin);\n  const startPoint = gestureCtx.origin.get(GESTURE_KEY) as InsertPoint;\n  snap.anchor(startPoint);\n\n  const session: InsertSession = {\n    dep,\n    textEdit: ctx.deps.textEdit,\n    snap,\n    opts,\n    priorSelection,\n    behaviors,\n    gestureCtx,\n    scene: ctx.deps.scene,\n    applyOps: ctx.deps.applyOps,\n    selection,\n  };\n  const frame: InsertFrame = {\n    pointer: { x: ctx.world.x, y: ctx.world.y },\n    points: ctx.drag?.points ?? null,\n    altHeld: ctx.modifiers.alt,\n    shaped: { start: startPoint, current: startPoint },\n  };\n  return { session, readers, frame };\n}\n"],"mappings":";;;;;;;;;;AAeA,IAAa,cAAc;;;AA8C3B,SAAgB,YACd,KACA,MACgF;CAChF,MAAM,MAAM,IAAI,KAAK;CACrB,IAAI,CAAC,KAAK,OAAO;CAQjB,MAAM,YAAY,IAAI,KAAK;CAC3B,MAAM,iBAAiB,YAAY,CAAC,GAAG,UAAU,IAAI,CAAC,IAAI,CAAC;CAC3D,IAAI,aAAa,eAAe,SAAS,GACvC,UAAU,MAAM;CAGlB,MAAM,OAAO,SAAS,IAAI,KAAK,YAC7B,WAAW,cAAc,MAAM,MAAM,CAAC,MAAM,SAAS,EAAE,MAAM,gBAAgB,IAAI,MAAS;CAC5F,MAAM,YAAa,MAAM,aAAa,CAAC;CACvC,MAAM,UAAU,eAAe,IAAI,IAAI;CACvC,MAAM,SAAS,KAAK,MAAM;EAAE,GAAG,IAAI,MAAM;EAAG,GAAG,IAAI,MAAM;CAAE,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;CAC7E,MAAM,aAAsC;EAC1C,YAAY,CAAC,WAAW;EACxB,wBAAQ,IAAI,IAAqB,CAAC,CAAC,aAAa,MAAM,CAAC,CAAC;EACxD,yBAAS,IAAI,IAAqB,CAAC,CAAC,aAAa,MAAM,CAAC,CAAC;EACzD,MAAM;EACN,WAAW,EAAE,GAAG,IAAI,UAAU;EAC9B,SAAS,eAAe,IAAI,OAAO,GAAG;EACtC,MAAM,QAAQ,KAAK;EACnB,OAAO,QAAQ,MAAM;EACrB,aAAa,QAAQ;EAErB,SAAS;EACT,SAAS,CAAC;CACZ;CACA,KAAK,MAAM,KAAK,WAAW,EAAE,UAAU,UAAU;CAEjD,IAAI,KAAK,UAAU,GAAG,WAAW,OAAO,IAAI,aAAa,MAAM;CAC/D,MAAM,aAAa,WAAW,OAAO,IAAI,WAAW;CACpD,KAAK,OAAO,UAAU;CAoBtB,OAAO;EAAE;GAjBP;GACA,UAAU,IAAI,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA,OAAO,IAAI,KAAK;GAChB,UAAU,IAAI,KAAK;GACnB;EAQO;EAAS;EAAS;GALzB,SAAS;IAAE,GAAG,IAAI,MAAM;IAAG,GAAG,IAAI,MAAM;GAAE;GAC1C,QAAQ,IAAI,MAAM,UAAU;GAC5B,SAAS,IAAI,UAAU;GACvB,QAAQ;IAAE,OAAO;IAAY,SAAS;GAAW;EAExB;CAAM;AACnC"}

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

@@ -1,34 +1,92 @@
-import { applyUserRotation as e, buildExtras as t } from "./extras.js";
-import { computeBounds as n, effectiveOriginMode as r } from "./geometry.js";
+import { minSizeOf } from "../../../core/scene/minSize.js";
+import { applyUserRotation, buildExtras } from "./extras.js";
+import { computeBounds, effectiveOriginMode } from "./geometry.js";
+
 //#region src/interactions/actions/insert/shape.ts
-function i(e) {
-	return e?.kind ?? "rect";
+/** The node kind a binding's resolved params ask for. */
+function insertKind(resolved) {
+	return resolved?.["kind"] ?? "rect";
+}
+/** The effective endpoints: `shaped`, plus — for the `line` kind only — the
+*  alt/center reading as "mirror the start around the pointer" rather than
+*  "grow a symmetric AABB". */
+function resolveEndpoints(shaped, kind, mode) {
+	let { start } = shaped;
+	const { current } = shaped;
+	if (kind === "line" && mode === "center") start = {
+		x: start.x - (current.x - start.x),
+		y: start.y - (current.y - start.y)
+	};
+	return {
+		start,
+		current
+	};
 }
-function a(e, t, n) {
-	let { start: r } = e, { current: i } = e;
-	return t === "line" && n === "center" && (r = {
-		x: r.x - (i.x - r.x),
-		y: r.y - (i.y - r.y)
-	}), {
-		start: r,
-		current: i
+/** `current` moved out from `start` until the box they make is no smaller
+*  than `min`, along the way the drag went (rightward and down when it has
+*  not gone either way). */
+function reachMinimum(start, current, min, mode) {
+	const k = mode === "center" ? .5 : 1;
+	const reach = (d, m) => Math.abs(d) >= m * k ? d : (d < 0 ? -1 : 1) * m * k;
+	return {
+		...current,
+		x: start.x + reach(current.x - start.x, min.width),
+		y: start.y + reach(current.y - start.y, min.height)
 	};
 }
-function o(o, s, c, l) {
-	let u = r(o?.originMode, s.altHeld), { start: d, current: f } = a(s.shaped, i(o), u), p = n(d.x, d.y, f.x, f.y, u), m = t({
-		...o ?? {},
-		originMode: u
-	}, d.x, d.y, f.x, f.y, c);
-	return e(m, l), {
-		bounds: p,
-		extras: m,
-		start: d
+/** Kinds a minimum size does not apply to: a line has no area, and a pencil
+*  trail is drawn where the pointer went. */
+var NO_MINIMUM = /* @__PURE__ */ new Set(["line", "pencil"]);
+/** The shape an insert has at `frame`. The live overlay and the commit both
+*  read it from here, so they can't disagree. Extras are derived with the
+*  effective origin mode, so polygon/star center+radius follow the live Alt
+*  toggle and not the binding's nominal `originMode`. */
+function insertShape(resolved, frame, points, userRotation) {
+	const mode = effectiveOriginMode(resolved?.["originMode"], frame.altHeld);
+	const kind = insertKind(resolved);
+	const ends = resolveEndpoints(frame.shaped, kind, mode);
+	const { start } = ends;
+	const min = NO_MINIMUM.has(kind) ? null : minSizeOf(resolved);
+	const current = min ? reachMinimum(start, ends.current, min, mode) : ends.current;
+	const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);
+	const extras = buildExtras({
+		...resolved ?? {},
+		originMode: mode
+	}, start.x, start.y, current.x, current.y, points);
+	applyUserRotation(extras, userRotation);
+	if (min) extras.minSize = min;
+	return {
+		bounds,
+		extras,
+		start,
+		ends: {
+			start: {
+				x: start.x,
+				y: start.y
+			},
+			end: {
+				x: current.x,
+				y: current.y
+			},
+			...mode === "center" ? { fromCenter: true } : {}
+		}
 	};
 }
-function s(e, t) {
-	return t === "pencil" ? !0 : t === "line" ? e.width !== 0 || e.height !== 0 : e.width !== 0 && e.height !== 0;
+/** Whether a drag produced enough extent to be worth committing. The test
+*  is kind-aware because "zero size" isn't one shape:
+*   - pencil: a sample trail can be meaningful even when start ≈ end
+*     (a closed loop), so no guard at all.
+*   - line: has no area by construction. An axis-aligned line has a
+*     zero-height (or zero-width) AABB and is perfectly valid — only
+*     a zero-LENGTH drag is degenerate. (Shift-constrain makes
+*     axis-aligned the common case, which is how this surfaced.)
+*   - everything else: a zero extent in either axis is degenerate. */
+function isCommittableExtent(bounds, kind) {
+	if (kind === "pencil") return true;
+	if (kind === "line") return bounds.width !== 0 || bounds.height !== 0;
+	return bounds.width !== 0 && bounds.height !== 0;
 }
-//#endregion
-export { i as insertKind, o as insertShape, s as isCommittableExtent };
 
+//#endregion
+export { insertKind, insertShape, isCommittableExtent };
 //# sourceMappingURL=shape.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"shape.js","names":["insertKind","resolved","\"kind\"","resolveEndpoints","shaped","kind","mode","start","current","insertShape","effectiveOriginMode","\"originMode\"","frame","bounds","computeBounds","extras","buildExtras","points","applyUserRotation","userRotation","isCommittableExtent"],"sources":["../../../../src/interactions/actions/insert/shape.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertPoint } from '../../gestures/types';\nimport type { InsertExtras } from '../depSchema';\nimport { applyUserRotation, buildExtras } from './extras';\nimport { computeBounds, effectiveOriginMode } from './geometry';\nimport type { InsertFrame } from './session';\n\n/** The node kind a binding's resolved params ask for. */\nexport function insertKind(resolved: Record<string, unknown> | undefined): string {\n  return (resolved?.['kind'] as string | undefined) ?? 'rect';\n}\n\n/** The effective endpoints: `shaped`, plus — for the `line` kind only — the\n *  alt/center reading as \"mirror the start around the pointer\" rather than\n *  \"grow a symmetric AABB\". */\nfunction resolveEndpoints(\n  shaped: InsertFrame['shaped'],\n  kind: string,\n  mode: 'corner' | 'center',\n): { start: InsertPoint; current: InsertPoint } {\n  let { start } = shaped;\n  const { current } = shaped;\n\n  // A line has no area, so \"from center\" means the drag is a half-line:\n  // mirror the start to the far side of the pointer.\n  if (kind === 'line' && mode === 'center') {\n    start = { x: start.x - (current.x - start.x), y: start.y - (current.y - start.y) };\n  }\n  return { start, current };\n}\n\nexport interface InsertShape {\n  bounds: { x: number; y: number; width: number; height: number };\n  extras: InsertExtras;\n  /** Where the drag started, after the endpoints were resolved. */\n  start: InsertPoint;\n}\n\n/** The shape an insert has at `frame`. The live overlay and the commit both\n *  read it from here, so they can't disagree. Extras are derived with the\n *  effective origin mode, so polygon/star center+radius follow the live Alt\n *  toggle and not the binding's nominal `originMode`. */\nexport function insertShape(\n  resolved: Record<string, unknown> | undefined,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): InsertShape {\n  const mode = effectiveOriginMode(resolved?.['originMode'], frame.altHeld);\n  const { start, current } = resolveEndpoints(frame.shaped, insertKind(resolved), mode);\n  const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n  const extras = buildExtras(\n    { ...(resolved ?? {}), originMode: mode },\n    start.x, start.y, current.x, current.y,\n    points,\n  );\n  applyUserRotation(extras, userRotation);\n  return { bounds, extras, start };\n}\n\n/** Whether a drag produced enough extent to be worth committing. The test\n *  is kind-aware because \"zero size\" isn't one shape:\n *   - pencil: a sample trail can be meaningful even when start ≈ end\n *     (a closed loop), so no guard at all.\n *   - line: has no area by construction. An axis-aligned line has a\n *     zero-height (or zero-width) AABB and is perfectly valid — only\n *     a zero-LENGTH drag is degenerate. (Shift-constrain makes\n *     axis-aligned the common case, which is how this surfaced.)\n *   - everything else: a zero extent in either axis is degenerate. */\nexport function isCommittableExtent(\n  bounds: { width: number; height: number },\n  kind: string,\n): boolean {\n  if (kind === 'pencil') return true;\n  if (kind === 'line') return bounds.width !== 0 || bounds.height !== 0;\n  return bounds.width !== 0 && bounds.height !== 0;\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAuD;CAChF,OAAQC,GAAWC,QAAkC;AACvD;AAKA,SAASC,EACP,GACA,GACA,GAC8C;CAC9C,IAAI,EAAE,aAAUC,GACV,EAAE,eAAYA;CAOpB,OAHIC,MAAS,UAAUC,MAAS,aAC9B,IAAQ;EAAE,GAAGC,EAAM,KAAKC,EAAQ,IAAID,EAAM;EAAI,GAAGA,EAAM,KAAKC,EAAQ,IAAID,EAAM;CAAG,IAE5E;EAAE;EAAO;CAAQ;AAC1B;AAaA,SAAgBE,EACd,GACA,GACA,GACA,GACa;CACb,IAAMH,IAAOI,EAAoBT,GAAWU,YAAeC,EAAM,OAAO,GAClE,EAAE,UAAO,eAAYT,EAAiBS,EAAM,QAAQZ,EAAWC,CAAQ,GAAGK,CAAI,GAC9EO,IAASC,EAAcP,EAAM,GAAGA,EAAM,GAAGC,EAAQ,GAAGA,EAAQ,GAAGF,CAAI,GACnES,IAASC,EACb;EAAE,GAAIf,KAAY,CAAC;EAAI,YAAYK;CAAK,GACxCC,EAAM,GAAGA,EAAM,GAAGC,EAAQ,GAAGA,EAAQ,GACrCS,CACF;CAEA,OADAC,EAAkBH,GAAQI,CAAY,GAC/B;EAAE;EAAQ;EAAQ;CAAM;AACjC;AAWA,SAAgBC,EACd,GACA,GACS;CAGT,OAFIf,MAAS,WAAiB,KAC1BA,MAAS,SAAeQ,EAAO,UAAU,KAAKA,EAAO,WAAW,IAC7DA,EAAO,UAAU,KAAKA,EAAO,WAAW;AACjD"}
+{"version":3,"file":"shape.js","names":[],"sources":["../../../../src/interactions/actions/insert/shape.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertPoint } from '../../gestures/types';\nimport type { InsertEnds, InsertExtras } from '../depSchema';\nimport { applyUserRotation, buildExtras } from './extras';\nimport { computeBounds, effectiveOriginMode } from './geometry';\nimport type { InsertFrame } from './session';\nimport { minSizeOf, type MinSize } from 'core/scene/minSize';\n\n/** The node kind a binding's resolved params ask for. */\nexport function insertKind(resolved: Record<string, unknown> | undefined): string {\n  return (resolved?.['kind'] as string | undefined) ?? 'rect';\n}\n\n/** The effective endpoints: `shaped`, plus — for the `line` kind only — the\n *  alt/center reading as \"mirror the start around the pointer\" rather than\n *  \"grow a symmetric AABB\". */\nfunction resolveEndpoints(\n  shaped: InsertFrame['shaped'],\n  kind: string,\n  mode: 'corner' | 'center',\n): { start: InsertPoint; current: InsertPoint } {\n  let { start } = shaped;\n  const { current } = shaped;\n\n  // A line has no area, so \"from center\" means the drag is a half-line:\n  // mirror the start to the far side of the pointer.\n  if (kind === 'line' && mode === 'center') {\n    start = { x: start.x - (current.x - start.x), y: start.y - (current.y - start.y) };\n  }\n  return { start, current };\n}\n\n/** `current` moved out from `start` until the box they make is no smaller\n *  than `min`, along the way the drag went (rightward and down when it has\n *  not gone either way). */\nfunction reachMinimum(\n  start: InsertPoint,\n  current: InsertPoint,\n  min: MinSize,\n  mode: 'corner' | 'center',\n): InsertPoint {\n  // A center drag makes a box twice its reach.\n  const k = mode === 'center' ? 0.5 : 1;\n  const reach = (d: number, m: number) => (Math.abs(d) >= m * k ? d : (d < 0 ? -1 : 1) * m * k);\n  return {\n    ...current,\n    x: start.x + reach(current.x - start.x, min.width),\n    y: start.y + reach(current.y - start.y, min.height),\n  };\n}\n\n/** Kinds a minimum size does not apply to: a line has no area, and a pencil\n *  trail is drawn where the pointer went. */\nconst NO_MINIMUM = new Set(['line', 'pencil']);\n\nexport interface InsertShape {\n  bounds: { x: number; y: number; width: number; height: number };\n  extras: InsertExtras;\n  /** Where the drag started, after the endpoints were resolved. */\n  start: InsertPoint;\n  /** The drag `bounds` came from. */\n  ends: InsertEnds;\n}\n\n/** The shape an insert has at `frame`. The live overlay and the commit both\n *  read it from here, so they can't disagree. Extras are derived with the\n *  effective origin mode, so polygon/star center+radius follow the live Alt\n *  toggle and not the binding's nominal `originMode`. */\nexport function insertShape(\n  resolved: Record<string, unknown> | undefined,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): InsertShape {\n  const mode = effectiveOriginMode(resolved?.['originMode'], frame.altHeld);\n  const kind = insertKind(resolved);\n  const ends = resolveEndpoints(frame.shaped, kind, mode);\n  const { start } = ends;\n  const min = NO_MINIMUM.has(kind) ? null : minSizeOf(resolved);\n  const current = min ? reachMinimum(start, ends.current, min, mode) : ends.current;\n  const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n  const extras = buildExtras(\n    { ...(resolved ?? {}), originMode: mode },\n    start.x, start.y, current.x, current.y,\n    points,\n  );\n  applyUserRotation(extras, userRotation);\n  // The node keeps the minimum it was drawn to, whatever its kind's extras hold.\n  if (min) (extras as { minSize?: MinSize }).minSize = min;\n  const drag: InsertEnds = {\n    start: { x: start.x, y: start.y },\n    end: { x: current.x, y: current.y },\n    ...(mode === 'center' ? { fromCenter: true } : {}),\n  };\n  return { bounds, extras, start, ends: drag };\n}\n\n/** Whether a drag produced enough extent to be worth committing. The test\n *  is kind-aware because \"zero size\" isn't one shape:\n *   - pencil: a sample trail can be meaningful even when start ≈ end\n *     (a closed loop), so no guard at all.\n *   - line: has no area by construction. An axis-aligned line has a\n *     zero-height (or zero-width) AABB and is perfectly valid — only\n *     a zero-LENGTH drag is degenerate. (Shift-constrain makes\n *     axis-aligned the common case, which is how this surfaced.)\n *   - everything else: a zero extent in either axis is degenerate. */\nexport function isCommittableExtent(\n  bounds: { width: number; height: number },\n  kind: string,\n): boolean {\n  if (kind === 'pencil') return true;\n  if (kind === 'line') return bounds.width !== 0 || bounds.height !== 0;\n  return bounds.width !== 0 && bounds.height !== 0;\n}\n"],"mappings":";;;;;;AASA,SAAgB,WAAW,UAAuD;CAChF,OAAQ,WAAW,WAAkC;AACvD;;;;AAKA,SAAS,iBACP,QACA,MACA,MAC8C;CAC9C,IAAI,EAAE,UAAU;CAChB,MAAM,EAAE,YAAY;CAIpB,IAAI,SAAS,UAAU,SAAS,UAC9B,QAAQ;EAAE,GAAG,MAAM,KAAK,QAAQ,IAAI,MAAM;EAAI,GAAG,MAAM,KAAK,QAAQ,IAAI,MAAM;CAAG;CAEnF,OAAO;EAAE;EAAO;CAAQ;AAC1B;;;;AAKA,SAAS,aACP,OACA,SACA,KACA,MACa;CAEb,MAAM,IAAI,SAAS,WAAW,KAAM;CACpC,MAAM,SAAS,GAAW,MAAe,KAAK,IAAI,CAAC,KAAK,IAAI,IAAI,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI;CAC3F,OAAO;EACL,GAAG;EACH,GAAG,MAAM,IAAI,MAAM,QAAQ,IAAI,MAAM,GAAG,IAAI,KAAK;EACjD,GAAG,MAAM,IAAI,MAAM,QAAQ,IAAI,MAAM,GAAG,IAAI,MAAM;CACpD;AACF;;;AAIA,IAAM,6BAAa,IAAI,IAAI,CAAC,QAAQ,QAAQ,CAAC;;;;;AAe7C,SAAgB,YACd,UACA,OACA,QACA,cACa;CACb,MAAM,OAAO,oBAAoB,WAAW,eAAe,MAAM,OAAO;CACxE,MAAM,OAAO,WAAW,QAAQ;CAChC,MAAM,OAAO,iBAAiB,MAAM,QAAQ,MAAM,IAAI;CACtD,MAAM,EAAE,UAAU;CAClB,MAAM,MAAM,WAAW,IAAI,IAAI,IAAI,OAAO,UAAU,QAAQ;CAC5D,MAAM,UAAU,MAAM,aAAa,OAAO,KAAK,SAAS,KAAK,IAAI,IAAI,KAAK;CAC1E,MAAM,SAAS,cAAc,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI;CACzE,MAAM,SAAS,YACb;EAAE,GAAI,YAAY,CAAC;EAAI,YAAY;CAAK,GACxC,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GACrC,MACF;CACA,kBAAkB,QAAQ,YAAY;CAEtC,IAAI,KAAK,OAAkC,UAAU;CAMrD,OAAO;EAAE;EAAQ;EAAQ;EAAO,MAAM;GAJpC,OAAO;IAAE,GAAG,MAAM;IAAG,GAAG,MAAM;GAAE;GAChC,KAAK;IAAE,GAAG,QAAQ;IAAG,GAAG,QAAQ;GAAE;GAClC,GAAI,SAAS,WAAW,EAAE,YAAY,KAAK,IAAI,CAAC;EAEZ;CAAK;AAC7C;;;;;;;;;;AAWA,SAAgB,oBACd,QACA,MACS;CACT,IAAI,SAAS,UAAU,OAAO;CAC9B,IAAI,SAAS,QAAQ,OAAO,OAAO,UAAU,KAAK,OAAO,WAAW;CACpE,OAAO,OAAO,UAAU,KAAK,OAAO,WAAW;AACjD"}