@weasel-js/core 1.7.0 → 1.7.2

package/dist/canvas/deps/hitTestArea.js

@@ -0,0 +1,51 @@
+import { rectToPlane as e, toPlane as t } from "../../core/viewport/parallax.js";
+import { poseDescriptorForNode as n, visualBoundsViaDescriptor as r } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as i } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { findShapeSilhouette as a } from "../NodeShape.js";
+import { pickWalk as o, scenePickSource as s } from "../pickWalk.js";
+import { polygonRegion as c, poseOutline as l, rectRegion as u, regionBoundsOf as d, regionOf as f, regionTakes as p } from "../../core/geometry/regionHit.js";
+import { pathIntersectsRect as m } from "@weasel-js/geom";
+//#region src/canvas/deps/hitTestArea.ts
+function h(e, t, n) {
+	let r = e?.get?.();
+	return {
+		...n ? { poseComposition: n } : {},
+		...t ? { alphaOf: t } : {},
+		...e?.layerIsPainted ? { layerIsPainted: (t) => e.layerIsPainted(t) } : {},
+		...r ? { camera: r } : {}
+	};
+}
+function g(e, t, n, r = i, a = {}) {
+	return v(e, u(t), "intersect", n, r, a);
+}
+function _(e, t, n, r, a = i, o = {}) {
+	let s = c(t);
+	return s ? v(e, s, n, r, a, o) : [];
+}
+function v(e, t, i, c, u, f) {
+	let h = (e) => ({
+		includeContainers: f.includeContainers === !0,
+		clipAdmits: (t, i, a) => {
+			let o = n(u, i);
+			return m(t, r(a, o)) && m(t, e.bounds);
+		},
+		hits: (t, r) => {
+			let o = n(u, t), s = d(t, r, o);
+			return p(e, i, r, s, () => a(t, r) ?? l(r, s));
+		},
+		inPlane: (t) => h(y(e, t))
+	});
+	return o(s(e, c), h(t));
+}
+function y(n, r) {
+	let i = [];
+	for (let e of n.verts) {
+		let n = t(r, e);
+		i.push(n.x, n.y);
+	}
+	return f(i, e(r, n.bounds), n.isRect);
+}
+//#endregion
+export { g as hitTestArea, _ as hitTestLassoPolygon, h as regionPickOptions };
+
+//# sourceMappingURL=hitTestArea.js.map

