@cognite/reveal-components 1.0.0

package/dist/data-providers/FdmSDK.js

@@ -0,0 +1,167 @@
+import { mergeQueryResults as e } from "./utils/mergeQueryResult.js";
+import { queryNodesAndEdges as t } from "./utils/queryNodesAndEdges.js";
+//#region libs/shared/reveal-components/src/data-providers/FdmSDK.ts
+var n = class {
+	_sdk;
+	_featureDataLoadPerformanceMetrics;
+	_byIdsEndpoint;
+	_listEndpoint;
+	_inspectEndpoint;
+	_searchEndpoint;
+	_listViewsEndpoint;
+	_viewsByIdEndpoint;
+	_listDataModelsEndpoint;
+	_createUpdateInstancesEndpoint;
+	_deleteInstancesEndpoint;
+	constructor(e, t) {
+		let n = e.getBaseUrl(), r = e.project, i = `${n}/api/v1/projects/${r}/models/instances`, a = `${n}/api/v1/projects/${r}/models/views`;
+		this._listEndpoint = `${i}/list`, this._byIdsEndpoint = `${i}/byids`, this._inspectEndpoint = `${i}/inspect`, this._searchEndpoint = `${i}/search`, this._listDataModelsEndpoint = `${n}/api/v1/projects/${r}/models/datamodels`, this._viewsByIdEndpoint = `${a}/byids`, this._listViewsEndpoint = a, this._createUpdateInstancesEndpoint = i, this._deleteInstancesEndpoint = `${i}/delete`, this._sdk = e, this._featureDataLoadPerformanceMetrics = t?.featureDataLoadPerformanceMetrics;
+	}
+	async listViews(e, t = !0) {
+		let n = await this._sdk.get(this._listViewsEndpoint, { params: {
+			includeInheritedProperties: t,
+			space: e
+		} });
+		if (n.status === 200) return { views: n.data.items };
+		throw Error(`Failed to list views. Status: ${n.status}`);
+	}
+	async searchInstances(e, t, n) {
+		let i = a(n.filter), o = {
+			view: e,
+			query: n.query ?? "",
+			instanceType: t,
+			...n.filter === void 0 ? {} : { filter: i },
+			...n.operator === void 0 ? {} : { operator: n.operator },
+			limit: n.limit ?? 1e3
+		}, s = await this._sdk.post(this._searchEndpoint, { data: o });
+		if (s.status === 200) return r(e, s.data.items), { instances: s.data.items };
+		throw Error(`Failed to search for instances. Status: ${s.status}`);
+	}
+	async filterInstances(e, t, n, i) {
+		let a = {
+			filter: e,
+			instanceType: t
+		};
+		n !== null && (a.sources = [{ source: n }]), i !== void 0 && (a.cursor = i);
+		let o = await this._sdk.post(this._listEndpoint, { data: a });
+		if (o.status !== 200) throw Error(`Failed to fetch instances. Status: ${o.status}`);
+		let s = o.data.items;
+		return r(n, s), {
+			instances: o.data.items,
+			nextCursor: o.data.nextCursor
+		};
+	}
+	async filterAllInstances(e, t, n) {
+		e = a(e);
+		let r = await this.filterInstances(e, t, n);
+		for (; r.nextCursor !== void 0;) {
+			let i = await this.filterInstances(e, t, n, r.nextCursor);
+			r = {
+				instances: [...r.instances, ...i.instances],
+				nextCursor: i.nextCursor
+			};
+		}
+		return { instances: r.instances };
+	}
+	async getByExternalIds(e, t) {
+		if (e.length === 0) return { items: [] };
+		let n = {
+			items: e,
+			includeTyping: !0
+		};
+		t !== void 0 && (n.sources = t.map((e) => ({ source: e })));
+		let r = await this._sdk.post(this._byIdsEndpoint, { data: n });
+		if (r.status === 200) return r.data;
+		throw Error(`Failed to fetch instances. Status: ${r.status}`);
+	}
+	async createInstance(e) {
+		let t = {
+			items: e,
+			autoCreateStartNodes: !1,
+			autoCreateEndNodes: !1,
+			skipOnVersionConflict: !1,
+			replace: !1
+		}, n = await this._sdk.post(this._createUpdateInstancesEndpoint, { data: t });
+		if (n.status === 200) return n.data;
+		throw Error(`Failed to create instances. Status: ${n.status}`);
+	}
+	async editInstance(e) {
+		let t = {
+			items: e,
+			autoCreateStartNodes: !1,
+			autoCreateEndNodes: !1,
+			skipOnVersionConflict: !1,
+			replace: !1
+		}, n = await this._sdk.post(this._createUpdateInstancesEndpoint, { data: t });
+		if (n.status === 200) return n.data;
+		throw Error(`Failed to edit instances. Status: ${n.status}`);
+	}
+	async deleteInstances(e) {
+		if (e.length === 0) return { items: [] };
+		let t = { items: e }, n = await this._sdk.post(this._deleteInstancesEndpoint, { data: t });
+		if (n.status === 200) return n.data;
+		throw Error(`Failed to delete instances. Status: ${n.status}`);
+	}
+	async inspectInstances(e) {
+		let t = await this._sdk.post(this._inspectEndpoint, { data: e });
+		if (t.status === 200) return t.data;
+		throw Error("Failed to fetch instances");
+	}
+	async getViewsByIds(e) {
+		let t = await this._sdk.post(this._viewsByIdEndpoint, { data: { items: e.map((e) => ({
+			externalId: e.externalId,
+			space: e.space,
+			version: e.version
+		})) } });
+		if (t.status === 200) return t.data;
+		throw Error(`Failed to fetch instances. Status: ${t.status}`);
+	}
+	async queryAllNodesAndEdges(n, r) {
+		let i = await t(n, this._sdk), a = i.items;
+		for (; i.nextCursor !== void 0 && Object.keys(i.nextCursor).length !== 0;) {
+			let o = i.nextCursor === void 0 ? [] : Object.keys(i.nextCursor), s = {}, c = i.nextCursor;
+			o.forEach((e) => {
+				r !== void 0 && r.includes(e) && i.nextCursor?.[e] !== void 0 && (s = {
+					...s,
+					[e]: i.nextCursor?.[e]
+				});
+			});
+			let l = Object.keys(s).length === 0 ? c : s, u = {
+				...n,
+				cursors: l
+			};
+			i = await t(u, this._sdk), a = e(a, i.items);
+		}
+		return { items: a };
+	}
+	async queryNodesAndEdges(e, n) {
+		return await t(e, this._sdk, i(this._featureDataLoadPerformanceMetrics, n?.metricsFeatureName));
+	}
+	async listDataModels() {
+		let e = await this._sdk.get(this._listDataModelsEndpoint, { params: {
+			limit: 1e3,
+			includeGlobal: !0
+		} });
+		if (e.status === 200) return e.data;
+		throw Error(`Failed to fetch data models. Status: ${e.status}`);
+	}
+};
+function r(e, t) {
+	if (e === void 0) return;
+	let n = `${e.externalId}/${e.version}`;
+	t.forEach((t) => {
+		let r = t.properties?.[e.space]?.[n];
+		r !== void 0 && Object.entries(r).reduce((e, [t, n]) => (e[t] = n, e), t.properties);
+	});
+}
+function i(e, t) {
+	if (e !== void 0 && t !== void 0) return { metrics: {
+		tracker: e,
+		featureName: t
+	} };
+}
+function a(e) {
+	return e !== void 0 && Object.keys(e).length === 0 ? void 0 : e;
+}
+//#endregion
+export { n as FdmSDK, a as makeSureNonEmptyFilterForRequest };

