@weasel-js/core 1.10.1 → 1.11.1

package/dist/canvas/SceneCanvas/useSceneSelectTool.js

@@ -1,92 +1,172 @@
-import { rectFromPlane as e } from "../../core/viewport/parallax.js";
-import { framedBounds as t, poseDescriptorForNode as n } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as r } from "../../core/geometry/autoPoseDescriptor.js";
-import { asNodeId as i } from "../../core/scene/types.js";
-import { pickWalk as a, scenePickSource as o, scenePlaneOf as s } from "../pickWalk.js";
-import { pickTopMostHit as c } from "../../tools/builtin/pickTopMostHit.js";
-import { useSelectTool as l } from "../../tools/builtin/select/useSelectTool.js";
-import { snap as u } from "../../interactions/gestures/shared/snap.js";
-import { scenePointQuery as d } from "./scenePointQuery.js";
-import { useMemo as f } from "react";
-import { useLatest as p } from "@weasel-js/react";
+import { rectFromPlane } from "../../core/viewport/parallax.js";
+import { AUTO_POSE_DESCRIPTOR } from "../../core/geometry/autoPoseDescriptor.js";
+import { drawnBoundsOf } from "../drawnBounds.js";
+import { asNodeId } from "../../core/scene/types.js";
+import { drawnBoundsScene } from "../derivedPath.js";
+import { pickWalk, scenePickSource, scenePlaneOf } from "../pickWalk.js";
+import { pickTopMostHit } from "../../tools/builtin/pickTopMostHit.js";
+import { useSelectTool } from "../../tools/builtin/select/useSelectTool.js";
+import { scenePointQuery } from "./scenePointQuery.js";
+import { useMemo } from "react";
+import { useKitSetting, useLatest } from "@weasel-js/react";
+
 //#region src/canvas/SceneCanvas/useSceneSelectTool.ts
