@weasel-js/core 1.10.0 → 1.11.0

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

@@ -1 +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"}
+{"version":3,"file":"commit.js","names":[],"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,SAAgB,UACd,KACA,aACA,UACA,OACM;CACN,MAAM,MAAY,CAAC;CACnB,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,OAAO,SAAS,IAAI,EAAE;EAC5B,IAAI,SAAS,QAAW;EACxB,MAAM,OAAO,YAAY,IAAI,EAAE;EAC/B,IAAI,SAAS,QAAW;EACxB,IAAI,KAAK,kBAA2B;GAAM;GAAc;GAAM,IAAI;GAAM;EAAM,CAAC,CAAC;CAClF;CACA,OAAO;AACT;;;AAIA,SAAgB,aAAa,SAAwB,OAA6B;CAChF,MAAM,EAAE,cAAc;CACtB,MAAM,SAAS;EACb,OAAO,QAAQ;EACf,UAAU,QAAQ;EAClB,SAAS,qBAAqB,QAAQ,OAAO,QAAQ,gBAAgB;CACvE;CACA,IAAI,QAAQ,UAAU,SAAS,GAAG;EAChC,mBAAmB,QAAQ,YAAY,QAAQ,MAAM,MAAM,KAAK;EAChE,MAAM,IAAI,kBAAkB,QAAQ,WAAW,QAAQ,UAAU;EACjE,IAAI,MAAM,MAAM,OAAO;EACvB,IAAI,MAAM,QAAW,OAAO,iBAAiB,QAAQ,WAAW,CAAC;CACnE;CACA,IAAI,MAAM,UAAU,GAAG,OAAO;CAC9B,MAAM,MAAM,UAAU,QAAQ,KAAK,QAAQ,aAAa,MAAM,UAAU,UAAU,KAAK;CACvF,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,OAAO,iBAAiB,QAAQ,WAAW,GAAG;AAChD"}

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

@@ -1,65 +1,93 @@
-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";
+import { translatePoseViaDescriptor } from "../../../core/geometry/poseDescriptor.js";
+import { carryPose, planeOf } from "../planeInput.js";
+import { pointerStateOf } from "../pointerState.js";
+import { snapMods } from "../../../features/snap/roles.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);
+/** `origin` turned by `delta` radians, its center orbiting `pivot` when one
+*  is given. */
+function turnPose(d, origin, delta, pivot) {
+	const rotated = d.withRotation(origin.world, origin.rotation + delta);
+	if (!pivot) return rotated;
+	const cos = Math.cos(delta);
+	const sin = Math.sin(delta);
+	const ox = origin.center.x - pivot.x;
+	const oy = origin.center.y - pivot.y;
+	const nx = pivot.x + ox * cos - oy * sin;
+	const ny = pivot.y + ox * sin + oy * cos;
+	return translatePoseViaDescriptor(rotated, nx - origin.center.x, ny - origin.center.y, d);
 }
-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;
+/** Each rotated node's world pose turned by `delta`. */
+function turnedWorlds(turn, delta) {
+	const out = /* @__PURE__ */ new Map();
+	const pivot = turn.useUnionPivot ? turn.pivot : null;
+	for (const [id, origin] of turn.origins) out.set(id, turnPose(turn.descriptorOf(id), origin, delta, pivot));
+	return out;
 }
