@weasel-js/core 1.9.4 → 1.10.1

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

@@ -0,0 +1,108 @@
+import { toPlane as e } from "../../../core/viewport/parallax.js";
+import { composeWorldPose as t, composesFrames as n, frameAtOrAbove as r } from "../../../core/scene/composeFrame.js";
+import { effectivePose as i } from "../../../core/scene/effectivePose.js";
+import { invertPlane as a, planeOf as o } from "../planeInput.js";
+import { poseDescriptorOf as s } from "../poseDescriptorDep.js";
+import { translateTargets as c } from "../selectionSubtree.js";
+import { scenePoseAdapter as l } from "../../../core/scene/scenePoseAdapter.js";
+import { catchGliding as u } from "./layout/glide.js";
+import { pointerStateOf as d } from "../pointerState.js";
+import { scenePoseFrame as f } from "../poseFrame.js";
+import { sceneGestureFrames as p } from "../gestureFrames.js";
+//#region src/interactions/actions/move/capture.ts
+function m(e, t, n, r) {
+	let a = /* @__PURE__ */ new Map(), o = [], s = /* @__PURE__ */ new Set(), c = [], l = /* @__PURE__ */ new Map(), d = (t) => {
+		let i = u(e, n, r, t);
+		i && l.set(t, i);
+	};
+	for (let n of t) {
+		let t = e.get(n);
+		t && (d(n), a.set(n, i(e, t)), s.add(n), c.push(n));
+	}
+	for (; c.length > 0;) {
+		let t = c.shift();
+		for (let n of e.childrenOf(t)) {
+			if (s.has(n)) continue;
+			s.add(n);
+			let t = e.get(n);
+			t && (d(n), a.set(n, i(e, t)), o.push(n), c.push(n));
+		}
+	}
+	return {
+		startPoses: a,
+		cascadeIds: o,
+		caught: l
+	};
+}
+function h(e, i, a) {
+	let o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map(), u = e.composition;
+	if (!n(u)) return {
+		carried: o,
+		frames: s
+	};
+	let d = new Set(c(e, f(e), i)), p = l(e);
+	for (let n of a.keys()) {
+		if (!d.has(n)) {
+			o.add(n);
+			continue;
+		}
+		let i = r(p, e.get(n)?.parent ?? null);
+		i !== null && s.set(n, {
+			world: t(p, n, u.compose),
+			frameWorld: t(p, i, u.compose)
+		});
+	}
+	return {
+		carried: o,
+		frames: s
+	};
+}
+function g(t, n, r, i, s, c) {
+	let l = /* @__PURE__ */ new Map();
+	for (let u of n) {
+		let n = t.get(u)?.layer;
+		if (n === void 0 || l.has(n)) continue;
+		let d = o(r, n);
+		if (d === null) continue;
+		let f = i.get(u)?.world ?? s.get(u);
+		if (f === void 0) continue;
+		let p = c.getBounds(f), m = {
+			x: p.x,
+			y: p.y
+		};
+		l.set(n, {
+			own: m,
+			edited: e(a(d), m)
+		});
+	}
+	return l;
+}
+function _(e, t, n, r, i, a) {
+	let o = /* @__PURE__ */ new Map();
+	for (let [e, t] of r) o.set(e, t);
+	let c = s(e.deps.poseDescriptor);
+	return {
+		draggedIds: n,
+		origin: o,
+		current: new Map(o),
+		snap: null,
+		modifiers: { ...e.modifiers },
+		pointer: d(e.world, e),
+		view: a.view(),
+		plane: a.plane(),
+		frames: p(t, e.deps.view),
+		offset: (e, t) => {
+			let n = c.getBounds(e), r = c.getBounds(t);
+			return {
+				dx: r.x - n.x,
+				dy: r.y - n.y
+			};
+		},
+		adapter: i,
+		scratch: {}
+	};
+}
+//#endregion
+export { _ as buildGestureContext, h as captureFrames, g as capturePlaneRefs, m as captureStartPoses };
+
+//# sourceMappingURL=capture.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capture.js","names":["captureStartPoses","startPoses","cascadeIds","seen","queue","caught","hold","held","catchGliding","scene","reflow","projection","id","ids","node","effectivePose","parent","childId","childNode","captureFrames","carried","frames","pc","composesFrames","written","translateTargets","scenePoseFrame","poseAdapter","scenePoseAdapter","frame","frameAtOrAbove","composeWorldPose","capturePlaneRefs","planeRefs","layer","m","planeOf","view","world","b","own","toPlane","invertPlane","buildGestureContext","origin","pose","poseDescriptorOf","ctx","pointerStateOf","readers","sceneGestureFrames","a","from","to"],"sources":["../../../../src/interactions/actions/move/capture.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { toPlane } from 'core/viewport/parallax';\nimport { composesFrames, composeWorldPose, frameAtOrAbove } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { ReflowTransition } from '../../../layout/types';\nimport type { GestureContext } from '../../gestures/types';\nimport { invertPlane, planeOf } from '../planeInput';\nimport { sceneGestureFrames } from '../gestureFrames';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { scenePoseFrame } from '../poseFrame';\nimport { translateTargets } from '../selectionSubtree';\nimport type { MoveGestureAdapter } from './gestureAdapter';\nimport { catchGliding } from './layout/glide';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\n\n/** Start pose of each root and descendant, the descendants in walk order, and\n *  the offsets of any caught mid-glide. */\nexport function captureStartPoses(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  reflow: ReflowTransition | null,\n  projection: PoseDescriptor<unknown>,\n): { startPoses: Map<NodeId, unknown>; cascadeIds: NodeId[]; caught: Map<NodeId, { dx: number; dy: number }> } {\n  // Capture origin poses once at drag start. Walk descendants so\n  // container drags can preview every displaced child — required by\n  // `usePreviewGhostLayer.buildSubtree` which only recurses into ids\n  // present in `previewIds()`.\n  const startPoses = new Map<NodeId, unknown>();\n  const cascadeIds: NodeId[] = [];\n  const seen = new Set<NodeId>();\n  const queue: NodeId[] = [];\n  // A node still gliding from an earlier reflow is held where it is\n  // shown, and the drag starts from there.\n  const caught = new Map<NodeId, { dx: number; dy: number }>();\n  const hold = (id: NodeId): void => {\n    const held = catchGliding(scene, reflow, projection, id);\n    if (held) caught.set(id, held);\n  };\n  for (const id of ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    hold(id);\n    startPoses.set(id, effectivePose(scene, node));\n    seen.add(id);\n    queue.push(id);\n  }\n  while (queue.length > 0) {\n    const parent = queue.shift()!;\n    for (const childId of scene.childrenOf(parent)) {\n      if (seen.has(childId)) continue;\n      seen.add(childId);\n      const childNode = scene.get(childId);\n      if (!childNode) continue;\n      hold(childId);\n      startPoses.set(childId, effectivePose(scene, childNode));\n      cascadeIds.push(childId);\n      queue.push(childId);\n    }\n  }\n  return { startPoses, cascadeIds, caught };\n}\n\n/** Which ids ride a moving frame, and the world poses of the rest that sit under one. */\nexport function captureFrames(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  startPoses: ReadonlyMap<NodeId, unknown>,\n): { carried: Set<NodeId>; frames: Map<NodeId, { world: unknown; frameWorld: unknown }> } {\n  const carried = new Set<NodeId>();\n  const frames = new Map<NodeId, { world: unknown; frameWorld: unknown }>();\n  const pc = scene.composition;\n  if (!composesFrames(pc)) return { carried, frames };\n  const written = new Set(translateTargets(scene, scenePoseFrame(scene), ids));\n  const poseAdapter = scenePoseAdapter(scene);\n  for (const id of startPoses.keys()) {\n    if (!written.has(id)) {\n      carried.add(id);\n      continue;\n    }\n    const frame = frameAtOrAbove(poseAdapter, scene.get(id)?.parent ?? null);\n    if (frame === null) continue;\n    frames.set(id, {\n      world: composeWorldPose(poseAdapter, id as string, pc.compose),\n      frameWorld: composeWorldPose(poseAdapter, frame, pc.compose),\n    });\n  }\n  return { carried, frames };\n}\n\n/** For each layer on another plane: a point of its first root, in its own world and the edited one. */\nexport function capturePlaneRefs(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  view: unknown,\n  frames: ReadonlyMap<NodeId, { world: unknown }>,\n  startPoses: ReadonlyMap<NodeId, unknown>,\n  projection: PoseDescriptor<unknown>,\n): Map<string, { own: { x: number; y: number }; edited: { x: number; y: number } }> {\n  const planeRefs = new Map<string, { own: { x: number; y: number }; edited: { x: number; y: number } }>();\n  for (const id of ids) {\n    const layer = scene.get(id)?.layer;\n    if (layer === undefined || planeRefs.has(layer)) continue;\n    const m = planeOf(view, layer);\n    if (m === null) continue;\n    const world = frames.get(id)?.world ?? startPoses.get(id);\n    if (world === undefined) continue;\n    const b = projection.getBounds(world);\n    const own = { x: b.x, y: b.y };\n    planeRefs.set(layer, { own, edited: toPlane(invertPlane(m)!, own) });\n  }\n  return planeRefs;\n}\n\nexport function buildGestureContext(\n  ctx: InvocationCtx,\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  startPoses: ReadonlyMap<NodeId, unknown>,\n  adapter: MoveGestureAdapter<unknown>,\n  readers: GestureReaders,\n): GestureContext<unknown> {\n  const origin = new Map<string, unknown>();\n  for (const [id, pose] of startPoses) origin.set(id as string, pose);\n  const projection = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const gestureCtx: GestureContext<unknown> = {\n    draggedIds: ids as unknown as string[],\n    origin,\n    current: new Map(origin),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(ctx.world, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    frames: sceneGestureFrames(scene, ctx.deps.view),\n    offset: (from, to) => {\n      const a = projection.getBounds(from);\n      const b = projection.getBounds(to);\n      return { dx: b.x - a.x, dy: b.y - a.y };\n    },\n    adapter: adapter as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n  return gestureCtx;\n}\n"],"mappings":"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"}

