@cognite/reveal-components 1.0.0

package/dist/data-providers/network/common/getResourceIdentifierWithType.js

@@ -0,0 +1,29 @@
+import { isClassicModelIdentifier as e } from "../../../utilities/instanceIds/typeGuards.js";
+import "../../../utilities/instanceIds/index.js";
+import { getModelIdAndRevisionIdFromExternalId as t } from "./getModelIdAndRevisionIdFromExternalId.js";
+import { assert as n } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/data-providers/network/common/getResourceIdentifierWithType.ts
+var r = { getModelIdAndRevisionIdFromExternalId: t };
+async function i(t, a, o, s = r) {
+	if (e(t)) {
+		let e = await a.determineModelType(t.modelId, t.revisionId);
+		if (e !== "cad" && e !== "pointcloud") throw Error(`Unknown model type for ID  ${JSON.stringify(t)}`);
+		return {
+			sourceType: "classic",
+			modelId: t.modelId,
+			revisionId: t.revisionId,
+			type: e
+		};
+	}
+	{
+		let e = await i(await s.getModelIdAndRevisionIdFromExternalId(t.revisionExternalId, t.revisionSpace, o), a, o, s);
+		return n(e.type === "cad" || e.type === "pointcloud"), {
+			externalId: t.revisionExternalId,
+			space: t.revisionSpace,
+			type: e.type,
+			sourceType: "cdm"
+		};
+	}
+}
+//#endregion
+export { r as defaultGetResourceIdentifierWithTypeDependencies, i as getResourceIdentifierWithType };

package/dist/data-providers/network/common/getTypedModels.d.ts

@@ -0,0 +1,6 @@
+import { AddModelOptions, ClassicDataSourceType, Cognite3DViewer, DataSourceType } from '@cognite/reveal';
+import { AddResourceOptions, TypedReveal3DModel } from '../../../utilities/modelIds/types';
+import { Model3DAddOptions } from '../../types/resources';
+type ViewerWithModelType = Pick<Cognite3DViewer<DataSourceType>, 'determineModelType'>;
+export declare const getTypedModels: <T extends DataSourceType = ClassicDataSourceType>(classicModelOptions: Array<AddModelOptions>, viewer: ViewerWithModelType, cadOrPointCloudResources: Model3DAddOptions[], onLoadFail?: (resource: AddResourceOptions, error: Error) => void) => Promise<TypedReveal3DModel<T>[]>;
+export {};

package/dist/data-providers/network/common/getTypedModels.js

@@ -0,0 +1,37 @@
+//#region libs/shared/reveal-components/src/data-providers/network/common/getTypedModels.ts
+var e = async (e, n, r, i) => {
+	let a = i ?? t, o = e.map(async (e, t) => {
+		let { modelId: i, revisionId: o } = e, s = r[t], c = await n.determineModelType(i, o).catch((t) => {
+			a(e, t);
+		}), l = {
+			modelId: i,
+			revisionId: o,
+			transform: s.transform,
+			styling: s.styling,
+			defaultVisible: s.defaultVisible
+		};
+		if (c === "cad") return s.sourceType === "cdm" ? {
+			...l,
+			revisionExternalId: s.externalId,
+			revisionSpace: s.space,
+			type: "cad"
+		} : {
+			...l,
+			type: "cad"
+		};
+		if (c === "pointcloud") return s.sourceType === "cdm" ? {
+			...l,
+			revisionExternalId: s.externalId,
+			revisionSpace: s.space,
+			type: "pointcloud"
+		} : {
+			...l,
+			type: "pointcloud"
+		};
+	});
+	return (await Promise.all(o)).filter((e) => e !== void 0);
+}, t = (e, t) => {
+	console.warn(`Could not load resource ${JSON.stringify(e)}: ${JSON.stringify(t)}`);
+};
+//#endregion
+export { e as getTypedModels };

package/dist/data-providers/network/common/modelIdentifierHelper.d.ts

@@ -0,0 +1,5 @@
+import { Model3D, TableExpressionEqualsFilterV3 } from '@cognite/sdk';
+import { LatestRevisionInfoResponse, ModelWithRevisionInfo } from '../../../ui/hooks/network/types';
+export declare function getNodeExternalIdEqualsFilter<T extends string>(externalId: T): TableExpressionEqualsFilterV3;
+export declare function getNodeSpaceEqualsFilter<T extends string>(space: T): TableExpressionEqualsFilterV3;
+export declare function mapModelsToRevisionInfo(models: Array<Model3D & LatestRevisionInfoResponse>): ModelWithRevisionInfo[];

