@weasel-js/core 1.6.1 → 1.7.1

package/dist/interactions/actions/move/behaviors/snapBackOrDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapBackOrDelete.js","names":["SNAPSHOTS","scratchKey","INDEXES","snapBackOrDelete","args","proj","AUTO_ORIGIN_PROJECTION","r2","radius","snapshots","indexes","nodes","ctx","id","obj","n","setScratch","o0","o1","dx","dy","onFreeRelease","getScratch","index","createDeleteOp","deleteLabel"],"sources":["../../../../../src/interactions/actions/move/behaviors/snapBackOrDelete.ts"],"sourcesContent":["import { createDeleteOp } from 'core/ops/delete';\nimport type { Op } from 'core/ops/types';\nimport type { MoveBehavior } from '../../../gestures/types';\nimport {\n  AUTO_ORIGIN_PROJECTION,\n  type OriginProjection,\n} from '../../../gestures/shared/originProjection';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\n\nconst SNAPSHOTS = scratchKey<Map<string, { id: string }>>('snapBackOrDelete.snapshots');\nconst INDEXES = scratchKey<Map<string, number>>('snapBackOrDelete.indexes');\n\n/**\n * Move behavior for a drag that is only meaningful near where it started:\n * release inside `radius` and the node returns to its original pose; release\n * outside it and the node either springs back anyway or is deleted, per\n * `onFreeRelease`. A deletion is recorded as an undoable op with paint order\n * preserved.\n */\nexport function snapBackOrDelete<TPose extends { x: number; y: number }>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n}): MoveBehavior<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the behavior how\n *  to read and write the pose's origin. */\nexport function snapBackOrDelete<TPose>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n  origin: OriginProjection<TPose>;\n}): MoveBehavior<TPose>;\n/** Snap back to the origin pose, or delete, depending on where the drag is\n *  released. */\nexport function snapBackOrDelete<TPose>(args: {\n  radius: number;\n  onFreeRelease: 'snap-back' | 'delete';\n  deleteLabel?: string;\n  origin?: OriginProjection<TPose>;\n}): MoveBehavior<TPose> {\n  const { radius, onFreeRelease, deleteLabel = 'Delete' } = args;\n  const proj: OriginProjection<TPose> =\n    args.origin ?? (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const r2 = radius * radius;\n\n  return {\n    onStart(ctx) {\n      // Snapshot the dragged objects + their z-indexes at gesture start so\n      // delete can undo with paint order intact.\n      const snapshots = new Map<string, { id: string }>();\n      const indexes = new Map<string, number>();\n      const nodes = ctx.adapter.getNodes();\n      for (const id of ctx.draggedIds) {\n        const obj = ctx.adapter.getNode(id) ?? { id };\n        snapshots.set(id, obj);\n        indexes.set(id, nodes.findIndex((n) => n.id === id));\n      }\n      setScratch(ctx.scratch, SNAPSHOTS, snapshots);\n      setScratch(ctx.scratch, INDEXES, indexes);\n    },\n\n    onEnd(ctx) {\n      if (ctx.snap) return;\n      const id = ctx.draggedIds[0];\n      const o0 = proj.getOrigin(ctx.origin.get(id)!);\n      const o1 = proj.getOrigin(ctx.current.get(id)!);\n      const dx = o1.x - o0.x;\n      const dy = o1.y - o0.y;\n      const within = dx * dx + dy * dy <= r2;\n      if (within) {\n        return null;\n      }\n      if (onFreeRelease === 'delete') {\n        const snapshots = getScratch(ctx.scratch, SNAPSHOTS);\n        const indexes = getScratch(ctx.scratch, INDEXES);\n        const obj = snapshots?.get(id) ?? { id };\n        const index = indexes?.get(id) ?? -1;\n        const ops: Op[] = [createDeleteOp({ node: obj, label: deleteLabel, index })];\n        return ops;\n      }\n      // `'snap-back'` — abort, same as a release inside the radius. Returning\n      // `undefined` would defer to the default translate and leave the node\n      // where it was dropped, which is the one thing this policy rules out.\n      return null;\n    },\n  };\n}\n"],"mappings":";;;;AASA,IAAMA,IAAYC,EAAwC,4BAA4B,GAChFC,IAAUD,EAAgC,0BAA0B;AAwB1E,SAAgBE,EAAwB,GAKhB;CACtB,IAAM,EAAE,WAAQ,kBAAe,iBAAc,aAAaC,GACpDC,IACJD,EAAK,UAAWE,GACZC,IAAKC,IAASA;CAEpB,OAAO;EACL,QAAQ,GAAK;GAGX,IAAMC,oBAAY,IAAI,IAA4B,GAC5CC,oBAAU,IAAI,IAAoB,GAClCC,IAAQC,EAAI,QAAQ,SAAS;GACnC,KAAK,IAAMC,KAAMD,EAAI,YAAY;IAC/B,IAAME,IAAMF,EAAI,QAAQ,QAAQC,CAAE,KAAK,EAAE,MAAG;IAE5C,AADAJ,EAAU,IAAII,GAAIC,CAAG,GACrBJ,EAAQ,IAAIG,GAAIF,EAAM,WAAW,MAAMI,EAAE,OAAOF,CAAE,CAAC;GACrD;GAEA,AADAG,EAAWJ,EAAI,SAASZ,GAAWS,CAAS,GAC5CO,EAAWJ,EAAI,SAASV,GAASQ,CAAO;EAC1C;EAEA,MAAM,GAAK;GACT,IAAIE,EAAI,MAAM;GACd,IAAMC,IAAKD,EAAI,WAAW,IACpBK,IAAKZ,EAAK,UAAUO,EAAI,OAAO,IAAIC,CAAE,CAAE,GACvCK,IAAKb,EAAK,UAAUO,EAAI,QAAQ,IAAIC,CAAE,CAAE,GACxCM,IAAKD,EAAG,IAAID,EAAG,GACfG,IAAKF,EAAG,IAAID,EAAG;GAErB,IADeE,IAAKA,IAAKC,IAAKA,KAAMb,GAElC,OAAO;GAET,IAAIc,MAAkB,UAAU;IAC9B,IAAMZ,IAAYa,EAAWV,EAAI,SAASZ,CAAS,GAC7CU,IAAUY,EAAWV,EAAI,SAASV,CAAO,GACzCY,IAAML,GAAW,IAAII,CAAE,KAAK,EAAE,MAAG,GACjCU,IAAQb,GAAS,IAAIG,CAAE,KAAK;IAElC,OAAO,CADYW,EAAe;KAAE,MAAMV;KAAK,OAAOW;KAAa;IAAM,CAAC,CACnE;GACT;GAIA,OAAO;EACT;CACF;AACF"}

package/dist/interactions/actions/move/behaviors/snapToContainer.js

@@ -0,0 +1,67 @@
+import { createTransformOp as e } from "../../../../core/ops/transform.js";
+import { createReparentOp as t } from "../../../../core/ops/reparent.js";
+import { getScratch as n, scratchKey as r, setScratch as i } from "@weasel-js/routing";
+//#region src/interactions/actions/move/behaviors/snapToContainer.ts
+var a = r("snapToContainer");
+function o(e) {
+	let t = n(e.scratch, a);
+	return t || (t = {
+		pendingTargetId: null,
+		pendingTimer: null,
+		committedSnap: null
+	}, i(e.scratch, a, t)), t;
+}
+function s(e) {
+	e.pendingTimer !== null && (clearTimeout(e.pendingTimer), e.pendingTimer = null), e.pendingTargetId = null;
+}
+function c(n) {
+	let { dwellMs: r, findTarget: i, isInstant: a, moveLabel: c = "Move", reparentLabel: l = "Move and reparent" } = n;
+	return {
+		onMove(e, t) {
+			let n = o(e), c = i(e.draggedIds[0], e.pointer.worldX, e.pointer.worldY);
+			if (n.committedSnap) {
+				if (c && c.parentId === n.committedSnap.parentId) return {
+					pose: n.committedSnap.slotPose,
+					snap: n.committedSnap
+				};
+				n.committedSnap = null;
+			}
+			if (!c) {
+				s(n);
+				return;
+			}
+			if (a?.(c)) return s(n), n.committedSnap = c, {
+				pose: c.slotPose,
+				snap: c
+			};
+			n.pendingTargetId !== c.parentId && (s(n), n.pendingTargetId = c.parentId, n.pendingTimer = setTimeout(() => {
+				n.committedSnap = c, n.pendingTimer = null;
+			}, r));
+		},
+		onCancel(e) {
+			s(o(e));
+		},
+		onEnd(n) {
+			let r = o(n);
+			s(r);
+			let i = r.committedSnap ?? n.snap;
+			if (!i) return;
+			let a = n.draggedIds[0], u = n.adapter.getParent?.(a) ?? null, d = n.origin.get(a), f = [e({
+				id: a,
+				from: d,
+				to: i.slotPose,
+				label: c
+			})];
+			return u !== i.parentId && f.push(t({
+				id: a,
+				fromParentId: u,
+				toParentId: i.parentId,
+				label: l
+			})), f;
+		}
+	};
+}
+//#endregion
+export { c as snapToContainer };
+
+//# sourceMappingURL=snapToContainer.js.map

