@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,80 @@
+import { isDmsInstance as e } from "../../../utilities/instanceIds/typeGuards.js";
+import { createFdmKey as t, createModelRevisionKey as n } from "../idAndKeyTranslation.js";
+import "../../../utilities/instanceIds/index.js";
+import { executeParallel as r } from "../../../utilities/executeParallel.js";
+import { isDefined as i } from "../../../utilities/isDefined.js";
+import { concatenateMapValues as a } from "../../../utilities/map/concatenateMapValues.js";
+import { mergeMapMapValues as o } from "../../../utilities/map/mergeMapMapValues.js";
+import "../../utils/getDMSModelRevisionRefs.js";
+import { isClassicCadAssetTreeIndexMapping as s } from "./assetMappingTypes.js";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/CadInstanceMappingsCacheImpl.ts
+function c(e, t) {
+	return new l(e, t);
+}
+var l = class {
+	_dmCache;
+	_classicCache;
+	constructor(e, t) {
+		this._dmCache = t, this._classicCache = e;
+	}
+	async getMappingsForModelsAndInstances(t, a, s) {
+		if (u(s), a.length === 0 || t.length === 0) return /* @__PURE__ */ new Map();
+		let c = t.filter(e), l = await this._dmCache?.getMappingsForFdmInstances(c, a);
+		u(s);
+		let f = d(l), p = a.map((e) => async () => {
+			u(s);
+			let r = await this._classicCache?.getNodesForInstanceIds(e.modelId, e.revisionId, t);
+			if (u(s), r !== void 0) return [n(e.modelId, e.revisionId), r];
+		}).filter(i), m = await r(p, 2);
+		u(s);
+		let h = new Map(m.filter(i));
+		return o([...h.entries(), ...f?.entries() ?? []]);
+	}
+	async getAllModelMappings(e, t) {
+		return await this.getAllModelMappingsInternal(e, !1, t);
+	}
+	async getAllModelMappingsWithViews(e, t) {
+		return await this.getAllModelMappingsInternal(e, !0, t);
+	}
+	async getAllModelMappingsInternal(e, c, l) {
+		u(l);
+		let d = r(e.map((e) => async () => {
+			if (this._classicCache !== void 0) return {
+				model: e,
+				mappings: await this._classicCache.getAssetMappingsForModel(e.modelId, e.revisionId)
+			};
+		}), 2), f = this._dmCache?.getAllMappingExternalIds(e, c), p = (await d).filter(i).flat();
+		u(l);
+		let m = await f;
+		u(l);
+		let h = new Map(p.map(({ model: e, mappings: r }) => {
+			let i = a(r.map((e) => {
+				if (s(e)) {
+					let { assetId: t, ...n } = e;
+					return [t, n];
+				}
+				{
+					let { instanceId: n, ...r } = e;
+					return [t(n), r];
+				}
+			}));
+			return [n(e.modelId, e.revisionId), i];
+		})), g = new Map([...m?.entries() ?? []].map(([e, n]) => {
+			let r = n.map((e) => [t(e.connection.instance), {
+				treeIndex: e.cadNode.treeIndex,
+				subtreeSize: e.cadNode.subtreeSize,
+				nodeId: e.cadNode.id
+			}]);
+			return [e, a(r)];
+		}));
+		return o([...h.entries(), ...g.entries()]);
+	}
+};
+function u(e) {
+	e?.throwIfAborted();
+}
+function d(e) {
+	if (e !== void 0) return new Map(e.map((e) => [n(e.modelId, e.revisionId), e.mappings]));
+}
+//#endregion
+export { c as createCadInstanceMappingsCache };

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

@@ -0,0 +1,22 @@
+import { Node3D } from '@cognite/sdk';
+import { ModelWithAssetMappings } from '../../../ui/hooks/cad/modelWithAssetMappings';
+import { InstanceId, InstanceKey } from '../../../utilities/instanceIds';
+import { ModelId, RevisionId } from '../types';
+import { HybridCadAssetMapping } from './assetMappingTypes';
+export type HybridCadNodeAssetMappingResult = {
+    node?: Node3D;
+    mappings: HybridCadAssetMapping[];
+};
+export type AssetMappingsPageResult = {
+    mappings: HybridCadAssetMapping[];
+    nextCursor: string | undefined;
+};
+export type ClassicCadAssetMappingCache = {
+    getAssetMappingsForLowestAncestor: (modelId: ModelId, revisionId: RevisionId, ancestors: Node3D[]) => Promise<HybridCadNodeAssetMappingResult>;
+    getNodesForInstanceIds: (modelId: ModelId, revisionId: RevisionId, instanceIds: InstanceId[]) => Promise<Map<InstanceKey, Node3D[]>>;
+    generateNode3DCachePerItem: (modelId: ModelId, revisionId: RevisionId, nodeIds: number[] | undefined) => Promise<void>;
+    generateAssetMappingsCachePerItemFromModelCache: (modelId: ModelId, revisionId: RevisionId, assetMappingsPerModel: ModelWithAssetMappings[] | undefined) => void;
+    getAssetMappingsForModel: (modelId: ModelId, revisionId: RevisionId) => Promise<HybridCadAssetMapping[]>;
+    getAssetMappingsForModelPage: (modelId: ModelId, revisionId: RevisionId, cursor?: string) => Promise<AssetMappingsPageResult>;
+    getAssetMappingsForInstanceIds: (modelId: ModelId, revisionId: RevisionId, assetIds: number[]) => Promise<HybridCadAssetMapping[]>;
+};

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

