@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,42 @@
+import { InstanceId } from '../../../utilities/instanceIds';
+import { DmsUniqueIdentifier } from '../../FdmSDK';
+import { AssetId, CadNodeIdData, CadNodeTreeData } from '../types';
+/**
+ * Raw CAD instance mapping instance identifier constituents
+ */
+export type ClassicCadAssetMappingInstance = {
+    assetId: AssetId;
+};
+export type DmCadAssetMappingInstance = {
+    instanceId: DmsUniqueIdentifier;
+};
+export type HybridCadAssetMappingInstance = ClassicCadAssetMappingInstance | DmCadAssetMappingInstance;
+/**
+ * These are reusable type guards that operate on any type that has an instance reference akin
+ * to the ones in the asset mappings (assetId or instanceId). Ideally, we could have used
+ * only these in place of the more specific ones defined further down in this file (e.g.
+ * `isClassicCadAssetMapping`), but the type checker was e.g. not able to infer the result type to be
+ * `ClassicCadAssetMapping[]` when using this inside a `.filter` on an array of `HybridCadAssetMapping`
+ */
+export declare function isClassicCadAssetMappingInstance(mapping: HybridCadAssetMappingInstance): mapping is ClassicCadAssetMappingInstance;
+export declare function isDmCadAssetMappingInstance(mapping: HybridCadAssetMappingInstance): mapping is DmCadAssetMappingInstance;
+/**
+ * asset mapping with treeIndex, subtreeSize and nodeId
+ */
+export type ClassicCadAssetMapping = CadNodeIdData & ClassicCadAssetMappingInstance;
+export type DmCadAssetMapping = CadNodeIdData & DmCadAssetMappingInstance;
+export type HybridCadAssetMapping = ClassicCadAssetMapping | DmCadAssetMapping;
+export declare function isClassicCadAssetMapping(mapping: HybridCadAssetMapping): mapping is ClassicCadAssetMapping;
+export declare function isDmCadAssetMapping(mapping: HybridCadAssetMapping): mapping is DmCadAssetMapping;
+/**
+ * asset mapping with treeIndex and subtreeSize only
+ */
+export type ClassicCadAssetTreeIndexMapping = CadNodeTreeData & ClassicCadAssetMappingInstance;
+export type DmCadAssetTreeIndexMapping = CadNodeTreeData & DmCadAssetMappingInstance;
+export type HybridCadAssetTreeIndexMapping = ClassicCadAssetTreeIndexMapping | DmCadAssetTreeIndexMapping;
+export declare function isClassicCadAssetTreeIndexMapping(mapping: HybridCadAssetTreeIndexMapping): mapping is ClassicCadAssetTreeIndexMapping;
+export declare function isDmCadAssetTreeIndexMapping(mapping: HybridCadAssetTreeIndexMapping): mapping is DmCadAssetTreeIndexMapping;
+/**
+ * asset instance key from mapping
+ */
+export declare function getMappingInstanceId(mappingInstance: ClassicCadAssetMappingInstance | DmCadAssetMappingInstance): InstanceId;

package/dist/data-providers/cache/cad/assetMappingTypes.js

@@ -0,0 +1,24 @@
+import { assertNever as e } from "../../../utilities/assertNever.js";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/assetMappingTypes.ts
+function t(e) {
+	return "assetId" in e && e.assetId !== void 0 && !("instanceId" in e);
+}
+function n(e) {
+	return "instanceId" in e && e.instanceId !== void 0 && !("assetId" in e);
+}
+function r(e) {
+	return t(e);
+}
+function i(e) {
+	return n(e);
+}
+function a(e) {
+	return t(e);
+}
+function o(r) {
+	if (t(r)) return r.assetId;
+	if (n(r)) return r.instanceId;
+	e(r);
+}
+//#endregion
+export { o as getMappingInstanceId, r as isClassicCadAssetMapping, t as isClassicCadAssetMappingInstance, a as isClassicCadAssetTreeIndexMapping, i as isDmCadAssetMapping, n as isDmCadAssetMappingInstance };

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

@@ -0,0 +1,3 @@
+import { CogniteClient } from '@cognite/sdk';
+import { ThreeDModelFdmMappings } from './types';
+export declare function enrichCadNodeMappingsWithBoundingBoxes(modelMappings: ThreeDModelFdmMappings[], cdfClient: CogniteClient): Promise<ThreeDModelFdmMappings[]>;

package/dist/data-providers/cache/cad/enrichCadNodeMappingsWithBoundingBoxes.js