-var m = 4;
-function h(e) {
-	return e && typeof e.x == "number" && typeof e.y == "number" ? {
-		x: e.x,
-		y: e.y,
-		scale: e.scale
+/**
+* Scene-aware select-tool synthesis for `<SceneCanvas>`: a `useSelectTool`
+* over the caller's scene adapter, configured with kit-default pickEvery /
+* boundsOf derived from pose shape. Caller-supplied `pickEvery` / `boundsOf`
+* overrides via the `geometry` arg take precedence.
+*/
+/**
+* Default grab slop around a shape's outline, in screen pixels.
+*
+* Four is the same number the path-pose stroke test has always used, and it's
+* the difference between a hairline being clickable and not: a 1px stroke is
+* half a world unit of reach at scale 1, which no pointing device can hit
+* reliably. It also lets a filled shape be grabbed a few pixels outside its
+* edge, which is what makes edge-adjacent dragging feel possible.
+*/
+var DEFAULT_PICK_TOLERANCE_PX = 4;
+/** A pick view that names a whole camera, or null. */
+function cameraOf(v) {
+	return v && typeof v.x === "number" && typeof v.y === "number" ? {
+		x: v.x,
+		y: v.y,
+		scale: v.scale
 	} : null;
 }
-function g(g) {
-	let { scene: _, adapter: v, geometry: y, selectTool: b, getView: x, alphaOf: S, layerIsPainted: C } = g, w = g.poseDescriptor ?? r, T = y?.pickEvery, E = y?.boundsOf, D = (y?.picking ?? "shape") === "shape", O = y?.pickTolerancePx ?? m, k = b?.move, A = b?.snap, j = f(() => {
-		let e = { ...k ?? {} };
-		if (A) {
-			let t = e.behaviors ?? [];
-			e.behaviors = [u(A), ...t];
-		}
-		return e;
-	}, [k, A]), M = f(() => (e, t, n) => {
-		if (T) {
-			let n = T(e, t);
-			return n == null ? [] : Array.isArray(n) ? n : [n];
-		}
-		let r = n ?? x?.() ?? null, i = n?.alphaOf ?? S, s = n?.layerIsPainted ?? C, c = h(r), l = o(_, {
-			getPose: (e) => v.getWorldPose(e),
-			...i ? { alphaOf: i } : {},
-			...s ? { layerIsPainted: s } : {},
-			...c ? { camera: c } : {}
-		}), u = d(w, D, O);
-		return a(l, u(e, t, r?.scale ?? {
-			x: 1,
-			y: 1
-		}));
+/** `id` drawn at `pose`, in world, as the chrome boxes it. */
+function chromeBox(scene, adapter, descriptor, includeStroke, id, pose, scale) {
+	return drawnBoundsOf(drawnBoundsScene(scene), asNodeId(id), pose, {
+		descriptor,
+		worldPoseOf: (m) => adapter.getWorldPose(m),
+		includeStroke,
+		...scale ? { scale } : {}
+	});
+}
+function useSceneSelectTool(args) {
+	const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted, isPointerInteractive } = args;
+	const d = args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+	const pickEveryProp = geometry?.pickEvery;
+	const boundsOfProp = geometry?.boundsOf;
+	const shapePicking = (geometry?.picking ?? "shape") === "shape";
+	const kitPickTolerancePx = useKitSetting("targets.pickTolerancePx");
+	const pickTolerancePx = geometry?.pickTolerancePx ?? kitPickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;
+	const includeStroke = geometry?.boundsIncludeStroke ?? true;
+	const moveOptions = opts?.move;
+	const wiredMoveOptions = useMemo(() => moveOptions ?? {}, [moveOptions]);
+	const wiredHitBody = usePointPick({
+		scene,
+		adapter,
+		d,
+		pickEveryProp,
+		shapePicking,
+		pickTolerancePx,
+		getView,
+		alphaOf,
+		layerIsPainted,
+		isPointerInteractive
+	});
+	const getViewRef = useLatest(getView);
+	const wiredPlaneOfNode = useMemo(() => {
+		return (id, view) => {
+			const n = scene.get(asNodeId(id));
+			const camera = cameraOf(view ?? getViewRef.current?.() ?? null);
+			if (!n || !camera) return null;
+			return scenePlaneOf(scene.layers, camera)?.(n.layer) ?? null;
+		};
+	}, [scene, getViewRef]);
+	const wiredBoundsOfPose = useMemo(() => {
+		return (id, pose, view) => {
+			if (!scene.get(asNodeId(id))) return null;
+			const scale = (view ?? getViewRef.current?.() ?? null)?.scale;
+			const own = chromeBox(scene, adapter, d, includeStroke, id, pose, scale);
+			const plane = wiredPlaneOfNode(id, view);
+			return plane ? rectFromPlane(plane, own) : own;
+		};
 	}, [
-		_,
-		v,
-		T,
-		D,
-		O,
-		x,
-		S,
-		C,
-		w
-	]), N = p(x), P = f(() => (e, t) => {
-		let n = _.get(i(e)), r = h(t ?? N.current?.() ?? null);
-		return !n || !r ? null : s(_.layers, r)?.(n.layer) ?? null;
-	}, [_, N]), F = f(() => (r, a, o) => {
-		let s = _.get(i(r));
-		if (!s) return null;
-		let c = t(a, n(w, s)), l = P(r, o);
-		return l ? e(l, c) : c;
+		scene,
+		adapter,
+		d,
+		includeStroke,
+		getViewRef,
+		wiredPlaneOfNode
+	]);
+	const wiredBoundsOf = useMemo(() => {
+		return (id, view) => {
+			if (boundsOfProp) return boundsOfProp(id);
+			if (!scene.get(asNodeId(id))) return null;
+			return wiredBoundsOfPose(id, adapter.getWorldPose(id), view);
+		};
 	}, [
-		_,
-		w,
-		P
-	]), I = f(() => (e, t) => E ? E(e) : _.get(i(e)) ? F(e, v.getWorldPose(e), t) : null, [
-		_,
-		v,
-		E,
-		F
+		scene,
+		adapter,
+		boundsOfProp,
+		wiredBoundsOfPose
 	]);
 	return {
-		selectTool: l(v, {
-			pickEvery: M,
-			...b?.pickBest ? { pickBest: b.pickBest } : {},
-			...b?.extendClickLocked ? { extendClickLocked: b.extendClickLocked } : {}
+		selectTool: useSelectTool(adapter, {
+			pickEvery: wiredHitBody,
+			...opts?.pickBest ? { pickBest: opts.pickBest } : {},
+			...opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}
 		}),
-		pickEvery: M,
-		pickBest: f(() => (e, t, n) => {
-			let r = M(e, t, n);
-			return c(r, v);
-		}, [M, v]),
-		boundsOf: I,
-		boundsOfPose: F,
-		planeOfNode: P,
-		moveOptions: j
+		pickEvery: wiredHitBody,
+		pickBest: useMemo(() => {
+			return (wx, wy, view) => {
+				const ids = wiredHitBody(wx, wy, view);
+				return pickTopMostHit(ids, adapter);
+			};
+		}, [wiredHitBody, adapter]),
+		boundsOf: wiredBoundsOf,
+		boundsOfPose: wiredBoundsOfPose,
+		planeOfNode: wiredPlaneOfNode,
+		moveOptions: wiredMoveOptions
 	};
 }
-//#endregion
-export { m as DEFAULT_PICK_TOLERANCE_PX, g as useSceneSelectTool };
+/** Every id under a world point, back-to-front: the caller's `geometry.pickEvery` or the pose
+*  walk, less whatever `isPointerInteractive` rejects. */
+function usePointPick(args) {
+	const { scene, adapter, d, pickEveryProp, shapePicking, pickTolerancePx, getView, alphaOf, layerIsPainted, isPointerInteractive } = args;
+	const walk = useMemo(() => {
+		return (wx, wy, view) => {
+			if (pickEveryProp) {
+				const r = pickEveryProp(wx, wy);
+				if (r == null) return [];
+				return Array.isArray(r) ? r : [r];
+			}
+			const asked = view ?? getView?.() ?? null;
+			const viewAlpha = view?.alphaOf ?? alphaOf;
+			const viewLayers = view?.layerIsPainted ?? layerIsPainted;
+			const camera = cameraOf(asked);
+			const src = scenePickSource(scene, {
+				getPose: (id) => adapter.getWorldPose(id),
+				...viewAlpha ? { alphaOf: viewAlpha } : {},
+				...viewLayers ? { layerIsPainted: viewLayers } : {},
+				...camera ? { camera } : {}
+			});
+			const pointQuery = scenePointQuery(d, shapePicking, pickTolerancePx);
+			return pickWalk(src, pointQuery(wx, wy, asked?.scale ?? {
+				x: 1,
+				y: 1
+			}));
+		};
+	}, [
+		scene,
+		adapter,
+		pickEveryProp,
+		shapePicking,
+		pickTolerancePx,
+		getView,
+		alphaOf,
+		layerIsPainted,
+		d
+	]);
+	return useMemo(() => {
+		if (!isPointerInteractive) return walk;
+		return (wx, wy, view) => walk(wx, wy, view).filter((id) => isPointerInteractive(id) !== false);
+	}, [walk, isPointerInteractive]);
+}
 
+//#endregion
+export { DEFAULT_PICK_TOLERANCE_PX, useSceneSelectTool };
 //# sourceMappingURL=useSceneSelectTool.js.map

package/dist/canvas/SceneCanvas/useSceneSelectTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSceneSelectTool.js","names":["snap","snapBehavior","DEFAULT_PICK_TOLERANCE_PX","cameraOf","v","useSceneSelectTool","opts","args","d","AUTO_POSE_DESCRIPTOR","pickEveryProp","geometry","boundsOfProp","shapePicking","pickTolerancePx","moveOptions","snap$1","wiredMoveOptions","useMemo","merged","existing","snap","wiredHitBody","r","wx","wy","asked","view","getView","viewAlpha","alphaOf","viewLayers","layerIsPainted","camera","src","scenePickSource","scene","adapter","id","pointQuery","scenePointQuery","pickWalk","getViewRef","useLatest","wiredPlaneOfNode","asNodeId","scenePlaneOf","wiredBoundsOfPose","n","own","framedBounds","pose","poseDescriptorForNode","plane","rectFromPlane","wiredBoundsOf","useSelectTool","ids","pickTopMostHit"],"sources":["../../../src/canvas/SceneCanvas/useSceneSelectTool.ts"],"sourcesContent":["/**\n * Scene-aware select-tool synthesis for `<SceneCanvas>`: a `useSelectTool`\n * over the caller's scene adapter, configured with kit-default pickEvery /\n * boundsOf derived from pose shape. Caller-supplied `pickEvery` / `boundsOf`\n * overrides via the `geometry` arg take precedence.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\nimport { pickWalk, scenePickSource, scenePlaneOf, type ViewPickGates } from 'canvas/pickWalk';\nimport { rectFromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { useSelectTool, type Bounds } from 'tools/builtin/select';\nimport { pickTopMostHit, type PickTopMostHitAdapter } from 'tools/builtin/pickTopMostHit';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport { snap as snapBehavior } from 'interactions/gestures/shared/snap';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { scenePointQuery } from './scenePointQuery';\n\n/**\n * Default grab slop around a shape's outline, in screen pixels.\n *\n * Four is the same number the path-pose stroke test has always used, and it's\n * the difference between a hairline being clickable and not: a 1px stroke is\n * half a world unit of reach at scale 1, which no pointing device can hit\n * reliably. It also lets a filled shape be grabbed a few pixels outside its\n * edge, which is what makes edge-adjacent dragging feel possible.\n */\nexport const DEFAULT_PICK_TOLERANCE_PX = 4;\n\n/** The view a pick is asked for. A world point carries neither the scale it\n *  was produced under nor what that view paints, so a caller picking for a\n *  view other than the surface's says both. A gate left out is the one this\n *  hook was built with. */\nexport interface PickView extends ViewPickGates {\n  scale: { x: number; y: number };\n  /** The rest of the asking camera. Supplied, it lets a parallax layer be\n   *  picked through its plane; left out, every layer is taken to move with\n   *  the camera. */\n  x?: number;\n  y?: number;\n}\n\n/** A pick view that names a whole camera, or null. */\nfunction cameraOf(v: Pick<PickView, 'scale' | 'x' | 'y'> | null): View | null {\n  return v && typeof v.x === 'number' && typeof v.y === 'number'\n    ? { x: v.x, y: v.y, scale: v.scale }\n    : null;\n}\n\nexport interface UseSceneSelectToolArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** The adapter the select tool drives, built over `scene` with the same\n   *  `poseDescriptor`. Its world poses are what picking and bounds read. */\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  geometry?: {\n    pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n    boundsOf?: (id: string) => Bounds | null;\n    /** How the default body-pick decides a node covers the pointer. Defaults\n     *  to `'shape'`; `'pose'` opts back down to the bare pose rect. See\n     *  `SceneCanvasProps.geometry.picking`. Ignored when `pickEvery` is\n     *  supplied — that override owns the whole test. */\n    picking?: 'pose' | 'shape';\n    /** Grab slop around a shape's outline, in screen pixels. See\n     *  `SceneCanvasProps.geometry.pickTolerancePx`. */\n    pickTolerancePx?: number;\n  };\n  /** The surface's camera, for converting the screen-pixel pick tolerance into\n   *  world units. A caller picking for another view passes that view's camera\n   *  to `pickEvery` / `pickBest` instead. Omitted in tests and non-viewport\n   *  hosts, where scale is 1. */\n  getView?: () => Pick<PickView, 'scale' | 'x' | 'y'> | null;\n  /** The asking view's painted alpha per node — its `alphaFor` times any\n   *  per-node override alpha. A node the view paints at alpha 0 is not on\n   *  screen, so picking must not answer for it. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\".\n   *  `layerVisibility` and `layerOrder` both gate a layer out of the paint\n   *  (`drawLayers` drops any layer missing from a supplied order), and an\n   *  undrawn layer must not claim clicks. */\n  layerIsPainted?: (layer: string) => boolean;\n  selectTool?: {\n    move?: UseMoveOptions<TPose>;\n    resize?: UseResizeOptions<TPose>;\n    snap?: SnapStrategy<TPose>;\n    /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n     *  the live alt state + current selection so consumers can implement\n     *  alt-cycling through an overlapping stack. Default: top-most hit\n     *  (alt ignored). Forwarded verbatim to `useSelectTool`. */\n    pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    /** Forwarded verbatim to `useSelectTool`. See\n     *  `UseSelectToolOptions.extendClickLocked`. */\n    extendClickLocked?: () => boolean;\n  };\n}\n\nexport interface UseSceneSelectToolReturn<TData, TLayer extends string, TPose> {\n  selectTool: ReturnType<typeof useSelectTool<Node<TData, TLayer, TPose>, TPose>>;\n  /** Every id under the world point, back-to-front (topmost last), from the\n   *  caller's `geometry.pickEvery` or the pose-walk default. */\n  pickEvery: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** Single-best hit under the world point, or null. Runs `pickEvery` then\n   *  collapses parent/child overlap via `pickTopMostHit` — matches the id\n   *  the select tool's pointerdown classifier would settle on for a bare\n   *  click. The canvas's `getNodeAtPoint` resolves through it. */\n  pickBest: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** World-space AABB of `id`, or null. Same as what the selection overlay +\n   *  affordance hit-test need. Exposed so SceneCanvas can pass it to the\n   *  `affordanceAt` thunk without re-deriving it. `view` is the camera the\n   *  box is drawn under — a plane node sits somewhere else in each — and\n   *  defaults to the surface's. */\n  boundsOf: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** How `view`'s world (the surface's camera by default) maps into the plane\n   *  `id` is drawn through, or null when its layer moves with the camera. */\n  planeOfNode: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) => PlaneMap | null;\n  /** `boundsOf` for `id` drawn at `pose` rather than its own — how chrome\n   *  boxes an in-flight preview. Ignores a `geometry.boundsOf` override, which\n   *  answers only for a node's own pose. */\n  boundsOfPose: (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** `selectTool.move` with `selectTool.snap` folded into its behaviors — what\n   *  the `move` preset's bindings carry. */\n  moveOptions: UseMoveOptions<TPose>;\n}\n\nexport function useSceneSelectTool<TData, TLayer extends string, TPose>(\n  args: UseSceneSelectToolArgs<TData, TLayer, TPose>,\n): UseSceneSelectToolReturn<TData, TLayer, TPose> {\n  const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted } = args;\n  const d = (args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const pickEveryProp = geometry?.pickEvery;\n  const boundsOfProp = geometry?.boundsOf;\n  // Default. The pose rect is the wrong answer for anything that isn't a\n  // rectangle, so `'pose'` is the opt-out rather than the baseline. Cheap to\n  // leave on: the rect pre-filter runs first and rejects every node the\n  // pointer isn't over, and the survivors' silhouettes are memoized per node.\n  const shapePicking = (geometry?.picking ?? 'shape') === 'shape';\n  const pickTolerancePx = geometry?.pickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;\n  const moveOptions = opts?.move;\n  const snap = opts?.snap;\n\n  const wiredMoveOptions = useMemo<UseMoveOptions<TPose>>(() => {\n    const merged: UseMoveOptions<TPose> = { ...(moveOptions ?? {}) };\n    if (snap) {\n      const existing = merged.behaviors ?? [];\n      merged.behaviors = [snapBehavior(snap), ...existing];\n    }\n    return merged;\n  }, [moveOptions, snap]);\n\n  // Default pickEvery: walk renderOrder() forward (back-to-front) and collect\n  // every node whose pose contains the world point. Order matches the\n  // `useSelectTool` contract — last element is the topmost — so `pickTopMostHit`\n  // picks correctly. Wraps the caller's `pickEvery` (string-or-null) into the\n  // array form `useSelectTool` expects. `poseContainsRotated` reads\n  // `pose.rotation` directly (the kit's one rotation convention), so rotated\n  // shapes pick against their rendered, rotated body without a per-demo override.\n  const wiredHitBody = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string[] => {\n      if (pickEveryProp) {\n        const r = pickEveryProp(wx, wy);\n        if (r == null) return [];\n        return Array.isArray(r) ? r : [r];\n      }\n      const asked = view ?? getView?.() ?? null;\n      const viewAlpha = view?.alphaOf ?? alphaOf;\n      const viewLayers = view?.layerIsPainted ?? layerIsPainted;\n      const camera = cameraOf(asked);\n      // Through the adapter, not `n.pose`: an ephemeral override is the pose\n      // the renderer draws, so it has to be the one picking tests. World, not\n      // local, for the same reason — a framed child is drawn in its parent's\n      // frame, not where its own pose says.\n      const src = scenePickSource<TData, TLayer, TPose>(scene, {\n        getPose: (id) => adapter.getWorldPose(id),\n        ...(viewAlpha ? { alphaOf: viewAlpha } : {}),\n        ...(viewLayers ? { layerIsPainted: viewLayers } : {}),\n        ...(camera ? { camera } : {}),\n      });\n      const pointQuery = scenePointQuery<TPose>(d as PoseDescriptor<unknown>, shapePicking, pickTolerancePx);\n      return pickWalk<TPose>(src, pointQuery(wx, wy, asked?.scale ?? { x: 1, y: 1 }));\n    };\n  }, [scene, adapter, pickEveryProp, shapePicking, pickTolerancePx, getView,\n      alphaOf, layerIsPainted, d]);\n\n  // Read through a ref: this is the chrome's bounds source, and a caller's\n  // inline `getView` would otherwise rebuild it, and everything keyed on it,\n  // every render.\n  const getViewRef = useLatest(getView);\n  const wiredPlaneOfNode = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): PlaneMap | null => {\n      const n = scene.get(asNodeId(id));\n      const camera = cameraOf(view ?? getViewRef.current?.() ?? null);\n      if (!n || !camera) return null;\n      return scenePlaneOf(scene.layers, camera)?.(n.layer) ?? null;\n    };\n  }, [scene, getViewRef]);\n\n  const wiredBoundsOfPose = useMemo(() => {\n    return (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      const n = scene.get(asNodeId(id));\n      if (!n) return null;\n      const own = framedBounds(pose, poseDescriptorForNode(d, n));\n      // A plane node is drawn where its plane puts it, and the chrome has to\n      // follow it there.\n      const plane = wiredPlaneOfNode(id, view);\n      return plane ? rectFromPlane(plane, own) : own;\n    };\n  }, [scene, d, wiredPlaneOfNode]);\n\n  const wiredBoundsOf = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      if (boundsOfProp) return boundsOfProp(id);\n      if (!scene.get(asNodeId(id))) return null;\n      // World, not local: a framed child is drawn in its parent's frame, and\n      // the chrome has to land on the ink.\n      return wiredBoundsOfPose(id, adapter.getWorldPose(id), view);\n    };\n  }, [scene, adapter, boundsOfProp, wiredBoundsOfPose]);\n\n  const selectTool = useSelectTool<Node<TData, TLayer, TPose>, TPose>(adapter, {\n    pickEvery: wiredHitBody,\n    ...(opts?.pickBest ? { pickBest: opts.pickBest } : {}),\n    ...(opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}),\n  });\n\n\n  const wiredPickBest = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string | null => {\n      const ids = wiredHitBody(wx, wy, view);\n      return pickTopMostHit(ids, adapter as unknown as PickTopMostHitAdapter);\n    };\n  }, [wiredHitBody, adapter]);\n\n  return {\n    selectTool,\n    pickEvery: wiredHitBody,\n    pickBest: wiredPickBest,\n    boundsOf: wiredBoundsOf,\n    boundsOfPose: wiredBoundsOfPose,\n    planeOfNode: wiredPlaneOfNode,\n    moveOptions: wiredMoveOptions,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"useSceneSelectTool.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneSelectTool.ts"],"sourcesContent":["/**\n * Scene-aware select-tool synthesis for `<SceneCanvas>`: a `useSelectTool`\n * over the caller's scene adapter, configured with kit-default pickEvery /\n * boundsOf derived from pose shape. Caller-supplied `pickEvery` / `boundsOf`\n * overrides via the `geometry` arg take precedence.\n */\nimport { drawnBoundsScene } from '../derivedPath';\nimport { useMemo } from 'react';\nimport { useKitSetting, useLatest } from '@weasel-js/react';\nimport type { SceneCanvasAdapter } from '../sceneAdapter';\nimport { pickWalk, scenePickSource, scenePlaneOf, type ViewPickGates } from 'canvas/pickWalk';\nimport { rectFromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { useSelectTool, type Bounds } from 'tools/builtin/select';\nimport { pickTopMostHit, type PickTopMostHitAdapter } from 'tools/builtin/pickTopMostHit';\nimport type { Node, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { drawnBoundsOf } from 'canvas/drawnBounds';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { scenePointQuery } from './scenePointQuery';\nimport type { SceneCanvasGeometry } from './geometryProps';\n\n/**\n * Default grab slop around a shape's outline, in screen pixels.\n *\n * Four is the same number the path-pose stroke test has always used, and it's\n * the difference between a hairline being clickable and not: a 1px stroke is\n * half a world unit of reach at scale 1, which no pointing device can hit\n * reliably. It also lets a filled shape be grabbed a few pixels outside its\n * edge, which is what makes edge-adjacent dragging feel possible.\n */\nexport const DEFAULT_PICK_TOLERANCE_PX = 4;\n\n/** The view a pick is asked for. A world point carries neither the scale it\n *  was produced under nor what that view paints, so a caller picking for a\n *  view other than the surface's says both. A gate left out is the one this\n *  hook was built with. */\nexport interface PickView extends ViewPickGates {\n  scale: { x: number; y: number };\n  /** The rest of the asking camera. Supplied, it lets a parallax layer be\n   *  picked through its plane; left out, every layer is taken to move with\n   *  the camera. */\n  x?: number;\n  y?: number;\n}\n\n/** A pick view that names a whole camera, or null. */\nfunction cameraOf(v: Pick<PickView, 'scale' | 'x' | 'y'> | null): View | null {\n  return v && typeof v.x === 'number' && typeof v.y === 'number'\n    ? { x: v.x, y: v.y, scale: v.scale }\n    : null;\n}\n\nexport interface UseSceneSelectToolArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** The adapter the select tool drives, built over `scene` with the same\n   *  `poseDescriptor`. Its world poses are what picking and bounds read. */\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  geometry?: SceneCanvasGeometry;\n  /** The surface's camera, for converting the screen-pixel pick tolerance into\n   *  world units. A caller picking for another view passes that view's camera\n   *  to `pickEvery` / `pickBest` instead. Omitted in tests and non-viewport\n   *  hosts, where scale is 1. */\n  getView?: () => Pick<PickView, 'scale' | 'x' | 'y'> | null;\n  /** The asking view's painted alpha per node — its `alphaFor` times any\n   *  per-node override alpha. A node the view paints at alpha 0 is not on\n   *  screen, so picking must not answer for it. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\".\n   *  `layerVisibility` and `layerOrder` both gate a layer out of the paint\n   *  (`drawLayers` drops any layer missing from a supplied order), and an\n   *  undrawn layer must not claim clicks. */\n  layerIsPainted?: (layer: string) => boolean;\n  /** `<SceneCanvas isPointerInteractive>`: a node it rejects is left out of every hit, so\n   *  whatever is beneath it answers instead. */\n  isPointerInteractive?: (id: string) => boolean;\n  selectTool?: {\n    move?: UseMoveOptions<TPose>;\n    resize?: UseResizeOptions<TPose>;\n    /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n     *  the live alt state + current selection so consumers can implement\n     *  alt-cycling through an overlapping stack. Default: top-most hit\n     *  (alt ignored). Forwarded verbatim to `useSelectTool`. */\n    pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    /** Forwarded verbatim to `useSelectTool`. See\n     *  `UseSelectToolOptions.extendClickLocked`. */\n    extendClickLocked?: () => boolean;\n  };\n}\n\n/** `id` drawn at `pose`, in world, as the chrome boxes it. */\nfunction chromeBox<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>,\n  descriptor: PoseDescriptor<TPose>,\n  includeStroke: boolean,\n  id: string,\n  pose: TPose,\n  scale: { x: number; y: number } | undefined,\n): Bounds {\n  return drawnBoundsOf(drawnBoundsScene(scene), asNodeId(id), pose, {\n    descriptor: descriptor as PoseDescriptor<unknown>,\n    worldPoseOf: (m) => adapter.getWorldPose(m),\n    includeStroke,\n    ...(scale ? { scale } : {}),\n  });\n}\n\nexport interface UseSceneSelectToolReturn<TData, TLayer extends string, TPose> {\n  selectTool: ReturnType<typeof useSelectTool<Node<TData, TLayer, TPose>, TPose>>;\n  /** Every id under the world point, back-to-front (topmost last), from the\n   *  caller's `geometry.pickEvery` or the pose-walk default. */\n  pickEvery: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** Single-best hit under the world point, or null. Runs `pickEvery` then\n   *  collapses parent/child overlap via `pickTopMostHit` — matches the id\n   *  the select tool's pointerdown classifier would settle on for a bare\n   *  click. The canvas's `getNodeAtPoint` resolves through it. */\n  pickBest: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** World-space AABB of `id`, or null. Same as what the selection overlay +\n   *  affordance hit-test need. Exposed so SceneCanvas can pass it to the\n   *  `affordanceAt` thunk without re-deriving it. `view` is the camera the\n   *  box is drawn under — a plane node sits somewhere else in each — and\n   *  defaults to the surface's. */\n  boundsOf: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** How `view`'s world (the surface's camera by default) maps into the plane\n   *  `id` is drawn through, or null when its layer moves with the camera. */\n  planeOfNode: (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) => PlaneMap | null;\n  /** `boundsOf` for `id` drawn at `pose` rather than its own — how chrome\n   *  boxes an in-flight preview. Ignores a `geometry.boundsOf` override, which\n   *  answers only for a node's own pose. */\n  boundsOfPose: (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null) =>\n    import('core/viewport/fitViewToBounds').Bounds | null;\n  /** `selectTool.move` — what the `move` preset's bindings carry. */\n  moveOptions: UseMoveOptions<TPose>;\n}\n\nexport function useSceneSelectTool<TData, TLayer extends string, TPose>(\n  args: UseSceneSelectToolArgs<TData, TLayer, TPose>,\n): UseSceneSelectToolReturn<TData, TLayer, TPose> {\n  const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted, isPointerInteractive } = args;\n  const d = (args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const pickEveryProp = geometry?.pickEvery;\n  const boundsOfProp = geometry?.boundsOf;\n  // Default. The pose rect is the wrong answer for anything that isn't a rectangle, so `'pose'`\n  // is the opt-out rather than the baseline. Cheap to leave on: the rect pre-filter rejects every\n  // node the pointer isn't over first, and the survivors' silhouettes are memoized per node.\n  const shapePicking = (geometry?.picking ?? 'shape') === 'shape';\n  const kitPickTolerancePx = useKitSetting('targets.pickTolerancePx');\n  const pickTolerancePx = geometry?.pickTolerancePx ?? kitPickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;\n  const includeStroke = geometry?.boundsIncludeStroke ?? true;\n  const moveOptions = opts?.move;\n  const wiredMoveOptions = useMemo<UseMoveOptions<TPose>>(() => moveOptions ?? {}, [moveOptions]);\n\n  const wiredHitBody = usePointPick({\n    scene, adapter, d, pickEveryProp, shapePicking, pickTolerancePx, getView,\n    alphaOf, layerIsPainted, isPointerInteractive,\n  });\n\n  // Read through a ref: this is the chrome's bounds source, and a caller's\n  // inline `getView` would otherwise rebuild it, and everything keyed on it,\n  // every render.\n  const getViewRef = useLatest(getView);\n  const wiredPlaneOfNode = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): PlaneMap | null => {\n      const n = scene.get(asNodeId(id));\n      const camera = cameraOf(view ?? getViewRef.current?.() ?? null);\n      if (!n || !camera) return null;\n      return scenePlaneOf(scene.layers, camera)?.(n.layer) ?? null;\n    };\n  }, [scene, getViewRef]);\n\n  const wiredBoundsOfPose = useMemo(() => {\n    return (id: string, pose: TPose, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      if (!scene.get(asNodeId(id))) return null;\n      const scale = (view ?? getViewRef.current?.() ?? null)?.scale;\n      const own = chromeBox(scene, adapter, d, includeStroke, id, pose, scale);\n      // A plane node is drawn where its plane puts it, and the chrome has to\n      // follow it there.\n      const plane = wiredPlaneOfNode(id, view);\n      return plane ? rectFromPlane(plane, own) : own;\n    };\n  }, [scene, adapter, d, includeStroke, getViewRef, wiredPlaneOfNode]);\n\n  const wiredBoundsOf = useMemo(() => {\n    return (id: string, view?: Pick<PickView, 'scale' | 'x' | 'y'> | null): Bounds | null => {\n      if (boundsOfProp) return boundsOfProp(id);\n      if (!scene.get(asNodeId(id))) return null;\n      // World, not local: a framed child is drawn in its parent's frame, and\n      // the chrome has to land on the ink.\n      return wiredBoundsOfPose(id, adapter.getWorldPose(id), view);\n    };\n  }, [scene, adapter, boundsOfProp, wiredBoundsOfPose]);\n\n  const selectTool = useSelectTool<Node<TData, TLayer, TPose>, TPose>(adapter, {\n    pickEvery: wiredHitBody,\n    ...(opts?.pickBest ? { pickBest: opts.pickBest } : {}),\n    ...(opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}),\n  });\n\n\n  const wiredPickBest = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string | null => {\n      const ids = wiredHitBody(wx, wy, view);\n      return pickTopMostHit(ids, adapter as unknown as PickTopMostHitAdapter);\n    };\n  }, [wiredHitBody, adapter]);\n\n  return {\n    selectTool,\n    pickEvery: wiredHitBody,\n    pickBest: wiredPickBest,\n    boundsOf: wiredBoundsOf,\n    boundsOfPose: wiredBoundsOfPose,\n    planeOfNode: wiredPlaneOfNode,\n    moveOptions: wiredMoveOptions,\n  };\n}\n\n/** Every id under a world point, back-to-front: the caller's `geometry.pickEvery` or the pose\n *  walk, less whatever `isPointerInteractive` rejects. */\nfunction usePointPick<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: SceneCanvasAdapter<TData, TLayer, TPose>;\n  d: PoseDescriptor<TPose>;\n  pickEveryProp: SceneCanvasGeometry['pickEvery'];\n  shapePicking: boolean;\n  pickTolerancePx: number;\n  getView: UseSceneSelectToolArgs<TData, TLayer, TPose>['getView'];\n  alphaOf: ((id: string) => number) | undefined;\n  layerIsPainted: ((layer: string) => boolean) | undefined;\n  isPointerInteractive: ((id: string) => boolean) | undefined;\n}): (wx: number, wy: number, view?: PickView | null) => string[] {\n  const {\n    scene, adapter, d, pickEveryProp, shapePicking, pickTolerancePx, getView,\n    alphaOf, layerIsPainted, isPointerInteractive,\n  } = args;\n  // Default pickEvery: walk renderOrder() forward (back-to-front) and collect\n  // every node whose pose contains the world point. Order matches the\n  // `useSelectTool` contract — last element is the topmost — so `pickTopMostHit`\n  // picks correctly. Wraps the caller's `pickEvery` (string-or-null) into the\n  // array form `useSelectTool` expects. `poseContainsRotated` reads\n  // `pose.rotation` directly (the kit's one rotation convention), so rotated\n  // shapes pick against their rendered, rotated body without a per-demo override.\n  const walk = useMemo(() => {\n    return (wx: number, wy: number, view?: PickView | null): string[] => {\n      if (pickEveryProp) {\n        const r = pickEveryProp(wx, wy);\n        if (r == null) return [];\n        return Array.isArray(r) ? r : [r];\n      }\n      const asked = view ?? getView?.() ?? null;\n      const viewAlpha = view?.alphaOf ?? alphaOf;\n      const viewLayers = view?.layerIsPainted ?? layerIsPainted;\n      const camera = cameraOf(asked);\n      // Through the adapter, not `n.pose`: an ephemeral override is the pose\n      // the renderer draws, so it has to be the one picking tests. World, not\n      // local, for the same reason — a framed child is drawn in its parent's\n      // frame, not where its own pose says.\n      const src = scenePickSource<TData, TLayer, TPose>(scene, {\n        getPose: (id) => adapter.getWorldPose(id),\n        ...(viewAlpha ? { alphaOf: viewAlpha } : {}),\n        ...(viewLayers ? { layerIsPainted: viewLayers } : {}),\n        ...(camera ? { camera } : {}),\n      });\n      const pointQuery = scenePointQuery<TPose>(d as PoseDescriptor<unknown>, shapePicking, pickTolerancePx);\n      return pickWalk<TPose>(src, pointQuery(wx, wy, asked?.scale ?? { x: 1, y: 1 }));\n    };\n  }, [scene, adapter, pickEveryProp, shapePicking, pickTolerancePx, getView,\n      alphaOf, layerIsPainted, d]);\n  const wiredHitBody = useMemo(() => {\n    if (!isPointerInteractive) return walk;\n    return (wx: number, wy: number, view?: PickView | null): string[] =>\n      walk(wx, wy, view).filter((id) => isPointerInteractive(id) !== false);\n  }, [walk, isPointerInteractive]);\n  return wiredHitBody;\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useSceneSlotLayers.js

@@ -1,37 +1,49 @@
-import { isCustomEntry as e } from "../layerSlots.js";
-import { buildSceneLayers as t } from "../buildSceneLayer.js";
-import { wireSceneSlotToScene as n } from "../sceneSlotWiring.js";
-import { useSceneLayerList as r } from "../useSceneLayerList.js";
-import { useMemo as i } from "react";
+import { isCustomEntry } from "../layerSlots.js";
+import { buildSceneLayers } from "../buildSceneLayer.js";
+import { wireSceneSlotToScene } from "../sceneSlotWiring.js";
+import { useSceneLayerList } from "../useSceneLayerList.js";
+import { useMemo } from "react";
+
 //#region src/canvas/SceneCanvas/useSceneSlotLayers.ts
-function a(a) {
-	let { slot: o, scene: s, adapter: c, alphaFor: l, colorOverrides: u, boundsOf: d, previewIds: f } = a, p = i(() => !o || e(o) ? o : n(o, s, l, u), [
-		o,
-		l,
-		s,
-		u
-	]), m = r(c);
+/**
+* The scene slot, built: the caller's config wired to the scene, and the
+* canvas layers it paints as. A hierarchical scene gets one canvas layer per
+* scene layer, so the list follows the scene's layers after mount.
+*/
+function useSceneSlotLayers(args) {
+	const { slot, scene, adapter, alphaFor, colorOverrides, boundsOf, previewIds } = args;
+	const config = useMemo(() => {
+		if (!slot || isCustomEntry(slot)) return slot;
+		return wireSceneSlotToScene(slot, scene, alphaFor, colorOverrides);
+	}, [
+		slot,
+		alphaFor,
+		scene,
+		colorOverrides
+	]);
+	const sceneLayersKey = useSceneLayerList(adapter);
 	return {
-		config: p,
-		layers: i(() => {
-			if (e(p)) return { layers: [{
+		config,
+		layers: useMemo(() => {
+			if (isCustomEntry(config)) return { layers: [{
 				key: "scene",
-				layer: p.layer
+				layer: config.layer
 			}] };
-			if (p && p.drawOne) return { layers: t(p, c, d, () => {
-				let e = new Set(f() ?? []);
-				return e.size > 0 ? e : null;
+			if (!config || !config.drawOne) return void 0;
+			return { layers: buildSceneLayers(config, adapter, boundsOf, () => {
+				const ids = new Set(previewIds() ?? []);
+				return ids.size > 0 ? ids : null;
 			}) };
 		}, [
-			p,
-			c,
-			d,
-			f,
-			m
+			config,
+			adapter,
+			boundsOf,
+			previewIds,
+			sceneLayersKey
 		])
 	};
 }
-//#endregion
-export { a as useSceneSlotLayers };
 
+//#endregion
+export { useSceneSlotLayers };
 //# sourceMappingURL=useSceneSlotLayers.js.map

package/dist/canvas/SceneCanvas/useSceneSlotLayers.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSceneSlotLayers.js","names":["useSceneSlotLayers","args","config","useMemo","slot","isCustomEntry","wireSceneSlotToScene","scene","alphaFor","colorOverrides","sceneLayersKey","useSceneLayerList","adapter","buildSceneLayers","boundsOf","ids","previewIds"],"sources":["../../../src/canvas/SceneCanvas/useSceneSlotLayers.ts"],"sourcesContent":["/**\n * The scene slot, built: the caller's config wired to the scene, and the\n * canvas layers it paints as. A hierarchical scene gets one canvas layer per\n * scene layer, so the list follows the scene's layers after mount.\n */\nimport { useMemo } from 'react';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { Node, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { buildSceneLayers, type SceneSlotConfig } from '../buildSceneLayer';\nimport type { HierarchicalAdapter } from '../buildSceneTree';\nimport { isCustomEntry, type LayersMap, type SceneSlotLayers } from '../layerSlots';\nimport { wireSceneSlotToScene } from '../sceneSlotWiring';\nimport { useSceneLayerList } from '../useSceneLayerList';\n\ntype SceneSlot<TData, TLayer extends string, TPose> =\n  LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n\nexport function useSceneSlotLayers<TData, TLayer extends string, TPose>(args: {\n  /** The slot after `mergeLayersWithDefaults`. */\n  slot: SceneSlot<TData, TLayer, TPose>;\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n  alphaFor: ((id: string) => number) | undefined;\n  colorOverrides: ColorOverrideRegistry | undefined;\n  /** Committed bounds of a node, for the debug overlay's record of it. */\n  boundsOf: (id: string) => Bounds | null;\n  /** Ids an in-flight gesture is ghosting; their committed paint is left out\n   *  so the source does not show through the ghost. */\n  previewIds: () => Iterable<string> | null;\n}): {\n  /** The scene-wired config, for whatever else paints with its `drawOne`. */\n  config: SceneSlot<TData, TLayer, TPose>;\n  /** Absent when the slot is empty or carries no `drawOne`; a pre-built layer is the whole slot. */\n  layers: SceneSlotLayers | undefined;\n} {\n  const { slot, scene, adapter, alphaFor, colorOverrides, boundsOf, previewIds } = args;\n\n  const config = useMemo(() => {\n    if (!slot || isCustomEntry(slot)) return slot;\n    return wireSceneSlotToScene(\n      slot as SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n      scene,\n      alphaFor,\n      colorOverrides,\n    );\n  }, [slot, alphaFor, scene, colorOverrides]);\n\n  const sceneLayersKey = useSceneLayerList(adapter);\n  const layers = useMemo<SceneSlotLayers | undefined>(() => {\n    if (isCustomEntry(config)) return { layers: [{ key: 'scene', layer: config.layer }] };\n    if (!config || !config.drawOne) return undefined;\n    return {\n      layers: buildSceneLayers(config, adapter, boundsOf, () => {\n        const ids = new Set(previewIds() ?? []);\n        return ids.size > 0 ? ids : null;\n      }),\n    };\n    // `sceneLayersKey` stands for `adapter.getLayers()`, which `buildSceneLayers` reads.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [config, adapter, boundsOf, previewIds, sceneLayersKey]);\n\n  return { config, layers };\n}\n"],"mappings":";;;;;;AAkBA,SAAgBA,EAAwD,GAiBtE;CACA,IAAM,EAAE,SAAM,UAAO,YAAS,aAAU,mBAAgB,aAAU,kBAAeC,GAE3EC,IAASC,QACT,CAACC,KAAQC,EAAcD,CAAI,IAAUA,IAClCE,EACLF,GACAG,GACAC,GACAC,CACF,GACC;EAACL;EAAMI;EAAUD;EAAOE;CAAc,CAAC,GAEpCC,IAAiBC,EAAkBC,CAAO;CAchD,OAAO;EAAE;EAAQ,QAbFT,QAA2C;GACxD,IAAIE,EAAcH,CAAM,GAAG,OAAO,EAAE,QAAQ,CAAC;IAAE,KAAK;IAAS,OAAOA,EAAO;GAAM,CAAC,EAAE;GACpF,IAAKA,KAAWA,EAAO,SACvB,OAAO,EACL,QAAQW,EAAiBX,GAAQU,GAASE,SAAgB;IACxD,IAAMC,IAAM,IAAI,IAAIC,EAAW,KAAK,CAAC,CAAC;IACtC,OAAOD,EAAI,OAAO,IAAIA,IAAM;GAC9B,CAAC,EACH;EAGF,GAAG;GAACb;GAAQU;GAASE;GAAUE;GAAYN;EAAc,CAExC;CAAO;AAC1B"}
+{"version":3,"file":"useSceneSlotLayers.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneSlotLayers.ts"],"sourcesContent":["/**\n * The scene slot, built: the caller's config wired to the scene, and the\n * canvas layers it paints as. A hierarchical scene gets one canvas layer per\n * scene layer, so the list follows the scene's layers after mount.\n */\nimport { useMemo } from 'react';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { Node, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { buildSceneLayers, type SceneSlotConfig } from '../buildSceneLayer';\nimport type { HierarchicalAdapter } from '../buildSceneTree';\nimport { isCustomEntry, type LayersMap, type SceneSlotLayers } from '../layerSlots';\nimport { wireSceneSlotToScene } from '../sceneSlotWiring';\nimport { useSceneLayerList } from '../useSceneLayerList';\n\ntype SceneSlot<TData, TLayer extends string, TPose> =\n  LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n\nexport function useSceneSlotLayers<TData, TLayer extends string, TPose>(args: {\n  /** The slot after `mergeLayersWithDefaults`. */\n  slot: SceneSlot<TData, TLayer, TPose>;\n  scene: Scene<TData, TLayer, TPose>;\n  adapter: HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n  alphaFor: ((id: string) => number) | undefined;\n  colorOverrides: ColorOverrideRegistry | undefined;\n  /** Committed bounds of a node, for the debug overlay's record of it. */\n  boundsOf: (id: string) => Bounds | null;\n  /** Ids an in-flight gesture is ghosting; their committed paint is left out\n   *  so the source does not show through the ghost. */\n  previewIds: () => Iterable<string> | null;\n}): {\n  /** The scene-wired config, for whatever else paints with its `drawOne`. */\n  config: SceneSlot<TData, TLayer, TPose>;\n  /** Absent when the slot is empty or carries no `drawOne`; a pre-built layer is the whole slot. */\n  layers: SceneSlotLayers | undefined;\n} {\n  const { slot, scene, adapter, alphaFor, colorOverrides, boundsOf, previewIds } = args;\n\n  const config = useMemo(() => {\n    if (!slot || isCustomEntry(slot)) return slot;\n    return wireSceneSlotToScene(\n      slot as SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n      scene,\n      alphaFor,\n      colorOverrides,\n    );\n  }, [slot, alphaFor, scene, colorOverrides]);\n\n  const sceneLayersKey = useSceneLayerList(adapter);\n  const layers = useMemo<SceneSlotLayers | undefined>(() => {\n    if (isCustomEntry(config)) return { layers: [{ key: 'scene', layer: config.layer }] };\n    if (!config || !config.drawOne) return undefined;\n    return {\n      layers: buildSceneLayers(config, adapter, boundsOf, () => {\n        const ids = new Set(previewIds() ?? []);\n        return ids.size > 0 ? ids : null;\n      }),\n    };\n    // `sceneLayersKey` stands for `adapter.getLayers()`, which `buildSceneLayers` reads.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [config, adapter, boundsOf, previewIds, sceneLayersKey]);\n\n  return { config, layers };\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,SAAgB,mBAAwD,MAiBtE;CACA,MAAM,EAAE,MAAM,OAAO,SAAS,UAAU,gBAAgB,UAAU,eAAe;CAEjF,MAAM,SAAS,cAAc;EAC3B,IAAI,CAAC,QAAQ,cAAc,IAAI,GAAG,OAAO;EACzC,OAAO,qBACL,MACA,OACA,UACA,cACF;CACF,GAAG;EAAC;EAAM;EAAU;EAAO;CAAc,CAAC;CAE1C,MAAM,iBAAiB,kBAAkB,OAAO;CAchD,OAAO;EAAE;EAAQ,QAbF,cAA2C;GACxD,IAAI,cAAc,MAAM,GAAG,OAAO,EAAE,QAAQ,CAAC;IAAE,KAAK;IAAS,OAAO,OAAO;GAAM,CAAC,EAAE;GACpF,IAAI,CAAC,UAAU,CAAC,OAAO,SAAS,OAAO;GACvC,OAAO,EACL,QAAQ,iBAAiB,QAAQ,SAAS,gBAAgB;IACxD,MAAM,MAAM,IAAI,IAAI,WAAW,KAAK,CAAC,CAAC;IACtC,OAAO,IAAI,OAAO,IAAI,MAAM;GAC9B,CAAC,EACH;EAGF,GAAG;GAAC;GAAQ;GAAS;GAAU;GAAY;EAAc,CAExC;CAAO;AAC1B"}

package/dist/canvas/SceneCanvas/useSceneStandardActions.js

@@ -0,0 +1,107 @@
+import { useDecayLoop } from "../../core/viewport/useDecayLoop.js";
+import { drawnBoxes } from "../../interactions/actions/drawnBoxes.js";
+import { useActionSet, useStandardDeps } from "../../interactions/actions/useActionSet.js";
+import { usePoseDescriptorDepSource } from "../deps/poseDescriptor.js";
+import { useViewDepSource } from "../deps/view.js";
+import { useAreaSelectDepSource } from "../deps/areaSelect.js";
+import { useNodeAtPointDepSource } from "../deps/nodeAtPoint.js";
+import { useLassoSelectDepSource } from "../deps/lassoSelect.js";
+import { useTextEditDepSource } from "../deps/textEdit.js";
+import { useEditAnchorsDepSource } from "../deps/editAnchors.js";
+import { useInsertDepSource } from "../deps/insert.js";
+import { useSnapDepSource } from "../deps/snap.js";
+import { usePathLeafDepSources } from "../deps/pathLeafDeps.js";
+import { useDebugDepSource } from "../deps/debug.js";
+import { usePreviewPathsDepSource } from "../deps/previewPaths.js";
+import { useSurfaceDepSources } from "../deps/surface.js";
+import { useDepChangeNotices } from "../deps/changes.js";
+import { useDispatcherDepSource } from "../deps/dispatcher.js";
+import { useLayoutDepSource } from "../deps/layout.js";
+import { useIngestionDepSource } from "../deps/ingestion.js";
+import { useActionsPropResolver } from "./useActionsPropResolver.js";
+import { useActionTunings } from "./useActionTunings.js";
+import { useViewportActions, viewportZoomOption } from "./useViewportActions.js";
+import { useEffect, useMemo } from "react";
+import { useActionsRegistry, useDepSource } from "@weasel-js/routing/react";
+
+//#region src/canvas/SceneCanvas/useSceneStandardActions.ts
+/**
+* Registers this canvas's standard actions, and the deps they read, into its
+* input scope, then applies the `actions` prop and `tune` over them.
+*
+* Called from a component ahead of `<SceneCanvas>`'s children, never from the
+* canvas's own body: registrations stack newest-live in effect order, and a
+* parent's effects run after its children's, so a child's override would lose.
+*/
+function useSceneStandardActions(inputs) {
+	const { props, viewOn, selection, scene, adapter, standardActions, currentViewRef, onViewChange, poseDescriptor, dispatcher, pickEvery, layerIsPainted, alphaOf, viewAnimation, editAnchorsExternalState, snap, canvasRef, canvasApiRef, ingestionClipboard } = inputs;
+	const { tune, viewport, ingestion } = props;
+	const boundsIncludeStroke = props.geometry?.boundsIncludeStroke ?? true;
+	const reflowTransition = props.reflowTransition;
+	const viewportZoom = useMemo(() => viewportZoomOption(viewport?.zoom, viewport?.animatedZoom), [viewport?.zoom, viewport?.animatedZoom]);
+	const registry = useActionsRegistry();
+	useEffect(() => {
+		if (!registry) return;
+		return registry.setDispatcher(dispatcher);
+	}, [registry, dispatcher]);
+	const decayLoop = useDecayLoop();
+	const view = useViewDepSource(currentViewRef, onViewChange, viewport?.recenter, () => {
+		const el = canvasRef.current;
+		return el ? {
+			width: el.clientWidth,
+			height: el.clientHeight
+		} : null;
+	}, viewAnimation, decayLoop, layerIsPainted);
+	useStandardDeps({
+		selection,
+		scene,
+		view,
+		history: scene.history
+	});
+	useActionSet(standardActions);
+	useDepSource("rootView", () => view);
+	useSurfaceDepSources(canvasRef, currentViewRef);
+	useDepSource("actionParams", () => registry?.paramsOf);
+	useViewportActions({
+		pan: viewOn ? viewport?.pan ?? true : false,
+		zoom: viewOn ? viewportZoom : false,
+		pinchZoom: viewOn ? viewport?.pinchZoom ?? true : false
+	});
+	useAreaSelectDepSource(scene, selection, poseDescriptor, alphaOf);
+	useNodeAtPointDepSource(pickEvery);
+	useLayoutDepSource(scene, props.layoutDropTarget, reflowTransition);
+	useInsertDepSource(scene, adapter, props.insertNodeFactories, props.insertPaint);
+	usePathLeafDepSources(scene, selection, adapter, poseDescriptor);
+	useSnapDepSource(currentViewRef, {
+		scene,
+		boxes: () => drawnBoxes({
+			scene,
+			poseDescriptor,
+			view,
+			boundsIncludeStroke
+		}),
+		sources: snap.sources,
+		...snap.registry ? { registry: snap.registry } : {},
+		...props.snap?.reachPx !== void 0 ? { reachPx: props.snap.reachPx } : {},
+		...props.snap?.omit ? { omit: props.snap.omit } : {},
+		...props.snap?.originProjection ? { originProjection: props.snap.originProjection } : {},
+		poseDescriptor,
+		debug: () => canvasApiRef.current?.getDebug()
+	}, snap.store);
+	useDebugDepSource(canvasApiRef);
+	usePreviewPathsDepSource(canvasApiRef);
+	useDepChangeNotices(scene, selection.current, editAnchorsExternalState);
+	useIngestionDepSource(canvasRef, () => currentViewRef.current, ingestion?.resolveSrc, ingestion?.svg, ingestionClipboard);
+	useLassoSelectDepSource(scene, selection, poseDescriptor, alphaOf);
+	useTextEditDepSource(scene);
+	useEditAnchorsDepSource(scene, selection, adapter, editAnchorsExternalState, tune);
+	useDispatcherDepSource(dispatcher);
+	usePoseDescriptorDepSource(poseDescriptor);
+	useDepSource("boundsIncludeStroke", () => boundsIncludeStroke);
+	useActionsPropResolver(props.actions, standardActions.map((a) => a.id).join("|"));
+	useActionTunings(tune);
+}
+
+//#endregion
+export { useSceneStandardActions };
+//# sourceMappingURL=useSceneStandardActions.js.map

package/dist/canvas/SceneCanvas/useSceneStandardActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneStandardActions.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useSceneStandardActions.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { useActionsRegistry, useDepSource } from '@weasel-js/routing/react';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { useDecayLoop } from 'core/viewport/useDecayLoop';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { View } from 'core/viewport/view';\nimport type { ClipboardIngestCtx } from 'interactions/actions/depSchema';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { useActionSet, useStandardDeps } from 'interactions/actions/useActionSet';\nimport { drawnBoxes } from 'interactions/actions/drawnBoxes';\nimport type React from 'react';\nimport { useEffect, useMemo } from 'react';\nimport type { ReflowTransition } from '../../layout/types';\nimport type { SnapOutcomeStore } from 'features/snap/outcomeStore';\nimport type { SnapSourceRegistry } from 'features/snap/registry';\nimport type { SnapSource } from 'features/snap/types';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport {\n  useAreaSelectDepSource,\n  useDebugDepSource,\n  usePreviewPathsDepSource,\n  useDepChangeNotices,\n  useDispatcherDepSource,\n  useEditAnchorsDepSource,\n  useIngestionDepSource,\n  useInsertDepSource,\n  useLassoSelectDepSource,\n  useLayoutDepSource,\n  useNodeAtPointDepSource,\n  usePoseDescriptorDepSource,\n  usePathLeafDepSources,\n  useSnapDepSource,\n  useSurfaceDepSources,\n  useTextEditDepSource,\n  useViewDepSource,\n} from '../deps';\nimport type { BridgeAdapter, SceneCanvasProps } from './props';\nimport { useActionsPropResolver } from './useActionsPropResolver';\nimport { useActionTunings } from './useActionTunings';\nimport { useViewportActions, viewportZoomOption } from './useViewportActions';\n\n/** The `<SceneCanvas>` props the standard actions and their deps read. */\nexport type StandardActionsProps = Pick<\n  SceneCanvasProps<unknown, string, unknown>,\n  | 'actions' | 'tune' | 'geometry' | 'viewport' | 'layoutDropTarget'\n  | 'reflowTransition' | 'insertNodeFactories' | 'insertPaint' | 'ingestion' | 'snap'\n>;\n\n/** What `<SceneCanvas>` hands {@link useSceneStandardActions}. */\nexport interface SceneStandardActionsInputs {\n  props: StandardActionsProps;\n  /** Whether the `view` preset is on; without it the viewport actions are off. */\n  viewOn: boolean;\n  selection: SelectionApi;\n  scene: Scene<unknown, string, unknown>;\n  adapter: BridgeAdapter;\n  /** The standard actions this canvas registers: its presets' and the ones\n   *  its tools bind, in registration order. */\n  standardActions: readonly Action[];\n  currentViewRef: React.RefObject<View>;\n  onViewChange: (v: View) => void;\n  /** Wires the `poseDescriptor` dep every built-in pose-touching action reads. */\n  poseDescriptor: PoseDescriptor<unknown>;\n  /** Forwarded so `cancelGestureAction` and other actions that need to\n   *  abort in-flight handles can read the dispatcher's control surface. */\n  dispatcher: Dispatcher;\n  /** World-space picker forwarded so the `nodeAtPoint` dep source can\n   *  reuse the same hit-test plumbing the tool dispatcher uses. */\n  pickEvery: (worldX: number, worldY: number) => string[];\n  /** This canvas's own view gate for scene layers, published on the `view`\n   *  dep and read by the selecting actions. Absent when it hides nothing. */\n  layerIsPainted?: (layerId: string) => boolean;\n  /** The composed paint alpha, when the consumer fades anything, so a region\n   *  select passes over what is painted at zero. */\n  alphaOf?: (id: string) => number;\n  /** The canvas's camera runner, published on the `view` dep so\n   *  `viewport.zoom`'s discrete branches can animate. */\n  viewAnimation: ViewAnimationApi;\n  /** Lifted edit-mode state so the `pathEditingOverlay` chrome (rendered\n   *  outside this subtree) can read the same `editingId` the dep does. */\n  editAnchorsExternalState: import('../deps/editAnchors').EditAnchorsStateSource;\n  /** The snap sources a session asks: the prop's and the presets', then the registry's. */\n  snap: { sources: readonly SnapSource[]; registry: SnapSourceRegistry | null; store: SnapOutcomeStore };\n  /** The canvas element ref, so `useIngestionDepSource` can compute the\n   *  visible world rect from the client rect + current view. */\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** The canvas handle, whose debug sink backs the `debug` dep. */\n  canvasApiRef: React.RefObject<CanvasExtensionApi | null>;\n  /** Clipboard-paste ctx (this canvas's adapter + the consumer's reviver)\n   *  for the kit weasel-JSON handler, from `useCanvasIngestion`; absent\n   *  when disabled. */\n  ingestionClipboard?: ClipboardIngestCtx;\n}\n\n/**\n * Registers this canvas's standard actions, and the deps they read, into its\n * input scope, then applies the `actions` prop and `tune` over them.\n *\n * Called from a component ahead of `<SceneCanvas>`'s children, never from the\n * canvas's own body: registrations stack newest-live in effect order, and a\n * parent's effects run after its children's, so a child's override would lose.\n */\nexport function useSceneStandardActions(inputs: SceneStandardActionsInputs): void {\n  const {\n    props, viewOn, selection, scene, adapter, standardActions, currentViewRef,\n    onViewChange, poseDescriptor, dispatcher, pickEvery, layerIsPainted, alphaOf, viewAnimation,\n    editAnchorsExternalState, snap, canvasRef, canvasApiRef, ingestionClipboard,\n  } = inputs;\n  const { tune, viewport, ingestion } = props;\n  const boundsIncludeStroke = props.geometry?.boundsIncludeStroke ?? true;\n  const reflowTransition = props.reflowTransition as ReflowTransition<unknown> | null | undefined;\n  const viewportZoom = useMemo(\n    () => viewportZoomOption(viewport?.zoom, viewport?.animatedZoom),\n    [viewport?.zoom, viewport?.animatedZoom],\n  );\n  const registry = useActionsRegistry();\n\n  // Wire the dispatcher into the registry so registry.begin() can delegate\n  // to dispatcher.beginUiOngoing() for UI-driven ongoing actions (color,\n  // opacity).\n  useEffect(() => {\n    if (!registry) return;\n    return registry.setDispatcher(dispatcher);\n  }, [registry, dispatcher]);\n\n  // Momentum for `viewport.dragPan`. The loop must be a hook (it owns a\n  // `useVisibleRaf`), so it is built here and republished on the view dep.\n  const decayLoop = useDecayLoop();\n\n  // Build the ViewApi (stable identity, refreshed closures) and hand it to\n  // useStandardDeps (which publishes the `view` dep along with selection,\n  // scene, history, activeTool). `hostSize` reads the live canvas\n  // element so keyboard zoom (Cmd+=/-) can anchor at the visible center.\n  const view = useViewDepSource(\n    currentViewRef,\n    onViewChange,\n    viewport?.recenter,\n    () => {\n      const el = canvasRef.current;\n      return el ? { width: el.clientWidth, height: el.clientHeight } : null;\n    },\n    viewAnimation,\n    decayLoop,\n    layerIsPainted,\n  );\n  useStandardDeps({ selection, scene, view, history: scene.history });\n  useActionSet(standardActions);\n  // A view overlays `view` with its own camera; this name it leaves alone.\n  useDepSource('rootView', () => view);\n  useSurfaceDepSources(canvasRef, currentViewRef);\n  useDepSource('actionParams', () => registry?.paramsOf);\n\n  // viewport.pan / viewport.zoom are SceneCanvas-coupled (need the `view` dep\n  // published just above), so they're registered here rather than in\n  // KIT_STANDARD_DESCRIPTORS. Both default ON; consumer opts out via\n  // `viewport={{ pan: false }}` / `viewport={{ zoom: false }}`.\n  useViewportActions({\n    pan: viewOn ? (viewport?.pan ?? true) : false,\n    zoom: viewOn ? viewportZoom : false,\n    pinchZoom: viewOn ? (viewport?.pinchZoom ?? true) : false,\n  });\n\n  // Per-dep wiring modules under `src/canvas/deps/`. See each file for the\n  // dep's contract and trade-offs.\n  useAreaSelectDepSource(scene, selection, poseDescriptor, alphaOf);\n  useNodeAtPointDepSource(pickEvery);\n  useLayoutDepSource(scene, props.layoutDropTarget, reflowTransition);\n  useInsertDepSource(scene, adapter, props.insertNodeFactories, props.insertPaint);\n  usePathLeafDepSources(scene, selection, adapter, poseDescriptor);\n  useSnapDepSource(\n    currentViewRef,\n    {\n      scene, boxes: () => drawnBoxes({ scene, poseDescriptor, view, boundsIncludeStroke }), sources: snap.sources,\n      ...(snap.registry ? { registry: snap.registry } : {}),\n      ...(props.snap?.reachPx !== undefined ? { reachPx: props.snap.reachPx } : {}),\n      ...(props.snap?.omit ? { omit: props.snap.omit } : {}),\n      ...(props.snap?.originProjection ? { originProjection: props.snap.originProjection } : {}),\n      poseDescriptor,\n      debug: () => canvasApiRef.current?.getDebug(),\n    },\n    snap.store,\n  );\n  useDebugDepSource(canvasApiRef);\n  usePreviewPathsDepSource(canvasApiRef);\n  useDepChangeNotices(scene, selection.current, editAnchorsExternalState);\n  useIngestionDepSource(canvasRef, () => currentViewRef.current, ingestion?.resolveSrc, ingestion?.svg, ingestionClipboard);\n  useLassoSelectDepSource(scene, selection, poseDescriptor, alphaOf);\n  useTextEditDepSource(scene);\n  useEditAnchorsDepSource(scene, selection, adapter, editAnchorsExternalState, tune);\n  useDispatcherDepSource(dispatcher);\n  usePoseDescriptorDepSource(poseDescriptor);\n  useDepSource('boundsIncludeStroke', () => boundsIncludeStroke);\n\n  // Keyed on the set too: a re-registration of it would otherwise land over\n  // the overrides applied on top of it.\n  useActionsPropResolver(props.actions, standardActions.map((a) => a.id).join('|'));\n  useActionTunings(tune);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,SAAgB,wBAAwB,QAA0C;CAChF,MAAM,EACJ,OAAO,QAAQ,WAAW,OAAO,SAAS,iBAAiB,gBAC3D,cAAc,gBAAgB,YAAY,WAAW,gBAAgB,SAAS,eAC9E,0BAA0B,MAAM,WAAW,cAAc,uBACvD;CACJ,MAAM,EAAE,MAAM,UAAU,cAAc;CACtC,MAAM,sBAAsB,MAAM,UAAU,uBAAuB;CACnE,MAAM,mBAAmB,MAAM;CAC/B,MAAM,eAAe,cACb,mBAAmB,UAAU,MAAM,UAAU,YAAY,GAC/D,CAAC,UAAU,MAAM,UAAU,YAAY,CACzC;CACA,MAAM,WAAW,mBAAmB;CAKpC,gBAAgB;EACd,IAAI,CAAC,UAAU;EACf,OAAO,SAAS,cAAc,UAAU;CAC1C,GAAG,CAAC,UAAU,UAAU,CAAC;CAIzB,MAAM,YAAY,aAAa;CAM/B,MAAM,OAAO,iBACX,gBACA,cACA,UAAU,gBACJ;EACJ,MAAM,KAAK,UAAU;EACrB,OAAO,KAAK;GAAE,OAAO,GAAG;GAAa,QAAQ,GAAG;EAAa,IAAI;CACnE,GACA,eACA,WACA,cACF;CACA,gBAAgB;EAAE;EAAW;EAAO;EAAM,SAAS,MAAM;CAAQ,CAAC;CAClE,aAAa,eAAe;CAE5B,aAAa,kBAAkB,IAAI;CACnC,qBAAqB,WAAW,cAAc;CAC9C,aAAa,sBAAsB,UAAU,QAAQ;CAMrD,mBAAmB;EACjB,KAAK,SAAU,UAAU,OAAO,OAAQ;EACxC,MAAM,SAAS,eAAe;EAC9B,WAAW,SAAU,UAAU,aAAa,OAAQ;CACtD,CAAC;CAID,uBAAuB,OAAO,WAAW,gBAAgB,OAAO;CAChE,wBAAwB,SAAS;CACjC,mBAAmB,OAAO,MAAM,kBAAkB,gBAAgB;CAClE,mBAAmB,OAAO,SAAS,MAAM,qBAAqB,MAAM,WAAW;CAC/E,sBAAsB,OAAO,WAAW,SAAS,cAAc;CAC/D,iBACE,gBACA;EACE;EAAO,aAAa,WAAW;GAAE;GAAO;GAAgB;GAAM;EAAoB,CAAC;EAAG,SAAS,KAAK;EACpG,GAAI,KAAK,WAAW,EAAE,UAAU,KAAK,SAAS,IAAI,CAAC;EACnD,GAAI,MAAM,MAAM,YAAY,SAAY,EAAE,SAAS,MAAM,KAAK,QAAQ,IAAI,CAAC;EAC3E,GAAI,MAAM,MAAM,OAAO,EAAE,MAAM,MAAM,KAAK,KAAK,IAAI,CAAC;EACpD,GAAI,MAAM,MAAM,mBAAmB,EAAE,kBAAkB,MAAM,KAAK,iBAAiB,IAAI,CAAC;EACxF;EACA,aAAa,aAAa,SAAS,SAAS;CAC9C,GACA,KAAK,KACP;CACA,kBAAkB,YAAY;CAC9B,yBAAyB,YAAY;CACrC,oBAAoB,OAAO,UAAU,SAAS,wBAAwB;CACtE,sBAAsB,iBAAiB,eAAe,SAAS,WAAW,YAAY,WAAW,KAAK,kBAAkB;CACxH,wBAAwB,OAAO,WAAW,gBAAgB,OAAO;CACjE,qBAAqB,KAAK;CAC1B,wBAAwB,OAAO,WAAW,SAAS,0BAA0B,IAAI;CACjF,uBAAuB,UAAU;CACjC,2BAA2B,cAAc;CACzC,aAAa,6BAA6B,mBAAmB;CAI7D,uBAAuB,MAAM,SAAS,gBAAgB,KAAK,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC;CAChF,iBAAiB,IAAI;AACvB"}