@cognite/reveal 2.1.2 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cognite/reveal",
-	"version": "2.1.2",
+	"version": "2.3.0",
 	"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": {
@@ -19,14 +19,14 @@
 	"main": "index.js",
 	"types": "index.d.ts",
 	"dependencies": {
-		"@cognite/potree-core": "1.5.0",
-		"@cognite/reveal-parser-worker": "1.2.0",
+		"@cognite/potree-core": "^1.5.1",
+		"@cognite/reveal-parser-worker": "1.3.0",
 		"@gltf-transform/core": "^0.12.11",
 		"@gltf-transform/extensions": "^0.12.11",
 		"@tweenjs/tween.js": "^18.6.4",
 		"@types/three": "0.133.0",
 		"assert": "^2.0.0",
-		"comlink": "4.3.1",
+		"comlink": "^4.3.1",
 		"geo-three": "^0.0.15",
 		"glslify": "^7.1.1",
 		"glslify-import": "^3.1.0",

package/packages/cad-geometry-loaders/index.d.ts

@@ -1,16 +1,10 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { CadNode, SuggestedCameraConfig } from './src/CadNode';
 export { SimpleAndDetailedToSector3D } from './src/sector/SimpleAndDetailedToSector3D';
-export { NodeTransformProvider } from './src/material-manager/styling/NodeTransformProvider';
 export { CadModelSectorBudget } from './src/CadModelSectorBudget';
-export { SectorNode } from './src/sector/SectorNode';
 export { CachedRepository } from './src/sector/CachedRepository';
-export { defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode, SectorQuads, RenderOptions } from './src/material-manager/rendering/types';
 export { CadLoadingHints } from './src/CadLoadingHints';
-export { EffectRenderManager } from './src/material-manager/rendering/EffectRenderManager';
-export { CadMaterialManager } from './src/material-manager/CadMaterialManager';
 export { CadModelUpdateHandler } from './src/CadModelUpdateHandler';
 export { LoadingState } from './src/utilities/types';
 export { SectorCuller } from './src/sector/culling/SectorCuller';

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

@@ -3,8 +3,8 @@
  */
 import * as THREE from 'three';
 import { ConsumedSector } from '../../cad-parsers';
+import { CadNode } from '../../rendering';
 import { Observable } from 'rxjs';
-import { CadNode } from './CadNode';
 import { SectorCuller } from './sector/culling/SectorCuller';
 import { CadLoadingHints } from './CadLoadingHints';
 import { Repository } from './sector/Repository';

package/packages/cad-geometry-loaders/src/sector/CachedRepository.d.ts

@@ -1,9 +1,9 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { CadSectorParser, WantedSector, ConsumedSector } from '../../../cad-parsers';
 import { SimpleAndDetailedToSector3D } from './SimpleAndDetailedToSector3D';
 import { Repository } from './Repository';
+import { CadSectorParser, WantedSector, ConsumedSector } from '../../../cad-parsers';
 import { BinaryFileProvider } from '../../../modeldata-api';
 export declare class CachedRepository implements Repository {
     private readonly _consumedSectorCache;

package/packages/cad-geometry-loaders/src/sector/SimpleAndDetailedToSector3D.d.ts

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { SectorQuads } from '@cognite/reveal-parser-worker';
 import { SectorMetadata, InstancedMeshFile, SectorGeometry } from '../../../cad-parsers';
 import { AutoDisposeGroup } from '../../../utilities';
-import { CadMaterialManager } from '../material-manager/CadMaterialManager';
+import { CadMaterialManager } from '../../../rendering';
 export declare class SimpleAndDetailedToSector3D {
     private readonly materialManager;
     constructor(materialManager: CadMaterialManager);

package/packages/cad-geometry-loaders/src/sector/culling/TakenSectorTree.d.ts

@@ -7,7 +7,7 @@ export declare class TakenSectorTree {
     get totalCost(): SectorCost;
     private readonly sectors;
     private readonly determineSectorCost;
-    private _totalCost;
+    private readonly _totalCost;
     constructor(sectorRoot: SectorMetadata, determineSectorCost: DetermineSectorCostDelegate);
     determineWantedSectorCount(): number;
     toWantedSectors(modelIdentifier: string, modelBaseUrl: string, geometryClipBox: THREE.Box3 | null): PrioritizedWantedSector[];

package/packages/cad-geometry-loaders/src/sector/sectorUtilities.d.ts

@@ -4,8 +4,9 @@
 import * as THREE from 'three';
 import { SectorQuads } from '@cognite/reveal-parser-worker';
 import { AutoDisposeGroup } from '../../../utilities';
-import { SectorMetadata, SectorGeometry, WantedSector, ConsumedSector, InstancedMeshFile, Materials } from '../../../cad-parsers';
-import { Observable, OperatorFunction } from 'rxjs';
+import { SectorMetadata, SectorGeometry, WantedSector, ConsumedSector, InstancedMeshFile } from '../../../cad-parsers';
+import { Observable, OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';
+import { Materials } from '../../../rendering';
 export declare function consumeSectorSimple(sector: SectorQuads, sectorBounds: THREE.Box3, materials: Materials, geometryClipBox: THREE.Box3 | null): {
     sectorMeshes: AutoDisposeGroup;
     instancedMeshes: InstancedMeshFile[];
@@ -14,6 +15,6 @@ export declare function consumeSectorDetailed(sector: SectorGeometry, metadata:
     sectorMeshes: AutoDisposeGroup;
     instancedMeshes: InstancedMeshFile[];
 };
-export declare function distinctUntilLevelOfDetailChanged(): import("rxjs").UnaryFunction<Observable<ConsumedSector>, Observable<ConsumedSector>>;
+export declare function distinctUntilLevelOfDetailChanged(): MonoTypeOperatorFunction<ConsumedSector>;
 export declare function filterCurrentWantedSectors(wantedObservable: Observable<WantedSector[]>): OperatorFunction<ConsumedSector, ConsumedSector>;
 export declare function findSectorMetadata(root: SectorMetadata, sectorId: number): SectorMetadata;

package/packages/cad-geometry-loaders/src/utilities/rxOperations.d.ts

@@ -1,5 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export declare const emissionLastMillis: (millis: number) => import("rxjs").UnaryFunction<import("rxjs").Observable<unknown>, import("rxjs").Observable<boolean>>;
-export declare const delayedSwitch: (millis: number) => import("rxjs").Observable<boolean>;
+import { Observable, OperatorFunction } from 'rxjs';
+export declare function emissionLastMillis(millis: number): OperatorFunction<unknown, boolean>;
+export declare function delayedSwitch(millis: number): Observable<boolean>;

package/packages/cad-geometry-loaders/src/utilities/types.d.ts

@@ -1,29 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import * as THREE from 'three';
-/**
- * Colors from the Cognite theme.
- */
-export declare class CogniteColors {
-    static readonly Black: THREE.Color;
-    static readonly White: THREE.Color;
-    static readonly Cyan: THREE.Color;
-    static readonly Blue: THREE.Color;
-    static readonly Purple: THREE.Color;
-    static readonly Pink: THREE.Color;
-    static readonly Orange: THREE.Color;
-    static readonly Yellow: THREE.Color;
-    static readonly VeryLightGray: THREE.Color;
-    static readonly LightGray: THREE.Color;
-}
-/**
- * Some additional colors to supplement {@link CogniteColors}.
- */
-export declare class RevealColors {
-    static readonly Red: THREE.Color;
-    static readonly Green: THREE.Color;
-}
 /**
  * State holding information about data being loaded.
  */

package/packages/cad-parsers/index.d.ts

@@ -9,12 +9,13 @@ export { SectorSceneImpl } from './src/utilities/SectorScene';
 export { SectorSceneFactory } from './src/utilities/SectorSceneFactory';
 export { SectorScene } from './src/utilities/types';
 export { SectorMetadataIndexFileSection, SectorMetadataFacesFileSection, SectorMetadata } from './src/metadata/types';
+export { SectorNode } from './src/sector/SectorNode';
+export { RootSectorNode } from './src/sector/RootSectorNode';
 export { CadSectorParser } from './src/cad/CadSectorParser';
-export { RenderMode } from './src/cad/RenderMode';
 export { LevelOfDetail } from './src/cad/LevelOfDetail';
+export { filterPrimitivesOutsideClipBoxByBaseBoundsAndInstanceMatrix, filterPrimitivesOutsideClipBoxByCenterAndRadius, filterPrimitivesOutsideClipBoxByEllipse, filterPrimitivesOutsideClipBoxByVertices } from './src/cad/filterPrimitives';
+export { filterInstanceMesh } from './src/cad/filterInstanceMesh';
+export { boxGeometry, quadGeometry, coneGeometry, trapeziumGeometry, nutGeometry, torusLodGeometries, boxGeometryBoundingBox, quadGeometryBoundingBox, nutGeometryBoundingBox } from './src/cad/primitiveGeometries';
 export { SectorGeometry, InstancedMeshFile, InstancedMesh, TriangleMesh, WantedSector, ConsumedSector } from './src/cad/types';
-export { createMaterials, Materials } from './src/cad/materials';
-export { createPrimitives } from './src/cad/primitives';
-export { filterPrimitivesOutsideClipBoxByBaseBoundsAndInstanceMatrix } from './src/cad/filterPrimitives';
 export { WellKnownDistanceToMeterConversionFactors } from './src/utilities/types';
-export { outlineDetectionShaders, fxaaShaders, ssaoShaders, ssaoBlurCombineShaders, coverageShaders } from './src/cad/shaders';
+export { createTriangleMeshes } from './src/cad/triangleMeshes';

package/packages/{cad-geometry-loaders/src/material-manager/rendering → cad-parsers/src/cad}/filterInstanceMesh.d.ts

@@ -2,5 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { InstancedMesh } from '../../../../cad-parsers';
+import { InstancedMesh } from './types';
 export declare function filterInstanceMesh(vertices: Float32Array, indices: Uint32Array, instanceMesh: InstancedMesh, geometryClipBox: THREE.Box3 | null): InstancedMesh;

package/packages/cad-parsers/src/cad/primitiveGeometries.d.ts

@@ -23,7 +23,7 @@ export declare const coneGeometry: {
 export declare const torusLodGeometries: {
     index: THREE.Uint16BufferAttribute;
     position: THREE.Float32BufferAttribute;
-}[], torusGeometryBoundingBox: THREE.Box3;
+}[];
 export declare const nutGeometry: {
     index: THREE.BufferAttribute | null;
     position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;

package/packages/{cad-geometry-loaders/src/material-manager/rendering → cad-parsers/src/cad}/triangleMeshes.d.ts

@@ -2,5 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { TriangleMesh } from '../../../../cad-parsers';
+import { TriangleMesh } from '../../../cad-parsers';
 export declare function createTriangleMeshes(triangleMeshes: TriangleMesh[], bounds: THREE.Box3, material: THREE.ShaderMaterial, geometryClipBox: THREE.Box3 | null): THREE.Mesh[];

package/packages/cad-parsers/src/metadata/CadModelMetadataRepository.d.ts

@@ -4,13 +4,13 @@
 import { CadMetadataParser } from './CadMetadataParser';
 import { CadModelMetadata } from './CadModelMetadata';
 import { MetadataRepository } from './MetadataRepository';
-import { ModelDataClient, ModelMetadataProvider } from '../../../modeldata-api';
-export declare class CadModelMetadataRepository<TModelIdentifier> implements MetadataRepository<TModelIdentifier, Promise<CadModelMetadata>> {
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../../modeldata-api';
+export declare class CadModelMetadataRepository implements MetadataRepository<Promise<CadModelMetadata>> {
     private readonly _modelMetadataProvider;
-    private readonly _modelDataClient;
+    private readonly _modelDataProvider;
     private readonly _cadSceneParser;
     private readonly _blobFileName;
     private _currentModelIdentifier;
-    constructor(modelMetadataProvider: ModelMetadataProvider<TModelIdentifier>, modelDataClient: ModelDataClient, cadMetadataParser: CadMetadataParser, blobFileName?: string);
-    loadData(model: TModelIdentifier): Promise<CadModelMetadata>;
+    constructor(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, cadMetadataParser: CadMetadataParser, blobFileName?: string);
+    loadData(modelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
 }

package/packages/cad-parsers/src/metadata/MetadataRepository.d.ts

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export interface MetadataRepository<Input, Output> {
-    loadData(input: Input): Output;
+import { ModelIdentifier } from '../../../modeldata-api';
+export interface MetadataRepository<Output> {
+    loadData(modelIdentifier: ModelIdentifier): Output;
 }

package/packages/{cad-geometry-loaders → cad-parsers}/src/sector/RootSectorNode.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { SectorNode } from './SectorNode';
-import { CadModelMetadata } from '../../../cad-parsers';
+import { CadModelMetadata } from '../metadata/CadModelMetadata';
 export declare class RootSectorNode extends SectorNode {
     readonly sectorNodeMap: Map<number, SectorNode>;
     constructor(modelMetadata: CadModelMetadata);

package/packages/{cad-geometry-loaders → cad-parsers}/src/sector/SectorNode.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { AutoDisposeGroup } from '../../../utilities';
-import { LevelOfDetail } from '../../../cad-parsers';
+import { LevelOfDetail } from '../cad/LevelOfDetail';
 export declare class SectorNode extends THREE.Group {
     readonly sectorPath: string;
     readonly sectorId: number;

package/packages/cad-parsers/src/utilities/SectorSceneFactory.d.ts

@@ -1,12 +1,9 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SectorSceneImpl } from './SectorScene';
 import { SectorMetadata } from '../metadata/types';
+import { SectorScene } from './types';
 /**
  * Factory for creating instance of {@link SectorScene} based on
  * the version of the format provided.
  */
 export declare class SectorSceneFactory {
-    createSectorScene(version: number, maxTreeIndex: number, unit: string, root: SectorMetadata): SectorSceneImpl;
+    createSectorScene(version: number, maxTreeIndex: number, unit: string, root: SectorMetadata): SectorScene;
 }

package/packages/cad-styling/src/CombineNodeCollectionBase.d.ts

@@ -7,7 +7,7 @@ import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBa
  * Node collection that combines the result from multiple underlying node collections.
  */
 export declare abstract class CombineNodeCollectionBase extends NodeCollectionBase {
-    private _changedUnderlyingNodeCollectionHandler;
+    private readonly _changedUnderlyingNodeCollectionHandler;
     private _cachedCombinedIndexSet;
     protected _nodeCollections: NodeCollectionBase[];
     constructor(classToken: string, nodeCollections?: NodeCollectionBase[]);

package/packages/cad-styling/src/NodeAppearanceProvider.d.ts

@@ -24,6 +24,10 @@ export declare class NodeAppearanceProvider {
     clear(): void;
     get isLoading(): boolean;
     private notifyChanged;
+    /**
+     * Schedules event 'changed' to trigger at the next tick.
+     */
+    private readonly scheduleNotifyChanged;
     private notifyLoadingStateChanged;
     private handleNodeCollectionChanged;
 }

package/packages/camera-manager/index.d.ts

@@ -1,4 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { default } from './src/ComboControls';
+export { ComboControls } from './src/ComboControls';
+export { CameraManager } from './src/CameraManager';
+export * from './src/types';

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

@@ -0,0 +1,85 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ComboControls } from './ComboControls';
+import { CameraManagerCallbackData, CameraControlsOptions, CameraChangeData, ControlsState } from './types';
+import { InputHandler } from '../../utilities';
+export declare class CameraManager {
+    private readonly _events;
+    private readonly _controls;
+    private readonly _camera;
+    private readonly _domElement;
+    private readonly _inputHandler;
+    private readonly _raycaster;
+    private isDisposed;
+    private readonly _modelRaycastCallback;
+    private _onClick;
+    private _onWheel;
+    private static readonly DefaultAnimationDuration;
+    private static readonly DefaultMinAnimationDuration;
+    private static readonly DefaultMaxAnimationDuration;
+    private static readonly DefaultMinDistance;
+    private static readonly DefaultMinZoomDistance;
+    private static readonly DefaultMinimalTimeBetweenRaycasts;
+    private static readonly DefaultCameraControlsOptions;
+    private _cameraControlsOptions;
+    automaticNearFarPlane: boolean;
+    automaticControlsSensitivity: boolean;
+    /**
+     * Reusable buffers used by functions in Cognite3dViewer to avoid allocations.
+     */
+    private readonly _updateNearAndFarPlaneBuffers;
+    private readonly _calculateCameraFarBuffers;
+    constructor(camera: THREE.PerspectiveCamera, domElement: HTMLElement, inputHandler: InputHandler, raycastFunction: (x: number, y: number) => Promise<CameraManagerCallbackData>);
+    on(event: 'cameraChange', callback: CameraChangeData): void;
+    off(event: 'cameraChange', callback: CameraChangeData): void;
+    fitCameraToBoundingBox(box: THREE.Box3, duration?: number, radiusFactor?: number): void;
+    set cameraControlsEnabled(enabled: boolean);
+    get cameraControlsEnabled(): boolean;
+    set keyboardNavigationEnabled(enabled: boolean);
+    get keyboardNavigationEnabled(): boolean;
+    get cameraControls(): ComboControls;
+    setCameraTarget(target: THREE.Vector3, animated?: boolean): void;
+    setCameraControlsState(controlsState: ControlsState): void;
+    getCameraControlsState(): ControlsState;
+    getCameraControlsOptions(): CameraControlsOptions;
+    setCameraControlsOptions(controlsOptions: CameraControlsOptions): void;
+    moveCameraTo(position: THREE.Vector3, target: THREE.Vector3, duration?: number): void;
+    moveCameraTargetTo(target: THREE.Vector3, duration?: number): void;
+    updateCameraNearAndFar(camera: THREE.PerspectiveCamera, combinedBbox: THREE.Box3): void;
+    updateCameraControlsState(deltaTime: number): void;
+    dispose(): void;
+    private calculateAnimationStartTarget;
+    private createTweenAnimation;
+    private calculateCameraFar;
+    private calculateCameraNear;
+    /**
+     * Calculates new target when raycaster doesn't have any intersections with the model.
+     * @param cursorPosition Cursor position for desired calculations.
+     * @param cursorPosition.x
+     * @param cursorPosition.y
+     */
+    private calculateNewTargetWithoutModel;
+    /**
+     * Calculates new camera target based on cursor position.
+     * @param event MouseEvent that contains pointer location data.
+     */
+    private calculateNewTarget;
+    /**
+     * Removes controls event listeners if they are defined.
+     */
+    private teardownControls;
+    private handleMouseWheelActionChange;
+    /**
+     * Method for setting up camera controls listeners and values inside current controls class.
+     */
+    private setupControls;
+    /**
+     * Convert pixel coordinates of the cursor to [-1,1]^2 coordinates.
+     * @param pixelX
+     * @param pixelY
+     */
+    private convertPixelCoordinatesToNormalized;
+    private calculateDefaultDuration;
+}

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,36 @@ 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 onPointerDown;
+    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;
+}