@@ -0,0 +1,30 @@
+import { fetchNodesForNodeIds as e } from "../requests.js";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/enrichCadNodeMappingsWithBoundingBoxes.ts
+async function t(e, t) {
+	return Promise.all(e.map((e) => n(e, t)));
+}
+async function n(t, n) {
+	let a = r(t);
+	if (a.length === 0) return t;
+	let o = await e(t.modelId, t.revisionId, a, n), s = new Map(o.flatMap((e) => e.boundingBox === void 0 ? [] : [[e.id, e.boundingBox]])), c = /* @__PURE__ */ new Map();
+	for (let [e, n] of t.mappings) c.set(e, n.map((e) => i(e, s)));
+	return {
+		...t,
+		mappings: c
+	};
+}
+function r(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e.mappings.values()) for (let e of n) e.boundingBox === void 0 && t.add(e.id);
+	return [...t];
+}
+function i(e, t) {
+	if (e.boundingBox !== void 0) return e;
+	let n = t.get(e.id);
+	return n === void 0 ? e : {
+		...e,
+		boundingBox: n
+	};
+}
+//#endregion
+export { t as enrichCadNodeMappingsWithBoundingBoxes };

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

@@ -0,0 +1,4 @@
+import { FdmCadConnection, FdmConnectionWithNode, FdmKey, ModelRevisionId, ModelRevisionKey } from '../types';
+import { ThreeDModelFdmConnections } from './types';
+export declare function buildThreeDModelFdmConnections(modelRevisionId: ModelRevisionId, connections: FdmCadConnection[], relevantFdmKeySet: Set<FdmKey>): ThreeDModelFdmConnections;
+export declare function mergeRawConnectionMaps(cachedConnectionsByRevision: Map<ModelRevisionKey, FdmCadConnection[]>, fetchedConnectionsByRevision: Map<ModelRevisionKey, FdmCadConnection[]>, cachedConnectionsWithNodesByRevision: Map<ModelRevisionKey, FdmConnectionWithNode[]>): Map<ModelRevisionKey, FdmCadConnection[]>;

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

@@ -0,0 +1,25 @@
+import { DmsUniqueIdentifier } from '../../FdmSDK';
+import { AssetId, NodeId, TreeIndex } from '../types';
+import { HybridCadAssetMapping } from './assetMappingTypes';
+/**
+ * The raw CDF asset mapping type, including DM instance IDs
+ * The AssetMapping3D type defined in the SDK does not cover all variations,
+ * in particular it always requires `assetId` to be defined, but it may be undefined
+ * if `assetInstanceId` is defined. Therefore we introduce the `RawCdfHybridCadASsetMapping
+ */
+export type RawCdfCadAssetMappingClassicInstance = {
+    assetId: AssetId;
+};
+export type RawCdfCadAssetMappingDmInstance = {
+    assetInstanceId: DmsUniqueIdentifier;
+};
+export type RawCdfCadAssetMappingHybridInstance = RawCdfCadAssetMappingClassicInstance | RawCdfCadAssetMappingDmInstance;
+export type RawCdfHybridCadAssetMappingBase = {
+    nodeId: NodeId;
+    treeIndex?: TreeIndex;
+    subtreeSize?: number;
+};
+export type RawCdfHybridClassicCadAssetMapping = RawCdfHybridCadAssetMappingBase & RawCdfCadAssetMappingClassicInstance;
+export type RawCdfHybridDmCadAssetMapping = RawCdfHybridCadAssetMappingBase & RawCdfCadAssetMappingDmInstance;
+export type RawCdfHybridCadAssetMapping = RawCdfHybridClassicCadAssetMapping | RawCdfHybridDmCadAssetMapping;
+export declare function convertToHybridAssetMapping(rawAssetMapping: RawCdfHybridCadAssetMapping): HybridCadAssetMapping[] | undefined;

package/dist/data-providers/cache/cad/rawAssetMappingTypes.js

@@ -0,0 +1,27 @@
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/rawAssetMappingTypes.ts
+function e(e) {
+	return e.treeIndex !== void 0 && e.subtreeSize !== void 0;
+}
+function t(e) {
+	return "assetId" in e && e.assetId !== void 0;
+}
+function n(e) {
+	return "assetInstanceId" in e && e.assetInstanceId !== void 0;
+}
+function r(r) {
+	if (!e(r)) return;
+	let i = [];
+	return t(r) && i.push({
+		nodeId: r.nodeId,
+		treeIndex: r.treeIndex,
+		subtreeSize: r.subtreeSize,
+		assetId: r.assetId
+	}), n(r) && i.push({
+		nodeId: r.nodeId,
+		treeIndex: r.treeIndex,
+		subtreeSize: r.subtreeSize,
+		instanceId: r.assetInstanceId
+	}), i;
+}
+//#endregion
+export { r as convertToHybridAssetMapping };

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

