@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,7 @@
+import { Image360AnnotationAssetInfo } from '../../data-providers/cache/types';
+import { InstanceReference } from '../../utilities/instanceIds';
+export type Image360AnnotationMappingsResult = {
+    data: Image360AnnotationAssetInfo[] | undefined;
+    isSuccess: boolean;
+};
+export declare const useImage360AnnotationMappingsForInstanceReferences: (assetIds: InstanceReference[] | undefined, image360CollectionKeys: string[] | undefined) => Image360AnnotationMappingsResult;

package/dist/ui/hooks/useImage360AnnotationMappingsForInstanceReferences.js

@@ -0,0 +1,30 @@
+import { createInstanceReferenceKey as e } from "../../utilities/instanceIds/toKey.js";
+import { Image360AnnotationMappingsContext as t } from "./useImage360AnnotationMappingsForInstanceReferences.context.js";
+import { useContext as n } from "react";
+import { useQueries as r } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/hooks/useImage360AnnotationMappingsForInstanceReferences.ts
+var i = (i, a) => {
+	let { useImage360AnnotationCache: o } = n(t), s = o(), c = (i?.length ?? 0) > 0 && (a?.length ?? 0) > 0, l = (i ?? []).map((t) => String(e(t))).sort(), u = r({ queries: (a ?? []).map((e) => ({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"image360-annotations-info",
+			e,
+			...l
+		],
+		queryFn: async () => i === void 0 || i.length === 0 ? [] : await s.getReveal360AnnotationsForAssets([e], i),
+		staleTime: Infinity,
+		enabled: c
+	})) });
+	if (!c) return {
+		data: [],
+		isSuccess: !0
+	};
+	let d = u.every((e) => e.isSuccess);
+	return {
+		data: d ? u.flatMap((e) => e.data ?? []) : void 0,
+		isSuccess: d
+	};
+};
+//#endregion
+export { i as useImage360AnnotationMappingsForInstanceReferences };

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

@@ -0,0 +1,8 @@
+import { Context } from 'react';
+import { DataSourceType, Image360Collection } from '@cognite/reveal';
+import { useRevealDomainObjects } from './useRevealDomainObjects';
+export type UseImage360CollectionsDependencies = {
+    useRevealDomainObjects: typeof useRevealDomainObjects;
+};
+export declare const UseImage360CollectionsContext: Context<UseImage360CollectionsDependencies>;
+export declare const useImage360Collections: () => Array<Image360Collection<DataSourceType>>;

package/dist/ui/hooks/useImage360Collections.js

@@ -0,0 +1,11 @@
+import { Image360CollectionDomainObject as e } from "../../domains/reveal/Image360Collection/Image360CollectionDomainObject.js";
+import { isDefined as t } from "../../utilities/isDefined.js";
+import { useRevealDomainObjects as n } from "./useRevealDomainObjects.js";
+import { createContext as r, useContext as i, useMemo as a } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useImage360Collections.ts
+var o = r({ useRevealDomainObjects: n }), s = () => {
+	let { useRevealDomainObjects: n } = i(o), r = n();
+	return a(() => r.filter((t) => t instanceof e).map((e) => e.model).filter(t), [r]);
+};
+//#endregion
+export { o as UseImage360CollectionsContext, s as useImage360Collections };

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

@@ -0,0 +1 @@
+export declare function useIsCoreDmOnly(): boolean;

package/dist/ui/hooks/useIsCoreDmOnly.js

@@ -0,0 +1,7 @@
+import { useRenderTarget as e } from "../components/RevealCanvas/ViewerContext.js";
+//#region libs/shared/reveal-components/src/ui/hooks/useIsCoreDmOnly.ts
+function t() {
+	return e().cdfCaches.coreDmOnly;
+}
+//#endregion
+export { t as useIsCoreDmOnly };

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

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

package/dist/ui/hooks/useIsDraggingOnViewer.js