package/dist/data-providers/cache/CacheProvider.d.ts

@@ -0,0 +1,12 @@
+import { Fdm3dDataProvider } from '../Fdm3dDataProvider';
+import { CadInstanceMappingsCache } from './cad/CadInstanceMappingsCache';
+import { ClassicCadAssetMappingCache } from './cad/ClassicCadAssetMappingCache';
+import { FdmCadNodeCache } from './cad/FdmCadNodeCache';
+import { Image360AnnotationCache } from './Image360AnnotationCache';
+import { PointCloudAnnotationCache } from './PointCloudAnnotationCache';
+export declare const useCadMappingsCache: () => CadInstanceMappingsCache;
+export declare const useFdmCadNodeCache: () => FdmCadNodeCache | undefined;
+export declare const useClassicCadAssetMappingCache: () => ClassicCadAssetMappingCache;
+export declare const usePointCloudAnnotationCache: () => PointCloudAnnotationCache;
+export declare const useImage360AnnotationCache: () => Image360AnnotationCache;
+export declare const useFdm3dDataProvider: () => Fdm3dDataProvider | undefined;

package/dist/data-providers/cache/CacheProvider.js

@@ -0,0 +1,6 @@
+import { useRenderTarget as e } from "../../ui/components/RevealCanvas/ViewerContext.js";
+import "../../ui/components/RevealCanvas/index.js";
+//#region libs/shared/reveal-components/src/data-providers/cache/CacheProvider.ts
+var t = () => e().cdfCaches, n = () => t().cadMappingsCache, r = () => t().fdmCadNodeCache, i = () => t().classicCadAssetMappingCache, a = () => t().pointCloudAnnotationCache, o = () => t().image360Cache, s = () => t().fdm3dDataProvider;
+//#endregion
+export { n as useCadMappingsCache, i as useClassicCadAssetMappingCache, s as useFdm3dDataProvider, r as useFdmCadNodeCache, o as useImage360AnnotationCache, a as usePointCloudAnnotationCache };

