@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/MinimapCanvas.js

@@ -1,140 +0,0 @@
-import { normalizeView as e } from "../core/viewport/view.js";
-import { AUTO_POSE_DESCRIPTOR as t } from "../interactions/actions/resize/autoPoseDescriptor.js";
-import { SceneViewCanvas as n } from "./SceneViewCanvas.js";
-import { usePointerContext as r, usePointerPosition as i } from "../features/pointer/PointerContext.js";
-import { PointerProviderIfRoot as a } from "./SceneCanvas/PointerProviderIfRoot.js";
-import { MINIMAP_CENTER as o, MINIMAP_PAN as s, minimapCenterAction as c, minimapPanAction as l } from "../features/minimap/actions.js";
-import { computeFitView as u, computeIndicatorCommand as d } from "./minimapMath.js";
-import { createLinkedCursorLayer as f } from "../features/minimap/layers.js";
-import { accentColorOf as p } from "./accentColor.js";
-import { useCallback as m, useEffect as h, useMemo as g, useRef as ee, useSyncExternalStore as te } from "react";
-import { assignRef as _, useLatest as v } from "@weasel-js/react";
-import { ActionsProvider as y, ActiveToolContextProvider as b, DepRegistryProvider as x, useActionsRegistry as S, useDepSource as ne, useGestureDispatcher as C } from "@weasel-js/routing/react";
-import { jsx as w } from "react/jsx-runtime";
-//#region src/canvas/MinimapCanvas.tsx
-var T = {
-	id: "minimap",
-	eligibility: { always: !0 },
-	bindings: [{
-		spec: { kind: "pointerDown" },
-		actionId: o
-	}, {
-		spec: { kind: "drag" },
-		actionId: s
-	}]
-}, E = /* @__PURE__ */ new Map([[T.id, T]]), D = {
-	wheel: !1,
-	pinch: !1,
-	contextMenu: !1,
-	ingest: !1
-};
-function O(a) {
-	let { scene: o, mainView: s, mainViewDims: y, onMainViewChange: b, width: x, height: T, drawOne: O, alphaFor: k, layerVisibility: A, layerOrder: j, animator: M, fit: N = "scene", poseDescriptor: re, indicatorStyle: P, className: F, canvasRef: I, id: L = "minimap" } = a, R = e(s), z = te(o.subscribe, o.getVersion, o.getVersion), B = re ?? t, V = g(() => e(u(o, {
-		width: x,
-		height: T
-	}, N, B)), [
-		o,
-		z,
-		x,
-		T,
-		N,
-		B
-	]), H = g(() => d(R, y, P, V), [
-		R,
-		y,
-		P,
-		V
-	]), U = ee(null), W = v(R), G = v(y), K = v(b), q = v(V), J = g(() => ({
-		get: () => W.current,
-		set: (e) => K.current(e),
-		hostSize: () => G.current
-	}), [
-		W,
-		K,
-		G
-	]);
-	ne("rootView", () => J);
-	let Y = S();
-	h(() => {
-		if (!Y) return;
-		let e = [Y.register(c()), Y.register(l())];
-		return () => {
-			for (let t of e) t();
-		};
-	}, [Y]);
-	let X = m((e, t) => {
-		let n = U.current?.getBoundingClientRect(), r = q.current;
-		return {
-			x: r.x + (e - (n?.left ?? 0)) / r.scale.x,
-			y: r.y + (t - (n?.top ?? 0)) / r.scale.y
-		};
-	}, [q]);
-	C({
-		canvasRef: U,
-		actions: Y,
-		entriesById: E,
-		clientToWorld: X,
-		keyboard: !1,
-		channels: D
-	});
-	let Z = r();
-	h(() => {
-		let e = U.current;
-		if (!e || !Z) return;
-		let t = (e) => {
-			let t = X(e.clientX, e.clientY);
-			Z.set({
-				worldX: t.x,
-				worldY: t.y,
-				viewId: L
-			});
-		}, n = (e) => {
-			e.buttons === 0 && Z.get()?.viewId === L && Z.set(null);
-		};
-		return e.addEventListener("pointermove", t), e.addEventListener("pointerleave", n), () => {
-			e.removeEventListener("pointermove", t), e.removeEventListener("pointerleave", n);
-		};
-	}, [
-		Z,
-		X,
-		L
-	]);
-	let Q = i(), $ = g(() => f({
-		id: `${L}.cursor`,
-		pointer: () => Q,
-		color: () => p(U.current)
-	}), [L, Q]), ie = g(() => [H, ...$.draw({ viewId: L }, V, {
-		width: x,
-		height: T
-	})], [
-		H,
-		$,
-		L,
-		V,
-		x,
-		T
-	]), ae = m((e) => {
-		U.current = e, _(I, e);
-	}, [I]);
-	return /* @__PURE__ */ w(n, {
-		scene: o,
-		view: V,
-		width: x,
-		height: T,
-		drawOne: O,
-		extraCommands: ie,
-		alphaFor: k,
-		layerVisibility: A,
-		layerOrder: j,
-		animator: M,
-		className: F,
-		canvasRef: ae
-	});
-}
-function k(e) {
-	return /* @__PURE__ */ w(x, { children: /* @__PURE__ */ w(y, { children: /* @__PURE__ */ w(b, { children: /* @__PURE__ */ w(a, { children: /* @__PURE__ */ w(O, { ...e }) }) }) }) });
-}
-//#endregion
-export { k as MinimapCanvas };
-
-//# sourceMappingURL=MinimapCanvas.js.map

