@weasel-js/core 1.9.4 → 1.10.1

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,63 @@
+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(e, t, a, u) {
+	let d = r(u.poseDescriptor), f = u.resizePolicy, { constraints: p, pointSnap: m, expandIds: h } = l(f), g = n(e, d), _ = c(e, t, h);
+	if (!_) return null;
+	let { writeIds: v, isGroupPath: y } = _, b = i(e), x = u.view, S = s(e, v, g, b, x);
+	if (S.startPoses.size === 0) return null;
+	let { box: C, ruleOrigin: w } = o(S, v, y, a, d, g);
+	return {
+		place: {
+			scene: e,
+			writeIds: v,
+			sharedBox: y || v.length > 1,
+			box: C,
+			startPoses: S.startPoses,
+			startWorlds: S.startWorlds,
+			geometryOf: g,
+			poseFrame: b,
+			view: x
+		},
+		ruleOrigin: w,
+		policy: f,
+		constraints: p,
+		pointSnap: m
+	};
+}
+function d(n) {
+	let r = n.deps.selection, i = n.deps.scene;
+	if (!r || !i) return null;
+	let o = r.get();
+	if (o.length === 0) return null;
+	let s = n.drag?.affordance?.anchor;
+	if (!s) return null;
+	let c = u(i, o, s, n.deps);
+	if (!c) return null;
+	let { place: l, ruleOrigin: d, policy: f, constraints: p, pointSnap: m } = c, h = {
+		x: n.drag?.start.x ?? 0,
+		y: n.drag?.start.y ?? 0
+	}, g = t(n.deps), _ = a(n, o, d, h, g);
+	for (let e of p) e.onStart?.(_);
+	return {
+		session: {
+			...l,
+			startWorld: h,
+			constraints: p,
+			pointSnap: m,
+			gestureCtx: _,
+			applyOps: n.deps.applyOps,
+			geometryProjection: n.deps.geometryProjection,
+			selectionMethods: r.adapterMethods,
+			lifecycle: e(f, "Resize", p)
+		},
+		readers: g
+	};
+}
+//#endregion
+export { d as beginResize, u as captureResize };
+
+//# sourceMappingURL=session.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["captureResize","geometry","poseDescriptorOf","deps","policy","resolvePolicy","geometryOf","nodeDescriptors","scene","targets","captureTargets","ids","expandIds","poseFrame","scenePoseFrame","view","starts","captureStarts","writeIds","captureBox","isGroupPath","anchor","beginResize","selection","ctx","captured","startWorld","readers","gestureReaders","gestureCtx","buildGestureContext","ruleOrigin","b","constraints","place","readGestureLifecycle"],"sources":["../../../../src/interactions/actions/resize/session.ts"],"sourcesContent":["import type { PoseLinear } from '@weasel-js/geom';\nimport type { ActionDeps, 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  /** The box the move resized `ResizeBox.bounds` to; absent before the first move. */\n  readonly proposed?: Bounds;\n}\n\n/** The part of a resize that a box alone decides: what it writes, the box\n *  they share, and where each starts. */\nexport type ResizePlace = Pick<\n  ResizeSession,\n  'scene' | 'writeIds' | 'sharedBox' | 'box' | 'startPoses' | 'startWorlds' | 'geometryOf' | 'poseFrame' | 'view'\n>;\n\n/** Capture what resizing `ids` from `anchor` acts on. Null when nothing it\n *  would write exists. */\nexport function captureResize(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  anchor: ResizeAnchor,\n  deps: Pick<ActionDeps, 'poseDescriptor' | 'resizePolicy' | 'view'>,\n): {\n  place: ResizePlace;\n  ruleOrigin: Bounds;\n  policy: ActionDeps['resizePolicy'];\n  constraints: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n} | null {\n  const geometry = poseDescriptorOf(deps.poseDescriptor);\n  const policy = 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 = 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  return {\n    place: {\n      scene,\n      writeIds,\n      sharedBox: isGroupPath || writeIds.length > 1,\n      box,\n      startPoses: starts.startPoses,\n      startWorlds: starts.startWorlds,\n      geometryOf,\n      poseFrame,\n      view,\n    },\n    ruleOrigin,\n    policy,\n    constraints,\n    pointSnap,\n  };\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 captured = captureResize(scene, ids, anchor, ctx.deps);\n  if (!captured) return null;\n  const { place, ruleOrigin, policy, constraints, pointSnap } = captured;\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    ...place,\n    startWorld,\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":";;;;;;AA+EA,SAAgBA,EACd,GACA,GACA,GACA,GAOO;CACP,IAAMC,IAAWC,EAAiBC,EAAK,cAAc,GAC/CC,IAASD,EAAK,cACd,EAAE,gBAAa,cAAW,iBAAcE,EAAcD,CAAM,GAC5DE,IAAaC,EAAgBC,GAAOP,CAAQ,GAE5CQ,IAAUC,EAAeF,GAAOG,GAAKC,CAAS;CACpD,IAAI,CAACH,GAAS,OAAO;CACrB,IAAM,EAAE,aAAU,mBAAgBA,GAK5BI,IAAYC,EAAeN,CAAK,GAChCO,IAAOZ,EAAK,MACZa,IAASC,EAAcT,GAAOU,GAAUZ,GAAYO,GAAWE,CAAI;CACzE,IAAIC,EAAO,WAAW,SAAS,GAAG,OAAO;CAEzC,IAAM,EAAE,QAAK,kBAAeG,EAAWH,GAAQE,GAAUE,GAAaC,GAAQpB,GAAUK,CAAU;CAClG,OAAO;EACL,OAAO;GACL;GACA;GACA,WAAWc,KAAeF,EAAS,SAAS;GAC5C;GACA,YAAYF,EAAO;GACnB,aAAaA,EAAO;GACpB;GACA;GACA;EACF;EACA;EACA;EACA;EACA;CACF;AACF;AAKA,SAAgBM,EACd,GAC4D;CAC5D,IAAMC,IAAYC,EAAI,KAAK,WACrBhB,IAAQgB,EAAI,KAAK;CACvB,IAAI,CAACD,KAAa,CAACf,GAAO,OAAO;CAEjC,IAAMG,IAAMY,EAAU,IAAI;CAC1B,IAAIZ,EAAI,WAAW,GAAG,OAAO;CAE7B,IAAMU,IAASG,EAAI,MAAM,YAAY;CACrC,IAAI,CAACH,GAAQ,OAAO;CAEpB,IAAMI,IAAWzB,EAAcQ,GAAOG,GAAKU,GAAQG,EAAI,IAAI;CAC3D,IAAI,CAACC,GAAU,OAAO;CACtB,IAAM,EAAE,UAAO,eAAY,WAAQ,gBAAa,iBAAcA,GACxDC,IAAa;EAAE,GAAGF,EAAI,MAAM,MAAM,KAAK;EAAG,GAAGA,EAAI,MAAM,MAAM,KAAK;CAAE,GACpEG,IAAUC,EAAeJ,EAAI,IAAI,GACjCK,IAAaC,EAAoBN,GAAKb,GAAKoB,GAAYL,GAAYC,CAAO;CAChF,KAAK,IAAMK,KAAKC,GAAa,EAAE,UAAUJ,CAAU;CAanD,OAAO;EAAE,SAAA;GAVP,GAAGK;GACH;GACA;GACA;GACA;GACA,UAAUV,EAAI,KAAK;GACnB,oBAAoBA,EAAI,KAAK;GAC7B,kBAAkBD,EAAU;GAC5B,WAAWY,EAAqB/B,GAAQ,UAAU6B,CAAW;EAEtD;EAAS;CAAQ;AAC5B"}