package/dist/data-providers/cache/Image360AnnotationCache.d.ts

@@ -0,0 +1,14 @@
+import { DataSourceType, Cognite3DViewer } from '@cognite/reveal';
+import { CogniteClient } from '@cognite/sdk';
+import { InstanceReference } from '../../utilities/instanceIds';
+import { Image360AnnotationAssetInfo } from './types';
+export declare class Image360AnnotationCache {
+    private readonly _sdk;
+    private readonly _viewer;
+    private readonly _annotationToAssetMappingsWithAssetInstance;
+    constructor(sdk: CogniteClient, viewer: Cognite3DViewer<DataSourceType> | undefined);
+    clearCache(): void;
+    getReveal360AnnotationsForAssets(image360CollectionKeys: string[], assetInstances: InstanceReference[]): Promise<Image360AnnotationAssetInfo[]>;
+    private getReveal360AnnotationInfoForAssets;
+    private getAssetWithAnnotationsMapped;
+}

package/dist/data-providers/cache/Image360AnnotationCache.js

@@ -0,0 +1,69 @@
+import { isDmsInstance as e, isExternalId as t, isInternalId as n } from "../../utilities/instanceIds/typeGuards.js";
+import { createInstanceReferenceKey as r } from "../../utilities/instanceIds/toKey.js";
+import "../../utilities/instanceIds/index.js";
+import { getImage360AnnotationAssetRef as i } from "../../utilities/image360Annotations/getImage360AnnotationAssetRef.js";
+import "../../utilities/image360Annotations/index.js";
+import { isDefined as a } from "../../utilities/isDefined.js";
+import { getAssetIdKeyForImage360Annotation as o } from "./utils.js";
+import { fetchAssetsForAssetReferences as s } from "./annotationModelUtils.js";
+import { chunk as c, uniqBy as l } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/cache/Image360AnnotationCache.ts
+var u = 20, d = class {
+	_sdk;
+	_viewer;
+	_annotationToAssetMappingsWithAssetInstance = /* @__PURE__ */ new Map();
+	constructor(e, t) {
+		this._sdk = e, this._viewer = t;
+	}
+	clearCache() {
+		this._annotationToAssetMappingsWithAssetInstance.clear();
+	}
+	async getReveal360AnnotationsForAssets(e, t) {
+		if (this._viewer === void 0 || e.length === 0 || t.length === 0) return [];
+		let n = this._viewer.get360ImageCollections().filter((t) => e.includes(t.id)), i = t.map((e) => String(r(e))).sort().join().concat(n.map((e) => e.id).join()), a = this._annotationToAssetMappingsWithAssetInstance.get(i);
+		if (a !== void 0) return a;
+		let o = this.getReveal360AnnotationInfoForAssets(t, n);
+		return this._annotationToAssetMappingsWithAssetInstance.set(i, o), o;
+	}
+	async getReveal360AnnotationInfoForAssets(e, t) {
+		let n = c(e, u), a = c(t, 5), o = [];
+		for (let e of n) for (let t of a) {
+			let n = await Promise.all(e.map(async (e) => (await Promise.all(t.map(async (t) => {
+				let n = f(e);
+				return n === void 0 ? [] : await t.findImageAnnotations({ assetRef: n });
+			}))).flat()));
+			o.push(...n.flat());
+		}
+		let d = o.reduce((e, t) => {
+			let n = i(t.annotation.annotation);
+			return n !== void 0 && e.push(n), e;
+		}, []), p = l(d, r), m = await s(p, this._sdk), h = new Map(m.map((e) => [r(e), e]));
+		return this.getAssetWithAnnotationsMapped(o, h);
+	}
+	getAssetWithAnnotationsMapped(e, t) {
+		return e.filter((e) => {
+			let n = o(e.annotation.annotation);
+			return n !== void 0 && t.has(n);
+		}).map((e) => p(e, t)).filter(a);
+	}
+};
+function f(r) {
+	if (n(r)) return { id: r.id };
+	if (e(r)) return {
+		externalId: r.externalId,
+		space: r.space
+	};
+	if (t(r)) return { externalId: r.externalId };
+}
+function p(e, t) {
+	let n = o(e.annotation.annotation);
+	if (n === void 0) return;
+	let r = t.get(n);
+	if (r !== void 0) return {
+		asset: r,
+		assetAnnotationImage360Info: e,
+		position: e.annotation.getCenter().applyMatrix4(e.image.transform)
+	};
+}
+//#endregion
+export { d as Image360AnnotationCache };