package/dist/interactions/actions/move/behaviors/snapToContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapToContainer.js","names":["STATE","scratchKey","getState","s","getScratch","ctx","setScratch","clearTimer","snapToContainer","args","target","findTarget","isInstant","dwellMs","snap","draggedId","oldParent","fromPose","ops","createTransformOp","moveLabel","createReparentOp","reparentLabel"],"sources":["../../../../../src/interactions/actions/move/behaviors/snapToContainer.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport { createReparentOp } from 'core/ops/reparent';\nimport type { Op } from 'core/ops/types';\nimport type { SnapTarget } from 'core/adapters/types';\nimport type { MoveBehavior, GestureContext } from '../../../gestures/types';\nimport { scratchKey, getScratch, setScratch } from '@weasel-js/routing';\n\ninterface SnapState<TPose> {\n  pendingTargetId: string | null;\n  pendingTimer: ReturnType<typeof setTimeout> | null;\n  committedSnap: SnapTarget<TPose> | null;\n}\n\n// The slot is generic over TPose; we keep the unknown-pose key at module\n// scope and project it through `as` at the read site (each consumer call\n// of `snapToContainer<TPose>` is the only writer of its own SnapState\n// instance, so the cast is safe at runtime).\nconst STATE = scratchKey<SnapState<unknown>>('snapToContainer');\n\nfunction getState<TPose>(ctx: GestureContext<TPose>): SnapState<TPose> {\n  let s = getScratch(ctx.scratch, STATE) as SnapState<TPose> | undefined;\n  if (!s) {\n    s = { pendingTargetId: null, pendingTimer: null, committedSnap: null };\n    setScratch(ctx.scratch, STATE, s as SnapState<unknown>);\n  }\n  return s;\n}\n\nfunction clearTimer<TPose>(s: SnapState<TPose>) {\n  if (s.pendingTimer !== null) {\n    clearTimeout(s.pendingTimer);\n    s.pendingTimer = null;\n  }\n  s.pendingTargetId = null;\n}\n\n/**\n * Move behavior that drops the dragged node into a container it hovers over\n * for `dwellMs`, reparenting it and taking the pose the container's layout\n * assigns.\n *\n * The dwell is what keeps a drag that merely passes over a container from\n * being captured by it.\n */\nexport function snapToContainer<TPose>(args: {\n  dwellMs: number;\n  findTarget: (\n    draggedId: string,\n    worldX: number,\n    worldY: number,\n  ) => SnapTarget<TPose> | null;\n  isInstant?: (target: SnapTarget<TPose>) => boolean;\n  moveLabel?: string;\n  reparentLabel?: string;\n}): MoveBehavior<TPose> {\n  const { dwellMs, findTarget, isInstant, moveLabel = 'Move', reparentLabel = 'Move and reparent' } = args;\n\n  return {\n    onMove(ctx, _proposed) {\n      const s = getState<TPose>(ctx);\n      const target = findTarget(ctx.draggedIds[0], ctx.pointer.worldX, ctx.pointer.worldY);\n\n      if (s.committedSnap) {\n        if (target && target.parentId === s.committedSnap.parentId) {\n          return { pose: s.committedSnap.slotPose, snap: s.committedSnap };\n        }\n        s.committedSnap = null;\n      }\n\n      if (!target) {\n        clearTimer(s);\n        return;\n      }\n\n      if (isInstant?.(target)) {\n        clearTimer(s);\n        s.committedSnap = target;\n        return { pose: target.slotPose, snap: target };\n      }\n\n      if (s.pendingTargetId === target.parentId) {\n        return;\n      }\n      clearTimer(s);\n      s.pendingTargetId = target.parentId;\n      s.pendingTimer = setTimeout(() => {\n        s.committedSnap = target;\n        s.pendingTimer = null;\n      }, dwellMs);\n      return;\n    },\n\n    onCancel(ctx) { clearTimer(getState<TPose>(ctx)); },\n\n    onEnd(ctx) {\n      const s = getState<TPose>(ctx);\n      clearTimer(s);\n      const snap = s.committedSnap ?? ctx.snap;\n      if (!snap) return;\n      const draggedId = ctx.draggedIds[0];\n      const oldParent = ctx.adapter.getParent?.(draggedId) ?? null;\n      const fromPose = ctx.origin.get(draggedId)!;\n      const ops: Op[] = [\n        createTransformOp<TPose>({\n          id: draggedId,\n          from: fromPose,\n          to: snap.slotPose,\n          label: moveLabel,\n        }),\n      ];\n      if (oldParent !== snap.parentId) {\n        ops.push(createReparentOp({\n          id: draggedId,\n          fromParentId: oldParent,\n          toParentId: snap.parentId,\n          label: reparentLabel,\n        }));\n      }\n      return ops;\n    },\n  };\n}\n"],"mappings":";;;;AAiBA,IAAMA,IAAQC,EAA+B,iBAAiB;AAE9D,SAASC,EAAgB,GAA8C;CACrE,IAAIC,IAAIC,EAAWC,EAAI,SAASL,CAAK;CAKrC,OAJKG,MACH,IAAI;EAAE,iBAAiB;EAAM,cAAc;EAAM,eAAe;CAAK,GACrEG,EAAWD,EAAI,SAASL,GAAOG,CAAuB,IAEjDA;AACT;AAEA,SAASI,EAAkB,GAAqB;CAK9C,AAJIJ,EAAE,iBAAiB,SACrB,aAAaA,EAAE,YAAY,GAC3B,EAAE,eAAe,OAEnB,EAAE,kBAAkB;AACtB;AAUA,SAAgBK,EAAuB,GAUf;CACtB,IAAM,EAAE,YAAS,eAAY,cAAW,eAAY,QAAQ,mBAAgB,wBAAwBC;CAEpG,OAAO;EACL,OAAO,GAAK,GAAW;GACrB,IAAMN,IAAID,EAAgBG,CAAG,GACvBK,IAASC,EAAWN,EAAI,WAAW,IAAIA,EAAI,QAAQ,QAAQA,EAAI,QAAQ,MAAM;GAEnF,IAAIF,EAAE,eAAe;IACnB,IAAIO,KAAUA,EAAO,aAAaP,EAAE,cAAc,UAChD,OAAO;KAAE,MAAMA,EAAE,cAAc;KAAU,MAAMA,EAAE;IAAc;IAEjE,EAAE,gBAAgB;GACpB;GAEA,IAAI,CAACO,GAAQ;IACX,EAAWP,CAAC;IACZ;GACF;GAEA,IAAIS,IAAYF,CAAM,GAGpB,OAFAH,EAAWJ,CAAC,GACZ,EAAE,gBAAgBO,GACX;IAAE,MAAMA,EAAO;IAAU,MAAMA;GAAO;GAG/C,AAAIP,EAAE,oBAAoBO,EAAO,aAGjCH,EAAWJ,CAAC,GACZ,EAAE,kBAAkBO,EAAO,UAC3B,EAAE,eAAe,iBAAiB;IAEhC,AADA,EAAE,gBAAgBA,GAClB,EAAE,eAAe;GACnB,GAAGG,CAAO;EAEZ;EAEA,SAAS,GAAK;GAAE,EAAWX,EAAgBG,CAAG,CAAC;EAAG;EAElD,MAAM,GAAK;GACT,IAAMF,IAAID,EAAgBG,CAAG;GAC7B,EAAWF,CAAC;GACZ,IAAMW,IAAOX,EAAE,iBAAiBE,EAAI;GACpC,IAAI,CAACS,GAAM;GACX,IAAMC,IAAYV,EAAI,WAAW,IAC3BW,IAAYX,EAAI,QAAQ,YAAYU,CAAS,KAAK,MAClDE,IAAWZ,EAAI,OAAO,IAAIU,CAAS,GACnCG,IAAY,CAChBC,EAAyB;IACvB,IAAIJ;IACJ,MAAME;IACN,IAAIH,EAAK;IACT,OAAOM;GACT,CAAC,CACH;GASA,OARIJ,MAAcF,EAAK,YACrBI,EAAI,KAAKG,EAAiB;IACxB,IAAIN;IACJ,cAAcC;IACd,YAAYF,EAAK;IACjB,OAAOQ;GACT,CAAC,CAAC,GAEGJ;EACT;CACF;AACF"}

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