@@ -0,0 +1,26 @@
+import { AssetInstance } from '../../../utilities/instances';
+import { DmsUniqueIdentifier } from '../../FdmSDK';
+import { SlimCadNodeWithBounds } from '../../utils/cadNodeConnectionFields';
+import { FdmKey } from '../types';
+/** DMS CAD connection data available before classic 3D node resolution. */
+export type FdmCadConnectionMapping = {
+    instance: DmsUniqueIdentifier;
+    treeIndex: number;
+    subtreeSize?: number;
+    nodeId?: number;
+};
+export type ThreeDModelFdmConnections = {
+    modelId: number;
+    revisionId: number;
+    mappings: Map<FdmKey, FdmCadConnectionMapping[]>;
+};
+export type HybridCadCacheIndexType = 'nodeIds' | 'assetIds';
+export type ThreeDModelFdmMappings = {
+    modelId: number;
+    revisionId: number;
+    mappings: Map<FdmKey, SlimCadNodeWithBounds[]>;
+};
+export type HybridImage360AnnotationMappedData = {
+    asset: AssetInstance;
+    annotationIds: number[];
+};

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

@@ -0,0 +1,13 @@
+import { InstanceId, InstanceKey, InstanceReference } from '../../utilities/instanceIds/types';
+import { DmsUniqueIdentifier } from '../FdmSDK';
+import { FdmKey, ModelTreeIndexKey, ModelRevisionKey, TreeIndex, RevisionId, ModelId, ModelInstanceIdKey, NodeId, ModelNodeIdKey } from './types';
+export declare function createModelRevisionKey(modelId: ModelId, revisionId: RevisionId): ModelRevisionKey;
+export declare function revisionKeyToIds(revisionKey: ModelRevisionKey): [ModelId, RevisionId];
+export declare function createFdmKey(id: DmsUniqueIdentifier): FdmKey;
+export declare function fdmKeyToId(fdmKey: FdmKey): DmsUniqueIdentifier;
+export declare function createInstanceKey(id: InstanceId): InstanceKey;
+export declare function instanceIdToInstanceReference(id: InstanceId): InstanceReference;
+export declare function isFdmKey(key: unknown): key is FdmKey;
+export declare function createModelTreeIndexKey(modelId: ModelId, revisionId: RevisionId, treeIndex: TreeIndex): ModelTreeIndexKey;
+export declare function createModelInstanceIdKey(modelId: ModelId, revisionId: RevisionId, id: InstanceKey): ModelInstanceIdKey;
+export declare function createModelNodeIdKey(modelId: ModelId, revisionId: RevisionId, id: NodeId): ModelNodeIdKey;

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

@@ -0,0 +1,40 @@
+import { isClassicInstanceId as e } from "../../utilities/instanceIds/typeGuards.js";
+import { split as t } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/cache/idAndKeyTranslation.ts
+function n(e, t) {
+	return `${e}/${t}`;
+}
+function r(e) {
+	let n = t(e, "/");
+	return [Number(n[0]), Number(n[1])];
+}
+function i(e) {
+	return `${e.space}/${e.externalId}`;
+}
+function a(e) {
+	let [n, ...r] = t(e, "/");
+	return {
+		space: n,
+		externalId: r.join("/")
+	};
+}
+function o(t) {
+	return e(t) ? t : i(t);
+}
+function s(t) {
+	return e(t) ? { id: t } : t;
+}
+function c(e) {
+	return typeof e == "string" && e.includes("/");
+}
+function l(e, t, n) {
+	return `${e}/${t}/${n}`;
+}
+function u(e, t, n) {
+	return `${e}/${t}/${n}`;
+}
+function d(e, t, n) {
+	return `${e}/${t}/${n}`;
+}
+//#endregion
+export { i as createFdmKey, o as createInstanceKey, u as createModelInstanceIdKey, d as createModelNodeIdKey, n as createModelRevisionKey, l as createModelTreeIndexKey, a as fdmKeyToId, s as instanceIdToInstanceReference, c as isFdmKey, r as revisionKeyToIds };

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

@@ -0,0 +1,5 @@
+export { type AssetId, type Image360AnnotationAssetInfo } from './types';
+export { createFdmKey, fdmKeyToId, isFdmKey } from './idAndKeyTranslation';
+export { getIdKeyForImage360, findViewerAnnotationInfo } from './utils';
+export { type FdmKey } from './types';
+export { type HybridImage360AnnotationMappedData as HybridImage360AnnotationMappedDatar, type FdmCadConnectionMapping, type ThreeDModelFdmConnections, type ThreeDModelFdmMappings, } from './cad/types';

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