package/dist/data-providers/cache/PointCloudAnnotationCache.d.ts

@@ -0,0 +1,24 @@
+import { CogniteClient } from '@cognite/sdk';
+import { InstanceReference, InstanceReferenceKey } from '../../utilities/instanceIds';
+import { AssetInstance } from '../../utilities/instances';
+import { fetchPointCloudAnnotationAssets } from './annotationModelUtils';
+import { ModelId, RevisionId, PointCloudAnnotationModel, AnnotationId } from './types';
+type PointCloudAnnotationCacheDependencies = {
+    fetchAnnotationAssets: typeof fetchPointCloudAnnotationAssets;
+};
+export declare class PointCloudAnnotationCache {
+    private readonly _sdk;
+    private readonly _modelToAnnotationAssetMappings;
+    private readonly _modelToAnnotationMappings;
+    private readonly _assetKeyToAnnotationIdsCache;
+    private readonly fetchAnnotationAssets;
+    constructor(sdk: CogniteClient, dependencies?: PointCloudAnnotationCacheDependencies);
+    private getPointCloudAnnotationAssetsForModel;
+    private fetchAndCacheAssetMappingsForModel;
+    private fetchAnnotationForModel;
+    private getOrBuildAssetKeyToAnnotationIdsCache;
+    getPointCloudAnnotationsForModel(modelId: ModelId, revisionId: RevisionId): Promise<PointCloudAnnotationModel[]>;
+    matchPointCloudAnnotationsForModel(modelId: ModelId, revisionId: RevisionId, assetId: InstanceReference): Promise<Map<AnnotationId, AssetInstance[]> | undefined>;
+    getPointCloudAnnotationsForInstanceIds(modelId: ModelId, revisionId: RevisionId, instanceIds: InstanceReference[]): Promise<Map<InstanceReferenceKey, AnnotationId[]>>;
+}
+export {};

package/dist/data-providers/cache/PointCloudAnnotationCache.js

