@weasel-js/core 1.9.3 → 1.10.0

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

@@ -0,0 +1,143 @@
+import { reduceBehaviorEnd as e, runBehaviorCancel as t, runBehaviorSettled as n } from "../gestureLifecycle.js";
+import { gestureViewReader as r } from "../../gestures/shared/screenTolerance.js";
+import { pointerStateOf as i } from "../pointerState.js";
+import { selectionFromHits as a } from "../hitSelection.js";
+import { applyOpsTo as o } from "../../../core/applyOps.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(e, t) {
+	let n = {
+		getSelection: () => e.getSelection(),
+		setSelection: (t) => e.setSelection(t),
+		hitTestArea: (n) => e.hitTestArea(n, t),
+		hitTestLasso: (n, r) => d(e, n, r, t),
+		applyOps: (e) => o(n, e)
+	};
+	return n;
+}
+var p = 2, m = {
+	id: "lassoSelect",
+	label: "Lasso Select",
+	eligible: { capability: "creates-selection" },
+	requires: ["lassoSelect", "view"],
+	invoker: {
+		timing: "ongoing",
+		start(e, t) {
+			let a = e.deps.lassoSelect;
+			if (!a) return {};
+			let o = c(t?.params), u = e.deps.view, d = [{
+				x: e.world.x,
+				y: e.world.y
+			}], m = t?.behaviors ?? [], g = null, _ = r(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: i(e.world, e),
+					view: _(),
+					adapter: f(a, u),
+					scratch: {}
+				}, l(g.scratch, s, d);
+				for (let e of m) e.onStart?.(g);
+			}
+			let v = {
+				dep: a,
+				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], a = t - r.x, o = n - r.y, s = v.minVertexSpacing;
+					a * a + o * o >= s * s && v.vertices.push({
+						x: t,
+						y: n
+					});
+					let c = v.gesture;
+					if (c) {
+						c.modifiers = { ...e.modifiers }, c.pointer = i(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 r = !1;
+					try {
+						r = h(v, t);
+					} finally {
+						v.gesture && n(v.behaviors, v.gesture, r);
+					}
+				}
+			};
+		}
+	},
+	enabled: () => !0
+};
+function h(n, r) {
+	if (n.open = !1, r === "cancel") return n.gesture && t(n.behaviors, n.gesture), !1;
+	let { dep: i, mode: o, view: s, vertices: c, shiftHeld: l, gesture: u } = n;
+	if (u) {
+		let t = e(n.behaviors, u);
+		if (t !== void 0) return t !== null && u.adapter.applyOps(t), t !== null;
+	}
+	if (c.length < 3) return l || i.setSelection([]), !l;
+	let f = d(i, c, o, s);
+	return i.setSelection(a(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/lasso-select/behaviors/selectFromLasso.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"selectFromLasso.js","names":["LASSO_VERTICES","scratchKey","MIN_AREA","selectFromLasso","mode","opts","adapter","ctx","vertices","getScratch","startPose","shiftHeld","from","polygonAabbArea","createSetSelectionOp","hits","to","mergeUnique","minX","minY","maxX","maxY","v","out","a","id","b"],"sources":["../../../../../src/interactions/actions/lasso-select/behaviors/selectFromLasso.ts"],"sourcesContent":["import { createSetSelectionOp } from 'core/ops/select';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type {\n  LassoHitMode,\n  LassoSelectAdapter,\n} from 'core/adapters/types';\nimport type { LassoSelectBehavior } from '../../../gestures/types';\nimport { scratchKey, getScratch } from '@weasel-js/routing';\n\n/** Typed scratch slot the lasso tool's gesture writes into for this behavior\n *  to consume. Shared identity: tools producing the polygon for a lasso\n *  selection write under this same key. */\nexport const LASSO_VERTICES = scratchKey<ReadonlyArray<{ x: number; y: number }>>('lassoSelect.vertices');\n\nconst MIN_AREA = 4;\n\n/** Options for `selectFromLasso`. */\nexport interface SelectFromLassoOptions {\n  /** Hit mode for `hitTestLasso`. Default 'intersect'. */\n  mode?: LassoHitMode;\n}\n\n/** A lasso behavior (`useLassoTool({ behaviors })`): replace selection with\n *  polygon hits in its own `mode`, or extend the existing selection when shift\n *  is held at gesture start. Tiny / degenerate lassos behave like a click —\n *  clear (or preserve, with shift). Hits come from the gesture adapter's\n *  `hitTestLasso`, which under `lassoSelectAction` is the `lassoSelect` dep. */\nexport function selectFromLasso(opts?: SelectFromLassoOptions): LassoSelectBehavior {\n  const mode: LassoHitMode = opts?.mode ?? 'intersect';\n  return {\n    defaultTransient: true,\n    onEnd(ctx) {\n      const adapter = ctx.adapter as unknown as LassoSelectAdapter;\n      if (!adapter.getSelection || !adapter.hitTestLasso) return null;\n\n      const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n      const startPose = ctx.origin.get('gesture');\n      const shiftHeld = startPose ? (startPose as { shiftHeld?: boolean }).shiftHeld === true : false;\n      const from = adapter.getSelection();\n\n      // Tiny / degenerate lassos behave like a click: clear (or preserve on shift).\n      const tiny = vertices.length < 3 || polygonAabbArea(vertices) < MIN_AREA;\n      if (tiny) {\n        const to = shiftHeld ? from : [];\n        const op: Op = createSetSelectionOp({ from: from as NodeId[], to: to as NodeId[] });\n        return [op];\n      }\n\n      const hits = adapter.hitTestLasso(vertices, mode);\n      const to = shiftHeld\n        ? mergeUnique(from, hits)\n        : hits;\n      const op: Op = createSetSelectionOp({ from: from as NodeId[], to: to as NodeId[] });\n      return [op];\n    },\n  };\n}\n\nfunction polygonAabbArea(vertices: ReadonlyArray<{ x: number; y: number }>): number {\n  if (vertices.length === 0) return 0;\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (const v of vertices) {\n    if (v.x < minX) minX = v.x;\n    if (v.y < minY) minY = v.y;\n    if (v.x > maxX) maxX = v.x;\n    if (v.y > maxY) maxY = v.y;\n  }\n  return (maxX - minX) * (maxY - minY);\n}\n\nfunction mergeUnique(a: ReadonlyArray<string>, b: ReadonlyArray<string>): string[] {\n  const out = [...a];\n  for (const id of b) if (!out.includes(id)) out.push(id);\n  return out;\n}\n"],"mappings":";;;AAaA,IAAaA,IAAiBC,EAAoD,sBAAsB,GAElGC,IAAW;AAajB,SAAgBC,EAAgB,GAAoD;CAClF,IAAMC,IAAqBC,GAAM,QAAQ;CACzC,OAAO;EACL,kBAAkB;EAClB,MAAM,GAAK;GACT,IAAMC,IAAUC,EAAI;GACpB,IAAI,CAACD,EAAQ,gBAAgB,CAACA,EAAQ,cAAc,OAAO;GAE3D,IAAME,IAAWC,EAAWF,EAAI,SAASP,CAAc,KAAK,CAAC,GACvDU,IAAYH,EAAI,OAAO,IAAI,SAAS,GACpCI,IAAYD,IAAaA,EAAsC,cAAc,KAAO,IACpFE,IAAON,EAAQ,aAAa;GAIlC,IADaE,EAAS,SAAS,KAAKK,EAAgBL,CAAQ,IAAIN,GAI9D,OAAO,CADQY,EAAqB;IAAQ;IAAsB,IADvDH,IAAYC,IAAO,CAAC;GACkD,CACzE,CAAE;GAGZ,IAAMG,IAAOT,EAAQ,aAAaE,GAAUJ,CAAI,GAC1CY,IAAKL,IACPM,EAAYL,GAAMG,CAAI,IACtBA;GAEJ,OAAO,CADQD,EAAqB;IAAQ;IAAsB;GAAe,CACzE,CAAE;EACZ;CACF;AACF;AAEA,SAASD,EAAgB,GAA2D;CAClF,IAAIL,EAAS,WAAW,GAAG,OAAO;CAClC,IAAIU,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;CAC/D,KAAK,IAAMC,KAAKd,GAId,AAHIc,EAAE,IAAIJ,MAAM,IAAOI,EAAE,IACrBA,EAAE,IAAIH,MAAM,IAAOG,EAAE,IACrBA,EAAE,IAAIF,MAAM,IAAOE,EAAE,IACrBA,EAAE,IAAID,MAAM,IAAOC,EAAE;CAE3B,QAAQF,IAAOF,MAASG,IAAOF;AACjC;AAEA,SAASF,EAAY,GAA0B,GAAoC;CACjF,IAAMM,IAAM,CAAC,GAAGC,CAAC;CACjB,KAAK,IAAMC,KAAMC,GAAG,AAAKH,EAAI,SAASE,CAAE,KAAGF,EAAI,KAAKE,CAAE;CACtD,OAAOF;AACT"}
+{"version":3,"file":"selectFromLasso.js","names":["LASSO_VERTICES","scratchKey","MIN_AREA","selectFromLasso","mode","opts","adapter","ctx","vertices","getScratch","startPose","shiftHeld","from","polygonAabbArea","createSetSelectionOp","hits","to","selectionFromHits","minX","minY","maxX","maxY","v"],"sources":["../../../../../src/interactions/actions/lasso-select/behaviors/selectFromLasso.ts"],"sourcesContent":["import { createSetSelectionOp } from 'core/ops/select';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type {\n  LassoHitMode,\n  LassoSelectAdapter,\n} from 'core/adapters/types';\nimport type { LassoSelectBehavior } from '../../../gestures/types';\nimport { scratchKey, getScratch } from '@weasel-js/routing';\nimport { selectionFromHits } from '../../hitSelection';\n\n/** Typed scratch slot the lasso tool's gesture writes into for this behavior\n *  to consume. Shared identity: tools producing the polygon for a lasso\n *  selection write under this same key. */\nexport const LASSO_VERTICES = scratchKey<ReadonlyArray<{ x: number; y: number }>>('lassoSelect.vertices');\n\nconst MIN_AREA = 4;\n\n/** Options for `selectFromLasso`. */\nexport interface SelectFromLassoOptions {\n  /** Hit mode for `hitTestLasso`. Default 'intersect'. */\n  mode?: LassoHitMode;\n}\n\n/** A lasso behavior (`useLassoTool({ behaviors })`): replace selection with\n *  polygon hits in its own `mode`, or extend the existing selection when shift\n *  is held at gesture start. Tiny / degenerate lassos behave like a click —\n *  clear (or preserve, with shift). Hits come from the gesture adapter's\n *  `hitTestLasso`, which under `lassoSelectAction` is the `lassoSelect` dep. */\nexport function selectFromLasso(opts?: SelectFromLassoOptions): LassoSelectBehavior {\n  const mode: LassoHitMode = opts?.mode ?? 'intersect';\n  return {\n    defaultTransient: true,\n    onEnd(ctx) {\n      const adapter = ctx.adapter as unknown as LassoSelectAdapter;\n      if (!adapter.getSelection || !adapter.hitTestLasso) return null;\n\n      const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n      const startPose = ctx.origin.get('gesture');\n      const shiftHeld = startPose ? (startPose as { shiftHeld?: boolean }).shiftHeld === true : false;\n      const from = adapter.getSelection();\n\n      // Tiny / degenerate lassos behave like a click: clear (or preserve on shift).\n      const tiny = vertices.length < 3 || polygonAabbArea(vertices) < MIN_AREA;\n      if (tiny) {\n        const to = shiftHeld ? from : [];\n        const op: Op = createSetSelectionOp({ from: from as NodeId[], to: to as NodeId[] });\n        return [op];\n      }\n\n      const hits = adapter.hitTestLasso(vertices, mode);\n      const to = selectionFromHits(from, hits, shiftHeld);\n      const op: Op = createSetSelectionOp({ from: from as NodeId[], to: to as NodeId[] });\n      return [op];\n    },\n  };\n}\n\nfunction polygonAabbArea(vertices: ReadonlyArray<{ x: number; y: number }>): number {\n  if (vertices.length === 0) return 0;\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (const v of vertices) {\n    if (v.x < minX) minX = v.x;\n    if (v.y < minY) minY = v.y;\n    if (v.x > maxX) maxX = v.x;\n    if (v.y > maxY) maxY = v.y;\n  }\n  return (maxX - minX) * (maxY - minY);\n}\n"],"mappings":";;;;AAcA,IAAaA,IAAiBC,EAAoD,sBAAsB,GAElGC,IAAW;AAajB,SAAgBC,EAAgB,GAAoD;CAClF,IAAMC,IAAqBC,GAAM,QAAQ;CACzC,OAAO;EACL,kBAAkB;EAClB,MAAM,GAAK;GACT,IAAMC,IAAUC,EAAI;GACpB,IAAI,CAACD,EAAQ,gBAAgB,CAACA,EAAQ,cAAc,OAAO;GAE3D,IAAME,IAAWC,EAAWF,EAAI,SAASP,CAAc,KAAK,CAAC,GACvDU,IAAYH,EAAI,OAAO,IAAI,SAAS,GACpCI,IAAYD,IAAaA,EAAsC,cAAc,KAAO,IACpFE,IAAON,EAAQ,aAAa;GAIlC,IADaE,EAAS,SAAS,KAAKK,EAAgBL,CAAQ,IAAIN,GAI9D,OAAO,CADQY,EAAqB;IAAQ;IAAsB,IADvDH,IAAYC,IAAO,CAAC;GACkD,CACzE,CAAE;GAGZ,IAAMG,IAAOT,EAAQ,aAAaE,GAAUJ,CAAI,GAC1CY,IAAKC,EAAkBL,GAAMG,GAAMJ,CAAS;GAElD,OAAO,CADQG,EAAqB;IAAQ;IAAsB;GAAe,CACzE,CAAE;EACZ;CACF;AACF;AAEA,SAASD,EAAgB,GAA2D;CAClF,IAAIL,EAAS,WAAW,GAAG,OAAO;CAClC,IAAIU,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;CAC/D,KAAK,IAAMC,KAAKd,GAId,AAHIc,EAAE,IAAIJ,MAAM,IAAOI,EAAE,IACrBA,EAAE,IAAIH,MAAM,IAAOG,EAAE,IACrBA,EAAE,IAAIF,MAAM,IAAOE,EAAE,IACrBA,EAAE,IAAID,MAAM,IAAOC,EAAE;CAE3B,QAAQF,IAAOF,MAASG,IAAOF;AACjC"}

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

@@ -0,0 +1,87 @@
+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 { pastDragThreshold as s } from "@weasel-js/routing";
+//#region src/interactions/actions/move/action.ts
+var c = 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 c = {
+				delta: {
+					dx: 0,
+					dy: 0
+				},
+				previews: /* @__PURE__ */ new Map(),
+				opaque: /* @__PURE__ */ new Set()
+			}, l = i(n, r, () => c);
+			if (!l) return {};
+			let { session: u, readers: d } = l, f = u.scene.overrides.hold(), p = null;
+			return {
+				kind: "move",
+				onMove(e) {
+					if (e.drag) {
+						if (!p) {
+							let t = e.drag.screenDelta;
+							if (t && !s({
+								clientX: 0,
+								clientY: 0
+							}, {
+								clientX: t.x,
+								clientY: t.y
+							}, u.dragThresholdPx)) return;
+							u.lifecycle.start(u.ids);
+						}
+						p = e.world, c = a(u, d, e), f.set(c.previews);
+					}
+				},
+				onEnd(n, r) {
+					let i = !1;
+					try {
+						r === "commit" && p ? i = o({
+							session: u,
+							delta: c.delta,
+							at: n.drag ? n.world : p
+						}) : t(u.behaviors, u.gestureCtx);
+					} finally {
+						e({
+							hold: f,
+							previews: c.previews,
+							behaviors: u.behaviors,
+							ctx: u.gestureCtx,
+							lifecycle: u.lifecycle
+						}, i);
+					}
+				},
+				previewIds: () => c.previews.keys(),
+				previewPose: (e) => c.previews.get(e) ?? null,
+				previewOpaqueIds: () => c.opaque.size === 0 ? null : c.opaque
+			};
+		}
+	},
+	enabled: () => !0
+}, r);
+//#endregion
+export { c 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","hold","session","engaged","moveCtx","s","pastDragThreshold","nextFrame","readers","committed","reason","commitMove","endCtx","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';\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 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            } 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":";;;;;;;AA0BA,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,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,IAAIL,EAAM,QAAQ;KAHvB;IAIF;IACA,MAAM,GAAuB,GAAmC;KAC9D,IAAIa,IAAY;KAChB,IAAI;MAGF,AAAIC,MAAW,YAAYP,IACzB,IAAYQ,EAAW;OACrB;OACA,OAAOf,EAAM;OACb,IAAIgB,EAAO,OAAOA,EAAO,QAAQT;MACnC,CAAC,IACIU,EAAkBX,EAAQ,WAAWA,EAAQ,UAAU;KAChE,UAAU;MAGR,EAAa;OAAE;OAAM,UAAUN,EAAM;OAAU,WAAWM,EAAQ;OAAW,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGO,CAAS;KACjJ;IACF;IACA,kBAAkBb,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIkB,CAAY,KAAK;IACjE,wBAAyBlB,EAAM,OAAO,SAAS,IAAI,OAAOA,EAAM;GAClE;EACF;CACF;CAOA,eAAe;AACjB,GAAGmB,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/snapBackOrDelete.js

@@ -19,12 +19,12 @@ function s(r) {
 			let r = t.draggedIds[0], i = u.getOrigin(t.origin.get(r)), s = u.getOrigin(t.current.get(r)), f = s.x - i.x, p = s.y - i.y;
 			if (f * f + p * p <= d) return null;
 			if (c === "delete") {
-				let i = n(t.scratch, a), s = n(t.scratch, o), c = i?.get(r) ?? { id: r }, u = s?.get(r) ?? -1;
-				return [e({
-					node: c,
+				let r = n(t.scratch, a), i = n(t.scratch, o), s = (e) => i?.get(e) ?? -1;
+				return [...t.draggedIds].sort((e, t) => s(t) - s(e)).map((t) => e({
+					node: r?.get(t) ?? { id: t },
 					label: l,
-					index: u
-				})];
+					index: s(t)
+				}));
 			}
 			return null;
 		}

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

@@ -1 +1 @@
-{"version":3,"file":"snapBackOrDelete.js","names":["SNAPSHOTS","scratchKey","INDEXES","snapBackOrDelete","args","proj","AUTO_ORIGIN_PROJECTION","r2","radius","snapshots","indexes","nodes","ctx","id","obj","n","setScratch","o0","o1","dx","dy","onFreeRelease","getScratch","index","createDeleteOp","deleteLabel"],"sources":["../../../../../src/interactions/actions/move/behaviors/snapBackOrDelete.ts"],"sourcesContent":["import { createDeleteOp } from 'core/ops/delete';\nimport type { Op } from 'core/ops/types';\nimport type { MoveBehavior } from '../../../gestures/types';\nimport {\n  AUTO_ORIGIN_PROJECTION,\n  type OriginProjection,\n} from '../../../gestures/shared/originProjection';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\n\nconst SNAPSHOTS = scratchKey<Map<string, { id: string }>>('snapBackOrDelete.snapshots');\nconst INDEXES = scratchKey<Map<string, number>>('snapBackOrDelete.indexes');\n\n/**\n * Move behavior for a drag that is only meaningful near where it started:\n * release inside `radius` and the node returns to its original pose; release\n * outside it and the node either springs back anyway or is deleted, per\n * `onFreeRelease`. A deletion is recorded as an undoable op with paint order\n * preserved.\n */\nexport function snapBackOrDelete<TPose extends { x: number; y: number }>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n}): MoveBehavior<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the behavior how\n *  to read and write the pose's origin. */\nexport function snapBackOrDelete<TPose>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n  origin: OriginProjection<TPose>;\n}): MoveBehavior<TPose>;\n/** Snap back to the origin pose, or delete, depending on where the drag is\n *  released. */\nexport function snapBackOrDelete<TPose>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n  origin?: OriginProjection<TPose>;\n}): MoveBehavior<TPose> {\n  const { radius, onFreeRelease, deleteLabel = 'Delete' } = args;\n  const proj: OriginProjection<TPose> =\n    args.origin ?? (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const r2 = radius * radius;\n\n  return {\n    onStart(ctx) {\n      // Snapshot the dragged objects + their z-indexes at gesture start so\n      // delete can undo with paint order intact.\n      const snapshots = new Map<string, { id: string }>();\n      const indexes = new Map<string, number>();\n      const nodes = ctx.adapter.getNodes();\n      for (const id of ctx.draggedIds) {\n        const obj = ctx.adapter.getNode(id) ?? { id };\n        snapshots.set(id, obj);\n        indexes.set(id, nodes.findIndex((n) => n.id === id));\n      }\n      setScratch(ctx.scratch, SNAPSHOTS, snapshots);\n      setScratch(ctx.scratch, INDEXES, indexes);\n    },\n\n    onEnd(ctx) {\n      if (ctx.snap) return;\n      const id = ctx.draggedIds[0];\n      const o0 = proj.getOrigin(ctx.origin.get(id)!);\n      const o1 = proj.getOrigin(ctx.current.get(id)!);\n      const dx = o1.x - o0.x;\n      const dy = o1.y - o0.y;\n      const within = dx * dx + dy * dy <= r2;\n      if (within) {\n        return null;\n      }\n      if (onFreeRelease === 'delete') {\n        const snapshots = getScratch(ctx.scratch, SNAPSHOTS);\n        const indexes = getScratch(ctx.scratch, INDEXES);\n        const obj = snapshots?.get(id) ?? { id };\n        const index = indexes?.get(id) ?? -1;\n        const ops: Op[] = [createDeleteOp({ node: obj, label: deleteLabel, index })];\n        return ops;\n      }\n      // `'snap-back'` — abort, same as a release inside the radius. Returning\n      // `undefined` would defer to the default translate and leave the node\n      // where it was dropped, which is the one thing this policy rules out.\n      return null;\n    },\n  };\n}\n"],"mappings":";;;;AASA,IAAMA,IAAYC,EAAwC,4BAA4B,GAChFC,IAAUD,EAAgC,0BAA0B;AAwB1E,SAAgBE,EAAwB,GAKhB;CACtB,IAAM,EAAE,WAAQ,kBAAe,iBAAc,aAAaC,GACpDC,IACJD,EAAK,UAAWE,GACZC,IAAKC,IAASA;CAEpB,OAAO;EACL,QAAQ,GAAK;GAGX,IAAMC,oBAAY,IAAI,IAA4B,GAC5CC,oBAAU,IAAI,IAAoB,GAClCC,IAAQC,EAAI,QAAQ,SAAS;GACnC,KAAK,IAAMC,KAAMD,EAAI,YAAY;IAC/B,IAAME,IAAMF,EAAI,QAAQ,QAAQC,CAAE,KAAK,EAAE,MAAG;IAE5C,AADAJ,EAAU,IAAII,GAAIC,CAAG,GACrBJ,EAAQ,IAAIG,GAAIF,EAAM,WAAW,MAAMI,EAAE,OAAOF,CAAE,CAAC;GACrD;GAEA,AADAG,EAAWJ,EAAI,SAASZ,GAAWS,CAAS,GAC5CO,EAAWJ,EAAI,SAASV,GAASQ,CAAO;EAC1C;EAEA,MAAM,GAAK;GACT,IAAIE,EAAI,MAAM;GACd,IAAMC,IAAKD,EAAI,WAAW,IACpBK,IAAKZ,EAAK,UAAUO,EAAI,OAAO,IAAIC,CAAE,CAAE,GACvCK,IAAKb,EAAK,UAAUO,EAAI,QAAQ,IAAIC,CAAE,CAAE,GACxCM,IAAKD,EAAG,IAAID,EAAG,GACfG,IAAKF,EAAG,IAAID,EAAG;GAErB,IADeE,IAAKA,IAAKC,IAAKA,KAAMb,GAElC,OAAO;GAET,IAAIc,MAAkB,UAAU;IAC9B,IAAMZ,IAAYa,EAAWV,EAAI,SAASZ,CAAS,GAC7CU,IAAUY,EAAWV,EAAI,SAASV,CAAO,GACzCY,IAAML,GAAW,IAAII,CAAE,KAAK,EAAE,MAAG,GACjCU,IAAQb,GAAS,IAAIG,CAAE,KAAK;IAElC,OAAO,CADYW,EAAe;KAAE,MAAMV;KAAK,OAAOW;KAAa;IAAM,CAAC,CACnE;GACT;GAIA,OAAO;EACT;CACF;AACF"}
+{"version":3,"file":"snapBackOrDelete.js","names":["SNAPSHOTS","scratchKey","INDEXES","snapBackOrDelete","args","proj","AUTO_ORIGIN_PROJECTION","r2","radius","snapshots","indexes","nodes","ctx","id","obj","n","setScratch","o0","o1","dx","dy","onFreeRelease","getScratch","indexOf","dragged","q","p","createDeleteOp","deleteLabel"],"sources":["../../../../../src/interactions/actions/move/behaviors/snapBackOrDelete.ts"],"sourcesContent":["import { createDeleteOp } from 'core/ops/delete';\nimport type { Op } from 'core/ops/types';\nimport type { MoveBehavior } from '../../../gestures/types';\nimport {\n  AUTO_ORIGIN_PROJECTION,\n  type OriginProjection,\n} from '../../../gestures/shared/originProjection';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\n\nconst SNAPSHOTS = scratchKey<Map<string, { id: string }>>('snapBackOrDelete.snapshots');\nconst INDEXES = scratchKey<Map<string, number>>('snapBackOrDelete.indexes');\n\n/**\n * Move behavior for a drag that is only meaningful near where it started:\n * release inside `radius` and every dragged node returns to its original\n * pose; release outside it and they all either spring back anyway or are\n * deleted, per `onFreeRelease`. The distance is the first dragged node's. A\n * deletion is recorded as undoable ops with paint order preserved.\n */\nexport function snapBackOrDelete<TPose extends { x: number; y: number }>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n}): MoveBehavior<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the behavior how\n *  to read and write the pose's origin. */\nexport function snapBackOrDelete<TPose>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n  origin: OriginProjection<TPose>;\n}): MoveBehavior<TPose>;\n/** Snap back to the origin pose, or delete, depending on where the drag is\n *  released. */\nexport function snapBackOrDelete<TPose>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n  origin?: OriginProjection<TPose>;\n}): MoveBehavior<TPose> {\n  const { radius, onFreeRelease, deleteLabel = 'Delete' } = args;\n  const proj: OriginProjection<TPose> =\n    args.origin ?? (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const r2 = radius * radius;\n\n  return {\n    onStart(ctx) {\n      // Snapshot the dragged objects + their z-indexes at gesture start so\n      // delete can undo with paint order intact.\n      const snapshots = new Map<string, { id: string }>();\n      const indexes = new Map<string, number>();\n      const nodes = ctx.adapter.getNodes();\n      for (const id of ctx.draggedIds) {\n        const obj = ctx.adapter.getNode(id) ?? { id };\n        snapshots.set(id, obj);\n        indexes.set(id, nodes.findIndex((n) => n.id === id));\n      }\n      setScratch(ctx.scratch, SNAPSHOTS, snapshots);\n      setScratch(ctx.scratch, INDEXES, indexes);\n    },\n\n    onEnd(ctx) {\n      if (ctx.snap) return;\n      const id = ctx.draggedIds[0];\n      const o0 = proj.getOrigin(ctx.origin.get(id)!);\n      const o1 = proj.getOrigin(ctx.current.get(id)!);\n      const dx = o1.x - o0.x;\n      const dy = o1.y - o0.y;\n      const within = dx * dx + dy * dy <= r2;\n      if (within) {\n        return null;\n      }\n      if (onFreeRelease === 'delete') {\n        const snapshots = getScratch(ctx.scratch, SNAPSHOTS);\n        const indexes = getScratch(ctx.scratch, INDEXES);\n        const indexOf = (dragged: string): number => indexes?.get(dragged) ?? -1;\n        // Topmost first, so an undo, which replays in reverse, restores each index in turn.\n        return [...ctx.draggedIds]\n          .sort((p, q) => indexOf(q) - indexOf(p))\n          .map((dragged): Op => createDeleteOp({\n            node: snapshots?.get(dragged) ?? { id: dragged },\n            label: deleteLabel,\n            index: indexOf(dragged),\n          }));\n      }\n      // `'snap-back'` — abort, same as a release inside the radius. Returning\n      // `undefined` would defer to the default translate and leave the node\n      // where it was dropped, which is the one thing this policy rules out.\n      return null;\n    },\n  };\n}\n"],"mappings":";;;;AASA,IAAMA,IAAYC,EAAwC,4BAA4B,GAChFC,IAAUD,EAAgC,0BAA0B;AAwB1E,SAAgBE,EAAwB,GAKhB;CACtB,IAAM,EAAE,WAAQ,kBAAe,iBAAc,aAAaC,GACpDC,IACJD,EAAK,UAAWE,GACZC,IAAKC,IAASA;CAEpB,OAAO;EACL,QAAQ,GAAK;GAGX,IAAMC,oBAAY,IAAI,IAA4B,GAC5CC,oBAAU,IAAI,IAAoB,GAClCC,IAAQC,EAAI,QAAQ,SAAS;GACnC,KAAK,IAAMC,KAAMD,EAAI,YAAY;IAC/B,IAAME,IAAMF,EAAI,QAAQ,QAAQC,CAAE,KAAK,EAAE,MAAG;IAE5C,AADAJ,EAAU,IAAII,GAAIC,CAAG,GACrBJ,EAAQ,IAAIG,GAAIF,EAAM,WAAW,MAAMI,EAAE,OAAOF,CAAE,CAAC;GACrD;GAEA,AADAG,EAAWJ,EAAI,SAASZ,GAAWS,CAAS,GAC5CO,EAAWJ,EAAI,SAASV,GAASQ,CAAO;EAC1C;EAEA,MAAM,GAAK;GACT,IAAIE,EAAI,MAAM;GACd,IAAMC,IAAKD,EAAI,WAAW,IACpBK,IAAKZ,EAAK,UAAUO,EAAI,OAAO,IAAIC,CAAE,CAAE,GACvCK,IAAKb,EAAK,UAAUO,EAAI,QAAQ,IAAIC,CAAE,CAAE,GACxCM,IAAKD,EAAG,IAAID,EAAG,GACfG,IAAKF,EAAG,IAAID,EAAG;GAErB,IADeE,IAAKA,IAAKC,IAAKA,KAAMb,GAElC,OAAO;GAET,IAAIc,MAAkB,UAAU;IAC9B,IAAMZ,IAAYa,EAAWV,EAAI,SAASZ,CAAS,GAC7CU,IAAUY,EAAWV,EAAI,SAASV,CAAO,GACzCqB,KAAW,MAA4Bb,GAAS,IAAIc,CAAO,KAAK;IAEtE,OAAO,CAAC,GAAGZ,EAAI,UAAU,CAAC,CACvB,MAAM,GAAG,MAAMW,EAAQE,CAAC,IAAIF,EAAQG,CAAC,CAAC,CAAC,CACvC,KAAK,MAAgBC,EAAe;KACnC,MAAMlB,GAAW,IAAIe,CAAO,KAAK,EAAE,IAAIA,EAAQ;KAC/C,OAAOI;KACP,OAAOL,EAAQC,CAAO;IACxB,CAAC,CAAC;GACN;GAIA,OAAO;EACT;CACF;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");
@@ -15,25 +15,30 @@ function s(e) {
 	e.pendingTimer !== null && (clearTimeout(e.pendingTimer), e.pendingTimer = null), e.pendingTargetId = null;
 }
 function c(n) {
-	let { dwellMs: r, findTarget: i, isInstant: a, moveLabel: c = "Move", reparentLabel: l = "Move and reparent" } = n;
+	let { dwellMs: r, findTarget: i, isInstant: a, moveLabel: c = "Move", reparentLabel: l = "Move and reparent" } = n, u = (e, t) => {
+		let [n, ...r] = e.draggedIds, a = /* @__PURE__ */ new Map([[n, t.slotPose]]);
+		for (let n of r) {
+			let r = i(n, e.pointer.worldX, e.pointer.worldY);
+			r?.parentId === t.parentId && a.set(n, r.slotPose);
+		}
+		return a;
+	}, d = (e, t) => ({
+		pose: t.slotPose,
+		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);
 			if (n.committedSnap) {
-				if (c && c.parentId === n.committedSnap.parentId) return {
-					pose: n.committedSnap.slotPose,
-					snap: n.committedSnap
-				};
+				if (c && c.parentId === n.committedSnap.parentId) return d(e, n.committedSnap);
 				n.committedSnap = null;
 			}
 			if (!c) {
 				s(n);
 				return;
 			}
-			if (a?.(c)) return s(n), n.committedSnap = c, {
-				pose: c.slotPose,
-				snap: c
-			};
+			if (a?.(c)) return s(n), n.committedSnap = c, d(e, c);
 			n.pendingTargetId !== c.parentId && (s(n), n.pendingTargetId = c.parentId, n.pendingTimer = setTimeout(() => {
 				n.committedSnap = c, n.pendingTimer = null;
 			}, r));
@@ -41,23 +46,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 = n.draggedIds[0], u = n.adapter.getParent?.(a) ?? null, d = n.origin.get(a), f = [e({
-				id: a,
-				from: d,
-				to: i.slotPose,
+		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) ?? null;
+				r !== a.parentId && d.push(e({
+					id: t,
+					fromParentId: r,
+					toParentId: a.parentId,
+					label: l
+				}));
+			}, p = u(n, a);
+			for (let [e, r] of p) d.push(t({
+				id: e,
+				from: n.origin.get(e),
+				to: r,
 				label: c
-			})];
-			return u !== i.parentId && f.push(t({
-				id: a,
-				fromParentId: u,
-				toParentId: i.parentId,
-				label: l
-			})), f;
+			})), 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","target","findTarget","isInstant","dwellMs","snap","draggedId","oldParent","fromPose","ops","createTransformOp","moveLabel","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 { 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 node into a container it hovers over\n * for `dwellMs`, reparenting it and taking the pose the container's layout\n * assigns.\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  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 { pose: s.committedSnap.slotPose, snap: 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 { pose: target.slotPose, snap: 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 draggedId = ctx.draggedIds[0];\n      const oldParent = ctx.adapter.getParent?.(draggedId) ?? null;\n      const fromPose = ctx.origin.get(draggedId)!;\n      const ops: Op[] = [\n        createTransformOp<TPose>({\n          id: draggedId,\n          from: fromPose,\n          to: snap.slotPose,\n          label: moveLabel,\n        }),\n      ];\n      if (oldParent !== snap.parentId) {\n        ops.push(createReparentOp({\n          id: draggedId,\n          fromParentId: oldParent,\n          toParentId: snap.parentId,\n          label: reparentLabel,\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;AAUA,SAAgBK,EAAuB,GAUf;CACtB,IAAM,EAAE,YAAS,eAAY,cAAW,eAAY,QAAQ,mBAAgB,wBAAwBC;CAEpG,OAAO;EACL,OAAO,GAAK,GAAW;GACrB,IAAMN,IAAID,EAAgBG,CAAG,GACvBK,IAASC,EAAWN,EAAI,WAAW,IAAIA,EAAI,QAAQ,QAAQA,EAAI,QAAQ,MAAM;GAEnF,IAAIF,EAAE,eAAe;IACnB,IAAIO,KAAUA,EAAO,aAAaP,EAAE,cAAc,UAChD,OAAO;KAAE,MAAMA,EAAE,cAAc;KAAU,MAAMA,EAAE;IAAc;IAEjE,EAAE,gBAAgB;GACpB;GAEA,IAAI,CAACO,GAAQ;IACX,EAAWP,CAAC;IACZ;GACF;GAEA,IAAIS,IAAYF,CAAM,GAGpB,OAFAH,EAAWJ,CAAC,GACZ,EAAE,gBAAgBO,GACX;IAAE,MAAMA,EAAO;IAAU,MAAMA;GAAO;GAG/C,AAAIP,EAAE,oBAAoBO,EAAO,aAGjCH,EAAWJ,CAAC,GACZ,EAAE,kBAAkBO,EAAO,UAC3B,EAAE,eAAe,iBAAiB;IAEhC,AADA,EAAE,gBAAgBA,GAClB,EAAE,eAAe;GACnB,GAAGG,CAAO;EAEZ;EAEA,SAAS,GAAK;GAAE,EAAWX,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,IAAMC,IAAYV,EAAI,WAAW,IAC3BW,IAAYX,EAAI,QAAQ,YAAYU,CAAS,KAAK,MAClDE,IAAWZ,EAAI,OAAO,IAAIU,CAAS,GACnCG,IAAY,CAChBC,EAAyB;IACvB,IAAIJ;IACJ,MAAME;IACN,IAAIH,EAAK;IACT,OAAOM;GACT,CAAC,CACH;GASA,OARIJ,MAAcF,EAAK,YACrBI,EAAI,KAAKG,EAAiB;IACxB,IAAIN;IACJ,cAAcC;IACd,YAAYF,EAAK;IACjB,OAAOQ;GACT,CAAC,CAAC,GAEGJ;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","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    ({ 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, 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) ?? 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      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,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,GAAK;GACd,IAAMF,IAAID,EAAgBG,CAAG;GAC7B,EAAWF,CAAC;GACZ,IAAMW,IAAOX,EAAE,iBAAiBE,EAAI;GACpC,IAAI,CAACS,GAAM;GACX,IAAMQ,IAAY,CAAC,GACbC,KAAY,MAAqB;IACrC,IAAMC,IAAYnB,EAAI,QAAQ,YAAYU,CAAE,KAAK;IACjD,AAAIS,MAAcV,EAAK,YACrBQ,EAAI,KAAKG,EAAiB;KACxB;KACA,cAAcD;KACd,YAAYV,EAAK;KACjB,OAAOY;IACT,CAAC,CAAC;GAEN,GACMb,IAAQH,EAASL,GAAKS,CAAI;GAChC,KAAK,IAAM,CAACC,GAAIY,MAAOd,GAErB,AADAS,EAAI,KAAKM,EAAyB;IAAE;IAAI,MAAMvB,EAAI,OAAO,IAAIU,CAAE;IAAI;IAAI,OAAOc;GAAU,CAAC,CAAC,GAC1FN,EAASR,CAAE;GAGb,IAAMH,IAAOP,EAAI,WAAW,QAAQ,MAAO,CAACQ,EAAM,IAAIE,CAAE,CAAC;GACzD,EAAI,KAAK,GAAGe,EAAI,aAAalB,CAAI,CAAC;GAClC,KAAK,IAAMG,KAAMH,GAAM,EAASG,CAAE;GAClC,OAAOO;EACT;CACF;AACF"}