@cognite/reveal 4.12.1-dev.20240425 → 4.12.1-dev.20240429

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

@@ -650,5 +650,4 @@ export declare class Cognite3DViewer {
     private recalculateBoundingBox;
     /** @private */
     private setupDomElementResizeListener;
-    private readonly startPointerEventListeners;
 }

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

@@ -145,10 +145,15 @@ export interface Cognite3DViewerOptions {
      */
     continuousModelStreaming?: boolean;
     /**
-     * Use the new the new flexiable camera manager or not, default not to be used.
+     * Use the new flexible camera manager or not, default not to be used.
      * @beta
      */
     useFlexibleCameraManager?: boolean;
+    /**
+     * Add event listerers around, default is having event listeners.
+     * @beta
+     */
+    hasEventListeners?: boolean;
 }
 /**
  * @module @cognite/reveal

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

@@ -10,12 +10,11 @@ export { ComboControls, ComboControlsEventType } from './src/ComboControls';
 export { ComboControlsOptions } from './src/ComboControlsOptions';
 export { CameraControlsOptions } from './src/CameraControlsOptions';
 export { DebouncedCameraStopEventTrigger } from './src/utils/DebouncedCameraStopEventTrigger';
-export { IFlexibleCameraManager } from './src/Flexible/IFlexibleCameraManager';
+export { IFlexibleCameraManager, isFlexibleCameraManager } from './src/Flexible/IFlexibleCameraManager';
 export { FlexibleControlsTypeChangeDelegate } from './src/Flexible/IFlexibleCameraManager';
 export { FlexibleCameraManager } from './src/Flexible/FlexibleCameraManager';
 export { FlexibleControlsOptions } from './src/Flexible/FlexibleControlsOptions';
 export { FlexibleWheelZoomType } from './src/Flexible/FlexibleWheelZoomType';
 export { FlexibleControlsType } from './src/Flexible/FlexibleControlsType';
 export { FlexibleMouseActionType } from './src/Flexible/FlexibleMouseActionType';
-export { asFlexibleCameraManager } from './src/Flexible/IFlexibleCameraManager';
 export * from './src/types';

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraEventTarget.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { FlexibleControls } from './FlexibleControls';
+import { CameraEventDelegate, CameraManagerEventType } from '../types';
+import { FlexibleControlsTypeChangeDelegate } from './IFlexibleCameraManager';
+type FlexibleCameraManagerEventType = CameraManagerEventType | 'controlsTypeChange';
+type FlexibleCameraEventDelegate = CameraEventDelegate | FlexibleControlsTypeChangeDelegate;
+export declare class FlexibleCameraEventTarget {
+    private readonly _controlsTypeChangeListeners;
+    private readonly _cameraChangeListeners;
+    private readonly _cameraStopListeners;
+    private readonly _debouncedCameraListener;
+    constructor();
+    removeEventListeners(): void;
+    dispatchEvent(event: FlexibleCameraManagerEventType, controls: FlexibleControls): void;
+    addEventListener(event: FlexibleCameraManagerEventType, callback: FlexibleCameraEventDelegate): void;
+    removeEventListener(event: FlexibleCameraManagerEventType, callback: FlexibleCameraEventDelegate): void;
+}
+export {};

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraManager.d.ts

@@ -4,31 +4,29 @@
 import { Box3, PerspectiveCamera, Vector3, Scene } from 'three';
 import { FlexibleControls } from './FlexibleControls';
 import { FlexibleControlsOptions } from './FlexibleControlsOptions';
-import { InputHandler } from '../../../utilities';
+import { PointerEvents } from '../../../utilities';
 import { CameraEventDelegate, CameraManagerCallbackData, CameraManagerEventType, CameraState } from './../types';
 import { CameraManager } from './../CameraManager';
 import { FlexibleControlsType } from './FlexibleControlsType';
 import { FlexibleControlsTypeChangeDelegate, IFlexibleCameraManager } from './IFlexibleCameraManager';
+import { FlexibleCameraEventTarget } from './FlexibleCameraEventTarget';
 type RaycastCallback = (x: number, y: number, pickBoundingBox: boolean) => Promise<CameraManagerCallbackData>;
 /**
  * Flexible implementation of {@link CameraManager}. The user can switch between Orbit, FirstPersion or OrbitInCenter
  * Supports automatic update of camera near and far planes and animated change of camera position and target.
  * @beta
  */
