@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,47 @@
+import { AddCadResourceOptions, AddImage360CollectionOptions, AddPointCloudResourceOptions, AddResourceOptions, TaggedAddResourceOptions, TaggedAddSceneResourceOptions } from '../../utilities/modelIds/types';
+import { AddReveal3DResource, AllResourceIdentifier, Image360AddOptions, Model3DAddOptions, SceneResourceIdentifier, ThreeDResourceIdentifier } from './resources';
+/**
+ * Result type for convertAndSeparateResources
+ */
+export type SeparatedLegacyResources = {
+    modelResources: Array<AddCadResourceOptions | AddPointCloudResourceOptions>;
+    image360Resources: AddImage360CollectionOptions[];
+};
+/**
+ * Result type for convertAndSeparateToNewResources
+ */
+export type SeparatedNewResources = {
+    modelResources: Model3DAddOptions[];
+    image360Resources: Image360AddOptions[];
+};
+/**
+ * Check if a resource is in the new format (has sourceType at top level).
+ */
+export declare function isNewFormatResource(resource: AddReveal3DResource | AddResourceOptions): resource is AddReveal3DResource;
+/**
+ * Check if a resource is in the legacy format (no sourceType).
+ */
+export declare function isLegacyFormatResource(resource: AddReveal3DResource | AddResourceOptions): resource is AddResourceOptions;
+/**
+ * Convert resources to legacy format and separate models from Image360.
+ * This avoids passing Image360 resources to useTypedModels.
+ */
+export declare function convertAndSeparateResources(resources: Array<AddReveal3DResource | AddResourceOptions>): SeparatedLegacyResources;
+export declare function convertNewModel3dAddOptionToRevealAddOptions(resource: Model3DAddOptions): AddCadResourceOptions | AddPointCloudResourceOptions;
+export declare function convertNewImage360AddOptionToRevealAddOptions(resource: Image360AddOptions): AddImage360CollectionOptions;
+/**
+ * Convert a ThreeDResourceIdentifier to AddReveal3DResource.
+ * This adds the required modelCategory field based on the identifier type.
+ *
+ * @param identifier - The identifier to convert
+ * @returns AddReveal3DResource with appropriate modelCategory
+ */
+export declare function convertIdentifierToReveal3DResource(identifier: ThreeDResourceIdentifier): AddReveal3DResource;
+export declare function convertLegacyResourceOptionToIdentifier(modelOption: TaggedAddResourceOptions): ThreeDResourceIdentifier;
+export declare function convertLegacyResourceOptionToIdentifier(modelOption: TaggedAddSceneResourceOptions): SceneResourceIdentifier;
+export declare function convertLegacyResourceOptionToIdentifier(modelOption: TaggedAddResourceOptions | TaggedAddSceneResourceOptions): AllResourceIdentifier;
+export declare function convertLegacyModelOptionToAddOptions(modelOption: AddResourceOptions): Model3DAddOptions | Image360AddOptions;
+/**
+ * Convert resources to new format and separate models from Image360.
+ */
+export declare function convertAndSeparateToNewResources(resources: Array<AddReveal3DResource | AddResourceOptions>): SeparatedNewResources;

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

