@cognite/reveal-components 1.0.0

package/dist/ui/hooks/scenes/useSceneConfig.js

@@ -0,0 +1,91 @@
+import { VIEWER_TO_CDF_TRANSFORMATION as e } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { UseSceneConfigContext as t } from "./useSceneConfig.context.js";
+import { useContext as n, useMemo as r } from "react";
+import { Euler as i, MathUtils as a, Matrix4 as o, Quaternion as s, Vector3 as c } from "three";
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/useSceneConfig.ts
+var l = (e, i) => {
+	let { use3dScene: a } = n(t), o = a(e, i);
+	return {
+		data: r(() => o.data === void 0 ? void 0 : u(o.data), [o.data]),
+		isFetched: o.isFetched,
+		error: o.error,
+		isError: o.isError
+	};
+};
+function u(e) {
+	return {
+		sceneConfiguration: {
+			name: e.name,
+			cameraTranslationX: e.cameraTranslationX,
+			cameraTranslationY: e.cameraTranslationY,
+			cameraTranslationZ: e.cameraTranslationZ,
+			cameraEulerRotationX: e.cameraEulerRotationX,
+			cameraEulerRotationY: e.cameraEulerRotationY,
+			cameraEulerRotationZ: e.cameraEulerRotationZ,
+			cameraTargetX: e.cameraTargetX,
+			cameraTargetY: e.cameraTargetY,
+			cameraTargetZ: e.cameraTargetZ,
+			updatedAt: e.updatedAt,
+			qualitySettings: e.qualitySettings
+		},
+		skybox: e.skybox,
+		groundPlanes: e.groundPlanes,
+		sceneModels: e.modelOptions.map(d),
+		image360Collections: e.image360CollectionOptions.map(f)
+	};
+}
+function d(e) {
+	let t = p(e.transform);
+	return e.sourceType === "classic" ? {
+		...t,
+		modelIdentifier: {
+			modelId: e.modelId,
+			revisionId: e.revisionId
+		},
+		defaultVisible: e.defaultVisible
+	} : {
+		...t,
+		modelIdentifier: {
+			revisionExternalId: e.externalId,
+			revisionSpace: e.space
+		},
+		defaultVisible: e.defaultVisible
+	};
+}
+function f(e) {
+	return {
+		...p(e.transform),
+		image360CollectionExternalId: e.externalId,
+		image360CollectionSpace: e.space,
+		defaultVisible: e.defaultVisible
+	};
+}
+function p(t) {
+	if (t === void 0) return {
+		translationX: 0,
+		translationY: 0,
+		translationZ: 0,
+		eulerRotationX: 0,
+		eulerRotationY: 0,
+		eulerRotationZ: 0,
+		scaleX: 1,
+		scaleY: 1,
+		scaleZ: 1
+	};
+	let n = new o().copy(t).premultiply(e), r = new c(), l = new s(), u = new c();
+	n.decompose(r, l, u);
+	let d = new i().setFromQuaternion(l, "XYZ");
+	return {
+		translationX: r.x,
+		translationY: r.y,
+		translationZ: r.z,
+		eulerRotationX: a.radToDeg(d.x),
+		eulerRotationY: a.radToDeg(d.y),
+		eulerRotationZ: a.radToDeg(d.z),
+		scaleX: u.x,
+		scaleY: u.y,
+		scaleZ: u.z
+	};
+}
+//#endregion
+export { l as useSceneConfig };

package/dist/ui/hooks/types.d.ts

