@kingsy/viewer 2.25.7

package/dist/modules/batching/InstancedMeshBatch.d.ts

@@ -0,0 +1,60 @@
+import { Box3, Material, Object3D, WebGLRenderer } from 'three';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { type Batch, type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
+import KingSyInstancedMesh from '../objects/KingSyInstancedMesh.js';
+import { DrawRanges } from './DrawRanges.js';
+export declare class InstancedMeshBatch implements Batch {
+    id: string;
+    subtreeId: string;
+    renderViews: NodeRenderView[];
+    private geometry;
+    batchMaterial: Material;
+    mesh: KingSyInstancedMesh;
+    protected drawRanges: DrawRanges;
+    private instanceTransformBuffer0;
+    private instanceTransformBuffer1;
+    private transformBufferIndex;
+    private instanceGradientBuffer;
+    private instanceObjectIdBuffer;
+    private needsShuffle;
+    get bounds(): Box3;
+    get drawCalls(): number;
+    get minDrawCalls(): number;
+    get maxDrawCalls(): number;
+    get triCount(): number;
+    get vertCount(): number;
+    get pointCount(): number;
+    get lineCount(): number;
+    get geometryType(): GeometryType;
+    get renderObject(): Object3D;
+    getCount(): number;
+    get materials(): Material[];
+    get groups(): Array<DrawGroup>;
+    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[], webGL2: boolean);
+    setBatchMaterial(material: Material): void;
+    onUpdate(deltaTime: number): void;
+    onRender(renderer: WebGLRenderer): void;
+    /** Note: You can only set visibility on ranges that exist as draw groups! */
+    setVisibleRange(ranges: BatchUpdateRange[]): void;
+    getVisibleRange(): BatchUpdateRange;
+    getOpaque(): BatchUpdateRange;
+    getDepth(): BatchUpdateRange;
+    getTransparent(): BatchUpdateRange;
+    getStencil(): BatchUpdateRange;
+    setBatchBuffers(ranges: BatchUpdateRange[]): void;
+    setDrawRanges(ranges: BatchUpdateRange[]): void;
+    private cleanMaterials;
+    private shuffleDrawGroups;
+    resetDrawRanges(): void;
+    private getCurrentTransformBuffer;
+    private getNextTransformBuffer;
+    private getCurrentGradientBuffer;
+    private getCurrentObjectIndexBuffer;
+    buildBatch(): Promise<void>;
+    getRenderView(index: number): NodeRenderView | null;
+    getMaterialAtIndex(index: number): Material | null;
+    getMaterial(rv: NodeRenderView): Material | null;
+    private makeInstancedMeshGeometry;
+    private updateGradientIndexBufferData;
+    purge(): void;
+}

package/dist/modules/batching/LineBatch.d.ts

@@ -0,0 +1,52 @@
+import { Box3, InstancedInterleavedBuffer, Material, Object3D, WebGLRenderer } from 'three';
+import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
+import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+import KingSyLineMaterial from '../materials/KingSyLineMaterial.js';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { type Batch, type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
+export default class LineBatch implements Batch {
+    id: string;
+    subtreeId: string;
+    renderViews: NodeRenderView[];
+    protected geometry: LineSegmentsGeometry;
+    batchMaterial: KingSyLineMaterial;
+    protected batchTransparent: boolean;
+    protected batchOpacity: number;
+    protected mesh: LineSegments2;
+    colorBuffer: InstancedInterleavedBuffer;
+    private static readonly vector4Buffer;
+    get bounds(): Box3;
+    get drawCalls(): number;
+    get minDrawCalls(): number;
+    get triCount(): number;
+    get vertCount(): number;
+    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[]);
+    get pointCount(): number;
+    get lineCount(): number;
+    get renderObject(): Object3D;
+    get geometryType(): GeometryType;
+    get materials(): Material[];
+    get groups(): DrawGroup[];
+    getCount(): number;
+    setBatchMaterial(material: KingSyLineMaterial): void;
+    onUpdate(deltaTime: number): void;
+    onRender(renderer: WebGLRenderer): void;
+    setVisibleRange(ranges: BatchUpdateRange[]): void;
+    getVisibleRange(): BatchUpdateRange;
+    getOpaque(): BatchUpdateRange;
+    getDepth(): BatchUpdateRange;
+    getTransparent(): BatchUpdateRange;
+    getStencil(): BatchUpdateRange;
+    /** Reminder here that line batches do not really change materials, just the color buffer changes */
+    setBatchBuffers(ranges: BatchUpdateRange[]): void;
+    setDrawRanges(ranges: BatchUpdateRange[]): void;
+    resetDrawRanges(): void;
+    buildBatch(): Promise<void>;
+    getRenderView(index: number): NodeRenderView | null;
+    getMaterialAtIndex(index: number): Material;
+    /** TODO: I wish we wouldn't clone the material here...  */
+    getMaterial(rv: NodeRenderView): Material;
+    private makeLineGeometry;
+    private updateColorBuffer;
+    purge(): void;
+}

