@weasel-js/core 1.6.1 → 1.7.1

package/dist/interactions/actions/align/align.js

@@ -0,0 +1,81 @@
+import { IDENTITY_POSE_COMPOSITION as e } from "../../../core/scene/composeFrame.js";
+import { createTransformOp as t } from "../../../core/ops/transform.js";
+import { unionAABB as n } from "../../../core/geometry/unionBounds.js";
+import { RECT_POSE_DESCRIPTOR as r, translatePoseViaDescriptor as i, visualBoundsViaDescriptor as a } from "../../../core/geometry/poseDescriptor.js";
+import { poseFrame as o } from "../poseFrame.js";
+import { dispatchApplyBatch as s } from "../../../core/applyOps.js";
+import { usePointerContext as c } from "../../../features/pointer/PointerContext.js";
+import { resolveSpatialReference as l } from "../spatialReference.js";
+import { useCallback as u } from "react";
+import { useLatest as d } from "@weasel-js/react";
+//#region src/interactions/actions/align/align.ts
+function f(e, t, r) {
+	return t === void 0 || t === "union" ? e.length < 2 ? null : n([...e]) : e.length === 0 ? null : l(t, r);
+}
+function p(e, t, n) {
+	switch (n) {
+		case "left": return {
+			dx: t.x - e.x,
+			dy: 0
+		};
+		case "right": return {
+			dx: t.x + t.width - (e.x + e.width),
+			dy: 0
+		};
+		case "top": return {
+			dx: 0,
+			dy: t.y - e.y
+		};
+		case "bottom": return {
+			dx: 0,
+			dy: t.y + t.height - (e.y + e.height)
+		};
+		case "center-x": return {
+			dx: t.x + t.width / 2 - (e.x + e.width / 2),
+			dy: 0
+		};
+		case "center-y": return {
+			dx: 0,
+			dy: t.y + t.height / 2 - (e.y + e.height / 2)
+		};
+	}
+}
+function m(n, l = {}) {
+	let m = d(n), h = d(l), g = c(), _ = d(g);
+	return { align: u((n, c) => {
+		let l = m.current, u = h.current, d = l.getSelection(), g = u.geometry ?? r, v = o({
+			getPose: (e) => l.getPose(e),
+			getParent: (e) => l.getParent?.(e) ?? null
+		}, u.composition ?? e), y = d.map((e) => v.world(e)), b = y.map((e) => a(e, g)), x = f(b, c, {
+			pointer: () => {
+				let e = _.current?.get();
+				return e ? {
+					x: e.worldX,
+					y: e.worldY
+				} : null;
+			},
+			nodeBounds: (e) => a(v.world(e), g)
+		});
+		if (x === null) return;
+		let S = [];
+		for (let e = 0; e < d.length; e++) {
+			let { dx: r, dy: a } = p(b[e], x, n);
+			if (r === 0 && a === 0) continue;
+			let o = i(y[e], r, a, g);
+			S.push(t({
+				id: d[e],
+				from: l.getPose(d[e]),
+				to: v.local(d[e], o)
+			}));
+		}
+		S.length !== 0 && s(l, S, u.label ?? "Align");
+	}, [
+		m,
+		h,
+		_
+	]) };
+}
+//#endregion
+export { p as alignDeltaFor, f as alignTargetBounds, i as translatePoseViaDescriptor, m as useAlign, a as visualBoundsViaDescriptor };
+
+//# sourceMappingURL=align.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"align.js","names":["alignTargetBounds","to","bounds","unionAABB","resolveSpatialReference","src","alignDeltaFor","edge","u","b","useAlign","adapterRef","useLatest","adapter","optsRef","options","pointer","usePointerContext","pointerRef","useCallback","a","o","sel","geom","RECT_POSE_DESCRIPTOR","frame","poseFrame","id","IDENTITY_POSE_COMPOSITION","poses","visualBoundsViaDescriptor","p","target","ops","i","dx","dy","translatePoseViaDescriptor","createTransformOp","dispatchApplyBatch"],"sources":["../../../../src/interactions/actions/align/align.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { NodeId } from 'core/scene/types';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from '../resize/geometry';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { poseFrame } from '../poseFrame';\nimport { IDENTITY_POSE_COMPOSITION, type PoseComposition } from 'features/groups/composePose';\nimport { usePointerContext } from 'features/pointer/PointerContext';\nimport { resolveSpatialReference, type SpatialReference, type SpatialReferenceSources } from '../spatialReference';\n\nexport { visualBoundsViaDescriptor, translatePoseViaDescriptor } from '../resize/geometry';\nimport { visualBoundsViaDescriptor, translatePoseViaDescriptor } from '../resize/geometry';\n\n/** Edge or center the selection should align to within the reference's\n *  bounds (rotated members contribute their ink extent). */\nexport type AlignEdge = 'left' | 'right' | 'top' | 'bottom' | 'center-x' | 'center-y';\n\n/** @experimental What the selection aligns to: `'union'` — the selection's\n *  own visual union AABB, the default — or a {@link SpatialReference}. */\nexport type AlignReference = 'union' | SpatialReference;\n\n/** @experimental The bounds each member of `bounds` aligns to under `to`, or\n *  `null` when there is nothing to align: a union of fewer than two members,\n *  an empty selection, or a reference that names nothing right now. */\nexport function alignTargetBounds(\n  bounds: readonly Bounds[],\n  to: AlignReference | undefined,\n  src: SpatialReferenceSources,\n): Bounds | null {\n  if (to === undefined || to === 'union') return bounds.length < 2 ? null : unionAABB([...bounds]);\n  if (bounds.length === 0) return null;\n  return resolveSpatialReference(to, src);\n}\n\n/** Adapter for `useAlign`. */\nexport interface AlignAdapter<TPose> {\n  getSelection(): NodeId[];\n  /** The pose as stored — local to the node's parent. */\n  getPose(id: NodeId): TPose;\n  /** The parent chain, for a scene whose container poses define a frame.\n   *  Omit it (or leave `composition` unset) for an absolute-pose scene. */\n  getParent?(id: NodeId): NodeId | null;\n  applyOps?(ops: Op[], label?: string): void;\n}\n\n/** Options for `useAlign`. */\nexport interface UseAlignOptions<TPose> {\n  /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`\n   *  for `{x,y,width,height}` poses. Pass `pathPoseDescriptor` for `Path`\n   *  poses so polygon coords translate correctly. */\n  geometry?: PoseDescriptor<TPose>;\n  /** Label passed to applyOps. Default 'Align'. */\n  label?: string;\n  /** How local poses fold up to world. Default IDENTITY, where the two are\n   *  the same value and the alignment runs entirely in stored coordinates. */\n  composition?: PoseComposition<TPose>;\n}\n\n/** Return shape of `useAlign`. */\nexport interface UseAlignReturn {\n  /** Imperative trigger. `to` defaults to `'union'`, which needs two items;\n   *  any other reference aligns a single item too. `'pointer'` reads the\n   *  surrounding `<PointerContextProvider>`. */\n  align(edge: AlignEdge, to?: AlignReference): void;\n}\n\n/** Compute the (dx, dy) translation that moves AABB `b` so that the requested\n *  `edge`/center matches the corresponding feature of the union AABB `u`. */\nexport function alignDeltaFor(b: Bounds, u: Bounds, edge: AlignEdge): { dx: number; dy: number } {\n  switch (edge) {\n    case 'left':     return { dx: u.x - b.x, dy: 0 };\n    case 'right':    return { dx: (u.x + u.width) - (b.x + b.width), dy: 0 };\n    case 'top':      return { dx: 0, dy: u.y - b.y };\n    case 'bottom':   return { dx: 0, dy: (u.y + u.height) - (b.y + b.height) };\n    case 'center-x': return { dx: (u.x + u.width / 2) - (b.x + b.width / 2), dy: 0 };\n    case 'center-y': return { dx: 0, dy: (u.y + u.height / 2) - (b.y + b.height / 2) };\n  }\n}\n\n/** Align the current selection to a shared edge or center of the selection's\n *  union AABB, or of another reference. Single batch — one undo step.\n *\n *  The edge is a world edge: bounds are measured and translated in world, and\n *  each result is stored back in its own parent's frame. */\nexport function useAlign<TPose>(\n  adapter: AlignAdapter<TPose>,\n  options: UseAlignOptions<TPose> = {},\n): UseAlignReturn {\n  const adapterRef = useLatest(adapter);\n  const optsRef = useLatest(options);\n  const pointer = usePointerContext();\n  const pointerRef = useLatest(pointer);\n\n  const align = useCallback((edge: AlignEdge, to?: AlignReference): void => {\n    const a = adapterRef.current;\n    const o = optsRef.current;\n    const sel = a.getSelection();\n    const geom =\n      o.geometry ??\n      (RECT_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>);\n    const frame = poseFrame<TPose>(\n      {\n        getPose: (id) => a.getPose(id as NodeId),\n        getParent: (id) => (a.getParent?.(id as NodeId) ?? null) as string | null,\n      },\n      o.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n    );\n    const poses = sel.map((id) => frame.world(id));\n    const bounds = poses.map((p) => visualBoundsViaDescriptor(p, geom));\n    const target = alignTargetBounds(bounds, to, {\n      pointer: () => {\n        const p = pointerRef.current?.get();\n        return p ? { x: p.worldX, y: p.worldY } : null;\n      },\n      nodeBounds: (id) => visualBoundsViaDescriptor(frame.world(id), geom),\n    });\n    if (target === null) return;\n    const ops: Op[] = [];\n    for (let i = 0; i < sel.length; i++) {\n      const { dx, dy } = alignDeltaFor(bounds[i], target, edge);\n      if (dx === 0 && dy === 0) continue;\n      const to = translatePoseViaDescriptor(poses[i], dx, dy, geom);\n      ops.push(createTransformOp<TPose>({\n        id: sel[i],\n        from: a.getPose(sel[i]),\n        to: frame.local(sel[i], to),\n      }));\n    }\n    if (ops.length === 0) return;\n    dispatchApplyBatch(a, ops, o.label ?? 'Align');\n  }, [adapterRef, optsRef, pointerRef]);\n\n  return { align };\n}\n"],"mappings":";;;;;;;;;;;AA4BA,SAAgBA,EACd,GACA,GACA,GACe;CAGf,OAFIC,MAAO,KAAA,KAAaA,MAAO,UAAgBC,EAAO,SAAS,IAAI,OAAOC,EAAU,CAAC,GAAGD,CAAM,CAAC,IAC3FA,EAAO,WAAW,IAAU,OACzBE,EAAwBH,GAAII,CAAG;AACxC;AAoCA,SAAgBC,EAAc,GAAW,GAAW,GAA6C;CAC/F,QAAQC,GAAR;EACE,KAAK,QAAY,OAAO;GAAE,IAAIC,EAAE,IAAIC,EAAE;GAAG,IAAI;EAAE;EAC/C,KAAK,SAAY,OAAO;GAAE,IAAKD,EAAE,IAAIA,EAAE,SAAUC,EAAE,IAAIA,EAAE;GAAQ,IAAI;EAAE;EACvE,KAAK,OAAY,OAAO;GAAE,IAAI;GAAG,IAAID,EAAE,IAAIC,EAAE;EAAE;EAC/C,KAAK,UAAY,OAAO;GAAE,IAAI;GAAG,IAAKD,EAAE,IAAIA,EAAE,UAAWC,EAAE,IAAIA,EAAE;EAAQ;EACzE,KAAK,YAAY,OAAO;GAAE,IAAKD,EAAE,IAAIA,EAAE,QAAQ,KAAMC,EAAE,IAAIA,EAAE,QAAQ;GAAI,IAAI;EAAE;EAC/E,KAAK,YAAY,OAAO;GAAE,IAAI;GAAG,IAAKD,EAAE,IAAIA,EAAE,SAAS,KAAMC,EAAE,IAAIA,EAAE,SAAS;EAAG;CACnF;AACF;AAOA,SAAgBC,EACd,GACA,IAAkC,CAAC,GACnB;CAChB,IAAMC,IAAaC,EAAUC,CAAO,GAC9BC,IAAUF,EAAUG,CAAO,GAC3BC,IAAUC,EAAkB,GAC5BC,IAAaN,EAAUI,CAAO;CAyCpC,OAAO,EAAE,OAvCKG,GAAa,GAAiB,MAA8B;EACxE,IAAMC,IAAIT,EAAW,SACfU,IAAIP,EAAQ,SACZQ,IAAMF,EAAE,aAAa,GACrBG,IACJF,EAAE,YACDG,GACGC,IAAQC,EACZ;GACE,UAAU,MAAON,EAAE,QAAQO,CAAY;GACvC,YAAY,MAAQP,EAAE,YAAYO,CAAY,KAAK;EACrD,GACAN,EAAE,eAAgBO,CACpB,GACMC,IAAQP,EAAI,KAAK,MAAOG,EAAM,MAAME,CAAE,CAAC,GACvCzB,IAAS2B,EAAM,KAAK,MAAMC,EAA0BC,GAAGR,CAAI,CAAC,GAC5DS,IAAShC,EAAkBE,GAAQD,GAAI;GAC3C,eAAe;IACb,IAAM8B,IAAIb,EAAW,SAAS,IAAI;IAClC,OAAOa,IAAI;KAAE,GAAGA,EAAE;KAAQ,GAAGA,EAAE;IAAO,IAAI;GAC5C;GACA,aAAa,MAAOD,EAA0BL,EAAM,MAAME,CAAE,GAAGJ,CAAI;EACrE,CAAC;EACD,IAAIS,MAAW,MAAM;EACrB,IAAMC,IAAY,CAAC;EACnB,KAAK,IAAIC,IAAI,GAAGA,IAAIZ,EAAI,QAAQ,KAAK;GACnC,IAAM,EAAE,OAAI,UAAOhB,EAAcJ,EAAOgC,IAAIF,GAAQzB,CAAI;GACxD,IAAI4B,MAAO,KAAKC,MAAO,GAAG;GAC1B,IAAMnC,IAAKoC,EAA2BR,EAAMK,IAAIC,GAAIC,GAAIb,CAAI;GAC5D,EAAI,KAAKe,EAAyB;IAChC,IAAIhB,EAAIY;IACR,MAAMd,EAAE,QAAQE,EAAIY,EAAE;IACtB,IAAIT,EAAM,MAAMH,EAAIY,IAAIjC,CAAE;GAC5B,CAAC,CAAC;EACJ;EACA,AAAIgC,EAAI,WAAW,KACnBM,EAAmBnB,GAAGa,GAAKZ,EAAE,SAAS,OAAO;CAC/C,GAAG;EAACV;EAAYG;EAASI;CAAU,CAE1B,EAAM;AACjB"}