@@ -0,0 +1,61 @@
+import { MOUSE, Vector2 } from 'three';
+import { AnyIntersection, DataSourceType, Image360AnnotationIntersection } from '@cognite/reveal';
+import { Asset, CogniteInternalId } from '@cognite/sdk';
+import { HybridImage360AnnotationMappedData } from '../../data-providers/cache/cad/types';
+import { AssetProperties } from '../../data-providers/core-dm-provider/utils/filters';
+import { Source, DmsUniqueIdentifier, FdmNode } from '../../data-providers/FdmSDK';
+import { SlimCadNode } from '../../data-providers/utils/cadNodeConnectionFields';
+import { PointCloudDMVolumeMappingWithViews } from '../query/core-dm/usePointCloudDMVolumeMappingForIntersection';
+export type ClassicPointCloudAnnotationMappedAssetData = {
+    annotationId: number;
+    asset: Asset;
+};
+export type DmPointCloudAnnotationMappedAssetData = {
+    annotationId: number;
+    asset: FdmNode<AssetProperties>;
+    views?: Source[];
+};
+export type PointCloudAnnotationMappedAssetData = ClassicPointCloudAnnotationMappedAssetData | DmPointCloudAnnotationMappedAssetData;
+export type Image360AnnotationMappedAssetData = HybridImage360AnnotationMappedData | DmImage360AnnotationMappedData;
+export type DmImage360AnnotationMappedData = {
+    asset: FdmNode<AssetProperties>;
+    annotationIds: DmsUniqueIdentifier[];
+};
+export type AssetMappingDataResult = {
+    cadNode: SlimCadNode;
+    assetIds: CogniteInternalId[];
+};
+export type FdmNodeDataResult = {
+    fdmNodes: DmsUniqueIdentifier[];
+    cadNode: SlimCadNode;
+    /**
+     * A value of `undefined` means it's not yet finished evaluating.
+     * A value of `null` means there was no result
+     */
+    views?: Source[][] | null;
+};
+export type ClickedNodeData = {
+    mouseButton?: MOUSE;
+    position?: Vector2;
+    /**
+     * A value of `undefined` means it's not yet finished evaluating.
+     * A value of `null` means there was no result
+     */
+    fdmResult?: FdmNodeDataResult | null;
+    /**
+     * A value of `undefined` means it's not yet finished evaluating.
+     * A value of `null` means there was no result
+     */
+    assetMappingResult?: AssetMappingDataResult | null;
+    /**
+     * A value of `undefined` means it's not yet finished evaluating.
+     * A value of `null` means there was no result
+     */
+    pointCloudAnnotationMappingResult?: PointCloudAnnotationMappedAssetData[] | null;
+    /**
+     * A value of `undefined` means it's not yet finished evaluating.
+     * A value of `null` means there was no result
+     */
+    pointCloudFdmVolumeMappingResult?: PointCloudDMVolumeMappingWithViews[] | null;
+    intersection: AnyIntersection | Image360AnnotationIntersection<DataSourceType>;
+};

package/dist/ui/hooks/use3dModels.d.ts

@@ -0,0 +1,13 @@
+import { Context } from 'react';
+import { CogniteModel, DataSourceType } from '@cognite/reveal';
+import { useRevealDomainObjects } from './useRevealDomainObjects';
+export type Use3dModelsDependencies = {
+    useRevealDomainObjects: typeof useRevealDomainObjects;
+};
+export declare const defaultUse3dModelsDependencies: Use3dModelsDependencies;
+export declare const Use3dModelsContext: Context<Use3dModelsDependencies>;
+/**
+ * Returns DomainObjects corresponding to the CogniteModel model types in
+ * Reveal; i.e. CAD and Point clouds only
+ */
+export declare const use3dModels: () => Array<CogniteModel<DataSourceType>>;

package/dist/ui/hooks/use3dModels.js

@@ -0,0 +1,12 @@
+import { PointCloudDomainObject as e } from "../../domains/reveal/pointCloud/PointCloudDomainObject.js";
+import { isDefined as t } from "../../utilities/isDefined.js";
+import { CadDomainObject as n } from "../../domains/reveal/cad/CadDomainObject.js";
+import { useRevealDomainObjects as r } from "./useRevealDomainObjects.js";
+import { createContext as i, useContext as a, useMemo as o } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/use3dModels.ts
+var s = { useRevealDomainObjects: r }, c = i(s), l = () => {
+	let { useRevealDomainObjects: r } = a(c), i = r();
+	return o(() => i.filter((t) => t instanceof e || t instanceof n).map((e) => e.model).filter(t), [i]);
+};
+//#endregion
+export { c as Use3dModelsContext, s as defaultUse3dModelsDependencies, l as use3dModels };