package/dist/data-providers/network/common/modelIdentifierHelper.js

@@ -0,0 +1,15 @@
+//#region libs/shared/reveal-components/src/data-providers/network/common/modelIdentifierHelper.ts
+function e(e) {
+	return { equals: {
+		property: ["node", "externalId"],
+		value: e
+	} };
+}
+function t(e) {
+	return { equals: {
+		property: ["node", "space"],
+		value: e
+	} };
+}
+//#endregion
+export { e as getNodeExternalIdEqualsFilter, t as getNodeSpaceEqualsFilter };

package/dist/data-providers/network/common/searchDmInstances.d.ts

@@ -0,0 +1,13 @@
+import { ViewDefinition, CogniteClient } from '@cognite/sdk';
+import { InstanceReferenceKey } from '../../../utilities/instanceIds';
+import { DMSearchOptions, NodeItem } from '../../FdmSDK';
+export type DmSearchResult = {
+    instances: NodeItem[];
+    instanceKeyToInstanceMap: Map<InstanceReferenceKey, NodeItem>;
+};
+/**
+ * Performs a DM instance search and returns both the instances and a lookup map.
+ * This function should be called once and the result shared across multiple resource types
+ * to avoid redundant search calls.
+ */
+export declare function searchDmInstances(view: ViewDefinition, options: DMSearchOptions, sdk: CogniteClient): Promise<DmSearchResult>;

package/dist/data-providers/network/common/searchDmInstances.js

@@ -0,0 +1,13 @@
+import { createFdmKey as e } from "../../cache/idAndKeyTranslation.js";
+import { FdmSDK as t } from "../../FdmSDK.js";
+import { restrictToViewReference as n } from "../../../utilities/restrictToViewReference.js";
+//#region libs/shared/reveal-components/src/data-providers/network/common/searchDmInstances.ts
+async function r(r, i, a) {
+	let o = await new t(a).searchInstances(n(r), "node", i), s = new Map(o.instances.map((t) => [e(t), t]));
+	return {
+		instances: o.instances,
+		instanceKeyToInstanceMap: s
+	};
+}
+//#endregion
+export { r as searchDmInstances };

package/dist/data-providers/network/getAssetMappedPointCloudAnnotations.d.ts

@@ -0,0 +1,11 @@
+import { CogniteClient } from '@cognite/sdk';
+import { AssetInstance } from '../../utilities/instances';
+import { FdmSDK } from '../FdmSDK';
+import { Classic3DResourceIdentifier } from '../types/resources';
+import { AllAssetFilterProps } from './common/filters';
+import { getAssetsForIds } from './common/getAssetsForIds';
+type AssetMappedPointCloudAnnotationsDependencies = {
+    getAssetsByIds: typeof getAssetsForIds;
+};
+export declare function getAssetsMappedPointCloudAnnotations(models: Classic3DResourceIdentifier[], filters: AllAssetFilterProps | undefined, sdk: CogniteClient, fdmSdk?: FdmSDK, dependencies?: AssetMappedPointCloudAnnotationsDependencies): Promise<AssetInstance[]>;
+export {};

package/dist/data-providers/network/getAssetMappedPointCloudAnnotations.js

@@ -0,0 +1,41 @@
+import { createFdmKey as e } from "../cache/idAndKeyTranslation.js";
+import { COGNITE_ASSET_SOURCE as t, COGNITE_ASSET_VIEW_VERSION_KEY as n, CORE_DM_SPACE as r } from "../core-dm-provider/dataModels.js";
+import { getAssetsForIds as i } from "./common/getAssetsForIds.js";
+import { toIdEither as a } from "../../utilities/instanceIds/toIdEither.js";
+import { isPointCloudAnnotationModel as o } from "../cache/typeGuards.js";
+import { chunk as s, uniq as c, uniqBy as l } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/getAssetMappedPointCloudAnnotations.ts
+async function u(e, t, n, r, i) {
+	let a = await d(e.map((e) => e.modelId), n), o = await f(a, t, n, i), s = r === void 0 ? [] : await p(a, r);
+	return [...o, ...s];
+}
+async function d(e, t) {
+	return (await Promise.all(s(e, 1e3).map(async (e) => {
+		let n = {
+			annotatedResourceIds: e.map((e) => ({ id: e })),
+			annotatedResourceType: "threedmodel",
+			annotationType: "pointcloud.BoundingVolume"
+		};
+		return await t.annotations.list({
+			filter: n,
+			limit: 1e3
+		}).autoPagingToArray({ limit: Infinity });
+	}))).flatMap((e) => e.filter(o));
+}
+async function f(e, t, n, r) {
+	let { getAssetsByIds: o } = r ?? { getAssetsByIds: i }, s = e.map((e) => e.data.assetRef?.id ?? e.data.assetRef?.externalId).filter((e) => e !== void 0);
+	return await o(c(s).map(a), t, n);
+}
+async function p(i, a) {
+	let o = i.map((e) => e.data.instanceRef).filter((e) => e !== void 0), s = l(o, e);
+	return (await a.getByExternalIds(s.filter((e) => e.sources.some((e) => e.externalId === t.externalId && e.space === t.space && e.version === t.version)).map((e) => ({
+		externalId: e.externalId,
+		space: e.space,
+		instanceType: e.instanceType
+	})), [t])).items.map((e) => ({
+		...e,
+		properties: e.properties[r][n]
+	}));
+}
+//#endregion
+export { u as getAssetsMappedPointCloudAnnotations };