@@ -0,0 +1,81 @@
+import { isSameAssetReference as e } from "../../utilities/instanceIds/equality.js";
+import { createModelRevisionKey as t } from "./idAndKeyTranslation.js";
+import { createInstanceReferenceKey as n } from "../../utilities/instanceIds/toKey.js";
+import "../../utilities/instanceIds/index.js";
+import { getInstanceReferencesFromPointCloudAnnotation as r } from "./utils.js";
+import { fetchPointCloudAnnotationAssets as i } from "./annotationModelUtils.js";
+import { isClassicAsset as a } from "../../utilities/instances/typeGuards.js";
+import "../../utilities/instances/index.js";
+import { assert as o } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/data-providers/cache/PointCloudAnnotationCache.ts
+var s = class {
+	_sdk;
+	_modelToAnnotationAssetMappings = /* @__PURE__ */ new Map();
+	_modelToAnnotationMappings = /* @__PURE__ */ new Map();
+	_assetKeyToAnnotationIdsCache = /* @__PURE__ */ new Map();
+	fetchAnnotationAssets;
+	constructor(e, t) {
+		this._sdk = e;
+		let { fetchAnnotationAssets: n } = t ?? { fetchAnnotationAssets: i };
+		this.fetchAnnotationAssets = n;
+	}
+	async getPointCloudAnnotationAssetsForModel(e, n) {
+		let r = t(e, n), i = this._modelToAnnotationAssetMappings.get(r);
+		if (i !== void 0) return await i;
+		let a = this.fetchAndCacheAssetMappingsForModel(e);
+		return this._modelToAnnotationAssetMappings.set(r, a), await a;
+	}
+	async fetchAndCacheAssetMappingsForModel(e) {
+		let t = await this.fetchAnnotationForModel(e);
+		return await this.fetchAnnotationAssets(t, this._sdk);
+	}
+	async fetchAnnotationForModel(e) {
+		let t = {
+			annotatedResourceIds: [{ id: e }],
+			annotatedResourceType: "threedmodel",
+			annotationType: "pointcloud.BoundingVolume"
+		}, n = await this._sdk.annotations.list({
+			filter: t,
+			limit: 1e3
+		}).autoPagingToArray({ limit: Infinity });
+		return o(n.every((e) => e.annotationType === "pointcloud.BoundingVolume")), n.filter((e) => r(e).length !== 0);
+	}
+	async getOrBuildAssetKeyToAnnotationIdsCache(e, n) {
+		let r = t(e, n), i = this._assetKeyToAnnotationIdsCache.get(r);
+		if (i !== void 0) return i;
+		let a = c(await this.getPointCloudAnnotationAssetsForModel(e, n));
+		return this._assetKeyToAnnotationIdsCache.set(r, a), a;
+	}
+	async getPointCloudAnnotationsForModel(e, n) {
+		let r = t(e, n), i = this._modelToAnnotationMappings.get(r);
+		if (i !== void 0) return i;
+		let a = await this.fetchAnnotationForModel(e);
+		return this._modelToAnnotationMappings.set(r, a), a;
+	}
+	async matchPointCloudAnnotationsForModel(t, n, r) {
+		let i = await this.getPointCloudAnnotationAssetsForModel(t, n), a = Array.from(i.entries()).filter(([, t]) => t.some((t) => e(t, r)));
+		return a.length > 0 ? new Map(a) : void 0;
+	}
+	async getPointCloudAnnotationsForInstanceIds(e, t, r) {
+		let i = await this.getOrBuildAssetKeyToAnnotationIdsCache(e, t), a = /* @__PURE__ */ new Map();
+		for (let e of r) {
+			let t = n(e), r = i.get(t);
+			r !== void 0 && a.set(t, Array.from(r));
+		}
+		return a;
+	}
+};
+function c(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let [r, i] of e.entries()) for (let e of i) {
+		let i = [];
+		a(e) ? (i.push(n({ id: e.id })), e.externalId !== void 0 && i.push(n({ externalId: e.externalId }))) : i.push(n(e));
+		for (let e of i) {
+			let n = t.get(e);
+			n === void 0 && (n = /* @__PURE__ */ new Set(), t.set(e, n)), n.add(r);
+		}
+	}
+	return t;
+}
+//#endregion
+export { s as PointCloudAnnotationCache };

package/dist/data-providers/cache/RevisionFdmNodeCache.d.ts

@@ -0,0 +1,28 @@
+import { CogniteClient } from '@cognite/sdk';
+import { Fdm3dDataProvider } from '../Fdm3dDataProvider';
+import { FdmSDK } from '../FdmSDK';
+import { TreeIndex, FdmConnectionWithNode, FdmNodeDataPromises } from './types';
+export declare class RevisionFdmNodeCache {
+    private readonly _cogniteClient;
+    private readonly _fdmClient;
+    private readonly _fdm3dDataProvider;
+    private readonly _modelId;
+    private readonly _revisionId;
+    private readonly _treeIndexToFdmConnections;
+    private readonly _modelInstances;
+    constructor(cogniteClient: CogniteClient, fdmClient: FdmSDK, fdmDataProvider: Fdm3dDataProvider, modelId: number, revisionId: number);
+    getClosestParentFdmData(searchTreeIndex: number): FdmNodeDataPromises;
+    private assertOrFetchViewsForNodeData;
+    private findAndCacheNodeDataFromAncestors;
+    private getViewsPromiseFromDataPromises;
+    private getCadAndConnectionsPromiseForAncestorData;
+    private setCacheDataForTreeIndices;
+    private getAndCacheViewsPromiseForNodeData;
+    private getClosestParentMapping;
+    private combineConnectionsWithTreeIndex;
+    private getMappingConnectionsForAncestors;
+    fetchViewsForAllConnections(): Promise<void>;
+    insertTreeIndexMappings(treeIndex: TreeIndex, connection: FdmConnectionWithNode): void;
+    getAllConnections(): FdmConnectionWithNode[];
+}
+export declare function checkDefinedViews(connections?: FdmConnectionWithNode[]): connections is Array<Required<FdmConnectionWithNode>>;