@@ -0,0 +1,19 @@
+import { useReveal as e } from "../components/RevealCanvas/ViewerContext.js";
+import { useCallback as t, useEffect as n, useState as r } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useIsDraggingOnViewer.ts
+var i = () => {
+	let i = e(), [a, o] = r(!1), s = t(() => {
+		o(!1);
+	}, [o]), c = t(() => {
+		o(!0);
+	}, [o]);
+	return n(() => (i.domElement.addEventListener("pointerdown", c), window.addEventListener("pointerup", s), () => {
+		i.domElement.removeEventListener("pointerdown", c), window.removeEventListener("pointerup", s);
+	}), [
+		s,
+		c,
+		i.domElement
+	]), a;
+};
+//#endregion
+export { i as useIsDraggingOnViewer };

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

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

package/dist/ui/hooks/useIsRevealInitialized.js

@@ -0,0 +1,5 @@
+import { useRevealKeepAlive as e } from "../components/RevealKeepAlive/RevealKeepAliveContext.js";
+//#region libs/shared/reveal-components/src/ui/hooks/useIsRevealInitialized.tsx
+var t = () => e()?.renderTargetRef.current !== void 0;
+//#endregion
+export { t as useIsRevealInitialized };

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

@@ -0,0 +1,9 @@
+import { Context } from 'react';
+import { getModelIdAndRevisionIdFromExternalId } from '../../data-providers/network/common/getModelIdAndRevisionIdFromExternalId';
+import { useFdmSdk } from '../components/RevealCanvas/SDKProvider';
+export type ModelIdRevisionIdFromModelOptionsDependencies = {
+    useFdmSdk: typeof useFdmSdk;
+    getModelIdAndRevisionIdFromExternalId: typeof getModelIdAndRevisionIdFromExternalId;
+};
+export declare const defaultModelIdRevisionIdFromModelOptionsDependencies: ModelIdRevisionIdFromModelOptionsDependencies;
+export declare const ModelIdRevisionIdFromModelOptionsContext: Context<ModelIdRevisionIdFromModelOptionsDependencies>;

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

@@ -0,0 +1,10 @@
+import { getModelIdAndRevisionIdFromExternalId as e } from "../../data-providers/network/common/getModelIdAndRevisionIdFromExternalId.js";
+import { useFdmSdk as t } from "../components/RevealCanvas/SDKProvider.js";
+import { createContext as n } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useModelIdRevisionIdFromModelOptions.context.ts
+var r = {
+	useFdmSdk: t,
+	getModelIdAndRevisionIdFromExternalId: e
+}, i = n(r);
+//#endregion
+export { i as ModelIdRevisionIdFromModelOptionsContext, r as defaultModelIdRevisionIdFromModelOptionsDependencies };

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

@@ -0,0 +1,3 @@
+import { ClassicDataSourceType, AddModelOptions } from '@cognite/reveal';
+import { ModelOptionsInput } from '../../data-providers/types/resources';
+export declare const useModelIdRevisionIdFromModelOptions: (addModelOptionsArray: ModelOptionsInput[] | undefined) => Array<AddModelOptions<ClassicDataSourceType>>;

package/dist/ui/hooks/useModelIdRevisionIdFromModelOptions.js

@@ -0,0 +1,17 @@
+import { getModelKeys as e } from "../../utilities/getModelKeys.js";
+import { queryKeys as t } from "../../utilities/queryKeys.js";
+import { fetchClassicModelOption as n } from "../../data-providers/network/common/fetchClassicModelOption.js";
+import { ModelIdRevisionIdFromModelOptionsContext as r } from "./useModelIdRevisionIdFromModelOptions.context.js";
+import { useContext as i, useMemo as a } from "react";
+import { useQuery as o } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/hooks/useModelIdRevisionIdFromModelOptions.ts
+var s = (s) => {
+	let { getModelIdAndRevisionIdFromExternalId: c, useFdmSdk: l } = i(r), u = l(), d = e(s ?? []), f = o({
+		queryKey: [t.modelRevisionId(d)],
+		queryFn: async () => s === void 0 || s.length === 0 ? [] : await Promise.all(s.map(async (e) => await n(e, u, c))),
+		staleTime: Infinity
+	});
+	return a(() => f.data === void 0 ? [] : f.data, [f]);
+};
+//#endregion
+export { s as useModelIdRevisionIdFromModelOptions };

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

