@maqiuyao/dxf-viewer 0.1.0

package/dist/src/dxfViewer/core/helpers/LoadingHelper.d.ts

@@ -0,0 +1,59 @@
+import { DxfData, DxfLoaderConfig } from '../dxf';
+import { FontManager } from '../font';
+import * as THREE from "three";
+export declare class LoadingHelper {
+    private static DecoderPath;
+    private static Rhino3dmLibraryPath;
+    private gltfLoader?;
+    private font?;
+    private manager?;
+    constructor(manager?: THREE.LoadingManager);
+    setLoadManager(manager?: THREE.LoadingManager): void;
+    /**
+     * Loads a model from local
+     * @param url Created by URL.createObjectURL(file)
+     * @param src Source filename, used to find out format
+     * @param onProgress On progress callback
+     * @returns Loaded object
+     */
+    loadLocalModel(url: string, src: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadModel(src: string, fileFormat?: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
+    loadGltf(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    parseGltf(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    loadFbx(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadObj(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadStl(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadShp(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadDae(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * Loads rhino 3dm file.
+     * @deprecated Rhino3dmLoader 已从 three@0.159 移除，3dm 格式不再支持
+     */
+    load3dm(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadDxf(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadPly(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * It is kind of tricky to load image into scene, but we'll do this by creating a sprite.
+     */
+    loadImage(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * Loads dxf data, including entities, tables(layers, blocks), etc.
+     */
+    loadDxfData(url: string, dxfDataId?: string, onProgress?: (event: ProgressEvent) => void, onLoad?: () => void, cfg?: DxfLoaderConfig): Promise<DxfData>;
+    /**
+     * Sets font.
+     * Font is required for Viewer2d to view Chinese, etc.
+     */
+    setFont(font: FontManager): void;
+    /**
+     * Sets decoder path for draco loader.
+     * @param path e.g., "libs/draco/gltf/"
+     */
+    static setDracoDecoderPath(path: string): void;
+    /**
+     * Sets decoder path for draco loader.
+     * @param path e.g., "libs/rhino3dm/"
+     */
+    static setRhino3dmLibraryPath(path: string): void;
+    private getGltfLoader;
+}

package/dist/src/dxfViewer/core/helpers/MeshBvhHelper.d.ts

@@ -0,0 +1,15 @@
+import { BvhParameter } from '../workers';
+import * as THREE from "three";
+/**
+ * Bvh: Bounding volume hierarchy
+ */
+export declare class MeshBvhHelper {
+    private running;
+    private workers;
+    constructor(workerCount?: number);
+    isRunning(): boolean;
+    generate(geometries: THREE.BufferGeometry[], params?: BvhParameter): Promise<void>;
+    dispose(): void;
+    static createMeshBvhSync(objects: THREE.Object3D[], params?: BvhParameter): void;
+    static createMeshBvhAsync(objects: THREE.Object3D[], params?: BvhParameter): Promise<void>;
+}

package/dist/src/dxfViewer/core/helpers/MobileTouchHelperDrawable.d.ts

@@ -0,0 +1,26 @@
+import { Drawable } from '../canvas';
+import { EventInfo } from '../input-manager/InputManager';
+import * as THREE from "three";
+/**
+ * Touch helper for mobile
+ */
+export declare class MobileTouchHelperDrawable extends Drawable {
+    private position;
+    needsFrustumCulled: boolean;
+    renderOrder: number;
+    constructor(position: THREE.Vector2);
+    setPosition(position: THREE.Vector2): void;
+    isPointInPath(p: THREE.Vector3, raycaster?: THREE.Raycaster | undefined): boolean;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawInnerCircle(ctx: CanvasRenderingContext2D): void;
+    drawOuterRing(ctx: CanvasRenderingContext2D): void;
+    drawSnapTriangle(ctx: CanvasRenderingContext2D): void;
+    translate(tx: number, ty: number): void;
+    getTouchPoint(): {
+        x: number;
+        y: number;
+    };
+    isIntersect(e: EventInfo): boolean;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    getClassType(): string;
+}

package/dist/src/dxfViewer/core/helpers/OSnapHelper.d.ts

@@ -0,0 +1,158 @@
+import { CanvasRender, Drawable, DrawableList } from '../canvas';
+import { ILine, OSnapMarkerType } from '../utils';
+import * as THREE from "three";
+export declare class SnapDrawable extends Drawable {
+    static lineColor: string;
+    static readonly FILL_COLOR_NONE = "rgba(0, 0, 0, 0)";
+    static readonly SNAP_LINE_COLOR = "rgba(255, 240, 0, 0.3)";
+    static lineWidth: number;
+    static iconSize: number;
+    needsFrustumCulled: boolean;
+    renderOrder: number;
+    snapType: OSnapMarkerType;
+    private osnapInfo?;
+    private drawSnapFunctions;
+    private snapLineVisible;
+    constructor(type: OSnapMarkerType);
+    setSnapLineVisible(visible: boolean): void;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawDebug(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    drawSnapLine(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     *      p1
+     *      |
+     *      | point (origin)
+     *     / \
+     *   /     \
+     *  p2      p3
+     */
+    drawTripleCorss(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSquare(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawTriangle(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     * Snap marker for circle center.
+     */
+    drawCircleWithCross(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawCross(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     * p4|\
+     *   |  \
+     * p2|____\ p1 (origin)
+     *   |    | \
+     *   |____|___\
+     * P5     p3   P6
+     */
+    drawPerpendicular(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    update(osnapInfo: OSnapInfo): void;
+    getClassType(): string;
+}
+export declare enum OSnapType {
+    None = 0,
+    Vertex = 1,
+    MiddlePoint = 2,
+    Edge = 4,
+    Face = 8,
+    FootOfPerpendicular = 16,
+    Intersection = 32,
+    CircleCenter = 64
+}
+interface OSnapInfo {
+    point: THREE.Vector3;
+    distance: number;
+    type: OSnapType;
+    line?: ILine;
+}
+export declare class OSnapHelper {
+    protected drawableList: DrawableList;
+    protected overlayRender?: CanvasRender;
+    protected markers: Record<number, SnapDrawable>;
+    protected activeOSnapType: OSnapType;
+    protected snapToleranceInWorldCoord: number;
+    protected intersectionLimit: number;
+    /**
+     * OSnapType priority. Lower value has a higher priority.
+     */
+    osnapTypePriorities: Record<OSnapType, number>;
+    protected enabledOSnapTypes: number;
+    constructor(overlayRender: CanvasRender);
+    private initOSnapMarkers;
+    /**
+     * If a specific OSnapType is enabled.
+     */
+    isOSnapTypeEnabled(type: OSnapType): boolean;
+    /**
+     * Enables a specific OSnapType.
+     */
+    setOSnapTypeEnabled(type: OSnapType, enabled: boolean): void;
+    /**
+     * Sets snap tolerance in world coordinate.
+     */
+    setSnapTolerance(toleranceInWorldCoord: number): void;
+    /**
+     * Gets snap tolerance in world coordinate.
+     */
+    getSnapTolerance(): number;
+    setIntersectionLimit(val: number): void;
+    getIntersectionLimit(): number;
+    /**
+     * Gets osnap marker line color.
+     * @returns rgb/rgba number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96].
+     */
+    getMarkerLineColor(): number[];
+    /**
+     * Sets osnap marker line color.
+     * @param color rgb/rgba number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96].
+     */
+    setMarkerLineColor(color: number[]): void;
+    /**
+     * Gets osnap marker line width.
+     */
+    getMarkerLineWidth(): number;
+    /**
+     * Sets osnap marker line width.
+     */
+    setMarkerLineWidth(width: number): void;
+    /**
+     * Gets osnap marker icon size in pixel.
+     */
+    getMarkerIconSize(): number;
+    /**
+     * Sets osnap marker icon size in pixel.
+     */
+    setMarkerIconSize(size: number): void;
+    getMarker(type: OSnapType): SnapDrawable;
+    setAllSnapLinesVisible(visible: boolean): void;
+    deactivate(): void;
+    destroy(): void;
+    /**
+     * Tries to find a proper snap point and display corresponding marker.
+     * @param intersections The raycaster intersections, must have been sorted by distance.
+     * @param is3d If it is a 3d or 2d viewer.
+     * @param lastMouseDownPosition Used in order to to get foot of perpendicular.
+     * @returns Target snap point if any
+     */
+    handleSnap(rayCasterResult: THREE.Intersection[], is3d: boolean, lastMouseDownPosition?: THREE.Vector3): THREE.Vector3 | undefined;
+    /**
+     * Tries to find a proper snap point and display corresponding marker.
+     * @param mousePosition Mouse position in world coordinate.
+     * @param intersections
+     * @param is3d If it is a 3d or 2d viewer.
+     * @param lastMouseDownPosition Used in order to to get foot of perpendicular.
+     * @returns Target snap point if any
+     */
+    protected getSnapPointAndUpdateMarker(mousePosition: THREE.Vector3, intersections: THREE.Intersection[], is3d: boolean, lastMouseDownPosition?: THREE.Vector3): THREE.Vector3 | undefined;
+    activateMarker(type: OSnapType, osnapInfo?: OSnapInfo): void;
+    private getFootOfPerpendicular;
+    private getSnapInfo;
+    private getOsnapInfoListFromMesh;
+    private getOsnapInfoFromSegment;
+    private getOsnapInfoListFromLine;
+    private getOsnapInfoListFromPoint;
+    /**
+     * Used for 3d scene to get outline info by faces.
+     */
+    private getIntersectsIncludeOutline;
+}
+export {};

package/dist/src/dxfViewer/core/helpers/ObjectPixelSizeHelper.d.ts

@@ -0,0 +1,13 @@
+import { default as CameraControls } from '../../core/camera-controls';
+import * as THREE from "three";
+/**
+ * Helper class to adjust object visual size
+ */
+export declare class ObjectPixelSizeHelper {
+    private object;
+    private camera;
+    targetPixelHeight: number;
+    canvasHeight: number;
+    constructor(camera: THREE.Camera, controls: CameraControls, object: THREE.Object3D, targetPixelHeight: number, canvasHeight: number);
+    adjustSize(): void;
+}

package/dist/src/dxfViewer/core/helpers/PickMarkupHelper.d.ts

@@ -0,0 +1,29 @@
+import { Tooltip } from '../../components/tool-tip';
+import { EventInfo } from '../input-manager/InputManager';
+import { BaseViewer } from '../viewers';
+import * as THREE from "three";
+/**
+ * Box select an area in screen coordinate.
+ * @internal
+ */
+export declare class PickMarkupHelper {
+    protected viewer: BaseViewer;
+    private active;
+    protected tooltip?: Tooltip;
+    protected resolve?: (value: THREE.Box2 | PromiseLike<THREE.Box2> | undefined) => void;
+    protected reject?: (reason: any) => void;
+    protected isResolvedOrRejected: boolean;
+    private mouseClicked;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    private get camera();
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    keydown: (e: EventInfo) => void;
+    /**
+     * Starts to pick a markup area.
+     */
+    pick(): Promise<THREE.Box2 | undefined>;
+    destroy(): void;
+}

package/dist/src/dxfViewer/core/helpers/RafHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This class implemented setTimeout and setInterval using RequestAnimationFrame
+ * This code references to
+ * https://github.com/aisriver/myHome3D/blob/master/src/utils/RAF.ts
+ * @internal
+ */
+export declare class RafHelper {
+    readonly TIMEOUT = "timeout";
+    readonly INTERVAL = "interval";
+    private timeoutMap;
+    private intervalMap;
+    private run;
+    private setIdMap;
+    setTimeout(cb: () => void, interval: number): symbol;
+    clearTimeout(timer: symbol): void;
+    setInterval(cb: () => void, interval: number): symbol;
+    clearInterval(timer: symbol): void;
+}

package/dist/src/dxfViewer/core/helpers/ZoomToRectHelper.d.ts

@@ -0,0 +1,24 @@
+import { BaseViewer } from '../viewers';
+import * as THREE from "three";
+/**
+ * Zoom to the selected rectangle area in screen coordinate.
+ * @internal
+ */
+export declare class ZoomToRectHelper {
+    protected viewer: BaseViewer;
+    private boxSelectHelper?;
+    private active;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    get camera(): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+    get raycaster(): THREE.Raycaster;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    /**
+     * Picks and get world position by screen position.
+     */
+    protected pickPositionByScreenPoint(p: THREE.Vector2): THREE.Vector3 | undefined;
+    protected handleZoomToRect(leftTop: THREE.Vector2, rightBottom: THREE.Vector2): void;
+    destroy(): void;
+}

package/dist/src/dxfViewer/core/helpers/index.d.ts

@@ -0,0 +1,11 @@
+export * from './InstantiateHelper';
+export * from './RafHelper';
+export * from './BinaryReader';
+export * from './LoadingHelper';
+export * from './MeshBvhHelper';
+export * from './ObjectPixelSizeHelper';
+export * from './OSnapHelper';
+export * from './PickMarkupHelper';
+export * from './BoxSelectHelper';
+export * from './ZoomToRectHelper';
+export * from './MobileTouchHelperDrawable';

package/dist/src/dxfViewer/core/index.d.ts

@@ -0,0 +1,19 @@
+export * from './patches';
+export * from './canvas';
+export * from './compare';
+export * from './components';
+export * from './controls';
+export * from './dxf';
+export * from './dxf-parser';
+export * from './geometry-offset';
+export * from './helpers';
+export * from './input-manager';
+export * from './font';
+export * from './utils';
+export * from './model';
+export * from './viewers';
+export * from './workers';
+export * from './Configs';
+export * from './Constants';
+export * from './Units';
+export * from './VersionManager';

package/dist/src/dxfViewer/core/indexeddb/BaseTable.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class BaseTable {
+    db?: IDBDatabase;
+    isCreatingTable: boolean;
+    constructor();
+    /**
+     * Derived class have to override this method and return a table name!
+     */
+    tableName(): string;
+    /**
+     * Adds a record to a table
+     */
+    add(record: any, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Saves a record
+     */
+    save(record: any, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Deletes a record
+     */
+    delete(key: string, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Updates a record
+     */
+    update(): void;
+    /**
+     * Queries records in a table
+     * @param cursorHandler callback to handle records one by one
+     */
+    query(cursorHandler?: any, errorCallback?: any): void;
+    queryByIndex(indexName: any, indexValue: any, successCallback?: any, errorCallback?: any): void;
+    queryAll(successCallback?: any, errorCallback?: any): void;
+    clearAll(successCallback?: any, errorCallback?: any): void;
+}

package/dist/src/dxfViewer/core/indexeddb/DxfDataTable.d.ts

@@ -0,0 +1,22 @@
+import { BaseTable } from './BaseTable';
+export interface DxfDataTableRecord {
+    dxfDataId: string;
+    dxf: object;
+}
+/**
+ * DxfDataTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class DxfDataTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): DxfDataTable;
+    /**
+     * Queires a dxf data
+     * @param dxfDataId should be a unique id to identify different dxf files
+     */
+    query(dxfDataId: string, successCallback?: any, errorCallback?: any): void;
+}

package/dist/src/dxfViewer/core/indexeddb/FontDataTable.d.ts

@@ -0,0 +1,32 @@
+import { BaseTable } from './BaseTable';
+import { Orientation, ShxFontType } from '../font/shx';
+export interface FontDataTableRecord {
+    fontType?: ShxFontType;
+    order: number;
+    data: Record<number, Uint8Array>;
+    info: string;
+    orientation: Orientation;
+    baseUp: number;
+    baseDown: number;
+    fileName: string;
+    fileHeader: string;
+    fileVersion: string;
+}
+/**
+ * DxfDataTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class FontDataTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): FontDataTable;
+    /**
+     * Queires a dxf data
+     * @param fileId should be a unique id to identify different dxf files
+     */
+    query(fileName: string): Promise<FontDataTableRecord>;
+    queryAll(): Promise<FontDataTableRecord[]>;
+}

package/dist/src/dxfViewer/core/indexeddb/IndexedDbManager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Definition of an indexeddb table.
+ */
+export interface IndexedDbTable {
+    name: string;
+    options?: IDBObjectStoreParameters;
+    indexArray?: {
+        name: string;
+        fields: string[];
+        unique: boolean;
+    }[];
+}
+/**
+ * IndexedDb manager.
+ */
+export declare class IndexedDbManager {
+    private readonly DATABASE_NAME;
+    /**
+     * Default tables.
+     */
+    private readonly DEFAULT_TABLES;
+    private db?;
+    private tables;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): IndexedDbManager;
+    constructor();
+    /**
+     * Sets indexeddb tables. This should be called before getDatabase() is called.
+     */
+    setTables(tables: IndexedDbTable[]): void;
+    /**
+     * Gets indexeddb tables.
+     */
+    getTables(): IndexedDbTable[];
+    /**
+     * Makes sure to open database, and the table is already created before add/put/delete, etc.
+     */
+    getDatabase(): Promise<IDBDatabase>;
+    /**
+     * Closes the database.
+     */
+    closeDatabase(): void;
+    private deleteDataBase;
+    private getDB;
+    private getUpgradedDB;
+    private createTable;
+}

package/dist/src/dxfViewer/core/indexeddb/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BaseTable';
+export * from './IndexedDbManager';
+export * from './DxfDataTable';
+export * from './FontDataTable';

package/dist/src/dxfViewer/core/input-manager/InputManager.d.ts

@@ -0,0 +1,146 @@
+import { Event } from '../../core/utils';
+type NativeEvent = UIEvent | MouseEvent | PointerEvent | WheelEvent | KeyboardEvent;
+export interface IUIEvent {
+    readonly type: string;
+    readonly target: any;
+    readonly preventDefault: () => void;
+}
+export interface IMouseEvent extends IUIEvent {
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly button: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly pageX: number;
+    readonly pageY: number;
+    readonly x: number;
+    readonly y: number;
+    readonly timestamp: number;
+}
+export interface IPointerEvent extends IMouseEvent {
+    readonly pointerId: number;
+    readonly pointerType: string;
+}
+export interface IWheelEvent extends IMouseEvent {
+    readonly deltaMode: number;
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly deltaZ: number;
+}
+export interface IKeyboardEvent extends IUIEvent {
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly key: string;
+    readonly code: string;
+}
+export declare enum MouseButton {
+    /** Left Click or Touch */
+    Left = 0,
+    /** Middle Click */
+    Middle = 1,
+    /** Right Click */
+    Right = 2,
+    /** Browser Back */
+    Back = 3,
+    /** Browser Forward */
+    Forward = 4
+}
+type MouseButtonType = MouseButton;
+/**
+ * Event info.
+ */
+export interface EventInfo {
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+    clientX: number;
+    clientY: number;
+    deltaMode: number;
+    deltaX: number;
+    deltaY: number;
+    movementX: number;
+    movementY: number;
+    code?: string;
+    pointerId: number;
+    pointers?: EventInfo[];
+    button?: MouseButtonType;
+    buttons: MouseButtonType;
+    pointerType: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    timestamp: number;
+    originalEvent?: NativeEvent;
+}
+/**
+ * Input events.
+ */
+export type InputEvents = {
+    pointerdown: EventInfo;
+    pointermove: EventInfo;
+    pointerup: EventInfo;
+    pointercancel: EventInfo;
+    pointerenter: EventInfo;
+    pointerleave: EventInfo;
+    wheel: EventInfo;
+    click: EventInfo;
+    dblclick: EventInfo;
+    contextmenu: EventInfo;
+    mousedown: EventInfo;
+    mousemove: EventInfo;
+    mouseup: EventInfo;
+    touchstart: EventInfo;
+    touchmove: EventInfo;
+    touchend: EventInfo;
+    keydown: EventInfo;
+    keyup: EventInfo;
+    resize: EventInfo;
+};
+export declare class InputManager extends Event<InputEvents> {
+    private element;
+    private enabled;
+    private keyboardEnabled;
+    protected mouseDownPositionX: number;
+    protected mouseDownPositionY: number;
+    protected lastLeftPointerUpTime: number;
+    private pointers;
+    private handleClick;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private handleMouseWheel;
+    private handleContextMenu;
+    private handlePointerEnter;
+    private handlePointerLeave;
+    private handleResize;
+    private handleKeydown;
+    private handleKeyup;
+    style: {};
+    constructor(element: HTMLElement);
+    getEnabled(): boolean;
+    setEnabled(enable: boolean): void;
+    getkKeyboardEnabled(): boolean;
+    setkKeyboardEnabled(enable: boolean): void;
+    setCursor(cursorStyle: string): void;
+    bindEvents(): void;
+    unBindEvents(): void;
+    private getBaseEvent;
+    private stop;
+    private updatePointers;
+    private removePointers;
+    getBoundingClientRect(): DOMRect;
+    /**
+     * Checks if user clicked on last position, this is used to detect a dblclick event.
+     */
+    private isCloseToLastPosition;
+    /**
+     * Checks if a dblclick event happen.
+     */
+    private isDoubleClick;
+}
+export {};

package/dist/src/dxfViewer/core/input-manager/index.d.ts

@@ -0,0 +1,2 @@
+export { InputManager } from './InputManager';
+export type { InputEvents as InputEvent } from './InputManager';