@@ -0,0 +1,37 @@
+import { documentPose as e } from "../../../core/scene/effectivePose.js";
+import { asNodeId as t } from "../../../core/scene/types.js";
+import { fnFieldsOfNode as n } from "../../../core/scene/nodeFnFields.js";
+//#region src/interactions/actions/move/gestureAdapter.ts
+function r(r) {
+	return {
+		getNode: (e) => r.get(t(e)),
+		getNodes: () => [...r.renderOrderNodes()],
+		getPose: (n) => e(r, r.get(t(n))),
+		getParent: (e) => r.get(t(e))?.parent ?? null,
+		setPose: (e, n) => r.setPose(t(e), n),
+		setParent: (e, n) => r.move(t(e), n === null ? null : t(n)),
+		setData: (e, n) => r.update(t(e), { data: n }),
+		removeNode: (e) => r.remove(t(e)),
+		insertNode: (e, t) => r.add({
+			kind: e.kind,
+			layer: e.layer,
+			pose: e.pose,
+			data: e.data,
+			id: e.id,
+			...t === void 0 ? {} : { index: t },
+			...e.parent === null ? {} : { parent: e.parent },
+			...e.dependsOn === void 0 ? {} : { dependsOn: e.dependsOn },
+			...n(e)
+		}),
+		getChildren: (e) => e === null ? [...r.roots] : [...r.childrenOf(t(e))],
+		setChildOrder: (e, n) => {
+			r.batch("Reorder", () => {
+				for (let i = 0; i < n.length; i++) (e === null ? r.roots : r.childrenOf(t(e)))[i] !== n[i] && r.reorder(t(n[i]), i);
+			});
+		}
+	};
+}
+//#endregion
+export { r as moveGestureAdapter };
+
+//# sourceMappingURL=gestureAdapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gestureAdapter.js","names":["moveGestureAdapter","scene","asNodeId","id","documentPose","pose","parentId","node","index","fnFieldsOfNode","ids"],"sources":["../../../../src/interactions/actions/move/gestureAdapter.ts"],"sourcesContent":["/**\n * Minimal scene-backed adapter for the move behavior pipeline.\n *\n * Lives in `interactions/` rather than reusing `canvas/sceneAdapter.ts` so the\n * move action does not import from `canvas/` (that back-edge would create an\n * `interactions → canvas → interactions` cycle). Carries exactly the methods\n * the move behaviors call (`getParent` / `getNodes` / `getNode`) plus the\n * mutators the committed ops apply through (`setPose` / `setParent` /\n * `setData` / `removeNode` / `insertNode` — `setData` carries the\n * geometryProjection seam's data-sync op) and the sibling-order seam\n * (`getChildren` / `setChildOrder`) those ops read to restore a node's slot.\n */\nimport { documentPose } from 'core/scene/effectivePose';\nimport { fnFieldsOfNode } from 'core/scene/nodeFnFields';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { MoveAdapter } from 'core/adapters/types';\n\nexport type MoveGestureAdapter<TPose> = MoveAdapter<Node<unknown, string, TPose>, TPose> & {\n  /** Required override — this adapter always provides parent lookup. */\n  getParent(id: string): string | null;\n  setParent(id: string, parentId: string | null): void;\n  setData(id: string, data: unknown): void;\n  removeNode(id: string): void;\n  insertNode(node: Node<unknown, string, TPose>, index?: number): void;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n};\n\nexport function moveGestureAdapter<TPose>(\n  scene: Scene<unknown, string, TPose>,\n): MoveGestureAdapter<TPose> {\n  return {\n    getNode: (id) => scene.get(asNodeId(id)),\n    getNodes: () => {\n      return [...scene.renderOrderNodes()] as Node<unknown, string, TPose>[];\n    },\n    getPose: (id) => documentPose(scene, scene.get(asNodeId(id))!),\n    getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,\n    setPose: (id, pose) => scene.setPose(asNodeId(id), pose),\n    setParent: (id, parentId) =>\n      scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId)),\n    setData: (id, data) => scene.update(asNodeId(id), { data } as never),\n    removeNode: (id) => scene.remove(asNodeId(id)),\n    insertNode: (node, index) =>\n      scene.add({\n        kind: node.kind,\n        layer: node.layer,\n        pose: node.pose,\n        data: node.data,\n        id: node.id,\n        ...(index !== undefined ? { index } : {}),\n        ...(node.parent !== null ? { parent: node.parent } : {}),\n        ...(node.dependsOn !== undefined ? { dependsOn: node.dependsOn } : {}),\n        ...fnFieldsOfNode(node),\n      }),\n    getChildren: (parentId) =>\n      parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))],\n    setChildOrder: (parentId, ids) => {\n      scene.batch('Reorder', () => {\n        for (let i = 0; i < ids.length; i++) {\n          const current = parentId === null ? scene.roots : scene.childrenOf(asNodeId(parentId));\n          if (current[i] === ids[i]) continue;\n          scene.reorder(asNodeId(ids[i]), i);\n        }\n      });\n    },\n  };\n}\n"],"mappings":";;;;AA6BA,SAAgBA,EACd,GAC2B;CAC3B,OAAO;EACL,UAAU,MAAOC,EAAM,IAAIC,EAASC,CAAE,CAAC;EACvC,gBACS,CAAC,GAAGF,EAAM,iBAAiB,CAAC;EAErC,UAAU,MAAOG,EAAaH,GAAOA,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAE;EAC7D,YAAY,MAAOF,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAC,EAAE,UAAU;EACtD,UAAU,GAAI,MAASF,EAAM,QAAQC,EAASC,CAAE,GAAGE,CAAI;EACvD,YAAY,GAAI,MACdJ,EAAM,KAAKC,EAASC,CAAE,GAAGG,MAAa,OAAO,OAAOJ,EAASI,CAAQ,CAAC;EACxE,UAAU,GAAI,MAASL,EAAM,OAAOC,EAASC,CAAE,GAAG,EAAE,QAAK,CAAU;EACnE,aAAa,MAAOF,EAAM,OAAOC,EAASC,CAAE,CAAC;EAC7C,aAAa,GAAM,MACjBF,EAAM,IAAI;GACR,MAAMM,EAAK;GACX,OAAOA,EAAK;GACZ,MAAMA,EAAK;GACX,MAAMA,EAAK;GACX,IAAIA,EAAK;GACT,GAAIC,MAAU,KAAA,IAAwB,CAAC,IAAb,EAAE,SAAM;GAClC,GAAID,EAAK,WAAW,OAAiC,CAAC,IAA3B,EAAE,QAAQA,EAAK,OAAO;GACjD,GAAIA,EAAK,cAAc,KAAA,IAA4C,CAAC,IAAjC,EAAE,WAAWA,EAAK,UAAU;GAC/D,GAAGE,EAAeF,CAAI;EACxB,CAAC;EACH,cAAc,MACZD,MAAa,OAAO,CAAC,GAAGL,EAAM,KAAK,IAAI,CAAC,GAAGA,EAAM,WAAWC,EAASI,CAAQ,CAAC,CAAC;EACjF,gBAAgB,GAAU,MAAQ;GAChC,EAAM,MAAM,iBAAiB;IAC3B,KAAK,IAAI,IAAI,GAAG,IAAII,EAAI,QAAQ,KAE9B,CADgBJ,MAAa,OAAOL,EAAM,QAAQA,EAAM,WAAWC,EAASI,CAAQ,CAAC,EAAA,CACzE,OAAOI,EAAI,MACvBT,EAAM,QAAQC,EAASQ,EAAI,EAAE,GAAG,CAAC;GAErC,CAAC;EACH;CACF;AACF"}

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