package/dist/modules/batching/MeshBatch.d.ts

@@ -0,0 +1,35 @@
+import { Material, BufferAttribute, Box3, BufferGeometry } from 'three';
+import { PrimitiveBatch } from './PrimitiveBatch.js';
+import KingSyMesh, { TransformStorage } from '../objects/KingSyMesh.js';
+import { DrawRanges } from './DrawRanges.js';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
+export declare class MeshBatch extends PrimitiveBatch {
+    protected primitive: KingSyMesh;
+    protected transformStorage: TransformStorage;
+    private indexBuffer0;
+    private indexBuffer1;
+    private indexBufferIndex;
+    protected drawRanges: DrawRanges;
+    get bounds(): Box3;
+    get minDrawCalls(): number;
+    get triCount(): number;
+    get pointCount(): number;
+    get lineCount(): number;
+    get geometryType(): GeometryType;
+    get mesh(): KingSyMesh;
+    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[], transformStorage: TransformStorage);
+    protected getCurrentIndexBuffer(): BufferAttribute;
+    protected getNextIndexBuffer(): BufferAttribute;
+    protected shuffleMaterialOrder(a: DrawGroup, b: DrawGroup): number;
+    protected updateGradientIndexBufferData(start: number, end: number, value: number): {
+        minIndex: number;
+        maxIndex: number;
+    };
+    setDrawRanges(ranges: BatchUpdateRange[]): void;
+    resetDrawRanges(): void;
+    buildBatch(): Promise<void>;
+    protected makeMeshGeometry(indices: Uint32Array | Uint16Array, position: Float64Array, normals: Float32Array, batchIndices: Float32Array, color?: Float32Array): BufferGeometry;
+    getRenderView(index: number): NodeRenderView | null;
+    getMaterialAtIndex(index: number): Material | null;
+}

package/dist/modules/batching/PointBatch.d.ts

@@ -0,0 +1,29 @@
+import { Material, Box3, BufferAttribute, Points, BufferGeometry } from 'three';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
+import { PrimitiveBatch } from './PrimitiveBatch.js';
+import { DrawRanges } from './DrawRanges.js';
+export declare class PointBatch extends PrimitiveBatch {
+    protected primitive: Points;
+    protected drawRanges: DrawRanges;
+    get geometryType(): GeometryType;
+    get bounds(): Box3;
+    get minDrawCalls(): number;
+    get triCount(): number;
+    get pointCount(): number;
+    get lineCount(): number;
+    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[]);
+    setDrawRanges(ranges: BatchUpdateRange[]): void;
+    resetDrawRanges(): void;
+    protected getCurrentIndexBuffer(): BufferAttribute;
+    protected getNextIndexBuffer(): BufferAttribute;
+    protected shuffleMaterialOrder(a: DrawGroup, b: DrawGroup): number;
+    protected updateGradientIndexBufferData(start: number, end: number, value: number): {
+        minIndex: number;
+        maxIndex: number;
+    };
+    buildBatch(): Promise<void>;
+    protected makePointGeometry(index: Int32Array, position: Float64Array, color: Float32Array): BufferGeometry;
+    getRenderView(index: number): NodeRenderView | null;
+    getMaterialAtIndex(index: number): Material | null;
+}

package/dist/modules/batching/PrimitiveBatch.d.ts

