@weasel-js/core 1.10.1 → 1.11.1

package/dist/interactions/actions/move/commit/reparent.js.map

@@ -1 +1 @@
-{"version":3,"file":"reparent.js","names":["resolveDropTarget","dep","session","hit","at","hitNode","reparentOps","adapter","scenePoseAdapter","scene","label","ops","siblings","target","id","node","crossing","world","carryPose","draggedWorldPose","grabbedPoseAdapter","delta","planeToPlane","planeOf","view","to","rebaseLocalPose","pc","from","createReparentOp","createSetLayerOp","was","mode","toIndex","createTransformOp","translateOps"],"sources":["../../../../../src/interactions/actions/move/commit/reparent.ts"],"sourcesContent":["import { createReparentOp } from 'core/ops/reparent';\nimport { createSetLayerOp } from 'core/ops/setLayer';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { planeToPlane } from 'core/viewport/parallax';\nimport { rebaseLocalPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport { carryPose, planeOf } from '../../planeInput';\nimport { draggedWorldPose, grabbedPoseAdapter } from '../delta';\nimport type { MoveSession, ReparentOnDrop } from '../session';\nimport { translateOps } from '../translate';\n\n/** Resolved drop target — the new parent + layer + (for `'above'` mode)\n *  the hit sibling whose z-order position the moved node should land\n *  immediately above. `newParent === null` means \"land at the layer\n *  root\" (top-level node of `newLayer`). */\nexport interface DropTarget {\n  newParent: NodeId | null;\n  newLayer: string;\n  hitSibling: NodeId | null;\n}\n\n/** Walk the hit chain to find the appropriate drop target. Returns\n *  `null` when no reparent should happen (drop on empty canvas, or the\n *  only hits are the moved subtree itself). */\nexport function resolveDropTarget(\n  session: MoveSession,\n  at: { x: number; y: number },\n): DropTarget | null {\n  const dep = session.nodeAtPoint;\n  if (!dep) return null;\n\n  // Exclude moved roots + their descendants. Otherwise we'd happily\n  // reparent a node into itself (or under one of its own children).\n  const exclude = new Set<NodeId>([...session.ids, ...session.cascadeIds]);\n  const hit = dep(at, exclude);\n  if (!hit) return null;\n\n  const hitNode = session.scene.get(hit);\n  if (!hitNode) return null;\n\n  // Containers act as drop-INTO targets; leaves act as drop-NEXT-TO\n  // targets (parent = leaf's parent). When the leaf has no parent\n  // (top-level under a layer), `newParent === null` and the moved\n  // subtree lands at the layer root.\n  if (hitNode.kind === 'container') {\n    return { newParent: hit, newLayer: hitNode.layer, hitSibling: null };\n  }\n  return {\n    newParent: hitNode.parent,\n    newLayer: hitNode.layer,\n    hitSibling: hit,\n  };\n}\n\n/** Reparent and reposition each moved root as ops, keeping the world pose the\n *  drag showed, then the ops that bring uncarried descendants along. */\nexport function reparentOps(\n  session: MoveSession,\n  target: DropTarget,\n  mode: ReparentOnDrop,\n  delta: { dx: number; dy: number },\n): Op[] {\n  const { scene, pc, view } = session;\n  const adapter = scenePoseAdapter(scene);\n  const label = session.lifecycle.label;\n  const ops: Op[] = [];\n  // The destination's children as each op will find them: an earlier root's\n  // landing shifts where a later one goes.\n  const siblings = [...(target.newParent === null ? scene.roots : scene.childrenOf(target.newParent))];\n  for (const id of session.ids) {\n    if (!session.startPoses.has(id)) continue;\n    const node = scene.get(id)!;\n    const crossing = node.layer !== target.newLayer;\n    const world = carryPose(\n      session.descriptorOf(id),\n      draggedWorldPose(session, grabbedPoseAdapter(session, adapter), id, delta),\n      crossing ? planeToPlane(planeOf(view, node.layer), planeOf(view, target.newLayer)) : null,\n    );\n    const to = rebaseLocalPose(adapter, world, target.newParent as string | null, pc.compose, pc.decompose);\n\n    let from = node.parent as string | null;\n    if (crossing) {\n      // The scene refuses a layer change on a node whose parent is on another layer.\n      if (from !== null) {\n        ops.push(createReparentOp({\n          id: id as string, fromParentId: from, toParentId: null, label, coalesceKey: `reparent:${id}:orphan`,\n        }));\n        from = null;\n      }\n      ops.push(createSetLayerOp({ id: id as string, from: node.layer, to: target.newLayer, label }));\n    }\n\n    const was = siblings.indexOf(id);\n    if (was >= 0) siblings.splice(was, 1);\n    const hit = mode === 'above' && target.hitSibling\n      ? siblings.indexOf(target.hitSibling)\n      : -1;\n    const toIndex = hit >= 0 ? hit + 1 : undefined;\n    if (toIndex === undefined) siblings.push(id);\n    else siblings.splice(toIndex, 0, id);\n\n    ops.push(createReparentOp({\n      id: id as string, fromParentId: from, toParentId: target.newParent as string | null, toIndex, label,\n    }));\n    ops.push(createTransformOp<unknown>({ id: id as string, from: node.pose, to, label }));\n  }\n  return [...ops, ...translateOps(session, session.cascadeIds, delta)];\n}\n"],"mappings":";;;;;;;;;;AA0BA,SAAgBA,EACd,GACA,GACmB;CACnB,IAAMC,IAAMC,EAAQ;CACpB,IAAI,CAACD,GAAK,OAAO;CAKjB,IAAME,IAAMF,EAAIG,mBAAI,IADA,IAAY,CAAC,GAAGF,EAAQ,KAAK,GAAGA,EAAQ,UAAU,CAClD,CAAO;CAC3B,IAAI,CAACC,GAAK,OAAO;CAEjB,IAAME,IAAUH,EAAQ,MAAM,IAAIC,CAAG;CAUrC,OATKE,IAMDA,EAAQ,SAAS,cACZ;EAAE,WAAWF;EAAK,UAAUE,EAAQ;EAAO,YAAY;CAAK,IAE9D;EACL,WAAWA,EAAQ;EACnB,UAAUA,EAAQ;EAClB,YAAYF;CACd,IAbqB;AAcvB;AAIA,SAAgBG,EACd,GACA,GACA,GACA,GACM;CACN,IAAM,EAAE,UAAO,OAAI,YAASJ,GACtBK,IAAUC,EAAiBC,CAAK,GAChCC,IAAQR,EAAQ,UAAU,OAC1BS,IAAY,CAAC,GAGbC,IAAW,CAAC,GAAIC,EAAO,cAAc,OAAOJ,EAAM,QAAQA,EAAM,WAAWI,EAAO,SAAS,CAAE;CACnG,KAAK,IAAMC,KAAMZ,EAAQ,KAAK;EAC5B,IAAI,CAACA,EAAQ,WAAW,IAAIY,CAAE,GAAG;EACjC,IAAMC,IAAON,EAAM,IAAIK,CAAE,GACnBE,IAAWD,EAAK,UAAUF,EAAO,UACjCI,IAAQC,EACZhB,EAAQ,aAAaY,CAAE,GACvBK,EAAiBjB,GAASkB,EAAmBlB,GAASK,CAAO,GAAGO,GAAIO,CAAK,GACzEL,IAAWM,EAAaC,EAAQC,GAAMT,EAAK,KAAK,GAAGQ,EAAQC,GAAMX,EAAO,QAAQ,CAAC,IAAI,IACvF,GACMY,IAAKC,EAAgBnB,GAASU,GAAOJ,EAAO,WAA4Bc,EAAG,SAASA,EAAG,SAAS,GAElGC,IAAOb,EAAK;EAChB,AAAIC,MAEEY,MAAS,SACXjB,EAAI,KAAKkB,EAAiB;GACpB;GAAc,cAAcD;GAAM,YAAY;GAAM;GAAO,aAAa,YAAYd,EAAG;EAC7F,CAAC,CAAC,GACF,IAAO,OAETH,EAAI,KAAKmB,EAAiB;GAAM;GAAc,MAAMf,EAAK;GAAO,IAAIF,EAAO;GAAU;EAAM,CAAC,CAAC;EAG/F,IAAMkB,IAAMnB,EAAS,QAAQE,CAAE;EAC/B,AAAIiB,KAAO,KAAGnB,EAAS,OAAOmB,GAAK,CAAC;EACpC,IAAM5B,IAAM6B,MAAS,WAAWnB,EAAO,aACnCD,EAAS,QAAQC,EAAO,UAAU,IAClC,IACEoB,IAAU9B,KAAO,IAAIA,IAAM,IAAI,KAAA;EAOrC,AANI8B,MAAY,KAAA,IAAWrB,EAAS,KAAKE,CAAE,IACtCF,EAAS,OAAOqB,GAAS,GAAGnB,CAAE,GAEnCH,EAAI,KAAKkB,EAAiB;GACpB;GAAc,cAAcD;GAAM,YAAYf,EAAO;GAA4B;GAAS;EAChG,CAAC,CAAC,GACFF,EAAI,KAAKuB,EAA2B;GAAM;GAAc,MAAMnB,EAAK;GAAM;GAAI;EAAM,CAAC,CAAC;CACvF;CACA,OAAO,CAAC,GAAGJ,GAAK,GAAGwB,EAAajC,GAASA,EAAQ,YAAYmB,CAAK,CAAC;AACrE"}
+{"version":3,"file":"reparent.js","names":[],"sources":["../../../../../src/interactions/actions/move/commit/reparent.ts"],"sourcesContent":["import { createReparentOp } from 'core/ops/reparent';\nimport { createSetLayerOp } from 'core/ops/setLayer';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { planeToPlane } from 'core/viewport/parallax';\nimport { rebaseLocalPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport { carryPose, planeOf } from '../../planeInput';\nimport { draggedWorldPose, grabbedPoseAdapter } from '../delta';\nimport type { MoveSession, ReparentOnDrop } from '../session';\nimport { translateOps } from '../translate';\n\n/** Resolved drop target — the new parent + layer + (for `'above'` mode)\n *  the hit sibling whose z-order position the moved node should land\n *  immediately above. `newParent === null` means \"land at the layer\n *  root\" (top-level node of `newLayer`). */\nexport interface DropTarget {\n  newParent: NodeId | null;\n  newLayer: string;\n  hitSibling: NodeId | null;\n}\n\n/** Walk the hit chain to find the appropriate drop target. Returns\n *  `null` when no reparent should happen (drop on empty canvas, or the\n *  only hits are the moved subtree itself). */\nexport function resolveDropTarget(\n  session: MoveSession,\n  at: { x: number; y: number },\n): DropTarget | null {\n  const dep = session.nodeAtPoint;\n  if (!dep) return null;\n\n  // Exclude moved roots + their descendants. Otherwise we'd happily\n  // reparent a node into itself (or under one of its own children).\n  const exclude = new Set<NodeId>([...session.ids, ...session.cascadeIds]);\n  const hit = dep(at, exclude);\n  if (!hit) return null;\n\n  const hitNode = session.scene.get(hit);\n  if (!hitNode) return null;\n\n  // Containers act as drop-INTO targets; leaves act as drop-NEXT-TO\n  // targets (parent = leaf's parent). When the leaf has no parent\n  // (top-level under a layer), `newParent === null` and the moved\n  // subtree lands at the layer root.\n  if (hitNode.kind === 'container' && session.admits(hit)) {\n    return { newParent: hit, newLayer: hitNode.layer, hitSibling: null };\n  }\n  // A container `canDropInto` refuses is a sibling to land beside, inside\n  // the nearest container around it that admits the drop.\n  let newParent = hitNode.parent;\n  let hitSibling: NodeId = hit;\n  while (newParent !== null && !session.admits(newParent)) {\n    hitSibling = newParent;\n    newParent = session.scene.get(newParent)?.parent ?? null;\n  }\n  return { newParent, newLayer: hitNode.layer, hitSibling };\n}\n\n/** Reparent and reposition each moved root as ops, keeping the world pose the\n *  drag showed, then the ops that bring uncarried descendants along. */\nexport function reparentOps(\n  session: MoveSession,\n  target: DropTarget,\n  mode: ReparentOnDrop,\n  delta: { dx: number; dy: number },\n): Op[] {\n  const { scene, pc, view } = session;\n  const adapter = scenePoseAdapter(scene);\n  const label = session.lifecycle.label;\n  const ops: Op[] = [];\n  // The destination's children as each op will find them: an earlier root's\n  // landing shifts where a later one goes.\n  const siblings = [...(target.newParent === null ? scene.roots : scene.childrenOf(target.newParent))];\n  for (const id of session.ids) {\n    if (!session.startPoses.has(id)) continue;\n    const node = scene.get(id)!;\n    const crossing = node.layer !== target.newLayer;\n    const world = carryPose(\n      session.descriptorOf(id),\n      draggedWorldPose(session, grabbedPoseAdapter(session, adapter), id, delta),\n      crossing ? planeToPlane(planeOf(view, node.layer), planeOf(view, target.newLayer)) : null,\n    );\n    const to = rebaseLocalPose(adapter, world, target.newParent as string | null, pc.compose, pc.decompose);\n\n    let from = node.parent as string | null;\n    if (crossing) {\n      // The scene refuses a layer change on a node whose parent is on another layer.\n      if (from !== null) {\n        ops.push(createReparentOp({\n          id: id as string, fromParentId: from, toParentId: null, label, coalesceKey: `reparent:${id}:orphan`,\n        }));\n        from = null;\n      }\n      ops.push(createSetLayerOp({ id: id as string, from: node.layer, to: target.newLayer, label }));\n    }\n\n    const was = siblings.indexOf(id);\n    if (was >= 0) siblings.splice(was, 1);\n    const hit = mode === 'above' && target.hitSibling\n      ? siblings.indexOf(target.hitSibling)\n      : -1;\n    const toIndex = hit >= 0 ? hit + 1 : undefined;\n    if (toIndex === undefined) siblings.push(id);\n    else siblings.splice(toIndex, 0, id);\n\n    ops.push(createReparentOp({\n      id: id as string, fromParentId: from, toParentId: target.newParent as string | null, toIndex, label,\n    }));\n    ops.push(createTransformOp<unknown>({ id: id as string, from: node.pose, to, label }));\n  }\n  return [...ops, ...translateOps(session, session.cascadeIds, delta)];\n}\n"],"mappings":";;;;;;;;;;;;;;AA0BA,SAAgB,kBACd,SACA,IACmB;CACnB,MAAM,MAAM,QAAQ;CACpB,IAAI,CAAC,KAAK,OAAO;CAKjB,MAAM,MAAM,IAAI,oBAAI,IADA,IAAY,CAAC,GAAG,QAAQ,KAAK,GAAG,QAAQ,UAAU,CAClD,CAAO;CAC3B,IAAI,CAAC,KAAK,OAAO;CAEjB,MAAM,UAAU,QAAQ,MAAM,IAAI,GAAG;CACrC,IAAI,CAAC,SAAS,OAAO;CAMrB,IAAI,QAAQ,SAAS,eAAe,QAAQ,OAAO,GAAG,GACpD,OAAO;EAAE,WAAW;EAAK,UAAU,QAAQ;EAAO,YAAY;CAAK;CAIrE,IAAI,YAAY,QAAQ;CACxB,IAAI,aAAqB;CACzB,OAAO,cAAc,QAAQ,CAAC,QAAQ,OAAO,SAAS,GAAG;EACvD,aAAa;EACb,YAAY,QAAQ,MAAM,IAAI,SAAS,CAAC,EAAE,UAAU;CACtD;CACA,OAAO;EAAE;EAAW,UAAU,QAAQ;EAAO;CAAW;AAC1D;;;AAIA,SAAgB,YACd,SACA,QACA,MACA,OACM;CACN,MAAM,EAAE,OAAO,IAAI,SAAS;CAC5B,MAAM,UAAU,iBAAiB,KAAK;CACtC,MAAM,QAAQ,QAAQ,UAAU;CAChC,MAAM,MAAY,CAAC;CAGnB,MAAM,WAAW,CAAC,GAAI,OAAO,cAAc,OAAO,MAAM,QAAQ,MAAM,WAAW,OAAO,SAAS,CAAE;CACnG,KAAK,MAAM,MAAM,QAAQ,KAAK;EAC5B,IAAI,CAAC,QAAQ,WAAW,IAAI,EAAE,GAAG;EACjC,MAAM,OAAO,MAAM,IAAI,EAAE;EACzB,MAAM,WAAW,KAAK,UAAU,OAAO;EACvC,MAAM,QAAQ,UACZ,QAAQ,aAAa,EAAE,GACvB,iBAAiB,SAAS,mBAAmB,SAAS,OAAO,GAAG,IAAI,KAAK,GACzE,WAAW,aAAa,QAAQ,MAAM,KAAK,KAAK,GAAG,QAAQ,MAAM,OAAO,QAAQ,CAAC,IAAI,IACvF;EACA,MAAM,KAAK,gBAAgB,SAAS,OAAO,OAAO,WAA4B,GAAG,SAAS,GAAG,SAAS;EAEtG,IAAI,OAAO,KAAK;EAChB,IAAI,UAAU;GAEZ,IAAI,SAAS,MAAM;IACjB,IAAI,KAAK,iBAAiB;KACpB;KAAc,cAAc;KAAM,YAAY;KAAM;KAAO,aAAa,YAAY,GAAG;IAC7F,CAAC,CAAC;IACF,OAAO;GACT;GACA,IAAI,KAAK,iBAAiB;IAAM;IAAc,MAAM,KAAK;IAAO,IAAI,OAAO;IAAU;GAAM,CAAC,CAAC;EAC/F;EAEA,MAAM,MAAM,SAAS,QAAQ,EAAE;EAC/B,IAAI,OAAO,GAAG,SAAS,OAAO,KAAK,CAAC;EACpC,MAAM,MAAM,SAAS,WAAW,OAAO,aACnC,SAAS,QAAQ,OAAO,UAAU,IAClC;EACJ,MAAM,UAAU,OAAO,IAAI,MAAM,IAAI;EACrC,IAAI,YAAY,QAAW,SAAS,KAAK,EAAE;OACtC,SAAS,OAAO,SAAS,GAAG,EAAE;EAEnC,IAAI,KAAK,iBAAiB;GACpB;GAAc,cAAc;GAAM,YAAY,OAAO;GAA4B;GAAS;EAChG,CAAC,CAAC;EACF,IAAI,KAAK,kBAA2B;GAAM;GAAc,MAAM,KAAK;GAAM;GAAI;EAAM,CAAC,CAAC;CACvF;CACA,OAAO,CAAC,GAAG,KAAK,GAAG,aAAa,SAAS,QAAQ,YAAY,KAAK,CAAC;AACrE"}

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