@@ -0,0 +1,8 @@
+import { CogniteClient } from '@cognite/sdk';
+import { AddReveal3DResource } from '../../data-providers/types/resources';
+export type UseSyncSceneConfigWithViewerProps = {
+    sdk: CogniteClient;
+    sceneExternalId: string;
+    sceneSpaceId: string;
+};
+export declare const useReveal3dResourcesFromScene: (sceneExternalId: string, sceneSpaceId: string) => AddReveal3DResource[];

package/dist/ui/hooks/useReveal3dResourcesFromScene.js

@@ -0,0 +1,24 @@
+import { useIsCoreDmOnly as e } from "./useIsCoreDmOnly.js";
+import { use3dScene as t } from "./scenes/use3dScene.js";
+import { useMemo as n } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useReveal3dResourcesFromScene.ts
+var r = (r, i) => {
+	let a = t(r, i), o = e();
+	return n(() => {
+		if (a.data === void 0 || a.data === null) return [];
+		let e = [...a.data.modelOptions];
+		return a.data.image360CollectionOptions.forEach((t) => {
+			let n = {
+				transform: t.transform,
+				defaultVisible: t.defaultVisible,
+				sourceType: o ? "cdm" : "dm",
+				externalId: t.externalId,
+				space: t.space,
+				modelCategory: "image360"
+			};
+			e.push(n);
+		}), e;
+	}, [o, a.data]);
+};
+//#endregion
+export { r as useReveal3dResourcesFromScene };

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

@@ -0,0 +1,8 @@
+import { Context } from 'react';
+import { RevealDomainObject } from '../../domains/reveal/RevealDomainObject';
+import { useRenderTarget } from '../components/RevealCanvas/ViewerContext';
+export type UseRevealDomainObjectsDependencies = {
+    useRenderTarget: typeof useRenderTarget;
+};
+export declare const UseRevealDomainObjectsContext: Context<UseRevealDomainObjectsDependencies>;
+export declare function useRevealDomainObjects(): RevealDomainObject[];

package/dist/ui/hooks/useRevealDomainObjects.js

@@ -0,0 +1,12 @@
+import { useRenderTarget as e } from "../components/RevealCanvas/ViewerContext.js";
+import { getRevealDomainUpdateSignal as t } from "../../domains/reveal/signal/getRevealDomainObjectsSignal.js";
+import { useDisposableSignal as n } from "../../utilities/signal/useDisposableSignal.js";
+import { createContext as r, useContext as i, useMemo as a } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useRevealDomainObjects.ts
+var o = r({ useRenderTarget: e });
+function s() {
+	let { useRenderTarget: e } = i(o), r = e(), s = a(() => t(r), [r]);
+	return n(s);
+}
+//#endregion
+export { o as UseRevealDomainObjectsContext, s as useRevealDomainObjects };

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

@@ -0,0 +1,11 @@
+import { Context } from 'react';
+import { useReveal } from '../components/RevealCanvas/ViewerContext';
+import { useSceneConfig } from './scenes/useSceneConfig';
+import { use3dModels } from './use3dModels';
+export type UseSceneDefaultCameraDependencies = {
+    useSceneConfig: typeof useSceneConfig;
+    useReveal: typeof useReveal;
+    use3dModels: typeof use3dModels;
+};
+export declare const defaultDependencies: UseSceneDefaultCameraDependencies;
+export declare const UseSceneDefaultCameraContext: Context<UseSceneDefaultCameraDependencies>;

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