package/dist/interactions/actions/move/commit/index.js

@@ -0,0 +1,41 @@
+import { commitGestureOps as e, reduceBehaviorEnd as t } from "../../gestureLifecycle.js";
+import { draggedStoredPose as n } from "../delta.js";
+import { rootTranslateOps as r, translateOps as i } from "../translate.js";
+import { landedDescendantOps as a } from "../landedDescendants.js";
+//#region src/interactions/actions/move/commit/index.ts
+function o(e, i, a) {
+	let { dx: o, dy: s } = i, c = e.gestureCtx;
+	for (let [t, r] of e.startPoses) c.current.set(t, n(e, t, r, o, s));
+	return t(e.behaviors, c, {
+		translateOps: (t) => r(e, t, i),
+		pointer: a
+	});
+}
+function s(t) {
+	let { session: n, at: r } = t, { dx: s, dy: c } = t.delta, l = (t) => {
+		let r = a({
+			scene: n.scene,
+			projection: n.projection,
+			startPoses: n.startPoses,
+			carried: n.carried,
+			roots: n.ids,
+			label: n.lifecycle.label
+		}, t);
+		return e(n, n.lifecycle, [...t, ...r]);
+	}, u = o(n, {
+		dx: s,
+		dy: c
+	}, r);
+	if (u === null) return !1;
+	if (u !== void 0) return l(u);
+	if (s === 0 && c === 0) return !1;
+	let d = i(n, [...n.ids, ...n.cascadeIds], {
+		dx: s,
+		dy: c
+	});
+	return d.length > 0 && l(d);
+}
+//#endregion
+export { s as commitMove };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["endBehaviors","delta","gctx","session","id","ori","draggedStoredPose","dx","dy","reduceBehaviorEnd","rootTranslateOps","ids","at","commitMove","input","commitOps","followers","landedDescendantOps","ops","commitGestureOps","answer","translateOps"],"sources":["../../../../../src/interactions/actions/move/commit/index.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport { commitGestureOps, reduceBehaviorEnd } from '../../gestureLifecycle';\nimport { draggedStoredPose } from '../delta';\nimport { landedDescendantOps } from '../landedDescendants';\nimport type { MoveSession } from '../session';\nimport { rootTranslateOps, translateOps } from '../translate';\n\nexport interface CommitInput {\n  session: MoveSession;\n  delta: { dx: number; dy: number };\n  /** Where the pointer was let go, or the last move's point when the end carried none. */\n  at: { x: number; y: number };\n}\n\n/** What the behaviors answer for the commit: ops, `null` to abort, or\n *  `undefined` when every one of them leaves it to the default translate. */\nfunction endBehaviors(\n  session: MoveSession,\n  delta: { dx: number; dy: number },\n  at: { x: number; y: number },\n): Op[] | null | undefined {\n  const { dx, dy } = delta;\n  const gctx = session.gestureCtx;\n  for (const [id, ori] of session.startPoses) {\n    gctx.current.set(id as string, draggedStoredPose(session, id, ori, dx, dy));\n  }\n  return reduceBehaviorEnd(session.behaviors, gctx, {\n    translateOps: (ids) => rootTranslateOps(session, ids, delta),\n    pointer: at,\n  });\n}\n\n/** Commit the drag. Returns whether anything reached the document: false\n *  when there was nothing to write, or a container refused what it was sent. */\nexport function commitMove(input: CommitInput): boolean {\n  const { session, at } = input;\n  // Apply the final delta as a single batch → one undo entry.\n  const { dx, dy } = input.delta;\n  const commitOps = (ops: Op[]): boolean => {\n    const followers = landedDescendantOps(\n      {\n        scene: session.scene,\n        projection: session.projection,\n        startPoses: session.startPoses,\n        carried: session.carried,\n        roots: session.ids,\n        label: session.lifecycle.label,\n      },\n      ops,\n    );\n    return commitGestureOps(session, session.lifecycle, [...ops, ...followers]);\n  };\n\n  // Behavior pipeline owns the commit if any behavior returns non-undefined.\n  const answer = endBehaviors(session, { dx, dy }, at);\n  if (answer === null) return false;           // abort (e.g. snap-back)\n  if (answer !== undefined) return commitOps(answer);\n\n  // No-op if no movement (sub-threshold drag or zero delta).\n  if (dx === 0 && dy === 0) return false;\n\n  // No behavior claimed it — translate-only commit, emitted as transform ops\n  // so it routes through the consumer `applyOps` hook (consumer history)\n  // when present, else the scene's own history. Under scene v1's\n  // absolute-pose semantics every node stores world coords\n  // independently, so a container drag must explicitly re-stamp every\n  // cascaded descendant by the same dx/dy — otherwise children stay at\n  // their old absolute positions (visually they snap to the\n  // container's former location).\n  // Translate the data-held geometry by the same (dx,dy). Opt-in via\n  // the geometryProjection seam; a no-op when the dep is absent.\n  const ops = translateOps(session, [...session.ids, ...session.cascadeIds], { dx, dy });\n  return ops.length > 0 && commitOps(ops);\n}\n"],"mappings":";;;;;AAgBA,SAASA,EACP,GACA,GACA,GACyB;CACzB,IAAM,EAAE,OAAI,UAAOC,GACbC,IAAOC,EAAQ;CACrB,KAAK,IAAM,CAACC,GAAIC,MAAQF,EAAQ,YAC9B,EAAK,QAAQ,IAAIC,GAAcE,EAAkBH,GAASC,GAAIC,GAAKE,GAAIC,CAAE,CAAC;CAE5E,OAAOC,EAAkBN,EAAQ,WAAWD,GAAM;EAChD,eAAe,MAAQQ,EAAiBP,GAASQ,GAAKV,CAAK;EAC3D,SAASW;CACX,CAAC;AACH;AAIA,SAAgBC,EAAW,GAA6B;CACtD,IAAM,EAAE,YAAS,UAAOC,GAElB,EAAE,OAAI,UAAOA,EAAM,OACnBC,KAAa,MAAuB;EACxC,IAAMC,IAAYC,EAChB;GACE,OAAOd,EAAQ;GACf,YAAYA,EAAQ;GACpB,YAAYA,EAAQ;GACpB,SAASA,EAAQ;GACjB,OAAOA,EAAQ;GACf,OAAOA,EAAQ,UAAU;EAC3B,GACAe,CACF;EACA,OAAOC,EAAiBhB,GAASA,EAAQ,WAAW,CAAC,GAAGe,GAAK,GAAGF,CAAS,CAAC;CAC5E,GAGMI,IAASpB,EAAaG,GAAS;EAAE;EAAI;CAAG,GAAGS,CAAE;CACnD,IAAIQ,MAAW,MAAM,OAAO;CAC5B,IAAIA,MAAW,KAAA,GAAW,OAAOL,EAAUK,CAAM;CAGjD,IAAIb,MAAO,KAAKC,MAAO,GAAG,OAAO;CAYjC,IAAMU,IAAMG,EAAalB,GAAS,CAAC,GAAGA,EAAQ,KAAK,GAAGA,EAAQ,UAAU,GAAG;EAAE;EAAI;CAAG,CAAC;CACrF,OAAOe,EAAI,SAAS,KAAKH,EAAUG,CAAG;AACxC"}

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