package/dist/ui/hooks/useActiveReveal3dResources.d.ts

@@ -0,0 +1,14 @@
+import { Context } from 'react';
+import { AddModelOptions, DataSourceType, Image360Collection } from '@cognite/reveal';
+import { useFdmSdk } from '../components/RevealCanvas/SDKProvider';
+import { useVisibleRevealDomainObjects } from './useVisibleRevealDomainObjects';
+export type UseActiveReveal3dResourcesDependencies = {
+    useVisibleRevealDomainObjects: typeof useVisibleRevealDomainObjects;
+    useFdmSdk: typeof useFdmSdk;
+};
+export declare const defaultUseActiveReveal3dResourcesDependencies: UseActiveReveal3dResourcesDependencies;
+export declare const UseActiveReveal3dResourcesContext: Context<UseActiveReveal3dResourcesDependencies>;
+export declare const useActiveReveal3dResources: () => {
+    models: AddModelOptions[];
+    image360Collections: Array<Image360Collection<DataSourceType>>;
+};

package/dist/ui/hooks/useActiveReveal3dResources.js

@@ -0,0 +1,44 @@
+import { Image360CollectionDomainObject as e } from "../../domains/reveal/Image360Collection/Image360CollectionDomainObject.js";
+import { PointCloudDomainObject as t } from "../../domains/reveal/pointCloud/PointCloudDomainObject.js";
+import { isDefined as n } from "../../utilities/isDefined.js";
+import { EMPTY_ARRAY as r } from "../../utilities/constants.js";
+import { CadDomainObject as i } from "../../domains/reveal/cad/CadDomainObject.js";
+import { getModelIdAndRevisionIdFromExternalId as a } from "../../data-providers/network/common/getModelIdAndRevisionIdFromExternalId.js";
+import { useFdmSdk as o } from "../components/RevealCanvas/SDKProvider.js";
+import { useVisibleRevealDomainObjects as s } from "./useVisibleRevealDomainObjects.js";
+import { createContext as c, useContext as l, useMemo as u } from "react";
+import { useQuery as d } from "@tanstack/react-query";
+import { CognitePointCloudModel as f, isDMPointCloudModel as p } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/hooks/useActiveReveal3dResources.ts
+var m = {
+	useVisibleRevealDomainObjects: s,
+	useFdmSdk: o
+}, h = c(m), g = () => {
+	let { useVisibleRevealDomainObjects: o, useFdmSdk: s } = l(h), c = o(), f = s(), m = u(() => c.filter((e) => e instanceof t || e instanceof i).map((e) => e.model).filter(n), [c]), g = u(() => c.filter((t) => t instanceof e).map((e) => e.model).filter(n), [c]), v = d({
+		queryKey: ["visible-3d-models", m.map(_).sort()],
+		queryFn: async () => {
+			let e = m.map(async (e) => {
+				if (e.type === "pointcloud" && p(e)) {
+					let t = e;
+					return await a(t.modelIdentifier.revisionExternalId, t.modelIdentifier.revisionSpace, f);
+				}
+				return {
+					modelId: e.modelId,
+					revisionId: e.revisionId
+				};
+			});
+			return (await Promise.allSettled(e)).filter((e) => e.status === "fulfilled").map((e) => e.value);
+		},
+		enabled: m.length > 0,
+		staleTime: Infinity
+	});
+	return u(() => ({
+		models: v.data ?? r,
+		image360Collections: g
+	}), [v.data, g]);
+};
+function _(e) {
+	return e instanceof f && p(e) ? `${e.modelIdentifier.revisionExternalId}/${e.modelIdentifier.revisionSpace}` : `${e.modelId}/${e.revisionId}`;
+}
+//#endregion
+export { h as UseActiveReveal3dResourcesContext, m as defaultUseActiveReveal3dResourcesDependencies, g as useActiveReveal3dResources };

package/dist/ui/hooks/useCameraNavigation.d.ts

