@weasel-js/core 1.6.1 → 1.7.1

package/dist/canvas/SceneCanvas.js

@@ -0,0 +1,992 @@
+import { normalizeView as e, viewZoom as t } from "../core/viewport/view.js";
+import { rectFromPlane as n } from "../core/viewport/parallax.js";
+import { DeviceProfileProvider as r, useDeviceProfile as i } from "../core/device/useDeviceProfile.js";
+import { clientToWorld as a } from "../core/viewport/clientToWorld.js";
+import { HANDLE_BASE_PX as o, targetSizesPx as s } from "../core/device/targets.js";
+import { AUTO_POSE_DESCRIPTOR as c } from "../interactions/actions/resize/autoPoseDescriptor.js";
+import { KIT_SHAPE_KINDS as l } from "../core/shapeKinds.js";
+import { usePointerContext as u } from "../features/pointer/PointerContext.js";
+import { dlog as d, dwarn as ee } from "../debug/flag.js";
+import { registerContentHandler as f } from "../features/ingestion/contentHandlers.js";
+import { KIT_STANDARD_ACTION_IDS as te, useStandardActions as p } from "../interactions/actions/useStandardActions.js";
+import { resizePolicyOptions as ne, useResizePolicy as re } from "./deps/resizePolicy.js";
+import { usePoseDescriptorDepSource as m } from "./deps/poseDescriptor.js";
+import { usePoseCompositionDepSource as ie } from "./deps/poseComposition.js";
+import { useSliceDepSource as ae } from "./deps/slice.js";
+import { useDecayLoop as h } from "../core/viewport/useDecayLoop.js";
+import { useAnimator as g } from "../animation/useAnimator.js";
+import { useViewAnimationOn as oe } from "../core/viewport/useViewAnimation.js";
+import { useTools as se } from "../tools/overlayBinding.js";
+import { useKeybindings as _ } from "../tools/useKeybindings.js";
+import { pathFromPlane as ce } from "./planeClips.js";
+import { selectionMoveContribution as le, selectionTransformContribution as v } from "../tools/builtin/select/selectionContributions.js";
+import { useHandTool as ue } from "../tools/builtin/hand/useHandTool.js";
+import { defaultDrawOne as de, defaultPaintBounds as fe, paintBoundsFor as y } from "./defaultDrawOne.js";
+import { useLateContentRedraw as pe } from "./useLateContentRedraw.js";
+import { createSceneLayerGate as me } from "./sceneLayerPaint.js";
+import { EMPTY_CHROME_STATE as he } from "../core/selection/chromeState.js";
+import { ViewRegistryProvider as b, useOptionalViewRegistry as ge } from "./viewRegistry.js";
+import { useSelection as _e } from "../core/selection/useSelection.js";
+import { createSelectionOverlayLayer as ve, rotationBadgeOf as x } from "../features/selection/overlay.js";
+import { rotateAroundAABBCenter as ye } from "./poseRotation.js";
+import { Canvas as be } from "./Canvas.js";
+import { composeAlphaFor as xe, wireSceneSlotToScene as Se } from "./sceneSlotWiring.js";
+import { useSceneAdapter as Ce } from "./sceneAdapter.js";
+import { sceneFromJSON as we } from "../core/scene/scene.js";
+import { usePublishSelection as Te } from "../features/selection/SelectionContext.js";
+import { ViewInputsProvider as Ee } from "./viewInputs.js";
+import { anchorStateFrom as De, buildAffordanceAt as Oe, buildClassifyTarget as S, chromeAffordances as ke } from "./affordanceAt.js";
+import { createDispatcherPreviewSources as Ae, createGestureSource as je } from "./SceneCanvas/dispatcherGestureBounds.js";
+import { CanvasView as Me } from "./CanvasView.js";
+import { contributionEntries as Ne, useContributionRoles as Pe } from "./SceneCanvas/useContributionRoles.js";
+import { PointerProviderIfRoot as Fe, PointerPublisher as Ie } from "./SceneCanvas/PointerProviderIfRoot.js";
+import { useSceneSelectTool as Le } from "./SceneCanvas/useSceneSelectTool.js";
+import { SCENE_CANVAS_FEATURES as Re, featureActionIds as ze, resolveFeatures as Be } from "./SceneCanvas/features.js";
+import { usePreviewGhostLayer as Ve } from "./SceneCanvas/usePreviewGhostLayer.js";
+import { useDispatcherOverlayLayer as He } from "./SceneCanvas/useDispatcherOverlayLayer.js";
+import { createPenPreviewLayer as Ue } from "../features/paths/penPreviewLayer.js";
+import { createPathEditingOverlayLayer as We } from "../features/paths/pathEditingOverlayLayer.js";
+import { createSlopsDebugLayer as Ge } from "./slopsDebugLayer.js";
+import { useBuiltinShapeTools as Ke } from "./SceneCanvas/useBuiltinShapeTools.js";
+import { useViewDepSource as qe } from "./deps/view.js";
+import { useAreaSelectDepSource as Je } from "./deps/areaSelect.js";
+import { useNodeAtPointDepSource as Ye } from "./deps/nodeAtPoint.js";
+import { useLassoSelectDepSource as Xe } from "./deps/lassoSelect.js";
+import { useTextEditDepSource as Ze } from "./deps/textEdit.js";
+import { resolveEditablePathOf as Qe, useEditAnchorsDepSource as $e } from "./deps/editAnchors.js";
+import { useInsertDepSource as et } from "./deps/insert.js";
+import { useSnapDepSource as C } from "./deps/snap.js";
+import { useDebugDepSource as tt } from "./deps/debug.js";
+import { useDispatcherDepSource as nt } from "./deps/dispatcher.js";
+import { useLayoutDepSource as rt } from "./deps/layout.js";
+import { useGeometryProjection as it } from "./deps/geometryProjection.js";
+import { useIngestionDepSource as w } from "./deps/ingestion.js";
+import { useLayoutArrivals as at } from "../layout/arrivals.js";
+import { acquireKitContentHandlers as ot } from "../features/ingestion/registerKitHandlers.js";
+import { itemsFromFiles as st } from "../features/ingestion/index.js";
+import { useActionsPropResolver as ct } from "./SceneCanvas/useActionsPropResolver.js";
+import { useViewportActions as lt } from "./SceneCanvas/useViewportActions.js";
+import { createLongPressFeedbackContribution as ut } from "../features/longPress/longPressFeedback.js";
+import { createNodeRouting as dt } from "../core/scene/NodeRouting.js";
+import { inferredNodeRouting as ft } from "./SceneCanvas/defaultNodeRouting.js";
+import { installTestHookIfRequested as pt } from "../test-hook/install.js";
+import { makeGetNodeAtPoint as mt } from "./getNodeAtPoint.js";
+import { never as T } from "../features/chrome-caps/conditions.js";
+import { resolveVisibility as ht } from "../features/chrome-caps/resolve.js";
+import { buildChromeCtx as gt } from "../features/chrome-caps/buildChromeCtx.js";
+import { useHoverTracking as _t } from "../features/chrome-caps/useHoverTracking.js";
+import { DEFAULT_ALLOWED_CAPABILITIES as vt } from "../features/chrome-caps/index.js";
+import { forwardRef as yt, useCallback as E, useEffect as D, useInsertionEffect as bt, useMemo as O, useRef as k, useState as A } from "react";
+import { useLatest as j } from "@weasel-js/react";
+import { createDispatcher as xt, createLongPressStore as St } from "@weasel-js/routing";
+import { InputScope as Ct, useActionsRegistry as wt, useDepRegistry as Tt, useDepSource as Et, useGestureDispatcher as M } from "@weasel-js/routing/react";
+import { Fragment as Dt, jsx as N, jsxs as Ot } from "react/jsx-runtime";
+import { getActiveModeFor as kt } from "@weasel-js/modes";
+//#region src/canvas/SceneCanvas.tsx
+var At = o, jt = (() => {
+	try {
+		return !1;
+	} catch {
+		return !1;
+	}
+})(), Mt = 200, P = [], Nt = jt;
+Nt && typeof window < "u" && (window.__weaselCoordLog__ = P);
+function Pt(e) {
+	Nt && (P.push(e), P.length > Mt && P.shift());
+}
+function Ft(e, t = 1) {
+	let n = {
+		scene: {
+			drawOne: de,
+			paintBounds: fe
+		},
+		selectionOverlay: { handles: { size: s(t).handle } }
+	};
+	if (!e) return n;
+	let r = { ...e };
+	if (!("scene" in e)) r.scene = n.scene;
+	else if (e.scene === null) r.scene = null;
+	else {
+		let t = {
+			...n.scene,
+			...e.scene
+		};
+		r.scene = e.scene && "paintBounds" in e.scene ? t : {
+			...t,
+			paintBounds: y(t.drawOne)
+		};
+	}
+	return r.selectionOverlay = "selectionOverlay" in e ? e.selectionOverlay === null ? null : {
+		...n.selectionOverlay,
+		...e.selectionOverlay
+	} : n.selectionOverlay, r;
+}
+var It = ["select", "hand"], F = [...It, ...l];
+function Lt(e) {
+	if (e === !1) return !1;
+	let { slops: t, ...n } = e;
+	return n;
+}
+var Rt = /* @__PURE__ */ new Set(), zt = /* @__PURE__ */ new Set();
+function Bt(e) {
+	return typeof e.setActive == "function";
+}
+function Vt(o, u) {
+	let { scene: p, geometry: ne, poseDescriptor: re, selectTool: m, insertTool: ie, insertNodeFactories: ae, ingestion: h, layouts: _, layoutDropTarget: de, reflowTransition: fe, poseComposition: y, geometryProjection: he, routing: b, selection: ye, selectionOptions: De, selectable: Oe = !0, tools: S, features: ke, enableKeybindings: Pe = !0, enableGestureDispatcher: Re = !0, onToolsCreated: qe, defaultTools: Je, toolOptions: Ye, initialActiveTool: Xe, ambient: Ze, versionCheck: $e, longPress: et, viewport: C, layers: tt, actions: nt, actionDefaults: rt, describeKind: it, animator: w, views: at, children: ct, shaders: lt, flattenTolerance: yt, backgroundFill: St, cursorCoordsHud: Ct, pickHud: wt, debug: Tt, modalityHud: Et, alphaFor: M, layerVisibility: At, layerOrder: Mt, isPointerInteractive: P, onDoubleClick: Nt, chromeVisibility: Pt, modes: F, getFocused: Vt, device: Gt, ...Kt } = o, I = re ?? c, L = i(Gt), qt = O(() => s(L.targetScale), [L.targetScale]), Jt = (e) => typeof e == "object" && !!e && e.version === 1 && Array.isArray(e.nodes), [Yt] = A(() => Jt(p) ? we(p, {}) : null), R = Yt ?? p, { view: z, onViewChange: Xt, defaultView: Zt, redrawOn: Qt, ...$t } = Kt, en = O(() => F ? kt(F) : void 0, [F]), tn = O(() => F ? [...Qt ?? [], F] : Qt, [F, Qt]), nn = k(null), B = k(null), [rn, an] = A(!1);
+	D(() => (d("scene-canvas", "mount"), () => d("scene-canvas", "unmount")), []);
+	let on = h?.handlers;
+	D(() => {
+		let e = [ot()];
+		for (let t of on ?? []) e.push(f(t));
+		return () => e.forEach((e) => e());
+	}, [on]), D(() => {
+		if (w) return w.onTick(() => {
+			B.current?.requestRedraw?.();
+		});
+	}, [w]), pe(E(() => {
+		B.current?.requestRedraw?.();
+	}, [])), D(() => R.overrides.subscribe(() => {
+		B.current?.requestRedraw?.();
+	}), [R]), D(() => R.subscribe(() => {
+		B.current?.requestRedraw?.();
+	}), [R]);
+	let V = k(e(z ?? Zt ?? {
+		x: 0,
+		y: 0,
+		scale: {
+			x: 1,
+			y: 1
+		}
+	}));
+	bt(() => {
+		z !== void 0 && (V.current = e(z));
+	}), D(() => {
+		let e = B.current;
+		if (e) return V.current = e.getView(), e.subscribeView((e) => {
+			V.current = e;
+		});
+	}, [rn]);
+	let sn = E((t) => {
+		let n = B.current;
+		if (z === void 0 && n) {
+			n.setView(t);
+			return;
+		}
+		Xt?.(e(t));
+	}, [z, Xt]), cn = g(), ln = O(() => ({
+		get: () => V.current,
+		set: sn
+	}), [sn]), H = oe(ln, cn), un = E((e) => {
+		H.stopIfExternal(), Xt?.(e);
+	}, [Xt, H]), dn = C?.animatedZoom, fn = C?.zoom ?? !0, pn = O(() => {
+		if (fn === !1) return !1;
+		let e = typeof fn == "object" ? fn : {};
+		return dn ? {
+			...e,
+			animate: dn === !0 ? {} : dn
+		} : e;
+	}, [fn, dn]), mn = O(() => ({
+		scene: R,
+		...De ?? {}
+	}), [R, De]), hn = _e(mn), gn = ye ?? hn, _n = gn.adapterMethods, vn = O(() => ({
+		getSelection: () => _n.getSelection(),
+		setSelection: () => {}
+	}), [_n]), U = O(() => {
+		if (Oe) return gn;
+		let e = () => {};
+		return {
+			get current() {
+				return gn.current;
+			},
+			get: gn.get,
+			contains: gn.contains,
+			set: e,
+			add: e,
+			remove: e,
+			toggle: e,
+			clear: e,
+			applyClick: e,
+			adapterMethods: vn
+		};
+	}, [
+		gn,
+		Oe,
+		vn
+	]), yn = U.current, bn = O(() => {
+		if (yn.length === 0) return;
+		let e = [];
+		for (let t of yn) {
+			let n = R.get(t);
+			if (!n) {
+				e.push(void 0);
+				continue;
+			}
+			if (it) {
+				e.push(it(n));
+				continue;
+			}
+			if (n.kind === "container") {
+				e.push("group");
+				continue;
+			}
+			let r = n.pose;
+			if (r && typeof r == "object" && "kind" in r && typeof r.kind == "string") {
+				e.push("path");
+				continue;
+			}
+			e.push(void 0);
+		}
+		return e;
+	}, [
+		yn,
+		R,
+		it
+	]);
+	Te(yn, bn);
+	let [xn, Sn] = A(""), Cn = j(xn), wn = k(void 0), W = E(() => {
+		let e = wn.current;
+		return e && !e() ? "" : Cn.current;
+	}, [Cn]), Tn = k(zt), En = k(null), Dn = O(() => ({
+		getEditingId: () => W(),
+		setEditingId: (e) => Sn(e ?? ""),
+		getSelectedAnchors: () => Tn.current,
+		setSelectedAnchors: (e) => {
+			Tn.current = e, B.current?.requestRedraw?.();
+		},
+		getMarquee: () => En.current,
+		setMarquee: (e) => {
+			En.current = e, B.current?.requestRedraw?.();
+		}
+	}), [W]), On = O(() => ({
+		handleHitRadius: qt.handle,
+		extendClickLocked: () => W() !== "",
+		...m
+	}), [
+		m,
+		qt.handle,
+		W
+	]), kn = j(U), An = O(() => {
+		let e = b === void 0 ? ft : b;
+		if (e.length === 0) return;
+		let t = dt();
+		for (let n of e) t.register(n);
+		return (e) => t.classify(e);
+	}, [b]), jn = O(() => {
+		if (An) return (e) => {
+			let t = R.get(e);
+			return t ? An(t.data) : void 0;
+		};
+	}, [An, R]), Mn = O(() => xe(R, M), [R, M]), Nn = ge(), Pn = j({
+		layerVisibility: At,
+		layerOrder: Mt
+	}), [Fn] = A(me), In = E((e) => Fn(Nn?.surface()?.layers() ?? [], Pn.current)(e), [
+		Nn,
+		Fn,
+		Pn
+	]), Ln = At !== void 0 || Mt !== void 0 ? In : void 0, Rn = y !== void 0 && y.closure !== "identity", G = Ce(R, {
+		selection: U.adapterMethods,
+		poseDescriptor: I,
+		commitInsert: ie?.create,
+		insertLayer: ie?.layer,
+		layouts: _,
+		poseComposition: y,
+		cascadeContainerPose: !Rn
+	}), { selectTool: zn, pickEvery: K, pickBest: Bn, boundsOf: Vn, boundsOfPose: Hn, planeOfNode: Un, moveOptions: Wn } = Le({
+		scene: R,
+		adapter: G,
+		poseDescriptor: I,
+		geometry: ne,
+		getView: () => V.current,
+		...M ? { alphaOf: Mn } : {},
+		...Ln ? { layerIsPainted: Ln } : {},
+		selectTool: On
+	}), Gn = j(Un), Kn = O(() => {
+		if (!K) return;
+		let e = mt(K, (e) => {
+			let t = G.getNode(e);
+			return {
+				kind: t && An ? An(t.data) : "unknown",
+				pose: G.getWorldPose(e),
+				data: t ?? { id: e }
+			};
+		});
+		return P ? (t, n, r) => {
+			let i = e(t, n, r);
+			return i == null || P(i.id) === !1 ? null : i;
+		} : e;
+	}, [
+		G,
+		K,
+		P,
+		An
+	]), qn = (ke ?? []).join("|"), Jn = C !== void 0, q = O(() => Be(ke, { viewport: Jn }), [qn, Jn]), Yn = !!C?.inertia, Xn = typeof C?.inertia == "object" ? C.inertia : void 0, Zn = Yn ? {
+		friction: Xn?.friction,
+		minSpeed: Xn?.minSpeed,
+		boundary: Xn?.boundary,
+		bounds: Xn?.bounds
+	} : void 0, Qn = ue(Zn ? { inertia: Zn } : {}), $n = [
+		...Je ?? [],
+		...q.has("pick") ? ["select"] : [],
+		...q.has("view") ? ["hand"] : []
+	], er = /* @__PURE__ */ new Set([...It, ...l]), tr = !S || Bt(S) ? null : S, nr = /* @__PURE__ */ new Set();
+	if (tr) {
+		for (let [e, t] of Object.entries(tr)) if (t === !0) {
+			if (!er.has(e)) {
+				jt && console.warn(`[SceneCanvas] tools.${e}=true is not a known built-in id; ignoring`);
+				continue;
+			}
+			nr.add(e);
+		}
+	}
+	let J = (e) => $n.includes(e) || nr.has(e), Y = Ke({
+		scene: R,
+		adapter: G,
+		options: Ye
+	}), rr = O(() => ut(), []), ir = et?.feedback ?? !0, ar = ir === !0 ? rr : ir || null, or = O(() => ar ? [...Ze ?? [], ar] : Ze ?? [], [Ze, ar]), X = {};
+	J("select") && (X.select = zn), J("hand") && (X.hand = Qn), J("rect") && (X.rect = Y.rect), J("ellipse") && (X.ellipse = Y.ellipse), J("line") && (X.line = Y.line), J("polygon") && (X.polygon = Y.polygon), J("star") && (X.star = Y.star), J("pen") && (X.pen = Y.pen), J("pencil") && (X.pencil = Y.pencil), J("lasso") && (X.lasso = Y.lasso), J("text") && (X.text = Y.text);
+	let sr = tr;
+	if (sr) for (let [e, t] of Object.entries(sr)) if (t === !1) delete X[e];
+	else if (t === !0) continue;
+	else jt && e in X && console.warn(`[SceneCanvas] tools prop overrides bundled "${e}" tool`), X[e] = t;
+	let cr = S && Bt(S) ? S : null, lr = se({
+		active: Xe ?? ("select" in X ? "select" : null),
+		registry: X,
+		...or.length ? { ambient: or } : {},
+		...F ? { modes: F } : {}
+	}), ur = j(cr ?? lr), Z = j(en), dr = E((e) => {
+		let t = Z.current;
+		if (!t) return !0;
+		let n = (ur.current?.registry)?.[e]?.eligibility.capabilities ?? [];
+		if (n.length === 0) return !1;
+		let r = t().allowedCapabilities;
+		for (let e of n) if (r.has(e)) return !0;
+		return !1;
+	}, [Z, ur]), Q = cr ?? lr, fr = O(() => ({ move: Wn }), [Wn]), pr = m?.rotate || void 0, mr = O(() => [...q.has("transform") ? [v({ rotate: pr })] : [], ...q.has("move") ? [le(fr)] : []], [
+		q,
+		fr,
+		pr
+	]), hr = O(() => {
+		let e = ze(q), t = [
+			...Object.values(Q.registry),
+			...Q.ambient,
+			...mr
+		];
+		for (let n of t) for (let t of n.bindings ?? []) e.add(t.actionId);
+		return te.filter((t) => !e.has(t));
+	}, [
+		q,
+		Q,
+		mr
+	]), gr = j(qe);
+	D(() => {
+		gr.current?.(Q);
+	}, [Q, gr]);
+	let _r = j(Nt), vr = j(Kn), yr = O(() => {
+		if (Nt) return (e) => {
+			let t = _r.current;
+			if (!t) return;
+			let n = vr.current?.(e.x, e.y);
+			t(n ? {
+				id: n.id,
+				kind: n.kind
+			} : null);
+		};
+	}, [!!Nt]), $ = O(() => Ft(tt, L.targetScale), [tt, L.targetScale]), br = O(() => {
+		if (m?.rotate !== !1) return nt;
+		if (nt === null) return null;
+		let e = { ...nt ?? {} };
+		return "rotate" in e || (e.rotate = null), e;
+	}, [nt, m?.rotate]), xr = k(null), Sr = k(null);
+	Sr.current ||= xt({ getAction: (e) => xr.current?.(e) });
+	let Cr = Sr.current, wr = O(() => je(() => Sr.current), []), { previewIdsExtra: Tr, previewPoseExtra: Er } = O(() => Ae(() => Sr.current), []), Dr = O(() => {
+		let e = $.scene;
+		return !e || "layer" in e ? e : Se(e, R, M, w?.colorOverrides);
+	}, [
+		$.scene,
+		M,
+		R,
+		w
+	]), Or = Ve({
+		scene: R,
+		sceneSlot: Dr,
+		dispatcher: Cr
+	}), kr = He({ dispatcher: Cr }), Ar = j(Kn), jr = _t({
+		canvasRef: nn,
+		nodeAtClientPoint: (e, t) => {
+			let n = nn.current;
+			if (!n) return null;
+			let r = Nn?.resolver.at(null, e, t), i = r?.origin ?? n.getBoundingClientRect(), o = r?.view ?? V.current, [s, c] = a(e, t, i, o), l = r?.id == null ? void 0 : Nn?.list().find((e) => e.id === r.id), u = Ar.current?.(s, c, l ? {
+				scale: o.scale,
+				layerIsPainted: l.layerIsPainted
+			} : o);
+			return u ? { id: u.id } : null;
+		},
+		enabled: Pt !== void 0
+	}), Mr = j(U.current), Nr = j(Vt), Pr = O(() => {
+		let e = {};
+		return q.has("pick") || (e["selection.outline"] = T), q.has("transform") || (e["selection.resize-handles"] = T, e["selection.rotation-handle"] = T), Oe || (e["action.marquee"] = T, e["action.lasso"] = T), m?.rotate === !1 && (e["selection.rotation-handle"] = T), Object.keys(e).length === 0 ? Pt : {
+			...e,
+			...Pt
+		};
+	}, [
+		Pt,
+		Oe,
+		m?.rotate,
+		q
+	]), Fr = j(Pr), Ir = j(L), Lr = j(m?.resize?.resizable), Rr = E((e) => {
+		let n = e.selection, r = Z.current?.() ?? {
+			id: "normal",
+			allowedCapabilities: vt
+		}, i = gt({
+			focused: !Nr.current || Nr.current(),
+			selection: n,
+			multiActive: n.length > 1,
+			modifiers: {
+				alt: !1,
+				ctrl: !1,
+				meta: !1,
+				shift: !1
+			},
+			action: e.action,
+			hover: jr(),
+			view: e.view
+		}), a = Lr.current, o = a ? n.every((e) => a(e)) : void 0;
+		return {
+			...i,
+			zoom: t(e.view),
+			mode: r.id,
+			allowedCapabilities: r.allowedCapabilities,
+			selectionResizable: o,
+			editingAnchors: W() !== "",
+			device: Ir.current
+		};
+	}, [
+		jr,
+		W,
+		Z,
+		Nr,
+		Lr,
+		Ir
+	]), zr = E(() => ({
+		selection: Mr.current,
+		view: V.current,
+		action: Cr.getActiveAction()
+	}), [Cr, Mr]), Br = E(() => Rr(zr()), [Rr, zr]), Vr = O(() => en ? () => Z.current().allowedCapabilities.has("edits-anchors") : void 0, [en, Z]);
+	bt(() => {
+		wn.current = Vr;
+	});
+	let Hr = O(() => ({
+		ruleCtx: (e) => Z.current ? Rr(e) : void 0,
+		isVisible: (e) => ht(Fr.current, Rr(e))
+	}), [
+		Rr,
+		Z,
+		Fr
+	]), Ur = E(() => Hr.isVisible(zr()), [Hr, zr]), Wr = J("pen"), Gr = O(() => Wr ? Ue({ penTool: Y.pen }) : null, [Y.pen, Wr]);
+	D(() => {
+		B.current?.requestRedraw?.();
+	}, [xn]);
+	let Kr = j(R), qr = Tt !== void 0 && Tt !== !1 && Tt.slops === !0, Jr = $.selectionOverlay, Yr = Jr ? x(Jr) : null, Xr = O(() => Yr, [Yr?.distancePx, Yr?.sizePx]), Zr = k([]), Qr = O(() => Ge({ getAffordances: () => Zr.current }), []), $r = (e, t, n) => {
+		let r = Kr.current?.get(e);
+		if (!r) return null;
+		let i = r.pose, a = r.data, o = !1;
+		for (let n of t) {
+			let t = n.previewIds?.();
+			if (!t) continue;
+			let r = !1;
+			for (let n of t) if (n === e) {
+				r = !0;
+				break;
+			}
+			if (!r) continue;
+			let s = n.previewPose?.(e);
+			s != null && !o && (i = s, o = !0);
+			let c = n.previewData?.(e);
+			c != null && (a = c, o = !0);
+		}
+		return ce(Qe({
+			pose: i,
+			data: a
+		}), Gn.current(e, n));
+	}, ei = O(() => We({
+		getEditingId: () => W() || null,
+		getPose: (e, t, n) => $r(e, t, n),
+		getSelectedAnchors: () => Tn.current,
+		getMarquee: (e) => {
+			let t = En.current, r = t ? Gn.current(W(), e) : null;
+			return t && r ? n(r, t) : t;
+		}
+	}), []), ti = E(() => {
+		let e = W();
+		return e ? /* @__PURE__ */ new Set([e]) : Rt;
+	}, [W]), ni = O(() => {
+		let e = $.selectionOverlay;
+		if (e === null) return null;
+		let t = e ?? {}, n = t.getSuppressedIds, r = () => {
+			let e = ti(), t = n?.();
+			if (!t || t.size === 0) return e;
+			if (e.size === 0) return t;
+			let r = new Set(t);
+			for (let t of e) r.add(t);
+			return r;
+		};
+		return ve({
+			...t,
+			getSuppressedIds: r,
+			...t.poseById ? {
+				getPose: t.poseById,
+				poseDescriptor: t.poseDescriptor ?? I
+			} : {}
+		});
+	}, [
+		$.selectionOverlay,
+		ti,
+		I
+	]), ri = O(() => ({
+		...$,
+		...Dr ? { scene: Dr } : {},
+		selectionOverlay: ni ? { layer: ni } : $.selectionOverlay === null ? null : void 0,
+		previewGhost: {
+			layer: Or,
+			after: "scene"
+		},
+		dispatcherOverlay: {
+			layer: kr,
+			after: "previewGhost"
+		},
+		...Gr ? { penPreview: {
+			layer: Gr,
+			after: "dispatcherOverlay"
+		} } : {},
+		pathEditingOverlay: {
+			layer: ei,
+			after: "selectionOverlay"
+		},
+		...qr ? { slopsDebug: {
+			layer: Qr,
+			after: "pathEditingOverlay"
+		} } : {}
+	}), [
+		$,
+		Dr,
+		ni,
+		Or,
+		kr,
+		Gr,
+		ei,
+		qr,
+		Qr
+	]), ii = k(null), ai = h?.clipboard?.reviver, oi = h?.clipboard?.enabled !== !1, si = O(() => {
+		if (oi && G?.commitPaste) return {
+			adapter: G,
+			...ai ? { reviver: ai } : {}
+		};
+	}, [
+		G,
+		oi,
+		ai
+	]), ci = E((e, t) => {
+		let n = e.map((e) => e instanceof File ? st([e])[0] : e);
+		if (n.length !== 0) {
+			if (!ii.current) {
+				ee("ingest", "CanvasExtensionApi.ingest called before the action registry mounted — call ignored. Defer to an effect or event handler.");
+				return;
+			}
+			ii.current.trigger("ingest", {
+				items: n,
+				...t ? {
+					worldX: t.x,
+					worldY: t.y
+				} : {}
+			});
+		}
+	}, []), [li, ui] = A([]), di = E((e) => (ui((t) => [...t.filter((t) => t.id !== e.id), e]), {
+		id: e.id,
+		draw: (t, n, r) => Nn?.list().find((t) => t.id === e.id)?.layer.draw(t, n, r) ?? [],
+		remove: () => ui((t) => t.filter((t) => t !== e))
+	}), [Nn]), fi = E((e) => {
+		nn.current = e?.element ?? null;
+		let t = e ? {
+			...e,
+			ingest: ci,
+			animateView: H.animate,
+			stopViewAnimation: H.stop,
+			isViewAnimating: H.isAnimating,
+			addView: di
+		} : null;
+		B.current = t, an(t !== null), typeof u == "function" ? u(t) : u && (u.current = t);
+	}, [
+		u,
+		ci,
+		H,
+		di
+	]), pi = O(() => ({
+		adapter: G,
+		geometry: I,
+		boundsOf: Vn,
+		boundsOfPose: Hn,
+		planeOfNode: Un,
+		tools: Q,
+		pickEvery: K,
+		pickBest: Bn,
+		kindOfNode: jn,
+		chromeCaps: Hr,
+		selectionApi: U,
+		rotationBadge: Xr
+	}), [
+		G,
+		I,
+		Vn,
+		Hn,
+		Un,
+		Q,
+		K,
+		Bn,
+		jn,
+		Hr,
+		U,
+		Xr
+	]), mi = /* @__PURE__ */ N(be, {
+		ref: fi,
+		adapter: G,
+		selection: U,
+		poseDescriptor: I,
+		tools: Q,
+		layers: ri,
+		pickEvery: K,
+		boundsOf: Vn,
+		boundsOfPose: Hn,
+		getIsVisible: Ur,
+		previewIdsExtra: Tr,
+		gestureSource: wr,
+		previewPoseExtra: Er,
+		backgroundFill: St,
+		cursorCoordsHud: Ct,
+		pickHud: wt,
+		modalityHud: Et,
+		...Tt === void 0 ? {} : { debug: Lt(Tt) },
+		pickBest: Bn,
+		contentVersion: R.getVersion,
+		layerVisibility: At,
+		layerOrder: Mt,
+		...z === void 0 ? { defaultView: Zt } : { view: z },
+		onViewChange: un,
+		shaders: lt,
+		flattenTolerance: yt,
+		...tn ? { redrawOn: tn } : {},
+		...$t
+	}), hi = j(R), gi = j(U), _i = k(null);
+	return D(() => {
+		process.env.NODE_ENV !== "production" && (_i.current = pt({
+			getScene: () => hi.current,
+			getSelectionIds: () => gi.current?.current ?? [],
+			getView: () => V.current,
+			getActiveToolId: () => ur.current?.active ?? null
+		}), _i.current?._markReady());
+	}, [
+		hi,
+		gi,
+		ur
+	]), /* @__PURE__ */ N(r, {
+		value: Gt,
+		children: /* @__PURE__ */ N(Ee, {
+			value: pi,
+			children: /* @__PURE__ */ N(Dt, { children: /* @__PURE__ */ N(Fe, { children: /* @__PURE__ */ Ot(Dt, { children: [
+				mi,
+				/* @__PURE__ */ N(Ie, { canvasRef: nn }),
+				/* @__PURE__ */ N(Wt, {
+					selection: U,
+					scene: R,
+					adapter: G,
+					actionDefaults: rt,
+					actions: br,
+					excludeActions: hr,
+					currentViewRef: V,
+					onViewChange: sn,
+					resizeOptions: m?.resize,
+					poseDescriptor: I,
+					geometryProjection: he,
+					dispatcher: Cr,
+					getActionRef: xr,
+					pickEvery: K,
+					layerIsPainted: Ln,
+					alphaOf: M ? Mn : void 0,
+					viewportPanEnabled: q.has("view") ? C?.pan ?? !0 : !1,
+					viewportZoom: q.has("view") ? pn : !1,
+					viewportPinchZoom: q.has("view") ? C?.pinchZoom ?? !0 : !1,
+					viewportRecenter: C?.recenter,
+					viewAnimation: H,
+					editAnchorsExternalState: Dn,
+					anchorEditingAllowed: Vr,
+					layouts: _,
+					layoutDropTarget: de,
+					reflowTransition: fe,
+					poseComposition: y,
+					insertNodeFactories: ae,
+					snapPoint: Ye?.snapPoint,
+					canvasRef: nn,
+					canvasApiRef: B,
+					ingestionResolveSrc: h?.resolveSrc,
+					ingestionSvg: h?.svg,
+					ingestionClipboard: si,
+					actionsRegistryRef: ii
+				}),
+				/* @__PURE__ */ N(Ut, {
+					canvasRef: nn,
+					canvasApiRef: B,
+					tools: Q,
+					contributions: mr,
+					enabled: Re,
+					keyboard: Pe,
+					selectionRef: kn,
+					boundsOf: Vn,
+					planeOfNode: Un,
+					pickEvery: K,
+					pickBest: Bn,
+					kindOfNode: jn,
+					viewRef: V,
+					dispatcher: Cr,
+					getIsVisibleForCanvas: Ur,
+					getRuleCtx: en ? Br : void 0,
+					targetScale: L.targetScale,
+					handleHitRadius: m?.handleHitRadius,
+					rotationBadge: Xr,
+					chromeAffordancesRef: Zr,
+					onDoubleClick: yr,
+					longPress: et
+				}),
+				/* @__PURE__ */ N(Ht, {
+					internalTools: lr,
+					toolsTakeover: cr ?? void 0,
+					enableKeybindings: Pe,
+					isToolEligible: dr,
+					canvasApi: rn ? B.current : null,
+					versionCheck: $e
+				}),
+				at?.map((e, t) => /* @__PURE__ */ N(Me, {
+					...e,
+					order: e.order ?? t
+				}, e.id)),
+				Ne(Q).flatMap((e) => e.views ?? []).map((e) => /* @__PURE__ */ N(Me, { ...e }, `contribution:${e.id}`)),
+				li.map((e) => /* @__PURE__ */ N(Me, { ...e }, `added:${e.id}`)),
+				ct
+			] }) }) })
+		})
+	});
+}
+function Ht({ internalTools: e, toolsTakeover: t, enableKeybindings: n, isToolEligible: r, canvasApi: i, versionCheck: a }) {
+	return _(e, {
+		disable: !!t || !n,
+		isToolEligible: r
+	}), _(t ?? e, {
+		disable: !t || !n,
+		isToolEligible: r
+	}), Pe(t ?? e, i, a), null;
+}
+function Ut({ canvasRef: e, canvasApiRef: t, tools: n, contributions: r, enabled: i, keyboard: o, selectionRef: s, boundsOf: c, planeOfNode: l, pickEvery: u, pickBest: d, kindOfNode: ee, viewRef: f, dispatcher: te, getIsVisibleForCanvas: p, getRuleCtx: ne, targetScale: re, handleHitRadius: m, rotationBadge: ie, chromeAffordancesRef: ae, onDoubleClick: h, longPress: g }) {
+	let oe = wt(), se = Tt(), _ = ge(), le = O(() => {
+		let e = /* @__PURE__ */ new Map();
+		for (let [t, r] of Object.entries(n.registry)) e.set(t, r);
+		for (let t of r) e.set(t.id, t);
+		for (let t of n.ambient) e.set(t.id, t);
+		return e;
+	}, [
+		n.registry,
+		n.ambient,
+		r
+	]), v = j(u), ue = j(d), de = j(ee), fe = j(se), y = j(l), pe = O(() => De(() => fe.current, (e, t) => ce(t, y.current?.(e) ?? null)), [fe, y]), me = O(() => ke({
+		...re === void 0 ? {} : { targetScale: re },
+		...m === void 0 ? {} : { handleHitRadius: m },
+		rotationBadge: ie,
+		getAnchorState: pe
+	}), [
+		re,
+		m,
+		ie,
+		pe
+	]);
+	bt(() => {
+		ae && (ae.current = me);
+	});
+	let b = O(() => {
+		if (s && c && f) return Oe({
+			getChromeState: () => _?.surface()?.chromeState() ?? he,
+			getView: () => f.current ?? {
+				x: 0,
+				y: 0,
+				scale: {
+					x: 1,
+					y: 1
+				}
+			},
+			affordances: me,
+			...p ? { getIsVisible: () => p() } : {}
+		});
+	}, [
+		s,
+		c,
+		f,
+		me,
+		p,
+		_
+	]), _e = O(() => {
+		if (s && u && f) return S(() => s.current?.current ?? [], (e, t) => {
+			if (ue.current) return ue.current(e, t);
+			let n = v.current?.(e, t) ?? [];
+			return n.length > 0 ? n[n.length - 1] : null;
+		}, (e) => de.current?.(e));
+	}, [
+		s,
+		u,
+		f,
+		ue,
+		v,
+		de
+	]), ve = E((t, n) => {
+		let r = e.current, i = f?.current;
+		if (!r || !i) return Pt({
+			ts: Date.now(),
+			clientX: t,
+			clientY: n,
+			rect: null,
+			view: null,
+			world: {
+				x: t,
+				y: n
+			},
+			fallback: !0
+		}), {
+			x: t,
+			y: n
+		};
+		let o = r.getBoundingClientRect(), [s, c] = a(t, n, o, i), l = {
+			x: s,
+			y: c
+		};
+		return Pt({
+			ts: Date.now(),
+			clientX: t,
+			clientY: n,
+			rect: {
+				left: o.left,
+				top: o.top,
+				width: o.width,
+				height: o.height
+			},
+			view: {
+				x: i.x,
+				y: i.y,
+				scaleX: i.scale.x,
+				scaleY: i.scale.y
+			},
+			world: l,
+			fallback: !1
+		}), l;
+	}, [e, f]), x = O(() => (e) => {
+		let n = t?.current?.hitTestExtras?.(e.x, e.y);
+		if (n) {
+			let e = n.hit;
+			return {
+				kind: `layer:${n.layerId}`,
+				owner: n.layerId,
+				strength: e.strength ?? "shared",
+				...e.claimedKinds === void 0 ? {} : { claimedKinds: e.claimedKinds },
+				...e.cursor === void 0 ? {} : { cursor: e.cursor },
+				...e.initialScratch === void 0 ? {} : { payload: e.initialScratch }
+			};
+		}
+		return b ? b(e) : null;
+	}, [b, t]), ye = E(() => {
+		t?.current?.requestRedraw?.();
+	}, [t]), be = E(() => t?.current?.paintedCursor, [t]), [xe] = A(St), Se = O(() => ({
+		state: xe,
+		...g?.duration === void 0 ? {} : { duration: g.duration },
+		...g?.haptics === void 0 ? {} : { haptics: g.haptics }
+	}), [
+		xe,
+		g?.duration,
+		g?.haptics
+	]), Ce = O(() => {
+		if (_) return {
+			targets: () => _.list().map((e) => ({
+				id: e.id,
+				...e.target
+			})),
+			resolver: _.resolver
+		};
+	}, [_]);
+	return M({
+		canvasRef: e,
+		actions: oe,
+		entriesById: le,
+		enabled: i,
+		keyboard: o,
+		affordanceAt: x,
+		classifyTarget: _e,
+		dispatcher: te,
+		clientToWorld: ve,
+		requestRedraw: ye,
+		paintedCursor: be,
+		getRuleCtx: ne,
+		onDoubleClick: h,
+		longPress: Se,
+		...Ce ? { views: Ce } : {}
+	}), Et("longPress", () => xe), null;
+}
+function Wt({ selection: e, scene: t, adapter: n, actions: r, excludeActions: i, currentViewRef: a, onViewChange: o, resizeOptions: s, poseDescriptor: c, geometryProjection: l, dispatcher: d, getActionRef: ee, pickEvery: f, layerIsPainted: te, alphaOf: ne, viewportPanEnabled: re, viewportZoom: g, viewportPinchZoom: oe, viewportRecenter: se, viewAnimation: _, editAnchorsExternalState: ce, anchorEditingAllowed: le, poseComposition: v, layouts: ue, layoutDropTarget: de, reflowTransition: fe, insertNodeFactories: y, snapPoint: pe, canvasRef: me, canvasApiRef: he, ingestionResolveSrc: b, ingestionSvg: ge, ingestionClipboard: _e, actionsRegistryRef: ve }) {
+	let x = wt();
+	D(() => (ve.current = x, () => {
+		ve.current = null;
+	}), [x, ve]), D(() => {
+		if (x) return x.setDispatcher(d);
+	}, [x, d]), D(() => {
+		if (x) return ee.current = (e) => x.list().find((t) => t.id === e), () => {
+			ee.current = null;
+		};
+	}, [x, ee]);
+	let ye = h(), be = qe(a, o, se, () => {
+		let e = me.current;
+		return e ? {
+			width: e.clientWidth,
+			height: e.clientHeight
+		} : null;
+	}, _, ye, te);
+	p({
+		selection: e,
+		scene: t,
+		view: be,
+		history: t.history,
+		exclude: i
+	}), Et("rootView", () => be);
+	let xe = u();
+	return Et("pointer", () => xe ?? void 0), lt({
+		pan: re,
+		zoom: g,
+		pinchZoom: oe
+	}), Je(t, e, c, v, ne), Ye(f), rt(t, ue, de, fe), at(t, {
+		layouts: ue,
+		poseDescriptor: c,
+		poseComposition: v
+	}), et(t, n, y), ae(t, e, n, v, c), C(pe), tt(he), w(me, () => a.current, b, ge, _e), Xe(t, e, c, v, ne), Ze(t), $e(t, e, n, ce, { anchorEditingAllowed: le }), nt(d), m(c), ie(v), ct(r, i.join("|")), /* @__PURE__ */ Ot(Dt, { children: [s ? /* @__PURE__ */ N(Gt, { options: s }) : null, l ? /* @__PURE__ */ N(Kt, { projection: l }) : null] });
+}
+function Gt({ options: e }) {
+	return re(ne(e)), null;
+}
+function Kt({ projection: e }) {
+	return it(e), null;
+}
+var I = yt(Vt);
+function L(e, t) {
+	return /* @__PURE__ */ N(Ct, {
+		yoke: e.yoke,
+		children: /* @__PURE__ */ N(b, { children: /* @__PURE__ */ N(I, {
+			...e,
+			ref: t
+		}) })
+	});
+}
+var qt = yt(L);
+//#endregion
+export { F as BUILTIN_TOOL_IDS, At as DEFAULT_HANDLE_SIZE, Re as SCENE_CANVAS_FEATURES, qt as SceneCanvas, Ft as mergeLayersWithDefaults, ye as rotateAroundAABBCenter };
+
+//# sourceMappingURL=SceneCanvas.js.map