@@ -0,0 +1,12 @@
+import { useReveal as e } from "../components/RevealCanvas/ViewerContext.js";
+import { use3dModels as t } from "./use3dModels.js";
+import { useSceneConfig as n } from "./scenes/useSceneConfig.js";
+import { createContext as r } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useSceneDefaultCamera.context.ts
+var i = {
+	useSceneConfig: n,
+	useReveal: e,
+	use3dModels: t
+}, a = r(i);
+//#endregion
+export { a as UseSceneDefaultCameraContext, i as defaultDependencies };

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

@@ -0,0 +1,3 @@
+export declare const useSceneDefaultCamera: (sceneExternalId: string | undefined, sceneSpaceId: string | undefined) => {
+    fitCameraToSceneDefault: () => void;
+} | undefined;

package/dist/ui/hooks/useSceneDefaultCamera.js

@@ -0,0 +1,82 @@
+import { fuzzyEquals as e } from "../../foundation/utilities/extensions/vectorUtils.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as t } from "../../foundation/renderTarget/convertCoordinates.js";
+import { UseSceneDefaultCameraContext as n } from "./useSceneDefaultCamera.context.js";
+import { useContext as r, useMemo as i } from "react";
+import { Euler as a, MathUtils as o, Matrix4 as s, Quaternion as c, Vector3 as l } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as u } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/hooks/useSceneDefaultCamera.tsx
+var d = (e, t) => {
+	let { useSceneConfig: a, use3dModels: o, useReveal: s } = r(n), { data: c, isFetched: u } = a(e, t), d = s(), m = o();
+	return i(() => {
+		if (!u) return;
+		if (c === void 0) return { fitCameraToSceneDefault: () => {
+			d.fitCameraToModels(m, 0, !0);
+		} };
+		if (c.sceneConfiguration.cameraTranslationX === 0 && c.sceneConfiguration.cameraTranslationY === 0 && c.sceneConfiguration.cameraTranslationZ === 0 && c.sceneConfiguration.cameraEulerRotationX === 0 && c.sceneConfiguration.cameraEulerRotationY === 0 && c.sceneConfiguration.cameraEulerRotationZ === 0 && c.sceneConfiguration.cameraTargetX === void 0 && c.sceneConfiguration.cameraTargetY === void 0 && c.sceneConfiguration.cameraTargetZ === void 0) return { fitCameraToSceneDefault: () => {
+			if (m.length === 0) {
+				let e = new l(-100, 200, 400), t = new l();
+				d.cameraManager.setCameraState({
+					position: e,
+					target: t
+				});
+			} else d.fitCameraToModels(m, 0, !0);
+		} };
+		let { position: e, target: t, rotation: n } = f(c.sceneConfiguration);
+		return { fitCameraToSceneDefault: () => {
+			let r = d.cameraManager.getCameraState();
+			if (r.target.x === 0 && r.target.y === 0 && r.target.z === 0) {
+				if (n === void 0) {
+					d.cameraManager.setCameraState({
+						position: e,
+						target: t
+					});
+					return;
+				}
+				d.cameraManager.setCameraState({
+					position: e,
+					rotation: n,
+					target: t
+				});
+			} else {
+				let n = p(e, t);
+				d.cameraManager.setCameraState({
+					position: e,
+					rotation: n
+				});
+			}
+		} };
+	}, [
+		d,
+		c,
+		u,
+		m
+	]);
+};
+function f(n) {
+	let r = new l(n.cameraTranslationX, n.cameraTranslationY, n.cameraTranslationZ), i = new l();
+	if (n.cameraTargetX === void 0 || n.cameraTargetY === void 0 || n.cameraTargetZ === void 0) {
+		let e = new c().setFromEuler(new a(o.degToRad(n.cameraEulerRotationX), o.degToRad(n.cameraEulerRotationY), o.degToRad(n.cameraEulerRotationZ), "XYZ"));
+		return i.copy(r).add(new l(0, 0, -50).applyQuaternion(e)), r.applyMatrix4(u), i.applyMatrix4(u), {
+			position: r,
+			target: i
+		};
+	}
+	i.set(n.cameraTargetX, n.cameraTargetY, n.cameraTargetZ);
+	let d = new l(n.cameraEulerRotationX, n.cameraEulerRotationY, n.cameraEulerRotationZ);
+	if (e(d, i, 1e-5)) return r.applyMatrix4(u), i.applyMatrix4(u), {
+		position: r,
+		target: i
+	};
+	let f = new s().makeRotationFromEuler(new a(o.degToRad(n.cameraEulerRotationX), o.degToRad(n.cameraEulerRotationY), o.degToRad(n.cameraEulerRotationZ), "XYZ"));
+	return f.premultiply(u).multiply(t), r.applyMatrix4(u), i.applyMatrix4(u), {
+		position: r,
+		rotation: new c().setFromRotationMatrix(f),
+		target: i
+	};
+}
+function p(e, t) {
+	let n = new l().subVectors(e, t).normalize(), r = new l(0, 1, 0), i = new l().crossVectors(r, n).normalize(), a = new l().crossVectors(n, i).normalize(), o = new s();
+	return o.makeBasis(i, a, n), new c().setFromRotationMatrix(o);
+}
+//#endregion
+export { d as useSceneDefaultCamera };

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

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

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

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

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

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