package/dist/data-providers/network/getClassicAssetMapped360Annotations.d.ts

@@ -0,0 +1,8 @@
+import { Image360AnnotationFilterOptions } from '@cognite/reveal';
+import { CogniteClient } from '@cognite/sdk';
+import { HybridImage360AnnotationMappedData } from '../cache/cad/types';
+import { AllAssetFilterProps } from './common/filters';
+export declare function getClassicAssetMapped360Annotations(siteIds: string[], filterOptions: {
+    assetFilters?: AllAssetFilterProps | undefined;
+    image360AnnotationFilterOptions: Image360AnnotationFilterOptions;
+}, sdk: CogniteClient): Promise<HybridImage360AnnotationMappedData[]>;

package/dist/data-providers/network/getClassicAssetMapped360Annotations.js

@@ -0,0 +1,75 @@
+import { isAnnotationInstanceRef as e, isClassicImage360AssetAnnotationData as t } from "../../utilities/image360Annotations/typeGuards.js";
+import { isIdEither as n } from "../../utilities/instanceIds/typeGuards.js";
+import { isSameAssetReference as r } from "../../utilities/instanceIds/equality.js";
+import { createInstanceReferenceKey as i } from "../../utilities/instanceIds/toKey.js";
+import "../../utilities/instanceIds/index.js";
+import { getImage360AnnotationAssetRef as a } from "../../utilities/image360Annotations/getImage360AnnotationAssetRef.js";
+import "../../utilities/image360Annotations/index.js";
+import { FdmSDK as o } from "../FdmSDK.js";
+import { isDefined as s } from "../../utilities/isDefined.js";
+import { getAssetsForIds as c } from "./common/getAssetsForIds.js";
+import { getDMAssetsForAnnotationReference as l } from "./common/getDMAssetsForAnnotationReference.js";
+import { chunk as u, uniqBy as d } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/getClassicAssetMapped360Annotations.ts
+var f = 5, p = 5;
+async function m(e, t, n) {
+	return await h(await y(await v(e, n), n, t.image360AnnotationFilterOptions), t.assetFilters, n);
+}
+async function h(t, r, a) {
+	let u = t.map(g).filter(s), f = d(u, (e) => i(e.assetReference)), p = await c(f.map((e) => e.assetReference).filter(n), r, a), m = new o(a), h = f.map((e) => e.assetReference).filter((t) => e(t)), v = await l(h, m);
+	return _([...p, ...v], u);
+}
+function g(e) {
+	let t = a(e);
+	if (t !== void 0) return {
+		assetReference: t,
+		annotationId: e.id
+	};
+}
+function _(e, t) {
+	let n = [];
+	return e.forEach((e) => {
+		let i = t.find((t) => r(t.assetReference, e));
+		if (i !== void 0) {
+			let t = n.find((t) => r(t.asset, e));
+			t === void 0 ? n.push({
+				asset: e,
+				annotationIds: [i.annotationId]
+			}) : t.annotationIds.push(i.annotationId);
+		}
+	}), n;
+}
+async function v(e, t) {
+	let n = [], r = u(e, p);
+	for (let e of r) {
+		let r = e.map(async (e) => await b({ metadata: { site_id: e } }, t)), i = await Promise.all(r);
+		n.push(...i.flat());
+	}
+	return n;
+}
+async function y(e, n, r) {
+	let i = u(e, 1e3), a = [];
+	for (let e of u(i, f)) {
+		let i = e.map(async (e) => {
+			let i = {
+				annotatedResourceIds: e.map((e) => ({ id: e })),
+				annotatedResourceType: "file"
+			};
+			return (await n.annotations.list({
+				filter: i,
+				limit: 1e3
+			}).autoPagingToArray({ limit: Infinity })).filter((e) => e.status === r.status || r.status === "all").filter((e) => t(e.data));
+		}), o = await Promise.all(i);
+		a.push(...o.flat());
+	}
+	return a;
+}
+async function b(e, t) {
+	let n = {
+		filter: e,
+		limit: 1e3
+	};
+	return (await t.files.list(n).autoPagingToArray({ limit: Infinity })).map((e) => e.id);
+}
+//#endregion
+export { m as getClassicAssetMapped360Annotations };