-function o(e, t, n) {
-	let r = a(t, n);
-	for (let [t, n] of r) e.current.set(t, n);
-	return r;
+/** Write the poses a turn by `delta` gives into `gctx.current`. */
+function syncGestureCurrent(gctx, turn, delta) {
+	const turned = turnedWorlds(turn, delta);
+	for (const [id, pose] of turned) gctx.current.set(id, pose);
+	return turned;
 }
-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
+/** The pointer's delta as the behaviors reshape it. */
+function shapeDelta(turn, behaviors, gctx, readers, moveCtx, raw) {
+	gctx.modifiers = { ...moveCtx.modifiers };
+	gctx.pointer = pointerStateOf(moveCtx.world, moveCtx);
+	gctx.view = readers.view();
+	gctx.plane = readers.plane();
+	const primary = turn.origins.keys().next().value;
+	const originRotation = turn.origins.get(primary)?.rotation ?? 0;
+	let delta = raw;
+	let proposed = {
+		pose: syncGestureCurrent(gctx, turn, raw).get(primary),
+		rotation: originRotation + raw
 	};
-	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
+	for (const b of behaviors) {
+		const r = b.onMove?.(gctx, proposed);
+		if (!r) continue;
+		if (r.rotation !== void 0) {
+			delta = r.rotation - originRotation;
+			proposed = {
+				pose: syncGestureCurrent(gctx, turn, delta).get(primary),
+				rotation: r.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
+		if (r.pose === void 0) continue;
+		const rotation = turn.descriptorOf(primary).getRotation?.(r.pose) ?? 0;
+		delta = rotation - originRotation;
+		proposed = {
+			pose: r.pose,
+			rotation
 		};
 	}
-	return u;
+	return delta;
 }
-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)));
+/** Every rotated id's stored pose under a turn by `delta`; none at zero. */
+function storedPreviews(session, delta) {
+	const previews = /* @__PURE__ */ new Map();
+	if (delta === 0) return previews;
+	for (const [id, turned] of turnedWorlds(session.turn, delta)) {
+		const layer = session.scene.get(id)?.layer;
+		const own = layer === void 0 ? null : planeOf(session.view, layer);
+		previews.set(id, session.poseFrame.local(id, carryPose(session.turn.descriptorOf(id), turned, own)));
 	}
-	return i;
+	return previews;
 }
-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;
+/** One move's delta and previews: the pointer's angle since press as the
+*  snap session and then the behaviors shaped it, and every rotated id's stored pose under it. */
+function nextFrame(session, readers, moveCtx) {
+	const { pivot } = session.turn;
+	const raw = Math.atan2(moveCtx.world.y - pivot.y, moveCtx.world.x - pivot.x) - session.startPointerAngle;
+	const snapped = session.snap.angle(session.theta0 + raw, snapMods(moveCtx)).theta - session.theta0;
+	const delta = session.behaviors.length > 0 ? shapeDelta(session.turn, session.behaviors, session.gestureCtx, readers, moveCtx, snapped) : snapped;
 	return {
-		delta: a,
-		previews: c(e, a)
+		delta,
+		previews: storedPreviews(session, delta)
 	};
 }
-//#endregion
-export { l as nextFrame, o as syncGestureCurrent, a as turnedWorlds };
 
+//#endregion
+export { nextFrame, storedPreviews, syncGestureCurrent, turnedWorlds };
 //# sourceMappingURL=frame.js.map

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

@@ -1 +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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"}
+{"version":3,"file":"frame.js","names":[],"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 { snapMods } from 'features/snap/roles';\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. */\nexport function 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 *  snap session and then the 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 snapped = session.snap.angle(session.theta0 + raw, snapMods(moveCtx)).theta - session.theta0;\n  const delta = session.behaviors.length > 0\n    ? shapeDelta(session.turn, session.behaviors, session.gestureCtx, readers, moveCtx, snapped)\n    : snapped;\n  return { delta, previews: storedPreviews(session, delta) };\n}\n"],"mappings":"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"}

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

@@ -1,46 +1,58 @@
 //#region src/interactions/actions/rotate/geometry.ts
