@weasel-js/core 1.9.3 → 1.10.0

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

@@ -0,0 +1,74 @@
+import { remapRotatedLeaf as e, translatePoseViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
+import { localToWorld as n, worldDeltaToLocal as r } from "../../../core/geometry/targetFrame.js";
+import { fixedCornerOf as i } from "./cornerHandles.js";
+import { carryPose as a, planeOf as o } from "../planeInput.js";
+import { pointerStateOf as s } from "../pointerState.js";
+import { boxFrame as c } from "./boxFrame.js";
+import { boundsForRules as l } from "./ruleBounds.js";
+import { snapPose as u } from "./pointSnap.js";
+import { poseRotationOf as d } from "@weasel-js/geom";
+//#region src/interactions/actions/resize/frame.ts
+function f(e, t, n, i, a) {
+	let { x: o, y: s } = r(a, n, i) ?? {
+		x: 0,
+		y: 0
+	}, c = e.x, l = e.y, u = e.width, d = e.height;
+	return t.x === "min" ? u = e.width + o : t.x === "max" && (c = e.x + o, u = e.width - o), t.y === "min" ? d = e.height + s : t.y === "max" && (l = e.y + s, d = e.height - s), {
+		x: c,
+		y: l,
+		width: u,
+		height: d
+	};
+}
+function p(e, t, n, r) {
+	let i = r;
+	for (let r of e) {
+		let e = r.onMove?.(t, {
+			pose: i,
+			anchor: n
+		});
+		e && e.pose !== void 0 && (i = {
+			x: e.pose.x,
+			y: e.pose.y,
+			width: e.pose.width,
+			height: e.pose.height
+		});
+	}
+	return i;
+}
+function m(t, n, r, i, a) {
+	return a && d(n) !== null ? e(n, r, i) : t.remapBounds(n, r, i);
+}
+function h(e, r, a, o) {
+	let s = c(a, o);
+	if (s.identity) return r;
+	let l = i(o, a.anchor), u = n(s, l.x, l.y);
+	return t(r, a.fixedWorld.x - u.x, a.fixedWorld.y - u.y, e);
+}
+function g(e, t, n) {
+	let r = e.scene.get(t)?.layer;
+	return e.poseFrame.local(t, a(e.geometryOf(t), n, r === void 0 ? null : o(e.view, r)));
+}
+function _(e, t, n) {
+	let r = n.drag.current, { box: i, gestureCtx: a } = e;
+	a.modifiers = { ...n.modifiers }, a.pointer = s(r, n), a.view = t.view(), a.plane = t.plane();
+	let o = p(e.constraints, a, i.anchor, f(i.bounds, i.anchor, r.x - e.startWorld.x, r.y - e.startWorld.y, c(i, i.bounds))), d = /* @__PURE__ */ new Map(), _ = (t) => {
+		let n = e.startWorlds.get(t);
+		if (n !== void 0) return m(e.geometryOf(t), n, i.bounds, o, e.sharedBox);
+	};
+	if (e.sharedBox) {
+		for (let t of e.writeIds) {
+			let n = _(t);
+			n !== void 0 && d.set(t, g(e, t, n));
+		}
+		return { previews: d };
+	}
+	let v = e.writeIds[0], y = e.geometryOf(v), b = _(v);
+	if (b === void 0) return { previews: d };
+	let x = u(e.pointSnap, y, h(y, b, i, o), i, i.anchor, a.modifiers, a.plane ?? null);
+	return d.set(v, g(e, v, x)), a.current = /* @__PURE__ */ new Map([[v, l(y, x)]]), { previews: d };
+}
+//#endregion
+export { _ as nextFrame };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","names":["computeProposedBounds","dx","dy","worldDeltaToLocal","frame","worldDx","worldDy","nx","ob","ny","nw","nh","anchor","constrain","bounds","proposed","b","constraints","r","gctx","leafPose","sharedBox","poseRotationOf","start","remapRotatedLeaf","src","dst","g","pinFixedCorner","boxFrame","box","pose","newFixedLocal","fixedCornerOf","newFixedWorld","localToWorld","translatePoseViaDescriptor","storedPose","layer","place","id","carryPose","world","planeOf","nextFrame","at","moveCtx","session","pointerStateOf","readers","previews","worldOf","next","remapped","snapPose","boundsForRules"],"sources":["../../../../src/interactions/actions/resize/frame.ts"],"sourcesContent":["import { poseRotationOf } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { localToWorld, worldDeltaToLocal, type TargetTransform } from 'core/geometry/targetFrame';\nimport type { NodeId } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, ResizeAnchor, RotatedPose } from '../../gestures/types';\nimport { carryPose, planeOf } from '../planeInput';\nimport { fixedCornerOf } from './cornerHandles';\nimport { remapRotatedLeaf, translatePoseViaDescriptor, type PoseDescriptor } from './geometry';\nimport { snapPose } from './pointSnap';\nimport { boundsForRules } from './ruleBounds';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox, ResizeFrame, ResizeSession } from './session';\n\n/** `ob` with the edges `anchor` leaves free moved by the drag delta, which is\n *  taken into the axes of the frame the box is drawn in first. A frame nothing\n *  maps back through moves no edge. */\nfunction computeProposedBounds(\n  ob: Bounds,\n  anchor: ResizeAnchor,\n  worldDx: number,\n  worldDy: number,\n  frame: TargetTransform,\n): Bounds {\n  const { x: dx, y: dy } = worldDeltaToLocal(frame, worldDx, worldDy) ?? { x: 0, y: 0 };\n  let nx = ob.x;\n  let ny = ob.y;\n  let nw = ob.width;\n  let nh = ob.height;\n  if (anchor.x === 'min') {\n    nw = ob.width + dx;\n  } else if (anchor.x === 'max') {\n    nx = ob.x + dx;\n    nw = ob.width - dx;\n  }\n  if (anchor.y === 'min') {\n    nh = ob.height + dy;\n  } else if (anchor.y === 'max') {\n    ny = ob.y + dy;\n    nh = ob.height - dy;\n  }\n  return { x: nx, y: ny, width: nw, height: nh };\n}\n\n/** `proposed` as the constraints rewrite it, each seeing the one before's. */\nfunction constrain(\n  constraints: readonly BoundsConstraint<Bounds>[],\n  gctx: GestureContext<Bounds>,\n  anchor: ResizeAnchor,\n  proposed: Bounds,\n): Bounds {\n  let bounds = proposed;\n  for (const b of constraints) {\n    const r = b.onMove?.(gctx, { pose: bounds, anchor });\n    if (!r) continue;\n    if (r.pose !== undefined) {\n      bounds = { x: r.pose.x, y: r.pose.y, width: r.pose.width, height: r.pose.height };\n    }\n  }\n  return bounds;\n}\n\n/** One write id's world pose with the box taken from `src` to `dst`.\n *\n *  A rotated leaf resized with others needs its own frame: `src`/`dst`\n *  are world-frame there, unlike the lone path where the drag delta\n *  was already projected into the leaf's frame, so the naive affine\n *  scales the wrong pair of extents. See `remapRotatedLeaf`. */\nfunction leafPose(\n  g: PoseDescriptor<unknown>,\n  start: unknown,\n  src: Bounds,\n  dst: Bounds,\n  sharedBox: boolean,\n): unknown {\n  if (sharedBox && poseRotationOf(start) !== null) {\n    return remapRotatedLeaf(start as RotatedPose, src, dst);\n  }\n  return g.remapBounds(start, src, dst);\n}\n\n/** `pose` shifted so the corner opposite the dragged one stays where the\n *  press found it, which resizing a box whose frame is about its center moves. */\nfunction pinFixedCorner(\n  g: PoseDescriptor<unknown>,\n  pose: unknown,\n  box: Pick<ResizeBox, 'anchor' | 'rotation' | 'transform' | 'fixedWorld'>,\n  proposed: Bounds,\n): unknown {\n  const frame = boxFrame(box, proposed);\n  if (frame.identity) return pose;\n  const newFixedLocal = fixedCornerOf(proposed, box.anchor);\n  const newFixedWorld = localToWorld(frame, newFixedLocal.x, newFixedLocal.y);\n  return translatePoseViaDescriptor(\n    pose,\n    box.fixedWorld.x - newFixedWorld.x,\n    box.fixedWorld.y - newFixedWorld.y,\n    g,\n  );\n}\n\n/** A world result for `id`, as stored. */\nfunction storedPose(\n  place: Pick<ResizeSession, 'scene' | 'poseFrame' | 'view' | 'geometryOf'>,\n  id: NodeId,\n  world: unknown,\n): unknown {\n  const layer = place.scene.get(id)?.layer;\n  return place.poseFrame.local(\n    id,\n    carryPose(place.geometryOf(id), world, layer === undefined ? null : planeOf(place.view, layer)),\n  );\n}\n\n/** One move's previews: the box as the drag and the constraints leave it,\n *  and every write id's stored pose inside it. A lone target also gets the\n *  rotated-resize pin and the point snaps, which a shared box, resized in the\n *  AABB frame, does not. `moveCtx` must carry a drag. */\nexport function nextFrame(session: ResizeSession, readers: GestureReaders, moveCtx: InvocationCtx): ResizeFrame {\n  const at = moveCtx.drag!.current;\n  const { box, gestureCtx: gctx } = session;\n  gctx.modifiers = { ...moveCtx.modifiers };\n  gctx.pointer = pointerStateOf(at, moveCtx);\n  gctx.view = readers.view();\n  gctx.plane = readers.plane();\n\n  const proposed = constrain(\n    session.constraints,\n    gctx,\n    box.anchor,\n    computeProposedBounds(box.bounds, box.anchor, at.x - session.startWorld.x, at.y - session.startWorld.y, boxFrame(box, box.bounds)),\n  );\n\n  const previews = new Map<NodeId, unknown>();\n  const worldOf = (id: NodeId): unknown => {\n    const start = session.startWorlds.get(id);\n    if (start === undefined) return undefined;\n    return leafPose(session.geometryOf(id), start, box.bounds, proposed, session.sharedBox);\n  };\n\n  if (session.sharedBox) {\n    for (const id of session.writeIds) {\n      const next = worldOf(id);\n      if (next === undefined) continue;\n      previews.set(id, storedPose(session, id, next));\n    }\n    return { previews };\n  }\n\n  const id = session.writeIds[0];\n  const g = session.geometryOf(id);\n  const remapped = worldOf(id);\n  if (remapped === undefined) return { previews };\n  const world = snapPose(\n    session.pointSnap,\n    g,\n    pinFixedCorner(g, remapped, box, proposed),\n    box,\n    box.anchor,\n    gctx.modifiers,\n    gctx.plane ?? null,\n  );\n  previews.set(id, storedPose(session, id, world));\n  gctx.current = new Map<string, Bounds>([[id as string, boundsForRules(g, world)]]);\n  return { previews };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/resize/pointSnap.js

@@ -0,0 +1,111 @@
+import { fromPlane as e, toPlane as t } from "../../../core/viewport/parallax.js";
+import { isRectPose as n } from "../../../core/geometry/autoPoseDescriptor.js";
+import { targetCorners as r, worldDeltaToLocal as i } from "../../../core/geometry/targetFrame.js";
+import { boxFrame as a } from "./boxFrame.js";
+import { boundsForRules as o } from "./ruleBounds.js";
+//#region src/interactions/actions/resize/pointSnap.ts
+function s(e, t, n, i, a) {
+	let o = e.x + e.width / 2, s = e.y + e.height / 2, [c, l, u, d] = r(e, t), f = null, p = null;
+	if (i.x !== "free" && i.y !== "free") {
+		let e = i.x === "min" && i.y === "min" ? c : i.x === "max" && i.y === "min" ? l : i.x === "max" && i.y === "max" ? u : d, t = i.x === "min" && i.y === "min" ? u : i.x === "max" && i.y === "min" ? d : i.x === "max" && i.y === "max" ? c : l;
+		p = {
+			worldX: e.x,
+			worldY: e.y
+		}, f = {
+			worldX: t.x,
+			worldY: t.y
+		};
+	}
+	return {
+		draggedCorner: f,
+		fixedCorner: p,
+		center: {
+			worldX: o,
+			worldY: s
+		},
+		origin: {
+			worldX: c.x,
+			worldY: c.y
+		},
+		rotation: n,
+		anchor: i,
+		proposed: e,
+		modifiers: a
+	};
+}
+function c(e, t, n, r) {
+	if (n.frame === "center") {
+		let t = n.worldX - r.center.worldX, i = n.worldY - r.center.worldY;
+		return {
+			...e,
+			x: e.x + t,
+			y: e.y + i
+		};
+	}
+	if (n.frame === "origin") {
+		let t = n.worldX - r.origin.worldX, i = n.worldY - r.origin.worldY;
+		return {
+			...e,
+			x: e.x + t,
+			y: e.y + i
+		};
+	}
+	let a = n.frame === "dragged-corner" ? r.fixedCorner : r.draggedCorner;
+	if (!a) return e;
+	let o = i(t, n.worldX - a.worldX, n.worldY - a.worldY);
+	if (!o) return e;
+	let s = Math.abs(o.x), c = Math.abs(o.y), l = (a.worldX + n.worldX) / 2, u = (a.worldY + n.worldY) / 2;
+	return {
+		...e,
+		x: l - s / 2,
+		y: u - c / 2,
+		width: s,
+		height: c
+	};
+}
+function l(t, n) {
+	let r = (t) => {
+		let r = e(n, {
+			x: t.worldX,
+			y: t.worldY
+		});
+		return {
+			worldX: r.x,
+			worldY: r.y
+		};
+	};
+	return {
+		...t,
+		draggedCorner: t.draggedCorner && r(t.draggedCorner),
+		fixedCorner: t.fixedCorner && r(t.fixedCorner),
+		center: r(t.center),
+		origin: r(t.origin)
+	};
+}
+function u(e, n) {
+	if (!e) return e;
+	let r = t(n, {
+		x: e.worldX,
+		y: e.worldY
+	});
+	return {
+		...e,
+		worldX: r.x,
+		worldY: r.y
+	};
+}
+function d(e, t, r, i, d, f, p) {
+	if (e.length === 0) return r;
+	let m = o(t, r), h = a(i, m), g = s(m, h, i.rotation, d, f);
+	for (let i of e) {
+		let e = p ? u(i.onMove(l(g, p)), p) : i.onMove(g);
+		if (!e) continue;
+		let a = c(m, h, e, g);
+		return n(r) ? a : t.remapBounds(r, m, a);
+	}
+	return r;
+}
+//#endregion
+export { d as snapPose };
+
+//# sourceMappingURL=pointSnap.js.map

package/dist/interactions/actions/resize/pointSnap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointSnap.js","names":["buildPointSnapContext","cx","pose","cy","tl","tr","br","bl","targetCorners","frame","draggedCorner","fixedCorner","anchor","fixedPt","draggedPt","applyPointSnap","result","dx","ctx","dy","pin","diagonal","worldDeltaToLocal","newWidth","newHeight","newCx","newCy","pointSnapToCamera","cam","w","fromPlane","m","p","pointSnapFromPlane","r","toPlane","snapPose","rules","poseAsRect","boundsForRules","g","boxFrame","box","psCtx","modifiers","rule","plane","snapped","isRectPose"],"sources":["../../../../src/interactions/actions/resize/pointSnap.ts"],"sourcesContent":["import { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { fromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type {\n  ModifierState,\n  PointSnapBehavior,\n  PointSnapContext,\n  PointSnapResult,\n  ResizeAnchor,\n} from '../../gestures/types';\nimport { targetCorners, worldDeltaToLocal, type TargetTransform } from 'core/geometry/targetFrame';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox } from './session';\nimport type { PoseDescriptor } from './geometry';\nimport { boundsForRules } from './ruleBounds';\n\nfunction buildPointSnapContext<TPose extends Bounds>(\n  pose: TPose,\n  frame: TargetTransform,\n  rotation: number,\n  anchor: ResizeAnchor,\n  modifiers: ModifierState,\n): PointSnapContext<TPose> {\n  const cx = pose.x + pose.width / 2;\n  const cy = pose.y + pose.height / 2;\n  const [tl, tr, br, bl] = targetCorners(pose, frame);\n\n  let draggedCorner: { worldX: number; worldY: number } | null = null;\n  let fixedCorner: { worldX: number; worldY: number } | null = null;\n\n  if (anchor.x !== 'free' && anchor.y !== 'free') {\n    const fixedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? tl :\n      anchor.x === 'max' && anchor.y === 'min' ? tr :\n      anchor.x === 'max' && anchor.y === 'max' ? br : bl;\n    const draggedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? br :\n      anchor.x === 'max' && anchor.y === 'min' ? bl :\n      anchor.x === 'max' && anchor.y === 'max' ? tl : tr;\n    fixedCorner = { worldX: fixedPt.x, worldY: fixedPt.y };\n    draggedCorner = { worldX: draggedPt.x, worldY: draggedPt.y };\n  }\n\n  return {\n    draggedCorner,\n    fixedCorner,\n    center: { worldX: cx, worldY: cy },\n    origin: { worldX: tl.x, worldY: tl.y },\n    rotation,\n    anchor,\n    proposed: pose,\n    modifiers,\n  };\n}\n\nfunction applyPointSnap<TPose extends Bounds>(\n  pose: TPose,\n  frame: TargetTransform,\n  result: PointSnapResult,\n  ctx: PointSnapContext<TPose>,\n): TPose {\n  if (result.frame === 'center') {\n    const dx = result.worldX - ctx.center.worldX;\n    const dy = result.worldY - ctx.center.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  if (result.frame === 'origin') {\n    const dx = result.worldX - ctx.origin.worldX;\n    const dy = result.worldY - ctx.origin.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  const pin = result.frame === 'dragged-corner' ? ctx.fixedCorner : ctx.draggedCorner;\n  if (!pin) return pose;\n  // The diagonal from the pinned corner, in the box's own axes.\n  const diagonal = worldDeltaToLocal(frame, result.worldX - pin.worldX, result.worldY - pin.worldY);\n  if (!diagonal) return pose;\n  const newWidth = Math.abs(diagonal.x);\n  const newHeight = Math.abs(diagonal.y);\n  const newCx = (pin.worldX + result.worldX) / 2;\n  const newCy = (pin.worldY + result.worldY) / 2;\n  return { ...pose, x: newCx - newWidth / 2, y: newCy - newHeight / 2, width: newWidth, height: newHeight };\n}\n\n/** `ctx`'s points in the camera's world, for a snap rule written against it. */\nfunction pointSnapToCamera<TPose extends Bounds>(\n  ctx: PointSnapContext<TPose>,\n  m: PlaneMap,\n): PointSnapContext<TPose> {\n  const cam = (p: { worldX: number; worldY: number }) => {\n    const w = fromPlane(m, { x: p.worldX, y: p.worldY });\n    return { worldX: w.x, worldY: w.y };\n  };\n  return {\n    ...ctx,\n    draggedCorner: ctx.draggedCorner && cam(ctx.draggedCorner),\n    fixedCorner: ctx.fixedCorner && cam(ctx.fixedCorner),\n    center: cam(ctx.center),\n    origin: cam(ctx.origin),\n  };\n}\n\n/** A snap rule's answer, back in the plane the resize works in. */\nfunction pointSnapFromPlane(\n  r: PointSnapResult | null | undefined,\n  m: PlaneMap,\n): PointSnapResult | null | undefined {\n  if (!r) return r;\n  const p = toPlane(m, { x: r.worldX, y: r.worldY });\n  return { ...r, worldX: p.x, worldY: p.y };\n}\n\n/** `pose` moved so the frame the first answering rule chose lands on its\n *  target; `pose` itself when no rule answers. `plane` is the plane the\n *  resize works in, null in the camera's own world. */\nexport function snapPose(\n  rules: readonly PointSnapBehavior<Bounds>[],\n  g: PoseDescriptor<unknown>,\n  pose: unknown,\n  box: Pick<ResizeBox, 'rotation' | 'transform'>,\n  anchor: ResizeAnchor,\n  modifiers: ModifierState,\n  plane: PlaneMap | null,\n): unknown {\n  if (rules.length === 0) return pose;\n  const poseAsRect = boundsForRules(g, pose);\n  const frame = boxFrame(box, poseAsRect);\n  const psCtx = buildPointSnapContext(poseAsRect, frame, box.rotation, anchor, modifiers);\n  // Point snaps are the surface's rules over the camera's world, so\n  // on a plane their points cross at this boundary.\n  for (const rule of rules) {\n    const result = plane\n      ? pointSnapFromPlane(rule.onMove(pointSnapToCamera(psCtx, plane)), plane)\n      : rule.onMove(psCtx);\n    if (!result) continue;\n    const snapped = applyPointSnap(poseAsRect, frame, result, psCtx);\n    return isRectPose(pose) ? snapped : g.remapBounds(pose, poseAsRect, snapped);\n  }\n  return pose;\n}\n"],"mappings":";;;;;;AAgBA,SAASA,EACP,GACA,GACA,GACA,GACA,GACyB;CACzB,IAAMC,IAAKC,EAAK,IAAIA,EAAK,QAAQ,GAC3BC,IAAKD,EAAK,IAAIA,EAAK,SAAS,GAC5B,CAACE,GAAIC,GAAIC,GAAIC,KAAMC,EAAcN,GAAMO,CAAK,GAE9CC,IAA2D,MAC3DC,IAAyD;CAE7D,IAAIC,EAAO,MAAM,UAAUA,EAAO,MAAM,QAAQ;EAC9C,IAAMC,IACJD,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQR,IAC3CQ,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQP,IAC3CO,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQN,IAAKC,GAC5CO,IACJF,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQN,IAC3CM,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQL,IAC3CK,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQR,IAAKC;EAElD,AADA,IAAc;GAAE,QAAQQ,EAAQ;GAAG,QAAQA,EAAQ;EAAE,GACrD,IAAgB;GAAE,QAAQC,EAAU;GAAG,QAAQA,EAAU;EAAE;CAC7D;CAEA,OAAO;EACL;EACA;EACA,QAAQ;GAAE,QAAQb;GAAI,QAAQE;EAAG;EACjC,QAAQ;GAAE,QAAQC,EAAG;GAAG,QAAQA,EAAG;EAAE;EACrC;EACA;EACA,UAAUF;EACV;CACF;AACF;AAEA,SAASa,EACP,GACA,GACA,GACA,GACO;CACP,IAAIC,EAAO,UAAU,UAAU;EAC7B,IAAMC,IAAKD,EAAO,SAASE,EAAI,OAAO,QAChCC,IAAKH,EAAO,SAASE,EAAI,OAAO;EACtC,OAAO;GAAE,GAAGhB;GAAM,GAAGA,EAAK,IAAIe;GAAI,GAAGf,EAAK,IAAIiB;EAAG;CACnD;CACA,IAAIH,EAAO,UAAU,UAAU;EAC7B,IAAMC,IAAKD,EAAO,SAASE,EAAI,OAAO,QAChCC,IAAKH,EAAO,SAASE,EAAI,OAAO;EACtC,OAAO;GAAE,GAAGhB;GAAM,GAAGA,EAAK,IAAIe;GAAI,GAAGf,EAAK,IAAIiB;EAAG;CACnD;CACA,IAAMC,IAAMJ,EAAO,UAAU,mBAAmBE,EAAI,cAAcA,EAAI;CACtE,IAAI,CAACE,GAAK,OAAOlB;CAEjB,IAAMmB,IAAWC,EAAkBb,GAAOO,EAAO,SAASI,EAAI,QAAQJ,EAAO,SAASI,EAAI,MAAM;CAChG,IAAI,CAACC,GAAU,OAAOnB;CACtB,IAAMqB,IAAW,KAAK,IAAIF,EAAS,CAAC,GAC9BG,IAAY,KAAK,IAAIH,EAAS,CAAC,GAC/BI,KAASL,EAAI,SAASJ,EAAO,UAAU,GACvCU,KAASN,EAAI,SAASJ,EAAO,UAAU;CAC7C,OAAO;EAAE,GAAGd;EAAM,GAAGuB,IAAQF,IAAW;EAAG,GAAGG,IAAQF,IAAY;EAAG,OAAOD;EAAU,QAAQC;CAAU;AAC1G;AAGA,SAASG,EACP,GACA,GACyB;CACzB,IAAMC,KAAO,MAA0C;EACrD,IAAMC,IAAIC,EAAUC,GAAG;GAAE,GAAGC,EAAE;GAAQ,GAAGA,EAAE;EAAO,CAAC;EACnD,OAAO;GAAE,QAAQH,EAAE;GAAG,QAAQA,EAAE;EAAE;CACpC;CACA,OAAO;EACL,GAAGX;EACH,eAAeA,EAAI,iBAAiBU,EAAIV,EAAI,aAAa;EACzD,aAAaA,EAAI,eAAeU,EAAIV,EAAI,WAAW;EACnD,QAAQU,EAAIV,EAAI,MAAM;EACtB,QAAQU,EAAIV,EAAI,MAAM;CACxB;AACF;AAGA,SAASe,EACP,GACA,GACoC;CACpC,IAAI,CAACC,GAAG,OAAOA;CACf,IAAMF,IAAIG,EAAQJ,GAAG;EAAE,GAAGG,EAAE;EAAQ,GAAGA,EAAE;CAAO,CAAC;CACjD,OAAO;EAAE,GAAGA;EAAG,QAAQF,EAAE;EAAG,QAAQA,EAAE;CAAE;AAC1C;AAKA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAIC,EAAM,WAAW,GAAG,OAAOnC;CAC/B,IAAMoC,IAAaC,EAAeC,GAAGtC,CAAI,GACnCO,IAAQgC,EAASC,GAAKJ,CAAU,GAChCK,IAAQ3C,EAAsBsC,GAAY7B,GAAOiC,EAAI,UAAU9B,GAAQgC,CAAS;CAGtF,KAAK,IAAMC,KAAQR,GAAO;EACxB,IAAMrB,IAAS8B,IACXb,EAAmBY,EAAK,OAAOlB,EAAkBgB,GAAOG,CAAK,CAAC,GAAGA,CAAK,IACtED,EAAK,OAAOF,CAAK;EACrB,IAAI,CAAC3B,GAAQ;EACb,IAAM+B,IAAUhC,EAAeuB,GAAY7B,GAAOO,GAAQ2B,CAAK;EAC/D,OAAOK,EAAW9C,CAAI,IAAI6C,IAAUP,EAAE,YAAYtC,GAAMoC,GAAYS,CAAO;CAC7E;CACA,OAAO7C;AACT"}

package/dist/interactions/actions/resize/ruleBounds.js

@@ -0,0 +1,9 @@
+import { isRectPose as e } from "../../../core/geometry/autoPoseDescriptor.js";
+//#region src/interactions/actions/resize/ruleBounds.ts
+function t(t, n) {
+	return e(n) ? n : t.getBounds(n);
+}
+//#endregion
+export { t as boundsForRules };
+
+//# sourceMappingURL=ruleBounds.js.map

package/dist/interactions/actions/resize/ruleBounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruleBounds.js","names":["boundsForRules","isRectPose","pose","geometry"],"sources":["../../../../src/interactions/actions/resize/ruleBounds.ts"],"sourcesContent":["import { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PoseDescriptor } from './geometry';\n\n/** `pose` as the bounds a constraint or a point snap reads. A pose that is\n *  already a box goes through whole, so a `rotation` on it rides along. */\nexport function boundsForRules(geometry: PoseDescriptor<unknown>, pose: unknown): Bounds {\n  return isRectPose(pose) ? pose : geometry.getBounds(pose);\n}\n"],"mappings":";;AAMA,SAAgBA,EAAe,GAAmC,GAAuB;CACvF,OAAOC,EAAWC,CAAI,IAAIA,IAAOC,EAAS,UAAUD,CAAI;AAC1D"}

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

@@ -0,0 +1,49 @@
+import { readGestureLifecycle as e } from "../gestureLifecycle.js";
+import { gestureReaders as t } from "../../gestures/shared/screenTolerance.js";
+import { nodeDescriptors as n, poseDescriptorOf as r } from "../poseDescriptorDep.js";
+import { scenePoseFrame as i } from "../poseFrame.js";
+import { buildGestureContext as a, captureBox as o, captureStarts as s, captureTargets as c, resolvePolicy as l } from "./capture.js";
+//#region src/interactions/actions/resize/session.ts
+function u(u) {
+	let d = u.deps.selection, f = u.deps.scene;
+	if (!d || !f) return null;
+	let p = d.get();
+	if (p.length === 0) return null;
+	let m = u.drag?.affordance?.anchor;
+	if (!m) return null;
+	let h = r(u.deps.poseDescriptor), g = u.deps.resizePolicy, { constraints: _, pointSnap: v, expandIds: y } = l(g), b = n(f, h), x = c(f, p, y);
+	if (!x) return null;
+	let { writeIds: S, isGroupPath: C } = x, w = i(f), T = u.deps.view, E = s(f, S, b, w, T);
+	if (E.startPoses.size === 0) return null;
+	let { box: D, ruleOrigin: O } = o(E, S, C, m, h, b), k = {
+		x: u.drag?.start.x ?? 0,
+		y: u.drag?.start.y ?? 0
+	}, A = t(u.deps), j = a(u, p, O, k, A);
+	for (let e of _) e.onStart?.(j);
+	return {
+		session: {
+			scene: f,
+			writeIds: S,
+			sharedBox: C || S.length > 1,
+			box: D,
+			startPoses: E.startPoses,
+			startWorlds: E.startWorlds,
+			startWorld: k,
+			geometryOf: b,
+			poseFrame: w,
+			view: T,
+			constraints: _,
+			pointSnap: v,
+			gestureCtx: j,
+			applyOps: u.deps.applyOps,
+			geometryProjection: u.deps.geometryProjection,
+			selectionMethods: d.adapterMethods,
+			lifecycle: e(g, "Resize", _)
+		},
+		readers: A
+	};
+}
+//#endregion
+export { u as beginResize };
+
+//# sourceMappingURL=session.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["beginResize","selection","ctx","scene","ids","anchor","geometry","poseDescriptorOf","policy","resolvePolicy","geometryOf","nodeDescriptors","targets","captureTargets","expandIds","poseFrame","scenePoseFrame","view","starts","captureStarts","writeIds","captureBox","isGroupPath","startWorld","readers","gestureReaders","gestureCtx","buildGestureContext","ruleOrigin","b","constraints","readGestureLifecycle"],"sources":["../../../../src/interactions/actions/resize/session.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\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 { BoundsConstraint, GestureContext, PointSnapBehavior, ResizeAnchor } from '../../gestures/types';\nimport type { GeometryProjection } from '../geometryProjection';\nimport { readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { buildGestureContext, captureBox, captureStarts, captureTargets, resolvePolicy } from './capture';\nimport type { PoseDescriptor } from './geometry';\n\n/** The box the drag resizes, as the press found it. */\nexport interface ResizeBox {\n  /** The union for a group or a multi-selection, a lone target's own bounds\n   *  otherwise. The `src` rect every write id is remapped from. */\n  readonly bounds: Bounds;\n  readonly anchor: ResizeAnchor;\n  /** A lone target's rotation; 0 for a group. */\n  readonly rotation: number;\n  /** A lone target's `transform`; none for a group. */\n  readonly transform?: PoseLinear;\n  /** World position of the corner opposite the dragged one, which a resize\n   *  in a turned or skewed frame pins. */\n  readonly fixedWorld: { x: number; y: number };\n}\n\n/** What a resize captured at press. Nothing here changes during the drag. */\nexport interface ResizeSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  /** The ids the gesture writes: the leaf set for a group, else the selection. */\n  readonly writeIds: readonly NodeId[];\n  /** Whether `box` stands for several write ids, each remapped inside it,\n   *  rather than being a lone target's own. */\n  readonly sharedBox: boolean;\n  readonly box: ResizeBox;\n  /** Start poses as stored: the `from` of each op. */\n  readonly startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Start poses in world, the frame the anchor math and the drag share. */\n  readonly startWorlds: ReadonlyMap<NodeId, unknown>;\n  /** Where the pointer pressed. */\n  readonly startWorld: { x: number; y: number };\n  readonly geometryOf: (id: NodeId) => PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  readonly poseFrame: PoseFrame<unknown>;\n  readonly view: unknown;\n  readonly constraints: readonly BoundsConstraint<Bounds>[];\n  readonly pointSnap: readonly PointSnapBehavior<Bounds>[];\n  /** Reused across the drag; constraints mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<Bounds>;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  /** When present, the commit maps each leaf's data-held geometry by the\n   *  affine its pose underwent. */\n  readonly geometryProjection?: GeometryProjection;\n  readonly selectionMethods: SelectionApi['adapterMethods'] | undefined;\n  /** Label, history, and callbacks from the `resizePolicy` dep. */\n  readonly lifecycle: GestureLifecycle;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface ResizeFrame {\n  /** Stored-frame pose of every write id the move reached. */\n  readonly previews: Map<NodeId, unknown>;\n}\n\n/** Capture a resize at press. Null when nothing is selected, the press is not\n *  on a resize handle, or nothing it would write exists. Runs each\n *  constraint's `onStart`. */\nexport function beginResize(\n  ctx: InvocationCtx,\n): { session: ResizeSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  if (!selection || !scene) return null;\n\n  const ids = selection.get() as NodeId[];\n  if (ids.length === 0) return null;\n\n  const anchor = ctx.drag?.affordance?.anchor;\n  if (!anchor) return null;\n\n  const geometry = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const policy = ctx.deps.resizePolicy;\n  const { constraints, pointSnap, expandIds } = resolvePolicy(policy);\n  const geometryOf = nodeDescriptors(scene, geometry);\n\n  const targets = captureTargets(scene, ids, expandIds);\n  if (!targets) return null;\n  const { writeIds, isGroupPath } = targets;\n\n  // The drag delta is world, so the anchor math runs on world poses — carried\n  // into the plane the edit is measured in — and each result is carried back\n  // to its node's plane and stored in the node's own parent frame.\n  const poseFrame = scenePoseFrame(scene);\n  const view = ctx.deps.view;\n  const starts = captureStarts(scene, writeIds, geometryOf, poseFrame, view);\n  if (starts.startPoses.size === 0) return null;\n\n  const { box, ruleOrigin } = captureBox(starts, writeIds, isGroupPath, anchor, geometry, geometryOf);\n  const startWorld = { x: ctx.drag?.start.x ?? 0, y: ctx.drag?.start.y ?? 0 };\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, ids, ruleOrigin, startWorld, readers);\n  for (const b of constraints) b.onStart?.(gestureCtx);\n\n  const session: ResizeSession = {\n    scene,\n    writeIds,\n    sharedBox: isGroupPath || writeIds.length > 1,\n    box,\n    startPoses: starts.startPoses,\n    startWorlds: starts.startWorlds,\n    startWorld,\n    geometryOf,\n    poseFrame,\n    view,\n    constraints,\n    pointSnap,\n    gestureCtx,\n    applyOps: ctx.deps.applyOps,\n    geometryProjection: ctx.deps.geometryProjection,\n    selectionMethods: selection.adapterMethods,\n    lifecycle: readGestureLifecycle(policy, 'Resize', constraints),\n  };\n  return { session, readers };\n}\n"],"mappings":";;;;;;AAuEA,SAAgBA,EACd,GAC4D;CAC5D,IAAMC,IAAYC,EAAI,KAAK,WACrBC,IAAQD,EAAI,KAAK;CACvB,IAAI,CAACD,KAAa,CAACE,GAAO,OAAO;CAEjC,IAAMC,IAAMH,EAAU,IAAI;CAC1B,IAAIG,EAAI,WAAW,GAAG,OAAO;CAE7B,IAAMC,IAASH,EAAI,MAAM,YAAY;CACrC,IAAI,CAACG,GAAQ,OAAO;CAEpB,IAAMC,IAAWC,EAAiBL,EAAI,KAAK,cAAc,GACnDM,IAASN,EAAI,KAAK,cAClB,EAAE,gBAAa,cAAW,iBAAcO,EAAcD,CAAM,GAC5DE,IAAaC,EAAgBR,GAAOG,CAAQ,GAE5CM,IAAUC,EAAeV,GAAOC,GAAKU,CAAS;CACpD,IAAI,CAACF,GAAS,OAAO;CACrB,IAAM,EAAE,aAAU,mBAAgBA,GAK5BG,IAAYC,EAAeb,CAAK,GAChCc,IAAOf,EAAI,KAAK,MAChBgB,IAASC,EAAchB,GAAOiB,GAAUV,GAAYK,GAAWE,CAAI;CACzE,IAAIC,EAAO,WAAW,SAAS,GAAG,OAAO;CAEzC,IAAM,EAAE,QAAK,kBAAeG,EAAWH,GAAQE,GAAUE,GAAajB,GAAQC,GAAUI,CAAU,GAC5Fa,IAAa;EAAE,GAAGrB,EAAI,MAAM,MAAM,KAAK;EAAG,GAAGA,EAAI,MAAM,MAAM,KAAK;CAAE,GACpEsB,IAAUC,EAAevB,EAAI,IAAI,GACjCwB,IAAaC,EAAoBzB,GAAKE,GAAKwB,GAAYL,GAAYC,CAAO;CAChF,KAAK,IAAMK,KAAKC,GAAa,EAAE,UAAUJ,CAAU;CAqBnD,OAAO;EAAE,SAAA;GAlBP;GACA;GACA,WAAWJ,KAAeF,EAAS,SAAS;GAC5C;GACA,YAAYF,EAAO;GACnB,aAAaA,EAAO;GACpB;GACA;GACA;GACA;GACA;GACA;GACA;GACA,UAAUhB,EAAI,KAAK;GACnB,oBAAoBA,EAAI,KAAK;GAC7B,kBAAkBD,EAAU;GAC5B,WAAW8B,EAAqBvB,GAAQ,UAAUsB,CAAW;EAEtD;EAAS;CAAQ;AAC5B"}

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

@@ -1 +1 @@
-{"version":3,"file":"resolveOverlays.js","names":["resolveOverlays","out","ov","overlays","x","y","width","height","insertPreviewExtent","bounds","geometry"],"sources":["../../../src/interactions/actions/resolveOverlays.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing to paint *beside* the scene, resolved\n * to geometry.\n *\n * The sibling of `resolvePreviews`: that one answers for the ghosts of scene\n * nodes a gesture is displacing, this one for the chrome a gesture draws that\n * is no node at all — a marquee rect, a lasso trail, the outline of a shape\n * being dragged out. `<SceneCanvas>`'s `useDispatcherOverlayLayer` used to be\n * the only thing that knew how to read an `OngoingOverlay`, and it read one\n * straight into `DrawCommand`s, so a consumer with its own renderer got\n * nothing. None of the normalizing is about drawing.\n *\n * What stays out, as in `resolvePreviews`: no view, no screen projection, no\n * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.\n */\n\nimport type { InsertPreviewGeometry } from '../../canvas/insertPreviewExtent';\nimport { insertPreviewExtent } from '../../canvas/insertPreviewExtent';\nimport type { Bounds } from '../../core/viewport/fitViewToBounds';\nimport type { KitInsertShape } from '../../core/shapeKinds';\nimport type { OngoingOverlay, OverlayRole } from '@weasel-js/routing';\n\ntype Point = { x: number; y: number };\n\n/**\n * The chrome-caps id a surface consults before painting each variant. The\n * gating itself is the painter's — two views of one surface may disagree about\n * whether to show an in-flight marquee — but the id is not something a caller\n * should have to guess.\n */\nexport type OverlayVisibilityId =\n  | 'action.marquee'\n  | 'action.lasso'\n  | 'action.insert-preview'\n  | 'action.polyline';\n\n/**\n * One in-flight overlay, in world coordinates.\n *\n * Every degenerate overlay is already gone: a marquee of zero size, a lasso\n * under two vertices, a zero-area insert of anything but a pencil, a pencil\n * under two samples, a run of fewer than two points. Whatever is in this list\n * is worth painting.\n */\nexport type ResolvedOverlay =\n  | {\n      kind: 'marquee';\n      visibilityId: 'action.marquee';\n      /** The drag normalized: `start`/`current` in either order, one AABB. */\n      bounds: Bounds;\n      /** Additive intent. Core's 2D layer paints the same rect either way. */\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'lasso';\n      visibilityId: 'action.lasso';\n      /** The trail so far, at least two long. The region it encloses is the\n       *  trail closed back to its first vertex. */\n      vertices: ReadonlyArray<Point>;\n      /** Live pointer position — the trail's last vertex until it advances. */\n      current: Point;\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'insertPreview';\n      visibilityId: 'action.insert-preview';\n      shape: KitInsertShape;\n      /** Extent of `geometry`, which for a radial or freehand shape is not the\n       *  drag rect. See `insertPreviewExtent`. */\n      bounds: Bounds;\n      geometry: InsertPreviewGeometry;\n      /** The drag's anchor — a growth axis to mark. Absent for a pencil, which\n       *  has none. */\n      anchorPoint?: Point;\n      /** The action's per-shape payload, verbatim. Carries what geometry\n       *  cannot: an image insert's `src`, say. */\n      extras: unknown;\n    }\n  | {\n      kind: 'polyline';\n      visibilityId: 'action.polyline';\n      /** The run, at least two long, open — the last point does not join the\n       *  first. A closed sweep is a `lasso`. */\n      points: ReadonlyArray<Point>;\n      /** What the run is, for a painter choosing a style. Never defaulted\n       *  away: `'chrome'` when the action named none. A role the painter has\n       *  no style for is drawn as plain chrome, not dropped. */\n      role: OverlayRole;\n    };\n\n/** The overlays worth painting, in the order the handles published them. */\nexport function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[] {\n  const out: ResolvedOverlay[] = [];\n  for (const ov of overlays) {\n    switch (ov.kind) {\n      case 'marquee': {\n        const x = Math.min(ov.start.x, ov.current.x);\n        const y = Math.min(ov.start.y, ov.current.y);\n        const width = Math.abs(ov.current.x - ov.start.x);\n        const height = Math.abs(ov.current.y - ov.start.y);\n        if (width === 0 && height === 0) break;\n        out.push({\n          kind: 'marquee',\n          visibilityId: 'action.marquee',\n          bounds: { x, y, width, height },\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'lasso': {\n        if (ov.vertices.length < 2) break;\n        out.push({\n          kind: 'lasso',\n          visibilityId: 'action.lasso',\n          vertices: ov.vertices,\n          current: ov.current,\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'insertPreview': {\n        const { bounds, geometry } = insertPreviewExtent(ov);\n        // A pencil can be meaningful at zero AABB — a closed loop, a\n        // sub-threshold gesture — where every other shape cannot.\n        if (bounds.width === 0 && bounds.height === 0 && ov.shape !== 'pencil') break;\n        if (geometry.kind === 'pencil' && geometry.samples.length < 2) break;\n        out.push({\n          kind: 'insertPreview',\n          visibilityId: 'action.insert-preview',\n          // Routing types the insert shape as an open string: a\n          // consumer-defined kind is legal there and simply gets no live\n          // preview. This narrows to the kinds the kit's overlay draws —\n          // the `break` above has already rejected everything else.\n          shape: ov.shape as KitInsertShape,\n          bounds,\n          geometry,\n          extras: ov.extras,\n          ...(ov.anchorPoint && ov.shape !== 'pencil' ? { anchorPoint: ov.anchorPoint } : {}),\n        });\n        break;\n      }\n      case 'polyline': {\n        if (ov.points.length < 2) break;\n        out.push({\n          kind: 'polyline',\n          visibilityId: 'action.polyline',\n          points: ov.points,\n          role: ov.role ?? 'chrome',\n        });\n        break;\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":";;AA2FA,SAAgBA,EAAgB,GAAuD;CACrF,IAAMC,IAAyB,CAAC;CAChC,KAAK,IAAMC,KAAMC,GACf,QAAQD,EAAG,MAAX;EACE,KAAK,WAAW;GACd,IAAME,IAAI,KAAK,IAAIF,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCG,IAAI,KAAK,IAAIH,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCI,IAAQ,KAAK,IAAIJ,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC,GAC1CK,IAAS,KAAK,IAAIL,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC;GACjD,IAAII,MAAU,KAAKC,MAAW,GAAG;GACjC,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQ;KAAE;KAAG;KAAG;KAAO;IAAO;IAC9B,WAAWL,EAAG;GAChB,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,SAAS,SAAS,GAAG;GAC5B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,UAAUA,EAAG;IACb,SAASA,EAAG;IACZ,WAAWA,EAAG;GAChB,CAAC;GACD;EAEF,KAAK,iBAAiB;GACpB,IAAM,EAAE,WAAQ,gBAAaM,EAAoBN,CAAE;GAInD,IADIO,EAAO,UAAU,KAAKA,EAAO,WAAW,KAAKP,EAAG,UAAU,YAC1DQ,EAAS,SAAS,YAAYA,EAAS,QAAQ,SAAS,GAAG;GAC/D,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IAKd,OAAOR,EAAG;IACV;IACA;IACA,QAAQA,EAAG;IACX,GAAIA,EAAG,eAAeA,EAAG,UAAU,WAAW,EAAE,aAAaA,EAAG,YAAY,IAAI,CAAC;GACnF,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,OAAO,SAAS,GAAG;GAC1B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQA,EAAG;IACX,MAAMA,EAAG,QAAQ;GACnB,CAAC;CAGL;CAEF,OAAOD;AACT"}
+{"version":3,"file":"resolveOverlays.js","names":["resolveOverlays","out","ov","overlays","x","y","width","height","insertPreviewExtent","bounds","geometry"],"sources":["../../../src/interactions/actions/resolveOverlays.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing to paint *beside* the scene, resolved\n * to geometry.\n *\n * The sibling of `resolvePreviews`: that one answers for the ghosts of scene\n * nodes a gesture is displacing, this one for the chrome a gesture draws that\n * is no node at all — a marquee rect, a lasso trail, the outline of a shape\n * being dragged out.\n *\n * What stays out, as in `resolvePreviews`: no view, no screen projection, no\n * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.\n */\n\nimport type { InsertPreviewGeometry } from '../../canvas/insertPreviewExtent';\nimport { insertPreviewExtent } from '../../canvas/insertPreviewExtent';\nimport type { Bounds } from '../../core/viewport/fitViewToBounds';\nimport type { KitInsertShape } from '../../core/shapeKinds';\nimport type { OngoingOverlay, OverlayRole } from '@weasel-js/routing';\n\ntype Point = { x: number; y: number };\n\n/**\n * The chrome-caps id a surface consults before painting each variant. The\n * gating itself is the painter's — two views of one surface may disagree about\n * whether to show an in-flight marquee — but the id is not something a caller\n * should have to guess.\n */\nexport type OverlayVisibilityId =\n  | 'action.marquee'\n  | 'action.lasso'\n  | 'action.insert-preview'\n  | 'action.polyline';\n\n/**\n * One in-flight overlay, in world coordinates.\n *\n * Every degenerate overlay is already gone: a marquee of zero size, a lasso\n * under two vertices, a zero-area insert of anything but a pencil, a pencil\n * under two samples, a run of fewer than two points. Whatever is in this list\n * is worth painting.\n */\nexport type ResolvedOverlay =\n  | {\n      kind: 'marquee';\n      visibilityId: 'action.marquee';\n      /** The drag normalized: `start`/`current` in either order, one AABB. */\n      bounds: Bounds;\n      /** Additive intent. Core's 2D layer paints the same rect either way. */\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'lasso';\n      visibilityId: 'action.lasso';\n      /** The trail so far, at least two long. The region it encloses is the\n       *  trail closed back to its first vertex. */\n      vertices: ReadonlyArray<Point>;\n      /** Live pointer position — the trail's last vertex until it advances. */\n      current: Point;\n      shiftHeld: boolean;\n    }\n  | {\n      kind: 'insertPreview';\n      visibilityId: 'action.insert-preview';\n      shape: KitInsertShape;\n      /** Extent of `geometry`, which for a radial or freehand shape is not the\n       *  drag rect. See `insertPreviewExtent`. */\n      bounds: Bounds;\n      geometry: InsertPreviewGeometry;\n      /** The drag's anchor — a growth axis to mark. Absent for a pencil, which\n       *  has none. */\n      anchorPoint?: Point;\n      /** The action's per-shape payload, verbatim. Carries what geometry\n       *  cannot: an image insert's `src`, say. */\n      extras: unknown;\n    }\n  | {\n      kind: 'polyline';\n      visibilityId: 'action.polyline';\n      /** The run, at least two long, open — the last point does not join the\n       *  first. A closed sweep is a `lasso`. */\n      points: ReadonlyArray<Point>;\n      /** What the run is, for a painter choosing a style. Never defaulted\n       *  away: `'chrome'` when the action named none. A role the painter has\n       *  no style for is drawn as plain chrome, not dropped. */\n      role: OverlayRole;\n    };\n\n/** The overlays worth painting, in the order the handles published them. */\nexport function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[] {\n  const out: ResolvedOverlay[] = [];\n  for (const ov of overlays) {\n    switch (ov.kind) {\n      case 'marquee': {\n        const x = Math.min(ov.start.x, ov.current.x);\n        const y = Math.min(ov.start.y, ov.current.y);\n        const width = Math.abs(ov.current.x - ov.start.x);\n        const height = Math.abs(ov.current.y - ov.start.y);\n        if (width === 0 && height === 0) break;\n        out.push({\n          kind: 'marquee',\n          visibilityId: 'action.marquee',\n          bounds: { x, y, width, height },\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'lasso': {\n        if (ov.vertices.length < 2) break;\n        out.push({\n          kind: 'lasso',\n          visibilityId: 'action.lasso',\n          vertices: ov.vertices,\n          current: ov.current,\n          shiftHeld: ov.shiftHeld,\n        });\n        break;\n      }\n      case 'insertPreview': {\n        const { bounds, geometry } = insertPreviewExtent(ov);\n        // A pencil can be meaningful at zero AABB — a closed loop, a\n        // sub-threshold gesture — where every other shape cannot.\n        if (bounds.width === 0 && bounds.height === 0 && ov.shape !== 'pencil') break;\n        if (geometry.kind === 'pencil' && geometry.samples.length < 2) break;\n        out.push({\n          kind: 'insertPreview',\n          visibilityId: 'action.insert-preview',\n          // Routing types the insert shape as an open string; a\n          // consumer-defined kind is legal there.\n          shape: ov.shape as KitInsertShape,\n          bounds,\n          geometry,\n          extras: ov.extras,\n          ...(ov.anchorPoint && ov.shape !== 'pencil' ? { anchorPoint: ov.anchorPoint } : {}),\n        });\n        break;\n      }\n      case 'polyline': {\n        if (ov.points.length < 2) break;\n        out.push({\n          kind: 'polyline',\n          visibilityId: 'action.polyline',\n          points: ov.points,\n          role: ov.role ?? 'chrome',\n        });\n        break;\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":";;AAwFA,SAAgBA,EAAgB,GAAuD;CACrF,IAAMC,IAAyB,CAAC;CAChC,KAAK,IAAMC,KAAMC,GACf,QAAQD,EAAG,MAAX;EACE,KAAK,WAAW;GACd,IAAME,IAAI,KAAK,IAAIF,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCG,IAAI,KAAK,IAAIH,EAAG,MAAM,GAAGA,EAAG,QAAQ,CAAC,GACrCI,IAAQ,KAAK,IAAIJ,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC,GAC1CK,IAAS,KAAK,IAAIL,EAAG,QAAQ,IAAIA,EAAG,MAAM,CAAC;GACjD,IAAII,MAAU,KAAKC,MAAW,GAAG;GACjC,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQ;KAAE;KAAG;KAAG;KAAO;IAAO;IAC9B,WAAWL,EAAG;GAChB,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,SAAS,SAAS,GAAG;GAC5B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,UAAUA,EAAG;IACb,SAASA,EAAG;IACZ,WAAWA,EAAG;GAChB,CAAC;GACD;EAEF,KAAK,iBAAiB;GACpB,IAAM,EAAE,WAAQ,gBAAaM,EAAoBN,CAAE;GAInD,IADIO,EAAO,UAAU,KAAKA,EAAO,WAAW,KAAKP,EAAG,UAAU,YAC1DQ,EAAS,SAAS,YAAYA,EAAS,QAAQ,SAAS,GAAG;GAC/D,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IAGd,OAAOR,EAAG;IACV;IACA;IACA,QAAQA,EAAG;IACX,GAAIA,EAAG,eAAeA,EAAG,UAAU,WAAW,EAAE,aAAaA,EAAG,YAAY,IAAI,CAAC;GACnF,CAAC;GACD;EACF;EACA,KAAK;GACH,IAAIA,EAAG,OAAO,SAAS,GAAG;GAC1B,EAAI,KAAK;IACP,MAAM;IACN,cAAc;IACd,QAAQA,EAAG;IACX,MAAMA,EAAG,QAAQ;GACnB,CAAC;CAGL;CAEF,OAAOD;AACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"resolvePreviews.js","names":["firstNonNull","source","sources","value","read","id","resolvePreviews","list","ids","previewing","opaque","settled","build","node","scene","asNodeId","pose","s","i","data","children","childId","child","roots","parent","root","flattenPreviews","out","walk","entry"],"sources":["../../../src/interactions/actions/resolvePreviews.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing, resolved against the committed scene.\n *\n * An ongoing action publishes interim poses on its handle rather than writing\n * them to the scene, and `<SceneCanvas>`'s ghost layer used to be the only\n * thing that knew how to read them: which ids are in flight, which of those are\n * roots, whose preview wins when two sources name the same id, and which are\n * merely displaced rather than dragged. None of that is about drawing, and a\n * consumer with its own renderer needs all of it.\n */\n\nimport type { GesturePreviewSource } from '../../canvas/gestureBounds';\nimport type { Node, NodeId, Scene } from '../../core/scene/types';\nimport { asNodeId } from '../../core/scene/types';\n\n/** One node an in-flight gesture is previewing, as {@link resolvePreviews} returns it. */\nexport interface PreviewNode<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  /** The node as committed — the gesture has not touched the scene. */\n  node: Node<TData, TLayer, TPose>;\n  /** The interim pose, or the committed one when only data is in flight. */\n  pose: TPose;\n  /** The interim data, or the committed one when only the pose is in flight. */\n  data: TData;\n  /**\n   * The gesture is not carrying this one under the pointer — a layout sibling\n   * reflowing into its destination slot. It reads better painted settled.\n   */\n  opaque: boolean;\n  /** Previewed descendants, so a container's ghost brings its children. */\n  children: PreviewNode<TData, TLayer, TPose>[];\n}\n\n/** First non-null answer across sources: tool-side before dispatcher-side. */\nfunction firstNonNull<T>(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n  read: (source: GesturePreviewSource, id: string) => unknown,\n): T | null {\n  for (const source of sources) {\n    const value = read(source, id);\n    if (value != null) return value as T;\n  }\n  return null;\n}\n\n/**\n * The previewing subtrees, as roots. A previewed node whose parent is also\n * previewing is a child of that parent's entry rather than a root of its own,\n * which is what lets a caller draw a container and its contents as one thing.\n *\n * An id with no node is skipped: an insert previews before the node it will\n * create exists. So is an id no source has a pose or data for.\n */\nexport function resolvePreviews<TData, TLayer extends string, TPose>(\n  sources: Iterable<GesturePreviewSource>,\n  scene: Scene<TData, TLayer, TPose>,\n): PreviewNode<TData, TLayer, TPose>[] {\n  const list = [...sources];\n  const ids = new Set<string>();\n  for (const source of list) {\n    const previewing = source.previewIds?.();\n    if (!previewing) continue;\n    for (const id of previewing) ids.add(id);\n  }\n  if (ids.size === 0) return [];\n\n  const opaque = new Set<string>();\n  for (const source of list) {\n    const settled = source.previewOpaqueIds?.();\n    if (!settled) continue;\n    for (const id of settled) opaque.add(id);\n  }\n\n  const build = (id: string): PreviewNode<TData, TLayer, TPose> | null => {\n    const node = scene.get(asNodeId(id));\n    if (!node) return null;\n    const pose = firstNonNull<TPose>(list, id, (s, i) => s.previewPose?.(i));\n    const data = firstNonNull<TData>(list, id, (s, i) => s.previewData?.(i));\n    if (pose == null && data == null) return null;\n\n    const children: PreviewNode<TData, TLayer, TPose>[] = [];\n    for (const childId of scene.childrenOf(asNodeId(id))) {\n      if (!ids.has(childId)) continue;\n      const child = build(childId);\n      if (child) children.push(child);\n    }\n\n    return {\n      id: asNodeId(id),\n      node,\n      pose: pose ?? node.pose,\n      data: data ?? node.data,\n      opaque: opaque.has(id),\n      children,\n    };\n  };\n\n  const roots: PreviewNode<TData, TLayer, TPose>[] = [];\n  for (const id of ids) {\n    const parent = scene.get(asNodeId(id))?.parent;\n    if (parent != null && ids.has(parent)) continue;\n    const root = build(id);\n    if (root) roots.push(root);\n  }\n  return roots;\n}\n\n/** Every entry in the forest, parents before their children. */\nexport function flattenPreviews<TData, TLayer extends string, TPose>(\n  roots: readonly PreviewNode<TData, TLayer, TPose>[],\n): PreviewNode<TData, TLayer, TPose>[] {\n  const out: PreviewNode<TData, TLayer, TPose>[] = [];\n  const walk = (entry: PreviewNode<TData, TLayer, TPose>) => {\n    out.push(entry);\n    for (const child of entry.children) walk(child);\n  };\n  for (const root of roots) walk(root);\n  return out;\n}\n"],"mappings":";;AAkCA,SAASA,EACP,GACA,GACA,GACU;CACV,KAAK,IAAMC,KAAUC,GAAS;EAC5B,IAAMC,IAAQC,EAAKH,GAAQI,CAAE;EAC7B,IAAIF,KAAS,MAAM,OAAOA;CAC5B;CACA,OAAO;AACT;AAUA,SAAgBG,EACd,GACA,GACqC;CACrC,IAAMC,IAAO,CAAC,GAAGL,CAAO,GAClBM,oBAAM,IAAI,IAAY;CAC5B,KAAK,IAAMP,KAAUM,GAAM;EACzB,IAAME,IAAaR,EAAO,aAAa;EACvC,IAAKQ,GACL,KAAK,IAAMJ,KAAMI,GAAY,EAAI,IAAIJ,CAAE;CACzC;CACA,IAAIG,EAAI,SAAS,GAAG,OAAO,CAAC;CAE5B,IAAME,oBAAS,IAAI,IAAY;CAC/B,KAAK,IAAMT,KAAUM,GAAM;EACzB,IAAMI,IAAUV,EAAO,mBAAmB;EAC1C,IAAKU,GACL,KAAK,IAAMN,KAAMM,GAAS,EAAO,IAAIN,CAAE;CACzC;CAEA,IAAMO,KAAS,MAAyD;EACtE,IAAMC,IAAOC,EAAM,IAAIC,EAASV,CAAE,CAAC;EACnC,IAAI,CAACQ,GAAM,OAAO;EAClB,IAAMG,IAAOhB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC,GACjEC,IAAOnB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC;EACvE,IAAIF,KAAQ,QAAQG,KAAQ,MAAM,OAAO;EAEzC,IAAMC,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAWP,EAAM,WAAWC,EAASV,CAAE,CAAC,GAAG;GACpD,IAAI,CAACG,EAAI,IAAIa,CAAO,GAAG;GACvB,IAAMC,IAAQV,EAAMS,CAAO;GAC3B,AAAIC,KAAOF,EAAS,KAAKE,CAAK;EAChC;EAEA,OAAO;GACL,IAAIP,EAASV,CAAE;GACf;GACA,MAAMW,KAAQH,EAAK;GACnB,MAAMM,KAAQN,EAAK;GACnB,QAAQH,EAAO,IAAIL,CAAE;GACrB;EACF;CACF,GAEMkB,IAA6C,CAAC;CACpD,KAAK,IAAMlB,KAAMG,GAAK;EACpB,IAAMgB,IAASV,EAAM,IAAIC,EAASV,CAAE,CAAC,CAAC,EAAE;EACxC,IAAImB,KAAU,QAAQhB,EAAI,IAAIgB,CAAM,GAAG;EACvC,IAAMC,IAAOb,EAAMP,CAAE;EACrB,AAAIoB,KAAMF,EAAM,KAAKE,CAAI;CAC3B;CACA,OAAOF;AACT;AAGA,SAAgBG,EACd,GACqC;CACrC,IAAMC,IAA2C,CAAC,GAC5CC,KAAQ,MAA6C;EACzD,EAAI,KAAKC,CAAK;EACd,KAAK,IAAMP,KAASO,EAAM,UAAU,EAAKP,CAAK;CAChD;CACA,KAAK,IAAMG,KAAQF,GAAO,EAAKE,CAAI;CACnC,OAAOE;AACT"}
+{"version":3,"file":"resolvePreviews.js","names":["firstNonNull","source","sources","value","read","id","resolvePreviews","list","ids","previewing","opaque","settled","build","node","scene","asNodeId","pose","s","i","data","children","childId","child","roots","parent","root","flattenPreviews","out","walk","entry"],"sources":["../../../src/interactions/actions/resolvePreviews.ts"],"sourcesContent":["/**\n * What an in-flight gesture is proposing, resolved against the committed scene.\n *\n * An ongoing action publishes interim poses on its handle rather than writing\n * them to the scene, and `<SceneCanvas>`'s ghost layer used to be the only\n * thing that knew how to read them: which ids are in flight, which of those are\n * roots, whose preview wins when two sources name the same id, and which are\n * merely displaced rather than dragged. None of that is about drawing, and a\n * consumer with its own renderer needs all of it.\n */\n\nimport type { GesturePreviewSource } from '../../canvas/gestureBounds';\nimport type { Node, NodeId, Scene } from '../../core/scene/types';\nimport { asNodeId } from '../../core/scene/types';\n\n/** One node an in-flight gesture is previewing, as {@link resolvePreviews} returns it. */\nexport interface PreviewNode<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  /** The node as committed — the gesture has not touched the scene. */\n  node: Node<TData, TLayer, TPose>;\n  /** The interim pose, or the committed one when only data is in flight. */\n  pose: TPose;\n  /** The interim data, or the committed one when only the pose is in flight. */\n  data: TData;\n  /**\n   * The gesture is not carrying this one under the pointer — a layout sibling\n   * reflowing into its destination slot. It reads better painted settled.\n   */\n  opaque: boolean;\n  /** Previewed descendants, so a container's ghost brings its children. */\n  children: PreviewNode<TData, TLayer, TPose>[];\n}\n\n/** First non-null answer across sources, in the order given. */\nfunction firstNonNull<T>(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n  read: (source: GesturePreviewSource, id: string) => unknown,\n): T | null {\n  for (const source of sources) {\n    const value = read(source, id);\n    if (value != null) return value as T;\n  }\n  return null;\n}\n\n/**\n * The previewing subtrees, as roots. A previewed node whose parent is also\n * previewing is a child of that parent's entry rather than a root of its own,\n * which is what lets a caller draw a container and its contents as one thing.\n *\n * An id with no node is skipped: an insert previews before the node it will\n * create exists. So is an id no source has a pose or data for.\n */\nexport function resolvePreviews<TData, TLayer extends string, TPose>(\n  sources: Iterable<GesturePreviewSource>,\n  scene: Scene<TData, TLayer, TPose>,\n): PreviewNode<TData, TLayer, TPose>[] {\n  const list = [...sources];\n  const ids = new Set<string>();\n  for (const source of list) {\n    const previewing = source.previewIds?.();\n    if (!previewing) continue;\n    for (const id of previewing) ids.add(id);\n  }\n  if (ids.size === 0) return [];\n\n  const opaque = new Set<string>();\n  for (const source of list) {\n    const settled = source.previewOpaqueIds?.();\n    if (!settled) continue;\n    for (const id of settled) opaque.add(id);\n  }\n\n  const build = (id: string): PreviewNode<TData, TLayer, TPose> | null => {\n    const node = scene.get(asNodeId(id));\n    if (!node) return null;\n    const pose = firstNonNull<TPose>(list, id, (s, i) => s.previewPose?.(i));\n    const data = firstNonNull<TData>(list, id, (s, i) => s.previewData?.(i));\n    if (pose == null && data == null) return null;\n\n    const children: PreviewNode<TData, TLayer, TPose>[] = [];\n    for (const childId of scene.childrenOf(asNodeId(id))) {\n      if (!ids.has(childId)) continue;\n      const child = build(childId);\n      if (child) children.push(child);\n    }\n\n    return {\n      id: asNodeId(id),\n      node,\n      pose: pose ?? node.pose,\n      data: data ?? node.data,\n      opaque: opaque.has(id),\n      children,\n    };\n  };\n\n  const roots: PreviewNode<TData, TLayer, TPose>[] = [];\n  for (const id of ids) {\n    const parent = scene.get(asNodeId(id))?.parent;\n    if (parent != null && ids.has(parent)) continue;\n    const root = build(id);\n    if (root) roots.push(root);\n  }\n  return roots;\n}\n\n/** Every entry in the forest, parents before their children. */\nexport function flattenPreviews<TData, TLayer extends string, TPose>(\n  roots: readonly PreviewNode<TData, TLayer, TPose>[],\n): PreviewNode<TData, TLayer, TPose>[] {\n  const out: PreviewNode<TData, TLayer, TPose>[] = [];\n  const walk = (entry: PreviewNode<TData, TLayer, TPose>) => {\n    out.push(entry);\n    for (const child of entry.children) walk(child);\n  };\n  for (const root of roots) walk(root);\n  return out;\n}\n"],"mappings":";;AAkCA,SAASA,EACP,GACA,GACA,GACU;CACV,KAAK,IAAMC,KAAUC,GAAS;EAC5B,IAAMC,IAAQC,EAAKH,GAAQI,CAAE;EAC7B,IAAIF,KAAS,MAAM,OAAOA;CAC5B;CACA,OAAO;AACT;AAUA,SAAgBG,EACd,GACA,GACqC;CACrC,IAAMC,IAAO,CAAC,GAAGL,CAAO,GAClBM,oBAAM,IAAI,IAAY;CAC5B,KAAK,IAAMP,KAAUM,GAAM;EACzB,IAAME,IAAaR,EAAO,aAAa;EACvC,IAAKQ,GACL,KAAK,IAAMJ,KAAMI,GAAY,EAAI,IAAIJ,CAAE;CACzC;CACA,IAAIG,EAAI,SAAS,GAAG,OAAO,CAAC;CAE5B,IAAME,oBAAS,IAAI,IAAY;CAC/B,KAAK,IAAMT,KAAUM,GAAM;EACzB,IAAMI,IAAUV,EAAO,mBAAmB;EAC1C,IAAKU,GACL,KAAK,IAAMN,KAAMM,GAAS,EAAO,IAAIN,CAAE;CACzC;CAEA,IAAMO,KAAS,MAAyD;EACtE,IAAMC,IAAOC,EAAM,IAAIC,EAASV,CAAE,CAAC;EACnC,IAAI,CAACQ,GAAM,OAAO;EAClB,IAAMG,IAAOhB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC,GACjEC,IAAOnB,EAAoBO,GAAMF,IAAK,GAAG,MAAMY,EAAE,cAAcC,CAAC,CAAC;EACvE,IAAIF,KAAQ,QAAQG,KAAQ,MAAM,OAAO;EAEzC,IAAMC,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAWP,EAAM,WAAWC,EAASV,CAAE,CAAC,GAAG;GACpD,IAAI,CAACG,EAAI,IAAIa,CAAO,GAAG;GACvB,IAAMC,IAAQV,EAAMS,CAAO;GAC3B,AAAIC,KAAOF,EAAS,KAAKE,CAAK;EAChC;EAEA,OAAO;GACL,IAAIP,EAASV,CAAE;GACf;GACA,MAAMW,KAAQH,EAAK;GACnB,MAAMM,KAAQN,EAAK;GACnB,QAAQH,EAAO,IAAIL,CAAE;GACrB;EACF;CACF,GAEMkB,IAA6C,CAAC;CACpD,KAAK,IAAMlB,KAAMG,GAAK;EACpB,IAAMgB,IAASV,EAAM,IAAIC,EAASV,CAAE,CAAC,CAAC,EAAE;EACxC,IAAImB,KAAU,QAAQhB,EAAI,IAAIgB,CAAM,GAAG;EACvC,IAAMC,IAAOb,EAAMP,CAAE;EACrB,AAAIoB,KAAMF,EAAM,KAAKE,CAAI;CAC3B;CACA,OAAOF;AACT;AAGA,SAAgBG,EACd,GACqC;CACrC,IAAMC,IAA2C,CAAC,GAC5CC,KAAQ,MAA6C;EACzD,EAAI,KAAKC,CAAK;EACd,KAAK,IAAMP,KAASO,EAAM,UAAU,EAAKP,CAAK;CAChD;CACA,KAAK,IAAMG,KAAQF,GAAO,EAAKE,CAAI;CACnC,OAAOE;AACT"}

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

@@ -0,0 +1,56 @@
+import { closeGesture as e, runBehaviorCancel as t } from "../gestureLifecycle.js";
+import { inPlane as n, selectionLayer as r } from "../planeInput.js";
+import { nextFrame as i } from "./frame.js";
+import { commitRotate as a } from "./commit.js";
+import { beginRotate as o } from "./session.js";
+//#region src/interactions/actions/rotate/action.ts
+var s = n({
+	id: "rotate",
+	label: "Rotate",
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps",
+		"poseDescriptor",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(n, r) {
+			let s = o(n, r);
+			if (!s) return {};
+			let { session: c, readers: l } = s, u = c.scene.overrides.hold(), d = {
+				delta: 0,
+				previews: /* @__PURE__ */ new Map()
+			};
+			return c.lifecycle.start(c.gestureCtx.draggedIds), {
+				kind: "rotate",
+				onMove(e) {
+					d = i(c, l, e), u.set(d.previews);
+				},
+				onEnd(n, r) {
+					let i = !1;
+					try {
+						r === "commit" ? i = a(c, d) : t(c.behaviors, c.gestureCtx);
+					} finally {
+						e({
+							hold: u,
+							previews: d.previews,
+							behaviors: c.behaviors,
+							ctx: c.gestureCtx,
+							lifecycle: c.lifecycle
+						}, i);
+					}
+				},
+				previewIds: () => d.previews.keys(),
+				previewPose: (e) => d.previews.get(e) ?? null
+			};
+		}
+	},
+	enabled: () => !0
+}, r);
+//#endregion
+export { s as rotateAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["rotateAction","inPlane","begun","beginRotate","ctx","opts","hold","session","frame","nextFrame","readers","moveCtx","committed","reason","commitRotate","runBehaviorCancel","id","selectionLayer"],"sources":["../../../../src/interactions/actions/rotate/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { closeGesture, runBehaviorCancel } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { commitRotate } from './commit';\nimport { nextFrame } from './frame';\nimport { beginRotate, type RotateFrame } from './session';\n\n/**\n * @experimental\n * Pointer-driven rotation of the selection, committed as one undo entry.\n *\n * A pose whose descriptor has no `withRotation`, or reports\n * `supportsRotation` false, is left alone. Behaviors (`opts.behaviors`) see\n * the first rotated node's turned pose; a pose one returns from `onMove` sets\n * the rotation for the whole selection.\n */\nexport const rotateAction: Action & { requires: string[] } = inPlane({\n  id: 'rotate',\n  label: 'Rotate',\n  // No default binding: a bare `{ kind: 'drag' }` makes any drag no active\n  // tool claimed rotate a non-empty selection. The rotation handle binds it\n  // (`selectionRotateBindings`).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'applyOps', 'poseDescriptor', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const begun = beginRotate(ctx, opts);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      const hold = session.scene.overrides.hold();\n      let frame: RotateFrame = { delta: 0, previews: new Map() };\n      session.lifecycle.start(session.gestureCtx.draggedIds);\n      return {\n        kind: 'rotate',\n        onMove(moveCtx: InvocationCtx): void {\n          frame = nextFrame(session, readers, moveCtx);\n          hold.set(frame.previews);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') committed = commitRotate(session, frame);\n            else runBehaviorCancel(session.behaviors, session.gestureCtx);\n          } finally {\n            closeGesture({ hold, previews: frame.previews, behaviors: session.behaviors, ctx: session.gestureCtx, lifecycle: session.lifecycle }, committed);\n          }\n        },\n        previewIds: () => frame.previews.keys(),\n        previewPose: (id: string) => frame.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;AAkBA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CAIP,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAY;EAAkB;CAAM;CACrE,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAQC,EAAYC,GAAKC,CAAI;GACnC,IAAI,CAACH,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACvBI,IAAOC,EAAQ,MAAM,UAAU,KAAK,GACtCC,IAAqB;IAAE,OAAO;IAAG,0BAAU,IAAI,IAAI;GAAE;GAEzD,OADAD,EAAQ,UAAU,MAAMA,EAAQ,WAAW,UAAU,GAC9C;IACL,MAAM;IACN,OAAO,GAA8B;KAEnC,AADA,IAAQE,EAAUF,GAASG,GAASC,CAAO,GAC3CL,EAAK,IAAIE,EAAM,QAAQ;IACzB;IACA,MAAM,GAAwB,GAAmC;KAC/D,IAAII,IAAY;KAChB,IAAI;MACF,AAAIC,MAAW,WAAU,IAAYC,EAAaP,GAASC,CAAK,IAC3DO,EAAkBR,EAAQ,WAAWA,EAAQ,UAAU;KAC9D,UAAU;MACR,EAAa;OAAE;OAAM,UAAUC,EAAM;OAAU,WAAWD,EAAQ;OAAW,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGK,CAAS;KACjJ;IACF;IACA,kBAAkBJ,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIQ,CAAY,KAAK;GACnE;EACF;CACF;CACA,eAAe;AACjB,GAAGC,CAAc"}

package/dist/interactions/actions/rotate/behaviors/index.js

@@ -0,0 +1,7 @@
+import { DEFAULT_ROTATION_SNAP_STEP as e, snapRotationWithModifier as t } from "./snapRotation.js";
+//#region src/interactions/actions/rotate/behaviors/index.ts
+var n = Object.freeze([t()]);
+//#endregion
+export { n as DEFAULT_ROTATE_BEHAVIORS, e as DEFAULT_ROTATION_SNAP_STEP, t as snapRotationWithModifier };
+
+//# sourceMappingURL=index.js.map

package/dist/interactions/actions/rotate/behaviors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["DEFAULT_ROTATE_BEHAVIORS","snapRotationWithModifier","DEFAULT_ROTATION_SNAP_STEP"],"sources":["../../../../../src/interactions/actions/rotate/behaviors/index.ts"],"sourcesContent":["export { DEFAULT_ROTATION_SNAP_STEP, snapRotationWithModifier } from './snapRotation';\n\nimport type { RotateBehavior } from '../../../gestures/types';\nimport { snapRotationWithModifier } from './snapRotation';\n\n/** The kit's standard rotate behaviors, applied when a rotate binding names\n *  none: shift-drag snaps the angle to 15 degree steps. An explicit\n *  `behaviors: []` opts out. Stateless, so one shared frozen instance is safe\n *  across every gesture. */\nexport const DEFAULT_ROTATE_BEHAVIORS: readonly RotateBehavior<unknown>[] =\n  Object.freeze([snapRotationWithModifier<unknown>()]);\n"],"mappings":";;AASA,IAAaA,IACX,OAAO,OAAO,CAACC,EAAkC,CAAC,CAAC"}

package/dist/interactions/actions/rotate/behaviors/snapRotation.js

@@ -0,0 +1,12 @@
+//#region src/interactions/actions/rotate/behaviors/snapRotation.ts
+var e = Math.PI / 12;
+function t(t = {}) {
+	let { key: n = "shift", step: r = e } = t;
+	return { onMove(e, { rotation: t }) {
+		if ((n === null || e.modifiers[n]) && r > 0) return { rotation: Math.round(t / r) * r };
+	} };
+}
+//#endregion
+export { e as DEFAULT_ROTATION_SNAP_STEP, t as snapRotationWithModifier };
+
+//# sourceMappingURL=snapRotation.js.map

package/dist/interactions/actions/rotate/behaviors/snapRotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapRotation.js","names":["DEFAULT_ROTATION_SNAP_STEP","snapRotationWithModifier","opts","key","ctx","step","rotation"],"sources":["../../../../../src/interactions/actions/rotate/behaviors/snapRotation.ts"],"sourcesContent":["import type { ModifierState, RotateBehavior } from '../../../gestures/types';\n\n/** The step {@link snapRotationWithModifier} snaps to by default: 15 degrees. */\nexport const DEFAULT_ROTATION_SNAP_STEP = Math.PI / 12;\n\n/**\n * Angle snap: rotate with `key` (default `'shift'`) held to land on a multiple\n * of `step` radians. What snaps is the angle the first rotated node ends at,\n * so a node already at 10 degrees goes to 15, 30, 45; the rest of a\n * multi-selection turns by the same amount. `key: null` snaps every move.\n */\nexport function snapRotationWithModifier<TPose>(opts: {\n  key?: keyof ModifierState | null;\n  step?: number;\n} = {}): RotateBehavior<TPose> {\n  const { key = 'shift', step = DEFAULT_ROTATION_SNAP_STEP } = opts;\n  return {\n    onMove(ctx, { rotation }) {\n      if (key !== null && !ctx.modifiers[key]) return;\n      if (!(step > 0)) return;\n      return { rotation: Math.round(rotation / step) * step };\n    },\n  };\n}\n"],"mappings":";AAGA,IAAaA,IAA6B,KAAK,KAAK;AAQpD,SAAgBC,EAAgC,IAG5C,CAAC,GAA0B;CAC7B,IAAM,EAAE,SAAM,SAAS,UAAOD,MAA+BE;CAC7D,OAAO,EACL,OAAO,GAAK,EAAE,eAAY;EACxB,KAAIC,MAAQ,QAASC,EAAI,UAAUD,OAC7BE,IAAO,GACb,OAAO,EAAE,UAAU,KAAK,MAAMC,IAAWD,CAAI,IAAIA,EAAK;CACxD,EACF;AACF"}

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

@@ -0,0 +1,40 @@
+import { commitGestureOps as e, reduceBehaviorEnd as t } from "../gestureLifecycle.js";
+import { createTransformOp as n } from "../../../core/ops/transform.js";
+import { defaultCommitAdapter as r } from "../defaultCommitAdapter.js";
+import { syncGestureCurrent as i } from "./frame.js";
+//#region src/interactions/actions/rotate/commit.ts
+function a(e, t, r, i) {
+	let a = [];
+	for (let o of e) {
+		let e = r.get(o);
+		if (e === void 0) continue;
+		let s = t.get(o);
+		s !== void 0 && a.push(n({
+			id: o,
+			from: s,
+			to: e,
+			label: i
+		}));
+	}
+	return a;
+}
+function o(n, o) {
+	let { lifecycle: s } = n, c = {
+		scene: n.scene,
+		applyOps: n.applyOps,
+		adapter: r(n.scene, n.selectionMethods)
+	};
+	if (n.behaviors.length > 0) {
+		i(n.gestureCtx, n.turn, o.delta);
+		let r = t(n.behaviors, n.gestureCtx);
+		if (r === null) return !1;
+		if (r !== void 0) return e(c, s, r);
+	}
+	if (o.delta === 0) return !1;
+	let l = a(n.ids, n.originPoses, o.previews, s.label);
+	return l.length !== 0 && e(c, s, l);
+}
+//#endregion
+export { o as commitRotate, a as rotateOps };
+
+//# sourceMappingURL=commit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":["rotateOps","ops","id","ids","next","previews","from","originPoses","createTransformOp","commitRotate","session","target","defaultCommitAdapter","frame","reduceBehaviorEnd","commitGestureOps","lifecycle"],"sources":["../../../../src/interactions/actions/rotate/commit.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { NodeId } from 'core/scene/types';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { commitGestureOps, reduceBehaviorEnd } from '../gestureLifecycle';\nimport { syncGestureCurrent } from './frame';\nimport type { RotateFrame, RotateSession } from './session';\n\n/** One transform op per rotated node: `from` the pose stored at press, `to`\n *  its preview. */\nexport function rotateOps(\n  ids: readonly NodeId[],\n  originPoses: ReadonlyMap<NodeId, unknown>,\n  previews: ReadonlyMap<NodeId, unknown>,\n  label: string,\n): Op[] {\n  const ops: Op[] = [];\n  for (const id of ids) {\n    const next = previews.get(id);\n    if (next === undefined) continue;\n    const from = originPoses.get(id);\n    if (from === undefined) continue;\n    ops.push(createTransformOp<unknown>({ id: id as string, from, to: next, label }));\n  }\n  return ops;\n}\n\n/** Commit the drag as one batch, so one undo entry. Returns whether anything\n *  reached the document. */\nexport function commitRotate(session: RotateSession, frame: RotateFrame): boolean {\n  const { lifecycle } = session;\n  const target = {\n    scene: session.scene,\n    applyOps: session.applyOps,\n    adapter: defaultCommitAdapter(session.scene, session.selectionMethods),\n  };\n  if (session.behaviors.length > 0) {\n    syncGestureCurrent(session.gestureCtx, session.turn, frame.delta);\n    const r = reduceBehaviorEnd(session.behaviors, session.gestureCtx);\n    if (r === null) return false;\n    if (r !== undefined) return commitGestureOps(target, lifecycle, r);\n  }\n  if (frame.delta === 0) return false;\n  const ops = rotateOps(session.ids, session.originPoses, frame.previews, lifecycle.label);\n  if (ops.length === 0) return false;\n  return commitGestureOps(target, lifecycle, ops);\n}\n"],"mappings":";;;;;AAUA,SAAgBA,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAMC,GAAK;EACpB,IAAMC,IAAOC,EAAS,IAAIH,CAAE;EAC5B,IAAIE,MAAS,KAAA,GAAW;EACxB,IAAME,IAAOC,EAAY,IAAIL,CAAE;EAC/B,AAAII,MAAS,KAAA,KACbL,EAAI,KAAKO,EAA2B;GAAM;GAAc;GAAM,IAAIJ;GAAM;EAAM,CAAC,CAAC;CAClF;CACA,OAAOH;AACT;AAIA,SAAgBQ,EAAa,GAAwB,GAA6B;CAChF,IAAM,EAAE,iBAAcC,GAChBC,IAAS;EACb,OAAOD,EAAQ;EACf,UAAUA,EAAQ;EAClB,SAASE,EAAqBF,EAAQ,OAAOA,EAAQ,gBAAgB;CACvE;CACA,IAAIA,EAAQ,UAAU,SAAS,GAAG;EAChC,EAAmBA,EAAQ,YAAYA,EAAQ,MAAMG,EAAM,KAAK;EAChE,IAAM,IAAIC,EAAkBJ,EAAQ,WAAWA,EAAQ,UAAU;EACjE,IAAI,MAAM,MAAM,OAAO;EACvB,IAAI,MAAM,KAAA,GAAW,OAAOK,EAAiBJ,GAAQK,GAAW,CAAC;CACnE;CACA,IAAIH,EAAM,UAAU,GAAG,OAAO;CAC9B,IAAMZ,IAAMD,EAAUU,EAAQ,KAAKA,EAAQ,aAAaG,EAAM,UAAUG,EAAU,KAAK;CAEvF,OADIf,EAAI,WAAW,KACZc,EAAiBJ,GAAQK,GAAWf,CAAG;AAChD"}

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

@@ -0,0 +1,65 @@
+import { translatePoseViaDescriptor as e } from "../../../core/geometry/poseDescriptor.js";
+import { carryPose as t, planeOf as n } from "../planeInput.js";
+import { pointerStateOf as r } from "../pointerState.js";
+//#region src/interactions/actions/rotate/frame.ts
+function i(t, n, r, i) {
+	let a = t.withRotation(n.world, n.rotation + r);
+	if (!i) return a;
+	let o = Math.cos(r), s = Math.sin(r), c = n.center.x - i.x, l = n.center.y - i.y, u = i.x + c * o - l * s, d = i.y + c * s + l * o;
+	return e(a, u - n.center.x, d - n.center.y, t);
+}
+function a(e, t) {
+	let n = /* @__PURE__ */ new Map(), r = e.useUnionPivot ? e.pivot : null;
+	for (let [a, o] of e.origins) n.set(a, i(e.descriptorOf(a), o, t, r));
+	return n;
+}
+function o(e, t, n) {
+	let r = a(t, n);
+	for (let [t, n] of r) e.current.set(t, n);
+	return r;
+}
+function s(e, t, n, i, a, s) {
+	n.modifiers = { ...a.modifiers }, n.pointer = r(a.world, a), n.view = i.view(), n.plane = i.plane();
+	let c = e.origins.keys().next().value, l = e.origins.get(c)?.rotation ?? 0, u = s, d = {
+		pose: o(n, e, s).get(c),
+		rotation: l + s
+	};
+	for (let r of t) {
+		let t = r.onMove?.(n, d);
+		if (!t) continue;
+		if (t.rotation !== void 0) {
+			u = t.rotation - l, d = {
+				pose: o(n, e, u).get(c),
+				rotation: t.rotation
+			};
+			continue;
+		}
+		if (t.pose === void 0) continue;
+		let i = e.descriptorOf(c).getRotation?.(t.pose) ?? 0;
+		u = i - l, d = {
+			pose: t.pose,
+			rotation: i
+		};
+	}
+	return u;
+}
+function c(e, r) {
+	let i = /* @__PURE__ */ new Map();
+	if (r === 0) return i;
+	for (let [o, s] of a(e.turn, r)) {
+		let r = e.scene.get(o)?.layer, a = r === void 0 ? null : n(e.view, r);
+		i.set(o, e.poseFrame.local(o, t(e.turn.descriptorOf(o), s, a)));
+	}
+	return i;
+}
+function l(e, t, n) {
+	let { pivot: r } = e.turn, i = Math.atan2(n.world.y - r.y, n.world.x - r.x) - e.startPointerAngle, a = e.behaviors.length > 0 ? s(e.turn, e.behaviors, e.gestureCtx, t, n, i) : i;
+	return {
+		delta: a,
+		previews: c(e, a)
+	};
+}
+//#endregion
+export { l as nextFrame, o as syncGestureCurrent, a as turnedWorlds };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","names":["turnPose","rotated","d","origin","delta","pivot","cos","sin","ox","oy","nx","ny","translatePoseViaDescriptor","turnedWorlds","out","turn","id","syncGestureCurrent","turned","pose","shapeDelta","moveCtx","pointerStateOf","readers","primary","originRotation","raw","proposed","gctx","b","behaviors","r","rotation","storedPreviews","previews","session","layer","own","planeOf","carryPose","nextFrame"],"sources":["../../../../src/interactions/actions/rotate/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 { GestureContext, RotateBehavior, RotateProposed } from '../../gestures/types';\nimport { carryPose, planeOf } from '../planeInput';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from '../resize/geometry';\nimport type { RotateFrame, RotateSession, Turn, TurnOrigin } from './session';\n\n/** `origin` turned by `delta` radians, its center orbiting `pivot` when one\n *  is given. */\nfunction turnPose(\n  d: PoseDescriptor<unknown>,\n  origin: TurnOrigin,\n  delta: number,\n  pivot: { x: number; y: number } | null,\n): unknown {\n  const rotated = d.withRotation!(origin.world, origin.rotation + delta);\n  if (!pivot) return rotated;\n  const cos = Math.cos(delta);\n  const sin = Math.sin(delta);\n  const ox = origin.center.x - pivot.x;\n  const oy = origin.center.y - pivot.y;\n  const nx = pivot.x + ox * cos - oy * sin;\n  const ny = pivot.y + ox * sin + oy * cos;\n  return translatePoseViaDescriptor(rotated, nx - origin.center.x, ny - origin.center.y, d);\n}\n\n/** Each rotated node's world pose turned by `delta`. */\nexport function turnedWorlds(turn: Turn, delta: number): Map<NodeId, unknown> {\n  const out = new Map<NodeId, unknown>();\n  const pivot = turn.useUnionPivot ? turn.pivot : null;\n  for (const [id, origin] of turn.origins) {\n    out.set(id, turnPose(turn.descriptorOf(id), origin, delta, pivot));\n  }\n  return out;\n}\n\n/** Write the poses a turn by `delta` gives into `gctx.current`. */\nexport function syncGestureCurrent(\n  gctx: GestureContext<unknown>,\n  turn: Turn,\n  delta: number,\n): Map<NodeId, unknown> {\n  const turned = turnedWorlds(turn, delta);\n  for (const [id, pose] of turned) gctx.current.set(id as string, pose);\n  return turned;\n}\n\n/** The pointer's delta as the behaviors reshape it. */\nfunction shapeDelta(\n  turn: Turn,\n  behaviors: readonly RotateBehavior<unknown>[],\n  gctx: GestureContext<unknown>,\n  readers: GestureReaders,\n  moveCtx: InvocationCtx,\n  raw: number,\n): number {\n  gctx.modifiers = { ...moveCtx.modifiers };\n  gctx.pointer = pointerStateOf(moveCtx.world, moveCtx);\n  gctx.view = readers.view();\n  gctx.plane = readers.plane();\n  const primary = turn.origins.keys().next().value as NodeId;\n  const originRotation = turn.origins.get(primary)?.rotation ?? 0;\n  let delta = raw;\n  let proposed: RotateProposed<unknown> = {\n    pose: syncGestureCurrent(gctx, turn, raw).get(primary),\n    rotation: originRotation + raw,\n  };\n  for (const b of behaviors) {\n    const r = b.onMove?.(gctx, proposed);\n    if (!r) continue;\n    if (r.rotation !== undefined) {\n      delta = r.rotation - originRotation;\n      proposed = { pose: syncGestureCurrent(gctx, turn, delta).get(primary), rotation: r.rotation };\n      continue;\n    }\n    if (r.pose === undefined) continue;\n    const rotation = turn.descriptorOf(primary).getRotation?.(r.pose) ?? 0;\n    delta = rotation - originRotation;\n    proposed = { pose: r.pose, rotation };\n  }\n  return delta;\n}\n\n/** Every rotated id's stored pose under a turn by `delta`; none at zero. */\nfunction storedPreviews(\n  session: Pick<RotateSession, 'scene' | 'turn' | 'poseFrame' | 'view'>,\n  delta: number,\n): Map<NodeId, unknown> {\n  const previews = new Map<NodeId, unknown>();\n  if (delta === 0) return previews;\n  for (const [id, turned] of turnedWorlds(session.turn, delta)) {\n    const layer = session.scene.get(id)?.layer;\n    const own = layer === undefined ? null : planeOf(session.view, layer);\n    previews.set(id, session.poseFrame.local(id, carryPose(session.turn.descriptorOf(id), turned, own)));\n  }\n  return previews;\n}\n\n/** One move's delta and previews: the pointer's angle since press as the\n *  behaviors shaped it, and every rotated id's stored pose under it. */\nexport function nextFrame(session: RotateSession, readers: GestureReaders, moveCtx: InvocationCtx): RotateFrame {\n  const { pivot } = session.turn;\n  const pointerAngle = Math.atan2(moveCtx.world.y - pivot.y, moveCtx.world.x - pivot.x);\n  const raw = pointerAngle - session.startPointerAngle;\n  const delta = session.behaviors.length > 0\n    ? shapeDelta(session.turn, session.behaviors, session.gestureCtx, readers, moveCtx, raw)\n    : raw;\n  return { delta, previews: storedPreviews(session, delta) };\n}\n"],"mappings":"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"}