@cognite/reveal 2.1.2 → 3.0.0-alpha.0

package/packages/sector-parser/src/reveal-glb-parser/primitiveGeometries.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { RevealGeometryCollectionType } from '../types';
+export declare function setBoxGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setQuadGeometry(geometry: THREE.BufferGeometry, includeNormal?: boolean): THREE.Box3;
+export declare function setTrapeziumGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setConeGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setTorusGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setNutGeometry(geometry: THREE.BufferGeometry): THREE.Box3;
+export declare function setPrimitiveTopology(primitiveCollectionName: RevealGeometryCollectionType, geometry: THREE.BufferGeometry): void;

package/packages/sector-parser/src/types.d.ts

@@ -0,0 +1,98 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type GltfJson = {
+    accessors: Accessor[];
+    asset: Asset;
+    bufferViews: BufferView[];
+    buffers: Buffer[];
+    extensionsUsed: string[];
+    meshes: Mesh[];
+    nodes: Node[];
+    scene: number;
+    scenes: Scene[];
+};
+export declare type Scene = {
+    nodes: number[];
+};
+export declare type Accessor = {
+    bufferView: number;
+    byteOffset: number | undefined;
+    componentType: number;
+    count: number;
+    type: string;
+};
+export declare type Asset = {
+    copyright: string;
+    generator: string;
+    version: string;
+};
+export declare type Buffer = {
+    byteLength: number;
+};
+export declare type BufferView = {
+    buffer: number;
+    byteLength: number;
+    byteOffset: number | undefined;
+    byteStride: number;
+};
+export declare type Node = {
+    name: string;
+    mesh: number | undefined;
+    extensions: {
+        EXT_mesh_gpu_instancing: {
+            attributes: {
+                [key: string]: number;
+            };
+        } | undefined;
+    };
+};
+export declare type Mesh = {
+    primitives: Primitive[];
+    extras: {
+        [key: string]: any;
+    } | undefined;
+};
+export declare type Primitive = {
+    attributes: {
+        [key: string]: number;
+    };
+    indices: number;
+};
+export declare enum RevealGeometryCollectionType {
+    BoxCollection = 0,
+    CircleCollection = 1,
+    ConeCollection = 2,
+    EccentricConeCollection = 3,
+    EllipsoidSegmentCollection = 4,
+    GeneralCylinderCollection = 5,
+    GeneralRingCollection = 6,
+    QuadCollection = 7,
+    TorusSegmentCollection = 8,
+    TrapeziumCollection = 9,
+    NutCollection = 10,
+    TriangleMesh = 11,
+    InstanceMesh = 12
+}
+export declare type GlbHeaderData = {
+    json: GltfJson;
+    binContentLength: number;
+    byteOffsetToBinContent: number;
+};
+export declare type GeometryProcessingPayload = {
+    geometryType: RevealGeometryCollectionType;
+    bufferGeometry: THREE.InstancedBufferGeometry | THREE.BufferGeometry;
+    instancingExtension: {
+        attributes: {
+            [key: string]: number;
+        };
+    } | undefined;
+    meshId: number | undefined;
+    glbHeaderData: GlbHeaderData;
+    data: ArrayBuffer;
+};
+export declare type ParsedGeometry = {
+    type: RevealGeometryCollectionType;
+    geometryBuffer: THREE.BufferGeometry;
+    instanceId?: string;
+};

package/packages/tools/index.d.ts

@@ -1,12 +1,15 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { HtmlOverlayTool, HtmlOverlayOptions } from './src/HtmlOverlayTool';
+export { HtmlOverlayTool, HtmlOverlayOptions, HtmlOverlayPositionUpdatedDelegate, HtmlOverlayCreateClusterDelegate } from './src/HtmlOverlay/HtmlOverlayTool';
 export { ExplodedViewTool } from './src/ExplodedViewTool';
 export { DebugCameraTool } from './src/DebugCameraTool';
 export { AxisViewTool } from './src/AxisView/AxisViewTool';
 export { AxisBoxConfig, AxisBoxCompassConfig, AxisBoxFaceConfig, Corner, AbsolutePosition, RelativePosition } from './src/AxisView/types';
 export { GeomapTool } from './src/Geomap/GeomapTool';
 export { MapConfig, MapProviders, BingMapConfig, HereMapConfig, MapboxConfig, MapboxMode, MapboxStyle, MapboxImageFormat, BingMapType, BingMapImageFormat, HereMapType, HereMapScheme, HereMapImageFormat } from './src/Geomap/MapConfig';
