@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/useSurfaceSize.js

@@ -0,0 +1,43 @@
+import { useElementSize } from "../core/viewport/useCanvasSize.js";
+import { useLayoutEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useSurfaceSize.ts
+var NO_ELEMENT = { current: null };
+/**
+* The CSS-pixel size a canvas host paints at: its `width` and `height`, with
+* an axis left out measured off `element`, which fills its parent on it.
+*/
+function useSurfaceSize(props, element) {
+	const fills = props.width === void 0 || props.height === void 0;
+	const measured = useElementSize(fills ? element : NO_ELEMENT);
+	const width = props.width ?? measured.width;
+	const height = props.height ?? measured.height;
+	const onResize = useLatest(props.onResize);
+	const reported = useRef(null);
+	useLayoutEffect(() => {
+		if (width === 0 || height === 0) return;
+		const was = reported.current;
+		if (was && was.width === width && was.height === height) return;
+		reported.current = {
+			width,
+			height
+		};
+		onResize.current?.({
+			width,
+			height
+		});
+	}, [
+		width,
+		height,
+		onResize
+	]);
+	return {
+		width,
+		height
+	};
+}
+
+//#endregion
+export { useSurfaceSize };
+//# sourceMappingURL=useSurfaceSize.js.map

package/dist/canvas/useSurfaceSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSurfaceSize.js","names":[],"sources":["../../src/canvas/useSurfaceSize.ts"],"sourcesContent":["import { useLayoutEffect, useRef, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { CanvasSize } from 'core/viewport/clampView';\nimport { useElementSize } from 'core/viewport/useCanvasSize';\n\n/** The size props every canvas host takes. */\nexport interface SurfaceSizeProps {\n  /** CSS-pixel width. Omit it, or `height`, and the element fills its parent\n   *  on that axis and is measured: the parent's box decides the size, and the\n   *  canvas adds nothing to it, so the parent needs a size of its own. Nothing\n   *  paints until the measurement lands. */\n  width?: number;\n  /** CSS-pixel height. Omit it to fill, as `width`. */\n  height?: number;\n  /** Every size the surface takes, once at mount and again on each change —\n   *  the measured one for an axis left to fill. */\n  onResize?: (size: CanvasSize) => void;\n}\n\nconst NO_ELEMENT: RefObject<HTMLElement | null> = { current: null };\n\n/**\n * The CSS-pixel size a canvas host paints at: its `width` and `height`, with\n * an axis left out measured off `element`, which fills its parent on it.\n */\nexport function useSurfaceSize(props: SurfaceSizeProps, element: RefObject<HTMLElement | null>): CanvasSize {\n  const fills = props.width === undefined || props.height === undefined;\n  const measured = useElementSize(fills ? element : NO_ELEMENT);\n  const width = props.width ?? measured.width;\n  const height = props.height ?? measured.height;\n\n  const onResize = useLatest(props.onResize);\n  const reported = useRef<CanvasSize | null>(null);\n  useLayoutEffect(() => {\n    // A filling axis reads 0 until measured, and that is no size to report.\n    if (width === 0 || height === 0) return;\n    const was = reported.current;\n    if (was && was.width === width && was.height === height) return;\n    reported.current = { width, height };\n    onResize.current?.({ width, height });\n  }, [width, height, onResize]);\n\n  return { width, height };\n}\n"],"mappings":";;;;;AAmBA,IAAM,aAA4C,EAAE,SAAS,KAAK;;;;;AAMlE,SAAgB,eAAe,OAAyB,SAAoD;CAC1G,MAAM,QAAQ,MAAM,UAAU,UAAa,MAAM,WAAW;CAC5D,MAAM,WAAW,eAAe,QAAQ,UAAU,UAAU;CAC5D,MAAM,QAAQ,MAAM,SAAS,SAAS;CACtC,MAAM,SAAS,MAAM,UAAU,SAAS;CAExC,MAAM,WAAW,UAAU,MAAM,QAAQ;CACzC,MAAM,WAAW,OAA0B,IAAI;CAC/C,sBAAsB;EAEpB,IAAI,UAAU,KAAK,WAAW,GAAG;EACjC,MAAM,MAAM,SAAS;EACrB,IAAI,OAAO,IAAI,UAAU,SAAS,IAAI,WAAW,QAAQ;EACzD,SAAS,UAAU;GAAE;GAAO;EAAO;EACnC,SAAS,UAAU;GAAE;GAAO;EAAO,CAAC;CACtC,GAAG;EAAC;EAAO;EAAQ;CAAQ,CAAC;CAE5B,OAAO;EAAE;EAAO;CAAO;AACzB"}

package/dist/canvas/useToolCursor.js

@@ -1,29 +1,38 @@
-import { useLayoutEffect as e } from "react";
-import { resolveCursorTier as t } from "@weasel-js/cursor";
+import { useLayoutEffect } from "react";
+import { resolveCursorTier } from "@weasel-js/cursor";
+
 //#region src/canvas/useToolCursor.ts
-function n(e) {
-	let n = e.hotkeyEngaged ?? e.active, r = n === null ? void 0 : e.registry[n];
-	if (r?.cursor) {
-		if (typeof r.cursor != "function") return t(r.cursor);
-		try {
-			return t(r.cursor());
-		} catch {
-			return;
-		}
+function resolveToolsCursor(tools) {
+	const id = tools.hotkeyEngaged ?? tools.active;
+	const tool = id === null ? void 0 : tools.registry[id];
+	if (!tool?.cursor) return void 0;
+	if (typeof tool.cursor !== "function") return resolveCursorTier(tool.cursor);
+	try {
+		return resolveCursorTier(tool.cursor());
+	} catch {
+		return;
 	}
 }
-function r(t, r, i, a) {
-	let o = r ? n(r) : void 0, s = o === void 0 ? "" : o.kind === "css" ? `css|${o.css}` : `${o.glyph}|${o.angle}|${o.size}|${o.worldRadius}`;
-	e(() => {
-		t.setBase(o ?? null, a ?? "");
+/**
+* Writes the active tool's cursor to `sink` as its base, and `rest` (the
+* element's own cursor) for when the tool declares none.
+*
+* `element` is what the sink writes to, named so the base is written again
+* when a detached surface's input element arrives a render late.
+*/
+function useToolCursor(sink, tools, element, rest) {
+	const tier = tools ? resolveToolsCursor(tools) : void 0;
+	const key = tier === void 0 ? "" : tier.kind === "css" ? `css|${tier.css}` : `${tier.glyph}|${tier.angle}|${tier.size}|${tier.worldRadius}`;
+	useLayoutEffect(() => {
+		sink.setBase(tier ?? null, rest ?? "");
 	}, [
-		t,
-		s,
-		i,
-		a
+		sink,
+		key,
+		element,
+		rest
 	]);
 }
-//#endregion
-export { r as useToolCursor };
 
+//#endregion
+export { useToolCursor };
 //# sourceMappingURL=useToolCursor.js.map

package/dist/canvas/useToolCursor.js.map

@@ -1 +1 @@
-{"version":3,"file":"useToolCursor.js","names":["resolveToolsCursor","id","tools","tool","resolveCursorTier","useToolCursor","tier","key","rest","sink","element"],"sources":["../../src/canvas/useToolCursor.ts"],"sourcesContent":["import { useLayoutEffect } from 'react';\nimport { resolveCursorTier, type CursorSink, type ResolvedCursor } from '@weasel-js/cursor';\nimport type { ToolsApi } from '../tools/overlayBinding';\n\nfunction resolveToolsCursor(tools: ToolsApi): ResolvedCursor | undefined {\n  const id = tools.hotkeyEngaged ?? tools.active;\n  const tool = id === null ? undefined : tools.registry[id];\n  if (!tool?.cursor) return undefined;\n  if (typeof tool.cursor !== 'function') return resolveCursorTier(tool.cursor);\n  try {\n    return resolveCursorTier(tool.cursor());\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Writes the active tool's cursor to `sink` as its base, and `rest` (the\n * element's own cursor) for when the tool declares none.\n *\n * `element` is what the sink writes to, named so the base is written again\n * when a detached surface's input element arrives a render late.\n */\nexport function useToolCursor(\n  sink: CursorSink,\n  tools: ToolsApi | undefined,\n  element: HTMLElement | null | undefined,\n  rest: string | undefined,\n): void {\n  const tier = tools ? resolveToolsCursor(tools) : undefined;\n  // Keyed on the value, not the object: the tier is rebuilt every render.\n  const key = tier === undefined\n    ? ''\n    : tier.kind === 'css'\n      ? `css|${tier.css}`\n      : `${tier.glyph}|${tier.angle}|${tier.size}|${tier.worldRadius}`;\n  useLayoutEffect(() => {\n    sink.setBase(tier ?? null, rest ?? '');\n    // `tier` is a fresh object each render; the key is its identity.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [sink, key, element, rest]);\n}\n"],"mappings":";;;AAIA,SAASA,EAAmB,GAA6C;CACvE,IAAMC,IAAKC,EAAM,iBAAiBA,EAAM,QAClCC,IAAOF,MAAO,OAAO,KAAA,IAAYC,EAAM,SAASD;CACtD,IAAKE,GAAM,QACX;MAAI,OAAOA,EAAK,UAAW,YAAY,OAAOC,EAAkBD,EAAK,MAAM;EAC3E,IAAI;GACF,OAAOC,EAAkBD,EAAK,OAAO,CAAC;EACxC,QAAQ;GACN;EACF;CAL2E;AAM7E;AASA,SAAgBE,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAOJ,IAAQF,EAAmBE,CAAK,IAAI,KAAA,GAE3CK,IAAMD,MAAS,KAAA,IACjB,KACAA,EAAK,SAAS,QACZ,OAAOA,EAAK,QACZ,GAAGA,EAAK,MAAM,GAAGA,EAAK,MAAM,GAAGA,EAAK,KAAK,GAAGA,EAAK;CACvD,QAAsB;EACpB,EAAK,QAAQA,KAAQ,MAAME,KAAQ,EAAE;CAGvC,GAAG;EAACC;EAAMF;EAAKG;EAASF;CAAI,CAAC;AAC/B"}
+{"version":3,"file":"useToolCursor.js","names":[],"sources":["../../src/canvas/useToolCursor.ts"],"sourcesContent":["import { useLayoutEffect } from 'react';\nimport { resolveCursorTier, type CursorSink, type ResolvedCursor } from '@weasel-js/cursor';\nimport type { ToolsApi } from '../tools/overlayBinding';\n\nfunction resolveToolsCursor(tools: ToolsApi): ResolvedCursor | undefined {\n  const id = tools.hotkeyEngaged ?? tools.active;\n  const tool = id === null ? undefined : tools.registry[id];\n  if (!tool?.cursor) return undefined;\n  if (typeof tool.cursor !== 'function') return resolveCursorTier(tool.cursor);\n  try {\n    return resolveCursorTier(tool.cursor());\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Writes the active tool's cursor to `sink` as its base, and `rest` (the\n * element's own cursor) for when the tool declares none.\n *\n * `element` is what the sink writes to, named so the base is written again\n * when a detached surface's input element arrives a render late.\n */\nexport function useToolCursor(\n  sink: CursorSink,\n  tools: ToolsApi | undefined,\n  element: HTMLElement | null | undefined,\n  rest: string | undefined,\n): void {\n  const tier = tools ? resolveToolsCursor(tools) : undefined;\n  // Keyed on the value, not the object: the tier is rebuilt every render.\n  const key = tier === undefined\n    ? ''\n    : tier.kind === 'css'\n      ? `css|${tier.css}`\n      : `${tier.glyph}|${tier.angle}|${tier.size}|${tier.worldRadius}`;\n  useLayoutEffect(() => {\n    sink.setBase(tier ?? null, rest ?? '');\n    // `tier` is a fresh object each render; the key is its identity.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [sink, key, element, rest]);\n}\n"],"mappings":";;;;AAIA,SAAS,mBAAmB,OAA6C;CACvE,MAAM,KAAK,MAAM,iBAAiB,MAAM;CACxC,MAAM,OAAO,OAAO,OAAO,SAAY,MAAM,SAAS;CACtD,IAAI,CAAC,MAAM,QAAQ,OAAO;CAC1B,IAAI,OAAO,KAAK,WAAW,YAAY,OAAO,kBAAkB,KAAK,MAAM;CAC3E,IAAI;EACF,OAAO,kBAAkB,KAAK,OAAO,CAAC;CACxC,QAAQ;EACN;CACF;AACF;;;;;;;;AASA,SAAgB,cACd,MACA,OACA,SACA,MACM;CACN,MAAM,OAAO,QAAQ,mBAAmB,KAAK,IAAI;CAEjD,MAAM,MAAM,SAAS,SACjB,KACA,KAAK,SAAS,QACZ,OAAO,KAAK,QACZ,GAAG,KAAK,MAAM,GAAG,KAAK,MAAM,GAAG,KAAK,KAAK,GAAG,KAAK;CACvD,sBAAsB;EACpB,KAAK,QAAQ,QAAQ,MAAM,QAAQ,EAAE;CAGvC,GAAG;EAAC;EAAM;EAAK;EAAS;CAAI,CAAC;AAC/B"}

package/dist/canvas/useViewHelpers.js

@@ -1,81 +1,132 @@
-import { unionAABB as e } from "../core/geometry/unionBounds.js";
-import { framedBounds as t } from "../core/geometry/poseDescriptor.js";
-import { buildChromeState as n } from "../core/selection/chromeState.js";
-import { useCallback as r, useMemo as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
+import { unionAABB } from "../core/geometry/unionBounds.js";
+import { framedBounds } from "../core/geometry/poseDescriptor.js";
+import { buildChromeState } from "../core/selection/chromeState.js";
+import { drawnBoundsOf } from "./drawnBounds.js";
+import { useCallback, useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/useViewHelpers.ts
-var o = () => {}, s = () => !0;
-function c(e, t) {
-	return typeof e.getWorldPose == "function" ? e.getWorldPose(t) : e.getPose(t);
+var noOpUnsubscribe = () => {};
+var alwaysVisible = () => true;
+function worldPoseOf(adapter, id) {
+	return typeof adapter.getWorldPose === "function" ? adapter.getWorldPose(id) : adapter.getPose(id);
 }
-function l(l) {
-	let { adapter: u, geometry: d, boundsOf: f, boundsOfPose: p, selection: m, gestureSource: h, previewPoseExtra: g, getIsVisible: _ } = l, v = r((e, n) => p ? p(e, n) : t(n, d), [p, d]), y = i(() => {
-		if (f) return f;
-		if (u) return (e) => {
+/**
+* Build one view's overlay-aware state: its chrome and the lookups its layers
+* draw and hit-test against. A canvas with N views mounts N components each
+* calling this once.
+*/
+function useViewHelpers(opts) {
+	const { adapter, geometry, boundsOf, boundsOfPose, nodes, getScale, selection, gestureSource, previewPoseExtra, getIsVisible, layerIsPainted } = opts;
+	const getScaleRef = useLatest(getScale);
+	const poseBoxOf = useCallback((id, pose) => {
+		if (!nodes) return framedBounds(pose, geometry);
+		const scale = getScaleRef.current?.();
+		return drawnBoundsOf(nodes, id, pose, {
+			descriptor: geometry,
+			...adapter ? { worldPoseOf: (m) => worldPoseOf(adapter, m) } : {},
+			...scale ? { scale } : {}
+		});
+	}, [
+		nodes,
+		geometry,
+		adapter,
+		getScaleRef
+	]);
+	const boxOf = useCallback((id, pose) => boundsOfPose ? boundsOfPose(id, pose) : poseBoxOf(id, pose), [boundsOfPose, poseBoxOf]);
+	const baseBoundsOf = useMemo(() => {
+		if (boundsOf) return boundsOf;
+		if (!adapter) return void 0;
+		return (id) => {
 			try {
-				return t(c(u, e), d);
+				return poseBoxOf(id, worldPoseOf(adapter, id));
 			} catch {
 				return null;
 			}
 		};
 	}, [
-		f,
-		u,
-		d
-	]), b = r((e) => {
-		if (!u) return null;
+		boundsOf,
+		adapter,
+		poseBoxOf
+	]);
+	const committedPoseOf = useCallback((id) => {
+		if (!adapter) return null;
 		try {
-			return c(u, e);
+			return worldPoseOf(adapter, id);
 		} catch {
 			return null;
 		}
-	}, [u]), x = m.length > 1, S = a(g), C = i(() => f ?? y, [f, y]), w = r((e) => S.current?.(e) ?? null, [S]), T = r((e) => {
-		let t = w(e);
-		return t == null ? null : v(e, t);
-	}, [w, v]), E = r((e) => T(e) || (C ? C(e) : null), [T, C]), D = i(() => n({
-		selection: m,
-		multiActive: x,
-		effectiveBoundsOf: E,
+	}, [adapter]);
+	const multiActive = selection.length > 1;
+	const previewPoseExtraRef = useLatest(previewPoseExtra);
+	const effectiveBoundsOf = useMemo(() => boundsOf ?? baseBoundsOf, [boundsOf, baseBoundsOf]);
+	const previewPoseOf = useCallback((id) => {
+		const p = previewPoseExtraRef.current?.(id);
+		return p != null ? p : null;
+	}, [previewPoseExtraRef]);
+	const previewBoundsOf = useCallback((id) => {
+		const p = previewPoseOf(id);
+		return p != null ? boxOf(id, p) : null;
+	}, [previewPoseOf, boxOf]);
+	/**
+	* Bounds for `id` with any in-flight gesture folded in — what the user can
+	* see, not what is committed. Both the chrome state and the layer helpers
+	* answer bounds questions with this, so resize handles cannot end up a frame
+	* away from the shape they belong to.
+	*/
+	const boundsWithPreview = useCallback((id) => {
+		const previewed = previewBoundsOf(id);
+		if (previewed) return previewed;
+		return effectiveBoundsOf ? effectiveBoundsOf(id) : null;
+	}, [previewBoundsOf, effectiveBoundsOf]);
+	const chromeState = useMemo(() => buildChromeState({
+		selection,
+		multiActive,
+		effectiveBoundsOf: boundsWithPreview,
 		modifiers: {
-			alt: !1,
-			shift: !1,
-			meta: !1,
-			ctrl: !1
+			alt: false,
+			shift: false,
+			meta: false,
+			ctrl: false
 		},
-		canRotate: (e) => {
-			if (!d.supportsRotation) return !0;
-			let t = b(e);
-			return t == null || d.supportsRotation(t);
-		}
+		canRotate: (id) => {
+			if (!geometry.supportsRotation) return true;
+			const pose = committedPoseOf(id);
+			if (pose == null) return true;
+			return geometry.supportsRotation(pose);
+		},
+		...layerIsPainted ? { layerIsPainted } : {},
+		...adapter?.getNode ? { layerOf: (id) => adapter.getNode?.(id)?.layer } : {}
 	}), [
-		m,
-		x,
-		E,
-		d,
-		b
+		selection,
+		multiActive,
+		boundsWithPreview,
+		geometry,
+		committedPoseOf,
+		layerIsPainted,
+		adapter
 	]);
-	return {
-		helpers: {
-			getEffectivePose: (e) => w(e) ?? b(e),
-			getEffectiveBounds: E,
-			getGestureBounds: () => {
-				let t = [];
-				for (let e of new Set(h?.ids() ?? [])) t.push(T(e));
-				let n = h?.bounds();
-				if (n) for (let e of n) t.push(e);
-				return e(t);
-			},
-			subscribeGestures: (e) => h?.subscribe(e) ?? o,
-			getGestureVersion: () => h?.getVersion() ?? 0,
-			getChromeState: () => D,
-			getPreviewSources: () => h?.previewSources() ?? [],
-			getGestureOverlays: () => h?.overlays() ?? [],
-			getIsVisible: () => _?.() ?? s
+	return { helpers: {
+		getEffectivePose: (id) => {
+			return previewPoseOf(id) ?? committedPoseOf(id);
+		},
+		getEffectiveBounds: boundsWithPreview,
+		getGestureBounds: () => {
+			const parts = [];
+			for (const id of new Set(gestureSource?.ids() ?? [])) parts.push(previewBoundsOf(id));
+			const extraBounds = gestureSource?.bounds();
+			if (extraBounds) for (const b of extraBounds) parts.push(b);
+			return unionAABB(parts);
 		},
-		chromeState: D
-	};
+		subscribeGestures: (fn) => gestureSource?.subscribe(fn) ?? noOpUnsubscribe,
+		getGestureVersion: () => gestureSource?.getVersion() ?? 0,
+		getChromeState: () => chromeState,
+		getPreviewSources: () => gestureSource?.previewSources() ?? [],
+		getGestureOverlays: () => gestureSource?.overlays() ?? [],
+		getIsVisible: () => getIsVisible?.() ?? alwaysVisible
+	} };
 }
-//#endregion
-export { l as useViewHelpers };
 
+//#endregion
+export { useViewHelpers };
 //# sourceMappingURL=useViewHelpers.js.map

package/dist/canvas/useViewHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"useViewHelpers.js","names":["noOpUnsubscribe","alwaysVisible","worldPoseOf","adapter","id","useViewHelpers","opts","boxOf","useCallback","boundsOfPose","pose","framedBounds","geometry","baseBoundsOf","useMemo","boundsOf","committedPoseOf","multiActive","selection","previewPoseExtraRef","useLatest","previewPoseExtra","effectiveBoundsOf","previewPoseOf","previewBoundsOf","p","boundsWithPreview","chromeState","buildChromeState","parts","gestureSource","extraBounds","b","unionAABB","fn","getIsVisible"],"sources":["../../src/canvas/useViewHelpers.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { useLatest } from '@weasel-js/react';\nimport type { GestureSource, GesturePreviewSource } from './gestureBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { buildChromeState, type ChromeState } from 'core/selection/chromeState';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { NodeId } from 'core/scene/types';\nimport type { DebugSink } from '../debug/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\nconst noOpUnsubscribe = (): void => {};\n\nconst alwaysVisible = (): boolean => true;\n\n/**\n * The half of {@link CanvasHelpers} that belongs to one view — everything\n * answered by a camera's own tools, gestures and selection. A canvas hosting\n * several viewports needs one of these per view; the surface half is shared.\n */\nexport interface CanvasViewHelpers<TPose> {\n  /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,\n   *  otherwise the committed pose from the adapter. Returns `null` if the id\n   *  isn't known. */\n  getEffectivePose(id: string): TPose | null;\n  /** Overlay-aware bounds for `id`. */\n  getEffectiveBounds(id: string): Bounds | null;\n  /**\n   * World-space AABB of everything the in-flight gesture proposes — the\n   * displaced poses of nodes being moved / resized / rotated / cloned, plus\n   * any nascent insert that has no scene node yet. `null` when no gesture is\n   * in flight.\n   *\n   * This reports the *gesture*, not the document: committed content the\n   * gesture isn't touching is excluded. Select-only gestures are excluded\n   * too: a marquee or lasso has geometry but proposes no content.\n   *\n   * The result is a plain AABB — never rotated. Rotated parts are folded in\n   * by their rotated extent.\n   */\n  getGestureBounds(): Bounds | null;\n  /**\n   * Subscribe to the gesture layer's change signal, for everything on this\n   * object that moves during a drag (`getEffectivePose`, `getEffectiveBounds`,\n   * `getGestureBounds`). Returns an unsubscribe.\n   *\n   * Fires once per dispatcher pump: gesture start, every pointermove that\n   * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing\n   * actions. It fires on the pump, not on a diff: a pump that changed nothing\n   * observable still notifies, so don't hang expensive work directly off the\n   * callback.\n   *\n   * It does **not** cover committed scene edits (subscribe to the scene for\n   * those) or previews a consumer's own tool publishes from React state.\n   * Without a gesture source wired — a bare `<Canvas>` — it never fires.\n   */\n  subscribeGestures(fn: () => void): () => void;\n  /**\n   * Monotonic counter bumped on exactly the events `subscribeGestures` fires\n   * on. Pair the two for `useSyncExternalStore`:\n   *\n   * ```ts\n   * const gestureVersion = useSyncExternalStore(\n   *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),\n   *   () => helpersRef.current?.getGestureVersion() ?? 0,\n   * );\n   * ```\n   *\n   * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with\n   * no gesture source reports, forever.\n   */\n  getGestureVersion(): number;\n  /** The live ChromeState built once per render: overlay-aware selection\n   *  state for affordances and custom layers. */\n  getChromeState(): ChromeState;\n  /**\n   * Everything publishing an in-flight preview for this view: the handles in\n   * flight on its dispatcher, in dispatch order. Readers take the first\n   * non-null answer per id.\n   *\n   * A ghost layer must read this off its draw envelope rather than close over\n   * a dispatcher: one layer array paints every view, so a closure ghosts view\n   * zero's drag into every panel.\n   */\n  getPreviewSources(): readonly GesturePreviewSource[];\n  /** Overlay shapes this view's in-flight handles publish — marquee, lasso,\n   *  insert preview, raw commands. Same envelope rule as\n   *  {@link CanvasViewHelpers.getPreviewSources}. */\n  getGestureOverlays(): readonly OngoingOverlay[];\n  /**\n   * Chrome-caps visibility predicate, keyed by chrome id. Overlay layers and\n   * affordances call it per element to decide whether to draw / hit-test.\n   * Unwired, it is the universal `() => true`.\n   */\n  getIsVisible(): (id: string) => boolean;\n}\n\n/**\n * The half of {@link CanvasHelpers} that belongs to the surface — one GL\n * context, one debug sink, however many views are drawn on it.\n */\nexport interface CanvasSurfaceHelpers {\n  /** Active debug sink, when `<Canvas debug=...>` is enabled, for layers to\n   *  call from their `draw` callback. `null` when debug is off. */\n  getDebug(): DebugSink | null;\n}\n\n/** Live overlay-aware lookups exposed to custom layers via `helpersRef`, and\n *  what a layer receives as its `data` argument. */\nexport interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {\n  /**\n   * The view this draw is for: a `<CanvasView>` id, or `null` for the\n   * surface's own camera. One layer array paints every view, so a layer that\n   * belongs in some views and not others — a minimap's indicator — declines\n   * the rest by this id.\n   */\n  readonly viewId: string | null;\n}\n\n/** What a view's pose and bounds lookups read of an adapter. */\nexport interface ViewPoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  /** Where the node is drawn, when the adapter composes poses. An adapter\n   *  without it stores absolute poses, where the two agree. */\n  getWorldPose?(id: string): TPose;\n}\n\nexport interface UseViewHelpersOpts<TPose> {\n  adapter: ViewPoseAdapter<TPose> | undefined;\n  geometry: PoseDescriptor<TPose>;\n  /** Consumer-supplied bounds resolver. Falls back to the adapter's pose. */\n  boundsOf: ((id: string) => Bounds | null) | undefined;\n  /** Bounds of `id` drawn at an in-flight `pose`. Falls back to the\n   *  geometry's box of that pose, which is wrong wherever the surface draws a\n   *  node somewhere its pose does not say — a parallax plane. */\n  boundsOfPose?: ((id: string, pose: TPose) => Bounds | null) | undefined;\n  selection: readonly NodeId[];\n  gestureSource: GestureSource | undefined;\n  /** The dispatcher's preview pose for an id, read through a ref so a change\n   *  mid-gesture doesn't rebuild the memos that depend on it. */\n  previewPoseExtra: ((id: string) => unknown) | undefined;\n  /** Chrome-caps predicate for this view. Absent means everything is visible. */\n  getIsVisible?: (() => (id: string) => boolean) | undefined;\n}\n\nexport interface ViewHelpersBundle<TPose> {\n  helpers: CanvasViewHelpers<TPose>;\n  chromeState: ChromeState;\n}\n\nfunction worldPoseOf<TPose>(adapter: ViewPoseAdapter<TPose>, id: string): TPose {\n  return typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id);\n}\n\n/**\n * Build one view's overlay-aware state: its chrome and the lookups its layers\n * draw and hit-test against. A canvas with N views mounts N components each\n * calling this once.\n */\nexport function useViewHelpers<TPose>(\n  opts: UseViewHelpersOpts<TPose>,\n): ViewHelpersBundle<TPose> {\n  const {\n    adapter, geometry, boundsOf, boundsOfPose, selection, gestureSource,\n    previewPoseExtra, getIsVisible,\n  } = opts;\n  const boxOf = useCallback(\n    (id: string, pose: TPose): Bounds | null =>\n      (boundsOfPose ? boundsOfPose(id, pose) : framedBounds(pose, geometry)),\n    [boundsOfPose, geometry],\n  );\n\n  const baseBoundsOf = useMemo(() => {\n    if (boundsOf) return boundsOf;\n    if (!adapter) return undefined;\n    return (id: string): Bounds | null => {\n      try {\n        // World: chrome is drawn over the picture, so it has to agree with\n        // where the renderer put the node, not with where its pose is stored.\n        return framedBounds(worldPoseOf(adapter, id), geometry);\n      } catch {\n        return null;\n      }\n    };\n  }, [boundsOf, adapter, geometry]);\n\n  const committedPoseOf = useCallback((id: string): TPose | null => {\n    if (!adapter) return null;\n    try {\n      return worldPoseOf(adapter, id);\n    } catch {\n      return null;\n    }\n  }, [adapter]);\n\n  const multiActive = selection.length > 1;\n\n  const previewPoseExtraRef = useLatest(previewPoseExtra);\n\n  const effectiveBoundsOf = useMemo(() => boundsOf ?? baseBoundsOf, [boundsOf, baseBoundsOf]);\n\n  const previewPoseOf = useCallback((id: string): TPose | null => {\n    const p = previewPoseExtraRef.current?.(id);\n    return p != null ? (p as TPose) : null;\n  }, [previewPoseExtraRef]);\n  const previewBoundsOf = useCallback((id: string): Bounds | null => {\n    const p = previewPoseOf(id);\n    return p != null ? boxOf(id, p) : null;\n  }, [previewPoseOf, boxOf]);\n\n  /**\n   * Bounds for `id` with any in-flight gesture folded in — what the user can\n   * see, not what is committed. Both the chrome state and the layer helpers\n   * answer bounds questions with this, so resize handles cannot end up a frame\n   * away from the shape they belong to.\n   */\n  const boundsWithPreview = useCallback((id: string): Bounds | null => {\n    const previewed = previewBoundsOf(id);\n    if (previewed) return previewed;\n    return effectiveBoundsOf ? effectiveBoundsOf(id) : null;\n  }, [previewBoundsOf, effectiveBoundsOf]);\n\n  const chromeState: ChromeState = useMemo(\n    () => buildChromeState({\n      selection,\n      multiActive,\n      effectiveBoundsOf: boundsWithPreview,\n      modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n      // Absent adapter / unknown ids fall back to `true` so the affordance\n      // stays visible for consumers that wire bounds without an adapter.\n      canRotate: (id) => {\n        if (!geometry.supportsRotation) return true;\n        const pose = committedPoseOf(id);\n        if (pose == null) return true;\n        return geometry.supportsRotation(pose);\n      },\n    }),\n    [selection, multiActive, boundsWithPreview, geometry, committedPoseOf],\n  );\n\n  const helpers: CanvasViewHelpers<TPose> = {\n    getEffectivePose: (id: string): TPose | null => {\n      return previewPoseOf(id) ?? committedPoseOf(id);\n    },\n    getEffectiveBounds: boundsWithPreview,\n    getGestureBounds: (): Bounds | null => {\n      // The same id sets the ghost layer walks, so this cannot disagree with\n      // what the user sees ghosted.\n      const parts: (Bounds | null)[] = [];\n      for (const id of new Set(gestureSource?.ids() ?? [])) parts.push(previewBoundsOf(id));\n      const extraBounds = gestureSource?.bounds();\n      if (extraBounds) for (const b of extraBounds) parts.push(b);\n      return unionAABB(parts);\n    },\n    subscribeGestures: (fn: () => void): (() => void) =>\n      gestureSource?.subscribe(fn) ?? noOpUnsubscribe,\n    getGestureVersion: (): number => gestureSource?.getVersion() ?? 0,\n    getChromeState: () => chromeState,\n    getPreviewSources: (): readonly GesturePreviewSource[] => gestureSource?.previewSources() ?? [],\n    getGestureOverlays: (): readonly OngoingOverlay[] => gestureSource?.overlays() ?? [],\n    getIsVisible: (): ((id: string) => boolean) => getIsVisible?.() ?? alwaysVisible,\n  };\n\n  return { helpers, chromeState };\n}\n"],"mappings":";;;;;;AAYA,IAAMA,UAA8B,CAAC,GAE/BC,UAA+B;AAyIrC,SAASC,EAAmB,GAAiC,GAAmB;CAC9E,OAAO,OAAOC,EAAQ,gBAAiB,aAAaA,EAAQ,aAAaC,CAAE,IAAID,EAAQ,QAAQC,CAAE;AACnG;AAOA,SAAgBC,EACd,GAC0B;CAC1B,IAAM,EACJ,YAAS,aAAU,aAAU,iBAAc,cAAW,kBACtD,qBAAkB,oBAChBC,GACEC,IAAQC,GACX,GAAY,MACVC,IAAeA,EAAaL,GAAIM,CAAI,IAAIC,EAAaD,GAAME,CAAQ,GACtE,CAACH,GAAcG,CAAQ,CACzB,GAEMC,IAAeC,QAAc;EACjC,IAAIC,GAAU,OAAOA;EACrB,IAAKZ,GACL,QAAQ,MAA8B;GACpC,IAAI;IAGF,OAAOQ,EAAaT,EAAYC,GAASC,CAAE,GAAGQ,CAAQ;GACxD,QAAQ;IACN,OAAO;GACT;EACF;CACF,GAAG;EAACG;EAAUZ;EAASS;CAAQ,CAAC,GAE1BI,IAAkBR,GAAa,MAA6B;EAChE,IAAI,CAACL,GAAS,OAAO;EACrB,IAAI;GACF,OAAOD,EAAYC,GAASC,CAAE;EAChC,QAAQ;GACN,OAAO;EACT;CACF,GAAG,CAACD,CAAO,CAAC,GAENc,IAAcC,EAAU,SAAS,GAEjCC,IAAsBC,EAAUC,CAAgB,GAEhDC,IAAoBR,QAAcC,KAAYF,GAAc,CAACE,GAAUF,CAAY,CAAC,GAEpFU,IAAgBf,GAAa,MACvBW,EAAoB,UAAUf,CAAE,KACR,MACjC,CAACe,CAAmB,CAAC,GAClBK,IAAkBhB,GAAa,MAA8B;EACjE,IAAMiB,IAAIF,EAAcnB,CAAE;EAC1B,OAAOqB,KAAK,OAAsB,OAAflB,EAAMH,GAAIqB,CAAC;CAChC,GAAG,CAACF,GAAehB,CAAK,CAAC,GAQnBmB,IAAoBlB,GAAa,MACnBgB,EAAgBpB,CAC9B,MACGkB,IAAoBA,EAAkBlB,CAAE,IAAI,OAClD,CAACoB,GAAiBF,CAAiB,CAAC,GAEjCK,IAA2Bb,QACzBc,EAAiB;EACrB;EACA;EACA,mBAAmBF;EACnB,WAAW;GAAE,KAAK;GAAO,OAAO;GAAO,MAAM;GAAO,MAAM;EAAM;EAGhE,YAAY,MAAO;GACjB,IAAI,CAACd,EAAS,kBAAkB,OAAO;GACvC,IAAMF,IAAOM,EAAgBZ,CAAE;GAE/B,OADIM,KAAQ,QACLE,EAAS,iBAAiBF,CAAI;EACvC;CACF,CAAC,GACD;EAACQ;EAAWD;EAAaS;EAAmBd;EAAUI;CAAe,CACvE;CAyBA,OAAO;EAAE,SAAA;GAtBP,mBAAmB,MACVO,EAAcnB,CAAE,KAAKY,EAAgBZ,CAAE;GAEhD,oBAAoBsB;GACpB,wBAAuC;IAGrC,IAAMG,IAA2B,CAAC;IAClC,KAAK,IAAMzB,KAAM,IAAI,IAAI0B,GAAe,IAAI,KAAK,CAAC,CAAC,GAAG,EAAM,KAAKN,EAAgBpB,CAAE,CAAC;IACpF,IAAM2B,IAAcD,GAAe,OAAO;IAC1C,IAAIC,GAAa,KAAK,IAAMC,KAAKD,GAAa,EAAM,KAAKC,CAAC;IAC1D,OAAOC,EAAUJ,CAAK;GACxB;GACA,oBAAoB,MAClBC,GAAe,UAAUI,CAAE,KAAKlC;GAClC,yBAAiC8B,GAAe,WAAW,KAAK;GAChE,sBAAsBH;GACtB,yBAA0DG,GAAe,eAAe,KAAK,CAAC;GAC9F,0BAAqDA,GAAe,SAAS,KAAK,CAAC;GACnF,oBAA+CK,IAAe,KAAKlC;EAG5D;EAAS;CAAY;AAChC"}
+{"version":3,"file":"useViewHelpers.js","names":[],"sources":["../../src/canvas/useViewHelpers.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { useLatest } from '@weasel-js/react';\nimport type { GestureSource, GesturePreviewSource } from './gestureBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { buildChromeState, type ChromeState } from 'core/selection/chromeState';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { NodeId } from 'core/scene/types';\nimport type { DebugSink } from '../debug/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { Scale2 } from '@weasel-js/geom';\nimport { drawnBoundsOf, type DrawnBoundsScene } from './drawnBounds';\n\nconst noOpUnsubscribe = (): void => {};\n\nconst alwaysVisible = (): boolean => true;\n\n/**\n * The half of {@link CanvasHelpers} that belongs to one view — everything\n * answered by a camera's own tools, gestures and selection. A canvas hosting\n * several viewports needs one of these per view; the surface half is shared.\n */\nexport interface CanvasViewHelpers<TPose> {\n  /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,\n   *  otherwise the committed pose from the adapter. Returns `null` if the id\n   *  isn't known. */\n  getEffectivePose(id: string): TPose | null;\n  /** Overlay-aware bounds for `id`. */\n  getEffectiveBounds(id: string): Bounds | null;\n  /**\n   * World-space AABB of everything the in-flight gesture proposes — the\n   * displaced poses of nodes being moved / resized / rotated / cloned, plus\n   * any nascent insert that has no scene node yet. `null` when no gesture is\n   * in flight.\n   *\n   * This reports the *gesture*, not the document: committed content the\n   * gesture isn't touching is excluded. Select-only gestures are excluded\n   * too: a marquee or lasso has geometry but proposes no content.\n   *\n   * The result is a plain AABB — never rotated. Rotated parts are folded in\n   * by their rotated extent.\n   */\n  getGestureBounds(): Bounds | null;\n  /**\n   * Subscribe to the gesture layer's change signal, for everything on this\n   * object that moves during a drag (`getEffectivePose`, `getEffectiveBounds`,\n   * `getGestureBounds`). Returns an unsubscribe.\n   *\n   * Fires once per dispatcher pump: gesture start, every pointermove that\n   * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing\n   * actions. It fires on the pump, not on a diff: a pump that changed nothing\n   * observable still notifies, so don't hang expensive work directly off the\n   * callback.\n   *\n   * It does **not** cover committed scene edits (subscribe to the scene for\n   * those) or previews a consumer's own tool publishes from React state.\n   * Without a gesture source wired — a bare `<Canvas>` — it never fires.\n   */\n  subscribeGestures(fn: () => void): () => void;\n  /**\n   * Monotonic counter bumped on exactly the events `subscribeGestures` fires\n   * on. Pair the two for `useSyncExternalStore`:\n   *\n   * ```ts\n   * const gestureVersion = useSyncExternalStore(\n   *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),\n   *   () => helpersRef.current?.getGestureVersion() ?? 0,\n   * );\n   * ```\n   *\n   * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with\n   * no gesture source reports, forever.\n   */\n  getGestureVersion(): number;\n  /** The live ChromeState built once per render: overlay-aware selection\n   *  state for affordances and custom layers. */\n  getChromeState(): ChromeState;\n  /**\n   * Everything publishing an in-flight preview for this view: the handles in\n   * flight on its dispatcher, in dispatch order. Readers take the first\n   * non-null answer per id.\n   *\n   * A ghost layer must read this off its draw envelope rather than close over\n   * a dispatcher: one layer array paints every view, so a closure ghosts view\n   * zero's drag into every panel.\n   */\n  getPreviewSources(): readonly GesturePreviewSource[];\n  /** Overlay shapes this view's in-flight handles publish — marquee, lasso,\n   *  insert preview, raw commands. Same envelope rule as\n   *  {@link CanvasViewHelpers.getPreviewSources}. */\n  getGestureOverlays(): readonly OngoingOverlay[];\n  /**\n   * Chrome-caps visibility predicate, keyed by chrome id. Overlay layers and\n   * affordances call it per element to decide whether to draw / hit-test.\n   * Unwired, it is the universal `() => true`.\n   */\n  getIsVisible(): (id: string) => boolean;\n}\n\n/**\n * The half of {@link CanvasHelpers} that belongs to the surface — one GL\n * context, one debug sink, however many views are drawn on it.\n */\nexport interface CanvasSurfaceHelpers {\n  /** Active debug sink, when `<Canvas debug=...>` is enabled, for layers to\n   *  call from their `draw` callback. `null` when debug is off. */\n  getDebug(): DebugSink | null;\n}\n\n/** Live overlay-aware lookups exposed to custom layers via `helpersRef`, and\n *  what a layer receives as its `data` argument. */\nexport interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {\n  /**\n   * The view this draw is for: a `<CanvasView>` id, or `null` for the\n   * surface's own camera. One layer array paints every view, so a layer that\n   * belongs in some views and not others — a minimap's indicator — declines\n   * the rest by this id.\n   */\n  readonly viewId: string | null;\n}\n\n/** What a view's pose and bounds lookups read of an adapter. */\nexport interface ViewPoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  /** Where the node is drawn, when the adapter composes poses. An adapter\n   *  without it stores absolute poses, where the two agree. */\n  getWorldPose?(id: string): TPose;\n  /** The node an id names, whose `layer` decides whether a view that hides\n   *  that layer shows its selection chrome. */\n  getNode?(id: string): { layer?: string } | undefined;\n}\n\nexport interface UseViewHelpersOpts<TPose> {\n  adapter: ViewPoseAdapter<TPose> | undefined;\n  geometry: PoseDescriptor<TPose>;\n  /** Consumer-supplied bounds resolver. Falls back to the adapter's pose. */\n  boundsOf: ((id: string) => Bounds | null) | undefined;\n  /** Bounds of `id` drawn at an in-flight `pose`. Falls back to the\n   *  geometry's box of that pose, which is wrong wherever the surface draws a\n   *  node somewhere its pose does not say — a parallax plane. */\n  boundsOfPose?: ((id: string, pose: TPose) => Bounds | null) | undefined;\n  /** The nodes the adapter's ids name: with them, the fallbacks box each as\n   *  drawn, stroke included, rather than by its pose. */\n  nodes?: DrawnBoundsScene | undefined;\n  /** The view's scale, which a screen-pixel stroke is resolved at. Default 1. */\n  getScale?: (() => Scale2) | undefined;\n  selection: readonly NodeId[];\n  gestureSource: GestureSource | undefined;\n  /** The dispatcher's preview pose for an id, read through a ref so a change\n   *  mid-gesture doesn't rebuild the memos that depend on it. */\n  previewPoseExtra: ((id: string) => unknown) | undefined;\n  /** Chrome-caps predicate for this view. Absent means everything is visible. */\n  getIsVisible?: (() => (id: string) => boolean) | undefined;\n  /** Whether a scene layer reaches the screen in this view. Absent means\n   *  every layer the scene shows does. */\n  layerIsPainted?: ((layerId: string) => boolean) | undefined;\n}\n\nexport interface ViewHelpersBundle<TPose> {\n  helpers: CanvasViewHelpers<TPose>;\n}\n\nfunction worldPoseOf<TPose>(adapter: ViewPoseAdapter<TPose>, id: string): TPose {\n  return typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id);\n}\n\n/**\n * Build one view's overlay-aware state: its chrome and the lookups its layers\n * draw and hit-test against. A canvas with N views mounts N components each\n * calling this once.\n */\nexport function useViewHelpers<TPose>(\n  opts: UseViewHelpersOpts<TPose>,\n): ViewHelpersBundle<TPose> {\n  const {\n    adapter, geometry, boundsOf, boundsOfPose, nodes, getScale, selection, gestureSource,\n    previewPoseExtra, getIsVisible, layerIsPainted,\n  } = opts;\n  const getScaleRef = useLatest(getScale);\n  const poseBoxOf = useCallback((id: string, pose: TPose): Bounds => {\n    if (!nodes) return framedBounds(pose, geometry);\n    const scale = getScaleRef.current?.();\n    return drawnBoundsOf(nodes, id as NodeId, pose, {\n      descriptor: geometry as PoseDescriptor<unknown>,\n      ...(adapter ? { worldPoseOf: (m: NodeId) => worldPoseOf(adapter, m) } : {}),\n      ...(scale ? { scale } : {}),\n    });\n  }, [nodes, geometry, adapter, getScaleRef]);\n  const boxOf = useCallback(\n    (id: string, pose: TPose): Bounds | null =>\n      (boundsOfPose ? boundsOfPose(id, pose) : poseBoxOf(id, pose)),\n    [boundsOfPose, poseBoxOf],\n  );\n\n  const baseBoundsOf = useMemo(() => {\n    if (boundsOf) return boundsOf;\n    if (!adapter) return undefined;\n    return (id: string): Bounds | null => {\n      try {\n        // World: chrome is drawn over the picture, so it has to agree with\n        // where the renderer put the node, not with where its pose is stored.\n        return poseBoxOf(id, worldPoseOf(adapter, id));\n      } catch {\n        return null;\n      }\n    };\n  }, [boundsOf, adapter, poseBoxOf]);\n\n  const committedPoseOf = useCallback((id: string): TPose | null => {\n    if (!adapter) return null;\n    try {\n      return worldPoseOf(adapter, id);\n    } catch {\n      return null;\n    }\n  }, [adapter]);\n\n  const multiActive = selection.length > 1;\n\n  const previewPoseExtraRef = useLatest(previewPoseExtra);\n\n  const effectiveBoundsOf = useMemo(() => boundsOf ?? baseBoundsOf, [boundsOf, baseBoundsOf]);\n\n  const previewPoseOf = useCallback((id: string): TPose | null => {\n    const p = previewPoseExtraRef.current?.(id);\n    return p != null ? (p as TPose) : null;\n  }, [previewPoseExtraRef]);\n  const previewBoundsOf = useCallback((id: string): Bounds | null => {\n    const p = previewPoseOf(id);\n    return p != null ? boxOf(id, p) : null;\n  }, [previewPoseOf, boxOf]);\n\n  /**\n   * Bounds for `id` with any in-flight gesture folded in — what the user can\n   * see, not what is committed. Both the chrome state and the layer helpers\n   * answer bounds questions with this, so resize handles cannot end up a frame\n   * away from the shape they belong to.\n   */\n  const boundsWithPreview = useCallback((id: string): Bounds | null => {\n    const previewed = previewBoundsOf(id);\n    if (previewed) return previewed;\n    return effectiveBoundsOf ? effectiveBoundsOf(id) : null;\n  }, [previewBoundsOf, effectiveBoundsOf]);\n\n  const chromeState: ChromeState = useMemo(\n    () => buildChromeState({\n      selection,\n      multiActive,\n      effectiveBoundsOf: boundsWithPreview,\n      modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n      // Absent adapter / unknown ids fall back to `true` so the affordance\n      // stays visible for consumers that wire bounds without an adapter.\n      canRotate: (id) => {\n        if (!geometry.supportsRotation) return true;\n        const pose = committedPoseOf(id);\n        if (pose == null) return true;\n        return geometry.supportsRotation(pose);\n      },\n      ...(layerIsPainted ? { layerIsPainted } : {}),\n      ...(adapter?.getNode ? { layerOf: (id: string) => adapter.getNode?.(id)?.layer } : {}),\n    }),\n    [selection, multiActive, boundsWithPreview, geometry, committedPoseOf, layerIsPainted, adapter],\n  );\n\n  const helpers: CanvasViewHelpers<TPose> = {\n    getEffectivePose: (id: string): TPose | null => {\n      return previewPoseOf(id) ?? committedPoseOf(id);\n    },\n    getEffectiveBounds: boundsWithPreview,\n    getGestureBounds: (): Bounds | null => {\n      // The same id sets the ghost layer walks, so this cannot disagree with\n      // what the user sees ghosted.\n      const parts: (Bounds | null)[] = [];\n      for (const id of new Set(gestureSource?.ids() ?? [])) parts.push(previewBoundsOf(id));\n      const extraBounds = gestureSource?.bounds();\n      if (extraBounds) for (const b of extraBounds) parts.push(b);\n      return unionAABB(parts);\n    },\n    subscribeGestures: (fn: () => void): (() => void) =>\n      gestureSource?.subscribe(fn) ?? noOpUnsubscribe,\n    getGestureVersion: (): number => gestureSource?.getVersion() ?? 0,\n    getChromeState: () => chromeState,\n    getPreviewSources: (): readonly GesturePreviewSource[] => gestureSource?.previewSources() ?? [],\n    getGestureOverlays: (): readonly OngoingOverlay[] => gestureSource?.overlays() ?? [],\n    getIsVisible: (): ((id: string) => boolean) => getIsVisible?.() ?? alwaysVisible,\n  };\n\n  return { helpers };\n}\n"],"mappings":";;;;;;;;AAcA,IAAM,wBAA8B,CAAC;AAErC,IAAM,sBAA+B;AAmJrC,SAAS,YAAmB,SAAiC,IAAmB;CAC9E,OAAO,OAAO,QAAQ,iBAAiB,aAAa,QAAQ,aAAa,EAAE,IAAI,QAAQ,QAAQ,EAAE;AACnG;;;;;;AAOA,SAAgB,eACd,MAC0B;CAC1B,MAAM,EACJ,SAAS,UAAU,UAAU,cAAc,OAAO,UAAU,WAAW,eACvE,kBAAkB,cAAc,mBAC9B;CACJ,MAAM,cAAc,UAAU,QAAQ;CACtC,MAAM,YAAY,aAAa,IAAY,SAAwB;EACjE,IAAI,CAAC,OAAO,OAAO,aAAa,MAAM,QAAQ;EAC9C,MAAM,QAAQ,YAAY,UAAU;EACpC,OAAO,cAAc,OAAO,IAAc,MAAM;GAC9C,YAAY;GACZ,GAAI,UAAU,EAAE,cAAc,MAAc,YAAY,SAAS,CAAC,EAAE,IAAI,CAAC;GACzE,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;EAC3B,CAAC;CACH,GAAG;EAAC;EAAO;EAAU;EAAS;CAAW,CAAC;CAC1C,MAAM,QAAQ,aACX,IAAY,SACV,eAAe,aAAa,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,GAC7D,CAAC,cAAc,SAAS,CAC1B;CAEA,MAAM,eAAe,cAAc;EACjC,IAAI,UAAU,OAAO;EACrB,IAAI,CAAC,SAAS,OAAO;EACrB,QAAQ,OAA8B;GACpC,IAAI;IAGF,OAAO,UAAU,IAAI,YAAY,SAAS,EAAE,CAAC;GAC/C,QAAQ;IACN,OAAO;GACT;EACF;CACF,GAAG;EAAC;EAAU;EAAS;CAAS,CAAC;CAEjC,MAAM,kBAAkB,aAAa,OAA6B;EAChE,IAAI,CAAC,SAAS,OAAO;EACrB,IAAI;GACF,OAAO,YAAY,SAAS,EAAE;EAChC,QAAQ;GACN,OAAO;EACT;CACF,GAAG,CAAC,OAAO,CAAC;CAEZ,MAAM,cAAc,UAAU,SAAS;CAEvC,MAAM,sBAAsB,UAAU,gBAAgB;CAEtD,MAAM,oBAAoB,cAAc,YAAY,cAAc,CAAC,UAAU,YAAY,CAAC;CAE1F,MAAM,gBAAgB,aAAa,OAA6B;EAC9D,MAAM,IAAI,oBAAoB,UAAU,EAAE;EAC1C,OAAO,KAAK,OAAQ,IAAc;CACpC,GAAG,CAAC,mBAAmB,CAAC;CACxB,MAAM,kBAAkB,aAAa,OAA8B;EACjE,MAAM,IAAI,cAAc,EAAE;EAC1B,OAAO,KAAK,OAAO,MAAM,IAAI,CAAC,IAAI;CACpC,GAAG,CAAC,eAAe,KAAK,CAAC;;;;;;;CAQzB,MAAM,oBAAoB,aAAa,OAA8B;EACnE,MAAM,YAAY,gBAAgB,EAAE;EACpC,IAAI,WAAW,OAAO;EACtB,OAAO,oBAAoB,kBAAkB,EAAE,IAAI;CACrD,GAAG,CAAC,iBAAiB,iBAAiB,CAAC;CAEvC,MAAM,cAA2B,cACzB,iBAAiB;EACrB;EACA;EACA,mBAAmB;EACnB,WAAW;GAAE,KAAK;GAAO,OAAO;GAAO,MAAM;GAAO,MAAM;EAAM;EAGhE,YAAY,OAAO;GACjB,IAAI,CAAC,SAAS,kBAAkB,OAAO;GACvC,MAAM,OAAO,gBAAgB,EAAE;GAC/B,IAAI,QAAQ,MAAM,OAAO;GACzB,OAAO,SAAS,iBAAiB,IAAI;EACvC;EACA,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;EAC3C,GAAI,SAAS,UAAU,EAAE,UAAU,OAAe,QAAQ,UAAU,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC;CACtF,CAAC,GACD;EAAC;EAAW;EAAa;EAAmB;EAAU;EAAiB;EAAgB;CAAO,CAChG;CAyBA,OAAO,EAAE;EAtBP,mBAAmB,OAA6B;GAC9C,OAAO,cAAc,EAAE,KAAK,gBAAgB,EAAE;EAChD;EACA,oBAAoB;EACpB,wBAAuC;GAGrC,MAAM,QAA2B,CAAC;GAClC,KAAK,MAAM,MAAM,IAAI,IAAI,eAAe,IAAI,KAAK,CAAC,CAAC,GAAG,MAAM,KAAK,gBAAgB,EAAE,CAAC;GACpF,MAAM,cAAc,eAAe,OAAO;GAC1C,IAAI,aAAa,KAAK,MAAM,KAAK,aAAa,MAAM,KAAK,CAAC;GAC1D,OAAO,UAAU,KAAK;EACxB;EACA,oBAAoB,OAClB,eAAe,UAAU,EAAE,KAAK;EAClC,yBAAiC,eAAe,WAAW,KAAK;EAChE,sBAAsB;EACtB,yBAA0D,eAAe,eAAe,KAAK,CAAC;EAC9F,0BAAqD,eAAe,SAAS,KAAK,CAAC;EACnF,oBAA+C,eAAe,KAAK;CAG5D,EAAQ;AACnB"}

package/dist/canvas/useViewLayerGate.js

@@ -0,0 +1,29 @@
+import { createSceneLayerGate } from "./sceneLayerPaint.js";
+import { useCallback, useState } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useViewLayerGate.ts
+/**
+* Whether a surface's own view paints a scene layer, judged against the stack
+* `surfaceLayers` returns, read at ask time, so a consumer slot anchored
+* between scene layers is weighed the way paint weighs it. Undefined when the
+* view hides nothing, so a pick walk or a chrome pass skips the gate.
+*/
+function useViewLayerGate(layerVisibility, layerOrder, surfaceLayers) {
+	const layerPaintRef = useLatest({
+		layerVisibility,
+		layerOrder
+	});
+	const surfaceLayersRef = useLatest(surfaceLayers);
+	const [sceneLayerGate] = useState(createSceneLayerGate);
+	const layerIsPainted = useCallback((layerId) => sceneLayerGate(surfaceLayersRef.current(), layerPaintRef.current)(layerId), [
+		sceneLayerGate,
+		surfaceLayersRef,
+		layerPaintRef
+	]);
+	return layerVisibility !== void 0 || layerOrder !== void 0 ? layerIsPainted : void 0;
+}
+
+//#endregion
+export { useViewLayerGate };
+//# sourceMappingURL=useViewLayerGate.js.map

package/dist/canvas/useViewLayerGate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewLayerGate.js","names":[],"sources":["../../src/canvas/useViewLayerGate.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { RenderLayer } from 'core/layers/render';\nimport { createSceneLayerGate, type ViewLayerPaint } from './sceneLayerPaint';\n\n/**\n * Whether a surface's own view paints a scene layer, judged against the stack\n * `surfaceLayers` returns, read at ask time, so a consumer slot anchored\n * between scene layers is weighed the way paint weighs it. Undefined when the\n * view hides nothing, so a pick walk or a chrome pass skips the gate.\n */\nexport function useViewLayerGate(\n  layerVisibility: ViewLayerPaint['layerVisibility'],\n  layerOrder: ViewLayerPaint['layerOrder'],\n  surfaceLayers: () => readonly RenderLayer<unknown>[],\n): ((layerId: string) => boolean) | undefined {\n  const layerPaintRef = useLatest<ViewLayerPaint>({ layerVisibility, layerOrder });\n  const surfaceLayersRef = useLatest(surfaceLayers);\n  const [sceneLayerGate] = useState(createSceneLayerGate);\n  const layerIsPainted = useCallback((layerId: string): boolean => (\n    sceneLayerGate(surfaceLayersRef.current(), layerPaintRef.current)(layerId)\n  ), [sceneLayerGate, surfaceLayersRef, layerPaintRef]);\n  return layerVisibility !== undefined || layerOrder !== undefined ? layerIsPainted : undefined;\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,iBACd,iBACA,YACA,eAC4C;CAC5C,MAAM,gBAAgB,UAA0B;EAAE;EAAiB;CAAW,CAAC;CAC/E,MAAM,mBAAmB,UAAU,aAAa;CAChD,MAAM,CAAC,kBAAkB,SAAS,oBAAoB;CACtD,MAAM,iBAAiB,aAAa,YAClC,eAAe,iBAAiB,QAAQ,GAAG,cAAc,OAAO,CAAC,CAAC,OAAO,GACxE;EAAC;EAAgB;EAAkB;CAAa,CAAC;CACpD,OAAO,oBAAoB,UAAa,eAAe,SAAY,iBAAiB;AACtF"}

package/dist/canvas/useViewNesting.js

@@ -0,0 +1,104 @@
+import { createSceneLayerGate, viewPaintedLayers } from "./sceneLayerPaint.js";
+import { useCallback, useRef, useState } from "react";
+
+//#region src/canvas/useViewNesting.ts
+/**
+* How a `<CanvasView>` sits in the view it is nested in: the frame its
+* `bounds` and derived camera are measured against, and the layers it may
+* paint. Without a `parent` the frame is the surface's.
+*/
+var NO_RECT = {
+	x: 0,
+	y: 0,
+	w: 0,
+	h: 0
+};
+var sizeOf = (rect) => ({
+	width: rect.w,
+	height: rect.h
+});
+function useViewNesting(registry, live) {
+	const measuring = useRef(false);
+	/** The frame this view is measured in, for a surface frame; `null` while
+	*  its parent is missing. */
+	const frameIn = useCallback((outer, dims) => {
+		const p = live.current.parent;
+		if (p === void 0) return {
+			view: outer,
+			dims,
+			origin: {
+				x: 0,
+				y: 0
+			}
+		};
+		const reg = registry?.get(p);
+		if (!reg || measuring.current) return null;
+		measuring.current = true;
+		try {
+			const r = reg.layer.resolvable(outer, dims);
+			return {
+				view: r.view,
+				dims: sizeOf(r.rect),
+				origin: {
+					x: r.rect.x,
+					y: r.rect.y
+				},
+				clip: r.clip ?? r.rect
+			};
+		} finally {
+			measuring.current = false;
+		}
+	}, [live, registry]);
+	const rectAt = useCallback((outer, dims) => {
+		const frame = frameIn(outer, dims);
+		if (!frame) return NO_RECT;
+		const b = live.current.bounds;
+		const r = typeof b === "function" ? b(frame.view, frame.dims) : b;
+		return {
+			...r,
+			x: r.x + frame.origin.x,
+			y: r.y + frame.origin.y
+		};
+	}, [live, frameIn]);
+	/** A derived camera, for a surface frame: asked of the frame it is measured in. */
+	const derivedAt = useCallback((derive, outer, dims) => {
+		const frame = frameIn(outer, dims);
+		return frame ? derive(frame.view, frame.dims) : derive(outer, dims);
+	}, [frameIn]);
+	/** The view this one is nested in, while it is registered. */
+	const parentReg = useCallback(() => {
+		const p = live.current.parent;
+		return p === void 0 ? void 0 : registry?.get(p);
+	}, [live, registry]);
+	/** The layers this view draws, in the order it draws them: of the surface's,
+	*  or of what the view it is nested in draws. */
+	const drawnLayers = useCallback(() => {
+		if (live.current.parent !== void 0) return viewPaintedLayers(parentReg()?.drawnLayers() ?? [], live.current);
+		return viewPaintedLayers(registry?.surface()?.layers() ?? [], live.current);
+	}, [
+		registry,
+		live,
+		parentReg
+	]);
+	const [sceneLayerGate] = useState(createSceneLayerGate);
+	return {
+		frameIn,
+		rectAt,
+		derivedAt,
+		drawnLayers,
+		layerIsPainted: useCallback((layerId) => {
+			if (!sceneLayerGate(registry?.surface()?.layers() ?? [], live.current)(layerId)) return false;
+			if (live.current.parent === void 0) return true;
+			return parentReg()?.layerIsPainted(layerId) ?? false;
+		}, [
+			registry,
+			sceneLayerGate,
+			live,
+			parentReg
+		])
+	};
+}
+
+//#endregion
+export { NO_RECT, useViewNesting };
+//# sourceMappingURL=useViewNesting.js.map

package/dist/canvas/useViewNesting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewNesting.js","names":[],"sources":["../../src/canvas/useViewNesting.ts"],"sourcesContent":["/**\n * How a `<CanvasView>` sits in the view it is nested in: the frame its\n * `bounds` and derived camera are measured against, and the layers it may\n * paint. Without a `parent` the frame is the surface's.\n */\nimport { useCallback, useRef, useState } from 'react';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { CanvasViewProps, ViewRect } from './canvasViewProps';\nimport { createSceneLayerGate, viewPaintedLayers } from './sceneLayerPaint';\nimport type { ViewRegistration, ViewRegistry } from './viewRegistry';\n\nexport const NO_RECT: ViewRect = { x: 0, y: 0, w: 0, h: 0 };\n\n/** What a view's `bounds` and `view` are measured against: the surface, or\n *  the view it is nested in. `origin` and `clip` are in canvas CSS px. */\nexport interface OuterFrame { view: View; dims: Dims; origin: { x: number; y: number }; clip?: ViewRect }\n\n/** The props the nesting reads, as of the last committed render. */\nexport type ViewNestingInputs = Pick<CanvasViewProps, 'parent' | 'bounds' | 'layers' | 'layerVisibility' | 'layerOrder'>;\n\nconst sizeOf = (rect: ViewRect): Dims => ({ width: rect.w, height: rect.h });\n\nexport function useViewNesting(\n  registry: ViewRegistry | null,\n  live: { readonly current: ViewNestingInputs },\n) {\n  // Set while this view asks its parent for a frame, so a parent chain that\n  // loops back finds no frame rather than recursing.\n  const measuring = useRef(false);\n  /** The frame this view is measured in, for a surface frame; `null` while\n   *  its parent is missing. */\n  const frameIn = useCallback((outer: View, dims: Dims): OuterFrame | null => {\n    const p = live.current.parent;\n    if (p === undefined) return { view: outer, dims, origin: { x: 0, y: 0 } };\n    const reg = registry?.get(p);\n    if (!reg || measuring.current) return null;\n    measuring.current = true;\n    try {\n      const r = reg.layer.resolvable(outer, dims);\n      return {\n        view: r.view, dims: sizeOf(r.rect), origin: { x: r.rect.x, y: r.rect.y }, clip: r.clip ?? r.rect,\n      };\n    } finally {\n      measuring.current = false;\n    }\n  }, [live, registry]);\n\n  const rectAt = useCallback((outer: View, dims: Dims): ViewRect => {\n    const frame = frameIn(outer, dims);\n    if (!frame) return NO_RECT;\n    const b = live.current.bounds;\n    const r = typeof b === 'function' ? b(frame.view, frame.dims) : b;\n    return { ...r, x: r.x + frame.origin.x, y: r.y + frame.origin.y };\n  }, [live, frameIn]);\n\n  /** A derived camera, for a surface frame: asked of the frame it is measured in. */\n  const derivedAt = useCallback((derive: (outer: View, dims: Dims) => View, outer: View, dims: Dims): View => {\n    const frame = frameIn(outer, dims);\n    return frame ? derive(frame.view, frame.dims) : derive(outer, dims);\n  }, [frameIn]);\n\n  /** The view this one is nested in, while it is registered. */\n  const parentReg = useCallback((): ViewRegistration | undefined => {\n    const p = live.current.parent;\n    return p === undefined ? undefined : registry?.get(p);\n  }, [live, registry]);\n\n  /** The layers this view draws, in the order it draws them: of the surface's,\n   *  or of what the view it is nested in draws. */\n  const drawnLayers = useCallback((): readonly RenderLayer<unknown>[] => {\n    if (live.current.parent !== undefined) return viewPaintedLayers(parentReg()?.drawnLayers() ?? [], live.current);\n    return viewPaintedLayers(registry?.surface()?.layers() ?? [], live.current);\n  }, [registry, live, parentReg]);\n\n  const [sceneLayerGate] = useState(createSceneLayerGate);\n  /** What this view's picks, marquees and select-alls ask of a scene layer:\n   *  painted here, and in every view this one is nested in. */\n  const layerIsPainted = useCallback((layerId: string): boolean => {\n    if (!sceneLayerGate(registry?.surface()?.layers() ?? [], live.current)(layerId)) return false;\n    if (live.current.parent === undefined) return true;\n    return parentReg()?.layerIsPainted(layerId) ?? false;\n  }, [registry, sceneLayerGate, live, parentReg]);\n  return { frameIn, rectAt, derivedAt, drawnLayers, layerIsPainted };\n}\n"],"mappings":";;;;;;;;;AAYA,IAAa,UAAoB;CAAE,GAAG;CAAG,GAAG;CAAG,GAAG;CAAG,GAAG;AAAE;AAS1D,IAAM,UAAU,UAA0B;CAAE,OAAO,KAAK;CAAG,QAAQ,KAAK;AAAE;AAE1E,SAAgB,eACd,UACA,MACA;CAGA,MAAM,YAAY,OAAO,KAAK;;;CAG9B,MAAM,UAAU,aAAa,OAAa,SAAkC;EAC1E,MAAM,IAAI,KAAK,QAAQ;EACvB,IAAI,MAAM,QAAW,OAAO;GAAE,MAAM;GAAO;GAAM,QAAQ;IAAE,GAAG;IAAG,GAAG;GAAE;EAAE;EACxE,MAAM,MAAM,UAAU,IAAI,CAAC;EAC3B,IAAI,CAAC,OAAO,UAAU,SAAS,OAAO;EACtC,UAAU,UAAU;EACpB,IAAI;GACF,MAAM,IAAI,IAAI,MAAM,WAAW,OAAO,IAAI;GAC1C,OAAO;IACL,MAAM,EAAE;IAAM,MAAM,OAAO,EAAE,IAAI;IAAG,QAAQ;KAAE,GAAG,EAAE,KAAK;KAAG,GAAG,EAAE,KAAK;IAAE;IAAG,MAAM,EAAE,QAAQ,EAAE;GAC9F;EACF,UAAU;GACR,UAAU,UAAU;EACtB;CACF,GAAG,CAAC,MAAM,QAAQ,CAAC;CAEnB,MAAM,SAAS,aAAa,OAAa,SAAyB;EAChE,MAAM,QAAQ,QAAQ,OAAO,IAAI;EACjC,IAAI,CAAC,OAAO,OAAO;EACnB,MAAM,IAAI,KAAK,QAAQ;EACvB,MAAM,IAAI,OAAO,MAAM,aAAa,EAAE,MAAM,MAAM,MAAM,IAAI,IAAI;EAChE,OAAO;GAAE,GAAG;GAAG,GAAG,EAAE,IAAI,MAAM,OAAO;GAAG,GAAG,EAAE,IAAI,MAAM,OAAO;EAAE;CAClE,GAAG,CAAC,MAAM,OAAO,CAAC;;CAGlB,MAAM,YAAY,aAAa,QAA2C,OAAa,SAAqB;EAC1G,MAAM,QAAQ,QAAQ,OAAO,IAAI;EACjC,OAAO,QAAQ,OAAO,MAAM,MAAM,MAAM,IAAI,IAAI,OAAO,OAAO,IAAI;CACpE,GAAG,CAAC,OAAO,CAAC;;CAGZ,MAAM,YAAY,kBAAgD;EAChE,MAAM,IAAI,KAAK,QAAQ;EACvB,OAAO,MAAM,SAAY,SAAY,UAAU,IAAI,CAAC;CACtD,GAAG,CAAC,MAAM,QAAQ,CAAC;;;CAInB,MAAM,cAAc,kBAAmD;EACrE,IAAI,KAAK,QAAQ,WAAW,QAAW,OAAO,kBAAkB,UAAU,CAAC,EAAE,YAAY,KAAK,CAAC,GAAG,KAAK,OAAO;EAC9G,OAAO,kBAAkB,UAAU,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC,GAAG,KAAK,OAAO;CAC5E,GAAG;EAAC;EAAU;EAAM;CAAS,CAAC;CAE9B,MAAM,CAAC,kBAAkB,SAAS,oBAAoB;CAQtD,OAAO;EAAE;EAAS;EAAQ;EAAW;EAAa,gBAL3B,aAAa,YAA6B;GAC/D,IAAI,CAAC,eAAe,UAAU,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC,OAAO,GAAG,OAAO;GACxF,IAAI,KAAK,QAAQ,WAAW,QAAW,OAAO;GAC9C,OAAO,UAAU,CAAC,EAAE,eAAe,OAAO,KAAK;EACjD,GAAG;GAAC;GAAU;GAAgB;GAAM;EAAS,CACK;CAAe;AACnE"}

package/dist/canvas/useViewRegistrySurface.js

@@ -0,0 +1,44 @@
+import { useEffect } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useViewRegistrySurface.ts
+/**
+* Attach this canvas to the view registry as its surface. The stack a view paints through its
+* own camera is this canvas's `layers`, before the views themselves are folded in — otherwise
+* a view would contain itself. Published by reference and read at draw time.
+*/
+function useViewRegistrySurface(viewRegistry, layers, frame, services) {
+	const surfaceLayersRef = useLatest(layers);
+	const { viewRef, dimsRef, helpersRef } = frame;
+	const { requestRedraw, hitTestExtrasIn, clientToWorld } = services;
+	useEffect(() => {
+		return viewRegistry?.attachSurface({
+			view: () => viewRef.current,
+			dims: () => dimsRef.current,
+			layers: () => surfaceLayersRef.current,
+			requestRedraw,
+			chromeState: () => helpersRef.current.getChromeState(),
+			hitTestExtras: hitTestExtrasIn,
+			clientToWorld,
+			claimsAbove: (x, y) => {
+				const view = viewRef.current;
+				const worldX = x / view.scale.x + view.x;
+				const worldY = y / view.scale.y + view.y;
+				return hitTestExtrasIn(worldX, worldY, view, dimsRef.current, helpersRef.current) !== null;
+			}
+		});
+	}, [
+		viewRegistry,
+		requestRedraw,
+		hitTestExtrasIn,
+		dimsRef,
+		surfaceLayersRef,
+		viewRef,
+		helpersRef,
+		clientToWorld
+	]);
+}
+
+//#endregion
+export { useViewRegistrySurface };
+//# sourceMappingURL=useViewRegistrySurface.js.map

package/dist/canvas/useViewRegistrySurface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewRegistrySurface.js","names":[],"sources":["../../src/canvas/useViewRegistrySurface.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { CanvasHelpers } from './useViewHelpers';\nimport type { SurfaceHandle, ViewRegistry } from './viewRegistry';\n\n/** What the canvas reads at draw and hit time that changes outside a render. */\nexport interface SurfaceFrame {\n  viewRef: { readonly current: View };\n  dimsRef: { readonly current: Dims };\n  helpersRef: { readonly current: Pick<CanvasHelpers<unknown>, 'getChromeState'> | null };\n}\n\n/** What the canvas does for a view that asks. */\nexport interface SurfaceServices {\n  requestRedraw: () => void;\n  hitTestExtrasIn: SurfaceHandle['hitTestExtras'];\n  clientToWorld: SurfaceHandle['clientToWorld'];\n}\n\n/**\n * Attach this canvas to the view registry as its surface. The stack a view paints through its\n * own camera is this canvas's `layers`, before the views themselves are folded in — otherwise\n * a view would contain itself. Published by reference and read at draw time.\n */\nexport function useViewRegistrySurface(\n  viewRegistry: ViewRegistry | null,\n  layers: readonly RenderLayer<unknown>[],\n  frame: SurfaceFrame,\n  services: SurfaceServices,\n): void {\n  const surfaceLayersRef = useLatest<readonly RenderLayer<unknown>[]>(layers);\n  const { viewRef, dimsRef, helpersRef } = frame;\n  const { requestRedraw, hitTestExtrasIn, clientToWorld } = services;\n  useEffect(() => {\n    return viewRegistry?.attachSurface({\n      view: () => viewRef.current,\n      dims: () => dimsRef.current,\n      layers: () => surfaceLayersRef.current,\n      requestRedraw,\n      chromeState: () => helpersRef.current!.getChromeState(),\n      hitTestExtras: hitTestExtrasIn,\n      clientToWorld,\n      claimsAbove: (x, y) => {\n        const view = viewRef.current;\n        const worldX = x / view.scale.x + view.x;\n        const worldY = y / view.scale.y + view.y;\n        return hitTestExtrasIn(worldX, worldY, view, dimsRef.current, helpersRef.current) !== null;\n      },\n    });\n  }, [viewRegistry, requestRedraw, hitTestExtrasIn, dimsRef, surfaceLayersRef, viewRef, helpersRef, clientToWorld]);\n}\n"],"mappings":";;;;;;;;;AA0BA,SAAgB,uBACd,cACA,QACA,OACA,UACM;CACN,MAAM,mBAAmB,UAA2C,MAAM;CAC1E,MAAM,EAAE,SAAS,SAAS,eAAe;CACzC,MAAM,EAAE,eAAe,iBAAiB,kBAAkB;CAC1D,gBAAgB;EACd,OAAO,cAAc,cAAc;GACjC,YAAY,QAAQ;GACpB,YAAY,QAAQ;GACpB,cAAc,iBAAiB;GAC/B;GACA,mBAAmB,WAAW,QAAS,eAAe;GACtD,eAAe;GACf;GACA,cAAc,GAAG,MAAM;IACrB,MAAM,OAAO,QAAQ;IACrB,MAAM,SAAS,IAAI,KAAK,MAAM,IAAI,KAAK;IACvC,MAAM,SAAS,IAAI,KAAK,MAAM,IAAI,KAAK;IACvC,OAAO,gBAAgB,QAAQ,QAAQ,MAAM,QAAQ,SAAS,WAAW,OAAO,MAAM;GACxF;EACF,CAAC;CACH,GAAG;EAAC;EAAc;EAAe;EAAiB;EAAS;EAAkB;EAAS;EAAY;CAAa,CAAC;AAClH"}

package/dist/canvas/viewInputs.js

@@ -1,17 +1,20 @@
-import { createContext as e, useContext as t } from "react";
-import { jsx as n } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+
 //#region src/canvas/viewInputs.tsx
-var r = e(null);
-function i({ value: e, children: t }) {
-	return /* @__PURE__ */ n(r.Provider, {
-		value: e,
-		children: t
+var ViewInputsContext = createContext(null);
+/** @internal */
+function ViewInputsProvider({ value, children }) {
+	return /* @__PURE__ */ jsx(ViewInputsContext.Provider, {
+		value,
+		children
 	});
 }
-function a() {
-	return t(r);
+/** The hosting surface's view-helper inputs, or `null` outside one. */
+function useOptionalViewInputs() {
+	return useContext(ViewInputsContext);
 }
-//#endregion
-export { i as ViewInputsProvider, a as useOptionalViewInputs };
 
+//#endregion
+export { ViewInputsProvider, useOptionalViewInputs };
 //# sourceMappingURL=viewInputs.js.map