@@ -0,0 +1,57 @@
+import { Material, Object3D, BufferGeometry, BufferAttribute, Box3 } from 'three';
+import { NodeRenderView } from '../../index.js';
+import { type Batch, type BatchUpdateRange, GeometryType } from './Batch.js';
+import { type DrawGroup } from './Batch.js';
+export declare abstract class Primitive<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[]> extends Object3D {
+    geometry: TGeometry;
+    material: TMaterial;
+    visible: boolean;
+}
+export declare abstract class PrimitiveBatch implements Batch {
+    id: string;
+    subtreeId: string;
+    renderViews: NodeRenderView[];
+    batchMaterial: Material;
+    protected abstract primitive: Primitive;
+    protected gradientIndexBuffer: BufferAttribute;
+    protected needsShuffle: boolean;
+    abstract get geometryType(): GeometryType;
+    abstract get bounds(): Box3;
+    abstract get minDrawCalls(): number;
+    abstract get triCount(): number;
+    abstract get pointCount(): number;
+    abstract get lineCount(): number;
+    get materials(): Material[];
+    get groups(): DrawGroup[];
+    set groups(value: DrawGroup[]);
+    get renderObject(): Object3D;
+    get drawCalls(): number;
+    get vertCount(): number;
+    getCount(): number;
+    setBatchMaterial(material: Material): void;
+    onUpdate(): void;
+    setVisibleRange(ranges: BatchUpdateRange[]): void;
+    getVisibleRange(): BatchUpdateRange;
+    getOpaque(): BatchUpdateRange;
+    getDepth(): BatchUpdateRange;
+    getTransparent(): BatchUpdateRange;
+    getStencil(): BatchUpdateRange;
+    setBatchBuffers(ranges: BatchUpdateRange[]): void;
+    protected cleanMaterials(): void;
+    protected abstract getCurrentIndexBuffer(): BufferAttribute;
+    protected abstract getNextIndexBuffer(): BufferAttribute;
+    protected abstract shuffleMaterialOrder(a: DrawGroup, b: DrawGroup): number;
+    private shuffleDrawGroups;
+    protected abstract updateGradientIndexBufferData(start: number, end: number, value: number): {
+        minIndex: number;
+        maxIndex: number;
+    };
+    protected updateGradientIndexBuffer(rangeMin?: number, rangeMax?: number): void;
+    abstract setDrawRanges(ranges: BatchUpdateRange[]): void;
+    resetDrawRanges(): void;
+    abstract buildBatch(): Promise<void>;
+    abstract getRenderView(index: number): NodeRenderView | null;
+    abstract getMaterialAtIndex(index: number): Material | null;
+    getMaterial(rv: NodeRenderView): Material | null;
+    purge(): void;
+}

package/dist/modules/batching/TextBatch.d.ts

@@ -0,0 +1,41 @@
+import { Box3, Material, Object3D, WebGLRenderer } from 'three';
+import { NodeRenderView } from '../tree/NodeRenderView.js';
+import { type Batch, type BatchUpdateRange, type DrawGroup, GeometryType } from './Batch.js';
+import { KingSyText } from '../objects/KingSyText.js';
+export default class TextBatch implements Batch {
+    id: string;
+    subtreeId: string;
+    renderViews: NodeRenderView[];
+    batchMaterial: Material;
+    mesh: KingSyText;
+    get bounds(): Box3;
+    get drawCalls(): number;
+    get minDrawCalls(): number;
+    get triCount(): number;
+    get vertCount(): number;
+    constructor(id: string, subtreeId: string, renderViews: NodeRenderView[]);
+    get pointCount(): number;
+    get lineCount(): number;
+    get geometryType(): GeometryType;
+    get renderObject(): Object3D;
+    getCount(): number;
+    get materials(): Material[];
+    get groups(): DrawGroup[];
+    setBatchMaterial(material: Material): void;
+    onUpdate(deltaTime: number): void;
+    onRender(renderer: WebGLRenderer): void;
+    setVisibleRange(ranges: BatchUpdateRange[]): void;
+    getVisibleRange(): BatchUpdateRange;
+    getOpaque(): BatchUpdateRange;
+    getDepth(): BatchUpdateRange;
+    getTransparent(): BatchUpdateRange;
+    getStencil(): BatchUpdateRange;
+    setBatchBuffers(range: BatchUpdateRange[]): void;
+    setDrawRanges(ranges: BatchUpdateRange[]): void;
+    resetDrawRanges(): void;
+    buildBatch(): Promise<void>;
+    getRenderView(index: number): NodeRenderView;
+    getMaterialAtIndex(index: number): Material;
+    getMaterial(rv: NodeRenderView): Material;
+    purge(): void;
+}

