@cognite/reveal 2.1.2 → 3.0.0-alpha.0

package/packages/camera-manager/src/ComboControls.d.ts

@@ -2,13 +2,13 @@
  * Copyright 2021 Cognite AS
  */
 import { EventDispatcher, Vector3, PerspectiveCamera, OrthographicCamera } from 'three';
-export default class ComboControls extends EventDispatcher {
+export declare class ComboControls extends EventDispatcher {
     enabled: boolean;
     enableDamping: boolean;
     dampingFactor: number;
     dynamicTarget: boolean;
     minDistance: number;
-    maxDistance: number;
+    minZoomDistance: number;
     dollyFactor: number;
     minPolarAngle: number;
     maxPolarAngle: number;
@@ -32,25 +32,34 @@ export default class ComboControls extends EventDispatcher {
     minZoom: number;
     maxZoom: number;
     orthographicCameraDollyFactor: number;
-    private temporarilyDisableDamping;
-    private camera;
-    private firstPersonMode;
-    private reusableCamera;
-    private reusableVector3;
-    private _accumulatedMouseMove;
-    private domElement;
-    private target;
-    private targetEnd;
-    private spherical;
-    private sphericalEnd;
-    private deltaTarget;
-    private keyboard;
-    private offsetVector;
-    private panVector;
-    private raycaster;
-    private targetFPS;
-    private targetFPSOverActualFPS;
-    private isFocused;
+    lookAtViewTarget: boolean;
+    useScrollTarget: boolean;
+    zoomToCursor: boolean;
+    minDeltaRatio: number;
+    maxDeltaRatio: number;
+    minDeltaDownscaleCoefficient: number;
+    maxDeltaDownscaleCoefficient: number;
+    private _temporarilyDisableDamping;
+    private readonly _camera;
+    private _firstPersonMode;
+    private readonly _reusableCamera;
+    private readonly _reusableVector3;
+    private readonly _accumulatedMouseMove;
+    private readonly _domElement;
+    private readonly _target;
+    private readonly _viewTarget;
+    private readonly _scrollTarget;
+    private readonly _targetEnd;
+    private readonly _spherical;
+    private _sphericalEnd;
+    private readonly _deltaTarget;
+    private _keyboard;
+    private readonly _offsetVector;
+    private readonly _panVector;
+    private readonly _raycaster;
+    private readonly _targetFPS;
+    private _targetFPSOverActualFPS;
+    private _isFocused;
     constructor(camera: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
     update: (deltaTime: number) => boolean;
     getState: () => {
@@ -58,26 +67,35 @@ export default class ComboControls extends EventDispatcher {
         position: Vector3;
     };
     setState: (position: Vector3, target: Vector3) => void;
+    setViewTarget: (target: Vector3) => void;
+    setScrollTarget: (target: Vector3) => void;
     triggerCameraChangeEvent: () => void;
-    private onMouseDown;
-    private onMouseUp;
-    private onMouseWheel;
-    private onTouchStart;
-    private onFocusChanged;
-    private onContextMenu;
-    private rotate;
-    private startMouseRotation;
-    private startMousePan;
-    private startTouchRotation;
-    private startTouchPinch;
-    private handleKeyboard;
-    private rotateSpherical;
-    private rotateFirstPersonMode;
-    private pan;
-    private dollyOrthographicCamera;
-    private dollyPerspectiveCamera;
-    private dolly;
-    private getDollyDeltaDistance;
-    private panLeft;
-    private panUp;
+    private calculateShortestDeltaTheta;
+    private readonly convertPixelCoordinatesToNormalized;
+    private readonly onMouseDown;
+    private readonly onMouseUp;
+    private readonly onMouseWheel;
+    private readonly onTouchStart;
+    private readonly onFocusChanged;
+    private readonly isDescendant;
+    private readonly onContextMenu;
+    private readonly rotate;
+    private readonly startMouseRotation;
+    private readonly startMousePan;
+    private readonly startTouchRotation;
+    private readonly startTouchPinch;
+    private readonly handleKeyboard;
+    private readonly rotateSpherical;
+    private readonly rotateFirstPersonMode;
+    private readonly pan;
+    private readonly dollyOrthographicCamera;
+    private readonly calculateNewRadiusAndTargetOffsetLerp;
+    private readonly clampedMap;
+    private readonly calculateNewRadiusAndTargetOffsetScrollTarget;
+    private readonly dollyWithWheelScroll;
+    private readonly dollyPerspectiveCamera;
+    private readonly dolly;
+    private readonly getDollyDeltaDistance;
+    private readonly panLeft;
+    private readonly panUp;
 }

package/packages/camera-manager/src/Keyboard.d.ts

@@ -1,14 +1,17 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
 export default class Keyboard {
     private keys;
     private _disabled;
     get disabled(): boolean;
     set disabled(isDisabled: boolean);
     constructor();
-    isPressed: (key: string) => boolean;
-    comsumePressed: (key: string) => boolean;
-    private addEventListeners;
-    private removeEventListeners;
-    private onKeydown;
-    private onKeyup;
-    private clearPressedKeys;
+    isPressed(key: string): boolean;
+    comsumePressed(key: string): boolean;
+    private readonly addEventListeners;
+    private readonly removeEventListeners;
+    private readonly onKeydown;
+    private readonly onKeyup;
+    private readonly clearPressedKeys;
 }

package/packages/camera-manager/src/types.d.ts

@@ -0,0 +1,64 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type CameraControlsOptions = {
+    /**
+     * Sets mouse wheel initiated action.
+     *
+     * Modes:
+     *
+     * 'zoomToTarget' - zooms just to the current target (center of the screen) of the camera.
+     *
+     * 'zoomPastCursor' - zooms in the direction of the ray coming from camera through cursor screen position, allows going through objects.
+     *
+     * 'zoomToCursor' - mouse wheel scroll zooms towards the point on the model where cursor is hovering over, doesn't allow going through objects.
+     *
+     * Default is 'zoomPastCursor'.
+     *
+     */
+    mouseWheelAction?: 'zoomToTarget' | 'zoomPastCursor' | 'zoomToCursor';
+    /**
+     * Enables or disables change of camera target on mouse click. New target is then set to the point of the model under current cursor position.
+     *
+     * Default is false.
+     *
+     */
+    changeCameraTargetOnClick?: boolean;
+};
+export declare type ControlsState = {
+    position: THREE.Vector3;
+    target: THREE.Vector3;
+};
+export declare type CameraManagerCallbackData = {
+    intersection: {
+        /**
+         * Coordinate of the intersection.
+         */
+        point: THREE.Vector3;
+        /**
+         * Distance from the camera to the intersection.
+         */
+        distanceToCamera: number;
+    } | null;
+    /**
+     * Bounding box for all models on the scene
+     */
+    modelsBoundingBox: THREE.Box3;
+};
+/**
+ * Delegate for pointer events.
+ * @module @cognite/reveal
+ */
+export declare type PointerEventDelegate = (event: {
+    offsetX: number;
+    offsetY: number;
+}) => void;
+/**
+ * Type defining camera change event data.
+ */
+export declare type CameraChangeData = (event: {
+    camera: {
+        position: THREE.Vector3;
+        target: THREE.Vector3;
+    };
+}) => void;

package/packages/data-source/index.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { DataSource } from './src/DataSource';
+export { CdfDataSource } from './src/CdfDataSource';
+export { LocalDataSource } from './src/LocalDataSource';

package/packages/data-source/src/CdfDataSource.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { DataSource } from './DataSource';
+import { NodesApiClient } from '../../nodes-api';
+import { ModelDataProvider, ModelMetadataProvider } from '../../modeldata-api';
+/**
+ * Data source for Cognite Data Fusion.
+ */
+export declare class CdfDataSource implements DataSource {
+    private readonly _metadataProvider;
+    private readonly _nodesApiClient;
+    private readonly _modelDataClient;
+    constructor(sdkClient: CogniteClient);
+    getNodesApiClient(): NodesApiClient;
+    getModelDataProvider(): ModelDataProvider;
+    getModelMetadataProvider(): ModelMetadataProvider;
+}

package/packages/data-source/src/DataSource.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { NodesApiClient } from '../../nodes-api';
+import { ModelDataProvider, ModelMetadataProvider } from '../../modeldata-api';
+/**
+ * Describes how Reveal data is stored, and provides means to create custom storage providers
+ * that Reveal will fetch data from.
+ * @version New since 2.2
+ */
+export interface DataSource {
+    /**
+     * Gets a node API client that is able to fetch data about
+     * models.
+     */
+    getNodesApiClient(): NodesApiClient;
+    /**
+     * Gets a metadata provider for models.
+     */
+    getModelMetadataProvider(): ModelMetadataProvider;
+    /**
+     * Gets a client that is able to download geometry and other files
+     * for models.
+     */
+    getModelDataProvider(): ModelDataProvider;
+}

package/packages/data-source/src/LocalDataSource.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { NodesApiClient } from '../../nodes-api';
+import { ModelDataProvider, ModelMetadataProvider } from '../../modeldata-api';
+import { DataSource } from './DataSource';
+/**
+ * Data source for loading models from local storage (i.e. by URL).
+ * This implementation is meant for use in development.
+ */
+export declare class LocalDataSource implements DataSource {
+    getNodesApiClient(): NodesApiClient;
+    getModelDataProvider(): ModelDataProvider;
+    getModelMetadataProvider(): ModelMetadataProvider;
+}

package/packages/metrics/index.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { MetricsLogger } from './src/MetricsLogger';
+export { EventProps, TrackedEvents } from './src/types';

package/packages/metrics/src/MetricsLogger.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { TrackedEvents, EventProps } from './types';
+export declare class MetricsLogger {
+    _sessionProps: {
+        VERSION: string;
+        project: string;
+        application: string;
+        sessionId: string;
+    };
+    private constructor();
+    static init(logMetrics: boolean, project: string, applicationId: string, eventProps: EventProps): void;
+    private innerTrackEvent;
+    static trackEvent(eventName: TrackedEvents, eventProps: EventProps): void;
+    static trackCreateTool(toolName: string): void;
+    static trackLoadModel(eventProps: EventProps, modelIdentifier: any): void;
+    static trackCadModelStyled(nodeCollectionClassToken: string, appearance: any): void;
+    static trackError(error: Error, eventProps: EventProps): void;
+    static trackCameraNavigation(eventProps: EventProps): void;
+}

package/packages/metrics/src/types.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type TrackedEvents = 'init' | 'construct3dViewer' | 'loadModel' | 'error' | 'cameraNavigated' | 'toolCreated' | 'cadModelStyleAssigned';
+export declare type EventProps = {
+    [key: string]: any;
+};

package/packages/modeldata-api/index.d.ts

@@ -1,8 +1,13 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { CdfModelDataClient } from './src/CdfModelDataClient';
+export { CdfModelDataProvider } from './src/CdfModelDataProvider';
+export { CdfModelIdentifier } from './src/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/CdfModelMetadataProvider';
-export { LocalModelDataClient } from './src/LocalModelDataClient';
+export { CdfModelOutputsProvider } from './src/CdfModelOutputsProvider';
+export { LocalModelDataProvider } from './src/LocalModelDataProvider';
+export { LocalModelIdentifier } from './src/LocalModelIdentifier';
 export { LocalModelMetadataProvider } from './src/LocalModelMetadataProvider';
-export { ModelDataClient, LocalModelIdentifier, CdfModelIdentifier, BinaryFileProvider, HttpHeadersProvider, ModelMetadataProvider, File3dFormat } from './src/types';
+export { ModelIdentifier } from './src/ModelIdentifier';
+export { ModelMetadataProvider } from './src/ModelMetadataProvider';
+export { BinaryFileProvider, File3dFormat, HttpHeadersProvider, ModelDataProvider, BlobOutputMetadata } from './src/types';

package/packages/modeldata-api/src/{CdfModelDataClient.d.ts → CdfModelDataProvider.d.ts}

@@ -1,17 +1,17 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { CogniteClient } from '@cognite/sdk';
-import { ModelDataClient } from './types';
+import { CogniteClient, HttpHeaders } from '@cognite/sdk';
+import { ModelDataProvider } from './types';
 /**
  * Provides 3D V2 specific extensions for the standard CogniteClient used by Reveal.
  */
-export declare class CdfModelDataClient implements ModelDataClient {
+export declare class CdfModelDataProvider implements ModelDataProvider {
     private readonly client;
-    private appId;
+    private authenticationPromise;
     constructor(client: CogniteClient);
-    get headers(): import("@cognite/sdk").HttpHeaders;
+    get headers(): HttpHeaders;
     getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
-    getApplicationIdentifier(): string;
+    private fetchWithRetry;
 }

package/packages/modeldata-api/src/CdfModelIdentifier.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { ModelIdentifier } from '..';
+/**
+ * Identifies a 3D model stored in CDF by the combination of a modelId, a revisionId
+ * and a format.
+ */
+export declare class CdfModelIdentifier implements ModelIdentifier {
+    readonly revealInternalId: symbol;
+    readonly modelId: number;
+    readonly revisionId: number;
+    constructor(modelId: number, revisionId: number);
+    toString(): string;
+}

package/packages/modeldata-api/src/CdfModelMetadataProvider.d.ts

@@ -2,35 +2,19 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
+import { BlobOutputMetadata, File3dFormat } from './types';
+import { ModelMetadataProvider } from './ModelMetadataProvider';
 import { CogniteClient } from '@cognite/sdk';
-import { File3dFormat, CameraConfiguration, ModelMetadataProvider } from './types';
-import { Model3DOutputList } from './Model3DOutputList';
-export declare class CdfModelMetadataProvider implements ModelMetadataProvider<{
-    modelId: number;
-    revisionId: number;
-    format: File3dFormat;
-}> {
+import { ModelIdentifier } from './ModelIdentifier';
+export declare class CdfModelMetadataProvider implements ModelMetadataProvider {
     private readonly _client;
     constructor(client: CogniteClient);
-    getModelMatrix(modelIdentifier: {
-        modelId: number;
-        revisionId: number;
-        format: File3dFormat | string;
-    }): Promise<THREE.Matrix4>;
-    getModelCamera(modelIdentifier: {
-        modelId: number;
-        revisionId: number;
-        format: File3dFormat | string;
-    }): Promise<CameraConfiguration | undefined>;
-    getModelUri(modelIdentifier: {
-        modelId: number;
-        revisionId: number;
-        format: File3dFormat | string;
-    }): Promise<string>;
-    getOutputs(modelIdentifier: {
-        modelId: number;
-        revisionId: number;
-        format?: File3dFormat | string;
-    }): Promise<Model3DOutputList>;
+    getModelMatrix(modelIdentifier: ModelIdentifier, format: File3dFormat): Promise<THREE.Matrix4>;
+    getModelCamera(modelIdentifier: ModelIdentifier): Promise<{
+        position: THREE.Vector3;
+        target: THREE.Vector3;
+    } | undefined>;
+    getModelUri(modelIdentifier: ModelIdentifier, formatMetadata: BlobOutputMetadata): Promise<string>;
+    getModelOutputs(modelIdentifier: ModelIdentifier): Promise<BlobOutputMetadata[]>;
     private getRequestPath;
 }

package/packages/modeldata-api/src/CdfModelOutputsProvider.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { CdfModelIdentifier } from './CdfModelIdentifier';
+import { Model3DOutputList } from './Model3DOutputList';
+import { File3dFormat } from './types';
+import { CogniteClient } from '@cognite/sdk';
+/**
+ * Helper class for getting the available 'outputs' from the Cognite
+ * 3D processing pipeline for a given model.
+ */
+export declare class CdfModelOutputsProvider {
+    private readonly _client;
+    constructor(client: CogniteClient);
+    getOutputs(modelIdentifier: CdfModelIdentifier, modelFormat: File3dFormat): Promise<Model3DOutputList>;
+}

package/packages/modeldata-api/src/LocalModelDataProvider.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { HttpHeaders } from '@cognite/sdk-core';
+import { ModelDataProvider } from './types';
+export declare class LocalModelDataProvider implements ModelDataProvider {
+    get headers(): HttpHeaders;
+    getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
+    getJsonFile(baseUrl: string, fileName: string): Promise<any>;
+}

package/packages/modeldata-api/src/LocalModelIdentifier.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { ModelIdentifier } from './ModelIdentifier';
+/**
+ * Identifies a 3D model by a URL. This implementation is used for testing
+ * purposes.
+ */
+export declare class LocalModelIdentifier implements ModelIdentifier {
+    readonly revealInternalId: symbol;
+    readonly localPath: string;
+    constructor(localPath: string);
+    toString(): string;
+}

package/packages/modeldata-api/src/LocalModelMetadataProvider.d.ts

@@ -2,18 +2,15 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { ModelMetadataProvider } from './types';
-import { CameraConfiguration } from './types';
-export declare class LocalModelMetadataProvider implements ModelMetadataProvider<{
-    fileName: string;
-}> {
-    getModelUri(params: {
-        fileName: string;
-    }): Promise<string>;
-    getModelMatrix(_identifier: {
-        fileName: string;
-    }): Promise<THREE.Matrix4>;
-    getModelCamera(_identifier: {
-        fileName: string;
-    }): Promise<CameraConfiguration | undefined>;
+import { ModelIdentifier } from './ModelIdentifier';
+import { ModelMetadataProvider } from './ModelMetadataProvider';
+import { BlobOutputMetadata } from './types';
+export declare class LocalModelMetadataProvider implements ModelMetadataProvider {
+    getModelUri(modelIdentifier: ModelIdentifier): Promise<string>;
+    getModelMatrix(modelIdentifier: ModelIdentifier): Promise<THREE.Matrix4>;
+    getModelCamera(modelIdentifier: ModelIdentifier): Promise<{
+        position: THREE.Vector3;
+        target: THREE.Vector3;
+    } | undefined>;
+    getModelOutputs(modelIdentifier: ModelIdentifier): Promise<BlobOutputMetadata[]>;
 }

package/packages/modeldata-api/src/ModelIdentifier.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Identifies a 3D model. Typically, implementations will use {@link CdfModelIdentifier}.
+ */
+export interface ModelIdentifier {
+    /**
+     * Unique ID of the model.
+     */
+    readonly revealInternalId: symbol;
+}

package/packages/modeldata-api/src/ModelMetadataProvider.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ModelIdentifier } from './ModelIdentifier';
+import { BlobOutputMetadata, File3dFormat } from './types';
+/**
+ * Provides metadata for 3D models.
+ * @version New since 2.2
+ */
+export interface ModelMetadataProvider {
+    getModelOutputs(modelIdentifier: ModelIdentifier): Promise<BlobOutputMetadata[]>;
+    getModelUri(identifier: ModelIdentifier, formatMetadata: BlobOutputMetadata): Promise<string>;
+    getModelCamera(identifier: ModelIdentifier): Promise<{
+        position: THREE.Vector3;
+        target: THREE.Vector3;
+    } | undefined>;
+    getModelMatrix(identifier: ModelIdentifier, format: File3dFormat | string): Promise<THREE.Matrix4>;
+}

package/packages/modeldata-api/src/types.d.ts

@@ -1,53 +1,46 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import * as THREE from 'three';
 import { HttpHeaders } from '@cognite/sdk-core';
-export interface LocalModelIdentifier {
-    fileName: string;
-}
-export interface CdfModelIdentifier {
-    modelId: number;
-    revisionId: number;
-}
 export interface JsonFileProvider {
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
 }
 export interface BinaryFileProvider {
     getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
 }
-export interface ModelMetadataProvider<TModelIdentifier> {
+/**
+ * Provides data for 3D models.
+ * @version New since 2.2
+ */
+export interface ModelDataProvider extends HttpHeadersProvider, JsonFileProvider, BinaryFileProvider {
     /**
-     * Returns an URI that identifies the resource where model geometry and metadata files are stored.
-     * @param identifier Identifier of the model
+     * Download and parse a JSON file and return the resulting struct.
+     * @param baseUrl     Base URL of the model.
+     * @param fileName    Filename of JSON file.
      */
-    getModelUri(identifier: TModelIdentifier): Promise<string>;
-    getModelCamera(identifier: TModelIdentifier): Promise<CameraConfiguration | undefined>;
-    getModelMatrix(identifier: TModelIdentifier): Promise<THREE.Matrix4>;
-}
-export interface ModelDataClient extends HttpHeadersProvider, JsonFileProvider, BinaryFileProvider {
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
-    getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
     /**
-     * Returns an identifier that can be used to identify the application Reveal is used in.
+     * Downloads a binary blob.
+     * @param baseUrl     Base URL of the model.
+     * @param fileName    Filename of binary file.
      */
-    getApplicationIdentifier(): string;
+    getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
 }
 export interface HttpHeadersProvider {
     readonly headers: HttpHeaders;
 }
 export declare enum File3dFormat {
     EptPointCloud = "ept-pointcloud",
+    /**
+     * V8 models only due to bug for version checks in Reveal <3.0
+     */
     RevealCadModel = "reveal-directory",
+    /**
+     * Reveal v9 and above (GLTF based output)
+     */
+    GltfCadModel = "gltf-directory",
     AnyFormat = "all-outputs"
 }
-/**
- * Represents a camera configuration, consisting of a camera position and target.
- */
-export declare type CameraConfiguration = {
-    readonly position: THREE.Vector3;
-    readonly target: THREE.Vector3;
-};
 export interface BlobOutputMetadata {
     blobId: number;
     format: File3dFormat | string;

package/packages/nodes-api/index.d.ts

@@ -4,4 +4,3 @@
 export { NodesApiClient } from './src/NodesApiClient';
 export { NodesCdfClient } from './src/NodesCdfClient';
 export { NodesLocalClient } from './src/NodesLocalClient';
-export { NodeTreeIndexAndSubtreeSize } from './src/types';