+export { TimelineTool } from './src/Timeline/TimelineTool';
+export { Keyframe } from './src/Timeline/Keyframe';
+export { TimelineDateUpdateDelegate } from './src/Timeline/types';
 export { Cognite3DViewerToolBase } from './src/Cognite3DViewerToolBase';
 export { DebugLoadedSectorsTool, DebugLoadedSectorsToolOptions } from './src/DebugLoadedSectorsTool';

package/packages/tools/src/AxisView/AxisViewTool.d.ts

@@ -1,9 +1,9 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { Cognite3DViewer } from '../../../../core';
 import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
 import { AxisBoxConfig } from './types';
+import { Cognite3DViewer } from '../../../../core';
 export declare class AxisViewTool extends Cognite3DViewerToolBase {
     private readonly _layoutConfig;
     private readonly _boxFaceGeometry;
@@ -15,7 +15,7 @@ export declare class AxisViewTool extends Cognite3DViewerToolBase {
     private readonly _screenPosition;
     private readonly _disposeClickDiv;
     private _dynamicUpdatePosition;
-    private _updateClickDiv;
+    private readonly _updateClickDiv;
     constructor(viewer: Cognite3DViewer, config?: AxisBoxConfig);
     dispose(): void;
     private createClickDiv;

package/packages/tools/src/DebugLoadedSectorsTool.d.ts

@@ -4,7 +4,7 @@ export declare type DebugLoadedSectorsToolOptions = {
     showSimpleSectors?: boolean;
     showDetailedSectors?: boolean;
     showDiscardedSectors?: boolean;
-    colorBy?: 'depth' | 'lod' | 'loadedTimestamp' | 'random';
+    colorBy?: 'depth' | 'lod' | 'loadedTimestamp' | 'drawcalls' | 'random';
     leafsOnly?: boolean;
     sectorPathFilterRegex?: string;
 };

package/packages/tools/src/Geomap/Geomap.d.ts

@@ -2,13 +2,16 @@ import { Cognite3DViewer } from '../../../../core';
 import { LatLongPosition, MapConfig } from './MapConfig';
 export declare class Geomap {
     private readonly _viewer;
-    private _map;
+    private readonly _map;
     private _intervalId;
     private readonly _onCameraChange;
     constructor(viewer: Cognite3DViewer, mapConfig: MapConfig);
     private requestRedraw;
     private getMapProvider;
-    latLongToWorldCoordinates(latLong: LatLongPosition): any;
+    latLongToWorldCoordinates(latLong: LatLongPosition): {
+        x: number;
+        y: number;
+    };
     private handleCameraChange;
     dispose(): void;
 }

package/packages/tools/src/Geomap/GeomapTool.d.ts

@@ -1,9 +1,9 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { Cognite3DViewer } from '../../../../core';
 import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
 import { LatLongPosition, MapConfig } from './MapConfig';
+import { Cognite3DViewer } from '../../../../core';
 /**
  * The `GeomapTool` is a geolocation for the models and allow the user to place them on the maps.
  * @version New since 2.1.
@@ -16,6 +16,9 @@ export declare class GeomapTool extends Cognite3DViewerToolBase {
      * Converts Latitude & Longitude into Vector2 World coordinates on the Map
      * @param latLong Latitude & Longitude
      */
-    latLongToWorldCoordinates(latLong: LatLongPosition): void;
+    latLongToWorldCoordinates(latLong: LatLongPosition): {
+        x: number;
+        y: number;
+    };
     dispose(): void;
 }

package/packages/tools/src/HtmlOverlay/BucketGrid2D.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Data structure that splits a 2D region into cells where each cell can contain zero to many
+ * elements. Elements can be stored in several cells. This data structure make overlap lookups
+ * efficient.
+ *
+ * Note! This class is tailored for usage with {@link HtmlOverlayTool} and has a few restrictions
+ * and assumptions associated with the usage. If used elsewhere, take care as to how this affects
+ * performance and behaviour.
+ */
+export declare class BucketGrid2D<T> {
+    private readonly _dimensions;
+    private readonly _bounds;
+    private readonly _cells;
+    /**
+     * Holds elements that has been removed from the collection using {@link removeOverlappingElements}.
+     * This is used to avoid expensive re-allocations of cells when removing elements.
+     */
+    private readonly _removedElements;
+    constructor(bounds: THREE.Box2, dimensions: [width: number, height: number]);
+    insert(bounds: THREE.Box2, element: T): void;
+    overlappingElements(bounds: THREE.Box2): Generator<T>;
+    removeOverlappingElements(bounds: THREE.Box2): Generator<T>;
+    private cellsIntersecting;
+}

package/packages/tools/src/HtmlOverlay/HtmlOverlayTool.d.ts

@@ -0,0 +1,160 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
+import { Cognite3DViewer } from '../../../../core';
+/**
+ * Callback that is triggered whenever the 2D position of an overlay is updated
+ * in {@link HtmlOverlayTool}.
+ */
+export declare type HtmlOverlayPositionUpdatedDelegate = (element: HTMLElement, position2D: THREE.Vector2, position3D: THREE.Vector3, distanceToCamera: number, userData: any) => void;
+/**
+ * Callback that is triggered when a set of overlays are clustered together in
+ * {@link HtmlOverlayTool}.
+ */
+export declare type HtmlOverlayCreateClusterDelegate = (overlayElements: {
+    htmlElement: HTMLElement;
+    userData: any;
+}[]) => HTMLElement;
+/**
+ * Options for an overlay added using {@link HtmlOverlayTool.add}.
+ */
+export declare type HtmlOverlayOptions = {
+    /**
+     * Callback that is triggered whenever the position of the overlay is updated. Optional.
+     */
+    positionUpdatedCallback?: HtmlOverlayPositionUpdatedDelegate;
+    /**
+     * Optional user specified data that is provided to the {@link HtmlOverlayCreateClusterDelegate} and
+     * {@link HtmlOverlayPositionUpdatedDelegate}.
+     */
+    userData?: any;
+};
+/**
+ * Controls how close overlay elements are clustered together.
+ */
+export declare type HtmlOverlayToolClusteringOptions = {
+    /**
+     * Currently only 'overlapInScreenSpace' is supported. In this mode,
+     * overlays are clustered together into a single element as defined by
+     * the {@link createClusterElementCallback} and hidden when they overlap
+     * in screen space. The composite element is placed at the midpoint of
+     * all clustered elements.
+     *
+     * Clustered elements are faded in/out using CSS styling `transition`,
+     * `opacity` and `visibility`.
+     */
+    mode: 'overlapInScreenSpace';
+    /**
+     * Callback that is triggered when a set of overlays are clustered together
+     * to create a "composite" element as a placeholder for the clustered elements.
+     * Note that this callback will be triggered every frame for each cluster so it
+     * must be performant.
+     */
+    createClusterElementCallback: HtmlOverlayCreateClusterDelegate;
+};
+export declare type HtmlOverlayToolOptions = {
+    clusteringOptions?: HtmlOverlayToolClusteringOptions;
+};
+/**
+ 
+ * Manages HTMLoverlays for {@see Cognite3DViewer}. Attaches HTML elements to a
+ * 3D position and updates its position/visibility as user moves the camera. This is
+ * useful to create HTML overlays to highlight information about key positions in the 3D model.
+ *
+ * Attached elements *must* have CSS style 'position: absolute'. It's also recommended
+ * in most cases to have styles 'pointer-events: none' and 'touch-action: none' to avoid
+ * interfering with 3D navigation. Consider also applying 'transform: translate(-50%, -50%)'
+ * to anchor the center of the element rather than the top-left corner. In some cases the
+ * `zIndex`-attribute is necessary for the element to appear on top of the viewer.
+ *
+ * @example
+ * ```js
+ * const el = document.createElement('div');
+ * el.style.position = 'absolute'; // Required!
+ * // Anchor to center of element
+ * el.style.transform = 'translate(-50%, -50%)';
+ * // Avoid being target for events
+ * el.style.pointerEvents = 'none;
+ * el.style.touchAction = 'none';
+ * // Render in front of other elements
+ * el.style.zIndex = 10;
+ *
+ * el.style.color = 'red';
+ * el.innerHtml = '<h1>Overlay</h1>';
+ *
+ * const overlayTool = new HtmlOverlayTool(viewer);
+ * overlayTool.add(el, new THREE.Vector3(10, 10, 10));
+ * // ...
+ * overlayTool.remove(el);
+ * // or, to remove all attached elements
+ * overlayTool.clear();
+ *
+ * // detach the tool from the viewer
+ * overlayTool.dispose();
+ * ```
+ */
+export declare class HtmlOverlayTool extends Cognite3DViewerToolBase {
+    private readonly _viewer;
+    private readonly _options;
+    private readonly _htmlOverlays;
+    private readonly _compositeOverlays;
+    private readonly _onSceneRenderedHandler;
+    private readonly _onViewerDisposedHandler;
+    private readonly _preallocatedVariables;
+    private readonly scheduleUpdate;
+    private get viewerDomElement();
+    private get viewerCamera();
+    private get viewerRenderer();
+    constructor(viewer: Cognite3DViewer, options?: HtmlOverlayToolOptions);
+    /**
+     * Returns all added HTML elements along with their 3D positions.
+     */
+    get elements(): {
+        element: HTMLElement;
+        position3D: THREE.Vector3;
+    }[];
+    /**
+     * Removes all elements and detaches from the viewer.
+     * @override
+     */
+    dispose(): void;
+    /**
+     * Registers a HTML overlay that will be updated on rendering.
+     *
+     * @param htmlElement
+     * @param position3D
+     * @param options
+     */
+    add(htmlElement: HTMLElement, position3D: THREE.Vector3, options?: HtmlOverlayOptions): void;
+    /**
+     * Removes a overlay and removes it from the DOM.
+     * @param htmlElement
+     */
+    remove(htmlElement: HTMLElement): void;
+    /**
+     * Removes all attached HTML overlay elements.
+     */
+    clear(): void;
+    /**
+     * Updates positions of all overlays. This is automatically managed and there
+     * shouldn't be any reason to trigger this unless the attached elements are
+     * modified externally.
+     *
+     * Calling this function often might cause degraded performance.
+     */
+    forceUpdate(): void;
+    /**
+     * Update size of new elements. This is only done once as this causes
+     * layout to be invalidated which is an expensive operation.
+     */
+    private updateNewElementSizes;
+    private commitDOMChanges;
+    private clusterElements;
+    private cleanupClusterElements;
+    private clusterByOverlapInScreenSpace;
+    private addComposite;
+    private onSceneRendered;
+    private onViewerDisposed;
+}

package/packages/tools/src/Timeline/Keyframe.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { NodeCollectionBase, NodeAppearance } from '../../../../core/src';
+import { Cognite3DModel } from '../../../../core';
+/**
+ * Timeline Key Frames contains parameters to access Nodes, Styles for the Timeline
+ */
+export declare class Keyframe {
+    private readonly _date;
+    private readonly _model;
+    private readonly _nodeCollectionAndAppearance;
+    constructor(model: Cognite3DModel, date: Date);
+    /**
+     * Get date of the Keyframe
+     * @returns date
+     */
+    getKeyframeDate(): Date;
+    /**
+     * Assigns the styles for the node set for the model for this Keyframe
+     */
+    activate(): void;
+    /**
+     * Removes the style for the model
+     */
+    deactivate(): void;
+    /**
+     * Add node & style to the collection. If the collection has been added, the style is updated to the
+     * appearance provided.
+     * @param nodeCollection Node set to apply the Styles
+     * @param nodeAppearance Style to assign to the node collection
+     */
+    assignStyledNodeCollection(nodeCollection: NodeCollectionBase, nodeAppearance: NodeAppearance): void;
+    /**
+     * Remove Node & Style for this keyframe's nodeCollection and nodeAppearance
+     * @param nodeCollection Nodes to be unassign from node collection
+     */
+    unassignStyledNodeCollection(nodeCollection: NodeCollectionBase): void;
+}

package/packages/tools/src/Timeline/TimelineTool.d.ts

@@ -0,0 +1,79 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Cognite3DModel } from '../../../../core';
+import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
+import { Keyframe } from './Keyframe';
+import { TimelineDateUpdateDelegate } from './types';
+/**
+ * Tool to applying styles to nodes based on date to play them over in Timeline
+ */
+export declare class TimelineTool extends Cognite3DViewerToolBase {
+    private readonly _model;
+    private readonly _keyframes;
+    private _playback;
+    private readonly _events;
+    constructor(cadModel: Cognite3DModel);
+    /**
+     * Subscribe to the Date changed event
+     * @param event `dateChanged` event
+     * @param listener Listen to Timeline date Update during Playback
+     */
+    subscribe(event: 'dateChanged', listener: TimelineDateUpdateDelegate): void;
+    /**
+     * Unsubscribe to the Date changed event
+     * @param event `dateChanged` event
+     * @param listener Remove Listen to Timeline date Update
+     */
+    unsubscribe(event: 'dateChanged', listener: TimelineDateUpdateDelegate): void;
+    /**
+     * Create Key frame for the Timeline
+     * @param date - date value by Date.now() since January 1, 1970
+     */
+    createKeyframe(date: Date): Keyframe;
+    /**
+     * Returns the keyframe at the date given, or undefined if not found.
+     * @param date
+     * @returns
+     */
+    getKeyframeByDate(date: Date): Keyframe | undefined;
+    /**
+     * Removes the Keyframe from the timeline. Does nothing if the keyframe isn't part of the timeline.
+     * @param keyframe - Keyframe to be removed from the timeline
+     */
+    removeKeyframe(keyframe: Keyframe): void;
+    /**
+     * Removes the Keyframe from the Timeline
+     * @param date - Date of the Keyframe to be removed from the Timeline
+     */
+    removeKeyframeByDate(date: Date): void;
+    /**
+     * Starts playback of Timeline
+     * @param startDate - Keyframe date to start the Playback of Keyframes
+     * @param endDate - Keyframe date to stop the Playback of Keyframes
+     * @param totalDurationInMilliSeconds - Number of milliseconds for all Keyframe within startDate & endDate to be rendered
+     */
+    play(startDate: Date, endDate: Date, totalDurationInMilliSeconds: number): void;
+    /**
+     * Stops any ongoing playback
+     */
+    stop(): void;
+    /**
+     * Pause any ongoing playback
+     */
+    pause(): void;
+    /**
+     * Resume any paused playback
+     */
+    resume(): void;
+    /**
+     * Provides all Keyframes in the Timeline
+     * @returns All Keyframes in Timeline
+     */
+    getAllKeyframes(): Keyframe[];
+    dispose(): void;
+    /**
+     * Sort the Timeline Keyframe by their Date
+     */
+    private sortKeyframesByDates;
+}

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

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Keyframe } from './Keyframe';
+/**
+ * Delegate for Timeline Date update
+ */
+export declare type TimelineDateUpdateDelegate = (event: {
+    date: Date;
+    activeKeyframe: Keyframe | undefined;
+    startDate: Date;
+    endDate: Date;
+}) => void;

