@weasel-js/core 1.10.1 → 1.11.1

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

@@ -1,63 +1,103 @@
-import { commitGestureOps as e, readGestureLifecycle as t } from "../gestureLifecycle.js";
-import { gestureReaders as n } from "../../gestures/shared/screenTolerance.js";
-import { nodeDescriptors as r, poseDescriptorOf as i } from "../poseDescriptorDep.js";
-import { moveSources as a } from "../selectionSubtree.js";
-import { layoutDrop as o } from "./behaviors/layoutDrop.js";
-import { reparentOnDrop as s } from "./behaviors/reparentOnDrop.js";
-import { buildGestureContext as c, captureFrames as l, capturePlaneRefs as u, captureStartPoses as d } from "./capture.js";
-import { moveGestureAdapter as f } from "./gestureAdapter.js";
-import { DRAG_THRESHOLD_PX as p, isPathEditPart as m, resolveParams as h } from "@weasel-js/routing";
+import { nodeDescriptors, poseDescriptorOf } from "../poseDescriptorDep.js";
+import { transformFinisher } from "../transformFinish.js";
+import { commitGestureOps, readGestureLifecycle } from "../gestureLifecycle.js";
+import { gestureReaders } from "../../gestures/shared/screenTolerance.js";
+import { moveSources } from "../selectionSubtree.js";
+import { layoutDrop } from "./behaviors/layoutDrop.js";
+import { reparentOnDrop } from "./behaviors/reparentOnDrop.js";
+import { buildGestureContext, captureFrames, capturePlaneRefs, captureStartPoses } from "./capture.js";
+import { moveGestureAdapter } from "./gestureAdapter.js";
+import { lazySnapSession } from "../../../features/snap/lazySession.js";
+import { DRAG_THRESHOLD_PX, isPathEditPart, resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/move/session.ts
-function g(g, _, v) {
-	let y = g.deps.selection, b = g.deps.scene, x = i(g.deps.poseDescriptor), S = g.deps.layout, C = g.deps.applyOps, w = g.deps.geometryProjection;
-	if (!y || !b) return null;
-	let T = b.composition;
-	if (m(g.drag?.affordance)) return null;
-	let E = h(_?.params), D = E?.expandIds, O = [...y.get()], k = a(b, D ? D(O) : O);
-	if (k.length === 0) return null;
-	let A = S?.reflow ?? null, { startPoses: j, cascadeIds: M, caught: N } = d(b, k, A, x), { carried: P, frames: F } = l(b, k, j), I = {
-		session: () => U,
-		frame: v
-	}, L = [
-		..._?.behaviors ?? [],
-		...S ? [o(I)] : [],
-		s(I)
-	], R = E?.dragThresholdPx ?? p, z = t(E, "Move", L), B = f(b, (t, n, r) => e({
-		scene: b,
-		applyOps: C,
-		adapter: r
-	}, z, t), y.adapterMethods), V = n(g.deps), H = c(g, b, k, j, B, V);
-	for (let e of L) e.onStart?.(H);
-	let U = {
-		startPoses: j,
-		ids: k,
-		cascadeIds: M,
-		carried: P,
-		frames: F,
-		scene: b,
-		view: g.deps.view,
-		planeRefs: u(b, k, g.deps.view, F, j, x),
-		caught: N,
-		projection: x,
-		descriptorOf: r(b, x),
-		behaviors: L,
-		gestureCtx: H,
-		adapter: B,
-		layout: S,
-		pc: T,
-		applyOps: C,
-		geometryProjection: w,
-		lifecycle: z,
-		nodeAtPoint: g.deps.nodeAtPoint,
-		reparentOnDrop: () => h(_?.params)?.reparentOnDrop ?? "off",
-		dragThresholdPx: R
+function admitsOf(canDropInto, ids) {
+	if (canDropInto === void 0) return () => true;
+	const roots = ids;
+	return (parent) => canDropInto(parent, roots);
+}
+/** Capture a drag at press. Null when there is nothing to move. Runs each
+*  behavior's `onStart`. `frame` reads the drag's latest frame, for the
+*  behaviors appended to the binding's own. */
+function beginMove(ctx, opts, frame) {
+	const selection = ctx.deps.selection;
+	const scene = ctx.deps.scene;
+	const projection = poseDescriptorOf(ctx.deps.poseDescriptor);
+	const layout = ctx.deps.layout;
+	const applyOps = ctx.deps.applyOps;
+	const geometryProjection = ctx.deps.geometryProjection;
+	const finish = transformFinisher(ctx.deps);
+	if (!selection || !scene) return null;
+	const pc = scene.composition;
+	if (isPathEditPart(ctx.drag?.affordance)) return null;
+	const params = resolveParams(opts?.params);
+	const expandIds = params?.["expandIds"];
+	const selected = [...selection.get()];
+	const ids = moveSources(scene, expandIds ? expandIds(selected) : selected);
+	if (ids.length === 0) return null;
+	const reflow = layout?.reflow ?? null;
+	const { startPoses, cascadeIds, caught } = captureStartPoses(scene, ids, reflow, projection);
+	const { carried, frames } = captureFrames(scene, ids, startPoses);
+	const gesture = {
+		session: () => session,
+		frame
+	};
+	const behaviors = [
+		...opts?.behaviors ?? [],
+		...layout ? [layoutDrop(gesture)] : [],
+		reparentOnDrop(gesture)
+	];
+	const dragThresholdPx = params?.["dragThresholdPx"] ?? ctx.deps.kitSettings?.get("gestures.dragPx") ?? DRAG_THRESHOLD_PX;
+	const lifecycle = readGestureLifecycle(params, "Move", behaviors);
+	const adapter = moveGestureAdapter(scene, (ops, _label, through) => commitGestureOps({
+		scene,
+		applyOps,
+		adapter: through,
+		finish
+	}, lifecycle, ops), selection.adapterMethods);
+	const readers = gestureReaders(ctx.deps);
+	const gestureCtx = buildGestureContext(ctx, scene, ids, startPoses, adapter, readers);
+	for (const b of behaviors) b.onStart?.(gestureCtx);
+	const press = ctx.drag?.start ?? ctx.world;
+	const session = {
+		startPoses,
+		ids,
+		cascadeIds,
+		carried,
+		frames,
+		scene,
+		view: ctx.deps.view,
+		planeRefs: capturePlaneRefs(scene, ids, ctx.deps.view, frames, startPoses, projection),
+		caught,
+		projection,
+		descriptorOf: nodeDescriptors(scene, projection),
+		behaviors,
+		gestureCtx,
+		adapter,
+		layout,
+		pc,
+		applyOps,
+		finish,
+		geometryProjection,
+		lifecycle,
+		nodeAtPoint: ctx.deps.nodeAtPoint,
+		admits: admitsOf(ctx.deps.canDropInto, ids),
+		reparentOnDrop: () => resolveParams(opts?.params)?.["reparentOnDrop"] ?? "off",
+		dragThresholdPx,
+		snap: lazySnapSession(ctx.deps.snap, {
+			gesture: "move",
+			ids,
+			press,
+			constrain: "axis"
+		}),
+		press
 	};
 	return {
-		session: U,
-		readers: V
+		session,
+		readers
 	};
 }
-//#endregion
-export { g as beginMove };
 
+//#endregion
+export { beginMove };
 //# sourceMappingURL=session.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"session.js","names":["beginMove","selection","ctx","scene","projection","poseDescriptorOf","layout","applyOps","geometryProjection","pc","isPathEditPart","params","resolveParams","opts","expandIds","\"expandIds\"","selected","ids","moveSources","reflow","captureStartPoses","captureFrames","startPoses","gesture","session","behaviors","layoutDrop","reparentOnDrop","dragThresholdPx","\"dragThresholdPx\"","DRAG_THRESHOLD_PX","lifecycle","readGestureLifecycle","adapter","moveGestureAdapter","commitGestureOps","through","ops","readers","gestureReaders","gestureCtx","buildGestureContext","b","capturePlaneRefs","frames","nodeDescriptors","\"reparentOnDrop\""],"sources":["../../../../src/interactions/actions/move/session.ts"],"sourcesContent":["import type { BindingOpts, InvocationCtx } from '@weasel-js/routing';\nimport { DRAG_THRESHOLD_PX, isPathEditPart, resolveParams } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { PoseComposition } from 'core/scene/composePose';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, MoveBehavior } from '../../gestures/types';\nimport type { LayoutDep, NodeAtPointDep } from '../depSchema';\nimport type { GeometryProjection } from '../geometryProjection';\nimport { commitGestureOps, readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { moveSources } from '../selectionSubtree';\nimport { layoutDrop } from './behaviors/layoutDrop';\nimport { reparentOnDrop } from './behaviors/reparentOnDrop';\nimport { buildGestureContext, captureFrames, capturePlaneRefs, captureStartPoses } from './capture';\nimport { moveGestureAdapter, type MoveGestureAdapter } from './gestureAdapter';\n\n/** Allowed values for the `reparentOnDrop` binding param. `'off'` (the\n *  default) preserves the legacy translate-only commit. `'top'` lands the\n *  moved node at the top of the container under the cursor. `'above'`\n *  lands it immediately above the hit sibling in z-order (falls back to\n *  `'top'` semantics when the hit is itself a container or when the hit\n *  and moved node share no parent). */\nexport type ReparentOnDrop = 'off' | 'top' | 'above';\n\n/** What a move captured at press. Nothing here changes during the drag. */\nexport interface MoveSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  /** The drag roots. */\n  readonly ids: readonly NodeId[];\n  /** Descendants of the roots, previewed along with them. */\n  readonly cascadeIds: readonly NodeId[];\n  /** Start pose of every root and descendant. */\n  readonly startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Ids whose frame is itself moving, so they ride it and are not translated. */\n  readonly carried: ReadonlySet<NodeId>;\n  /** For each moved id stored under a frame: its world pose and the frame's, at press. */\n  readonly frames: ReadonlyMap<NodeId, { world: unknown; frameWorld: unknown }>;\n  /** Ids grabbed mid-glide, with how far the pose shown stood from the document's. */\n  readonly caught: ReadonlyMap<NodeId, { dx: number; dy: number }>;\n  /** Per layer on another plane than the edited one: a point of its first root, in both. */\n  readonly planeRefs: ReadonlyMap<string, { own: { x: number; y: number }; edited: { x: number; y: number } }>;\n  readonly view: unknown;\n  readonly projection: PoseDescriptor<unknown>;\n  readonly descriptorOf: (id: NodeId | string) => PoseDescriptor<unknown>;\n  readonly pc: PoseComposition<unknown>;\n  /** The binding's behaviors, then the ones the action adds: a layout drop\n   *  when the `layout` dep is present, and reparent-on-drop. */\n  readonly behaviors: readonly MoveBehavior<unknown>[];\n  /** Reused across the drag; behaviors mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<unknown>;\n  readonly adapter: MoveGestureAdapter<unknown>;\n  readonly layout: LayoutDep | undefined;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  readonly geometryProjection?: GeometryProjection;\n  readonly lifecycle: GestureLifecycle;\n  readonly nodeAtPoint: NodeAtPointDep | undefined;\n  /** Read at release: a binding's params may be a thunk. */\n  readonly reparentOnDrop: () => ReparentOnDrop;\n  readonly dragThresholdPx: number;\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface MoveFrame {\n  readonly delta: { dx: number; dy: number };\n  /** Stored-frame pose of every displaced id, roots and descendants, and of\n   *  any other id a behavior posed. */\n  readonly previews: Map<NodeId, unknown>;\n  /** Ids the behaviors asked to have painted at full opacity. */\n  readonly opaque: ReadonlySet<NodeId>;\n}\n\n/** What the behaviors the action builds itself read of the drag they belong\n *  to. Neither is readable from `onStart`, which runs before the session\n *  exists. */\nexport interface MoveGesture {\n  session(): MoveSession;\n  /** The latest frame: the previous one while an `onMove` is running. */\n  frame(): MoveFrame;\n}\n\n/** Capture a drag at press. Null when there is nothing to move. Runs each\n *  behavior's `onStart`. `frame` reads the drag's latest frame, for the\n *  behaviors appended to the binding's own. */\nexport function beginMove(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n  frame: () => MoveFrame,\n): { session: MoveSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  const projection = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const layout = ctx.deps.layout;\n  const applyOps = ctx.deps.applyOps;\n  const geometryProjection = ctx.deps.geometryProjection;\n\n  if (!selection || !scene) return null;\n  const pc = scene.composition;\n  // Anchors and segments sit on the selected body, and this binding ties editAnchors' and\n  // bendSegment's on specificity; with no mode registry to filter move out, declining is what\n  // lets them through.\n  if (isPathEditPart(ctx.drag?.affordance)) return null;\n\n  const params = resolveParams(opts?.params);\n  const expandIds = params?.['expandIds'] as ((ids: string[]) => string[]) | undefined;\n  const selected = [...selection.get()] as string[];\n  const ids = moveSources(scene, expandIds ? expandIds(selected) : selected) as NodeId[];\n  if (ids.length === 0) return null;\n\n  const reflow = layout?.reflow ?? null;\n  const { startPoses, cascadeIds, caught } = captureStartPoses(scene, ids, reflow, projection);\n  const { carried, frames } = captureFrames(scene, ids, startPoses);\n\n  // Everything a move does beyond translating is a behavior: the binding's\n  // own, then the layout drop, then reparent-on-drop. On release the first to\n  // answer owns the commit, so each preempts the ones after it.\n  const gesture: MoveGesture = { session: () => session, frame };\n  const behaviors: MoveBehavior<unknown>[] = [\n    ...((opts?.behaviors ?? []) as MoveBehavior<unknown>[]),\n    ...(layout ? [layoutDrop(gesture)] : []),\n    reparentOnDrop(gesture),\n  ];\n  const dragThresholdPx = (params?.['dragThresholdPx'] as number | undefined)\n    ?? DRAG_THRESHOLD_PX;\n  const lifecycle = readGestureLifecycle(params, 'Move', behaviors);\n  // A behavior that commits after the gesture has ended, a coast coming to\n  // rest, lands its batch the way the gesture's own commit does.\n  const adapter = moveGestureAdapter<unknown>(scene, (ops, _label, through) =>\n    commitGestureOps({ scene, applyOps, adapter: through }, lifecycle, ops), selection.adapterMethods);\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, scene, ids, startPoses, adapter, readers);\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n\n  const session: MoveSession = {\n    startPoses,\n    ids,\n    cascadeIds,\n    carried,\n    frames,\n    scene,\n    view: ctx.deps.view,\n    planeRefs: capturePlaneRefs(scene, ids, ctx.deps.view, frames, startPoses, projection),\n    caught,\n    projection,\n    descriptorOf: nodeDescriptors(scene, projection),\n    behaviors,\n    gestureCtx,\n    adapter,\n    layout,\n    pc,\n    applyOps,\n    geometryProjection,\n    lifecycle,\n    nodeAtPoint: ctx.deps.nodeAtPoint,\n    reparentOnDrop: () => (resolveParams(opts?.params)?.['reparentOnDrop'] as ReparentOnDrop | undefined) ?? 'off',\n    dragThresholdPx,\n  };\n  return { session, readers };\n}\n"],"mappings":";;;;;;;;;;AAqFA,SAAgBA,EACd,GACA,GACA,GAC0D;CAC1D,IAAMC,IAAYC,EAAI,KAAK,WACrBC,IAAQD,EAAI,KAAK,OACjBE,IAAaC,EAAiBH,EAAI,KAAK,cAAc,GACrDI,IAASJ,EAAI,KAAK,QAClBK,IAAWL,EAAI,KAAK,UACpBM,IAAqBN,EAAI,KAAK;CAEpC,IAAI,CAACD,KAAa,CAACE,GAAO,OAAO;CACjC,IAAMM,IAAKN,EAAM;CAIjB,IAAIO,EAAeR,EAAI,MAAM,UAAU,GAAG,OAAO;CAEjD,IAAMS,IAASC,EAAcC,GAAM,MAAM,GACnCC,IAAYH,GAASI,WACrBC,IAAW,CAAC,GAAGf,EAAU,IAAI,CAAC,GAC9BgB,IAAMC,EAAYf,GAAOW,IAAYA,EAAUE,CAAQ,IAAIA,CAAQ;CACzE,IAAIC,EAAI,WAAW,GAAG,OAAO;CAE7B,IAAME,IAASb,GAAQ,UAAU,MAC3B,EAAE,eAAY,eAAY,cAAWc,EAAkBjB,GAAOc,GAAKE,GAAQf,CAAU,GACrF,EAAE,YAAS,cAAWiB,EAAclB,GAAOc,GAAKK,CAAU,GAK1DC,IAAuB;EAAE,eAAeC;EAAS;CAAM,GACvDC,IAAqC;EACzC,GAAKZ,GAAM,aAAa,CAAC;EACzB,GAAIP,IAAS,CAACoB,EAAWH,CAAO,CAAC,IAAI,CAAC;EACtCI,EAAeJ,CAAO;CACxB,GACMK,IAAmBjB,GAASkB,mBAC7BC,GACCC,IAAYC,EAAqBrB,GAAQ,QAAQc,CAAS,GAG1DQ,IAAUC,EAA4B/B,IAAQ,GAAK,GAAQ,MAC/DgC,EAAiB;EAAE;EAAO;EAAU,SAASC;CAAQ,GAAGL,GAAWM,CAAG,GAAGpC,EAAU,cAAc,GAC7FqC,IAAUC,EAAerC,EAAI,IAAI,GACjCsC,IAAaC,EAAoBvC,GAAKC,GAAOc,GAAKK,GAAYW,GAASK,CAAO;CACpF,KAAK,IAAMI,KAAKjB,GAAW,EAAE,UAAUe,CAAU;CAEjD,IAAMhB,IAAuB;EAC3B;EACA;EACA;EACA;EACA;EACA;EACA,MAAMtB,EAAI,KAAK;EACf,WAAWyC,EAAiBxC,GAAOc,GAAKf,EAAI,KAAK,MAAM0C,GAAQtB,GAAYlB,CAAU;EACrF;EACA;EACA,cAAcyC,EAAgB1C,GAAOC,CAAU;EAC/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAaF,EAAI,KAAK;EACtB,sBAAuBU,EAAcC,GAAM,MAAM,CAAC,EAAGiC,kBAAoD;EACzG;CACF;CACA,OAAO;EAAE;EAAS;CAAQ;AAC5B"}
+{"version":3,"file":"session.js","names":[],"sources":["../../../../src/interactions/actions/move/session.ts"],"sourcesContent":["import type { BindingOpts, InvocationCtx } from '@weasel-js/routing';\nimport { DRAG_THRESHOLD_PX, isPathEditPart, resolveParams } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { PoseComposition } from 'core/scene/composePose';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, MoveBehavior } from '../../gestures/types';\nimport type { CanDropIntoDep, LayoutDep, NodeAtPointDep } from '../depSchema';\nimport type { GeometryProjection } from '../geometryProjection';\nimport { commitGestureOps, readGestureLifecycle, type GestureLifecycle } from '../gestureLifecycle';\nimport { transformFinisher, type TransformFinisher } from '../transformFinish';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { moveSources } from '../selectionSubtree';\nimport { layoutDrop } from './behaviors/layoutDrop';\nimport { reparentOnDrop } from './behaviors/reparentOnDrop';\nimport { buildGestureContext, captureFrames, capturePlaneRefs, captureStartPoses } from './capture';\nimport { moveGestureAdapter, type MoveGestureAdapter } from './gestureAdapter';\nimport type { SnapSession } from '../snapDep';\nimport { lazySnapSession } from 'features/snap/lazySession';\n\n/** Allowed values for the `reparentOnDrop` binding param. `'off'` (the\n *  default) preserves the legacy translate-only commit. `'top'` lands the\n *  moved node at the top of the container under the cursor. `'above'`\n *  lands it immediately above the hit sibling in z-order (falls back to\n *  `'top'` semantics when the hit is itself a container or when the hit\n *  and moved node share no parent). */\nexport type ReparentOnDrop = 'off' | 'top' | 'above';\n\n/** What a move captured at press. Nothing here changes during the drag. */\nexport interface MoveSession {\n  readonly scene: Scene<unknown, string, unknown>;\n  /** The drag roots. */\n  readonly ids: readonly NodeId[];\n  /** Descendants of the roots, previewed along with them. */\n  readonly cascadeIds: readonly NodeId[];\n  /** Start pose of every root and descendant. */\n  readonly startPoses: ReadonlyMap<NodeId, unknown>;\n  /** Ids whose frame is itself moving, so they ride it and are not translated. */\n  readonly carried: ReadonlySet<NodeId>;\n  /** For each moved id stored under a frame: its world pose and the frame's, at press. */\n  readonly frames: ReadonlyMap<NodeId, { world: unknown; frameWorld: unknown }>;\n  /** Ids grabbed mid-glide, with how far the pose shown stood from the document's. */\n  readonly caught: ReadonlyMap<NodeId, { dx: number; dy: number }>;\n  /** Per layer on another plane than the edited one: a point of its first root, in both. */\n  readonly planeRefs: ReadonlyMap<string, { own: { x: number; y: number }; edited: { x: number; y: number } }>;\n  readonly view: unknown;\n  readonly projection: PoseDescriptor<unknown>;\n  readonly descriptorOf: (id: NodeId | string) => PoseDescriptor<unknown>;\n  readonly pc: PoseComposition<unknown>;\n  /** The binding's behaviors, then the ones the action adds: a layout drop\n   *  when the `layout` dep is present, and reparent-on-drop. */\n  readonly behaviors: readonly MoveBehavior<unknown>[];\n  /** Reused across the drag; behaviors mutate its `scratch`. */\n  readonly gestureCtx: GestureContext<unknown>;\n  readonly adapter: MoveGestureAdapter<unknown>;\n  readonly layout: LayoutDep | undefined;\n  readonly applyOps?: (ops: Op[], label: string) => void;\n  /** Finishes the committed batch with the other nodes that change with it. */\n  readonly finish?: TransformFinisher;\n  readonly geometryProjection?: GeometryProjection;\n  readonly lifecycle: GestureLifecycle;\n  readonly nodeAtPoint: NodeAtPointDep | undefined;\n  /** Whether a container admits the dragged roots; every one does when absent. */\n  readonly admits: (parent: NodeId) => boolean;\n  /** Read at release: a binding's params may be a thunk. */\n  readonly reparentOnDrop: () => ReparentOnDrop;\n  readonly dragThresholdPx: number;\n  /** The drag's snapping, begun once the drag passes its threshold; null\n   *  with no `snap` dep. */\n  readonly snap: SnapSession | null;\n  /** The press, in the coordinates the drag's delta is measured in. */\n  readonly press: { x: number; y: number };\n}\n\n/** What one `onMove` produced. Replaced, not mutated, by the next. */\nexport interface MoveFrame {\n  readonly delta: { dx: number; dy: number };\n  /** Stored-frame pose of every displaced id, roots and descendants, and of\n   *  any other id a behavior posed. */\n  readonly previews: Map<NodeId, unknown>;\n  /** Ids the behaviors asked to have painted at full opacity. */\n  readonly opaque: ReadonlySet<NodeId>;\n}\n\n/** What the behaviors the action builds itself read of the drag they belong\n *  to. Neither is readable from `onStart`, which runs before the session\n *  exists. */\nexport interface MoveGesture {\n  session(): MoveSession;\n  /** The latest frame: the previous one while an `onMove` is running. */\n  frame(): MoveFrame;\n}\n\nfunction admitsOf(\n  canDropInto: CanDropIntoDep | undefined,\n  ids: readonly NodeId[],\n): (parent: NodeId) => boolean {\n  if (canDropInto === undefined) return () => true;\n  const roots = ids as readonly string[];\n  return (parent) => canDropInto(parent as string, roots);\n}\n\n/** Capture a drag at press. Null when there is nothing to move. Runs each\n *  behavior's `onStart`. `frame` reads the drag's latest frame, for the\n *  behaviors appended to the binding's own. */\nexport function beginMove(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n  frame: () => MoveFrame,\n): { session: MoveSession; readers: GestureReaders } | null {\n  const selection = ctx.deps.selection;\n  const scene = ctx.deps.scene;\n  const projection = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const layout = ctx.deps.layout;\n  const applyOps = ctx.deps.applyOps;\n  const geometryProjection = ctx.deps.geometryProjection;\n  const finish = transformFinisher(ctx.deps);\n\n  if (!selection || !scene) return null;\n  const pc = scene.composition;\n  // Anchors, segments, and balance grips sit on the selected body, and this binding ties the\n  // path-edit drags' on specificity; with no mode registry to filter move out, declining is what\n  // lets them through.\n  if (isPathEditPart(ctx.drag?.affordance)) return null;\n\n  const params = resolveParams(opts?.params);\n  const expandIds = params?.['expandIds'] as ((ids: string[]) => string[]) | undefined;\n  const selected = [...selection.get()] as string[];\n  const ids = moveSources(scene, expandIds ? expandIds(selected) : selected) as NodeId[];\n  if (ids.length === 0) return null;\n\n  const reflow = layout?.reflow ?? null;\n  const { startPoses, cascadeIds, caught } = captureStartPoses(scene, ids, reflow, projection);\n  const { carried, frames } = captureFrames(scene, ids, startPoses);\n\n  // Everything a move does beyond translating is a behavior: the binding's\n  // own, then the layout drop, then reparent-on-drop. On release the first to\n  // answer owns the commit, so each preempts the ones after it.\n  const gesture: MoveGesture = { session: () => session, frame };\n  const behaviors: MoveBehavior<unknown>[] = [\n    ...((opts?.behaviors ?? []) as MoveBehavior<unknown>[]),\n    ...(layout ? [layoutDrop(gesture)] : []),\n    reparentOnDrop(gesture),\n  ];\n  const dragThresholdPx = (params?.['dragThresholdPx'] as number | undefined)\n    ?? ctx.deps.kitSettings?.get('gestures.dragPx') ?? DRAG_THRESHOLD_PX;\n  const lifecycle = readGestureLifecycle(params, 'Move', behaviors);\n  // A behavior that commits after the gesture has ended, a coast coming to\n  // rest, lands its batch the way the gesture's own commit does.\n  const adapter = moveGestureAdapter<unknown>(scene, (ops, _label, through) =>\n    commitGestureOps({ scene, applyOps, adapter: through, finish }, lifecycle, ops), selection.adapterMethods);\n  const readers = gestureReaders(ctx.deps);\n  const gestureCtx = buildGestureContext(ctx, scene, ids, startPoses, adapter, readers);\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n\n  const press = ctx.drag?.start ?? ctx.world;\n  const session: MoveSession = {\n    startPoses,\n    ids,\n    cascadeIds,\n    carried,\n    frames,\n    scene,\n    view: ctx.deps.view,\n    planeRefs: capturePlaneRefs(scene, ids, ctx.deps.view, frames, startPoses, projection),\n    caught,\n    projection,\n    descriptorOf: nodeDescriptors(scene, projection),\n    behaviors,\n    gestureCtx,\n    adapter,\n    layout,\n    pc,\n    applyOps,\n    finish,\n    geometryProjection,\n    lifecycle,\n    nodeAtPoint: ctx.deps.nodeAtPoint,\n    admits: admitsOf(ctx.deps.canDropInto, ids),\n    reparentOnDrop: () => (resolveParams(opts?.params)?.['reparentOnDrop'] as ReparentOnDrop | undefined) ?? 'off',\n    dragThresholdPx,\n    snap: lazySnapSession(ctx.deps.snap, { gesture: 'move', ids, press, constrain: 'axis' }),\n    press,\n  };\n  return { session, readers };\n}\n"],"mappings":";;;;;;;;;;;;;AA8FA,SAAS,SACP,aACA,KAC6B;CAC7B,IAAI,gBAAgB,QAAW,aAAa;CAC5C,MAAM,QAAQ;CACd,QAAQ,WAAW,YAAY,QAAkB,KAAK;AACxD;;;;AAKA,SAAgB,UACd,KACA,MACA,OAC0D;CAC1D,MAAM,YAAY,IAAI,KAAK;CAC3B,MAAM,QAAQ,IAAI,KAAK;CACvB,MAAM,aAAa,iBAAiB,IAAI,KAAK,cAAc;CAC3D,MAAM,SAAS,IAAI,KAAK;CACxB,MAAM,WAAW,IAAI,KAAK;CAC1B,MAAM,qBAAqB,IAAI,KAAK;CACpC,MAAM,SAAS,kBAAkB,IAAI,IAAI;CAEzC,IAAI,CAAC,aAAa,CAAC,OAAO,OAAO;CACjC,MAAM,KAAK,MAAM;CAIjB,IAAI,eAAe,IAAI,MAAM,UAAU,GAAG,OAAO;CAEjD,MAAM,SAAS,cAAc,MAAM,MAAM;CACzC,MAAM,YAAY,SAAS;CAC3B,MAAM,WAAW,CAAC,GAAG,UAAU,IAAI,CAAC;CACpC,MAAM,MAAM,YAAY,OAAO,YAAY,UAAU,QAAQ,IAAI,QAAQ;CACzE,IAAI,IAAI,WAAW,GAAG,OAAO;CAE7B,MAAM,SAAS,QAAQ,UAAU;CACjC,MAAM,EAAE,YAAY,YAAY,WAAW,kBAAkB,OAAO,KAAK,QAAQ,UAAU;CAC3F,MAAM,EAAE,SAAS,WAAW,cAAc,OAAO,KAAK,UAAU;CAKhE,MAAM,UAAuB;EAAE,eAAe;EAAS;CAAM;CAC7D,MAAM,YAAqC;EACzC,GAAK,MAAM,aAAa,CAAC;EACzB,GAAI,SAAS,CAAC,WAAW,OAAO,CAAC,IAAI,CAAC;EACtC,eAAe,OAAO;CACxB;CACA,MAAM,kBAAmB,SAAS,sBAC7B,IAAI,KAAK,aAAa,IAAI,iBAAiB,KAAK;CACrD,MAAM,YAAY,qBAAqB,QAAQ,QAAQ,SAAS;CAGhE,MAAM,UAAU,mBAA4B,QAAQ,KAAK,QAAQ,YAC/D,iBAAiB;EAAE;EAAO;EAAU,SAAS;EAAS;CAAO,GAAG,WAAW,GAAG,GAAG,UAAU,cAAc;CAC3G,MAAM,UAAU,eAAe,IAAI,IAAI;CACvC,MAAM,aAAa,oBAAoB,KAAK,OAAO,KAAK,YAAY,SAAS,OAAO;CACpF,KAAK,MAAM,KAAK,WAAW,EAAE,UAAU,UAAU;CAEjD,MAAM,QAAQ,IAAI,MAAM,SAAS,IAAI;CACrC,MAAM,UAAuB;EAC3B;EACA;EACA;EACA;EACA;EACA;EACA,MAAM,IAAI,KAAK;EACf,WAAW,iBAAiB,OAAO,KAAK,IAAI,KAAK,MAAM,QAAQ,YAAY,UAAU;EACrF;EACA;EACA,cAAc,gBAAgB,OAAO,UAAU;EAC/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa,IAAI,KAAK;EACtB,QAAQ,SAAS,IAAI,KAAK,aAAa,GAAG;EAC1C,sBAAuB,cAAc,MAAM,MAAM,CAAC,GAAG,qBAAoD;EACzG;EACA,MAAM,gBAAgB,IAAI,KAAK,MAAM;GAAE,SAAS;GAAQ;GAAK;GAAO,WAAW;EAAO,CAAC;EACvF;CACF;CACA,OAAO;EAAE;EAAS;CAAQ;AAC5B"}

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

@@ -1,61 +1,47 @@
-import { translatePoseViaDescriptor as e } from "../../../core/geometry/poseDescriptor.js";
-import { createTransformOp as t } from "../../../core/ops/transform.js";
-import { localDelta as n } from "./delta.js";
-import { geometryDataOp as r } from "../geometryProjection.js";
+import { localDelta } from "./delta.js";
+import { translateNodeOps } from "../moveNodes.js";
+
 //#region src/interactions/actions/move/translate.ts
-function i(i, a, o) {
-	let s = [];
-	for (let c of a) {
-		if (!i.startPoses.has(c) || i.carried.has(c)) continue;
-		let a = i.scene.get(c);
-		if (!a) continue;
-		let l = n(i, c, o.dx, o.dy), u = i.caught.get(c);
-		u && (l.dx += u.dx, l.dy += u.dy);
-		let d = [
-			1,
-			0,
-			0,
-			1,
-			l.dx,
-			l.dy
-		], f = a.pose;
-		if (s.push(t({
-			id: c,
-			from: f,
-			to: e(f, l.dx, l.dy, i.descriptorOf(c)),
-			label: i.lifecycle.label
-		})), i.geometryProjection) {
-			let e = r(i.geometryProjection, {
-				id: c,
-				data: a.data,
-				pose: f
-			}, d, i.lifecycle.label);
-			e && s.push(e);
-		}
-	}
-	return s;
+/** The default translate commit: one transform op per id, plus the data-held
+*  geometry op when the `geometryProjection` seam is wired. */
+function translateOps(session, ids, delta) {
+	return translateNodeOps(session.scene, ids, (id) => {
+		if (!session.startPoses.has(id) || session.carried.has(id)) return null;
+		const l = localDelta(session, id, delta.dx, delta.dy);
+		const c = session.caught.get(id);
+		return c ? {
+			dx: l.dx + c.dx,
+			dy: l.dy + c.dy
+		} : l;
+	}, session.descriptorOf, session.geometryProjection, session.lifecycle.label);
 }
-function a(e, t, n) {
-	let r = new Set(t);
-	return i(e, o(e, new Set(e.ids.filter((e) => !r.has(e)))), n);
+/** The default translate commit for the dragged roots among `roots` and the
+*  descendants that follow them. Anything else in `roots` is ignored. */
+function rootTranslateOps(session, roots, delta) {
+	const wanted = new Set(roots);
+	return translateOps(session, unreleasedIds(session, new Set(session.ids.filter((id) => !wanted.has(id)))), delta);
 }
-function o(e, t) {
-	let n = new Set(e.ids), r = e.ids.filter((e) => !t.has(e));
-	for (let i of e.cascadeIds) {
-		let a = e.scene.get(i)?.parent ?? null, o = !1;
-		for (; a;) {
-			if (t.has(a)) {
-				o = !0;
+/** Selected roots no source layout claimed on release, plus the descendants
+*  that follow them — the part of the selection the translate commit owns. */
+function unreleasedIds(session, released) {
+	const selected = new Set(session.ids);
+	const out = session.ids.filter((id) => !released.has(id));
+	for (const id of session.cascadeIds) {
+		let cur = session.scene.get(id)?.parent ?? null;
+		let claimed = false;
+		while (cur) {
+			if (released.has(cur)) {
+				claimed = true;
 				break;
 			}
-			if (n.has(a)) break;
-			a = e.scene.get(a)?.parent ?? null;
+			if (selected.has(cur)) break;
+			cur = session.scene.get(cur)?.parent ?? null;
 		}
-		o || r.push(i);
+		if (!claimed) out.push(id);
 	}
-	return r;
+	return out;
 }
-//#endregion
-export { a as rootTranslateOps, i as translateOps, o as unreleasedIds };
 
+//#endregion
+export { rootTranslateOps, translateOps, unreleasedIds };
 //# sourceMappingURL=translate.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"translate.js","names":["translateOps","ops","id","ids","session","node","localDelta","delta","c","m","authored","createTransformOp","translatePoseViaDescriptor","dataOp","geometryDataOp","rootTranslateOps","wanted","roots","unreleasedIds","selected","out","released","cur","claimed"],"sources":["../../../../src/interactions/actions/move/translate.ts"],"sourcesContent":["import type { Affine } from '@weasel-js/geom';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { geometryDataOp } from '../geometryProjection';\nimport { localDelta } from './delta';\nimport type { MoveSession } from './session';\n\n/** The default translate commit: one transform op per id, plus the data-held\n *  geometry op when the `geometryProjection` seam is wired. */\nexport function translateOps(session: MoveSession, ids: Iterable<NodeId>, delta: { dx: number; dy: number }): Op[] {\n  const ops: Op[] = [];\n  for (const id of ids) {\n    if (!session.startPoses.has(id) || session.carried.has(id)) continue;\n    const node = session.scene.get(id);\n    if (!node) continue;\n    const l = localDelta(session, id, delta.dx, delta.dy);\n    const c = session.caught.get(id);\n    if (c) { l.dx += c.dx; l.dy += c.dy; }\n    const m: Affine = [1, 0, 0, 1, l.dx, l.dy];\n    // The authored pose, not the captured one: a derived node's captured pose\n    // is its derivation, and writing that back would lose the placeholder undo\n    // restores.\n    const authored = node.pose;\n    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from: authored,\n      to: translatePoseViaDescriptor(authored, l.dx, l.dy, session.descriptorOf(id)),\n      label: session.lifecycle.label,\n    }));\n    if (session.geometryProjection) {\n      const dataOp = geometryDataOp(\n        session.geometryProjection,\n        { id: id as string, data: node.data, pose: authored },\n        m,\n        session.lifecycle.label,\n      );\n      if (dataOp) ops.push(dataOp);\n    }\n  }\n  return ops;\n}\n\n/** The default translate commit for the dragged roots among `roots` and the\n *  descendants that follow them. Anything else in `roots` is ignored. */\nexport function rootTranslateOps(session: MoveSession, roots: Iterable<string>, delta: { dx: number; dy: number }): Op[] {\n  const wanted = new Set<string>(roots);\n  const others = new Set<NodeId>(session.ids.filter((id) => !wanted.has(id)));\n  return translateOps(session, unreleasedIds(session, others), delta);\n}\n\n/** Selected roots no source layout claimed on release, plus the descendants\n *  that follow them — the part of the selection the translate commit owns. */\nexport function unreleasedIds(session: MoveSession, released: Set<NodeId>): NodeId[] {\n  const selected = new Set<NodeId>(session.ids);\n  const out: NodeId[] = session.ids.filter((id) => !released.has(id));\n  for (const id of session.cascadeIds) {\n    let cur = session.scene.get(id)?.parent ?? null;\n    let claimed = false;\n    while (cur) {\n      if (released.has(cur)) { claimed = true; break; }\n      if (selected.has(cur)) break;\n      cur = session.scene.get(cur)?.parent ?? null;\n    }\n    if (!claimed) out.push(id);\n  }\n  return out;\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EAAa,GAAsB,GAAuB,GAAyC;CACjH,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAMC,GAAK;EACpB,IAAI,CAACC,EAAQ,WAAW,IAAIF,CAAE,KAAKE,EAAQ,QAAQ,IAAIF,CAAE,GAAG;EAC5D,IAAMG,IAAOD,EAAQ,MAAM,IAAIF,CAAE;EACjC,IAAI,CAACG,GAAM;EACX,IAAM,IAAIC,EAAWF,GAASF,GAAIK,EAAM,IAAIA,EAAM,EAAE,GAC9CC,IAAIJ,EAAQ,OAAO,IAAIF,CAAE;EAC/B,AAAIM,MAAK,EAAE,MAAMA,EAAE,IAAI,EAAE,MAAMA,EAAE;EACjC,IAAMC,IAAY;GAAC;GAAG;GAAG;GAAG;GAAG,EAAE;GAAI,EAAE;EAAE,GAInCC,IAAWL,EAAK;EAOtB,IANAJ,EAAI,KAAKU,EAA2B;GAC9B;GACJ,MAAMD;GACN,IAAIE,EAA2BF,GAAU,EAAE,IAAI,EAAE,IAAIN,EAAQ,aAAaF,CAAE,CAAC;GAC7E,OAAOE,EAAQ,UAAU;EAC3B,CAAC,CAAC,GACEA,EAAQ,oBAAoB;GAC9B,IAAMS,IAASC,EACbV,EAAQ,oBACR;IAAM;IAAc,MAAMC,EAAK;IAAM,MAAMK;GAAS,GACpDD,GACAL,EAAQ,UAAU,KACpB;GACA,AAAIS,KAAQZ,EAAI,KAAKY,CAAM;EAC7B;CACF;CACA,OAAOZ;AACT;AAIA,SAAgBc,EAAiB,GAAsB,GAAyB,GAAyC;CACvH,IAAMC,IAAS,IAAI,IAAYC,CAAK;CAEpC,OAAOjB,EAAaI,GAASc,EAAcd,GAAS,IADjC,IAAYA,EAAQ,IAAI,QAAQ,MAAO,CAACY,EAAO,IAAId,CAAE,CAAC,CACrB,CAAM,GAAGK,CAAK;AACpE;AAIA,SAAgBW,EAAc,GAAsB,GAAiC;CACnF,IAAMC,IAAW,IAAI,IAAYf,EAAQ,GAAG,GACtCgB,IAAgBhB,EAAQ,IAAI,QAAQ,MAAO,CAACiB,EAAS,IAAInB,CAAE,CAAC;CAClE,KAAK,IAAMA,KAAME,EAAQ,YAAY;EACnC,IAAIkB,IAAMlB,EAAQ,MAAM,IAAIF,CAAE,CAAC,EAAE,UAAU,MACvCqB,IAAU;EACd,OAAOD,IAAK;GACV,IAAID,EAAS,IAAIC,CAAG,GAAG;IAAE,IAAU;IAAM;GAAO;GAChD,IAAIH,EAAS,IAAIG,CAAG,GAAG;GACvB,IAAMlB,EAAQ,MAAM,IAAIkB,CAAG,CAAC,EAAE,UAAU;EAC1C;EACA,AAAKC,KAASH,EAAI,KAAKlB,CAAE;CAC3B;CACA,OAAOkB;AACT"}
+{"version":3,"file":"translate.js","names":[],"sources":["../../../../src/interactions/actions/move/translate.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { translateNodeOps } from '../moveNodes';\nimport { localDelta } from './delta';\nimport type { MoveSession } from './session';\n\n/** The default translate commit: one transform op per id, plus the data-held\n *  geometry op when the `geometryProjection` seam is wired. */\nexport function translateOps(session: MoveSession, ids: Iterable<NodeId>, delta: { dx: number; dy: number }): Op[] {\n  return translateNodeOps(\n    session.scene,\n    ids,\n    (id) => {\n      if (!session.startPoses.has(id) || session.carried.has(id)) return null;\n      const l = localDelta(session, id, delta.dx, delta.dy);\n      const c = session.caught.get(id);\n      return c ? { dx: l.dx + c.dx, dy: l.dy + c.dy } : l;\n    },\n    session.descriptorOf,\n    session.geometryProjection,\n    session.lifecycle.label,\n  );\n}\n\n/** The default translate commit for the dragged roots among `roots` and the\n *  descendants that follow them. Anything else in `roots` is ignored. */\nexport function rootTranslateOps(session: MoveSession, roots: Iterable<string>, delta: { dx: number; dy: number }): Op[] {\n  const wanted = new Set<string>(roots);\n  const others = new Set<NodeId>(session.ids.filter((id) => !wanted.has(id)));\n  return translateOps(session, unreleasedIds(session, others), delta);\n}\n\n/** Selected roots no source layout claimed on release, plus the descendants\n *  that follow them — the part of the selection the translate commit owns. */\nexport function unreleasedIds(session: MoveSession, released: Set<NodeId>): NodeId[] {\n  const selected = new Set<NodeId>(session.ids);\n  const out: NodeId[] = session.ids.filter((id) => !released.has(id));\n  for (const id of session.cascadeIds) {\n    let cur = session.scene.get(id)?.parent ?? null;\n    let claimed = false;\n    while (cur) {\n      if (released.has(cur)) { claimed = true; break; }\n      if (selected.has(cur)) break;\n      cur = session.scene.get(cur)?.parent ?? null;\n    }\n    if (!claimed) out.push(id);\n  }\n  return out;\n}\n"],"mappings":";;;;;;AAQA,SAAgB,aAAa,SAAsB,KAAuB,OAAyC;CACjH,OAAO,iBACL,QAAQ,OACR,MACC,OAAO;EACN,IAAI,CAAC,QAAQ,WAAW,IAAI,EAAE,KAAK,QAAQ,QAAQ,IAAI,EAAE,GAAG,OAAO;EACnE,MAAM,IAAI,WAAW,SAAS,IAAI,MAAM,IAAI,MAAM,EAAE;EACpD,MAAM,IAAI,QAAQ,OAAO,IAAI,EAAE;EAC/B,OAAO,IAAI;GAAE,IAAI,EAAE,KAAK,EAAE;GAAI,IAAI,EAAE,KAAK,EAAE;EAAG,IAAI;CACpD,GACA,QAAQ,cACR,QAAQ,oBACR,QAAQ,UAAU,KACpB;AACF;;;AAIA,SAAgB,iBAAiB,SAAsB,OAAyB,OAAyC;CACvH,MAAM,SAAS,IAAI,IAAY,KAAK;CAEpC,OAAO,aAAa,SAAS,cAAc,SAAS,IADjC,IAAY,QAAQ,IAAI,QAAQ,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CACrB,CAAM,GAAG,KAAK;AACpE;;;AAIA,SAAgB,cAAc,SAAsB,UAAiC;CACnF,MAAM,WAAW,IAAI,IAAY,QAAQ,GAAG;CAC5C,MAAM,MAAgB,QAAQ,IAAI,QAAQ,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;CAClE,KAAK,MAAM,MAAM,QAAQ,YAAY;EACnC,IAAI,MAAM,QAAQ,MAAM,IAAI,EAAE,CAAC,EAAE,UAAU;EAC3C,IAAI,UAAU;EACd,OAAO,KAAK;GACV,IAAI,SAAS,IAAI,GAAG,GAAG;IAAE,UAAU;IAAM;GAAO;GAChD,IAAI,SAAS,IAAI,GAAG,GAAG;GACvB,MAAM,QAAQ,MAAM,IAAI,GAAG,CAAC,EAAE,UAAU;EAC1C;EACA,IAAI,CAAC,SAAS,IAAI,KAAK,EAAE;CAC3B;CACA,OAAO;AACT"}

package/dist/interactions/actions/moveNodes.js

@@ -0,0 +1,87 @@
+import { translatePoseViaDescriptor } from "../../core/geometry/poseDescriptor.js";
+import { scenePoseFrame } from "./poseFrame.js";
+import { nodeDescriptors, poseDescriptorOf } from "./poseDescriptorDep.js";
+import { commitTransformOps } from "./transformFinish.js";
+import { createTransformOp } from "../../core/ops/transform.js";
+import { moveSources, storedDelta, translateTargets } from "./selectionSubtree.js";
+import { geometryDataOp } from "./geometryProjection.js";
+
+//#region src/interactions/actions/moveNodes.ts
+/** The deps {@link moveNodes} reads; an action calling it declares these. */
+var MOVE_NODES_REQUIRES = [
+	"scene",
+	"selection",
+	"applyOps",
+	"poseDescriptor",
+	"geometryProjection",
+	"transformFollowers"
+];
+/**
+* One transform op per id, translating its authored pose by the stored-frame
+* delta `deltaOf` gives it, plus its data-held geometry's op when a
+* `geometryProjection` is wired. An id `deltaOf` answers null for is skipped.
+* Every translate commit — a drag, a nudge, {@link moveNodes} — builds its ops here.
+*/
+function translateNodeOps(scene, ids, deltaOf, descriptorOf, geometryProjection, label) {
+	const ops = [];
+	for (const id of ids) {
+		const node = scene.get(id);
+		if (!node) continue;
+		const l = deltaOf(id);
+		if (!l) continue;
+		const from = node.pose;
+		ops.push(createTransformOp({
+			id,
+			from,
+			to: translatePoseViaDescriptor(from, l.dx, l.dy, descriptorOf(id)),
+			label
+		}));
+		const m = [
+			1,
+			0,
+			0,
+			1,
+			l.dx,
+			l.dy
+		];
+		const dataOp = geometryDataOp(geometryProjection, {
+			id,
+			data: node.data,
+			pose: from
+		}, m, label);
+		if (dataOp) ops.push(dataOp);
+	}
+	return ops;
+}
+/**
+* The ops that move `ids` by `delta` the way a drag of them commits: each id
+* that is not itself derived (a derived one is moved through what it derives
+* from) and every descendant not carried by a moving frame, each translated in
+* the frame it is stored in. `delta` is in the coordinates a gesture's points
+* are — world on a 2D canvas — and the `poseDescriptor` dep turns it into each
+* pose's translation, so a 3D host's descriptor lands it on the node's plane.
+*/
+function moveNodesOps(scene, ids, delta, deps, label = "Move") {
+	const { dx, dy } = delta;
+	if (dx === 0 && dy === 0) return [];
+	const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(deps?.poseDescriptor));
+	const frame = scenePoseFrame(scene);
+	return translateNodeOps(scene, translateTargets(scene, frame, moveSources(scene, ids)), (id) => storedDelta(frame, descriptorOf(id), id, dx, dy), descriptorOf, deps?.geometryProjection, label);
+}
+/**
+* Move `ids` by `delta` the way a drag of them commits ({@link moveNodesOps}),
+* finished by the `transformFollowers` and committed as one undo entry through
+* `applyOps`, else the scene. Inside an open `scene.batch` it joins that
+* batch's entry. Returns whether anything moved. A caller running as an
+* action declares {@link MOVE_NODES_REQUIRES}.
+*/
+function moveNodes(deps, ids, delta, label = "Move") {
+	const scene = deps.scene;
+	if (!scene) return false;
+	const ops = moveNodesOps(scene, ids, delta, deps, label);
+	return ops.length > 0 && commitTransformOps(deps, ops, label);
+}
+
+//#endregion
+export { MOVE_NODES_REQUIRES, moveNodes, moveNodesOps, translateNodeOps };
+//# sourceMappingURL=moveNodes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moveNodes.js","names":[],"sources":["../../../src/interactions/actions/moveNodes.ts"],"sourcesContent":["import type { ActionDeps } from '@weasel-js/routing';\nimport type { Affine } from '@weasel-js/geom';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { geometryDataOp, type GeometryProjection } from './geometryProjection';\nimport { nodeDescriptors, poseDescriptorOf } from './poseDescriptorDep';\nimport { scenePoseFrame } from './poseFrame';\nimport { moveSources, storedDelta, translateTargets } from './selectionSubtree';\nimport { commitTransformOps } from './transformFinish';\n\ntype AnyScene = Scene<unknown, string, unknown>;\n\n/** The deps {@link moveNodes} reads; an action calling it declares these. */\nexport const MOVE_NODES_REQUIRES = [\n  'scene', 'selection', 'applyOps', 'poseDescriptor', 'geometryProjection', 'transformFollowers',\n] as const;\n\n/**\n * One transform op per id, translating its authored pose by the stored-frame\n * delta `deltaOf` gives it, plus its data-held geometry's op when a\n * `geometryProjection` is wired. An id `deltaOf` answers null for is skipped.\n * Every translate commit — a drag, a nudge, {@link moveNodes} — builds its ops here.\n */\nexport function translateNodeOps(\n  scene: AnyScene,\n  ids: Iterable<NodeId>,\n  deltaOf: (id: NodeId) => { dx: number; dy: number } | null,\n  descriptorOf: (id: NodeId) => PoseDescriptor<unknown>,\n  geometryProjection: GeometryProjection | undefined,\n  label: string,\n): Op[] {\n  const ops: Op[] = [];\n  for (const id of ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const l = deltaOf(id);\n    if (!l) continue;\n    // The authored pose, not the effective one: a derived node's effective\n    // pose is its derivation, and writing that back would lose the\n    // placeholder undo restores.\n    const from = node.pose;\n    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from,\n      to: translatePoseViaDescriptor(from, l.dx, l.dy, descriptorOf(id)),\n      label,\n    }));\n    const m: Affine = [1, 0, 0, 1, l.dx, l.dy];\n    const dataOp = geometryDataOp(geometryProjection, { id: id as string, data: node.data, pose: from }, m, label);\n    if (dataOp) ops.push(dataOp);\n  }\n  return ops;\n}\n\n/**\n * The ops that move `ids` by `delta` the way a drag of them commits: each id\n * that is not itself derived (a derived one is moved through what it derives\n * from) and every descendant not carried by a moving frame, each translated in\n * the frame it is stored in. `delta` is in the coordinates a gesture's points\n * are — world on a 2D canvas — and the `poseDescriptor` dep turns it into each\n * pose's translation, so a 3D host's descriptor lands it on the node's plane.\n */\nexport function moveNodesOps(\n  scene: AnyScene,\n  ids: readonly string[],\n  delta: { dx: number; dy: number },\n  deps?: Pick<ActionDeps, 'poseDescriptor' | 'geometryProjection'>,\n  label = 'Move',\n): Op[] {\n  const { dx, dy } = delta;\n  if (dx === 0 && dy === 0) return [];\n  const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(deps?.poseDescriptor));\n  const frame = scenePoseFrame(scene);\n  const targets = translateTargets(scene, frame, moveSources(scene, ids));\n  return translateNodeOps(\n    scene,\n    targets,\n    (id) => storedDelta(frame, descriptorOf(id), id, dx, dy),\n    descriptorOf,\n    deps?.geometryProjection,\n    label,\n  );\n}\n\n/**\n * Move `ids` by `delta` the way a drag of them commits ({@link moveNodesOps}),\n * finished by the `transformFollowers` and committed as one undo entry through\n * `applyOps`, else the scene. Inside an open `scene.batch` it joins that\n * batch's entry. Returns whether anything moved. A caller running as an\n * action declares {@link MOVE_NODES_REQUIRES}.\n */\nexport function moveNodes(\n  deps: ActionDeps,\n  ids: readonly string[],\n  delta: { dx: number; dy: number },\n  label = 'Move',\n): boolean {\n  const scene = deps.scene as AnyScene | undefined;\n  if (!scene) return false;\n  const ops = moveNodesOps(scene, ids, delta, deps, label);\n  return ops.length > 0 && commitTransformOps(deps, ops, label);\n}\n"],"mappings":";;;;;;;;;;AAeA,IAAa,sBAAsB;CACjC;CAAS;CAAa;CAAY;CAAkB;CAAsB;AAC5E;;;;;;;AAQA,SAAgB,iBACd,OACA,KACA,SACA,cACA,oBACA,OACM;CACN,MAAM,MAAY,CAAC;CACnB,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,OAAO,MAAM,IAAI,EAAE;EACzB,IAAI,CAAC,MAAM;EACX,MAAM,IAAI,QAAQ,EAAE;EACpB,IAAI,CAAC,GAAG;EAIR,MAAM,OAAO,KAAK;EAClB,IAAI,KAAK,kBAA2B;GAC9B;GACJ;GACA,IAAI,2BAA2B,MAAM,EAAE,IAAI,EAAE,IAAI,aAAa,EAAE,CAAC;GACjE;EACF,CAAC,CAAC;EACF,MAAM,IAAY;GAAC;GAAG;GAAG;GAAG;GAAG,EAAE;GAAI,EAAE;EAAE;EACzC,MAAM,SAAS,eAAe,oBAAoB;GAAM;GAAc,MAAM,KAAK;GAAM,MAAM;EAAK,GAAG,GAAG,KAAK;EAC7G,IAAI,QAAQ,IAAI,KAAK,MAAM;CAC7B;CACA,OAAO;AACT;;;;;;;;;AAUA,SAAgB,aACd,OACA,KACA,OACA,MACA,QAAQ,QACF;CACN,MAAM,EAAE,IAAI,OAAO;CACnB,IAAI,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC;CAClC,MAAM,eAAe,gBAAgB,OAAO,iBAAiB,MAAM,cAAc,CAAC;CAClF,MAAM,QAAQ,eAAe,KAAK;CAElC,OAAO,iBACL,OAFc,iBAAiB,OAAO,OAAO,YAAY,OAAO,GAAG,CAGnE,IACC,OAAO,YAAY,OAAO,aAAa,EAAE,GAAG,IAAI,IAAI,EAAE,GACvD,cACA,MAAM,oBACN,KACF;AACF;;;;;;;;AASA,SAAgB,UACd,MACA,KACA,OACA,QAAQ,QACC;CACT,MAAM,QAAQ,KAAK;CACnB,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,MAAM,aAAa,OAAO,KAAK,OAAO,MAAM,KAAK;CACvD,OAAO,IAAI,SAAS,KAAK,mBAAmB,MAAM,KAAK,KAAK;AAC9D"}

package/dist/interactions/actions/outlines/createOutlines.js

@@ -1,37 +1,45 @@
-import { replaceWithPaths as e } from "./replaceWithPaths.js";
-import { TextOutlinesError as t, textToPathsByPaint as n } from "@weasel-js/text";
+import { replaceWithPaths } from "./replaceWithPaths.js";
+import { TextOutlinesError, textToPathsByPaint } from "@weasel-js/text";
+
 //#region src/interactions/actions/outlines/createOutlines.ts
-function r(r) {
-	let i = [...r.getSelection()], a = [];
+/**
+* Convert every text node in the selection to outlines, as one batch labeled
+* "Create Outlines". Other selected nodes are left alone and stay selected.
+* All or nothing: if any text node's face cannot supply outlines the scene is
+* untouched and the error comes back in the result.
+*/
+function applyCreateOutlines(adapter) {
+	const sel = [...adapter.getSelection()];
+	const converted = [];
 	try {
-		for (let e of i) {
-			let t = r.getTextSource(e);
-			if (!t) continue;
-			let i = n(t.data, t.pose);
-			i.length > 0 && a.push({
-				id: e,
-				paths: i
+		for (const id of sel) {
+			const text = adapter.getTextSource(id);
+			if (!text) continue;
+			const paths = textToPathsByPaint(text.data, text.pose);
+			if (paths.length > 0) converted.push({
+				id,
+				paths
 			});
 		}
-	} catch (e) {
-		if (e instanceof t) return {
+	} catch (err) {
+		if (err instanceof TextOutlinesError) return {
 			kind: "failed",
 			reason: "text-outlines",
-			error: e
+			error: err
 		};
-		throw e;
+		throw err;
 	}
-	if (a.length === 0) return {
+	if (converted.length === 0) return {
 		kind: "noop",
 		reason: "no-text"
 	};
-	let o = e(r, i, a, "Create Outlines");
+	const replaced = replaceWithPaths(adapter, sel, converted, "Create Outlines");
 	return {
 		kind: "applied",
-		resultIds: a.flatMap((e) => o.get(e.id))
+		resultIds: converted.flatMap((c) => replaced.get(c.id))
 	};
 }
-//#endregion
-export { r as applyCreateOutlines };
 
+//#endregion
+export { applyCreateOutlines };
 //# sourceMappingURL=createOutlines.js.map

package/dist/interactions/actions/outlines/createOutlines.js.map

@@ -1 +1 @@
-{"version":3,"file":"createOutlines.js","names":["applyCreateOutlines","sel","adapter","converted","id","text","paths","textToPathsByPaint","err","TextOutlinesError","replaced","replaceWithPaths","c"],"sources":["../../../../src/interactions/actions/outlines/createOutlines.ts"],"sourcesContent":["/**\n * Create Outlines: replace each selected text node with path nodes carrying\n * its glyph outlines, giving up editability for geometry — the destructive\n * conversion every vector editor has. One path per paint the text wears; one\n * undoable batch; the replacement takes the text node's slot, so stacking\n * order is unchanged.\n */\nimport type { Affine, Path, Rect } from '@weasel-js/geom';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { textToPathsByPaint, TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport { replaceWithPaths, type PaintedPath } from './replaceWithPaths';\n\n/** What a path minted by an outline action must carry — see\n *  {@link CreateOutlinesAdapter.createPathNode}. */\nexport interface OutlinePathSpec extends PathPaint {\n  /** The parent the path goes under: the source's own, or the container\n   *  minted to hold a source's several paths. */\n  parent: string | null;\n}\n\n/** What `applyCreateOutlines` and `applyOutlineStroke` read and write through. */\nexport interface CreateOutlinesAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  /** The text node behind `id`, or `undefined` for anything else. */\n  getTextSource(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Optional: the world-space path of the path node behind `id`, and the\n   * paint it wears. Outline Stroke reads both, and passes over a node that\n   * lacks either.\n   */\n  getWorldPath?(id: NodeId): Path | undefined;\n  getPaint?(id: NodeId): PathPaint | undefined;\n  /**\n   * Optional: the frame the node behind `id` draws its stroke in, as the\n   * matrix taking that frame to world (`poseFrameOf`); null or absent for a\n   * node drawn straight. Outline Stroke skews and stretches a world-width\n   * stroke with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Affine | null | undefined;\n  /**\n   * Mint one path node of node `sourceId`'s outlines. `path` is in world\n   * space. The node must wear `spec`'s fill and stroke — a text whose runs\n   * differ in paint gets one path per paint, and a filled node whose stroke\n   * is outlined gets one for the fill and one for the stroke — and sit under\n   * `spec.parent`. The kit places it; only the consumer knows its data shape,\n   * so anything else of the source's `data` worth keeping is the adapter's to\n   * copy: onto this path when it stands alone in the source's slot, onto the\n   * container when `createContainerNode` minted one.\n   */\n  createPathNode(path: Path, sourceId: NodeId, spec: OutlinePathSpec): { id: string };\n  /**\n   * Mint the container that holds one source's several paths, under `parent`.\n   * `bounds` is the world envelope of the paths. The kit puts the container in\n   * the source's slot and the paths inside it, back to front. Without this,\n   * the paths are laid flat in that slot instead.\n   */\n  createContainerNode?(sourceId: NodeId, spec: { parent: string | null; bounds: Rect }): { id: string };\n  /** Full node for `id`, so undo restores the text node whole. */\n  getNode(id: string): { id: string } | undefined | null;\n  /** The tree: each path is inserted at its source node's index among its\n   *  parent's children. */\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }, index?: number): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome of {@link applyCreateOutlines}. */\nexport type CreateOutlinesResult =\n  /** `resultIds` are what replaced the text nodes at their level — a path,\n   *  a container, or a run of flat paths each — which is also what is now\n   *  selected in the text nodes' place. */\n  | { kind: 'applied'; resultIds: string[] }\n  /** Nothing selected is text with ink. */\n  | { kind: 'noop'; reason: 'no-text' }\n  /** Some selected text has no outline geometry; nothing was changed. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\n/**\n * Convert every text node in the selection to outlines, as one batch labeled\n * \"Create Outlines\". Other selected nodes are left alone and stay selected.\n * All or nothing: if any text node's face cannot supply outlines the scene is\n * untouched and the error comes back in the result.\n */\nexport function applyCreateOutlines(adapter: CreateOutlinesAdapter): CreateOutlinesResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const converted: { id: NodeId; paths: PaintedPath[] }[] = [];\n  try {\n    for (const id of sel) {\n      const text = adapter.getTextSource(id);\n      if (!text) continue;\n      const paths = textToPathsByPaint(text.data, text.pose);\n      if (paths.length > 0) converted.push({ id, paths });\n    }\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  if (converted.length === 0) return { kind: 'noop', reason: 'no-text' };\n\n  const replaced = replaceWithPaths(adapter, sel, converted, 'Create Outlines');\n  return { kind: 'applied', resultIds: converted.flatMap((c) => replaced.get(c.id)!) };\n}\n"],"mappings":";;;AAwFA,SAAgBA,EAAoB,GAAsD;CACxF,IAAMC,IAAM,CAAC,GAAGC,EAAQ,aAAa,CAAC,GAChCC,IAAoD,CAAC;CAC3D,IAAI;EACF,KAAK,IAAMC,KAAMH,GAAK;GACpB,IAAMI,IAAOH,EAAQ,cAAcE,CAAE;GACrC,IAAI,CAACC,GAAM;GACX,IAAMC,IAAQC,EAAmBF,EAAK,MAAMA,EAAK,IAAI;GACrD,AAAIC,EAAM,SAAS,KAAGH,EAAU,KAAK;IAAE;IAAI;GAAM,CAAC;EACpD;CACF,SAASK,GAAK;EACZ,IAAIA,aAAeC,GAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAOD;EAAI;EACnG,MAAMA;CACR;CACA,IAAIL,EAAU,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAU;CAErE,IAAMO,IAAWC,EAAiBT,GAASD,GAAKE,GAAW,iBAAiB;CAC5E,OAAO;EAAE,MAAM;EAAW,WAAWA,EAAU,SAAS,MAAMO,EAAS,IAAIE,EAAE,EAAE,CAAE;CAAE;AACrF"}
+{"version":3,"file":"createOutlines.js","names":[],"sources":["../../../../src/interactions/actions/outlines/createOutlines.ts"],"sourcesContent":["/**\n * Create Outlines: replace each selected text node with path nodes carrying\n * its glyph outlines, giving up editability for geometry — the destructive\n * conversion every vector editor has. One path per paint the text wears; one\n * undoable batch; the replacement takes the text node's slot, so stacking\n * order is unchanged.\n */\nimport type { Affine, Path, Rect } from '@weasel-js/geom';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { textToPathsByPaint, TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport { replaceWithPaths, type PaintedPath } from './replaceWithPaths';\n\n/** What a path minted by an outline action must carry — see\n *  {@link CreateOutlinesAdapter.createPathNode}. */\nexport interface OutlinePathSpec extends PathPaint {\n  /** The parent the path goes under: the source's own, or the container\n   *  minted to hold a source's several paths. */\n  parent: string | null;\n}\n\n/** What `applyCreateOutlines` and `applyOutlineStroke` read and write through. */\nexport interface CreateOutlinesAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  /** The text node behind `id`, or `undefined` for anything else. */\n  getTextSource(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Optional: the world-space path of the path node behind `id`, and the\n   * paint it wears. Outline Stroke reads both, and passes over a node that\n   * lacks either.\n   */\n  getWorldPath?(id: NodeId): Path | undefined;\n  getPaint?(id: NodeId): PathPaint | undefined;\n  /**\n   * Optional: the frame the node behind `id` draws its stroke in, as the\n   * matrix taking that frame to world (`poseFrameOf`); null or absent for a\n   * node drawn straight. Outline Stroke skews and stretches a world-width\n   * stroke with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Affine | null | undefined;\n  /**\n   * Mint one path node of node `sourceId`'s outlines. `path` is in world\n   * space. The node must wear `spec`'s fill and stroke — a text whose runs\n   * differ in paint gets one path per paint, and a filled node whose stroke\n   * is outlined gets one for the fill and one for the stroke — and sit under\n   * `spec.parent`. The kit places it; only the consumer knows its data shape,\n   * so anything else of the source's `data` worth keeping is the adapter's to\n   * copy: onto this path when it stands alone in the source's slot, onto the\n   * container when `createContainerNode` minted one.\n   */\n  createPathNode(path: Path, sourceId: NodeId, spec: OutlinePathSpec): { id: string };\n  /**\n   * Mint the container that holds one source's several paths, under `parent`.\n   * `bounds` is the world envelope of the paths. The kit puts the container in\n   * the source's slot and the paths inside it, back to front. Without this,\n   * the paths are laid flat in that slot instead.\n   */\n  createContainerNode?(sourceId: NodeId, spec: { parent: string | null; bounds: Rect }): { id: string };\n  /** Full node for `id`, so undo restores the text node whole. */\n  getNode(id: string): { id: string } | undefined | null;\n  /** The tree: each path is inserted at its source node's index among its\n   *  parent's children. */\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }, index?: number): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome of {@link applyCreateOutlines}. */\nexport type CreateOutlinesResult =\n  /** `resultIds` are what replaced the text nodes at their level — a path,\n   *  a container, or a run of flat paths each — which is also what is now\n   *  selected in the text nodes' place. */\n  | { kind: 'applied'; resultIds: string[] }\n  /** Nothing selected is text with ink. */\n  | { kind: 'noop'; reason: 'no-text' }\n  /** Some selected text has no outline geometry; nothing was changed. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\n/**\n * Convert every text node in the selection to outlines, as one batch labeled\n * \"Create Outlines\". Other selected nodes are left alone and stay selected.\n * All or nothing: if any text node's face cannot supply outlines the scene is\n * untouched and the error comes back in the result.\n */\nexport function applyCreateOutlines(adapter: CreateOutlinesAdapter): CreateOutlinesResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const converted: { id: NodeId; paths: PaintedPath[] }[] = [];\n  try {\n    for (const id of sel) {\n      const text = adapter.getTextSource(id);\n      if (!text) continue;\n      const paths = textToPathsByPaint(text.data, text.pose);\n      if (paths.length > 0) converted.push({ id, paths });\n    }\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  if (converted.length === 0) return { kind: 'noop', reason: 'no-text' };\n\n  const replaced = replaceWithPaths(adapter, sel, converted, 'Create Outlines');\n  return { kind: 'applied', resultIds: converted.flatMap((c) => replaced.get(c.id)!) };\n}\n"],"mappings":";;;;;;;;;;AAwFA,SAAgB,oBAAoB,SAAsD;CACxF,MAAM,MAAM,CAAC,GAAG,QAAQ,aAAa,CAAC;CACtC,MAAM,YAAoD,CAAC;CAC3D,IAAI;EACF,KAAK,MAAM,MAAM,KAAK;GACpB,MAAM,OAAO,QAAQ,cAAc,EAAE;GACrC,IAAI,CAAC,MAAM;GACX,MAAM,QAAQ,mBAAmB,KAAK,MAAM,KAAK,IAAI;GACrD,IAAI,MAAM,SAAS,GAAG,UAAU,KAAK;IAAE;IAAI;GAAM,CAAC;EACpD;CACF,SAAS,KAAK;EACZ,IAAI,eAAe,mBAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAO;EAAI;EACnG,MAAM;CACR;CACA,IAAI,UAAU,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAU;CAErE,MAAM,WAAW,iBAAiB,SAAS,KAAK,WAAW,iBAAiB;CAC5E,OAAO;EAAE,MAAM;EAAW,WAAW,UAAU,SAAS,MAAM,SAAS,IAAI,EAAE,EAAE,CAAE;CAAE;AACrF"}