package/dist/modules/converter/Geometry.d.ts

@@ -0,0 +1,38 @@
+import { Box3, BufferGeometry, Matrix4, Vector2, Vector3 } from 'three';
+import { type KingSyObject } from '../../IViewer.js';
+export declare enum GeometryAttributes {
+    POSITION = "POSITION",
+    COLOR = "COLOR",
+    NORMAL = "NORMAL",
+    UV = "UV",
+    TANGENT = "TANGENT",
+    INDEX = "INDEX"
+}
+export interface GeometryData {
+    attributes: ({
+        [GeometryAttributes.POSITION]: number[];
+    } & Partial<Record<Exclude<GeometryAttributes, GeometryAttributes.POSITION>, number[]>>) | null;
+    bakeTransform: Matrix4 | null;
+    transform: Matrix4 | null;
+    metaData?: KingSyObject;
+    instanced?: boolean;
+}
+export declare class Geometry {
+    static updateRTEGeometry(geometry: BufferGeometry, doublePositions: Float64Array | Float32Array): void;
+    static mergeGeometryAttribute(attributes: (number[] | undefined)[], target: Float32Array | Float64Array): ArrayLike<number>;
+    static mergeIndexAttribute(indexAttributes: (number[] | undefined)[], positionAttributes: (number[] | undefined)[]): number[];
+    static mergeGeometryData(geometries: GeometryData[]): GeometryData;
+    static transformGeometryData(geometryData: GeometryData, m: Matrix4 | null): void;
+    static unpackColors(int32Colors: number[]): number[];
+    /** Please see https://kingsy.systems/blog/improving-kingsys-rte-implementation/ for additional details
+     *  regarding double -> <float low; float high> encoding.
+     */
+    static DoubleToHighLowVector(input: Vector3, low: Vector3, high: Vector3): void;
+    static DoubleToHighLowBuffer(input: ArrayLike<number>, position_low: number[] | Float32Array, position_high: number[] | Float32Array): void;
+    static needsRTE(bounds: Box3): boolean;
+    static getFP32ProjectionDelta(point: Vector3, projection: Matrix4, screenSize: Vector2, relativeOffset?: number): Vector2;
+    /** Only supports indexed geometry */
+    static computeVertexNormalsBuffer(buffer: number[], position: number[], index: number[]): void;
+    static computeVertexNormals(buffer: BufferGeometry, doublePositions: Float64Array): void;
+    static triangulatePolygon(points: Vector2[]): number[];
+}