package/packages/utilities/index.d.ts

@@ -3,8 +3,9 @@
  */
 export { traverseDepthFirst } from './src/objectTraversal';
 export { transformCameraConfiguration } from './src/transformCameraConfiguration';
+export { RandomColors } from './src/RandomColors';
 export { CameraConfiguration } from './src/CameraConfiguration';
-export { EventTrigger, clickOrTouchEventOffset } from './src/events';
+export { EventTrigger, clickOrTouchEventOffset, InputHandler } from './src/events';
 export { assertNever } from './src/assertNever';
 export { NumericRange } from './src/NumericRange';
 export { determinePowerOfTwoDimensions } from './src/determinePowerOfTwoDimensions';
@@ -13,12 +14,15 @@ export { packFloatInto } from './src/packFloat';
 export { DynamicDefragmentedBuffer } from './src/datastructures/DynamicDefragmentedBuffer';
 export { AutoDisposeGroup } from './src/three/AutoDisposeGroup';
 export { BoundingBoxLOD } from './src/three/BoundingBoxLOD';
-export { getBox3CornerPoints } from './src/three/getBox3CornerPoints';
+export { toThreeBox3 } from './src/three/toThreeBox3';
+export { isBox3OnPositiveSideOfPlane } from './src/three/isBox3OnPositiveSideOfPlane';
+export { visitBox3CornerPoints } from './src/three/visitBox3CornerPoints';
 export { isMobileOrTablet } from './src/isMobileOrTablet';
 export { WebGLRendererStateHelper } from './src/WebGLRendererStateHelper';
 export { WorkerPool } from './src/workers/WorkerPool';