@@ -0,0 +1,3 @@
+import { CogniteClient } from '@cognite/sdk';
+import { ClassicCadAssetMappingCache } from './ClassicCadAssetMappingCache';
+export declare function createClassicCadAssetMappingCache(sdk: CogniteClient): ClassicCadAssetMappingCache;

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

@@ -0,0 +1,135 @@
+import { createInstanceKey as e, createModelInstanceIdKey as t, createModelNodeIdKey as n, createModelRevisionKey as r, fdmKeyToId as i } from "../idAndKeyTranslation.js";
+import { isDefined as a } from "../../../utilities/isDefined.js";
+import { getMappingInstanceId as o } from "./assetMappingTypes.js";
+import { ClassicCadAssetMappingPerAssetIdCache as s } from "./ClassicCadAssetMappingPerAssetIdCache.js";
+import { convertToHybridAssetMapping as c } from "./rawAssetMappingTypes.js";
+import { ClassicCadAssetMappingPerModelCache as l } from "./ClassicCadAssetMappingPerModelCache.js";
+import { ClassicCadAssetMappingPerNodeIdCache as u } from "./ClassicCadAssetMappingPerNodeIdCache.js";
+import { ClassicCadNode3DPerNodeIdCache as d } from "./ClassicCadNode3DPerNodeIdCache.js";
+import { chunk as f, maxBy as p, partition as m } from "lodash-es";
+import { assert as h } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/ClassicCadAssetMappingCacheImpl.ts
+function g(e) {
+	return new _(e);
+}
+var _ = class {
+	_sdk;
+	modelToAssetMappingsCache;
+	assetIdsToAssetMappingCache;
+	nodeIdsToAssetMappingCache;
+	nodeIdsToNode3DCache;
+	_amountOfAssetIdsChunks = 1;
+	_individuallyCachedPages = /* @__PURE__ */ new Set();
+	constructor(e) {
+		this._sdk = e, this.assetIdsToAssetMappingCache = new s(), this.nodeIdsToAssetMappingCache = new u(), this.modelToAssetMappingsCache = new l(this._sdk), this.nodeIdsToNode3DCache = new d(this._sdk);
+	}
+	async getAssetMappingsForLowestAncestor(e, t, n) {
+		if (n.length === 0) return { mappings: [] };
+		let r = new Set(n.map((e) => e.treeIndex)), i = (await this.getAssetMappingsForNodes(e, t, n)).filter((e) => r.has(e.treeIndex));
+		if (i.length === 0) return { mappings: [] };
+		let a = p(i, (e) => e.treeIndex)?.treeIndex;
+		h(a !== void 0);
+		let o = i.filter((e) => e.treeIndex === a), s = n.find((e) => e.treeIndex === a);
+		return h(s !== void 0), {
+			node: s,
+			mappings: o
+		};
+	}
+	async getNodesForInstanceIds(t, n, r) {
+		let i = Math.round(r.length / this._amountOfAssetIdsChunks), a = f(r, i).map(async (e) => await this.getAssetMappingsForInstanceIds(t, n, e)), s = (await Promise.all(a)).flat(), c = new Set(r.map(e)), l = s.filter((t) => c.has(e(o(t))));
+		return (await this.nodeIdsToNode3DCache.getNodesForNodeIds(t, n, l.map((e) => e.nodeId))).reduce((t, n, r) => {
+			let i = e(o(l[r])), a = t.get(i);
+			return a === void 0 ? t.set(i, [n]) : a.push(n), t;
+		}, /* @__PURE__ */ new Map());
+	}
+	async generateNode3DCachePerItem(e, t, n) {
+		await this.nodeIdsToNode3DCache.generateNode3DCachePerItem(e, t, n);
+	}
+	generateAssetMappingsCachePerItemFromModelCache(n, r, i) {
+		i !== void 0 && i.flatMap((i) => i.assetMappings.forEach((i) => {
+			let a = t(n, r, e(o(i)));
+			this.assetIdsToAssetMappingCache.setAssetMappingsCacheItem(a, i);
+		}));
+	}
+	async getAssetMappingsForModel(e, t) {
+		let n = r(e, t), i = await this.modelToAssetMappingsCache.getModelToAssetMappingCacheItems(n);
+		return i === void 0 ? await this.modelToAssetMappingsCache.fetchAndCacheMappingsForModel(e, t) : i;
+	}
+	async getAssetMappingsForModelPage(e, t, n, i = !1) {
+		let a = await this.modelToAssetMappingsCache.fetchAssetMappingsPage(e, t, n, i), o = `${r(e, t)}|${n ?? ""}`;
+		return this._individuallyCachedPages.has(o) || (this._individuallyCachedPages.add(o), this.cacheIndividualMappings(e, t, a.mappings)), a;
+	}
+	cacheIndividualMappings(r, i, a) {
+		a.forEach((a) => {
+			let s = t(r, i, e(o(a))), c = n(r, i, a.nodeId);
+			this.assetIdsToAssetMappingCache.setAssetMappingsCacheItem(s, a), this.nodeIdsToAssetMappingCache.setAssetMappingsCacheItem(c, a);
+		});
+	}
+	async splitChunkInCacheAssetMappings(e, n, r, i) {
+		let a = [], o = [];
+		return await Promise.all(e.map(async (e) => {
+			let s = t(n, r, e), c = await this.getItemCacheResult(i, s);
+			c === void 0 ? o.push(e) : a.push(...c);
+		})), {
+			chunkInCache: a,
+			chunkNotInCache: o
+		};
+	}
+	async getItemCacheResult(e, t) {
+		return e === "nodeIds" ? await this.nodeIdsToAssetMappingCache.getNodeIdsToAssetMappingCacheItem(t) : await this.assetIdsToAssetMappingCache.getAssetIdsToAssetMappingCacheItem(t);
+	}
+	setItemCacheResult(e, t, n) {
+		let r = Promise.resolve(n ?? []);
+		e === "nodeIds" ? this.nodeIdsToAssetMappingCache.setNodeIdsToAssetMappingCacheItem(t, r) : this.assetIdsToAssetMappingCache.setAssetIdsToAssetMappingCacheItem(t, r);
+	}
+	async fetchAssetMappingsRequest(r, i, s, l) {
+		let u = (await (async () => i === "nodeIds" ? await this.fetchAssetMappingsByNodeIds(r, s, l) : await this.fetchAssetMappingsByInstanceIds(r, s, l))()).flatMap(c).filter(a);
+		return await Promise.all(u.map(async (r) => {
+			let i = t(s, l, e(o(r))), a = n(s, l, r.nodeId);
+			this.assetIdsToAssetMappingCache.setAssetMappingsCacheItem(i, r), this.nodeIdsToAssetMappingCache.setAssetMappingsCacheItem(a, r);
+		})), r.forEach(async (e) => {
+			let n = t(s, l, e);
+			await this.getItemCacheResult(i, n) === void 0 && this.setItemCacheResult(i, n, []);
+		}), u;
+	}
+	async fetchAssetMappingsByInstanceIds(e, t, n) {
+		let [r, a] = m(e, (e) => typeof e == "number"), o = a.map(i), s = r.length === 0 ? Promise.resolve([]) : this.fetchMappingsWithFilter(t, n, { filter: { assetIds: r } }), c = o.length === 0 ? Promise.resolve([]) : this.fetchMappingsWithFilter(t, n, {
+			filter: { assetInstanceIds: o },
+			getDmsInstances: !0
+		}), [l, u] = await Promise.all([s, c]);
+		return [...l, ...u];
+	}
+	async fetchAssetMappingsByNodeIds(e, t, n) {
+		let r = e.filter((e) => typeof e == "number");
+		if (r.length === 0) return [];
+		let i = { nodeIds: r }, a = this.fetchMappingsWithFilter(t, n, { filter: i }), o = this.fetchMappingsWithFilter(t, n, {
+			filter: i,
+			getDmsInstances: !0
+		}), [s, c] = await Promise.all([a, o]);
+		return [...s, ...c];
+	}
+	async fetchMappingsWithFilter(e, t, n) {
+		return await this._sdk.assetMappings3D.filter(e, t, n).autoPagingToArray({ limit: Infinity });
+	}
+	async fetchMappingsInQueue(e, t, n, r, i, a) {
+		let o = await this.fetchAssetMappingsRequest(t[e], n, r, i);
+		if (a = a.concat(o), e >= t.length - 1) return a;
+		let s = e + 1;
+		return await this.fetchMappingsInQueue(s, t, n, r, i, a);
+	}
+	async fetchAndCacheMappingsForIds(e, t, n, r) {
+		if (n.length === 0) return [];
+		let i = f(n, 1e3);
+		return await this.fetchMappingsInQueue(0, i, r, e, t, []);
+	}
+	async getAssetMappingsForNodes(e, t, n) {
+		let r = n.map((e) => e.id), { chunkNotInCache: i, chunkInCache: a } = await this.splitChunkInCacheAssetMappings(r, e, t, "nodeIds"), o = i, s = await this.fetchAndCacheMappingsForIds(e, t, o, "nodeIds");
+		return a.concat(s);
+	}
+	async getAssetMappingsForInstanceIds(t, n, r) {
+		let i = r.map(e), { chunkNotInCache: a, chunkInCache: o } = await this.splitChunkInCacheAssetMappings(i, t, n, "assetIds"), s = a, c = await this.fetchAndCacheMappingsForIds(t, n, s, "assetIds");
+		return o.concat(c);
+	}
+};
+//#endregion
+export { g as createClassicCadAssetMappingCache };

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

