@kingsy/viewer 2.25.7

package/dist/modules/extensions/measurements/AreaMeasurement.d.ts

@@ -0,0 +1,64 @@
+import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { Measurement } from './Measurement.js';
+import { ExtendedMeshIntersection } from '../../objects/KingSyRaycaster.js';
+export declare class AreaMeasurement extends Measurement {
+    /** We store all gizmos here */
+    private pointGizmos;
+    /** This stores the last touched point position and normal */
+    private surfacePoint;
+    private surfaceNormal;
+    /** The plane params defined by the first placed point */
+    private planeOrigin;
+    private planeNormal;
+    /** The location of the area text label */
+    private labelPoint;
+    /** Various point list. A bit exhaustive, but safer */
+    private pointIndex;
+    /** The selected points in 3D space */
+    private points;
+    /** The selected points projected on the measurement plane */
+    private measuredPoints;
+    /** The points defining the fill polygon. Also projected on the measurement plane */
+    private polygonPoints;
+    private fillPolygon;
+    private snapDistance;
+    set isVisible(value: boolean);
+    get bounds(): Box3;
+    constructor();
+    /** Frame */
+    frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
+    /** Called whenver the last touched location updates */
+    locationUpdated(point: Vector3, normal: Vector3): void;
+    /** Called whenver a location is selected for measuring*/
+    locationSelected(): void;
+    /** Adds a point to the area measurement */
+    addPoint(): number;
+    /** Removes point from the measurement */
+    removePoint(): number;
+    /** Auto completes the measurement by joining with the first point */
+    autoFinish(): void;
+    /** Area measurement's custom snap function. We snap to the first point by design */
+    snap(ndcPoint: Vector2, _intersection: ExtendedMeshIntersection, outPoint: Vector3, outNormal: Vector3): boolean;
+    /** Updates the gizmo components based on it's state and values */
+    update(): Promise<void>;
+    /** Updates the area label location using the polyong's pole of innaccessibility
+     *  We do this to avoid having the label outside of the polygin in case of concave polygons
+     *  It works great for concave polygons, but not so great for convex regular ones
+     */
+    private updateLabelLocation;
+    /** Updates the measured polygon's geometry */
+    private updateFillPolygon;
+    /** Measurement's custom picking. We don't test the polygon when casting */
+    raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
+    highlight(value: boolean): void;
+    updateClippingPlanes(planes: Plane[]): void;
+    /** Had to make my own. Three's Hesse normal form trips me up */
+    private projectOnPlane;
+    /** Selects the vector components to use based on the measurement plane.
+     *  Don't really like it, but it works
+     */
+    private chooseProjectionAxes;
+    /** Area calculation */
+    private shoelaceArea;
+    private shoelaceArea3D;
+}

package/dist/modules/extensions/measurements/Measurement.d.ts