@@ -0,0 +1,23 @@
+import { Context } from 'react';
+import { CameraState } from '@cognite/reveal';
+import { useFdmCadNodeCache } from '../../data-providers/cache/CacheProvider';
+import { useReveal } from '../components/RevealCanvas/ViewerContext';
+export type CameraNavigationActions = {
+    fitCameraToVisualSceneBoundingBox: (duration?: number) => void;
+    fitCameraToAllModels: (duration?: number) => void;
+    fitCameraToModelNode: (revisionId: number, nodeId: number) => Promise<void>;
+    fitCameraToModelNodes: (revisionId: number, nodeids: number[]) => Promise<void>;
+    fitCameraToInstance: (externalId: string, space: string) => Promise<void>;
+    fitCameraToInstances: (instances: Array<{
+        externalId: string;
+        space: string;
+    }>) => Promise<void>;
+    fitCameraToState: (cameraState: CameraState) => void;
+};
+export type UseCameraNavigationDependencies = {
+    useReveal: typeof useReveal;
+    useFdmCadNodeCache: typeof useFdmCadNodeCache;
+};
+export declare const defaultUseCameraNavigationDependencies: UseCameraNavigationDependencies;
+export declare const UseCameraNavigationContext: Context<UseCameraNavigationDependencies>;
+export declare const useCameraNavigation: () => CameraNavigationActions;

package/dist/ui/hooks/useCameraNavigation.js

@@ -0,0 +1,68 @@
+import { useReveal as e } from "../components/RevealCanvas/ViewerContext.js";
+import { useFdmCadNodeCache as t } from "../../data-providers/cache/CacheProvider.js";
+import { createContext as n, useCallback as r, useContext as i, useMemo as a } from "react";
+import { Box3 as o } from "three";
+import { CogniteCadModel as s } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/hooks/useCameraNavigation.tsx
+var c = {
+	useReveal: e,
+	useFdmCadNodeCache: t
+}, l = n(c), u = () => {
+	let { useFdmCadNodeCache: e, useReveal: t } = i(l), n = e(), c = t(), u = r((e) => {
+		c.fitCameraToVisualSceneBoundingBox(e);
+	}, [c]), d = r((e) => {
+		let t = c.models;
+		t.length !== 0 && c.fitCameraToModels(t, e, !0);
+	}, [c]), f = r(async (e, t) => {
+		let n = c.models.find((t) => t.revisionId === e);
+		if (n === void 0) {
+			await Promise.reject(/* @__PURE__ */ Error(`Could not find model with revision ${e}`));
+			return;
+		}
+		if (!(n instanceof s)) return;
+		let r = (await n.getBoundingBoxesByNodeIds(t)).reduce((e, t) => e.union(t), new o());
+		c.cameraManager.fitCameraToBoundingBox(r);
+	}, [c]), p = r(async (e, t) => {
+		await f(e, [t]);
+	}, [f]), m = r(async (e) => {
+		let t = c.models.map((e) => ({
+			modelId: e.modelId,
+			revisionId: e.revisionId
+		})), r = (await n?.getMappingsForFdmInstances(e, t))?.find((e) => e.mappings.size > 0), i = [...r?.mappings.values() ?? []].flat().map((e) => e.id);
+		if (r === void 0 || i.length === 0) {
+			await Promise.reject(/* @__PURE__ */ Error("Could not find a model connected to the instances"));
+			return;
+		}
+		await f(r.revisionId, i);
+	}, [
+		c,
+		n,
+		f
+	]), h = r(async (e, t) => {
+		await m([{
+			externalId: e,
+			space: t
+		}]);
+	}, [m]), g = r((e) => {
+		c.cameraManager.setCameraState(e);
+	}, [c]);
+	return a(() => ({
+		fitCameraToVisualSceneBoundingBox: u,
+		fitCameraToAllModels: d,
+		fitCameraToInstance: h,
+		fitCameraToInstances: m,
+		fitCameraToModelNode: p,
+		fitCameraToModelNodes: f,
+		fitCameraToState: g
+	}), [
+		u,
+		d,
+		h,
+		m,
+		p,
+		f,
+		g
+	]);
+};
+//#endregion
+export { l as UseCameraNavigationContext, c as defaultUseCameraNavigationDependencies, u as useCameraNavigation };

package/dist/ui/hooks/useClickedNode.context.d.ts