@@ -0,0 +1,8 @@
+import { ModelInstanceIdKey } from '../types';
+import { HybridCadAssetMapping } from './assetMappingTypes';
+export declare class ClassicCadAssetMappingPerAssetIdCache {
+    private readonly _assetIdsToAssetMappings;
+    setAssetIdsToAssetMappingCacheItem(key: ModelInstanceIdKey, item: Promise<HybridCadAssetMapping[]>): void;
+    getAssetIdsToAssetMappingCacheItem(key: ModelInstanceIdKey): Promise<HybridCadAssetMapping[] | undefined>;
+    setAssetMappingsCacheItem(key: ModelInstanceIdKey, item: HybridCadAssetMapping): void;
+}

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

@@ -0,0 +1,16 @@
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/ClassicCadAssetMappingPerAssetIdCache.ts
+var e = class {
+	_assetIdsToAssetMappings = /* @__PURE__ */ new Map();
+	setAssetIdsToAssetMappingCacheItem(e, t) {
+		this._assetIdsToAssetMappings.set(e, Promise.resolve(t));
+	}
+	async getAssetIdsToAssetMappingCacheItem(e) {
+		return await this._assetIdsToAssetMappings.get(e);
+	}
+	setAssetMappingsCacheItem(e, t) {
+		let n = this.getAssetIdsToAssetMappingCacheItem(e);
+		this.setAssetIdsToAssetMappingCacheItem(e, n.then((e) => e === void 0 ? [t] : (e.push(t), e)));
+	}
+};
+//#endregion
+export { e as ClassicCadAssetMappingPerAssetIdCache };

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