package/dist/data-providers/cache/RevisionFdmNodeCache.js

@@ -0,0 +1,151 @@
+import { fetchAncestorNodesForTreeIndex as e, inspectNodes as t } from "./requests.js";
+import { max as n } from "lodash-es";
+import { assert as r } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/data-providers/cache/RevisionFdmNodeCache.ts
+var i = {
+	connections: [],
+	ancestorsWithSameMapping: [],
+	firstMappedAncestorTreeIndex: -1
+}, a = class {
+	_cogniteClient;
+	_fdmClient;
+	_fdm3dDataProvider;
+	_modelId;
+	_revisionId;
+	_treeIndexToFdmConnections = /* @__PURE__ */ new Map();
+	_modelInstances;
+	constructor(e, t, n, r, i) {
+		this._cogniteClient = e, this._fdmClient = t, this._fdm3dDataProvider = n, this._modelId = r, this._revisionId = i, this._modelInstances = n.getDMSModels(this._modelId).catch(() => void 0);
+	}
+	getClosestParentFdmData(e) {
+		let t = this._treeIndexToFdmConnections.get(e);
+		return t === void 0 ? this.findAndCacheNodeDataFromAncestors(e) : t.length === 0 ? {
+			cadAndFdmNodesPromise: Promise.resolve(void 0),
+			viewsPromise: Promise.resolve(void 0)
+		} : {
+			cadAndFdmNodesPromise: Promise.resolve({
+				cadNode: t[0].cadNode,
+				fdmIds: t.map((e) => e.connection.instance)
+			}),
+			viewsPromise: this.assertOrFetchViewsForNodeData(e, t)
+		};
+	}
+	async assertOrFetchViewsForNodeData(e, t) {
+		if (c(t)) return t.map((e) => e.views);
+		let n = t[0].cadNode, r = {
+			cadNode: n,
+			connections: t.map((e) => e.connection)
+		};
+		return await this.getAndCacheViewsPromiseForNodeData(r, [n.treeIndex, e]);
+	}
+	findAndCacheNodeDataFromAncestors(e) {
+		let t = this.getClosestParentMapping(e), n = this.getCadAndConnectionsPromiseForAncestorData(t);
+		return {
+			cadAndFdmNodesPromise: n.then((e) => e === void 0 ? void 0 : {
+				cadNode: e.cadNode,
+				fdmIds: e.connections.map((e) => e.instance)
+			}),
+			viewsPromise: this.getViewsPromiseFromDataPromises(n, t)
+		};
+	}
+	async getViewsPromiseFromDataPromises(e, t) {
+		let n = await e, { ancestorsWithSameMapping: r } = await t, i = r.map((e) => e.treeIndex), a = i.filter((e) => this._treeIndexToFdmConnections.has(e)).sort((e, t) => t - e), o = a.length === 0 ? void 0 : this._treeIndexToFdmConnections.get(a[0]);
+		return c(o) ? (this.setCacheDataForTreeIndices(i, o), o.map((e) => e.views)) : await this.getAndCacheViewsPromiseForNodeData(n, i);
+	}
+	async getCadAndConnectionsPromiseForAncestorData(e) {
+		let { connections: t, ancestorsWithSameMapping: n, firstMappedAncestorTreeIndex: i } = await e;
+		if (t.length === 0) {
+			this.setCacheDataForTreeIndices(n.map((e) => e.treeIndex), []);
+			return;
+		}
+		let a = n.find((e) => e.treeIndex === i);
+		return r(a !== void 0), {
+			cadNode: a,
+			connections: t
+		};
+	}
+	setCacheDataForTreeIndices(e, t) {
+		e.forEach((e) => {
+			this._treeIndexToFdmConnections.set(e, t);
+		});
+	}
+	async getAndCacheViewsPromiseForNodeData(e, n) {
+		if (e === void 0) {
+			this.setCacheDataForTreeIndices(n, []);
+			return;
+		}
+		let r = (await t(this._fdmClient, e.connections.map((e) => e.instance))).items.map((e) => e.inspectionResults.involvedViews), i = e.connections.map((t, n) => ({
+			connection: t,
+			cadNode: e.cadNode,
+			view: r[n]
+		}));
+		return this.setCacheDataForTreeIndices(n, i), r;
+	}
+	async getClosestParentMapping(t) {
+		let n = await e(this._modelId, this._revisionId, t, this._cogniteClient), r = await this.getMappingConnectionsForAncestors(n);
+		if (r.length === 0) return i;
+		let a = this.combineConnectionsWithTreeIndex(r, n), c = o(a);
+		return c === void 0 ? i : s(c, a, n);
+	}
+	combineConnectionsWithTreeIndex(e, t) {
+		return e.reduce((e, n) => {
+			let r = t.find((e) => e.treeIndex === n.treeIndex);
+			return r !== void 0 && e.push({
+				connection: n,
+				treeIndex: r.treeIndex
+			}), e;
+		}, []);
+	}
+	async getMappingConnectionsForAncestors(e) {
+		let t = e.filter((e) => this._treeIndexToFdmConnections.has(e.treeIndex)).sort((e, t) => t.treeIndex - e.treeIndex)[0];
+		if (t !== void 0) {
+			let e = this._treeIndexToFdmConnections.get(t.treeIndex);
+			return r(e !== void 0), e.map((e) => e.connection);
+		}
+		let n = await this._modelInstances;
+		return n === void 0 || n.length === 0 ? [] : await this._fdm3dDataProvider.getFdmConnectionsForNodes(n, this._revisionId, e);
+	}
+	async fetchViewsForAllConnections() {
+		let e = this.getAllConnections().filter((e) => e.views === void 0 || e.views.length === 0);
+		if (e.length === 0) return;
+		let n = await t(this._fdmClient, e.map((e) => e.connection.instance));
+		e.forEach((e, t) => {
+			let r = {
+				...e,
+				views: [n.items[t].inspectionResults.involvedViews[0]]
+			};
+			this.insertTreeIndexMappings(r.cadNode.treeIndex, r);
+		});
+	}
+	insertTreeIndexMappings(e, t) {
+		let n = this._treeIndexToFdmConnections.get(e);
+		if (n === void 0) this._treeIndexToFdmConnections.set(e, [t]);
+		else {
+			let e = n?.find((e) => e.cadNode.id === t.cadNode.id);
+			if (e !== void 0) {
+				e.views = t.views;
+				return;
+			}
+			n.push(t);
+		}
+	}
+	getAllConnections() {
+		return [...this._treeIndexToFdmConnections.values()].flat();
+	}
+};
+function o(e) {
+	return n(e.map((e) => e.treeIndex));
+}
+function s(e, t, n) {
+	let r = t.filter((t) => t.treeIndex === e), i = n.filter((t) => t.treeIndex >= e);
+	return {
+		connections: r.map((e) => e.connection),
+		ancestorsWithSameMapping: i,
+		firstMappedAncestorTreeIndex: e
+	};
+}
+function c(e) {
+	return e !== void 0 && e?.every((e) => e.views !== void 0 && e.views.length > 0);
+}
+//#endregion
+export { a as RevisionFdmNodeCache, c as checkDefinedViews };