@@ -0,0 +1,84 @@
+import { locateChild as e } from "../../../core/ops/slot.js";
+import { unionBounds as t } from "../../../core/geometry/unionBounds.js";
+import { createDeleteOp as n } from "../../../core/ops/delete.js";
+import { createInsertOp as r } from "../../../core/ops/create.js";
+import { dispatchApplyBatch as i } from "../../../core/applyOps.js";
+import { createSetSelectionOp as a } from "../../../core/ops/select.js";
+import { TextOutlinesError as o, textToPathsByPaint as s } from "../../../features/text/textToPath.js";
+import { boundsOfPath as c } from "@weasel-js/geom";
+//#region src/interactions/actions/outlines/createOutlines.ts
+function l(t) {
+	let c = [...t.getSelection()], l = [];
+	try {
+		for (let e of c) {
+			let n = t.getTextSource(e);
+			if (!n) continue;
+			let r = s(n.data, n.pose);
+			r.length > 0 && l.push({
+				id: e,
+				paths: r
+			});
+		}
+	} catch (e) {
+		if (e instanceof o) return {
+			kind: "failed",
+			reason: "text-outlines",
+			error: e
+		};
+		throw e;
+	}
+	if (l.length === 0) return {
+		kind: "noop",
+		reason: "no-text"
+	};
+	let f = [], p = /* @__PURE__ */ new Map(), m = [...l.map((n) => ({
+		...n,
+		at: e(t, n.id)
+	}))].sort((e, t) => (t.at?.index ?? -1) - (e.at?.index ?? -1));
+	for (let { id: e, paths: i, at: a } of m) {
+		let o = t.getNode?.(e) ?? { id: e }, s = a?.index ?? -1, c = a?.parentId ?? t.getParent?.(e) ?? null, l = (e, t) => r(s >= 0 ? {
+			node: e,
+			index: s + t
+		} : { node: e });
+		f.push(n({
+			node: o,
+			index: s
+		}));
+		let m = i.length > 1 ? t.createContainerNode?.(e, {
+			parent: c,
+			bounds: d(i)
+		}) : void 0;
+		if (m) {
+			f.push(l(m, 0));
+			for (let n of i) f.push(r({ node: t.createPathNode(n.path, e, u(n, m.id)) }));
+			p.set(e, [m.id]);
+		} else {
+			let n = i.map((n) => t.createPathNode(n.path, e, u(n, c)));
+			n.forEach((e, t) => f.push(l(e, t))), p.set(e, n.map((e) => e.id));
+		}
+	}
+	return f.push(a({
+		from: c,
+		to: c.flatMap((e) => p.get(e) ?? [e])
+	})), i(t, f, "Create Outlines"), {
+		kind: "applied",
+		resultIds: l.flatMap((e) => p.get(e.id))
+	};
+}
+function u(e, t) {
+	return e.stroke === void 0 ? {
+		fill: e.fill,
+		parent: t
+	} : {
+		fill: e.fill,
+		stroke: e.stroke,
+		parent: t
+	};
+}
+function d(e) {
+	return t(e.map((e) => c(e.path)));
+}
+//#endregion
+export { l as applyCreateOutlines };
+
+//# sourceMappingURL=createOutlines.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createOutlines.js","names":["applyCreateOutlines","sel","adapter","converted","id","text","paths","textToPathsByPaint","err","TextOutlinesError","ops","replaced","order","c","locateChild","b","a","node","index","at","parent","place","createInsertOp","created","i","createDeleteOp","container","envelope","p","specOf","n","createSetSelectionOp","dispatchApplyBatch","unionBounds","boundsOfPath"],"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 { boundsOfPath, type PolygonPath, type Rect } from '@weasel-js/geom';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport { locateChild } from 'core/ops/slot';\nimport { unionBounds } from 'core/geometry/unionBounds';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport {\n  textToPathsByPaint, TextOutlinesError, type TextNodeSource, type TextPaintPath,\n} from 'features/text/textToPath';\n\n/** What a path minted by Create Outlines must carry — see\n *  {@link CreateOutlinesAdapter.createPathNode}. */\nexport interface OutlinePathSpec {\n  /** The fill these glyphs wear, resolved: their run's, else the node's,\n   *  else the default text fill. `null` is no fill. */\n  fill: FillStyle | null;\n  /** The stroke they wear, resolved the same way; absent for none. */\n  stroke?: Stroke;\n  /** The parent the path goes under: the text's own, or the container\n   *  minted to hold a multi-paint text's paths. */\n  parent: string | null;\n}\n\n/** What `applyCreateOutlines` reads and writes 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   * Mint one path node of text 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 sit under `spec.parent`.\n   * The kit places it; only the consumer knows its data shape.\n   */\n  createPathNode(path: PolygonPath, sourceId: NodeId, spec: OutlinePathSpec): { id: string };\n  /**\n   * Mint the container that holds a multi-paint text's paths, under `parent`.\n   * `bounds` is the world envelope of the paths. The kit puts the container in\n   * the text's slot and the paths inside it, in the text's order. Without\n   * this, 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. Without it the\n   *  delete captures an `{ id }` stub. */\n  getNode?(id: string): { id: string } | undefined | null;\n  /** Parent and sibling order — the reorder contract. With both, each path is\n   *  inserted at its text node's index; without, where `insertNode` defaults. */\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly 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: TextPaintPath[] }[] = [];\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 ops: Op[] = [];\n  const replaced = new Map<NodeId, string[]>();\n  // Replacements in the same parent are inserted top slot first, so an\n  // earlier one widening the sibling list cannot shift a later one's index.\n  const located = converted.map((c) => ({ ...c, at: locateChild(adapter, c.id) }));\n  const order = [...located].sort((a, b) => (b.at?.index ?? -1) - (a.at?.index ?? -1));\n  for (const { id, paths, at } of order) {\n    const node = adapter.getNode?.(id) ?? { id };\n    const index = at?.index ?? -1;\n    const parent = at?.parentId ?? adapter.getParent?.(id) ?? null;\n    const place = (created: { id: string }, i: number) =>\n      createInsertOp(index >= 0 ? { node: created, index: index + i } : { node: created });\n    ops.push(createDeleteOp({ node, index }));\n\n    const container = paths.length > 1\n      ? adapter.createContainerNode?.(id, { parent, bounds: envelope(paths) })\n      : undefined;\n    if (container) {\n      ops.push(place(container, 0));\n      for (const p of paths) {\n        ops.push(createInsertOp({ node: adapter.createPathNode(p.path, id, specOf(p, container.id)) }));\n      }\n      replaced.set(id, [container.id]);\n    } else {\n      const created = paths.map((p) => adapter.createPathNode(p.path, id, specOf(p, parent)));\n      created.forEach((n, i) => ops.push(place(n, i)));\n      replaced.set(id, created.map((n) => n.id));\n    }\n  }\n  ops.push(createSetSelectionOp({\n    from: sel,\n    to: sel.flatMap((id) => (replaced.get(id) ?? [id]) as NodeId[]),\n  }));\n  dispatchApplyBatch(adapter, ops, 'Create Outlines');\n  return { kind: 'applied', resultIds: converted.flatMap((c) => replaced.get(c.id)!) };\n}\n\nfunction specOf(p: TextPaintPath, parent: string | null): OutlinePathSpec {\n  return p.stroke !== undefined ? { fill: p.fill, stroke: p.stroke, parent } : { fill: p.fill, parent };\n}\n\nfunction envelope(paths: readonly TextPaintPath[]): Rect {\n  return unionBounds(paths.map((p) => boundsOfPath(p.path)))!;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { useDepSource as e } from "@weasel-js/routing/react";
+//#region src/interactions/actions/outlines/useCreateOutlinesAdapter.ts
+function t(t) {
+	e("createOutlinesAdapter", () => t);
+}
+//#endregion
+export { t as useCreateOutlinesAdapter };
+
+//# sourceMappingURL=useCreateOutlinesAdapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateOutlinesAdapter.js","names":["useCreateOutlinesAdapter","adapter"],"sources":["../../../../src/interactions/actions/outlines/useCreateOutlinesAdapter.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport type { CreateOutlinesAdapter } from './createOutlines';\n\n/** Publish a Create Outlines adapter so the built-in `createOutlines` action\n *  can run. Silently does nothing outside a `<DepRegistryProvider>`. */\nexport function useCreateOutlinesAdapter(adapter: CreateOutlinesAdapter): void {\n  useDepSource('createOutlinesAdapter', () => adapter);\n}\n"],"mappings":";;AAKA,SAAgBA,EAAyB,GAAsC;CAC7E,EAAa,+BAA+BC,CAAO;AACrD"}

package/dist/interactions/actions/planeInput.js