@@ -0,0 +1,18 @@
+import { CogniteClient } from '@cognite/sdk';
+import { ModelId, RevisionId, ModelRevisionKey } from '../types';
+import { HybridCadAssetMapping } from './assetMappingTypes';
+import { AssetMappingsPageResult } from './ClassicCadAssetMappingCache';
+export declare class ClassicCadAssetMappingPerModelCache {
+    private readonly _sdk;
+    private readonly _modelToAssetMappings;
+    private readonly _classicPageCache;
+    private readonly _dmPageCache;
+    private readonly _fullyLoadedModels;
+    constructor(sdk: CogniteClient);
+    private setModelToAssetMappingCacheItems;
+    getModelToAssetMappingCacheItems(key: ModelRevisionKey): Promise<HybridCadAssetMapping[] | undefined>;
+    fetchAssetMappingsPage(modelId: ModelId, revisionId: RevisionId, cursor?: string, isDmMappingsPage?: boolean): Promise<AssetMappingsPageResult>;
+    private getOrFetchPage;
+    fetchAndCacheMappingsForModel(modelId: ModelId, revisionId: RevisionId): Promise<HybridCadAssetMapping[]>;
+    private fetchAllMappingPages;
+}

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

@@ -0,0 +1,53 @@
+import { createModelRevisionKey as e } from "../idAndKeyTranslation.js";
+import { isDefined as t } from "../../../utilities/isDefined.js";
+import { convertToHybridAssetMapping as n } from "./rawAssetMappingTypes.js";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/ClassicCadAssetMappingPerModelCache.ts
+var r = class {
+	_sdk;
+	_modelToAssetMappings = /* @__PURE__ */ new Map();
+	_classicPageCache = /* @__PURE__ */ new Map();
+	_dmPageCache = /* @__PURE__ */ new Map();
+	_fullyLoadedModels = /* @__PURE__ */ new Set();
+	constructor(e) {
+		this._sdk = e;
+	}
+	setModelToAssetMappingCacheItems(e, t) {
+		this._modelToAssetMappings.set(e, t);
+	}
+	async getModelToAssetMappingCacheItems(e) {
+		return await this._modelToAssetMappings.get(e);
+	}
+	async fetchAssetMappingsPage(r, i, a, o = !1) {
+		let s = `${e(r, i)}|${a ?? ""}`, c = o ? this._dmPageCache : this._classicPageCache, l = await this.getOrFetchPage(c, s, () => this._sdk.assetMappings3D.list(r, i, {
+			limit: 1e3,
+			...a === void 0 ? {} : { cursor: a },
+			getDmsInstances: o
+		}));
+		return {
+			mappings: [...l.items].flatMap(n).filter(t),
+			nextCursor: l.nextCursor
+		};
+	}
+	getOrFetchPage(e, t, n) {
+		let r = e.get(t);
+		if (r !== void 0) return r;
+		let i = n();
+		return e.set(t, i), i;
+	}
+	async fetchAndCacheMappingsForModel(t, n) {
+		let r = e(t, n), i = await this.getModelToAssetMappingCacheItems(r);
+		if (i !== void 0) return i;
+		let a = await this.fetchAllMappingPages(t, n, !1), o = await this.fetchAllMappingPages(t, n, !0), s = [...a, ...o];
+		return this.setModelToAssetMappingCacheItems(r, Promise.resolve(s)), this._fullyLoadedModels.add(r), s;
+	}
+	async fetchAllMappingPages(e, t, n) {
+		let r = [], i;
+		do {
+			let { mappings: a, nextCursor: o } = await this.fetchAssetMappingsPage(e, t, i, n);
+			r.push(...a), i = o;
+		} while (i !== void 0);
+		return r;
+	}
+};
+//#endregion
+export { r as ClassicCadAssetMappingPerModelCache };

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