@@ -1,51 +1,73 @@
-import { toPlane as e } from "../../../core/viewport/parallax.js";
-import { composeWorldPose as t } from "../../../core/scene/composeFrame.js";
-import { translatePoseViaDescriptor as n } from "../../../core/geometry/poseDescriptor.js";
-import { planeOf as r } from "../planeInput.js";
+import { toPlane } from "../../../core/viewport/parallax.js";
+import { composeWorldPose } from "../../../core/scene/composeFrame.js";
+import { translatePoseViaDescriptor } from "../../../core/geometry/poseDescriptor.js";
+import { planeOf } from "../planeInput.js";
+
 //#region src/interactions/actions/move/delta.ts
-function i(e, t, r, i) {
-	let { dx: a, dy: s } = o(e, t, r, i), c = e.frames.get(t);
-	if (c === void 0) return {
-		dx: a,
-		dy: s
+/**
+* The world drag `(dx, dy)` as a translation of `id`'s stored pose. A pose is
+* stored in its frame, so under a turned frame the two point different ways.
+*/
+function localDelta(session, id, dx0, dy0) {
+	const { dx, dy } = planeDelta(session, id, dx0, dy0);
+	const f = session.frames.get(id);
+	if (f === void 0) return {
+		dx,
+		dy
 	};
-	let { pc: l } = e, u = e.descriptorOf(t), d = u.getBounds(l.decompose(c.frameWorld, c.world)), f = u.getBounds(l.decompose(c.frameWorld, n(c.world, a, s, u)));
+	const { pc } = session;
+	const d = session.descriptorOf(id);
+	const from = d.getBounds(pc.decompose(f.frameWorld, f.world));
+	const to = d.getBounds(pc.decompose(f.frameWorld, translatePoseViaDescriptor(f.world, dx, dy, d)));
 	return {
-		dx: f.x - d.x,
-		dy: f.y - d.y
+		dx: to.x - from.x,
+		dy: to.y - from.y
 	};
 }
-function a(e, t, r, a, o) {
-	if (e.carried.has(t)) return r;
-	let s = i(e, t, a, o);
-	return n(r, s.dx, s.dy, e.descriptorOf(t));
+/** The pose `id` stores once dragged by `(dx, dy)` from `start`, its stored
+*  pose at press. Unmoved when its frame is what moves. */
+function draggedStoredPose(session, id, start, dx, dy) {
+	if (session.carried.has(id)) return start;
+	const l = localDelta(session, id, dx, dy);
+	return translatePoseViaDescriptor(start, l.dx, l.dy, session.descriptorOf(id));
 }
-function o(t, n, i, a) {
-	let o = t.scene.get(n)?.layer, s = o === void 0 ? void 0 : t.planeRefs.get(o);
-	if (!s) return {
-		dx: i,
-		dy: a
+/** The drag `(dx, dy)`, measured in the edited plane, as the drag of `id` in
+*  the world its own layer stores it in. */
+function planeDelta(session, id, dx, dy) {
+	const layer = session.scene.get(id)?.layer;
+	const ref = layer === void 0 ? void 0 : session.planeRefs.get(layer);
+	if (!ref) return {
+		dx,
+		dy
+	};
+	const out = planeOf(session.view, layer);
+	const at = {
+		x: ref.edited.x + dx,
+		y: ref.edited.y + dy
 	};
-	let c = r(t.view, o), l = {
-		x: s.edited.x + i,
-		y: s.edited.y + a
-	}, u = c ? e(c, l) : l;
+	const p = out ? toPlane(out, at) : at;
 	return {
-		dx: u.x - s.own.x,
-		dy: u.y - s.own.y
+		dx: p.x - ref.own.x,
+		dy: p.y - ref.own.y
 	};
 }
-function s(e, t) {
-	return e.caught.size === 0 ? t : {
-		...t,
-		getPose: (n) => e.caught.has(n) ? e.startPoses.get(n) : t.getPose(n)
+/** `adapter`, except that an id caught mid-glide answers with the pose it was
+*  grabbed at — where the drag measures it from. */
+function grabbedPoseAdapter(session, adapter) {
+	if (session.caught.size === 0) return adapter;
+	return {
+		...adapter,
+		getPose: (id) => session.caught.has(id) ? session.startPoses.get(id) : adapter.getPose(id)
 	};
 }
-function c(e, r, i, a) {
-	let s = t(r, i, e.pc.compose), c = o(e, i, a.dx, a.dy);
-	return n(s, c.dx, c.dy, e.descriptorOf(i));
+/** The world pose `id` was dragged to: its pose at press composed up through
+*  `adapter`, moved by the drag as its own layer's plane measures it. */
+function draggedWorldPose(session, adapter, id, delta) {
+	const start = composeWorldPose(adapter, id, session.pc.compose);
+	const own = planeDelta(session, id, delta.dx, delta.dy);
+	return translatePoseViaDescriptor(start, own.dx, own.dy, session.descriptorOf(id));
 }
-//#endregion
-export { a as draggedStoredPose, c as draggedWorldPose, s as grabbedPoseAdapter, i as localDelta, o as planeDelta };
 
+//#endregion
+export { draggedStoredPose, draggedWorldPose, grabbedPoseAdapter, localDelta, planeDelta };
 //# sourceMappingURL=delta.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"delta.js","names":["localDelta","planeDelta","session","id","dx0","dy0","f","d","from","pc","to","translatePoseViaDescriptor","dx","dy","draggedStoredPose","start","l","layer","ref","out","planeOf","at","p","toPlane","grabbedPoseAdapter","adapter","draggedWorldPose","composeWorldPose","own","delta"],"sources":["../../../../src/interactions/actions/move/delta.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { toPlane } from 'core/viewport/parallax';\nimport { composeWorldPose, type PoseAdapter } from 'core/scene/composePose';\nimport { planeOf } from '../planeInput';\nimport type { MoveSession } from './session';\n\n/**\n * The world drag `(dx, dy)` as a translation of `id`'s stored pose. A pose is\n * stored in its frame, so under a turned frame the two point different ways.\n */\nexport function localDelta(\n  session: MoveSession,\n  id: NodeId,\n  dx0: number,\n  dy0: number,\n): { dx: number; dy: number } {\n  const { dx, dy } = planeDelta(session, id, dx0, dy0);\n  const f = session.frames.get(id);\n  if (f === undefined) return { dx, dy };\n  const { pc } = session;\n  const d = session.descriptorOf(id);\n  const from = d.getBounds(pc.decompose(f.frameWorld, f.world));\n  const to = d.getBounds(\n    pc.decompose(f.frameWorld, translatePoseViaDescriptor(f.world, dx, dy, d)),\n  );\n  return { dx: to.x - from.x, dy: to.y - from.y };\n}\n\n/** The pose `id` stores once dragged by `(dx, dy)` from `start`, its stored\n *  pose at press. Unmoved when its frame is what moves. */\nexport function draggedStoredPose(session: MoveSession, id: NodeId, start: unknown, dx: number, dy: number): unknown {\n  if (session.carried.has(id)) return start;\n  const l = localDelta(session, id, dx, dy);\n  return translatePoseViaDescriptor(start, l.dx, l.dy, session.descriptorOf(id));\n}\n\n/** The drag `(dx, dy)`, measured in the edited plane, as the drag of `id` in\n *  the world its own layer stores it in. */\nexport function planeDelta(\n  session: MoveSession,\n  id: NodeId,\n  dx: number,\n  dy: number,\n): { dx: number; dy: number } {\n  const layer = session.scene.get(id)?.layer;\n  const ref = layer === undefined ? undefined : session.planeRefs.get(layer);\n  if (!ref) return { dx, dy };\n  const out = planeOf(session.view, layer!);\n  const at = { x: ref.edited.x + dx, y: ref.edited.y + dy };\n  const p = out ? toPlane(out, at) : at;\n  return { dx: p.x - ref.own.x, dy: p.y - ref.own.y };\n}\n\n/** `adapter`, except that an id caught mid-glide answers with the pose it was\n *  grabbed at — where the drag measures it from. */\nexport function grabbedPoseAdapter(\n  session: MoveSession,\n  adapter: PoseAdapter<unknown>,\n): PoseAdapter<unknown> {\n  if (session.caught.size === 0) return adapter;\n  return {\n    ...adapter,\n    getPose: (id) => (session.caught.has(id as NodeId)\n      ? session.startPoses.get(id as NodeId)\n      : adapter.getPose(id)),\n  };\n}\n\n/** The world pose `id` was dragged to: its pose at press composed up through\n *  `adapter`, moved by the drag as its own layer's plane measures it. */\nexport function draggedWorldPose(\n  session: MoveSession,\n  adapter: PoseAdapter<unknown>,\n  id: NodeId,\n  delta: { dx: number; dy: number },\n): unknown {\n  const start = composeWorldPose(adapter, id as string, session.pc.compose);\n  const own = planeDelta(session, id, delta.dx, delta.dy);\n  return translatePoseViaDescriptor(start, own.dx, own.dy, session.descriptorOf(id));\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EACd,GACA,GACA,GACA,GAC4B;CAC5B,IAAM,EAAE,OAAI,UAAOC,EAAWC,GAASC,GAAIC,GAAKC,CAAG,GAC7CC,IAAIJ,EAAQ,OAAO,IAAIC,CAAE;CAC/B,IAAIG,MAAM,KAAA,GAAW,OAAO;EAAE;EAAI;CAAG;CACrC,IAAM,EAAE,UAAOJ,GACTK,IAAIL,EAAQ,aAAaC,CAAE,GAC3BK,IAAOD,EAAE,UAAUE,EAAG,UAAUH,EAAE,YAAYA,EAAE,KAAK,CAAC,GACtDI,IAAKH,EAAE,UACXE,EAAG,UAAUH,EAAE,YAAYK,EAA2BL,EAAE,OAAOM,GAAIC,GAAIN,CAAC,CAAC,CAC3E;CACA,OAAO;EAAE,IAAIG,EAAG,IAAIF,EAAK;EAAG,IAAIE,EAAG,IAAIF,EAAK;CAAE;AAChD;AAIA,SAAgBM,EAAkB,GAAsB,GAAY,GAAgB,GAAY,GAAqB;CACnH,IAAIZ,EAAQ,QAAQ,IAAIC,CAAE,GAAG,OAAOY;CACpC,IAAMC,IAAIhB,EAAWE,GAASC,GAAIS,GAAIC,CAAE;CACxC,OAAOF,EAA2BI,GAAOC,EAAE,IAAIA,EAAE,IAAId,EAAQ,aAAaC,CAAE,CAAC;AAC/E;AAIA,SAAgBF,EACd,GACA,GACA,GACA,GAC4B;CAC5B,IAAMgB,IAAQf,EAAQ,MAAM,IAAIC,CAAE,CAAC,EAAE,OAC/Be,IAAMD,MAAU,KAAA,IAAY,KAAA,IAAYf,EAAQ,UAAU,IAAIe,CAAK;CACzE,IAAI,CAACC,GAAK,OAAO;EAAE;EAAI;CAAG;CAC1B,IAAMC,IAAMC,EAAQlB,EAAQ,MAAMe,CAAM,GAClCI,IAAK;EAAE,GAAGH,EAAI,OAAO,IAAIN;EAAI,GAAGM,EAAI,OAAO,IAAIL;CAAG,GAClDS,IAAIH,IAAMI,EAAQJ,GAAKE,CAAE,IAAIA;CACnC,OAAO;EAAE,IAAIC,EAAE,IAAIJ,EAAI,IAAI;EAAG,IAAII,EAAE,IAAIJ,EAAI,IAAI;CAAE;AACpD;AAIA,SAAgBM,EACd,GACA,GACsB;CAEtB,OADItB,EAAQ,OAAO,SAAS,IAAUuB,IAC/B;EACL,GAAGA;EACH,UAAU,MAAQvB,EAAQ,OAAO,IAAIC,CAAY,IAC7CD,EAAQ,WAAW,IAAIC,CAAY,IACnCsB,EAAQ,QAAQtB,CAAE;CACxB;AACF;AAIA,SAAgBuB,EACd,GACA,GACA,GACA,GACS;CACT,IAAMX,IAAQY,EAAiBF,GAAStB,GAAcD,EAAQ,GAAG,OAAO,GAClE0B,IAAM3B,EAAWC,GAASC,GAAI0B,EAAM,IAAIA,EAAM,EAAE;CACtD,OAAOlB,EAA2BI,GAAOa,EAAI,IAAIA,EAAI,IAAI1B,EAAQ,aAAaC,CAAE,CAAC;AACnF"}
+{"version":3,"file":"delta.js","names":[],"sources":["../../../../src/interactions/actions/move/delta.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { toPlane } from 'core/viewport/parallax';\nimport { composeWorldPose, type PoseAdapter } from 'core/scene/composePose';\nimport { planeOf } from '../planeInput';\nimport type { MoveSession } from './session';\n\n/**\n * The world drag `(dx, dy)` as a translation of `id`'s stored pose. A pose is\n * stored in its frame, so under a turned frame the two point different ways.\n */\nexport function localDelta(\n  session: MoveSession,\n  id: NodeId,\n  dx0: number,\n  dy0: number,\n): { dx: number; dy: number } {\n  const { dx, dy } = planeDelta(session, id, dx0, dy0);\n  const f = session.frames.get(id);\n  if (f === undefined) return { dx, dy };\n  const { pc } = session;\n  const d = session.descriptorOf(id);\n  const from = d.getBounds(pc.decompose(f.frameWorld, f.world));\n  const to = d.getBounds(\n    pc.decompose(f.frameWorld, translatePoseViaDescriptor(f.world, dx, dy, d)),\n  );\n  return { dx: to.x - from.x, dy: to.y - from.y };\n}\n\n/** The pose `id` stores once dragged by `(dx, dy)` from `start`, its stored\n *  pose at press. Unmoved when its frame is what moves. */\nexport function draggedStoredPose(session: MoveSession, id: NodeId, start: unknown, dx: number, dy: number): unknown {\n  if (session.carried.has(id)) return start;\n  const l = localDelta(session, id, dx, dy);\n  return translatePoseViaDescriptor(start, l.dx, l.dy, session.descriptorOf(id));\n}\n\n/** The drag `(dx, dy)`, measured in the edited plane, as the drag of `id` in\n *  the world its own layer stores it in. */\nexport function planeDelta(\n  session: MoveSession,\n  id: NodeId,\n  dx: number,\n  dy: number,\n): { dx: number; dy: number } {\n  const layer = session.scene.get(id)?.layer;\n  const ref = layer === undefined ? undefined : session.planeRefs.get(layer);\n  if (!ref) return { dx, dy };\n  const out = planeOf(session.view, layer!);\n  const at = { x: ref.edited.x + dx, y: ref.edited.y + dy };\n  const p = out ? toPlane(out, at) : at;\n  return { dx: p.x - ref.own.x, dy: p.y - ref.own.y };\n}\n\n/** `adapter`, except that an id caught mid-glide answers with the pose it was\n *  grabbed at — where the drag measures it from. */\nexport function grabbedPoseAdapter(\n  session: MoveSession,\n  adapter: PoseAdapter<unknown>,\n): PoseAdapter<unknown> {\n  if (session.caught.size === 0) return adapter;\n  return {\n    ...adapter,\n    getPose: (id) => (session.caught.has(id as NodeId)\n      ? session.startPoses.get(id as NodeId)\n      : adapter.getPose(id)),\n  };\n}\n\n/** The world pose `id` was dragged to: its pose at press composed up through\n *  `adapter`, moved by the drag as its own layer's plane measures it. */\nexport function draggedWorldPose(\n  session: MoveSession,\n  adapter: PoseAdapter<unknown>,\n  id: NodeId,\n  delta: { dx: number; dy: number },\n): unknown {\n  const start = composeWorldPose(adapter, id as string, session.pc.compose);\n  const own = planeDelta(session, id, delta.dx, delta.dy);\n  return translatePoseViaDescriptor(start, own.dx, own.dy, session.descriptorOf(id));\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,WACd,SACA,IACA,KACA,KAC4B;CAC5B,MAAM,EAAE,IAAI,OAAO,WAAW,SAAS,IAAI,KAAK,GAAG;CACnD,MAAM,IAAI,QAAQ,OAAO,IAAI,EAAE;CAC/B,IAAI,MAAM,QAAW,OAAO;EAAE;EAAI;CAAG;CACrC,MAAM,EAAE,OAAO;CACf,MAAM,IAAI,QAAQ,aAAa,EAAE;CACjC,MAAM,OAAO,EAAE,UAAU,GAAG,UAAU,EAAE,YAAY,EAAE,KAAK,CAAC;CAC5D,MAAM,KAAK,EAAE,UACX,GAAG,UAAU,EAAE,YAAY,2BAA2B,EAAE,OAAO,IAAI,IAAI,CAAC,CAAC,CAC3E;CACA,OAAO;EAAE,IAAI,GAAG,IAAI,KAAK;EAAG,IAAI,GAAG,IAAI,KAAK;CAAE;AAChD;;;AAIA,SAAgB,kBAAkB,SAAsB,IAAY,OAAgB,IAAY,IAAqB;CACnH,IAAI,QAAQ,QAAQ,IAAI,EAAE,GAAG,OAAO;CACpC,MAAM,IAAI,WAAW,SAAS,IAAI,IAAI,EAAE;CACxC,OAAO,2BAA2B,OAAO,EAAE,IAAI,EAAE,IAAI,QAAQ,aAAa,EAAE,CAAC;AAC/E;;;AAIA,SAAgB,WACd,SACA,IACA,IACA,IAC4B;CAC5B,MAAM,QAAQ,QAAQ,MAAM,IAAI,EAAE,CAAC,EAAE;CACrC,MAAM,MAAM,UAAU,SAAY,SAAY,QAAQ,UAAU,IAAI,KAAK;CACzE,IAAI,CAAC,KAAK,OAAO;EAAE;EAAI;CAAG;CAC1B,MAAM,MAAM,QAAQ,QAAQ,MAAM,KAAM;CACxC,MAAM,KAAK;EAAE,GAAG,IAAI,OAAO,IAAI;EAAI,GAAG,IAAI,OAAO,IAAI;CAAG;CACxD,MAAM,IAAI,MAAM,QAAQ,KAAK,EAAE,IAAI;CACnC,OAAO;EAAE,IAAI,EAAE,IAAI,IAAI,IAAI;EAAG,IAAI,EAAE,IAAI,IAAI,IAAI;CAAE;AACpD;;;AAIA,SAAgB,mBACd,SACA,SACsB;CACtB,IAAI,QAAQ,OAAO,SAAS,GAAG,OAAO;CACtC,OAAO;EACL,GAAG;EACH,UAAU,OAAQ,QAAQ,OAAO,IAAI,EAAY,IAC7C,QAAQ,WAAW,IAAI,EAAY,IACnC,QAAQ,QAAQ,EAAE;CACxB;AACF;;;AAIA,SAAgB,iBACd,SACA,SACA,IACA,OACS;CACT,MAAM,QAAQ,iBAAiB,SAAS,IAAc,QAAQ,GAAG,OAAO;CACxE,MAAM,MAAM,WAAW,SAAS,IAAI,MAAM,IAAI,MAAM,EAAE;CACtD,OAAO,2BAA2B,OAAO,IAAI,IAAI,IAAI,IAAI,QAAQ,aAAa,EAAE,CAAC;AACnF"}

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

@@ -1,47 +1,78 @@
-import { draggedStoredPose as e } from "./delta.js";
-import { pointerStateOf as t } from "../pointerState.js";
+import { draggedStoredPose } from "./delta.js";
+import { pointerStateOf } from "../pointerState.js";
+import { snapMods } from "../../../features/snap/roles.js";
+
 //#region src/interactions/actions/move/frame.ts
-function n(n, r, i, a, o) {
-	let s = a, c = o, l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set(), d = n.gestureCtx;
-	d.modifiers = { ...i.modifiers }, d.pointer = t(i.drag.current, i), d.view = r.view(), d.plane = r.plane();
-	for (let [t, r] of n.startPoses) d.current.set(t, e(n, t, r, s, c));
-	let f = {
+function foldBehaviors(session, readers, moveCtx, dx, dy) {
+	const posed = /* @__PURE__ */ new Map();
+	const opaque = /* @__PURE__ */ new Set();
+	const gctx = session.gestureCtx;
+	gctx.modifiers = { ...moveCtx.modifiers };
+	gctx.pointer = pointerStateOf(moveCtx.drag.current, moveCtx);
+	gctx.view = readers.view();
+	gctx.plane = readers.plane();
+	for (const [id, ori] of session.startPoses) gctx.current.set(id, draggedStoredPose(session, id, ori, dx, dy));
+	let transform = {
 		kind: "translate",
-		dx: s,
-		dy: c
+		dx,
+		dy
 	};
-	for (let e of n.behaviors) {
-		let t = e.onMove?.(d, f);
-		if (t) {
-			if (t.poses) for (let [e, n] of t.poses) l.set(e, n);
-			if (t.opaque) for (let e of t.opaque) u.add(e);
-			t.transform && t.transform.kind === "translate" && (f = t.transform), t.snap !== void 0 && (d.snap = t.snap);
-		}
+	for (const b of session.behaviors) {
+		const r = b.onMove?.(gctx, transform);
+		if (!r) continue;
+		if (r.poses) for (const [id, pose] of r.poses) posed.set(id, pose);
+		if (r.opaque) for (const id of r.opaque) opaque.add(id);
+		if (r.transform) transform = r.transform;
+		if (r.snap !== void 0) gctx.snap = r.snap;
 	}
-	return f.kind === "translate" && (s = f.dx, c = f.dy), {
-		dx: s,
-		dy: c,
-		posed: l,
-		opaque: u
+	return {
+		dx: transform.dx,
+		dy: transform.dy,
+		posed,
+		opaque
 	};
 }
-function r(t, r, i) {
-	let { dx: a, dy: o, posed: s, opaque: c } = n(t, r, i, i.drag.delta.x, i.drag.delta.y), l = {
-		dx: a,
-		dy: o
-	}, u = /* @__PURE__ */ new Map();
-	for (let [n, r] of t.startPoses) {
-		let i = e(t, n, r, a, o);
-		u.set(n, t.carried.has(n) ? i : s.get(n) ?? i);
+/** The pointer's delta, moved so the subject lands on what the snap session
+*  holds it to. */
+function snapDelta(session, moveCtx) {
+	const d = moveCtx.drag.delta;
+	if (!session.snap) return {
+		dx: d.x,
+		dy: d.y
+	};
+	const { press } = session;
+	const out = session.snap.at({
+		x: press.x + d.x,
+		y: press.y + d.y
+	}, snapMods(moveCtx));
+	return {
+		dx: out.point.x - press.x,
+		dy: out.point.y - press.y
+	};
+}
+/** One move's delta and previews: the pointer's delta as the behaviors shaped
+*  it, every displaced id's stored pose under it, and whatever else the
+*  behaviors posed. */
+function nextFrame(session, readers, moveCtx) {
+	const snapped = snapDelta(session, moveCtx);
+	const { dx, dy, posed, opaque } = foldBehaviors(session, readers, moveCtx, snapped.dx, snapped.dy);
+	const delta = {
+		dx,
+		dy
+	};
+	const previews = /* @__PURE__ */ new Map();
+	for (const [id, ori] of session.startPoses) {
+		const dragged = draggedStoredPose(session, id, ori, dx, dy);
+		previews.set(id, session.carried.has(id) ? dragged : posed.get(id) ?? dragged);
 	}
-	for (let [e, n] of s) t.startPoses.has(e) || u.set(e, n);
+	for (const [id, pose] of posed) if (!session.startPoses.has(id)) previews.set(id, pose);
 	return {
-		delta: l,
-		previews: u,
-		opaque: c
+		delta,
+		previews,
+		opaque
 	};
 }
-//#endregion
-export { r as nextFrame };
 
+//#endregion
+export { nextFrame };
 //# sourceMappingURL=frame.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"frame.js","names":["foldBehaviors","dx","dx0","dy","dy0","posed","opaque","gctx","session","moveCtx","pointerStateOf","readers","id","ori","draggedStoredPose","transform","b","r","pose","nextFrame","delta","previews","dragged"],"sources":["../../../../src/interactions/actions/move/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { NodeId } from 'core/scene/types';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BehaviorResult, GroupTransform } from '../../gestures/types';\nimport { draggedStoredPose } from './delta';\nimport type { MoveFrame, MoveSession } from './session';\n\nfunction foldBehaviors(\n  session: MoveSession,\n  readers: GestureReaders,\n  moveCtx: InvocationCtx,\n  dx0: number,\n  dy0: number,\n): { dx: number; dy: number; posed: Map<NodeId, unknown>; opaque: Set<NodeId> } {\n  let dx = dx0;\n  let dy = dy0;\n\n  const posed = new Map<NodeId, unknown>();\n  const opaque = new Set<NodeId>();\n  const gctx = session.gestureCtx;\n  gctx.modifiers = { ...moveCtx.modifiers };\n  gctx.pointer = pointerStateOf(moveCtx.drag!.current, moveCtx);\n  gctx.view = readers.view();\n  gctx.plane = readers.plane();\n  // `current` is pre-populated from the raw cursor delta BEFORE\n  // any behavior shapes `transform`. Unlike `onEnd`, it is NOT\n  // refreshed after each behavior runs — so onMove behaviors\n  // should derive position from `origin` + the `proposed`\n  // GroupTransform arg, NOT from `ctx.current` (which reflects\n  // the unmodified delta at this frame's start).\n  for (const [id, ori] of session.startPoses) {\n    gctx.current.set(id as string, draggedStoredPose(session, id, ori, dx, dy));\n  }\n  let transform: GroupTransform = { kind: 'translate', dx, dy };\n  for (const b of session.behaviors) {\n    const r: BehaviorResult<unknown> | void = b.onMove?.(gctx, transform);\n    if (!r) continue;\n    if (r.poses) for (const [id, pose] of r.poses) posed.set(id as NodeId, pose);\n    if (r.opaque) for (const id of r.opaque) opaque.add(id as NodeId);\n    if (r.transform && r.transform.kind === 'translate') transform = r.transform;\n    if (r.snap !== undefined) gctx.snap = r.snap;\n  }\n  if (transform.kind === 'translate') { dx = transform.dx; dy = transform.dy; }\n  return { dx, dy, posed, opaque };\n}\n\n/** One move's delta and previews: the pointer's delta as the behaviors shaped\n *  it, every displaced id's stored pose under it, and whatever else the\n *  behaviors posed. */\nexport function nextFrame(session: MoveSession, readers: GestureReaders, moveCtx: InvocationCtx): MoveFrame {\n  const { dx, dy, posed, opaque } = foldBehaviors(session, readers, moveCtx, moveCtx.drag!.delta.x, moveCtx.drag!.delta.y);\n\n  // The delta stays in the frame — no scene writes, no history entries.\n  const delta = { dx, dy };\n  // Refresh preview poses for every displaced id (roots + cascade).\n  // The preview-ghost layer reads these via `previewIds`/`previewPose`.\n  const previews = new Map<NodeId, unknown>();\n  for (const [id, ori] of session.startPoses) {\n    const dragged = draggedStoredPose(session, id, ori, dx, dy);\n    previews.set(id, session.carried.has(id) ? dragged : posed.get(id) ?? dragged);\n  }\n  for (const [id, pose] of posed) if (!session.startPoses.has(id)) previews.set(id, pose);\n  return { delta, previews, opaque };\n}\n"],"mappings":";;;AAQA,SAASA,EACP,GACA,GACA,GACA,GACA,GAC8E;CAC9E,IAAIC,IAAKC,GACLC,IAAKC,GAEHC,oBAAQ,IAAI,IAAqB,GACjCC,oBAAS,IAAI,IAAY,GACzBC,IAAOC,EAAQ;CAIrB,AAHA,EAAK,YAAY,EAAE,GAAGC,EAAQ,UAAU,GACxC,EAAK,UAAUC,EAAeD,EAAQ,KAAM,SAASA,CAAO,GAC5D,EAAK,OAAOE,EAAQ,KAAK,GACzB,EAAK,QAAQA,EAAQ,MAAM;CAO3B,KAAK,IAAM,CAACC,GAAIC,MAAQL,EAAQ,YAC9B,EAAK,QAAQ,IAAII,GAAcE,EAAkBN,GAASI,GAAIC,GAAKZ,GAAIE,CAAE,CAAC;CAE5E,IAAIY,IAA4B;EAAE,MAAM;EAAa;EAAI;CAAG;CAC5D,KAAK,IAAMC,KAAKR,EAAQ,WAAW;EACjC,IAAMS,IAAoCD,EAAE,SAAST,GAAMQ,CAAS;EACpE,IAAKE,GACL;OAAIA,EAAE,OAAO,KAAK,IAAM,CAACL,GAAIM,MAASD,EAAE,OAAO,EAAM,IAAIL,GAAcM,CAAI;GAC3E,IAAID,EAAE,QAAQ,KAAK,IAAML,KAAMK,EAAE,QAAQ,EAAO,IAAIL,CAAY;GAEhE,AADIK,EAAE,aAAaA,EAAE,UAAU,SAAS,gBAAa,IAAYA,EAAE,YAC/DA,EAAE,SAAS,KAAA,MAAW,EAAK,OAAOA,EAAE;EAHmC;CAI7E;CAEA,OADIF,EAAU,SAAS,gBAAe,IAAKA,EAAU,IAAI,IAAKA,EAAU,KACjE;EAAE;EAAI;EAAI;EAAO;CAAO;AACjC;AAKA,SAAgBI,EAAU,GAAsB,GAAyB,GAAmC;CAC1G,IAAM,EAAE,OAAI,OAAI,UAAO,cAAWnB,EAAcQ,GAASG,GAASF,GAASA,EAAQ,KAAM,MAAM,GAAGA,EAAQ,KAAM,MAAM,CAAC,GAGjHW,IAAQ;EAAE;EAAI;CAAG,GAGjBC,oBAAW,IAAI,IAAqB;CAC1C,KAAK,IAAM,CAACT,GAAIC,MAAQL,EAAQ,YAAY;EAC1C,IAAMc,IAAUR,EAAkBN,GAASI,GAAIC,GAAKZ,GAAIE,CAAE;EAC1D,EAAS,IAAIS,GAAIJ,EAAQ,QAAQ,IAAII,CAAE,IAAIU,IAAUjB,EAAM,IAAIO,CAAE,KAAKU,CAAO;CAC/E;CACA,KAAK,IAAM,CAACV,GAAIM,MAASb,GAAO,AAAKG,EAAQ,WAAW,IAAII,CAAE,KAAGS,EAAS,IAAIT,GAAIM,CAAI;CACtF,OAAO;EAAE;EAAO;EAAU;CAAO;AACnC"}
+{"version":3,"file":"frame.js","names":[],"sources":["../../../../src/interactions/actions/move/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { NodeId } from 'core/scene/types';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BehaviorResult, GroupTransform } from '../../gestures/types';\nimport { draggedStoredPose } from './delta';\nimport { snapMods } from 'features/snap/roles';\nimport type { MoveFrame, MoveSession } from './session';\n\nfunction foldBehaviors(\n  session: MoveSession,\n  readers: GestureReaders,\n  moveCtx: InvocationCtx,\n  dx: number,\n  dy: number,\n): { dx: number; dy: number; posed: Map<NodeId, unknown>; opaque: Set<NodeId> } {\n  const posed = new Map<NodeId, unknown>();\n  const opaque = new Set<NodeId>();\n  const gctx = session.gestureCtx;\n  gctx.modifiers = { ...moveCtx.modifiers };\n  gctx.pointer = pointerStateOf(moveCtx.drag!.current, moveCtx);\n  gctx.view = readers.view();\n  gctx.plane = readers.plane();\n  // `current` is pre-populated from the raw cursor delta BEFORE\n  // any behavior shapes `transform`. Unlike `onEnd`, it is NOT\n  // refreshed after each behavior runs — so onMove behaviors\n  // should derive position from `origin` + the `proposed`\n  // GroupTransform arg, NOT from `ctx.current` (which reflects\n  // the unmodified delta at this frame's start).\n  for (const [id, ori] of session.startPoses) {\n    gctx.current.set(id as string, draggedStoredPose(session, id, ori, dx, dy));\n  }\n  let transform: GroupTransform = { kind: 'translate', dx, dy };\n  for (const b of session.behaviors) {\n    const r: BehaviorResult<unknown> | void = b.onMove?.(gctx, transform);\n    if (!r) continue;\n    if (r.poses) for (const [id, pose] of r.poses) posed.set(id as NodeId, pose);\n    if (r.opaque) for (const id of r.opaque) opaque.add(id as NodeId);\n    if (r.transform) transform = r.transform;\n    if (r.snap !== undefined) gctx.snap = r.snap;\n  }\n  return { dx: transform.dx, dy: transform.dy, posed, opaque };\n}\n\n/** The pointer's delta, moved so the subject lands on what the snap session\n *  holds it to. */\nfunction snapDelta(session: MoveSession, moveCtx: InvocationCtx): { dx: number; dy: number } {\n  const d = moveCtx.drag!.delta;\n  if (!session.snap) return { dx: d.x, dy: d.y };\n  const { press } = session;\n  const out = session.snap.at({ x: press.x + d.x, y: press.y + d.y }, snapMods(moveCtx));\n  return { dx: out.point.x - press.x, dy: out.point.y - press.y };\n}\n\n/** One move's delta and previews: the pointer's delta as the behaviors shaped\n *  it, every displaced id's stored pose under it, and whatever else the\n *  behaviors posed. */\nexport function nextFrame(session: MoveSession, readers: GestureReaders, moveCtx: InvocationCtx): MoveFrame {\n  const snapped = snapDelta(session, moveCtx);\n  const { dx, dy, posed, opaque } = foldBehaviors(session, readers, moveCtx, snapped.dx, snapped.dy);\n\n  // The delta stays in the frame — no scene writes, no history entries.\n  const delta = { dx, dy };\n  // Every displaced id's pose (roots + cascade), published to the scene's\n  // overrides by the action.\n  const previews = new Map<NodeId, unknown>();\n  for (const [id, ori] of session.startPoses) {\n    const dragged = draggedStoredPose(session, id, ori, dx, dy);\n    previews.set(id, session.carried.has(id) ? dragged : posed.get(id) ?? dragged);\n  }\n  for (const [id, pose] of posed) if (!session.startPoses.has(id)) previews.set(id, pose);\n  return { delta, previews, opaque };\n}\n"],"mappings":";;;;;AASA,SAAS,cACP,SACA,SACA,SACA,IACA,IAC8E;CAC9E,MAAM,wBAAQ,IAAI,IAAqB;CACvC,MAAM,yBAAS,IAAI,IAAY;CAC/B,MAAM,OAAO,QAAQ;CACrB,KAAK,YAAY,EAAE,GAAG,QAAQ,UAAU;CACxC,KAAK,UAAU,eAAe,QAAQ,KAAM,SAAS,OAAO;CAC5D,KAAK,OAAO,QAAQ,KAAK;CACzB,KAAK,QAAQ,QAAQ,MAAM;CAO3B,KAAK,MAAM,CAAC,IAAI,QAAQ,QAAQ,YAC9B,KAAK,QAAQ,IAAI,IAAc,kBAAkB,SAAS,IAAI,KAAK,IAAI,EAAE,CAAC;CAE5E,IAAI,YAA4B;EAAE,MAAM;EAAa;EAAI;CAAG;CAC5D,KAAK,MAAM,KAAK,QAAQ,WAAW;EACjC,MAAM,IAAoC,EAAE,SAAS,MAAM,SAAS;EACpE,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,OAAO,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,OAAO,MAAM,IAAI,IAAc,IAAI;EAC3E,IAAI,EAAE,QAAQ,KAAK,MAAM,MAAM,EAAE,QAAQ,OAAO,IAAI,EAAY;EAChE,IAAI,EAAE,WAAW,YAAY,EAAE;EAC/B,IAAI,EAAE,SAAS,QAAW,KAAK,OAAO,EAAE;CAC1C;CACA,OAAO;EAAE,IAAI,UAAU;EAAI,IAAI,UAAU;EAAI;EAAO;CAAO;AAC7D;;;AAIA,SAAS,UAAU,SAAsB,SAAoD;CAC3F,MAAM,IAAI,QAAQ,KAAM;CACxB,IAAI,CAAC,QAAQ,MAAM,OAAO;EAAE,IAAI,EAAE;EAAG,IAAI,EAAE;CAAE;CAC7C,MAAM,EAAE,UAAU;CAClB,MAAM,MAAM,QAAQ,KAAK,GAAG;EAAE,GAAG,MAAM,IAAI,EAAE;EAAG,GAAG,MAAM,IAAI,EAAE;CAAE,GAAG,SAAS,OAAO,CAAC;CACrF,OAAO;EAAE,IAAI,IAAI,MAAM,IAAI,MAAM;EAAG,IAAI,IAAI,MAAM,IAAI,MAAM;CAAE;AAChE;;;;AAKA,SAAgB,UAAU,SAAsB,SAAyB,SAAmC;CAC1G,MAAM,UAAU,UAAU,SAAS,OAAO;CAC1C,MAAM,EAAE,IAAI,IAAI,OAAO,WAAW,cAAc,SAAS,SAAS,SAAS,QAAQ,IAAI,QAAQ,EAAE;CAGjG,MAAM,QAAQ;EAAE;EAAI;CAAG;CAGvB,MAAM,2BAAW,IAAI,IAAqB;CAC1C,KAAK,MAAM,CAAC,IAAI,QAAQ,QAAQ,YAAY;EAC1C,MAAM,UAAU,kBAAkB,SAAS,IAAI,KAAK,IAAI,EAAE;EAC1D,SAAS,IAAI,IAAI,QAAQ,QAAQ,IAAI,EAAE,IAAI,UAAU,MAAM,IAAI,EAAE,KAAK,OAAO;CAC/E;CACA,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO,IAAI,CAAC,QAAQ,WAAW,IAAI,EAAE,GAAG,SAAS,IAAI,IAAI,IAAI;CACtF,OAAO;EAAE;EAAO;EAAU;CAAO;AACnC"}

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

@@ -1,29 +1,39 @@
-import { asNodeId as e } from "../../../core/scene/types.js";
-import { scenePoseTarget as t } from "../../../animation/poseTarget.js";
-import { defaultCommitAdapter as n } from "../defaultCommitAdapter.js";
+import { asNodeId } from "../../../core/scene/types.js";
+import { scenePoseTarget } from "../../../animation/poseTarget.js";
+import { defaultCommitAdapter } from "../defaultCommitAdapter.js";
+
 //#region src/interactions/actions/move/gestureAdapter.ts
-function r(r, i, a) {
-	let o = /* @__PURE__ */ new Map(), s = {
-		...n(r, a),
-		...i ? { applyOps: (e, t) => i(e, t, s) } : {},
-		previewPoses: (t) => {
-			let { overrides: n } = r;
-			for (let [r, i] of t) {
-				let t = e(r), a = o.get(r), s = a !== void 0 && n.get(t) === a;
-				if (i === null) o.delete(r), s && n.clear(t);
-				else if (s) a.pose = i;
+/** `commit` is how a behavior's own `applyOps` batch lands; the returned
+*  adapter is passed back so the ops apply through it. Left out, the adapter
+*  has no `applyOps`. `selection` is as `defaultCommitAdapter` takes it. */
+function moveGestureAdapter(scene, commit, selection) {
+	const previews = /* @__PURE__ */ new Map();
+	const adapter = {
+		...defaultCommitAdapter(scene, selection),
+		...commit ? { applyOps: (ops, label) => commit(ops, label, adapter) } : {},
+		previewPoses: (poses) => {
+			const { overrides } = scene;
+			for (const [id, pose] of poses) {
+				const nodeId = asNodeId(id);
+				const mine = previews.get(id);
+				const installed = mine !== void 0 && overrides.get(nodeId) === mine;
+				if (pose === null) {
+					previews.delete(id);
+					if (installed) overrides.clear(nodeId);
+				} else if (installed) mine.pose = pose;
 				else {
-					let e = { pose: i };
-					o.set(r, e), n.set(t, e);
+					const entry = { pose };
+					previews.set(id, entry);
+					overrides.set(nodeId, entry);
 				}
 			}
-			n.commit();
+			overrides.commit();
 		},
-		poseTarget: (e, n) => t(r, e, n)
+		poseTarget: (id, descriptor) => scenePoseTarget(scene, id, descriptor)
 	};
-	return s;
+	return adapter;
 }
-//#endregion
-export { r as moveGestureAdapter };
 
+//#endregion
+export { moveGestureAdapter };
 //# sourceMappingURL=gestureAdapter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"gestureAdapter.js","names":["moveGestureAdapter","previews","adapter","defaultCommitAdapter","scene","selection","commit","ops","label","id","pose","poses","nodeId","asNodeId","mine","installed","overrides","entry","scenePoseTarget","descriptor"],"sources":["../../../../src/interactions/actions/move/gestureAdapter.ts"],"sourcesContent":["/**\n * The scene-backed adapter the move behavior pipeline reads and commits\n * through: the default actions' commit adapter, plus what a behavior needs\n * while the gesture runs and after it ends (`previewPoses`, `poseTarget`, and\n * an `applyOps` of its own).\n */\nimport type { Op } from 'core/ops/types';\nimport type { Node, PoseOverride, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { MoveAdapter } from 'core/adapters/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { scenePoseTarget } from '../../../animation/poseTarget';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\n\nexport type MoveGestureAdapter<TPose> = MoveAdapter<Node<unknown, string, TPose>, TPose>\n  & ReturnType<typeof defaultCommitAdapter<TPose>>\n  & { previewPoses(poses: ReadonlyMap<string, TPose | null>): void };\n\n/** `commit` is how a behavior's own `applyOps` batch lands; the returned\n *  adapter is passed back so the ops apply through it. Left out, the adapter\n *  has no `applyOps`. `selection` is as `defaultCommitAdapter` takes it. */\nexport function moveGestureAdapter<TPose>(\n  scene: Scene<unknown, string, TPose>,\n  commit?: (ops: Op[], label: string, adapter: MoveGestureAdapter<TPose>) => void,\n  selection?: SelectionApi['adapterMethods'],\n): MoveGestureAdapter<TPose> {\n  const previews = new Map<string, PoseOverride<TPose>>();\n  const adapter: MoveGestureAdapter<TPose> = {\n    ...defaultCommitAdapter(scene, selection),\n    ...(commit ? { applyOps: (ops: Op[], label: string) => commit(ops, label, adapter) } : {}),\n    previewPoses: (poses) => {\n      const { overrides } = scene;\n      for (const [id, pose] of poses) {\n        const nodeId = asNodeId(id);\n        const mine = previews.get(id);\n        const installed = mine !== undefined && overrides.get(nodeId) === mine;\n        if (pose === null) {\n          previews.delete(id);\n          if (installed) overrides.clear(nodeId);\n        } else if (installed) {\n          mine.pose = pose;\n        } else {\n          const entry = { pose };\n          previews.set(id, entry);\n          overrides.set(nodeId, entry);\n        }\n      }\n      overrides.commit();\n    },\n    poseTarget: (id, descriptor) => scenePoseTarget(scene, id, descriptor),\n  };\n  return adapter;\n}\n"],"mappings":";;;;AAqBA,SAAgBA,EACd,GACA,GACA,GAC2B;CAC3B,IAAMC,oBAAW,IAAI,IAAiC,GAChDC,IAAqC;EACzC,GAAGC,EAAqBC,GAAOC,CAAS;EACxC,GAAIC,IAAS,EAAE,WAAW,GAAW,MAAkBA,EAAOC,GAAKC,GAAON,CAAO,EAAE,IAAI,CAAC;EACxF,eAAe,MAAU;GACvB,IAAM,EAAE,iBAAcE;GACtB,KAAK,IAAM,CAACK,GAAIC,MAASC,GAAO;IAC9B,IAAMC,IAASC,EAASJ,CAAE,GACpBK,IAAOb,EAAS,IAAIQ,CAAE,GACtBM,IAAYD,MAAS,KAAA,KAAaE,EAAU,IAAIJ,CAAM,MAAME;IAClE,IAAIJ,MAAS,MAEX,AADAT,EAAS,OAAOQ,CAAE,GACdM,KAAWC,EAAU,MAAMJ,CAAM;SAChC,IAAIG,GACT,EAAK,OAAOL;SACP;KACL,IAAMO,IAAQ,EAAE,QAAK;KAErB,AADAhB,EAAS,IAAIQ,GAAIQ,CAAK,GACtBD,EAAU,IAAIJ,GAAQK,CAAK;IAC7B;GACF;GACA,EAAU,OAAO;EACnB;EACA,aAAa,GAAI,MAAeC,EAAgBd,GAAOK,GAAIU,CAAU;CACvE;CACA,OAAOjB;AACT"}
+{"version":3,"file":"gestureAdapter.js","names":[],"sources":["../../../../src/interactions/actions/move/gestureAdapter.ts"],"sourcesContent":["/**\n * The scene-backed adapter the move behavior pipeline reads and commits\n * through: the default actions' commit adapter, plus what a behavior needs\n * while the gesture runs and after it ends (`previewPoses`, `poseTarget`, and\n * an `applyOps` of its own).\n */\nimport type { Op } from 'core/ops/types';\nimport type { Node, PoseOverride, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { MoveAdapter } from 'core/adapters/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { scenePoseTarget } from '../../../animation/poseTarget';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\n\nexport type MoveGestureAdapter<TPose> = MoveAdapter<Node<unknown, string, TPose>, TPose>\n  & ReturnType<typeof defaultCommitAdapter<TPose>>\n  & { previewPoses(poses: ReadonlyMap<string, TPose | null>): void };\n\n/** `commit` is how a behavior's own `applyOps` batch lands; the returned\n *  adapter is passed back so the ops apply through it. Left out, the adapter\n *  has no `applyOps`. `selection` is as `defaultCommitAdapter` takes it. */\nexport function moveGestureAdapter<TPose>(\n  scene: Scene<unknown, string, TPose>,\n  commit?: (ops: Op[], label: string, adapter: MoveGestureAdapter<TPose>) => void,\n  selection?: SelectionApi['adapterMethods'],\n): MoveGestureAdapter<TPose> {\n  const previews = new Map<string, PoseOverride<TPose>>();\n  const adapter: MoveGestureAdapter<TPose> = {\n    ...defaultCommitAdapter(scene, selection),\n    ...(commit ? { applyOps: (ops: Op[], label: string) => commit(ops, label, adapter) } : {}),\n    previewPoses: (poses) => {\n      const { overrides } = scene;\n      for (const [id, pose] of poses) {\n        const nodeId = asNodeId(id);\n        const mine = previews.get(id);\n        const installed = mine !== undefined && overrides.get(nodeId) === mine;\n        if (pose === null) {\n          previews.delete(id);\n          if (installed) overrides.clear(nodeId);\n        } else if (installed) {\n          mine.pose = pose;\n        } else {\n          const entry = { pose };\n          previews.set(id, entry);\n          overrides.set(nodeId, entry);\n        }\n      }\n      overrides.commit();\n    },\n    poseTarget: (id, descriptor) => scenePoseTarget(scene, id, descriptor),\n  };\n  return adapter;\n}\n"],"mappings":";;;;;;;;AAqBA,SAAgB,mBACd,OACA,QACA,WAC2B;CAC3B,MAAM,2BAAW,IAAI,IAAiC;CACtD,MAAM,UAAqC;EACzC,GAAG,qBAAqB,OAAO,SAAS;EACxC,GAAI,SAAS,EAAE,WAAW,KAAW,UAAkB,OAAO,KAAK,OAAO,OAAO,EAAE,IAAI,CAAC;EACxF,eAAe,UAAU;GACvB,MAAM,EAAE,cAAc;GACtB,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO;IAC9B,MAAM,SAAS,SAAS,EAAE;IAC1B,MAAM,OAAO,SAAS,IAAI,EAAE;IAC5B,MAAM,YAAY,SAAS,UAAa,UAAU,IAAI,MAAM,MAAM;IAClE,IAAI,SAAS,MAAM;KACjB,SAAS,OAAO,EAAE;KAClB,IAAI,WAAW,UAAU,MAAM,MAAM;IACvC,OAAO,IAAI,WACT,KAAK,OAAO;SACP;KACL,MAAM,QAAQ,EAAE,KAAK;KACrB,SAAS,IAAI,IAAI,KAAK;KACtB,UAAU,IAAI,QAAQ,KAAK;IAC7B;GACF;GACA,UAAU,OAAO;EACnB;EACA,aAAa,IAAI,eAAe,gBAAgB,OAAO,IAAI,UAAU;CACvE;CACA,OAAO;AACT"}

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

@@ -1,33 +1,51 @@
-import { translatePoseViaDescriptor as e } from "../../../core/geometry/poseDescriptor.js";
-import { subtreeIds as t } from "../selectionSubtree.js";
-import { createTransformOp as n } from "../../../core/ops/transform.js";
+import { translatePoseViaDescriptor } from "../../../core/geometry/poseDescriptor.js";
+import { carriedDescendants, sceneCarrySource } from "../../../core/scene/carryDescendants.js";
+import { createTransformOp } from "../../../core/ops/transform.js";
+
 //#region src/interactions/actions/move/landedDescendants.ts
-function r(r, i) {
-	let { scene: a, projection: o, startPoses: s, carried: c, label: l } = r, u = /* @__PURE__ */ new Map();
-	for (let e of i) {
-		if (e.name !== "transform") continue;
-		let t = e.args;
-		u.set(t.id, t.to);
+/**
+* Ops that bring along the descendants of every node `ops` transforms. A
+* layout drop or a behavior places a dragged root somewhere the drag delta
+* does not describe, and a layout shifts siblings to make room, so each
+* descendant moves by its nearest transformed ancestor's landed pose less
+* that ancestor's start pose. A descendant `ops` already writes, or that a
+* moving frame carries, is left alone.
+*/
+function landedDescendantOps(input, ops) {
+	const { scene, projection, startPoses, label } = input;
+	const landed = /* @__PURE__ */ new Map();
+	for (const op of ops) {
+		if (op.name !== "transform") continue;
+		const a = op.args;
+		const id = a.id;
+		landed.set(id, {
+			from: landed.get(id)?.from ?? startPoses.get(id) ?? a.from,
+			to: a.to
+		});
 	}
-	let d = [];
-	for (let i of r.roots) {
-		let r = u.get(i), f = s.get(i);
-		if (r === void 0 || f === void 0) continue;
-		let p = o.getBounds(f), m = o.getBounds(r), h = m.x - p.x, g = m.y - p.y;
-		if (h !== 0 || g !== 0) for (let r of t(a, i)) {
-			if (r === i || u.has(r) || c.has(r)) continue;
-			let t = a.get(r);
-			t && d.push(n({
-				id: r,
-				from: t.pose,
-				to: e(t.pose, h, g, o),
-				label: l
+	const source = sceneCarrySource(scene);
+	const out = [];
+	for (const [root, { from, to }] of landed) {
+		if (from === void 0 || to === void 0) continue;
+		const a = projection.getBounds(from);
+		const b = projection.getBounds(to);
+		const dx = b.x - a.x;
+		const dy = b.y - a.y;
+		if (dx === 0 && dy === 0) continue;
+		const carried = carriedDescendants(source, root, (pose) => translatePoseViaDescriptor(pose, dx, dy, projection), (id) => landed.has(id));
+		for (const [id, pose] of carried) {
+			const node = scene.get(id);
+			if (node) out.push(createTransformOp({
+				id,
+				from: node.pose,
+				to: pose,
+				label
 			}));
 		}
 	}
-	return d;
+	return out;
 }
-//#endregion
-export { r as landedDescendantOps };
 
+//#endregion
+export { landedDescendantOps };
 //# sourceMappingURL=landedDescendants.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"landedDescendants.js","names":["landedDescendantOps","input","landed","op","ops","a","out","root","to","start","startPoses","projection","b","dx","dy","id","subtreeIds","scene","carried","node","createTransformOp","translatePoseViaDescriptor"],"sources":["../../../../src/interactions/actions/move/landedDescendants.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { subtreeIds } from '../selectionSubtree';\n\n/** What a move gesture captured at its start, as this pass reads it. */\nexport interface LandedDescendantsInput {\n  scene: Scene<unknown, string, unknown>;\n  projection: PoseDescriptor<unknown>;\n  /** The dragged roots. */\n  roots: readonly NodeId[];\n  /** Start pose of every root and descendant. */\n  startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Descendants stored in a moving node's frame, which that node carries. */\n  carried: ReadonlySet<NodeId>;\n  label: string;\n}\n\n/**\n * Ops that bring each dragged root's descendants along to wherever `ops` put\n * the root. A layout drop or a behavior places the root itself, somewhere the\n * drag delta does not describe, so each descendant moves by its root's landed\n * pose less its start pose. A descendant `ops` already writes, or that a\n * moving frame carries, is left alone.\n */\nexport function landedDescendantOps(input: LandedDescendantsInput, ops: readonly Op[]): Op[] {\n  const { scene, projection, startPoses, carried, label } = input;\n  const landed = new Map<string, unknown>();\n  for (const op of ops) {\n    if (op.name !== 'transform') continue;\n    const a = op.args as { id: string; to: unknown };\n    landed.set(a.id, a.to);\n  }\n  const out: Op[] = [];\n  for (const root of input.roots) {\n    const to = landed.get(root);\n    const start = startPoses.get(root);\n    if (to === undefined || start === undefined) continue;\n    const a = projection.getBounds(start);\n    const b = projection.getBounds(to);\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    if (dx === 0 && dy === 0) continue;\n    for (const id of subtreeIds(scene, root)) {\n      if (id === root || landed.has(id) || carried.has(id)) continue;\n      const node = scene.get(id);\n      if (!node) continue;\n      out.push(createTransformOp<unknown>({\n        id,\n        from: node.pose,\n        to: translatePoseViaDescriptor(node.pose, dx, dy, projection),\n        label,\n      }));\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;AA0BA,SAAgBA,EAAoB,GAA+B,GAA0B;CAC3F,IAAM,EAAE,UAAO,eAAY,eAAY,YAAS,aAAUC,GACpDC,oBAAS,IAAI,IAAqB;CACxC,KAAK,IAAMC,KAAMC,GAAK;EACpB,IAAID,EAAG,SAAS,aAAa;EAC7B,IAAME,IAAIF,EAAG;EACb,EAAO,IAAIE,EAAE,IAAIA,EAAE,EAAE;CACvB;CACA,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAQN,EAAM,OAAO;EAC9B,IAAMO,IAAKN,EAAO,IAAIK,CAAI,GACpBE,IAAQC,EAAW,IAAIH,CAAI;EACjC,IAAIC,MAAO,KAAA,KAAaC,MAAU,KAAA,GAAW;EAC7C,IAAMJ,IAAIM,EAAW,UAAUF,CAAK,GAC9BG,IAAID,EAAW,UAAUH,CAAE,GAC3BK,IAAKD,EAAE,IAAIP,EAAE,GACbS,IAAKF,EAAE,IAAIP,EAAE;EACnB,IAAIQ,MAAO,KAAKC,MAAO,GACvB,KAAK,IAAMC,KAAMC,EAAWC,GAAOV,CAAI,GAAG;GACxC,IAAIQ,MAAOR,KAAQL,EAAO,IAAIa,CAAE,KAAKG,EAAQ,IAAIH,CAAE,GAAG;GACtD,IAAMI,IAAOF,EAAM,IAAIF,CAAE;GACzB,AAAKI,KACLb,EAAI,KAAKc,EAA2B;IAClC;IACA,MAAMD,EAAK;IACX,IAAIE,EAA2BF,EAAK,MAAMN,GAAIC,GAAIH,CAAU;IAC5D;GACF,CAAC,CAAC;EACJ;CACF;CACA,OAAOL;AACT"}
+{"version":3,"file":"landedDescendants.js","names":[],"sources":["../../../../src/interactions/actions/move/landedDescendants.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { carriedDescendants, sceneCarrySource } from 'core/scene/carryDescendants';\n\n/** What a move gesture captured at its start, as this pass reads it. */\nexport interface LandedDescendantsInput {\n  scene: Scene<unknown, string, unknown>;\n  projection: PoseDescriptor<unknown>;\n  /** Start pose of every root and descendant. */\n  startPoses: ReadonlyMap<NodeId, unknown>;\n  label: string;\n}\n\n/**\n * Ops that bring along the descendants of every node `ops` transforms. A\n * layout drop or a behavior places a dragged root somewhere the drag delta\n * does not describe, and a layout shifts siblings to make room, so each\n * descendant moves by its nearest transformed ancestor's landed pose less\n * that ancestor's start pose. A descendant `ops` already writes, or that a\n * moving frame carries, is left alone.\n */\nexport function landedDescendantOps(input: LandedDescendantsInput, ops: readonly Op[]): Op[] {\n  const { scene, projection, startPoses, label } = input;\n  const landed = new Map<NodeId, { from: unknown; to: unknown }>();\n  for (const op of ops) {\n    if (op.name !== 'transform') continue;\n    const a = op.args as { id: string; from: unknown; to: unknown };\n    const id = a.id as NodeId;\n    landed.set(id, { from: landed.get(id)?.from ?? startPoses.get(id) ?? a.from, to: a.to });\n  }\n  const source = sceneCarrySource(scene);\n  const out: Op[] = [];\n  for (const [root, { from, to }] of landed) {\n    if (from === undefined || to === undefined) continue;\n    const a = projection.getBounds(from);\n    const b = projection.getBounds(to);\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    if (dx === 0 && dy === 0) continue;\n    const carried = carriedDescendants(\n      source,\n      root,\n      (pose) => translatePoseViaDescriptor(pose, dx, dy, projection),\n      (id) => landed.has(id),\n    );\n    for (const [id, pose] of carried) {\n      const node = scene.get(id);\n      if (node) out.push(createTransformOp<unknown>({ id, from: node.pose, to: pose, label }));\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,SAAgB,oBAAoB,OAA+B,KAA0B;CAC3F,MAAM,EAAE,OAAO,YAAY,YAAY,UAAU;CACjD,MAAM,yBAAS,IAAI,IAA4C;CAC/D,KAAK,MAAM,MAAM,KAAK;EACpB,IAAI,GAAG,SAAS,aAAa;EAC7B,MAAM,IAAI,GAAG;EACb,MAAM,KAAK,EAAE;EACb,OAAO,IAAI,IAAI;GAAE,MAAM,OAAO,IAAI,EAAE,CAAC,EAAE,QAAQ,WAAW,IAAI,EAAE,KAAK,EAAE;GAAM,IAAI,EAAE;EAAG,CAAC;CACzF;CACA,MAAM,SAAS,iBAAiB,KAAK;CACrC,MAAM,MAAY,CAAC;CACnB,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,SAAS,QAAQ;EACzC,IAAI,SAAS,UAAa,OAAO,QAAW;EAC5C,MAAM,IAAI,WAAW,UAAU,IAAI;EACnC,MAAM,IAAI,WAAW,UAAU,EAAE;EACjC,MAAM,KAAK,EAAE,IAAI,EAAE;EACnB,MAAM,KAAK,EAAE,IAAI,EAAE;EACnB,IAAI,OAAO,KAAK,OAAO,GAAG;EAC1B,MAAM,UAAU,mBACd,QACA,OACC,SAAS,2BAA2B,MAAM,IAAI,IAAI,UAAU,IAC5D,OAAO,OAAO,IAAI,EAAE,CACvB;EACA,KAAK,MAAM,CAAC,IAAI,SAAS,SAAS;GAChC,MAAM,OAAO,MAAM,IAAI,EAAE;GACzB,IAAI,MAAM,IAAI,KAAK,kBAA2B;IAAE;IAAI,MAAM,KAAK;IAAM,IAAI;IAAM;GAAM,CAAC,CAAC;EACzF;CACF;CACA,OAAO;AACT"}