@@ -0,0 +1,168 @@
+import { deriveParallaxView as e, fromPlane as t, planeMap as n, rectFromPlane as r, toPlane as i } from "../../core/viewport/parallax.js";
+import { asNodeId as a } from "../../core/scene/types.js";
+//#region src/interactions/actions/planeInput.ts
+var o = (e, t) => t ? e.scene?.get(a(t))?.layer : void 0, s = (e, t) => {
+	let n = e.selection;
+	for (let r of [...t?.targetIds ?? [], ...n?.get() ?? []]) {
+		let t = o(e, r);
+		if (t !== void 0) return t;
+	}
+}, c = (e) => e.insert?.layer?.(), l = (e) => o(e, e.editAnchors?.editingId);
+function u(e, t) {
+	let n = e.invoker;
+	if (!n) return e;
+	let r = e.requires ?? [], a = [.../* @__PURE__ */ new Set([
+		...r,
+		"scene",
+		"selection",
+		"view"
+	])];
+	return n.timing === "immediate" ? {
+		...e,
+		requires: a,
+		invoker: {
+			timing: "immediate",
+			run(e, a) {
+				let o = d(e, t(e), r, null);
+				if (o === null) return n.run(e, a);
+				let s = a?.worldX, c = a?.worldY, l = typeof s == "number" && typeof c == "number" ? i(o.map(), {
+					x: s,
+					y: c
+				}) : null;
+				n.run(o.deps, l ? {
+					...a,
+					worldX: l.x,
+					worldY: l.y
+				} : a);
+			}
+		}
+	} : {
+		...e,
+		requires: a,
+		invoker: {
+			timing: "ongoing",
+			start(e, i) {
+				let a = d(e.deps, t(e.deps, e.drag?.affordance), r, e.drag?.start ?? null);
+				return a === null ? n.start(e, i) : p(n.start(a.carry(e), i), a);
+			}
+		}
+	};
+}
+function d(r, a, o, s) {
+	let c = r.scene, l = r.view;
+	if (a === void 0 || !c || !l) return null;
+	let u = () => c.layers.find((e) => e.id === a)?.parallax;
+	if (u() === void 0) return null;
+	let d = {
+		scale: {
+			x: 1,
+			y: 1
+		},
+		offset: {
+			x: 0,
+			y: 0
+		}
+	}, p = () => {
+		let e = u();
+		return e ? n(l.get(), e) : d;
+	}, m = Object.defineProperties(Object.create(l), {
+		get: { value: () => {
+			let t = u(), n = l.get();
+			return t ? e(n, t) : n;
+		} },
+		plane: { value: p }
+	}), h = Object.create(r), g = (e, t) => Object.defineProperty(h, e, {
+		value: t,
+		enumerable: !0
+	});
+	g("view", m);
+	let _ = o.includes("nodeAtPoint") ? r.nodeAtPoint : void 0;
+	_ && g("nodeAtPoint", ((e, n) => _(t(p(), e), n)));
+	let v = o.includes("snap") ? r.snap : void 0;
+	v && g("snap", { point: (e) => i(p(), v.point(t(p(), e))) });
+	let y = s ? i(p(), s) : null, b = f();
+	return {
+		map: p,
+		deps: h,
+		carry(e) {
+			let t = p(), n = {
+				...e,
+				world: i(t, e.world)
+			};
+			if (e.drag) {
+				let r = y ?? i(t, e.drag.start), a = i(t, e.drag.current), o = e.drag.affordance;
+				n.drag = {
+					...e.drag,
+					start: r,
+					current: a,
+					delta: {
+						x: a.x - r.x,
+						y: a.y - r.y
+					},
+					...e.drag.points ? { points: b(e.drag.points, t) } : {},
+					...o?.fixedPoint ? { affordance: {
+						...o,
+						fixedPoint: i(t, o.fixedPoint)
+					} } : {}
+				};
+			}
+			return e.deps && (n.deps = h), n;
+		}
+	};
+}
+function f() {
+	let e = null, t = null, n = [];
+	return (r, a) => {
+		let o = t !== null && t.scale.x === a.scale.x && t.scale.y === a.scale.y && t.offset.x === a.offset.x && t.offset.y === a.offset.y;
+		(r !== e || !o || r.length < n.length) && (e = r, n = []), t = a;
+		for (let e = n.length; e < r.length; e++) n.push({
+			...r[e],
+			...i(a, r[e])
+		});
+		return n.slice();
+	};
+}
+function p(e, t) {
+	let n = { ...e };
+	return e.onMove && (n.onMove = (n) => e.onMove(t.carry(n))), e.onEnd && (n.onEnd = (n, r) => e.onEnd(t.carry(n), r)), e.overlay && (n.overlay = () => {
+		let n = e.overlay();
+		return n && m(n, t.map());
+	}), n;
+}
+function m(e, n) {
+	let i = (e) => t(n, e);
+	switch (e.kind) {
+		case "marquee": return {
+			...e,
+			start: i(e.start),
+			current: i(e.current)
+		};
+		case "lasso": return {
+			...e,
+			vertices: e.vertices.map(i),
+			current: i(e.current)
+		};
+		case "polyline": return {
+			...e,
+			points: e.points.map(i)
+		};
+		case "insertPreview": return {
+			...e,
+			bounds: r(n, e.bounds),
+			extras: h(e.extras, n),
+			...e.anchorPoint ? { anchorPoint: i(e.anchorPoint) } : {}
+		};
+	}
+}
+function h(e, n) {
+	if (typeof e != "object" || !e) return e;
+	let r = e, i = (e) => t(n, e), a = (e) => typeof e == "number" ? e / ((n.scale.x + n.scale.y) / 2) : e, o = { ...r };
+	return r.a && r.b && (o.a = i(r.a), o.b = i(r.b)), r.center && (o.center = i(r.center)), "radius" in r && (o.radius = a(r.radius)), "outerRadius" in r && (o.outerRadius = a(r.outerRadius)), Array.isArray(r.samples) && (o.samples = r.samples.map((e) => ({
+		...e,
+		...i(e)
+	}))), o;
+}
+//#endregion
+export { l as editingLayer, u as inPlane, c as insertLayer, s as selectionLayer };
+
+//# sourceMappingURL=planeInput.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planeInput.js","names":["layerOfNode","id","deps","asNodeId","selectionLayer","selection","affordance","layer","insertLayer","editingLayer","inPlane","inner","action","declared","requires","plane","livePlane","layerOf","params","wx","\"worldX\"","wy","\"worldY\"","at","toPlane","ctx","opts","planeHandle","scene","bag","viewApi","parallax","l","IDENTITY","map","p","planeMap","planeView","camera","deriveParallaxView","override","name","nodeAtPoint","fromPlane","exclude","snap","start0","pressedAt","trail","trailCarrier","m","out","c","start","current","aff","src","lastMap","same","points","i","handle","reason","ov","overlayFromPlane","pt","rectFromPlane","insertExtrasFromPlane","extras","e","r","v","\"a\"","\"b\"","\"center\"","\"radius\"","\"outerRadius\"","\"samples\"","s"],"sources":["../../../src/interactions/actions/planeInput.ts"],"sourcesContent":["/**\n * Editing a node on a parallax plane.\n *\n * The dispatcher hands every action the camera's world. A node on a layer\n * carrying `parallax` stores its pose in its plane's world, which the camera's\n * reaches through a `PlaneMap` that changes with the camera. An editing action\n * pairs the pointer with the pose it edits, so the two have to be in one world.\n *\n * `inPlane` is that one place: it wraps an action so its input is carried into\n * the plane of the layer it edits before the action reads it — pointer, drag,\n * trail, affordance pivot, and the camera it converts screen pixels through —\n * and so the chrome it publishes back comes out in the camera's world. A dep\n * that answers in world points (`nodeAtPoint`, `snap`) is the surface's, so it\n * keeps speaking the camera's world and the seam converts at its boundary.\n * The action sees the plane only as `view.plane()`, which it hands its snap\n * behaviors so they can bring the camera's guides and grid into the plane.\n *\n * The map is read afresh on every call: a camera panning under a held drag, or\n * a plane whose factors are being animated, moves the node with the pointer.\n */\nimport type {\n  Action, ActionDeps, AffordanceHit, BindingOpts, DragSample, InvocationCtx, OngoingHandle,\n  OngoingOverlay,\n} from '@weasel-js/routing';\nimport type { Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport {\n  deriveParallaxView, fromPlane, planeMap, rectFromPlane, toPlane,\n  type ParallaxOpts, type PlaneMap,\n} from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport type { EditAnchorsDep, InsertDep, NodeAtPointDep, SnapDep, ViewApi } from './depSchema';\n\ntype Point = { x: number; y: number };\n\n/** Which scene layer an invocation edits, read once as it starts, from its\n *  deps and — for a drag — the affordance it grabbed. `undefined` means none:\n *  the action runs in the camera's world. */\nexport type EditedLayerOf = (deps: ActionDeps, affordance?: AffordanceHit) => string | undefined;\n\nconst layerOfNode = (deps: ActionDeps, id: string | null | undefined): string | undefined =>\n  (id ? (deps.scene as Scene<unknown, string, unknown> | undefined)?.get(asNodeId(id))?.layer : undefined);\n\n/** The layer of the node a selection edit acts on: the affordance's target\n *  when the drag grabbed one, the first selected node otherwise. A selection\n *  spanning planes is edited in that one node's plane. */\nexport const selectionLayer: EditedLayerOf = (deps, affordance) => {\n  const selection = deps.selection as SelectionApi | undefined;\n  for (const id of [...(affordance?.targetIds ?? []), ...(selection?.get() ?? [])]) {\n    const layer = layerOfNode(deps, id);\n    if (layer !== undefined) return layer;\n  }\n  return undefined;\n};\n\n/** The layer the `insert` dep will put a new node on. */\nexport const insertLayer: EditedLayerOf = (deps) =>\n  (deps.insert as InsertDep | undefined)?.layer?.();\n\n/** The layer of the path in anchor-edit mode. */\nexport const editingLayer: EditedLayerOf = (deps) =>\n  layerOfNode(deps, (deps.editAnchors as EditAnchorsDep | undefined)?.editingId);\n\n/** `action`, with its input carried into the plane of the layer `layerOf`\n *  names. An action on a layer with no `parallax`, or invoked with no scene or\n *  view to read the plane from, runs exactly as it would unwrapped.\n *\n *  An ongoing action's drag is carried as a whole. An immediate one's world\n *  point is `params.worldX` / `params.worldY`, the dispatcher's convention for\n *  a click; it is carried when present. */\nexport function inPlane<A extends Action>(action: A, layerOf: EditedLayerOf): A {\n  const inner = action.invoker;\n  if (!inner) return action;\n  const declared = action.requires ?? [];\n  const requires = [...new Set([...declared, 'scene', 'selection', 'view'])];\n  if (inner.timing === 'immediate') {\n    return {\n      ...action,\n      requires,\n      invoker: {\n        timing: 'immediate',\n        run(deps: ActionDeps, params?: Record<string, unknown>): void {\n          const plane = livePlane(deps, layerOf(deps), declared, null);\n          if (plane === null) return inner.run(deps, params);\n          const wx = params?.['worldX'];\n          const wy = params?.['worldY'];\n          const at = typeof wx === 'number' && typeof wy === 'number'\n            ? toPlane(plane.map(), { x: wx, y: wy })\n            : null;\n          inner.run(plane.deps, at ? { ...params, worldX: at.x, worldY: at.y } : params);\n        },\n      },\n    } as A;\n  }\n  return {\n    ...action,\n    requires,\n    invoker: {\n      timing: 'ongoing',\n      start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n        const plane = livePlane(\n          ctx.deps, layerOf(ctx.deps, ctx.drag?.affordance), declared, ctx.drag?.start ?? null,\n        );\n        if (plane === null) return inner.start(ctx, opts);\n        return planeHandle(inner.start(plane.carry(ctx), opts), plane);\n      },\n    },\n  } as A;\n}\n\ninterface LivePlane {\n  map(): PlaneMap;\n  /** The invocation's deps, speaking the plane's world. */\n  deps: ActionDeps;\n  /** `ctx` in the plane's world. */\n  carry(ctx: InvocationCtx): InvocationCtx;\n}\n\nfunction livePlane(\n  bag: ActionDeps,\n  layer: string | undefined,\n  /** What the wrapped action declared. The dispatcher's dev deps bag throws\n   *  on any other read, so the seam converts only the deps it can see. */\n  declared: readonly string[],\n  /** The drag's press point in the camera's world, when there is a drag. */\n  pressedAt: Point | null,\n): LivePlane | null {\n  const scene = bag.scene as Scene<unknown, string, unknown> | undefined;\n  const viewApi = bag.view as ViewApi | undefined;\n  if (layer === undefined || !scene || !viewApi) return null;\n  const parallax = (): ParallaxOpts | undefined => scene.layers.find((l) => l.id === layer)?.parallax;\n  if (parallax() === undefined) return null;\n\n  const IDENTITY: PlaneMap = { scale: { x: 1, y: 1 }, offset: { x: 0, y: 0 } };\n  const map = (): PlaneMap => {\n    const p = parallax();\n    return p ? planeMap(viewApi.get(), p) : IDENTITY;\n  };\n\n  // A screen-pixel tolerance, and anything else an action reads off the\n  // camera, has to be read at the plane's scale.\n  const planeView = Object.defineProperties(Object.create(viewApi), {\n    get: {\n      value: (): View => {\n        const p = parallax();\n        const camera = viewApi.get();\n        return p ? deriveParallaxView(camera, p) : camera;\n      },\n    },\n    plane: { value: map },\n  }) as ViewApi;\n\n  // Over the dispatcher's bag rather than a copy of it, so every other read\n  // still goes through whatever checks the bag makes.\n  const deps = Object.create(bag) as typeof bag;\n  const override = (name: string, value: unknown) =>\n    Object.defineProperty(deps, name, { value, enumerable: true });\n  override('view', planeView);\n  const nodeAtPoint = declared.includes('nodeAtPoint')\n    ? bag.nodeAtPoint as NodeAtPointDep | undefined\n    : undefined;\n  if (nodeAtPoint) {\n    override('nodeAtPoint', ((p, exclude) => nodeAtPoint(fromPlane(map(), p), exclude)) as NodeAtPointDep);\n  }\n  const snap = declared.includes('snap') ? bag.snap as SnapDep | undefined : undefined;\n  if (snap) {\n    override('snap', { point: (p: Point) => toPlane(map(), snap.point(fromPlane(map(), p))) } as SnapDep);\n  }\n\n  // The drag's origin, fixed in the plane at the moment it was pressed: where\n  // the pointer went down on the node is where the node was grabbed, whatever\n  // the camera does after.\n  const start0 = pressedAt ? toPlane(map(), pressedAt) : null;\n  const trail = trailCarrier();\n\n  return {\n    map,\n    deps,\n    carry(c) {\n      const m = map();\n      const out: InvocationCtx = { ...c, world: toPlane(m, c.world) };\n      if (c.drag) {\n        const start = start0 ?? toPlane(m, c.drag.start);\n        const current = toPlane(m, c.drag.current);\n        const aff = c.drag.affordance;\n        out.drag = {\n          ...c.drag,\n          start,\n          current,\n          delta: { x: current.x - start.x, y: current.y - start.y },\n          ...(c.drag.points ? { points: trail(c.drag.points, m) } : {}),\n          ...(aff?.fixedPoint ? { affordance: { ...aff, fixedPoint: toPlane(m, aff.fixedPoint) } } : {}),\n        };\n      }\n      // The dispatcher hands `onMove` no deps; only `start` has any to carry.\n      if (c.deps) out.deps = deps;\n      return out;\n    },\n  };\n}\n\n/** The drag trail in the plane. The dispatcher grows its trail in place, so\n *  only the samples added since the last call are mapped — unless the map\n *  moved, when every sample is. */\nfunction trailCarrier(): (points: DragSample[], m: PlaneMap) => DragSample[] {\n  let src: DragSample[] | null = null;\n  let lastMap: PlaneMap | null = null;\n  let out: DragSample[] = [];\n  return (points, m) => {\n    const same = lastMap !== null\n      && lastMap.scale.x === m.scale.x && lastMap.scale.y === m.scale.y\n      && lastMap.offset.x === m.offset.x && lastMap.offset.y === m.offset.y;\n    if (points !== src || !same || points.length < out.length) {\n      src = points;\n      out = [];\n    }\n    lastMap = m;\n    for (let i = out.length; i < points.length; i++) {\n      out.push({ ...points[i], ...toPlane(m, points[i]) });\n    }\n    // A copy, so a snapshot taken on `onEnd` is not the live accumulator.\n    return out.slice();\n  };\n}\n\nfunction planeHandle(handle: OngoingHandle, plane: LivePlane): OngoingHandle {\n  const out: OngoingHandle = { ...handle };\n  if (handle.onMove) out.onMove = (c) => handle.onMove!(plane.carry(c));\n  if (handle.onEnd) out.onEnd = (c, reason) => handle.onEnd!(plane.carry(c), reason);\n  if (handle.overlay) {\n    out.overlay = () => {\n      const ov = handle.overlay!();\n      return ov ? overlayFromPlane(ov, plane.map()) : ov;\n    };\n  }\n  return out;\n}\n\n/** An overlay drawn in the plane, in the camera's world: what every painter\n *  reads an overlay as. */\nfunction overlayFromPlane(ov: OngoingOverlay, m: PlaneMap): OngoingOverlay {\n  const pt = (p: Point) => fromPlane(m, p);\n  switch (ov.kind) {\n    case 'marquee':\n      return { ...ov, start: pt(ov.start), current: pt(ov.current) };\n    case 'lasso':\n      return { ...ov, vertices: ov.vertices.map(pt), current: pt(ov.current) };\n    case 'polyline':\n      return { ...ov, points: ov.points.map(pt) };\n    case 'insertPreview':\n      return {\n        ...ov,\n        bounds: rectFromPlane(m, ov.bounds),\n        extras: insertExtrasFromPlane(ov.extras, m),\n        ...(ov.anchorPoint ? { anchorPoint: pt(ov.anchorPoint) } : {}),\n      };\n  }\n}\n\n/** The geometry the kit's insert kinds carry in `extras`, in the camera's\n *  world. A consumer kind's extras are opaque, and pass through. */\nfunction insertExtrasFromPlane(extras: unknown, m: PlaneMap): unknown {\n  if (extras === null || typeof extras !== 'object') return extras;\n  const e = extras as Record<string, unknown>;\n  const pt = (p: unknown) => fromPlane(m, p as Point);\n  // Radial kinds inscribe in a square, so one scale carries a radius.\n  const r = (v: unknown) => (typeof v === 'number' ? v / ((m.scale.x + m.scale.y) / 2) : v);\n  const out: Record<string, unknown> = { ...e };\n  if (e['a'] && e['b']) { out['a'] = pt(e['a']); out['b'] = pt(e['b']); }\n  if (e['center']) out['center'] = pt(e['center']);\n  if ('radius' in e) out['radius'] = r(e['radius']);\n  if ('outerRadius' in e) out['outerRadius'] = r(e['outerRadius']);\n  if (Array.isArray(e['samples'])) {\n    out['samples'] = (e['samples'] as DragSample[]).map((s) => ({ ...s, ...pt(s) }));\n  }\n  return out;\n}\n"],"mappings":"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"}

