@weasel-js/core 1.9.4 → 1.10.1

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

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

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

@@ -0,0 +1,34 @@
+import { applyUserRotation as e, buildExtras as t } from "./extras.js";
+import { computeBounds as n, effectiveOriginMode as r } from "./geometry.js";
+//#region src/interactions/actions/insert/shape.ts
+function i(e) {
+	return e?.kind ?? "rect";
+}
+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
+	};
+}
+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
+	};
+}
+function s(e, t) {
+	return t === "pencil" ? !0 : t === "line" ? e.width !== 0 || e.height !== 0 : e.width !== 0 && e.height !== 0;
+}
+//#endregion
+export { i as insertKind, o as insertShape, s as isCommittableExtent };
+
+//# sourceMappingURL=shape.js.map

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

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

package/dist/interactions/actions/lasso-select/action.js

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

package/dist/interactions/actions/lasso-select/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.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","pointerStateOf","setScratch","LASSO_VERTICES","b","scratch","moveCtx","x","y","last","dx","dy","min","g","proposed","committed","endLasso","reason","runBehaviorSettled","runBehaviorCancel","d","r","reduceBehaviorEnd","shiftHeld","hits","selectionFromHits"],"sources":["../../../../src/interactions/actions/lasso-select/action.ts"],"sourcesContent":["/**\n * `lassoSelectAction` — ongoing Action descriptor for polygon lasso selection.\n *\n * A move adds a vertex unless it is closer than the binding's\n * `params.minVertexSpacing` (default 2 world-px) to the last one. The commit\n * hit-tests the polygon with `dep.hitTestLasso(polygon, mode)` — `mode` from\n * the binding's `params.mode`, default `'intersect'` — falling back to the\n * polygon's AABB via `dep.hitTestArea(bounds)`. Shift extends the selection.\n * Always transient: no undo entry.\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. A behavior's ops are applied\n * transiently too.\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 { pointerStateOf } from '../pointerState';\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 './behaviors/selectFromLasso';\nimport { reduceBehaviorEnd, runBehaviorCancel, runBehaviorSettled } from '../gestureLifecycle';\nimport { selectionFromHits } from '../hitSelection';\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\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 * @experimental\n * Static descriptor for the `lassoSelect` Action.\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;\n      if (!dep) return {};\n\n      const params = resolveParams(opts?.params) as\n        { mode?: LassoHitMode; minVertexSpacing?: number } | undefined;\n      const view = ctx.deps.view;\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: pointerStateOf(ctx.world, ctx),\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 = pointerStateOf(moveCtx.world, moveCtx);\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          let committed = false;\n          try {\n            committed = endLasso(scratch, reason);\n          } finally {\n            if (scratch.gesture) runBehaviorSettled(scratch.behaviors, scratch.gesture, committed);\n          }\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n\n/** Close the lasso. Returns whether it committed: a behavior's ops were\n *  applied, or the lasso set the selection. */\nfunction endLasso(scratch: LassoScratch, reason: 'commit' | 'cancel'): boolean {\n  scratch.open = false;\n  if (reason === 'cancel') {\n    if (scratch.gesture) runBehaviorCancel(scratch.behaviors, scratch.gesture);\n    return false;\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 r !== null;\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 !shiftHeld;\n  }\n\n  const hits = hitTestPolygon(d, vertices, mode, view);\n\n  d.setSelection(selectionFromHits(d.getSelection(), hits, shiftHeld));\n  return true;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,91 @@
+import { closeGesture as e, runBehaviorCancel as t } from "../gestureLifecycle.js";
+import { inPlane as n, selectionLayer as r } from "../planeInput.js";
+import { beginMove as i } from "./session.js";
+import { nextFrame as a } from "./frame.js";
+import { commitMove as o } from "./commit/index.js";
+import { recordTransform as s } from "../transform-again/memory.js";
+import { pastDragThreshold as c } from "@weasel-js/routing";
+//#region src/interactions/actions/move/action.ts
+var l = n({
+	id: "move",
+	label: "Move",
+	activeCursor: "move",
+	defaultBinding: {
+		kind: "drag",
+		target: "selected-body"
+	},
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"poseDescriptor",
+		"layout",
+		"applyOps",
+		"geometryProjection",
+		"nodeAtPoint",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(n, r) {
+			let l = {
+				delta: {
+					dx: 0,
+					dy: 0
+				},
+				previews: /* @__PURE__ */ new Map(),
+				opaque: /* @__PURE__ */ new Set()
+			}, u = i(n, r, () => l);
+			if (!u) return {};
+			let { session: d, readers: f } = u, p = [...n.deps.selection?.get() ?? []], m = d.scene.overrides.hold(), h = null;
+			return {
+				kind: "move",
+				onMove(e) {
+					if (e.drag) {
+						if (!h) {
+							let t = e.drag.screenDelta;
+							if (t && !c({
+								clientX: 0,
+								clientY: 0
+							}, {
+								clientX: t.x,
+								clientY: t.y
+							}, d.dragThresholdPx)) return;
+							d.lifecycle.start(d.ids);
+						}
+						h = e.world, l = a(d, f, e), m.set(l.previews);
+					}
+				},
+				onEnd(n, r) {
+					let i = !1;
+					try {
+						r === "commit" && h ? (i = o({
+							session: d,
+							delta: l.delta,
+							at: n.drag ? n.world : h
+						}), i && s(d.scene, {
+							kind: "translate",
+							...l.delta
+						}, p)) : t(d.behaviors, d.gestureCtx);
+					} finally {
+						e({
+							hold: m,
+							previews: l.previews,
+							behaviors: d.behaviors,
+							ctx: d.gestureCtx,
+							lifecycle: d.lifecycle
+						}, i);
+					}
+				},
+				previewIds: () => l.previews.keys(),
+				previewPose: (e) => l.previews.get(e) ?? null,
+				previewOpaqueIds: () => l.opaque.size === 0 ? null : l.opaque
+			};
+		}
+	},
+	enabled: () => !0
+}, r);
+//#endregion
+export { l as moveAction };
+
+//# sourceMappingURL=action.js.map