package/dist/data-providers/network/image360/searchHybridDmImage360AssetMappingsWithFilters.d.ts

@@ -0,0 +1,5 @@
+import { Image360AnnotationCache } from '../../cache/Image360AnnotationCache';
+import { NodeItem } from '../../FdmSDK';
+import { DmSearchResult } from '../common/searchDmInstances';
+export type Image360CollectionId = string;
+export declare function searchHybridDmImage360AssetMappingsWithFilters(collectionIds: Image360CollectionId[], searchResult: DmSearchResult, image360AnnotationCache: Image360AnnotationCache): Promise<NodeItem[]>;

package/dist/data-providers/network/image360/searchHybridDmImage360AssetMappingsWithFilters.js

@@ -0,0 +1,19 @@
+import { createFdmKey as e } from "../../cache/idAndKeyTranslation.js";
+import { createInstanceReferenceKey as t } from "../../../utilities/instanceIds/toKey.js";
+import { chunk as n } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/image360/searchHybridDmImage360AssetMappingsWithFilters.ts
+var r = 10;
+async function i(i, a, o) {
+	if (i.length === 0) return [];
+	let { instances: s, instanceKeyToInstanceMap: c } = a, l = /* @__PURE__ */ new Map();
+	for (let a of n(i, r)) {
+		let n = await o.getReveal360AnnotationsForAssets(a, s);
+		[...new Set(n.map((e) => t(e.asset)))].forEach((t) => {
+			let n = c.get(t);
+			n !== void 0 && l.set(e(n), n);
+		});
+	}
+	return Array.from(l.values());
+}
+//#endregion
+export { i as searchHybridDmImage360AssetMappingsWithFilters };

package/dist/data-providers/network/pointcloud/searchHybridDmPointCloudAssetMappingsWithFilters.d.ts

@@ -0,0 +1,5 @@
+import { PointCloudAnnotationCache } from '../../cache/PointCloudAnnotationCache';
+import { ModelRevisionId } from '../../cache/types';
+import { NodeItem } from '../../FdmSDK';
+import { DmSearchResult } from '../common/searchDmInstances';
+export declare function searchHybridDmPointCloudAssetMappingsWithFilters(models: ModelRevisionId[], assetMappingAndAnnotationCache: PointCloudAnnotationCache, searchResult: DmSearchResult): Promise<NodeItem[]>;

package/dist/data-providers/network/pointcloud/searchHybridDmPointCloudAssetMappingsWithFilters.js

@@ -0,0 +1,18 @@
+import { createFdmKey as e } from "../../cache/idAndKeyTranslation.js";
+import { isDefined as t } from "../../../utilities/isDefined.js";
+import { chunk as n } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/pointcloud/searchHybridDmPointCloudAssetMappingsWithFilters.ts
+var r = 10;
+async function i(i, a, o) {
+	if (i.length === 0) return [];
+	let { instances: s, instanceKeyToInstanceMap: c } = o, l = /* @__PURE__ */ new Map();
+	for (let o of n(i, r)) {
+		let n = o.map(async (e) => await a.getPointCloudAnnotationsForInstanceIds(e.modelId, e.revisionId, s)), r = await Promise.all(n);
+		[...new Set(r.flatMap((e) => [...e.keys()]))].map((e) => c.get(e)).filter(t).forEach((t) => {
+			l.set(e(t), t);
+		});
+	}
+	return Array.from(l.values());
+}
+//#endregion
+export { i as searchHybridDmPointCloudAssetMappingsWithFilters };

package/dist/data-providers/network/pointcloud/searchHybridPointCloudDmAssetsForModels.d.ts