package/dist/ui/hooks/useSkyboxFromScene.js

@@ -0,0 +1,35 @@
+import { SkyboxDomainObject as e } from "../../domains/skybox/SkyboxDomainObject.js";
+import "../../domains/skybox/index.js";
+import { SkyboxFromSceneContext as t } from "./useSkyboxFromScene.context.js";
+import { useContext as n, useEffect as r } from "react";
+import { useQuery as i } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/hooks/useSkyboxFromScene.tsx
+function a(a, o) {
+	let { useSceneConfig: s, useSDK: c, useRenderTarget: l, loadTexture: u, logError: d } = n(t), f = s(a, o), p = l(), m = c(), { data: h } = i({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"skyboxUrl",
+			f.data
+		],
+		queryFn: async () => {
+			if (f.data?.skybox === void 0) return null;
+			let e = f.data.skybox.file, t = await m.files.getDownloadUrls([{ externalId: e }]);
+			if (t.length === 0) return null;
+			let n = t[0].downloadUrl;
+			try {
+				return await u(n);
+			} catch {
+				return d("Failed to load skybox texture"), null;
+			}
+		},
+		staleTime: Infinity
+	});
+	r(() => {
+		if (h == null) return;
+		let t = new e(h);
+		p.root.addChild(t), t.setVisible(!0, p);
+	}, [h, p]);
+}
+//#endregion
+export { a as useSkyboxFromScene };

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

@@ -0,0 +1,8 @@
+import { Context } from 'react';
+import { RevealDomainObject } from '../../domains/reveal/RevealDomainObject';
+import { useRenderTarget } from '../components/RevealCanvas/ViewerContext';
+export type UseVisibleRevealDomainObjectsDependencies = {
+    useRenderTarget: typeof useRenderTarget;
+};
+export declare const UseVisibleRevealDomainObjectsContext: Context<UseVisibleRevealDomainObjectsDependencies>;
+export declare function useVisibleRevealDomainObjects(): RevealDomainObject[];

package/dist/ui/hooks/useVisibleRevealDomainObjects.js

@@ -0,0 +1,17 @@
+import { useRenderTarget as e } from "../components/RevealCanvas/ViewerContext.js";
+import { Changes as t } from "../../foundation/domainObjectsHelpers/Changes.js";
+import "../../domains/index.js";
+import { getRevealDomainUpdateSignal as n } from "../../domains/reveal/signal/getRevealDomainObjectsSignal.js";
+import { useDisposableSignal as r } from "../../utilities/signal/useDisposableSignal.js";
+import { createContext as i, useContext as a, useMemo as o } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/useVisibleRevealDomainObjects.ts
+var s = i({ useRenderTarget: e });
+function c() {
+	let { useRenderTarget: e } = a(s), i = e(), c = o(() => {
+		let e = (e) => e.isVisible(i), r = [t.visibleState];
+		return n(i, e, r);
+	}, [i]);
+	return r(c);
+}
+//#endregion
+export { s as UseVisibleRevealDomainObjectsContext, c as useVisibleRevealDomainObjects };