package/dist/interactions/actions/move/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["moveAction","inPlane","frame","begun","beginMove","ctx","opts","subject","hold","session","engaged","moveCtx","s","pastDragThreshold","nextFrame","readers","committed","reason","commitMove","endCtx","recordTransform","runBehaviorCancel","id","selectionLayer"],"sources":["../../../../src/interactions/actions/move/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts } from '@weasel-js/routing';\nimport { pastDragThreshold } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { closeGesture, runBehaviorCancel } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { beginMove, type MoveFrame, type ReparentOnDrop } from './session';\nimport { nextFrame } from './frame';\nimport { commitMove } from './commit';\nimport { recordTransform } from '../transform-again/memory';\nexport type { ReparentOnDrop };\n\n/**\n * @experimental\n * Drag-translates the selection.\n *\n * Each frame's poses go to the scene's ephemeral override table, not the\n * document: `Scene.setPose` records an undo entry per call, and the overrides\n * are what let a node deriving its geometry from a dragged one follow the\n * drag. Release commits one batch — at most one undo entry, none when the\n * binding's params make it transient — and cancel drops the overrides.\n *\n * Behaviors from the binding's `opts.behaviors` fold into each frame; on\n * release the first non-`undefined` answer wins (`Op[]` commits, `null`\n * aborts). `beginMove` appends the action's own two: a layout drop and\n * reparent-on-drop.\n */\nexport const moveAction: Action & { requires: string[] } = inPlane({\n  id: 'move',\n  label: 'Move',\n  // No hover `cursor`: pointing at a node shouldn't preemptively promise a move.\n  activeCursor: 'move',\n  // Ambient default targets `selected-body`, not a bare `{ kind: 'drag' }`,\n  // which catches every drag in ambient scope and bleeds the move into\n  // drawing-tool gestures wherever the higher-priority active match falls\n  // through.\n  defaultBinding: { kind: 'drag', target: 'selected-body' },\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'poseDescriptor', 'layout', 'applyOps', 'geometryProjection', 'nodeAtPoint', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      let frame: MoveFrame = { delta: { dx: 0, dy: 0 }, previews: new Map(), opaque: new Set() };\n      const begun = beginMove(ctx, opts, () => frame);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      const subject = [...(ctx.deps.selection?.get() ?? [])] as string[];\n      const hold = session.scene.overrides.hold();\n      // Where the last move put the pointer, once the drag has passed its\n      // threshold; null until then.\n      let engaged: { x: number; y: number } | null = null;\n      return {\n        kind: 'move',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          if (!engaged) {\n            const s = moveCtx.drag.screenDelta;\n            if (s && !pastDragThreshold({ clientX: 0, clientY: 0 }, { clientX: s.x, clientY: s.y }, session.dragThresholdPx)) return;\n            session.lifecycle.start(session.ids as unknown as string[]);\n          }\n          engaged = moveCtx.world;\n          frame = nextFrame(session, readers, moveCtx);\n          hold.set(frame.previews);\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            // A press that never traveled `dragThresholdPx` was never a move:\n            // its behaviors started, so they are canceled, not asked to commit.\n            if (reason === 'commit' && engaged) {\n              committed = commitMove({\n                session,\n                delta: frame.delta,\n                at: endCtx.drag ? endCtx.world : engaged,\n              });\n              if (committed) recordTransform(session.scene, { kind: 'translate', ...frame.delta }, subject);\n            } else runBehaviorCancel(session.behaviors, session.gestureCtx);\n          } finally {\n            // After the commit, so no frame can paint the pre-drag pose between\n            // the override going away and the document catching up.\n            closeGesture({ hold, previews: frame.previews, behaviors: session.behaviors, ctx: session.gestureCtx, lifecycle: session.lifecycle }, committed);\n          }\n        },\n        previewIds: () => frame.previews.keys(),\n        previewPose: (id: string) => frame.previews.get(id as NodeId) ?? null,\n        previewOpaqueIds: () => (frame.opaque.size === 0 ? null : frame.opaque),\n      };\n    },\n  },\n  /**\n   * Always enabled: the dispatcher treats anything `!== true` as \"fall\n   * through to the next-best match\", so a disabled reason here loses every\n   * drag-on-selected-body to a lower-specificity binding (a shape tool's\n   * insert drag).\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;;;AA2BA,IAAaA,IAA8CC,EAAQ;CACjE,IAAI;CACJ,OAAO;CAEP,cAAc;CAKd,gBAAgB;EAAE,MAAM;EAAQ,QAAQ;CAAgB;CACxD,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAkB;EAAU;EAAY;EAAsB;EAAe;CAAM;CACpH,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAIC,IAAmB;IAAE,OAAO;KAAE,IAAI;KAAG,IAAI;IAAE;IAAG,0BAAU,IAAI,IAAI;IAAG,wBAAQ,IAAI,IAAI;GAAE,GACnFC,IAAQC,EAAUC,GAAKC,SAAYJ,CAAK;GAC9C,IAAI,CAACC,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACvBI,IAAU,CAAC,GAAIF,EAAI,KAAK,WAAW,IAAI,KAAK,CAAC,CAAE,GAC/CG,IAAOC,EAAQ,MAAM,UAAU,KAAK,GAGtCC,IAA2C;GAC/C,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAKC,EAAQ,MACb;UAAI,CAACD,GAAS;OACZ,IAAME,IAAID,EAAQ,KAAK;OACvB,IAAIC,KAAK,CAACC,EAAkB;QAAE,SAAS;QAAG,SAAS;OAAE,GAAG;QAAE,SAASD,EAAE;QAAG,SAASA,EAAE;OAAE,GAAGH,EAAQ,eAAe,GAAG;OAClH,EAAQ,UAAU,MAAMA,EAAQ,GAA0B;MAC5D;MAGA,AAFA,IAAUE,EAAQ,OAClB,IAAQG,EAAUL,GAASM,GAASJ,CAAO,GAC3CH,EAAK,IAAIN,EAAM,QAAQ;KAHvB;IAIF;IACA,MAAM,GAAuB,GAAmC;KAC9D,IAAIc,IAAY;KAChB,IAAI;MAGF,AAAIC,MAAW,YAAYP,KACzB,IAAYQ,EAAW;OACrB;OACA,OAAOhB,EAAM;OACb,IAAIiB,EAAO,OAAOA,EAAO,QAAQT;MACnC,CAAC,GACGM,KAAWI,EAAgBX,EAAQ,OAAO;OAAE,MAAM;OAAa,GAAGP,EAAM;MAAM,GAAGK,CAAO,KACvFc,EAAkBZ,EAAQ,WAAWA,EAAQ,UAAU;KAChE,UAAU;MAGR,EAAa;OAAE;OAAM,UAAUP,EAAM;OAAU,WAAWO,EAAQ;OAAW,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGO,CAAS;KACjJ;IACF;IACA,kBAAkBd,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIoB,CAAY,KAAK;IACjE,wBAAyBpB,EAAM,OAAO,SAAS,IAAI,OAAOA,EAAM;GAClE;EACF;CACF;CAOA,eAAe;AACjB,GAAGqB,CAAc"}