@@ -0,0 +1,10 @@
+import { PointCloudAnnotationCache } from '../../cache/PointCloudAnnotationCache';
+import { NodeItem } from '../../FdmSDK';
+import { ThreeDResourceIdentifier } from '../../types/resources';
+import { DmSearchResult } from '../common/searchDmInstances';
+import { searchHybridDmPointCloudAssetMappingsWithFilters } from './searchHybridDmPointCloudAssetMappingsWithFilters';
+type SearchHybridDmAssetsForPointModelDependency = {
+    searchHybridDmPointCloudAssetMappingsWithFilters: typeof searchHybridDmPointCloudAssetMappingsWithFilters;
+};
+export declare function searchHybridPointCloudDmAssetsForModels(resources: ThreeDResourceIdentifier[], pointCloudAnnotationCache: PointCloudAnnotationCache, searchResult: DmSearchResult, dependencies?: SearchHybridDmAssetsForPointModelDependency): Promise<NodeItem[]>;
+export {};

package/dist/data-providers/network/pointcloud/searchHybridPointCloudDmAssetsForModels.js

@@ -0,0 +1,9 @@
+import { searchHybridDmPointCloudAssetMappingsWithFilters as e } from "./searchHybridDmPointCloudAssetMappingsWithFilters.js";
+//#region libs/shared/reveal-components/src/data-providers/network/pointcloud/searchHybridPointCloudDmAssetsForModels.ts
+var t = { searchHybridDmPointCloudAssetMappingsWithFilters: e };
+async function n(e, n, r, i = t) {
+	let { searchHybridDmPointCloudAssetMappingsWithFilters: a } = i;
+	return await a(e.filter((e) => e.type === "pointcloud" && e.sourceType === "classic"), n, r);
+}
+//#endregion
+export { n as searchHybridPointCloudDmAssetsForModels };

package/dist/data-providers/network/searchClassicAssetsForModels.d.ts

@@ -0,0 +1,17 @@
+import { CogniteClient } from '@cognite/sdk';
+import { RevealRenderTarget } from '../../domains';
+import { FdmSDK } from '../FdmSDK';
+import { ThreeDResourceIdentifier } from '../types/resources';
+import { SearchClassicCadAssetsResponse } from './cad/types';
+import { AllAssetFilterProps } from './common/filters';
+export type SearchQueryOptions = {
+    limit: number;
+    cadAssetsCursor?: string;
+    /**
+     * This contains both a `filter` and an `advancedFilter` field, which correspond
+     * to the fields of the same name that are used in the asset-filter endpoint
+     * https://api-docs.cognite.com/20230101/tag/Assets/operation/listAssets
+     */
+    filters?: AllAssetFilterProps;
+};
+export declare function searchClassicAssetsForModels(resources: ThreeDResourceIdentifier[], { limit, cadAssetsCursor, filters }: SearchQueryOptions, sdk: CogniteClient, renderTarget: RevealRenderTarget, fdmSDK?: FdmSDK): Promise<SearchClassicCadAssetsResponse>;

package/dist/data-providers/network/searchClassicAssetsForModels.js

@@ -0,0 +1,20 @@
+import { isClassicAsset as e } from "../../utilities/instances/typeGuards.js";
+import "../../utilities/instances/index.js";
+import { getAssetsMappedPointCloudAnnotations as t } from "./getAssetMappedPointCloudAnnotations.js";
+import { searchClassicAssetsForCadModels as n } from "./cad/searchClassicAssetsForCadModels.js";
+import { searchClassicImage360Assets as r } from "./searchClassicImage360Assets.js";
+import { uniqBy as i } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/searchClassicAssetsForModels.ts
+async function a(a, { limit: o, cadAssetsCursor: s, filters: c }, l, u, d) {
+	let f = s === void 0, p = u.cdfCaches.classicCadAssetMappingCache, m = a.filter((e) => e.type === "cad" && e.sourceType === "classic"), h = a.filter((e) => e.type === "pointcloud" && e.sourceType === "classic"), g = a.filter((e) => e.type === "image360"), _ = n(m, 1e3, s, c, l, p), v = f ? t(h, c, l, d) : Promise.resolve([]), y = f ? r(g, c, o, l) : Promise.resolve([]), { nextCursor: b, data: x } = await _, S = await v, C = await y, w = S.filter((t) => e(t)), T = C.filter((t) => e(t));
+	return {
+		nextCursor: b,
+		data: i([
+			...x,
+			...w,
+			...T
+		], (e) => e.id)
+	};
+}
+//#endregion
+export { a as searchClassicAssetsForModels };

package/dist/data-providers/network/searchClassicImage360Assets.d.ts

@@ -0,0 +1,5 @@
+import { CogniteClient } from '@cognite/sdk';
+import { AssetInstance } from '../../utilities/instances';
+import { Image360ResourceIdentifier } from '../types/resources';
+import { AllAssetFilterProps } from './common/filters';
+export declare function searchClassicImage360Assets(image360s: Image360ResourceIdentifier[], assetFilters: AllAssetFilterProps | undefined, limit: number, sdk: CogniteClient): Promise<AssetInstance[]>;