@@ -0,0 +1,44 @@
+import { rebaseLocalPose as e } from "../../../../core/scene/composeFrame.js";
+import { asNodeId as t } from "../../../../core/scene/types.js";
+import { createReparentOp as n } from "../../../../core/ops/reparent.js";
+import { createTransformOp as r } from "../../../../core/ops/transform.js";
+import { scenePoseAdapter as i } from "../../../../core/scene/scenePoseAdapter.js";
+import { rebaseTransformOp as a } from "./rebase.js";
+//#region src/interactions/actions/move/commit/layoutDrop.ts
+function o(o, s) {
+	let c = s, l = o.pc, u = i(o.scene), d = c.container.id, f = new Set(o.ids.map((e) => e)), p = (e) => {
+		let n = e.args?.id;
+		if (n === void 0) return e;
+		let r = o.scene.get(t(n))?.parent ?? null, i = f.has(n) ? d : r;
+		return a(e, u, l, r, i);
+	}, m = [], h = [];
+	for (let e of c.placements) {
+		e.dragged.sourceContainerId !== d && m.push(n({
+			id: e.dragged.id,
+			fromParentId: e.dragged.sourceContainerId,
+			toParentId: d,
+			label: "Reparent"
+		}));
+		let t = c.layout.commitDrop(c.container, e.children, e.dragged, e.target);
+		for (let e of t) h.push(p(e));
+	}
+	let g = [];
+	for (let [n, i] of c.sourceReflow) {
+		let a = o.scene.get(t(n))?.parent ?? null;
+		g.push(r({
+			id: n,
+			from: o.scene.get(t(n)).pose,
+			to: e(u, i, a, l.compose, l.decompose),
+			label: "Source reflow"
+		}));
+	}
+	return [
+		...m,
+		...h,
+		...g
+	];
+}
+//#endregion
+export { o as layoutDropOps };
+
+//# sourceMappingURL=layoutDrop.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layoutDrop.js","names":["layoutDropOps","lp","pass","pc","session","commitAdapter","scenePoseAdapter","destId","draggedIds","id","rebaseOpToLocal","op","curParent","asNodeId","toParent","rebaseTransformOp","reparentOps","dropOps","placement","createReparentOp","ops","reflowOps","cid","worldPose","parent","createTransformOp","rebaseLocalPose"],"sources":["../../../../../src/interactions/actions/move/commit/layoutDrop.ts"],"sourcesContent":["import { createReparentOp } from 'core/ops/reparent';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { asNodeId } from 'core/scene/types';\nimport { rebaseLocalPose } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { LayoutPass } from '../layout/types';\nimport type { MoveSession } from '../session';\nimport { rebaseTransformOp } from './rebase';\n\n/** The ops of a drop a layout container accepted: reparents, then each\n *  placement's `commitDrop`, then the source containers' reflow. */\nexport function layoutDropOps(session: MoveSession, pass: LayoutPass): Op[] {\n  const lp = pass;\n  const pc = session.pc;\n  const commitAdapter = scenePoseAdapter(session.scene);\n  const destId = lp.container.id;\n  const draggedIds = new Set<string>(session.ids.map((id) => id as string));\n  // commitDrop returns world poses (the contract is world in/out).\n  // Rebase each transform op to local: a dragged id lands under the\n  // destination container; any other id keeps its current parent.\n  // `from` rebases under the node's PRE-commit parent.\n  const rebaseOpToLocal = (op: Op): Op => {\n    const id = (op.args as { id?: string } | undefined)?.id;\n    if (id === undefined) return op;\n    const curParent = session.scene.get(asNodeId(id))?.parent ?? null;\n    const toParent = draggedIds.has(id) ? destId : curParent;\n    return rebaseTransformOp(op, commitAdapter, pc, curParent, toParent);\n  };\n  // Cross-container drop: reparent each dragged node under the\n  // destination container so its tree position matches its new\n  // visual home. Scene v1's absolute-pose semantics mean the\n  // subsequent pose op still lands the child at the snapped cell.\n  // Every reparent precedes every drop.\n  const reparentOps: Op[] = [];\n  const dropOps: Op[] = [];\n  for (const placement of lp.placements) {\n    if (placement.dragged.sourceContainerId !== destId) {\n      reparentOps.push(createReparentOp({\n        id: placement.dragged.id,\n        fromParentId: placement.dragged.sourceContainerId,\n        toParentId: destId,\n        label: 'Reparent',\n      }));\n    }\n    const ops = lp.layout.commitDrop(\n      lp.container,\n      placement.children,\n      placement.dragged,\n      placement.target,\n    );\n    for (const op of ops) dropOps.push(rebaseOpToLocal(op));\n  }\n  const reflowOps: Op[] = [];\n  for (const [cid, worldPose] of lp.sourceReflow) {\n    const parent = session.scene.get(asNodeId(cid))?.parent ?? null;\n    // Source-reflow siblings keep their parent, so `from` is already\n    // the live local pose (no rebase); only `to` (a world pose stored\n    // in `lp.sourceReflow`) is rebased to local. This is the\n    // intentional counterpart to the dropOps rebaser above, where\n    // `from` comes from a world `commitDrop` op and so does rebase.\n    reflowOps.push(createTransformOp<unknown>({\n      id: cid,\n      from: session.scene.get(asNodeId(cid))!.pose,\n      to: rebaseLocalPose(commitAdapter, worldPose, parent, pc.compose, pc.decompose),\n      label: 'Source reflow',\n    }));\n  }\n  return [...reparentOps, ...dropOps, ...reflowOps];\n}\n"],"mappings":";;;;;;;AAYA,SAAgBA,EAAc,GAAsB,GAAwB;CAC1E,IAAMC,IAAKC,GACLC,IAAKC,EAAQ,IACbC,IAAgBC,EAAiBF,EAAQ,KAAK,GAC9CG,IAASN,EAAG,UAAU,IACtBO,IAAa,IAAI,IAAYJ,EAAQ,IAAI,KAAK,MAAOK,CAAY,CAAC,GAKlEC,KAAmB,MAAe;EACtC,IAAMD,IAAME,EAAG,MAAsC;EACrD,IAAIF,MAAO,KAAA,GAAW,OAAOE;EAC7B,IAAMC,IAAYR,EAAQ,MAAM,IAAIS,EAASJ,CAAE,CAAC,CAAC,EAAE,UAAU,MACvDK,IAAWN,EAAW,IAAIC,CAAE,IAAIF,IAASK;EAC/C,OAAOG,EAAkBJ,GAAIN,GAAeF,GAAIS,GAAWE,CAAQ;CACrE,GAMME,IAAoB,CAAC,GACrBC,IAAgB,CAAC;CACvB,KAAK,IAAMC,KAAajB,EAAG,YAAY;EACrC,AAAIiB,EAAU,QAAQ,sBAAsBX,KAC1CS,EAAY,KAAKG,EAAiB;GAChC,IAAID,EAAU,QAAQ;GACtB,cAAcA,EAAU,QAAQ;GAChC,YAAYX;GACZ,OAAO;EACT,CAAC,CAAC;EAEJ,IAAMa,IAAMnB,EAAG,OAAO,WACpBA,EAAG,WACHiB,EAAU,UACVA,EAAU,SACVA,EAAU,MACZ;EACA,KAAK,IAAMP,KAAMS,GAAK,EAAQ,KAAKV,EAAgBC,CAAE,CAAC;CACxD;CACA,IAAMU,IAAkB,CAAC;CACzB,KAAK,IAAM,CAACC,GAAKC,MAActB,EAAG,cAAc;EAC9C,IAAMuB,IAASpB,EAAQ,MAAM,IAAIS,EAASS,CAAG,CAAC,CAAC,EAAE,UAAU;EAM3D,EAAU,KAAKG,EAA2B;GACxC,IAAIH;GACJ,MAAMlB,EAAQ,MAAM,IAAIS,EAASS,CAAG,CAAC,CAAC,CAAE;GACxC,IAAII,EAAgBrB,GAAekB,GAAWC,GAAQrB,EAAG,SAASA,EAAG,SAAS;GAC9E,OAAO;EACT,CAAC,CAAC;CACJ;CACA,OAAO;EAAC,GAAGa;EAAa,GAAGC;EAAS,GAAGI;CAAS;AAClD"}