@@ -0,0 +1,19 @@
+import { Context } from 'react';
+import { getPoiIntersectionFromPixel } from '../../domains/pointsOfInterest/getPoiIntersectionFromPixel';
+import { isActiveEditTool } from '../../foundation/commands/BaseEditTool';
+import { useRenderTarget, useReveal } from '../components/RevealCanvas/ViewerContext';
+import { usePointCloudDMVolumeMappingForIntersection } from '../query/core-dm/usePointCloudDMVolumeMappingForIntersection';
+import { useFdm3dNodeDataPromises, useAssetMappingForTreeIndex } from './cad';
+import { usePointCloudAnnotationMappingForIntersection } from './pointClouds/usePointCloudAnnotationMappingForIntersection';
+export type UseClickedNodeDataDependencies = {
+    useFdm3dNodeDataPromises: typeof useFdm3dNodeDataPromises;
+    useAssetMappingForTreeIndex: typeof useAssetMappingForTreeIndex;
+    usePointCloudAnnotationMappingForIntersection: typeof usePointCloudAnnotationMappingForIntersection;
+    usePointCloudDMVolumeMappingForIntersection: typeof usePointCloudDMVolumeMappingForIntersection;
+    useRenderTarget: typeof useRenderTarget;
+    useReveal: typeof useReveal;
+    isActiveEditTool: typeof isActiveEditTool;
+    getPoiIntersectionFromPixel: typeof getPoiIntersectionFromPixel;
+};
+export declare const defaultUseClickedNodeDataDependencies: UseClickedNodeDataDependencies;
+export declare const UseClickedNodeDataContext: Context<UseClickedNodeDataDependencies>;

package/dist/ui/hooks/useClickedNode.context.js

@@ -0,0 +1,22 @@
+import { useRenderTarget as e, useReveal as t } from "../components/RevealCanvas/ViewerContext.js";
+import { isActiveEditTool as n } from "../../foundation/commands/BaseEditTool.js";
+import { getPoiIntersectionFromPixel as r } from "../../domains/pointsOfInterest/getPoiIntersectionFromPixel.js";
+import { usePointCloudDMVolumeMappingForIntersection as i } from "../query/core-dm/usePointCloudDMVolumeMappingForIntersection.js";
+import { useAssetMappingForTreeIndex as a } from "./cad/useAssetMappingForTreeIndex.js";
+import { useFdm3dNodeDataPromises as o } from "./cad/useFdm3dNodeDataPromises.js";
+import "./cad/index.js";
+import { usePointCloudAnnotationMappingForIntersection as s } from "./pointClouds/usePointCloudAnnotationMappingForIntersection.js";
+import { createContext as c } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useClickedNode.context.ts
+var l = {
+	useFdm3dNodeDataPromises: o,
+	useAssetMappingForTreeIndex: a,
+	usePointCloudAnnotationMappingForIntersection: s,
+	usePointCloudDMVolumeMappingForIntersection: i,
+	useRenderTarget: e,
+	useReveal: t,
+	isActiveEditTool: n,
+	getPoiIntersectionFromPixel: r
+}, u = c(l);
+//#endregion
+export { u as UseClickedNodeDataContext, l as defaultUseClickedNodeDataDependencies };

package/dist/ui/hooks/useClickedNode.d.ts

@@ -0,0 +1,8 @@
+import { Vector3 } from 'three';
+import { ClickedNodeData } from './types';
+export declare const useClickedNodeData: (options?: {
+    leftClick?: boolean;
+    rightClick?: boolean;
+    disableOnEditTool?: boolean;
+}) => ClickedNodeData | undefined;
+export declare function getClickedNodeDataIntersectionPosition(clickedNodeData: ClickedNodeData): Vector3 | undefined;

package/dist/ui/hooks/useClickedNode.js