package/dist/data-providers/network/searchClassicImage360Assets.js

@@ -0,0 +1,12 @@
+import { getClassicAssetMapped360Annotations as e } from "./getClassicAssetMapped360Annotations.js";
+import { partition as t, take as n } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/searchClassicImage360Assets.ts
+async function r(r, i, a, o) {
+	let [s, c] = t(r, (e) => e.sourceType === "events"), l = [...s.map((e) => e.siteId), ...c.map((e) => e.externalId)], u = await e(l, {
+		assetFilters: i,
+		image360AnnotationFilterOptions: { status: "approved" }
+	}, o);
+	return n(u, a).map((e) => e.asset);
+}
+//#endregion
+export { r as searchClassicImage360Assets };

package/dist/data-providers/network/searchHybridDmAssetsForModels.d.ts

@@ -0,0 +1,14 @@
+import { ViewDefinition, CogniteClient } from '@cognite/sdk';
+import { ClassicCadAssetMappingCache } from '../cache/cad/ClassicCadAssetMappingCache';
+import { Image360AnnotationCache } from '../cache/Image360AnnotationCache';
+import { PointCloudAnnotationCache } from '../cache/PointCloudAnnotationCache';
+import { DMSearchOptions, NodeItem } from '../FdmSDK';
+import { ThreeDResourceIdentifier } from '../types/resources';
+import { searchDmInstances } from './common/searchDmInstances';
+export type DMSView = {
+    rawView: ViewDefinition;
+};
+export type SearchHybridDmAssetsForModelsDependencies = {
+    searchDmInstances: typeof searchDmInstances;
+};
+export declare function searchHybridDmAssetsForModels(resources: ThreeDResourceIdentifier[], view: DMSView, options: DMSearchOptions, sdk: CogniteClient, classicCadCache: ClassicCadAssetMappingCache, pointCloudAnnotationCache: PointCloudAnnotationCache, image360Cache: Image360AnnotationCache, dependencies?: SearchHybridDmAssetsForModelsDependencies): Promise<NodeItem[]>;

package/dist/data-providers/network/searchHybridDmAssetsForModels.js

@@ -0,0 +1,21 @@
+import { createFdmKey as e } from "../cache/idAndKeyTranslation.js";
+import { isDefined as t } from "../../utilities/isDefined.js";
+import { searchHybridDmAssetsForCadModels as n } from "./cad/searchHybridDmAssetsForCadModels.js";
+import { searchDmInstances as r } from "./common/searchDmInstances.js";
+import { searchHybridDmImage360AssetMappingsWithFilters as i } from "./image360/searchHybridDmImage360AssetMappingsWithFilters.js";
+import { searchHybridPointCloudDmAssetsForModels as a } from "./pointcloud/searchHybridPointCloudDmAssetsForModels.js";
+import { uniqBy as o } from "lodash-es";
+//#region libs/shared/reveal-components/src/data-providers/network/searchHybridDmAssetsForModels.ts
+var s = { searchDmInstances: r };
+async function c(r, c, l, u, d, f, p, m = s) {
+	let { searchDmInstances: h } = m;
+	if (r.length === 0) return [];
+	let g = c.rawView, _ = r.filter((e) => e.type === "cad" && e.sourceType === "classic"), v = r.filter((e) => e.type === "image360").map((t) => t.sourceType === "events" ? t.siteId : e(t)).filter(t), y = await h(g, l, u), b = await a(r, f, y), x = await n(_, g, l, u, d, y), S = await i(v, y, p);
+	return o([
+		...x,
+		...b,
+		...S
+	], e);
+}
+//#endregion
+export { c as searchHybridDmAssetsForModels };

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