@@ -0,0 +1,158 @@
+import { assertNever as e } from "../../utilities/assertNever.js";
+import { is360ImageDataModelAddOptions as t, is360ImageEventsAddOptions as n, isClassicIdentifier as r, isDM3DModelIdentifier as i } from "../../utilities/modelIds/typeGuards.js";
+import { assert as a } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/data-providers/types/typeAdapters.ts
+function o(e) {
+	return "sourceType" in e && "modelCategory" in e;
+}
+function s(e) {
+	return !o(e);
+}
+function c(e) {
+	let r = [], i = [];
+	for (let a of e) {
+		if (s(a)) {
+			t(a) || n(a) ? i.push(a) : r.push(a);
+			continue;
+		}
+		a.modelCategory === "image360" ? i.push(u(a)) : r.push(l(a));
+	}
+	return {
+		modelResources: r,
+		image360Resources: i
+	};
+}
+function l(t) {
+	let n = {
+		transform: t.transform,
+		defaultVisible: t.defaultVisible
+	};
+	if (t.sourceType === "classic") return {
+		modelId: t.modelId,
+		revisionId: t.revisionId,
+		...n
+	};
+	if (t.sourceType === "cdm") return {
+		revisionExternalId: t.externalId,
+		revisionSpace: t.space,
+		...n
+	};
+	e(t);
+}
+function u(t) {
+	let n = {
+		transform: t.transform,
+		iconCullingOptions: t.iconCullingOptions,
+		defaultVisible: t.defaultVisible
+	};
+	if (t.sourceType === "events") return {
+		source: "events",
+		siteId: t.siteId,
+		...n
+	};
+	if (t.sourceType === "dm" || t.sourceType === "cdm") return {
+		source: t.sourceType,
+		space: t.space,
+		externalId: t.externalId,
+		...n
+	};
+	e(t.sourceType);
+}
+function d(e) {
+	return e.type === "image360" ? e.sourceType === "events" ? {
+		siteId: e.siteId,
+		sourceType: "events",
+		modelCategory: "image360"
+	} : {
+		externalId: e.externalId,
+		space: e.space,
+		sourceType: e.sourceType,
+		modelCategory: "image360"
+	} : e.sourceType === "classic" ? {
+		modelId: e.modelId,
+		revisionId: e.revisionId,
+		sourceType: "classic",
+		modelCategory: "model3d"
+	} : {
+		externalId: e.externalId,
+		space: e.space,
+		sourceType: "cdm",
+		modelCategory: "model3d"
+	};
+}
+function f(t) {
+	if (t.type === "scene") return {
+		...t.addOptions,
+		type: "scene"
+	};
+	let n = p(t.addOptions);
+	if (t.type === "cad" || t.type === "pointcloud") {
+		if (a(n.modelCategory === "model3d"), n.sourceType === "cdm") return {
+			externalId: n.externalId,
+			space: n.space,
+			sourceType: n.sourceType,
+			type: t.type
+		};
+		if (n.sourceType === "classic") return {
+			modelId: n.modelId,
+			revisionId: n.revisionId,
+			sourceType: n.sourceType,
+			type: t.type
+		};
+		e(n);
+	}
+	if (t.type === "image360") {
+		if (a(n.modelCategory === "image360"), n.sourceType === "cdm" || n.sourceType === "dm") return {
+			externalId: n.externalId,
+			space: n.space,
+			sourceType: n.sourceType,
+			type: "image360"
+		};
+		if (n.sourceType === "events") return {
+			siteId: n.siteId,
+			sourceType: n.sourceType,
+			type: t.type
+		};
+		e(n.sourceType);
+	}
+	e(t);
+}
+function p(a) {
+	if (r(a)) return {
+		sourceType: "classic",
+		modelId: a.modelId,
+		revisionId: a.revisionId,
+		modelCategory: "model3d"
+	};
+	if (i(a)) return {
+		sourceType: "cdm",
+		externalId: a.revisionExternalId,
+		space: a.revisionSpace,
+		modelCategory: "model3d"
+	};
+	if (n(a)) return {
+		sourceType: "events",
+		siteId: a.siteId,
+		modelCategory: "image360"
+	};
+	if (t(a)) return {
+		sourceType: a.source,
+		externalId: a.externalId,
+		space: a.space,
+		modelCategory: "image360"
+	};
+	e(a);
+}
+function m(e) {
+	let t = [], n = [];
+	for (let r of e) {
+		let e = o(r) ? r : p(r);
+		e.modelCategory === "image360" ? n.push(e) : t.push(e);
+	}
+	return {
+		modelResources: t,
+		image360Resources: n
+	};
+}
+//#endregion
+export { c as convertAndSeparateResources, m as convertAndSeparateToNewResources, d as convertIdentifierToReveal3DResource, p as convertLegacyModelOptionToAddOptions, f as convertLegacyResourceOptionToIdentifier, u as convertNewImage360AddOptionToRevealAddOptions, l as convertNewModel3dAddOptionToRevealAddOptions, s as isLegacyFormatResource, o as isNewFormatResource };

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