package/dist/modules/converter/MeshTriangulationHelper.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Set of functions to triangulate n-gon faces (i.e. polygon faces with an arbitrary (n) number of vertices).
+ * This class is a JavaScript port of https://github.com/kingsysystems/kingsy-sharp/blob/main/Objects/Objects/Utils/MeshTriangulationHelper.cs
+ */
+export default class MeshTriangulationHelper {
+    /**
+     * Calculates the triangulation of the face at given faceIndex.
+     * @remarks This implementation is based the ear clipping method proposed by "Christer Ericson (2005) <i>Real-Time Collision Detection</i>.
+     * @param {Number}   faceIndex      The index of the face's cardinality indicator `n`
+     * @param {Number[]}   faces      The list of faces in the mesh
+     * @param {Number[]}   vertices   The list of vertices in the mesh
+     * @return {Number[]} flat list of triangle faces (without cardinality indicators)
+     */
+    static triangulateFace(faceIndex: number, faces: number[], vertices: number[]): number[];
+    /**
+     * Tests if point v is within the triangle *abc*.
+     * @param {Vector3} v
+     * @param {Vector3} a
+     * @param {Vector3} b
+     * @param {Vector3} c
+     * @returns {boolean} true if v is within triangle.
+     */
+    static testPointTriangle(v: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
+    /**
+     * Checks that triangle abc is clockwise with reference to referenceNormal.
+     * @param {Vector3} referenceNormal The normal direction of the face.
+     * @param {Vector3} a
+     * @param {Vector3} b
+     * @param {Vector3} c
+     * @returns {boolean} true if triangle is ccw
+     */
+    static triangleIsCCW(referenceNormal: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
+}
+/**
+ * Encapsulates vector maths operations required for polygon triangulation
+ */
+declare class Vector3 {
+    constructor(x: any, y: any, z: any);
+    x: any;
+    y: any;
+    z: any;
+    add(v: any): Vector3;
+    sub(v: any): Vector3;
+    mul(n: any): Vector3;
+    dot(v: any): number;
+    cross(v: any): Vector3;
+    squareSum(): number;
+    normalize(): void;
+}
+export {};

package/dist/modules/converter/Units.d.ts

@@ -0,0 +1,12 @@
+export function getConversionFactor(from: any, to?: string): 1 | 0.001 | 12 | 10 | 0.01 | 0.1 | 0.000001 | 0.0393701 | 0.00328084 | 0.00109361 | 6.21371e-7 | 0.00001 | 0.393701 | 0.0328084 | 0.0109361 | 0.00000621371 | 1000 | 100 | 39.3701 | 3.28084 | 1.09361 | 0.000621371 | 1000000 | 100000 | 39370.1 | 3280.84 | 1093.61 | 0.621371 | 25.4 | 2.54 | 0.0254 | 0.0000254 | 0.0833333 | 0.027777694 | 0.0000157828 | 304.8 | 30.48 | 0.3048 | 0.0003048 | 0.333332328 | 0.000189394 | 1609000 | 160934 | 1609.34 | 1.60934 | 63360 | 5280 | 1759.99469184;
+export function normaliseName(unit: any): string;
+export namespace Units {
+    let Millimeters: string;
+    let Centimeters: string;
+    let Meters: string;
+    let Kilometers: string;
+    let Inches: string;
+    let Feet: string;
+    let Yards: string;
+    let Miles: string;
+}

package/dist/modules/extensions/CameraController.d.ts

@@ -0,0 +1,95 @@
+import { Extension } from './Extension.js';
+import { Box3, Camera, OrthographicCamera, PerspectiveCamera, Vector2, Vector3 } from 'three';
+import { type CameraEventPayload } from '../objects/KingSyCamera.js';
+import { CameraEvent, type KingSyCamera } from '../objects/KingSyCamera.js';
+import { FlyControls, FlyControlsOptions } from './controls/FlyControls.js';
+import { KingSyControls } from './controls/KingSyControls.js';
+import { IViewer, KingSyView } from '../../IViewer.js';
+import { SmoothOrbitControlsOptions, SmoothOrbitControls } from './controls/SmoothOrbitControls.js';
+export declare enum NearPlaneCalculation {
+    EMPIRIC = 0,
+    ACCURATE = 1
+}
+export type CanonicalView = 'front' | 'back' | 'up' | 'top' | 'down' | 'bottom' | 'right' | 'left' | '3d' | '3D';
+export type InlineView = {
+    position: Vector3;
+    target: Vector3;
+};
+export type PolarView = {
+    azimuth: number;
+    polar: number;
+    radius?: number;
+    origin?: Vector3;
+};
+export type CameraControllerOptions = SmoothOrbitControlsOptions & FlyControlsOptions & {
+    nearPlaneCalculation?: NearPlaneCalculation;
+};
+export declare function isPerspectiveCamera(camera: Camera): camera is PerspectiveCamera;
+export declare function isOrthographicCamera(camera: Camera): camera is OrthographicCamera;
+export declare function computeOrthographicSize(distance: number, fov: number, aspect: number): Vector2;
+export declare const DefaultOrbitControlsOptions: Required<CameraControllerOptions>;
+export declare class CameraController extends Extension implements KingSyCamera {
+    protected _renderingCamera: PerspectiveCamera | OrthographicCamera;
+    protected perspectiveCamera: PerspectiveCamera;
+    protected orthographicCamera: OrthographicCamera;
+    protected _lastCameraChanged: boolean;
+    protected _options: Required<CameraControllerOptions>;
+    protected _activeControls: KingSyControls;
+    protected _orbitControls: SmoothOrbitControls;
+    protected _flyControls: FlyControls;
+    get renderingCamera(): PerspectiveCamera | OrthographicCamera;
+    set renderingCamera(value: PerspectiveCamera | OrthographicCamera);
+    get enabled(): boolean;
+    set enabled(val: boolean);
+    get fieldOfView(): number;
+    set fieldOfView(value: number);
+    get aspect(): number;
+    get controls(): KingSyControls;
+    get options(): Required<CameraControllerOptions>;
+    set options(value: CameraControllerOptions);
+    constructor(viewer: IViewer);
+    default(): void;
+    on<T extends CameraEvent>(eventType: T, listener: (arg: CameraEventPayload[T]) => void): void;
+    getTarget(): Vector3;
+    getPosition(): Vector3;
+    toggleControls(): void;
+    setCameraView(objectIds: string[] | undefined, transition: boolean | undefined, fit?: number): void;
+    setCameraView(view: CanonicalView | KingSyView | InlineView | PolarView, transition: boolean | undefined, fit?: number): void;
+    setCameraView(bounds: Box3, transition: boolean | undefined, fit?: number): void;
+    onEarlyUpdate(_delta?: number): void;
+    onLateUpdate(): void;
+    onResize(): void;
+    setPerspectiveCameraOn(): void;
+    setOrthoCameraOn(): void;
+    toggleCameras(): void;
+    protected setupOrthoCamera(): void;
+    protected setupPerspectiveCamera(): void;
+    disableRotations(): void;
+    enableRotations(): void;
+    updateCameraPlanes(targetVolume?: Box3, offsetScale?: number): void;
+    protected computeNearCameraPlaneEmpiric(targetVolume?: Box3, offsetScale?: number): number | undefined;
+    protected computeNearCameraPlaneAccurate(targetVolume?: Box3, offsetScale?: number, fallback?: number): number | undefined;
+    protected updateFarCameraPlane(): void;
+    protected getClosestGeometryDistance(fallback?: number): number;
+    protected zoom(objectIds?: string[], fit?: number, transition?: boolean): void;
+    protected zoomExtents(fit?: number, transition?: boolean): void;
+    protected zoomToBox(box: Box3, fit?: number, transition?: boolean): void;
+    protected fitToRadius(radius: number): number;
+    protected isKingSyView(view: CanonicalView | KingSyView | InlineView | PolarView): view is KingSyView;
+    protected isCanonicalView(view: CanonicalView | KingSyView | InlineView | PolarView): view is CanonicalView;
+    protected isInlineView(view: CanonicalView | KingSyView | InlineView | PolarView): view is InlineView;
+    protected isPolarView(view: CanonicalView | KingSyView | InlineView | PolarView): view is PolarView;
+    protected isBox3(view: CanonicalView | KingSyView | InlineView | PolarView | Box3): view is Box3;
+    protected setView(view: CanonicalView | KingSyView | InlineView | PolarView, transition?: boolean): void;
+    protected setViewKingSy(view: KingSyView, transition?: boolean): void;
+    /**
+     * Rotates camera to some canonical views
+     * @param  {string}  side       Can be any of front, back, up (top), down (bottom), right, left.
+     * @param  {Number}  fit        [description]
+     * @param  {Boolean} transition [description]
+     * @return {[type]}             [description]
+     */
+    protected setViewCanonical(side: string, transition?: boolean): void;
+    protected setViewInline(view: InlineView, transition?: boolean): void;
+    private setViewPolar;
+}

package/dist/modules/extensions/Controls.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Abstract base class for controls.
+ *
+ * @abstract
+ * @augments EventDispatcher
+ */
+export class Controls extends EventDispatcher<import("three").Event> {
+    /**
+     * Constructs a new controls instance.
+     *
+     * @param {Object3D} object - The object that is managed by the controls.
+     * @param {?HTMLDOMElement} domElement - The HTML element used for event listeners.
+     */
+    constructor(object: Object3D, domElement?: HTMLDOMElement | null);
+    /**
+     * The object that is managed by the controls.
+     *
+     * @type {Object3D}
+     */
+    object: Object3D;
+    /**
+     * The HTML element used for event listeners.
+     *
+     * @type {?HTMLDOMElement}
+     * @default null
+     */
+    domElement: HTMLDOMElement | null;
+    /**
+     * Whether the controls responds to user input or not.
+     *
+     * @type {boolean}
+     * @default true
+     */
+    enabled: boolean;
+    /**
+     * The internal state of the controls.
+     *
+     * @type {number}
+     * @default -1
+     */
+    state: number;
+    /**
+     * This object defines the keyboard input of the controls.
+     *
+     * @type {Object}
+     */
+    keys: Object;
+    /**
+     * This object defines what type of actions are assigned to the available mouse buttons.
+     * It depends on the control implementation what kind of mouse buttons and actions are supported.
+     *
+     * @type {{LEFT: ?number, MIDDLE: ?number, RIGHT: ?number}}
+     */
+    mouseButtons: {
+        LEFT: number | null;
+        MIDDLE: number | null;
+        RIGHT: number | null;
+    };
+    /**
+     * This object defines what type of actions are assigned to what kind of touch interaction.
+     * It depends on the control implementation what kind of touch interaction and actions are supported.
+     *
+     * @type {{ONE: ?number, TWO: ?number}}
+     */
+    touches: {
+        ONE: number | null;
+        TWO: number | null;
+    };
+    /**
+     * Connects the controls to the DOM. This method has so called "side effects" since
+     * it adds the module's event listeners to the DOM.
+     */
+    connect(): void;
+    /**
+     * Disconnects the controls from the DOM.
+     */
+    disconnect(): void;
+    /**
+     * Call this method if you no longer want use to the controls. It frees all internal
+     * resources and removes all event listeners.
+     */
+    dispose(): void;
+    /**
+     * Controls should implement this method if they have to update their internal state
+     * per simulation step.
+     *
+     * @param {number} [delta] - The time delta in seconds.
+     */
+    update(): void;
+}
+import { EventDispatcher } from 'three';

package/dist/modules/extensions/DiffExtension.d.ts

@@ -0,0 +1,50 @@
+import { type TreeNode, WorldTree } from '../tree/WorldTree.js';
+import { type IViewer } from '../../IViewer.js';
+import { Extension } from './Extension.js';
+export declare enum VisualDiffMode {
+    PLAIN = 0,
+    COLORED = 1
+}
+export interface DiffResult {
+    unchanged: Array<TreeNode>;
+    added: Array<TreeNode>;
+    removed: Array<TreeNode>;
+    modified: Array<Array<TreeNode>>;
+}
+export declare class DiffExtension extends Extension {
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    protected tree: WorldTree;
+    private addedMaterialMesh;
+    private changedNewMaterialMesh;
+    private changedOldMaterialMesh;
+    private removedMaterialMesh;
+    private addedMaterialPoint;
+    private changedNewMaterialPoint;
+    private changedOldMaterialPoint;
+    private removedMaterialPoint;
+    private addedMaterials;
+    private changedOldMaterials;
+    private changedNewMaterials;
+    private removedMaterials;
+    private _materialGroups;
+    private _visualDiff;
+    private _diffTime;
+    private _diffMode;
+    constructor(viewer: IViewer);
+    private dynamicallyLoadedDiffResources;
+    diff(urlA: string, urlB: string, mode: VisualDiffMode, authToken?: string): Promise<DiffResult>;
+    /** Currently, the diff does not store the existing materials. We can do that if we need to */
+    undiff(): Promise<void>;
+    private buildIdMaps;
+    private getDiff;
+    private diffIterative;
+    updateVisualDiff(time?: number, mode?: VisualDiffMode): void;
+    private setDiffTime;
+    private buildMaterialGroups;
+    private resetMaterialGroups;
+    private getVisualDiffResult;
+    private getColoredMaterialGroups;
+    private getPlainMaterialGroups;
+    private getBatchesSubgroups;
+}

package/dist/modules/extensions/ExplodeExtension.d.ts

@@ -0,0 +1,17 @@
+import { Extension } from './Extension.js';
+export declare enum ExplodeEvent {
+    Finshed = "explode-finished"
+}
+export interface ViewModeEventPayload {
+    [ExplodeEvent.Finshed]: void;
+}
+export declare class ExplodeExtension extends Extension {
+    protected _enabled: boolean;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    private explodeTime;
+    private explodeRange;
+    onEarlyUpdate(): void;
+    setExplode(time: number): void;
+    private explode;
+}

package/dist/modules/extensions/Extension.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from 'type-fest';
+import { type IViewer } from '../../index.js';
+import EventEmitter from '../EventEmitter.js';
+export declare class Extension extends EventEmitter {
+    get inject(): Array<Constructor<Extension>>;
+    protected viewer: IViewer;
+    protected _enabled: boolean;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    constructor(viewer: IViewer, ...args: Extension[]);
+    onEarlyUpdate(deltaTime?: number): void;
+    onLateUpdate(deltaTime?: number): void;
+    onRender(): void;
+    onResize(): void;
+}