@@ -0,0 +1,3 @@
+import { createFdmKey as e, fdmKeyToId as t, isFdmKey as n } from "./idAndKeyTranslation.js";
+import { findViewerAnnotationInfo as r, getIdKeyForImage360 as i } from "./utils.js";
+export { e as createFdmKey, t as fdmKeyToId, r as findViewerAnnotationInfo, i as getIdKeyForImage360, n as isFdmKey };

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

@@ -0,0 +1,8 @@
+import { CogniteClient, Node3D } from '@cognite/sdk';
+import { FdmSDK, InspectResultList, DmsUniqueIdentifier } from '../FdmSDK';
+import { ModelId, NodeId, RevisionId, TreeIndex } from './types';
+export declare function fetchAncestorNodesForTreeIndex(modelId: ModelId, revisionId: RevisionId, treeIndex: TreeIndex, cogniteClient: CogniteClient): Promise<Node3D[]>;
+export declare function inspectNodes(fdmClient: FdmSDK, dataNodes: DmsUniqueIdentifier[]): Promise<InspectResultList>;
+export declare function treeIndexesToNodeIds(modelId: ModelId, revisionId: RevisionId, treeIndexes: TreeIndex[], cogniteClient: CogniteClient): Promise<NodeId[]>;
+export declare function nodeIdsToTreeIndices(modelId: ModelId, revisionId: RevisionId, nodeIds: NodeId[], cogniteClient: CogniteClient): Promise<TreeIndex[]>;
+export declare function fetchNodesForNodeIds(modelId: ModelId, revisionId: RevisionId, nodeIds: NodeId[], cogniteClient: CogniteClient): Promise<Node3D[]>;

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

@@ -0,0 +1,40 @@
+import { chunk as e } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/cache/requests.ts
+async function t(e, t, n, i) {
+	let a = await r(e, t, [n], i);
+	return (await i.revisions3D.list3DNodeAncestors(e, t, a[0])).items;
+}
+async function n(t, n) {
+	let r = e(n, 100), i = { items: [] };
+	for (let e of r) {
+		let n = await t.inspectInstances({
+			inspectionOperations: { involvedViews: { allVersions: !0 } },
+			items: e.map((e) => ({
+				instanceType: "node",
+				externalId: e.externalId,
+				space: e.space
+			}))
+		});
+		i.items.push(...n.items);
+	}
+	return i;
+}
+async function r(t, n, r, i) {
+	let a = `${i.getBaseUrl()}/api/v1/projects/${i.project}/3d/models/${t}/revisions/${n}/nodes/internalids/bytreeindices`, o = e(r, 1e3), s = [];
+	for (let e of o) {
+		let t = await i.post(a, { data: { items: e } });
+		if (t.status === 200) s.push(...t.data.items);
+		else throw Error(`treeIndex-nodeId translation failed for treeIndexes ${e.join(",")}`);
+	}
+	return s;
+}
+async function i(e, t, n, r) {
+	let i = `${r.getBaseUrl()}/api/v1/projects/${r.project}/3d/models/${e}/revisions/${t}/nodes/treeindices/byinternalids`, a = await r.post(i, { data: { items: n } });
+	if (a.status === 200) return a.data.items;
+	throw Error(`nodeId-treeIndex translation failed for nodeIds ${n.join(",")}`);
+}
+async function a(e, t, n, r) {
+	return n.length === 0 ? [] : await r.revisions3D.retrieve3DNodes(e, t, n.map((e) => ({ id: e })));
+}
+//#endregion
+export { t as fetchAncestorNodesForTreeIndex, a as fetchNodesForNodeIds, n as inspectNodes, i as nodeIdsToTreeIndices, r as treeIndexesToNodeIds };

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

@@ -0,0 +1,3 @@
+import { AnnotationModel } from '@cognite/sdk';
+import { PointCloudAnnotationModel } from './types';
+export declare function isPointCloudAnnotationModel(annotationModel: AnnotationModel): annotationModel is PointCloudAnnotationModel;

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

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/data-providers/cache/typeGuards.ts
+function e(e) {
+	return typeof e == "object" && !!e && e.data !== null && typeof e.data == "object" && "region" in e.data;
+}
+//#endregion
+export { e as isPointCloudAnnotationModel };

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