@@ -0,0 +1,23 @@
+import { DataSourceType, Image360Collection } from '@cognite/reveal';
+import { Image360DMResourceIdentifier, AddReveal3DResource, Image360EventsResourceIdentifier, Image360AddOptions, ThreeDResourceIdentifier, CadResourceIdentifier, PointCloudResourceIdentifier, RevealModelCollectionTypes } from './resources';
+/**
+ * Type guard to check if a resource has a DM/CDM Image360 identifier.
+ * 'dm' and 'cdm' are reserved for Image360 (used by Reveal).
+ */
+export declare const isImage360DMResource: (resource: AddReveal3DResource) => resource is Image360AddOptions & Image360DMResourceIdentifier;
+/**
+ * Type guard to check if a resource has an Events identifier (siteId).
+ */
+export declare const isImage360EventsResource: (resource: AddReveal3DResource) => resource is Image360AddOptions & Image360EventsResourceIdentifier;
+/**
+ * Type guard to check if a resource is an Image360 resource.
+ */
+export declare const isImage360Resource: (resource: AddReveal3DResource) => resource is Image360AddOptions;
+/**
+ * Type guard to check if an identifier is a CAD or PointCloud (model) resource.
+ */
+export declare const isModelIdentifier: (identifier: ThreeDResourceIdentifier) => identifier is CadResourceIdentifier | PointCloudResourceIdentifier;
+/**
+ * Type guard to check if a model is an Image360 Collection.
+ */
+export declare const isImage360Collection: (model: RevealModelCollectionTypes) => model is Image360Collection<DataSourceType>;

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

@@ -0,0 +1,4 @@
+//#region libs/shared/reveal-components/src/data-providers/types/typeGuards.ts
+var e = (e) => e.modelCategory === "image360" && (e.sourceType === "dm" || e.sourceType === "cdm"), t = (e) => e.modelCategory === "image360" && e.sourceType === "events", n = (e) => "image360Entities" in e && Array.isArray(e.image360Entities);
+//#endregion
+export { n as isImage360Collection, e as isImage360DMResource, t as isImage360EventsResource };

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

@@ -0,0 +1,13 @@
+import { ThreeDResourceIdentifier, AddReveal3DResource } from './resources';
+/**
+ * Generate a unique key for a resource based on its identifier.
+ */
+export declare function getResourceKey(resource: AddReveal3DResource): string;
+/**
+ * Generate a unique Reveal's key for a resource based on its identifier.
+ */
+export declare function getRevealResourceKey(resource: AddReveal3DResource): string;
+/**
+ * Generate a unique key for a resource based on its identifier.
+ */
+export declare function getResourceKeyFromIdentifier(resource: ThreeDResourceIdentifier): string;

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

@@ -0,0 +1,13 @@
+import { isImage360DMResource as e, isImage360EventsResource as t } from "./typeGuards.js";
+//#region libs/shared/reveal-components/src/data-providers/types/utils.ts
+function n(n) {
+	return n.sourceType === "classic" ? `${n.sourceType}-${n.modelId}/${n.revisionId}` : n.sourceType === "cdm" || e(n) ? `${n.sourceType}-${n.space}/${n.externalId}` : t(n) ? `${n.sourceType}-${n.siteId}` : `unknown-${JSON.stringify(n)}`;
+}
+function r(n) {
+	return n.sourceType === "classic" ? `${n.modelId}/${n.revisionId}` : n.sourceType === "cdm" || e(n) ? `${n.space}/${n.externalId}` : t(n) ? `${n.siteId}` : `unknown-${JSON.stringify(n)}`;
+}
+function i(e) {
+	return e.sourceType === "classic" ? `${e.sourceType}-${e.modelId}/${e.revisionId}` : e.sourceType === "cdm" || e.type === "image360" && e.sourceType === "dm" ? `${e.sourceType}-${e.space}/${e.externalId}` : e.type === "image360" && e.sourceType === "events" ? `${e.sourceType}-${e.siteId}` : `unknown-${JSON.stringify(e)}`;
+}
+//#endregion
+export { n as getResourceKey, i as getResourceKeyFromIdentifier, r as getRevealResourceKey };

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

