@cognite/reveal 4.34.0 → 4.34.2

package/dist/packages/360-images/src/entity/Image360VisualizationBox.d.ts

@@ -1,13 +1,10 @@
+import { Matrix4, Texture, Vector3 } from 'three';
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
 import { DataSourceType, Image360Face, Image360Texture } from '../../../data-providers';
 import { Image360Visualization } from './Image360Visualization';
 import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
 import { JpegType } from '../utils/JpegDataStreamParser';
 import { FaceTextureLoader } from './Image360FaceTextureLoader';
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
 export declare const DEFAULT_IMAGE_360_OPACITY = 1;
 export declare class Image360VisualizationBox implements Image360Visualization {
     private readonly _requestRedraw;
@@ -25,17 +22,17 @@ export declare class Image360VisualizationBox implements Image360Visualization {
     set visible(value: boolean);
     get opacity(): number;
     set opacity(value: number);
-    set scale(value: THREE.Vector3);
+    set scale(value: Vector3);
     set renderOrder(value: number);
     setAnnotations(annotations: ImageAnnotationObject<DataSourceType>[]): void;
-    constructor(worldTransform: THREE.Matrix4, sceneHandler: SceneHandler, device: DeviceDescriptor, _requestRedraw?: () => void, faceTextureLoader?: FaceTextureLoader);
-    setWorldTransform(matrix: THREE.Matrix4): void;
+    constructor(worldTransform: Matrix4, sceneHandler: SceneHandler, device: DeviceDescriptor, _requestRedraw?: () => void, faceTextureLoader?: FaceTextureLoader);
+    setWorldTransform(matrix: Matrix4): void;
     setImages(textures: Image360Texture[]): void;
     private buildVisualizationMesh;
-    getTransform(): THREE.Matrix4;
+    getTransform(): Matrix4;
     loadFaceTextures(faces: Image360Face[], onFirstFaceReady?: () => void, onFirstFaceTypeDetected?: (type: JpegType) => void, abortSignal?: AbortSignal): Promise<Image360Texture[]>;
     private createPlaceholderMesh;
-    updateFaceTexture(face: Image360Face['face'], texture: THREE.Texture): void;
+    updateFaceTexture(face: Image360Face['face'], texture: Texture): void;
     unloadImages(): void;
     setAnnotationsVisibility(visibility: boolean): void;
 }

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

@@ -1,3 +1,4 @@
+import { PerspectiveCamera, Plane, WebGLRenderTarget } from 'three';
 import { PointCloudBudget } from './types';
 import { GeometryFilter, CadModelSectorLoadStatistics, CadNode } from '../../../cad-model';
 import { PointCloudManager, PointCloudNode } from '../../../pointclouds';
@@ -8,10 +9,6 @@ import { RenderMode, RenderPipelineExecutor, CadMaterialManager, RenderPipelineP
 import { CameraManager } from '../../../camera-manager';
 import { DataSourceType, File3dFormat, InternalDataSourceType } from '../../../data-providers';
 import { AddModelOptionsWithModelRevisionId } from '../../../data-providers/src/utilities/internalAddModelOptions';
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
 export type AddCadModelOptions = {
     nodeAppearanceProvider?: NodeAppearanceProvider;
     geometryFilter?: GeometryFilter;
@@ -38,10 +35,10 @@ export declare class RevealManager {
     dispose(): void;
     requestRedraw(): void;
     resetRedraw(): void;
-    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
+    setOutputRenderTarget(target: WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     get materialManager(): CadMaterialManager;
     get needsRedraw(): boolean;
-    update(camera: THREE.PerspectiveCamera): void;
+    update(camera: PerspectiveCamera): void;
     get cadBudget(): CadModelBudget;
     set cadBudget(budget: CadModelBudget);
     get cadLoadedStatistics(): CadModelSectorLoadStatistics;
@@ -49,15 +46,15 @@ export declare class RevealManager {
     set cadRenderMode(renderMode: RenderMode);
     get pointCloudBudget(): PointCloudBudget;
     set pointCloudBudget(budget: PointCloudBudget);
-    set clippingPlanes(clippingPlanes: THREE.Plane[]);
-    get clippingPlanes(): THREE.Plane[];
+    set clippingPlanes(clippingPlanes: Plane[]);
+    get clippingPlanes(): Plane[];
     on(event: 'loadingStateChanged', listener: LoadingStateChangeListener): void;
     off(event: 'loadingStateChanged', listener: LoadingStateChangeListener): void;
     getResolutionThreshold(): number;
     setResolutionThreshold(threshold: number): void;
     getMovingCameraResolutionFactor(): number;
     setMovingCameraResolutionFactor(factor: number): void;
-    render(camera: THREE.PerspectiveCamera): void;
+    render(camera: PerspectiveCamera): void;
     addModel<T extends InternalDataSourceType>(type: 'cad', modelIdentifier: AddModelOptionsWithModelRevisionId<T>, options?: AddCadModelOptions): Promise<CadNode>;
     addModel<T extends DataSourceType>(type: 'pointcloud', modelIdentifier: AddModelOptionsWithModelRevisionId<T>): Promise<PointCloudNode<T>>;
     removeModel(type: 'cad', model: CadNode): void;

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

@@ -1,9 +1,6 @@
+import { WebGLRenderTarget } from 'three';
 import { RenderOptions } from '../../../rendering';
 import { InternalRevealCadOptions } from '../../../cad-geometry-loaders';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 /**
  * @property logMetrics Might be used to disable usage statistics.
  * @property movingCameraResolutionFactor Factor with which the resolution (number of screen pixels) is scaled
@@ -15,7 +12,7 @@ export type RevealOptions = {
     renderOptions?: RenderOptions;
     continuousModelStreaming?: boolean;
     outputRenderTarget?: {
-        target: THREE.WebGLRenderTarget;
+        target: WebGLRenderTarget;
         autoSize?: boolean;
     };
     rendererResolutionThreshold?: number;

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

@@ -1,12 +1,9 @@
+import { WebGLRenderer } from 'three';
 import { RevealOptions } from './RevealOptions';
 import { RevealManager } from './RevealManager';
 import { CogniteClient } from '@cognite/sdk';
 import { SceneHandler } from '../../../utilities';
 import { CameraManager } from '../../../camera-manager';
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
 /**
  * Used to create an instance of reveal manager that works with localhost.
  * @param renderer
@@ -15,7 +12,7 @@ import type * as THREE from 'three';
  * @param revealOptions
  * @returns RevealManager instance.
  */
-export declare function createLocalRevealManager(renderer: THREE.WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions?: RevealOptions): RevealManager;
+export declare function createLocalRevealManager(renderer: WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions?: RevealOptions): RevealManager;
 /**
  * Used to create an instance of reveal manager that works with the CDF.
  * @param client
@@ -24,4 +21,4 @@ export declare function createLocalRevealManager(renderer: THREE.WebGLRenderer,
  * @param cameraManager
  * @param revealOptions
  */
-export declare function createCdfRevealManager(client: CogniteClient, renderer: THREE.WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions?: RevealOptions): RevealManager;
+export declare function createCdfRevealManager(client: CogniteClient, renderer: WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions?: RevealOptions): RevealManager;

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

@@ -1,3 +1,4 @@
+import { Object3D, Plane, Box3, Color, Vector2, Vector3 } from 'three';
 import { PointerEventDelegate, SceneRenderedDelegate, DisposedDelegate, BeforeSceneRenderedDelegate, ICustomObject, CustomObjectIntersectInput } from '../../../../utilities';
 import { CogniteCadModel } from '../../../../cad-model';
 import { PointCloudBudget, CognitePointCloudModel } from '../../../../pointclouds';
@@ -9,10 +10,6 @@ import { Image360DataModelIdentifier, ClassicDataSourceType, DataSourceType } fr
 import { SupportedModelTypes } from '../../../../model-base';
 import { Image360Collection, Image360, Image360Revision, Image360AnnotationIntersection } from '../../../../360-images';
 import { Image360Action } from '../../../../360-images/src/Image360Action';
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
 /**
  * @example
  * ```js
@@ -39,7 +36,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      */
     get domElement(): HTMLElement;
     /**
-     * Returns parameters of THREE.WebGLRenderer used by the viewer.
+     * Returns parameters of WebGLRenderer used by the viewer.
      */
     get renderParameters(): RenderParameters;
     /**
@@ -377,26 +374,26 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     determineModelType(modelId: number, revisionId: number): Promise<SupportedModelTypes | ''>;
     private determineModelTypeInternal;
     /**
-     * Add a THREE.Object3D to the viewer.
+     * Add a Object3D to the viewer.
      * @param object
      * @example
      * ```js
-     * const sphere = new THREE.Mesh(
-     * new THREE.SphereGeometry(),
-     * new THREE.MeshBasicMaterial()
+     * const sphere = new Mesh(
+     * new SphereGeometry(),
+     * new MeshBasicMaterial()
      * );
      * viewer.addObject3D(sphere);
      * ```
      */
-    addObject3D(object: THREE.Object3D): void;
+    addObject3D(object: Object3D): void;
     /**
      * Add a CustomObject to the viewer.
      * @param customObject
      * @example
      * ```js
-     * const sphere = new THREE.Mesh(
-     * new THREE.SphereGeometry(),
-     * new THREE.MeshBasicMaterial()
+     * const sphere = new Mesh(
+     * new SphereGeometry(),
+     * new MeshBasicMaterial()
      * );
      * const customObject = CustomObject(sphere);
      * customObject.isPartOfBoundingBox = false;
@@ -406,22 +403,22 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      */
     addCustomObject(customObject: ICustomObject): void;
     /**
-     * Remove a THREE.Object3D from the viewer.
+     * Remove a Object3D from the viewer.
      * @param object
      * @example
      * ```js
-     * const sphere = new THREE.Mesh(new THREE.SphereGeometry(), new THREE.MeshBasicMaterial());
+     * const sphere = new Mesh(new SphereGeometry(), new MeshBasicMaterial());
      * viewer.addObject3D(sphere);
      * viewer.removeObject3D(sphere);
      * ```
      */
-    removeObject3D(object: THREE.Object3D): void;
+    removeObject3D(object: Object3D): void;
     /**
      * Remove a CustomObject from the viewer.
      * @param customObject
      * @example
      * ```js
-     * const sphere = new THREE.Mesh(new THREE.SphereGeometry(), new THREE.MeshBasicMaterial());
+     * const sphere = new Mesh(new SphereGeometry(), new MeshBasicMaterial());
      * const customObject = CustomObject(sphere);
      * viewer.addCustomObject(sphere);
      * viewer.removeCustomObject(sphere);
@@ -436,7 +433,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param backgroundColor.alpha
      */
     setBackgroundColor(backgroundColor: {
-        color?: THREE.Color;
+        color?: Color;
         alpha?: number;
     }): void;
     /**
@@ -445,23 +442,23 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @example
      * ```js
      * // Hide pixels with values less than 0 in the x direction
-     * const plane = new THREE.Plane(new THREE.Vector3(1, 0, 0), 0);
+     * const plane = new Plane(new Vector3(1, 0, 0), 0);
      * viewer.setGlobalClippingPlanes([plane]);
      * ```
      * ```js
      * // Hide pixels with values greater than 20 in the x direction
-     *  const plane = new THREE.Plane(new THREE.Vector3(-1, 0, 0), 20);
+     *  const plane = new Plane(new Vector3(-1, 0, 0), 20);
      * viewer.setGlobalClippingPlanes([plane]);
      * ```
      * ```js
      * // Hide pixels with values less than 0 in the x direction or greater than 0 in the y direction
-     * const xPlane = new THREE.Plane(new THREE.Vector3(1, 0, 0), 0);
-     * const yPlane = new THREE.Plane(new THREE.Vector3(0, -1, 0), 0);
+     * const xPlane = new Plane(new Vector3(1, 0, 0), 0);
+     * const yPlane = new Plane(new Vector3(0, -1, 0), 0);
      * viewer.setGlobalClippingPlanes([xPlane, yPlane]);
      * ```
      * ```js
      * // Hide pixels behind an arbitrary, non axis-aligned plane
-     *  const plane = new THREE.Plane(new THREE.Vector3(1.5, 20, -19), 20);
+     *  const plane = new Plane(new Vector3(1.5, 20, -19), 20);
      * viewer.setGlobalClippingPlanes([plane]);
      * ```
      * ```js
@@ -469,33 +466,33 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      *  viewer.setGlobalClippingPlanes([]);
      * ```
      */
-    setGlobalClippingPlanes(clippingPlanes: THREE.Plane[]): void;
+    setGlobalClippingPlanes(clippingPlanes: Plane[]): void;
     /**
      * Sets per-pixel clipping planes. Pixels behind any of the planes will be sliced away.
      * @param clippingPlanes
      * @deprecated Use {@link Cognite3DViewer.setGlobalClippingPlanes} instead.
      */
-    setClippingPlanes(clippingPlanes: THREE.Plane[]): void;
+    setClippingPlanes(clippingPlanes: Plane[]): void;
     /**
      * Returns the current active global clipping planes.
      * @deprecated Use {@link Cognite3DViewer.getGlobalClippingPlanes} instead.
      */
-    getClippingPlanes(): THREE.Plane[];
+    getClippingPlanes(): Plane[];
     /**
      * Returns the current active global clipping planes.
      */
-    getGlobalClippingPlanes(): THREE.Plane[];
+    getGlobalClippingPlanes(): Plane[];
     /**
      * Returns the union of all bounding boxes in reveal, including custom objects.
      * @beta
      */
-    getSceneBoundingBox(): THREE.Box3;
+    getSceneBoundingBox(): Box3;
     /**
      * Get the union of bounding box of all visual objects in the Cognite3DViewer.
      * @returns The visual bounding box of the Cognite3DViewer.
      * @beta
      */
-    getVisualSceneBoundingBox(): THREE.Box3;
+    getVisualSceneBoundingBox(): Box3;
     /**
      * Attempts to load the camera settings from the settings stored for the
      * provided model. See {@link https://docs.cognite.com/api/v1/#operation/get3DRevision}
@@ -558,7 +555,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * viewer.fitCameraToBoundingBox(boundingBox, 500, 2);
      * ```
      */
-    fitCameraToBoundingBox(boundingBox: THREE.Box3, duration?: number, radiusFactor?: number): void;
+    fitCameraToBoundingBox(boundingBox: Box3, duration?: number, radiusFactor?: number): void;
     /**
      * Typically used when you perform some changes and can't see them unless you move camera.
      */
@@ -571,21 +568,21 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @returns Returns 2D coordinates if the point is visible on screen, or `null` if object is outside screen.
      * @example
      * ```js
-     * const boundingBoxCenter = new THREE.Vector3();
+     * const boundingBoxCenter = new Vector3();
      * // Find center of bounding box in world space
      * model.getBoundingBox(nodeId).getCenter(boundingBoxCenter);
      * // Screen coordinates of that point
      * const screenCoordinates = viewer.worldToScreen(boundingBoxCenter);
      * ```
      * ```js
-     * const boundingBoxCenter = new THREE.Vector3();
+     * const boundingBoxCenter = new Vector3();
      * // Find center of bounding box in world space
      * model.getBoundingBox(nodeId).getCenter(boundingBoxCenter);
      * // Screen coordinates of that point normalized in the range [0,1]
      * const screenCoordinates = viewer.worldToScreen(boundingBoxCenter, true);
      * ```
      * ```js
-     * const boundingBoxCenter = new THREE.Vector3();
+     * const boundingBoxCenter = new Vector3();
      * // Find center of bounding box in world space
      * model.getBoundingBox(nodeId).getCenter(boundingBoxCenter);
      * // Screen coordinates of that point
@@ -597,7 +594,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * }
      * ```
      */
-    worldToScreen(point: THREE.Vector3, normalize?: boolean): THREE.Vector2 | null;
+    worldToScreen(point: Vector3, normalize?: boolean): Vector2 | null;
     /**
      * Take a screenshot from the current camera position. When drawing UI, only the viewer DOM element and its children will be included in the image.
      * The DOM is scaled to fit any provided resolution, and as a result some elements can be positioned incorrectly in regards to the 3D render.
@@ -626,20 +623,20 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param pixelCoords A Vector2 containing pixel coordinates relative to the 3D viewer.
      * @returns A Vector2 containing the normalized device coordinate (in range [-1, 1]).
      */
-    getNormalizedPixelCoordinates(pixelCoords: THREE.Vector2): THREE.Vector2;
+    getNormalizedPixelCoordinates(pixelCoords: Vector2): Vector2;
     /**
      * Determines clicked or touched pixel coordinate as offset.
      * @param event An PointerEvent or WheelEvent.
      * @returns A Vector2 containing pixel coordinates relative to the 3D viewer.
      */
-    getPixelCoordinatesFromEvent(event: PointerEvent | WheelEvent): THREE.Vector2;
+    getPixelCoordinatesFromEvent(event: PointerEvent | WheelEvent): Vector2;
     /**
      * Creates and initialize a CustomObjectIntersectInput to be used by CustomObject.intersectIfCloser method.
      * @param pixelCoords A Vector2 containing pixel coordinates relative to the 3D viewer.
      * @returns A CustomObjectIntersectInput ready to use.
      * @beta
      */
-    createCustomObjectIntersectInput(pixelCoords: THREE.Vector2): CustomObjectIntersectInput;
+    createCustomObjectIntersectInput(pixelCoords: Vector2): CustomObjectIntersectInput;
     /**
      * Raycasting model(s) for finding where the ray intersects with the model.
      * @param offsetX X coordinate in pixels (relative to the domElement).
@@ -684,7 +681,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * returns `null` if there were no intersections.
      * @beta
      */
-    getAnyIntersectionFromPixel(pixelCoords: THREE.Vector2, options?: {
+    getAnyIntersectionFromPixel(pixelCoords: Vector2, options?: {
         stopOnHitting360Icon?: boolean;
         predicate?: (customObject: ICustomObject) => boolean;
     }): Promise<AnyIntersection<DataSourceT> | undefined>;
@@ -721,7 +718,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param clickedWorldPosition  World-space position of the user's click (e.g. from a point cloud intersection).
      * @returns The best matching Image360 Entity and its collection, or `undefined` if not inside a 360 image or no candidates qualify.
      */
-    findBestNext360ImageEntity(clickedWorldPosition: THREE.Vector3): Image360WithCollection<DataSourceT> | undefined;
+    findBestNext360ImageEntity(clickedWorldPosition: Vector3): Image360WithCollection<DataSourceT> | undefined;
     /** @private */
     private getModels;
     /**

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

@@ -15,4 +15,4 @@ export type Image360WithCollection<T extends DataSourceType = ClassicDataSourceT
     image360Collection: Image360Collection<T>;
     image360: Image360<T>;
 };
-export * from './migration/types';
+export type * from './migration/types';

package/dist/packages/api/src/storage/RevealManagerHelper.d.ts

@@ -1,3 +1,4 @@
+import { WebGLRenderer } from 'three';
 import { RevealManager } from '../public/RevealManager';
 import { RevealOptions } from '../public/RevealOptions';
 import { InternalDataSourceType, DataSourceType, AddModelOptionsWithModelRevisionId } from '../../../data-providers';
@@ -7,10 +8,6 @@ import { CadNode } from '../../../cad-model';
 import { CogniteClient } from '@cognite/sdk';
 import { PointCloudNode } from '../../../pointclouds';
 import { CameraManager } from '../../../camera-manager';
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
 /**
  * Helper for {@link RevealManager} for creating a uniform interface for
  * working with instances that fetch models from CDF or instances that fetch
@@ -31,7 +28,7 @@ export declare class RevealManagerHelper {
      * @param cameraManager
      * @param revealOptions
      */
-    static createLocalHelper(renderer: THREE.WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions: RevealOptions): RevealManagerHelper;
+    static createLocalHelper(renderer: WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions: RevealOptions): RevealManagerHelper;
     /**
      * Creates a helper for RevealManager that loads models from CDF.
      * @param renderer
@@ -40,8 +37,8 @@ export declare class RevealManagerHelper {
      * @param revealOptions
      * @param sdkClient
      */
-    static createCdfHelper(renderer: THREE.WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions: RevealOptions, sdkClient: CogniteClient): RevealManagerHelper;
-    static createCustomDataSourceHelper(renderer: THREE.WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions: RevealOptions, dataSource: DataSource): RevealManagerHelper;
+    static createCdfHelper(renderer: WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions: RevealOptions, sdkClient: CogniteClient): RevealManagerHelper;
+    static createCustomDataSourceHelper(renderer: WebGLRenderer, sceneHandler: SceneHandler, cameraManager: CameraManager, revealOptions: RevealOptions, dataSource: DataSource): RevealManagerHelper;
     get revealManager(): RevealManager;
     /**
      * Adds a local CAD model.

package/dist/packages/api/src/utilities/Spinner.d.ts

@@ -1,7 +1,4 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
+import { Color } from 'three';
 export type Corner = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
 export declare class Spinner {
     private readonly stylesId;
@@ -22,6 +19,6 @@ export declare class Spinner {
      * @param color.g 0..1 green
      * @param color.b 0..1 blue
      */
-    updateBackgroundColor(color: Pick<THREE.Color, 'getHSL'>): void;
+    updateBackgroundColor(color: Pick<Color, 'getHSL'>): void;
     dispose(): void;
 }

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

@@ -1,3 +1,4 @@
+import { PerspectiveCamera, Plane } from 'three';
 import { CadModelMetadata } from '../../cad-parsers';
 import { CadModelUpdateHandler } from './CadModelUpdateHandler';
 import { LoadingState } from '../../model-base';
@@ -5,10 +6,6 @@ import { CadMaterialManager, RenderMode } from '../../rendering';
 import { ModelIdentifier, File3dFormat } from '../../data-providers';
 import { CadModelBudget } from './CadModelBudget';
 import { CadModelFactory, CadModelSectorLoadStatistics, CadNode, GeometryFilter } from '../../cad-model';
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
 export declare class CadManager {
     private readonly _materialManager;
     private readonly _cadModelFactory;
@@ -34,9 +31,9 @@ export declare class CadManager {
     requestRedraw(): void;
     resetRedraw(): void;
     get needsRedraw(): boolean;
-    updateCamera(camera: THREE.PerspectiveCamera, cameraInMotion: boolean): void;
-    get clippingPlanes(): THREE.Plane[];
-    set clippingPlanes(clippingPlanes: THREE.Plane[]);
+    updateCamera(camera: PerspectiveCamera, cameraInMotion: boolean): void;
+    get clippingPlanes(): Plane[];
+    set clippingPlanes(clippingPlanes: Plane[]);
     get renderMode(): RenderMode;
     set renderMode(renderMode: RenderMode);
     doesModelHaveCompatibleFormat(modelMetadata: CadModelMetadata): boolean;

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

@@ -1,3 +1,4 @@
+import { PerspectiveCamera, Plane } from 'three';
 import { EventTrigger, EventListener } from '../../utilities';
 import { ConsumedSector } from '../../cad-parsers';
 import { SectorCuller } from './sector/culling/SectorCuller';
@@ -6,10 +7,6 @@ import { LoadingState } from '../../model-base';
 import { CadModelBudget } from './CadModelBudget';
 import { SectorLoadingSpent } from './sector/culling/types';
 import { CadNode } from '../../cad-model';
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
 type CadModelUpdateHandlerEvents = {
     onNewConsumedSector: EventTrigger<(consumedSector: ConsumedSector) => void>;
     onLoadingStateChanged: EventTrigger<(loadingState: LoadingState) => void>;
@@ -30,8 +27,8 @@ export declare class CadModelUpdateHandler {
     private readonly _events;
     constructor(sectorCuller: SectorCuller, continuousModelStreaming?: boolean);
     dispose(): void;
-    updateCamera(camera: THREE.PerspectiveCamera, cameraInMotion: boolean): void;
-    set clippingPlanes(value: THREE.Plane[]);
+    updateCamera(camera: PerspectiveCamera, cameraInMotion: boolean): void;
+    set clippingPlanes(value: Plane[]);
     get budget(): CadModelBudget;
     set budget(b: CadModelBudget);
     get lastBudgetSpendage(): SectorLoadingSpent;

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

@@ -1,35 +1,32 @@
+import { PerspectiveCamera, Box3, Matrix4 } from 'three';
 import { SectorMetadata } from '../../../../cad-parsers';
 import { PrioritizedArea } from '../../../../cad-styling';
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
 export declare class WeightFunctionsHelper {
     private readonly _camera;
     private _minSectorDistance;
     private _maxSectorDistance;
     private readonly _modifiedFrustums;
-    constructor(camera: THREE.PerspectiveCamera);
+    constructor(camera: PerspectiveCamera);
     reset(): void;
-    addCandidateSectors(sectors: SectorMetadata[], modelMatrix: THREE.Matrix4): void;
-    computeTransformedSectorBounds(sectorBounds: THREE.Box3, modelMatrix: THREE.Matrix4, out: THREE.Box3): void;
+    addCandidateSectors(sectors: SectorMetadata[], modelMatrix: Matrix4): void;
+    computeTransformedSectorBounds(sectorBounds: Box3, modelMatrix: Matrix4, out: Box3): void;
     /**
      * Computes a weight in range [0-1], where 1 means close to camera and 0 means far away.
      */
-    computeDistanceToCameraWeight(transformedSectorBounds: THREE.Box3): number;
+    computeDistanceToCameraWeight(transformedSectorBounds: Box3): number;
     /**
      * Compute a weight in range [0-1] where 1 means the sector covers the entire screen
      * and 0 means no coverage.
      * @param transformedSectorBounds
      * @returns
      */
-    computeScreenAreaWeight(transformedSectorBounds: THREE.Box3): number;
+    computeScreenAreaWeight(transformedSectorBounds: Box3): number;
     /**
      * Compute a weight in range [0-1] based on at what "depths"
      * in the frustum the sector is placed.
      * @param transformedSectorBounds
      */
-    computeFrustumDepthWeight(transformedSectorBounds: THREE.Box3): number;
+    computeFrustumDepthWeight(transformedSectorBounds: Box3): number;
     /**
      * Computes a weight based on placement in sector tree (i.e. prioritize)
      * sectors right below root sector.
@@ -40,12 +37,12 @@ export declare class WeightFunctionsHelper {
      * Computes a weight based on how large the biggest node within the sector
      * will be on screen (a number in range [0-1]).
      */
-    computeMaximumNodeScreenSizeWeight(transformedSectorBounds: THREE.Box3, maxNodeDiagonalLength: number): number;
+    computeMaximumNodeScreenSizeWeight(transformedSectorBounds: Box3, maxNodeDiagonalLength: number): number;
     /**
      * Returns a weight that is the maximum of the extra priority in intersecting prioritized areas.
      * @param transformedSectorBounds   Bounds of sectors in "Reveal coordinates".
      * @param prioritizedAreas          Zero or more areas with associated priorities.
      */
-    computePrioritizedAreaWeight(transformedSectorBounds: THREE.Box3, prioritizedAreas: PrioritizedArea[]): number;
+    computePrioritizedAreaWeight(transformedSectorBounds: Box3, prioritizedAreas: PrioritizedArea[]): number;
     private distanceToCamera;
 }

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

@@ -1,7 +1,4 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
+import { Camera, Box3 } from 'three';
 /**
  * Computes area of the box after converting it to NDC space. The returned value will be a number
  * in range [0, 1].
@@ -9,4 +6,4 @@ import * as THREE from 'three';
  * @param box
  * @returns
  */
-export declare function computeNdcAreaOfBox(camera: THREE.Camera, box: THREE.Box3): number;
+export declare function computeNdcAreaOfBox(camera: Camera, box: Box3): number;

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

@@ -1,5 +1,2 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-export declare function transformBoxToNDC(box: THREE.Box3, camera: THREE.Camera, out?: THREE.Box3): THREE.Box3;
+import { Camera, Box3 } from 'three';
+export declare function transformBoxToNDC(box: Box3, camera: Camera, out?: Box3): Box3;

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

@@ -1,15 +1,12 @@
+import { PerspectiveCamera, Plane } from 'three';
 import { PrioritizedArea } from '../../../../cad-styling';
 import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
 import { CadLoadingHints } from '../../CadLoadingHints';
 import { CadModelBudget } from '../../CadModelBudget';
 import { CadNode } from '../../../../cad-model';
-/*!
- * Copyright 2021 Cognite AS
- */
-import type * as THREE from 'three';
 export interface DetermineSectorsInput {
-    camera: THREE.PerspectiveCamera;
-    modelClippingPlanes: THREE.Plane[][];
+    camera: PerspectiveCamera;
+    modelClippingPlanes: Plane[][];
     cadModelsMetadata: CadModelMetadata[];
     loadingHints: CadLoadingHints;
     cameraInMotion: boolean;
@@ -27,8 +24,8 @@ export interface DetermineSectorsInput {
     lockedSectorIdsByModel: Map<symbol, ReadonlySet<number>>;
 }
 export type DetermineSectorsPayload = {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
+    camera: PerspectiveCamera;
+    clippingPlanes: Plane[];
     models: CadNode[];
     loadingHints: CadLoadingHints;
     cameraInMotion: boolean;

package/dist/packages/cad-model/src/picking/PickingHandler.d.ts

@@ -1,17 +1,14 @@
+import { Object3D, WebGLRenderer, Vector3 } from 'three';
 import { IntersectInput } from '../../../model-base';
 import { CadMaterialManager } from '../../../rendering';
 import { SceneHandler } from '../../../utilities';
 import { CadNode } from '../wrappers/CadNode';
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
 type IntersectCadNodesResult = {
     distance: number;
-    point: THREE.Vector3;
+    point: Vector3;
     treeIndex: number;
     cadNode: CadNode;
-    object: THREE.Object3D;
+    object: Object3D;
 };
 export declare class PickingHandler {
     private readonly _clearColor;
@@ -28,7 +25,7 @@ export declare class PickingHandler {
     private readonly _depthRenderPipeline;
     private readonly _treeIndexRenderPipeline;
     private readonly _mutex;
-    constructor(renderer: THREE.WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
+    constructor(renderer: WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
     intersectCadNodes(cadNodes: CadNode[], input: IntersectInput, shouldRunAsync?: boolean): Promise<IntersectCadNodesResult[]>;
     private filterOutOfBoundCadNodes;
     private intersectCadNodeDepth;