package/dist/canvas/deps/hitTestArea.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitTestArea.js","names":["regionPickOptions","camera","view","poseComposition","alphaOf","layer","hitTestArea","AUTO_POSE_DESCRIPTOR","walkArea","scene","rectRegion","bounds","opts","descriptor","query","hitTestLassoPolygon","region","polygonRegion","polygon","mode","regionQuery","g","poseDescriptorForNode","node","pathIntersectsRect","clip","visualBoundsViaDescriptor","pose","r","b","regionBoundsOf","regionTakes","findShapeSilhouette","poseOutline","regionInPlane","m","pickWalk","scenePickSource","coords","v","p","toPlane","regionOf","rectToPlane"],"sources":["../../../src/canvas/deps/hitTestArea.ts"],"sourcesContent":["/**\n * Shared, silhouette-aware area hit-test used by both `areaSelect` (marquee)\n * and `lassoSelect` dep sources, and by `sceneToAdapter`.\n *\n * The per-node decision is `regionTakes` (`core/geometry/regionHit`), which\n * `arrayAdapter` shares. This module supplies the scene walk — layers, clips,\n * pose composition, containers — and the node's drawn outline: the painter's\n * world-frame silhouette (`findShapeSilhouette`), which is what reaches the\n * kit's own inserted shapes, whose geometry sits on `node.data` behind a bare\n * `{x,y,w,h}` pose. With no painter the outline is the pose rect, rotated if\n * the pose is.\n */\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { pathIntersectsRect } from '@weasel-js/geom';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport {\n  poseDescriptorForNode,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport {\n  pickWalk,\n  scenePickSource,\n  type PickQuery,\n  type ScenePickSourceOptions,\n} from 'canvas/pickWalk';\nimport { rectToPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\n\nexport { hiddenLayerIds } from 'canvas/pickWalk';\nimport type { HitTestView } from 'interactions/actions/depSchema';\nimport type { PoseComposition } from 'features/groups/composePose';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\nimport {\n  polygonRegion,\n  poseOutline,\n  rectRegion,\n  regionBoundsOf,\n  regionOf,\n  regionTakes,\n  type SelectRegion,\n} from 'core/geometry/regionHit';\n\nexport interface AABBBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** What a region query takes back beyond leaves. */\nexport interface RegionQueryOptions {\n  /** Default `false`: a region that takes a container and its children\n   *  selects the same ink twice. A bare-adapter consumer, which has nothing\n   *  to fold children back into their container, asks for them. */\n  includeContainers?: boolean;\n}\n\n\n/** The pick options a region dep hands the shared walk: the asking view's\n *  layer gate and camera, the surface's alpha, and the scene's pose\n *  composition. */\nexport function regionPickOptions(\n  view: HitTestView | undefined,\n  alphaOf: ((id: string) => number) | undefined,\n  poseComposition: PoseComposition<unknown> | undefined,\n): ScenePickSourceOptions<unknown> {\n  const camera = view?.get?.();\n  return {\n    ...(poseComposition ? { poseComposition } : {}),\n    ...(alphaOf ? { alphaOf } : {}),\n    ...(view?.layerIsPainted ? { layerIsPainted: (layer: string) => view.layerIsPainted!(layer) } : {}),\n    ...(camera ? { camera } : {}),\n  };\n}\n\n/** Marquee entry point: every node the rect `bounds` meets. */\nexport function hitTestArea(\n  scene: Scene<unknown, string, unknown>,\n  bounds: AABBBounds,\n  opts?: ScenePickSourceOptions<unknown>,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  return walkArea(scene, rectRegion(bounds), 'intersect', opts, descriptor, query);\n}\n\n/**\n * Every node an arbitrary closed area polygon meets. `area` is interleaved\n * `[x0,y0,x1,y1,…]`; `areaBounds` is its AABB, derived when omitted.\n */\nexport function hitTestAreaPolygon(\n  scene: Scene<unknown, string, unknown>,\n  area: ArrayLike<number>,\n  areaBounds?: AABBBounds,\n  /** True when `area` IS its own bounding rect, so `areaBounds` containment\n   *  implies containment in the area proper. Never pass this for a lasso\n   *  polygon — a node inside the hull's box can miss the hull. */\n  areaIsRect = false,\n  /** The asking view's alpha and layer accessors. A bare scene answers for\n   *  itself; a view that dims or reorders layers has to supply its own. */\n  opts?: ScenePickSourceOptions<unknown>,\n  /** How to read this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  const region = regionOf(area, areaBounds, areaIsRect);\n  return region ? walkArea(scene, region, 'intersect', opts, descriptor, query) : [];\n}\n\n/**\n * Lasso entry point: which nodes a closed lasso polygon picks under `mode`\n * (see `regionTakes`).\n */\nexport function hitTestLassoPolygon(\n  scene: Scene<unknown, string, unknown>,\n  polygon: ReadonlyArray<{ x: number; y: number }>,\n  mode: LassoHitMode,\n  opts?: ScenePickSourceOptions<unknown>,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n  query: RegionQueryOptions = {},\n): NodeId[] {\n  const region = polygonRegion(polygon);\n  return region ? walkArea(scene, region, mode, opts, descriptor, query) : [];\n}\n\n/** The walk every region query shares: skip containers unless asked, gate on\n *  the clip, and let `regionTakes` decide each node. */\nfunction walkArea(\n  scene: Scene<unknown, string, unknown>,\n  region: SelectRegion,\n  mode: LassoHitMode,\n  opts: ScenePickSourceOptions<unknown> | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  query: RegionQueryOptions,\n): NodeId[] {\n  const regionQuery = (r: SelectRegion): PickQuery<unknown> => ({\n    includeContainers: query.includeContainers === true,\n    clipAdmits: (clip, node, pose) => {\n      const g = poseDescriptorForNode(descriptor, node);\n      return pathIntersectsRect(clip, visualBoundsViaDescriptor(pose, g))\n        && pathIntersectsRect(clip, r.bounds);\n    },\n    hits: (node, pose) => {\n      // The descriptor sees the node here, so a pose shape whose extent\n      // depends on `node.data` bounds itself rather than its pose's default.\n      const g = poseDescriptorForNode(descriptor, node);\n      const b = regionBoundsOf(node as object, pose, g);\n      return regionTakes(r, mode, pose, b, () =>\n        findShapeSilhouette(node as never, pose) ?? poseOutline(pose, b));\n    },\n    inPlane: (m) => regionQuery(regionInPlane(r, m)),\n  });\n  return pickWalk<unknown>(scenePickSource(scene, opts), regionQuery(region)) as NodeId[];\n}\n\n/** `r` carried into a plane's world. The map is axis-aligned, so a rect stays\n *  one; a flipped axis reverses the winding, which no region test reads. */\nfunction regionInPlane(r: SelectRegion, m: PlaneMap): SelectRegion {\n  const coords: number[] = [];\n  for (const v of r.verts) {\n    const p = toPlane(m, v);\n    coords.push(p.x, p.y);\n  }\n  return regionOf(coords, rectToPlane(m, r.bounds), r.isRect)!;\n}\n"],"mappings":";;;;;;;;AA8DA,SAAgBA,EACd,GACA,GACA,GACiC;CACjC,IAAMC,IAASC,GAAM,MAAM;CAC3B,OAAO;EACL,GAAIC,IAAkB,EAAE,mBAAgB,IAAI,CAAC;EAC7C,GAAIC,IAAU,EAAE,WAAQ,IAAI,CAAC;EAC7B,GAAIF,GAAM,iBAAiB,EAAE,iBAAiB,MAAkBA,EAAK,eAAgBG,CAAK,EAAE,IAAI,CAAC;EACjG,GAAIJ,IAAS,EAAE,UAAO,IAAI,CAAC;CAC7B;AACF;AAGA,SAAgBK,EACd,GACA,GACA,GACA,IAAsCC,GACtC,IAA4B,CAAC,GACnB;CACV,OAAOC,EAASC,GAAOC,EAAWC,CAAM,GAAG,aAAaC,GAAMC,GAAYC,CAAK;AACjF;AA6BA,SAAgBC,EACd,GACA,GACA,GACA,GACA,IAAsCR,GACtC,IAA4B,CAAC,GACnB;CACV,IAAMS,IAASC,EAAcC,CAAO;CACpC,OAAOF,IAASR,EAASC,GAAOO,GAAQG,GAAMP,GAAMC,GAAYC,CAAK,IAAI,CAAC;AAC5E;AAIA,SAASN,EACP,GACA,GACA,GACA,GACA,GACA,GACU;CACV,IAAMY,KAAe,OAAyC;EAC5D,mBAAmBN,EAAM,sBAAsB;EAC/C,aAAa,GAAM,GAAM,MAAS;GAChC,IAAMO,IAAIC,EAAsBT,GAAYU,CAAI;GAChD,OAAOC,EAAmBC,GAAMC,EAA0BC,GAAMN,CAAC,CAAC,KAC7DG,EAAmBC,GAAMG,EAAE,MAAM;EACxC;EACA,OAAO,GAAM,MAAS;GAGpB,IAAMP,IAAIC,EAAsBT,GAAYU,CAAI,GAC1CM,IAAIC,EAAeP,GAAgBI,GAAMN,CAAC;GAChD,OAAOU,EAAYH,GAAGT,GAAMQ,GAAME,SAChCG,EAAoBT,GAAeI,CAAI,KAAKM,EAAYN,GAAME,CAAC,CAAC;EACpE;EACA,UAAU,MAAMT,EAAYc,EAAcN,GAAGO,CAAC,CAAC;CACjD;CACA,OAAOC,EAAkBC,EAAgB5B,GAAOG,CAAI,GAAGQ,EAAYJ,CAAM,CAAC;AAC5E;AAIA,SAASkB,EAAc,GAAiB,GAA2B;CACjE,IAAMI,IAAmB,CAAC;CAC1B,KAAK,IAAMC,KAAKX,EAAE,OAAO;EACvB,IAAMY,IAAIC,EAAQN,GAAGI,CAAC;EACtB,EAAO,KAAKC,EAAE,GAAGA,EAAE,CAAC;CACtB;CACA,OAAOE,EAASJ,GAAQK,EAAYR,GAAGP,EAAE,MAAM,GAAGA,EAAE,MAAM;AAC5D"}

package/dist/canvas/deps/ingestion.js

@@ -0,0 +1,31 @@
+import { viewportWorldRect as e } from "../../core/viewport/viewportWorldRect.js";
+import { useLatest as t } from "@weasel-js/react";
+import { useDepSource as n } from "@weasel-js/routing/react";
+//#region src/canvas/deps/ingestion.ts
+function r(r, i, a, o, s) {
+	let c = t(i), l = t(a), u = t(o), d = t(s);
+	n("ingestion", () => ({
+		viewportWorldRect() {
+			let t = r.current;
+			return t ? e(c.current(), t.getBoundingClientRect()) : {
+				x: 0,
+				y: 0,
+				width: 0,
+				height: 0
+			};
+		},
+		get resolveSrc() {
+			return l.current;
+		},
+		get svg() {
+			return u.current;
+		},
+		get clipboard() {
+			return d.current;
+		}
+	}));
+}
+//#endregion
+export { r as useIngestionDepSource };
+
+//# sourceMappingURL=ingestion.js.map

package/dist/canvas/deps/ingestion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestion.js","names":["useIngestionDepSource","getViewRef","useLatest","getView","resolveSrcRef","resolveSrc","svgRef","svg","clipboardRef","clipboard","canvas","canvasRef","viewportWorldRect"],"sources":["../../../src/canvas/deps/ingestion.ts"],"sourcesContent":["/**\n * `useIngestionDepSource` — wires the `ingestion` dep consumed by\n * `ingestAction`, for the canvas's own view. Computes the visible world rect\n * from the canvas's client rect + current view, and forwards the consumer's\n * optional `resolveSrc`. A `<CanvasView>` overlays this dep with its own rect.\n */\nimport type { RefObject } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { ClipboardIngestCtx, IngestionDep, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport { viewportWorldRect } from 'core/viewport/viewportWorldRect';\nimport type { View } from 'core/viewport/view';\n\nexport function useIngestionDepSource(\n  canvasRef: RefObject<HTMLElement | null>,\n  getView: () => View,\n  resolveSrc?: (file: File) => Promise<string>,\n  svg?: SvgIngestOptions,\n  clipboard?: ClipboardIngestCtx,\n): void {\n  const getViewRef = useLatest(getView);\n  const resolveSrcRef = useLatest(resolveSrc);\n  const svgRef = useLatest(svg);\n  const clipboardRef = useLatest(clipboard);\n\n  useDepSource('ingestion', (): IngestionDep => ({\n    viewportWorldRect() {\n      const canvas = canvasRef.current;\n      if (!canvas) return { x: 0, y: 0, width: 0, height: 0 };\n      return viewportWorldRect(getViewRef.current(), canvas.getBoundingClientRect());\n    },\n    get resolveSrc() {\n      return resolveSrcRef.current;\n    },\n    get svg() {\n      return svgRef.current;\n    },\n    get clipboard() {\n      return clipboardRef.current;\n    },\n  }));\n}\n"],"mappings":";;;;AAaA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAaC,EAAUC,CAAO,GAC9BC,IAAgBF,EAAUG,CAAU,GACpCC,IAASJ,EAAUK,CAAG,GACtBC,IAAeN,EAAUO,CAAS;CAExC,EAAa,oBAAkC;EAC7C,oBAAoB;GAClB,IAAMC,IAASC,EAAU;GAEzB,OADKD,IACEE,EAAkBX,EAAW,QAAQ,GAAGS,EAAO,sBAAsB,CAAC,IADzD;IAAE,GAAG;IAAG,GAAG;IAAG,OAAO;IAAG,QAAQ;GAAE;EAExD;EACA,IAAI,aAAa;GACf,OAAON,EAAc;EACvB;EACA,IAAI,MAAM;GACR,OAAOE,EAAO;EAChB;EACA,IAAI,YAAY;GACd,OAAOE,EAAa;EACtB;CACF,EAAE;AACJ"}

package/dist/canvas/deps/insert.js

@@ -0,0 +1,116 @@
+import { asNodeId as e } from "../../core/scene/types.js";
+import { createInsertOp as t } from "../../core/ops/create.js";
+import { cycleFill as n, solid as r, strokeOf as i } from "../../util/paint.js";
+import { insertPreviewExtent as a } from "../insertPreviewExtent.js";
+import { ellipsePath as o, linePath as s, polygonFromPoints as c, rectPath as l, regularPolygonPath as u, schneiderFit as d, starPath as f } from "@weasel-js/geom";
+import { useRef as p } from "react";
+import { useLatest as m } from "@weasel-js/react";
+import { useDepSource as h } from "@weasel-js/routing/react";
+//#region src/canvas/deps/insert.ts
+function g(g, _, v) {
+	let y = m(g), b = m(_), x = m(v), S = p(0);
+	h("insert", () => {
+		let p = y.current, m = b.current, h = p.layers[0]?.id ?? "default";
+		return {
+			layer: () => h,
+			commit(g, _) {
+				let v = _.kind, y = ++S.current, b = e(`kit-${v}-${y}`);
+				for (; p.get(b) !== void 0;) y = ++S.current, b = e(`kit-${v}-${y}`);
+				let C = n(y), w = r(C), T = a({
+					shape: v,
+					bounds: g,
+					extras: _
+				}), E = T.bounds, D = x.current?.[v];
+				if (D) {
+					let e = D(g, _);
+					return e === null ? null : (m.applyOps([t({
+						node: {
+							id: b,
+							kind: "leaf",
+							layer: h,
+							pose: e.pose ?? E,
+							data: e.data
+						},
+						label: `Insert ${v}`
+					})], `Insert ${v}`), b);
+				}
+				let O = T.geometry, k;
+				switch (O.kind) {
+					case "line":
+						k = {
+							path: s(O.a, O.b),
+							fill: w,
+							stroke: i(C, 2)
+						};
+						break;
+					case "polygon":
+						k = {
+							path: u(O.center, O.radius, O.sides, O.rotation),
+							fill: w
+						};
+						break;
+					case "star":
+						k = {
+							path: f(O.center, O.outerRadius, O.points, O.innerRadius, O.rotation),
+							fill: w
+						};
+						break;
+					case "pencil": {
+						let e = O.samples;
+						k = e.length >= 4 ? {
+							path: d(e, 2),
+							stroke: i(C, 2)
+						} : e.length >= 2 ? {
+							path: c(e),
+							stroke: i(C, 2)
+						} : {
+							path: l(0, 0, T.bounds.width, T.bounds.height),
+							fill: w
+						};
+						break;
+					}
+					case "box": switch (v) {
+						case "rect":
+							k = {
+								path: l(0, 0, T.bounds.width, T.bounds.height),
+								fill: w
+							};
+							break;
+						case "ellipse":
+							k = {
+								path: o(T.bounds),
+								fill: w
+							};
+							break;
+						case "text":
+							k = { text: _.text ?? "" };
+							break;
+						case "image": {
+							let e = _;
+							k = { image: {
+								src: e.src ?? "",
+								...e.opacity === void 0 ? {} : { opacity: e.opacity }
+							} };
+							break;
+						}
+						default: return console.warn(`weasel insertDep: no factory for kind="${v}". Skipping insert.`), null;
+					}
+				}
+				return m.applyOps([t({
+					node: {
+						id: b,
+						kind: "leaf",
+						layer: h,
+						pose: E,
+						data: k
+					},
+					label: `Insert ${v}`
+				})], `Insert ${v}`), b;
+			}
+		};
+	});
+}
+//#endregion
+export { g as useInsertDepSource };
+
+//# sourceMappingURL=insert.js.map

package/dist/canvas/deps/insert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.js","names":["e","useInsertDepSource","sceneRef","useLatest","scene","adapterRef","adapter","factoriesRef","factories","insertSeqRef","useRef","sc","ad","layer","kind","extras","seq","id","asNodeId","color","cycleFill","fill","solid","extent","insertPreviewExtent","pose","factory","built","bounds","createInsertOp","geom","data","linePath","strokeOf","regularPolygonPath","starPath","samples","schneiderFit","polygonFromPoints","rectPath","ellipsePath"],"sources":["../../../src/canvas/deps/insert.ts"],"sourcesContent":["/**\n * `useInsertDepSource` — wires the `insert` dep consumed by `insertAction`.\n *\n * Provides kit-side kind→data factories for the 6 builtin shape kinds\n * (`rect`, `ellipse`, `line`, `polygon`, `star`, `pencil`). Acceptable because\n * these kinds are kit-shipped tools; a future phase can expose a\n * `nodeFactories` prop for consumer-defined kinds.\n *\n * `line`, `polygon`, `star` and `pencil` receive the drag AABB from the\n * insertAction invoker, but `extras` may carry richer geometry (endpoints,\n * center+radius+rotation, point trail). `insertPreviewExtent` resolves the\n * two into the node's real extent — the same resolution the live preview\n * and the reported gesture bounds use.\n */\nimport { useRef } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { InsertDep, InsertExtras } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport {\n  rectPath,\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  linePath,\n  polygonFromPoints,\n  schneiderFit,\n} from '@weasel-js/geom';\nimport { insertPreviewExtent } from '../insertPreviewExtent';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * Consumer-supplied node factory for one insert `kind`. Given the drag AABB\n * and the tool's `extras`, returns the node's `data` (in the consumer's own\n * data shape) plus an optional `pose` override — the dep supplies id, layer,\n * and the undoable insert op. Return `null` to reject the insert.\n *\n * A factory registered for a kit kind (`rect`, `line`, …) fully replaces the\n * kit's default `{ path, fill }` factory for that kind; a factory for a novel\n * kind adds support the kit doesn't ship (e.g. `text`). See\n * `SceneCanvas`'s `insertNodeFactories` prop.\n */\nexport type InsertNodeFactory = (\n  bounds: { x: number; y: number; width: number; height: number },\n  extras: InsertExtras,\n) => { data: unknown; pose?: unknown } | null;\n\nexport function useInsertDepSource(\n  scene: Scene<unknown, string, unknown>,\n  adapter: OpsApplier,\n  factories?: Record<string, InsertNodeFactory>,\n): void {\n  const sceneRef = useLatest(scene);\n  const adapterRef = useLatest(adapter);\n  const factoriesRef = useLatest(factories);\n  const insertSeqRef = useRef(0);\n\n  useDepSource('insert', (): InsertDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n\n    const layer = (sc.layers[0]?.id ?? 'default') as string;\n    return {\n      layer: () => layer,\n      commit(bounds, extras): NodeId | null {\n        const kind = extras.kind;\n        // Walk the seq counter forward until we land on an id that doesn't\n        // already exist in the scene. Handles two cases:\n        //   1. Fresh mount after localStorage rehydration — the scene starts\n        //      with `kit-${kind}-1` etc. already populated; bare ++seq would\n        //      collide on the first insert.\n        //   2. Hot-reload re-mounts the hook with a reset counter.\n        let seq = ++insertSeqRef.current;\n        let id = asNodeId(`kit-${kind}-${seq}`);\n        while (sc.get(id) !== undefined) {\n          seq = ++insertSeqRef.current;\n          id = asNodeId(`kit-${kind}-${seq}`);\n        }\n        const color = cycleFill(seq);\n        const fill = solid(color);\n\n        // The nascent node's extent — drag AABB reconciled with whatever\n        // richer geometry `extras` carries.\n        const extent = insertPreviewExtent({ shape: kind, bounds, extras });\n        const pose: unknown = extent.bounds;\n\n        // Consumer factory wins over the kit default for this kind (and is the\n        // only way to insert consumer-defined kinds like `text`). It owns the\n        // node's data + optional pose; the dep still supplies id/layer/op.\n        const factory = factoriesRef.current?.[kind];\n        if (factory) {\n          const built = factory(bounds, extras);\n          if (built === null) return null;\n          ad.applyOps(\n            [createInsertOp({ node: { id, kind: 'leaf', layer, pose: built.pose ?? pose, data: built.data } as unknown as { id: string }, label: `Insert ${kind}` })],\n            `Insert ${kind}`,\n          );\n          return id;\n        }\n\n        const geom = extent.geometry;\n        let data: unknown;\n\n        switch (geom.kind) {\n          case 'line':\n            data = { path: linePath(geom.a, geom.b), fill, stroke: strokeOf(color, 2) };\n            break;\n          case 'polygon':\n            data = {\n              path: regularPolygonPath(geom.center, geom.radius, geom.sides, geom.rotation),\n              fill,\n            };\n            break;\n          case 'star':\n            data = {\n              path: starPath(geom.center, geom.outerRadius, geom.points, geom.innerRadius, geom.rotation),\n              fill,\n            };\n            break;\n          case 'pencil': {\n            const samples = geom.samples as { x: number; y: number }[];\n            if (samples.length >= 4) {\n              data = { path: schneiderFit(samples, 2.0), stroke: strokeOf(color, 2) };\n            } else if (samples.length >= 2) {\n              data = { path: polygonFromPoints(samples), stroke: strokeOf(color, 2) };\n            } else {\n              data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), fill };\n            }\n            break;\n          }\n          case 'box':\n            switch (kind) {\n              case 'rect':\n                // Geometry-in-local-frame: the rect path lives at the origin and\n                // the pose carries position. `pathInPoseFrame` rebases a rect path\n                // onto the pose box regardless of the stored coords, so origin vs.\n                // duplicated-pose-coords render identically — don't double-count\n                // the position. (#13)\n                data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), fill };\n                break;\n              case 'ellipse':\n                data = { path: ellipsePath(extent.bounds), fill };\n                break;\n              case 'text': {\n                // The built-in `useTextTool` drags an empty text box you then type\n                // into (edit is entered via `enterTextEdit`), so `extras` carries\n                // no content and `text` defaults to `''`. The kit:text painter\n                // matches on `data.text != null` and applies style defaults at\n                // render time, so a bare `{ text }` is a complete, editable node.\n                const e = extras as Partial<{ text: string }>;\n                data = { text: e.text ?? '' };\n                break;\n              }\n              case 'image': {\n                // The bitmap is loaded + cached by `imageCache` keyed on `src`;\n                // only the (serializable) `src` lives on the node.\n                const e = extras as Partial<{ src: string; opacity: number }>;\n                data = {\n                  image: {\n                    src: e.src ?? '',\n                    ...(e.opacity !== undefined ? { opacity: e.opacity } : {}),\n                  },\n                };\n                break;\n              }\n              default:\n                console.warn(`weasel insertDep: no factory for kind=\"${kind}\". Skipping insert.`);\n                return null;\n            }\n            break;\n        }\n\n        ad.applyOps(\n          [createInsertOp({ node: { id, kind: 'leaf', layer, pose, data } as unknown as { id: string }, label: `Insert ${kind}` })],\n          `Insert ${kind}`,\n        );\n        return id;\n      },\n    };\n  });\n}\n"],"mappings":"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"}

package/dist/canvas/deps/lassoSelect.js

@@ -0,0 +1,20 @@
+import { hitTestArea as e, hitTestLassoPolygon as t, regionPickOptions as n } from "./hitTestArea.js";
+import { useLatest as r } from "@weasel-js/react";
+import { useDepSource as i } from "@weasel-js/routing/react";
+//#region src/canvas/deps/lassoSelect.ts
+function a(a, o, s, c, l) {
+	let u = r(a), d = r(o), f = r(s), p = r(l);
+	i("lassoSelect", () => {
+		let r = u.current, i = d.current, a = f.current, o = p.current;
+		return {
+			hitTestLasso: (e, i, s) => t(r, e, i, n(s, o, c), a),
+			hitTestArea: (t, i) => e(r, t, n(i, o, c), a),
+			getSelection: () => i.current,
+			setSelection: (e) => i.set(e)
+		};
+	});
+}
+//#endregion
+export { a as useLassoSelectDepSource };
+
+//# sourceMappingURL=lassoSelect.js.map

package/dist/canvas/deps/lassoSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lassoSelect.js","names":["hitTestAreaShared","useLassoSelectDepSource","sceneRef","useLatest","scene","selectionRef","selection","descriptorRef","descriptor","alphaOfRef","alphaOf","sc","s","d","a","hitTestLassoPolygon","polygon","mode","regionPickOptions","view","poseComposition","hitTestArea","bounds","ids"],"sources":["../../../src/canvas/deps/lassoSelect.ts"],"sourcesContent":["/**\n * `useLassoSelectDepSource` — wires the `lassoSelect` dep consumed by\n * `lassoSelectAction`: `hitTestLasso` tests the lasso polygon itself, and\n * `hitTestArea` is the same silhouette-aware rect test `areaSelect` uses.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { LassoSelectDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { hitTestArea as hitTestAreaShared, hitTestLassoPolygon, regionPickOptions } from './hitTestArea';\nimport type { PoseComposition } from 'features/groups/composePose';\n\nexport function useLassoSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<unknown>,\n  poseComposition?: PoseComposition<unknown>,\n  /** The painted alpha the surface's layers apply, which every view shares. */\n  alphaOf?: (id: string) => number,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const descriptorRef = useLatest(descriptor);\n  const alphaOfRef = useLatest(alphaOf);\n\n  useDepSource('lassoSelect', (): LassoSelectDep => {\n    const sc = sceneRef.current;\n    const s = selectionRef.current;\n    const d = descriptorRef.current;\n    const a = alphaOfRef.current;\n    return {\n      hitTestLasso: (polygon, mode, view) =>\n        hitTestLassoPolygon(sc, polygon, mode, regionPickOptions(view, a, poseComposition), d),\n      hitTestArea: (bounds, view) =>\n        hitTestAreaShared(sc, bounds, regionPickOptions(view, a, poseComposition), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids as NodeId[]),\n    };\n  });\n}\n"],"mappings":";;;;AAcA,SAAgBC,EACd,GACA,GACA,GACA,GAEA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAgBJ,EAAUK,CAAU,GACpCC,IAAaN,EAAUO,CAAO;CAEpC,EAAa,qBAAqC;EAChD,IAAMC,IAAKT,EAAS,SACdU,IAAIP,EAAa,SACjBQ,IAAIN,EAAc,SAClBO,IAAIL,EAAW;EACrB,OAAO;GACL,eAAe,GAAS,GAAM,MAC5BM,EAAoBJ,GAAIK,GAASC,GAAMC,EAAkBC,GAAML,GAAGM,CAAe,GAAGP,CAAC;GACvF,cAAc,GAAQ,MACpBb,EAAkBW,GAAIW,GAAQJ,EAAkBC,GAAML,GAAGM,CAAe,GAAGP,CAAC;GAC9E,oBAAoBD,EAAE;GACtB,eAAe,MAAQA,EAAE,IAAIW,CAAe;EAC9C;CACF,CAAC;AACH"}

package/dist/canvas/deps/layout.js

@@ -0,0 +1,34 @@
+import { asNodeId as e } from "../../core/scene/types.js";
+import { useEffect as t } from "react";
+import { useLatest as n } from "@weasel-js/react";
+import { useDepSource as r } from "@weasel-js/routing/react";
+//#region src/canvas/deps/layout.ts
+function i(i, a, o, s) {
+	let c = n({
+		layouts: a,
+		dropTarget: o,
+		reflow: s
+	});
+	r("layout", () => ({
+		getLayout: (t) => {
+			let n = i.layoutOf(e(t));
+			if (n !== null) return n;
+			let r = c.current.layouts;
+			return r ? typeof r == "function" ? r(t) : r[t] ?? null : null;
+		},
+		dropTarget: c.current.dropTarget,
+		get reflow() {
+			return c.current.reflow ?? null;
+		}
+	})), t(() => i.onReflow((e) => {
+		let t = c.current.reflow;
+		if (t) for (let n of e) {
+			let e = n.id;
+			t.settle(e, t.poseOf(e) === void 0 ? { from: n.from } : void 0);
+		}
+	}), [i, c]);
+}
+//#endregion
+export { i as useLayoutDepSource };
+
+//# sourceMappingURL=layout.js.map

package/dist/canvas/deps/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","names":["useLayoutDepSource","ref","useLatest","useDepSource","declared","scene","asNodeId","containerId","l","useEffect","glide","m","moves","id"],"sources":["../../../src/canvas/deps/layout.ts"],"sourcesContent":["/**\n * `useLayoutDepSource` — wires the `layout` dep consumed by `moveAction`'s\n * drag-time reflow pass. A container's layout is the one its scene node\n * declares (`scene.layoutOf`); `<SceneCanvas>`'s `layouts` prop (a static map\n * or a resolver fn) fills in for containers that declare none. Carries the\n * `layoutDropTarget` mode, and hands every reflow the scene records to the\n * reflow transition so it glides as a drag's does. Always registers; returns\n * null per-container when no layout is configured, so the reflow pass is a\n * no-op without churning dep registration on prop changes.\n */\nimport { useEffect } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { LayoutDep } from 'interactions/actions/depSchema';\nimport type { Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { SceneToAdapterOptions } from '../sceneAdapter';\n\n// Reuse the canonical `layouts` option type from the scene adapter under the\n// dep's erased generics (`unknown`/`string`/`unknown`) so the public surface\n// stays a single source of truth.\ntype LayoutsProp = NonNullable<SceneToAdapterOptions<unknown, string, unknown>['layouts']>;\n\nexport function useLayoutDepSource(\n  scene: Scene<unknown, string, unknown>,\n  layouts: LayoutsProp | undefined,\n  dropTarget?: LayoutDropTargetMode,\n  reflow?: ReflowTransition<unknown> | null,\n): void {\n  const ref = useLatest({ layouts, dropTarget, reflow });\n\n  useDepSource('layout', (): LayoutDep => ({\n    getLayout: (containerId) => {\n      const declared = scene.layoutOf(asNodeId(containerId));\n      if (declared !== null) return declared;\n      const l = ref.current.layouts;\n      if (!l) return null;\n      return typeof l === 'function' ? l(containerId) : (l[containerId] ?? null);\n    },\n    dropTarget: ref.current.dropTarget,\n    get reflow() { return ref.current.reflow ?? null; },\n  }));\n\n  useEffect(() => scene.onReflow((moves) => {\n    const glide = ref.current.reflow;\n    if (!glide) return;\n    for (const m of moves) {\n      // One already gliding carries on from where it is shown.\n      const id = m.id as string;\n      glide.settle(id, glide.poseOf(id) === undefined ? { from: m.from } : undefined);\n    }\n  }), [scene, ref]);\n}\n"],"mappings":";;;;;AAwBA,SAAgBA,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAMC,EAAU;EAAE;EAAS;EAAY;CAAO,CAAC;CAcrD,AAZAC,EAAa,iBAA4B;EACvC,YAAY,MAAgB;GAC1B,IAAMC,IAAWC,EAAM,SAASC,EAASC,CAAW,CAAC;GACrD,IAAIH,MAAa,MAAM,OAAOA;GAC9B,IAAMI,IAAIP,EAAI,QAAQ;GAEtB,OADKO,IACE,OAAOA,KAAM,aAAaA,EAAED,CAAW,IAAKC,EAAED,MAAgB,OADtD;EAEjB;EACA,YAAYN,EAAI,QAAQ;EACxB,IAAI,SAAS;GAAE,OAAOA,EAAI,QAAQ,UAAU;EAAM;CACpD,EAAE,GAEFQ,QAAgBJ,EAAM,UAAU,MAAU;EACxC,IAAMK,IAAQT,EAAI,QAAQ;EAC1B,IAAKS,GACL,KAAK,IAAMC,KAAKC,GAAO;GAErB,IAAMC,IAAKF,EAAE;GACb,EAAM,OAAOE,GAAIH,EAAM,OAAOG,CAAE,MAAM,KAAA,IAAY,EAAE,MAAMF,EAAE,KAAK,IAAI,KAAA,CAAS;EAChF;CACF,CAAC,GAAG,CAACN,GAAOJ,CAAG,CAAC;AAClB"}

package/dist/canvas/deps/nodeAtPoint.js

@@ -0,0 +1,19 @@
+import { asNodeId as e } from "../../core/scene/types.js";
+import { useLatest as t } from "@weasel-js/react";
+import { useDepSource as n } from "@weasel-js/routing/react";
+//#region src/canvas/deps/nodeAtPoint.ts
+function r(r) {
+	let i = t(r);
+	n("nodeAtPoint", () => (t, n) => {
+		let r = i.current(t.x, t.y);
+		if (r.length === 0) return null;
+		if (!n) return e(r[r.length - 1]);
+		let a = n instanceof Set ? n : new Set(n);
+		for (let t = r.length - 1; t >= 0; t--) if (!a.has(e(r[t]))) return e(r[t]);
+		return null;
+	});
+}
+//#endregion
+export { r as useNodeAtPointDepSource };
+
+//# sourceMappingURL=nodeAtPoint.js.map

package/dist/canvas/deps/nodeAtPoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeAtPoint.js","names":["useNodeAtPointDepSource","pickRef","useLatest","pickEvery","ids","point","exclude","asNodeId","ex","i"],"sources":["../../../src/canvas/deps/nodeAtPoint.ts"],"sourcesContent":["/**\n * `useNodeAtPointDepSource` — wires the `nodeAtPoint` dep consumed by\n * `moveAction` (reparent-on-drop) and any other action needing a\n * single-best pick. Delegates to `<SceneCanvas>`'s `pickEvery` (the\n * back-to-front pose-walking picker) so consumer-supplied geometry\n * overrides are honored automatically.\n *\n * The exclude set is consulted front-to-back: the dep returns the\n * topmost id that isn't in `exclude`, which lets callers ignore the\n * node(s) they're currently manipulating without separate plumbing.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeAtPointDep } from 'interactions/actions/depSchema';\nimport { asNodeId } from 'core/scene/types';\n\nexport function useNodeAtPointDepSource(\n  pickEvery: (worldX: number, worldY: number) => string[],\n): void {\n  const pickRef = useLatest(pickEvery);\n\n  useDepSource('nodeAtPoint', (): NodeAtPointDep => {\n    return (point, exclude) => {\n      const ids = pickRef.current(point.x, point.y);\n      if (ids.length === 0) return null;\n      if (!exclude) {\n        // `pickEvery` returns back-to-front; topmost is the last entry.\n        return asNodeId(ids[ids.length - 1]);\n      }\n      const ex = exclude instanceof Set ? exclude : new Set(exclude);\n      for (let i = ids.length - 1; i >= 0; i--) {\n        if (!ex.has(asNodeId(ids[i]))) return asNodeId(ids[i]);\n      }\n      return null;\n    };\n  });\n}\n"],"mappings":";;;;AAgBA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAUC,EAAUC,CAAS;CAEnC,EAAa,sBACH,GAAO,MAAY;EACzB,IAAMC,IAAMH,EAAQ,QAAQI,EAAM,GAAGA,EAAM,CAAC;EAC5C,IAAID,EAAI,WAAW,GAAG,OAAO;EAC7B,IAAI,CAACE,GAEH,OAAOC,EAASH,EAAIA,EAAI,SAAS,EAAE;EAErC,IAAMI,IAAKF,aAAmB,MAAMA,IAAU,IAAI,IAAIA,CAAO;EAC7D,KAAK,IAAIG,IAAIL,EAAI,SAAS,GAAGK,KAAK,GAAG,KACnC,IAAI,CAACD,EAAG,IAAID,EAASH,EAAIK,EAAE,CAAC,GAAG,OAAOF,EAASH,EAAIK,EAAE;EAEvD,OAAO;CACT,CACD;AACH"}

package/dist/canvas/deps/poseComposition.js

@@ -0,0 +1,11 @@
+import { useLatest as e } from "@weasel-js/react";
+import { useDepSource as t } from "@weasel-js/routing/react";
+//#region src/canvas/deps/poseComposition.ts
+function n(n) {
+	let r = e(n);
+	t("poseComposition", () => r.current);
+}
+//#endregion
+export { n as usePoseCompositionDepSource };
+
+//# sourceMappingURL=poseComposition.js.map

package/dist/canvas/deps/poseComposition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseComposition.js","names":["usePoseCompositionDepSource","ref","useLatest","composition"],"sources":["../../../src/canvas/deps/poseComposition.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { PoseComposition } from 'features/groups/composePose';\n\n/** Publish the scene's pose-composition strategy to the built-in actions.\n *  Absent is the absolute-pose model: `scenePoseFrame` falls back to identity\n *  and every world/local conversion in an action is a no-op. */\nexport function usePoseCompositionDepSource(\n  composition: PoseComposition<unknown> | undefined,\n): void {\n  const ref = useLatest(composition);\n  useDepSource('poseComposition', () => ref.current);\n}\n"],"mappings":";;;AAOA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAW;CACjC,EAAa,yBAAyBF,EAAI,OAAO;AACnD"}

package/dist/canvas/deps/poseDescriptor.js

@@ -0,0 +1,12 @@
+import { AUTO_POSE_DESCRIPTOR as e } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { useLatest as t } from "@weasel-js/react";
+import { useDepSource as n } from "@weasel-js/routing/react";
+//#region src/canvas/deps/poseDescriptor.ts
+function r(r) {
+	let i = t(r);
+	n("poseDescriptor", () => i.current ?? e);
+}
+//#endregion
+export { r as usePoseDescriptorDepSource };
+
+//# sourceMappingURL=poseDescriptor.js.map

package/dist/canvas/deps/poseDescriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseDescriptor.js","names":["usePoseDescriptorDepSource","ref","useLatest","descriptor","AUTO_POSE_DESCRIPTOR"],"sources":["../../../src/canvas/deps/poseDescriptor.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\n\n/** Publish the pose descriptor every built-in action reads. */\nexport function usePoseDescriptorDepSource(\n  descriptor: PoseDescriptor<unknown> | undefined,\n): void {\n  const ref = useLatest(descriptor);\n  useDepSource('poseDescriptor', () => ref.current ?? AUTO_POSE_DESCRIPTOR);\n}\n"],"mappings":";;;;AAMA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAU;CAChC,EAAa,wBAAwBF,EAAI,WAAWG,CAAoB;AAC1E"}

package/dist/canvas/deps/resizePolicy.js

@@ -0,0 +1,35 @@
+import { DEFAULT_RESIZE_BEHAVIORS as e } from "../../interactions/actions/resize/behaviors/index.js";
+import { useLatest as t } from "@weasel-js/react";
+import { useDepSource as n } from "@weasel-js/routing/react";
+//#region src/canvas/deps/resizePolicy.ts
+var r = (e) => e, i = Object.freeze([]);
+function a(a) {
+	let o = t(a);
+	n("resizePolicy", () => {
+		let t = o.current;
+		return {
+			label: t.label,
+			transient: t.transient,
+			onGestureStart: t.onGestureStart,
+			onGestureEnd: t.onGestureEnd,
+			constraints: t.constraints ?? e,
+			pointSnap: t.pointSnap ?? i,
+			expandIds: t.expandIds ?? r
+		};
+	});
+}
+function o(e) {
+	return {
+		constraints: e.behaviors,
+		pointSnap: e.pointSnapBehaviors,
+		expandIds: e.expandIds,
+		label: e.resizeLabel,
+		transient: e.transient,
+		onGestureStart: e.onGestureStart,
+		onGestureEnd: e.onGestureEnd
+	};
+}
+//#endregion
+export { o as resizePolicyOptions, a as useResizePolicy };
+
+//# sourceMappingURL=resizePolicy.js.map

package/dist/canvas/deps/resizePolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizePolicy.js","names":["IDENTITY_EXPAND","ids","EMPTY","useResizePolicy","optsRef","useLatest","options","o","DEFAULT_RESIZE_BEHAVIORS","resizePolicyOptions"],"sources":["../../../src/canvas/deps/resizePolicy.ts"],"sourcesContent":["/**\n * `useResizePolicy` — wires the `resizePolicy` dep consumed\n * by `resizeAction`.\n *\n *   - `constraints`   — bounds-frame constraints (e.g. `lockAspectWithModifier`).\n *   - `pointSnap`     — world-space anchor-point snap behaviors.\n *   - `expandIds`     — group-expansion at gesture start.\n *   - `label`, `transient`, `onGestureStart`, `onGestureEnd` — the commit's\n *     history label and recording, and the gesture's lifecycle callbacks.\n *\n * Every field is optional; omitted fields fall back to kit defaults\n * (`DEFAULT_RESIZE_BEHAVIORS` — shift = aspect lock; pass `[]` to disable —\n * then `[]`, `ids => ids`).\n *\n * Built once per render and stabilised by `useDepSource` (which reads via a\n * ref internally), so callers can pass fresh closures without triggering\n * re-registration.\n *\n * @see ResizePolicy — the dep schema entry.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { ResizePolicy } from 'interactions/actions/depSchema';\nimport type {\n  PointSnapBehavior,\n  BoundsConstraint,\n} from 'interactions/gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { DEFAULT_RESIZE_BEHAVIORS } from 'interactions/actions/resize/behaviors';\nimport type { GestureLifecycleOptions } from 'interactions/actions/gestureLifecycle';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\n\n/** Options for `useResizePolicy`. Each omitted field falls back to the kit\n *  default. */\nexport interface UseResizePolicyOptions<TPose> extends GestureLifecycleOptions {\n  constraints?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never[];\n  pointSnap?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never[];\n  expandIds?: (ids: string[]) => string[];\n}\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** Publish how resizing should behave — constraints, point snapping, group\n *  expansion — for the resize action to consult. */\nexport function useResizePolicy<TPose>(\n  options: UseResizePolicyOptions<TPose>,\n): void {\n  const optsRef = useLatest(options);\n\n  useDepSource('resizePolicy', (): ResizePolicy<unknown> => {\n    const o = optsRef.current;\n    return {\n      label: o.label,\n      transient: o.transient,\n      onGestureStart: o.onGestureStart,\n      onGestureEnd: o.onGestureEnd,\n      constraints: (o.constraints ?? DEFAULT_RESIZE_BEHAVIORS) as ResizePolicy<unknown>['constraints'],\n      pointSnap: (o.pointSnap ?? (EMPTY as unknown[])) as ResizePolicy<unknown>['pointSnap'],\n      expandIds: o.expandIds ?? IDENTITY_EXPAND,\n    };\n  });\n}\n\n/** `<SceneCanvas selectTool.resize>` as {@link useResizePolicy} options.\n *  `resizable` is read by `<SceneCanvas>` itself. */\nexport function resizePolicyOptions<TPose>(o: UseResizeOptions<TPose>): UseResizePolicyOptions<TPose> {\n  return {\n    constraints: o.behaviors as UseResizePolicyOptions<TPose>['constraints'],\n    pointSnap: o.pointSnapBehaviors as UseResizePolicyOptions<TPose>['pointSnap'],\n    expandIds: o.expandIds,\n    label: o.resizeLabel,\n    transient: o.transient,\n    onGestureStart: o.onGestureStart,\n    onGestureEnd: o.onGestureEnd,\n  };\n}\n"],"mappings":";;;;AAwCA,IAAMA,KAAmB,MAAkBC,GACrCC,IAA4B,OAAO,OAAO,CAAC,CAAC;AAIlD,SAAgBC,EACd,GACM;CACN,IAAMC,IAAUC,EAAUC,CAAO;CAEjC,EAAa,sBAA6C;EACxD,IAAMC,IAAIH,EAAQ;EAClB,OAAO;GACL,OAAOG,EAAE;GACT,WAAWA,EAAE;GACb,gBAAgBA,EAAE;GAClB,cAAcA,EAAE;GAChB,aAAcA,EAAE,eAAeC;GAC/B,WAAYD,EAAE,aAAcL;GAC5B,WAAWK,EAAE,aAAaP;EAC5B;CACF,CAAC;AACH;AAIA,SAAgBS,EAA2B,GAA2D;CACpG,OAAO;EACL,aAAaF,EAAE;EACf,WAAWA,EAAE;EACb,WAAWA,EAAE;EACb,OAAOA,EAAE;EACT,WAAWA,EAAE;EACb,gBAAgBA,EAAE;EAClB,cAAcA,EAAE;CAClB;AACF"}

package/dist/canvas/deps/slice.js

@@ -0,0 +1,99 @@
+import { poseDescriptorForNode as e } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as t } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { scenePoseFrame as n } from "../../interactions/actions/poseFrame.js";
+import { freshNodeId as r } from "../../interactions/actions/defaults/freshNodeId.js";
+import { pathInWorld as i, worldEditToStorage as a } from "../../features/paths/pathInWorld.js";
+import { computeSliceOps as o } from "../../interactions/actions/defaults/sliceOps.js";
+import { useLatest as s } from "@weasel-js/react";
+import { useDepSource as c } from "@weasel-js/routing/react";
+//#region src/canvas/deps/slice.ts
+function l(e) {
+	let t = s(e);
+	c("slice", () => t.current);
+}
+function u(a, l, u, h, g) {
+	let _ = s(a), v = s(l), y = s(u), b = s(h), x = s(g);
+	c("slice", () => ({ commit(a) {
+		let s = _.current, c = n(s, b.current), l = x.current ?? t, u = [], h = /* @__PURE__ */ new Map();
+		for (let t of s.renderOrderNodes()) {
+			let n = p(s, t);
+			if (!n) continue;
+			let r = d(e(l, t), c.world(t.id));
+			r && (h.set(t.id, r), u.push({
+				node: t,
+				index: m(s, t),
+				worldPath: i(n, r.box)
+			}));
+		}
+		let g = v.current, { ops: S, nextSelection: C } = o({
+			leaves: u,
+			cut: a,
+			nextId: r,
+			selection: g.get(),
+			placePiece: (e, t) => {
+				let n = f(h.get(e.node.id), t);
+				return {
+					pose: c.local(e.node.id, n.pose),
+					path: n.path
+				};
+			}
+		});
+		S.length !== 0 && (y.current.applyOps(S, "Slice"), C && g.set(C));
+	} }));
+}
+function d(e, t) {
+	let n = e.getBounds(t);
+	if (!n || ![
+		n.x,
+		n.y,
+		n.width,
+		n.height
+	].every(Number.isFinite)) return null;
+	let r = e.getRotation?.(t) ?? 0;
+	return {
+		world: t,
+		g: e,
+		box: {
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height,
+			rotation: r
+		}
+	};
+}
+function f({ world: e, g: t, box: n }, r) {
+	let i = !!t.withRotation && t.supportsRotation?.(e) !== !1, o = n.rotation ?? 0;
+	if (o !== 0 && !i) {
+		let i = a({
+			...n,
+			rotation: 0
+		}, r);
+		return {
+			pose: t.fromBounds(i.pose, e),
+			path: i.path
+		};
+	}
+	let { pose: s, path: c } = a(n, r), l = {
+		x: s.x,
+		y: s.y,
+		width: s.width,
+		height: s.height
+	}, u = t.remapBounds(e, t.getBounds(e), l);
+	return {
+		pose: o === 0 ? u : t.withRotation(u, o),
+		path: c
+	};
+}
+function p(e, t) {
+	if (t.kind !== "leaf" || t.derivePath || t.derivePose || e.isLocked(t.id)) return null;
+	let n = t.data?.path;
+	return n && (n.kind === "rect" || n.kind === "polygon") ? n : null;
+}
+function m(e, t) {
+	return (t.parent == null ? e.roots : e.childrenOf(t.parent)).indexOf(t.id);
+}
+//#endregion
+export { l as useSliceDep, u as useSliceDepSource };
+
+//# sourceMappingURL=slice.js.map

package/dist/canvas/deps/slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.js","names":["useSliceDep","depRef","useLatest","dep","useSliceDepSource","sceneRef","scene","selectionRef","selection","adapterRef","adapter","compositionRef","poseComposition","descriptorRef","poseDescriptor","sc","frame","scenePoseFrame","descriptor","AUTO_POSE_DESCRIPTOR","leaves","drawnAt","node","path","sliceablePath","drawn","drawnPose","poseDescriptorForNode","siblingIndex","pathInWorld","sel","computeSliceOps","freshNodeId","stored","storePiece","leaf","piece","ops","nextSelection","b","g","world","rotation","keepsRotation","box","baked","worldEditToStorage","dst","pose"],"sources":["../../../src/canvas/deps/slice.ts"],"sourcesContent":["/**\n * The `slice` dep `sliceAction` and `useSliceTool` commit their cuts through.\n *\n * `<SceneCanvas>` publishes `useSliceDepSource` over its own scene. A consumer\n * replaces it with `useSliceDep` (or `useDepSource('slice', …)`) from under\n * the canvas; the newest registration wins, and a canvas child registers\n * after the canvas's own.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SliceDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId, Node } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { Path } from '@weasel-js/geom';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { pathInWorld, worldEditToStorage, type PathInWorldPose } from 'features/paths/pathInWorld';\nimport { scenePoseFrame } from 'interactions/actions/poseFrame';\nimport { freshNodeId } from 'interactions/actions/defaults/freshNodeId';\nimport { computeSliceOps, type SliceLeaf } from 'interactions/actions/defaults/sliceOps';\nimport type { PoseComposition } from 'features/groups/composePose';\n\n/** Publish how a slice (knife cut) is performed, so the `slice` action can\n *  run against the consumer's geometry. */\nexport function useSliceDep(dep: SliceDep): void {\n  const depRef = useLatest(dep);\n\n  useDepSource('slice', (): SliceDep => depRef.current);\n}\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * The kit `slice` dep: cut every leaf the cut crosses and swap it for its\n * pieces in one undoable batch.\n *\n * A leaf is cut when its `data.path` is a `Path` and `poseDescriptor` can read\n * its world pose as a box and a rotation; a leaf on a locked layer, or one\n * whose geometry derives from other nodes, is passed over. Each path is drawn\n * into world space the way the renderer draws it, so a child is cut where it\n * appears, and each piece is mapped back into the source's frame: it keeps the\n * source's rotation in its pose when the descriptor can write one\n * (`withRotation`), and has the rotation baked into its path otherwise. The\n * piece's pose is then stored in its parent's frame through `poseComposition`.\n * The pieces of a selected leaf take its place in the selection.\n */\nexport function useSliceDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  poseComposition?: PoseComposition<unknown>,\n  poseDescriptor?: PoseDescriptor<unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n  const compositionRef = useLatest(poseComposition);\n  const descriptorRef = useLatest(poseDescriptor);\n\n  useDepSource('slice', (): SliceDep => ({\n    commit(cut) {\n      const sc = sceneRef.current;\n      const frame = scenePoseFrame(sc, compositionRef.current);\n      const descriptor = descriptorRef.current ?? AUTO_POSE_DESCRIPTOR;\n      const leaves: SliceLeaf<Node<unknown, string, unknown>>[] = [];\n      const drawnAt = new Map<string, DrawnPose>();\n      for (const node of sc.renderOrderNodes()) {\n        const path = sliceablePath(sc, node);\n        if (!path) continue;\n        const drawn = drawnPose(poseDescriptorForNode(descriptor, node), frame.world(node.id));\n        if (!drawn) continue;\n        drawnAt.set(node.id, drawn);\n        leaves.push({ node, index: siblingIndex(sc, node), worldPath: pathInWorld(path, drawn.box) });\n      }\n\n      const sel = selectionRef.current;\n      const { ops, nextSelection } = computeSliceOps({\n        leaves,\n        cut,\n        nextId: freshNodeId,\n        selection: sel.get(),\n        placePiece: (leaf, piece) => {\n          const stored = storePiece(drawnAt.get(leaf.node.id)!, piece);\n          return { pose: frame.local(leaf.node.id, stored.pose), path: stored.path };\n        },\n      });\n      if (ops.length === 0) return;\n      adapterRef.current.applyOps(ops, 'Slice');\n      if (nextSelection) sel.set(nextSelection as NodeId[]);\n    },\n  }));\n}\n\n/** A leaf's world pose, and the box and rotation its path is drawn through. */\ninterface DrawnPose {\n  world: unknown;\n  g: PoseDescriptor<unknown>;\n  box: PathInWorldPose;\n}\n\nfunction drawnPose(g: PoseDescriptor<unknown>, world: unknown): DrawnPose | null {\n  const b = g.getBounds(world);\n  if (!b || ![b.x, b.y, b.width, b.height].every(Number.isFinite)) return null;\n  const rotation = g.getRotation?.(world) ?? 0;\n  return { world, g, box: { x: b.x, y: b.y, width: b.width, height: b.height, rotation } };\n}\n\n/** A world-space piece as a world pose of the source's kind plus the path it draws. */\nfunction storePiece({ world, g, box }: DrawnPose, piece: Path): { pose: unknown; path: Path } {\n  const keepsRotation = !!g.withRotation && g.supportsRotation?.(world) !== false;\n  const rotation = box.rotation ?? 0;\n  if (rotation !== 0 && !keepsRotation) {\n    const baked = worldEditToStorage({ ...box, rotation: 0 }, piece);\n    return { pose: g.fromBounds(baked.pose, world), path: baked.path };\n  }\n  const { pose: b, path } = worldEditToStorage(box, piece);\n  const dst = { x: b.x, y: b.y, width: b.width, height: b.height };\n  const pose = g.remapBounds(world, g.getBounds(world), dst);\n  return { pose: rotation !== 0 ? g.withRotation!(pose, rotation) : pose, path };\n}\n\nfunction sliceablePath(scene: Scene<unknown, string, unknown>, node: Node<unknown, string, unknown>): Path | null {\n  if (node.kind !== 'leaf' || node.derivePath || node.derivePose) return null;\n  if (scene.isLocked(node.id)) return null;\n  const path = (node.data as { path?: unknown } | null)?.path as Path | undefined;\n  return path && (path.kind === 'rect' || path.kind === 'polygon') ? path : null;\n}\n\nfunction siblingIndex(scene: Scene<unknown, string, unknown>, node: Node<unknown, string, unknown>): number {\n  const siblings = node.parent == null ? scene.roots : scene.childrenOf(node.parent);\n  return siblings.indexOf(node.id);\n}\n"],"mappings":"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"}

package/dist/canvas/deps/snap.js

@@ -0,0 +1,11 @@
+import { useLatest as e } from "@weasel-js/react";
+import { useDepSource as t } from "@weasel-js/routing/react";
+//#region src/canvas/deps/snap.ts
+function n(n) {
+	let r = e(n);
+	t("snap", () => ({ point: (e) => r.current?.(e) ?? e }));
+}
+//#endregion
+export { n as useSnapDepSource };
+
+//# sourceMappingURL=snap.js.map

package/dist/canvas/deps/snap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap.js","names":["useSnapDepSource","snapRef","useLatest","snapPoint","p"],"sources":["../../../src/canvas/deps/snap.ts"],"sourcesContent":["/**\n * `useSnapDepSource` — wires the `snap` dep consumed by `insertAction`.\n *\n * Sourced from `<SceneCanvas toolOptions={{ snapPoint }} />`. The dep is a\n * live thunk over a ref, so toggling snap on/off (WeaselDraw's snap-to-grid\n * switch) takes effect on the next gesture without remounting the registry.\n *\n * Always registered (hooks can't be conditional); when no `snapPoint` is\n * supplied the dep's `point` is the identity function, which is the same\n * behavior actions fall back to when the dep is absent entirely.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SnapDep } from 'interactions/actions/depSchema';\n\nexport function useSnapDepSource(\n  snapPoint: ((p: { x: number; y: number }) => { x: number; y: number }) | undefined,\n): void {\n  const snapRef = useLatest(snapPoint);\n\n  useDepSource('snap', (): SnapDep => ({\n    point: (p) => snapRef.current?.(p) ?? p,\n  }));\n}\n"],"mappings":";;;AAeA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAUC,EAAUC,CAAS;CAEnC,EAAa,eAAwB,EACnC,QAAQ,MAAMF,EAAQ,UAAUG,CAAC,KAAKA,EACxC,EAAE;AACJ"}

package/dist/canvas/deps/textEdit.js

@@ -0,0 +1,21 @@
+import { useLatest as e } from "@weasel-js/react";
+import { useDepSource as t } from "@weasel-js/routing/react";
+//#region src/canvas/deps/textEdit.ts
+function n(n) {
+	let r = e(n);
+	t("textEdit", () => {
+		let e = r.current;
+		return {
+			startEdit(e, t) {
+				process.env.NODE_ENV !== "production" && console.warn("weasel textEditDep: startEdit called but no useTextEdit hook is mounted in SceneCanvas. Override the \"textEdit\" dep via useDepSource(\"textEdit\", ...) to enable in-place text editing.");
+			},
+			isTextNode(t) {
+				return e.get(t)?.data?.kind === "text";
+			}
+		};
+	});
+}
+//#endregion
+export { n as useTextEditDepSource };
+
+//# sourceMappingURL=textEdit.js.map

package/dist/canvas/deps/textEdit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textEdit.js","names":["useTextEditDepSource","sceneRef","useLatest","scene","sc","id"],"sources":["../../../src/canvas/deps/textEdit.ts"],"sourcesContent":["/**\n * `useTextEditDepSource` — wires the `textEdit` dep consumed by\n * `enterTextEditAction`. Kit-default implementation is a no-op stub for\n * `startEdit` plus a convention-based `isTextNode` predicate\n * (`data.kind === 'text'`). Consumers wanting real text editing override the\n * dep via their own `useDepSource('textEdit', ...)` sourced from a\n * `useSceneTextEdit` instance.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { TextEditDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\n\nexport function useTextEditDepSource(\n  scene: Scene<unknown, string, unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n\n  useDepSource('textEdit', (): TextEditDep => {\n    const sc = sceneRef.current;\n    return {\n      startEdit(_id: string, _opts?: { caret?: number | 'all' }) {\n        if (process.env.NODE_ENV !== 'production') {\n          console.warn(\n            'weasel textEditDep: startEdit called but no useTextEdit hook is mounted in SceneCanvas. ' +\n            'Override the \"textEdit\" dep via useDepSource(\"textEdit\", ...) to enable in-place text editing.',\n          );\n        }\n      },\n      isTextNode(id: string) {\n        const node = sc.get(id as NodeId);\n        return (node?.data as { kind?: string } | null | undefined)?.kind === 'text';\n      },\n    };\n  });\n}\n"],"mappings":";;;AAaA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK;CAEhC,EAAa,kBAA+B;EAC1C,IAAMC,IAAKH,EAAS;EACpB,OAAO;GACL,UAAU,GAAa,GAAoC;IACzD,AAAA,QAAA,IAAA,aAA6B,gBAC3B,QAAQ,KACN,4LAEF;GAEJ;GACA,WAAW,GAAY;IAErB,OADaG,EAAG,IAAIC,CACZ,CAAA,EAAM,MAA+C,SAAS;GACxE;EACF;CACF,CAAC;AACH"}