package/dist/interactions/actions/move/commit/layoutRelease.js

@@ -0,0 +1,100 @@
+import { composeWorldPose as e, rebaseLocalPose as t } from "../../../../core/scene/composeFrame.js";
+import { asNodeId as n } from "../../../../core/scene/types.js";
+import { createReparentOp as r } from "../../../../core/ops/reparent.js";
+import { createTransformOp as i } from "../../../../core/ops/transform.js";
+import { scenePoseAdapter as a } from "../../../../core/scene/scenePoseAdapter.js";
+import { rebaseTransformOp as o } from "./rebase.js";
+import { draggedWorldPose as s, grabbedPoseAdapter as c } from "../delta.js";
+import { groupBySourceContainer as l } from "../layout/dropPass.js";
+import { resolveLayoutExits as u } from "../layout/exits.js";
+import { translateOps as d, unreleasedIds as f } from "../translate.js";
+//#region src/interactions/actions/move/commit/layoutRelease.ts
+function p(t, r, i, a, l) {
+	let { dx: u, dy: d } = r, f = t.pc, p = [], m = [], h = (e) => {
+		let r = e.args?.id;
+		if (r === void 0) return e;
+		let i = t.scene.get(n(r))?.parent ?? null;
+		return o(e, l, f, i, i);
+	}, g = t.layout?.getLayout(i);
+	if (!g?.releaseDrop) return {
+		ops: m,
+		released: p
+	};
+	let _ = {
+		id: i,
+		bounds: t.projection.getBounds(e(l, i, f.compose))
+	}, v = t.scene.childrenOf(n(i)).filter((e) => !a.has(e)).map((t) => ({
+		id: t,
+		pose: e(l, t, f.compose)
+	}));
+	for (let n of a) {
+		let r = e(c(t, l), n, f.compose), a = g.releaseDrop(_, v, {
+			id: n,
+			originPose: r,
+			pose: s(t, c(t, l), n, {
+				dx: u,
+				dy: d
+			}),
+			sourceContainerId: i
+		});
+		if (a === null) continue;
+		p.push(n);
+		let o = r;
+		for (let e of a) {
+			let t = e.args;
+			e.name === "transform" && t.id === n && (o = t.to), m.push(h(e));
+		}
+		v = [...v, {
+			id: n,
+			pose: o
+		}];
+	}
+	return {
+		ops: m,
+		released: p
+	};
+}
+function m(e, n, o) {
+	let { dx: m, dy: h } = n, g = /* @__PURE__ */ new Set(), _ = [], v = /* @__PURE__ */ new Map(), y = [];
+	if (e.layout) {
+		let d = e.pc, f = a(e.scene), b = l(e.ids.map((t) => ({
+			id: t,
+			sourceContainerId: e.scene.get(t)?.parent ?? null
+		})), null);
+		for (let [t, r] of b) {
+			let i = p(e, n, t, r, f);
+			for (let e of i.released) g.add(e);
+			_.push(...i.ops);
+		}
+		v = u(e, o, e.ids.filter((e) => !g.has(e)));
+		for (let [n, a] of v) {
+			let o = e.scene.get(n), l = s(e, c(e, f), n, {
+				dx: m,
+				dy: h
+			});
+			y.push(r({
+				id: n,
+				fromParentId: o.parent,
+				toParentId: a,
+				label: "Reparent"
+			})), y.push(i({
+				id: n,
+				from: o.pose,
+				to: t(f, l, a, d.compose, d.decompose),
+				label: e.lifecycle.label
+			}));
+		}
+	}
+	if (g.size !== 0 || v.size !== 0) return [
+		..._,
+		...y,
+		...d(e, f(e, g).filter((e) => !v.has(e)), {
+			dx: m,
+			dy: h
+		})
+	];
+}
+//#endregion
+export { m as layoutReleaseOps };
+
+//# sourceMappingURL=layoutRelease.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layoutRelease.js","names":["releaseFrom","delta","pc","session","released","releasedOps","rebaseReleased","id","op","parent","asNodeId","rebaseTransformOp","commitAdapter","srcLayout","srcId","srcContainer","composeWorldPose","srcChildren","leaving","cid","startWorld","grabbedPoseAdapter","ops","draggedWorldPose","landed","a","layoutReleaseOps","exits","exitOps","scenePoseAdapter","sources","groupBySourceContainer","from","resolveLayoutExits","dropCenter","toParent","node","world","createReparentOp","createTransformOp","rebaseLocalPose","translateOps","unreleasedIds"],"sources":["../../../../../src/interactions/actions/move/commit/layoutRelease.ts"],"sourcesContent":["import { createReparentOp } from 'core/ops/reparent';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { asNodeId, type NodeId } from 'core/scene/types';\nimport { composeWorldPose, rebaseLocalPose, type PoseAdapter } from 'core/scene/composePose';\nimport { scenePoseAdapter } from 'core/scene/scenePoseAdapter';\nimport type { LayoutChild, LayoutContainer } from '../../../../layout/types';\nimport { draggedWorldPose, grabbedPoseAdapter } from '../delta';\nimport { groupBySourceContainer } from '../layout/dropPass';\nimport { resolveLayoutExits } from '../layout/exits';\nimport type { MoveSession } from '../session';\nimport { translateOps, unreleasedIds } from '../translate';\nimport { rebaseTransformOp } from './rebase';\n\nfunction releaseFrom(\n  session: MoveSession,\n  delta: { dx: number; dy: number },\n  srcId: string,\n  leaving: Set<NodeId>,\n  commitAdapter: PoseAdapter<unknown>,\n): { ops: Op[]; released: NodeId[] } {\n  const { dx, dy } = delta;\n  const pc = session.pc;\n  const released: NodeId[] = [];\n  const releasedOps: Op[] = [];\n  // Released children keep their parent, so both ends of a transform\n  // rebase under the same frame.\n  const rebaseReleased = (op: Op): Op => {\n    const id = (op.args as { id?: string } | undefined)?.id;\n    if (id === undefined) return op;\n    const parent = session.scene.get(asNodeId(id))?.parent ?? null;\n    return rebaseTransformOp(op, commitAdapter, pc, parent, parent);\n  };\n  const srcLayout = session.layout?.getLayout(srcId);\n  if (!srcLayout?.releaseDrop) return { ops: releasedOps, released };\n  const srcContainer: LayoutContainer = {\n    id: srcId,\n    bounds: session.projection.getBounds(\n      composeWorldPose(commitAdapter, srcId, pc.compose),\n    ),\n  };\n  // What the container is left holding — grown back as each\n  // release puts one of its own home again.\n  let srcChildren: LayoutChild<unknown>[] =\n    session.scene.childrenOf(asNodeId(srcId))\n      .filter((cid) => !leaving.has(cid))\n      .map((cid) => ({\n        id: cid as string,\n        pose: composeWorldPose(commitAdapter, cid as string, pc.compose),\n      }));\n  for (const id of leaving) {\n    const startWorld = composeWorldPose(\n      grabbedPoseAdapter(session, commitAdapter), id as string, pc.compose,\n    );\n    const ops = srcLayout.releaseDrop!(srcContainer, srcChildren, {\n      id: id as string,\n      originPose: startWorld,\n      pose: draggedWorldPose(session, grabbedPoseAdapter(session, commitAdapter), id, { dx, dy }),\n      sourceContainerId: srcId,\n    });\n    if (ops === null) continue;\n    released.push(id);\n    let landed: unknown = startWorld;\n    for (const op of ops) {\n      const a = op.args as { id?: string; to?: unknown };\n      if (op.name === 'transform' && a.id === (id as string)) landed = a.to;\n      releasedOps.push(rebaseReleased(op));\n    }\n    srcChildren = [...srcChildren, { id: id as string, pose: landed }];\n  }\n  return { ops: releasedOps, released };\n}\n\n/** What the source layouts and the exits decide for a drop no container took.\n *  `undefined` when none of them claims any dragged id. */\nexport function layoutReleaseOps(\n  session: MoveSession,\n  delta: { dx: number; dy: number },\n  dropCenter: { x: number; y: number } | null,\n): Op[] | undefined {\n  const { dx, dy } = delta;\n  // No container accepted the drop. Each source layout gets a say\n  // over its own children before they are left wherever the pointer\n  // stopped; the rest of the selection falls through to the translate.\n  const released = new Set<NodeId>();\n  const releasedOps: Op[] = [];\n  let exits = new Map<NodeId, NodeId | null>();\n  const exitOps: Op[] = [];\n  if (session.layout) {\n    const pc = session.pc;\n    const commitAdapter = scenePoseAdapter(session.scene);\n    const sources = groupBySourceContainer(\n      session.ids.map((id) => ({\n        id,\n        sourceContainerId: (session.scene.get(id)?.parent ?? null) as string | null,\n      })),\n      null,\n    );\n    for (const [srcId, leaving] of sources) {\n      const from = releaseFrom(session, delta, srcId, leaving, commitAdapter);\n      for (const id of from.released) released.add(id);\n      releasedOps.push(...from.ops);\n    }\n    // A child its container let go of outside that container leaves it,\n    // keeping the world pose it was dropped at.\n    exits = resolveLayoutExits(session, dropCenter, session.ids.filter((id) => !released.has(id)));\n    for (const [id, toParent] of exits) {\n      const node = session.scene.get(id)!;\n      const world = draggedWorldPose(session, grabbedPoseAdapter(session, commitAdapter), id, { dx, dy });\n      exitOps.push(createReparentOp({\n        id: id as string,\n        fromParentId: node.parent as string | null,\n        toParentId: toParent as string | null,\n        label: 'Reparent',\n      }));\n      exitOps.push(createTransformOp<unknown>({\n        id: id as string,\n        from: node.pose,\n        to: rebaseLocalPose(commitAdapter, world, toParent as string | null, pc.compose, pc.decompose),\n        label: session.lifecycle.label,\n      }));\n    }\n  }\n  if (released.size === 0 && exits.size === 0) return undefined;\n  return [\n    ...releasedOps,\n    ...exitOps,\n    ...translateOps(\n      session,\n      unreleasedIds(session, released).filter((id) => !exits.has(id)),\n      { dx, dy },\n    ),\n  ];\n}\n"],"mappings":"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"}