package/dist/ui/query/FilterOnClassicAssetsInScene.context.d.ts

@@ -0,0 +1,12 @@
+import { Context } from 'react';
+import { useReveal3dResourcesFromScene } from '../hooks';
+import { useAllAssetsMapped360Annotations } from './useSearchAssetsMapped360Annotations';
+import { useAllAssetsMappedPointCloudAnnotations } from './useSearchAssetsMappedPointCloudAnnotations';
+import { useAllMappedEquipmentAssetMappings } from './useSearchMappedEquipmentAssetMappings';
+export type FilterOnClassicAssetsInSceneDependencies = {
+    useReveal3dResourcesFromScene: typeof useReveal3dResourcesFromScene;
+    useAllMappedEquipmentAssetMappings: typeof useAllMappedEquipmentAssetMappings;
+    useAllAssetsMappedPointCloudAnnotations: typeof useAllAssetsMappedPointCloudAnnotations;
+    useAllAssetsMapped360Annotations: typeof useAllAssetsMapped360Annotations;
+};
+export declare const FilterOnClassicAssetsInSceneContext: Context<FilterOnClassicAssetsInSceneDependencies>;

package/dist/ui/query/FilterOnClassicAssetsInScene.context.js

@@ -0,0 +1,15 @@
+import { useReveal3dResourcesFromScene as e } from "../hooks/useReveal3dResourcesFromScene.js";
+import "../hooks/index.js";
+import { useAllAssetsMapped360Annotations as t } from "./useSearchAssetsMapped360Annotations.js";
+import { useAllAssetsMappedPointCloudAnnotations as n } from "./useSearchAssetsMappedPointCloudAnnotations.js";
+import { useAllMappedEquipmentAssetMappings as r } from "./useSearchMappedEquipmentAssetMappings.js";
+import { createContext as i } from "react";
+//#region libs/shared/reveal-components/src/ui/query/FilterOnClassicAssetsInScene.context.ts
+var a = i({
+	useReveal3dResourcesFromScene: e,
+	useAllMappedEquipmentAssetMappings: r,
+	useAllAssetsMappedPointCloudAnnotations: n,
+	useAllAssetsMapped360Annotations: t
+});
+//#endregion
+export { a as FilterOnClassicAssetsInSceneContext };

package/dist/ui/query/core-dm/pointCloudDMVolumesQuery.d.ts

@@ -0,0 +1,32 @@
+import { ViewRef, DmsQueryShape } from '../../../data-providers/core-dm-provider/utils/queryTypeHelpers';
+import { DmsUniqueIdentifier } from '../../../data-providers/FdmSDK';
+type PointCloudVolumeSources = [
+    {
+        readonly source: ViewRef<'CognitePointCloudVolume'>;
+        readonly properties: [
+            'volumeReferences',
+            'object3D',
+            'revisions',
+            'volumeType',
+            'volume'
+        ];
+    }
+];
+type AssetSources = [
+    {
+        readonly source: ViewRef<'CogniteAsset'>;
+        readonly properties: ['object3D', 'name', 'description'];
+    }
+];
+declare function createPointCloudDMVolumesQuery(revisionRefs: DmsUniqueIdentifier[]): DmsQueryShape<{
+    pointCloudVolumes: 'nodes';
+    object3D: 'nodes';
+    assets: 'nodes';
+}, {
+    pointCloudVolumes: PointCloudVolumeSources;
+    object3D: undefined;
+    assets: AssetSources;
+}>;
+export type CdfPointCloudCollectionDmQuery = ReturnType<typeof createPointCloudDMVolumesQuery>;
+export declare const pointCloudDMVolumesQuery: (revisionRefs: DmsUniqueIdentifier[]) => CdfPointCloudCollectionDmQuery;
+export {};

