@cognite/reveal 4.28.5 → 4.28.6

package/dist/packages/api/src/public/RevealManager.d.ts

@@ -30,7 +30,6 @@ export declare class RevealManager {
     private _isDisposed;
     private readonly _subscriptions;
     private readonly _events;
-    private readonly _updateSubject;
     private readonly _cameraManager;
     private readonly _onCameraChange;
     private readonly _onCameraStop;
@@ -62,6 +61,5 @@ export declare class RevealManager {
     addModel<T extends DataSourceType>(type: 'pointcloud', modelIdentifier: AddModelOptionsWithModelRevisionId<T>): Promise<PointCloudNode<T>>;
     removeModel(type: 'cad', model: CadNode): void;
     removeModel(type: 'pointcloud', model: PointCloudNode): void;
-    private notifyLoadingStateChanged;
     private initLoadingStateObserver;
 }

package/dist/packages/api/src/public/migration/Cognite3DViewer.d.ts

@@ -27,6 +27,7 @@ import { Image360Action } from '../../../../360-images/src/Image360Action';
 export declare class Cognite3DViewer<DataSourceT extends DataSourceType = ClassicDataSourceType> {
     private readonly _domElementResizeObserver;
     private readonly _image360ApiHelper;
+    private readonly _unsubsribeOnLoading;
     /**
      * Returns the rendering canvas, the DOM element where the renderer draws its output.
      */
@@ -50,7 +51,6 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     private readonly _dataSource;
     private readonly _sceneHandler;
     private readonly _activeCameraManager;
-    private readonly _subscription;
     private readonly _revealManagerHelper;
     private readonly _domElement;
     private readonly _renderer;

package/dist/packages/cad-geometry-loaders/src/CadManager.d.ts

@@ -2,7 +2,6 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { Observable } from 'rxjs';
 import { CadModelMetadata } from '../../cad-parsers';
 import { CadModelUpdateHandler } from './CadModelUpdateHandler';
 import { LoadingState } from '../../model-base';
@@ -15,9 +14,11 @@ export declare class CadManager {
     private readonly _cadModelFactory;
     private readonly _cadModelUpdateHandler;
     private readonly _cadModelMap;
-    private readonly _subscription;
+    private readonly _unsubscribeConsumedSectors;
+    private readonly _unsubscribeLoadingState;
     private _compatibleFileFormat;
     private _needsRedraw;
+    private readonly _loadingStateChangedTrigger;
     private readonly _markNeedsRedrawBound;
     private readonly _materialsChangedListener;
     private readonly _sectorBufferTime;
@@ -42,7 +43,8 @@ export declare class CadManager {
     updateModelCompatibilityFormat(modelMetadata: CadModelMetadata): void;
     addModel(modelIdentifier: ModelIdentifier, geometryFilter?: GeometryFilter): Promise<CadNode>;
     removeModel(model: CadNode): void;
-    getLoadingStateObserver(): Observable<LoadingState>;
+    on(event: 'loadingStateChanged', listener: (loadingState: LoadingState) => void): void;
+    off(event: 'loadingStateChanged', listener: (loadingState: LoadingState) => void): void;
     /**
      * Sets the Memory Cache size for all loaded models to the current budget
      * @param budget The budget to calculate cache size by

package/dist/packages/cad-geometry-loaders/src/CadModelUpdateHandler.d.ts

@@ -2,14 +2,18 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
+import { EventTrigger, type EventListener } from '../../utilities';
 import { ConsumedSector } from '../../cad-parsers';
-import { Observable } from 'rxjs';
 import { SectorCuller } from './sector/culling/SectorCuller';
 import { CadLoadingHints } from './CadLoadingHints';
 import { LoadingState } from '../../model-base';
 import { CadModelBudget } from './CadModelBudget';
 import { SectorLoadingSpent } from './sector/culling/types';
 import { CadNode } from '../../cad-model';
+type CadModelUpdateHandlerEvents = {
+    onNewConsumedSector: EventTrigger<(consumedSector: ConsumedSector) => void>;
+    onLoadingStateChanged: EventTrigger<(loadingState: LoadingState) => void>;
+};
 export declare class CadModelUpdateHandler {
     private readonly _sectorCuller;
     private readonly _modelStateHandler;
@@ -22,8 +26,8 @@ export declare class CadModelUpdateHandler {
     private readonly _prioritizedLoadingHintsSubject;
     private readonly _modelSubject;
     private readonly _budgetSubject;
-    private readonly _progressSubject;
-    private _updateObservable;
+    private readonly _consumedSectorSubscription;
+    private readonly _events;
     constructor(sectorCuller: SectorCuller, continuousModelStreaming?: boolean);
     dispose(): void;
     updateCamera(camera: THREE.PerspectiveCamera, cameraInMotion: boolean): void;
@@ -35,8 +39,7 @@ export declare class CadModelUpdateHandler {
     removeModel(model: CadNode): void;
     updateLoadingHints(cadLoadingHints: CadLoadingHints): void;
     private updatePrioritizedAreas;
-    consumedSectorObservable(): Observable<ConsumedSector>;
-    getLoadingStateObserver(): Observable<LoadingState>;
+    on<EventKey extends keyof CadModelUpdateHandlerEvents>(event: EventKey, listener: EventListener<CadModelUpdateHandlerEvents, EventKey>): () => void;
     reportNewSectorsLoaded(loadedCountChange: number): void;
     /**
      * When loading hints of a CAD model changes, propagate the event down to the stream and either add or remove
@@ -44,3 +47,4 @@ export declare class CadModelUpdateHandler {
      */
     private loadingModelObservable;
 }
+export {};

package/dist/packages/cad-model/src/CadModelFactory.d.ts

@@ -10,7 +10,7 @@ export declare class CadModelFactory {
     private _gltfSectorRepository;
     constructor(materialManager: CadMaterialManager, modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider);
     loadModelMetadata(externalModelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
-    createModel(metadata: CadModelMetadata, geometryFilter?: GeometryFilter): Promise<CadNode>;
+    createModel(metadata: CadModelMetadata, geometryFilter?: GeometryFilter): CadNode;
     private getSectorRepository;
     dispose(): void;
 }

package/dist/packages/cad-model/src/wrappers/CadNode.d.ts

@@ -1,11 +1,11 @@
 /**
  * Copyright 2021 Cognite AS
  */
-import { NodeAppearanceProvider, NodeAppearance, PrioritizedArea } from '../../../cad-styling';
+import { NodeAppearanceProvider, NodeAppearance, PrioritizedArea, type NodeTransformProvider } from '../../../cad-styling';
 import { SectorScene, CadModelMetadata, RootSectorNode, WantedSector, ConsumedSector } from '../../../cad-parsers';
 import { SectorRepository } from '../../../sector-loader';
 import { ParsedGeometry } from '../../../sector-parser';
-import { CadMaterialManager, NodeTransformProvider, RenderMode } from '../../../rendering';
+import { CadMaterialManager, RenderMode } from '../../../rendering';
 import { Group, Object3D, Plane, Matrix4, Object3DEventMap } from 'three';
 import { TreeIndexToSectorsMap } from '../utilities/TreeIndexToSectorsMap';
 import { ParsedMeshGeometry } from '../../../cad-parsers';

package/dist/packages/cad-styling/index.d.ts

@@ -22,3 +22,6 @@ export { AreaCollection } from './src/prioritized/AreaCollection';
 export { EmptyAreaCollection } from './src/prioritized/EmptyAreaCollection';
 export { ClusteredAreaCollection } from './src/prioritized/ClusteredAreaCollection';
 export { PrioritizedArea } from './src/prioritized/types';
+export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
+export { NodeTransformTextureBuilder } from './src/transform/NodeTransformTextureBuilder';
+export { NodeAppearanceTextureBuilder } from './src/NodeAppearanceTextureBuilder';

package/dist/packages/{rendering/src/rendering → cad-styling/src}/NodeAppearanceTextureBuilder.d.ts

@@ -2,8 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { IndexSet } from '../../../utilities';
-import { NodeAppearanceProvider, NodeAppearance } from '../../../cad-styling';
+import { IndexSet } from '../../utilities';
+import { type NodeAppearance } from './NodeAppearance';
+import type { NodeAppearanceProvider } from './NodeAppearanceProvider';
 export declare class NodeAppearanceTextureBuilder {
     private _defaultAppearance;
     private readonly _styleProvider;

package/dist/packages/pointclouds/src/potree-three-loader/Potree.d.ts

@@ -19,6 +19,9 @@ export declare class Potree implements IPotree {
     private readonly _materialManager;
     private _throttledUpdateFunc;
     private _shouldLoad;
+    private _updateInProgress;
+    private readonly _tempCameraForward;
+    private readonly _tempToNode;
     maxNumNodesLoading: number;
     lru: LRU;
     constructor(modelDataProvider: ModelDataProvider, pointCloudMaterialManager: PointCloudMaterialManager);
@@ -26,6 +29,7 @@ export declare class Potree implements IPotree {
     loadPointCloud(baseUrl: string, fileName: string, stylableObject: StylableObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
     updatePointClouds(pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer): void;
     set shouldLoad(value: boolean);
+    private createEmptyVisibilityResult;
     private innerUpdatePointClouds;
     get pointBudget(): number;
     set pointBudget(value: number);

package/dist/packages/rendering/index.d.ts

@@ -3,7 +3,6 @@
  */
 export { CadMaterialManager } from './src/CadMaterialManager';
 export { PointCloudMaterialManager } from './src/PointCloudMaterialManager';
-export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
 export { RenderOptions, defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode, EdlOptions } from './src/rendering/types';
 export * from './src/pointcloud-rendering/constants';
 export * from './src/pointcloud-rendering/enums';

package/dist/packages/rendering/src/CadMaterialManager.d.ts

@@ -2,10 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { NodeTransformProvider } from './transform/NodeTransformProvider';
 import { Materials } from './rendering/materials';
 import { RenderMode } from './rendering/RenderMode';
-import { NodeAppearance, NodeAppearanceProvider } from '../../cad-styling';
+import { NodeAppearance, NodeAppearanceProvider, NodeTransformProvider } from '../../cad-styling';
 import { IndexSet } from '../../utilities';
 export declare class CadMaterialManager {
     private readonly _events;

package/dist/packages/rendering/src/pointcloud-rendering/constants.d.ts

@@ -2,17 +2,17 @@
  * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
  */
 import { Color } from 'three';
-export declare const DEFAULT_MAX_POINT_SIZE = 50;
+export declare const DEFAULT_MAX_POINT_SIZE = 10;
 export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;
 export declare const DEFAULT_MIN_POINT_SIZE = 1;
 export declare const DEFAULT_PICK_WINDOW_SIZE = 15;
 export declare const DEFAULT_POINT_BUDGET = 3000000;
-export declare const MAX_LOADS_TO_GPU = 2;
+export declare const MAX_LOADS_TO_GPU = 15;
 export declare const MAX_NUM_NODES_LOADING = 8;
 export declare const UPDATE_THROTTLE_TIME_MS = 100;
 export declare const PERSPECTIVE_CAMERA = "PerspectiveCamera";
 export declare const COLOR_BLACK: Color;
 export declare const COLOR_WHITE: Color;
-export declare const DEFAULT_EDL_NEIGHBOURS_COUNT = 8;
+export declare const DEFAULT_EDL_NEIGHBOURS_COUNT = 16;
 export declare const OBJECT_STYLING_TEXTURE_WIDTH = 256;
 export declare const OBJECT_STYLING_TEXTURE_HEIGHT = 256;

package/dist/packages/utilities/index.d.ts

@@ -5,7 +5,7 @@ export { traverseDepthFirst } from './src/objectTraversal';
 export { transformCameraConfiguration } from './src/transformCameraConfiguration';
 export { RandomColors } from './src/RandomColors';
 export { CameraConfiguration } from './src/CameraConfiguration';
-export { EventTrigger } from './src/events/EventTrigger';
+export { EventTrigger, EventListener } from './src/events/EventTrigger';
 export { InputHandler } from './src/events/InputHandler';
 export { PointerEvents } from './src/events/PointerEvents';
 export { PointerEventsTarget } from './src/events/PointerEventsTarget';
@@ -25,6 +25,7 @@ export { unionBoxes } from './src/three/unionBoxes';
 export { determineCurrentDevice, DeviceDescriptor } from './src/device';
 export { createRenderTriangle } from './src/three/createFullScreenTriangleGeometry';
 export { VariableWidthLine } from './src/three/VariableWidthLine';
+export { batchedDebounce, BatchedDebounce } from './src/batchedDebounce';
 export { fitCameraToBoundingBox } from './src/three/fitCameraToBoundingBox';
 export { isBox3OnPositiveSideOfPlane } from './src/three/isBox3OnPositiveSideOfPlane';
 export { visitBox3CornerPoints } from './src/three/visitBox3CornerPoints';

package/dist/packages/utilities/src/batchedDebounce.d.ts

@@ -0,0 +1,58 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import debounce from 'lodash/debounce';
+export interface BatchedDebounce<T, R> {
+    (item: T): Promise<R>;
+    cancel: () => void;
+}
+type BatchCallback<T, R> = (items: T[]) => R extends void ? Promise<void> | void : Promise<R[]> | R[];
+/**
+ * Creates a debounced function that batches multiple individual calls into a single batch operation.
+ * Each call returns a promise that resolves with the corresponding result from the batch callback.
+ *
+ * @template T - The type of input items
+ * @template R - The type of result items (use void for callbacks that don't return results)
+ *
+ * @param callback - Function that processes a batch of items. Should return an array with the same
+ * length as the input array, or void if no results are needed.
+ * @param wait - The number of milliseconds to delay before processing the batch
+ * @param options - Optional debounce options (leading, trailing, maxWait) passed to lodash debounce
+ *
+ * @returns A debounced function that accepts individual items and returns promises for their results.
+ * The function includes a `cancel()` method to cancel pending batches.
+ *
+ * @example
+ * ```typescript
+ * // With results
+ * const batchedFetch = batchedDebounce(
+ *   async (ids: number[]) => {
+ *     const response = await fetch('/api/items', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ ids })
+ *     });
+ *     return response.json();
+ *   },
+ *   100
+ * );
+ *
+ * const item1 = batchedFetch(1);
+ * const item2 = batchedFetch(2);
+ * const results = await Promise.all([item1, item2]);
+ *
+ * // Without results (void)
+ * const batchedLog = batchedDebounce(
+ *   async (ids: number[]) => {
+ *     await fetch('/api/log', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ ids })
+ *     });
+ *   },
+ *   100
+ * );
+ *
+ * await batchedLog(1);
+ * ```
+ */
+export declare function batchedDebounce<T, R = void>(callback: BatchCallback<T, R>, wait: number, options?: Parameters<typeof debounce>[2]): BatchedDebounce<T, R>;
+export {};

package/dist/packages/utilities/src/events/EventTrigger.d.ts

@@ -1,6 +1,10 @@
 /*!
  * Copyright 2021 Cognite AS
  */
+/**
+ * Extracts the listener type from an EventTrigger in an events map
+ */
+export type EventListener<T extends Record<string, EventTrigger<(...args: any[]) => void>>, K extends keyof T> = T[K] extends EventTrigger<infer U> ? U : never;
 /**
  * Subscribable event source.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.28.5",
+  "version": "4.28.6",
   "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": {
@@ -108,7 +108,7 @@
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-unused-imports": "^3.1.0",
     "file-loader": "^6.2.0",
-    "glob": "^11.0.0",
+    "glob": "^11.1.0",
     "glslify-loader": "^2.0.0",
     "html-webpack-plugin": "^5.6.0",
     "jest": "^29.7.0",