package/dist/interactions/actions/move/commit/rebase.js

@@ -0,0 +1,18 @@
+import { rebaseLocalPose as e } from "../../../../core/scene/composeFrame.js";
+import { createTransformOp as t } from "../../../../core/ops/transform.js";
+//#region src/interactions/actions/move/commit/rebase.ts
+function n(n, r, i, a, o) {
+	if (n.name !== "transform") return n;
+	let s = n.args;
+	return t({
+		id: s.id,
+		from: e(r, s.from, a, i.compose, i.decompose),
+		to: e(r, s.to, o, i.compose, i.decompose),
+		label: s.label,
+		coalesceKey: s.coalesceKey
+	});
+}
+//#endregion
+export { n as rebaseTransformOp };
+
+//# sourceMappingURL=rebase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rebase.js","names":["rebaseTransformOp","op","a","createTransformOp","rebaseLocalPose","adapter","fromParent","pc","toParent"],"sources":["../../../../../src/interactions/actions/move/commit/rebase.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { rebaseLocalPose, type PoseAdapter, type PoseComposition } from 'core/scene/composePose';\n\n/** A world-posed transform op as one in its node's stored frame: `from` under\n *  `fromParent`, `to` under `toParent`. Any other op is returned as it is. */\nexport function rebaseTransformOp(\n  op: Op,\n  adapter: PoseAdapter<unknown>,\n  pc: PoseComposition<unknown>,\n  fromParent: string | null,\n  toParent: string | null,\n): Op {\n  if (op.name !== 'transform') return op;\n  const a = op.args as { id: string; from: unknown; to: unknown; label?: string; coalesceKey?: string };\n  return createTransformOp<unknown>({\n    id: a.id,\n    from: rebaseLocalPose(adapter, a.from, fromParent, pc.compose, pc.decompose),\n    to: rebaseLocalPose(adapter, a.to, toParent, pc.compose, pc.decompose),\n    label: a.label,\n    coalesceKey: a.coalesceKey,\n  });\n}\n"],"mappings":";;;AAMA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACI;CACJ,IAAIC,EAAG,SAAS,aAAa,OAAOA;CACpC,IAAMC,IAAID,EAAG;CACb,OAAOE,EAA2B;EAChC,IAAID,EAAE;EACN,MAAME,EAAgBC,GAASH,EAAE,MAAMI,GAAYC,EAAG,SAASA,EAAG,SAAS;EAC3E,IAAIH,EAAgBC,GAASH,EAAE,IAAIM,GAAUD,EAAG,SAASA,EAAG,SAAS;EACrE,OAAOL,EAAE;EACT,aAAaA,EAAE;CACjB,CAAC;AACH"}

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

