@weasel-js/core 1.7.0 → 1.7.1

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

@@ -0,0 +1,288 @@
+import { gesturePlaneReader as e, gestureViewReader as t } from "../../gestures/shared/screenTolerance.js";
+import { commitGestureOps as n, readGestureLifecycle as r, reduceBehaviorEnd as i, runBehaviorCancel as a } from "../gestureLifecycle.js";
+import { inPlane as o, insertLayer as s } from "../planeInput.js";
+import { defaultCommitAdapter as c } from "../defaultCommitAdapter.js";
+import { shapeKindInfo as l } from "../../../core/shapeKinds.js";
+import { resolveParams as u } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/insert.ts
+var d = null;
+function f(e, t) {
+	let n = e === "center" ? "center" : "corner";
+	return t ? n === "center" ? "corner" : "center" : n;
+}
+function p(e, t, n, r, i) {
+	if (i === "center") {
+		let i = Math.abs(n - e), a = Math.abs(r - t);
+		return {
+			x: e - i,
+			y: t - a,
+			width: i * 2,
+			height: a * 2
+		};
+	}
+	return {
+		x: Math.min(e, n),
+		y: Math.min(t, r),
+		width: Math.abs(n - e),
+		height: Math.abs(r - t)
+	};
+}
+function m(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)
+	};
+}
+var h = "gesture";
+function g(e, t) {
+	let n = u(e.opts?.params), r = n?.kind ?? "rect", i = e.gestureCtx, a = i.origin.get(h), o = {
+		x: e.currentX,
+		y: e.currentY
+	};
+	if (r === "line" && e.shiftHeld && (o = m({
+		x: e.startX,
+		y: e.startY
+	}, o)), o = e.snap(o), e.behaviors.length > 0) {
+		i.modifiers = { ...t }, i.pointer = {
+			worldX: e.currentX,
+			worldY: e.currentY,
+			clientX: 0,
+			clientY: 0
+		}, i.view = e.readView(), i.plane = e.readPlane(), i.current.set(h, o);
+		let r = f(n?.originMode, e.altHeld);
+		for (let t of e.behaviors) {
+			let e = p(a.x, a.y, o.x, o.y, r), n = t.onMove?.(i, {
+				start: a,
+				current: o,
+				bounds: e,
+				pose: e
+			});
+			n && (n.start && (a = n.start), n.current && (o = n.current));
+		}
+		i.current.set(h, o);
+	}
+	e.shaped = {
+		start: a,
+		current: o
+	};
+}
+function _(e, t, n) {
+	let { start: r } = e.shaped, { current: i } = e.shaped;
+	return t === "line" && n === "center" && (r = {
+		x: r.x - (i.x - r.x),
+		y: r.y - (i.y - r.y)
+	}), {
+		startX: r.x,
+		startY: r.y,
+		currentX: i.x,
+		currentY: i.y
+	};
+}
+function v(e, t, n, r, i, a) {
+	let o = e?.kind ?? "rect";
+	switch (o) {
+		case "rect":
+		case "ellipse": return { kind: o };
+		case "line": return {
+			kind: "line",
+			a: {
+				x: t,
+				y: n
+			},
+			b: {
+				x: r,
+				y: i
+			}
+		};
+		case "polygon": {
+			let a = Number(e?.sides ?? 6), o = r === t && i === n ? 0 : Math.atan2(i - n, r - t), s = {
+				kind: "polygon",
+				sides: a,
+				rotation: e?.rotation === void 0 ? o : Number(e.rotation)
+			};
+			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;
+		}
+		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 = {
+				kind: "star",
+				points: a,
+				innerRadiusRatio: o,
+				rotation: e?.rotation === void 0 ? s : Number(e.rotation)
+			};
+			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;
+		}
+		case "pencil": return {
+			kind: "pencil",
+			samples: e?.samples ?? a ?? []
+		};
+		default: return {
+			...e ?? {},
+			kind: o
+		};
+	}
+}
+var y = o({
+	id: "insert",
+	label: "Insert",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	requires: [
+		"insert",
+		"selection",
+		"snap",
+		"textEdit",
+		"scene",
+		"applyOps",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(o, s) {
+			let m = o.deps.insert;
+			if (!m) return {};
+			let y = o.deps.selection;
+			y && y.get().length > 0 && y.clear();
+			let S = o.deps.snap, C = S ? (e) => S.point(e) : (e) => e, w = s?.behaviors ?? [], T = t(o.deps), E = e(o.deps), D = C({
+				x: o.world.x,
+				y: o.world.y
+			}), O = {
+				draggedIds: [h],
+				origin: /* @__PURE__ */ new Map([[h, D]]),
+				current: /* @__PURE__ */ new Map([[h, D]]),
+				snap: null,
+				modifiers: { ...o.modifiers },
+				pointer: {
+					worldX: o.world.x,
+					worldY: o.world.y,
+					clientX: 0,
+					clientY: 0
+				},
+				view: T(),
+				plane: E(),
+				adapter: void 0,
+				scratch: {}
+			};
+			for (let e of w) e.onStart?.(O);
+			let k = O.origin.get(h), A = {
+				dep: m,
+				textEdit: o.deps.textEdit,
+				snap: C,
+				opts: s,
+				behaviors: w,
+				gestureCtx: O,
+				readView: T,
+				readPlane: E,
+				shaped: {
+					start: k,
+					current: k
+				},
+				scene: o.deps.scene,
+				applyOps: o.deps.applyOps,
+				selection: y,
+				startX: o.world.x,
+				startY: o.world.y,
+				currentX: o.world.x,
+				currentY: o.world.y,
+				points: o.drag?.points ?? null,
+				altHeld: o.modifiers.alt,
+				shiftHeld: o.modifiers.shift,
+				open: !0,
+				userRotation: 0
+			};
+			return d = A, {
+				kind: "insert",
+				onMove(e) {
+					A.currentX = e.world.x, A.currentY = e.world.y, A.shiftHeld = e.modifiers.shift, A.altHeld = e.modifiers.alt, e.drag?.points && (A.points = e.drag.points), g(A, e.modifiers);
+				},
+				overlay() {
+					if (!A.open) return null;
+					let e = u(A.opts?.params), t = e?.kind ?? "rect";
+					if (!l(t)?.insertPreview) return null;
+					let n = f(e?.originMode, A.altHeld), r = _(A, t, n), i = p(r.startX, r.startY, r.currentX, r.currentY, n), a = v({
+						...e ?? {},
+						originMode: n
+					}, r.startX, r.startY, r.currentX, r.currentY, A.points);
+					return x(a, A.userRotation), {
+						kind: "insertPreview",
+						shape: a.kind,
+						bounds: i,
+						extras: a,
+						anchorPoint: {
+							x: r.startX,
+							y: r.startY
+						}
+					};
+				},
+				onEnd(e, t) {
+					if (A.open = !1, d === A && (d = null), t === "cancel") {
+						a(A.behaviors, A.gestureCtx);
+						return;
+					}
+					let { dep: o, opts: s } = A, l = e.drag?.points ?? A.points, m = u(s?.params);
+					if (A.behaviors.length > 0) {
+						let e = i(A.behaviors, A.gestureCtx);
+						if (e === null) return;
+						if (e !== void 0) {
+							A.scene && n({
+								scene: A.scene,
+								applyOps: A.applyOps,
+								adapter: c(A.scene, A.selection?.adapterMethods)
+							}, r(m, "Insert", A.behaviors), e);
+							return;
+						}
+					}
+					let h = m?.kind ?? "rect", g = f(m?.originMode, A.altHeld), { startX: y, startY: S, currentX: C, currentY: w } = _(A, h, g), T = p(y, S, C, w, g), E = v({
+						...m ?? {},
+						originMode: g
+					}, y, S, C, w, l);
+					if (x(E, A.userRotation), !b(T, E.kind)) return;
+					let D = o.commit(T, E);
+					D !== null && E.kind === "text" && A.textEdit?.startEdit(String(D), { caret: 0 });
+				}
+			};
+		}
+	},
+	enabled: () => !0
+}, s);
+function b(e, t) {
+	return t === "pencil" ? !0 : t === "line" ? e.width !== 0 || e.height !== 0 : e.width !== 0 && e.height !== 0;
+}
+function x(e, t) {
+	t !== 0 && (e.kind === "star" || e.kind === "polygon") && (e.rotation += t);
+}
+var S = Math.PI / 720, C = {
+	id: "insert.adjustRotation",
+	label: "Insert — rotate",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let n = d;
+			if (!n || !n.open) return;
+			let r = t?.deltaY ?? 0;
+			r !== 0 && (n.userRotation += r * S);
+		}
+	}
+};
+//#endregion
+export { y as insertAction, C as insertRotateAction };
+
+//# sourceMappingURL=insert.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insert.js","names":["liveInsertScratch","effectiveOriginMode","nominal","paramsOrigin","altHeld","computeBounds","originMode","dx","currentX","startX","dy","currentY","startY","snapTo15Degrees","end","start","len","step","snapped","GESTURE_KEY","shapeEndpoints","resolved","resolveParams","scratch","kind","\"kind\"","gctx","current","modifiers","mode","\"originMode\"","b","bounds","r","resolveEndpoints","buildExtras","params","sides","\"sides\"","dragAngle","extras","\"rotation\"","\"center\"","\"radius\"","pts","\"points\"","ir","\"innerRadiusRatio\"","\"outerRadius\"","\"samples\"","points","insertAction","inPlane","dep","ctx","selection","snapDep","snap","p","behaviors","opts","readView","gestureViewReader","readPlane","gesturePlaneReader","origin","gestureCtx","startPoint","moveCtx","shapeKindInfo","effectiveExtras","applyUserRotation","reason","d","o","endCtx","reduceBehaviorEnd","commitGestureOps","defaultCommitAdapter","readGestureLifecycle","isCommittableExtent","id","insertLayer","userRotation","ROTATION_SENSITIVITY","insertRotateAction","deltaY"],"sources":["../../../../src/interactions/actions/defaults/insert.ts"],"sourcesContent":["/**\n * `insertAction` — ongoing Action descriptor for drag-to-insert.\n *\n * ## Status: REAL\n *\n * Implements the drag-rect insert logic from `useInsert`:\n *   - `start`: validates the `insert` dep and records the drag start point.\n *   - `onMove`: tracks the live drag bounds (no scene writes).\n *   - `onEnd('commit')`: derives final bounds from drag.start + drag.current;\n *     calls `deps.insert.commit(bounds, kind)` to materialise the new node.\n *     `kind` comes from `opts.params.kind` (set by the active tool's binding).\n *   - `onEnd('cancel')`: no-op.\n *\n * ## Dependencies\n *\n * Requires `insert` dep from DepSchema:\n *   `{ commit(bounds, kind): NodeId | null }`\n *\n * `<SceneCanvas>` / `<StandardActionsRegistrar>` should source this dep by\n * delegating to the scene's `add()` with a sensible default data payload for\n * the given `kind`. Override per-consumer for custom node factories.\n *\n * ## Modifiers and snapping\n *\n * Grid snapping comes from the optional `snap` dep, applied to the drag's\n * start and current point (never to freehand pencil samples). The `line`\n * kind additionally honors Shift (constrain to 15°) and reads Alt/center as\n * \"mirror the start around the pointer\" rather than \"grow a symmetric AABB\".\n * Behaviors from the binding's `opts.behaviors` (`InsertBehavior[]` — e.g.\n * `@weasel-js/guides`' `snapToGrid` and `alignInsertBehavior`) run over the two\n * points after those, the way `moveAction` runs its own: `onStart` on the\n * start point, `onMove` on each frame's proposal, `onEnd` on release, where\n * the first answer wins (`null` aborts, `Op[]` commits in place of the\n * insert). `shapeEndpoints` folds them each pump event and `resolveEndpoints`\n * reads the result, so the live preview and the committed node can't\n * disagree.\n *\n * ## What this does NOT wire (vs `useInsert`)\n *\n * - `pointInsert` fallback for click / sub-threshold drags — not wired; a\n *   sub-threshold drag produces no insert.\n * - `clickOnly` mode — not applicable to the descriptor model.\n *\n * ## Live preview\n *\n * Insert produces a brand-new node that has no scene id until commit, so\n * the preview-ghost layer (`usePreviewGhostLayer`, keyed by node id) can't\n * paint a silhouette for it. Instead, the action exposes its in-flight\n * geometry via the `overlay()` surface with `kind: 'insertPreview'`. The\n * canvas's `useDispatcherOverlayLayer` rebuilds the shape using the same\n * path builders the commit-time factory uses (`rectPath`, `ellipsePath`,\n * `linePath`, `regularPolygonPath`, `starPath`, polyline / `polygonFromPoints`),\n * so the preview is geometry-faithful to the eventual node.\n *\n * Consumer-defined insert kinds (kinds the kit doesn't know how to draw)\n * skip the preview but still commit normally on release.\n *\n * ## Relationship to `useInsert`\n *\n * `useInsert` calls `adapter.commitInsert(bounds)` which returns a node and\n * dispatches a `createInsertOp`. This descriptor delegates to `deps.insert.commit`\n * which encapsulates both factory + op dispatch in one call. This keeps the\n * dep contract thin and avoids importing `createInsertOp` into the descriptor.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts, OngoingOverlay, DragSample } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { InsertDep, InsertExtras, SnapDep } from '../depSchema';\nimport type { Op } from 'core/ops/types';\nimport type { Scene } from 'core/scene/types';\nimport type { GestureContext, InsertBehavior, InsertPoint } from '../../gestures/types';\nimport { gesturePlaneReader, gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport type { View } from 'core/viewport/view';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel } from '../gestureLifecycle';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport type { TextEditDep } from '../depSchema';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { shapeKindInfo } from 'core/shapeKinds';\nimport type { KitInsertShape } from 'core/shapeKinds';\nimport { inPlane, insertLayer } from '../planeInput';\nimport type { PlaneMap } from 'core/viewport/parallax';\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface InsertScratch {\n  dep: InsertDep;\n  /** Text-edit dep captured at gesture start, for the text kind's\n   *  drop-into-the-caret step. Stashed rather than read at commit because\n   *  the dispatcher only builds the deps bag once, on `start` — every later\n   *  pump event carries `deps: {}`. */\n  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  snap: (p: { x: number; y: number }) => { x: number; y: number };\n  /** The active binding's opts — re-resolved at commit time so thunked\n   *  params see the latest tool state (e.g. polygon `sides` after ArrowUp). */\n  opts: BindingOpts | undefined;\n  /** RAW (unsnapped) drag endpoints in world space. `shapeEndpoints`\n   *  constrains the angle first, THEN aligns the endpoint to the grid, so\n   *  the documented modifier ordering holds for the preview and the commit. */\n  startX: number;\n  startY: number;\n  currentX: number;\n  currentY: number;\n  /** Pointer trail accumulated by the dispatcher in world space. Same array\n   *  reference as `ctx.drag.points`; pencil-kind commits read from this. */\n  points: ReadonlyArray<DragSample> | null;\n  /** Live Alt-key state from the most recent pump event. Alt INVERTS the\n   *  binding's nominal `originMode` (corner → center and vice versa), so\n   *  the user can press / release Alt mid-drag and the preview/commit\n   *  flip without needing the dispatcher to re-route to a different\n   *  binding. Captured per-onMove from `ctx.modifiers.alt`. */\n  altHeld: boolean;\n  /** Live Shift-key state from the most recent pump event. Constrains the\n   *  `line` kind to 15° increments (the modifier the line tool documents).\n   *  Captured per-onMove from `ctx.modifiers.shift`. */\n  shiftHeld: boolean;\n  /** Cleared once `onEnd` runs so subsequent `overlay()` calls report no\n   *  in-flight preview (mirrors the areaSelect/lasso convention). */\n  open: boolean;\n  /** Behaviors from `opts.behaviors`; empty when none were bound. */\n  behaviors: 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  gestureCtx: GestureContext<unknown>;\n  readView: () => View | null;\n  readPlane: () => PlaneMap | null;\n  /** The endpoints after Shift-constrain, the `snap` dep and the behaviors,\n   *  recomputed on every pump event so each behavior runs once per frame. */\n  shaped: { start: InsertPoint; current: InsertPoint };\n  /** Captured at `start` for committing a behavior's `Op[]`. */\n  scene: Scene<unknown, string, unknown> | undefined;\n  applyOps: ((ops: Op[], label: string) => void) | undefined;\n  selection: SelectionApi | undefined;\n  /** Accumulated user-driven rotation (radians) layered on top of any\n   *  drag-direction / params rotation. Driven by `insert.adjustRotation`\n   *  (Shift+wheel during engaged phase). Only consulted for kinds that\n   *  carry a `rotation` field on their extras (star / polygon today). */\n  userRotation: number;\n}\n\n// Module-scoped pointer to the in-flight insert scratch. There is at most\n// one insert gesture at a time (single primary pointer) so a single ref\n// is sufficient. `insert.adjustRotation` reads this to mutate the live\n// scratch without needing handle-passing plumbing through the dispatcher.\nlet liveInsertScratch: InsertScratch | null = null;\n\n/** 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 */\nfunction 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). */\nfunction 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. */\nfunction 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\n/** The key an insert's single gesture point rides under in the behaviors'\n *  `draggedIds` / `origin` / `current` — insert has no node id yet. */\nconst GESTURE_KEY = 'gesture';\n\n/**\n * Shape the raw drag endpoints, in order: the line tool's Shift-constrain\n * (on raw coords, so the locked angle survives), the `snap` dep, then each\n * behavior's `onMove`, each seeing the points the one before it returned.\n * Stored on `scratch.shaped`; `resolveEndpoints` reads it.\n */\nfunction shapeEndpoints(scratch: InsertScratch, modifiers: GestureContext<unknown>['modifiers']): void {\n  const resolved = resolveParams(scratch.opts?.params);\n  const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n  const gctx = scratch.gestureCtx;\n  let start = gctx.origin.get(GESTURE_KEY) as InsertPoint;\n  let current = { x: scratch.currentX, y: scratch.currentY };\n  if (kind === 'line' && scratch.shiftHeld) {\n    current = snapTo15Degrees({ x: scratch.startX, y: scratch.startY }, current);\n  }\n  current = scratch.snap(current);\n\n  if (scratch.behaviors.length > 0) {\n    gctx.modifiers = { ...modifiers };\n    gctx.pointer = { worldX: scratch.currentX, worldY: scratch.currentY, clientX: 0, clientY: 0 };\n    gctx.view = scratch.readView();\n    gctx.plane = scratch.readPlane();\n    gctx.current.set(GESTURE_KEY, current);\n    const mode = effectiveOriginMode(resolved?.['originMode'], scratch.altHeld);\n    for (const b of scratch.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  scratch.shaped = { start, current };\n}\n\n/**\n * The effective endpoints: `scratch.shaped`, plus — for the `line` kind\n * only — the alt/center reading as \"mirror the start around the pointer\"\n * rather than \"grow a symmetric AABB\".\n *\n * Every geometry consumer (bounds, extras, preview) goes through this, so\n * the live overlay and the committed node can't disagree.\n */\nfunction resolveEndpoints(\n  scratch: InsertScratch,\n  kind: string,\n  mode: 'corner' | 'center',\n): { startX: number; startY: number; currentX: number; currentY: number } {\n  let { start } = scratch.shaped;\n  const { current } = scratch.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\n  return { startX: start.x, startY: start.y, currentX: current.x, currentY: current.y };\n}\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, ... }`. */\nfunction 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// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `insert` Action.\n *\n * Requires dep-schema entry: `insert`.\n * Node `kind` is read from `opts.params.kind`; defaults to `'rect'` when absent.\n *\n * @see useInsert — the React hook this descriptor mirrors for the simple case.\n */\nexport const insertAction: Action & { requires: string[] } = inPlane({\n  id: 'insert',\n  label: 'Insert',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  requires: ['insert', 'selection', 'snap', 'textEdit', 'scene', 'applyOps', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const dep = ctx.deps.insert as InsertDep | undefined;\n      if (!dep) return {};\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 as SelectionApi | undefined;\n      if (selection && selection.get().length > 0) {\n        selection.clear();\n      }\n\n      const snapDep = ctx.deps.snap as SnapDep | undefined;\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 readView = gestureViewReader(ctx.deps);\n      const readPlane = gesturePlaneReader(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: { worldX: ctx.world.x, worldY: ctx.world.y, clientX: 0, clientY: 0 },\n        view: readView(),\n        plane: readPlane(),\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 scratch: InsertScratch = {\n        dep,\n        textEdit: ctx.deps.textEdit as TextEditDep | undefined,\n        snap,\n        opts,\n        behaviors,\n        gestureCtx,\n        readView,\n        readPlane,\n        shaped: { start: startPoint, current: startPoint },\n        scene: ctx.deps.scene as Scene<unknown, string, unknown> | undefined,\n        applyOps: ctx.deps.applyOps as ((ops: Op[], label: string) => void) | undefined,\n        selection,\n        startX: ctx.world.x,\n        startY: ctx.world.y,\n        currentX: ctx.world.x,\n        currentY: ctx.world.y,\n        points: ctx.drag?.points ?? null,\n        altHeld: ctx.modifiers.alt,\n        shiftHeld: ctx.modifiers.shift,\n        open: true,\n        userRotation: 0,\n      };\n      liveInsertScratch = scratch;\n\n      return {\n        kind: 'insert',\n        onMove(moveCtx: InvocationCtx): void {\n          scratch.currentX = moveCtx.world.x;\n          scratch.currentY = moveCtx.world.y;\n          scratch.shiftHeld = moveCtx.modifiers.shift;\n          // Track live Alt state for the corner ⇄ center toggle. Each\n          // pointermove carries fresh modifier state from the dispatcher;\n          // releasing / pressing Alt mid-drag flips the bounds mode on\n          // the next move tick (true modifier-only events don't fire\n          // without a cursor change).\n          scratch.altHeld = moveCtx.modifiers.alt;\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          if (moveCtx.drag?.points) scratch.points = moveCtx.drag.points;\n          shapeEndpoints(scratch, moveCtx.modifiers);\n        },\n        overlay(): OngoingOverlay | null {\n          if (!scratch.open) return null;\n          // Resolve params on every overlay() so thunked params (polygon\n          // sides ticking via ArrowUp mid-drag) reflect in the live preview.\n          const resolved = resolveParams(scratch.opts?.params);\n          const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n          // Consumer-defined kinds aren't renderable by the kit overlay —\n          // skip the preview rather than emit something half-faithful.\n          if (!shapeKindInfo(kind)?.insertPreview) return null;\n          const mode = effectiveOriginMode(resolved?.['originMode'], scratch.altHeld);\n          const pts = resolveEndpoints(scratch, kind, mode);\n          const bounds = computeBounds(\n            pts.startX, pts.startY, pts.currentX, pts.currentY, mode,\n          );\n          // Derive extras with the *effective* mode so polygon/star\n          // center+radius reflect the live Alt toggle, not the binding's\n          // nominal originMode.\n          const effectiveExtras = buildExtras(\n            { ...(resolved ?? {}), originMode: mode },\n            pts.startX, pts.startY, pts.currentX, pts.currentY,\n            scratch.points,\n          );\n          applyUserRotation(effectiveExtras, scratch.userRotation);\n          return {\n            kind: 'insertPreview',\n            shape: effectiveExtras.kind as KitInsertShape,\n            bounds,\n            extras: effectiveExtras,\n            // Anchor dot at the click point — chrome that sells \"this\n            // is where the drag started.\" Useful for radial shapes\n            // (no vertex at click) and for center mode (dot marks the\n            // growth axis).\n            anchorPoint: { x: pts.startX, y: pts.startY },\n          };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          scratch.open = false;\n          if (liveInsertScratch === scratch) liveInsertScratch = null;\n          if (reason === 'cancel') {\n            runBehaviorCancel(scratch.behaviors, scratch.gestureCtx);\n            return;\n          }\n\n          const { dep: d, opts: o } = scratch;\n          const points = endCtx.drag?.points ?? scratch.points;\n\n          // Resolve params at commit time so thunked params (polygon\n          // `sides` adjusted mid-drag, etc.) see the latest tool state.\n          const resolved = resolveParams(o?.params);\n\n          if (scratch.behaviors.length > 0) {\n            const r = reduceBehaviorEnd(scratch.behaviors, scratch.gestureCtx);\n            if (r === null) return;\n            if (r !== undefined) {\n              if (scratch.scene) {\n                commitGestureOps(\n                  {\n                    scene: scratch.scene,\n                    applyOps: scratch.applyOps,\n                    adapter: defaultCommitAdapter(scratch.scene, scratch.selection?.adapterMethods),\n                  },\n                  readGestureLifecycle(resolved, 'Insert', scratch.behaviors),\n                  r,\n                );\n              }\n              return;\n            }\n          }\n\n          const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n          const mode = effectiveOriginMode(resolved?.['originMode'], scratch.altHeld);\n          const { startX, startY, currentX, currentY } = resolveEndpoints(scratch, kind, mode);\n          const bounds = computeBounds(startX, startY, currentX, currentY, mode);\n          const extras = buildExtras(\n            { ...(resolved ?? {}), originMode: mode },\n            startX, startY, currentX, currentY, points,\n          );\n          applyUserRotation(extras, scratch.userRotation);\n\n          // Sub-threshold drag — no insert. The test is kind-aware because\n          // \"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.\n          if (!isCommittableExtent(bounds, extras.kind)) return;\n\n          const id = d.commit(bounds, extras);\n\n          // A freshly dragged text box is empty, so it draws nothing and the\n          // tool's own `click on selected body → enterTextEdit` binding has\n          // nothing visible to click. Drop straight into the caret instead —\n          // which is also what every other editor does with a text tool.\n          // `textEdit` is optional: without it the box is still committed,\n          // exactly as before.\n          //\n          // Read from the scratch, not `endCtx.deps`: the dispatcher builds\n          // the deps bag once, at `start`, and passes `deps: {}` on every\n          // later pump event. Same reason the insert dep itself is stashed.\n          if (id !== null && extras.kind === 'text') {\n            scratch.textEdit?.startEdit(String(id), { caret: 0 });\n          }\n        },\n      };\n    },\n  },\n  /**\n   * Insert is always available — no selection required. Returns `true` so the\n   * dispatcher allows the action through on every drag-on-empty gesture.\n   *\n   * Fixed from the stale `ActionDisabledReason.SelectionRequired`\n   * placeholder that was silently blocking all dispatcher-routed inserts.\n   */\n  enabled: () => true as const,\n}, insertLayer);\n\n/** Whether a drag produced enough extent to be worth committing, per kind.\n *  See the call site in `onEnd` for why this isn't one uniform test. */\nfunction 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\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. */\nfunction 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\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 scratch = liveInsertScratch;\n      if (!scratch || !scratch.open) return;\n      const deltaY = (params as { deltaY?: number } | undefined)?.deltaY ?? 0;\n      if (deltaY === 0) return;\n      scratch.userRotation += deltaY * ROTATION_SENSITIVITY;\n    },\n  },\n};\n"],"mappings":"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"}

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