package/dist/interactions/actions/poseDescriptorDep.js

@@ -0,0 +1,9 @@
+import { AUTO_POSE_DESCRIPTOR as e } from "./resize/autoPoseDescriptor.js";
+//#region src/interactions/actions/poseDescriptorDep.ts
+function t(t) {
+	return t ?? e;
+}
+//#endregion
+export { t as poseDescriptorOf };
+
+//# sourceMappingURL=poseDescriptorDep.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseDescriptorDep.js","names":["poseDescriptorOf","dep","AUTO_POSE_DESCRIPTOR"],"sources":["../../../src/interactions/actions/poseDescriptorDep.ts"],"sourcesContent":["import type { PoseDescriptor } from './resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from './resize/autoPoseDescriptor';\n\n/** The `poseDescriptor` dep's value, or the auto descriptor when unsourced. */\nexport function poseDescriptorOf(dep: unknown): PoseDescriptor<unknown> {\n  return (dep as PoseDescriptor<unknown> | undefined) ?? AUTO_POSE_DESCRIPTOR;\n}\n"],"mappings":";;AAIA,SAAgBA,EAAiB,GAAuC;CACtE,OAAQC,KAA+CC;AACzD"}

package/dist/interactions/actions/poseFrame.js

@@ -0,0 +1,38 @@
+import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, frameAtOrAbove as n, rebaseLocalPose as r } from "../../core/scene/composeFrame.js";
+import { definesFrame as i, effectivePose as a } from "../../core/scene/effectivePose.js";
+//#region src/interactions/actions/poseFrame.ts
+function o(e, i) {
+	return {
+		pc: i,
+		world: (n) => t(e, n, i.compose),
+		parentWorld: (r) => {
+			let a = n(e, e.getParent(r));
+			return a === null ? null : t(e, a, i.compose);
+		},
+		local: (t, n) => r(e, n, e.getParent(t), i.compose, i.decompose),
+		localUnder: (t, n) => r(e, n, t, i.compose, i.decompose)
+	};
+}
+function s(t, n) {
+	let r = n ?? e, s = t;
+	return o({
+		getPose: (e) => {
+			let n = t.get(e);
+			return n === void 0 ? {
+				x: 0,
+				y: 0,
+				width: 0,
+				height: 0
+			} : a(s, n);
+		},
+		getParent: (e) => t.get(e)?.parent ?? null,
+		definesFrame: (e) => {
+			let n = t.get(e);
+			return n === void 0 || i(n);
+		}
+	}, r);
+}
+//#endregion
+export { o as poseFrame, s as scenePoseFrame };
+
+//# sourceMappingURL=poseFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseFrame.js","names":["poseFrame","composeWorldPose","adapter","id","pc","frame","frameAtOrAbove","rebaseLocalPose","worldPose","parentId","scenePoseFrame","poseComposition","IDENTITY_POSE_COMPOSITION","source","scene","node","effectivePose","definesFrame"],"sources":["../../../src/interactions/actions/poseFrame.ts"],"sourcesContent":["/**\n * World reads and local writes, paired, for the default actions.\n *\n * A container's pose defines a frame, so a node's stored pose is expressed in\n * its parent's. The geometry an action reasons about — a rotate pivot, an\n * alignment edge, a distribute span, a flip axis — is world; every pose it\n * writes back through `setPose` or a pose op is local. An action that reads\n * world and writes world looks right for one gesture and drifts on the next,\n * because the stored pose is then read in the parent's frame again.\n *\n * Under `IDENTITY_POSE_COMPOSITION` — the default, and what every consumer\n * ships today — local and world are the same value and all of this is an\n * identity. `features/groups/frameFixture.ts` is the scene where they differ.\n */\nimport { definesFrame, effectivePose, type PoseSource } from 'core/scene/effectivePose';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport {\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  IDENTITY_POSE_COMPOSITION,\n  type PoseAdapter,\n  type PoseComposition,\n} from 'features/groups/composePose';\n\n/** The two directions an action needs, over one composition strategy. */\nexport interface PoseFrame<TPose> {\n  /** The strategy in force. `closure` says what it can express exactly. */\n  readonly pc: PoseComposition<TPose>;\n  /** `id`'s pose in world coordinates, honoring an in-flight gesture override. */\n  world(id: NodeId): TPose;\n  /** World pose of the frame `id` is stored in, or `null` for the root frame. */\n  parentWorld(id: NodeId): TPose | null;\n  /** `worldPose` expressed in `id`'s own parent frame — what `setPose` stores. */\n  local(id: NodeId, worldPose: TPose): TPose;\n  /** `worldPose` expressed under `parentId`'s frame. For a node about to be\n   *  reparented, whose current parent is not the frame it will be stored in. */\n  localUnder(parentId: NodeId | null, worldPose: TPose): TPose;\n}\n\n/** Pair the two directions over an arbitrary pose adapter. */\nexport function poseFrame<TPose>(\n  adapter: PoseAdapter<TPose>,\n  pc: PoseComposition<TPose>,\n): PoseFrame<TPose> {\n  return {\n    pc,\n    world: (id) => composeWorldPose(adapter, id as string, pc.compose),\n    parentWorld: (id) => {\n      const frame = frameAtOrAbove(adapter, adapter.getParent(id as string));\n      return frame === null ? null : composeWorldPose(adapter, frame, pc.compose);\n    },\n    local: (id, worldPose) =>\n      rebaseLocalPose(adapter, worldPose, adapter.getParent(id as string), pc.compose, pc.decompose),\n    localUnder: (parentId, worldPose) =>\n      rebaseLocalPose(adapter, worldPose, parentId as string | null, pc.compose, pc.decompose),\n  };\n}\n\n/** The `poseFrame` a scene-backed action works in. `poseComposition` is the\n *  dep as it arrives — absent means IDENTITY, where every method is a no-op. */\nexport function scenePoseFrame(\n  scene: Scene<unknown, string, unknown>,\n  poseComposition: unknown,\n): PoseFrame<unknown> {\n  const pc =\n    (poseComposition as PoseComposition<unknown> | undefined) ?? IDENTITY_POSE_COMPOSITION;\n  const source = scene as unknown as PoseSource<unknown>;\n  const adapter: PoseAdapter<unknown> = {\n    getPose: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined ? { x: 0, y: 0, width: 0, height: 0 } : effectivePose(source, node);\n    },\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  return poseFrame(adapter, pc);\n}\n"],"mappings":";;;AAyCA,SAAgBA,EACd,GACA,GACkB;CAClB,OAAO;EACL;EACA,QAAQ,MAAOC,EAAiBC,GAASC,GAAcC,EAAG,OAAO;EACjE,cAAc,MAAO;GACnB,IAAMC,IAAQC,EAAeJ,GAASA,EAAQ,UAAUC,CAAY,CAAC;GACrE,OAAOE,MAAU,OAAO,OAAOJ,EAAiBC,GAASG,GAAOD,EAAG,OAAO;EAC5E;EACA,QAAQ,GAAI,MACVG,EAAgBL,GAASM,GAAWN,EAAQ,UAAUC,CAAY,GAAGC,EAAG,SAASA,EAAG,SAAS;EAC/F,aAAa,GAAU,MACrBG,EAAgBL,GAASM,GAAWC,GAA2BL,EAAG,SAASA,EAAG,SAAS;CAC3F;AACF;AAIA,SAAgBM,EACd,GACA,GACoB;CACpB,IAAMN,IACHO,KAA4DC,GACzDC,IAASC;CAYf,OAAOd,EAAU;EAVf,UAAU,MAAO;GACf,IAAMe,IAAOD,EAAM,IAAIX,CAAY;GACnC,OAAOY,MAAS,KAAA,IAAY;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;IAAG,QAAQ;GAAE,IAAIC,EAAcH,GAAQE,CAAI;EAC9F;EACA,YAAY,MAAOD,EAAM,IAAIX,CAAY,CAAC,EAAE,UAAU;EACtD,eAAe,MAAO;GACpB,IAAMY,IAAOD,EAAM,IAAIX,CAAY;GACnC,OAAOY,MAAS,KAAA,KAAaE,EAAaF,CAAI;EAChD;CAEe,GAASX,CAAE;AAC9B"}