@@ -0,0 +1,25 @@
+import { FdmCadConnectionRevisionFields, FdmKey } from '../cache/types';
+import { COGNITE_CAD_NODE_VIEW_VERSION_KEY, CogniteCADNodeProperties, CORE_DM_SPACE } from '../core-dm-provider/dataModels';
+import { DmsUniqueIdentifier, NodeItem } from '../FdmSDK';
+type CadNodeWithCoreDmProperties = DmsUniqueIdentifier & {
+    properties: {
+        [CORE_DM_SPACE]: {
+            [COGNITE_CAD_NODE_VIEW_VERSION_KEY]: CogniteCADNodeProperties;
+        };
+    };
+};
+type CadNodeWithObject3D<T extends CadNodeWithCoreDmProperties> = T & {
+    properties: {
+        [CORE_DM_SPACE]: {
+            [COGNITE_CAD_NODE_VIEW_VERSION_KEY]: CogniteCADNodeProperties & {
+                object3D: DmsUniqueIdentifier;
+            };
+        };
+    };
+};
+export declare function filterCadNodesWithObject3D<T extends CadNodeWithCoreDmProperties>(cadNodes: T[]): Array<CadNodeWithObject3D<T>>;
+export declare function createObject3dToAssetMap<T extends NodeItem<{
+    object3D: unknown;
+}>>(assets: T[]): Map<FdmKey, T>;
+export declare function getModelRevisionAndTreeIndex(modelRevisions: Array<[DmsUniqueIdentifier, DmsUniqueIdentifier]>, cadNodeProps: CogniteCADNodeProperties): FdmCadConnectionRevisionFields | undefined;
+export {};

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

@@ -0,0 +1,31 @@
+import { isDmsInstance as e } from "../../utilities/instanceIds/typeGuards.js";
+import { createFdmKey as t } from "../cache/idAndKeyTranslation.js";
+import "../../utilities/instanceIds/index.js";
+import { COGNITE_CAD_NODE_VIEW_VERSION_KEY as n, COGNITE_VISUALIZABLE_VIEW_VERSION_KEY as r, CORE_DM_SPACE as i } from "../core-dm-provider/dataModels.js";
+import { getCadConnectionFieldsForRevision as a } from "./cadNodeConnectionFields.js";
+import { getModelIdFromExternalId as o, getRevisionIdFromExternalId as s } from "../core-dm-provider/getCdfIdFromExternalId.js";
+//#region libs/shared/reveal-components/src/data-providers/utils/cadConnectionMapping.ts
+function c(t) {
+	return t.filter((t) => e(t.properties[i][n].object3D));
+}
+function l(n) {
+	return new Map(n.flatMap((n) => {
+		let i = (n.properties?.cdf_cdm)?.[r]?.object3D ?? void 0;
+		return e(i) ? [[t(i), n]] : [];
+	}));
+}
+function u(e, t) {
+	let n = e.find(([e]) => t.model3D.externalId === e.externalId && t.model3D.space === e.space);
+	if (n === void 0) return;
+	let r = t.revisions.findIndex((e) => n[1].externalId === e.externalId && n[1].space === e.space);
+	if (r === -1) return;
+	let i = t.treeIndexes[r];
+	if (i !== void 0) return {
+		modelId: o(t.model3D.externalId),
+		revisionId: s(t.revisions[r].externalId),
+		treeIndex: i,
+		...a(t, r)
+	};
+}
+//#endregion
+export { l as createObject3dToAssetMap, c as filterCadNodesWithObject3D, u as getModelRevisionAndTreeIndex };

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