@@ -0,0 +1,40 @@
+import { Datapoints, Timeseries, ExternalId, InternalId, Metadata, Relationship, Asset } from '@cognite/sdk';
+export type RelationshipsFilterInternal = {
+    labels?: string[];
+};
+export type ExtendedRelationship = {
+    relation: 'Source' | 'Target';
+} & Relationship;
+export type ExtendedRelationshipWithSourceAndTarget = {
+    relation: 'Source' | 'Target';
+} & Relationship & Partial<RelationshipSourceAndTargetTimeseries>;
+export type RelationshipSourceAndTargetTimeseries = {
+    source: Timeseries;
+    target: Timeseries;
+};
+export type RelationshipSourceAndTarget = {
+    source: RelationshipSourceAndTargetData;
+    target: RelationshipSourceAndTargetData;
+};
+export type RelationshipSourceAndTargetData = {
+    externalId?: string;
+    id?: number;
+    metadata?: Metadata;
+};
+export type RelationshipData = ExtendedRelationship & RelationshipSourceAndTarget;
+export type AssetIdsAndTimeseries = {
+    assetIds?: Partial<ExternalId & InternalId>;
+    timeseries?: Timeseries | undefined;
+};
+export type AssetAndTimeseries = {
+    asset: Asset;
+    timeseries?: Timeseries[] | undefined;
+};
+export type AssetAndTimeseriesIds = {
+    assetIds: Partial<ExternalId & InternalId>;
+    timeseriesIds: Partial<ExternalId & InternalId>;
+};
+export type AssetIdsAndTimeseriesData = {
+    assetIdsWithTimeseries: AssetIdsAndTimeseries[];
+    timeseriesDatapoints: Datapoints[];
+};

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

@@ -0,0 +1,5 @@
+export { type RevealModelCollectionTypes, type Classic3DResourceIdentifier, type DM3DResourceIdentifier, type Image360DMResourceIdentifier, type Image360EventsResourceIdentifier, type ThreeDResourceIdentifier, type AllResourceIdentifier, type BaseAddOptions, type CadModelStyling as NewCadModelStyling, type CadResourceIdentifier, type PointCloudResourceIdentifier, type Image360ResourceIdentifier, type SceneResourceIdentifier, type NamedThreeDResourceIdentifier, type CadAddOptions, type PointCloudAddOptions, type Image360IconCullingOptions, type Image360AddOptions, type SceneAddOptions, type Model3DAddOptions, type AddReveal3DResource, type ClassicModelAddOptions, type DMModelAddOptions, type DMImage360AddOptions, type EventsImage360AddOptions, } from './resources';
+export { type BaseResourceStyling, type CadResourceStyling, type PointCloudResourceStyling, type Image360ResourceStyling, } from './styling';
+export { isImage360DMResource, isImage360EventsResource, isImage360Collection, } from './typeGuards';
+export { getResourceKey, getRevealResourceKey } from './utils';
+export { isNewFormatResource, isLegacyFormatResource, convertAndSeparateResources, convertIdentifierToReveal3DResource, convertLegacyResourceOptionToIdentifier, type SeparatedLegacyResources, } from './typeAdapters';

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

@@ -0,0 +1,4 @@
+import { convertAndSeparateResources as e, convertIdentifierToReveal3DResource as t, convertLegacyResourceOptionToIdentifier as n, isLegacyFormatResource as r, isNewFormatResource as i } from "./typeAdapters.js";
+import { isImage360Collection as a, isImage360DMResource as o, isImage360EventsResource as s } from "./typeGuards.js";
+import { getResourceKey as c, getRevealResourceKey as l } from "./utils.js";
+export { e as convertAndSeparateResources, t as convertIdentifierToReveal3DResource, n as convertLegacyResourceOptionToIdentifier, c as getResourceKey, l as getRevealResourceKey, a as isImage360Collection, o as isImage360DMResource, s as isImage360EventsResource, r as isLegacyFormatResource, i as isNewFormatResource };

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