package/dist/interactions/actions/previewOverrides.js

@@ -0,0 +1,25 @@
+//#region src/interactions/actions/previewOverrides.ts
+function e(e) {
+	let { overrides: t } = e.scene;
+	for (let [n, r] of e.previews) {
+		let i = e.overrideEntries.get(n);
+		if (i) {
+			i.pose = r;
+			continue;
+		}
+		let a = { pose: r };
+		e.overrideEntries.set(n, a), t.set(n, a);
+	}
+	for (let n of e.overrideEntries.keys()) e.previews.has(n) || (e.overrideEntries.delete(n), t.clear(n));
+	t.commit();
+}
+function t(e) {
+	if (e.overrideEntries.size !== 0) {
+		for (let t of e.overrideEntries.keys()) e.scene.overrides.clear(t);
+		e.overrideEntries.clear(), e.scene.overrides.commit();
+	}
+}
+//#endregion
+export { t as dropPreviewOverrides, e as syncPreviewOverrides };
+
+//# sourceMappingURL=previewOverrides.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"previewOverrides.js","names":["syncPreviewOverrides","state","id","pose","existing","entry","overrides","dropPreviewOverrides"],"sources":["../../../src/interactions/actions/previewOverrides.ts"],"sourcesContent":["/**\n * Publishing an in-flight gesture's poses where the *scene* can see them.\n *\n * An ongoing action keeps its per-frame poses in its own scratch and exposes\n * them as `previewIds` / `previewPose`. That surface is enough to paint a\n * ghost and to size selection chrome, but it is invisible to anything that\n * asks the scene where a node is — `sceneDepLookup`, which resolves a derived\n * node's geometry, and the pick source, which decides what the pointer can\n * grab. A node deriving its path from a dragged one therefore stayed anchored\n * to the pre-drag position and jumped on drop.\n *\n * These publish the same frame into the scene's ephemeral override table, the\n * one channel both of those already read. Nothing here reaches `executeAndLog`,\n * so a drag still commits as exactly one undo entry.\n */\nimport type { NodeId, Scene } from 'core/scene/types';\n\n/** The scratch fields these operate on. Actions carry more; this is the part\n *  that has to agree across them. */\nexport interface PreviewOverrideState {\n  scene: Scene<unknown, string, unknown>;\n  /** This frame's poses, keyed by node id — the action's own buffer. */\n  previews: Map<NodeId, unknown>;\n  /** The entry published per id, held by reference so a frame mutates it in\n   *  place. Initialize to an empty map in the action's scratch. */\n  overrideEntries: Map<NodeId, { pose: unknown }>;\n}\n\n/**\n * Publish `previews` as scene overrides. Call once per frame, after every\n * pass that can add to `previews` (a layout reflow, a cascade).\n *\n * Entries are set once and mutated in place, then published with a single\n * `commit()` — `PoseOverrides.set` notifies subscribers per call, so setting\n * every id every frame would fan out one repaint per node.\n */\nexport function syncPreviewOverrides(state: PreviewOverrideState): void {\n  const { overrides } = state.scene;\n  for (const [id, pose] of state.previews) {\n    const existing = state.overrideEntries.get(id);\n    if (existing) {\n      existing.pose = pose;\n      continue;\n    }\n    const entry = { pose };\n    state.overrideEntries.set(id, entry);\n    overrides.set(id, entry);\n  }\n  // An id can leave the preview set mid-gesture — a cascade child whose\n  // container stopped being the drag root, a layout sibling that stopped\n  // reflowing. Left published, it would pin that node to a stale frame.\n  for (const id of state.overrideEntries.keys()) {\n    if (state.previews.has(id)) continue;\n    state.overrideEntries.delete(id);\n    overrides.clear(id);\n  }\n  overrides.commit();\n}\n\n/**\n * Drop everything this gesture published. Call on both ends — on commit the\n * document poses take over, on cancel the untouched originals do.\n *\n * On commit, call it *after* the ops land: dropping first leaves a window in\n * which the scene answers with the pre-gesture pose.\n */\nexport function dropPreviewOverrides(state: PreviewOverrideState): void {\n  if (state.overrideEntries.size === 0) return;\n  for (const id of state.overrideEntries.keys()) state.scene.overrides.clear(id);\n  state.overrideEntries.clear();\n  state.scene.overrides.commit();\n}\n"],"mappings":";AAoCA,SAAgBA,EAAqB,GAAmC;CACtE,IAAM,EAAE,iBAAcC,EAAM;CAC5B,KAAK,IAAM,CAACC,GAAIC,MAASF,EAAM,UAAU;EACvC,IAAMG,IAAWH,EAAM,gBAAgB,IAAIC,CAAE;EAC7C,IAAIE,GAAU;GACZ,EAAS,OAAOD;GAChB;EACF;EACA,IAAME,IAAQ,EAAE,QAAK;EAErB,AADAJ,EAAM,gBAAgB,IAAIC,GAAIG,CAAK,GACnCC,EAAU,IAAIJ,GAAIG,CAAK;CACzB;CAIA,KAAK,IAAMH,KAAMD,EAAM,gBAAgB,KAAK,GAC1C,AAAIA,EAAM,SAAS,IAAIC,CAAE,MACzBD,EAAM,gBAAgB,OAAOC,CAAE,GAC/BI,EAAU,MAAMJ,CAAE;CAEpB,EAAU,OAAO;AACnB;AASA,SAAgBK,EAAqB,GAAmC;CACtE,IAAIN,EAAM,gBAAgB,SAAS,GACnC;OAAK,IAAMC,KAAMD,EAAM,gBAAgB,KAAK,GAAG,EAAM,MAAM,UAAU,MAAMC,CAAE;EAE7E,AADAD,EAAM,gBAAgB,MAAM,GAC5BA,EAAM,MAAM,UAAU,OAAO;CAFgD;AAG/E"}

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

