@cognite/reveal 4.28.1 → 4.28.2

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/cdm/Cdf360CdmBatchCollectionLoader.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { DataModelsSdk } from '../../../../DataModelsSdk';
+import type { Historical360ImageSet } from '../../../../types';
+import type { DMDataSourceType } from '../../../../DataSourceType';
+import { DMInstanceKey, DMInstanceRef } from '../../../../../../utilities';
+import { BatchLoader } from '../../../../utilities/BatchLoader';
+/**
+ * Coordinates batched loading of multiple 360 image collections.
+ * Instead of loading each collection individually (1000 queries for 1000 collections),
+ * it batches them into groups and makes far fewer queries (e.g., 20 queries for 1000 collections).
+ * This allows collections with any number of images, not just ~200 per collection (10,000 / 50 batch size).
+ */
+export declare class Cdf360CdmBatchCollectionLoader extends BatchLoader<DMInstanceRef, Historical360ImageSet<DMDataSourceType>[]> {
+    private readonly _dmsSdk;
+    private readonly _cogniteSdk;
+    constructor(dmsSdk: DataModelsSdk, cogniteSdk: CogniteClient);
+    getCollectionDescriptors(identifier: DMInstanceRef): Promise<Historical360ImageSet<DMDataSourceType>[]>;
+    protected fetchBatch(identifiers: DMInstanceRef[]): Promise<Map<DMInstanceKey, Historical360ImageSet<DMDataSourceType>[]>>;
+    protected getKeyForIdentifier(identifier: DMInstanceRef): DMInstanceKey;
+    protected getDefaultResult(_identifier: DMInstanceRef): Historical360ImageSet<DMDataSourceType>[];
+    private fetchAllPages;
+    private groupResultsByCollection;
+    private getFileDescriptorsForBatch;
+    private getFileDescriptorsForImages;
+    private createHistoricalImageSets;
+    private getHistorical360ImageSet;
+    private getImageRevision;
+    private getFaceDescriptors;
+    private getRevisionTransform;
+    private getCdmFiles;
+    private stringifyValue;
+    private toNumber;
+}

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/cdm/Cdf360CdmDescriptorProvider.d.ts

@@ -7,12 +7,7 @@ import { Image360DataModelIdentifier } from '../system-space/Cdf360DataModelsDes
 import { DMDataSourceType } from '../../../../DataSourceType';
 export declare class Cdf360CdmDescriptorProvider implements Image360DescriptorProvider<DMDataSourceType> {
     private readonly _dmsSdk;
-    private readonly _cogniteSdk;
+    private readonly _batchLoader;
     constructor(sdk: CogniteClient);
     get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet<DMDataSourceType>[]>;
-    private queryCollection;
-    private getFileDescriptors;
-    private getHistorical360ImageSet;
-    private getImageRevision;
-    private getRevisionTransform;
 }

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/cdm/get360CdmCollectionsQuery.d.ts