@@ -0,0 +1,65 @@
+import { planeToPlane as e } from "../../../../core/viewport/parallax.js";
+import { rebaseLocalPose as t } from "../../../../core/scene/composeFrame.js";
+import { carryPose as n, planeOf as r } from "../../planeInput.js";
+import { createReparentOp as i } from "../../../../core/ops/reparent.js";
+import { createTransformOp as a } from "../../../../core/ops/transform.js";
+import { scenePoseAdapter as o } from "../../../../core/scene/scenePoseAdapter.js";
+import { draggedWorldPose as s, grabbedPoseAdapter as c } from "../delta.js";
+import { translateOps as l } from "../translate.js";
+import { createSetLayerOp as u } from "../../../../core/ops/setLayer.js";
+//#region src/interactions/actions/move/commit/reparent.ts
+function d(e, t) {
+	let n = e.nodeAtPoint;
+	if (!n) return null;
+	let r = n(t, /* @__PURE__ */ new Set([...e.ids, ...e.cascadeIds]));
+	if (!r) return null;
+	let i = e.scene.get(r);
+	return i ? i.kind === "container" ? {
+		newParent: r,
+		newLayer: i.layer,
+		hitSibling: null
+	} : {
+		newParent: i.parent,
+		newLayer: i.layer,
+		hitSibling: r
+	} : null;
+}
+function f(d, f, p, m) {
+	let { scene: h, pc: g, view: _ } = d, v = o(h), y = d.lifecycle.label, b = [], x = [...f.newParent === null ? h.roots : h.childrenOf(f.newParent)];
+	for (let o of d.ids) {
+		if (!d.startPoses.has(o)) continue;
+		let l = h.get(o), S = l.layer !== f.newLayer, C = n(d.descriptorOf(o), s(d, c(d, v), o, m), S ? e(r(_, l.layer), r(_, f.newLayer)) : null), w = t(v, C, f.newParent, g.compose, g.decompose), T = l.parent;
+		S && (T !== null && (b.push(i({
+			id: o,
+			fromParentId: T,
+			toParentId: null,
+			label: y,
+			coalesceKey: `reparent:${o}:orphan`
+		})), T = null), b.push(u({
+			id: o,
+			from: l.layer,
+			to: f.newLayer,
+			label: y
+		})));
+		let E = x.indexOf(o);
+		E >= 0 && x.splice(E, 1);
+		let D = p === "above" && f.hitSibling ? x.indexOf(f.hitSibling) : -1, O = D >= 0 ? D + 1 : void 0;
+		O === void 0 ? x.push(o) : x.splice(O, 0, o), b.push(i({
+			id: o,
+			fromParentId: T,
+			toParentId: f.newParent,
+			toIndex: O,
+			label: y
+		})), b.push(a({
+			id: o,
+			from: l.pose,
+			to: w,
+			label: y
+		}));
+	}
+	return [...b, ...l(d, d.cascadeIds, m)];
+}
+//#endregion
+export { f as reparentOps, d as resolveDropTarget };
+
+//# sourceMappingURL=reparent.js.map

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

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

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