-function e(e) {
+/** AABB center of an unrotated rect — the canonical rotation pivot. */
+function aabbCenter(bounds) {
 	return {
-		x: e.x + e.width / 2,
-		y: e.y + e.height / 2
+		x: bounds.x + bounds.width / 2,
+		y: bounds.y + bounds.height / 2
 	};
 }
-function t(e, t, n, r, i) {
-	let a = Math.cos(i), o = Math.sin(i), s = e - n, c = t - r;
+/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */
+function rotatePoint(px, py, cx, cy, angle) {
+	const c = Math.cos(angle);
+	const s = Math.sin(angle);
+	const dx = px - cx;
+	const dy = py - cy;
 	return {
-		x: n + s * a - c * o,
-		y: r + s * o + c * a
+		x: cx + dx * c - dy * s,
+		y: cy + dx * s + dy * c
 	};
 }
-function n(e) {
+/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */
+function rectCorners(bounds) {
 	return [
 		{
-			x: e.x,
-			y: e.y
+			x: bounds.x,
+			y: bounds.y
 		},
 		{
-			x: e.x + e.width,
-			y: e.y
+			x: bounds.x + bounds.width,
+			y: bounds.y
 		},
 		{
-			x: e.x + e.width,
-			y: e.y + e.height
+			x: bounds.x + bounds.width,
+			y: bounds.y + bounds.height
 		},
 		{
-			x: e.x,
-			y: e.y + e.height
+			x: bounds.x,
+			y: bounds.y + bounds.height
 		}
 	];
 }
-function r(r) {
-	let i = e(r);
-	return n(r).map((e) => t(e.x, e.y, i.x, i.y, r.rotation));
+/** Four corners of a rotated rect (rotation around AABB center), in
+*  TL/TR/BR/BL order. Useful for selection-overlay rendering. */
+function rotatedRectCorners(pose) {
+	const c = aabbCenter(pose);
+	return rectCorners(pose).map((p) => rotatePoint(p.x, p.y, c.x, c.y, pose.rotation));
 }
-function i(n, r, i) {
-	let a = e(n), o = t(r, i, a.x, a.y, -n.rotation);
-	return o.x >= n.x && o.x <= n.x + n.width && o.y >= n.y && o.y <= n.y + n.height;
+/** Hit-test a world point against a rotated rect (rotation around AABB
+*  center). Standard pattern: invert the rotation and AABB-test in the
+*  rect's local frame. */
+function pointInRotatedRect(pose, worldX, worldY) {
+	const c = aabbCenter(pose);
+	const local = rotatePoint(worldX, worldY, c.x, c.y, -pose.rotation);
+	return local.x >= pose.x && local.x <= pose.x + pose.width && local.y >= pose.y && local.y <= pose.y + pose.height;
 }
-//#endregion
-export { e as aabbCenter, i as pointInRotatedRect, n as rectCorners, t as rotatePoint, r as rotatedRectCorners };
 
+//#endregion
+export { aabbCenter, pointInRotatedRect, rectCorners, rotatePoint, rotatedRectCorners };
 //# sourceMappingURL=geometry.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.js","names":["aabbCenter","bounds","rotatePoint","c","angle","s","dx","px","cx","dy","py","cy","rectCorners","rotatedRectCorners","pose","p","pointInRotatedRect","local","worldX","worldY"],"sources":["../../../../src/interactions/actions/rotate/geometry.ts"],"sourcesContent":["import type { RotatedPose } from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** AABB center of an unrotated rect — the canonical rotation pivot. */\nexport function aabbCenter(bounds: Bounds): { x: number; y: number } {\n  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n}\n\n/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */\nexport function rotatePoint(\n  px: number,\n  py: number,\n  cx: number,\n  cy: number,\n  angle: number,\n): { x: number; y: number } {\n  const c = Math.cos(angle);\n  const s = Math.sin(angle);\n  const dx = px - cx;\n  const dy = py - cy;\n  return { x: cx + dx * c - dy * s, y: cy + dx * s + dy * c };\n}\n\n/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */\nexport function rectCorners(bounds: Bounds): { x: number; y: number }[] {\n  return [\n    { x: bounds.x, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y + bounds.height },\n    { x: bounds.x, y: bounds.y + bounds.height },\n  ];\n}\n\n/** Four corners of a rotated rect (rotation around AABB center), in\n *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */\nexport function rotatedRectCorners(pose: RotatedPose): { x: number; y: number }[] {\n  const c = aabbCenter(pose);\n  return rectCorners(pose).map((p) => rotatePoint(p.x, p.y, c.x, c.y, pose.rotation));\n}\n\n/** Hit-test a world point against a rotated rect (rotation around AABB\n *  center). Standard pattern: invert the rotation and AABB-test in the\n *  rect's local frame. */\nexport function pointInRotatedRect(\n  pose: RotatedPose,\n  worldX: number,\n  worldY: number,\n): boolean {\n  const c = aabbCenter(pose);\n  const local = rotatePoint(worldX, worldY, c.x, c.y, -pose.rotation);\n  return (\n    local.x >= pose.x &&\n    local.x <= pose.x + pose.width &&\n    local.y >= pose.y &&\n    local.y <= pose.y + pose.height\n  );\n}\n"],"mappings":";AAIA,SAAgBA,EAAW,GAA0C;CACnE,OAAO;EAAE,GAAGC,EAAO,IAAIA,EAAO,QAAQ;EAAG,GAAGA,EAAO,IAAIA,EAAO,SAAS;CAAE;AAC3E;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GAC0B;CAC1B,IAAMC,IAAI,KAAK,IAAIC,CAAK,GAClBC,IAAI,KAAK,IAAID,CAAK,GAClBE,IAAKC,IAAKC,GACVC,IAAKC,IAAKC;CAChB,OAAO;EAAE,GAAGH,IAAKF,IAAKH,IAAIM,IAAKJ;EAAG,GAAGM,IAAKL,IAAKD,IAAII,IAAKN;CAAE;AAC5D;AAGA,SAAgBS,EAAY,GAA4C;CACtE,OAAO;EACL;GAAE,GAAGX,EAAO;GAAG,GAAGA,EAAO;EAAE;EAC3B;GAAE,GAAGA,EAAO,IAAIA,EAAO;GAAO,GAAGA,EAAO;EAAE;EAC1C;GAAE,GAAGA,EAAO,IAAIA,EAAO;GAAO,GAAGA,EAAO,IAAIA,EAAO;EAAO;EAC1D;GAAE,GAAGA,EAAO;GAAG,GAAGA,EAAO,IAAIA,EAAO;EAAO;CAC7C;AACF;AAIA,SAAgBY,EAAmB,GAA+C;CAChF,IAAMV,IAAIH,EAAWc,CAAI;CACzB,OAAOF,EAAYE,CAAI,CAAC,CAAC,KAAK,MAAMZ,EAAYa,EAAE,GAAGA,EAAE,GAAGZ,EAAE,GAAGA,EAAE,GAAGW,EAAK,QAAQ,CAAC;AACpF;AAKA,SAAgBE,EACd,GACA,GACA,GACS;CACT,IAAMb,IAAIH,EAAWc,CAAI,GACnBG,IAAQf,EAAYgB,GAAQC,GAAQhB,EAAE,GAAGA,EAAE,GAAG,CAACW,EAAK,QAAQ;CAClE,OACEG,EAAM,KAAKH,EAAK,KAChBG,EAAM,KAAKH,EAAK,IAAIA,EAAK,SACzBG,EAAM,KAAKH,EAAK,KAChBG,EAAM,KAAKH,EAAK,IAAIA,EAAK;AAE7B"}
+{"version":3,"file":"geometry.js","names":[],"sources":["../../../../src/interactions/actions/rotate/geometry.ts"],"sourcesContent":["import type { RotatedPose } from 'core/geometry/poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** AABB center of an unrotated rect — the canonical rotation pivot. */\nexport function aabbCenter(bounds: Bounds): { x: number; y: number } {\n  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n}\n\n/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */\nexport function rotatePoint(\n  px: number,\n  py: number,\n  cx: number,\n  cy: number,\n  angle: number,\n): { x: number; y: number } {\n  const c = Math.cos(angle);\n  const s = Math.sin(angle);\n  const dx = px - cx;\n  const dy = py - cy;\n  return { x: cx + dx * c - dy * s, y: cy + dx * s + dy * c };\n}\n\n/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */\nexport function rectCorners(bounds: Bounds): { x: number; y: number }[] {\n  return [\n    { x: bounds.x, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y },\n    { x: bounds.x + bounds.width, y: bounds.y + bounds.height },\n    { x: bounds.x, y: bounds.y + bounds.height },\n  ];\n}\n\n/** Four corners of a rotated rect (rotation around AABB center), in\n *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */\nexport function rotatedRectCorners(pose: RotatedPose): { x: number; y: number }[] {\n  const c = aabbCenter(pose);\n  return rectCorners(pose).map((p) => rotatePoint(p.x, p.y, c.x, c.y, pose.rotation));\n}\n\n/** Hit-test a world point against a rotated rect (rotation around AABB\n *  center). Standard pattern: invert the rotation and AABB-test in the\n *  rect's local frame. */\nexport function pointInRotatedRect(\n  pose: RotatedPose,\n  worldX: number,\n  worldY: number,\n): boolean {\n  const c = aabbCenter(pose);\n  const local = rotatePoint(worldX, worldY, c.x, c.y, -pose.rotation);\n  return (\n    local.x >= pose.x &&\n    local.x <= pose.x + pose.width &&\n    local.y >= pose.y &&\n    local.y <= pose.y + pose.height\n  );\n}\n"],"mappings":";;AAIA,SAAgB,WAAW,QAA0C;CACnE,OAAO;EAAE,GAAG,OAAO,IAAI,OAAO,QAAQ;EAAG,GAAG,OAAO,IAAI,OAAO,SAAS;CAAE;AAC3E;;AAGA,SAAgB,YACd,IACA,IACA,IACA,IACA,OAC0B;CAC1B,MAAM,IAAI,KAAK,IAAI,KAAK;CACxB,MAAM,IAAI,KAAK,IAAI,KAAK;CACxB,MAAM,KAAK,KAAK;CAChB,MAAM,KAAK,KAAK;CAChB,OAAO;EAAE,GAAG,KAAK,KAAK,IAAI,KAAK;EAAG,GAAG,KAAK,KAAK,IAAI,KAAK;CAAE;AAC5D;;AAGA,SAAgB,YAAY,QAA4C;CACtE,OAAO;EACL;GAAE,GAAG,OAAO;GAAG,GAAG,OAAO;EAAE;EAC3B;GAAE,GAAG,OAAO,IAAI,OAAO;GAAO,GAAG,OAAO;EAAE;EAC1C;GAAE,GAAG,OAAO,IAAI,OAAO;GAAO,GAAG,OAAO,IAAI,OAAO;EAAO;EAC1D;GAAE,GAAG,OAAO;GAAG,GAAG,OAAO,IAAI,OAAO;EAAO;CAC7C;AACF;;;AAIA,SAAgB,mBAAmB,MAA+C;CAChF,MAAM,IAAI,WAAW,IAAI;CACzB,OAAO,YAAY,IAAI,CAAC,CAAC,KAAK,MAAM,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,QAAQ,CAAC;AACpF;;;;AAKA,SAAgB,mBACd,MACA,QACA,QACS;CACT,MAAM,IAAI,WAAW,IAAI;CACzB,MAAM,QAAQ,YAAY,QAAQ,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,QAAQ;CAClE,OACE,MAAM,KAAK,KAAK,KAChB,MAAM,KAAK,KAAK,IAAI,KAAK,SACzB,MAAM,KAAK,KAAK,KAChB,MAAM,KAAK,KAAK,IAAI,KAAK;AAE7B"}

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

@@ -1,27 +1,40 @@
-import { ROTATION_HANDLE_BASE_PX as e } from "../../../core/device/targets.js";
-import { localToWorld as t, normalToWorld as n, targetTransformOf as r } from "../../../core/geometry/targetFrame.js";
-import { standoff as i } from "@weasel-js/geom";
+import { ROTATION_HANDLE_BASE_PX } from "../../../core/device/targets.js";
+import { localToWorld, normalToWorld, targetTransformOf } from "../../../core/geometry/targetFrame.js";
+import { standoff } from "@weasel-js/geom";
+
 //#region src/interactions/actions/rotate/handle.ts
-var a = e;
-function o(e, o = a, c = s) {
-	let l = r(e), u = t(l, e.x + e.width / 2, e.y), d = i(u, n(l, {
+/** Default world-space distance from the rect's top edge to the rotation
+*  handle's center. Matches the demo's visual default; consumers can
+*  override per-call. Unscaled — kit-internal use sites multiply by
+*  `DeviceProfile.targetScale`. */
+var DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;
+/** Rotation handle for a box as its frame draws it: `distance` pixels off the
+*  top edge's midpoint, along that edge's outward normal as it lands on a
+*  screen whose per-axis zoom is `scale`. With no `scale`, a pixel is a world
+*  unit. */
+function rotationHandle(pose, distance = DEFAULT_ROTATION_HANDLE_DISTANCE, scale = UNIT_SCALE) {
+	const xf = targetTransformOf(pose);
+	const top = localToWorld(xf, pose.x + pose.width / 2, pose.y);
+	const p = standoff(top, normalToWorld(xf, {
 		x: 0,
 		y: -1
-	}), o, c);
+	}), distance, scale);
 	return {
-		cx: d.x,
-		cy: d.y,
-		angle: Math.atan2(d.nx, -d.ny)
+		cx: p.x,
+		cy: p.y,
+		angle: Math.atan2(p.nx, -p.ny)
 	};
 }
-var s = {
+var UNIT_SCALE = {
 	x: 1,
 	y: 1
 };
-function c(e, t, n, r) {
-	return Math.abs(t - e.cx) <= r && Math.abs(n - e.cy) <= r;
+/** Square hit-test: returns true if `(px, py)` is within `radius` of the
+*  handle's center on both axes. Mirrors `hitCornerHandle`. */
+function hitRotationHandle(handle, px, py, radius) {
+	return Math.abs(px - handle.cx) <= radius && Math.abs(py - handle.cy) <= radius;
 }
-//#endregion
-export { a as DEFAULT_ROTATION_HANDLE_DISTANCE, c as hitRotationHandle, o as rotationHandle };
 
+//#endregion
+export { DEFAULT_ROTATION_HANDLE_DISTANCE, hitRotationHandle, rotationHandle };
 //# sourceMappingURL=handle.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"handle.js","names":["DEFAULT_ROTATION_HANDLE_DISTANCE","ROTATION_HANDLE_BASE_PX","rotationHandle","UNIT_SCALE","xf","targetTransformOf","pose","top","localToWorld","p","standoff","normalToWorld","distance","scale","hitRotationHandle","px","handle","radius","py"],"sources":["../../../../src/interactions/actions/rotate/handle.ts"],"sourcesContent":["import { localToWorld, normalToWorld, targetTransformOf } from 'core/geometry/targetFrame';\nimport { ROTATION_HANDLE_BASE_PX } from 'core/device/targets';\nimport { standoff, type PoseLinear, type Scale2 } from '@weasel-js/geom';\n\n/** Default world-space distance from the rect's top edge to the rotation\n *  handle's center. Matches the demo's visual default; consumers can\n *  override per-call. Unscaled — kit-internal use sites multiply by\n *  `DeviceProfile.targetScale`. */\nexport const DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;\n\n/** Rotation handle position in world coords. */\nexport interface RotationHandle {\n  /** Handle center in world coords. */\n  cx: number;\n  cy: number;\n  /** How far the handle is turned on screen, radians: the angle from screen\n   *  up to the top edge's outward normal as it lands there. Equals the pose\n   *  rotation under uniform zoom. */\n  angle: number;\n}\n\n/** Rotation handle for a box as its frame draws it: `distance` pixels off the\n *  top edge's midpoint, along that edge's outward normal as it lands on a\n *  screen whose per-axis zoom is `scale`. With no `scale`, a pixel is a world\n *  unit. */\nexport function rotationHandle(\n  pose: { x: number; y: number; width: number; height: number; rotation?: number; transform?: PoseLinear },\n  distance: number = DEFAULT_ROTATION_HANDLE_DISTANCE,\n  scale: Scale2 = UNIT_SCALE,\n): RotationHandle {\n  const xf = targetTransformOf(pose);\n  const top = localToWorld(xf, pose.x + pose.width / 2, pose.y);\n  const p = standoff(top, normalToWorld(xf, { x: 0, y: -1 }), distance, scale);\n  return { cx: p.x, cy: p.y, angle: Math.atan2(p.nx, -p.ny) };\n}\n\nconst UNIT_SCALE: Scale2 = { x: 1, y: 1 };\n\n/** Square hit-test: returns true if `(px, py)` is within `radius` of the\n *  handle's center on both axes. Mirrors `hitCornerHandle`. */\nexport function hitRotationHandle(\n  handle: Pick<RotationHandle, 'cx' | 'cy'>,\n  px: number,\n  py: number,\n  radius: number,\n): boolean {\n  return Math.abs(px - handle.cx) <= radius && Math.abs(py - handle.cy) <= radius;\n}\n"],"mappings":";;;;AAQA,IAAaA,IAAmCC;AAiBhD,SAAgBC,EACd,GACA,IAAmBF,GACnB,IAAgBG,GACA;CAChB,IAAMC,IAAKC,EAAkBC,CAAI,GAC3BC,IAAMC,EAAaJ,GAAIE,EAAK,IAAIA,EAAK,QAAQ,GAAGA,EAAK,CAAC,GACtDG,IAAIC,EAASH,GAAKI,EAAcP,GAAI;EAAE,GAAG;EAAG,GAAG;CAAG,CAAC,GAAGQ,GAAUC,CAAK;CAC3E,OAAO;EAAE,IAAIJ,EAAE;EAAG,IAAIA,EAAE;EAAG,OAAO,KAAK,MAAMA,EAAE,IAAI,CAACA,EAAE,EAAE;CAAE;AAC5D;AAEA,IAAMN,IAAqB;CAAE,GAAG;CAAG,GAAG;AAAE;AAIxC,SAAgBW,EACd,GACA,GACA,GACA,GACS;CACT,OAAO,KAAK,IAAIC,IAAKC,EAAO,EAAE,KAAKC,KAAU,KAAK,IAAIC,IAAKF,EAAO,EAAE,KAAKC;AAC3E"}
+{"version":3,"file":"handle.js","names":[],"sources":["../../../../src/interactions/actions/rotate/handle.ts"],"sourcesContent":["import { localToWorld, normalToWorld, targetTransformOf } from 'core/geometry/targetFrame';\nimport { ROTATION_HANDLE_BASE_PX } from 'core/device/targets';\nimport { standoff, type PoseLinear, type Scale2 } from '@weasel-js/geom';\n\n/** Default world-space distance from the rect's top edge to the rotation\n *  handle's center. Matches the demo's visual default; consumers can\n *  override per-call. Unscaled — kit-internal use sites multiply by\n *  `DeviceProfile.targetScale`. */\nexport const DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;\n\n/** Rotation handle position in world coords. */\nexport interface RotationHandle {\n  /** Handle center in world coords. */\n  cx: number;\n  cy: number;\n  /** How far the handle is turned on screen, radians: the angle from screen\n   *  up to the top edge's outward normal as it lands there. Equals the pose\n   *  rotation under uniform zoom. */\n  angle: number;\n}\n\n/** Rotation handle for a box as its frame draws it: `distance` pixels off the\n *  top edge's midpoint, along that edge's outward normal as it lands on a\n *  screen whose per-axis zoom is `scale`. With no `scale`, a pixel is a world\n *  unit. */\nexport function rotationHandle(\n  pose: { x: number; y: number; width: number; height: number; rotation?: number; transform?: PoseLinear },\n  distance: number = DEFAULT_ROTATION_HANDLE_DISTANCE,\n  scale: Scale2 = UNIT_SCALE,\n): RotationHandle {\n  const xf = targetTransformOf(pose);\n  const top = localToWorld(xf, pose.x + pose.width / 2, pose.y);\n  const p = standoff(top, normalToWorld(xf, { x: 0, y: -1 }), distance, scale);\n  return { cx: p.x, cy: p.y, angle: Math.atan2(p.nx, -p.ny) };\n}\n\nconst UNIT_SCALE: Scale2 = { x: 1, y: 1 };\n\n/** Square hit-test: returns true if `(px, py)` is within `radius` of the\n *  handle's center on both axes. Mirrors `hitCornerHandle`. */\nexport function hitRotationHandle(\n  handle: Pick<RotationHandle, 'cx' | 'cy'>,\n  px: number,\n  py: number,\n  radius: number,\n): boolean {\n  return Math.abs(px - handle.cx) <= radius && Math.abs(py - handle.cy) <= radius;\n}\n"],"mappings":";;;;;;;;;AAQA,IAAa,mCAAmC;;;;;AAiBhD,SAAgB,eACd,MACA,WAAmB,kCACnB,QAAgB,YACA;CAChB,MAAM,KAAK,kBAAkB,IAAI;CACjC,MAAM,MAAM,aAAa,IAAI,KAAK,IAAI,KAAK,QAAQ,GAAG,KAAK,CAAC;CAC5D,MAAM,IAAI,SAAS,KAAK,cAAc,IAAI;EAAE,GAAG;EAAG,GAAG;CAAG,CAAC,GAAG,UAAU,KAAK;CAC3E,OAAO;EAAE,IAAI,EAAE;EAAG,IAAI,EAAE;EAAG,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE;CAAE;AAC5D;AAEA,IAAM,aAAqB;CAAE,GAAG;CAAG,GAAG;AAAE;;;AAIxC,SAAgB,kBACd,QACA,IACA,IACA,QACS;CACT,OAAO,KAAK,IAAI,KAAK,OAAO,EAAE,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,EAAE,KAAK;AAC3E"}

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

@@ -0,0 +1,26 @@
+import { shapeSources } from "../selectionSubtree.js";
+import { storedPreviews } from "./frame.js";
+import { rotateOps } from "./commit.js";
+import { captureTurn } from "./session.js";
+
+//#region src/interactions/actions/rotate/replay.ts
+/** The ops that turn `selected` by `angle` radians the way a rotate drag
+*  would: about the selection's center, or each node about its own. */
+function rotateSelectionOps(scene, selected, deps, angle, pivot, label) {
+	const ids = shapeSources(scene, selected);
+	if (ids.length === 0 || angle === 0) return [];
+	const captured = captureTurn(scene, ids, deps, pivot);
+	if (!captured) return [];
+	const { turn, originPoses, poseFrame } = captured;
+	const previews = storedPreviews({
+		scene,
+		turn,
+		poseFrame,
+		view: deps.view
+	}, angle);
+	return rotateOps([...turn.origins.keys()], originPoses, previews, label);
+}
+
+//#endregion
+export { rotateSelectionOps };
+//# sourceMappingURL=replay.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","names":[],"sources":["../../../../src/interactions/actions/rotate/replay.ts"],"sourcesContent":["import type { ActionDeps } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { shapeSources } from '../selectionSubtree';\nimport { rotateOps } from './commit';\nimport { storedPreviews } from './frame';\nimport { captureTurn } from './session';\n\n/** The ops that turn `selected` by `angle` radians the way a rotate drag\n *  would: about the selection's center, or each node about its own. */\nexport function rotateSelectionOps(\n  scene: Scene<unknown, string, unknown>,\n  selected: readonly string[],\n  deps: Pick<ActionDeps, 'view' | 'poseDescriptor' | 'boundsIncludeStroke'>,\n  angle: number,\n  pivot: 'union' | 'each',\n  label: string,\n): Op[] {\n  const ids = shapeSources(scene, selected) as NodeId[];\n  if (ids.length === 0 || angle === 0) return [];\n  const captured = captureTurn(scene, ids, deps, pivot);\n  if (!captured) return [];\n  const { turn, originPoses, poseFrame } = captured;\n  const previews = storedPreviews({ scene, turn, poseFrame, view: deps.view }, angle);\n  return rotateOps([...turn.origins.keys()], originPoses, previews, label);\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,mBACd,OACA,UACA,MACA,OACA,OACA,OACM;CACN,MAAM,MAAM,aAAa,OAAO,QAAQ;CACxC,IAAI,IAAI,WAAW,KAAK,UAAU,GAAG,OAAO,CAAC;CAC7C,MAAM,WAAW,YAAY,OAAO,KAAK,MAAM,KAAK;CACpD,IAAI,CAAC,UAAU,OAAO,CAAC;CACvB,MAAM,EAAE,MAAM,aAAa,cAAc;CACzC,MAAM,WAAW,eAAe;EAAE;EAAO;EAAM;EAAW,MAAM,KAAK;CAAK,GAAG,KAAK;CAClF,OAAO,UAAU,CAAC,GAAG,KAAK,QAAQ,KAAK,CAAC,GAAG,aAAa,UAAU,KAAK;AACzE"}