package/dist/ui/query/core-dm/pointCloudDMVolumesQuery.js

@@ -0,0 +1,68 @@
+import { COGNITE_ASSET_SOURCE as e, COGNITE_POINT_CLOUD_VOLUME_SOURCE as t, COGNITE_VISUALIZABLE_SOURCE as n } from "../../../data-providers/core-dm-provider/dataModels.js";
+import { getRevisionContainsAnyFilter as r, hasDataObject3DContainerFilter as i, hasDataPointCloudVolumeContainerFilter as a, hasDataVisualizableContainerFilter as o, pointCloudVolumeHasObject3DFilter as s } from "../../../data-providers/core-dm-provider/utils/filters.js";
+//#region libs/shared/reveal-components/src/ui/query/core-dm/pointCloudDMVolumesQuery.ts
+var c = 2e3;
+function l(l) {
+	return {
+		with: {
+			pointCloudVolumes: {
+				nodes: { filter: { and: [
+					a,
+					r([{
+						externalId: l[0].externalId,
+						space: l[0].space
+					}]),
+					s
+				] } },
+				limit: c
+			},
+			object3D: {
+				nodes: {
+					from: "pointCloudVolumes",
+					filter: i,
+					through: {
+						view: t,
+						identifier: "object3D"
+					},
+					direction: "outwards"
+				},
+				limit: c
+			},
+			assets: {
+				nodes: {
+					from: "object3D",
+					filter: o,
+					through: {
+						view: n,
+						identifier: "object3D"
+					}
+				},
+				limit: 2001
+			}
+		},
+		select: {
+			pointCloudVolumes: { sources: [{
+				source: t,
+				properties: [
+					"volumeReferences",
+					"object3D",
+					"revisions",
+					"volumeType",
+					"volume"
+				]
+			}] },
+			object3D: {},
+			assets: { sources: [{
+				source: e,
+				properties: [
+					"object3D",
+					"name",
+					"description"
+				]
+			}] }
+		}
+	};
+}
+var u = (e) => l(e);
+//#endregion
+export { u as pointCloudDMVolumesQuery };

package/dist/ui/query/core-dm/typeGuards.d.ts

@@ -0,0 +1,2 @@
+import { PointCloudIntersection, AnyIntersection, DMDataSourceType } from '@cognite/reveal';
+export declare const isPointCloudVolumeIntersection: (intersection: AnyIntersection | undefined) => intersection is PointCloudIntersection<DMDataSourceType>;

package/dist/ui/query/core-dm/typeGuards.js

@@ -0,0 +1,4 @@
+//#region libs/shared/reveal-components/src/ui/query/core-dm/typeGuards.ts
+var e = (e) => e?.type === "pointcloud" && e.volumeMetadata !== void 0 && "assetRef" in e.volumeMetadata && "volumeInstanceRef" in e.volumeMetadata;
+//#endregion
+export { e as isPointCloudVolumeIntersection };

package/dist/ui/query/core-dm/usePointCloudDMVolumeMappingForAssetInstances.context.d.ts

@@ -0,0 +1,13 @@
+import { Context } from 'react';
+import { useFdmSdk } from '../../components/RevealCanvas/SDKProvider';
+import { useModelIdRevisionIdFromModelOptions } from '../../hooks/useModelIdRevisionIdFromModelOptions';
+import { usePointCloudModelRevisionIdsFromReveal } from '../usePointCloudModelRevisionIdsFromReveal';
+import { usePointCloudDMVolumes } from './usePointCloudDMVolumes';
+export type UsePointCloudDMVolumeMappingForAssetInstancesDependencies = {
+    usePointCloudModelRevisionIdsFromReveal: typeof usePointCloudModelRevisionIdsFromReveal;
+    useModelIdRevisionIdFromModelOptions: typeof useModelIdRevisionIdFromModelOptions;
+    usePointCloudDMVolumes: typeof usePointCloudDMVolumes;
+    useFdmSdk: typeof useFdmSdk;
+};
+export declare const defaultUsePointCloudDMVolumeMappingForAssetInstancesDependencies: UsePointCloudDMVolumeMappingForAssetInstancesDependencies;
+export declare const UsePointCloudDMVolumeMappingForAssetInstancesContext: Context<UsePointCloudDMVolumeMappingForAssetInstancesDependencies>;