@@ -0,0 +1,28 @@
+import { BoundingBox3D, Node3D } from '@cognite/sdk';
+import { FdmCadConnection, FdmCadConnectionWithDmsNodeData } from '../cache/types';
+import { CogniteCADNodeProperties } from '../core-dm-provider/dataModels';
+export type SlimCadNode = Pick<Node3D, 'id' | 'treeIndex' | 'subtreeSize'>;
+export type SlimCadNodeWithBounds = SlimCadNode & {
+    boundingBox?: BoundingBox3D;
+};
+export declare function createSlimCadNode(id: number, treeIndex: number, subtreeSize: number): SlimCadNode;
+export declare function normalizeToSlimCadNode(node: Node3D): SlimCadNode;
+/**
+ * Parses the classic 3D internal node id stored on CogniteCADNode.cadNodeReference.
+ * DMS stores this as a string; callers need a numeric id for retrieve3DNodes (byIds).
+ */
+export declare function getNodeIdFromCadNodeReference(cadNodeReference: string | undefined): number | undefined;
+/**
+ * Maps revision-aligned DMS CogniteCADNode fields onto FdmCadConnection.
+ * treeIndexes and subTreeSizes are arrays indexed by revision; nodeId is parsed from cadNodeReference.
+ */
+export declare function getCadConnectionFieldsForRevision(cadNodeProps: CogniteCADNodeProperties, revisionIndex: number): Pick<FdmCadConnection, 'subtreeSize' | 'nodeId'>;
+export declare function hasValidTreeIndex(treeIndex: number): boolean;
+export declare function isFdmCadConnectionWithNodeData(connection: FdmCadConnection): connection is FdmCadConnectionWithDmsNodeData;
+/**
+ * Chooses the classic 3D API path over DMS-only resolution.
+ * Used when DMS lacks a valid nodeId, lacks a positive subtreeSize, or when
+ * treeIndex/subtreeSize look suspect. When nodeId is present, retrieve3DNodes
+ * is called directly; otherwise bytreeindices is used first.
+ */
+export declare function shouldResolveCadNodeViaApi(connection: FdmCadConnection): boolean;

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

@@ -0,0 +1,38 @@
+//#region libs/shared/reveal-components/src/data-providers/utils/cadNodeConnectionFields.ts
+function e(e, t, n) {
+	return {
+		id: e,
+		treeIndex: t,
+		subtreeSize: n
+	};
+}
+function t(t) {
+	return e(t.id, t.treeIndex, t.subtreeSize);
+}
+function n(e) {
+	if (e === void 0 || e.trim() === "") return;
+	let t = Number(e);
+	return Number.isFinite(t) ? t : void 0;
+}
+function r(e, t) {
+	let r = e.subTreeSizes?.[t], i = n(e.cadNodeReference);
+	return {
+		...r === void 0 ? {} : { subtreeSize: r },
+		...i === void 0 ? {} : { nodeId: i }
+	};
+}
+function i(e) {
+	return Number.isFinite(e) && e > 0;
+}
+function a(e) {
+	return e !== void 0 && Number.isFinite(e) && e > 0;
+}
+function o(e) {
+	let t = e.subtreeSize;
+	return i(e.treeIndex) && a(t) && e.treeIndex === t;
+}
+function s(e) {
+	return i(e.treeIndex) && !o(e) && e.nodeId !== void 0 && a(e.subtreeSize);
+}
+//#endregion
+export { e as createSlimCadNode, r as getCadConnectionFieldsForRevision, n as getNodeIdFromCadNodeReference, i as hasValidTreeIndex, s as isFdmCadConnectionWithNodeData, t as normalizeToSlimCadNode };

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

@@ -0,0 +1,3 @@
+import { ViewDefinition } from '@cognite/sdk';
+import { DmsUniqueIdentifier, NodeItem } from '../FdmSDK';
+export declare function getCogniteAssetDirectRelationProperties(searchResultNode: NodeItem, viewDefinition: ViewDefinition): DmsUniqueIdentifier[];

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