@@ -0,0 +1,115 @@
+import { isClassicCadAssetMapping as e, isDmCadAssetMapping as t } from "../../data-providers/cache/cad/assetMappingTypes.js";
+import { UseClickedNodeDataContext as n } from "./useClickedNode.context.js";
+import { useContext as r, useEffect as i, useMemo as a, useState as o } from "react";
+import { MOUSE as s, Vector2 as c } from "three";
+//#region libs/shared/reveal-components/src/ui/hooks/useClickedNode.tsx
+var l = (e) => {
+	let { useFdm3dNodeDataPromises: t, useAssetMappingForTreeIndex: a, usePointCloudAnnotationMappingForIntersection: l, usePointCloudDMVolumeMappingForIntersection: d, useRenderTarget: f, useReveal: p, isActiveEditTool: m, getPoiIntersectionFromPixel: h } = r(n), g = e?.leftClick ?? !0, _ = e?.rightClick ?? !1, v = e?.disableOnEditTool ?? !0, y = p(), b = f(), [x, S] = o(void 0), [C, w] = o(void 0), [T, E] = o(void 0), [D, O] = o(void 0);
+	i(() => {
+		let e = (e) => {
+			(async () => {
+				let t = g && e.button === s.LEFT, n = _ && e.button === s.RIGHT;
+				if (!(t || n) || v && m(b.commandsController)) {
+					E(void 0), O(void 0);
+					return;
+				}
+				let r = new c(e.offsetX, e.offsetY);
+				E(r), O(e.button);
+				let i = h(b, b.root, r);
+				if (i !== void 0) {
+					S(i), w(void 0);
+					return;
+				}
+				let a = await y.getAnyIntersectionFromPixel(r), o = await y.get360AnnotationIntersectionFromPixel(e.offsetX, e.offsetY);
+				S(a === void 0 ? void 0 : a), w(o === null ? void 0 : o);
+			})();
+		};
+		return y.on("click", e), () => {
+			y.off("click", e);
+		};
+	}, [
+		y,
+		b,
+		h
+	]);
+	let { data: k } = t(x), { data: A } = a(x);
+	return u(D, T, k, A, l(x), d(x), C ?? x);
+}, u = (e, t, n, r, i, o, s) => {
+	let c = d(n);
+	return a(() => {
+		if (s !== void 0) return {
+			mouseButton: e,
+			position: t,
+			fdmResult: f(r, c),
+			assetMappingResult: p(r),
+			pointCloudAnnotationMappingResult: l(i),
+			pointCloudFdmVolumeMappingResult: l(o),
+			intersection: s
+		};
+	}, [
+		s,
+		r,
+		c,
+		i,
+		o,
+		e,
+		t
+	]);
+	function l(e) {
+		return e.isFetching ? void 0 : e.data === void 0 || e.data.length === 0 ? null : e.data;
+	}
+}, d = (e) => {
+	let [t, n] = o();
+	return i(() => {
+		if (e === void 0) {
+			n(void 0);
+			return;
+		}
+		t(e);
+		async function t(e) {
+			let t = await e.cadAndFdmNodesPromise;
+			if (t === void 0 || t.fdmIds.length === 0) {
+				n(null);
+				return;
+			}
+			n({
+				fdmNodes: t.fdmIds,
+				cadNode: t.cadNode,
+				views: void 0
+			});
+			let r = await e.viewsPromise;
+			if (r === void 0 || r.length === 0) {
+				n({
+					fdmNodes: t.fdmIds,
+					cadNode: t.cadNode,
+					views: null
+				});
+				return;
+			}
+			n({
+				fdmNodes: t.fdmIds,
+				cadNode: t.cadNode,
+				views: r
+			});
+		}
+	}, [e]), t;
+};
+function f(e, n) {
+	if (e !== void 0 && e.node !== void 0 && e.mappings.some(t)) {
+		let n = e.mappings.filter(t).map((e) => e.instanceId);
+		return {
+			cadNode: e.node,
+			fdmNodes: n
+		};
+	}
+	if (n != null) return n;
+	if (n !== void 0 && e !== void 0) return null;
+}
+function p(t) {
+	if (t !== void 0) return t.node === void 0 ? null : {
+		cadNode: t.node,
+		assetIds: t.mappings.filter(e).map((e) => e.assetId)
+	};
+}
+//#endregion
+export { l as useClickedNodeData };

package/dist/ui/hooks/useCreateAssetMappingsMapPerModel.d.ts

