@weasel-js/core 1.10.0 → 1.11.0

package/dist/interactions/actions/rotate/session.js

@@ -1,92 +1,141 @@
-import { unionAABB as e } from "../../../core/geometry/unionBounds.js";
-import { visualBoundsViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
-import { readGestureLifecycle as n } from "../gestureLifecycle.js";
-import { carryPose as r, invertPlane as i, planeOf as a } from "../planeInput.js";
-import { gestureReaders as o } from "../../gestures/shared/screenTolerance.js";
-import { nodeDescriptors as s, poseDescriptorOf as c } from "../poseDescriptorDep.js";
-import { shapeSources as l } from "../selectionSubtree.js";
-import { pointerStateOf as u } from "../pointerState.js";
-import { scenePoseFrame as d } from "../poseFrame.js";
-import { sceneGestureFrames as f } from "../gestureFrames.js";
-import { moveGestureAdapter as p } from "../move/gestureAdapter.js";
-import { DEFAULT_ROTATE_BEHAVIORS as m } from "./behaviors/index.js";
-import { resolveParams as h } from "@weasel-js/routing";
+import { unionAABB } from "../../../core/geometry/unionBounds.js";
+import { scenePoseFrame } from "../poseFrame.js";
+import { nodeDescriptors, poseDescriptorOf } from "../poseDescriptorDep.js";
+import { readGestureLifecycle } from "../gestureLifecycle.js";
+import { carryPose, invertPlane, planeOf } from "../planeInput.js";
+import { gestureReaders } from "../../gestures/shared/screenTolerance.js";
+import { shapeSources } from "../selectionSubtree.js";
+import { pointerStateOf } from "../pointerState.js";
+import { drawnBoxes } from "../drawnBoxes.js";
+import { sceneGestureFrames } from "../gestureFrames.js";
+import { moveGestureAdapter } from "../move/gestureAdapter.js";
+import { SNAP_ANGLE_STEP } from "../../../features/snap/roles.js";
+import { inputSession } from "../../../features/snap/session2d.js";
+import { resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/rotate/session.ts
-function g(e, n, o, s, c) {
-	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = [];
-	for (let f of o) {
-		let o = n.get(f);
-		if (!o) continue;
-		let p = s(f);
-		if (!p.withRotation || p.supportsRotation?.(o.pose) === !1) continue;
-		l.set(f, o.pose);
-		let m = r(p, c.world(f), i(a(e.deps.view, o.layer))), h = p.getBounds(m);
-		u.set(f, {
-			world: m,
+function captureOrigins(view, scene, ids, descriptorOf, poseFrame, boxes) {
+	const originPoses = /* @__PURE__ */ new Map();
+	const origins = /* @__PURE__ */ new Map();
+	const visual = [];
+	for (const id of ids) {
+		const node = scene.get(id);
+		if (!node) continue;
+		const g = descriptorOf(id);
+		if (!g.withRotation || g.supportsRotation?.(node.pose) === false) continue;
+		originPoses.set(id, node.pose);
+		const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(view, node.layer)));
+		const b = g.getBounds(world);
+		origins.set(id, {
+			world,
 			center: {
-				x: h.x + h.width / 2,
-				y: h.y + h.height / 2
+				x: b.x + b.width / 2,
+				y: b.y + b.height / 2
 			},
-			rotation: p.getRotation?.(m) ?? 0
-		}), d.push(t(m, p));
+			rotation: g.getRotation?.(world) ?? 0
+		});
+		visual.push(boxes.aabb(id, world));
 	}
 	return {
-		originPoses: l,
-		origins: u,
-		visual: d
+		originPoses,
+		origins,
+		visual
 	};
 }
-function _(e, t, n, r, i) {
+function buildGestureContext(ctx, scene, origins, readers, selectionMethods) {
 	return {
-		draggedIds: [...n.keys()],
-		origin: new Map([...n].map(([e, t]) => [e, t.world])),
-		current: new Map([...n].map(([e, t]) => [e, t.world])),
+		draggedIds: [...origins.keys()],
+		origin: new Map([...origins].map(([id, o]) => [id, o.world])),
+		current: new Map([...origins].map(([id, o]) => [id, o.world])),
 		snap: null,
-		modifiers: { ...e.modifiers },
-		pointer: u(e.world, e),
-		view: r.view(),
-		plane: r.plane(),
-		frames: f(t, e.deps.view),
-		adapter: p(t, void 0, i),
+		modifiers: { ...ctx.modifiers },
+		pointer: pointerStateOf(ctx.world, ctx),
+		view: readers.view(),
+		plane: readers.plane(),
+		kitSettings: readers.kitSettings,
+		frames: sceneGestureFrames(scene, ctx.deps),
+		adapter: moveGestureAdapter(scene, void 0, selectionMethods),
 		scratch: {}
 	};
 }
-function v(t, r) {
-	let i = t.deps.selection, a = t.deps.scene, u = h(r?.params), f = r?.behaviors ?? m;
-	if (!i || !a) return null;
-	let p = l(a, i.get());
-	if (p.length === 0) return null;
-	let v = s(a, c(t.deps.poseDescriptor)), y = d(a), { originPoses: b, origins: x, visual: S } = g(t, a, p, v, y);
-	if (b.size === 0) return null;
-	let C = e(S), w = {
-		x: C.x + C.width / 2,
-		y: C.y + C.height / 2
-	}, T = o(t.deps), E = _(t, a, x, T, i.adapterMethods);
-	for (let e of f) e.onStart?.(E);
+/** What turning `ids` (already resolved to shape sources) is computed from,
+*  with each one's pose as stored. Null when none of them can turn. */
+function captureTurn(scene, ids, deps, pivot) {
+	const view = deps.view;
+	const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(deps.poseDescriptor));
+	const poseFrame = scenePoseFrame(scene);
+	const { originPoses, origins, visual } = captureOrigins(view, scene, ids, descriptorOf, poseFrame, drawnBoxes({
+		...deps,
+		scene
+	}, poseFrame));
+	if (originPoses.size === 0) return null;
+	const union = unionAABB(visual);
 	return {
-		session: {
-			scene: a,
-			ids: p,
-			turn: {
-				origins: x,
-				pivot: w,
-				useUnionPivot: p.length > 1 && u?.pivot !== "each",
-				descriptorOf: v
+		turn: {
+			origins,
+			pivot: {
+				x: union.x + union.width / 2,
+				y: union.y + union.height / 2
 			},
-			poseFrame: y,
-			view: t.deps.view,
-			originPoses: b,
-			startPointerAngle: Math.atan2(t.world.y - w.y, t.world.x - w.x),
-			behaviors: f,
-			gestureCtx: E,
-			applyOps: t.deps.applyOps,
-			selectionMethods: i.adapterMethods,
-			lifecycle: n(u, "Rotate", f)
+			useUnionPivot: ids.length > 1 && pivot !== "each",
+			descriptorOf
 		},
-		readers: T
+		originPoses,
+		poseFrame
+	};
+}
+/** The drag's snap session: the first rotated node's angle about the pivot,
+*  stepping by `SNAP_ANGLE_STEP` while `snap.constrain` is held. */
+function beginSnap(ctx, ids, pivot, theta0) {
+	const req = {
+		gesture: "rotate",
+		ids,
+		press: ctx.world,
+		pivot,
+		theta0,
+		constrain: { step: SNAP_ANGLE_STEP }
+	};
+	return ctx.deps.snap?.begin(req) ?? inputSession(req);
+}
+/** Capture a rotate at press. Null when nothing selected can turn. Runs each
+*  behavior's `onStart`. */
+function beginRotate(ctx, opts) {
+	const selection = ctx.deps.selection;
+	const scene = ctx.deps.scene;
+	const params = resolveParams(opts?.params);
+	const behaviors = opts?.behaviors ?? [];
+	if (!selection || !scene) return null;
+	const ids = shapeSources(scene, selection.get());
+	if (ids.length === 0) return null;
+	const captured = captureTurn(scene, ids, ctx.deps, params?.["pivot"] === "each" ? "each" : "union");
+	if (!captured) return null;
+	const { turn, originPoses, poseFrame } = captured;
+	const { origins, pivot } = turn;
+	const readers = gestureReaders(ctx.deps);
+	const gestureCtx = buildGestureContext(ctx, scene, origins, readers, selection.adapterMethods);
+	for (const b of behaviors) b.onStart?.(gestureCtx);
+	const theta0 = origins.values().next().value?.rotation ?? 0;
+	return {
+		session: {
+			scene,
+			ids,
+			turn,
+			poseFrame,
+			view: ctx.deps.view,
+			originPoses,
+			startPointerAngle: Math.atan2(ctx.world.y - pivot.y, ctx.world.x - pivot.x),
+			theta0,
+			snap: beginSnap(ctx, [.../* @__PURE__ */ new Set([...selection.get(), ...ids])], pivot, theta0),
+			behaviors,
+			gestureCtx,
+			applyOps: ctx.deps.applyOps,
+			selectionMethods: selection.adapterMethods,
+			lifecycle: readGestureLifecycle(params, "Rotate", behaviors)
+		},
+		readers
 	};
 }
-//#endregion
-export { v as beginRotate };
 
+//#endregion
+export { beginRotate, captureTurn };
 //# sourceMappingURL=session.js.map

package/dist/interactions/actions/rotate/session.js.map

@@ -1 +1 @@
-{"version":3,"file":"session.js","names":["captureOrigins","originPoses","origins","visual","id","ids","node","scene","g","descriptorOf","world","carryPose","poseFrame","invertPlane","planeOf","ctx","b","visualBoundsViaDescriptor","buildGestureContext","o","pointerStateOf","readers","sceneGestureFrames","moveGestureAdapter","selectionMethods","beginRotate","selection","params","resolveParams","opts","behaviors","DEFAULT_ROTATE_BEHAVIORS","shapeSources","nodeDescriptors","poseDescriptorOf","scenePoseFrame","union","unionAABB","pivot","gestureReaders","gestureCtx","\"pivot\"","readGestureLifecycle"],"sources":["../../../../src/interactions/actions/rotate/session.ts"],"sourcesContent":["import type { BindingOpts, InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { sceneGestureFrames } from '../gestureFrames';\nimport { resolveParams } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, RotateBehavior } from '../../gestures/types';\nimport { readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { DEFAULT_ROTATE_BEHAVIORS } from './behaviors';\nimport { moveGestureAdapter } from '../move/gestureAdapter';\nimport { carryPose, invertPlane, planeOf } from '../planeInput';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from '../resize/geometry';\nimport { shapeSources } from '../selectionSubtree';\n\n/** One rotated node as the press found it, in the plane the pointer's angle\n *  is read in. */\nexport interface TurnOrigin {\n  readonly world: unknown;\n  /** Center of `world`'s bounds. */\n  readonly center: { x: number; y: number };\n  readonly rotation: number;\n}\n\n/** What a turn by some delta is computed from. */\nexport interface Turn {\n  readonly origins: ReadonlyMap<NodeId, TurnOrigin>;\n  /** The point the pointer orbits: the center of what the selection draws. */\n  readonly pivot: { x: number; y: number };\n  /** Orbit each node's center around `pivot`, for a multi-selection. Off,\n   *  each node turns about its own center. */\n  readonly useUnionPivot: boolean;\n  readonly descriptorOf: (id: NodeId) => PoseDescriptor<unknown>;\n}\n\n/** What a rotate captured at press. Nothing here changes during the drag. */\nexport interface RotateSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  readonly ids: readonly NodeId[];\n  readonly turn: Turn;\n  /** World reads and local writes over the scene's composition strategy. */\n  readonly poseFrame: PoseFrame<unknown>;\n  readonly view: unknown;\n  /** Each rotated node's pose as stored: the `from` of its op. */\n  readonly originPoses: ReadonlyMap<NodeId, unknown>;\n  /** Pointer angle around the pivot at press. */\n  readonly startPointerAngle: number;\n  readonly behaviors: readonly RotateBehavior<unknown>[];\n  /** Reused across the drag; behaviors mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<unknown>;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  readonly selectionMethods: SelectionApi['adapterMethods'] | undefined;\n  readonly lifecycle: GestureLifecycle;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface RotateFrame {\n  /** Radians turned since press, as the behaviors shaped it. */\n  readonly delta: number;\n  /** Stored-frame pose of every rotated id; empty at a zero delta. */\n  readonly previews: Map<NodeId, unknown>;\n}\n\nfunction captureOrigins(\n  ctx: InvocationCtx,\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  descriptorOf: (id: NodeId) => PoseDescriptor<unknown>,\n  poseFrame: PoseFrame<unknown>,\n): { originPoses: Map<NodeId, unknown>; origins: Map<NodeId, TurnOrigin>; visual: Bounds[] } {\n  const originPoses = new Map<NodeId, unknown>();\n  const origins = new Map<NodeId, TurnOrigin>();\n  const visual: Bounds[] = [];\n  for (const id of ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const g = descriptorOf(id);\n    if (!g.withRotation || g.supportsRotation?.(node.pose) === false) continue;\n    originPoses.set(id, node.pose);\n    // The pivot is a world point, so every measurement the gesture orbits\n    // is taken from the world pose, not the stored one — carried into the\n    // plane the edit is measured in, where the pointer's angle is read.\n    const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(ctx.deps.view, node.layer)));\n    const b = g.getBounds(world);\n    origins.set(id, {\n      world,\n      center: { x: b.x + b.width / 2, y: b.y + b.height / 2 },\n      rotation: g.getRotation?.(world) ?? 0,\n    });\n    visual.push(visualBoundsViaDescriptor(world, g));\n  }\n  return { originPoses, origins, visual };\n}\n\nfunction buildGestureContext(\n  ctx: InvocationCtx,\n  scene: Scene<unknown, string, unknown>,\n  origins: ReadonlyMap<NodeId, TurnOrigin>,\n  readers: GestureReaders,\n  selectionMethods: SelectionApi['adapterMethods'],\n): GestureContext<unknown> {\n  return {\n    draggedIds: [...origins.keys()] as string[],\n    origin: new Map([...origins].map(([id, o]) => [id as string, o.world])),\n    current: new Map([...origins].map(([id, o]) => [id as string, o.world])),\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    adapter: moveGestureAdapter(scene, undefined, selectionMethods) as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n}\n\n/** Capture a rotate at press. Null when nothing selected can turn. Runs each\n *  behavior's `onStart`. */\nexport function beginRotate(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n): { session: RotateSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  const params = resolveParams(opts?.params);\n  const behaviors = (opts?.behaviors ?? DEFAULT_ROTATE_BEHAVIORS) as readonly RotateBehavior<unknown>[];\n\n  if (!selection || !scene) return null;\n\n  // A group whose pose derives from its children turns by turning them.\n  const ids = shapeSources(scene, selection.get()) as NodeId[];\n  if (ids.length === 0) return null;\n\n  const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(ctx.deps.poseDescriptor));\n  // The pivot the pointer orbits is a world point, so every pose the\n  // gesture turns is a world pose. Each turned result is stored back in\n  // the node's own parent frame at preview and commit alike.\n  const poseFrame = scenePoseFrame(scene);\n  const { originPoses, origins, visual } = captureOrigins(ctx, scene, ids, descriptorOf, poseFrame);\n  if (originPoses.size === 0) return null;\n\n  const union = unionAABB(visual)!;\n  const pivot = { x: union.x + union.width / 2, y: union.y + union.height / 2 };\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, scene, origins, readers, selection.adapterMethods);\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n\n  const session: RotateSession = {\n    scene,\n    ids,\n    turn: {\n      origins,\n      pivot,\n      useUnionPivot: ids.length > 1 && params?.['pivot'] !== 'each',\n      descriptorOf,\n    },\n    poseFrame,\n    view: ctx.deps.view,\n    originPoses,\n    startPointerAngle: Math.atan2(ctx.world.y - pivot.y, ctx.world.x - pivot.x),\n    behaviors,\n    gestureCtx,\n    applyOps: ctx.deps.applyOps,\n    selectionMethods: selection.adapterMethods,\n    lifecycle: readGestureLifecycle(params, 'Rotate', behaviors),\n  };\n  return { session, readers };\n}\n"],"mappings":"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"}
+{"version":3,"file":"session.js","names":[],"sources":["../../../../src/interactions/actions/rotate/session.ts"],"sourcesContent":["import type { ActionDeps, BindingOpts, InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { sceneGestureFrames } from '../gestureFrames';\nimport { resolveParams } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, RotateBehavior } from '../../gestures/types';\nimport { readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { moveGestureAdapter } from '../move/gestureAdapter';\nimport { carryPose, invertPlane, planeOf } from '../planeInput';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport type { PoseDescriptor } from '../resize/geometry';\nimport { drawnBoxes, type DrawnBoxes } from '../drawnBoxes';\nimport { shapeSources } from '../selectionSubtree';\nimport type { SnapBegin, SnapSession } from '../snapDep';\nimport { inputSession } from 'features/snap/session2d';\nimport { SNAP_ANGLE_STEP } from 'features/snap/roles';\n\n/** One rotated node as the press found it, in the plane the pointer's angle\n *  is read in. */\nexport interface TurnOrigin {\n  readonly world: unknown;\n  /** Center of `world`'s bounds. */\n  readonly center: { x: number; y: number };\n  readonly rotation: number;\n}\n\n/** What a turn by some delta is computed from. */\nexport interface Turn {\n  readonly origins: ReadonlyMap<NodeId, TurnOrigin>;\n  /** The point the pointer orbits: the center of what the selection draws. */\n  readonly pivot: { x: number; y: number };\n  /** Orbit each node's center around `pivot`, for a multi-selection. Off,\n   *  each node turns about its own center. */\n  readonly useUnionPivot: boolean;\n  readonly descriptorOf: (id: NodeId) => PoseDescriptor<unknown>;\n}\n\n/** What a rotate captured at press. Nothing here changes during the drag. */\nexport interface RotateSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  readonly ids: readonly NodeId[];\n  readonly turn: Turn;\n  /** World reads and local writes over the scene's composition strategy. */\n  readonly poseFrame: PoseFrame<unknown>;\n  readonly view: unknown;\n  /** Each rotated node's pose as stored: the `from` of its op. */\n  readonly originPoses: ReadonlyMap<NodeId, unknown>;\n  /** Pointer angle around the pivot at press. */\n  readonly startPointerAngle: number;\n  /** The first rotated node's rotation at press: the angle that snaps. */\n  readonly theta0: number;\n  /** The drag's snapping: the `snap` dep's session, else one that only\n   *  steps while `snap.constrain` is held. */\n  readonly snap: SnapSession;\n  readonly behaviors: readonly RotateBehavior<unknown>[];\n  /** Reused across the drag; behaviors mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<unknown>;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  readonly selectionMethods: SelectionApi['adapterMethods'] | undefined;\n  readonly lifecycle: GestureLifecycle;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface RotateFrame {\n  /** Radians turned since press, as the behaviors shaped it. */\n  readonly delta: number;\n  /** Stored-frame pose of every rotated id; empty at a zero delta. */\n  readonly previews: Map<NodeId, unknown>;\n}\n\nfunction captureOrigins(\n  view: unknown,\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  descriptorOf: (id: NodeId) => PoseDescriptor<unknown>,\n  poseFrame: PoseFrame<unknown>,\n  boxes: DrawnBoxes,\n): { originPoses: Map<NodeId, unknown>; origins: Map<NodeId, TurnOrigin>; visual: Bounds[] } {\n  const originPoses = new Map<NodeId, unknown>();\n  const origins = new Map<NodeId, TurnOrigin>();\n  const visual: Bounds[] = [];\n  for (const id of ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const g = descriptorOf(id);\n    if (!g.withRotation || g.supportsRotation?.(node.pose) === false) continue;\n    originPoses.set(id, node.pose);\n    // The pivot is a world point, so every measurement the gesture orbits\n    // is taken from the world pose, not the stored one — carried into the\n    // plane the edit is measured in, where the pointer's angle is read.\n    const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(view, node.layer)));\n    const b = g.getBounds(world);\n    origins.set(id, {\n      world,\n      center: { x: b.x + b.width / 2, y: b.y + b.height / 2 },\n      rotation: g.getRotation?.(world) ?? 0,\n    });\n    visual.push(boxes.aabb(id, world));\n  }\n  return { originPoses, origins, visual };\n}\n\nfunction buildGestureContext(\n  ctx: InvocationCtx,\n  scene: Scene<unknown, string, unknown>,\n  origins: ReadonlyMap<NodeId, TurnOrigin>,\n  readers: GestureReaders,\n  selectionMethods: SelectionApi['adapterMethods'],\n): GestureContext<unknown> {\n  return {\n    draggedIds: [...origins.keys()] as string[],\n    origin: new Map([...origins].map(([id, o]) => [id as string, o.world])),\n    current: new Map([...origins].map(([id, o]) => [id as string, o.world])),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(ctx.world, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    kitSettings: readers.kitSettings,\n    frames: sceneGestureFrames(scene, ctx.deps),\n    adapter: moveGestureAdapter(scene, undefined, selectionMethods) as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n}\n\n/** What turning `ids` (already resolved to shape sources) is computed from,\n *  with each one's pose as stored. Null when none of them can turn. */\nexport function captureTurn(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  deps: Pick<ActionDeps, 'view' | 'poseDescriptor' | 'boundsIncludeStroke'>,\n  pivot: 'union' | 'each',\n): { turn: Turn; originPoses: Map<NodeId, unknown>; poseFrame: PoseFrame<unknown> } | null {\n  const view = deps.view;\n  const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(deps.poseDescriptor));\n  // The pivot the pointer orbits is a world point, so every pose the\n  // gesture turns is a world pose. Each turned result is stored back in\n  // the node's own parent frame at preview and commit alike.\n  const poseFrame = scenePoseFrame(scene);\n  // A selection turns about the center of the box its chrome draws.\n  const boxes = drawnBoxes({ ...deps, scene }, poseFrame);\n  const { originPoses, origins, visual } = captureOrigins(view, scene, ids, descriptorOf, poseFrame, boxes);\n  if (originPoses.size === 0) return null;\n  const union = unionAABB(visual)!;\n  return {\n    turn: {\n      origins,\n      pivot: { x: union.x + union.width / 2, y: union.y + union.height / 2 },\n      useUnionPivot: ids.length > 1 && pivot !== 'each',\n      descriptorOf,\n    },\n    originPoses,\n    poseFrame,\n  };\n}\n\n/** The drag's snap session: the first rotated node's angle about the pivot,\n *  stepping by `SNAP_ANGLE_STEP` while `snap.constrain` is held. */\nfunction beginSnap(ctx: InvocationCtx, ids: readonly string[], pivot: { x: number; y: number }, theta0: number): SnapSession {\n  const req: SnapBegin = {\n    gesture: 'rotate', ids, press: ctx.world, pivot, theta0, constrain: { step: SNAP_ANGLE_STEP },\n  };\n  return ctx.deps.snap?.begin(req) ?? inputSession(req);\n}\n\n/** Capture a rotate at press. Null when nothing selected can turn. Runs each\n *  behavior's `onStart`. */\nexport function beginRotate(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n): { session: RotateSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  const params = resolveParams(opts?.params);\n  const behaviors = (opts?.behaviors ?? []) as readonly RotateBehavior<unknown>[];\n\n  if (!selection || !scene) return null;\n\n  // A group whose pose derives from its children turns by turning them.\n  const ids = shapeSources(scene, selection.get()) as NodeId[];\n  if (ids.length === 0) return null;\n\n  const captured = captureTurn(scene, ids, ctx.deps, params?.['pivot'] === 'each' ? 'each' : 'union');\n  if (!captured) return null;\n  const { turn, originPoses, poseFrame } = captured;\n  const { origins, pivot } = turn;\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, scene, origins, readers, selection.adapterMethods);\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n  const theta0 = origins.values().next().value?.rotation ?? 0;\n\n  const session: RotateSession = {\n    scene,\n    ids,\n    turn,\n    poseFrame,\n    view: ctx.deps.view,\n    originPoses,\n    startPointerAngle: Math.atan2(ctx.world.y - pivot.y, ctx.world.x - pivot.x),\n    theta0,\n    snap: beginSnap(ctx, [...new Set([...selection.get(), ...ids])], pivot, theta0),\n    behaviors,\n    gestureCtx,\n    applyOps: ctx.deps.applyOps,\n    selectionMethods: selection.adapterMethods,\n    lifecycle: readGestureLifecycle(params, 'Rotate', behaviors),\n  };\n  return { session, readers };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/selectionSubtree.js

@@ -1,69 +1,140 @@
-import { poseDescriptorForNode as e, translatePoseViaDescriptor as t } from "../../core/geometry/poseDescriptor.js";
-import { asNodeId as n } from "../../core/scene/types.js";
+import { poseDescriptorForNode, translatePoseViaDescriptor } from "../../core/geometry/poseDescriptor.js";
+import { asNodeId } from "../../core/scene/types.js";
+
 //#region src/interactions/actions/selectionSubtree.ts
-function r(e, t, n) {
-	let r = e.get(t)?.parent ?? null;
-	for (; r != null;) {
-		if (n.has(r)) return !0;
-		r = e.get(r)?.parent ?? null;
+/** True when any ancestor of `id` is also in `set` — acting on that ancestor
+*  already reaches this node, so acting on it again would double it. */
+function hasSelectedAncestor(scene, id, set) {
+	let parent = scene.get(id)?.parent ?? null;
+	while (parent != null) {
+		if (set.has(parent)) return true;
+		parent = scene.get(parent)?.parent ?? null;
 	}
-	return !1;
+	return false;
+}
+/** The ids in `ids` that are in the scene and have no selected ancestor. */
+function selectedRoots(scene, ids) {
+	const set = new Set(ids);
+	return ids.map((id) => asNodeId(id)).filter((id) => scene.get(id) !== void 0 && !hasSelectedAncestor(scene, id, set));
 }
-function i(e, t) {
-	let i = new Set(t);
-	return t.map((e) => n(e)).filter((t) => e.get(t) !== void 0 && !r(e, t, i));
+/** Whether `id` draws a path derived from other nodes. Its pose is a
+*  placeholder: the path follows the nodes it derives from. */
+function derivesPathOnly(scene, id) {
+	const node = scene.get(asNodeId(id));
+	return node?.derivePath !== void 0 && node.derivePose === void 0 && Array.isArray(node.dependsOn) && node.dependsOn.length > 0;
 }
-function a(e, t) {
-	let r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), a = (t) => {
-		if (i.has(t)) return;
-		i.add(t);
-		let o = e.get(n(t)), s = o?.derivePose !== void 0 && Array.isArray(o.dependsOn) ? o.dependsOn : [];
-		if (s.length === 0) r.add(t);
-		else for (let e of s) a(e);
+/**
+* The nodes a translation of `ids` has to act on. A node whose pose is derived
+* from an id list cannot be moved itself, since a pose written to it is
+* overwritten on the next read, so the nodes it derives from stand in for it,
+* through however many derived nodes that takes. A node reached that way which
+* derives only its path — a wire under a label — follows its own dependencies
+* and is not written. Each id appears once, in the order it was first reached.
+*/
+function moveSources(scene, ids) {
+	const out = /* @__PURE__ */ new Set();
+	const walked = /* @__PURE__ */ new Set();
+	const visit = (id, reached) => {
+		if (walked.has(id)) return;
+		walked.add(id);
+		if (reached && derivesPathOnly(scene, id)) return;
+		const node = scene.get(asNodeId(id));
+		const deps = node?.derivePose !== void 0 && Array.isArray(node.dependsOn) ? node.dependsOn : [];
+		if (deps.length === 0) out.add(id);
+		else for (const dep of deps) visit(dep, true);
 	};
-	for (let e of t) a(e);
-	return [...r];
+	for (const id of ids) visit(id, false);
+	return [...out];
 }
-function o(e, t) {
-	let r = /* @__PURE__ */ new Set(), i = (t) => {
-		let a = e.get(n(t));
-		if (a !== void 0 && a.dependsOn === "children" && a.derivePose !== void 0) for (let r of e.childrenOf(n(t))) i(r);
-		else r.add(t);
+/**
+* The nodes a resize, rotation, flip, or alignment of `ids` has to write. A
+* node whose pose is derived cannot be written itself, so what it derives
+* from stands in for it — a container's children, or the ids a node names —
+* through however many derived nodes that takes, leaving out one reached that
+* way which derives only its path, as {@link moveSources} does. Each id appears once, in the order it
+* was first reached.
+*/
+function shapeSources(scene, ids) {
+	const out = /* @__PURE__ */ new Set();
+	const walked = /* @__PURE__ */ new Set();
+	const visit = (id, reached) => {
+		if (walked.has(id)) return;
+		walked.add(id);
+		if (reached && derivesPathOnly(scene, id)) return;
+		const node = scene.get(asNodeId(id));
+		const deps = node?.derivePose === void 0 ? [] : node.dependsOn === "children" ? scene.childrenOf(asNodeId(id)) : node.dependsOn ?? [];
+		if (deps.length === 0 && node?.dependsOn !== "children") out.add(id);
+		else for (const dep of deps) visit(dep, true);
 	};
-	for (let e of t) i(e);
-	return [...r];
+	for (const id of ids) visit(id, false);
+	return [...out];
 }
-function s(e, t) {
-	let n = [], r = (t) => {
-		n.push(t);
-		for (let n of e.childrenOf(t)) r(n);
+/** `id` and everything under it, a parent ahead of its children. */
+function subtreeIds(scene, id) {
+	const out = [];
+	const walk = (at) => {
+		out.push(at);
+		for (const child of scene.childrenOf(at)) walk(child);
 	};
-	return r(t), n;
+	walk(id);
+	return out;
 }
-function c(e, t, n) {
-	let r = /* @__PURE__ */ new Set();
-	for (let t of i(e, n)) for (let n of s(e, t)) r.add(n);
-	return t.pc.closure === "identity" ? [...r] : [...r].filter((e) => {
-		let n = t.frame(e);
-		return n === null || !r.has(n);
+/**
+* The nodes whose stored pose has to change for `ids` to move as a unit: each
+* selected node and its descendants, less any stored in the frame of another
+* node in the set, which that frame carries. With the default absolute poses
+* nothing is carried and every descendant is written.
+*/
+function translateTargets(scene, frame, ids) {
+	const moving = /* @__PURE__ */ new Set();
+	for (const root of selectedRoots(scene, ids)) for (const id of subtreeIds(scene, root)) moving.add(id);
+	if (frame.pc.closure === "identity") return [...moving];
+	return [...moving].filter((id) => {
+		const storedIn = frame.frame(id);
+		return storedIn === null || !moving.has(storedIn);
 	});
 }
-function l(n, r, i, a) {
-	let o = [], s = /* @__PURE__ */ new Set();
-	for (let { id: l, dx: u, dy: d } of a) if (u !== 0 || d !== 0) for (let a of c(n, r, [l])) {
-		if (s.has(a)) continue;
-		s.add(a);
-		let c = n.get(a);
-		if (!c) continue;
-		let l = e(i, c);
-		o.push({
-			id: a,
-			to: r.local(a, t(r.world(a), u, d, l))
-		});
+/**
+* Move each of `moves` by its own delta, taking along whatever has to be
+* written for that node to move as a unit ({@link translateTargets}). Every
+* world pose is read before the first write, so one move cannot shift what a
+* later one reads. Call inside a `scene.batch`.
+*/
+function translateEach(scene, frame, descriptor, moves) {
+	const writes = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const { id, dx, dy } of moves) {
+		if (dx === 0 && dy === 0) continue;
+		for (const target of translateTargets(scene, frame, [id])) {
+			if (seen.has(target)) continue;
+			seen.add(target);
+			const node = scene.get(target);
+			if (!node) continue;
+			const d = poseDescriptorForNode(descriptor, node);
+			writes.push({
+				id: target,
+				to: frame.local(target, translatePoseViaDescriptor(frame.world(target), dx, dy, d))
+			});
+		}
 	}
-	for (let { id: e, to: t } of o) n.setPose(e, t);
+	for (const { id, to } of writes) scene.setPose(id, to);
+}
+/** The world translation `(dx, dy)` as a translation of `id`'s stored pose,
+*  which under a turned frame points another way. */
+function storedDelta(frame, descriptor, id, dx, dy) {
+	if (frame.pc.closure === "identity" || frame.frame(id) === null) return {
+		dx,
+		dy
+	};
+	const world = frame.world(id);
+	const from = descriptor.getBounds(frame.local(id, world));
+	const to = descriptor.getBounds(frame.local(id, translatePoseViaDescriptor(world, dx, dy, descriptor)));
+	return {
+		dx: to.x - from.x,
+		dy: to.y - from.y
+	};
 }
-//#endregion
-export { r as hasSelectedAncestor, a as moveSources, i as selectedRoots, o as shapeSources, s as subtreeIds, l as translateEach, c as translateTargets };
 
+//#endregion
+export { hasSelectedAncestor, moveSources, selectedRoots, shapeSources, storedDelta, subtreeIds, translateEach, translateTargets };
 //# sourceMappingURL=selectionSubtree.js.map

package/dist/interactions/actions/selectionSubtree.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectionSubtree.js","names":["hasSelectedAncestor","parent","scene","id","set","selectedRoots","ids","asNodeId","moveSources","out","walked","visit","node","deps","dep","shapeSources","child","subtreeIds","walk","at","translateTargets","moving","root","frame","storedIn","translateEach","writes","seen","moves","dx","dy","target","d","poseDescriptorForNode","descriptor","translatePoseViaDescriptor","to"],"sources":["../../../src/interactions/actions/selectionSubtree.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { PoseFrame } from './poseFrame';\nimport { poseDescriptorForNode, translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\n\ntype AnyScene = Scene<unknown, string, unknown>;\n\n/** True when any ancestor of `id` is also in `set` — acting on that ancestor\n *  already reaches this node, so acting on it again would double it. */\nexport function hasSelectedAncestor(scene: AnyScene, id: NodeId, set: ReadonlySet<string>): boolean {\n  let parent = scene.get(id)?.parent ?? null;\n  while (parent != null) {\n    if (set.has(parent)) return true;\n    parent = scene.get(parent)?.parent ?? null;\n  }\n  return false;\n}\n\n/** The ids in `ids` that are in the scene and have no selected ancestor. */\nexport function selectedRoots(scene: AnyScene, ids: readonly string[]): NodeId[] {\n  const set = new Set<string>(ids);\n  return ids\n    .map((id) => asNodeId(id))\n    .filter((id) => scene.get(id) !== undefined && !hasSelectedAncestor(scene, id, set));\n}\n\n/**\n * The nodes a translation of `ids` has to act on. A node whose pose is derived\n * from an id list cannot be moved itself, since a pose written to it is\n * overwritten on the next read, so the nodes it derives from stand in for it,\n * through however many derived nodes that takes. Each id appears once, in the\n * order it was first reached.\n */\nexport function moveSources(scene: AnyScene, ids: readonly string[]): string[] {\n  const out = new Set<string>();\n  const walked = new Set<string>();\n  const visit = (id: string): void => {\n    if (walked.has(id)) return;\n    walked.add(id);\n    const node = scene.get(asNodeId(id));\n    const deps = node?.derivePose !== undefined && Array.isArray(node.dependsOn) ? node.dependsOn : [];\n    if (deps.length === 0) out.add(id);\n    else for (const dep of deps) visit(dep);\n  };\n  for (const id of ids) visit(id);\n  return [...out];\n}\n\n/**\n * The nodes a resize, rotation, flip, or alignment of `ids` has to write. A\n * container whose pose is derived from its children cannot be written itself,\n * so its children stand in for it, through however many such containers\n * nest. Each id appears once, in the order it was first reached.\n */\nexport function shapeSources(scene: AnyScene, ids: readonly string[]): string[] {\n  const out = new Set<string>();\n  const visit = (id: string): void => {\n    const node = scene.get(asNodeId(id));\n    if (node !== undefined && node.dependsOn === 'children' && node.derivePose !== undefined) {\n      for (const child of scene.childrenOf(asNodeId(id))) visit(child);\n    } else {\n      out.add(id);\n    }\n  };\n  for (const id of ids) visit(id);\n  return [...out];\n}\n\n/** `id` and everything under it, a parent ahead of its children. */\nexport function subtreeIds(scene: AnyScene, id: NodeId): NodeId[] {\n  const out: NodeId[] = [];\n  const walk = (at: NodeId): void => {\n    out.push(at);\n    for (const child of scene.childrenOf(at)) walk(child);\n  };\n  walk(id);\n  return out;\n}\n\n/**\n * The nodes whose stored pose has to change for `ids` to move as a unit: each\n * selected node and its descendants, less any stored in the frame of another\n * node in the set, which that frame carries. With the default absolute poses\n * nothing is carried and every descendant is written.\n */\nexport function translateTargets(\n  scene: AnyScene,\n  frame: PoseFrame<unknown>,\n  ids: readonly string[],\n): NodeId[] {\n  const moving = new Set<NodeId>();\n  for (const root of selectedRoots(scene, ids)) {\n    for (const id of subtreeIds(scene, root)) moving.add(id);\n  }\n  if (frame.pc.closure === 'identity') return [...moving];\n  return [...moving].filter((id) => {\n    const storedIn = frame.frame(id);\n    return storedIn === null || !moving.has(storedIn);\n  });\n}\n\n/**\n * Move each of `moves` by its own delta, taking along whatever has to be\n * written for that node to move as a unit ({@link translateTargets}). Every\n * world pose is read before the first write, so one move cannot shift what a\n * later one reads. Call inside a `scene.batch`.\n */\nexport function translateEach(\n  scene: AnyScene,\n  frame: PoseFrame<unknown>,\n  descriptor: PoseDescriptor<unknown>,\n  moves: readonly { id: string; dx: number; dy: number }[],\n): void {\n  const writes: { id: NodeId; to: unknown }[] = [];\n  const seen = new Set<NodeId>();\n  for (const { id, dx, dy } of moves) {\n    if (dx === 0 && dy === 0) continue;\n    for (const target of translateTargets(scene, frame, [id])) {\n      if (seen.has(target)) continue;\n      seen.add(target);\n      const node = scene.get(target);\n      if (!node) continue;\n      const d = poseDescriptorForNode(descriptor, node);\n      writes.push({ id: target, to: frame.local(target, translatePoseViaDescriptor(frame.world(target), dx, dy, d)) });\n    }\n  }\n  for (const { id, to } of writes) scene.setPose(id, to);\n}\n"],"mappings":"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"}
+{"version":3,"file":"selectionSubtree.js","names":[],"sources":["../../../src/interactions/actions/selectionSubtree.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { PoseFrame } from './poseFrame';\nimport { poseDescriptorForNode, translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\n\ntype AnyScene = Scene<unknown, string, unknown>;\n\n/** True when any ancestor of `id` is also in `set` — acting on that ancestor\n *  already reaches this node, so acting on it again would double it. */\nexport function hasSelectedAncestor(scene: AnyScene, id: NodeId, set: ReadonlySet<string>): boolean {\n  let parent = scene.get(id)?.parent ?? null;\n  while (parent != null) {\n    if (set.has(parent)) return true;\n    parent = scene.get(parent)?.parent ?? null;\n  }\n  return false;\n}\n\n/** The ids in `ids` that are in the scene and have no selected ancestor. */\nexport function selectedRoots(scene: AnyScene, ids: readonly string[]): NodeId[] {\n  const set = new Set<string>(ids);\n  return ids\n    .map((id) => asNodeId(id))\n    .filter((id) => scene.get(id) !== undefined && !hasSelectedAncestor(scene, id, set));\n}\n\n/** Whether `id` draws a path derived from other nodes. Its pose is a\n *  placeholder: the path follows the nodes it derives from. */\nfunction derivesPathOnly(scene: AnyScene, id: string): boolean {\n  const node = scene.get(asNodeId(id));\n  return node?.derivePath !== undefined && node.derivePose === undefined\n    && Array.isArray(node.dependsOn) && node.dependsOn.length > 0;\n}\n\n/**\n * The nodes a translation of `ids` has to act on. A node whose pose is derived\n * from an id list cannot be moved itself, since a pose written to it is\n * overwritten on the next read, so the nodes it derives from stand in for it,\n * through however many derived nodes that takes. A node reached that way which\n * derives only its path — a wire under a label — follows its own dependencies\n * and is not written. Each id appears once, in the order it was first reached.\n */\nexport function moveSources(scene: AnyScene, ids: readonly string[]): string[] {\n  const out = new Set<string>();\n  const walked = new Set<string>();\n  const visit = (id: string, reached: boolean): void => {\n    if (walked.has(id)) return;\n    walked.add(id);\n    if (reached && derivesPathOnly(scene, id)) return;\n    const node = scene.get(asNodeId(id));\n    const deps = node?.derivePose !== undefined && Array.isArray(node.dependsOn) ? node.dependsOn : [];\n    if (deps.length === 0) out.add(id);\n    else for (const dep of deps) visit(dep, true);\n  };\n  for (const id of ids) visit(id, false);\n  return [...out];\n}\n\n/**\n * The nodes a resize, rotation, flip, or alignment of `ids` has to write. A\n * node whose pose is derived cannot be written itself, so what it derives\n * from stands in for it — a container's children, or the ids a node names —\n * through however many derived nodes that takes, leaving out one reached that\n * way which derives only its path, as {@link moveSources} does. Each id appears once, in the order it\n * was first reached.\n */\nexport function shapeSources(scene: AnyScene, ids: readonly string[]): string[] {\n  const out = new Set<string>();\n  const walked = new Set<string>();\n  const visit = (id: string, reached: boolean): void => {\n    if (walked.has(id)) return;\n    walked.add(id);\n    if (reached && derivesPathOnly(scene, id)) return;\n    const node = scene.get(asNodeId(id));\n    const deps = node?.derivePose === undefined\n      ? []\n      : node.dependsOn === 'children' ? scene.childrenOf(asNodeId(id)) : node.dependsOn ?? [];\n    if (deps.length === 0 && node?.dependsOn !== 'children') out.add(id);\n    else for (const dep of deps) visit(dep, true);\n  };\n  for (const id of ids) visit(id, false);\n  return [...out];\n}\n\n/** `id` and everything under it, a parent ahead of its children. */\nexport function subtreeIds(scene: AnyScene, id: NodeId): NodeId[] {\n  const out: NodeId[] = [];\n  const walk = (at: NodeId): void => {\n    out.push(at);\n    for (const child of scene.childrenOf(at)) walk(child);\n  };\n  walk(id);\n  return out;\n}\n\n/**\n * The nodes whose stored pose has to change for `ids` to move as a unit: each\n * selected node and its descendants, less any stored in the frame of another\n * node in the set, which that frame carries. With the default absolute poses\n * nothing is carried and every descendant is written.\n */\nexport function translateTargets(\n  scene: AnyScene,\n  frame: PoseFrame<unknown>,\n  ids: readonly string[],\n): NodeId[] {\n  const moving = new Set<NodeId>();\n  for (const root of selectedRoots(scene, ids)) {\n    for (const id of subtreeIds(scene, root)) moving.add(id);\n  }\n  if (frame.pc.closure === 'identity') return [...moving];\n  return [...moving].filter((id) => {\n    const storedIn = frame.frame(id);\n    return storedIn === null || !moving.has(storedIn);\n  });\n}\n\n/**\n * Move each of `moves` by its own delta, taking along whatever has to be\n * written for that node to move as a unit ({@link translateTargets}). Every\n * world pose is read before the first write, so one move cannot shift what a\n * later one reads. Call inside a `scene.batch`.\n */\nexport function translateEach(\n  scene: AnyScene,\n  frame: PoseFrame<unknown>,\n  descriptor: PoseDescriptor<unknown>,\n  moves: readonly { id: string; dx: number; dy: number }[],\n): void {\n  const writes: { id: NodeId; to: unknown }[] = [];\n  const seen = new Set<NodeId>();\n  for (const { id, dx, dy } of moves) {\n    if (dx === 0 && dy === 0) continue;\n    for (const target of translateTargets(scene, frame, [id])) {\n      if (seen.has(target)) continue;\n      seen.add(target);\n      const node = scene.get(target);\n      if (!node) continue;\n      const d = poseDescriptorForNode(descriptor, node);\n      writes.push({ id: target, to: frame.local(target, translatePoseViaDescriptor(frame.world(target), dx, dy, d)) });\n    }\n  }\n  for (const { id, to } of writes) scene.setPose(id, to);\n}\n\n/** The world translation `(dx, dy)` as a translation of `id`'s stored pose,\n *  which under a turned frame points another way. */\nexport function storedDelta(\n  frame: PoseFrame<unknown>,\n  descriptor: PoseDescriptor<unknown>,\n  id: NodeId,\n  dx: number,\n  dy: number,\n): { dx: number; dy: number } {\n  if (frame.pc.closure === 'identity' || frame.frame(id) === null) return { dx, dy };\n  const world = frame.world(id);\n  const from = descriptor.getBounds(frame.local(id, world));\n  const to = descriptor.getBounds(frame.local(id, translatePoseViaDescriptor(world, dx, dy, descriptor)));\n  return { dx: to.x - from.x, dy: to.y - from.y };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/spatialReference.js

@@ -1,42 +1,49 @@
-import { visualBoundsViaDescriptor as e } from "../../core/geometry/poseDescriptor.js";
 //#region src/interactions/actions/spatialReference.ts
-function t(e, t) {
-	if (e === "pointer") {
-		let e = t.pointer();
-		return e ? {
-			x: e.x,
-			y: e.y,
+/**
+* The world bounds `ref` names — a point comes back as a zero-size rect — or
+* `null` when it names nothing right now (no pointer, a missing node, a
+* malformed value).
+*/
+function resolveSpatialReference(ref, src) {
+	if (ref === "pointer") {
+		const p = src.pointer();
+		return p ? {
+			x: p.x,
+			y: p.y,
 			width: 0,
 			height: 0
 		} : null;
 	}
-	if (typeof e != "object" || !e) return null;
-	if ("node" in e) return t.nodeBounds(e.node);
-	let n = e;
-	return typeof n.x != "number" || typeof n.y != "number" ? null : {
-		x: n.x,
-		y: n.y,
-		width: typeof n.width == "number" ? n.width : 0,
-		height: typeof n.height == "number" ? n.height : 0
+	if (typeof ref !== "object" || ref === null) return null;
+	if ("node" in ref) return src.nodeBounds(ref.node);
+	const r = ref;
+	if (typeof r.x !== "number" || typeof r.y !== "number") return null;
+	return {
+		x: r.x,
+		y: r.y,
+		width: typeof r.width === "number" ? r.width : 0,
+		height: typeof r.height === "number" ? r.height : 0
 	};
 }
-function n(t, n, r, i, a) {
+/** The sources an immediate action resolves a reference from. A click's
+*  `worldX`/`worldY` params outrank the `pointer` dep. */
+function actionReferenceSources(params, pointer, scene, frame, boxes) {
 	return {
 		pointer: () => {
-			if (typeof t?.worldX == "number" && typeof t.worldY == "number") return {
-				x: t.worldX,
-				y: t.worldY
+			if (typeof params?.worldX === "number" && typeof params.worldY === "number") return {
+				x: params.worldX,
+				y: params.worldY
 			};
-			let e = n?.get();
-			return e ? {
-				x: e.worldX,
-				y: e.worldY
+			const p = pointer?.get();
+			return p ? {
+				x: p.worldX,
+				y: p.worldY
 			} : null;
 		},
-		nodeBounds: (t) => r.get(t) === void 0 ? null : e(i.world(t), a)
+		nodeBounds: (id) => scene.get(id) === void 0 ? null : boxes.aabb(id, frame.world(id))
 	};
 }
-//#endregion
-export { n as actionReferenceSources, t as resolveSpatialReference };
 
+//#endregion
+export { actionReferenceSources, resolveSpatialReference };
 //# sourceMappingURL=spatialReference.js.map