@@ -0,0 +1,50 @@
+import { editingLayer as e, inPlane as t } from "../planeInput.js";
+import { pathToAnchors as n } from "../../../features/paths/anchors.js";
+import { editAnchorSet as r, insertAnchorOnSegment as i, segmentAt as a } from "../../../features/paths/anchorEdits.js";
+import { ActionDisabledReason as o } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/insertPathAnchor.ts
+var s = 8, c = {
+	glyph: "penPlus",
+	fallback: "crosshair"
+};
+function l(e, t, r) {
+	let i = e?.editAnchors;
+	if (!i?.editingId) return null;
+	let o = i.getEditablePath(i.editingId);
+	if (!o || o.kind !== "polygon") return null;
+	let c = (e?.view)?.get().scale, l = a(n(o), t, r, {
+		tolerancePx: s,
+		...c ? { scale: c } : {}
+	});
+	return l ? {
+		dep: i,
+		hit: l
+	} : null;
+}
+var u = t({
+	id: "insertPathAnchor",
+	label: "Insert anchor",
+	defaultBinding: {
+		kind: "click",
+		mods: { alt: !0 }
+	},
+	cursor: c,
+	eligible: { capability: "edits-anchors" },
+	requires: ["editAnchors", "view"],
+	invoker: {
+		timing: "immediate",
+		run(e, t) {
+			let n = t?.worldX, a = t?.worldY;
+			if (typeof n != "number" || typeof a != "number") return;
+			let o = l(e, n, a);
+			if (!o) return;
+			let { dep: s, hit: c } = o, u = s.getEditablePath(s.editingId), d = -1, f = r(u, (e) => (d = i(e, c), d !== -1));
+			f && (s.applyEdit(s.editingId, f, "Insert anchor"), s.setSelectedAnchors([d]));
+		}
+	},
+	enabled: (e, t) => !e?.editAnchors?.editingId || t && !l(e, t.x, t.y) ? o.NotApplicable : !0
+}, e);
+//#endregion
+export { u as insertPathAnchorAction };
+
+//# sourceMappingURL=insertPathAnchor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"insertPathAnchor.js","names":["SEGMENT_HIT_PX","INSERT_CURSOR","segmentUnder","dep","deps","path","scale","hit","segmentAt","pathToAnchors","x","y","insertPathAnchorAction","inPlane","wx","params","wy","under","inserted","next","editAnchorSet","insertAnchorOnSegment","set","at","ActionDisabledReason","editingLayer"],"sources":["../../../../src/interactions/actions/defaults/insertPathAnchor.ts"],"sourcesContent":["/**\n * `insertPathAnchorAction` — Alt+click on a segment of the path being\n * edited inserts a new anchor there, without changing the path's shape.\n *\n * Alt+click because plain click already belongs to `selectAnchorAction`\n * (select an anchor, or clear the anchor selection on a miss), and\n * Alt+Shift+click to `cutPathAtAnchorAction`.\n *\n * The segment test lives in `enabled`, which the dispatcher hands the\n * event's world point: a click off every segment (or on an anchor) reports\n * not-applicable, so the dispatcher falls through to whatever else the\n * click could mean, and the hover pump shows `cursor` only where a click\n * would insert.\n */\n\nimport type { Action, ActionDeps, ImmediateInvoker } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { EditAnchorsDep, ViewApi } from '../depSchema';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { pathToAnchors } from 'features/paths/anchors';\nimport {\n  editAnchorSet,\n  insertAnchorOnSegment,\n  segmentAt,\n  type AnchorSet,\n  type SegmentHit,\n} from 'features/paths/anchorEdits';\nimport { inPlane, editingLayer } from '../planeInput';\n\n/** Screen-px reach of a segment, and the radius around each anchor that\n *  stays the anchor's. Matches the path-anchor affordance's default hit\n *  radius, so the two regions meet without a gap. */\nconst SEGMENT_HIT_PX = 8;\n\nconst INSERT_CURSOR: CursorSpec = { glyph: 'penPlus', fallback: 'crosshair' };\n\nfunction segmentUnder(\n  deps: ActionDeps | undefined,\n  x: number,\n  y: number,\n): { dep: EditAnchorsDep; hit: SegmentHit } | null {\n  const dep = deps?.editAnchors as EditAnchorsDep | undefined;\n  if (!dep?.editingId) return null;\n  const path = dep.getEditablePath(dep.editingId) as PolygonPath | null | undefined;\n  if (!path || path.kind !== 'polygon') return null;\n  const scale = (deps?.view as ViewApi | undefined)?.get().scale;\n  const hit = segmentAt(pathToAnchors(path) as AnchorSet, x, y, {\n    tolerancePx: SEGMENT_HIT_PX,\n    ...(scale ? { scale } : {}),\n  });\n  return hit ? { dep, hit } : null;\n}\n\nexport const insertPathAnchorAction: Action & { requires: string[] } = inPlane({\n  id: 'insertPathAnchor',\n  label: 'Insert anchor',\n  defaultBinding: { kind: 'click', mods: { alt: true } },\n  cursor: INSERT_CURSOR,\n  eligible: { capability: 'edits-anchors' },\n  requires: ['editAnchors', 'view'],\n  invoker: {\n    timing: 'immediate',\n    run(deps, params) {\n      const wx = params?.worldX as number | undefined;\n      const wy = params?.worldY as number | undefined;\n      if (typeof wx !== 'number' || typeof wy !== 'number') return;\n      const under = segmentUnder(deps, wx, wy);\n      if (!under) return;\n      const { dep, hit } = under;\n      const path = dep.getEditablePath(dep.editingId) as PolygonPath;\n      let inserted = -1;\n      const next = editAnchorSet(path, (set) => {\n        inserted = insertAnchorOnSegment(set, hit);\n        return inserted !== -1;\n      });\n      if (!next) return;\n      dep.applyEdit(dep.editingId, next, 'Insert anchor');\n      dep.setSelectedAnchors([inserted]);\n    },\n  } as ImmediateInvoker,\n  enabled: (deps, at) => {\n    const dep = deps?.editAnchors as EditAnchorsDep | undefined;\n    if (!dep?.editingId) return ActionDisabledReason.NotApplicable;\n    if (at && !segmentUnder(deps, at.x, at.y)) return ActionDisabledReason.NotApplicable;\n    return true;\n  },\n}, editingLayer);\n"],"mappings":";;;;;AAiCA,IAAMA,IAAiB,GAEjBC,IAA4B;CAAE,OAAO;CAAW,UAAU;AAAY;AAE5E,SAASC,EACP,GACA,GACA,GACiD;CACjD,IAAMC,IAAMC,GAAM;CAClB,IAAI,CAACD,GAAK,WAAW,OAAO;CAC5B,IAAME,IAAOF,EAAI,gBAAgBA,EAAI,SAAS;CAC9C,IAAI,CAACE,KAAQA,EAAK,SAAS,WAAW,OAAO;CAC7C,IAAMC,KAASF,GAAM,KAAA,EAA8B,IAAI,CAAC,CAAC,OACnDG,IAAMC,EAAUC,EAAcJ,CAAI,GAAgBK,GAAGC,GAAG;EAC5D,aAAaX;EACb,GAAIM,IAAQ,EAAE,SAAM,IAAI,CAAC;CAC3B,CAAC;CACD,OAAOC,IAAM;EAAE;EAAK;CAAI,IAAI;AAC9B;AAEA,IAAaK,IAA0DC,EAAQ;CAC7E,IAAI;CACJ,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAS,MAAM,EAAE,KAAK,GAAK;CAAE;CACrD,QAAQZ;CACR,UAAU,EAAE,YAAY,gBAAgB;CACxC,UAAU,CAAC,eAAe,MAAM;CAChC,SAAS;EACP,QAAQ;EACR,IAAI,GAAM,GAAQ;GAChB,IAAMa,IAAKC,GAAQ,QACbC,IAAKD,GAAQ;GACnB,IAAI,OAAOD,KAAO,YAAY,OAAOE,KAAO,UAAU;GACtD,IAAMC,IAAQf,EAAaE,GAAMU,GAAIE,CAAE;GACvC,IAAI,CAACC,GAAO;GACZ,IAAM,EAAE,QAAK,WAAQA,GACfZ,IAAOF,EAAI,gBAAgBA,EAAI,SAAS,GAC1Ce,IAAW,IACTC,IAAOC,EAAcf,IAAO,OAChC,IAAWgB,EAAsBC,GAAKf,CAAG,GAClCW,MAAa,GACrB;GACD,AAAKC,MACLhB,EAAI,UAAUA,EAAI,WAAWgB,GAAM,eAAe,GAClDhB,EAAI,mBAAmB,CAACe,CAAQ,CAAC;EACnC;CACF;CACA,UAAU,GAAM,MAEV,CADQd,GAAM,aACR,aACNmB,KAAM,CAACrB,EAAaE,GAAMmB,EAAG,GAAGA,EAAG,CAAC,IAAUC,EAAqB,gBAChE;AAEX,GAAGC,CAAY"}

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