@@ -0,0 +1,95 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { DMInstanceRef } from '../../../../../../utilities';
+declare function createCollectionsQuery(instanceReferences: DMInstanceRef[]): {
+    with: {
+        image_collections: {
+            nodes: {
+                filter: {
+                    instanceReferences: DMInstanceRef[];
+                };
+            };
+            limit: number;
+        };
+        images: {
+            nodes: {
+                from: string;
+                through: {
+                    view: {
+                        readonly externalId: "Cognite360Image";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                        readonly type: "view";
+                    };
+                    identifier: string;
+                };
+            };
+            limit: number;
+        };
+        stations: {
+            nodes: {
+                from: string;
+                through: {
+                    view: {
+                        readonly externalId: "Cognite360Image";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                        readonly type: "view";
+                    };
+                    identifier: string;
+                };
+                direction: "outwards";
+            };
+            limit: number;
+        };
+    };
+    select: {
+        image_collections: {
+            sources: {
+                source: {
+                    readonly externalId: "Cognite360ImageCollection";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                    readonly type: "view";
+                };
+                properties: string[];
+            }[];
+        };
+        images: {
+            sources: {
+                source: {
+                    readonly externalId: "Cognite360Image";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                    readonly type: "view";
+                };
+                properties: ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "front", "back", "left", "right", "top", "bottom", "collection360", "station360", "takenAt"];
+            }[];
+        };
+        stations: {
+            sources: {
+                source: {
+                    readonly externalId: "Cognite360ImageStation";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                    readonly type: "view";
+                };
+                properties: string[];
+            }[];
+        };
+    };
+};
+export type CdfImage360CollectionDmQuery = ReturnType<typeof createCollectionsQuery>;
+/**
+ * Creates a DMS query to fetch multiple 360 image collections in a single request.
+ * This is much more efficient than making individual queries per collection.
+ *
+ * @param collectionRefs - Array of collection identifiers to fetch
+ * @returns DMS query that fetches all collections and their images in one request
+ */
+export declare function get360CdmCollectionsQuery(collectionRefs: Array<{
+    externalId: string;
+    space: string;
+}>): CdfImage360CollectionDmQuery;
+export {};

package/dist/packages/data-providers/src/utilities/BatchLoader.d.ts

@@ -0,0 +1,66 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+/**
+ * Generic batch loader for accumulating and processing requests in batches.
+ * This prevents overwhelming APIs with thousands of individual requests by grouping them.
+ *
+ * Example use cases:
+ * - Batching DMS queries for multiple 360 image collections
+ * - Batching CDF Events/Files API calls for event-based 360 images
+ * - Batching point cloud data fetching
+ *
+ * @template TIdentifier - Type of the identifier used to request data (e.g., DMInstanceRef, string)
+ * @template TResult - Type of the result returned for each identifier
+ */
+export declare abstract class BatchLoader<TIdentifier, TResult> {
+    private readonly _batchSize;
+    private readonly _batchDelayMs;
+    private readonly _pendingBatch;
+    private _batchTimer;
+    private _isProcessing;
+    /**
+     * @param _batchSize - Maximum number of identifiers to process in a single batch
+     * @param _batchDelayMs - Delay in milliseconds to wait for more requests before executing batch
+     */
+    constructor(_batchSize: number, _batchDelayMs: number);
+    /**
+     * Load data for the given identifier. Requests are automatically batched.
+     *
+     * @param identifier - The identifier to load data for
+     * @returns Promise that resolves with the result for this identifier
+     */
+    load(identifier: TIdentifier): Promise<TResult>;
+    /**
+     * Try to execute a batch. If already processing, this will be a no-op.
+     * The next batch will be picked up when the current one finishes.
+     */
+    private tryExecuteBatch;
+    /**
+     * Execute a batch of requests.
+     */
+    private executeBatch;
+    /**
+     * Fetch data for a batch of identifiers. This is where the actual API calls happen.
+     *
+     * @param identifiers - Array of identifiers to fetch data for
+     * @returns Map of key to result, where key is generated by getKeyForIdentifier
+     */
+    protected abstract fetchBatch(identifiers: TIdentifier[]): Promise<Map<string, TResult>>;
+    /**
+     * Convert an identifier to a string key for mapping results.
+     * This key is used to match requests with their results.
+     *
+     * @param identifier - The identifier to convert
+     * @returns String key uniquely identifying this identifier
+     */
+    protected abstract getKeyForIdentifier(identifier: TIdentifier): string;
+    /**
+     * Get the default result when an identifier is not found in the batch results.
+     * This is called when fetchBatch doesn't return a result for a given identifier.
+     *
+     * @param identifier - The identifier that wasn't found
+     * @returns Default result to return
+     */
+    protected abstract getDefaultResult(identifier: TIdentifier): TResult;
+}