package/dist/interactions/actions/booleans/booleans.js

@@ -0,0 +1,120 @@
+import { locateChild as e } from "../../../core/ops/slot.js";
+import { createDeleteOp as t } from "../../../core/ops/delete.js";
+import { createInsertOp as n } from "../../../core/ops/create.js";
+import { dispatchApplyBatch as r } from "../../../core/applyOps.js";
+import { createSetSelectionOp as i } from "../../../core/ops/select.js";
+import { createMoveToIndexOp as a } from "../../../core/ops/reorder/index.js";
+import { pathCrop as o, pathDivide as s, pathExclude as c, pathIntersect as l, pathSubtract as u, pathUnion as d } from "../../../features/paths/booleans.js";
+import { TextOutlinesError as f, textToPath as p } from "../../../features/text/textToPath.js";
+//#region src/interactions/actions/booleans/booleans.ts
+function m(e, t) {
+	let n = e.getWorldPath(t);
+	if (n) return n;
+	let r = e.getTextSource?.(t);
+	if (!r) return;
+	let i = p(r.data, r.pose);
+	return i.commands.length > 0 ? i : void 0;
+}
+var h = {
+	union: "Union",
+	intersect: "Intersect",
+	subtract: "Subtract",
+	exclude: "Exclude",
+	divide: "Divide",
+	crop: "Crop"
+};
+function g(e) {
+	return e.commands.length === 0;
+}
+function _(p, _) {
+	let v = [...p.getSelection()], y = (t) => p.getZOrder ? p.getZOrder(t) : e(p, t) ?? void 0, b;
+	try {
+		b = v.map((e) => ({
+			id: e,
+			path: m(p, e)
+		}));
+	} catch (e) {
+		if (e instanceof f) return {
+			kind: "failed",
+			reason: "text-outlines",
+			error: e
+		};
+		throw e;
+	}
+	let x = b.filter((e) => e.path != null).sort((e, t) => p.compareZ(e.id, t.id));
+	if (x.length === 0) return {
+		kind: "noop",
+		reason: "no-paths"
+	};
+	if (_ === "subtract" && x.length < 2) return {
+		kind: "noop",
+		reason: "too-few-for-subtract"
+	};
+	if (x.length < 2) return {
+		kind: "noop",
+		reason: "no-paths"
+	};
+	let S = x.map((e) => e.path), C;
+	switch (_) {
+		case "union":
+			C = [d(...S)];
+			break;
+		case "intersect":
+			C = [l(...S)];
+			break;
+		case "exclude":
+			C = [c(...S)];
+			break;
+		case "subtract": {
+			let e = S[0], t = S.length === 2 ? S[1] : d(...S.slice(1));
+			C = [u(e, t)];
+			break;
+		}
+		case "divide":
+			C = s(...S);
+			break;
+		case "crop": C = o(...S);
+	}
+	if (C = C.filter((e) => !g(e)), C.length === 0) return {
+		kind: "noop",
+		reason: "empty-result"
+	};
+	let w = x[x.length - 1].id, T = y(w), E = T?.index;
+	if (T) {
+		let e = 0;
+		for (let t = 0; t < x.length - 1; t++) {
+			let n = y(x[t].id);
+			n && n.parentId === T.parentId && n.index < T.index && e++;
+		}
+		E = T.index - e;
+	}
+	let D = C.map((e) => p.createPathNode(e, _, w)), O = [], k = [];
+	for (let e of x) {
+		let t = p.getNode?.(e.id) ?? { id: e.id }, n = y(e.id)?.index ?? -1;
+		k.push({
+			node: t,
+			index: n
+		});
+	}
+	k.sort((e, t) => t.index - e.index);
+	for (let { node: e, index: n } of k) O.push(t({
+		node: e,
+		index: n
+	}));
+	for (let e of D) O.push(n({ node: e }));
+	return T && E !== void 0 && O.push(a({
+		ids: D.map((e) => e.id),
+		parentId: T.parentId,
+		index: E
+	})), O.push(i({
+		from: v,
+		to: D.map((e) => e.id)
+	})), r(p, O, h[_]), {
+		kind: "applied",
+		resultIds: D.map((e) => e.id)
+	};
+}
+//#endregion
+export { _ as applyBooleanOp };
+
+//# sourceMappingURL=booleans.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"booleans.js","names":["operandPath","path","adapter","id","text","glyphs","textToPath","LABEL","isEmpty","p","applyBooleanOp","sel","zOrder","locateChild","resolved","err","TextOutlinesError","entries","a","b","op","paths","results","pathUnion","pathIntersect","pathExclude","back","front","pathSubtract","pathDivide","pathCrop","topmostId","topAnchor","targetIndex","shift","i","z","newNodes","ops","captured","node","index","createDeleteOp","n","createInsertOp","createMoveToIndexOp","createSetSelectionOp","dispatchApplyBatch"],"sources":["../../../../src/interactions/actions/booleans/booleans.ts"],"sourcesContent":["/**\n * Pure action core for path boolean operations. Resolves the current\n * selection into z-ordered paths, runs the chosen op, and dispatches a\n * single batch of `Op`s (delete sources + insert results + set selection).\n *\n * The hook (`useBooleans`) wraps this with React glue; testing here is\n * trivial because the function takes a plain adapter.\n */\nimport {\n  pathUnion,\n  pathIntersect,\n  pathSubtract,\n  pathExclude,\n  pathDivide,\n  pathCrop,\n} from 'features/paths/booleans';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createMoveToIndexOp } from 'core/ops/reorder';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport { locateChild } from 'core/ops/slot';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { textToPath, TextOutlinesError, type TextNodeSource } from 'features/text/textToPath';\n\n/** Boolean op identifiers — five Pathfinder primaries plus Crop. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop';\n\n/**\n * z-position descriptor for a path node. `parentId` is the direct parent\n * (or `null` for a top-level node); `index` is the position within that\n * parent's child order — never a global render index.\n */\n/** @internal */\nexport interface BooleanZOrder {\n  parentId: string | null;\n  index: number;\n}\n\n/** Adapter the hook and the pure core both consume. */\nexport interface BooleansAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  getWorldPath(id: NodeId): Path | undefined;\n  /**\n   * Optional: the text node behind `id`, for an id `getWorldPath` has no path\n   * for. Its glyph outlines (`textToPath`) become the operand, so text can be\n   * cut, united or intersected like any shape.\n   */\n  getTextSource?(id: NodeId): TextNodeSource | undefined;\n  compareZ(a: NodeId, b: NodeId): number;\n  /**\n   * Mint a new node from a boolean-op result `Path`. `producedBy` names the\n   * op that synthesized it — adapters that store provenance (e.g. for a\n   * layer-panel icon) record it; others ignore the arg. `sourceId` is the\n   * topmost source, whose slot the result takes: give the node that source's\n   * parent, or the kit's reorder cannot find it there.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId): { id: string };\n  /**\n   * Optional: return the full object for an id, used by the delete ops so\n   * their `invert` (an insert) can restore the complete object on undo.\n   * If omitted, a `{ id }` stub is captured — undo will reinstate the id\n   * but consumers reading other fields (path, fill, etc.) will see them as\n   * undefined. Mirrors `DeleteAdapter.getNode`; should be provided whenever\n   * undo over boolean ops is expected to be lossless.\n   */\n  getNode?(id: NodeId): { id: string } | undefined | null;\n  /**\n   * Optional: the reorder contract. With `getChildren` (and `getParent`, or\n   * every node reads as top-level) the kit reads each source's slot among its\n   * siblings, and with `setChildOrder` as well it moves the result into the\n   * topmost source's slot. Without them the result lands wherever\n   * `insertNode` defaults to. `defaultCommitAdapter` supplies all three.\n   */\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n  /**\n   * Optional override for the slot the kit otherwise reads through\n   * `getParent` / `getChildren`: `id`'s parent and its index in that\n   * parent's child order.\n   *\n   * @deprecated Supply `getParent` and `getChildren` instead, and the kit\n   * derives this.\n   */\n  getZOrder?(id: NodeId): BooleanZOrder | undefined;\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome reported back to callers (lets the hook surface no-op signals). */\nexport type BooleanOpResult =\n  | { kind: 'applied'; resultIds: string[] }\n  | { kind: 'noop'; reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result' }\n  /** A text operand had no outline geometry. Nothing was changed: an op that\n   *  quietly dropped the operand would commit a different shape than asked. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\nfunction operandPath(adapter: BooleansAdapter, id: NodeId): Path | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) return path;\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  // Blank text has no geometry, and is no more an operand than a group is.\n  const glyphs = textToPath(text.data, text.pose);\n  return glyphs.commands.length > 0 ? glyphs : undefined;\n}\n\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n};\n\nfunction isEmpty(p: PolygonPath): boolean {\n  return p.commands.length === 0;\n}\n\n/**\n * Run one Boolean operation over the selected paths and commit the result as a\n * single undoable batch.\n *\n * Operands are ordered back-to-front, which is what makes `subtract` mean\n * \"everything in front removed from the backmost shape\". Returns without\n * mutating anything when the selection holds no paths, or too few for the\n * requested operation.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const zOrder = (id: NodeId): BooleanZOrder | undefined =>\n    adapter.getZOrder ? adapter.getZOrder(id) : locateChild(adapter, id) ?? undefined;\n  // Resolve path nodes only, sorted ascending by `compareZ` so paths[0] is\n  // the bottommost (back) member. `subtract` relies on this: it computes\n  // `back − union(rest)`, which is Illustrator's \"Minus Front.\" Keep this\n  // convention in sync if compareZ semantics ever flip.\n  let resolved: { id: NodeId; path: Path | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, path: operandPath(adapter, id) }));\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  const entries = resolved\n    .filter((e): e is { id: NodeId; path: Path } => e.path != null)\n    .sort((a, b) => adapter.compareZ(a.id, b.id));\n\n  if (entries.length === 0) return { kind: 'noop', reason: 'no-paths' };\n  if (op === 'subtract' && entries.length < 2) {\n    return { kind: 'noop', reason: 'too-few-for-subtract' };\n  }\n  if (entries.length < 2) return { kind: 'noop', reason: 'no-paths' };\n\n  const paths = entries.map((e) => e.path);\n  let results: PolygonPath[];\n\n  switch (op) {\n    case 'union':     results = [pathUnion(...paths)]; break;\n    case 'intersect': results = [pathIntersect(...paths)]; break;\n    case 'exclude':   results = [pathExclude(...paths)]; break;\n    case 'subtract': {\n      // Illustrator \"Minus Front\": back − union(everything in front).\n      const back = paths[0];\n      const front = paths.length === 2 ? paths[1] : pathUnion(...paths.slice(1));\n      results = [pathSubtract(back, front)];\n      break;\n    }\n    case 'divide': {\n      results = pathDivide(...paths);\n      break;\n    }\n    case 'crop': {\n      // Illustrator \"Crop\": clip every source-below-top to the topmost\n      // path; topmost is consumed as the mask. `paths` is back-to-front\n      // ascending, so the topmost source is `paths[paths.length-1]`.\n      results = pathCrop(...paths);\n      break;\n    }\n  }\n\n  results = results.filter((p) => !isEmpty(p));\n  if (results.length === 0) return { kind: 'noop', reason: 'empty-result' };\n\n  // Capture the topmost source's z-slot before we mutate the scene. The\n  // topmost source is the last entry (entries are back-to-front ascending).\n  // We adjust for selected members that sit below the topmost in the same\n  // parent — their deletions collapse the parent's child list before the\n  // reorder runs, so the visual slot the topmost occupied lives at a lower\n  // index after the deletes. Members in a different parent don't affect\n  // this parent's indexing.\n  const topmostId = entries[entries.length - 1].id;\n  const topAnchor = zOrder(topmostId);\n  let targetIndex = topAnchor?.index;\n  if (topAnchor) {\n    let shift = 0;\n    for (let i = 0; i < entries.length - 1; i++) {\n      const z = zOrder(entries[i].id);\n      if (z && z.parentId === topAnchor.parentId && z.index < topAnchor.index) {\n        shift++;\n      }\n    }\n    targetIndex = topAnchor.index - shift;\n  }\n\n  const newNodes = results.map((p) => adapter.createPathNode(p, op, topmostId));\n  const ops: Op[] = [];\n  const captured: { node: { id: string }; index: number }[] = [];\n  for (const e of entries) {\n    // Capture the full node so the delete's `invert()` (an insert) restores\n    // every field on undo. Fallback to a `{ id }` stub matches the legacy\n    // behavior for adapters that haven't opted in yet. Index comes from\n    // the same slot read used for anchoring; -1 when the adapter doesn't\n    // expose order.\n    const node = adapter.getNode?.(e.id) ?? { id: e.id };\n    const index = zOrder(e.id)?.index ?? -1;\n    captured.push({ node, index });\n  }\n  // Order by index DESC so reverse-then-invert (history's undo path)\n  // re-inserts ASC — each splice lands on a correctly-sized array\n  // instead of clamping high indices to a still-growing length.\n  captured.sort((a, b) => b.index - a.index);\n  for (const { node, index } of captured) ops.push(createDeleteOp({ node, index }));\n  for (const n of newNodes) ops.push(createInsertOp({ node: n }));\n  if (topAnchor && targetIndex !== undefined) {\n    // After the deletes, the topmost source's index is no longer occupied;\n    // moving the new nodes to the adjusted index drops them into that slot.\n    // For divide (N outputs), they form a contiguous block in input order\n    // starting at the target index.\n    ops.push(createMoveToIndexOp({\n      ids: newNodes.map((n) => n.id),\n      parentId: topAnchor.parentId,\n      index: targetIndex,\n    }));\n  }\n  ops.push(createSetSelectionOp({\n    from: sel,\n    to: newNodes.map((n) => n.id as NodeId),\n  }));\n  dispatchApplyBatch(adapter, ops, LABEL[op]);\n\n  return { kind: 'applied', resultIds: newNodes.map((n) => n.id) };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/booleans/useBooleans.js