@@ -0,0 +1,156 @@
+import { gestureViewReader as e } from "../../gestures/shared/screenTolerance.js";
+import { reduceBehaviorEnd as t, runBehaviorCancel as n } from "../gestureLifecycle.js";
+import { applyOpsTo as r } from "../../../core/applyOps.js";
+import { LASSO_VERTICES as i } from "../lasso-select/behaviors/selectFromLasso.js";
+import { resolveParams as a, setScratch as o } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/lassoSelect.ts
+function s(e) {
+	if (e.length === 0) return null;
+	let t = e[0].x, n = e[0].y, r = e[0].x, i = e[0].y;
+	for (let a of e) a.x < t && (t = a.x), a.y < n && (n = a.y), a.x > r && (r = a.x), a.y > i && (i = a.y);
+	return {
+		x: t,
+		y: n,
+		width: r - t,
+		height: i - n
+	};
+}
+function c(e, t, n, r) {
+	if (e.hitTestLasso) return e.hitTestLasso(t, n, r);
+	let i = s(t);
+	return i ? e.hitTestArea(i, r) : [];
+}
+function l(e, t) {
+	let n = {
+		getSelection: () => e.getSelection(),
+		setSelection: (t) => e.setSelection(t),
+		hitTestArea: (n) => e.hitTestArea(n, t),
+		hitTestLasso: (n, r) => c(e, n, r, t),
+		applyOps: (e) => r(n, e)
+	};
+	return n;
+}
+var u = 2, d = {
+	id: "lassoSelect",
+	label: "Lasso Select",
+	eligible: { capability: "creates-selection" },
+	requires: ["lassoSelect", "view"],
+	invoker: {
+		timing: "ongoing",
+		start(r, s) {
+			let d = r.deps.lassoSelect;
+			if (!d) return {};
+			let f = a(s?.params), p = r.deps.view, m = [{
+				x: r.world.x,
+				y: r.world.y
+			}], h = s?.behaviors ?? [], g = null, _ = e(r.deps);
+			if (h.length > 0) {
+				let e = {
+					worldX: r.world.x,
+					worldY: r.world.y,
+					shiftHeld: r.modifiers.shift
+				};
+				g = {
+					draggedIds: ["gesture"],
+					origin: /* @__PURE__ */ new Map([["gesture", e]]),
+					current: /* @__PURE__ */ new Map([["gesture", { ...e }]]),
+					snap: null,
+					modifiers: { ...r.modifiers },
+					pointer: {
+						worldX: r.world.x,
+						worldY: r.world.y,
+						clientX: 0,
+						clientY: 0
+					},
+					view: _(),
+					adapter: l(d, p),
+					scratch: {}
+				}, o(g.scratch, i, m);
+				for (let e of h) e.onStart?.(g);
+			}
+			let v = {
+				dep: d,
+				mode: f?.mode ?? "intersect",
+				minVertexSpacing: f?.minVertexSpacing ?? u,
+				view: p,
+				vertices: m,
+				shiftHeld: r.modifiers.shift,
+				currentX: r.world.x,
+				currentY: r.world.y,
+				open: !0,
+				behaviors: h,
+				gesture: g
+			};
+			return {
+				kind: "lasso",
+				onMove(e) {
+					let { x: t, y: n } = e.world;
+					v.currentX = t, v.currentY = n;
+					let r = v.vertices[v.vertices.length - 1], i = t - r.x, a = n - r.y, o = v.minVertexSpacing;
+					i * i + a * a >= o * o && v.vertices.push({
+						x: t,
+						y: n
+					});
+					let s = v.gesture;
+					if (s) {
+						s.modifiers = { ...e.modifiers }, s.pointer = {
+							worldX: t,
+							worldY: n,
+							clientX: 0,
+							clientY: 0
+						}, s.view = _(), s.current.set("gesture", {
+							worldX: t,
+							worldY: n,
+							shiftHeld: v.shiftHeld
+						});
+						let r = {
+							vertices: v.vertices,
+							shiftHeld: v.shiftHeld
+						};
+						for (let e of v.behaviors) e.onMove?.(s, r);
+					}
+				},
+				overlay() {
+					return v.open ? {
+						kind: "lasso",
+						vertices: v.vertices,
+						current: {
+							x: v.currentX,
+							y: v.currentY
+						},
+						shiftHeld: v.shiftHeld
+					} : null;
+				},
+				onEnd(e, r) {
+					if (v.open = !1, r === "cancel") {
+						v.gesture && n(v.behaviors, v.gesture);
+						return;
+					}
+					let { dep: i, mode: a, view: o, vertices: s, shiftHeld: l, gesture: u } = v;
+					if (u) {
+						let e = t(v.behaviors, u);
+						if (e !== void 0) {
+							e !== null && u.adapter.applyOps(e);
+							return;
+						}
+					}
+					if (s.length < 3) {
+						l || i.setSelection([]);
+						return;
+					}
+					let d = c(i, s, a, o);
+					if (l) {
+						let e = [...i.getSelection()];
+						for (let t of d) e.includes(t) || e.push(t);
+						i.setSelection(e);
+					} else i.setSelection(d);
+				}
+			};
+		}
+	},
+	enabled: () => !0
+};
+//#endregion
+export { d as lassoSelectAction };
+
+//# sourceMappingURL=lassoSelect.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lassoSelect.js","names":["polygonAABB","pts","minX","minY","maxX","maxY","p","hitTestPolygon","dep","vertices","mode","view","aabb","behaviorAdapter","adapter","ids","rect","polygon","applyOpsTo","ops","DEFAULT_MIN_VERTEX_SPACING","lassoSelectAction","ctx","params","resolveParams","opts","behaviors","gesture","readView","gestureViewReader","pose","setScratch","LASSO_VERTICES","b","scratch","moveCtx","x","y","last","dx","dy","min","g","proposed","reason","runBehaviorCancel","d","r","reduceBehaviorEnd","shiftHeld","hits","merged","id"],"sources":["../../../../src/interactions/actions/defaults/lassoSelect.ts"],"sourcesContent":["/**\n * `lassoSelectAction` — ongoing Action descriptor for polygon lasso selection.\n *\n * ## Status: REAL\n *\n * Implements lasso-select via the full pointermove stream (accumulated in\n * `InvocationCtx.drag.points` by the dispatcher extension):\n *   - `start`: initializes vertex list from the drag-start world point.\n *   - `onMove`: appends the current world point, skipping one closer than\n *     the binding's `params.minVertexSpacing` (default 2 world-px) to the\n *     last vertex.\n *   - `onEnd('commit')`: performs hit-testing against the accumulated polygon.\n *     Uses `dep.hitTestLasso(polygon, mode)` when available — `mode` from the\n *     binding's `params.mode`, default `'intersect'` — otherwise falls back to\n *     the polygon's AABB via `dep.hitTestArea(bounds)`.\n *     Extends selection with shift, replaces otherwise.\n *   - `onEnd('cancel')`: no-op.\n *\n * ## Behaviors\n *\n * `opts.behaviors` (`LassoSelectBehavior[]`) run over a `GestureContext`\n * whose `origin.get('gesture')` is the start pose, whose scratch holds the\n * vertices under `LASSO_VERTICES`, and whose adapter answers selection and\n * hit-testing from the `lassoSelect` dep. `onEnd` is first-non-undefined-wins:\n * `Op[]` is applied in place of the default selection, `null` aborts, and\n * all-`undefined` falls through to it.\n *\n * ## Dep\n *\n * Requires `lassoSelect` dep from DepSchema:\n *   `{ hitTestLasso?(...), hitTestArea(...), getSelection(), setSelection(ids) }`\n *\n * ## What this does NOT wire\n *\n * - Committed history — always transient (no undo entry); a behavior's ops\n *   are applied the same way.\n * - Debug sink recording.\n */\n\nimport { gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport { resolveParams, setScratch, type Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, OngoingOverlay, Point2 } from '@weasel-js/routing';\nimport type { LassoSelectDep, ViewApi } from '../depSchema';\nimport type { LassoHitMode, LassoSelectAdapter } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport { applyOpsTo } from 'core/applyOps';\nimport type { GestureContext, LassoSelectBehavior, LassoSelectPose } from '../../gestures/types';\nimport { LASSO_VERTICES } from '../lasso-select/behaviors/selectFromLasso';\nimport { reduceBehaviorEnd, runBehaviorCancel } from '../gestureLifecycle';\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/** Compute AABB of a polygon (for fallback hit-test when hitTestLasso is absent). */\nfunction polygonAABB(\n  pts: Point2[],\n): { x: number; y: number; width: number; height: number } | null {\n  if (pts.length === 0) return null;\n  let minX = pts[0].x, minY = pts[0].y, maxX = pts[0].x, maxY = pts[0].y;\n  for (const p of pts) {\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    if (p.x > maxX) maxX = p.x;\n    if (p.y > maxY) maxY = p.y;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/** The dep's polygon test, or its rect test over the polygon's AABB when it\n *  has none. What both the default commit and a behavior's adapter ask. */\nfunction hitTestPolygon(\n  dep: LassoSelectDep,\n  vertices: ReadonlyArray<Point2>,\n  mode: LassoHitMode,\n  view: ViewApi | undefined,\n): string[] {\n  if (dep.hitTestLasso) return dep.hitTestLasso(vertices, mode, view);\n  const aabb = polygonAABB(vertices as Point2[]);\n  return aabb ? dep.hitTestArea(aabb, view) : [];\n}\n\n/** The adapter a behavior sees: selection and hit-testing from the dep,\n *  scoped to the view the lasso started in. */\nfunction behaviorAdapter(dep: LassoSelectDep, view: ViewApi | undefined): LassoSelectAdapter {\n  const adapter: LassoSelectAdapter = {\n    getSelection: () => dep.getSelection(),\n    setSelection: (ids) => dep.setSelection(ids),\n    hitTestArea: (rect) => dep.hitTestArea(rect, view),\n    hitTestLasso: (polygon, mode) => hitTestPolygon(dep, polygon, mode, view),\n    applyOps: (ops: Op[]) => applyOpsTo(adapter, ops),\n  };\n  return adapter;\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_MIN_VERTEX_SPACING = 2; // world-px\n\ninterface LassoScratch {\n  dep: LassoSelectDep;\n  mode: LassoHitMode;\n  minVertexSpacing: number;\n  /** The view the lasso started in: what it does not paint is not taken. */\n  view: ViewApi | undefined;\n  vertices: Point2[];\n  shiftHeld: boolean;\n  /** Current pointer position — paint the live \"close-line\" from the last\n   *  vertex back to the start while the gesture is open. Tracked separately\n   *  from `vertices` because we throttle vertex insertion. */\n  currentX: number;\n  currentY: number;\n  /** Cleared by `onEnd` so post-commit `overlay()` returns null. */\n  open: boolean;\n  behaviors: LassoSelectBehavior[];\n  /** Built only when there are behaviors to hand it to. */\n  gesture: GestureContext<LassoSelectPose> | null;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `lassoSelect` Action.\n *\n * Requires dep-schema entry: `lassoSelect`.\n *\n * The invoker accumulates pointermove vertices via `InvocationCtx.drag.points`\n * (dispatcher extension) and commits a polygon hit-test at drag end.\n *\n * @see useLassoSelect — the React hook this descriptor mirrors for the default case.\n */\nexport const lassoSelectAction: Action & { requires: string[] } = {\n  id: 'lassoSelect',\n  label: 'Lasso Select',\n  eligible: { capability: 'creates-selection' },\n  requires: ['lassoSelect', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts): OngoingHandle {\n      const dep = ctx.deps.lassoSelect as LassoSelectDep | undefined;\n      if (!dep) return {};\n\n      const params = resolveParams(opts?.params) as\n        { mode?: LassoHitMode; minVertexSpacing?: number } | undefined;\n      const view = ctx.deps.view as ViewApi | undefined;\n      const vertices: Point2[] = [{ x: ctx.world.x, y: ctx.world.y }];\n      const behaviors = (opts?.behaviors ?? []) as LassoSelectBehavior[];\n      let gesture: GestureContext<LassoSelectPose> | null = null;\n      const readView = gestureViewReader(ctx.deps);\n      if (behaviors.length > 0) {\n        const pose: LassoSelectPose = {\n          worldX: ctx.world.x, worldY: ctx.world.y, shiftHeld: ctx.modifiers.shift,\n        };\n        gesture = {\n          draggedIds: ['gesture'],\n          origin: new Map([['gesture', pose]]),\n          current: new Map([['gesture', { ...pose }]]),\n          snap: null,\n          modifiers: { ...ctx.modifiers },\n          pointer: { worldX: ctx.world.x, worldY: ctx.world.y, clientX: 0, clientY: 0 },\n          view: readView(),\n          adapter: behaviorAdapter(dep, view) as unknown as GestureContext<LassoSelectPose>['adapter'],\n          scratch: {},\n        };\n        // The live array, so a behavior reads every vertex added since.\n        setScratch(gesture.scratch, LASSO_VERTICES, vertices);\n        for (const b of behaviors) b.onStart?.(gesture);\n      }\n      const scratch: LassoScratch = {\n        dep,\n        mode: params?.mode ?? 'intersect',\n        minVertexSpacing: params?.minVertexSpacing ?? DEFAULT_MIN_VERTEX_SPACING,\n        view,\n        vertices,\n        shiftHeld: ctx.modifiers.shift,\n        currentX: ctx.world.x,\n        currentY: ctx.world.y,\n        open: true,\n        behaviors,\n        gesture,\n      };\n\n      return {\n        kind: 'lasso',\n        onMove(moveCtx: InvocationCtx): void {\n          const { x, y } = moveCtx.world;\n          scratch.currentX = x;\n          scratch.currentY = y;\n          const last = scratch.vertices[scratch.vertices.length - 1];\n          const dx = x - last.x;\n          const dy = y - last.y;\n          const min = scratch.minVertexSpacing;\n          if (dx * dx + dy * dy >= min * min) {\n            scratch.vertices.push({ x, y });\n          }\n          const g = scratch.gesture;\n          if (g) {\n            g.modifiers = { ...moveCtx.modifiers };\n            g.pointer = { worldX: x, worldY: y, clientX: 0, clientY: 0 };\n            g.view = readView();\n            g.current.set('gesture', { worldX: x, worldY: y, shiftHeld: scratch.shiftHeld });\n            const proposed = { vertices: scratch.vertices, shiftHeld: scratch.shiftHeld };\n            for (const b of scratch.behaviors) b.onMove?.(g, proposed);\n          }\n        },\n        overlay(): OngoingOverlay | null {\n          if (!scratch.open) return null;\n          return {\n            kind: 'lasso',\n            vertices: scratch.vertices,\n            current: { x: scratch.currentX, y: scratch.currentY },\n            shiftHeld: scratch.shiftHeld,\n          };\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          scratch.open = false;\n          if (reason === 'cancel') {\n            if (scratch.gesture) runBehaviorCancel(scratch.behaviors, scratch.gesture);\n            return;\n          }\n\n          const { dep: d, mode, view, vertices, shiftHeld, gesture: g } = scratch;\n\n          if (g) {\n            const r = reduceBehaviorEnd(scratch.behaviors, g);\n            if (r !== undefined) {\n              if (r !== null) (g.adapter as unknown as LassoSelectAdapter).applyOps!(r);\n              return;\n            }\n          }\n\n          // Need at least 3 vertices for a meaningful polygon; otherwise no-op.\n          if (vertices.length < 3) {\n            if (!shiftHeld) d.setSelection([]);\n            return;\n          }\n\n          const hits = hitTestPolygon(d, vertices, mode, view);\n\n          if (shiftHeld) {\n            // Extend: merge current + hits (deduplicated).\n            const current = d.getSelection();\n            const merged = [...current];\n            for (const id of hits) {\n              if (!merged.includes(id)) merged.push(id);\n            }\n            d.setSelection(merged);\n          } else {\n            d.setSelection(hits);\n          }\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n"],"mappings":"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"}