package/dist/interactions/actions/move/behaviors/layoutDrop.js

@@ -0,0 +1,51 @@
+import { layoutDropOps as e } from "../commit/layoutDrop.js";
+import { runDropPass as t } from "../layout/dropPass.js";
+import { layoutReleaseOps as n } from "../commit/layoutRelease.js";
+import { landReleased as r, releasedPoses as i, stepGlide as a } from "../layout/glide.js";
+//#region src/interactions/actions/move/behaviors/layoutDrop.ts
+function o(o) {
+	let s = null, c = /* @__PURE__ */ new Set(), l = null, u = () => {
+		let e = o.session();
+		e.layout?.reflow && (l = i(e, o.frame().previews));
+	};
+	return {
+		onMove(e, n) {
+			if (s = null, n.kind !== "translate") return;
+			let r = o.session();
+			s = t(r, {
+				dx: n.dx,
+				dy: n.dy
+			}, {
+				x: e.pointer.worldX,
+				y: e.pointer.worldY
+			});
+			let i = s?.pass?.reflowIds, l = r.layout?.reflow;
+			return l ? (a(l, c, s?.reflow ?? /* @__PURE__ */ new Map()), { opaque: i }) : {
+				poses: s?.reflow,
+				opaque: i
+			};
+		},
+		onEnd(t, r) {
+			if (u(), r.answered) return;
+			let i = o.session(), { delta: a } = o.frame();
+			if (a.dx === 0 && a.dy === 0) return;
+			let c = (e) => e.length > 0 ? e : null;
+			if (s?.pass) return c(e(i, s.pass));
+			let l = n(i, a, s?.dropCenter ?? null);
+			return l === void 0 ? void 0 : c(l);
+		},
+		onCancel: u,
+		onSettled() {
+			let e = o.session(), t = e.layout?.reflow;
+			if (t) {
+				for (let e of c) t.settle(e);
+				r(e, t, l ?? /* @__PURE__ */ new Map());
+			}
+			c.clear();
+		}
+	};
+}
+//#endregion
+export { o as layoutDrop };
+
+//# sourceMappingURL=layoutDrop.js.map