+export { TypedArray, TypedArrayConstructor } from './src/types';
 export { MemoryRequestCache } from './src/cache/MemoryRequestCache';
 export { MostFrequentlyUsedCache } from './src/cache/MostFrequentlyUsedCache';
-export { trackError, trackLoadModel, trackCameraNavigation, trackEvent, initMetrics } from './src/metrics';
 export { disposeAttributeArrayOnUpload } from './src/disposeAttributeArrayOnUpload';
 export { revealEnv } from './src/revealEnv';
+export { incrementOrInsertIndex, decrementOrDeleteIndex } from './src/counterMap';

package/packages/utilities/src/NumericRange.d.ts

@@ -17,5 +17,6 @@ export declare class NumericRange {
     isInside(range: NumericRange): boolean;
     union(range: NumericRange): NumericRange;
     forEach(action: (value: number) => void): void;
-    str(): string;
+    toString(): string;
+    static isNumericRange(value: any): value is NumericRange;
 }

package/packages/utilities/src/RandomColors.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Utility class for creating reasonable visible colors. Mainly meant for use
+ * in debugging.
+ */
+export declare class RandomColors {
+    private static readonly _colors;
+    /**
+     * Returns a color as a THREE.Color.
+     * @param colorIndex
+     * @returns
+     */
+    static color(colorIndex: number): THREE.Color;
+    /**
+     * Returns color as RGB components between 0 and 255.
+     * @param colorIndex Return
+     * @returns
+     */
+    static colorRGB(colorIndex: number): [number, number, number];
+    /**
+     * Returns a color string suitable for usage in CSS styles.
+     * @param colorIndex
+     * @returns
+     */
+    static colorCSS(colorIndex: number): string;
+    /**
+     * Returns a random color with reasonable lightness and saturation
+     * to make the color easily distinguishable from other colors.
+     */
+    static generateRandomColor(): THREE.Color;
+}