package/dist/packages/data-providers/src/utilities/dmsPaginationUtils.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+/**
+ * Determines if DMS query pagination should continue and returns the cursor.
+ * Pagination continues only when the result set reached the limit, indicating more data may exist.
+ *
+ * @param results - The array of results from the current page
+ * @param nextCursor - The cursor object from the DMS response
+ * @param cursorKey - The key to extract from the cursor object (e.g., 'images', 'nodes')
+ * @param limit - The limit used in the query
+ * @returns The cursor string if pagination should continue, undefined otherwise
+ *
+ */
+export declare function getDmsPaginationCursor(results: unknown[] | undefined, nextCursor: Record<string, string> | undefined, cursorKey: string, limit: number): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.28.1",
+  "version": "4.28.2",
   "description": "WebGL based 3D viewer for CAD and point clouds processed in Cognite Data Fusion.",
   "homepage": "https://github.com/cognitedata/reveal/tree/master/viewer",
   "repository": {

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/cdm/get360CdmCollectionQuery.d.ts

@@ -1,103 +0,0 @@
-/*!
- * Copyright 2023 Cognite AS
- */
-declare const Image360CollectionQuery: {
-    readonly with: {
-        readonly image_collection: {
-            readonly nodes: {
-                readonly filter: {
-                    readonly and: readonly [{
-                        readonly equals: {
-                            readonly property: readonly ["node", "externalId"];
-                            readonly value: {
-                                readonly parameter: "collectionExternalId";
-                            };
-                        };
-                    }, {
-                        readonly equals: {
-                            readonly property: readonly ["node", "space"];
-                            readonly value: {
-                                readonly parameter: "collectionSpace";
-                            };
-                        };
-                    }];
-                };
-            };
-            readonly limit: 1;
-        };
-        readonly images: {
-            readonly nodes: {
-                readonly from: "image_collection";
-                readonly through: {
-                    readonly view: {
-                        readonly type: "view";
-                        readonly space: "cdf_cdm";
-                        readonly externalId: "Cognite360Image";
-                        readonly version: "v1";
-                    };
-                    readonly identifier: "collection360";
-                };
-            };
-            readonly limit: 10000;
-        };
-        readonly stations: {
-            readonly nodes: {
-                readonly from: "images";
-                readonly through: {
-                    readonly view: {
-                        readonly type: "view";
-                        readonly space: "cdf_cdm";
-                        readonly externalId: "Cognite360Image";
-                        readonly version: "v1";
-                    };
-                    readonly identifier: "station360";
-                };
-                readonly direction: "outwards";
-            };
-            readonly limit: 10000;
-        };
-    };
-    readonly select: {
-        readonly image_collection: {
-            readonly sources: readonly [{
-                readonly source: {
-                    readonly type: "view";
-                    readonly space: "cdf_cdm";
-                    readonly externalId: "Cognite360ImageCollection";
-                    readonly version: "v1";
-                };
-                readonly properties: readonly ["name"];
-            }];
-        };
-        readonly images: {
-            readonly sources: readonly [{
-                readonly source: {
-                    readonly type: "view";
-                    readonly space: "cdf_cdm";
-                    readonly externalId: "Cognite360Image";
-                    readonly version: "v1";
-                };
-                readonly properties: readonly ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "front", "back", "left", "right", "top", "bottom", "collection360", "station360", "takenAt"];
-            }];
-        };
-        readonly stations: {
-            readonly sources: readonly [{
-                readonly source: {
-                    readonly type: "view";
-                    readonly space: "cdf_cdm";
-                    readonly externalId: "Cognite360ImageStation";
-                    readonly version: "v1";
-                };
-                readonly properties: readonly ["name"];
-            }];
-        };
-    };
-};
-export type Cdf360FdmQuery = typeof Image360CollectionQuery;
-export declare function get360CollectionQuery(externalId: string, space: string): Cdf360FdmQuery & {
-    parameters: {
-        collectionExternalId: string;
-        collectionSpace: string;
-    };
-};
-export {};