@weasel-js/core 1.7.0 → 1.7.2

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

@@ -0,0 +1,760 @@
+import { planeToPlane as e, toPlane as t } from "../../../core/viewport/parallax.js";
+import { dropPreviewOverrides as n, syncPreviewOverrides as r } from "../previewOverrides.js";
+import { IDENTITY_POSE_COMPOSITION as i, composeWorldPose as a, frameAtOrAbove as o, rebaseLocalPose as s } from "../../../core/scene/composeFrame.js";
+import { definesFrame as c, documentPose as l, effectivePose as u } from "../../../core/scene/effectivePose.js";
+import { gesturePlaneReader as d, gestureViewReader as f } from "../../gestures/shared/screenTolerance.js";
+import { commitGestureOps as p, readGestureLifecycle as m, reduceBehaviorEnd as h, runBehaviorCancel as g } from "../gestureLifecycle.js";
+import { asNodeId as _ } from "../../../core/scene/types.js";
+import { SceneArrivalRefused as v } from "../../../core/scene/arrivals.js";
+import { createTransformOp as y } from "../../../core/ops/transform.js";
+import { createReparentOp as b } from "../../../core/ops/reparent.js";
+import { geometryDataOp as x } from "../geometryProjection.js";
+import { poseDescriptorForNode as S, translatePoseViaDescriptor as C } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as w } from "../poseDescriptorDep.js";
+import { moveGestureAdapter as T } from "../move/gestureAdapter.js";
+import { carryPose as E, inPlane as D, invertPlane as ee, planeOf as O, selectionLayer as k } from "../planeInput.js";
+import { pointInPath as A } from "@weasel-js/geom";
+import { DRAG_THRESHOLD_PX as te, isAnchorOrControl as j, pastDragThreshold as M, resolveParams as N } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/move.ts
+function P(e, n) {
+	let r = e.layout;
+	if (!r || !n.drag) return;
+	let i = e.scene, o = e.pc, c = V(i), { dx: l, dy: u } = e.currentDelta, d = (t, n) => {
+		r.reflow ? e.reflowTargets.set(t, n) : e.previews.set(t, n);
+	}, f = e.projection, p = H(e, c), m = [];
+	for (let t of e.ids) {
+		let n = i.get(t);
+		if (!n) continue;
+		let r = a(p, t, o.compose), s = S(f, n), c = z(e, t, l, u), d = ee(O(e.view, n.layer)), h = E(s, C(r, c.dx, c.dy, s), d), g = s.getBounds(h);
+		m.push({
+			id: t,
+			arg: {
+				id: t,
+				originPose: E(s, r, d),
+				pose: h,
+				sourceContainerId: n.parent ?? null
+			},
+			center: {
+				x: g.x + g.width / 2,
+				y: g.y + g.height / 2
+			}
+		});
+	}
+	let h = (e, n) => {
+		if (n === null) return e;
+		let r = S(f, i.get(e.id));
+		return {
+			id: e.id,
+			arg: {
+				...e.arg,
+				originPose: E(r, e.arg.originPose, n),
+				pose: E(r, e.arg.pose, n)
+			},
+			center: t(n, e.center)
+		};
+	};
+	if (m.length === 0) return;
+	let g = new Set(m.map((e) => e.id)), v = Infinity, y = Infinity, b = -Infinity, x = -Infinity;
+	for (let e of m) {
+		let t = f.getBounds(e.arg.pose);
+		v = Math.min(v, t.x), y = Math.min(y, t.y), b = Math.max(b, t.x + t.width), x = Math.max(x, t.y + t.height);
+	}
+	let w = {
+		x: (v + b) / 2,
+		y: (y + x) / 2
+	};
+	e.dropCenter = w;
+	let T = {
+		x: n.drag.current.x - w.x,
+		y: n.drag.current.y - w.y
+	}, D = [], k = r.dropTarget ?? "innermost", A = (e, t, n, r, i) => {
+		let a = r.dropRegion?.({
+			id: e,
+			bounds: n
+		}) ?? null;
+		return a ? F(a, n, i) : k === "region" ? !1 : r.contains ? r.contains(t, i) : i.x >= n.x && i.x < n.x + n.width && i.y >= n.y && i.y < n.y + n.height;
+	}, te = (n, s) => {
+		if (g.has(n)) return;
+		let l = r.getLayout(n);
+		if (!l) return;
+		let u = i.get(n);
+		if (!u) return;
+		let d = a(c, n, o.compose), p = S(f, u).getBounds(d), _ = O(e.view, u.layer), v = _ ? t(_, w) : w;
+		if (A(n, d, p, l, v)) {
+			if (l.acceptsDrop) {
+				let e = {
+					id: n,
+					bounds: p
+				};
+				for (let t of m) if (!l.acceptsDrop(e, h(t, _).arg)) return;
+			}
+			D.push({
+				id: n,
+				bounds: p,
+				layout: l,
+				zPath: s,
+				depth: s.length,
+				plane: _
+			});
+		}
+	}, j = (e, t) => {
+		let n = e === null ? i.roots : i.childrenOf(e);
+		for (let e = 0; e < n.length; e++) {
+			let r = [...t, e];
+			te(n[e], r), j(n[e], r);
+		}
+	};
+	j(null, []);
+	let M = null;
+	if (k === "topmost") {
+		let e = new Map(D.map((e) => [e.id, e]));
+		for (let t of i.renderOrder()) M = e.get(t) ?? M;
+	} else for (let e of D) {
+		if (M === null) {
+			M = e;
+			continue;
+		}
+		if (e.depth > M.depth) {
+			M = e;
+			continue;
+		}
+		if (e.depth < M.depth) continue;
+		let t = !1;
+		for (let n = 0; n < e.zPath.length; n++) {
+			if (e.zPath[n] > M.zPath[n]) {
+				t = !0;
+				break;
+			}
+			if (e.zPath[n] < M.zPath[n]) {
+				t = !1;
+				break;
+			}
+		}
+		t && (M = e);
+	}
+	if (!M) return;
+	let N = M.layout, P = {
+		id: M.id,
+		bounds: M.bounds
+	}, I = i.childrenOf(M.id).map((e) => ({
+		id: e,
+		pose: a(c, e, o.compose)
+	})), L = (e, t) => {
+		let n = I.findIndex((t) => t.id === e);
+		n >= 0 ? I[n] = {
+			id: e,
+			pose: t
+		} : I.push({
+			id: e,
+			pose: t
+		});
+	}, R = [], B = /* @__PURE__ */ new Map(), U = M.plane;
+	for (let e of m) {
+		let n = h(e, U), r = I.map((e) => ({ ...e })), i = N.getDropTargets(P, r, n.arg), a = {
+			x: e.center.x + T.x,
+			y: e.center.y + T.y
+		}, o = N.snap.pickTarget(i, U ? t(U, a) : a);
+		if (!o) return;
+		R.push({
+			dragged: n.arg,
+			children: r,
+			target: o
+		});
+		let s = N.reflowPoses(P, r, n.arg, o);
+		for (let [e, t] of s) L(e, t), g.has(_(e)) || B.set(_(e), t);
+		L(n.arg.id, s.get(n.arg.id) ?? o.pose);
+	}
+	let W = /* @__PURE__ */ new Set();
+	for (let [e, t] of B) {
+		let n = i.get(e)?.parent ?? null;
+		d(e, s(c, t, n, o.compose, o.decompose)), W.add(e);
+	}
+	let G = /* @__PURE__ */ new Map();
+	for (let [e, t] of ne(m.map((e) => ({
+		id: e.id,
+		sourceContainerId: e.arg.sourceContainerId
+	})), P.id)) {
+		let n = r.getLayout(e), l = i.get(_(e));
+		if (!n || !l) continue;
+		let u = {
+			id: e,
+			bounds: f.getBounds(a(c, e, o.compose))
+		}, p = i.childrenOf(_(e)).filter((e) => !t.has(e)).map((e) => ({
+			id: e,
+			pose: a(c, e, o.compose)
+		}));
+		for (let [e, t] of n.childPoses(u, p)) {
+			let n = f.getBounds(a(c, e, o.compose)), r = f.getBounds(t);
+			if (n.x === r.x && n.y === r.y && n.width === r.width && n.height === r.height) continue;
+			G.set(e, t);
+			let l = i.get(_(e))?.parent ?? null;
+			d(_(e), s(c, t, l, o.compose, o.decompose)), W.add(_(e));
+		}
+	}
+	e.layoutPass = {
+		layout: N,
+		container: P,
+		placements: R,
+		sourceReflow: G,
+		reflowIds: W
+	};
+}
+function F(e, t, n) {
+	let r = {
+		x: n.x - t.x,
+		y: n.y - t.y
+	};
+	return typeof e == "function" ? e(r) : A(e, r.x, r.y);
+}
+function ne(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		let e = r.sourceContainerId;
+		if (!e || e === t) continue;
+		let i = n.get(e);
+		i || (i = /* @__PURE__ */ new Set(), n.set(e, i)), i.add(r.id);
+	}
+	return n;
+}
+function I(e, n) {
+	let r = /* @__PURE__ */ new Map(), i = e.layout, o = e.dropCenter;
+	if (!i || !o) return r;
+	let { scene: s, pc: c, projection: l } = e, u = V(s), d = /* @__PURE__ */ new Set([...e.ids, ...e.cascadeIds]), f = (n, r) => {
+		let i = s.get(n), d = O(e.view, i.layer), f = d ? t(d, o) : o, p = a(u, n, c.compose);
+		if (r?.contains) return r.contains(p, f);
+		let m = S(l, i).getBounds(p);
+		return f.x >= m.x && f.x < m.x + m.width && f.y >= m.y && f.y < m.y + m.height;
+	}, p = /* @__PURE__ */ new Map(), m = (e) => {
+		if (p.has(e)) return p.get(e);
+		let t = null, n = -1, r = (a, o) => {
+			for (let c of a === null ? s.roots : s.childrenOf(a)) {
+				if (d.has(c)) continue;
+				let a = s.get(c);
+				a && a.kind === "container" && (a.layer === e && o >= n && i.getLayout(c) === null && f(c, null) && (t = c, n = o), r(c, o + 1));
+			}
+		};
+		return r(null, 0), p.set(e, t), t;
+	};
+	for (let e of n) {
+		let t = s.get(e), n = t?.parent ?? null;
+		if (!t || n === null) continue;
+		let a = i.getLayout(n);
+		a && !f(n, a) && r.set(e, m(t.layer));
+	}
+	return r;
+}
+function L(e, t, n, r) {
+	let i = [];
+	for (let a of t) {
+		if (!e.startPoses.has(a) || e.carried.has(a)) continue;
+		let t = e.scene.get(a);
+		if (!t) continue;
+		let o = R(e, a, n, r), s = e.caught.get(a);
+		s && (o.dx += s.dx, o.dy += s.dy);
+		let c = [
+			1,
+			0,
+			0,
+			1,
+			o.dx,
+			o.dy
+		], l = t.pose;
+		if (i.push(y({
+			id: a,
+			from: l,
+			to: C(l, o.dx, o.dy, e.projection),
+			label: e.lifecycle.label
+		})), e.geometryProjection) {
+			let n = x(e.geometryProjection, {
+				id: a,
+				data: t.data,
+				pose: l
+			}, c, e.lifecycle.label);
+			n && i.push(n);
+		}
+	}
+	return i;
+}
+function R(e, t, n, r) {
+	let { dx: i, dy: a } = z(e, t, n, r), o = e.frames.get(t);
+	if (o === void 0) return {
+		dx: i,
+		dy: a
+	};
+	let { pc: s, projection: c } = e, l = c.getBounds(s.decompose(o.frameWorld, o.world)), u = c.getBounds(s.decompose(o.frameWorld, C(o.world, i, a, c)));
+	return {
+		dx: u.x - l.x,
+		dy: u.y - l.y
+	};
+}
+function z(e, n, r, i) {
+	let a = e.scene.get(n)?.layer, o = a === void 0 ? void 0 : e.planeRefs.get(a);
+	if (!o) return {
+		dx: r,
+		dy: i
+	};
+	let s = O(e.view, a), c = {
+		x: o.edited.x + r,
+		y: o.edited.y + i
+	}, l = s ? t(s, c) : c;
+	return {
+		dx: l.x - o.own.x,
+		dy: l.y - o.own.y
+	};
+}
+function B(e, t) {
+	let n = new Set(e.ids), r = e.ids.filter((e) => !t.has(e));
+	for (let i of e.cascadeIds) {
+		let a = e.scene.get(i)?.parent ?? null, o = !1;
+		for (; a;) {
+			if (t.has(a)) {
+				o = !0;
+				break;
+			}
+			if (n.has(a)) break;
+			a = e.scene.get(a)?.parent ?? null;
+		}
+		o || r.push(i);
+	}
+	return r;
+}
+function V(e) {
+	return {
+		getPose: (t) => l(e, e.get(t)),
+		getParent: (t) => e.get(t)?.parent ?? null,
+		definesFrame: (t) => {
+			let n = e.get(t);
+			return n === void 0 || c(n);
+		}
+	};
+}
+function H(e, t) {
+	return e.caught.size === 0 ? t : {
+		...t,
+		getPose: (n) => e.caught.has(n) ? e.startPoses.get(n) : t.getPose(n)
+	};
+}
+function U(e) {
+	let t = /* @__PURE__ */ new Map(), { scene: n, pc: r } = e, i = V(n);
+	for (let s of e.startPoses.keys()) {
+		let c = e.previews.get(s);
+		if (c === void 0) continue;
+		let l = n.get(s)?.parent ?? null, u = o(i, l), d = u === null ? c : r.compose(a(i, u, r.compose), c);
+		t.set(s, {
+			local: c,
+			parent: l,
+			world: d
+		});
+	}
+	return t;
+}
+function W(e, t, n) {
+	let { scene: r, pc: i } = e, a = V(r);
+	for (let o of e.startPoses.keys()) {
+		let c = n.get(o);
+		if (!c) {
+			e.caught.has(o) && t.settle(o);
+			continue;
+		}
+		let l = r.get(o)?.parent ?? null, u = l === c.parent ? c.local : s(a, c.world, l, i.compose, i.decompose);
+		t.settle(o, { from: u });
+	}
+}
+function G(e, t) {
+	let n = e.deps.nodeAtPoint;
+	if (!n) return null;
+	let r = /* @__PURE__ */ new Set([...t.ids, ...t.cascadeIds]), i = n(e.world, r);
+	if (!i) return null;
+	let a = t.scene.get(i);
+	return a ? a.kind === "container" ? {
+		newParent: i,
+		newLayer: a.layer,
+		hitSibling: null
+	} : {
+		newParent: a.parent,
+		newLayer: a.layer,
+		hitSibling: i
+	} : null;
+}
+function re(t, n, r, i, o, c) {
+	let l = t.scene, u = V(l);
+	for (let d of t.ids) {
+		if (!t.startPoses.has(d)) continue;
+		let f = a(u, d, c.compose), p = z(t, d, i, o), m = l.get(d).layer, h = E(t.projection, C(f, p.dx, p.dy, t.projection), m === n.newLayer ? null : e(O(t.view, m), O(t.view, n.newLayer))), g = s(u, h, n.newParent, c.compose, c.decompose), _ = l.get(d);
+		_.layer !== n.newLayer && (_.parent !== null && l.move(d, null), l.setLayer(d, n.newLayer));
+		let v;
+		if (r === "above" && n.hitSibling) {
+			let e = (n.newParent === null ? l.roots : l.childrenOf(n.newParent)).filter((e) => e !== d).indexOf(n.hitSibling);
+			e >= 0 && (v = e + 1);
+		}
+		l.move(d, n.newParent, v), l.setPose(d, g);
+	}
+}
+var K = D({
+	id: "move",
+	label: "Move",
+	activeCursor: "move",
+	defaultBinding: {
+		kind: "drag",
+		target: "selected-body"
+	},
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"poseDescriptor",
+		"layout",
+		"applyOps",
+		"poseComposition",
+		"geometryProjection",
+		"nodeAtPoint",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(e, c) {
+			let x = e.deps.selection, S = e.deps.scene, E = w(e.deps.poseDescriptor), D = e.deps.layout, k = e.deps.applyOps, A = e.deps.geometryProjection, F = e.deps.poseComposition ?? i;
+			if (!x || !S || j(e.drag?.affordance)) return {};
+			let K = N(c?.params), ie = K?.expandIds, ae = [...x.get()], q = ie ? ie(ae) : ae;
+			if (q.length === 0) return {};
+			let J = /* @__PURE__ */ new Map(), oe = [], Y = /* @__PURE__ */ new Set(), X = [], Z = D?.reflow ?? null, se = /* @__PURE__ */ new Map(), ce = (e, t) => {
+				let n = Z?.poseOf(e);
+				if (!Z || n === void 0) return;
+				Z.glide(e, n, { from: n });
+				let r = E.getBounds(n), i = E.getBounds(l(S, t));
+				se.set(e, {
+					dx: r.x - i.x,
+					dy: r.y - i.y
+				});
+			};
+			for (let e of q) {
+				let t = S.get(e);
+				t && (ce(e, t), J.set(e, u(S, t)), Y.add(e), X.push(e));
+			}
+			for (; X.length > 0;) {
+				let e = X.shift();
+				for (let t of S.childrenOf(e)) {
+					if (Y.has(t)) continue;
+					Y.add(t);
+					let e = S.get(t);
+					e && (ce(t, e), J.set(t, u(S, e)), oe.push(t), X.push(t));
+				}
+			}
+			let le = /* @__PURE__ */ new Set(), ue = /* @__PURE__ */ new Map();
+			if (F.closure !== "identity") {
+				let e = V(S);
+				for (let t of J.keys()) {
+					let n = o(e, S.get(t)?.parent ?? null);
+					if (n !== null) {
+						if (J.has(_(n))) {
+							le.add(t);
+							continue;
+						}
+						ue.set(t, {
+							world: a(e, t, F.compose),
+							frameWorld: a(e, n, F.compose)
+						});
+					}
+				}
+			}
+			let de = c?.behaviors ?? [], fe = K?.dragThresholdPx ?? te, Q = m(K, "Move", de), pe = !1, me = T(S), he = /* @__PURE__ */ new Map();
+			for (let [e, t] of J) he.set(e, t);
+			let ge = f(e.deps), _e = d(e.deps), ve = {
+				draggedIds: q,
+				origin: he,
+				current: new Map(he),
+				snap: null,
+				modifiers: { ...e.modifiers },
+				pointer: {
+					worldX: e.world.x,
+					worldY: e.world.y,
+					clientX: 0,
+					clientY: 0
+				},
+				view: ge(),
+				plane: _e(),
+				adapter: me,
+				scratch: {}
+			};
+			for (let e of de) e.onStart?.(ve);
+			let $ = {
+				startPoses: J,
+				ids: q,
+				cascadeIds: oe,
+				carried: le,
+				frames: ue,
+				scene: S,
+				currentDelta: {
+					dx: 0,
+					dy: 0
+				},
+				view: e.deps.view,
+				planeRefs: /* @__PURE__ */ new Map(),
+				previews: /* @__PURE__ */ new Map(),
+				overrideEntries: /* @__PURE__ */ new Map(),
+				reflowTargets: /* @__PURE__ */ new Map(),
+				gliding: /* @__PURE__ */ new Set(),
+				caught: se,
+				projection: E,
+				behaviors: de,
+				gestureCtx: ve,
+				adapter: me,
+				layout: D,
+				layoutPass: null,
+				dropCenter: null,
+				pc: F,
+				applyOps: k,
+				geometryProjection: A,
+				lifecycle: Q
+			};
+			for (let e of q) {
+				let n = S.get(e)?.layer;
+				if (n === void 0 || $.planeRefs.has(n)) continue;
+				let r = O($.view, n);
+				if (r === null) continue;
+				let i = ue.get(e)?.world ?? J.get(e);
+				if (i === void 0) continue;
+				let a = E.getBounds(i), o = {
+					x: a.x,
+					y: a.y
+				};
+				$.planeRefs.set(n, {
+					own: o,
+					edited: t(ee(r), o)
+				});
+			}
+			let ye = (e) => {
+				let { dx: t, dy: n } = $.currentDelta, r = !1, i = (e) => {
+					p($, Q, e), r = !0;
+				};
+				if ($.behaviors.length > 0) {
+					let e = $.gestureCtx;
+					for (let [r, i] of $.startPoses) {
+						let a = z($, r, t, n);
+						e.current.set(r, C(i, a.dx, a.dy, $.projection));
+					}
+					let r = h($.behaviors, e);
+					if (r === null) return !1;
+					if (r !== void 0) return i(r), !0;
+				}
+				if (t === 0 && n === 0) return !1;
+				if ($.layout && $.layoutPass) {
+					let e = $.layoutPass, t = $.pc, n = V($.scene), a = e.container.id, o = new Set($.ids.map((e) => e)), c = (e) => {
+						if (e.name !== "transform") return e;
+						let r = e.args, i = $.scene.get(_(r.id))?.parent ?? null, c = o.has(r.id) ? a : i;
+						return y({
+							id: r.id,
+							from: s(n, r.from, i, t.compose, t.decompose),
+							to: s(n, r.to, c, t.compose, t.decompose),
+							label: r.label,
+							coalesceKey: r.coalesceKey
+						});
+					}, l = [], u = [];
+					for (let t of e.placements) {
+						t.dragged.sourceContainerId !== a && l.push(b({
+							id: t.dragged.id,
+							fromParentId: t.dragged.sourceContainerId,
+							toParentId: a,
+							label: "Reparent"
+						}));
+						let n = e.layout.commitDrop(e.container, t.children, t.dragged, t.target);
+						for (let e of n) u.push(c(e));
+					}
+					let d = [];
+					for (let [r, i] of e.sourceReflow) {
+						let e = $.scene.get(_(r))?.parent ?? null;
+						d.push(y({
+							id: r,
+							from: $.scene.get(_(r)).pose,
+							to: s(n, i, e, t.compose, t.decompose),
+							label: "Source reflow"
+						}));
+					}
+					let f = [
+						...l,
+						...u,
+						...d
+					];
+					return f.length > 0 && i(f), r;
+				}
+				let o = /* @__PURE__ */ new Set(), l = [], u = /* @__PURE__ */ new Map(), d = [];
+				if ($.layout && !$.layoutPass) {
+					let e = $.pc, r = V($.scene), i = (t) => {
+						if (t.name !== "transform") return t;
+						let n = t.args, i = $.scene.get(_(n.id))?.parent ?? null;
+						return y({
+							id: n.id,
+							from: s(r, n.from, i, e.compose, e.decompose),
+							to: s(r, n.to, i, e.compose, e.decompose),
+							label: n.label,
+							coalesceKey: n.coalesceKey
+						});
+					}, c = ne($.ids.map((e) => ({
+						id: e,
+						sourceContainerId: $.scene.get(e)?.parent ?? null
+					})), null);
+					for (let [s, u] of c) {
+						let c = $.layout.getLayout(s);
+						if (!c?.releaseDrop) continue;
+						let d = {
+							id: s,
+							bounds: $.projection.getBounds(a(r, s, e.compose))
+						}, f = $.scene.childrenOf(_(s)).filter((e) => !u.has(e)).map((t) => ({
+							id: t,
+							pose: a(r, t, e.compose)
+						}));
+						for (let p of u) {
+							let u = a(H($, r), p, e.compose), m = z($, p, t, n), h = c.releaseDrop(d, f, {
+								id: p,
+								originPose: u,
+								pose: C(u, m.dx, m.dy, $.projection),
+								sourceContainerId: s
+							});
+							if (h === null) continue;
+							o.add(p);
+							let g = u;
+							for (let e of h) {
+								let t = e.args;
+								e.name === "transform" && t.id === p && (g = t.to), l.push(i(e));
+							}
+							f = [...f, {
+								id: p,
+								pose: g
+							}];
+						}
+					}
+					u = I($, $.ids.filter((e) => !o.has(e)));
+					for (let [i, o] of u) {
+						let c = $.scene.get(i), l = a(H($, r), i, e.compose), u = z($, i, t, n), f = C(l, u.dx, u.dy, $.projection);
+						d.push(b({
+							id: i,
+							fromParentId: c.parent,
+							toParentId: o,
+							label: "Reparent"
+						})), d.push(y({
+							id: i,
+							from: c.pose,
+							to: s(r, f, o, e.compose, e.decompose),
+							label: Q.label
+						}));
+					}
+				}
+				if (o.size > 0 || u.size > 0) {
+					let e = [
+						...l,
+						...d,
+						...L($, B($, o).filter((e) => !u.has(e)), t, n)
+					];
+					return e.length > 0 && i(e), r;
+				}
+				let f = N(c?.params)?.reparentOnDrop ?? "off", m = f === "off" ? null : G(e, $);
+				if (m) {
+					let e = () => re($, m, f, t, n, $.pc);
+					try {
+						Q.transient ? $.scene.untracked(e) : $.scene.batch(Q.label, e), r = !0;
+					} catch (e) {
+						if (!(e instanceof v)) throw e;
+					}
+				} else {
+					let e = L($, [...$.ids, ...$.cascadeIds], t, n);
+					e.length > 0 && i(e);
+				}
+				return r;
+			};
+			return {
+				kind: "move",
+				onMove(e) {
+					if (!e.drag) return;
+					if (!pe) {
+						let t = e.drag.screenDelta;
+						if (t && !M({
+							clientX: 0,
+							clientY: 0
+						}, {
+							clientX: t.x,
+							clientY: t.y
+						}, fe)) return;
+						pe = !0, Q.start($.ids);
+					}
+					let t = e.drag.delta.x, n = e.drag.delta.y;
+					if ($.behaviors.length > 0) {
+						let r = $.gestureCtx;
+						r.modifiers = { ...e.modifiers }, r.pointer = {
+							worldX: e.drag.current.x,
+							worldY: e.drag.current.y,
+							clientX: 0,
+							clientY: 0
+						}, r.view = ge(), r.plane = _e();
+						for (let [e, i] of $.startPoses) {
+							let a = z($, e, t, n);
+							r.current.set(e, C(i, a.dx, a.dy, $.projection));
+						}
+						let i = {
+							kind: "translate",
+							dx: t,
+							dy: n
+						}, a = $.ids[0];
+						for (let e of $.behaviors) {
+							let t = e.onMove?.(r, i);
+							if (t) {
+								if (t.transform && t.transform.kind === "translate") i = t.transform;
+								else if (t.pose !== void 0 && a !== void 0) {
+									let e = $.startPoses.get(a);
+									if (e !== void 0) {
+										let n = $.projection.getBounds(e), r = $.projection.getBounds(t.pose);
+										i = {
+											kind: "translate",
+											dx: r.x - n.x,
+											dy: r.y - n.y
+										};
+									}
+								}
+								t.snap !== void 0 && (r.snap = t.snap);
+							}
+						}
+						i.kind === "translate" && (t = i.dx, n = i.dy);
+					}
+					$.currentDelta = {
+						dx: t,
+						dy: n
+					}, $.previews.clear();
+					for (let [e, r] of $.startPoses) {
+						if ($.carried.has(e)) {
+							$.previews.set(e, r);
+							continue;
+						}
+						let i = R($, e, t, n);
+						$.previews.set(e, C(r, i.dx, i.dy, $.projection));
+					}
+					$.layoutPass = null, $.dropCenter = null, $.reflowTargets.clear(), P($, e);
+					let i = $.layout?.reflow;
+					if (i) {
+						for (let [e, t] of $.reflowTargets) i.glide(e, t), $.gliding.add(e);
+						for (let e of $.gliding) $.reflowTargets.has(e) || (i.settle(e), $.gliding.delete(e));
+					}
+					r($);
+				},
+				onEnd(e, t) {
+					let r = !1, i = $.layout?.reflow ?? null, a = i ? U($) : null;
+					try {
+						t === "commit" ? r = ye(e) : g($.behaviors, $.gestureCtx);
+					} finally {
+						if (n($), $.previews.clear(), i && a) {
+							for (let e of $.gliding) i.settle(e);
+							W($, i, a);
+						}
+						$.gliding.clear(), Q.end(r);
+					}
+				},
+				previewIds: () => $.previews.keys(),
+				previewPose: (e) => $.previews.get(e) ?? null,
+				previewOpaqueIds: () => $.layoutPass?.reflowIds ?? null
+			};
+		}
+	},
+	enabled: () => !0
+}, k);
+//#endregion
+export { K as moveAction };
+
+//# sourceMappingURL=move.js.map