@@ -0,0 +1,26 @@
+import { isDefined as e } from "../../utilities/isDefined.js";
+import { COGNITE_ASSET_SOURCE as t } from "../core-dm-provider/dataModels.js";
+//#region libs/shared/reveal-components/src/data-providers/utils/getCogniteAssetDirectRelationProperties.ts
+function n(t, n) {
+	let i = n.properties, a = Object.keys(i).filter((e) => r(e, n)), o = t.properties[n.space]?.[`${n.externalId}/${n.version}`];
+	return Object.entries(o).length === 0 ? [] : a.map((e) => {
+		let n = o[e];
+		if (n === void 0) return;
+		let { space: r, externalId: i } = n;
+		if (t.externalId !== i || t.space !== r) return {
+			space: r,
+			externalId: i
+		};
+	}).filter(e);
+}
+function r(e, n) {
+	let r = n.properties[e], a = i(r);
+	if (a === void 0 || a.list === !0) return !1;
+	let o = a.source;
+	return o?.externalId === t.externalId && o?.space === t.space && o?.version === t.version;
+}
+function i(e) {
+	if ("type" in e && typeof e.type == "object" && e.type !== null && "type" in e.type && e.type.type === "direct") return e.type;
+}
+//#endregion
+export { n as getCogniteAssetDirectRelationProperties };

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

@@ -0,0 +1,4 @@
+import { FdmSDK, DmsUniqueIdentifier } from '../FdmSDK';
+export declare const MAX_PARALLEL_QUERIES = 2;
+export declare function getDMSRevisionsForRevisionIdsAndModelRefs(modelRefs: Array<DmsUniqueIdentifier | undefined>, revisionIds: number[], fdmSdk: FdmSDK): Promise<DmsUniqueIdentifier[]>;
+export declare function getDMSModelsForIds(modelIds: number[], fdmSdk: FdmSDK): Promise<DmsUniqueIdentifier[]>;

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

@@ -0,0 +1,12 @@
+import { executeParallel as e } from "../../utilities/executeParallel.js";
+import { isDefined as t } from "../../utilities/isDefined.js";
+import { getDMSModels as n } from "../core-dm-provider/getDMSModels.js";
+import { getDMSRevision as r } from "../core-dm-provider/getDMSRevision.js";
+async function i(n, i, a) {
+	return (await e(i.map((e, t) => async () => n[t] === void 0 ? void 0 : await r(n[t], e, a)), 2)).filter(t);
+}
+async function a(e, t) {
+	return await n(e, t);
+}
+//#endregion
+export { a as getDMSModelsForIds, i as getDMSRevisionsForRevisionIdsAndModelRefs };

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

@@ -0,0 +1,2 @@
+import { DmsUniqueIdentifier, NodeItem } from '../FdmSDK';
+export declare function getDirectRelationProperties(searchResultNode: NodeItem): DmsUniqueIdentifier[];

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

@@ -0,0 +1,13 @@
+//#region libs/shared/reveal-components/src/data-providers/utils/getDirectRelationProperties.ts
+function e(e) {
+	let t = [], n = e.properties;
+	return Object.keys(n).forEach((e) => {
+		let { space: r, externalId: i } = n[e];
+		r !== void 0 && i !== void 0 && t.push({
+			space: r,
+			externalId: i
+		});
+	}), t;
+}
+//#endregion
+export { e as getDirectRelationProperties };

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

@@ -0,0 +1 @@
+export type { SlimCadNode, SlimCadNodeWithBounds, } from './cadNodeConnectionFields';

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

@@ -0,0 +1 @@
+export declare function mergeQueryResults<T extends Record<string, unknown[]>>(dst: T, src: T): T;

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

@@ -0,0 +1,8 @@
+//#region libs/shared/reveal-components/src/data-providers/utils/mergeQueryResult.ts
+function e(e, t) {
+	return Object.keys(t).forEach((n) => {
+		n in e || Object.assign(e, n, []), e[n].push(...t[n]);
+	}), e;
+}
+//#endregion
+export { e as mergeQueryResults };

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