@@ -0,0 +1,34 @@
+import { Box3, Camera, Object3D, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { ExtendedMeshIntersection } from '../../objects/KingSyRaycaster.js';
+export declare enum MeasurementState {
+    HIDDEN = 0,
+    DANGLING_START = 1,
+    DANGLING_END = 2,
+    COMPLETE = 3
+}
+export declare abstract class Measurement extends Object3D {
+    startPoint: Vector3;
+    endPoint: Vector3;
+    startNormal: Vector3;
+    endNormal: Vector3;
+    startLineLength: number;
+    endLineLength: number;
+    value: number;
+    units: string;
+    precision: number;
+    protected _state: MeasurementState;
+    protected renderingCamera: Camera | null;
+    protected renderingSize: Vector2;
+    set state(value: MeasurementState);
+    get state(): MeasurementState;
+    abstract set isVisible(value: boolean);
+    get bounds(): Box3;
+    frameUpdate(camera: Camera | null, size: Vector2, _bounds?: Box3): void;
+    abstract update(): Promise<void>;
+    abstract raycast(_raycaster: Raycaster, _intersects: Array<Intersection>): void;
+    abstract highlight(_value: boolean): void;
+    abstract updateClippingPlanes(_planes: Plane[]): void;
+    abstract locationUpdated(point?: Vector3, normal?: Vector3, ndcScreen?: Vector2): void;
+    abstract locationSelected(point?: Vector3, normal?: Vector3, ndcScreen?: Vector2): void;
+    snap?(ndcPoint: Vector2, intersection: ExtendedMeshIntersection, outPoint: Vector3, outNormal: Vector3): boolean;
+}

package/dist/modules/extensions/measurements/MeasurementPointGizmo.d.ts

@@ -0,0 +1,42 @@
+import { Camera, Group, Plane, Quaternion, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+export interface MeasurementPointGizmoStyle {
+    dashedLine?: boolean;
+    normalIndicatorPixelSize?: number;
+    normalIndicatorColor?: number;
+    normalIndicatorOpacity?: number;
+    lineColor?: number;
+    lineOpacity?: number;
+    pointColor?: number;
+    pointOpacity?: number;
+    textColor?: number;
+    textOpacity?: number;
+    textPixelHeight?: number;
+    pointPixelHeight?: number;
+}
+export declare class MeasurementPointGizmo extends Group {
+    private normalIndicator;
+    private normalIndicatorBuffer;
+    private normalIndicatorNormal;
+    private normalIndicatorTangent;
+    private normalIndicatorBitangent;
+    private line;
+    private point;
+    private text;
+    private _style;
+    set style(value: MeasurementPointGizmoStyle);
+    set highlight(value: boolean);
+    private getNormalIndicatorMaterial;
+    private getLineMaterial;
+    private getPointMaterial;
+    private getTextMaterial;
+    constructor(style?: MeasurementPointGizmoStyle);
+    enable(normalIndicator: boolean, line: boolean, point: boolean, text: boolean): void;
+    frameUpdate(camera: Camera, size: Vector2): void;
+    updateNormalIndicator(position: Vector3, normal: Vector3): void;
+    updatePoint(position: Vector3): void;
+    updateLine(points: Vector3[]): void;
+    updateText(value: string, position?: Vector3, quaternion?: Quaternion, scale?: Vector3): Promise<void>;
+    updateStyle(): void;
+    raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
+    updateClippingPlanes(planes: Plane[]): void;
+}

package/dist/modules/extensions/measurements/MeasurementsExtension.d.ts

@@ -0,0 +1,71 @@
+import KingSyRenderer from '../../KingSyRenderer.js';
+import { type IViewer } from '../../../IViewer.js';
+import { Plane, Raycaster, Vector2, Vector3 } from 'three';
+import { Measurement } from './Measurement.js';
+import { ExtendedMeshIntersection } from '../../objects/KingSyRaycaster.js';
+import { Extension } from '../Extension.js';
+import { CameraController } from '../CameraController.js';
+export declare enum MeasurementType {
+    PERPENDICULAR = 0,
+    POINTTOPOINT = 1,
+    AREA = 2,
+    POINT = 3
+}
+export interface MeasurementOptions {
+    visible: boolean;
+    type?: MeasurementType;
+    vertexSnap?: boolean;
+    units?: string;
+    precision?: number;
+    chain?: boolean;
+}
+export declare class MeasurementsExtension extends Extension {
+    protected cameraProvider: CameraController;
+    get inject(): (typeof CameraController)[];
+    protected renderer: KingSyRenderer;
+    protected measurements: Measurement[];
+    protected _activeMeasurement: Measurement | null;
+    protected _selectedMeasurement: Measurement | null;
+    protected raycaster: Raycaster;
+    protected _options: MeasurementOptions;
+    private _frameLock;
+    private _paused;
+    private _sceneHit;
+    private pointBuff;
+    private normalBuff;
+    private screenBuff0;
+    private screenBuff1;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get options(): MeasurementOptions;
+    set options(options: MeasurementOptions);
+    get selectedMeasurement(): Measurement | null;
+    get activeMeasurement(): Measurement | null;
+    constructor(viewer: IViewer, cameraProvider: CameraController);
+    onLateUpdate(): void;
+    onResize(): void;
+    protected onPointerMove(data: Vector2 & {
+        event: Event;
+    }): void;
+    protected onPointerClick(data: {
+        event: PointerEvent;
+        multiSelect: boolean;
+    } & Vector2): void;
+    protected onPointerDoubleClick(data: Vector2 & {
+        event: PointerEvent;
+        multiSelect: boolean;
+    }): void;
+    protected autoLazerMeasure(data: Vector2): void;
+    protected startMeasurement(): Measurement;
+    protected cancelMeasurement(): void;
+    protected finishMeasurement(): void;
+    removeMeasurement(): void;
+    clearMeasurements(): void;
+    protected flashMeasurement(): void;
+    protected pickMeasurement(data: Vector2): Measurement | null;
+    protected selectMeasurement(measurement: Measurement, value: boolean): void;
+    protected snap(intersection: ExtendedMeshIntersection, outPoint: Vector3, outNormal: Vector3): void;
+    protected updateClippingPlanes(planes: Plane[]): void;
+    protected applyOptions(): void;
+    fromMeasurementData(startPoint: Vector3, endPoint: Vector3): Promise<void>;
+}

package/dist/modules/extensions/measurements/PerpendicularMeasurement.d.ts

@@ -0,0 +1,19 @@
+import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { Measurement } from './Measurement.js';
+export declare class PerpendicularMeasurement extends Measurement {
+    private startGizmo;
+    private endGizmo;
+    private normalIndicatorPixelSize;
+    flipStartNormal: boolean;
+    midPoint: Vector3;
+    set isVisible(value: boolean);
+    get bounds(): Box3;
+    constructor();
+    frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
+    locationUpdated(point: Vector3, normal: Vector3): void;
+    locationSelected(): void;
+    update(): Promise<void>;
+    raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
+    highlight(value: boolean): void;
+    updateClippingPlanes(planes: Plane[]): void;
+}

package/dist/modules/extensions/measurements/PointMeasurement.d.ts

@@ -0,0 +1,25 @@
+import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { Measurement } from './Measurement.js';
+import { KingSyText } from '../../objects/KingSyText.js';
+import { MeasurementPointGizmo } from './MeasurementPointGizmo.js';
+export declare class PointMeasurement extends Measurement {
+    protected gizmo: MeasurementPointGizmo;
+    protected xLabel: KingSyText;
+    protected yLabel: KingSyText;
+    protected zLabel: KingSyText;
+    protected xLabelPosition: Vector3;
+    protected yLabelPosition: Vector3;
+    protected zLabelPosition: Vector3;
+    protected readonly pixelsOffX: number;
+    protected readonly pixelsOffY: number;
+    set isVisible(value: boolean);
+    constructor();
+    frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
+    locationUpdated(point: Vector3, normal: Vector3): void;
+    locationSelected(): void;
+    protected updateLabelPositions(): void;
+    update(): Promise<void>;
+    raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
+    highlight(value: boolean): void;
+    updateClippingPlanes(planes: Plane[]): void;
+}

package/dist/modules/extensions/measurements/PointToPointMeasurement.d.ts

@@ -0,0 +1,15 @@
+import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
+import { Measurement } from './Measurement.js';
+export declare class PointToPointMeasurement extends Measurement {
+    private startGizmo;
+    private endGizmo;
+    set isVisible(value: boolean);
+    constructor();
+    frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
+    locationUpdated(point: Vector3, normal: Vector3): void;
+    locationSelected(): void;
+    update(): Promise<void>;
+    raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
+    highlight(value: boolean): void;
+    updateClippingPlanes(planes: Plane[]): void;
+}

package/dist/modules/extensions/sections/SectionOutlines.d.ts

@@ -0,0 +1,45 @@
+import { Plane } from 'three';
+import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
+import { Extension } from '../Extension.js';
+import { SectionTool, type IViewer } from '../../../index.js';
+export declare enum PlaneId {
+    POSITIVE_X = "POSITIVE_X",
+    POSITIVE_Y = "POSITIVE_Y",
+    POSITIVE_Z = "POSITIVE_Z",
+    NEGATIVE_X = "NEGATIVE_X",
+    NEGATIVE_Y = "NEGATIVE_Y",
+    NEGATIVE_Z = "NEGATIVE_Z"
+}
+export interface PlaneOutline {
+    renderable: LineSegments2;
+}
+export declare class SectionOutlines extends Extension {
+    protected sectionProvider: SectionTool;
+    get inject(): (typeof SectionTool)[];
+    private static readonly OUTLINE_Z_OFFSET;
+    private static readonly INITIAL_BUFFER_SIZE;
+    private tmpVec;
+    private up;
+    private down;
+    private left;
+    private right;
+    private forward;
+    private back;
+    private planeOutlines;
+    private lastSectionPlanes;
+    private sectionPlanesChanged;
+    constructor(viewer: IViewer, sectionProvider: SectionTool);
+    private getPlaneOutline;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    sectionUpdated(planes: Plane[]): void;
+    requestUpdate(force?: boolean): void;
+    private updatePlaneOutline;
+    private createPlaneOutline;
+    private onSectionBoxDragStart;
+    private onSectionBoxDragEnd;
+    private setSectionPlaneChanged;
+    private updateOutlines;
+    private resizeGeometryBuffer;
+    private getPlaneId;
+}

package/dist/modules/extensions/sections/SectionTool.d.ts

@@ -0,0 +1,219 @@
+import { Group, Box3, BufferGeometry, Mesh, Vector3, Plane, Raycaster, Object3D, Matrix4, Vector2, Face, PlaneGeometry } from 'three';
+import { TransformControls } from '../TransformControls.js';
+import { OBB } from 'three/examples/jsm/math/OBB.js';
+import { type IViewer } from '../../../IViewer.js';
+import { CameraController } from '../CameraController.js';
+import { Vector3Like } from '../../batching/BatchObject.js';
+import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
+import KingSyStandardMaterial from '../../materials/KingSyStandardMaterial.js';
+import { Extension } from '../Extension.js';
+export declare enum SectionToolEvent {
+    DragStart = "section-box-drag-start",
+    DragEnd = "section-box-drag-end",
+    Updated = "section-box-changed"
+}
+export interface SectionToolEventPayload {
+    [SectionToolEvent.DragStart]: void;
+    [SectionToolEvent.DragEnd]: void;
+    [SectionToolEvent.Updated]: Plane[];
+}
+export declare class SectionTool extends Extension {
+    protected cameraProvider: CameraController;
+    get inject(): (typeof CameraController)[];
+    /** This is our data model. All we need is an OBB */
+    protected obb: OBB;
+    /** The planes that will send out as clipping planes */
+    protected planes: Plane[];
+    /** The six planes of the unit cube */
+    protected localPlanes: Plane[];
+    /** Convenience LUT for when clicking on the box faces */
+    protected cubeFaces: {
+        '256': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '152': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '407': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '703': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '327': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '726': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '450': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '051': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '312': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '013': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '546': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+        '647': {
+            verts: number[];
+            axis: string;
+            normal: Vector3;
+        };
+    };
+    /** The root object  */
+    protected display: Group;
+    /** We only use this for hit testing to select it's faces */
+    protected boxHitMesh: Mesh;
+    /** The displayed box as an outline */
+    protected boxOutline: LineSegments2;
+    /** Mesh that gets shown across a box face when it gets selected */
+    protected facePlane: Mesh;
+    /** Anchor objects for the controls. Not displayable */
+    protected translationRotationAnchor: Object3D;
+    protected scaleAnchor: Object3D;
+    /** Controls instances */
+    protected translateControls: TransformControls;
+    protected rotateControls: TransformControls;
+    protected scaleControls: TransformControls;
+    /** Sum state */
+    protected lastScale: Vector3 | null;
+    protected lastObbTransform: Matrix4;
+    protected draggingFace: Face | null;
+    /** Hit testing related */
+    protected raycaster: Raycaster;
+    protected dragging: boolean;
+    /** Manadatory property for all extensions */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /** Hides all controls and the box outline but keeps the sections enabled */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /** Gets the up to date section planes */
+    get sectionPlanes(): Plane[];
+    /**
+     *
+     */
+    constructor(viewer: IViewer, cameraProvider: CameraController);
+    /**
+     *
+     */
+    /** We use the viewer's frame update to enable/disable the translate and rotate controls
+     *  The controls were not meant to be overlayed and working in multiple instance setups
+     *  so their input events overlap. It's not the best solution in the world, but it's one
+     *  that requires little to no source change
+     */
+    onEarlyUpdate(): void;
+    /** Explicit events for the selection tool */
+    on<T extends SectionToolEvent>(eventType: T, listener: (arg: SectionToolEventPayload[T]) => void): void;
+    /** Gets the OBB model */
+    getBox(): OBB;
+    /**
+     * Sets the OBB model and updates the tool gizmos and box
+     * @param targetBox The box to set. It accepts an aabb as well
+     * @param offset Optional offset
+     */
+    setBox(targetBox: OBB | Box3 | {
+        min: Vector3Like;
+        max: Vector3Like;
+    }, offset?: number): void;
+    /**
+     * Convenience method
+     */
+    toggle(): void;
+    /** Gets the transformation defined by the OBB */
+    getObbTransform(): Matrix4;
+    /**
+     * Creates the controls and all their gizmos
+     */
+    protected setupControls(): void;
+    /**
+     * Controls, outline and hitbox update based on the OBB model
+     */
+    protected updateVisual(): void;
+    /**
+     * Triggers when dragging starts/stops
+     * @param event Controls event
+     */
+    protected draggingHandler(event: any): void;
+    /** Triggers whenever there is a change in the controls and their gizmos
+     *  This is where the model OBB gets updated according to controls changes.
+     *  Each control type writes it's data in the anchor's matching property. So:
+     *  - Translate control write to it's anchor 'position'
+     *  - Rotate control writes to it's anchor 'quaternion'
+     *  - Scale control writes to it's anchor 'scale
+     */
+    protected changeHandler(): void;
+    /**
+     * Handler used for detecting when we click on the box faces
+     * @param args NDC pointer coords + original event + multiselect
+     * @returns
+     */
+    protected clickHandler(args: Vector2 & {
+        event: PointerEvent;
+        multiSelect: boolean;
+    }): void;
+    /**
+     * Computes the final box planes from the unit cube planes
+     * transformed against the current OBB model
+     */
+    protected updatePlanes(): void;
+    /**
+     * Creates the plane mesh that will be shown when selecting a box face
+     * It's RTE enabled
+     */
+    protected createFacePlane(): Mesh<PlaneGeometry, KingSyStandardMaterial>;
+    /**
+     * Updates the scale control and plane mesh when a cube face is selected
+     * @param face The face we're pulling/pushing
+     * @returns void
+     */
+    protected updateFaceControls(face: Face | null): void;
+    /** Creates the geometry for the visible outline of the section tool */
+    protected createOutline(): LineSegments2;
+    /** Updates the section tool outline by updating it's vertices
+     *  We chose to do it this way in order have RTE working
+     */
+    protected updateOutline(): void;
+    /** Creates a unit cube geometry instance*/
+    protected createCubeGeometry(): BufferGeometry;
+    /** Restes the gizmos. Honestly not sure if it does anything meaningfull */
+    protected reset(): void;
+    /** Type guards */
+    protected isAABB(box: Box3 | {
+        min: Vector3Like;
+        max: Vector3Like;
+    } | OBB): box is Box3;
+    protected isOBB(box: Box3 | {
+        min: Vector3Like;
+        max: Vector3Like;
+    } | OBB): box is OBB;
+}

package/dist/modules/filtering/PropertyManager.d.ts

@@ -0,0 +1,55 @@
+import { WorldTree } from '../tree/WorldTree.js';
+export declare class PropertyManager {
+    private propCache;
+    /**
+     *
+     * @param resourceUrl The target resource's url. This must be an **object url** or null. If null, it will return the props for the whole scene.
+     * @param bypassCache Forces a full rescan if set to true.
+     * @returns a list of property infos containing basic information for filtering purposes.
+     */
+    getProperties(tree: WorldTree, resourceUrl?: string | null, bypassCache?: boolean): Promise<PropertyInfo[]>;
+}
+/**
+ * PropertyInfo types represent all of the properties that you can filter on in the viewer
+ */
+export interface PropertyInfo {
+    /**
+     * Property identifier, flattened
+     */
+    key: string;
+    /**
+     * Total number of objects that have this property
+     */
+    objectCount: number;
+    type: 'number' | 'string';
+}
+export interface NumericPropertyInfo extends PropertyInfo {
+    type: 'number';
+    /**
+     * Absolute min/max values that are available for this property
+     */
+    min: number;
+    max: number;
+    /**
+     * An array of pairs of object IDs and their actual values for that property
+     */
+    valueGroups: {
+        value: number;
+        id: string;
+    }[];
+    /**
+     * User defined/filtered min/max that is bound within min/max above
+     */
+    passMin: number | null;
+    passMax: number | null;
+}
+export interface StringPropertyInfo extends PropertyInfo {
+    type: 'string';
+    /**
+     * An array of pairs of object IDs and their actual values for that property
+     */
+    valueGroups: {
+        value: string;
+        ids: string[];
+    }[];
+}

package/dist/modules/input/Input.d.ts

@@ -0,0 +1,47 @@
+import { Vector2 } from 'three';
+import EventEmitter from '../EventEmitter.js';
+export declare enum InputEvent {
+    PointerDown = "pointer-down",
+    PointerUp = "pointer-up",
+    PointerMove = "pointer-move",
+    PointerCancel = "pointer-cancel",
+    Wheel = "wheel",
+    Click = "click",
+    DoubleClick = "double-click",
+    KeyUp = "key-up"
+}
+export interface InputEventPayload {
+    [InputEvent.PointerDown]: Vector2 & {
+        event: PointerEvent;
+    };
+    [InputEvent.PointerUp]: Vector2 & {
+        event: PointerEvent;
+    };
+    [InputEvent.PointerMove]: Vector2 & {
+        event: PointerEvent;
+    };
+    [InputEvent.PointerCancel]: void;
+    [InputEvent.Wheel]: WheelEvent;
+    [InputEvent.Click]: Vector2 & {
+        event: PointerEvent;
+        multiSelect: boolean;
+    };
+    [InputEvent.DoubleClick]: Vector2 & {
+        event: PointerEvent;
+        multiSelect: boolean;
+    };
+    [InputEvent.KeyUp]: KeyboardEvent;
+}
+export default class Input extends EventEmitter {
+    private static readonly MAX_DOUBLE_CLICK_TIMING;
+    private static readonly MIN_CLICK_TIMING;
+    private tapTimeout;
+    private lastTap;
+    private lastClick;
+    private touchLocation;
+    private container;
+    constructor(container: HTMLElement);
+    on<T extends InputEvent>(eventType: T, listener: (arg: InputEventPayload[T]) => void): void;
+    _getNormalisedClickPosition(e: MouseEvent | Touch): Vector2;
+    dispose(): void;
+}

package/dist/modules/loaders/GeometryConverter.d.ts

@@ -0,0 +1,32 @@
+import { type GeometryData } from '../converter/Geometry.js';
+import type { NodeData } from '../tree/WorldTree.js';
+export declare enum KingSyType {
+    View3D = "View3D",
+    BlockInstance = "BlockInstance",
+    Pointcloud = "Pointcloud",
+    Brep = "Brep",
+    Mesh = "Mesh",
+    Point = "Point",
+    Line = "Line",
+    Polyline = "Polyline",
+    Box = "Box",
+    Polycurve = "Polycurve",
+    Curve = "Curve",
+    Circle = "Circle",
+    Arc = "Arc",
+    Ellipse = "Ellipse",
+    RevitInstance = "RevitInstance",
+    Text = "Text",
+    Transform = "Transform",
+    InstanceProxy = "InstanceProxy",
+    RenderMaterialProxy = "RenderMaterialProxy",
+    ColorProxy = "ColorProxy",
+    Region = "Region",
+    Unknown = "Unknown"
+}
+export declare const KingSyTypeAllRenderables: KingSyType[];
+export declare abstract class GeometryConverter {
+    abstract getKingSyType(node: NodeData): KingSyType;
+    abstract convertNodeToGeometryData(node: NodeData): GeometryData | null;
+    abstract disposeNodeGeometryData(node: NodeData): void;
+}