@weasel-js/core 1.7.0 → 1.7.1

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

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