package/dist/data-providers/cache/annotationModelUtils.d.ts

@@ -0,0 +1,7 @@
+import { CogniteClient, Asset, IdEither } from '@cognite/sdk';
+import { InstanceReference } from '../../utilities/instanceIds';
+import { AssetInstance } from '../../utilities/instances';
+import { AnnotationId, PointCloudAnnotationModel } from './types';
+export declare function fetchPointCloudAnnotationAssets(annotations: PointCloudAnnotationModel[], sdk: CogniteClient): Promise<Map<AnnotationId, AssetInstance[]>>;
+export declare function fetchAssetsForAssetReferences(assetIds: InstanceReference[], sdk: CogniteClient): Promise<AssetInstance[]>;
+export declare function fetchAssetsForAssetIds(assetIds: IdEither[], sdk: CogniteClient): Promise<Asset[]>;

package/dist/data-providers/cache/annotationModelUtils.js

@@ -0,0 +1,40 @@
+import { isDmsInstance as e, isIdEither as t } from "../../utilities/instanceIds/typeGuards.js";
+import { isSameIdEither as n } from "../../utilities/instanceIds/equality.js";
+import { createInstanceReferenceKey as r } from "../../utilities/instanceIds/toKey.js";
+import "../../utilities/instanceIds/index.js";
+import { FdmSDK as i } from "../FdmSDK.js";
+import { isDefined as a } from "../../utilities/isDefined.js";
+import { concatenateMapValues as o } from "../../utilities/map/concatenateMapValues.js";
+import { COGNITE_ASSET_SOURCE as s, COGNITE_ASSET_VIEW_VERSION_KEY as c, CORE_DM_SPACE as l } from "../core-dm-provider/dataModels.js";
+import { getInstanceReferencesFromPointCloudAnnotation as u } from "./utils.js";
+import { chunk as d, uniqBy as f, uniqWith as p } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/cache/annotationModelUtils.ts
+async function m(e, t) {
+	let n = e.flatMap((e) => u(e).map((t) => ({
+		annotationId: e.id,
+		assetId: t
+	}))).filter(a), i = await h(f(n.map((e) => e.assetId), r), t), s = new Map(i.map((e) => [r(e), e]));
+	return o(n.map((e) => {
+		let t = r(e.assetId), n = s.get(t);
+		if (n !== void 0) return [e.annotationId, n];
+	}).filter(a));
+}
+async function h(n, r) {
+	let i = n.filter(t), a = n.filter(e);
+	return [].concat(await _(i, r), await g(a, r));
+}
+async function g(e, t) {
+	return e.length === 0 ? [] : (await new i(t).getByExternalIds(e.map((e) => ({
+		...e,
+		instanceType: "node"
+	})), [s])).items.map((e) => ({
+		...e,
+		properties: e.properties[l][c]
+	}));
+}
+async function _(e, t) {
+	let r = p(e, n);
+	return (await Promise.all(d(r, 1e3).map(async (e) => await t.assets.retrieve(e, { ignoreUnknownIds: !0 })))).flat();
+}
+//#endregion
+export { _ as fetchAssetsForAssetIds, h as fetchAssetsForAssetReferences, m as fetchPointCloudAnnotationAssets };