@@ -0,0 +1,51 @@
+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";
+//#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
+	};
+	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)));
+	return {
+		dx: f.x - d.x,
+		dy: f.y - d.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));
+}
+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
+	};
+	let c = r(t.view, o), l = {
+		x: s.edited.x + i,
+		y: s.edited.y + a
+	}, u = c ? e(c, l) : l;
+	return {
+		dx: u.x - s.own.x,
+		dy: u.y - s.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)
+	};
+}
+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));
+}
+//#endregion
+export { a as draggedStoredPose, c as draggedWorldPose, s as grabbedPoseAdapter, i as localDelta, o as planeDelta };
+
+//# sourceMappingURL=delta.js.map

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

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

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

@@ -0,0 +1,47 @@
+import { draggedStoredPose as e } from "./delta.js";
+import { pointerStateOf as t } from "../pointerState.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 = {
+		kind: "translate",
+		dx: s,
+		dy: c
+	};
+	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);
+		}
+	}
+	return f.kind === "translate" && (s = f.dx, c = f.dy), {
+		dx: s,
+		dy: c,
+		posed: l,
+		opaque: u
+	};
+}
+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);
+	}
+	for (let [e, n] of s) t.startPoses.has(e) || u.set(e, n);
+	return {
+		delta: l,
+		previews: u,
+		opaque: c
+	};
+}
+//#endregion
+export { r as nextFrame };
+
+//# sourceMappingURL=frame.js.map

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

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