-export declare class FlexibleCameraManager implements IFlexibleCameraManager {
-    private readonly _triggers;
-    private readonly _stopEventTrigger;
+export declare class FlexibleCameraManager extends PointerEvents implements IFlexibleCameraManager {
+    private readonly _pointerEventsTarget?;
     private readonly _controls;
-    private readonly _inputHandler;
     private readonly _markers?;
     private readonly _currentBoundingBox;
     private _isDisposed;
     private _isEnableClickAndDoubleClick;
     private _nearAndFarNeedsUpdate;
-    private _prevTime;
-    private readonly _prevCoords;
     private readonly _raycastCallback;
-    constructor(domElement: HTMLElement, inputHandler: InputHandler, raycastCallback: RaycastCallback, camera?: PerspectiveCamera, scene?: Scene);
+    private readonly _haveEventListeners;
+    constructor(domElement: HTMLElement, raycastCallback: RaycastCallback, camera?: PerspectiveCamera, scene?: Scene, haveEventListeners?: boolean);
     getCamera(): PerspectiveCamera;
     getCameraState(): Required<CameraState>;
     /**
@@ -51,9 +49,18 @@ export declare class FlexibleCameraManager implements IFlexibleCameraManager {
     addControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
     removeControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
     updateModelBoundingBox(modelBoundingBox: Box3): void;
+    onClick(event: PointerEvent): Promise<void>;
+    onDoubleClick(event: PointerEvent): Promise<void>;
+    onPointerDown(event: PointerEvent, leftButton: boolean): Promise<void>;
+    onPointerDrag(event: PointerEvent, leftButton: boolean): Promise<void>;
+    onPointerUp(event: PointerEvent, leftButton: boolean): Promise<void>;
+    onWheel(event: WheelEvent): Promise<void>;
+    onKey(event: KeyboardEvent, down: boolean): void;
+    onFocusChanged(haveFocus: boolean): void;
     get options(): FlexibleControlsOptions;
     get controls(): FlexibleControls;
     get camera(): PerspectiveCamera;
+    get listeners(): FlexibleCameraEventTarget;
     get domElement(): HTMLElement;
     get isEnabled(): boolean;
     get isEnableClickAndDoubleClick(): boolean;
@@ -68,12 +75,6 @@ export declare class FlexibleCameraManager implements IFlexibleCameraManager {
     private getTargetByBoundingBox;
     private addEventListeners;
     private removeEventListeners;
-    private readonly onCameraChange;
-    private readonly onControlsTypeChange;
-    private readonly onKeyDown;
-    private readonly onClick;
-    private readonly onDoubleClick;
-    private readonly onWheel;
     private mouseAction;
     private setTargetAndCameraPosition;
     private updateCameraNearAndFar;

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraMarkers.d.ts

@@ -8,4 +8,5 @@ export declare class FlexibleCameraMarkers {
     private _targetMarker;
     constructor(scene: Scene);
     update(manager: FlexibleCameraManager): void;
+    private isVisible;
 }

package/dist/packages/camera-manager/src/Flexible/FlexibleControls.d.ts

@@ -1,17 +1,17 @@
 /*!
  * Copyright 2024 Cognite AS
  */
-import { EventDispatcher, OrthographicCamera, PerspectiveCamera, Quaternion, Spherical, Vector2, Vector3 } from 'three';
+import { OrthographicCamera, PerspectiveCamera, Quaternion, Spherical, Vector2, Vector3 } from 'three';
 import { FlexibleControlsType } from './FlexibleControlsType';
 import { FlexibleControlsOptions } from './FlexibleControlsOptions';
 import { DampedVector3 } from './DampedVector3';
 import { DampedSpherical } from './DampedSpherical';
-import { FlexibleControlsEvent } from './FlexibleControlsEvent';
 import { GetPickedPointByPixelCoordinates } from './GetPickedPointByPixelCoordinates';
+import { FlexibleCameraEventTarget } from './FlexibleCameraEventTarget';
 /**
  * @beta
  */
-export declare class FlexibleControls extends EventDispatcher<FlexibleControlsEvent> {
+export declare class FlexibleControls {
     private _isEnabled;
     private _isInitialized;
     private _isStationary;
@@ -25,17 +25,20 @@ export declare class FlexibleControls extends EventDispatcher<FlexibleControlsEv
     private _scrollDirection;
     private _scrollDistance;
     private _tempTarget;
+    private readonly _listeners;
     private readonly _keyboard;
     private readonly _touchEvents;
     private _getPickedPointByPixelCoordinates;
     private readonly _reusableVector3s;
     private readonly _rotationHelper;
     private _mouseDragInfo;
+    private _prevTime;
+    private readonly _prevCoords;
     constructor(camera: PerspectiveCamera | undefined, domElement: HTMLElement, options: FlexibleControlsOptions);
-    dispose(): void;
     get options(): FlexibleControlsOptions;
     get camera(): PerspectiveCamera | OrthographicCamera;
     get domElement(): HTMLElement;
+    get listeners(): FlexibleCameraEventTarget;
     get target(): DampedVector3;
     get cameraVector(): DampedSpherical;
     get cameraPosition(): DampedVector3;
@@ -57,7 +60,7 @@ export declare class FlexibleControls extends EventDispatcher<FlexibleControlsEv
         position: Vector3;
     };
     private getMousePosition;
-    getNormalizedPixelCoordinates(event: PointerEvent): Vector2;
+    getNormalizedPixelCoordinates(event: PointerEvent | WheelEvent): Vector2;
     setScrollCursor(value: Vector3 | undefined): void;
     setTempTarget(value: Vector3 | undefined): void;
     setFov(value: number, triggerCameraChangeEvent?: boolean): boolean;
@@ -71,28 +74,29 @@ export declare class FlexibleControls extends EventDispatcher<FlexibleControlsEv
     private getDampingFactor;
     private newVector3;
     update(deltaTimeS: number, forceUpdate?: boolean): boolean;
-    triggerCameraChangeEvent(): void;
-    triggerControlsTypeChangeEvent(): void;
     rotateCameraTo(startDirection: Spherical, endDirection: Spherical, factor: number): void;
-    private readonly onPointerDown;
-    private onMouseDown;
-    private readonly onPointerMove;
-    private readonly onPointerUp;
-    private readonly onMouseWheel;
-    private onTouchStart;
-    private readonly onFocusChanged;
+    onPointerDown(event: PointerEvent, _leftButton: boolean): Promise<void>;
+    onPointerDrag(event: PointerEvent, leftButton: boolean): Promise<void>;
+    onPointerUp(event: PointerEvent, _leftButton: boolean): void;
+    readonly onKeyDown: (event: KeyboardEvent) => void;
+    onFocusChanged(_haveFocus: boolean): void;
+    onKey(event: KeyboardEvent, down: boolean): void;
+    readonly onWheel: (event: WheelEvent) => Promise<void>;
     private readonly onContextMenu;
     addEventListeners(): void;
-    private removeEventListeners;
+    removeEventListeners(): void;
     updateCameraAndTriggerCameraChangeEvent(): void;
     updateCamera(deltaTimeS: number, forceUpdate?: boolean, useDampening?: boolean): boolean;
-    private startTouchRotation;
     private rotate;
     getAzimuthCompensationFactor(): number;
     rotateByAngles(deltaAzimuth: number, deltaPolar: number): void;
     private rawRotateByAngles;
+    private onTouchDown;
+    private startTouchRotation;
     private startTouchPinch;
-    private replaceTouchEvent;
+    private get touchEventsCount();
+    private removeTouchEvent;
+    private updateTouchEvents;
     private pan;
     translate(delta: Vector3): void;
     private dollyOrthographicCamera;
@@ -102,10 +106,8 @@ export declare class FlexibleControls extends EventDispatcher<FlexibleControlsEv
     private getTranslationByScrollCursor;
     private getStep;
     private zoomCameraByFov;
+    private setScrollCursorByWheelEventCoords;
     private handleKeyboard;
     private handleRotationFromKeyboard;
     private handleMoveFromKeyboard;
 }
-export declare function isMouse(event: PointerEvent): boolean;
-export declare function isTouch(event: PointerEvent): boolean;
-export declare function isPressed(event: PointerEvent): boolean;

package/dist/packages/camera-manager/src/Flexible/IFlexibleCameraManager.d.ts

@@ -41,5 +41,49 @@ export interface IFlexibleCameraManager extends CameraManager {
      * @param callback - The callback function to be removed from the controls type change listeners.
      */
     removeControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
+    /**
+     * Called when a click event is triggered
+     * @beta
+     */
+    onClick(event: PointerEvent): Promise<void>;
+    /**
+     * Called when double click event is triggered
+     * @beta
+     */
+    onDoubleClick(event: PointerEvent): Promise<void>;
+    /**
+     * Called when pointer is pressed
+     * @beta
+     */
+    onPointerDown(event: PointerEvent, leftButton: boolean): Promise<void>;
+    /**
+     * Called when pointer is dragged
+     * @beta
+     */
+    onPointerDrag(event: PointerEvent, leftButton: boolean): Promise<void>;
+    /**
+     * Called when pointer is released
+     * @beta
+     */
+    onPointerUp(event: PointerEvent, leftButton: boolean): Promise<void>;
+    /**
+     * Called when wheel event is triggered
+     * @beta
+     */
+    onWheel(event: WheelEvent): Promise<void>;
+    /**
+     * Called when a key is pressed or released
+     * @beta
+     */
+    onKey(event: KeyboardEvent, down: boolean): void;
+    /**
+     * Called when focus is changed
+     * @beta
+     */
+    onFocusChanged(haveFocus: boolean): void;
 }
-export declare function asFlexibleCameraManager(manager: CameraManager): IFlexibleCameraManager | undefined;
+/**
+ * Check id the CameraManager is a IFlexibleCameraManager
+ * @beta
+ */
+export declare function isFlexibleCameraManager(manager: CameraManager): manager is IFlexibleCameraManager;

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

@@ -6,10 +6,8 @@ type EventCode = (typeof EVENT_CODES)[number];
 export default class Keyboard {
     private readonly _keys;
     private _isEnabled;
-    private readonly _domElement;
     get isEnabled(): boolean;
     set isEnabled(value: boolean);
-    constructor(domElement: HTMLElement);
     isPressed(key: EventCode): boolean;
     isShiftPressed(): boolean;
     isShiftPressedOnly(): boolean;
@@ -17,7 +15,6 @@ export default class Keyboard {
     isCtrlPressedOnly(): boolean;
     isAltPressed(): boolean;
     isMetaPressed(): boolean;
-    dispose(): void;
     /**
      * Given two keys representing positive and negative directions (e.g., left and right, or up and down),
      * this method returns 1 for the positive key, -1 for the negative key, or 0 if neither or both is pressed.
@@ -27,10 +24,11 @@ export default class Keyboard {
      * @returns A value indicating the direction of movement: 1 (positive), -1 (negative), or 0 (none).
      */
     getKeyboardMovementValue(positiveKey: EventCode, negativeKey: EventCode): number;
-    private readonly addEventListeners;
-    private readonly removeEventListeners;
+    addEventListeners(domElement: HTMLElement): void;
+    removeEventListeners(domElement: HTMLElement): void;
     private readonly onKeyDown;
     private readonly onKeyUp;
+    onKey(event: KeyboardEvent, down: boolean): void;
     readonly clearPressedKeys: () => void;
 }
 export {};

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

@@ -5,7 +5,13 @@ export { traverseDepthFirst } from './src/objectTraversal';
 export { transformCameraConfiguration } from './src/transformCameraConfiguration';
 export { RandomColors } from './src/RandomColors';
 export { CameraConfiguration } from './src/CameraConfiguration';
-export { EventTrigger, clickOrTouchEventOffset, getClickOrTouchEventPoint, InputHandler, disposeOfAllEventListeners } from './src/events';
+export { EventTrigger } from './src/events/EventTrigger';
+export { InputHandler } from './src/events/InputHandler';
+export { PointerEvents } from './src/events/PointerEvents';
+export { PointerEventsTarget } from './src/events/PointerEventsTarget';
+export { disposeOfAllEventListeners } from './src/events/disposeOfAllEventListeners';
+export { clickOrTouchEventOffset, getClickOrTouchEventPoint } from './src/events/clickOrTouchEventOffset';
+export { getWheelEventDelta } from './src/events/getWheelEventDelta';
 export { DisposedDelegate, BeforeSceneRenderedDelegate, SceneRenderedDelegate, PointerEventDelegate, PointerEventData } from './src/events/types';
 export { assertNever } from './src/assertNever';
 export { NumericRange } from './src/NumericRange';

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

@@ -1,14 +1,12 @@
-import { EventTrigger } from './EventTrigger';
 import { PointerEventDelegate } from './types';
-export type EventCollection = {
-    [eventName: string]: EventTrigger<(...args: any[]) => void>;
-};
-export declare class InputHandler {
-    private readonly domElement;
-    private static readonly maxMoveDistance;
-    private static readonly maxClickDuration;
-    private readonly _events;
+import { PointerEvents } from './PointerEvents';
+export declare class InputHandler extends PointerEvents {
+    private readonly _domElement;
+    private readonly _pointerEventsTarget;
+    private readonly _clickEvents;
+    private readonly _hoverEvents;
     constructor(domElement: HTMLElement);
+    dispose(): void;
     /**
      * @example
      * ```js
@@ -18,13 +16,7 @@ export declare class InputHandler {
      */
     on(event: 'click' | 'hover', callback: PointerEventDelegate): void;
     off(event: 'click' | 'hover', callback: PointerEventDelegate): void;
-    dispose(): void;
-    private setupEventListeners;
-    private isProperClick;
-    private handleClickEvent;
-    private readonly onHoverCallback;
+    onClick(event: PointerEvent): Promise<void>;
+    onHover(event: PointerEvent): void;
+    get isEnabled(): boolean;
 }
-/**
- * Method for deleting all external events that are associated with current instance of a class.
- */
-export declare function disposeOfAllEventListeners(eventList: EventCollection): void;

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

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * This base should be extended for listen to various pointer events.
+ * @beta
+ */
+export declare class PointerEvents {
+    onHover(_event: PointerEvent): void;
+    onClick(_event: PointerEvent): Promise<void>;
+    onDoubleClick(_event: PointerEvent): Promise<void>;
+    onPointerDown(_event: PointerEvent, _leftButton: boolean): Promise<void>;
+    onPointerUp(_event: PointerEvent, _leftButton: boolean): Promise<void>;
+    onPointerDrag(_event: PointerEvent, _leftButton: boolean): Promise<void>;
+    get isEnabled(): boolean;
+}

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

@@ -0,0 +1,29 @@
+import { PointerEvents } from './PointerEvents';
+/**
+ * This class fires click, double click, hover end similar events at a PointerEvents
+ * onClick will fired if it's a single click, and the mouse hasn't move too much
+ * If onDoubleClick is fired, the onClick will not be fired
+ * onHover will be fired only if the mouse button is not pressed and not to often
+ * If mouse, the onDoubleClick and onClick is fired when the left mouse button is pressed
+ * onPointerDrag will be fired wnen the mouse button is pressed and the mouse is moving
+ * @beta
+ */
+export declare class PointerEventsTarget {
+    private readonly _domElement;
+    private readonly _events;
+    private readonly _downPosition;
+    private _lastDownTimestamp;
+    private _prevDownTimestamp;
+    private _clickCounter;
+    private _isLeftDown;
+    private get isEnabled();
+    constructor(domElement: HTMLElement, events: PointerEvents);
+    addEventListeners(): void;
+    removeEventListeners(): void;
+    private readonly onPointerDown;
+    private readonly onPointerHover;
+    private readonly onPointerDrag;
+    private readonly onPointerUp;
+    private isProperClick;
+    private isDoubleClick;
+}

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

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { EventTrigger } from './EventTrigger';
+export type EventCollection = {
+    [eventName: string]: EventTrigger<(...args: any[]) => void>;
+};
+/**
+ * Method for deleting all external events that are associated with current instance of a class.
+ */
+export declare function disposeOfAllEventListeners(eventList: EventCollection): void;

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

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * Determines hove many deltas the whell has been scrolled.
+ * @param event     An WheelEvent
+ */
+export declare function getWheelEventDelta(event: WheelEvent): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.12.1-dev.20240425",
+  "version": "4.12.1-dev.20240429",
   "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": {
@@ -81,7 +81,7 @@
   "devDependencies": {
     "@azure/msal-browser": "2.38.4",
     "@cognite/sdk": "8.3.0",
-    "@microsoft/api-extractor": "7.42.3",
+    "@microsoft/api-extractor": "7.43.1",
     "@types/dat.gui": "0.7.13",
     "@types/gl": "^6.0.2",
     "@types/glob": "8.1.0",
@@ -89,7 +89,7 @@
     "@types/jest-environment-puppeteer": "5.0.6",
     "@types/jest-image-snapshot": "6.4.0",
     "@types/jsdom": "21.1.6",
-    "@types/lodash": "4.14.202",
+    "@types/lodash": "4.17.0",
     "@types/mixpanel-browser": "2.49.0",
     "@types/node": "18.19.31",
     "@types/random-seed": "0.3.5",

package/dist/packages/camera-manager/src/Flexible/FlexibleControlsEvent.d.ts

@@ -1,19 +0,0 @@
-/*!
- * Copyright 2024 Cognite AS
- */
-import { Vector3 } from 'three';
-import { FlexibleControlsType } from './FlexibleControlsType';
-/**
- * @beta
- */
-export type FlexibleControlsEvent = {
-    cameraChange: {
-        content: {
-            position: Vector3;
-            target: Vector3;
-        };
-    };
-    controlsTypeChange: {
-        controlsType: FlexibleControlsType;
-    };
-};

package/dist/packages/camera-manager/src/utils/getWheelDelta.d.ts

@@ -1,4 +0,0 @@
-/*!
- * Copyright 2024 Cognite AS
- */
-export declare function getWheelDelta(event: WheelEvent): number;

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

@@ -1,7 +0,0 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export { clickOrTouchEventOffset, getClickOrTouchEventPoint } from './clickOrTouchEventOffset';
-export { EventTrigger } from './EventTrigger';
-export { InputHandler, disposeOfAllEventListeners } from './InputHandler';
-export * from './types';