@@ -0,0 +1,4 @@
+import { CogniteCadModel, CogniteModel, DataSourceType } from '@cognite/reveal';
+import { HybridCadAssetMapping } from '../../data-providers/cache/cad/assetMappingTypes';
+import { ModelWithAssetMappings } from './cad/modelWithAssetMappings';
+export declare const useCreateAssetMappingsMapPerModel: (models: Array<CogniteModel<DataSourceType>>, assetMappings: ModelWithAssetMappings[] | undefined) => Map<CogniteCadModel, HybridCadAssetMapping[] | undefined>;

package/dist/ui/hooks/useCreateAssetMappingsMapPerModel.js

@@ -0,0 +1,14 @@
+import { isDefined as e } from "../../utilities/isDefined.js";
+import { useMemo as t } from "react";
+import { CogniteCadModel as n } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/hooks/useCreateAssetMappingsMapPerModel.tsx
+var r = (r, i) => t(() => {
+	let t = /* @__PURE__ */ new Map();
+	return r.forEach((r) => {
+		if (!(r instanceof n)) return;
+		let a = i?.filter((e) => e.model.modelId === r.modelId).map((e) => e.assetMappings).flat().filter(e) ?? [];
+		t.set(r, a);
+	}), t;
+}, [i, r]);
+//#endregion
+export { r as useCreateAssetMappingsMapPerModel };

package/dist/ui/hooks/useGhostMode.d.ts

@@ -0,0 +1 @@
+export declare const useGhostMode: () => boolean;

package/dist/ui/hooks/useGhostMode.js

@@ -0,0 +1,11 @@
+import { useRenderTarget as e } from "../components/RevealCanvas/ViewerContext.js";
+import "../components/RevealCanvas/index.js";
+import { useNullableCommandProperty as t } from "../components/commandBased/hooks/useCommandProperty.js";
+import { SetGhostModeCommand as n } from "../../domains/reveal/cad/commands/SetGhostModeCommand.js";
+//#region libs/shared/reveal-components/src/ui/hooks/useGhostMode.tsx
+var r = () => {
+	let r = e().commandsController.getCommandByTypeRecursive(n);
+	return t(r, () => r?.isChecked) ?? !1;
+};
+//#endregion
+export { r as useGhostMode };

package/dist/ui/hooks/useGroundPlaneFromScene.context.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'react';
+import { Texture } from 'three';
+import { useSDK } from '../components/RevealCanvas/SDKProvider';
+import { useRenderTarget } from '../components/RevealCanvas/ViewerContext';
+import { initializeGroundPlane, GroundPlaneData } from './initializeGroundPlane';
+import { useSceneConfig } from './scenes/useSceneConfig';
+export type GroundPlaneFromSceneDependencies = {
+    useSceneConfig: typeof useSceneConfig;
+    useSDK: typeof useSDK;
+    useRenderTarget: typeof useRenderTarget;
+    loadTexture: (url: string) => Promise<Texture>;
+    initializeGroundPlane: typeof initializeGroundPlane;
+    logError: (message: string) => void;
+};
+export declare const defaultGroundPlaneFromSceneDependencies: GroundPlaneFromSceneDependencies;
+export declare const GroundPlaneFromSceneContext: Context<GroundPlaneFromSceneDependencies>;
+export type { GroundPlaneData };

package/dist/ui/hooks/useGroundPlaneFromScene.context.js

@@ -0,0 +1,23 @@
+import { useRenderTarget as e } from "../components/RevealCanvas/ViewerContext.js";
+import { initializeGroundPlane as t } from "./initializeGroundPlane.js";
+import { useSDK as n } from "../components/RevealCanvas/SDKProvider.js";
+import { useSceneConfig as r } from "./scenes/useSceneConfig.js";
+import { createContext as i } from "react";
+import { TextureLoader as a } from "three";
+//#region libs/shared/reveal-components/src/ui/hooks/useGroundPlaneFromScene.context.ts
+async function o(e) {
+	return new a().loadAsync(e);
+}
+function s(e) {
+	console.error(e);
+}
+var c = {
+	useSceneConfig: r,
+	useSDK: n,
+	useRenderTarget: e,
+	loadTexture: o,
+	initializeGroundPlane: t,
+	logError: s
+}, l = i(c);
+//#endregion
+export { l as GroundPlaneFromSceneContext, c as defaultGroundPlaneFromSceneDependencies };