package/dist/data-providers/cache/cad/CadInstanceMappingsCache.d.ts

@@ -0,0 +1,20 @@
+import { InstanceId, InstanceKey } from '../../../utilities/instanceIds';
+import { DmsUniqueIdentifier } from '../../FdmSDK';
+import { SlimCadNodeWithBounds } from '../../utils/cadNodeConnectionFields';
+import { ModelRevisionKey, ModelRevisionId, CadNodeIdData } from '../types';
+export type CadModelMappingsWithNodes = Map<ModelRevisionKey, Map<InstanceKey, SlimCadNodeWithBounds[]>>;
+export type CadModelMappings = Map<ModelRevisionKey, Map<InstanceKey, CadNodeIdData[]>>;
+export type CadNodeMapping = {
+    sourceType: 'cdm';
+    node: CadNodeIdData;
+    instance: DmsUniqueIdentifier;
+} | {
+    sourceType: 'assetMapping';
+    node: CadNodeIdData;
+    instance: InstanceId;
+};
+export type CadInstanceMappingsCache = {
+    getMappingsForModelsAndInstances: (instances: InstanceId[], models: ModelRevisionId[], signal?: AbortSignal) => Promise<CadModelMappingsWithNodes>;
+    getAllModelMappings: (models: ModelRevisionId[], signal?: AbortSignal) => Promise<CadModelMappings>;
+    getAllModelMappingsWithViews: (models: ModelRevisionId[], signal?: AbortSignal) => Promise<CadModelMappings>;
+};

package/dist/data-providers/cache/cad/CadInstanceMappingsCacheImpl.d.ts

@@ -0,0 +1,4 @@
+import { CadInstanceMappingsCache } from './CadInstanceMappingsCache';
+import { ClassicCadAssetMappingCache } from './ClassicCadAssetMappingCache';
+import { FdmCadNodeCache } from './FdmCadNodeCache';
+export declare function createCadInstanceMappingsCache(classicCache: ClassicCadAssetMappingCache | undefined, dmCache: FdmCadNodeCache | undefined): CadInstanceMappingsCache;