package/dist/interactions/actions/resolveOverlays.js

@@ -39,7 +39,8 @@ function t(t) {
 				bounds: t,
 				geometry: i,
 				extras: r.extras,
-				...r.anchorPoint && r.shape !== "pencil" ? { anchorPoint: r.anchorPoint } : {}
+				...r.anchorPoint && r.shape !== "pencil" ? { anchorPoint: r.anchorPoint } : {},
+				...r.copies ? { copies: r.copies } : {}
 			});
 			break;
 		}

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      /** World affines the shape will also be drawn under, as the action gave them. */\n      copies?: readonly (readonly [number, number, number, number, number, number])[];\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          ...(ov.copies ? { copies: ov.copies } : {}),\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":";;AA0FA,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;IACjF,GAAIA,EAAG,SAAS,EAAE,QAAQA,EAAG,OAAO,IAAI,CAAC;GAC3C,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,71 @@
+import { rotateCursorAt as e } from "../../../affordances/rotateCursor.js";
+import { closeGesture as t, runBehaviorCancel as n } from "../gestureLifecycle.js";
+import { inPlane as r, selectionLayer as i } from "../planeInput.js";
+import { recordTransform as a } from "../transform-again/memory.js";
+import { nextFrame as o } from "./frame.js";
+import { commitRotate as s } from "./commit.js";
+import { beginRotate as c } from "./session.js";
+//#region src/interactions/actions/rotate/action.ts
+var l = r({
+	id: "rotate",
+	label: "Rotate",
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps",
+		"poseDescriptor",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(r, i) {
+			let l = c(r, i);
+			if (!l) return {};
+			let { session: u, readers: d } = l, f = [...r.deps.selection?.get() ?? []], p = u.scene.overrides.hold(), m = {
+				delta: 0,
+				previews: /* @__PURE__ */ new Map()
+			}, h = r.world;
+			return u.lifecycle.start(u.gestureCtx.draggedIds), {
+				kind: "rotate",
+				cursor: () => {
+					let t = r.deps.view?.get().scale;
+					return t ? e(u.turn.pivot, h, t) : void 0;
+				},
+				onMove(e) {
+					h = e.world, m = o(u, d, e), p.set(m.previews);
+				},
+				onEnd(e, r) {
+					let i = !1;
+					try {
+						if (r === "commit") {
+							if (i = s(u, m), i) {
+								let e = u.ids.length > 1 && !u.turn.useUnionPivot ? "each" : "union";
+								a(u.scene, {
+									kind: "rotate",
+									angle: m.delta,
+									pivot: e
+								}, f);
+							}
+						} else n(u.behaviors, u.gestureCtx);
+					} finally {
+						t({
+							hold: p,
+							previews: m.previews,
+							behaviors: u.behaviors,
+							ctx: u.gestureCtx,
+							lifecycle: u.lifecycle
+						}, i);
+					}
+				},
+				previewIds: () => m.previews.keys(),
+				previewPose: (e) => m.previews.get(e) ?? null
+			};
+		}
+	},
+	enabled: () => !0
+}, i);
+//#endregion
+export { l 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","subject","hold","session","frame","pointer","scale","rotateCursorAt","moveCtx","nextFrame","readers","committed","reason","commitRotate","pivot","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 { rotateCursorAt } from 'affordances/rotateCursor';\nimport { commitRotate } from './commit';\nimport { nextFrame } from './frame';\nimport { beginRotate, type RotateFrame } from './session';\nimport { recordTransform } from '../transform-again/memory';\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 subject = [...(ctx.deps.selection?.get() ?? [])] as string[];\n      const hold = session.scene.overrides.hold();\n      let frame: RotateFrame = { delta: 0, previews: new Map() };\n      let pointer = ctx.world;\n      session.lifecycle.start(session.gestureCtx.draggedIds);\n      return {\n        kind: 'rotate',\n        cursor: () => {\n          const scale = ctx.deps.view?.get().scale;\n          return scale ? rotateCursorAt(session.turn.pivot, pointer, scale) : undefined;\n        },\n        onMove(moveCtx: InvocationCtx): void {\n          pointer = moveCtx.world;\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') {\n              committed = commitRotate(session, frame);\n              if (committed) {\n                const pivot = session.ids.length > 1 && !session.turn.useUnionPivot ? 'each' : 'union';\n                recordTransform(session.scene, { kind: 'rotate', angle: frame.delta, pivot }, subject);\n              }\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":";;;;;;;;AAoBA,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,IAAU,CAAC,GAAIF,EAAI,KAAK,WAAW,IAAI,KAAK,CAAC,CAAE,GAC/CG,IAAOC,EAAQ,MAAM,UAAU,KAAK,GACtCC,IAAqB;IAAE,OAAO;IAAG,0BAAU,IAAI,IAAI;GAAE,GACrDC,IAAUN,EAAI;GAElB,OADAI,EAAQ,UAAU,MAAMA,EAAQ,WAAW,UAAU,GAC9C;IACL,MAAM;IACN,cAAc;KACZ,IAAMG,IAAQP,EAAI,KAAK,MAAM,IAAI,CAAC,CAAC;KACnC,OAAOO,IAAQC,EAAeJ,EAAQ,KAAK,OAAOE,GAASC,CAAK,IAAI,KAAA;IACtE;IACA,OAAO,GAA8B;KAGnC,AAFA,IAAUE,EAAQ,OAClB,IAAQC,EAAUN,GAASO,GAASF,CAAO,GAC3CN,EAAK,IAAIE,EAAM,QAAQ;IACzB;IACA,MAAM,GAAwB,GAAmC;KAC/D,IAAIO,IAAY;KAChB,IAAI;MACF,IAAIC,MAAW,UAEb;WADA,IAAYC,EAAaV,GAASC,CAAK,GACnCO,GAAW;QACb,IAAMG,IAAQX,EAAQ,IAAI,SAAS,KAAK,CAACA,EAAQ,KAAK,gBAAgB,SAAS;QAC/E,EAAgBA,EAAQ,OAAO;SAAE,MAAM;SAAU,OAAOC,EAAM;SAAO;QAAM,GAAGH,CAAO;OACvF;aACK,EAAkBE,EAAQ,WAAWA,EAAQ,UAAU;KAChE,UAAU;MACR,EAAa;OAAE;OAAM,UAAUC,EAAM;OAAU,WAAWD,EAAQ;OAAW,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGQ,CAAS;KACjJ;IACF;IACA,kBAAkBP,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIW,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, c as storedPreviews, 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. */\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 *  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":";;;;AAWA,SAASA,EACP,GACA,GACA,GACA,GACS;CACT,IAAMC,IAAUC,EAAE,aAAcC,EAAO,OAAOA,EAAO,WAAWC,CAAK;CACrE,IAAI,CAACC,GAAO,OAAOJ;CACnB,IAAMK,IAAM,KAAK,IAAIF,CAAK,GACpBG,IAAM,KAAK,IAAIH,CAAK,GACpBI,IAAKL,EAAO,OAAO,IAAIE,EAAM,GAC7BI,IAAKN,EAAO,OAAO,IAAIE,EAAM,GAC7BK,IAAKL,EAAM,IAAIG,IAAKF,IAAMG,IAAKF,GAC/BI,IAAKN,EAAM,IAAIG,IAAKD,IAAME,IAAKH;CACrC,OAAOM,EAA2BX,GAASS,IAAKP,EAAO,OAAO,GAAGQ,IAAKR,EAAO,OAAO,GAAGD,CAAC;AAC1F;AAGA,SAAgBW,EAAa,GAAY,GAAqC;CAC5E,IAAMC,oBAAM,IAAI,IAAqB,GAC/BT,IAAQU,EAAK,gBAAgBA,EAAK,QAAQ;CAChD,KAAK,IAAM,CAACC,GAAIb,MAAWY,EAAK,SAC9B,EAAI,IAAIC,GAAIhB,EAASe,EAAK,aAAaC,CAAE,GAAGb,GAAQC,GAAOC,CAAK,CAAC;CAEnE,OAAOS;AACT;AAGA,SAAgBG,EACd,GACA,GACA,GACsB;CACtB,IAAMC,IAASL,EAAaE,GAAMX,CAAK;CACvC,KAAK,IAAM,CAACY,GAAIG,MAASD,GAAQ,EAAK,QAAQ,IAAIF,GAAcG,CAAI;CACpE,OAAOD;AACT;AAGA,SAASE,EACP,GACA,GACA,GACA,GACA,GACA,GACQ;CAIR,AAHA,EAAK,YAAY,EAAE,GAAGC,EAAQ,UAAU,GACxC,EAAK,UAAUC,EAAeD,EAAQ,OAAOA,CAAO,GACpD,EAAK,OAAOE,EAAQ,KAAK,GACzB,EAAK,QAAQA,EAAQ,MAAM;CAC3B,IAAMC,IAAUT,EAAK,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,OACrCU,IAAiBV,EAAK,QAAQ,IAAIS,CAAO,CAAC,EAAE,YAAY,GAC1DpB,IAAQsB,GACRC,IAAoC;EACtC,MAAMV,EAAmBW,GAAMb,GAAMW,CAAG,CAAC,CAAC,IAAIF,CAAO;EACrD,UAAUC,IAAiBC;CAC7B;CACA,KAAK,IAAMG,KAAKC,GAAW;EACzB,IAAMC,IAAIF,EAAE,SAASD,GAAMD,CAAQ;EACnC,IAAI,CAACI,GAAG;EACR,IAAIA,EAAE,aAAa,KAAA,GAAW;GAE5B,AADA,IAAQA,EAAE,WAAWN,GACrB,IAAW;IAAE,MAAMR,EAAmBW,GAAMb,GAAMX,CAAK,CAAC,CAAC,IAAIoB,CAAO;IAAG,UAAUO,EAAE;GAAS;GAC5F;EACF;EACA,IAAIA,EAAE,SAAS,KAAA,GAAW;EAC1B,IAAMC,IAAWjB,EAAK,aAAaS,CAAO,CAAC,CAAC,cAAcO,EAAE,IAAI,KAAK;EAErE,AADA,IAAQC,IAAWP,GACnB,IAAW;GAAE,MAAMM,EAAE;GAAM;EAAS;CACtC;CACA,OAAO3B;AACT;AAGA,SAAgB6B,EACd,GACA,GACsB;CACtB,IAAMC,oBAAW,IAAI,IAAqB;CAC1C,IAAI9B,MAAU,GAAG,OAAO8B;CACxB,KAAK,IAAM,CAAClB,GAAIE,MAAWL,EAAasB,EAAQ,MAAM/B,CAAK,GAAG;EAC5D,IAAMgC,IAAQD,EAAQ,MAAM,IAAInB,CAAE,CAAC,EAAE,OAC/BqB,IAAMD,MAAU,KAAA,IAAY,OAAOE,EAAQH,EAAQ,MAAMC,CAAK;EACpE,EAAS,IAAIpB,GAAImB,EAAQ,UAAU,MAAMnB,GAAIuB,EAAUJ,EAAQ,KAAK,aAAanB,CAAE,GAAGE,GAAQmB,CAAG,CAAC,CAAC;CACrG;CACA,OAAOH;AACT;AAIA,SAAgBM,EAAU,GAAwB,GAAyB,GAAqC;CAC9G,IAAM,EAAE,aAAUL,EAAQ,MAEpBT,IADe,KAAK,MAAML,EAAQ,MAAM,IAAIhB,EAAM,GAAGgB,EAAQ,MAAM,IAAIhB,EAAM,CACvE,IAAe8B,EAAQ,mBAC7B/B,IAAQ+B,EAAQ,UAAU,SAAS,IACrCf,EAAWe,EAAQ,MAAMA,EAAQ,WAAWA,EAAQ,YAAYZ,GAASF,GAASK,CAAG,IACrFA;CACJ,OAAO;EAAE;EAAO,UAAUO,EAAeE,GAAS/B,CAAK;CAAE;AAC3D"}

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

@@ -1,27 +1,27 @@
-import { standoff as e } from "../../../core/viewport/pxExtent.js";
-import { ROTATION_HANDLE_BASE_PX as t } from "../../../core/device/targets.js";
-import { aabbCenter as n, rotatePoint as r } from "./geometry.js";
+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";
 //#region src/interactions/actions/rotate/handle.ts
-var i = t;
-function a(t, a = i, s = o) {
-	let c = t.rotation ?? 0, l = n(t), u = r(t.x + t.width / 2, t.y, l.x, l.y, c), d = e(u, {
-		x: Math.sin(c),
-		y: -Math.cos(c)
-	}, a, s);
+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, {
+		x: 0,
+		y: -1
+	}), o, c);
 	return {
 		cx: d.x,
 		cy: d.y,
 		angle: Math.atan2(d.nx, -d.ny)
 	};
 }
-var o = {
+var s = {
 	x: 1,
 	y: 1
 };
-function s(e, t, n, r) {
+function c(e, t, n, r) {
 	return Math.abs(t - e.cx) <= r && Math.abs(n - e.cy) <= r;
 }
 //#endregion
-export { i as DEFAULT_ROTATION_HANDLE_DISTANCE, s as hitRotationHandle, a as rotationHandle };
+export { a as DEFAULT_ROTATION_HANDLE_DISTANCE, c as hitRotationHandle, o as 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","rotation","pose","c","aabbCenter","top","rotatePoint","p","standoff","distance","scale","hitRotationHandle","px","handle","radius","py"],"sources":["../../../../src/interactions/actions/rotate/handle.ts"],"sourcesContent":["import { aabbCenter, rotatePoint } from './geometry';\nimport { ROTATION_HANDLE_BASE_PX } from 'core/device/targets';\nimport { standoff, type Scale2 } from 'core/viewport/pxExtent';\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 rotated rect: `distance` pixels off the top edge's\n *  midpoint, along that edge's outward normal as it lands on a screen whose\n *  per-axis zoom is `scale`. With no `scale`, a pixel is a world unit. When\n *  `pose.rotation` is missing it's treated as 0. */\nexport function rotationHandle(\n  pose: { x: number; y: number; width: number; height: number; rotation?: number },\n  distance: number = DEFAULT_ROTATION_HANDLE_DISTANCE,\n  scale: Scale2 = UNIT_SCALE,\n): RotationHandle {\n  const rotation = pose.rotation ?? 0;\n  const c = aabbCenter(pose);\n  const top = rotatePoint(pose.x + pose.width / 2, pose.y, c.x, c.y, rotation);\n  const p = standoff(top, { x: Math.sin(rotation), y: -Math.cos(rotation) }, 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,IAAWC,EAAK,YAAY,GAC5BC,IAAIC,EAAWF,CAAI,GACnBG,IAAMC,EAAYJ,EAAK,IAAIA,EAAK,QAAQ,GAAGA,EAAK,GAAGC,EAAE,GAAGA,EAAE,GAAGF,CAAQ,GACrEM,IAAIC,EAASH,GAAK;EAAE,GAAG,KAAK,IAAIJ,CAAQ;EAAG,GAAG,CAAC,KAAK,IAAIA,CAAQ;CAAE,GAAGQ,GAAUC,CAAK;CAC1F,OAAO;EAAE,IAAIH,EAAE;EAAG,IAAIA,EAAE;EAAG,OAAO,KAAK,MAAMA,EAAE,IAAI,CAACA,EAAE,EAAE;CAAE;AAC5D;AAEA,IAAMP,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":["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"}

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

@@ -0,0 +1,22 @@
+import { shapeSources as e } from "../selectionSubtree.js";
+import { storedPreviews as t } from "./frame.js";
+import { rotateOps as n } from "./commit.js";
+import { captureTurn as r } from "./session.js";
+//#region src/interactions/actions/rotate/replay.ts
+function i(i, a, o, s, c, l, u) {
+	let d = e(i, a);
+	if (d.length === 0 || c === 0) return [];
+	let f = r(i, d, o, s, l);
+	if (!f) return [];
+	let { turn: p, originPoses: m, poseFrame: h } = f, g = t({
+		scene: i,
+		turn: p,
+		poseFrame: h,
+		view: o
+	}, c);
+	return n([...p.origins.keys()], m, g, u);
+}
+//#endregion
+export { i as rotateSelectionOps };
+
+//# sourceMappingURL=replay.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","names":["rotateSelectionOps","ids","shapeSources","scene","selected","angle","captured","captureTurn","view","poseDescriptor","pivot","previews","storedPreviews","rotateOps","turn","originPoses","label"],"sources":["../../../../src/interactions/actions/rotate/replay.ts"],"sourcesContent":["import 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  view: unknown,\n  poseDescriptor: unknown,\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, view, poseDescriptor, pivot);\n  if (!captured) return [];\n  const { turn, originPoses, poseFrame } = captured;\n  const previews = storedPreviews({ scene, turn, poseFrame, view }, angle);\n  return rotateOps([...turn.origins.keys()], originPoses, previews, label);\n}\n"],"mappings":";;;;;AASA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAMC,EAAaC,GAAOC,CAAQ;CACxC,IAAIH,EAAI,WAAW,KAAKI,MAAU,GAAG,OAAO,CAAC;CAC7C,IAAMC,IAAWC,EAAYJ,GAAOF,GAAKO,GAAMC,GAAgBC,CAAK;CACpE,IAAI,CAACJ,GAAU,OAAO,CAAC;CACvB,IAAM,EAAE,SAAM,gBAAa,iBAAcA,GACnCK,IAAWC,EAAe;EAAE;EAAO;EAAM;EAAW;CAAK,GAAGP,CAAK;CACvE,OAAOQ,EAAU,CAAC,GAAGC,EAAK,QAAQ,KAAK,CAAC,GAAGC,GAAaJ,GAAUK,CAAK;AACzE"}

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

@@ -0,0 +1,102 @@
+import { unionAABB as e } from "../../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor as t } from "../../../core/geometry/poseDescriptor.js";
+import { readGestureLifecycle as n } from "../gestureLifecycle.js";
+import { carryPose as r, invertPlane as i, planeOf as a } from "../planeInput.js";
+import { gestureReaders as o } from "../../gestures/shared/screenTolerance.js";
+import { nodeDescriptors as s, poseDescriptorOf as c } from "../poseDescriptorDep.js";
+import { shapeSources as l } from "../selectionSubtree.js";
+import { pointerStateOf as u } from "../pointerState.js";
+import { scenePoseFrame as d } from "../poseFrame.js";
+import { sceneGestureFrames as f } from "../gestureFrames.js";
+import { moveGestureAdapter as p } from "../move/gestureAdapter.js";
+import { DEFAULT_ROTATE_BEHAVIORS as m } from "./behaviors/index.js";
+import { resolveParams as h } from "@weasel-js/routing";
+//#region src/interactions/actions/rotate/session.ts
+function g(e, n, o, s, c) {
+	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = [];
+	for (let f of o) {
+		let o = n.get(f);
+		if (!o) continue;
+		let p = s(f);
+		if (!p.withRotation || p.supportsRotation?.(o.pose) === !1) continue;
+		l.set(f, o.pose);
+		let m = r(p, c.world(f), i(a(e, o.layer))), h = p.getBounds(m);
+		u.set(f, {
+			world: m,
+			center: {
+				x: h.x + h.width / 2,
+				y: h.y + h.height / 2
+			},
+			rotation: p.getRotation?.(m) ?? 0
+		}), d.push(t(m, p));
+	}
+	return {
+		originPoses: l,
+		origins: u,
+		visual: d
+	};
+}
+function _(e, t, n, r, i) {
+	return {
+		draggedIds: [...n.keys()],
+		origin: new Map([...n].map(([e, t]) => [e, t.world])),
+		current: new Map([...n].map(([e, t]) => [e, t.world])),
+		snap: null,
+		modifiers: { ...e.modifiers },
+		pointer: u(e.world, e),
+		view: r.view(),
+		plane: r.plane(),
+		frames: f(t, e.deps.view),
+		adapter: p(t, void 0, i),
+		scratch: {}
+	};
+}
+function v(t, n, r, i, a) {
+	let o = s(t, c(i)), l = d(t), { originPoses: u, origins: f, visual: p } = g(r, t, n, o, l);
+	if (u.size === 0) return null;
+	let m = e(p);
+	return {
+		turn: {
+			origins: f,
+			pivot: {
+				x: m.x + m.width / 2,
+				y: m.y + m.height / 2
+			},
+			useUnionPivot: n.length > 1 && a !== "each",
+			descriptorOf: o
+		},
+		originPoses: u,
+		poseFrame: l
+	};
+}
+function y(e, t) {
+	let r = e.deps.selection, i = e.deps.scene, a = h(t?.params), s = t?.behaviors ?? m;
+	if (!r || !i) return null;
+	let c = l(i, r.get());
+	if (c.length === 0) return null;
+	let u = v(i, c, e.deps.view, e.deps.poseDescriptor, a?.pivot === "each" ? "each" : "union");
+	if (!u) return null;
+	let { turn: d, originPoses: f, poseFrame: p } = u, { origins: g, pivot: y } = d, b = o(e.deps), x = _(e, i, g, b, r.adapterMethods);
+	for (let e of s) e.onStart?.(x);
+	return {
+		session: {
+			scene: i,
+			ids: c,
+			turn: d,
+			poseFrame: p,
+			view: e.deps.view,
+			originPoses: f,
+			startPointerAngle: Math.atan2(e.world.y - y.y, e.world.x - y.x),
+			behaviors: s,
+			gestureCtx: x,
+			applyOps: e.deps.applyOps,
+			selectionMethods: r.adapterMethods,
+			lifecycle: n(a, "Rotate", s)
+		},
+		readers: b
+	};
+}
+//#endregion
+export { y as beginRotate, v as captureTurn };
+
+//# sourceMappingURL=session.js.map