package/dist/ui/hooks/useGroundPlaneFromScene.d.ts

@@ -0,0 +1 @@
+export declare function useGroundPlaneFromScene(sceneExternalId: string, sceneSpaceId: string): void;

package/dist/ui/hooks/useGroundPlaneFromScene.js

@@ -0,0 +1,60 @@
+import { GroundPlaneFromSceneContext as e } from "./useGroundPlaneFromScene.context.js";
+import { useContext as t, useEffect as n } from "react";
+import { useQuery as r } from "@tanstack/react-query";
+import { Vector2 as i, Vector3 as a } from "three";
+//#region libs/shared/reveal-components/src/ui/hooks/useGroundPlaneFromScene.tsx
+function o(o, c) {
+	let { useSceneConfig: l, useSDK: u, useRenderTarget: d, loadTexture: f, initializeGroundPlane: p, logError: m } = t(e), h = l(o, c), g = d(), _ = u(), { data: v } = r({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"groundplaneUrls",
+			h.data ?? "noSceneData"
+		],
+		queryFn: async () => {
+			if (h.data?.groundPlanes === void 0 || h.data.groundPlanes.length === 0) return [];
+			let e = await _.files.getDownloadUrls(h.data.groundPlanes.map((e) => ({ externalId: e.file })));
+			return await Promise.all(e.map(async (e) => {
+				try {
+					return await f(e.downloadUrl);
+				} catch {
+					m("Failed to load groundplane texture");
+					return;
+				}
+			}));
+		},
+		staleTime: Infinity
+	});
+	n(() => {
+		let e = [];
+		if (h.data === void 0 || v === void 0 || v.length === 0) return () => {
+			for (let t of e) t();
+		};
+		let t = s(h.data.sceneConfiguration.updatedAt);
+		return h.data.groundPlanes.forEach((n, r) => {
+			let o = v[r];
+			if (o === void 0) return;
+			let s = {
+				texture: o,
+				wrapping: n.wrapping,
+				repeatUV: new i(n.repeatU, n.repeatV),
+				scaleXY: new i(n.scaleX, t ? n.scaleZ : n.scaleY),
+				translation: new a(n.translationX, n.translationY, n.translationZ),
+				rotation: new a(n.eulerRotationX, n.eulerRotationY, n.eulerRotationZ)
+			}, [, c] = p(s, g);
+			e.push(c);
+		}), () => {
+			for (let t of e) t();
+		};
+	}, [
+		v,
+		h.data,
+		g,
+		p
+	]);
+}
+function s(e) {
+	return e !== void 0 && new Date(e) > /* @__PURE__ */ new Date("2024-08-01T10:44:00.000Z");
+}
+//#endregion
+export { o as useGroundPlaneFromScene };

package/dist/ui/hooks/useImage360AnnotationMappingsForInstanceReferences.context.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'react';
+import { useImage360AnnotationCache } from '../../data-providers/cache/CacheProvider';
+export type Image360AnnotationMappingsDependencies = {
+    useImage360AnnotationCache: typeof useImage360AnnotationCache;
+};
+export declare const defaultImage360AnnotationMappingsDependencies: Image360AnnotationMappingsDependencies;
+export declare const Image360AnnotationMappingsContext: Context<Image360AnnotationMappingsDependencies>;

package/dist/ui/hooks/useImage360AnnotationMappingsForInstanceReferences.context.js

@@ -0,0 +1,6 @@
+import { useImage360AnnotationCache as e } from "../../data-providers/cache/CacheProvider.js";
+import { createContext as t } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useImage360AnnotationMappingsForInstanceReferences.context.ts
+var n = { useImage360AnnotationCache: e }, r = t(n);
+//#endregion
+export { r as Image360AnnotationMappingsContext, n as defaultImage360AnnotationMappingsDependencies };