@weasel-js/core 1.10.0 → 1.10.1

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

@@ -1,9 +1,9 @@
 import { IDENTITY_POSE_COMPOSITION as e } from "../../../core/scene/composeFrame.js";
 import { unionAABB as t } from "../../../core/geometry/unionBounds.js";
 import { RECT_POSE_DESCRIPTOR as n, translatePoseViaDescriptor as r, visualBoundsViaDescriptor as i } from "../../../core/geometry/poseDescriptor.js";
-import { createTransformOp as a } from "../../../core/ops/transform.js";
-import { poseFrame as o } from "../poseFrame.js";
-import { dispatchApplyBatch as s } from "../../../core/applyOps.js";
+import { dispatchApplyBatch as a } from "../../../core/applyOps.js";
+import { createTransformOp as o } from "../../../core/ops/transform.js";
+import { poseFrame as s } from "../poseFrame.js";
 import { resolveSpatialReference as c } from "../spatialReference.js";
 import { useCallback as l } from "react";
 import { useLatest as u } from "@weasel-js/react";
@@ -43,9 +43,9 @@ function p(e, t, n) {
 function m(t, c = {}) {
 	let m = u(t), h = u(c), g = d(), _ = u(g);
 	return { align: l((t, c) => {
-		let l = m.current, u = h.current, d = l.getSelection(), g = u.geometry ?? n, v = o({
+		let l = m.current, u = h.current, d = l.getSelection(), g = u.geometry ?? n, v = s({
 			getPose: (e) => l.getPose(e),
-			getParent: (e) => l.getParent?.(e) ?? null
+			getParent: (e) => l.getParent(e)
 		}, u.composition ?? e), y = d.map((e) => v.world(e)), b = y.map((e) => i(e, g)), x = f(b, c, {
 			pointer: () => {
 				let e = _.current?.get();
@@ -61,14 +61,14 @@ function m(t, c = {}) {
 		for (let e = 0; e < d.length; e++) {
 			let { dx: n, dy: i } = p(b[e], x, t);
 			if (n === 0 && i === 0) continue;
-			let o = r(y[e], n, i, g);
-			S.push(a({
+			let a = r(y[e], n, i, g);
+			S.push(o({
 				id: d[e],
 				from: l.getPose(d[e]),
-				to: v.local(d[e], o)
+				to: v.local(d[e], a)
 			}));
 		}
-		S.length !== 0 && s(l, S, u.label ?? "Align");
+		S.length !== 0 && a(l, S, u.label ?? "Align");
 	}, [
 		m,
 		h,

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

@@ -1 +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 'core/scene/composePose';\nimport { usePointerContext } from '@weasel-js/routing/react';\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"}
+{"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 'core/scene/composePose';\nimport { usePointerContext } from '@weasel-js/routing/react';\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 node's container, `null` for a root: the chain a pose is composed\n   *  through when container poses define a frame. */\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) 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,MAAOP,EAAE,UAAUO,CAAY;EAC7C,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

@@ -1,7 +1,7 @@
-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 { dispatchApplyBatch as e } from "../../../core/applyOps.js";
+import { locateChild as t } from "../../../core/ops/slot.js";
+import { createDeleteOp as n } from "../../../core/ops/delete.js";
+import { createInsertOp as r } from "../../../core/ops/create.js";
 import { createSetSelectionOp as i } from "../../../core/ops/select.js";
 import { resolveOperand as a } from "./operands.js";
 import { booleanPieces as o } from "./pieces.js";
@@ -78,31 +78,31 @@ function d(e, t, n = {}) {
 function f(a, o, c = {}) {
 	let d = [...a.getSelection()], f = u(a, d, o, c);
 	if ("kind" in f) return f;
-	let { entries: p, pieces: m } = f, h = (t) => a.getZOrder ? a.getZOrder(t) : e(a, t) ?? void 0, g = p.map((e) => h(e.id)), _ = m.map((e) => {
+	let { entries: p, pieces: m } = f, h = p.map((e) => t(a, e.id) ?? void 0), g = m.map((e) => {
 		let { id: t, operand: n } = p[e.source];
 		return {
 			node: a.createPathNode(e.path, o, t, n.paint),
-			slot: g[e.source]
+			slot: h[e.source]
 		};
-	}), v = _.map((e) => e.node), y = [], b = p.map((e, t) => ({
-		node: a.getNode?.(e.id) ?? { id: e.id },
-		index: g[t]?.index ?? -1
+	}), _ = g.map((e) => e.node), v = [], y = p.map((e, t) => ({
+		node: a.getNode(e.id) ?? { id: e.id },
+		index: h[t]?.index ?? -1
 	}));
-	b.sort((e, t) => t.index - e.index);
-	for (let { node: e, index: n } of b) y.push(t({
+	y.sort((e, t) => t.index - e.index);
+	for (let { node: e, index: t } of y) v.push(n({
 		node: e,
-		index: n
+		index: t
 	}));
-	for (let e of v) y.push(n({ node: e }));
-	return y.push(...s(_.map((e) => ({
+	for (let e of _) v.push(r({ node: e }));
+	return v.push(...s(g.map((e) => ({
 		id: e.node.id,
 		slot: e.slot
-	})), g)), y.push(i({
+	})), h)), v.push(i({
 		from: d,
-		to: v.map((e) => e.id)
-	})), r(a, y, l[o]), {
+		to: _.map((e) => e.id)
+	})), e(a, v, l[o]), {
 		kind: "applied",
-		resultIds: v.map((e) => e.id)
+		resultIds: _.map((e) => e.id)
 	};
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"booleans.js","names":["LABEL","planBooleanOp","resolved","sel","resolveOperand","adapter","id","opts","err","TextOutlinesError","entries","a","b","op","pieces","booleanPieces","i","paint","operand","previewBooleanOp","plan","piece","applyBooleanOp","zOrder","locateChild","slots","made","newNodes","m","ops","captured","createDeleteOp","n","createInsertOp","placementOps","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 */\nimport type { Mat3, Path } from '@weasel-js/geom';\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 type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport { resolveOperand, type BooleanOpOptions, type BooleanOperand } from './operands';\nimport { booleanPieces, type ResultPiece } from './pieces';\nimport { placementOps } from './placement';\n\n/** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';\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  /**\n   * Optional: the paint the path node behind `id` wears. An operation told to\n   * count strokes (`BooleanOpOptions.strokes`) reads it to learn whether the\n   * node is stroked and whether it is filled; without it every operand is its\n   * path alone.\n   */\n  getPaint?(id: NodeId): PathPaint | undefined;\n  /**\n   * Optional: the frame the node behind `id` draws its stroke in, as the\n   * matrix taking that frame to world (`poseFrameOf`); null or absent for a\n   * node drawn straight. A counted world-width stroke is skewed and stretched\n   * with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Mat3 | null | 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   * source the result stands in for: the topmost, except that each piece of\n   * a Divide, Crop, Trim, or Merge names the topmost source it was cut from. Give the\n   * node that source's parent, or the kit's reorder cannot find it there.\n   * `paint` is passed when that source's stroke went into the geometry, and\n   * the node must wear it as given: wearing the source's stroke again would\n   * draw it twice. Without `paint`, give it that source's paint. The kit never\n   * reads a node's `data`: anything else the result should keep of its source,\n   * a name say, is the adapter's to copy from `sourceId`.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId, paint?: PathPaint): { 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.\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 each result into the\n   * slot of the topmost source in its own source's parent. 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\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n  trim: 'Trim',\n  merge: 'Merge',\n};\n\n/** One path a Boolean operation would make. */\nexport interface BooleanPreviewPiece {\n  path: Path;\n  /** The source the piece stands in for; see `BooleansAdapter.createPathNode`. */\n  sourceId: NodeId;\n  /** Set when that source's stroke went into `path`: the paint the piece wears. */\n  paint?: PathPaint;\n}\n\n/** What {@link previewBooleanOp} answers: the pieces, or why there are none. */\nexport type BooleanOpPreview =\n  | { kind: 'pieces'; pieces: BooleanPreviewPiece[] }\n  | Exclude<BooleanOpResult, { kind: 'applied' }>;\n\ntype Entry = { id: NodeId; operand: BooleanOperand };\n\n/** The operands back to front and the pieces `op` makes of them, or the\n *  result that says why it makes none. Reads the adapter and changes nothing. */\nfunction planBooleanOp(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  op: BooleanOp,\n  opts: BooleanOpOptions,\n): { entries: Entry[]; pieces: ResultPiece[] } | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  // Sorted ascending by `compareZ` so the first entry is the bottommost\n  // (back) member. `subtract` relies on this: it computes `back − union(rest)`.\n  let resolved: { id: NodeId; operand: BooleanOperand | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, operand: resolveOperand(adapter, id, opts) }));\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 Entry => e.operand != 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  // Merge unites the operands that wear one fill; one whose paint is unknown is united with nothing.\n  const fillKey = (i: number): unknown => {\n    const { id, operand } = entries[i]!;\n    const paint = operand.paint ?? adapter.getPaint?.(id);\n    return paint ? JSON.stringify(paint.fill ?? null) : i;\n  };\n  const pieces = booleanPieces(op, entries.map((e) => e.operand.path), fillKey);\n  if (pieces.length === 0) return { kind: 'noop', reason: 'empty-result' };\n  return { entries, pieces };\n}\n\n/**\n * What {@link applyBooleanOp} would make of the selection, without minting a\n * node or committing anything: for drawing an operation before it is applied.\n */\nexport function previewBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpPreview {\n  const plan = planBooleanOp(adapter, [...adapter.getSelection()] as NodeId[], op, opts);\n  if ('kind' in plan) return plan;\n  return {\n    kind: 'pieces',\n    pieces: plan.pieces.map((piece) => {\n      const { id, operand } = plan.entries[piece.source]!;\n      return operand.paint ? { path: piece.path, sourceId: id, paint: operand.paint } : { path: piece.path, sourceId: id };\n    }),\n  };\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. `opts.strokes` says what a stroked operand gives.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const plan = planBooleanOp(adapter, sel, op, opts);\n  if ('kind' in plan) return plan;\n  const { entries, pieces } = plan;\n  const zOrder = (id: NodeId): BooleanZOrder | undefined =>\n    adapter.getZOrder ? adapter.getZOrder(id) : locateChild(adapter, id) ?? undefined;\n\n  // Every source's slot, read before the scene is mutated.\n  const slots = entries.map((e) => zOrder(e.id));\n  // A piece stands in for its own source: it is minted from that source, wears\n  // the paint a stroke folded into that source left it, and takes its slot.\n  const made = pieces.map((piece) => {\n    const { id, operand } = entries[piece.source]!;\n    return { node: adapter.createPathNode(piece.path, op, id, operand.paint), slot: slots[piece.source] };\n  });\n  const newNodes = made.map((m) => m.node);\n  const ops: Op[] = [];\n  // Capture the full node so the delete's `invert()` (an insert) restores\n  // every field on undo; a `{ id }` stub for an adapter with no `getNode`.\n  // The index is -1 when the adapter exposes no order.\n  const captured = entries.map((e, i) => ({\n    node: adapter.getNode?.(e.id) ?? { id: e.id },\n    index: slots[i]?.index ?? -1,\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  ops.push(...placementOps(made.map((m) => ({ id: m.node.id, slot: m.slot })), slots));\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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"}
+{"version":3,"file":"booleans.js","names":["LABEL","planBooleanOp","resolved","sel","resolveOperand","adapter","id","opts","err","TextOutlinesError","entries","a","b","op","pieces","booleanPieces","i","paint","operand","previewBooleanOp","plan","piece","applyBooleanOp","slots","locateChild","made","newNodes","m","ops","captured","createDeleteOp","n","createInsertOp","placementOps","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 */\nimport type { Affine, Path } from '@weasel-js/geom';\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 type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport { resolveOperand, type BooleanOpOptions, type BooleanOperand } from './operands';\nimport { booleanPieces, type ResultPiece } from './pieces';\nimport { placementOps } from './placement';\n\n/** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';\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  /**\n   * Optional: the paint the path node behind `id` wears. An operation told to\n   * count strokes (`BooleanOpOptions.strokes`) reads it to learn whether the\n   * node is stroked and whether it is filled; without it every operand is its\n   * path alone.\n   */\n  getPaint?(id: NodeId): PathPaint | undefined;\n  /**\n   * Optional: the frame the node behind `id` draws its stroke in, as the\n   * matrix taking that frame to world (`poseFrameOf`); null or absent for a\n   * node drawn straight. A counted world-width stroke is skewed and stretched\n   * with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Affine | null | 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   * source the result stands in for: the topmost, except that each piece of\n   * a Divide, Crop, Trim, or Merge names the topmost source it was cut from. Give the\n   * node that source's parent, or the kit's reorder cannot find it there.\n   * `paint` is passed when that source's stroke went into the geometry, and\n   * the node must wear it as given: wearing the source's stroke again would\n   * draw it twice. Without `paint`, give it that source's paint. The kit never\n   * reads a node's `data`: anything else the result should keep of its source,\n   * a name say, is the adapter's to copy from `sourceId`.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId, paint?: PathPaint): { id: string };\n  /**\n   * The full object for an id. The delete ops capture it, so their `invert`\n   * (an insert) restores the complete object on undo.\n   */\n  getNode(id: NodeId): { id: string } | undefined | null;\n  /**\n   * The tree. The kit reads each source's slot among its siblings through\n   * `getParent` and `getChildren`, and moves each result into the slot of\n   * the topmost source in its own source's parent through `setChildOrder`.\n   * `defaultCommitAdapter` supplies all three, and `getNode`.\n   */\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\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\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n  trim: 'Trim',\n  merge: 'Merge',\n};\n\n/** One path a Boolean operation would make. */\nexport interface BooleanPreviewPiece {\n  path: Path;\n  /** The source the piece stands in for; see `BooleansAdapter.createPathNode`. */\n  sourceId: NodeId;\n  /** Set when that source's stroke went into `path`: the paint the piece wears. */\n  paint?: PathPaint;\n}\n\n/** What {@link previewBooleanOp} answers: the pieces, or why there are none. */\nexport type BooleanOpPreview =\n  | { kind: 'pieces'; pieces: BooleanPreviewPiece[] }\n  | Exclude<BooleanOpResult, { kind: 'applied' }>;\n\ntype Entry = { id: NodeId; operand: BooleanOperand };\n\n/** The operands back to front and the pieces `op` makes of them, or the\n *  result that says why it makes none. Reads the adapter and changes nothing. */\nfunction planBooleanOp(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  op: BooleanOp,\n  opts: BooleanOpOptions,\n): { entries: Entry[]; pieces: ResultPiece[] } | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  // Sorted ascending by `compareZ` so the first entry is the bottommost\n  // (back) member. `subtract` relies on this: it computes `back − union(rest)`.\n  let resolved: { id: NodeId; operand: BooleanOperand | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, operand: resolveOperand(adapter, id, opts) }));\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 Entry => e.operand != 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  // Merge unites the operands that wear one fill; one whose paint is unknown is united with nothing.\n  const fillKey = (i: number): unknown => {\n    const { id, operand } = entries[i]!;\n    const paint = operand.paint ?? adapter.getPaint?.(id);\n    return paint ? JSON.stringify(paint.fill ?? null) : i;\n  };\n  const pieces = booleanPieces(op, entries.map((e) => e.operand.path), fillKey);\n  if (pieces.length === 0) return { kind: 'noop', reason: 'empty-result' };\n  return { entries, pieces };\n}\n\n/**\n * What {@link applyBooleanOp} would make of the selection, without minting a\n * node or committing anything: for drawing an operation before it is applied.\n */\nexport function previewBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpPreview {\n  const plan = planBooleanOp(adapter, [...adapter.getSelection()] as NodeId[], op, opts);\n  if ('kind' in plan) return plan;\n  return {\n    kind: 'pieces',\n    pieces: plan.pieces.map((piece) => {\n      const { id, operand } = plan.entries[piece.source]!;\n      return operand.paint ? { path: piece.path, sourceId: id, paint: operand.paint } : { path: piece.path, sourceId: id };\n    }),\n  };\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. `opts.strokes` says what a stroked operand gives.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const plan = planBooleanOp(adapter, sel, op, opts);\n  if ('kind' in plan) return plan;\n  const { entries, pieces } = plan;\n  // Every source's slot, read before the scene is mutated.\n  const slots: (BooleanZOrder | undefined)[] =\n    entries.map((e) => locateChild(adapter, e.id) ?? undefined);\n  // A piece stands in for its own source: it is minted from that source, wears\n  // the paint a stroke folded into that source left it, and takes its slot.\n  const made = pieces.map((piece) => {\n    const { id, operand } = entries[piece.source]!;\n    return { node: adapter.createPathNode(piece.path, op, id, operand.paint), slot: slots[piece.source] };\n  });\n  const newNodes = made.map((m) => m.node);\n  const ops: Op[] = [];\n  // Capture the full node so the delete's `invert()` (an insert) restores\n  // every field on undo. The index is -1 for a source its parent does not list.\n  const captured = entries.map((e, i) => ({\n    node: adapter.getNode(e.id) ?? { id: e.id },\n    index: slots[i]?.index ?? -1,\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  ops.push(...placementOps(made.map((m) => ({ id: m.node.id, slot: m.slot })), slots));\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/operands.js.map

@@ -1 +1 @@
-{"version":3,"file":"operands.js","names":["inkOf","source","strokePaint","stroke","strokes","fill","ribbon","strokeRegion","path","frame","scale","pathUnion","resolveOperand","adapter","id","paint","text","glyphs","textToPath","inks","textToPathsByPaint","p","ink","whole"],"sources":["../../../../src/interactions/actions/booleans/operands.ts"],"sourcesContent":["/**\n * What each selected node gives a Boolean operation: its path, its glyph\n * outlines, or the region its ink covers once a stroke is counted.\n */\nimport type { Mat3, Path, Scale2 } from '@weasel-js/geom';\nimport { pathUnion } from '@weasel-js/geom/booleans';\nimport { textToPath, textToPathsByPaint } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { NodeId } from 'core/scene/types';\nimport type { PaintedPath } from '../outlines/replaceWithPaths';\nimport { strokeRegion } from '../outlines/strokeRegion';\nimport type { BooleansAdapter } from './booleans';\n\n/**\n * What a stroked operand gives a Boolean operation.\n *\n * - `'ignore'`: its path, as though it had no stroke.\n * - `'unfilled'`: the region its stroke covers when it has no fill, as a line\n *   or an open pencil stroke has none; its path when it is filled.\n * - `'include'`: what it paints — its fill and its stroke together, or the\n *   stroke alone when it has no fill.\n *\n * Any mode but `'ignore'` needs {@link BooleansAdapter.getPaint}.\n */\nexport type BooleanStrokes = 'ignore' | 'unfilled' | 'include';\n\n/** Options for `applyBooleanOp`. */\nexport interface BooleanOpOptions {\n  /** Default `'ignore'`. */\n  strokes?: BooleanStrokes;\n  /** The view scale a `{ px }` stroke width resolves against: one number, or\n   *  the view's own scale per axis. Default 1. */\n  scale?: number | Scale2;\n}\n\n/** @internal */\nexport interface BooleanOperand {\n  path: Path;\n  /** Set when a stroke went into `path`: what a result standing in for this\n   *  operand wears, the stroke being part of its shape now. */\n  paint?: PathPaint;\n}\n\nfunction inkOf(\n  source: PaintedPath,\n  strokes: BooleanStrokes,\n  frame: Mat3 | null | undefined,\n  scale: number | Scale2 | undefined,\n): BooleanOperand {\n  const { path, fill } = source;\n  const { stroke } = source;\n  const strokePaint = stroke?.paint;\n  if (!stroke || strokePaint == null) return { path };\n  if (strokes === 'ignore' || (strokes === 'unfilled' && fill !== null)) return { path };\n  const ribbon = strokeRegion(path, stroke, frame, scale === undefined ? {} : { scale });\n  if (ribbon.commands.length === 0) return { path };\n  return { path: fill !== null ? pathUnion(path, ribbon) : ribbon, paint: { fill: fill ?? { paint: strokePaint } } };\n}\n\n/**\n * The operand behind `id`, or `undefined` for a node that is not one: a group,\n * blank text, anything the adapter has neither a path nor text for. Throws\n * `TextOutlinesError` for text whose face has no outlines.\n */\nexport function resolveOperand(\n  adapter: BooleansAdapter,\n  id: NodeId,\n  { strokes = 'ignore', scale }: BooleanOpOptions,\n): BooleanOperand | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) {\n    const paint = strokes === 'ignore' ? undefined : adapter.getPaint?.(id);\n    return paint ? inkOf({ path, ...paint }, strokes, adapter.getStrokeFrame?.(id), scale) : { path };\n  }\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  if (strokes === 'ignore') {\n    const glyphs = textToPath(text.data, text.pose);\n    return glyphs.commands.length > 0 ? { path: glyphs } : undefined;\n  }\n  const inks = textToPathsByPaint(text.data, text.pose).map((p) => inkOf(p, strokes, adapter.getStrokeFrame?.(id), scale));\n  if (inks.length === 0) return undefined;\n  const paint = inks.find((ink) => ink.paint)?.paint;\n  const whole = inks.length === 1 ? inks[0]!.path : pathUnion(...inks.map((ink) => ink.path));\n  return paint ? { path: whole, paint } : { path: whole };\n}\n"],"mappings":";;;;AA2CA,SAASA,EACP,GACA,GACA,GACA,GACgB;CAChB,IAAM,EAAE,SAAM,YAASC,GACjB,EAAE,cAAWA,GACbC,IAAcC,GAAQ;CAE5B,IADI,CAACA,KAAUD,KAAe,QAC1BE,MAAY,YAAaA,MAAY,cAAcC,MAAS,MAAO,OAAO,EAAE,QAAK;CACrF,IAAMC,IAASC,EAAaC,GAAML,GAAQM,GAAOC,MAAU,KAAA,IAAY,CAAC,IAAI,EAAE,SAAM,CAAC;CAErF,OADIJ,EAAO,SAAS,WAAW,IAAU,EAAE,QAAK,IACzC;EAAE,MAAMD,MAAS,OAAiCC,IAA1BK,EAAUH,GAAMF,CAAM;EAAY,OAAO,EAAE,MAAMD,KAAQ,EAAE,OAAOH,EAAY,EAAE;CAAE;AACnH;AAOA,SAAgBU,EACd,GACA,GACA,EAAE,aAAU,UAAU,YACM;CAC5B,IAAMJ,IAAOK,EAAQ,aAAaC,CAAE;CACpC,IAAIN,GAAM;EACR,IAAMO,IAAQX,MAAY,WAAW,KAAA,IAAYS,EAAQ,WAAWC,CAAE;EACtE,OAAOC,IAAQf,EAAM;GAAE;GAAM,GAAGe;EAAM,GAAGX,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,IAAI,EAAE,QAAK;CAClG;CACA,IAAMM,IAAOH,EAAQ,gBAAgBC,CAAE;CACvC,IAAI,CAACE,GAAM;CACX,IAAIZ,MAAY,UAAU;EACxB,IAAMa,IAASC,EAAWF,EAAK,MAAMA,EAAK,IAAI;EAC9C,OAAOC,EAAO,SAAS,SAAS,IAAI,EAAE,MAAMA,EAAO,IAAI,KAAA;CACzD;CACA,IAAME,IAAOC,EAAmBJ,EAAK,MAAMA,EAAK,IAAI,CAAC,CAAC,KAAK,MAAMhB,EAAMqB,GAAGjB,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,CAAC;CACvH,IAAIS,EAAK,WAAW,GAAG;CACvB,IAAMJ,IAAQI,EAAK,MAAM,MAAQG,EAAI,KAAK,CAAC,EAAE,OACvCC,IAAQJ,EAAK,WAAW,IAAIA,EAAK,EAAE,CAAE,OAAOR,EAAU,GAAGQ,EAAK,KAAK,MAAQG,EAAI,IAAI,CAAC;CAC1F,OAAOP,IAAQ;EAAE,MAAMQ;EAAO;CAAM,IAAI,EAAE,MAAMA,EAAM;AACxD"}
+{"version":3,"file":"operands.js","names":["inkOf","source","strokePaint","stroke","strokes","fill","ribbon","strokeRegion","path","frame","scale","pathUnion","resolveOperand","adapter","id","paint","text","glyphs","textToPath","inks","textToPathsByPaint","p","ink","whole"],"sources":["../../../../src/interactions/actions/booleans/operands.ts"],"sourcesContent":["/**\n * What each selected node gives a Boolean operation: its path, its glyph\n * outlines, or the region its ink covers once a stroke is counted.\n */\nimport type { Affine, Path, Scale2 } from '@weasel-js/geom';\nimport { pathUnion } from '@weasel-js/geom/booleans';\nimport { textToPath, textToPathsByPaint } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { NodeId } from 'core/scene/types';\nimport type { PaintedPath } from '../outlines/replaceWithPaths';\nimport { strokeRegion } from '../outlines/strokeRegion';\nimport type { BooleansAdapter } from './booleans';\n\n/**\n * What a stroked operand gives a Boolean operation.\n *\n * - `'ignore'`: its path, as though it had no stroke.\n * - `'unfilled'`: the region its stroke covers when it has no fill, as a line\n *   or an open pencil stroke has none; its path when it is filled.\n * - `'include'`: what it paints — its fill and its stroke together, or the\n *   stroke alone when it has no fill.\n *\n * Any mode but `'ignore'` needs {@link BooleansAdapter.getPaint}.\n */\nexport type BooleanStrokes = 'ignore' | 'unfilled' | 'include';\n\n/** Options for `applyBooleanOp`. */\nexport interface BooleanOpOptions {\n  /** Default `'ignore'`. */\n  strokes?: BooleanStrokes;\n  /** The view scale a `{ px }` stroke width resolves against: one number, or\n   *  the view's own scale per axis. Default 1. */\n  scale?: number | Scale2;\n}\n\n/** @internal */\nexport interface BooleanOperand {\n  path: Path;\n  /** Set when a stroke went into `path`: what a result standing in for this\n   *  operand wears, the stroke being part of its shape now. */\n  paint?: PathPaint;\n}\n\nfunction inkOf(\n  source: PaintedPath,\n  strokes: BooleanStrokes,\n  frame: Affine | null | undefined,\n  scale: number | Scale2 | undefined,\n): BooleanOperand {\n  const { path, fill } = source;\n  const { stroke } = source;\n  const strokePaint = stroke?.paint;\n  if (!stroke || strokePaint == null) return { path };\n  if (strokes === 'ignore' || (strokes === 'unfilled' && fill !== null)) return { path };\n  const ribbon = strokeRegion(path, stroke, frame, scale === undefined ? {} : { scale });\n  if (ribbon.commands.length === 0) return { path };\n  return { path: fill !== null ? pathUnion(path, ribbon) : ribbon, paint: { fill: fill ?? { paint: strokePaint } } };\n}\n\n/**\n * The operand behind `id`, or `undefined` for a node that is not one: a group,\n * blank text, anything the adapter has neither a path nor text for. Throws\n * `TextOutlinesError` for text whose face has no outlines.\n */\nexport function resolveOperand(\n  adapter: BooleansAdapter,\n  id: NodeId,\n  { strokes = 'ignore', scale }: BooleanOpOptions,\n): BooleanOperand | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) {\n    const paint = strokes === 'ignore' ? undefined : adapter.getPaint?.(id);\n    return paint ? inkOf({ path, ...paint }, strokes, adapter.getStrokeFrame?.(id), scale) : { path };\n  }\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  if (strokes === 'ignore') {\n    const glyphs = textToPath(text.data, text.pose);\n    return glyphs.commands.length > 0 ? { path: glyphs } : undefined;\n  }\n  const inks = textToPathsByPaint(text.data, text.pose).map((p) => inkOf(p, strokes, adapter.getStrokeFrame?.(id), scale));\n  if (inks.length === 0) return undefined;\n  const paint = inks.find((ink) => ink.paint)?.paint;\n  const whole = inks.length === 1 ? inks[0]!.path : pathUnion(...inks.map((ink) => ink.path));\n  return paint ? { path: whole, paint } : { path: whole };\n}\n"],"mappings":";;;;AA2CA,SAASA,EACP,GACA,GACA,GACA,GACgB;CAChB,IAAM,EAAE,SAAM,YAASC,GACjB,EAAE,cAAWA,GACbC,IAAcC,GAAQ;CAE5B,IADI,CAACA,KAAUD,KAAe,QAC1BE,MAAY,YAAaA,MAAY,cAAcC,MAAS,MAAO,OAAO,EAAE,QAAK;CACrF,IAAMC,IAASC,EAAaC,GAAML,GAAQM,GAAOC,MAAU,KAAA,IAAY,CAAC,IAAI,EAAE,SAAM,CAAC;CAErF,OADIJ,EAAO,SAAS,WAAW,IAAU,EAAE,QAAK,IACzC;EAAE,MAAMD,MAAS,OAAiCC,IAA1BK,EAAUH,GAAMF,CAAM;EAAY,OAAO,EAAE,MAAMD,KAAQ,EAAE,OAAOH,EAAY,EAAE;CAAE;AACnH;AAOA,SAAgBU,EACd,GACA,GACA,EAAE,aAAU,UAAU,YACM;CAC5B,IAAMJ,IAAOK,EAAQ,aAAaC,CAAE;CACpC,IAAIN,GAAM;EACR,IAAMO,IAAQX,MAAY,WAAW,KAAA,IAAYS,EAAQ,WAAWC,CAAE;EACtE,OAAOC,IAAQf,EAAM;GAAE;GAAM,GAAGe;EAAM,GAAGX,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,IAAI,EAAE,QAAK;CAClG;CACA,IAAMM,IAAOH,EAAQ,gBAAgBC,CAAE;CACvC,IAAI,CAACE,GAAM;CACX,IAAIZ,MAAY,UAAU;EACxB,IAAMa,IAASC,EAAWF,EAAK,MAAMA,EAAK,IAAI;EAC9C,OAAOC,EAAO,SAAS,SAAS,IAAI,EAAE,MAAMA,EAAO,IAAI,KAAA;CACzD;CACA,IAAME,IAAOC,EAAmBJ,EAAK,MAAMA,EAAK,IAAI,CAAC,CAAC,KAAK,MAAMhB,EAAMqB,GAAGjB,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,CAAC;CACvH,IAAIS,EAAK,WAAW,GAAG;CACvB,IAAMJ,IAAQI,EAAK,MAAM,MAAQG,EAAI,KAAK,CAAC,EAAE,OACvCC,IAAQJ,EAAK,WAAW,IAAIA,EAAK,EAAE,CAAE,OAAOR,EAAU,GAAGQ,EAAK,KAAK,MAAQG,EAAI,IAAI,CAAC;CAC1F,OAAOP,IAAQ;EAAE,MAAMQ;EAAO;CAAM,IAAI,EAAE,MAAMA,EAAM;AACxD"}

package/dist/interactions/actions/clone/action.js

@@ -5,25 +5,26 @@ import { nodeDescriptors as c, poseDescriptorOf as l } from "../poseDescriptorDe
 import { selectedRoots as u, translateTargets as d } from "../selectionSubtree.js";
 import { scenePoseFrame as f } from "../poseFrame.js";
 import { defaultCommitAdapter as p } from "../defaultCommitAdapter.js";
-import { startCloneBehaviors as m } from "./behaviors.js";
-import { copySelection as h } from "../defaults/copySubtree.js";
+import { recordTransform as m } from "../transform-again/memory.js";
+import { startCloneBehaviors as h } from "./behaviors.js";
+import { copySelection as g } from "../defaults/copySubtree.js";
 //#region src/interactions/actions/clone/action.ts
-function g(t, n, i, a) {
+function _(t, n, i, a) {
 	let s = t.originPoses.get(n), c = t.scene.get(n);
 	if (s === void 0 || !c) return;
 	let l = t.descriptorOf(n), u = e(s, i, a, l);
 	return t.frame.local(n, r(l, u, o(t.view, c.layer)));
 }
-function _(e, t, n) {
+function v(e, t, n) {
 	let { dx: r, dy: i } = e.currentDelta, a = (t) => {
 		e.applyOps ? e.applyOps(t, "Clone") : e.scene.applyBatch(t, "Clone", p(e.scene, n.adapterMethods));
 	}, o = t.end(e.currentDelta);
 	if (o === null) return !1;
 	if (o !== void 0) return o.length > 0 && a(o), !0;
-	let { ops: s, copies: c } = h(e.scene, e.ids, (t, n) => e.originPoses.has(t) ? g(e, t, r, i) : n.pose, "Clone");
+	let { ops: s, copies: c } = g(e.scene, e.ids, (t, n) => e.originPoses.has(t) ? _(e, t, r, i) : n.pose, "Clone");
 	return s.length !== 0 && (a(s), n.set(c), !0);
 }
-var v = i({
+var y = i({
 	id: "clone",
 	label: "Clone",
 	cursor: "copy",
@@ -38,61 +39,65 @@ var v = i({
 	invoker: {
 		timing: "ongoing",
 		start(e, i) {
-			let s = e.deps.selection, p = e.deps.scene, h = e.deps.applyOps;
+			let s = e.deps.selection, p = e.deps.scene, g = e.deps.applyOps;
 			if (!s || !p) return {};
-			let v = s.get();
-			if (v.length === 0) return {};
-			let y = f(p), b = /* @__PURE__ */ new Map(), x = c(p, l(e.deps.poseDescriptor));
-			for (let t of d(p, y, v)) {
+			let y = s.get();
+			if (y.length === 0) return {};
+			let b = f(p), x = /* @__PURE__ */ new Map(), S = c(p, l(e.deps.poseDescriptor));
+			for (let t of d(p, b, y)) {
 				let n = p.get(t);
 				if (n === void 0) continue;
 				let i = a(o(e.deps.view, n.layer));
-				b.set(t, r(x(t), y.world(t), i));
+				x.set(t, r(S(t), b.world(t), i));
 			}
-			if (b.size === 0) return {};
-			let S = {
-				ids: u(p, v),
+			if (x.size === 0) return {};
+			let C = {
+				ids: u(p, y),
 				scene: p,
-				descriptorOf: x,
-				frame: y,
-				originPoses: b,
+				descriptorOf: S,
+				frame: b,
+				originPoses: x,
 				view: e.deps.view,
 				currentDelta: {
 					dx: 0,
 					dy: 0
 				},
 				previews: /* @__PURE__ */ new Map(),
-				applyOps: h
-			}, C = m(e, i, p, S.ids, b, x);
+				applyOps: g
+			}, w = h(e, i, p, C.ids, x, S);
 			return {
 				kind: "clone",
 				previewHidesSource: !1,
 				onMove(e) {
 					if (!e.drag) return;
-					S.currentDelta = C.shape(e, {
+					C.currentDelta = w.shape(e, {
 						dx: e.drag.delta.x,
 						dy: e.drag.delta.y
-					}), S.previews.clear();
-					let { dx: t, dy: n } = S.currentDelta;
-					if (t !== 0 || n !== 0) for (let e of S.originPoses.keys()) S.previews.set(e, g(S, e, t, n));
+					}), C.previews.clear();
+					let { dx: t, dy: n } = C.currentDelta;
+					if (t !== 0 || n !== 0) for (let e of C.originPoses.keys()) C.previews.set(e, _(C, e, t, n));
 				},
 				onEnd(e, r) {
 					let i = !1;
 					try {
-						let { dx: e, dy: n } = S.currentDelta;
-						r === "commit" && (e !== 0 || n !== 0) ? i = _(S, C, s) : t(C.list, C.gctx);
+						let { dx: e, dy: n } = C.currentDelta;
+						r === "commit" && (e !== 0 || n !== 0) ? (i = v(C, w, s), i && m(p, {
+							kind: "duplicate",
+							dx: e,
+							dy: n
+						}, s.get())) : t(w.list, w.gctx);
 					} finally {
-						S.previews.clear(), n(C.list, C.gctx, i);
+						C.previews.clear(), n(w.list, w.gctx, i);
 					}
 				},
-				previewIds: () => S.previews.keys(),
-				previewPose: (e) => S.previews.get(e) ?? null
+				previewIds: () => C.previews.keys(),
+				previewPose: (e) => C.previews.get(e) ?? null
 			};
 		}
 	},
 	enabled: () => !0
 }, s);
 //#endregion
-export { v as cloneAction };
+export { y as cloneAction };
 
 //# sourceMappingURL=action.js.map

package/dist/interactions/actions/clone/action.js.map

@@ -1 +1 @@
-{"version":3,"file":"action.js","names":["landed","origin","scratch","id","node","d","moved","translatePoseViaDescriptor","dx","dy","carryPose","planeOf","commitClone","apply","ops","defaultCommitAdapter","selection","answer","behaviors","copySelection","copies","cloneAction","inPlane","ctx","scene","applyOps","ids","frame","scenePoseFrame","originPoses","descriptorOf","nodeDescriptors","poseDescriptorOf","translateTargets","toEdited","invertPlane","selectedRoots","startCloneBehaviors","opts","moveCtx","committed","reason","runBehaviorCancel","runBehaviorSettled","selectionLayer"],"sources":["../../../../src/interactions/actions/clone/action.ts"],"sourcesContent":["/**\n * `cloneAction` — ongoing Action descriptor for alt-drag clone. Nothing is\n * written before the commit, so a cancel only clears the preview.\n *\n * The action does not gate on a modifier: it runs whenever the dispatcher\n * routes to it, and the binding that names it carries the `alt` requirement.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { runBehaviorCancel, runBehaviorSettled } from '../gestureLifecycle';\nimport { startCloneBehaviors, type CloneBehaviors } from './behaviors';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { copySelection } from '../defaults/copySubtree';\nimport { selectedRoots, translateTargets } from '../selectionSubtree';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from '../resize/geometry';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { carryPose, invertPlane, inPlane, planeOf, selectionLayer } from '../planeInput';\n\ninterface CloneScratch {\n  /** The selected ids a copy starts from; each brings its subtree. */\n  ids: NodeId[];\n  scene: Scene<unknown, string, unknown>;\n  descriptorOf: (id: NodeId) => PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  frame: PoseFrame<unknown>;\n  /** Origin poses captured at drag start, in world — the frame the drag\n   *  delta is expressed in, and the plane the edit is measured in. The copy\n   *  keeps its source's parent and layer, so each translated result is\n   *  carried back to that layer's plane and stored in that same frame.\n   *  Holds every node the copy moves itself: a node stored in a copied frame\n   *  is absent, because the copy of that frame carries it. */\n  originPoses: Map<NodeId, unknown>;\n  /** The view the invocation started with, read for `planeOf`. */\n  view: unknown;\n  /** Running drag delta — updated each onMove, applied once at commit. */\n  currentDelta: { dx: number; dy: number };\n  /** Preview poses keyed by the original's id: the copies have no ids yet. */\n  previews: Map<NodeId, unknown>;\n  /** Optional consumer commit hook captured at gesture start. When present,\n   *  the insert ops route through it instead of `scene.applyBatch`. */\n  applyOps?: (ops: Op[], label: string) => void;\n}\n\n/** Where the copy of `id` lands for a drag of `(dx, dy)`, as stored. */\nfunction landed(scratch: CloneScratch, id: NodeId, dx: number, dy: number): unknown {\n  const origin = scratch.originPoses.get(id);\n  const node = scratch.scene.get(id);\n  if (origin === undefined || !node) return undefined;\n  const d = scratch.descriptorOf(id);\n  const moved = translatePoseViaDescriptor(origin, dx, dy, d);\n  return scratch.frame.local(id, carryPose(d, moved, planeOf(scratch.view, node.layer)));\n}\n\n/** Commit the drag: a behavior's ops when one claims it, else the copies,\n *  which become the selection. Returns whether anything was committed. */\nfunction commitClone(scratch: CloneScratch, behaviors: CloneBehaviors, selection: SelectionApi): boolean {\n  const { dx, dy } = scratch.currentDelta;\n  const apply = (ops: Op[]): void => {\n    if (scratch.applyOps) scratch.applyOps(ops, 'Clone');\n    else scratch.scene.applyBatch(ops, 'Clone', defaultCommitAdapter(scratch.scene, selection.adapterMethods));\n  };\n  const answer = behaviors.end(scratch.currentDelta);\n  if (answer === null) return false;\n  if (answer !== undefined) {\n    if (answer.length > 0) apply(answer);\n    return true;\n  }\n  const { ops, copies } = copySelection(\n    scratch.scene,\n    scratch.ids,\n    (id, node) => (scratch.originPoses.has(id) ? landed(scratch, id, dx, dy) : node.pose),\n    'Clone',\n  );\n  if (ops.length === 0) return false;\n  apply(ops);\n  selection.set(copies);\n  return true;\n}\n\n/**\n * @experimental\n * Static descriptor for the `clone` Action. Copies each selected node, with\n * its subtree, to where the drag left it. One undo entry.\n */\nexport const cloneAction: Action & { requires: string[] } = inPlane({\n  id: 'clone',\n  label: 'Clone',\n  // No default binding: a bare `{ kind: 'drag' }` would clone a non-empty\n  // selection on any drag no tool claimed. Alt-drag on a body binds it\n  // (`selectionMoveBindings`, the `move` preset).\n  // The platform's duplicate cursor. The select tool binds clone behind\n  // `mods: { alt: true }`, so the pump shows this only while Alt is down.\n  cursor: 'copy',\n  activeCursor: 'copy',\n  eligible: { capability: ['edits-page', 'creates-selection'] },\n  requires: ['selection', 'scene', 'applyOps', 'poseDescriptor'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const selection = ctx.deps.selection;\n      const scene = ctx.deps.scene;\n      const applyOps = ctx.deps.applyOps;\n\n      if (!selection || !scene) return {};\n\n      const ids = selection.get() as NodeId[];\n      if (ids.length === 0) return {};\n\n      // Capture origin poses once at drag start.\n      const frame = scenePoseFrame(scene);\n      const originPoses = new Map<NodeId, unknown>();\n      const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(ctx.deps.poseDescriptor));\n      for (const id of translateTargets(scene, frame, ids)) {\n        const node = scene.get(id);\n        if (node === undefined) continue;\n        const toEdited = invertPlane(planeOf(ctx.deps.view, node.layer));\n        originPoses.set(id, carryPose(descriptorOf(id), frame.world(id), toEdited));\n      }\n\n      if (originPoses.size === 0) return {};\n\n      const scratch: CloneScratch = {\n        ids: selectedRoots(scene, ids),\n        scene,\n        descriptorOf,\n        frame,\n        originPoses,\n        view: ctx.deps.view,\n        currentDelta: { dx: 0, dy: 0 },\n        previews: new Map<NodeId, unknown>(),\n        applyOps,\n      };\n      const behaviors = startCloneBehaviors(ctx, opts, scene, scratch.ids, originPoses, descriptorOf);\n\n      return {\n        kind: 'clone',\n        // The source stays visible at its committed pose; the ghost appears\n        // at the drag target.\n        previewHidesSource: false,\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          scratch.currentDelta = behaviors.shape(moveCtx, { dx: moveCtx.drag.delta.x, dy: moveCtx.drag.delta.y });\n          scratch.previews.clear();\n          const { dx, dy } = scratch.currentDelta;\n          if (dx === 0 && dy === 0) return;\n          for (const id of scratch.originPoses.keys()) scratch.previews.set(id, landed(scratch, id, dx, dy)!);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            const { dx, dy } = scratch.currentDelta;\n            // A zero-delta drag makes no clone, so its behaviors are canceled.\n            if (reason === 'commit' && (dx !== 0 || dy !== 0)) committed = commitClone(scratch, behaviors, selection);\n            else runBehaviorCancel(behaviors.list, behaviors.gctx);\n          } finally {\n            scratch.previews.clear();\n            runBehaviorSettled(behaviors.list, behaviors.gctx, committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":"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"}
+{"version":3,"file":"action.js","names":["landed","origin","scratch","id","node","d","moved","translatePoseViaDescriptor","dx","dy","carryPose","planeOf","commitClone","apply","ops","defaultCommitAdapter","selection","answer","behaviors","copySelection","copies","cloneAction","inPlane","ctx","scene","applyOps","ids","frame","scenePoseFrame","originPoses","descriptorOf","nodeDescriptors","poseDescriptorOf","translateTargets","toEdited","invertPlane","selectedRoots","startCloneBehaviors","opts","moveCtx","committed","reason","recordTransform","runBehaviorCancel","runBehaviorSettled","selectionLayer"],"sources":["../../../../src/interactions/actions/clone/action.ts"],"sourcesContent":["/**\n * `cloneAction` — ongoing Action descriptor for alt-drag clone. Nothing is\n * written before the commit, so a cancel only clears the preview.\n *\n * The action does not gate on a modifier: it runs whenever the dispatcher\n * routes to it, and the binding that names it carries the `alt` requirement.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { BindingOpts, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { runBehaviorCancel, runBehaviorSettled } from '../gestureLifecycle';\nimport { startCloneBehaviors, type CloneBehaviors } from './behaviors';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { copySelection } from '../defaults/copySubtree';\nimport { selectedRoots, translateTargets } from '../selectionSubtree';\nimport { nodeDescriptors, poseDescriptorOf } from '../poseDescriptorDep';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from '../resize/geometry';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { carryPose, invertPlane, inPlane, planeOf, selectionLayer } from '../planeInput';\nimport { recordTransform } from '../transform-again/memory';\n\ninterface CloneScratch {\n  /** The selected ids a copy starts from; each brings its subtree. */\n  ids: NodeId[];\n  scene: Scene<unknown, string, unknown>;\n  descriptorOf: (id: NodeId) => PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  frame: PoseFrame<unknown>;\n  /** Origin poses captured at drag start, in world — the frame the drag\n   *  delta is expressed in, and the plane the edit is measured in. The copy\n   *  keeps its source's parent and layer, so each translated result is\n   *  carried back to that layer's plane and stored in that same frame.\n   *  Holds every node the copy moves itself: a node stored in a copied frame\n   *  is absent, because the copy of that frame carries it. */\n  originPoses: Map<NodeId, unknown>;\n  /** The view the invocation started with, read for `planeOf`. */\n  view: unknown;\n  /** Running drag delta — updated each onMove, applied once at commit. */\n  currentDelta: { dx: number; dy: number };\n  /** Preview poses keyed by the original's id: the copies have no ids yet. */\n  previews: Map<NodeId, unknown>;\n  /** Optional consumer commit hook captured at gesture start. When present,\n   *  the insert ops route through it instead of `scene.applyBatch`. */\n  applyOps?: (ops: Op[], label: string) => void;\n}\n\n/** Where the copy of `id` lands for a drag of `(dx, dy)`, as stored. */\nfunction landed(scratch: CloneScratch, id: NodeId, dx: number, dy: number): unknown {\n  const origin = scratch.originPoses.get(id);\n  const node = scratch.scene.get(id);\n  if (origin === undefined || !node) return undefined;\n  const d = scratch.descriptorOf(id);\n  const moved = translatePoseViaDescriptor(origin, dx, dy, d);\n  return scratch.frame.local(id, carryPose(d, moved, planeOf(scratch.view, node.layer)));\n}\n\n/** Commit the drag: a behavior's ops when one claims it, else the copies,\n *  which become the selection. Returns whether anything was committed. */\nfunction commitClone(scratch: CloneScratch, behaviors: CloneBehaviors, selection: SelectionApi): boolean {\n  const { dx, dy } = scratch.currentDelta;\n  const apply = (ops: Op[]): void => {\n    if (scratch.applyOps) scratch.applyOps(ops, 'Clone');\n    else scratch.scene.applyBatch(ops, 'Clone', defaultCommitAdapter(scratch.scene, selection.adapterMethods));\n  };\n  const answer = behaviors.end(scratch.currentDelta);\n  if (answer === null) return false;\n  if (answer !== undefined) {\n    if (answer.length > 0) apply(answer);\n    return true;\n  }\n  const { ops, copies } = copySelection(\n    scratch.scene,\n    scratch.ids,\n    (id, node) => (scratch.originPoses.has(id) ? landed(scratch, id, dx, dy) : node.pose),\n    'Clone',\n  );\n  if (ops.length === 0) return false;\n  apply(ops);\n  selection.set(copies);\n  return true;\n}\n\n/**\n * @experimental\n * Static descriptor for the `clone` Action. Copies each selected node, with\n * its subtree, to where the drag left it. One undo entry.\n */\nexport const cloneAction: Action & { requires: string[] } = inPlane({\n  id: 'clone',\n  label: 'Clone',\n  // No default binding: a bare `{ kind: 'drag' }` would clone a non-empty\n  // selection on any drag no tool claimed. Alt-drag on a body binds it\n  // (`selectionMoveBindings`, the `move` preset).\n  // The platform's duplicate cursor. The select tool binds clone behind\n  // `mods: { alt: true }`, so the pump shows this only while Alt is down.\n  cursor: 'copy',\n  activeCursor: 'copy',\n  eligible: { capability: ['edits-page', 'creates-selection'] },\n  requires: ['selection', 'scene', 'applyOps', 'poseDescriptor'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const selection = ctx.deps.selection;\n      const scene = ctx.deps.scene;\n      const applyOps = ctx.deps.applyOps;\n\n      if (!selection || !scene) return {};\n\n      const ids = selection.get() as NodeId[];\n      if (ids.length === 0) return {};\n\n      // Capture origin poses once at drag start.\n      const frame = scenePoseFrame(scene);\n      const originPoses = new Map<NodeId, unknown>();\n      const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(ctx.deps.poseDescriptor));\n      for (const id of translateTargets(scene, frame, ids)) {\n        const node = scene.get(id);\n        if (node === undefined) continue;\n        const toEdited = invertPlane(planeOf(ctx.deps.view, node.layer));\n        originPoses.set(id, carryPose(descriptorOf(id), frame.world(id), toEdited));\n      }\n\n      if (originPoses.size === 0) return {};\n\n      const scratch: CloneScratch = {\n        ids: selectedRoots(scene, ids),\n        scene,\n        descriptorOf,\n        frame,\n        originPoses,\n        view: ctx.deps.view,\n        currentDelta: { dx: 0, dy: 0 },\n        previews: new Map<NodeId, unknown>(),\n        applyOps,\n      };\n      const behaviors = startCloneBehaviors(ctx, opts, scene, scratch.ids, originPoses, descriptorOf);\n\n      return {\n        kind: 'clone',\n        // The source stays visible at its committed pose; the ghost appears\n        // at the drag target.\n        previewHidesSource: false,\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          scratch.currentDelta = behaviors.shape(moveCtx, { dx: moveCtx.drag.delta.x, dy: moveCtx.drag.delta.y });\n          scratch.previews.clear();\n          const { dx, dy } = scratch.currentDelta;\n          if (dx === 0 && dy === 0) return;\n          for (const id of scratch.originPoses.keys()) scratch.previews.set(id, landed(scratch, id, dx, dy)!);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            const { dx, dy } = scratch.currentDelta;\n            // A zero-delta drag makes no clone, so its behaviors are canceled.\n            if (reason === 'commit' && (dx !== 0 || dy !== 0)) {\n              committed = commitClone(scratch, behaviors, selection);\n              if (committed) recordTransform(scene, { kind: 'duplicate', dx, dy }, selection.get());\n            } else runBehaviorCancel(behaviors.list, behaviors.gctx);\n          } finally {\n            scratch.previews.clear();\n            runBehaviorSettled(behaviors.list, behaviors.gctx, committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":"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"}