@@ -0,0 +1,115 @@
+import { Vector3 } from 'three';
+import { Image360AnnotationAssetQueryResult, DataSourceType } from '@cognite/reveal';
+import { AnnotationsTypesImagesAssetLink, AnnotationModel, AnnotationsBoundingVolume, Node3D } from '@cognite/sdk';
+import { InstanceKey } from '../../utilities/instanceIds/types';
+import { AssetInstance } from '../../utilities/instances/AssetInstance';
+import { Source, DmsUniqueIdentifier } from '../FdmSDK';
+import { SlimCadNode } from '../utils/cadNodeConnectionFields';
+export type FdmCadConnection = {
+    instance: DmsUniqueIdentifier;
+    modelId: number;
+    revisionId: number;
+    treeIndex: number;
+    subtreeSize?: number;
+    nodeId?: number;
+};
+export type FdmCadConnectionRevisionFields = Omit<FdmCadConnection, 'instance'>;
+/** DMS connection with trustworthy nodeId and subtreeSize for styling without the 3D API. */
+export type FdmCadConnectionWithDmsNodeData = FdmCadConnection & {
+    nodeId: number;
+    subtreeSize: number;
+};
+export type FdmCadConnectionWithViews = {
+    connection: FdmCadConnection;
+    views?: Source[];
+};
+export type FdmCadConnectionWithDmsNodeDataAndViews = {
+    connection: FdmCadConnectionWithDmsNodeData;
+    views?: Source[];
+};
+export type FdmConnectionWithNode = {
+    connection: FdmCadConnection;
+    cadNode: SlimCadNode;
+    views?: Source[];
+};
+export type CadNodeTreeData = {
+    treeIndex: number;
+    subtreeSize: number;
+};
+export type CadNodeIdData = CadNodeTreeData & {
+    nodeId: number;
+};
+export type CadNodeWithFdmIds = {
+    cadNode: SlimCadNode;
+    fdmIds: DmsUniqueIdentifier[];
+};
+export type CadNodeWithConnections = {
+    cadNode: SlimCadNode;
+    connections: FdmCadConnection[];
+};
+export type FdmNodeDataPromises = {
+    cadAndFdmNodesPromise: Promise<CadNodeWithFdmIds | undefined>;
+    viewsPromise: Promise<Source[][] | undefined>;
+};
+export type ModelRevisionAssetNodesResult = {
+    modelId: ModelId;
+    revisionId: RevisionId;
+    assetToNodeMap: Map<AssetId, Node3D[]>;
+};
+export type AncestorQueryResult = {
+    connections: FdmCadConnection[];
+    ancestorsWithSameMapping: Node3D[];
+    firstMappedAncestorTreeIndex: number;
+};
+export type ModelId = number;
+export type RevisionId = number;
+export type NodeId = number;
+export type TreeIndex = number;
+export type AssetId = number;
+export type ModelRevisionId = {
+    modelId: number;
+    revisionId: number;
+};
+export type ModelRevisionKey = `${ModelId}/${RevisionId}`;
+export type FdmKey = `${string}/${string}`;
+export type ModelTreeIndexKey = `${ModelId}/${RevisionId}/${TreeIndex}`;
+export type ModelNodeIdKey = `${ModelId}/${RevisionId}/${NodeId}`;
+export type ModelAssetIdKey = `${ModelId}/${RevisionId}/${AssetId}`;
+export type ModelFdmIdKey = `${ModelId}/${RevisionId}/${FdmKey}`;
+export type ModelInstanceIdKey = ModelAssetIdKey | ModelFdmIdKey;
+export type ModelRevisionToConnectionMap = Map<ModelRevisionKey, FdmConnectionWithNode[]>;
+export type PointCloudAnnotationModel = AnnotationModel & {
+    data: AnnotationsBoundingVolume;
+};
+export type Image360AnnotationModel = AnnotationModel & {
+    data: AnnotationsTypesImagesAssetLink;
+};
+export type Image360AnnotationAssetInfo = {
+    asset: AssetInstance;
+    assetAnnotationImage360Info: Image360AnnotationAssetQueryResult<DataSourceType>;
+    position: Vector3;
+};
+export type AnnotationId = number;
+export type ChunkInCacheTypes<ObjectType, KeyType extends InstanceKey | NodeId> = {
+    chunkInCache: ObjectType[];
+    chunkNotInCache: KeyType[];
+};
+type PointCloudVolume = {
+    externalId: string;
+    space: string;
+    volumeReference: string;
+    volumeType: string;
+    volume: number[];
+    object3D: DmsUniqueIdentifier;
+};
+export type PointCloudVolumeWithAsset = PointCloudVolume & {
+    dmAsset?: {
+        externalId: string;
+        space: string;
+        object3D: DmsUniqueIdentifier;
+        name: string;
+        description: string;
+    };
+};
+export type PointCloudVolumeId = AnnotationId | DmsUniqueIdentifier;
+export {};

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