@@ -0,0 +1,32 @@
+import { RECT_POSE_DESCRIPTOR as e } from "../../../core/geometry/poseDescriptor.js";
+import { pathPoseDescriptor as t } from "../../../features/paths/poseDescriptor.js";
+//#region src/interactions/actions/resize/autoPoseDescriptor.ts
+function n(e) {
+	return !!e && typeof e == "object" && "kind" in e && (e.kind === "polygon" || e.kind === "rect");
+}
+function r(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = e;
+	return typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number";
+}
+var i = {
+	getBounds: (r) => n(r) ? t.getBounds(r) : e.getBounds(r),
+	remapBounds: (r, i, a) => n(r) ? t.remapBounds(r, i, a) : e.remapBounds(r, i, a),
+	fromBounds: (r, i) => n(i) ? t.fromBounds(r, i) : e.fromBounds(r, i),
+	translate: (r, i, a) => n(r) ? t.translate(r, i, a) : e.translate(r, i, a),
+	intersectsRect: (r, i) => n(r) ? t.intersectsRect(r, i) : e.intersectsRect(r, i),
+	getRotation: (e) => {
+		if (n(e)) return 0;
+		let t = e.rotation;
+		return typeof t == "number" ? t : 0;
+	},
+	supportsRotation: (e) => !n(e),
+	withRotation: (e, t) => n(e) ? e : {
+		...e,
+		rotation: t
+	}
+};
+//#endregion
+export { i as AUTO_POSE_DESCRIPTOR, n as isPathLike, r as isRectPose };
+
+//# sourceMappingURL=autoPoseDescriptor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autoPoseDescriptor.js","names":["isPathLike","p","isRectPose","r","AUTO_POSE_DESCRIPTOR","pathPoseDescriptor","RECT_POSE_DESCRIPTOR","src","dst","template","b","dx","dy","rect"],"sources":["../../../../src/interactions/actions/resize/autoPoseDescriptor.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { pathPoseDescriptor } from 'features/paths/poseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from './geometry';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire\n *  `poseDescriptor` explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only\n *  shape the rect descriptor and the kit's built-in painters can read. */\nexport function isRectPose(p: unknown): p is { x: number; y: number; width: number; height: number; rotation?: number } {\n  if (!p || typeof p !== 'object') return false;\n  const r = p as Record<string, unknown>;\n  return typeof r.x === 'number' && typeof r.y === 'number'\n    && typeof r.width === 'number' && typeof r.height === 'number';\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`\n *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses\n *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to\n *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated\n *  selection chrome and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  fromBounds: (b, template) => isPathLike(template)\n    ? pathPoseDescriptor.fromBounds(b, template)\n    : RECT_POSE_DESCRIPTOR.fromBounds(b, template as Bounds),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  intersectsRect: (p, rect) => isPathLike(p)\n    ? pathPoseDescriptor.intersectsRect!(p, rect)\n    : RECT_POSE_DESCRIPTOR.intersectsRect!(p as { x: number; y: number; width: number; height: number }, rect),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n  withRotation: (p, rotation) => isPathLike(p) ? p : { ...(p as object), rotation },\n};\n"],"mappings":";;;AASA,SAAgBA,EAAW,GAAuB;CAChD,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,UAAUA,MAC1CA,EAAwB,SAAS,aAAcA,EAAwB,SAAS;AACzF;AAIA,SAAgBC,EAAW,GAA6F;CACtH,IAAI,CAACD,KAAK,OAAOA,KAAM,UAAU,OAAO;CACxC,IAAME,IAAIF;CACV,OAAO,OAAOE,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAC5C,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW;AAC1D;AASA,IAAaC,IAAgD;CAC3D,YAAY,MAAMJ,EAAWC,CAAC,IAC1BI,EAAmB,UAAUJ,CAAC,IAC9BK,EAAqB,UAAUL,CAA4D;CAC/F,cAAc,GAAG,GAAK,MAAQD,EAAWC,CAAC,IACtCI,EAAmB,YAAYJ,GAAGM,GAAKC,CAAG,IAC1CF,EAAqB,YAAYL,GAA8DM,GAAKC,CAAG;CAC3G,aAAa,GAAG,MAAaR,EAAWS,CAAQ,IAC5CJ,EAAmB,WAAWK,GAAGD,CAAQ,IACzCH,EAAqB,WAAWI,GAAGD,CAAkB;CACzD,YAAY,GAAG,GAAI,MAAOT,EAAWC,CAAC,IAClCI,EAAmB,UAAWJ,GAAGU,GAAIC,CAAE,IACvCN,EAAqB,UAAWL,GAA8DU,GAAIC,CAAE;CACxG,iBAAiB,GAAG,MAASZ,EAAWC,CAAC,IACrCI,EAAmB,eAAgBJ,GAAGY,CAAI,IAC1CP,EAAqB,eAAgBL,GAA8DY,CAAI;CAC3G,cAAc,MAAM;EAClB,IAAIb,EAAWC,CAAC,GAAG,OAAO;EAC1B,IAAME,IAAKF,EAA6B;EACxC,OAAO,OAAOE,KAAM,WAAWA,IAAI;CACrC;CAKA,mBAAmB,MAAM,CAACH,EAAWC,CAAC;CACtC,eAAe,GAAG,MAAaD,EAAWC,CAAC,IAAIA,IAAI;EAAE,GAAIA;EAAc;CAAS;AAClF"}