package/dist/ui/query/core-dm/usePointCloudDMVolumeMappingForAssetInstances.context.js

@@ -0,0 +1,14 @@
+import { useFdmSdk as e } from "../../components/RevealCanvas/SDKProvider.js";
+import { useModelIdRevisionIdFromModelOptions as t } from "../../hooks/useModelIdRevisionIdFromModelOptions.js";
+import { usePointCloudModelRevisionIdsFromReveal as n } from "../usePointCloudModelRevisionIdsFromReveal.js";
+import { usePointCloudDMVolumes as r } from "./usePointCloudDMVolumes.js";
+import { createContext as i } from "react";
+//#region libs/shared/reveal-components/src/ui/query/core-dm/usePointCloudDMVolumeMappingForAssetInstances.context.ts
+var a = {
+	usePointCloudModelRevisionIdsFromReveal: n,
+	useModelIdRevisionIdFromModelOptions: t,
+	usePointCloudDMVolumes: r,
+	useFdmSdk: e
+}, o = i(a);
+//#endregion
+export { o as UsePointCloudDMVolumeMappingForAssetInstancesContext, a as defaultUsePointCloudDMVolumeMappingForAssetInstancesDependencies };

package/dist/ui/query/core-dm/usePointCloudDMVolumeMappingForAssetInstances.d.ts

@@ -0,0 +1,8 @@
+import { DMInstanceRef } from '@cognite/reveal';
+import { AssetProperties } from '../../../data-providers/core-dm-provider/utils/filters';
+import { DmsUniqueIdentifier } from '../../../data-providers/FdmSDK';
+export type PointCloudDMVolumeMappedAssetData = {
+    volumeInstanceRef: DMInstanceRef;
+    asset: DMInstanceRef & AssetProperties;
+};
+export declare const usePointCloudDMVolumeMappingForAssetInstances: (assetInstanceRefs: DmsUniqueIdentifier[]) => PointCloudDMVolumeMappedAssetData[];

package/dist/ui/query/core-dm/usePointCloudDMVolumeMappingForAssetInstances.js

@@ -0,0 +1,23 @@
+import { isDefined as e } from "../../../utilities/isDefined.js";
+import { EMPTY_ARRAY as t } from "../../../utilities/constants.js";
+import { UsePointCloudDMVolumeMappingForAssetInstancesContext as n } from "./usePointCloudDMVolumeMappingForAssetInstances.context.js";
+import { useContext as r, useMemo as i } from "react";
+//#region libs/shared/reveal-components/src/ui/query/core-dm/usePointCloudDMVolumeMappingForAssetInstances.ts
+var a = (a) => {
+	let { usePointCloudModelRevisionIdsFromReveal: o, useModelIdRevisionIdFromModelOptions: s, usePointCloudDMVolumes: c } = r(n), { data: l } = o(), u = s(l), { data: d } = c(u);
+	return i(() => u.length === 0 || a.length === 0 ? t : d?.flatMap((t) => t.pointCloudDMVolumeWithAsset.filter((e) => a.some((t) => e.dmAsset !== void 0 && t.externalId === e.dmAsset.externalId && t.space === e.dmAsset.space)).map((e) => {
+		if (e.dmAsset !== void 0) return {
+			volumeInstanceRef: {
+				externalId: e.externalId,
+				space: e.space
+			},
+			asset: e.dmAsset
+		};
+	}).filter(e)) ?? t, [
+		u.length,
+		a,
+		d
+	]);
+};
+//#endregion
+export { a as usePointCloudDMVolumeMappingForAssetInstances };