@@ -0,0 +1,8 @@
+import { ModelInstanceIdKey, ModelNodeIdKey } from '../types';
+import { HybridCadAssetMapping } from './assetMappingTypes';
+export declare class ClassicCadAssetMappingPerNodeIdCache {
+    private readonly _nodeIdsToAssetMappings;
+    setNodeIdsToAssetMappingCacheItem(key: ModelNodeIdKey | ModelInstanceIdKey, item: Promise<HybridCadAssetMapping[]>): void;
+    getNodeIdsToAssetMappingCacheItem(key: ModelNodeIdKey | ModelInstanceIdKey): Promise<HybridCadAssetMapping[] | undefined>;
+    setAssetMappingsCacheItem(key: ModelNodeIdKey | ModelInstanceIdKey, item: HybridCadAssetMapping): void;
+}

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

@@ -0,0 +1,16 @@
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/ClassicCadAssetMappingPerNodeIdCache.ts
+var e = class {
+	_nodeIdsToAssetMappings = /* @__PURE__ */ new Map();
+	setNodeIdsToAssetMappingCacheItem(e, t) {
+		this._nodeIdsToAssetMappings.set(e, Promise.resolve(t));
+	}
+	async getNodeIdsToAssetMappingCacheItem(e) {
+		return await this._nodeIdsToAssetMappings.get(e);
+	}
+	setAssetMappingsCacheItem(e, t) {
+		let n = this.getNodeIdsToAssetMappingCacheItem(e);
+		this.setNodeIdsToAssetMappingCacheItem(e, n.then((e) => e === void 0 ? [t] : (e.push(t), e)));
+	}
+};
+//#endregion
+export { e as ClassicCadAssetMappingPerNodeIdCache };

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

@@ -0,0 +1,12 @@
+import { Node3D, CogniteClient } from '@cognite/sdk';
+import { ModelId, RevisionId, ModelNodeIdKey } from '../types';
+export declare class ClassicCadNode3DPerNodeIdCache {
+    private readonly _sdk;
+    private readonly _nodeIdsToNode3D;
+    constructor(sdk: CogniteClient);
+    private splitChunkInCacheNode3D;
+    generateNode3DCachePerItem(modelId: ModelId, revisionId: RevisionId, nodeIds: number[] | undefined): Promise<void>;
+    getNodesForNodeIds(modelId: ModelId, revisionId: RevisionId, nodeIds: number[]): Promise<Node3D[]>;
+    getNodeIdToNode3DCacheItem(key: ModelNodeIdKey): Promise<Node3D | undefined>;
+    setNodeIdToNode3DCacheItem(key: ModelNodeIdKey, item: Promise<Node3D>): void;
+}

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