@@ -0,0 +1,20 @@
+import { Cognite3DViewer, Image360AnnotationAssetQueryResult, Image360, PointCloudObjectMetadata, DataSourceType } from '@cognite/reveal';
+import { AnnotationModel } from '@cognite/sdk';
+import { InstanceReference } from '../../utilities/instanceIds';
+import { InstanceReferenceKey } from '../../utilities/instanceIds/toKey';
+import { PointCloudVolumeId } from './types';
+export declare function getInstanceReferencesFromPointCloudAnnotation(annotation: AnnotationModel): InstanceReference[];
+export declare function getInstanceReferencesFromPointCloudVolume(volume: PointCloudObjectMetadata<DataSourceType>): InstanceReference[];
+export declare function getPointCloudVolumeId(volume: PointCloudObjectMetadata<DataSourceType>): PointCloudVolumeId;
+export declare function getAssetIdKeyForImage360Annotation(annotation: DataSourceType['image360AnnotationType']): InstanceReferenceKey | undefined;
+export declare function getIdKeyForImage360Annotation(annotation: DataSourceType['image360AnnotationType']): string | number;
+export declare function getIdKeyForImage360(image: Image360<DataSourceType>): string;
+/**
+ * Returns a tuple of `image, revision, annotation` for the given annotation instances
+ * The given annotation instances already contains an image, revision and annotation, but
+ * they may be provided through the `Image360AnnotationCache`, which means they may not correspond
+ * to the current instance of the 360 Image collection, but e.g. a now-removed 360-collection instance
+ * with the same ID as the currently added one.
+ * TODO(BND3D-6604): Fix the image360 annotation cache behavior
+ */
+export declare function findViewerAnnotationInfo(viewer: Cognite3DViewer<DataSourceType>, annotationInfo: Image360AnnotationAssetQueryResult<DataSourceType>): Promise<Image360AnnotationAssetQueryResult<DataSourceType> | undefined>;

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

@@ -0,0 +1,48 @@
+import { isDmsInstance as e, isIdEither as t } from "../../utilities/instanceIds/typeGuards.js";
+import { createFdmKey as n } from "./idAndKeyTranslation.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 { getImage360AnnotationId as a } from "../../utilities/image360Annotations/getImage360AnnotationId.js";
+import { isSameImage360AnnotationId as o } from "../../utilities/image360Annotations/equality.js";
+import "../../utilities/image360Annotations/index.js";
+import { isClassicPointCloudVolume as s, isDMPointCloudVolume as c } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/data-providers/cache/utils.ts
+function l(n) {
+	let r = n.data, i = [];
+	if (r.assetRef !== void 0 && t(r.assetRef) && i.push(r.assetRef), r.instanceRef !== void 0 && e(r.instanceRef)) {
+		let e = {
+			space: r.instanceRef.space,
+			externalId: r.instanceRef.externalId
+		};
+		i.push(e);
+	}
+	return i;
+}
+function u(n) {
+	let r = [];
+	return s(n) && (t(n.assetRef) && r.push(n.assetRef), e(n.instanceRef) && r.push(n.instanceRef)), c(n) && n.assetRef !== void 0 && r.push(n.assetRef), r;
+}
+function d(e) {
+	return s(e) ? e.annotationId : e.volumeInstanceRef;
+}
+function f(e) {
+	let t = i(e);
+	if (t !== void 0) return r(t);
+}
+function p(t) {
+	return e(t.id) ? n(t.id) : t.id;
+}
+async function m(e, t) {
+	let n = e.get360ImageCollections().flatMap((e) => e.image360Entities.filter((e) => p(e) === p(t.image))).flatMap((e) => e.getRevisions().map(async (n) => ({
+		image: e,
+		revision: n,
+		annotation: await h(n, t.annotation.annotation)
+	})));
+	return (await Promise.all(n)).filter((e) => e.annotation !== void 0)[0];
+}
+async function h(e, t) {
+	return (await e.getAnnotations()).find((e) => o(a(e.annotation), a(t)));
+}
+//#endregion
+export { m as findViewerAnnotationInfo, f as getAssetIdKeyForImage360Annotation, p as getIdKeyForImage360, l as getInstanceReferencesFromPointCloudAnnotation, u as getInstanceReferencesFromPointCloudVolume, d as getPointCloudVolumeId };

package/dist/data-providers/core-dm-provider/CoreDm3dDataProvider.d.ts