@@ -0,0 +1,107 @@
+import { Matrix4 } from 'three';
+import { CogniteCadModel, CognitePointCloudModel, DataSourceType, Image360Collection, NodeAppearance } from '@cognite/reveal';
+import { AddCadResourceOptions, AddPointCloudResourceOptions } from '../../utilities/modelIds/types';
+import { TreeIndexStylingGroup } from '../../utilities/styling/stylingGroups';
+export type Classic3DResourceIdentifier = {
+    readonly sourceType: 'classic';
+    readonly modelId: number;
+    readonly revisionId: number;
+};
+export type DM3DResourceIdentifier = {
+    readonly sourceType: 'cdm';
+    readonly externalId: string;
+    readonly space: string;
+};
+export type Image360DMResourceIdentifier = {
+    readonly sourceType: 'dm' | 'cdm';
+    readonly externalId: string;
+    readonly space: string;
+};
+export type Image360EventsResourceIdentifier = {
+    readonly sourceType: 'events';
+    readonly siteId: string;
+};
+export type BaseAddOptions = {
+    transform?: Matrix4;
+    defaultVisible?: boolean;
+};
+export type CadModelStyling = {
+    default?: NodeAppearance;
+    mapped?: NodeAppearance;
+    nodeGroups?: TreeIndexStylingGroup[];
+};
+export type CadResourceIdentifier = (Classic3DResourceIdentifier | DM3DResourceIdentifier) & {
+    type: 'cad';
+};
+export type PointCloudResourceIdentifier = (Classic3DResourceIdentifier | DM3DResourceIdentifier) & {
+    type: 'pointcloud';
+};
+export type Image360ResourceIdentifier = (Image360DMResourceIdentifier | Image360EventsResourceIdentifier) & {
+    type: 'image360';
+};
+export type SceneResourceIdentifier = {
+    type: 'scene';
+    externalId: string;
+    space: string;
+};
+export type ThreeDResourceIdentifier = CadResourceIdentifier | PointCloudResourceIdentifier | Image360ResourceIdentifier;
+export type CadAddOptions = BaseAddOptions & (Classic3DResourceIdentifier | DM3DResourceIdentifier) & {
+    styling?: CadModelStyling;
+    modelCategory: 'model3d';
+};
+export type PointCloudAddOptions = BaseAddOptions & (Classic3DResourceIdentifier | DM3DResourceIdentifier) & {
+    styling?: {
+        default?: NodeAppearance;
+        mapped?: NodeAppearance;
+    };
+    modelCategory: 'model3d';
+};
+export type Image360IconCullingOptions = {
+    radius?: number;
+    iconCountLimit?: number;
+};
+export type Image360AddOptions = BaseAddOptions & (Image360EventsResourceIdentifier | Image360DMResourceIdentifier) & {
+    iconCullingOptions?: Image360IconCullingOptions;
+    modelCategory: 'image360';
+};
+export type Model3DAddOptions = CadAddOptions | PointCloudAddOptions;
+export type SceneAddOptions = {
+    sourceType: 'dm';
+    externalId: string;
+    space: string;
+    modelCategory: 'scene';
+};
+export type AddReveal3DResource = CadAddOptions | PointCloudAddOptions | Image360AddOptions;
+export type AllResourceIdentifier = ThreeDResourceIdentifier | SceneResourceIdentifier;
+export type NamedThreeDResourceIdentifier = (CadResourceIdentifier & {
+    name: string;
+}) | (PointCloudResourceIdentifier & {
+    name: string;
+}) | (Image360ResourceIdentifier & {
+    name: string;
+});
+export type RevealModelCollectionTypes = CogniteCadModel | CognitePointCloudModel<DataSourceType> | Image360Collection<DataSourceType>;
+export type AllResourceContentType = 'scene' | 'cad' | 'pointcloud' | 'image360';
+/**
+ * Helper types for creating resources without union type discrimination issues.
+ * Use these when constructing resource objects programmatically.
+ */
+export type ClassicModelAddOptions = BaseAddOptions & Classic3DResourceIdentifier & {
+    styling?: CadModelStyling;
+    modelCategory: 'model3d';
+};
+export type DMModelAddOptions = BaseAddOptions & DM3DResourceIdentifier & {
+    styling?: CadModelStyling;
+    modelCategory: 'model3d';
+};
+export type DMImage360AddOptions = BaseAddOptions & Image360DMResourceIdentifier & {
+    iconCullingOptions?: Image360IconCullingOptions;
+    modelCategory: 'image360';
+};
+export type EventsImage360AddOptions = BaseAddOptions & Image360EventsResourceIdentifier & {
+    iconCullingOptions?: Image360IconCullingOptions;
+    modelCategory: 'image360';
+};
+type LegacyModelOptions = AddCadResourceOptions | AddPointCloudResourceOptions;
+export type ModelOptionsInput = Model3DAddOptions | LegacyModelOptions;
+export {};

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

@@ -0,0 +1,18 @@
+import { NodeAppearance, PointCloudAppearance, Image360AnnotationAppearance } from '@cognite/reveal';
+import { PointCloudVolumeStylingGroup, TreeIndexStylingGroup } from '../../utilities/styling/stylingGroups';
+export type BaseResourceStyling<T> = {
+    default?: T;
+    mapped?: T;
+};
+export type CadResourceStyling = BaseResourceStyling<NodeAppearance> & {
+    nodeGroups?: TreeIndexStylingGroup[];
+};
+export type PointCloudResourceStyling = BaseResourceStyling<PointCloudAppearance> & {
+    volumeGroups?: PointCloudVolumeStylingGroup[];
+};
+export type Image360ResourceStyling = BaseResourceStyling<Image360AnnotationAppearance>;
+export type DefaultResourceStyling = {
+    cad?: CadResourceStyling;
+    pointcloud?: PointCloudResourceStyling;
+    image360?: Image360ResourceStyling;
+};