@@ -0,0 +1,38 @@
+import { createModelNodeIdKey as e } from "../idAndKeyTranslation.js";
+import { fetchNodesForNodeIds as t } from "../requests.js";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/ClassicCadNode3DPerNodeIdCache.ts
+var n = class {
+	_sdk;
+	_nodeIdsToNode3D = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this._sdk = e;
+	}
+	async splitChunkInCacheNode3D(t, n, r) {
+		let i = [], a = [];
+		return await Promise.all(t.map(async (t) => {
+			let o = e(n, r, t), s = await this.getNodeIdToNode3DCacheItem(o);
+			s === void 0 ? a.push(t) : i.push(s);
+		})), {
+			chunkInCache: i,
+			chunkNotInCache: a
+		};
+	}
+	async generateNode3DCachePerItem(t, n, r) {
+		(await this.getNodesForNodeIds(t, n, r ?? [])).forEach((r) => {
+			let i = e(t, n, r.id);
+			this.setNodeIdToNode3DCacheItem(i, Promise.resolve(r));
+		});
+	}
+	async getNodesForNodeIds(e, n, r) {
+		let { chunkNotInCache: i, chunkInCache: a } = await this.splitChunkInCacheNode3D(r, e, n), o = await t(e, n, i, this._sdk);
+		return a.concat(o);
+	}
+	async getNodeIdToNode3DCacheItem(e) {
+		return await this._nodeIdsToNode3D.get(e);
+	}
+	setNodeIdToNode3DCacheItem(e, t) {
+		this._nodeIdsToNode3D.set(e, Promise.resolve(t));
+	}
+};
+//#endregion
+export { n as ClassicCadNode3DPerNodeIdCache };

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

@@ -0,0 +1,8 @@
+import { DmsUniqueIdentifier } from '../../FdmSDK';
+import { FdmNodeDataPromises, ModelRevisionId, ModelRevisionToConnectionMap } from '../types';
+import { ThreeDModelFdmMappings } from './types';
+export type FdmCadNodeCache = {
+    getMappingsForFdmInstances: (instances: DmsUniqueIdentifier[], modelRevisionIds: ModelRevisionId[]) => Promise<ThreeDModelFdmMappings[]>;
+    getAllMappingExternalIds: (modelRevisionIds: ModelRevisionId[], fetchViews: boolean) => Promise<ModelRevisionToConnectionMap>;
+    getClosestParentDataPromises: (modelId: number, revisionId: number, treeIndex: number) => FdmNodeDataPromises;
+};

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

@@ -0,0 +1,11 @@
+import { CogniteClient } from '@cognite/sdk';
+import { Fdm3dDataProvider } from '../../Fdm3dDataProvider';
+import { fetchNodesForNodeIds, inspectNodes, treeIndexesToNodeIds } from '../requests';
+import { FdmCadNodeCache } from './FdmCadNodeCache';
+export type FdmCadNodeCacheDeps = {
+    treeIndexesToNodeIds: typeof treeIndexesToNodeIds;
+    fetchNodesForNodeIds: typeof fetchNodesForNodeIds;
+    inspectNodes: typeof inspectNodes;
+};
+export declare const defaultFdmCadNodeCacheDeps: FdmCadNodeCacheDeps;
+export declare function createFdmCadNodeCache(cdfClient: CogniteClient, fdm3dDataProvider: Fdm3dDataProvider, deps?: FdmCadNodeCacheDeps): FdmCadNodeCache;

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