@@ -0,0 +1,50 @@
+import { EdgeDefinition, NodeDefinition, NodeOrEdge, CogniteClient, QueryRequest, QueryNodeTableExpressionV3, QueryEdgeTableExpressionV3 } from '@cognite/sdk';
+import { LoadMetricsRecorder } from '../../utilities/loadMetricsParameters';
+export type QueryNodesAndEdgesOptions = {
+    metrics?: {
+        tracker: LoadMetricsRecorder;
+        featureName: string;
+    };
+};
+export type FdmSdkQueryNodesAndEdgesOptions = {
+    metricsFeatureName?: string;
+};
+export type QueryFunction<TQueryRequest extends QueryRequest, TypedSelectSources extends SelectSourceWithParams = SelectSourceWithParams> = (query: TQueryRequest, options?: FdmSdkQueryNodesAndEdgesOptions) => Promise<QueryResult<TQueryRequest, TypedSelectSources>>;
+export declare function queryNodesAndEdges<TQueryRequest extends QueryRequest, TypedSelectSources extends SelectSourceWithParams = SelectSourceWithParams>(query: TQueryRequest, sdk: CogniteClient, options?: QueryNodesAndEdgesOptions): Promise<QueryResult<TQueryRequest, TypedSelectSources>>;
+type SELECT = 'select';
+type WITH = 'with';
+type PROPERTIES = 'properties';
+type SOURCES = 'sources';
+type SOURCE = 'source';
+type SPACE = 'space';
+type EXTERNALID = 'externalId';
+type VERSION = 'version';
+type ALLPROPERTIES = '*';
+export type InstanceType<TQueryRequest extends QueryRequest, SelectKey extends keyof TQueryRequest[SELECT]> = TQueryRequest[WITH][SelectKey] extends QueryNodeTableExpressionV3 ? Omit<NodeDefinition, PROPERTIES> : TQueryRequest[WITH][SelectKey] extends QueryEdgeTableExpressionV3 ? Omit<EdgeDefinition, PROPERTIES> : Omit<NodeOrEdge, PROPERTIES>;
+export type TypedSourceProperty<SelectSource extends NonNullable<QueryRequest[SELECT][keyof QueryRequest[SELECT]][SOURCES]>[number], TypedSelectSourcePropertyMap extends SelectSourceWithParams = SelectSourceWithParams> = Extract<TypedSelectSourcePropertyMap[number], Pick<SelectSource, SOURCE>>[PROPERTIES];
+export type SelectSourceWithParams = Array<{
+    source: {
+        type: string;
+        space: string;
+        externalId: string;
+        version: string;
+    };
+    properties: Record<string, unknown>;
+}>;
+export type QueryResult<TQueryRequest extends QueryRequest, TSelectSourceWithParams extends SelectSourceWithParams = SelectSourceWithParams> = {
+    items: {
+        [SELECT_KEY in keyof TQueryRequest[SELECT]]: Array<InstanceType<TQueryRequest, SELECT_KEY> & {
+            properties: {
+                [SELECT_SOURCE in NonNullable<TQueryRequest[SELECT][SELECT_KEY][SOURCES]>[number] as SELECT_SOURCE[SOURCE][SPACE]]: {
+                    [SELECT_SOURCE_VAR in SELECT_SOURCE as `${SELECT_SOURCE_VAR[SOURCE][EXTERNALID]}/${SELECT_SOURCE_VAR[SOURCE][VERSION]}`]: SELECT_SOURCE_VAR[PROPERTIES][0] extends ALLPROPERTIES ? Record<string, unknown> : {
+                        [SELECT_SOURCE_PROPERTY in SELECT_SOURCE_VAR[PROPERTIES][number]]: TypedSourceProperty<SELECT_SOURCE_VAR, TSelectSourceWithParams>[SELECT_SOURCE_PROPERTY] extends never ? unknown : TypedSourceProperty<SELECT_SOURCE_VAR, TSelectSourceWithParams>[SELECT_SOURCE_PROPERTY];
+                    };
+                };
+            };
+        }>;
+    };
+    nextCursor?: {
+        [SELECT_SOURCE_KEY in keyof TQueryRequest[SELECT]]: string;
+    };
+};
+export {};

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

