@cognite/reveal 4.2.0-dev.20230512 → 4.2.0-dev.20230516

package/dist/packages/360-images/index.d.ts

@@ -14,3 +14,4 @@ export { Image360AnnotationAppearance } from './src/annotation/types';
 export { Image360AnnotationIntersection } from './src/annotation/Image360AnnotationIntersection';
 export { Image360Annotation } from './src/annotation/Image360Annotation';
 export { DefaultImage360Collection } from './src/collection/DefaultImage360Collection';
+export { IconsOptions } from './src/icons/IconCollection';

package/dist/packages/360-images/src/Image360Facade.d.ts

@@ -14,7 +14,8 @@ export declare class Image360Facade<T> {
     private readonly _image360Cache;
     get collections(): DefaultImage360Collection[];
     set allIconsVisibility(visible: boolean);
-    set allHoverIconsVisibility(visible: boolean);
+    set allIconsSelected(visible: boolean);
+    set hoverIconVisibility(visible: boolean);
     set allIconCullingScheme(scheme: IconCullingScheme);
     constructor(_entityFactory: Image360CollectionFactory<T>);
     create(dataProviderFilter: T, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<DefaultImage360Collection>;

package/dist/packages/360-images/src/annotation/ImageAnnotationObject.d.ts

@@ -16,6 +16,8 @@ export declare class ImageAnnotationObject implements Image360Annotation {
     get annotation(): AnnotationModel;
     static createAnnotationObject(annotation: AnnotationModel, face: FaceType): ImageAnnotationObject | undefined;
     private static createObjectData;
+    private static createObjectDetectionAnnotationData;
+    private static createAssetLinkAnnotationData;
     private constructor();
     private getRotationFromFace;
     private initializeTransform;

package/dist/packages/360-images/src/annotation/PolygonAnnotationData.d.ts

@@ -2,12 +2,12 @@
  * Copyright 2023 Cognite AS
  */
 import { BufferGeometry, Matrix4, ShapeGeometry } from 'three';
-import { AnnotationsObjectDetection } from '@cognite/sdk';
+import { AnnotationsPolygon } from '@cognite/sdk';
 import { ImageAnnotationObjectData } from './ImageAnnotationData';
 export declare class PolygonAnnotationData implements ImageAnnotationObjectData {
     private readonly _geometry;
-    constructor(annotation: AnnotationsObjectDetection);
-    createGeometry(annotation: AnnotationsObjectDetection): ShapeGeometry;
+    constructor(polygon: AnnotationsPolygon);
+    createGeometry(polygon: AnnotationsPolygon): ShapeGeometry;
     getGeometry(): BufferGeometry;
     getNormalizationMatrix(): Matrix4;
 }

package/dist/packages/360-images/src/collection/DefaultImage360Collection.d.ts

@@ -66,6 +66,7 @@ export declare class DefaultImage360Collection implements Image360Collection {
      */
     off(event: 'image360Entered', callback: Image360EnteredDelegate): void;
     off(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    setSelectedForAll(selected: boolean): void;
     setSelectedVisibility(visible: boolean): void;
     setCullingScheme(scheme: IconCullingScheme): void;
     remove(entity: Image360Entity): void;

package/dist/packages/360-images/src/collection/Image360CollectionFactory.d.ts

@@ -4,11 +4,13 @@
 import { Image360Provider } from '../../../data-providers';
 import { BeforeSceneRenderedDelegate, DeviceDescriptor, EventTrigger, SceneHandler } from '../../../utilities';
 import { DefaultImage360Collection } from './DefaultImage360Collection';
+import { IconsOptions } from '../icons/IconCollection';
 export declare class Image360CollectionFactory<T> {
     private readonly _image360DataProvider;
     private readonly _sceneHandler;
     private readonly _onBeforeSceneRendered;
+    private readonly _iconsOptions;
     private readonly _device;
-    constructor(image360DataProvider: Image360Provider<T>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, device: DeviceDescriptor);
+    constructor(image360DataProvider: Image360Provider<T>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, device: DeviceDescriptor, iconsOptions?: IconsOptions);
     create(dataProviderFilter: T, postTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<DefaultImage360Collection>;
 }

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

@@ -3,12 +3,12 @@
  */
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
 import { Image360DataProvider } from '../../../data-providers';
-import { Image360Icon } from '../icons/Image360Icon';
 import { Image360, Image360Metadata } from './Image360';
 import { Historical360ImageSet } from '../../../data-providers/src/types';
 import { Image360RevisionEntity } from './Image360RevisionEntity';
 import { Image360VisualizationBox } from './Image360VisualizationBox';
 import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
+import { Overlay3DIcon } from '../../../3d-overlays';
 export declare class Image360Entity implements Image360 {
     private readonly _revisions;
     private readonly _imageMetadata;
@@ -27,13 +27,13 @@ export declare class Image360Entity implements Image360 {
      * image during normal visualization.
      * @returns Image360Icon
      */
-    get icon(): Image360Icon;
+    get icon(): Overlay3DIcon;
     /**
      * The object containing the unit cube with the 360 images.
      * @returns Image360Visualization
      */
     get image360Visualization(): Image360VisualizationBox;
-    constructor(image360Metadata: Historical360ImageSet, sceneHandler: SceneHandler, imageProvider: Image360DataProvider, transform: THREE.Matrix4, icon: Image360Icon, device: DeviceDescriptor);
+    constructor(image360Metadata: Historical360ImageSet, sceneHandler: SceneHandler, imageProvider: Image360DataProvider, transform: THREE.Matrix4, icon: Overlay3DIcon, device: DeviceDescriptor);
     /**
      * List all historical images for this entity.
      * @returns A list of available revisions.

package/dist/packages/360-images/src/icons/IconCollection.d.ts

@@ -3,16 +3,20 @@
  */
 import { Vector3 } from 'three';
 import { BeforeSceneRenderedDelegate, EventTrigger, SceneHandler } from '../../../utilities';
-import { Image360Icon } from './Image360Icon';
+import { Overlay3DIcon } from '../../../3d-overlays';
 export type IconCullingScheme = 'clustered' | 'proximity';
+export type IconsOptions = {
+    platformMaxPointsSize?: number;
+};
 export declare class IconCollection {
-    private readonly MIN_PIXEL_SIZE;
-    private readonly MAX_PIXEL_SIZE;
+    private static readonly MinPixelSize;
+    private static readonly DefaultMaxPixelSize;
+    private readonly _maxPixelSize;
     private readonly _sceneHandler;
-    private readonly _hoverIconTexture;
     private readonly _sharedTexture;
+    private readonly _hoverSprite;
     private readonly _icons;
-    private readonly _iconsSprite;
+    private readonly _pointsObject;
     private readonly _computeClustersEventHandler;
     private readonly _computeProximityPointsEventHandler;
     private readonly _onBeforeSceneRenderedEvent;
@@ -21,14 +25,16 @@ export declare class IconCollection {
     private _iconCullingScheme;
     private _proximityRadius;
     private _proximityPointLimit;
-    get icons(): Image360Icon[];
+    get icons(): Overlay3DIcon[];
+    set hoverSpriteVisibility(value: boolean);
     setCullingScheme(scheme: IconCullingScheme): void;
     set360IconCullingRestrictions(radius: number, pointLimit: number): void;
-    constructor(points: Vector3[], sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
+    constructor(points: Vector3[], sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, iconOptions?: IconsOptions);
     private setIconClustersByLOD;
     private computeProximityPoints;
     private initializeImage360Icons;
     dispose(): void;
+    private createHoverSprite;
     private createOuterRingsTexture;
     private createHoverIconTexture;
 }

package/dist/packages/3d-overlays/index.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+export { Overlay3DCollection } from './src/Overlay3DCollection';
+export { OverlayPointsObject, OverlayPointsParameters } from './src/OverlayPointsObject';
+export { Overlay3DIcon } from './src/Overlay3DIcon';
+export { Overlay3D } from './src/Overlay3D';
+export { OverlayCollection, OverlayInfo, DefaultMetadataType } from './src/OverlayCollection';
+export { IconOctree } from './src/IconOctree';

package/dist/packages/{360-images/src/icons → 3d-overlays/src}/IconOctree.d.ts

@@ -3,13 +3,13 @@
  */
 import { Node, PointOctant, PointOctree } from 'sparse-octree';
 import { Box3, Matrix4 } from 'three';
-import { Image360Icon } from '../icons/Image360Icon';
-export declare class IconOctree extends PointOctree<Image360Icon> {
+import { Overlay3DIcon } from './Overlay3DIcon';
+export declare class IconOctree extends PointOctree<Overlay3DIcon> {
     private readonly _nodeCenters;
-    static getMinimalOctreeBoundsFromIcons(icons: Image360Icon[]): Box3;
-    constructor(icons: Image360Icon[], bounds: Box3, maxLeafSize: number);
-    getNodeIcon(node: Node): Image360Icon | undefined;
-    getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Image360Icon>>;
+    static getMinimalOctreeBoundsFromIcons(icons: Overlay3DIcon[]): Box3;
+    constructor(icons: Overlay3DIcon[], bounds: Box3, maxLeafSize: number);
+    getNodeIcon(node: Node): Overlay3DIcon | undefined;
+    getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Overlay3DIcon>>;
     private populateNodeCenters;
     private filterEmptyLeaves;
     private hasChildren;

package/dist/packages/3d-overlays/src/Overlay3D.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+export interface Overlay3D<MetadataType> {
+    /**
+     * Set whether this overlay should be visible.
+     * */
+    set visible(visible: boolean);
+    /**
+     * Get whether this overlay is visible.
+     */
+    get visible(): boolean;
+    /**
+     * Get the position of this overlay.
+     */
+    get position(): THREE.Vector3;
+    /**
+     * Set the display color of this overlay.
+     * */
+    setColor(color: THREE.Color): void;
+    /**
+     * Get the display color of this overlay.
+     * */
+    get color(): THREE.Color;
+    /**
+     * Get the metadata associated with this overlay.
+     * */
+    getMetadata(): MetadataType | undefined;
+}

package/dist/packages/3d-overlays/src/Overlay3DCollection.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, Texture, Object3D } from 'three';
+import { Overlay3D } from './Overlay3D';
+import { DefaultMetadataType, OverlayCollection, OverlayInfo } from './OverlayCollection';
+export type Overlay3DCollectionOptions = {
+    overlayTexture?: Texture;
+    maxPointSize?: number;
+    defaultOverlayColor?: Color;
+};
+export declare class Overlay3DCollection<MetadataType = DefaultMetadataType> extends Object3D implements OverlayCollection<MetadataType> {
+    private readonly MinPixelSize;
+    private readonly MaxPixelSize;
+    private readonly DefaultMaxPoints;
+    private readonly defaultOverlayColor;
+    private readonly _sharedTexture;
+    private readonly _overlayPoints;
+    private readonly _iconRadius;
+    private _overlays;
+    private _octree;
+    constructor(overlayInfos?: OverlayInfo<MetadataType>[], options?: Overlay3DCollectionOptions);
+    setVisibility(visibility: boolean): void;
+    getOverlays(): Overlay3D<MetadataType>[];
+    addOverlays(overlayInfos: OverlayInfo<MetadataType>[]): Overlay3D<MetadataType>[];
+    sortOverlaysRelativeToCamera(camera: THREE.Camera): void;
+    removeOverlays(overlays: Overlay3D<MetadataType>[]): void;
+    removeAllOverlays(): void;
+    private rebuildOctree;
+    private updatePointsObject;
+    private initializeOverlay3DIcons;
+    dispose(): void;
+    private createCircleTexture;
+}

package/dist/packages/3d-overlays/src/Overlay3DIcon.d.ts

@@ -0,0 +1,70 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { PerspectiveCamera, Ray, Vector3, Color } from 'three';
+import { Overlay3D } from './Overlay3D';
+import { DefaultMetadataType } from './OverlayCollection';
+export type IconParameters = {
+    position: THREE.Vector3;
+    color?: THREE.Color;
+    minPixelSize: number;
+    maxPixelSize: number;
+    iconRadius: number;
+    hoverSprite?: THREE.Sprite;
+};
+export type SetAdaptiveScaleDelegate = (args: {
+    camera: THREE.Camera;
+    renderSize: THREE.Vector2;
+    domElement: HTMLElement;
+}) => void;
+export type ParametersChangeDelegate = (event: {
+    color: THREE.Color;
+    visble: boolean;
+}) => void;
+export type SelectedDelegate = (event: {
+    selected: boolean;
+}) => void;
+export type IconEvent = 'selected' | 'parametersChange';
+export declare class Overlay3DIcon<MetadataType = DefaultMetadataType> implements Overlay3D<MetadataType> {
+    private readonly _position;
+    private readonly _minPixelSize;
+    private readonly _maxPixelSize;
+    private readonly _setAdaptiveScale;
+    private readonly _iconRadius;
+    private readonly _hoverSprite?;
+    private readonly _iconMetadata?;
+    private readonly _raycastBoundingSphere;
+    private _adaptiveScale;
+    private _visible;
+    private _culled;
+    private _selected;
+    private _color;
+    private readonly _ndcPosition;
+    private readonly _events;
+    constructor(iconParameters: IconParameters, iconMetadata?: MetadataType);
+    on(event: 'selected', callback: SelectedDelegate): void;
+    on(event: 'parametersChange', callback: ParametersChangeDelegate): void;
+    off(event: 'selected', callback: SelectedDelegate): void;
+    off(event: 'parametersChange', callback: ParametersChangeDelegate): void;
+    set selected(newValue: boolean);
+    get selected(): boolean;
+    updateHoverSpriteScale(): void;
+    updateAdaptiveScale(delegateArguments: {
+        renderSize: THREE.Vector2;
+        camera: PerspectiveCamera;
+        domElement: HTMLElement;
+    }): void;
+    setColor(color: Color): void;
+    get color(): Color;
+    getMetadata(): MetadataType | undefined;
+    get adaptiveScale(): number;
+    set culled(culled: boolean);
+    get culled(): boolean;
+    set visible(visible: boolean);
+    get visible(): boolean;
+    get position(): Vector3;
+    intersect(ray: Ray): Vector3 | null;
+    dispose(): void;
+    private setupAdaptiveScaling;
+    private computeAdaptiveScaling;
+}

package/dist/packages/3d-overlays/src/OverlayCollection.d.ts

@@ -0,0 +1,38 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Overlay3D } from './Overlay3D';
+export type DefaultMetadataType = {
+    text?: string;
+    [key: string]: string | undefined;
+};
+export type OverlayInfo<MetadataType = DefaultMetadataType> = {
+    position: THREE.Vector3;
+    metadata?: MetadataType;
+    color?: THREE.Color;
+};
+export interface OverlayCollection<MetadataType> {
+    /**
+     * Get all overlays in the collection.
+     * */
+    getOverlays(): Overlay3D<MetadataType>[];
+    /**
+     * Add overlays to the collection.
+     * @param overlays Overlays to add to the collection.
+     * @returns The added overlays.
+     */
+    addOverlays(overlays: OverlayInfo<MetadataType>[]): Overlay3D<MetadataType>[];
+    /**
+     * Remove overlays from the collection.
+     * @param overlays Overlays to remove from the collection.
+     */
+    removeOverlays(overlays: Overlay3D<MetadataType>[]): void;
+    /**
+     * Remove all overlays from the collection.
+     */
+    removeAllOverlays(): void;
+    /**
+     * Sets whether overlays in the collection should be visible.
+     */
+    setVisibility(visibility: boolean): void;
+}

package/dist/packages/3d-overlays/src/OverlayPointsObject.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, DepthModes, Group, Texture, Vector3 } from 'three';
+export type OverlayPointsParameters = {
+    spriteTexture: Texture;
+    minPixelSize: number;
+    maxPixelSize: number;
+    radius: number;
+    colorTint?: Color;
+    depthMode?: DepthModes;
+    collectionOpacity?: number;
+};
+export declare class OverlayPointsObject extends Group {
+    private readonly _geometry;
+    private readonly _frontMaterial;
+    private readonly _positionBuffer;
+    private readonly _positionAttribute;
+    private readonly _colorBuffer;
+    private readonly _colorAttribute;
+    constructor(maxNumberOfPoints: number, materialParameters: OverlayPointsParameters);
+    setPoints(points: Vector3[], colors?: Color[]): void;
+    dispose(): void;
+    private initializePoints;
+    private createIconsMaterial;
+}

package/dist/packages/api/src/api-helpers/Image360ApiHelper.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { CogniteClient, Metadata } from '@cognite/sdk';
-import { Image360Collection, Image360Entity, Image360, Image360RevisionEntity, Image360AnnotationIntersection } from '../../../360-images';
+import { Image360Collection, Image360Entity, Image360, IconsOptions, Image360RevisionEntity, Image360AnnotationIntersection } from '../../../360-images';
 import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 export declare class Image360ApiHelper {
@@ -19,7 +19,7 @@ export declare class Image360ApiHelper {
     private readonly _image360Navigation;
     private readonly _onBeforeSceneRenderedEvent;
     private _cachedCameraManager;
-    constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
+    constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, iconsOptions?: IconsOptions);
     get needsRedraw(): boolean;
     resetRedraw(): void;
     private getNormalizedOffset;

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

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { PointerEventDelegate, SceneRenderedDelegate, DisposedDelegate, BeforeSceneRenderedDelegate } from '../../../../utilities';
 import { CogniteCadModel } from '../../../../cad-model';
 import { PointCloudBudget, CognitePointCloudModel } from '../../../../pointclouds';
-import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions } from './types';
+import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions, RenderParameters } from './types';
 import { CogniteModel } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
 import { CameraManager, CameraChangeDelegate, CameraStopDelegate } from '../../../../camera-manager';
@@ -35,6 +35,10 @@ export declare class Cognite3DViewer {
      * The DOM element cannot be changed after the viewer has been created.
      */
     get domElement(): HTMLElement;
+    /**
+     * Returns parameters of THREE.WebGLRenderer used by the viewer.
+     */
+    get renderParameters(): RenderParameters;
     /**
      * Returns the renderer used to produce images from 3D geometry.
      */

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

@@ -18,6 +18,15 @@ import { EdlOptions } from '../../../../rendering';
  * @param itemsCulled Number of items deemed unnecessary to load in this batch.
  */
 export type OnLoadingCallback = (itemsLoaded: number, itemsRequested: number, itemsCulled: number) => void;
+/**
+ * Some parameters of THREE.WebGLRenderer initialized with {@link Cognite3DViewer}.
+ */
+export type RenderParameters = {
+    /**
+     * Current width and height of the renderer's output canvas, in pixels.
+     */
+    renderSize: THREE.Vector2;
+};
 /**
  * @module @cognite/reveal
  */

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

@@ -5,6 +5,7 @@ export { HtmlOverlayTool, HtmlOverlayOptions, HtmlOverlayToolOptions, HtmlOverla
 export { DebugCameraTool } from './src/DebugCameraTool';
 export { AxisViewTool } from './src/AxisView/AxisViewTool';
 export { AxisBoxConfig, AxisBoxCompassConfig, AxisBoxFaceConfig, Corner, AbsolutePosition, RelativePosition } from './src/AxisView/types';
+export { SmartOverlayTool, SmartOverlayToolParameters, OverlayEventHandler, OverlayToolEvent } from './src/SmartOverlay/SmartOverlayTool';
 export { TimelineTool } from './src/Timeline/TimelineTool';
 export { Keyframe } from './src/Timeline/Keyframe';
 export { TimelineDateUpdateDelegate } from './src/Timeline/types';

package/dist/packages/tools/src/SmartOverlay/SmartOverlayTool.d.ts

@@ -0,0 +1,86 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Cognite3DViewer } from '../../../api';
+import { DisposedDelegate } from '../../../utilities';
+import * as THREE from 'three';
+import { OverlayInfo, DefaultMetadataType, OverlayCollection, Overlay3D } from '../../../3d-overlays';
+import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
+export type OverlayToolEvent = 'hover' | 'click' | 'disposed';
+export type OverlayEventHandler<MetadataType> = (event: {
+    targetOverlay: Overlay3D<MetadataType>;
+    htmlOverlay: HTMLElement;
+    mousePosition: {
+        clientX: number;
+        clientY: number;
+    };
+}) => void;
+export type SmartOverlayToolParameters = {
+    /**
+     * Max point markers size in pixels. Different platforms has limitations for this value.
+     * On Android and MacOS in Chrome maximum is 64. Windows in Chrome and MacOS Safari desktops can support up to 500.
+     * Default is 64.
+     */
+    maxPointSize?: number;
+    /**
+     * Sets default overlay color for newly added labels.
+     */
+    defaultOverlayColor: THREE.Color;
+};
+export declare class SmartOverlayTool<MetadataType = DefaultMetadataType> extends Cognite3DViewerToolBase {
+    private readonly _viewer;
+    private readonly _textOverlay;
+    private readonly _defaultOverlayColor;
+    private readonly _defaultTextOverlayToCursorOffset;
+    private readonly _temporaryVec;
+    private readonly _raycaster;
+    private _overlayCollections;
+    private _isVisible;
+    private _textOverlayVisible;
+    private readonly _events;
+    constructor(viewer: Cognite3DViewer, toolParameters?: SmartOverlayToolParameters);
+    /**
+     * Creates new OverlayCollection.
+     * @param overlays Array of overlays to add.
+     * @returns Overlay group containing it's id.
+     */
+    createOverlayCollection(overlays?: OverlayInfo<MetadataType>[]): OverlayCollection<MetadataType>;
+    /**
+     * Removes overlays that were added with addOverlays method.
+     * @param overlayCollection Id of the overlay group to remove.
+     */
+    removeOverlayCollection(overlayCollection: OverlayCollection<MetadataType>): void;
+    /**
+     * Gets all added overlay collections.
+     */
+    get collections(): OverlayCollection<MetadataType>[];
+    /**
+     * Sets whether overlays are visible.
+     */
+    set visible(visible: boolean);
+    get visible(): boolean;
+    set textOverlayVisible(visible: boolean);
+    get textOverlayVisible(): boolean;
+    /**
+     * Removes all overlays.
+     */
+    clear(): void;
+    /**
+     * Subscribes to overlay events.
+     * @param event event to subscribe to.
+     * @param eventHandler
+     */
+    on(event: 'hover', eventHandler: OverlayEventHandler<MetadataType>): void;
+    on(event: 'click', eventHandler: OverlayEventHandler<MetadataType>): void;
+    on(event: 'disposed', eventHandler: DisposedDelegate): void;
+    off(event: 'hover', eventHandler: OverlayEventHandler<MetadataType>): void;
+    off(event: 'click', eventHandler: OverlayEventHandler<MetadataType>): void;
+    off(event: 'disposed', eventHandler: DisposedDelegate): void;
+    dispose(): void;
+    private readonly onMouseMove;
+    private readonly onMouseClick;
+    private positionTextOverlay;
+    private intersectPointsMarkers;
+    private convertPixelCoordinatesToNormalized;
+    private createTextOverlay;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.2.0-dev.20230512",
+  "version": "4.2.0-dev.20230516",
   "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": {
@@ -91,14 +91,14 @@
     "@types/jsdom": "21.1.1",
     "@types/lodash": "4.14.194",
     "@types/mixpanel-browser": "2.38.1",
-    "@types/node": "18.16.5",
+    "@types/node": "18.16.7",
     "@types/random-seed": "0.3.3",
     "@types/skmeans": "0.11.4",
     "@types/stats": "0.16.30",
     "@types/three": "0.152.0",
     "@types/tween.js": "18.5.1",
-    "@typescript-eslint/eslint-plugin": "5.59.2",
-    "@typescript-eslint/parser": "5.59.2",
+    "@typescript-eslint/eslint-plugin": "5.59.5",
+    "@typescript-eslint/parser": "5.59.5",
     "concurrently": "8.0.1",
     "cross-env": "7.0.3",
     "dat.gui": "0.7.9",
@@ -111,7 +111,7 @@
     "eslint-plugin-unused-imports": "2.0.0",
     "file-loader": "6.2.0",
     "gl": "6.0.2",
-    "glob": "10.2.2",
+    "glob": "10.2.3",
     "glslify-loader": "2.0.0",
     "html-webpack-plugin": "5.5.1",
     "jest": "29.5.0",
@@ -120,12 +120,12 @@
     "jest-extended": "3.2.4",
     "jest-image-snapshot": "6.1.0",
     "jest-puppeteer": "8.0.6",
-    "jsdom": "21.1.2",
+    "jsdom": "22.0.0",
     "moq.ts": "10.0.6",
     "nock": "13.3.1",
     "prettier": "2.8.8",
     "process": "0.11.10",
-    "puppeteer": "19.11.1",
+    "puppeteer": "20.1.1",
     "random-seed": "0.3.0",
     "raw-loader": "4.0.2",
     "remove-files-webpack-plugin": "1.5.0",
@@ -137,10 +137,10 @@
     "ts-loader": "9.4.2",
     "tsc-alias": "1.8.6",
     "typescript": "5.0.4",
-    "wasm-pack": "0.10.3",
-    "webpack": "5.82.0",
-    "webpack-cli": "5.1.0",
-    "webpack-dev-server": "4.14.0",
+    "wasm-pack": "0.11.1",
+    "webpack": "5.82.1",
+    "webpack-cli": "5.1.1",
+    "webpack-dev-server": "4.15.0",
     "webpack-node-externals": "3.0.0",
     "whatwg-fetch": "3.6.2",
     "workerize-loader": "2.0.2"

package/dist/packages/360-images/src/icons/Image360Icon.d.ts

@@ -1,29 +0,0 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import { BeforeSceneRenderedDelegate, EventTrigger, SceneHandler } from '../../../utilities';
-import * as THREE from 'three';
-import { Ray, Vector3 } from 'three';
-export declare class Image360Icon {
-    private readonly _hoverSprite;
-    private readonly _position;
-    private readonly _sceneHandler;
-    private readonly _minPixelSize;
-    private readonly _maxPixelSize;
-    private readonly _iconRadius;
-    private readonly _setAdaptiveScale;
-    private readonly _onRenderTrigger;
-    private _adaptiveScale;
-    private _visible;
-    private _culled;
-    constructor(position: THREE.Vector3, hoverIconTexture: THREE.CanvasTexture, sceneHandler: SceneHandler, minPixelSize: number, maxPixelSize: number, iconRadius: number, onRenderTrigger: EventTrigger<BeforeSceneRenderedDelegate>);
-    setVisibility(visible: boolean): void;
-    setCulled(culled: boolean): void;
-    isVisible(): boolean;
-    get position(): Vector3;
-    set hoverSpriteVisible(visible: boolean);
-    intersect(ray: Ray): Vector3 | null;
-    dispose(): void;
-    private setupAdaptiveScaling;
-    private createHoverSprite;
-}

package/dist/packages/360-images/src/icons/InstancedIconSprite.d.ts

@@ -1,16 +0,0 @@
-/*!
- * Copyright 2023 Cognite AS
- */
-import { Color, Group, Texture, Vector3 } from 'three';
-export declare class InstancedIconSprite extends Group {
-    private readonly _geometry;
-    private readonly _frontMaterial;
-    private readonly _backMaterial;
-    private readonly _positionBuffer;
-    private readonly _positionAttribute;
-    constructor(maxNumberOfPoints: number, spriteTexture: Texture, minPixelSize: number, maxPixelSize: number, radius: number, colorTint?: Color);
-    setPoints(points: Vector3[]): void;
-    dispose(): void;
-    private initializePoints;
-    private createIconsMaterial;
-}

package/dist/packages/tools/src/types.d.ts

@@ -1,4 +0,0 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export type DisposedDelegate = () => void;