@@ -0,0 +1,20 @@
+import { applyBooleanOp as e } from "./booleans.js";
+import { useCallback as t } from "react";
+import { useLatest as n } from "@weasel-js/react";
+function r(r, i = {}) {
+	let a = n(r), o = t((t) => {
+		e(a.current, t);
+	}, [a]);
+	return {
+		union: t(() => o("union"), [o]),
+		intersect: t(() => o("intersect"), [o]),
+		subtract: t(() => o("subtract"), [o]),
+		exclude: t(() => o("exclude"), [o]),
+		divide: t(() => o("divide"), [o]),
+		crop: t(() => o("crop"), [o])
+	};
+}
+//#endregion
+export { r as useBooleans };
+
+//# sourceMappingURL=useBooleans.js.map

package/dist/interactions/actions/booleans/useBooleans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBooleans.js","names":["useBooleans","adapterRef","useLatest","adapter","run","useCallback","op"],"sources":["../../../../src/interactions/actions/booleans/useBooleans.ts"],"sourcesContent":["/**\n * `useBooleans` — selection-driven Boolean ops on path layers.\n *\n * Returns six imperative callables (`union` / `intersect` / `subtract` /\n * `exclude` / `divide` / `crop`). Each reads the current selection,\n * performs the op in world space, and dispatches a single batch through\n * the adapter's `applyOps` (one undo step).\n *\n * Adapter shape: see `BooleansAdapter` in `./booleans.ts`. Consumers\n * supply how to read selection, fetch the world-space `Path` for an id,\n * compare ids by stacking order, and mint a node from a result `Path`.\n *\n * No-ops are silent in production; in dev, `subtract` with < 2 selected\n * paths emits a `console.warn`.\n */\nimport { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { applyBooleanOp, type BooleansAdapter, type BooleanOp } from './booleans';\n\n/** The six Boolean path operations, each acting on the current selection and\n *  committing as one undo step. */\nexport interface UseBooleansReturn {\n  union(): void;\n  intersect(): void;\n  subtract(): void;\n  exclude(): void;\n  divide(): void;\n  crop(): void;\n}\n\n/** Options for `useBooleans`. */\nexport interface UseBooleansOptions {\n  /** No-op. Retained for source-compatibility; auto-registration is now\n   *  handled by `useStandardActions` via the Pathfinder descriptors. */\n  enableActions?: boolean;\n}\n\nconst isDev = typeof import.meta !== 'undefined'\n  && (import.meta as { env?: { DEV?: boolean } }).env?.DEV;\n\n/** Bind the Boolean path operations to an adapter that knows how to read the\n *  selection, fetch world-space paths and mint result nodes. */\nexport function useBooleans(\n  adapter: BooleansAdapter,\n  _options: UseBooleansOptions = {},\n): UseBooleansReturn {\n  const adapterRef = useLatest(adapter);\n\n  const run = useCallback((op: BooleanOp) => {\n    const result = applyBooleanOp(adapterRef.current, op);\n    if (isDev && result.kind === 'noop' && result.reason === 'too-few-for-subtract') {\n      console.warn('[useBooleans] subtract requires at least 2 selected paths');\n    }\n  }, [adapterRef]);\n\n  return {\n    union: useCallback(() => run('union'), [run]),\n    intersect: useCallback(() => run('intersect'), [run]),\n    subtract: useCallback(() => run('subtract'), [run]),\n    exclude: useCallback(() => run('exclude'), [run]),\n    divide: useCallback(() => run('divide'), [run]),\n    crop: useCallback(() => run('crop'), [run]),\n  };\n}\n"],"mappings":";;;AA0CA,SAAgBA,EACd,GACA,IAA+B,CAAC,GACb;CACnB,IAAMC,IAAaC,EAAUC,CAAO,GAE9BC,IAAMC,GAAa,MAAkB;EAC1B,EAAeJ,EAAW,SAASK,CAAE;CAItD,GAAG,CAACL,CAAU,CAAC;CAEf,OAAO;EACL,OAAOI,QAAkBD,EAAI,OAAO,GAAG,CAACA,CAAG,CAAC;EAC5C,WAAWC,QAAkBD,EAAI,WAAW,GAAG,CAACA,CAAG,CAAC;EACpD,UAAUC,QAAkBD,EAAI,UAAU,GAAG,CAACA,CAAG,CAAC;EAClD,SAASC,QAAkBD,EAAI,SAAS,GAAG,CAACA,CAAG,CAAC;EAChD,QAAQC,QAAkBD,EAAI,QAAQ,GAAG,CAACA,CAAG,CAAC;EAC9C,MAAMC,QAAkBD,EAAI,MAAM,GAAG,CAACA,CAAG,CAAC;CAC5C;AACF"}

package/dist/interactions/actions/booleans/useBooleansAdapter.js

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

package/dist/interactions/actions/booleans/useBooleansAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBooleansAdapter.js","names":["useBooleansAdapter","adapter"],"sources":["../../../../src/interactions/actions/booleans/useBooleansAdapter.ts"],"sourcesContent":["/**\n * `useBooleansAdapter` — publishes a `BooleansAdapter` to the surrounding\n * `<DepRegistryProvider>` (typically inside `<SceneCanvas>`).\n *\n * The Pathfinder action descriptors (`pathfinderUnionAction`, etc., registered\n * by `useStandardActions`) read this dep both in their `enabled` predicate\n * (via `deps.booleansAdapter` — actually they read selection; the adapter is\n * read by the invoker) and in their immediate invoker. Consumers construct an\n * adapter that bridges to their scene's data shape and call this hook to make\n * the kit's Pathfinder strip operational.\n *\n * No-op when no `<DepRegistryProvider>` is in scope — mirrors the silent-\n * no-op contract of `useDepSource`.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport type { BooleansAdapter } from './booleans';\n\n/** Publish a Boolean-ops adapter so the built-in Pathfinder actions can run.\n *  Silently does nothing outside a `<DepRegistryProvider>`. */\nexport function useBooleansAdapter(adapter: BooleansAdapter): void {\n  useDepSource('booleansAdapter', () => adapter);\n}\n"],"mappings":";;AAmBA,SAAgBA,EAAmB,GAAgC;CACjE,EAAa,yBAAyBC,CAAO;AAC/C"}

package/dist/interactions/actions/clipboard/clipboardOps.js

@@ -0,0 +1,94 @@
+import { dispatchApplyBatch as e } from "../../../core/applyOps.js";
+import { usePointerContext as t } from "../../../features/pointer/PointerContext.js";
+import { dwarn as n } from "../../../debug/flag.js";
+import { materializePaste as r } from "./materializePaste.js";
+import { WEASEL_CLIPBOARD_MIME as i, buildWeaselClipboardText as a } from "./wireFormat.js";
+import { useCallback as o, useRef as s } from "react";
+import { useLatest as c } from "@weasel-js/react";
+//#region src/interactions/actions/clipboard/clipboardOps.ts
+var l = { items: [] };
+function u(i, a) {
+	let { getSelection: u, onPaste: f, pasteLabel: m = "Paste", getDropPoint: h, produceFlavors: g, jsonReplacer: _ } = a, v = t(), y = h ?? v?.getDropPoint, b = s(l), x = c(i), S = c({
+		getSelection: u,
+		onPaste: f,
+		pasteLabel: m,
+		getDropPoint: y,
+		produceFlavors: g,
+		jsonReplacer: _
+	});
+	return {
+		copy: o(() => {
+			let e = S.current.getSelection();
+			if (e.length === 0) return;
+			let t = x.current.snapshotSelection;
+			if (!t) return;
+			b.current = t(e);
+			let r = null;
+			try {
+				r = S.current.produceFlavors?.(b.current) ?? d(b.current, S.current.jsonReplacer);
+			} catch (e) {
+				n("clipboard", `flavor producer threw — skipping OS write: ${String(e)}`);
+			}
+			r && p(r);
+		}, [x, S]),
+		paste: o(() => {
+			let t = b.current;
+			if (t.items.length === 0) return;
+			let n = x.current, i = r(n, t, {
+				currentSelection: S.current.getSelection(),
+				dropPoint: S.current.getDropPoint?.()
+			});
+			i && (e(n, i.ops, S.current.pasteLabel), b.current = { items: i.created }, S.current.onPaste?.(i.newIds));
+		}, [x, S]),
+		isEmpty: o(() => b.current.items.length === 0, [])
+	};
+}
+function d(e, t) {
+	let n = a(e.items, t);
+	return {
+		[i]: n,
+		"text/plain": n
+	};
+}
+var f = /* @__PURE__ */ new Set([
+	"text/plain",
+	"text/html",
+	"image/png"
+]);
+async function p(e) {
+	let t = Object.entries(e);
+	if (t.length === 0) return;
+	let r = typeof navigator < "u" ? navigator.clipboard : void 0;
+	if (!r?.write || typeof ClipboardItem > "u") return;
+	let i = /* @__PURE__ */ new Set();
+	for (let [e, n] of t) typeof n != "string" && n.catch(() => {
+		i.add(e);
+	});
+	let a = (e) => f.has(e) ? e : `web ${e}`, o = (e) => new ClipboardItem(Object.fromEntries(e.map(([e, t]) => {
+		let n = a(e), r = (e) => new Blob([e], { type: n });
+		if (typeof t == "string") return [n, r(t)];
+		let i = t.then(r);
+		return i.catch(() => {}), [n, i];
+	}))), s = async (e) => {
+		let t = e;
+		for (;;) try {
+			return await r.write([o(t)]), null;
+		} catch (e) {
+			let n = t.filter(([e]) => !i.has(e));
+			if (n.length === t.length || n.length === 0) return e;
+			t = n;
+		}
+	};
+	if (await s(t) === null) return;
+	let c = t.filter(([e]) => f.has(e) && !i.has(e));
+	if (c.length === 0) {
+		n("clipboard", "OS write failed; no standard flavors to fall back to");
+		return;
+	}
+	let l = await s(c);
+	l !== null && n("clipboard", `OS clipboard write failed twice — copy stays in-memory only: ${String(l)}`);
+}
+//#endregion
+export { u as useClipboardOps, p as writeOsClipboard };
+
+//# sourceMappingURL=clipboardOps.js.map

package/dist/interactions/actions/clipboard/clipboardOps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboardOps.js","names":["EMPTY","useClipboardOps","options","pointerCtx","usePointerContext","effectiveGetDropPoint","getDropPoint","clipboardRef","useRef","adapterRef","useLatest","adapter","optsRef","useCallback","ids","snap","flavors","defaultFlavors","err","writeOsClipboard","cb","a","result","materializePaste","dispatchApplyBatch","text","buildWeaselClipboardText","snapshot","replacer","WEASEL_CLIPBOARD_MIME","WELL_KNOWN_CLIPBOARD_MIMES","entries","rejected","mime","wireMime","toItem","fs","wire","blob","t","promised","writeLive","live","next","standard","dwarn"],"sources":["../../../../src/interactions/actions/clipboard/clipboardOps.ts"],"sourcesContent":["import { useCallback, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { InsertAdapter } from 'core/adapters/types';\nimport type { ClipboardSnapshot } from './types';\nimport { usePointerContext } from 'features/pointer/PointerContext';\nimport { dwarn } from 'debug/flag';\nimport { materializePaste } from './materializePaste';\nimport { WEASEL_CLIPBOARD_MIME, buildWeaselClipboardText } from './wireFormat';\n\ntype Replacer = (key: string, value: unknown) => unknown;\n\n/** Options for `useClipboardOps`. */\nexport interface UseClipboardOpsOptions {\n  /** How the hook reads \"current selection\" for copy. The kit doesn't assume\n   *  a global selection store; each consumer wires this. */\n  getSelection: () => NodeId[];\n  /** Called after a successful paste with the ids of the newly inserted objects. */\n  onPaste?: (newIds: NodeId[]) => void;\n  /** Label for the history entry produced by paste. Default 'Paste'. */\n  pasteLabel?: string;\n  /** Pulled once per paste() call. When non-null, threaded to commitPaste\n   *  as `ctx.dropPoint`; adapters typically use it as the cluster origin\n   *  (ignoring `offset`). When null/undefined, the hook falls back to the\n   *  existing cascade-offset behavior. */\n  getDropPoint?: () => { worldX: number; worldY: number } | null;\n  /** Produce the OS-clipboard flavor map for a copied snapshot. Keys are MIME\n   *  types, values the serialized payload. The kit default emits\n   *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the\n   *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to\n   *  replace the text flavor. Return an empty object to skip the OS write\n   *  entirely. A value may be a promise — an SVG flavor waiting on\n   *  `warmSvg`, say: the write is still issued inside the copy gesture and\n   *  the clipboard takes the text when it resolves. The producer itself runs\n   *  synchronously, so it reads the selection as it stood at the copy. */\n  produceFlavors?: (snapshot: ClipboardSnapshot) => ClipboardFlavors;\n  /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored\n   *  when `produceFlavors` is supplied. */\n  jsonReplacer?: Replacer;\n}\n\n/** MIME type to payload, as `produceFlavors` returns it. */\nexport type ClipboardFlavors = Record<string, string | Promise<string>>;\n\n/** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */\nexport interface UseClipboardOpsReturn {\n  copy(): void;\n  paste(): void;\n  isEmpty(): boolean;\n}\n\nconst EMPTY: ClipboardSnapshot = { items: [] };\n\n/** In-memory copy/paste of selections via `InsertAdapter.snapshotSelection` / `commitPaste`. */\nexport function useClipboardOps<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  options: UseClipboardOpsOptions,\n): UseClipboardOpsReturn {\n  const { getSelection, onPaste, pasteLabel = 'Paste', getDropPoint, produceFlavors, jsonReplacer } = options;\n  // Fall back to the ambient pointer context (auto-published by SceneCanvas)\n  // when the caller didn't supply an explicit `getDropPoint`. Null context\n  // (no provider in scope) and no caller-supplied thunk together mean\n  // \"no drop point\" — paste uses the cascade offset instead.\n  const pointerCtx = usePointerContext();\n  const effectiveGetDropPoint = getDropPoint ?? pointerCtx?.getDropPoint;\n  const clipboardRef = useRef<ClipboardSnapshot>(EMPTY);\n  // Keep callbacks stable across renders.\n  const adapterRef = useLatest(adapter);\n  const optsRef = useLatest({\n    getSelection, onPaste, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors, jsonReplacer,\n  });\n\n  const copy = useCallback(() => {\n    const ids = optsRef.current.getSelection();\n    if (ids.length === 0) return;\n    const snap = adapterRef.current.snapshotSelection;\n    if (!snap) return;\n    clipboardRef.current = snap(ids);\n    // Best-effort OS write. Never blocks or throws — the in-memory ref is\n    // already set, and OS clipboard support varies (custom formats are\n    // Chromium-only via the \"web \" prefix; jsdom/non-secure contexts have\n    // no API at all). The flavor producer itself is untrusted consumer code\n    // (`produceFlavors`), so guard its call too — a throwing producer must\n    // not break `copy()`, it just skips the OS write.\n    let flavors: ClipboardFlavors | null = null;\n    try {\n      flavors = optsRef.current.produceFlavors?.(clipboardRef.current)\n        ?? defaultFlavors(clipboardRef.current, optsRef.current.jsonReplacer);\n    } catch (err) {\n      dwarn('clipboard', `flavor producer threw — skipping OS write: ${String(err)}`);\n    }\n    if (flavors) void writeOsClipboard(flavors);\n  }, [adapterRef, optsRef]);\n\n  const paste = useCallback(() => {\n    const cb = clipboardRef.current;\n    if (cb.items.length === 0) return;\n    const a = adapterRef.current;\n    const result = materializePaste(a, cb, {\n      currentSelection: optsRef.current.getSelection(),\n      dropPoint: optsRef.current.getDropPoint?.(),\n    });\n    if (!result) return;\n    dispatchApplyBatch(a, result.ops, optsRef.current.pasteLabel);\n    // Use the just-created objects as the next cascade source. Re-snapshotting\n    // via `adapter.snapshotSelection(newIds)` would read adapter state, but\n    // React-state adapters haven't flushed yet — `itemsRef.current` still\n    // points at the pre-insert array, so the snapshot would come back empty\n    // and the next paste would no-op.\n    clipboardRef.current = { items: result.created };\n    optsRef.current.onPaste?.(result.newIds as NodeId[]);\n  }, [adapterRef, optsRef]);\n\n  const isEmpty = useCallback(() => clipboardRef.current.items.length === 0, []);\n\n  return { copy, paste, isEmpty };\n}\n\nfunction defaultFlavors(snapshot: ClipboardSnapshot, replacer?: Replacer): ClipboardFlavors {\n  const text = buildWeaselClipboardText(snapshot.items, replacer);\n  return { [WEASEL_CLIPBOARD_MIME]: text, 'text/plain': text };\n}\n\n/** MIME types the async Clipboard API accepts unprefixed. Every other type\n *  (including our own custom MIME, and app-supplied flavors like\n *  `image/svg+xml`) must carry Chromium's `web ` prefix or `ClipboardItem`'s\n *  constructor throws. */\nconst WELL_KNOWN_CLIPBOARD_MIMES = new Set(['text/plain', 'text/html', 'image/png']);\n\n/** Degradation ladder: full map (every non-well-known MIME web-prefixed) →\n *  the same minus any promised flavor that rejected → well-known-only → give\n *  up with a dwarn. Chromium writes nothing when one flavor rejects, so a\n *  rejection costs only that flavor, never the clipboard's previous content\n *  half-overwritten.\n *  @internal test seam — exported so unit tests can await the fire-and-forget\n *  write directly; tests should still exercise this at least once through\n *  the public `copy()` (see clipboardOps.test.tsx). */\nexport async function writeOsClipboard(flavors: ClipboardFlavors): Promise<void> {\n  const entries = Object.entries(flavors);\n  if (entries.length === 0) return;\n  const cb = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;\n  if (!cb?.write || typeof ClipboardItem === 'undefined') return;\n  const rejected = new Set<string>();\n  for (const [mime, text] of entries) {\n    if (typeof text !== 'string') text.catch(() => { rejected.add(mime); });\n  }\n  const wireMime = (mime: string) => (WELL_KNOWN_CLIPBOARD_MIMES.has(mime) ? mime : `web ${mime}`);\n  const toItem = (fs: Flavor[]) => new ClipboardItem(Object.fromEntries(\n    fs.map(([mime, text]) => {\n      const wire = wireMime(mime);\n      const blob = (t: string) => new Blob([t], { type: wire });\n      if (typeof text === 'string') return [wire, blob(text)];\n      const promised = text.then(blob);\n      // Chromium leaves a ClipboardItem's rejected promise unhandled.\n      promised.catch(() => {});\n      return [wire, promised];\n    }),\n  ));\n  // Writes `fs`, dropping flavors whose promise rejected and retrying the\n  // rest. Returns the last error, or null once a write lands.\n  const writeLive = async (fs: Flavor[]): Promise<unknown> => {\n    let live = fs;\n    for (;;) {\n      try {\n        await cb.write([toItem(live)]);\n        return null;\n      } catch (err) {\n        const next = live.filter(([mime]) => !rejected.has(mime));\n        if (next.length === live.length || next.length === 0) return err;\n        live = next;\n      }\n    }\n  };\n  if (await writeLive(entries) === null) return;\n  const standard = entries.filter(([mime]) => WELL_KNOWN_CLIPBOARD_MIMES.has(mime) && !rejected.has(mime));\n  if (standard.length === 0) { dwarn('clipboard', 'OS write failed; no standard flavors to fall back to'); return; }\n  const err = await writeLive(standard);\n  if (err !== null) dwarn('clipboard', `OS clipboard write failed twice — copy stays in-memory only: ${String(err)}`);\n}\n\ntype Flavor = [mime: string, text: string | Promise<string>];\n"],"mappings":"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"}

package/dist/interactions/actions/clipboard/materializePaste.js

@@ -0,0 +1,25 @@
+import { createInsertOp as e } from "../../../core/ops/create.js";
+import { createSetSelectionOp as t } from "../../../core/ops/select.js";
+//#region src/interactions/actions/clipboard/materializePaste.ts
+function n(n, r, i) {
+	let a = n.commitPaste;
+	if (!a) return null;
+	let o = n.getPasteOffset?.(r) ?? {
+		dx: 0,
+		dy: 0
+	}, s = i.dropPoint == null ? void 0 : { dropPoint: i.dropPoint }, c = a.call(n, r, o, s);
+	if (c.length === 0) return null;
+	let l = c.map((e) => e.id);
+	return {
+		ops: [...c.map((t) => e({ node: t })), t({
+			from: i.currentSelection,
+			to: l
+		})],
+		newIds: l,
+		created: c
+	};
+}
+//#endregion
+export { n as materializePaste };
+
+//# sourceMappingURL=materializePaste.js.map

package/dist/interactions/actions/clipboard/materializePaste.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"materializePaste.js","names":["materializePaste","commitPaste","adapter","offset","snapshot","ctx","opts","created","newIds","o","createInsertOp","createSetSelectionOp"],"sources":["../../../../src/interactions/actions/clipboard/materializePaste.ts"],"sourcesContent":["/**\n * Shared paste materialization — the one place the paste recipe lives:\n * offset policy → `commitPaste` → the op batch (InsertOps parents-first +\n * a SetSelectionOp). Both `useClipboardOps.paste` (in-memory paste) and the\n * kit weasel-JSON content handler (OS-clipboard paste) dispatch exactly this\n * batch, so the two arrival paths stay indistinguishable in history.\n *\n * Pure: no dispatching here — callers own how the ops are applied\n * (`dispatchApplyBatch` vs `IngestCtx.applyOps`) and any post-paste\n * bookkeeping (the hook's cascade re-snapshot, the handler's selection set).\n */\nimport { createInsertOp } from 'core/ops/create';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type { ClipboardSnapshot, InsertAdapter } from 'core/adapters/types';\n\n/** Shared paste materialization: offset policy → commitPaste → the op batch\n *  both the in-memory paste and the OS-paste handler dispatch. Returns null\n *  when the adapter can't paste or nothing was created. */\nexport function materializePaste<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  snapshot: ClipboardSnapshot,\n  opts: {\n    currentSelection: string[];\n    dropPoint?: { worldX: number; worldY: number } | null;\n  },\n): { ops: Op[]; newIds: string[]; created: TNode[] } | null {\n  const commitPaste = adapter.commitPaste;\n  if (!commitPaste) return null;\n  const offset = adapter.getPasteOffset?.(snapshot) ?? { dx: 0, dy: 0 };\n  const ctx = opts.dropPoint != null ? { dropPoint: opts.dropPoint } : undefined;\n  const created = commitPaste.call(adapter, snapshot, offset, ctx);\n  if (created.length === 0) return null;\n  const newIds = created.map((o) => o.id);\n  const ops: Op[] = [\n    ...created.map((o) => createInsertOp({ node: o })),\n    createSetSelectionOp({ from: opts.currentSelection as NodeId[], to: newIds as NodeId[] }),\n  ];\n  return { ops, newIds, created };\n}\n"],"mappings":";;;AAoBA,SAAgBA,EACd,GACA,GACA,GAI0D;CAC1D,IAAMC,IAAcC,EAAQ;CAC5B,IAAI,CAACD,GAAa,OAAO;CACzB,IAAME,IAASD,EAAQ,iBAAiBE,CAAQ,KAAK;EAAE,IAAI;EAAG,IAAI;CAAE,GAC9DC,IAAMC,EAAK,aAAa,OAAuC,KAAA,IAAhC,EAAE,WAAWA,EAAK,UAAU,GAC3DC,IAAUN,EAAY,KAAKC,GAASE,GAAUD,GAAQE,CAAG;CAC/D,IAAIE,EAAQ,WAAW,GAAG,OAAO;CACjC,IAAMC,IAASD,EAAQ,KAAK,MAAME,EAAE,EAAE;CAKtC,OAAO;EAAE,KAAA,CAHP,GAAGF,EAAQ,KAAK,MAAMG,EAAe,EAAE,MAAMD,EAAE,CAAC,CAAC,GACjDE,EAAqB;GAAE,MAAML,EAAK;GAA8B,IAAIE;EAAmB,CAAC,CAEjF;EAAK;EAAQ;CAAQ;AAChC"}

package/dist/interactions/actions/clipboard/wireFormat.js

@@ -0,0 +1,43 @@
+import { dwarn as e } from "../../../debug/flag.js";
+//#region src/interactions/actions/clipboard/wireFormat.ts
+var t = "application/x-weasel-clipboard+json", n = `web ${t}`;
+function r(e, t) {
+	return JSON.stringify({
+		weaselClipboard: 1,
+		nodes: e
+	}, t);
+}
+function i(e) {
+	if (!e.includes("\"weaselClipboard\"")) return !1;
+	try {
+		let t = JSON.parse(e);
+		return !!t && t.weaselClipboard === 1;
+	} catch {
+		return !1;
+	}
+}
+var a = /<svg(?:\s[^>]*)?>/i;
+function o(t, n) {
+	let r = a.exec(t);
+	if (!r) return e("clipboard", "embedWeaselMetadataInSvg: no <svg ...> open tag found — returning input unchanged"), t;
+	let i = `<![CDATA[${n.replaceAll("]]>", "]]]]><![CDATA[>")}]]>`, o = r.index + r[0].length;
+	return `${t.slice(0, o)}<metadata>${i}</metadata>${t.slice(o)}`;
+}
+function s(e) {
+	let t = /<metadata(?:\s[^>]*)?>([\s\S]*?)<\/metadata>/i.exec(e);
+	if (!t) return null;
+	let n = t[1], r = n.includes("<![CDATA[") ? Array.from(n.matchAll(/<!\[CDATA\[([\s\S]*?)\]\]>/g), (e) => e[1]).join("") : n;
+	return i(r) ? r : null;
+}
+function c(t, n) {
+	try {
+		let e = JSON.parse(t, n);
+		return !e || e.weaselClipboard !== 1 || !Array.isArray(e.nodes) ? null : e.nodes;
+	} catch (t) {
+		return e("clipboard", `weasel payload failed to parse: ${String(t)}`), null;
+	}
+}
+//#endregion
+export { t as WEASEL_CLIPBOARD_MIME, n as WEASEL_CLIPBOARD_MIME_WEB, r as buildWeaselClipboardText, o as embedWeaselMetadataInSvg, s as extractWeaselClipboardFromSvg, c as parseWeaselClipboardText, i as sniffWeaselClipboardText };
+
+//# sourceMappingURL=wireFormat.js.map

package/dist/interactions/actions/clipboard/wireFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wireFormat.js","names":["WEASEL_CLIPBOARD_MIME","WEASEL_CLIPBOARD_MIME_WEB","buildWeaselClipboardText","items","replacer","sniffWeaselClipboardText","text","parsed","SVG_OPEN_TAG","embedWeaselMetadataInSvg","open","svgText","dwarn","cdata","payloadText","at","extractWeaselClipboardFromSvg","block","inner","payload","m","parseWeaselClipboardText","reviver","err"],"sources":["../../../../src/interactions/actions/clipboard/wireFormat.ts"],"sourcesContent":["import { dwarn } from 'debug/flag';\n\n/** MIME type the kit writes its full-fidelity clipboard payload under, so a\n *  copy/paste between two weasel canvases round-trips scene nodes rather than\n *  the SVG or text flavors other apps read. */\nexport const WEASEL_CLIPBOARD_MIME = 'application/x-weasel-clipboard+json';\n/** Chromium's async-clipboard spelling for custom formats. */\nexport const WEASEL_CLIPBOARD_MIME_WEB = `web ${WEASEL_CLIPBOARD_MIME}`;\n\ninterface WeaselClipboardPayload { weaselClipboard: 1; nodes: unknown[] }\n\ntype Replacer = (key: string, value: unknown) => unknown;\ntype Reviver = (key: string, value: unknown) => unknown;\n\n/** Serialize snapshot items into the versioned wire text.\n *\n *  Function-valued fields (e.g. a container's `clipFromPose`) are dropped by\n *  JSON serialization — OS-pasted clip containers arrive unclipped.\n *  Consumers who need clips to survive the OS round-trip can translate\n *  function ↔ registry key in their `jsonReplacer`/reviver pair (the\n *  scene-serialization `clipFromPoseKey` precedent). */\nexport function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string {\n  const payload: WeaselClipboardPayload = { weaselClipboard: 1, nodes: items };\n  return JSON.stringify(payload, replacer as Parameters<typeof JSON.stringify>[1]);\n}\n\n/** Cheap check: could this text be a weasel clipboard payload? Substring\n *  pre-check, then a guarded parse + marker/version test. */\nexport function sniffWeaselClipboardText(text: string): boolean {\n  if (!text.includes('\"weaselClipboard\"')) return false;\n  try {\n    const parsed = JSON.parse(text) as Partial<WeaselClipboardPayload> | null;\n    return !!parsed && parsed.weaselClipboard === 1;\n  } catch {\n    return false;\n  }\n}\n\n// Opening `<svg ...>` tag of a serialized document. `[^>]*` is safe for OUR\n// serializer's output (attribute values are XML-escaped, so no raw `>` can\n// appear inside the tag) — see embedWeaselMetadataInSvg's contract note.\nconst SVG_OPEN_TAG = /<svg(?:\\s[^>]*)?>/i;\n\n/**\n * Embed a weasel clipboard payload in an SVG document as a `<metadata>`\n * child of the root — legal SVG 1.1, ignored by external tools — so one\n * `text/plain` flavor serves both audiences: external tools parse the SVG,\n * weasel extracts the JSON for full fidelity on draw→draw DOM paste.\n *\n * The payload rides in CDATA so JSON's `<` / `&` need no entity escaping; a\n * literal `]]>` inside the payload is split across CDATA sections\n * (`]]]]><![CDATA[>`), which {@link extractWeaselClipboardFromSvg} rejoins.\n *\n * Intended for OUR serializer's output only (`serializeSvg` — single\n * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found\n * the input is returned unchanged with a debug warning.\n */\nexport function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string {\n  const open = SVG_OPEN_TAG.exec(svgText);\n  if (!open) {\n    dwarn('clipboard', 'embedWeaselMetadataInSvg: no <svg ...> open tag found — returning input unchanged');\n    return svgText;\n  }\n  const cdata = `<![CDATA[${payloadText.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`;\n  const at = open.index + open[0].length;\n  return `${svgText.slice(0, at)}<metadata>${cdata}</metadata>${svgText.slice(at)}`;\n}\n\n/**\n * Recover an embedded weasel clipboard payload from SVG text: read the first\n * `<metadata>` block, rejoin its CDATA sections (concatenation restores the\n * `]]>` split by {@link embedWeaselMetadataInSvg}; plain non-CDATA content\n * passes through as-is), and return the payload text iff it sniffs as the\n * weasel wire format — else null (external/non-weasel metadata declines).\n *\n * A text scan, not an XML parse — the payload is small and ours.\n */\nexport function extractWeaselClipboardFromSvg(svgText: string): string | null {\n  const block = /<metadata(?:\\s[^>]*)?>([\\s\\S]*?)<\\/metadata>/i.exec(svgText);\n  if (!block) return null;\n  const inner = block[1];\n  const payload = inner.includes('<![CDATA[')\n    ? Array.from(inner.matchAll(/<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>/g), (m) => m[1]).join('')\n    : inner;\n  return sniffWeaselClipboardText(payload) ? payload : null;\n}\n\n/** Parse wire text to snapshot items, or null when malformed/mismatched\n *  (callers decline to the next content handler). */\nexport function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null {\n  try {\n    const parsed = JSON.parse(text, reviver as Parameters<typeof JSON.parse>[1]) as\n      Partial<WeaselClipboardPayload> | null;\n    if (!parsed || parsed.weaselClipboard !== 1 || !Array.isArray(parsed.nodes)) return null;\n    return parsed.nodes;\n  } catch (err) {\n    dwarn('clipboard', `weasel payload failed to parse: ${String(err)}`);\n    return null;\n  }\n}\n"],"mappings":";;AAKA,IAAaA,IAAwB,uCAExBC,IAA4B,OAAOD;AAchD,SAAgBE,EAAyB,GAAkB,GAA6B;CAEtF,OAAO,KAAK,UAAU;EADoB,iBAAiB;EAAG,OAAOC;CAC/C,GAASC,CAAgD;AACjF;AAIA,SAAgBC,EAAyB,GAAuB;CAC9D,IAAI,CAACC,EAAK,SAAS,qBAAmB,GAAG,OAAO;CAChD,IAAI;EACF,IAAMC,IAAS,KAAK,MAAMD,CAAI;EAC9B,OAAO,CAAC,CAACC,KAAUA,EAAO,oBAAoB;CAChD,QAAQ;EACN,OAAO;CACT;AACF;AAKA,IAAMC,IAAe;AAgBrB,SAAgBC,EAAyB,GAAiB,GAA6B;CACrF,IAAMC,IAAOF,EAAa,KAAKG,CAAO;CACtC,IAAI,CAACD,GAEH,OADAE,EAAM,aAAa,mFAAmF,GAC/FD;CAET,IAAME,IAAQ,YAAYC,EAAY,WAAW,OAAO,iBAAiB,EAAE,MACrEC,IAAKL,EAAK,QAAQA,EAAK,EAAE,CAAC;CAChC,OAAO,GAAGC,EAAQ,MAAM,GAAGI,CAAE,EAAE,YAAYF,EAAM,aAAaF,EAAQ,MAAMI,CAAE;AAChF;AAWA,SAAgBC,EAA8B,GAAgC;CAC5E,IAAMC,IAAQ,gDAAgD,KAAKN,CAAO;CAC1E,IAAI,CAACM,GAAO,OAAO;CACnB,IAAMC,IAAQD,EAAM,IACdE,IAAUD,EAAM,SAAS,WAAW,IACtC,MAAM,KAAKA,EAAM,SAAS,6BAA6B,IAAI,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAC9EF;CACJ,OAAOb,EAAyBc,CAAO,IAAIA,IAAU;AACvD;AAIA,SAAgBE,EAAyB,GAAc,GAAqC;CAC1F,IAAI;EACF,IAAMd,IAAS,KAAK,MAAMD,GAAMgB,CAA2C;EAG3E,OADI,CAACf,KAAUA,EAAO,oBAAoB,KAAK,CAAC,MAAM,QAAQA,EAAO,KAAK,IAAU,OAC7EA,EAAO;CAChB,SAASgB,GAAK;EAEZ,OADAX,EAAM,aAAa,mCAAmC,OAAOW,CAAG,GAAG,GAC5D;CACT;AACF"}

package/dist/interactions/actions/clone/behaviors/cloneByAltDrag.js

@@ -0,0 +1,26 @@
+import { createInsertOp as e } from "../../../../core/ops/create.js";
+import { createSetSelectionOp as t } from "../../../../core/ops/select.js";
+//#region src/interactions/actions/clone/behaviors/cloneByAltDrag.ts
+function n() {
+	return {
+		id: "cloneByAltDrag",
+		activates: (e) => e.alt === !0,
+		onEnd(n, r) {
+			if (!r.adapter.snapshotSelection || !r.adapter.commitPaste) return [];
+			let i = r.adapter.snapshotSelection(n.ids), a = r.adapter.commitPaste(i, n.offset, { dropPoint: {
+				worldX: n.worldX,
+				worldY: n.worldY
+			} });
+			if (a.length === 0) return [];
+			let o = a.map((e) => e.id), s = r.adapter.getSelection?.() ?? [];
+			return [...a.map((t) => e({ node: t })), t({
+				from: s,
+				to: o
+			})];
+		}
+	};
+}
+//#endregion
+export { n as cloneByAltDrag };
+
+//# sourceMappingURL=cloneByAltDrag.js.map

package/dist/interactions/actions/clone/behaviors/cloneByAltDrag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneByAltDrag.js","names":["cloneByAltDrag","mods","ctx","snap","pose","created","newIds","o","from","createInsertOp","createSetSelectionOp"],"sources":["../../../../../src/interactions/actions/clone/behaviors/cloneByAltDrag.ts"],"sourcesContent":["import { createInsertOp } from 'core/ops/create';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport type { NodeId } from 'core/scene/types';\nimport type { CloneBehavior } from '../../../gestures/types';\n\n/** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */\nexport function cloneByAltDrag(): CloneBehavior {\n  return {\n    id: 'cloneByAltDrag',\n    activates: (mods) => mods.alt === true,\n    onEnd(pose, ctx) {\n      if (!ctx.adapter.snapshotSelection || !ctx.adapter.commitPaste) return [];\n      const snap = ctx.adapter.snapshotSelection(pose.ids);\n      const created = ctx.adapter.commitPaste(snap, pose.offset, {\n        dropPoint: { worldX: pose.worldX, worldY: pose.worldY },\n      });\n      if (created.length === 0) return [];\n      const newIds = created.map((o: { id: string }) => o.id);\n      const from = ctx.adapter.getSelection?.() ?? [];\n      return [\n        ...created.map((o) => createInsertOp({ node: o })),\n        createSetSelectionOp({ from: from as NodeId[], to: newIds as NodeId[] }),\n      ];\n    },\n  };\n}\n"],"mappings":";;;AAMA,SAAgBA,IAAgC;CAC9C,OAAO;EACL,IAAI;EACJ,YAAY,MAASC,EAAK,QAAQ;EAClC,MAAM,GAAM,GAAK;GACf,IAAI,CAACC,EAAI,QAAQ,qBAAqB,CAACA,EAAI,QAAQ,aAAa,OAAO,CAAC;GACxE,IAAMC,IAAOD,EAAI,QAAQ,kBAAkBE,EAAK,GAAG,GAC7CC,IAAUH,EAAI,QAAQ,YAAYC,GAAMC,EAAK,QAAQ,EACzD,WAAW;IAAE,QAAQA,EAAK;IAAQ,QAAQA,EAAK;GAAO,EACxD,CAAC;GACD,IAAIC,EAAQ,WAAW,GAAG,OAAO,CAAC;GAClC,IAAMC,IAASD,EAAQ,KAAK,MAAsBE,EAAE,EAAE,GAChDC,IAAON,EAAI,QAAQ,eAAe,KAAK,CAAC;GAC9C,OAAO,CACL,GAAGG,EAAQ,KAAK,MAAMI,EAAe,EAAE,MAAMF,EAAE,CAAC,CAAC,GACjDG,EAAqB;IAAQ;IAAkB,IAAIJ;GAAmB,CAAC,CACzE;EACF;CACF;AACF"}

package/dist/interactions/actions/defaultCommitAdapter.js

@@ -0,0 +1,42 @@
+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/defaultCommitAdapter.ts
+function r(r, i) {
+	return {
+		getNode: (e) => r.get(t(e)),
+		getNodes: () => [...r.renderOrderNodes()],
+		getPose: (n) => e(r, r.get(t(n))),
+		getSelection: () => [...i ? i.getSelection() : r.getSelection()],
+		setSelection: (e) => {
+			i ? i.setSelection(e.map(t)) : r.setSelection(e.map(t));
+		},
+		getParent: (e) => r.get(t(e))?.parent ?? null,
+		getRemovalClosure: (e) => [...r.removalClosure(e.map(t))],
+		getChildren: (e) => e === null ? [...r.roots] : [...r.childrenOf(t(e))],
+		setChildOrder: (e, n) => {
+			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);
+		},
+		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 }),
+		setLayer: (e, n) => r.setLayer(t(e), n),
+		setLayout: (e, n) => r.setLayout(t(e), 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,
+			...e.parent == null ? {} : { parent: e.parent },
+			...t === void 0 ? {} : { index: t },
+			...e.dependsOn === void 0 ? {} : { dependsOn: e.dependsOn },
+			...n(e)
+		})
+	};
+}
+//#endregion
+export { r as defaultCommitAdapter };
+
+//# sourceMappingURL=defaultCommitAdapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultCommitAdapter.js","names":["defaultCommitAdapter","scene","asNodeId","id","documentPose","selection","ids","parentId","orderedIds","pose","layer","layout","node","index","fnFieldsOfNode"],"sources":["../../../src/interactions/actions/defaultCommitAdapter.ts"],"sourcesContent":["/**\n * Shared scene-backed commit adapter for default actions.\n *\n * Default actions route data/layer/pose/parent mutations through the\n * consumer's `applyOps` commit hook when one is present; when it isn't, they\n * fall back to applying the committed ops directly against the scene through\n * this adapter. It carries the scene-backed op-apply methods (`setPose` /\n * `setParent` / `setData` / `setLayer` / `setLayout` / `removeNode` /\n * `insertNode` / `setChildOrder`) plus the read-side queries (`getNode` / `getNodes` /\n * `getPose` / `getParent` / `getChildren` / `getSelection`) and\n * `setSelection`. Known exclusions from the op factory roster — surfaces the\n * scene doesn't own: `setPath` and `setText`.\n *\n * Lives in `interactions/actions/` (not `canvas/sceneAdapter.ts`) so default\n * actions never import from `canvas/` — that back-edge would create an\n * `interactions → canvas → interactions` cycle. Mirrors `moveGestureAdapter`,\n * widened to all op-apply methods.\n */\nimport { fnFieldsOfNode } from 'core/scene/nodeFnFields';\nimport { documentPose } from 'core/scene/effectivePose';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { LayoutStrategy } from '../../layout/types';\n\n/** Build the adapter the default actions commit through when the consumer\n *  supplies no `applyOps` hook of its own — it applies ops straight to the\n *  scene. Path and text ops are not covered; those surfaces belong to their\n *  own owners.\n *\n *  Pass `selection` (a `SelectionApi`'s `adapterMethods`) and selection reads\n *  and writes go through it rather than the scene, so a canvas that gates its\n *  selection — `selectable={false}` — gates what these batches select too. */\nexport function defaultCommitAdapter<TPose>(\n  scene: Scene<unknown, string, TPose>,\n  selection?: SelectionApi['adapterMethods'],\n) {\n  return {\n    getNode: (id: string) => scene.get(asNodeId(id)),\n    getNodes: () => {\n      return [...scene.renderOrderNodes()] as Node<unknown, string, TPose>[];\n    },\n    getPose: (id: string) => documentPose(scene, scene.get(asNodeId(id))!),\n    getSelection: (): string[] => [...(selection ? selection.getSelection() : scene.getSelection())],\n    setSelection: (ids: string[]) => {\n      if (selection) selection.setSelection(ids.map(asNodeId));\n      else scene.setSelection(ids.map(asNodeId));\n    },\n    getParent: (id: string) => (scene.get(asNodeId(id))?.parent ?? null) as string | null,\n    getRemovalClosure: (ids: readonly string[]): string[] =>\n      [...scene.removalClosure(ids.map(asNodeId))],\n    getChildren: (parentId: string | null): string[] =>\n      (parentId === null\n        ? [...scene.roots]\n        : [...scene.childrenOf(asNodeId(parentId))]) as string[],\n    // Re-stamp each slot whose occupant changed. `scene.reorder` mutates the\n    // live sibling list in place, so re-read it each iteration and skip slots\n    // already holding the desired id (an earlier reorder may have shifted a\n    // later id into place). One enclosing batch is provided by the caller\n    // (`scene.applyBatch` / consumer `applyOps`), so no batch here.\n    setChildOrder: (parentId: string | null, orderedIds: string[]): void => {\n      for (let i = 0; i < orderedIds.length; i++) {\n        const current = parentId === null\n          ? (scene.roots as readonly NodeId[])\n          : (scene.childrenOf(asNodeId(parentId)) as readonly NodeId[]);\n        if ((current[i] as string) === orderedIds[i]) continue;\n        scene.reorder(asNodeId(orderedIds[i]), i);\n      }\n    },\n    setPose: (id: string, pose: TPose) => scene.setPose(asNodeId(id), pose),\n    setParent: (id: string, parentId: string | null) =>\n      scene.move(asNodeId(id), parentId == null ? null : asNodeId(parentId)),\n    setData: (id: string, data: unknown) => scene.update(asNodeId(id), { data } as never),\n    setLayer: (id: string, layer: string) => scene.setLayer(asNodeId(id), layer as never),\n    setLayout: (id: string, layout: LayoutStrategy<TPose> | string | null) =>\n      scene.setLayout(asNodeId(id), layout),\n    removeNode: (id: string) => scene.remove(asNodeId(id)),\n    insertNode: (node: Node<unknown, string, TPose>, index?: number) =>\n      scene.add({\n        kind: node.kind,\n        layer: node.layer,\n        pose: node.pose,\n        data: node.data,\n        id: node.id,\n        ...(node.parent != null ? { parent: node.parent } : {}),\n        // Sibling-index passthrough: undo of a delete (or a boolean op's\n        // source removal) re-inserts at the recorded z-order slot instead\n        // of appending at the end.\n        ...(index !== undefined ? { index } : {}),\n        ...(node.dependsOn !== undefined ? { dependsOn: node.dependsOn } : {}),\n        ...fnFieldsOfNode(node),\n      }),\n  };\n}\n"],"mappings":";;;;AAiCA,SAAgBA,EACd,GACA,GACA;CACA,OAAO;EACL,UAAU,MAAeC,EAAM,IAAIC,EAASC,CAAE,CAAC;EAC/C,gBACS,CAAC,GAAGF,EAAM,iBAAiB,CAAC;EAErC,UAAU,MAAeG,EAAaH,GAAOA,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAE;EACrE,oBAA8B,CAAC,GAAIE,IAAYA,EAAU,aAAa,IAAIJ,EAAM,aAAa,CAAE;EAC/F,eAAe,MAAkB;GAC/B,AAAII,IAAWA,EAAU,aAAaC,EAAI,IAAIJ,CAAQ,CAAC,IAClDD,EAAM,aAAaK,EAAI,IAAIJ,CAAQ,CAAC;EAC3C;EACA,YAAY,MAAgBD,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAC,EAAE,UAAU;EAC/D,oBAAoB,MAClB,CAAC,GAAGF,EAAM,eAAeK,EAAI,IAAIJ,CAAQ,CAAC,CAAC;EAC7C,cAAc,MACXK,MAAa,OACV,CAAC,GAAGN,EAAM,KAAK,IACf,CAAC,GAAGA,EAAM,WAAWC,EAASK,CAAQ,CAAC,CAAC;EAM9C,gBAAgB,GAAyB,MAA+B;GACtE,KAAK,IAAI,IAAI,GAAG,IAAIC,EAAW,QAAQ,KAIrC,CAHgBD,MAAa,OACxBN,EAAM,QACNA,EAAM,WAAWC,EAASK,CAAQ,CAAC,EAAA,CAC3B,OAAkBC,EAAW,MAC1CP,EAAM,QAAQC,EAASM,EAAW,EAAE,GAAG,CAAC;EAE5C;EACA,UAAU,GAAY,MAAgBP,EAAM,QAAQC,EAASC,CAAE,GAAGM,CAAI;EACtE,YAAY,GAAY,MACtBR,EAAM,KAAKC,EAASC,CAAE,GAAGI,KAAY,OAAO,OAAOL,EAASK,CAAQ,CAAC;EACvE,UAAU,GAAY,MAAkBN,EAAM,OAAOC,EAASC,CAAE,GAAG,EAAE,QAAK,CAAU;EACpF,WAAW,GAAY,MAAkBF,EAAM,SAASC,EAASC,CAAE,GAAGO,CAAc;EACpF,YAAY,GAAY,MACtBT,EAAM,UAAUC,EAASC,CAAE,GAAGQ,CAAM;EACtC,aAAa,MAAeV,EAAM,OAAOC,EAASC,CAAE,CAAC;EACrD,aAAa,GAAoC,MAC/CF,EAAM,IAAI;GACR,MAAMW,EAAK;GACX,OAAOA,EAAK;GACZ,MAAMA,EAAK;GACX,MAAMA,EAAK;GACX,IAAIA,EAAK;GACT,GAAIA,EAAK,UAAU,OAAiC,CAAC,IAA3B,EAAE,QAAQA,EAAK,OAAO;GAIhD,GAAIC,MAAU,KAAA,IAAwB,CAAC,IAAb,EAAE,SAAM;GAClC,GAAID,EAAK,cAAc,KAAA,IAA4C,CAAC,IAAjC,EAAE,WAAWA,EAAK,UAAU;GAC/D,GAAGE,EAAeF,CAAI;EACxB,CAAC;CACL;AACF"}