package/dist/interactions/actions/move/behaviors/layoutDrop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutDrop.js","names":["layoutDrop","drop","gliding","released","noteReleased","session","move","releasedPoses","proposed","runDropPass","ctx","opaque","reflow","stepGlide","end","delta","orAbort","ops","layoutDropOps","release","layoutReleaseOps","id"],"sources":["../../../../../src/interactions/actions/move/behaviors/layoutDrop.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type { BehaviorResult, MoveBehavior } from '../../../gestures/types';\nimport { layoutDropOps } from '../commit/layoutDrop';\nimport { layoutReleaseOps } from '../commit/layoutRelease';\nimport { runDropPass } from '../layout/dropPass';\nimport { landReleased, releasedPoses, stepGlide, type Released } from '../layout/glide';\nimport type { DropPass } from '../layout/types';\nimport type { MoveGesture } from '../session';\n\n/**\n * The move behavior that drops the selection into the layout container under\n * it. Each move it resolves the drop and shows the siblings making room; on\n * release it answers with the container's `commitDrop`, or, outside every\n * container, with what the source layouts' `releaseDrop` and the exits decide.\n *\n * Built by the move action for one drag, after the binding's own behaviors, and\n * only when the `layout` dep is present.\n */\nexport function layoutDrop(move: MoveGesture): MoveBehavior<unknown> {\n  // This frame's pass; reset by every move, a throwing one included.\n  let drop: DropPass | null = null;\n  const gliding = new Set<NodeId>();\n  let released: Map<NodeId, Released> | null = null;\n  // Before the commit: where each dragged id is shown as the gesture closes.\n  const noteReleased = (): void => {\n    const session = move.session();\n    if (session.layout?.reflow) released = releasedPoses(session, move.frame().previews);\n  };\n\n  return {\n    onMove(ctx, proposed): BehaviorResult<unknown> | void {\n      drop = null;\n      if (proposed.kind !== 'translate') return;\n      const session = move.session();\n      drop = runDropPass(\n        session,\n        { dx: proposed.dx, dy: proposed.dy },\n        { x: ctx.pointer.worldX, y: ctx.pointer.worldY },\n      );\n      const opaque = drop?.pass?.reflowIds;\n      const reflow = session.layout?.reflow;\n      if (!reflow) return { poses: drop?.reflow, opaque };\n      stepGlide(reflow, gliding, drop?.reflow ?? new Map());\n      return { opaque };\n    },\n\n    onEnd(_ctx, end): Op[] | null | void {\n      noteReleased();\n      if (end.answered) return;\n      const session = move.session();\n      const { delta } = move.frame();\n      // No-op if no movement (sub-threshold drag or zero delta).\n      if (delta.dx === 0 && delta.dy === 0) return;\n      // A drop or a release that claims the selection and writes nothing\n      // commits nothing: the translate must not run in its place.\n      const orAbort = (ops: Op[]): Op[] | null => (ops.length > 0 ? ops : null);\n      // Layout drop commit — takes precedence over reparent-on-drop when a\n      // layout container accepted the drag this gesture. One placement per\n      // dragged child, replayed in the order the preview resolved them.\n      // TODO: geometryProjection for drop-reflow — left pose-only because the\n      // reflow distributes per-child poses with no single global delta; not\n      // exercised by the geometry contract gate.\n      if (drop?.pass) return orAbort(layoutDropOps(session, drop.pass));\n      const release = layoutReleaseOps(session, delta, drop?.dropCenter ?? null);\n      return release === undefined ? undefined : orAbort(release);\n    },\n\n    onCancel: noteReleased,\n\n    onSettled(): void {\n      const session = move.session();\n      const reflow = session.layout?.reflow;\n      // After the commit: each glide settles onto the pose the document now\n      // holds, or back home on a cancel — the dragged ids from where they\n      // were let go.\n      if (reflow) {\n        for (const id of gliding) reflow.settle(id as string);\n        landReleased(session, reflow, released ?? new Map());\n      }\n      gliding.clear();\n    },\n  };\n}\n"],"mappings":";;;;;AAmBA,SAAgBA,EAAW,GAA0C;CAEnE,IAAIC,IAAwB,MACtBC,oBAAU,IAAI,IAAY,GAC5BC,IAAyC,MAEvCC,UAA2B;EAC/B,IAAMC,IAAUC,EAAK,QAAQ;EAC7B,AAAID,EAAQ,QAAQ,WAAQ,IAAWE,EAAcF,GAASC,EAAK,MAAM,CAAC,CAAC,QAAQ;CACrF;CAEA,OAAO;EACL,OAAO,GAAK,GAA0C;GAEpD,IADA,IAAO,MACHE,EAAS,SAAS,aAAa;GACnC,IAAMH,IAAUC,EAAK,QAAQ;GAC7B,IAAOG,EACLJ,GACA;IAAE,IAAIG,EAAS;IAAI,IAAIA,EAAS;GAAG,GACnC;IAAE,GAAGE,EAAI,QAAQ;IAAQ,GAAGA,EAAI,QAAQ;GAAO,CACjD;GACA,IAAMC,IAASV,GAAM,MAAM,WACrBW,IAASP,EAAQ,QAAQ;GAG/B,OAFKO,KACLC,EAAUD,GAAQV,GAASD,GAAM,0BAAU,IAAI,IAAI,CAAC,GAC7C,EAAE,UAAO,KAFI;IAAE,OAAOA,GAAM;IAAQ;GAAO;EAGpD;EAEA,MAAM,GAAM,GAAyB;GAEnC,IADAG,EAAa,GACTU,EAAI,UAAU;GAClB,IAAMT,IAAUC,EAAK,QAAQ,GACvB,EAAE,aAAUA,EAAK,MAAM;GAE7B,IAAIS,EAAM,OAAO,KAAKA,EAAM,OAAO,GAAG;GAGtC,IAAMC,KAAW,MAA4BC,EAAI,SAAS,IAAIA,IAAM;GAOpE,IAAIhB,GAAM,MAAM,OAAOe,EAAQE,EAAcb,GAASJ,EAAK,IAAI,CAAC;GAChE,IAAMkB,IAAUC,EAAiBf,GAASU,GAAOd,GAAM,cAAc,IAAI;GACzE,OAAOkB,MAAY,KAAA,IAAY,KAAA,IAAYH,EAAQG,CAAO;EAC5D;EAEA,UAAUf;EAEV,YAAkB;GAChB,IAAMC,IAAUC,EAAK,QAAQ,GACvBM,IAASP,EAAQ,QAAQ;GAI/B,IAAIO,GAAQ;IACV,KAAK,IAAMS,KAAMnB,GAAS,EAAO,OAAOmB,CAAY;IACpD,EAAahB,GAASO,GAAQT,qBAAY,IAAI,IAAI,CAAC;GACrD;GACA,EAAQ,MAAM;EAChB;CACF;AACF"}

package/dist/interactions/actions/move/behaviors/reparentOnDrop.js

@@ -0,0 +1,15 @@
+import { reparentOps as e, resolveDropTarget as t } from "../commit/reparent.js";
+//#region src/interactions/actions/move/behaviors/reparentOnDrop.ts
+function n(n) {
+	return { onEnd(r, i) {
+		if (i.answered) return;
+		let a = n.session(), { delta: o } = n.frame();
+		if (o.dx === 0 && o.dy === 0) return;
+		let s = a.reparentOnDrop(), c = s === "off" ? null : t(a, i.pointer);
+		return c ? e(a, c, s, o) : void 0;
+	} };
+}
+//#endregion
+export { n as reparentOnDrop };
+
+//# sourceMappingURL=reparentOnDrop.js.map

package/dist/interactions/actions/move/behaviors/reparentOnDrop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparentOnDrop.js","names":["reparentOnDrop","end","session","move","delta","mode","target","resolveDropTarget","reparentOps"],"sources":["../../../../../src/interactions/actions/move/behaviors/reparentOnDrop.ts"],"sourcesContent":["import type { MoveBehavior } from '../../../gestures/types';\nimport { reparentOps, resolveDropTarget } from '../commit/reparent';\nimport type { MoveGesture } from '../session';\n\n/**\n * The move behavior that reparents the selection under the node the pointer is\n * released over, when the binding's `reparentOnDrop` param asks for it.\n *\n * Built by the move action for one drag and run last, so a binding's behavior\n * or a layout drop that claims the commit preempts it.\n */\nexport function reparentOnDrop(move: MoveGesture): MoveBehavior<unknown> {\n  return {\n    onEnd(_ctx, end) {\n      if (end.answered) return;\n      const session = move.session();\n      const { delta } = move.frame();\n      // No-op if no movement (sub-threshold drag or zero delta).\n      if (delta.dx === 0 && delta.dy === 0) return;\n      // Reparent-on-drop, when opted in via `opts.params.reparentOnDrop`.\n      // Resolves the drop target via the `nodeAtPoint` dep (sourced by\n      // `<SceneCanvas>`) and reparents each moved root under it, then\n      // writes the translated pose in the new parent's frame so the\n      // visual position is preserved across the parent swap.\n      // An end with no drag carries no pointer: the dispatcher's `cancelAll`\n      // reports the world origin.\n      const mode = session.reparentOnDrop();\n      const target = mode !== 'off' ? resolveDropTarget(session, end.pointer) : null;\n      return target ? reparentOps(session, target, mode, delta) : undefined;\n    },\n  };\n}\n"],"mappings":";;AAWA,SAAgBA,EAAe,GAA0C;CACvE,OAAO,EACL,MAAM,GAAM,GAAK;EACf,IAAIC,EAAI,UAAU;EAClB,IAAMC,IAAUC,EAAK,QAAQ,GACvB,EAAE,aAAUA,EAAK,MAAM;EAE7B,IAAIC,EAAM,OAAO,KAAKA,EAAM,OAAO,GAAG;EAQtC,IAAMC,IAAOH,EAAQ,eAAe,GAC9BI,IAASD,MAAS,QAAkD,OAA1CE,EAAkBL,GAASD,EAAI,OAAO;EACtE,OAAOK,IAASE,EAAYN,GAASI,GAAQD,GAAMD,CAAK,IAAI,KAAA;CAC9D,EACF;AACF"}

package/dist/interactions/actions/move/behaviors/snapToContainer.js

@@ -1,5 +1,5 @@
-import { createTransformOp as e } from "../../../../core/ops/transform.js";
-import { createReparentOp as t } from "../../../../core/ops/reparent.js";
+import { createReparentOp as e } from "../../../../core/ops/reparent.js";
+import { createTransformOp as t } from "../../../../core/ops/transform.js";
 import { getScratch as n, scratchKey as r, setScratch as i } from "@weasel-js/routing";
 //#region src/interactions/actions/move/behaviors/snapToContainer.ts
 var a = r("snapToContainer");
@@ -22,11 +22,17 @@ function c(n) {
 			r?.parentId === t.parentId && a.set(n, r.slotPose);
 		}
 		return a;
-	}, d = (e, t) => ({
-		pose: t.slotPose,
-		poses: u(e, t),
-		snap: t
-	});
+	}, d = (e, t) => {
+		let n = e.origin.get(e.draggedIds[0]), r = n === void 0 ? void 0 : e.offset?.(n, t.slotPose);
+		return {
+			...r ? { transform: {
+				kind: "translate",
+				...r
+			} } : {},
+			poses: u(e, t),
+			snap: t
+		};
+	};
 	return {
 		onMove(e, t) {
 			let n = o(e), c = i(e.draggedIds[0], e.pointer.worldX, e.pointer.worldY);
@@ -46,29 +52,30 @@ function c(n) {
 		onCancel(e) {
 			s(o(e));
 		},
-		onEnd(n) {
-			let r = o(n);
-			s(r);
-			let i = r.committedSnap ?? n.snap;
-			if (!i) return;
-			let a = [], d = u(n, i);
-			for (let e of n.draggedIds) d.has(e) || d.set(e, n.current.get(e));
-			for (let [r, o] of d) {
-				a.push(e({
-					id: r,
-					from: n.origin.get(r),
-					to: o,
-					label: c
-				}));
-				let s = n.adapter.getParent?.(r) ?? null;
-				s !== i.parentId && a.push(t({
-					id: r,
-					fromParentId: s,
-					toParentId: i.parentId,
+		onEnd(n, r) {
+			let i = o(n);
+			s(i);
+			let a = i.committedSnap ?? n.snap;
+			if (!a) return;
+			let d = [], f = (t) => {
+				let r = n.adapter.getParent(t);
+				r !== a.parentId && d.push(e({
+					id: t,
+					fromParentId: r,
+					toParentId: a.parentId,
 					label: l
 				}));
-			}
-			return a;
+			}, p = u(n, a);
+			for (let [e, r] of p) d.push(t({
+				id: e,
+				from: n.origin.get(e),
+				to: r,
+				label: c
+			})), f(e);
+			let m = n.draggedIds.filter((e) => !p.has(e));
+			d.push(...r.translateOps(m));
+			for (let e of m) f(e);
+			return d;
 		}
 	};
 }

package/dist/interactions/actions/move/behaviors/snapToContainer.js.map

@@ -1 +1 @@
-{"version":3,"file":"snapToContainer.js","names":["STATE","scratchKey","getState","s","getScratch","ctx","setScratch","clearTimer","snapToContainer","args","slotsFor","primary","rest","slots","snap","id","own","findTarget","snapped","target","isInstant","dwellMs","ops","to","createTransformOp","moveLabel","oldParent","createReparentOp","reparentLabel"],"sources":["../../../../../src/interactions/actions/move/behaviors/snapToContainer.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport { createReparentOp } from 'core/ops/reparent';\nimport type { Op } from 'core/ops/types';\nimport type { SnapTarget } from 'core/adapters/types';\nimport type { BehaviorResult, MoveBehavior, GestureContext } from '../../../gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\n\ninterface SnapState<TPose> {\n  pendingTargetId: string | null;\n  pendingTimer: ReturnType<typeof setTimeout> | null;\n  committedSnap: SnapTarget<TPose> | null;\n}\n\n// The slot is generic over TPose; we keep the unknown-pose key at module\n// scope and project it through `as` at the read site (each consumer call\n// of `snapToContainer<TPose>` is the only writer of its own SnapState\n// instance, so the cast is safe at runtime).\nconst STATE = scratchKey<SnapState<unknown>>('snapToContainer');\n\nfunction getState<TPose>(ctx: GestureContext<TPose>): SnapState<TPose> {\n  let s = getScratch(ctx.scratch, STATE) as SnapState<TPose> | undefined;\n  if (!s) {\n    s = { pendingTargetId: null, pendingTimer: null, committedSnap: null };\n    setScratch(ctx.scratch, STATE, s as SnapState<unknown>);\n  }\n  return s;\n}\n\nfunction clearTimer<TPose>(s: SnapState<TPose>) {\n  if (s.pendingTimer !== null) {\n    clearTimeout(s.pendingTimer);\n    s.pendingTimer = null;\n  }\n  s.pendingTargetId = null;\n}\n\n/**\n * Move behavior that drops the dragged nodes into a container the pointer\n * hovers over for `dwellMs`, reparenting each and giving it the slot\n * `findTarget` answers for its id. A node `findTarget` has no slot for in\n * that container rides along with the first, at its offset from it.\n *\n * The dwell is what keeps a drag that merely passes over a container from\n * being captured by it.\n */\nexport function snapToContainer<TPose>(args: {\n  dwellMs: number;\n  findTarget: (\n    draggedId: string,\n    worldX: number,\n    worldY: number,\n  ) => SnapTarget<TPose> | null;\n  isInstant?: (target: SnapTarget<TPose>) => boolean;\n  moveLabel?: string;\n  reparentLabel?: string;\n}): MoveBehavior<TPose> {\n  const { dwellMs, findTarget, isInstant, moveLabel = 'Move', reparentLabel = 'Move and reparent' } = args;\n\n  /** Each dragged node's slot in the snapped container: the snapped slot for\n   *  the first, and for each other node the one `findTarget` answers for it. */\n  const slotsFor = (ctx: GestureContext<TPose>, snap: SnapTarget<TPose>): Map<string, TPose> => {\n    const [primary, ...rest] = ctx.draggedIds;\n    const slots = new Map<string, TPose>([[primary, snap.slotPose]]);\n    for (const id of rest) {\n      const own = findTarget(id, ctx.pointer.worldX, ctx.pointer.worldY);\n      if (own?.parentId === snap.parentId) slots.set(id, own.slotPose);\n    }\n    return slots;\n  };\n  const snapped = (ctx: GestureContext<TPose>, snap: SnapTarget<TPose>): BehaviorResult<TPose> =>\n    ({ pose: snap.slotPose, poses: slotsFor(ctx, snap), snap });\n\n  return {\n    onMove(ctx, _proposed) {\n      const s = getState<TPose>(ctx);\n      const target = findTarget(ctx.draggedIds[0], ctx.pointer.worldX, ctx.pointer.worldY);\n\n      if (s.committedSnap) {\n        if (target && target.parentId === s.committedSnap.parentId) {\n          return snapped(ctx, s.committedSnap);\n        }\n        s.committedSnap = null;\n      }\n\n      if (!target) {\n        clearTimer(s);\n        return;\n      }\n\n      if (isInstant?.(target)) {\n        clearTimer(s);\n        s.committedSnap = target;\n        return snapped(ctx, target);\n      }\n\n      if (s.pendingTargetId === target.parentId) {\n        return;\n      }\n      clearTimer(s);\n      s.pendingTargetId = target.parentId;\n      s.pendingTimer = setTimeout(() => {\n        s.committedSnap = target;\n        s.pendingTimer = null;\n      }, dwellMs);\n      return;\n    },\n\n    onCancel(ctx) { clearTimer(getState<TPose>(ctx)); },\n\n    onEnd(ctx) {\n      const s = getState<TPose>(ctx);\n      clearTimer(s);\n      const snap = s.committedSnap ?? ctx.snap;\n      if (!snap) return;\n      const ops: Op[] = [];\n      const slots = slotsFor(ctx, snap);\n      // A node with no slot of its own lands where the preview drew it.\n      for (const id of ctx.draggedIds) if (!slots.has(id)) slots.set(id, ctx.current.get(id)!);\n      for (const [id, to] of slots) {\n        ops.push(createTransformOp<TPose>({ id, from: ctx.origin.get(id)!, to, label: moveLabel }));\n        const oldParent = ctx.adapter.getParent?.(id) ?? null;\n        if (oldParent !== snap.parentId) {\n          ops.push(createReparentOp({\n            id,\n            fromParentId: oldParent,\n            toParentId: snap.parentId,\n            label: reparentLabel,\n          }));\n        }\n      }\n      return ops;\n    },\n  };\n}\n"],"mappings":";;;;AAiBA,IAAMA,IAAQC,EAA+B,iBAAiB;AAE9D,SAASC,EAAgB,GAA8C;CACrE,IAAIC,IAAIC,EAAWC,EAAI,SAASL,CAAK;CAKrC,OAJKG,MACH,IAAI;EAAE,iBAAiB;EAAM,cAAc;EAAM,eAAe;CAAK,GACrEG,EAAWD,EAAI,SAASL,GAAOG,CAAuB,IAEjDA;AACT;AAEA,SAASI,EAAkB,GAAqB;CAK9C,AAJIJ,EAAE,iBAAiB,SACrB,aAAaA,EAAE,YAAY,GAC3B,EAAE,eAAe,OAEnB,EAAE,kBAAkB;AACtB;AAWA,SAAgBK,EAAuB,GAUf;CACtB,IAAM,EAAE,YAAS,eAAY,cAAW,eAAY,QAAQ,mBAAgB,wBAAwBC,GAI9FC,KAAY,GAA4B,MAAgD;EAC5F,IAAM,CAACC,GAAS,GAAGC,KAAQP,EAAI,YACzBQ,oBAAQ,IAAI,IAAmB,CAAC,CAACF,GAASG,EAAK,QAAQ,CAAC,CAAC;EAC/D,KAAK,IAAMC,KAAMH,GAAM;GACrB,IAAMI,IAAMC,EAAWF,GAAIV,EAAI,QAAQ,QAAQA,EAAI,QAAQ,MAAM;GACjE,AAAIW,GAAK,aAAaF,EAAK,YAAUD,EAAM,IAAIE,GAAIC,EAAI,QAAQ;EACjE;EACA,OAAOH;CACT,GACMK,KAAW,GAA4B,OAC1C;EAAE,MAAMJ,EAAK;EAAU,OAAOJ,EAASL,GAAKS,CAAI;EAAG;CAAK;CAE3D,OAAO;EACL,OAAO,GAAK,GAAW;GACrB,IAAMX,IAAID,EAAgBG,CAAG,GACvBc,IAASF,EAAWZ,EAAI,WAAW,IAAIA,EAAI,QAAQ,QAAQA,EAAI,QAAQ,MAAM;GAEnF,IAAIF,EAAE,eAAe;IACnB,IAAIgB,KAAUA,EAAO,aAAahB,EAAE,cAAc,UAChD,OAAOe,EAAQb,GAAKF,EAAE,aAAa;IAErC,EAAE,gBAAgB;GACpB;GAEA,IAAI,CAACgB,GAAQ;IACX,EAAWhB,CAAC;IACZ;GACF;GAEA,IAAIiB,IAAYD,CAAM,GAGpB,OAFAZ,EAAWJ,CAAC,GACZ,EAAE,gBAAgBgB,GACXD,EAAQb,GAAKc,CAAM;GAG5B,AAAIhB,EAAE,oBAAoBgB,EAAO,aAGjCZ,EAAWJ,CAAC,GACZ,EAAE,kBAAkBgB,EAAO,UAC3B,EAAE,eAAe,iBAAiB;IAEhC,AADA,EAAE,gBAAgBA,GAClB,EAAE,eAAe;GACnB,GAAGE,CAAO;EAEZ;EAEA,SAAS,GAAK;GAAE,EAAWnB,EAAgBG,CAAG,CAAC;EAAG;EAElD,MAAM,GAAK;GACT,IAAMF,IAAID,EAAgBG,CAAG;GAC7B,EAAWF,CAAC;GACZ,IAAMW,IAAOX,EAAE,iBAAiBE,EAAI;GACpC,IAAI,CAACS,GAAM;GACX,IAAMQ,IAAY,CAAC,GACbT,IAAQH,EAASL,GAAKS,CAAI;GAEhC,KAAK,IAAMC,KAAMV,EAAI,YAAY,AAAKQ,EAAM,IAAIE,CAAE,KAAGF,EAAM,IAAIE,GAAIV,EAAI,QAAQ,IAAIU,CAAE,CAAE;GACvF,KAAK,IAAM,CAACA,GAAIQ,MAAOV,GAAO;IAC5B,EAAI,KAAKW,EAAyB;KAAE;KAAI,MAAMnB,EAAI,OAAO,IAAIU,CAAE;KAAI;KAAI,OAAOU;IAAU,CAAC,CAAC;IAC1F,IAAMC,IAAYrB,EAAI,QAAQ,YAAYU,CAAE,KAAK;IACjD,AAAIW,MAAcZ,EAAK,YACrBQ,EAAI,KAAKK,EAAiB;KACxB;KACA,cAAcD;KACd,YAAYZ,EAAK;KACjB,OAAOc;IACT,CAAC,CAAC;GAEN;GACA,OAAON;EACT;CACF;AACF"}
+{"version":3,"file":"snapToContainer.js","names":["STATE","scratchKey","getState","s","getScratch","ctx","setScratch","clearTimer","snapToContainer","args","slotsFor","primary","rest","slots","snap","id","own","findTarget","snapped","start","toSlot","target","isInstant","dwellMs","ops","reparent","oldParent","createReparentOp","reparentLabel","to","createTransformOp","moveLabel","end"],"sources":["../../../../../src/interactions/actions/move/behaviors/snapToContainer.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport { createReparentOp } from 'core/ops/reparent';\nimport type { Op } from 'core/ops/types';\nimport type { SnapTarget } from 'core/adapters/types';\nimport type { BehaviorResult, MoveBehavior, GestureContext } from '../../../gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\n\ninterface SnapState<TPose> {\n  pendingTargetId: string | null;\n  pendingTimer: ReturnType<typeof setTimeout> | null;\n  committedSnap: SnapTarget<TPose> | null;\n}\n\n// The slot is generic over TPose; we keep the unknown-pose key at module\n// scope and project it through `as` at the read site (each consumer call\n// of `snapToContainer<TPose>` is the only writer of its own SnapState\n// instance, so the cast is safe at runtime).\nconst STATE = scratchKey<SnapState<unknown>>('snapToContainer');\n\nfunction getState<TPose>(ctx: GestureContext<TPose>): SnapState<TPose> {\n  let s = getScratch(ctx.scratch, STATE) as SnapState<TPose> | undefined;\n  if (!s) {\n    s = { pendingTargetId: null, pendingTimer: null, committedSnap: null };\n    setScratch(ctx.scratch, STATE, s as SnapState<unknown>);\n  }\n  return s;\n}\n\nfunction clearTimer<TPose>(s: SnapState<TPose>) {\n  if (s.pendingTimer !== null) {\n    clearTimeout(s.pendingTimer);\n    s.pendingTimer = null;\n  }\n  s.pendingTargetId = null;\n}\n\n/**\n * Move behavior that drops the dragged nodes into a container the pointer\n * hovers over for `dwellMs`, reparenting each and giving it the slot\n * `findTarget` answers for its id. A node `findTarget` has no slot for in\n * that container rides along with the first, at its offset from it.\n *\n * The dwell is what keeps a drag that merely passes over a container from\n * being captured by it.\n */\nexport function snapToContainer<TPose>(args: {\n  dwellMs: number;\n  findTarget: (\n    draggedId: string,\n    worldX: number,\n    worldY: number,\n  ) => SnapTarget<TPose> | null;\n  isInstant?: (target: SnapTarget<TPose>) => boolean;\n  moveLabel?: string;\n  reparentLabel?: string;\n}): MoveBehavior<TPose> {\n  const { dwellMs, findTarget, isInstant, moveLabel = 'Move', reparentLabel = 'Move and reparent' } = args;\n\n  /** Each dragged node's slot in the snapped container: the snapped slot for\n   *  the first, and for each other node the one `findTarget` answers for it. */\n  const slotsFor = (ctx: GestureContext<TPose>, snap: SnapTarget<TPose>): Map<string, TPose> => {\n    const [primary, ...rest] = ctx.draggedIds;\n    const slots = new Map<string, TPose>([[primary, snap.slotPose]]);\n    for (const id of rest) {\n      const own = findTarget(id, ctx.pointer.worldX, ctx.pointer.worldY);\n      if (own?.parentId === snap.parentId) slots.set(id, own.slotPose);\n    }\n    return slots;\n  };\n  const snapped = (ctx: GestureContext<TPose>, snap: SnapTarget<TPose>): BehaviorResult<TPose> => {\n    const start = ctx.origin.get(ctx.draggedIds[0]);\n    const toSlot = start !== undefined ? ctx.offset?.(start, snap.slotPose) : undefined;\n    return {\n      ...(toSlot ? { transform: { kind: 'translate' as const, ...toSlot } } : {}),\n      poses: slotsFor(ctx, snap),\n      snap,\n    };\n  };\n\n  return {\n    onMove(ctx, _proposed) {\n      const s = getState<TPose>(ctx);\n      const target = findTarget(ctx.draggedIds[0], ctx.pointer.worldX, ctx.pointer.worldY);\n\n      if (s.committedSnap) {\n        if (target && target.parentId === s.committedSnap.parentId) {\n          return snapped(ctx, s.committedSnap);\n        }\n        s.committedSnap = null;\n      }\n\n      if (!target) {\n        clearTimer(s);\n        return;\n      }\n\n      if (isInstant?.(target)) {\n        clearTimer(s);\n        s.committedSnap = target;\n        return snapped(ctx, target);\n      }\n\n      if (s.pendingTargetId === target.parentId) {\n        return;\n      }\n      clearTimer(s);\n      s.pendingTargetId = target.parentId;\n      s.pendingTimer = setTimeout(() => {\n        s.committedSnap = target;\n        s.pendingTimer = null;\n      }, dwellMs);\n      return;\n    },\n\n    onCancel(ctx) { clearTimer(getState<TPose>(ctx)); },\n\n    onEnd(ctx, end) {\n      const s = getState<TPose>(ctx);\n      clearTimer(s);\n      const snap = s.committedSnap ?? ctx.snap;\n      if (!snap) return;\n      const ops: Op[] = [];\n      const reparent = (id: string): void => {\n        const oldParent = ctx.adapter.getParent(id);\n        if (oldParent !== snap.parentId) {\n          ops.push(createReparentOp({\n            id,\n            fromParentId: oldParent,\n            toParentId: snap.parentId,\n            label: reparentLabel,\n          }));\n        }\n      };\n      const slots = slotsFor(ctx, snap);\n      for (const [id, to] of slots) {\n        ops.push(createTransformOp<TPose>({ id, from: ctx.origin.get(id)!, to, label: moveLabel }));\n        reparent(id);\n      }\n      // A node with no slot of its own lands where the preview drew it.\n      const rest = ctx.draggedIds.filter((id) => !slots.has(id));\n      ops.push(...end.translateOps(rest));\n      for (const id of rest) reparent(id);\n      return ops;\n    },\n  };\n}\n"],"mappings":";;;;AAiBA,IAAMA,IAAQC,EAA+B,iBAAiB;AAE9D,SAASC,EAAgB,GAA8C;CACrE,IAAIC,IAAIC,EAAWC,EAAI,SAASL,CAAK;CAKrC,OAJKG,MACH,IAAI;EAAE,iBAAiB;EAAM,cAAc;EAAM,eAAe;CAAK,GACrEG,EAAWD,EAAI,SAASL,GAAOG,CAAuB,IAEjDA;AACT;AAEA,SAASI,EAAkB,GAAqB;CAK9C,AAJIJ,EAAE,iBAAiB,SACrB,aAAaA,EAAE,YAAY,GAC3B,EAAE,eAAe,OAEnB,EAAE,kBAAkB;AACtB;AAWA,SAAgBK,EAAuB,GAUf;CACtB,IAAM,EAAE,YAAS,eAAY,cAAW,eAAY,QAAQ,mBAAgB,wBAAwBC,GAI9FC,KAAY,GAA4B,MAAgD;EAC5F,IAAM,CAACC,GAAS,GAAGC,KAAQP,EAAI,YACzBQ,oBAAQ,IAAI,IAAmB,CAAC,CAACF,GAASG,EAAK,QAAQ,CAAC,CAAC;EAC/D,KAAK,IAAMC,KAAMH,GAAM;GACrB,IAAMI,IAAMC,EAAWF,GAAIV,EAAI,QAAQ,QAAQA,EAAI,QAAQ,MAAM;GACjE,AAAIW,GAAK,aAAaF,EAAK,YAAUD,EAAM,IAAIE,GAAIC,EAAI,QAAQ;EACjE;EACA,OAAOH;CACT,GACMK,KAAW,GAA4B,MAAmD;EAC9F,IAAMC,IAAQd,EAAI,OAAO,IAAIA,EAAI,WAAW,EAAE,GACxCe,IAASD,MAAU,KAAA,IAAiD,KAAA,IAArCd,EAAI,SAASc,GAAOL,EAAK,QAAQ;EACtE,OAAO;GACL,GAAIM,IAAS,EAAE,WAAW;IAAE,MAAM;IAAsB,GAAGA;GAAO,EAAE,IAAI,CAAC;GACzE,OAAOV,EAASL,GAAKS,CAAI;GACzB;EACF;CACF;CAEA,OAAO;EACL,OAAO,GAAK,GAAW;GACrB,IAAMX,IAAID,EAAgBG,CAAG,GACvBgB,IAASJ,EAAWZ,EAAI,WAAW,IAAIA,EAAI,QAAQ,QAAQA,EAAI,QAAQ,MAAM;GAEnF,IAAIF,EAAE,eAAe;IACnB,IAAIkB,KAAUA,EAAO,aAAalB,EAAE,cAAc,UAChD,OAAOe,EAAQb,GAAKF,EAAE,aAAa;IAErC,EAAE,gBAAgB;GACpB;GAEA,IAAI,CAACkB,GAAQ;IACX,EAAWlB,CAAC;IACZ;GACF;GAEA,IAAImB,IAAYD,CAAM,GAGpB,OAFAd,EAAWJ,CAAC,GACZ,EAAE,gBAAgBkB,GACXH,EAAQb,GAAKgB,CAAM;GAG5B,AAAIlB,EAAE,oBAAoBkB,EAAO,aAGjCd,EAAWJ,CAAC,GACZ,EAAE,kBAAkBkB,EAAO,UAC3B,EAAE,eAAe,iBAAiB;IAEhC,AADA,EAAE,gBAAgBA,GAClB,EAAE,eAAe;GACnB,GAAGE,CAAO;EAEZ;EAEA,SAAS,GAAK;GAAE,EAAWrB,EAAgBG,CAAG,CAAC;EAAG;EAElD,MAAM,GAAK,GAAK;GACd,IAAMF,IAAID,EAAgBG,CAAG;GAC7B,EAAWF,CAAC;GACZ,IAAMW,IAAOX,EAAE,iBAAiBE,EAAI;GACpC,IAAI,CAACS,GAAM;GACX,IAAMU,IAAY,CAAC,GACbC,KAAY,MAAqB;IACrC,IAAMC,IAAYrB,EAAI,QAAQ,UAAUU,CAAE;IAC1C,AAAIW,MAAcZ,EAAK,YACrBU,EAAI,KAAKG,EAAiB;KACxB;KACA,cAAcD;KACd,YAAYZ,EAAK;KACjB,OAAOc;IACT,CAAC,CAAC;GAEN,GACMf,IAAQH,EAASL,GAAKS,CAAI;GAChC,KAAK,IAAM,CAACC,GAAIc,MAAOhB,GAErB,AADAW,EAAI,KAAKM,EAAyB;IAAE;IAAI,MAAMzB,EAAI,OAAO,IAAIU,CAAE;IAAI;IAAI,OAAOgB;GAAU,CAAC,CAAC,GAC1FN,EAASV,CAAE;GAGb,IAAMH,IAAOP,EAAI,WAAW,QAAQ,MAAO,CAACQ,EAAM,IAAIE,CAAE,CAAC;GACzD,EAAI,KAAK,GAAGiB,EAAI,aAAapB,CAAI,CAAC;GAClC,KAAK,IAAMG,KAAMH,GAAM,EAASG,CAAE;GAClC,OAAOS;EACT;CACF;AACF"}