package/packages/utilities/src/WebGLRendererStateHelper.d.ts

@@ -10,6 +10,6 @@ export declare class WebGLRendererStateHelper {
     setSize(width: number, height: number): void;
     set localClippingEnabled(enabled: boolean);
     set autoClear(enabled: boolean);
-    setRenderTarget(renderTarget: THREE.RenderTarget | null): void;
+    setRenderTarget(renderTarget: THREE.WebGLRenderTarget | null): void;
     resetState(): void;
 }

package/packages/utilities/src/counterMap.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2022 Cognite AS
+ */
+export declare function incrementOrInsertIndex(indexMap: Map<number, number>, index: number): void;
+export declare function decrementOrDeleteIndex(indexMap: Map<number, number>, index: number): void;

package/packages/utilities/src/datastructures/DynamicDefragmentedBuffer.d.ts

@@ -4,19 +4,32 @@
 import { TypedArray } from '../types';
 export declare class DynamicDefragmentedBuffer<T extends TypedArray> {
     get length(): number;
-    get buffer(): T;
-    private _buffer;
+    get bufferView(): T;
+    private _bufferView;
     private _numFilled;
-    private _type;
-    private _batchMap;
+    private readonly _type;
+    private readonly _batchMap;
     private _currentTail;
     private _batchIdCounter;
     constructor(initialSize: number, type: new (length: number) => T);
     add(array: T): {
         batchId: number;
         bufferIsReallocated: boolean;
+        updateRange: {
+            byteOffset: number;
+            byteCount: number;
+        };
+    };
+    remove(batchId: number): {
+        updateRange: {
+            byteOffset: number;
+            byteCount: number;
+        };
+    };
+    getRangeForBatchId(batchId: number): {
+        byteOffset: number;
+        byteCount: number;
     };
-    remove(batchId: number): void;
     private createBatch;
     private allocateNewBuffer;
 }