@@ -0,0 +1,33 @@
+import { ViewDefinition, Node3D } from '@cognite/sdk';
+import { InstancesWithView, InstancesWithViewDefinition } from '../../ui/query/useSearchMappedEquipmentFDM';
+import { FdmCadConnection } from '../cache/types';
+import { Fdm3dDataProvider } from '../Fdm3dDataProvider';
+import { DmsUniqueIdentifier, FdmSDK, InstanceFilter, NodeItem, Source } from '../FdmSDK';
+import { Classic3DResourceIdentifier, ThreeDResourceIdentifier } from '../types/resources';
+import { listAllMappedFdmNodes as listAllMappedFdmNodesImpl, listMappedFdmNodes as listMappedFdmNodesImpl } from './listMappedFdmNodes';
+export type CoreDm3dDataProviderDeps = {
+    listMappedFdmNodes: typeof listMappedFdmNodesImpl;
+    listAllMappedFdmNodes: typeof listAllMappedFdmNodesImpl;
+};
+export declare class CoreDm3dFdm3dDataProvider implements Fdm3dDataProvider {
+    private readonly _fdmSdk;
+    private readonly _deps;
+    private readonly _revisionIdToDMSIdentifier;
+    private readonly _modelIdToDMSIdentifier;
+    constructor(fdmSdk: FdmSDK, deps?: CoreDm3dDataProviderDeps);
+    is3dView(view: ViewDefinition): boolean;
+    getDMSModels(modelId: number): Promise<DmsUniqueIdentifier[]>;
+    private getDMSRevision;
+    private getDMSModelsForIds;
+    private getDMSRevisionsForRevisionIdsAndModelRefs;
+    private getRevisionRefsByType;
+    getEdgeConnected3dInstances(instance: DmsUniqueIdentifier): Promise<DmsUniqueIdentifier[]>;
+    getFdmConnectionsForNodes(models: DmsUniqueIdentifier[], revisionId: number, nodes: Node3D[]): Promise<FdmCadConnection[]>;
+    listMappedFdmNodes(models: ThreeDResourceIdentifier[], sourcesToSearch: ViewDefinition[], instanceFilter: InstanceFilter | undefined, limit: number): Promise<NodeItem[]>;
+    listAllMappedFdmNodes(models: ThreeDResourceIdentifier[], sourcesToSearch: Source[], instanceFilter: InstanceFilter | undefined): Promise<NodeItem[]>;
+    filterNodesByMappedTo3d(nodes: InstancesWithViewDefinition[], models: ThreeDResourceIdentifier[], includeIndirectRelations: boolean): Promise<InstancesWithView[]>;
+    getCadModelsForInstance(instance: DmsUniqueIdentifier): Promise<ThreeDResourceIdentifier[]>;
+    getCadConnectionsForRevisions(classicModels: Classic3DResourceIdentifier[]): Promise<FdmCadConnection[]>;
+    getCadConnectionsForInstances(instances: DmsUniqueIdentifier[], classicModels: Classic3DResourceIdentifier[]): Promise<FdmCadConnection[]>;
+    getRevisionRefs(models: ThreeDResourceIdentifier[]): Promise<DmsUniqueIdentifier[]>;
+}

package/dist/data-providers/core-dm-provider/CoreDm3dDataProvider.js