@@ -0,0 +1,218 @@
+import { createFdmKey as e, createModelRevisionKey as t, createModelTreeIndexKey as n, revisionKeyToIds as r } from "../idAndKeyTranslation.js";
+import { FdmSDK as i } from "../../FdmSDK.js";
+import { concatenateMapValues as a } from "../../../utilities/map/concatenateMapValues.js";
+import { concatenateMapListValues as o } from "../../../utilities/map/mergeMapMapValues.js";
+import { fetchNodesForNodeIds as s, inspectNodes as c, treeIndexesToNodeIds as l } from "../requests.js";
+import { isFdmCadConnectionWithNodeData as u, normalizeToSlimCadNode as d } from "../../utils/cadNodeConnectionFields.js";
+import { RevisionFdmNodeCache as f } from "../RevisionFdmNodeCache.js";
+import { enrichCadNodeMappingsWithBoundingBoxes as p } from "./enrichCadNodeMappingsWithBoundingBoxes.js";
+import { partition as m } from "lodash-es";
+import { assert as h } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/data-providers/cache/cad/FdmCadNodeCacheImpl.ts
+var g = {
+	treeIndexesToNodeIds: l,
+	fetchNodesForNodeIds: s,
+	inspectNodes: c
+};
+function _(e, t, n = g) {
+	return new v(e, t, n);
+}
+var v = class {
+	_revisionNodeCaches = /* @__PURE__ */ new Map();
+	_cdfClient;
+	_fdmClient;
+	_fdm3dDataProvider;
+	_deps;
+	_completeRevisions = /* @__PURE__ */ new Set();
+	constructor(e, t, n = g) {
+		this._cdfClient = e, this._fdmClient = new i(e), this._fdm3dDataProvider = t, this._deps = n;
+	}
+	async getMappingsForFdmInstances(e, n) {
+		let [r, i] = m(n, (e) => {
+			let n = t(e.modelId, e.revisionId);
+			return this._completeRevisions.has(n);
+		}), a = await this.getNonCachedModelMappings(e, i), o = [...this.getCachedModelMappings(r, e), ...a];
+		return p(o, this._cdfClient);
+	}
+	getCachedModelMappings(t, n) {
+		let r = new Set(n.map(e));
+		return t.map((e) => this.getCachedModelMappingForRevision(e, r));
+	}
+	getCachedModelMappingForRevision(t, n) {
+		let r = E(this.getOrCreateRevisionCache(t.modelId, t.revisionId).getAllConnections(), n), i = a(r.map((t) => [e(t.connection.instance), t.cadNode]));
+		return {
+			...t,
+			mappings: i
+		};
+	}
+	async getNonCachedModelMappings(n, r) {
+		if (r.length === 0 || n.length === 0) return [];
+		let i = new Set(n.map(e)), a = await this.fetchInstanceScopedConnections(n, r);
+		return r.map(({ modelId: e, revisionId: n }) => {
+			let r = t(e, n), o = a.get(r);
+			return this.getRelevantExternalIdToNodeMapForRevision({
+				modelId: e,
+				revisionId: n
+			}, o, i);
+		});
+	}
+	getRelevantExternalIdToNodeMapForRevision({ modelId: t, revisionId: n }, r, i) {
+		if (r === void 0 || r.length === 0) return {
+			modelId: t,
+			revisionId: n,
+			mappings: /* @__PURE__ */ new Map()
+		};
+		let o = E(r, i);
+		return {
+			modelId: t,
+			revisionId: n,
+			mappings: a(o.map((t) => [e(t.connection.instance), t.cadNode]))
+		};
+	}
+	async getAllMappingExternalIds(e, n = !1) {
+		let [r, i] = m(e, (e) => {
+			let n = t(e.modelId, e.revisionId);
+			return this._completeRevisions.has(n);
+		});
+		n && await this.fetchAllViewsForCachedRevisions(r);
+		let a = r.map((e) => this.getCachedConnectionsForRevision(e)), o = await this.getAndCacheRevisionToConnectionsMap(i, n);
+		return a.forEach(([e, t]) => {
+			o.set(e, t);
+		}), o;
+	}
+	async fetchAllViewsForCachedRevisions(e) {
+		for (let t of e) await this.getOrCreateRevisionCache(t.modelId, t.revisionId).fetchViewsForAllConnections();
+	}
+	getCachedConnectionsForRevision(e) {
+		let n = this.getOrCreateRevisionCache(e.modelId, e.revisionId);
+		return [t(e.modelId, e.revisionId), n.getAllConnections()];
+	}
+	writeRevisionDataToCache(e, t) {
+		for (let [n, i] of e.entries()) {
+			let [e, a] = r(n), o = this.getOrCreateRevisionCache(e, a);
+			i.forEach((e) => {
+				o.insertTreeIndexMappings(e.cadNode.treeIndex, e);
+			}), t && this._completeRevisions.add(n);
+		}
+	}
+	async fetchInstanceScopedConnections(t, n) {
+		if (this._fdm3dDataProvider.getCadConnectionsForInstances === void 0) return this.getAndCacheRevisionToConnectionsMap(n, !1);
+		let r = new Set(t.map(e)), i = this.collectCachedConnectionsAndFetchPlan(t, n, r);
+		if (i.revisionsToFetch.length === 0) return i.cachedByRevision;
+		let a = t.filter((t) => i.instancesToFetchKeys.has(e(t))), s = i.revisionsToFetch.map((e) => ({
+			...e,
+			sourceType: "classic"
+		})), c = await this._fdm3dDataProvider.getCadConnectionsForInstances(a, s), l = D(await this.cacheFetchedConnectionsForInstances(c, i.revisionsToFetch), i.cachedByRevision);
+		return o([...i.cachedByRevision.entries(), ...l]);
+	}
+	collectCachedConnectionsAndFetchPlan(n, r, i) {
+		let a = /* @__PURE__ */ new Map(), o = [], s = /* @__PURE__ */ new Set();
+		for (let c of r) {
+			let r = t(c.modelId, c.revisionId), l = E(this.getOrCreateRevisionCache(c.modelId, c.revisionId).getAllConnections(), i), u = new Set(l.map((t) => e(t.connection.instance))), d = n.filter((t) => !u.has(e(t)));
+			l.length > 0 && a.set(r, l), d.length > 0 && (o.push(c), d.forEach((t) => s.add(e(t))));
+		}
+		return {
+			cachedByRevision: a,
+			revisionsToFetch: o,
+			instancesToFetchKeys: s
+		};
+	}
+	async cacheFetchedConnectionsForInstances(e, t) {
+		let n = await y(e.map((e) => ({ connection: e })), t, this._cdfClient, this._deps);
+		return this.writeRevisionDataToCache(n, !1), n;
+	}
+	async getAndCacheRevisionToConnectionsMap(e, t) {
+		let n = e.map((e) => ({
+			...e,
+			sourceType: "classic"
+		})), r = await this._fdm3dDataProvider.getCadConnectionsForRevisions(n), i = await y(t ? await this.getViewsForConnections(r) : r.map((e) => ({ connection: e })), e, this._cdfClient, this._deps);
+		return this.writeRevisionDataToCache(i, !0), i;
+	}
+	getClosestParentDataPromises(e, t, n) {
+		return this.getOrCreateRevisionCache(e, t).getClosestParentFdmData(n);
+	}
+	async getViewsForConnections(e) {
+		let t = await this._deps.inspectNodes(this._fdmClient, e.map((e) => e.instance));
+		return e.map((e, n) => ({
+			connection: e,
+			views: t.items[n].inspectionResults.involvedViews
+		}));
+	}
+	getOrCreateRevisionCache(e, n) {
+		let r = t(e, n), i = this._revisionNodeCaches.get(r);
+		if (i !== void 0) return i;
+		let a = new f(this._cdfClient, this._fdmClient, this._fdm3dDataProvider, e, n);
+		return this._revisionNodeCaches.set(r, a), a;
+	}
+};
+async function y(e, t, n, r) {
+	let [i, a] = m(e, (e) => u(e.connection)), o = new Map([...S(i, t), ...await C(a, t, n, r)]);
+	return e.reduce((e, n) => {
+		let r = n.connection.revisionId, i = t.find((e) => e.revisionId === r);
+		return i === void 0 || x(b(i, o, n.connection, n.views), e, i), e;
+	}, /* @__PURE__ */ new Map());
+}
+function b(e, t, r, i) {
+	let a = n(e.modelId, e.revisionId, r.treeIndex), o = t.get(a);
+	return h(o !== void 0), {
+		connection: r,
+		cadNode: o,
+		views: i
+	};
+}
+function x(e, n, r) {
+	let i = t(r.modelId, r.revisionId), a = n.get(i);
+	a === void 0 ? n.set(i, [e]) : a.push(e);
+}
+function S(e, t) {
+	let r = /* @__PURE__ */ new Map();
+	for (let { connection: i } of e) {
+		let e = t.find((e) => e.revisionId === i.revisionId);
+		if (e === void 0) continue;
+		let a = n(e.modelId, e.revisionId, i.treeIndex);
+		r.set(a, {
+			id: i.nodeId,
+			treeIndex: i.treeIndex,
+			subtreeSize: i.subtreeSize
+		});
+	}
+	return r;
+}
+async function C(e, t, n, r) {
+	let i = /* @__PURE__ */ new Map();
+	for (let { connection: t } of e) {
+		let e = i.get(t.revisionId);
+		e === void 0 ? i.set(t.revisionId, [t]) : e.push(t);
+	}
+	let a = [...i.entries()].map(([e, i]) => w(e, i, t, n, r)), o = await Promise.all(a);
+	return new Map(o.flatMap((e) => [...e.entries()]));
+}
+async function w(e, t, r, i, a) {
+	let o = /* @__PURE__ */ new Map(), s = T(r, e), [c, l] = m(t, (e) => e.nodeId !== void 0), u = [];
+	l.length > 0 && (u = await a.treeIndexesToNodeIds(s, e, l.map((e) => e.treeIndex), i));
+	let f = [.../* @__PURE__ */ new Set([...c.map((e) => e.nodeId), ...u])];
+	if (f.length === 0) return o;
+	let p = await a.fetchNodesForNodeIds(s, e, f, i), h = new Map(p.map((e) => [e.id, e])), g = new Map(p.map((e) => [e.treeIndex, e]));
+	for (let r of t) {
+		let t = r.nodeId === void 0 ? g.get(r.treeIndex) : h.get(r.nodeId);
+		t !== void 0 && o.set(n(s, e, r.treeIndex), d(t));
+	}
+	return o;
+}
+function T(e, t) {
+	let n = e.find((e) => e.revisionId === t)?.modelId;
+	return h(n !== void 0, `ModelId not found for revisionId: ${t}`), n;
+}
+function E(t, n) {
+	return t.filter((t) => n.has(e(t.connection.instance)));
+}
+function D(t, n) {
+	return [...t.entries()].map(([t, r]) => {
+		let i = n.get(t);
+		if (i === void 0) return [t, r];
+		let a = new Set(i.map((t) => e(t.connection.instance)));
+		return [t, r.filter((t) => !a.has(e(t.connection.instance)))];
+	});
+}
+//#endregion
+export { _ as createFdmCadNodeCache, g as defaultFdmCadNodeCacheDeps };