@@ -0,0 +1,10 @@
+//#region libs/shared/reveal-components/src/data-providers/utils/queryNodesAndEdges.ts
+async function e(e, t, n) {
+	let r = performance.now(), i = await t.instances.query(e);
+	return n?.metrics !== void 0 && n.metrics.tracker.record({
+		featureName: n.metrics.featureName,
+		durationMs: performance.now() - r
+	}), i;
+}
+//#endregion
+export { e as queryNodesAndEdges };

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

@@ -0,0 +1,2 @@
+export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends ReadonlyArray<infer ElementType> ? ElementType : never;
+export type PromiseType<PromiseType extends Promise<unknown>> = PromiseType extends Promise<infer ElementType> ? ElementType : never;

package/dist/domains/annotation360/DeleteSelectedImage360AnnotationCommand.d.ts

@@ -0,0 +1,12 @@
+import { InstanceCommand } from '../../foundation/commands/InstanceCommand';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName, ButtonType } from '../../foundation/utilities/types';
+export declare class DeleteSelectedImage360AnnotationCommand extends InstanceCommand {
+    get tooltip(): TranslationInput;
+    get icon(): IconName;
+    get buttonType(): ButtonType;
+    protected get shortCutKey(): string;
+    protected invokeCore(): boolean;
+    protected isInstance(domainObject: DomainObject): boolean;
+}

package/dist/domains/annotation360/DeleteSelectedImage360AnnotationCommand.js

@@ -0,0 +1,30 @@
+import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../foundation/domainObjectsHelpers/FocusType.js";
+import { InstanceCommand as n } from "../../foundation/commands/InstanceCommand.js";
+import { Image360AnnotationDomainObject as r } from "./Image360AnnotationDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/annotation360/DeleteSelectedImage360AnnotationCommand.ts
+var i = class extends n {
+	get tooltip() {
+		return { untranslated: "Remove selected polygon" };
+	}
+	get icon() {
+		return "Delete";
+	}
+	get buttonType() {
+		return "ghost-destructive";
+	}
+	get shortCutKey() {
+		return "Delete";
+	}
+	invokeCore() {
+		let t = Array.from(this.getInstances());
+		t.reverse();
+		for (let n of t) this.addTransaction(n.createTransaction(e.deleted)), n.remove();
+		return !0;
+	}
+	isInstance(e) {
+		return e instanceof r && e.isSelected && e.focusType !== t.Pending;
+	}
+};
+//#endregion
+export { i as DeleteSelectedImage360AnnotationCommand };

package/dist/domains/annotation360/Image360AnnotationCreateTool.d.ts

@@ -0,0 +1,23 @@
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { VisualDomainObject } from '../../foundation/domainObjects/VisualDomainObject';
+import { BaseCreator } from '../../foundation/domainObjectsHelpers/BaseCreator';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+import { PrimitiveEditTool } from '../primitives/tools/PrimitiveEditTool';
+export declare class Image360AnnotationCreateTool extends PrimitiveEditTool {
+    private readonly _mustBeInside360Image;
+    constructor(mustBeInside360Image?: boolean);
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    update(): void;
+    onDeactivate(): void;
+    onEscapeKey(): boolean;
+    onHover(event: PointerEvent): Promise<void>;
+    onHoverByDebounce(_event: PointerEvent): Promise<void>;
+    onClick(event: PointerEvent): Promise<void>;
+    protected canBeSelected(domainObject: VisualDomainObject): boolean;
+    protected createCreator(): BaseCreator | undefined;
+    protected getOrCreateParent(): DomainObject;
+    private setSelectTool;
+}