@@ -0,0 +1,107 @@
+import { restrictToDmsId as e } from "../../utilities/restrictToDmsId.js";
+import { executeParallel as t } from "../../utilities/executeParallel.js";
+import { isDefined as n } from "../../utilities/isDefined.js";
+import { COGNITE_3D_OBJECT_SOURCE as r } from "./dataModels.js";
+import { getDMSModels as i } from "./getDMSModels.js";
+import { getDMSRevision as a } from "./getDMSRevision.js";
+import { EMPTY_ARRAY as o } from "../../utilities/constants.js";
+import { transformViewDefinitionToSource as s } from "./utils/transformViewItemToSource.js";
+import { filterNodesByMappedTo3d as c } from "./filterNodesByMappedTo3d.js";
+import { getCadConnectionsForInstances as l } from "./getCadConnectionsForInstances.js";
+import { getCadConnectionsForRevisions as u } from "./getCadConnectionsForRevisions.js";
+import { getCadModelsForInstance as d } from "./getCadModelsForInstance.js";
+import { getEdgeConnected3dInstances as f } from "./getEdgeConnected3dInstances.js";
+import { getFdmConnectionsForNodes as p } from "./getFdmConnectionsForNodes.js";
+import { listAllMappedFdmNodes as m, listMappedFdmNodes as h } from "./listMappedFdmNodes.js";
+import { partition as g, zip as _ } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/core-dm-provider/CoreDm3dDataProvider.ts
+var v = 2, y = {
+	listMappedFdmNodes: h,
+	listAllMappedFdmNodes: m
+}, b = class {
+	_fdmSdk;
+	_deps;
+	_revisionIdToDMSIdentifier = /* @__PURE__ */ new Map();
+	_modelIdToDMSIdentifier = /* @__PURE__ */ new Map();
+	constructor(e, t = y) {
+		this._fdmSdk = e, this._deps = t;
+	}
+	is3dView(e) {
+		return e.implements?.some((e) => e.externalId === r.externalId && e.space === r.space && e.version === r.version) ?? !1;
+	}
+	async getDMSModels(e) {
+		let t = this._modelIdToDMSIdentifier.get(e);
+		if (t !== void 0) return t;
+		let n = await i([e], this._fdmSdk);
+		return this._modelIdToDMSIdentifier.set(e, n), n;
+	}
+	async getDMSRevision(t, n) {
+		let r = this._revisionIdToDMSIdentifier.get(n);
+		if (r === void 0) {
+			let e = await a(t, n, this._fdmSdk);
+			this._revisionIdToDMSIdentifier.set(n, e), r = e;
+		}
+		if (r === void 0) throw Error(`No revision with id ${n} found`);
+		return e(r);
+	}
+	async getDMSModelsForIds(e) {
+		return (await t(e.map((e) => async () => await this.getDMSModels(e)), v)).flat();
+	}
+	async getDMSRevisionsForRevisionIdsAndModelRefs(e, r) {
+		return (await t(r.map((t, n) => async () => e[n] === void 0 ? void 0 : await this.getDMSRevision(e[n], t)), v)).filter(n);
+	}
+	async getRevisionRefsByType(e) {
+		let [t, n] = g(e, (e) => e.type === "cad"), [r, i] = g(n, (e) => e.type === "pointcloud"), [a, o, s] = await Promise.all([
+			this.getRevisionRefs(t),
+			this.getRevisionRefs(r),
+			this.getRevisionRefs(i)
+		]);
+		return {
+			cad: a,
+			pointCloud: o,
+			image360: s
+		};
+	}
+	async getEdgeConnected3dInstances(e) {
+		return await f(e, this._fdmSdk);
+	}
+	async getFdmConnectionsForNodes(e, t, n) {
+		e.length !== 1 && console.warn(`Expected 1 CoreDM 3D model, got ${e.length}:`, ...e);
+		let r = e[0], i = await this.getDMSRevision(r, t);
+		return await p(r, i, t, n, this._fdmSdk);
+	}
+	async listMappedFdmNodes(e, t, n, r) {
+		let i = await this.getRevisionRefsByType(e);
+		return await this._deps.listMappedFdmNodes(i, t.map((e) => s(e)), n, r, this._fdmSdk);
+	}
+	async listAllMappedFdmNodes(e, t, n) {
+		let r = await this.getRevisionRefsByType(e);
+		return await this._deps.listAllMappedFdmNodes(r, t, n, this._fdmSdk);
+	}
+	async filterNodesByMappedTo3d(e, t, n) {
+		let r = await this.getRevisionRefs(t);
+		return await c(e, r, this._fdmSdk, n);
+	}
+	async getCadModelsForInstance(e) {
+		return await d(e, this._fdmSdk);
+	}
+	async getCadConnectionsForRevisions(e) {
+		if (e.length === 0) return o;
+		let t = await this.getDMSModelsForIds(e.map((e) => e.modelId)), r = await this.getDMSRevisionsForRevisionIdsAndModelRefs(t, e.map((e) => e.revisionId)), i = _(t, r).filter((e) => n(e[0]) && n(e[1]));
+		return await u(i, this._fdmSdk);
+	}
+	async getCadConnectionsForInstances(e, t) {
+		if (t.length === 0) return o;
+		let r = await this.getDMSModelsForIds(t.map((e) => e.modelId)), i = await this.getDMSRevisionsForRevisionIdsAndModelRefs(r, t.map((e) => e.revisionId)), a = _(r, i).filter((e) => n(e[0]) && n(e[1]));
+		return await l(e, a, this._fdmSdk);
+	}
+	async getRevisionRefs(e) {
+		let [t, n] = g(e, (e) => e.sourceType === "classic"), r = await this.getDMSModelsForIds(t.map((e) => e.modelId)), i = await this.getDMSRevisionsForRevisionIdsAndModelRefs(r, t.map((e) => e.revisionId)), a = n.flatMap((e) => "externalId" in e ? [{
+			externalId: e.externalId,
+			space: e.space
+		}] : []);
+		return i.concat(a);
+	}
+};
+//#endregion
+export { b as CoreDm3dFdm3dDataProvider };

package/dist/data-providers/core-dm-provider/assetsInstanceFilterWithHasDataQuery.d.ts

@@ -0,0 +1,2 @@
+import { InstanceFilter, Source } from '../FdmSDK';
+export declare function assetsInstanceFilterWithHasDataQuery(sourcesToSearch: Source[]): InstanceFilter;