package/dist/canvas/MinimapCanvas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MinimapCanvas.js","names":["MINIMAP_INPUT","MINIMAP_CENTER","MINIMAP_PAN","TOOLS_BY_ID","CHANNELS","MinimapCanvasInner","mainViewProp","props","mainView","normalizeView","sceneVersion","useSyncExternalStore","scene","descriptor","poseDescriptor","AUTO_POSE_DESCRIPTOR","fitView","useMemo","computeFitView","fit","width","height","indicatorCmd","computeIndicatorCommand","mainViewDims","indicatorStyle","localCanvasRef","useRef","mainViewRef","useLatest","mainViewDimsRef","onMainViewChangeRef","onMainViewChange","fitViewRef","rootView","v","actions","useActionsRegistry","off","minimapCenterAction","minimapPanAction","u","clientToWorld","useCallback","rect","fv","cx","cy","pointerStore","usePointerContext","el","onMove","w","id","onLeave","pointer","usePointerPosition","cursorLayer","createLinkedCursorLayer","accentColorOf","extraCommands","setCanvasRef","assignRef","canvasRef","SceneViewCanvas","MinimapCanvas","DepRegistryProvider","ActionsProvider","ActiveToolContextProvider","PointerProviderIfRoot"],"sources":["../../src/canvas/MinimapCanvas.tsx"],"sourcesContent":["/**\n * `<MinimapCanvas>` — opinionated minimap on a canvas of its own, built on\n * `<SceneViewCanvas>`.\n *\n * Renders the same `scene` the main canvas is showing, through a derived\n * \"fit\" view, and overlays a dashed visible-window indicator showing where\n * the main canvas is currently looking. Press anywhere in the minimap to\n * recenter the main view on that world point; drag to pan continuously.\n *\n * Input runs on a dispatcher of its own, through the same `minimap.center` /\n * `minimap.pan` actions the in-surface minimap (`createMinimapContribution`)\n * binds. It publishes its pointer into the pointer store in scope, and draws a\n * crosshair wherever that store says the pointer is on another surface — put\n * one `<PointerContextProvider>` around it and the main canvas for linked\n * cursors both ways.\n */\nimport {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport {\n  ActionsProvider,\n  ActiveToolContextProvider,\n  DepRegistryProvider,\n  useActionsRegistry,\n  useDepSource,\n  useGestureDispatcher,\n} from '@weasel-js/routing/react';\nimport { assignRef, useLatest } from '@weasel-js/react';\nimport type { Tool } from '@weasel-js/routing';\nimport { PointerProviderIfRoot } from './SceneCanvas/PointerProviderIfRoot';\nimport { usePointerContext, usePointerPosition } from 'features/pointer/PointerContext';\nimport {\n  MINIMAP_CENTER, MINIMAP_PAN, minimapCenterAction, minimapPanAction,\n} from 'features/minimap/actions';\nimport { createLinkedCursorLayer } from 'features/minimap/layers';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport { SceneViewCanvas } from './SceneViewCanvas';\nimport {\n  computeFitView,\n  computeIndicatorCommand,\n} from './minimapMath';\nimport type { IndicatorStyle, MinimapFit } from './minimapMath';\nimport type { SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport type { Animator } from '../animation/types';\nimport { AUTO_POSE_DESCRIPTOR } from '../interactions/actions/resize/autoPoseDescriptor';\nimport { accentColorOf } from './accentColor';\n\n/** Props for `<MinimapCanvas>`. */\nexport interface MinimapCanvasProps<TData, TLayer extends string, TPose> {\n  /** Same scene the main canvas is rendering. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Main canvas's view — used to position the visible-window indicator and\n   *  to preserve `scale` when the minimap recenters. */\n  mainView: View;\n  /** Main canvas's CSS-pixel dims. Used to compute the visible-window rect\n   *  and the recenter offset. */\n  mainViewDims: { width: number; height: number };\n  /** Setter called on click (single recenter) and during drag (continuous\n   *  recenter). Receives a `View` with the same `scale` as `mainView` and\n   *  `(x, y)` shifted so the pointer's world point lands at the main\n   *  canvas's center. */\n  onMainViewChange: (next: View) => void;\n  /** Minimap's own CSS-pixel dims. */\n  width: number;\n  height: number;\n  /** Consumer's draw callback. Applied through the derived fit view; same\n   *  signature as `<SceneCanvas>`'s scene-slot `drawOne` so the consumer\n   *  can reuse it (typically simplified — just colored AABBs). */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Fit policy. Defaults to `\"scene\"` (AABB union of leaf poses). See\n   *  `MinimapFit` for the full shape.\n   *\n   *  Framing is derived from **document** poses, not `scene.overrides` — a\n   *  node moved by an override paints where the override puts it, outside the\n   *  frame if it goes there, rather than making the whole minimap rescale on\n   *  every frame of a drag or a settle. */\n  fit?: MinimapFit<TData, TLayer, TPose>;\n  /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses so a\n   *  scoping-dim treatment shows up in the minimap too. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in the minimap, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map so both show the same set. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for the minimap, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Optional animator: the minimap repaints on its ticks and paints its\n   *  `colorOverrides`. Pass the main canvas's animator so both show the same\n   *  colors. */\n  animator?: Animator;\n  /** Visual tuning of the indicator stroke. */\n  indicatorStyle?: IndicatorStyle;\n  /** CSS class for positioning the canvas. Its size is `width` × `height`. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n  /** The view id this minimap publishes its pointer under. Default\n   *  `'minimap'`. */\n  id?: string;\n}\n\n/** The minimap's own bindings. Unscoped: this dispatcher routes no views, so\n *  every input on it is the minimap's. */\nconst MINIMAP_INPUT: Tool = {\n  id: 'minimap',\n  eligibility: { always: true },\n  bindings: [\n    { spec: { kind: 'pointerDown' }, actionId: MINIMAP_CENTER },\n    { spec: { kind: 'drag' }, actionId: MINIMAP_PAN },\n  ],\n};\nconst TOOLS_BY_ID: ReadonlyMap<string, Tool> = new Map([[MINIMAP_INPUT.id, MINIMAP_INPUT]]);\nconst CHANNELS = { wheel: false, pinch: false, contextMenu: false, ingest: false } as const;\n\nfunction MinimapCanvasInner<TData, TLayer extends string, TPose>(\n  props: MinimapCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene,\n    mainView: mainViewProp,\n    mainViewDims,\n    onMainViewChange,\n    width,\n    height,\n    drawOne,\n    alphaFor,\n    layerVisibility,\n    layerOrder,\n    animator,\n    fit = 'scene',\n    poseDescriptor,\n    indicatorStyle,\n    className,\n    canvasRef,\n    id = 'minimap',\n  } = props;\n  const mainView = normalizeView(mainViewProp);\n\n  // Subscribe to scene version so the fit view recomputes when the scene\n  // mutates. `<SceneViewCanvas>` also subscribes, but it owns its own\n  // rendering; we need the version *here* to invalidate the memoized fit.\n  const sceneVersion = useSyncExternalStore(\n    scene.subscribe,\n    scene.getVersion,\n    scene.getVersion,\n  );\n\n  const descriptor = (poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const fitView = useMemo<View>(() => {\n    // A `fit` function's result is the caller's; pointer math divides by its scale.\n    return normalizeView(computeFitView(scene, { width, height }, fit, descriptor));\n    // `sceneVersion` participates so the memo re-evaluates after scene mutations.\n    // `descriptor` is stable when the prop is omitted.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [scene, sceneVersion, width, height, fit, descriptor]);\n\n  const indicatorCmd = useMemo<DrawCommand>(() => {\n    return computeIndicatorCommand(mainView, mainViewDims, indicatorStyle, fitView);\n  }, [mainView, mainViewDims, indicatorStyle, fitView]);\n\n  // -------------------------------------------------------------------------\n  // Input\n  // -------------------------------------------------------------------------\n  //\n  // The \"latest\" pattern (refs holding the current mainView / dims / setter\n  // / fitView) lets the dep and the listeners read up-to-date values without\n  // re-binding every frame.\n\n  const localCanvasRef = useRef<HTMLCanvasElement | null>(null);\n  const mainViewRef = useLatest(mainView);\n  const mainViewDimsRef = useLatest(mainViewDims);\n  const onMainViewChangeRef = useLatest(onMainViewChange);\n  const fitViewRef = useLatest(fitView);\n\n  // The main canvas's camera, which is what the minimap's actions move.\n  const rootView = useMemo<ViewApi>(() => ({\n    get: () => mainViewRef.current,\n    set: (v) => onMainViewChangeRef.current(v),\n    hostSize: () => mainViewDimsRef.current,\n  }), [mainViewRef, onMainViewChangeRef, mainViewDimsRef]);\n  useDepSource('rootView', () => rootView);\n\n  const actions = useActionsRegistry();\n  useEffect(() => {\n    if (!actions) return;\n    const off = [actions.register(minimapCenterAction()), actions.register(minimapPanAction())];\n    return () => { for (const u of off) u(); };\n  }, [actions]);\n\n  /** Client point → world, through the fit camera. */\n  const clientToWorld = useCallback((cx: number, cy: number) => {\n    const rect = localCanvasRef.current?.getBoundingClientRect();\n    const fv = fitViewRef.current;\n    return {\n      x: fv.x + (cx - (rect?.left ?? 0)) / fv.scale.x,\n      y: fv.y + (cy - (rect?.top ?? 0)) / fv.scale.y,\n    };\n  }, [fitViewRef]);\n\n  useGestureDispatcher({\n    canvasRef: localCanvasRef,\n    actions: actions!,\n    entriesById: TOOLS_BY_ID,\n    clientToWorld,\n    keyboard: false,\n    channels: CHANNELS,\n  });\n\n  // -------------------------------------------------------------------------\n  // Linked cursor\n  // -------------------------------------------------------------------------\n\n  const pointerStore = usePointerContext();\n  useEffect(() => {\n    const el = localCanvasRef.current;\n    if (!el || !pointerStore) return;\n    const onMove = (e: PointerEvent): void => {\n      const w = clientToWorld(e.clientX, e.clientY);\n      pointerStore.set({ worldX: w.x, worldY: w.y, viewId: id });\n    };\n    const onLeave = (e: PointerEvent): void => {\n      if (e.buttons !== 0) return;\n      if (pointerStore.get()?.viewId === id) pointerStore.set(null);\n    };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    return () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [pointerStore, clientToWorld, id]);\n\n  const pointer = usePointerPosition();\n  const cursorLayer = useMemo(() => createLinkedCursorLayer({\n    id: `${id}.cursor`,\n    pointer: () => pointer,\n    color: () => accentColorOf(localCanvasRef.current),\n  }), [id, pointer]);\n\n  const extraCommands = useMemo<DrawCommand[]>(() => [\n    indicatorCmd,\n    ...cursorLayer.draw({ viewId: id }, fitView, { width, height }),\n  ], [indicatorCmd, cursorLayer, id, fitView, width, height]);\n\n  // `<SceneViewCanvas>` doesn't expose its element except via `canvasRef`, so\n  // we route both our internal ref and the consumer's ref through one setter.\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null) => {\n    localCanvasRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n\n  return (\n    <SceneViewCanvas\n      scene={scene}\n      view={fitView}\n      width={width}\n      height={height}\n      drawOne={drawOne}\n      extraCommands={extraCommands}\n      alphaFor={alphaFor}\n      layerVisibility={layerVisibility}\n      layerOrder={layerOrder}\n      animator={animator}\n      className={className}\n      canvasRef={setCanvasRef}\n    />\n  );\n}\n\n/**\n * Opinionated minimap. See `MinimapCanvasProps` for the full surface and\n * the module docstring for the rendering / input model.\n *\n * Its dispatcher, actions and deps are its own, so it never competes with\n * the main canvas for input. The pointer store is shared when one is in scope.\n *\n * `forwardRef` is not used because the component is generic over\n * `<TData, TLayer, TPose>` and React's `forwardRef` erases generics. The\n * `canvasRef` prop is the plain-prop equivalent.\n */\nexport function MinimapCanvas<TData, TLayer extends string, TPose>(\n  props: MinimapCanvasProps<TData, TLayer, TPose>,\n) {\n  return (\n    <DepRegistryProvider>\n      <ActionsProvider>\n        <ActiveToolContextProvider>\n          <PointerProviderIfRoot>\n            <MinimapCanvasInner {...props} />\n          </PointerProviderIfRoot>\n        </ActiveToolContextProvider>\n      </ActionsProvider>\n    </DepRegistryProvider>\n  );\n}\n"],"mappings":"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"}

package/dist/canvas/deps/poseComposition.js

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/minimapMath.js

@@ -1,82 +0,0 @@
-import { documentPose as e } from "../core/scene/effectivePose.js";
-import { poseDescriptorForNode as t } from "../core/geometry/poseDescriptor.js";
-//#region src/canvas/minimapMath.ts
-var n = 8, r = {
-	x: 0,
-	y: 0,
-	scale: {
-		x: 1,
-		y: 1
-	}
-}, i = "#ffffff", a = 1, o = [2, 3];
-function s(e, t, n) {
-	let r = Math.max(1, t.width - n * 2), i = Math.max(1, t.height - n * 2), a = e.width > 0, o = e.height > 0;
-	if (!a && !o) return {
-		x: e.x - t.width / 2,
-		y: e.y - t.height / 2,
-		scale: {
-			x: 1,
-			y: 1
-		}
-	};
-	let s = Math.min(a ? r / e.width : Infinity, o ? i / e.height : Infinity), c = e.x + Math.max(0, e.width) / 2, l = e.y + Math.max(0, e.height) / 2;
-	return {
-		x: c - t.width / (2 * s),
-		y: l - t.height / (2 * s),
-		scale: {
-			x: s,
-			y: s
-		}
-	};
-}
-function c(n, r) {
-	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity, c = !1;
-	for (let l of n.nodes.values()) {
-		if (l.kind !== "leaf") continue;
-		let u = t(r, l).getBounds(e(n, l));
-		if (!Number.isFinite(u.x + u.y + u.width + u.height)) continue;
-		u.x < i && (i = u.x), u.y < a && (a = u.y);
-		let d = u.x + u.width, f = u.y + u.height;
-		d > o && (o = d), f > s && (s = f), c = !0;
-	}
-	return c ? {
-		x: i,
-		y: a,
-		width: o - i,
-		height: s - a
-	} : null;
-}
-function l(e, t, i, a, o = {}) {
-	let l = o.padding ?? n;
-	if (typeof i == "function") return i(e, t);
-	if (i === "scene") {
-		let n = c(e, a);
-		return n === null ? r : s(n, t, l);
-	}
-	return s(i.rect, t, l);
-}
-function u(e, t, n = {}, r) {
-	let s = e.x, c = e.y, l = t.width / e.scale.x, u = t.height / e.scale.y, d = r ? 1 / Math.abs(r.scale.x) : 1;
-	return {
-		kind: "path",
-		path: {
-			kind: "rect",
-			x: s,
-			y: c,
-			width: l,
-			height: u
-		},
-		stroke: {
-			paint: {
-				fill: "solid",
-				color: n.stroke ?? i
-			},
-			width: (n.width ?? a) * d,
-			dash: (n.dash ?? o).map((e) => e * d)
-		}
-	};
-}
-//#endregion
-export { r as FALLBACK_FIT_VIEW, l as computeFitView, u as computeIndicatorCommand };
-
-//# sourceMappingURL=minimapMath.js.map

package/dist/canvas/minimapMath.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"minimapMath.js","names":["DEFAULT_FIT_PADDING","FALLBACK_FIT_VIEW","DEFAULT_INDICATOR_STROKE","DEFAULT_INDICATOR_WIDTH","DEFAULT_INDICATOR_DASH","fitRectInto","availW","dims","padding","availH","hasW","rect","hasH","worldCx","worldCy","sceneLeafBounds","minX","minY","maxX","maxY","any","node","scene","b","poseDescriptorForNode","descriptor","documentPose","right","bottom","computeFitView","opts","fit","computeIndicatorCommand","x","mainView","y","width","mainViewDims","height","px","minimapView","style","d"],"sources":["../../src/canvas/minimapMath.ts"],"sourcesContent":["/**\n * Pure math helpers for `<MinimapCanvas>`.\n *\n * `computeFitView` derives a `View` that fits a chosen world rect into a\n * minimap canvas of given pixel dims. `computeIndicatorCommand` builds the\n * dashed \"visible window\" rect — the main canvas's screen window projected\n * into the minimap's own screen coordinates.\n *\n * Neither helper touches GL, the DOM, or the renderer; they're pure\n * functions, unit-testable with `expect`.\n */\nimport { documentPose } from '../core/scene';\nimport type { Scene } from '../core/scene';\nimport type { View } from '../core/viewport/view';\nimport type { Bounds, ViewportDims } from '../core/viewport/fitViewToBounds';\nimport { poseDescriptorForNode, type PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport type { PathDrawCommand } from '../renderer/DrawCommand';\n\n/** Inset (CSS px) around the fit rect on each side. Matches the spec note. */\nconst DEFAULT_FIT_PADDING = 8;\n\n/**\n * Fallback view returned when there is nothing to fit (empty scene, etc.).\n * Identity view at the origin — produces a 1:1 mapping centered on (0, 0).\n */\nexport const FALLBACK_FIT_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/**\n * Fit policy for `<MinimapCanvas>` / `computeFitView`.\n *\n * - `\"scene\"` — union of leaf-node pose AABBs (via the pose descriptor).\n * - `{ kind: \"world\", rect }` — caller-supplied world rect.\n * - `(scene, dims) => View` — caller derives the view directly.\n */\nexport type MinimapFit<TData, TLayer extends string, TPose> =\n  | 'scene'\n  | { kind: 'world'; rect: Bounds }\n  | ((scene: Scene<TData, TLayer, TPose>, dims: ViewportDims) => View);\n\n/** Style for the visible-window indicator rect drawn over the minimap. */\nexport interface IndicatorStyle {\n  /** Stroke color (any CSS color). Defaults to `'#ffffff'`. */\n  stroke?: string;\n  /** Stroke width in CSS px. Defaults to `1`. */\n  width?: number;\n  /** Dash pattern in CSS px. Defaults to `[2, 3]`. */\n  dash?: number[];\n}\n\nconst DEFAULT_INDICATOR_STROKE = '#ffffff';\nconst DEFAULT_INDICATOR_WIDTH = 1;\nconst DEFAULT_INDICATOR_DASH: readonly number[] = [2, 3];\n\n/** Internal: fit a world rect uniformly into dims with padding. */\nfunction fitRectInto(rect: Bounds, dims: ViewportDims, padding: number): View {\n  const availW = Math.max(1, dims.width - padding * 2);\n  const availH = Math.max(1, dims.height - padding * 2);\n  const hasW = rect.width > 0;\n  const hasH = rect.height > 0;\n  if (!hasW && !hasH) {\n    return {\n      x: rect.x - dims.width / 2,\n      y: rect.y - dims.height / 2,\n      scale: { x: 1, y: 1 },\n    };\n  }\n  const s = Math.min(\n    hasW ? availW / rect.width : Infinity,\n    hasH ? availH / rect.height : Infinity,\n  );\n  const worldCx = rect.x + Math.max(0, rect.width) / 2;\n  const worldCy = rect.y + Math.max(0, rect.height) / 2;\n  return {\n    x: worldCx - dims.width / (2 * s),\n    y: worldCy - dims.height / (2 * s),\n    scale: { x: s, y: s },\n  };\n}\n\n/**\n * Compute the AABB union of all leaf-node poses in the scene, via\n * `descriptor`. Container nodes are skipped — their effective bounds come\n * from their descendant leaves, and so is a leaf whose bounds are not finite,\n * which would otherwise make the whole union non-finite. Returns `null` when\n * the scene has no leaf with bounds.\n */\nfunction sceneLeafBounds<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  descriptor: PoseDescriptor<TPose>,\n): Bounds | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const node of scene.nodes.values()) {\n    if (node.kind !== 'leaf') continue;\n    const b = poseDescriptorForNode(descriptor, node).getBounds(documentPose(scene, node));\n    if (!Number.isFinite(b.x + b.y + b.width + b.height)) continue;\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n    any = true;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/** Options for {@link computeFitView}. */\nexport interface ComputeFitViewOptions {\n  /** Inset (CSS px) around the fit rect on each side. Defaults to `8`. */\n  padding?: number;\n}\n\n/**\n * Derive a `View` that fits the chosen world rect into a minimap of\n * `dims.width × dims.height` CSS px. Uniform scale on both axes; the rect\n * is centered with `padding` (default 8) on each side. The smaller-axis\n * fit ratio wins, so the whole rect is visible.\n *\n * - `fit === \"scene\"`: union AABB of leaf-node poses via `descriptor`.\n *   Empty scene → {@link FALLBACK_FIT_VIEW}.\n * - `fit` is `{ kind: \"world\", rect }`: fit `rect`.\n * - `fit` is a function: called with `(scene, dims)`; its return is\n *   passed through unchanged.\n *\n * A rect with one zero axis (a line) is fitted along the other. One with no\n * positive axis falls back to identity scale centered on its top-left.\n */\nexport function computeFitView<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  dims: ViewportDims,\n  fit: MinimapFit<TData, TLayer, TPose>,\n  descriptor: PoseDescriptor<TPose>,\n  opts: ComputeFitViewOptions = {},\n): View {\n  const padding = opts.padding ?? DEFAULT_FIT_PADDING;\n\n  if (typeof fit === 'function') {\n    return fit(scene, dims);\n  }\n  if (fit === 'scene') {\n    const rect = sceneLeafBounds(scene, descriptor);\n    if (rect === null) return FALLBACK_FIT_VIEW;\n    return fitRectInto(rect, dims, padding);\n  }\n  // { kind: 'world', rect }\n  return fitRectInto(fit.rect, dims, padding);\n}\n\n/**\n * Build the visible-window indicator `DrawCommand` for the minimap.\n *\n * The main canvas's visible world rect is:\n * ```\n * worldX = mainView.x\n * worldY = mainView.y\n * worldW = mainViewDims.width  / mainView.scale.x\n * worldH = mainViewDims.height / mainView.scale.y\n * ```\n * That world rect is then transformed into the minimap's screen\n * coordinates through `minimapView`.\n *\n * The returned command is a dashed-stroke `path` rect with no fill. Pass the\n * `minimapView` it will be drawn through, so the stroke width and dash come\n * out in CSS px at any fit scale; without it they are in world units.\n */\nexport function computeIndicatorCommand(\n  mainView: View,\n  mainViewDims: ViewportDims,\n  style: IndicatorStyle = {},\n  minimapView?: View,\n): PathDrawCommand {\n  // World-space rect: returned as-is. The caller wraps the command list\n  // (scene + extras) in a group transformed by the minimap's view, so the\n  // indicator lands in screen coords automatically. Returning screen coords\n  // here would get the view transform applied a second time — a bug that\n  // manifested as the indicator drifting at non-identity minimap scale.\n  const x = mainView.x;\n  const y = mainView.y;\n  const width = mainViewDims.width / mainView.scale.x;\n  const height = mainViewDims.height / mainView.scale.y;\n  const px = minimapView ? 1 / Math.abs(minimapView.scale.x) : 1;\n  return {\n    kind: 'path',\n    path: { kind: 'rect', x, y, width, height },\n    stroke: {\n      paint: { fill: 'solid', color: style.stroke ?? DEFAULT_INDICATOR_STROKE },\n      width: (style.width ?? DEFAULT_INDICATOR_WIDTH) * px,\n      dash: (style.dash ?? DEFAULT_INDICATOR_DASH).map((d) => d * px),\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/toolPreview.js

@@ -1,39 +0,0 @@
-//#region src/canvas/toolPreview.ts
-function* e(e) {
-	let t = /* @__PURE__ */ new Set(), n = e.hotkeyEngaged ? e.registry[e.hotkeyEngaged] : void 0, r = e.active === null ? void 0 : e.registry[e.active];
-	for (let e of [n, r]) e && !t.has(e) && (t.add(e), yield e);
-	for (let n of Object.values(e.registry)) n && !t.has(n) && (t.add(n), yield n);
-	for (let n of e.ambient) n && !t.has(n) && (t.add(n), yield n);
-}
-function t(t, n) {
-	if (!t) return null;
-	for (let r of e(t)) {
-		let e = r.previewPose?.(n);
-		if (e != null) return e;
-	}
-	return null;
-}
-function n(t, n) {
-	if (!t) return null;
-	for (let r of e(t)) {
-		let e = r.previewBounds?.(n);
-		if (e) return e;
-	}
-	return null;
-}
-function r(t) {
-	let n = /* @__PURE__ */ new Set();
-	if (!t) return n;
-	for (let r of e(t)) {
-		let e = r.previewIds?.();
-		if (e) for (let t of e) n.add(t);
-	}
-	return n;
-}
-function i(t) {
-	return t ? [...e(t)] : [];
-}
-//#endregion
-export { r as aggregatePreviewIds, n as firstPreviewBounds, t as firstPreviewPose, i as toolPreviewSources, e as toolsInPriorityOrder };
-
-//# sourceMappingURL=toolPreview.js.map

package/dist/canvas/toolPreview.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolPreview.js","names":["toolsInPriorityOrder","seen","hotkey","tools","active","t","firstPreviewPose","p","id","firstPreviewBounds","b","aggregatePreviewIds","out","ids","toolPreviewSources"],"sources":["../../src/canvas/toolPreview.ts"],"sourcesContent":["/**\n * Helpers for reading preview pose / bounds / ids from a ToolsApi.\n * Extracted from Canvas.tsx so SceneCanvas can use the same logic when\n * constructing scene-aware layers (selection overlay, etc.) without\n * going through Canvas's internal render closure.\n */\nimport type { ToolsApi } from '../tools/overlayBinding';\nimport type { AnyTool } from '../tools/overlayBinding';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GesturePreviewSource } from './gestureBounds';\n\n/** Iterate all tools in priority order: hotkey-engaged → active → rest of\n *  registry → ambient. Skips duplicates so each tool is only visited once.\n *  This preserves the \"most-specific tool wins\" contract when multiple\n *  siblings of select each publish their own preview slice. */\nexport function* toolsInPriorityOrder(tools: ToolsApi): IterableIterator<AnyTool> {\n  const seen = new Set<AnyTool>();\n  const hotkey = tools.hotkeyEngaged ? tools.registry[tools.hotkeyEngaged] : undefined;\n  const active = tools.active === null ? undefined : tools.registry[tools.active];\n  for (const t of [hotkey, active]) {\n    if (t && !seen.has(t)) { seen.add(t); yield t; }\n  }\n  for (const t of Object.values(tools.registry)) {\n    if (t && !seen.has(t)) { seen.add(t); yield t; }\n  }\n  for (const t of tools.ambient) {\n    if (t && !seen.has(t)) { seen.add(t); yield t; }\n  }\n}\n\n/** Return the first non-null `previewPose(id)` from any tool in priority\n *  order, or `null` when no tool owns a preview for this id. */\nexport function firstPreviewPose(tools: ToolsApi | undefined, id: string): unknown {\n  if (!tools) return null;\n  for (const t of toolsInPriorityOrder(tools)) {\n    const p = t.previewPose?.(id);\n    if (p != null) return p;\n  }\n  return null;\n}\n\n/** Return the first non-null `previewBounds(id)` from any tool in priority\n *  order, or `null` when no tool owns a bounds preview for this id. */\nexport function firstPreviewBounds(tools: ToolsApi | undefined, id: string): Bounds | null {\n  if (!tools) return null;\n  for (const t of toolsInPriorityOrder(tools)) {\n    const b = t.previewBounds?.(id);\n    if (b) return b as Bounds;\n  }\n  return null;\n}\n\n/** Aggregate all `previewIds()` from every registered tool into a single Set. */\nexport function aggregatePreviewIds(tools: ToolsApi | undefined): Set<string> {\n  const out = new Set<string>();\n  if (!tools) return out;\n  for (const t of toolsInPriorityOrder(tools)) {\n    const ids = t.previewIds?.();\n    if (!ids) continue;\n    for (const id of ids) out.add(id);\n  }\n  return out;\n}\n\n/** Every tool that can publish a preview, in priority order and deduplicated —\n *  the tool half of a view's preview sources. A drag may run through `select`\n *  while the active tool is `clone`, so the active tool alone is the wrong\n *  source. */\nexport function toolPreviewSources(tools: ToolsApi | undefined): GesturePreviewSource[] {\n  if (!tools) return [];\n  return [...toolsInPriorityOrder(tools)];\n}\n"],"mappings":";AAeA,UAAiBA,EAAqB,GAA4C;CAChF,IAAMC,oBAAO,IAAI,IAAa,GACxBC,IAASC,EAAM,gBAAgBA,EAAM,SAASA,EAAM,iBAAiB,KAAA,GACrEC,IAASD,EAAM,WAAW,OAAO,KAAA,IAAYA,EAAM,SAASA,EAAM;CACxE,KAAK,IAAME,KAAK,CAACH,GAAQE,CAAM,GAC7B,AAAIC,KAAK,CAACJ,EAAK,IAAII,CAAC,MAAKJ,EAAK,IAAII,CAAC,GAAG,MAAMA;CAE9C,KAAK,IAAMA,KAAK,OAAO,OAAOF,EAAM,QAAQ,GAC1C,AAAIE,KAAK,CAACJ,EAAK,IAAII,CAAC,MAAKJ,EAAK,IAAII,CAAC,GAAG,MAAMA;CAE9C,KAAK,IAAMA,KAAKF,EAAM,SACpB,AAAIE,KAAK,CAACJ,EAAK,IAAII,CAAC,MAAKJ,EAAK,IAAII,CAAC,GAAG,MAAMA;AAEhD;AAIA,SAAgBC,EAAiB,GAA6B,GAAqB;CACjF,IAAI,CAACH,GAAO,OAAO;CACnB,KAAK,IAAME,KAAKL,EAAqBG,CAAK,GAAG;EAC3C,IAAMI,IAAIF,EAAE,cAAcG,CAAE;EAC5B,IAAID,KAAK,MAAM,OAAOA;CACxB;CACA,OAAO;AACT;AAIA,SAAgBE,EAAmB,GAA6B,GAA2B;CACzF,IAAI,CAACN,GAAO,OAAO;CACnB,KAAK,IAAME,KAAKL,EAAqBG,CAAK,GAAG;EAC3C,IAAMO,IAAIL,EAAE,gBAAgBG,CAAE;EAC9B,IAAIE,GAAG,OAAOA;CAChB;CACA,OAAO;AACT;AAGA,SAAgBC,EAAoB,GAA0C;CAC5E,IAAMC,oBAAM,IAAI,IAAY;CAC5B,IAAI,CAACT,GAAO,OAAOS;CACnB,KAAK,IAAMP,KAAKL,EAAqBG,CAAK,GAAG;EAC3C,IAAMU,IAAMR,EAAE,aAAa;EAC3B,IAAKQ,GACL,KAAK,IAAML,KAAMK,GAAK,EAAI,IAAIL,CAAE;CAClC;CACA,OAAOI;AACT;AAMA,SAAgBE,EAAmB,GAAqD;CAEtF,OADKX,IACE,CAAC,GAAGH,EAAqBG,CAAK,CAAC,IADnB,CAAC;AAEtB"}

package/dist/core/adapters/arrayAdapter.js

@@ -1,94 +0,0 @@
-import { RECT_POSE_DESCRIPTOR as e, poseDescriptorForNode as t, translatePoseViaDescriptor as n } from "../geometry/poseDescriptor.js";
-import { parentOf as r } from "../ops/slot.js";
-import { applyOpsTo as i } from "../applyOps.js";
-import { polygonRegion as a, poseOutline as o, rectRegion as s, regionBoundsOf as c, regionTakes as l } from "../geometry/regionHit.js";
-//#region src/core/adapters/arrayAdapter.ts
-function u(e, t) {
-	return {
-		...e,
-		...t
-	};
-}
-var d = 0;
-function f() {
-	let e = globalThis.crypto;
-	return e && typeof e.randomUUID == "function" ? e.randomUUID() : `paste-${d++}`;
-}
-function p(d) {
-	let { ref: p, setItems: m, toPose: h, fromPose: g = u, getParent: _ = () => null, setParent: v = () => {}, getChildren: y, selectionRef: b, setSelection: x = () => {}, createDefault: S, nextId: C = f, silhouette: w } = d, T = d.poseDescriptor ?? e, E = b ? () => b.current : () => [], D = (e, n) => {
-		let r = [];
-		for (let i of p.current) {
-			let a = h(i), s = c(i, a, t(T, i));
-			l(e, n, a, s, () => w?.(i, a) ?? o(a, s)) && r.push(i.id);
-		}
-		return r;
-	}, O = (e, t) => t === null ? e.filter((e) => _(e.id) === null).map((e) => e.id) : y?.(t) ?? [], k = (e, t, n) => {
-		if (n === void 0 || n < 0) return;
-		if (!y) return n < e.length ? n : void 0;
-		let i = O(e, r(t)).filter((e) => e !== t.id)[n], a = i === void 0 ? -1 : e.findIndex((e) => e.id === i);
-		return a < 0 ? void 0 : a;
-	}, A = {
-		getNode: (e) => p.current.find((t) => t.id === e),
-		getNodes: () => p.current,
-		getPose: (e) => {
-			let t = p.current.find((t) => t.id === e);
-			if (!t) throw Error(`arrayAdapter.getPose: id "${e}" not found`);
-			return h(t);
-		},
-		setPose: (e, t) => {
-			m((n) => n.map((n) => n.id === e ? g(n, t) : n));
-		},
-		getParent: _,
-		setParent: v,
-		insertNode: (e, t) => m((n) => {
-			let r = k(n, e, t);
-			return r === void 0 ? [...n, e] : [
-				...n.slice(0, r),
-				e,
-				...n.slice(r)
-			];
-		}),
-		removeNode: (e) => m((t) => t.filter((t) => t.id !== e)),
-		getSelection: E,
-		setSelection: x,
-		hitTestArea: (e) => D(s(e), "intersect"),
-		hitTestLasso: (e, t) => {
-			let n = a(e);
-			return n ? D(n, t) : [];
-		},
-		applyOps(e) {
-			i(this, e);
-		},
-		commitInsert: S ? (e) => S(e) : () => null,
-		commitPaste: (e, r, i) => {
-			let a = e.items;
-			if (a.length === 0) return [];
-			let o = r.dx, s = r.dy;
-			if (i?.dropPoint) {
-				let e = Infinity, n = Infinity, r = -Infinity, c = -Infinity;
-				for (let i of a) {
-					let a = t(T, i).getBounds(h(i));
-					a.x < e && (e = a.x), a.y < n && (n = a.y), a.x + a.width > r && (r = a.x + a.width), a.y + a.height > c && (c = a.y + a.height);
-				}
-				if (Number.isFinite(e) && Number.isFinite(n)) {
-					let t = (e + r) / 2, a = (n + c) / 2;
-					o = i.dropPoint.worldX - t, s = i.dropPoint.worldY - a;
-				}
-			}
-			let c = [];
-			for (let e of a) {
-				let r = JSON.parse(JSON.stringify(e));
-				r.id = C();
-				let i = n(h(r), o, s, t(T, r));
-				c.push(g(r, i));
-			}
-			return c;
-		},
-		snapshotSelection: (e) => ({ items: e.map((e) => p.current.find((t) => t.id === e)).filter((e) => !!e) })
-	};
-	return y && (A.getChildren = (e) => O(p.current, e)), A;
-}
-//#endregion
-export { p as arrayAdapter };
-
-//# sourceMappingURL=arrayAdapter.js.map

package/dist/core/adapters/arrayAdapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrayAdapter.js","names":["defaultFromPose","obj","pose","monotonicPasteCounter","defaultNextId","c","arrayAdapter","config","d","RECT_POSE_DESCRIPTOR","getSelection","selectionRef","takenBy","out","o","ref","toPose","b","regionBoundsOf","poseDescriptorForNode","regionTakes","region","mode","silhouette","poseOutline","childrenIn","parentId","items","getParent","getChildren","arrayIndexFor","index","before","parentOf","id","at","adapter","fromPose","setItems","rectRegion","rect","polygonRegion","polygon","ops","createDefault","src","clip","dx","offset","dy","ctx","minX","minY","maxX","maxY","n","cx","cy","cloned","nextId","translated","translatePoseViaDescriptor","ids"],"sources":["../../../src/core/adapters/arrayAdapter.ts"],"sourcesContent":["import type { MutableRefObject } from 'react';\nimport type {\n  AreaSelectAdapter,\n  InsertAdapter,\n  LassoHitMode,\n  LassoSelectAdapter,\n  MoveAdapter,\n  ResizeAdapter,\n} from './types';\nimport type { Op } from '../ops/types';\nimport { applyOpsTo } from '../applyOps';\nimport { parentOf } from '../ops/slot';\nimport type { Bounds } from '../viewport/fitViewToBounds';\nimport type { ClipboardSnapshot } from './types';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  RECT_POSE_DESCRIPTOR,\n  type PoseDescriptor,\n} from 'core/geometry/poseDescriptor';\nimport type { Path } from '@weasel-js/geom';\nimport {\n  polygonRegion,\n  poseOutline,\n  rectRegion,\n  regionBoundsOf,\n  regionTakes,\n  type SelectRegion,\n} from 'core/geometry/regionHit';\n\n/** Configuration for `arrayAdapter`. */\nexport interface ArrayAdapterConfig<TNode extends { id: string }, TPose> {\n  /** Live ref to the current array. */\n  ref: MutableRefObject<TNode[]>;\n  /** Functional setter (typically the second value from `useState`). */\n  setItems: (updater: (items: TNode[]) => TNode[]) => void;\n  /** Project an object to its pose. Required. */\n  toPose: (obj: TNode) => TPose;\n  /** Merge a new pose back into an object. Default: shallow spread. */\n  fromPose?: (obj: TNode, pose: TPose) => TNode;\n  /** Optional parent lookup. Default returns `null`. */\n  getParent?: (id: string) => string | null;\n  /** Optional reparent mutator. Default is a noop. */\n  setParent?: (id: string, parentId: string | null) => void;\n  /** Optional children lookup for a node id. The adapter answers the root\n   *  itself, from `ref` and `getParent` in array order, so this is never\n   *  called with `null`. Default omits the method entirely. */\n  getChildren?: (id: string) => string[] | undefined;\n\n  /** Live ref to the current selection. Default: empty array. */\n  selectionRef?: MutableRefObject<string[]>;\n  /** Selection setter. Default: noop. */\n  setSelection?: (ids: string[]) => void;\n\n  /** Factory for `commitInsert` — invoked at the end of an insert drag.\n   *  Consumers own id generation and any palette/payload fields. Returning\n   *  `null` aborts the insert. When omitted, `commitInsert` returns `null`. */\n  createDefault?: (bounds: Bounds) => TNode | null;\n\n  /** How to read and rewrite item poses. Default `RECT_POSE_DESCRIPTOR`,\n   *  which reads the pose as its own AABB — the canonical axis-aligned rect\n   *  pose. `AUTO_POSE_DESCRIPTOR` lives above `core/` and so cannot be the\n   *  default here; pass it for a scene whose poses may be Paths. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n\n  /** The outline a node draws, for marquee and lasso, in world coordinates.\n   *  Return `null` where the pose says it all. Default: none — a polygon pose\n   *  is its own outline, and anything else is its pose rect, rotated by\n   *  `rotation`. The kit's painters live above `core/`, so a scene whose\n   *  nodes they draw passes `findShapeSilhouette` to be tested as drawn. */\n  silhouette?: (node: TNode, pose: TPose) => Path | null;\n\n  /** Factory for fresh node ids in `commitPaste`. Default: `crypto.randomUUID()`\n   *  when available, otherwise a monotonic `paste-<n>` counter. Override\n   *  when consumers want stable id schemes (e.g. `clip-${n++}`). */\n  nextId?: () => string;\n}\n\n/**\n * Combined adapter satisfying every narrow adapter the kit ships. Methods\n * with no default implementation (e.g. `commitInsert` without\n * `createDefault`) return null/[]/noop — sufficient to typecheck against\n * `InsertAdapter`/`AreaSelectAdapter`, and the corresponding gesture hook\n * simply produces no commit.\n */\nexport interface ArrayAdapter<TNode extends { id: string }, TPose>\n  extends MoveAdapter<TNode, TPose>,\n    ResizeAdapter<TNode, TPose>,\n    InsertAdapter<TNode>,\n    AreaSelectAdapter,\n    LassoSelectAdapter {\n  getNodes(): TNode[];\n  removeNode(id: string): void;\n  // ArrayAdapter satisfies the union of all narrow adapters; redeclare the\n  // methods that are optional on AreaSelectAdapter (post-relaxation) but\n  // required on InsertAdapter so TS sees a single non-conflicting signature.\n  getSelection(): string[];\n  setSelection(ids: string[]): void;\n  // Redeclare applyOps with an optional label so it's compatible with both\n  // MoveAdapter (label required) and AreaSelectAdapter (label absent = transient).\n  applyOps?(ops: Op[], label?: string): void;\n}\n\nfunction defaultFromPose<TNode extends { id: string }, TPose>(\n  obj: TNode,\n  pose: TPose,\n): TNode {\n  return { ...obj, ...(pose as object) } as TNode;\n}\n\nlet monotonicPasteCounter = 0;\nfunction defaultNextId(): string {\n  const c = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (c && typeof c.randomUUID === 'function') return c.randomUUID();\n  return `paste-${monotonicPasteCounter++}`;\n}\n\n/**\n * Synthesize a many-faceted adapter from a `useState`-array scene. Always\n * satisfies `MoveAdapter`, `ResizeAdapter`, `InsertAdapter`, and\n * `AreaSelectAdapter` via structural typing. Override individual methods by\n * spreading the result.\n *\n * `applyOps` is intentionally omitted — hooks fall back to the built-in\n * dispatcher (see `dispatchApplyBatch`). Apps with custom history\n * integration supply their own via spread.\n */\nexport function arrayAdapter<TNode extends { id: string }, TPose>(\n  config: ArrayAdapterConfig<TNode, TPose>,\n): ArrayAdapter<TNode, TPose> {\n  const {\n    ref,\n    setItems,\n    toPose,\n    fromPose = defaultFromPose,\n    getParent = () => null,\n    setParent = () => {},\n    getChildren,\n    selectionRef,\n    setSelection = () => {},\n    createDefault,\n    nextId = defaultNextId,\n    silhouette,\n  } = config;\n\n  const d = (config.poseDescriptor ?? RECT_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const getSelection = selectionRef ? () => selectionRef.current : () => [];\n\n  const takenBy = (region: SelectRegion, mode: LassoHitMode): string[] => {\n    const out: string[] = [];\n    for (const o of ref.current) {\n      const pose = toPose(o);\n      const b = regionBoundsOf(o, pose, poseDescriptorForNode(d, o) as PoseDescriptor<unknown>);\n      const outline = (): Path => silhouette?.(o, pose) ?? poseOutline(pose, b);\n      if (regionTakes(region, mode, pose, b, outline)) out.push(o.id);\n    }\n    return out;\n  };\n\n  // Root order is the item array's order, which this adapter owns — asking\n  // the consumer would get a callback written for node ids, and its `[]`\n  // is indistinguishable from \"the root has no children\".\n  const childrenIn = (items: readonly TNode[], parentId: string | null): string[] =>\n    parentId === null\n      ? items.filter((o) => getParent(o.id) === null).map((o) => o.id)\n      : getChildren?.(parentId) ?? [];\n\n  /** Where in `items` an insert at `index` lands, `undefined` to append. With\n   *  `getChildren` configured the ops hand over an ordinal among the node's\n   *  siblings, which is an array index only when nothing else sits between. */\n  const arrayIndexFor = (items: readonly TNode[], obj: TNode, index: number | undefined): number | undefined => {\n    if (index === undefined || index < 0) return undefined;\n    if (!getChildren) return index < items.length ? index : undefined;\n    const before = childrenIn(items, parentOf(obj)).filter((id) => id !== obj.id)[index];\n    const at = before === undefined ? -1 : items.findIndex((o) => o.id === before);\n    return at < 0 ? undefined : at;\n  };\n\n  const adapter: ArrayAdapter<TNode, TPose> = {\n    getNode: (id) => ref.current.find((o) => o.id === id),\n    getNodes: () => ref.current,\n    getPose: (id) => {\n      const obj = ref.current.find((o) => o.id === id);\n      if (!obj) throw new Error(`arrayAdapter.getPose: id \"${id}\" not found`);\n      return toPose(obj);\n    },\n    setPose: (id, pose) => {\n      setItems((items) => items.map((o) => (o.id === id ? fromPose(o, pose) : o)));\n    },\n    getParent,\n    setParent,\n\n    insertNode: (obj, index) => setItems((items) => {\n      const at = arrayIndexFor(items, obj, index);\n      if (at === undefined) return [...items, obj];\n      return [...items.slice(0, at), obj, ...items.slice(at)];\n    }),\n    removeNode: (id) => setItems((items) => items.filter((o) => o.id !== id)),\n\n    getSelection,\n    setSelection,\n\n    hitTestArea: (rect) => takenBy(rectRegion(rect), 'intersect'),\n\n    hitTestLasso: (polygon, mode: LassoHitMode) => {\n      const region = polygonRegion(polygon);\n      return region ? takenBy(region, mode) : [];\n    },\n\n    // Use a method shorthand so `this` is the call-site receiver, not the\n    // adapter we're building here. That way consumers can spread additional\n    // methods on top (e.g. `{ ...arrayAdapter(...), ...selection.adapterMethods }`)\n    // and `applyOps` will dispatch ops against the merged object.\n    applyOps(ops: Op[]) {\n      applyOpsTo(this, ops);\n    },\n\n    commitInsert: createDefault ? (b) => createDefault(b) : () => null,\n    commitPaste: (\n      clip: ClipboardSnapshot,\n      offset: { dx: number; dy: number },\n      ctx?: { dropPoint?: { worldX: number; worldY: number } },\n    ): TNode[] => {\n      const src = clip.items as TNode[];\n      if (src.length === 0) return [];\n\n      // Default translation = `offset`. When `dropPoint` is supplied, center\n      // the cluster's union AABB at the drop point — matches the\n      // `ClipboardDemo` reference wiring.\n      let dx = offset.dx;\n      let dy = offset.dy;\n      if (ctx?.dropPoint) {\n        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n        for (const n of src) {\n          const b = poseDescriptorForNode(d, n).getBounds(toPose(n));\n          if (b.x < minX) minX = b.x;\n          if (b.y < minY) minY = b.y;\n          if (b.x + b.width > maxX) maxX = b.x + b.width;\n          if (b.y + b.height > maxY) maxY = b.y + b.height;\n        }\n        // Defensive: if the descriptor returned nothing usable, fall back to offset.\n        if (Number.isFinite(minX) && Number.isFinite(minY)) {\n          const cx = (minX + maxX) / 2;\n          const cy = (minY + maxY) / 2;\n          dx = ctx.dropPoint.worldX - cx;\n          dy = ctx.dropPoint.worldY - cy;\n        }\n      }\n\n      // Deep-clone via JSON round-trip so the snapshot isn't mutated by\n      // downstream pose edits.\n      const out: TNode[] = [];\n      for (const n of src) {\n        const cloned = JSON.parse(JSON.stringify(n)) as TNode;\n        (cloned as { id: string }).id = nextId();\n        const translated = translatePoseViaDescriptor(\n          toPose(cloned), dx, dy, poseDescriptorForNode(d, cloned),\n        );\n        out.push(fromPose(cloned, translated));\n      }\n      return out;\n    },\n    snapshotSelection: (ids) => ({\n      items: ids\n        .map((id) => ref.current.find((o) => o.id === id))\n        .filter((o): o is TNode => !!o),\n    }),\n  };\n\n  if (getChildren) {\n    (adapter as ArrayAdapter<TNode, TPose> & {\n      getChildren: (parentId: string | null) => string[];\n    }).getChildren = (parentId) => childrenIn(ref.current, parentId);\n  }\n\n  return adapter;\n}\n"],"mappings":";;;;;AAuGA,SAASA,EACP,GACA,GACO;CACP,OAAO;EAAE,GAAGC;EAAK,GAAIC;CAAgB;AACvC;AAEA,IAAIC,IAAwB;AAC5B,SAASC,IAAwB;CAC/B,IAAMC,IAAK,WAA0D;CAErE,OADIA,KAAK,OAAOA,EAAE,cAAe,aAAmBA,EAAE,WAAW,IAC1D,SAAS;AAClB;AAYA,SAAgBC,EACd,GAC4B;CAC5B,IAAM,EACJ,QACA,aACA,WACA,cAAWN,GACX,qBAAkB,MAClB,qBAAkB,CAAC,GACnB,gBACA,iBACA,wBAAqB,CAAC,GACtB,kBACA,YAASI,GACT,kBACEG,GAEEC,IAAKD,EAAO,kBAAkBE,GAE9BC,IAAeC,UAAqBA,EAAa,gBAAgB,CAAC,GAElEC,KAAW,GAAsB,MAAiC;EACtE,IAAMC,IAAgB,CAAC;EACvB,KAAK,IAAMC,KAAKC,EAAI,SAAS;GAC3B,IAAMb,IAAOc,EAAOF,CAAC,GACfG,IAAIC,EAAeJ,GAAGZ,GAAMiB,EAAsBX,GAAGM,CAAC,CAA4B;GAExF,AAAIM,EAAYC,GAAQC,GAAMpB,GAAMe,SADRM,IAAaT,GAAGZ,CAAI,KAAKsB,EAAYtB,GAAMe,CAAC,CAC1B,KAAGJ,EAAI,KAAKC,EAAE,EAAE;EAChE;EACA,OAAOD;CACT,GAKMY,KAAc,GAAyB,MAC3CC,MAAa,OACTC,EAAM,QAAQ,MAAMC,EAAUd,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC,KAAK,MAAMA,EAAE,EAAE,IAC7De,IAAcH,CAAQ,KAAK,CAAC,GAK5BI,KAAiB,GAAyB,GAAY,MAAkD;EAC5G,IAAIC,MAAU,KAAA,KAAaA,IAAQ,GAAG;EACtC,IAAI,CAACF,GAAa,OAAOE,IAAQJ,EAAM,SAASI,IAAQ,KAAA;EACxD,IAAMC,IAASP,EAAWE,GAAOM,EAAShC,CAAG,CAAC,CAAC,CAAC,QAAQ,MAAOiC,MAAOjC,EAAI,EAAE,CAAC,CAAC8B,IACxEI,IAAKH,MAAW,KAAA,IAAY,KAAKL,EAAM,WAAW,MAAMb,EAAE,OAAOkB,CAAM;EAC7E,OAAOG,IAAK,IAAI,KAAA,IAAYA;CAC9B,GAEMC,IAAsC;EAC1C,UAAU,MAAOrB,EAAI,QAAQ,MAAM,MAAMD,EAAE,OAAOoB,CAAE;EACpD,gBAAgBnB,EAAI;EACpB,UAAU,MAAO;GACf,IAAMd,IAAMc,EAAI,QAAQ,MAAM,MAAMD,EAAE,OAAOoB,CAAE;GAC/C,IAAI,CAACjC,GAAK,MAAU,MAAM,6BAA6BiC,EAAG,YAAY;GACtE,OAAOlB,EAAOf,CAAG;EACnB;EACA,UAAU,GAAI,MAAS;GACrB,GAAU,MAAU0B,EAAM,KAAK,MAAOb,EAAE,OAAOoB,IAAKG,EAASvB,GAAGZ,CAAI,IAAIY,CAAE,CAAC;EAC7E;EACA;EACA;EAEA,aAAa,GAAK,MAAUwB,GAAU,MAAU;GAC9C,IAAMH,IAAKL,EAAcH,GAAO1B,GAAK8B,CAAK;GAE1C,OADII,MAAO,KAAA,IAAkB,CAAC,GAAGR,GAAO1B,CAAG,IACpC;IAAC,GAAG0B,EAAM,MAAM,GAAGQ,CAAE;IAAGlC;IAAK,GAAG0B,EAAM,MAAMQ,CAAE;GAAC;EACxD,CAAC;EACD,aAAa,MAAOG,GAAU,MAAUX,EAAM,QAAQ,MAAMb,EAAE,OAAOoB,CAAE,CAAC;EAExE;EACA;EAEA,cAAc,MAAStB,EAAQ2B,EAAWC,CAAI,GAAG,WAAW;EAE5D,eAAe,GAAS,MAAuB;GAC7C,IAAMnB,IAASoB,EAAcC,CAAO;GACpC,OAAOrB,IAAST,EAAQS,GAAQC,CAAI,IAAI,CAAC;EAC3C;EAMA,SAAS,GAAW;GAClB,EAAW,MAAMqB,CAAG;EACtB;EAEA,cAAcC,KAAiB,MAAMA,EAAc3B,CAAC,UAAU;EAC9D,cACE,GACA,GACA,MACY;GACZ,IAAM4B,IAAMC,EAAK;GACjB,IAAID,EAAI,WAAW,GAAG,OAAO,CAAC;GAK9B,IAAIE,IAAKC,EAAO,IACZC,IAAKD,EAAO;GAChB,IAAIE,GAAK,WAAW;IAClB,IAAIC,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;IAC/D,KAAK,IAAMC,KAAKV,GAAK;KACnB,IAAM5B,IAAIE,EAAsBX,GAAG+C,CAAC,CAAC,CAAC,UAAUvC,EAAOuC,CAAC,CAAC;KAIzD,AAHItC,EAAE,IAAIkC,MAAM,IAAOlC,EAAE,IACrBA,EAAE,IAAImC,MAAM,IAAOnC,EAAE,IACrBA,EAAE,IAAIA,EAAE,QAAQoC,MAAM,IAAOpC,EAAE,IAAIA,EAAE,QACrCA,EAAE,IAAIA,EAAE,SAASqC,MAAM,IAAOrC,EAAE,IAAIA,EAAE;IAC5C;IAEA,IAAI,OAAO,SAASkC,CAAI,KAAK,OAAO,SAASC,CAAI,GAAG;KAClD,IAAMI,KAAML,IAAOE,KAAQ,GACrBI,KAAML,IAAOE,KAAQ;KAE3B,AADA,IAAKJ,EAAI,UAAU,SAASM,GAC5B,IAAKN,EAAI,UAAU,SAASO;IAC9B;GACF;GAIA,IAAM5C,IAAe,CAAC;GACtB,KAAK,IAAM0C,KAAKV,GAAK;IACnB,IAAMa,IAAS,KAAK,MAAM,KAAK,UAAUH,CAAC,CAAC;IAC3C,EAA2B,KAAKI,EAAO;IACvC,IAAMC,IAAaC,EACjB7C,EAAO0C,CAAM,GAAGX,GAAIE,GAAI9B,EAAsBX,GAAGkD,CAAM,CACzD;IACA,EAAI,KAAKrB,EAASqB,GAAQE,CAAU,CAAC;GACvC;GACA,OAAO/C;EACT;EACA,oBAAoB,OAAS,EAC3B,OAAOiD,EACJ,KAAK,MAAO/C,EAAI,QAAQ,MAAM,MAAMD,EAAE,OAAOoB,CAAE,CAAC,CAAC,CACjD,QAAQ,MAAkB,CAAC,CAACpB,CAAC,EAClC;CACF;CAQA,OANIe,MACF,EAEG,eAAe,MAAaJ,EAAWV,EAAI,SAASW,CAAQ,IAG1DU;AACT"}

package/dist/core/adapters/useArrayAdapter.js

@@ -1,13 +0,0 @@
-import { arrayAdapter as e } from "./arrayAdapter.js";
-//#region src/core/adapters/useArrayAdapter.ts
-function t(t) {
-	let { items: n, ...r } = t;
-	return e({
-		ref: { current: n },
-		...r
-	});
-}
-//#endregion
-export { t as useArrayAdapter };
-
-//# sourceMappingURL=useArrayAdapter.js.map

package/dist/core/adapters/useArrayAdapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useArrayAdapter.js","names":["useArrayAdapter","rest","options","arrayAdapter","items"],"sources":["../../../src/core/adapters/useArrayAdapter.ts"],"sourcesContent":["import { arrayAdapter, type ArrayAdapter, type ArrayAdapterConfig } from './arrayAdapter';\n\n/** Options for `useArrayAdapter` — same shape as `ArrayAdapterConfig` minus the\n *  `ref` field, which the hook manages internally from `items`. */\nexport type UseArrayAdapterOptions<TNode extends { id: string }, TPose> =\n  Omit<ArrayAdapterConfig<TNode, TPose>, 'ref' | 'setItems'> & {\n    items: TNode[];\n    setItems: ArrayAdapterConfig<TNode, TPose>['setItems'];\n  };\n\n/** Hook wrapper around `arrayAdapter` over this render's `items`. Eliminates\n *  the `useRef + ref.current = items` boilerplate every flat-list scene needs.\n *  Returns a fresh adapter each render, reading that render's items — so an\n *  adapter a render reads from sees its own items, and the gesture hooks, which\n *  hold the latest committed adapter, see the committed ones. */\nexport function useArrayAdapter<TNode extends { id: string }, TPose>(\n  options: UseArrayAdapterOptions<TNode, TPose>,\n): ArrayAdapter<TNode, TPose> {\n  const { items, ...rest } = options;\n  return arrayAdapter<TNode, TPose>({ ref: { current: items }, ...rest });\n}\n"],"mappings":";;AAeA,SAAgBA,EACd,GAC4B;CAC5B,IAAM,EAAE,UAAO,GAAGC,MAASC;CAC3B,OAAOC,EAA2B;EAAE,KAAK,EAAE,SAASC,EAAM;EAAG,GAAGH;CAAK,CAAC;AACxE"}

package/dist/core/fillInPoseFrame.js

@@ -1,102 +0,0 @@
-import { getPaintKind as e } from "./paintKinds.js";
-//#region src/core/fillInPoseFrame.ts
-function t(t, n) {
-	if (!a(t)) return e(t.fill)?.inPoseFrame?.(t, n) ?? t;
-	if (r(t)) {
-		let e = t.origin ?? {
-			x: 0,
-			y: 0
-		};
-		return {
-			...t,
-			origin: {
-				x: n.x + e.x,
-				y: n.y + e.y
-			},
-			units: "local"
-		};
-	}
-	if (!i(t)) return t;
-	let o = (e) => ({
-		x: n.x + e.x * n.width,
-		y: n.y + e.y * n.height
-	});
-	if (t.fill === "linear-gradient") return {
-		...t,
-		from: o(t.from),
-		to: o(t.to),
-		units: "local"
-	};
-	if (t.fill === "radial-gradient") {
-		let e = Math.hypot(n.width, n.height) / Math.SQRT2;
-		return {
-			...t,
-			center: o(t.center),
-			radius: t.radius * e,
-			units: "local"
-		};
-	}
-	return {
-		...t,
-		center: o(t.center),
-		units: "local"
-	};
-}
-function n(t, n) {
-	if (!a(t)) return e(t.fill)?.toBoundsFrame?.(t, n) ?? t;
-	if (t.fill === "pattern") {
-		let e = t.origin ?? {
-			x: 0,
-			y: 0
-		};
-		return {
-			...t,
-			origin: {
-				x: e.x - n.x,
-				y: e.y - n.y
-			},
-			units: "bounds"
-		};
-	}
-	if (t.fill !== "linear-gradient" && t.fill !== "radial-gradient" && t.fill !== "conic-gradient" || n.width === 0 || n.height === 0) return t;
-	let r = (e) => ({
-		x: (e.x - n.x) / n.width,
-		y: (e.y - n.y) / n.height
-	});
-	if (t.fill === "linear-gradient") return {
-		...t,
-		from: r(t.from),
-		to: r(t.to),
-		units: "bounds"
-	};
-	if (t.fill === "radial-gradient") {
-		let e = Math.hypot(n.width, n.height) / Math.SQRT2;
-		return {
-			...t,
-			center: r(t.center),
-			radius: t.radius / e,
-			units: "bounds"
-		};
-	}
-	return {
-		...t,
-		center: r(t.center),
-		units: "bounds"
-	};
-}
-function r(e) {
-	return e.fill === "pattern" && e.units === "bounds";
-}
-function i(e) {
-	if (e === void 0) return !1;
-	let t = e.fill;
-	return t !== "linear-gradient" && t !== "radial-gradient" && t !== "conic-gradient" ? !1 : e.units === "bounds";
-}
-function a(e) {
-	let t = e.fill ?? "solid";
-	return t === "solid" || t === "pattern" || t === "linear-gradient" || t === "radial-gradient" || t === "conic-gradient";
-}
-//#endregion
-export { t as fillInPoseFrame, n as fillToBoundsFrame };
-
-//# sourceMappingURL=fillInPoseFrame.js.map

package/dist/core/fillInPoseFrame.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fillInPoseFrame.js","names":["fillInPoseFrame","isBuiltinKind","fill","getPaintKind","box","isBoundsPattern","o","isBoundsGradient","toBox","p","scale","fillToBoundsFrame","fromBox","kind"],"sources":["../../src/core/fillInPoseFrame.ts"],"sourcesContent":["/**\n * Resolve a `units: 'bounds'` gradient into the frame its node is painted in.\n *\n * Node painters bake the pose into their geometry (`pathInPoseFrame`) rather\n * than emitting a per-node transform, so by the time the renderer sees a\n * scene node there is no node-local space left for a gradient to refer to.\n * This is the paint-side counterpart: it maps box-relative gradient geometry\n * onto the same box the path was just projected into, so the two arrive in\n * the renderer in one frame.\n */\n\nimport type { FillStyle, GradientFill, PosedFill } from '@weasel-js/paint';\nimport { getPaintKind } from './paintKinds';\n\n/** The box a `'bounds'` gradient's normalized geometry is mapped onto —\n *  usually a node's bounds. */\nexport interface FillPoseBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Map a `'bounds'` gradient's `0..1` geometry onto `box`, returning it in the\n * box's own frame (`units: 'local'`). Any other fill — solid, pattern, or a\n * gradient in another space — is returned untouched.\n *\n * Radii scale by the box's normalized diagonal, SVG's rule for a percentage\n * radius against `objectBoundingBox`: `sqrt(w² + h²) / sqrt(2)`, which is\n * exactly `w` for a square box. The renderer's radial gradient is circular,\n * so a non-square box cannot make it the ellipse SVG would — this keeps the\n * radius proportionate instead.\n */\nexport function fillInPoseFrame(fill: FillStyle, box: FillPoseBox): PosedFill {\n  if (!isBuiltinKind(fill)) {\n    return (getPaintKind(fill.fill)?.inPoseFrame?.(fill, box) ?? fill) as PosedFill;\n  }\n  if (isBoundsPattern(fill)) {\n    const o = fill.origin ?? { x: 0, y: 0 };\n    return { ...fill, origin: { x: box.x + o.x, y: box.y + o.y }, units: 'local' as const };\n  }\n  if (!isBoundsGradient(fill)) return fill as PosedFill;\n\n  const toBox = (p: { x: number; y: number }): { x: number; y: number } => ({\n    x: box.x + p.x * box.width,\n    y: box.y + p.y * box.height,\n  });\n\n  if (fill.fill === 'linear-gradient') {\n    return { ...fill, from: toBox(fill.from), to: toBox(fill.to), units: 'local' as const };\n  }\n  if (fill.fill === 'radial-gradient') {\n    const scale = Math.hypot(box.width, box.height) / Math.SQRT2;\n    return { ...fill, center: toBox(fill.center), radius: fill.radius * scale, units: 'local' as const };\n  }\n  return { ...fill, center: toBox(fill.center), units: 'local' as const };\n}\n\n/**\n * Inverse of {@link fillInPoseFrame}: express a gradient already positioned\n * in `box`'s frame as `0..1` fractions of that box (`units: 'bounds'`), so\n * it follows the node when moved or resized.\n *\n * The importer's counterpart — SVG `userSpaceOnUse` coordinates arrive in\n * page space, and normalizing them here makes an imported gradient behave\n * exactly like one drawn in the app.\n *\n * A zero-width or zero-height box has no frame to normalize against; the\n * fill is returned untouched rather than divided by zero.\n */\nexport function fillToBoundsFrame(fill: FillStyle, box: FillPoseBox): FillStyle {\n  if (!isBuiltinKind(fill)) {\n    return getPaintKind(fill.fill)?.toBoundsFrame?.(fill, box) ?? fill;\n  }\n  if (fill.fill === 'pattern') {\n    const o = fill.origin ?? { x: 0, y: 0 };\n    return { ...fill, origin: { x: o.x - box.x, y: o.y - box.y }, units: 'bounds' as const };\n  }\n  const isGradient = fill.fill === 'linear-gradient'\n    || fill.fill === 'radial-gradient'\n    || fill.fill === 'conic-gradient';\n  if (!isGradient) return fill;\n  if (box.width === 0 || box.height === 0) return fill;\n\n  const fromBox = (p: { x: number; y: number }): { x: number; y: number } => ({\n    x: (p.x - box.x) / box.width,\n    y: (p.y - box.y) / box.height,\n  });\n\n  if (fill.fill === 'linear-gradient') {\n    return { ...fill, from: fromBox(fill.from), to: fromBox(fill.to), units: 'bounds' as const };\n  }\n  if (fill.fill === 'radial-gradient') {\n    const scale = Math.hypot(box.width, box.height) / Math.SQRT2;\n    return { ...fill, center: fromBox(fill.center), radius: fill.radius / scale, units: 'bounds' as const };\n  }\n  return { ...fill, center: fromBox(fill.center), units: 'bounds' as const };\n}\n\n/** True when this fill is a pattern anchored to the painted node's box.\n *  Rebasing it is a translation only — a resize must reveal more tiles, not\n *  stretch them, which is the whole reason patterns get their own branch. */\nfunction isBoundsPattern(\n  fill: FillStyle,\n): fill is Extract<FillStyle, { fill: 'pattern' }> {\n  return fill.fill === 'pattern' && fill.units === 'bounds';\n}\n\n/** True when this fill is a gradient declaring box-relative geometry. */\nfunction isBoundsGradient(fill: FillStyle | undefined): fill is GradientFill {\n  if (fill === undefined) return false;\n  const kind = fill.fill;\n  if (kind !== 'linear-gradient' && kind !== 'radial-gradient' && kind !== 'conic-gradient') {\n    return false;\n  }\n  return fill.units === 'bounds';\n}\n\n/** The five kinds whose frame conversion is written above. Anything else is a\n *  registered kind and converts through its own entry. */\nfunction isBuiltinKind(fill: FillStyle): boolean {\n  const kind = fill.fill ?? 'solid';\n  return kind === 'solid' || kind === 'pattern'\n    || kind === 'linear-gradient' || kind === 'radial-gradient' || kind === 'conic-gradient';\n}\n"],"mappings":"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"}