@maqiuyao/dxf-viewer 0.1.0

package/dist/src/dxfViewer/core/utils/CommonUtils.d.ts

@@ -0,0 +1,129 @@
+import { IconClass } from '../Configs';
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export declare class CommonUtils {
+    /**
+     * Checks full screen mode
+     */
+    static isFullScreen(): boolean;
+    /**
+     * Enters full screen mode
+     */
+    static fullScreen(element?: HTMLElement): void;
+    /**
+     * Exits full screen mode
+     */
+    static exitFullscreen(): void;
+    /**
+     * Join strings
+     * @param args
+     * @returns
+     */
+    static joinStrings(...args: string[]): string;
+    /**
+     * Converts a number to a string with proper fraction digits
+     */
+    static numberToString(num: number): string;
+    /**
+     * Converts a byte number to proper units(Kilobyte, Megabyte, Gigabyte, etc.)
+     * @param num
+     */
+    static byteCountToString(num: number): string;
+    static hexToBase64(hexstring: string): string;
+    /**
+     * Converts vector to a string with proper fraction digits
+     */
+    static vectorToString(vec: THREE.Vector2 | THREE.Vector3 | number[]): string;
+    /**
+     * Converts number array to THREE.Vector2
+     */
+    static arrayToVector2(arr: number[] | THREE.Vector2 | undefined): THREE.Vector2 | undefined;
+    /**
+     * Converts number array to THREE.Vector3
+     * If length of arr is 2, will assign z value to 0
+     */
+    static arrayToVector3(arr: number[] | THREE.Vector3 | undefined): THREE.Vector3 | undefined;
+    /**
+     * Converts number array to THREE.Euler
+     */
+    static arrayToEuler(arr: number[] | THREE.Euler | undefined): THREE.Euler | undefined;
+    /**
+     * Converts number array to THREE.Vector3
+     */
+    static arrayOrObjectToVector3(arrOrObj: number[] | THREE.Vector2 | THREE.Vector3 | undefined): THREE.Vector3 | undefined;
+    static isVectorValid(vec: THREE.Vector2 | THREE.Vector3): boolean;
+    static isBoxValid(box: THREE.Box2 | THREE.Box3): boolean;
+    static isMatrixValid(matrix: THREE.Matrix4): boolean;
+    static guid(): string;
+    /**
+     * Expands given box by a scale factor
+     */
+    static expandBoxByScale(box: THREE.Box3, scale: number): void;
+    /**
+     * Expands given box by a min size
+     */
+    static expandBoxByMinSize(box: THREE.Box3, minSize: number): void;
+    /**
+     * Generate random integers in the range [min, max]
+     */
+    static generateRandomInt(min: number, max: number): number;
+    /**
+     * Round to N decimal places
+     */
+    static roundNumber(value: number, n: number): number;
+    static convertDecimalToHex(decimal: number | string): string;
+    static canvasToImage(canvas: HTMLCanvasElement): Promise<HTMLImageElement>;
+    /**
+     * Takes screenshot to given rendering context and return base64 string in png/jpeg format.
+     * @param bbox If valid, takes screenshot of a sub image with given bounding box in screen coordinate.
+     */
+    static renderingContextToImage(context: CanvasRenderingContext2D, bbox?: THREE.Box2, type?: string, quality?: number): string;
+    /**
+     * Prints memory usage
+     */
+    static printMemory(title: string): void;
+    static printGpuInfo(webgl: WebGLRenderingContext): void;
+    static getExtension(url: string): string;
+    static isBinaryFile(url: string): boolean;
+    static isGzip(data: Uint8Array): boolean;
+    /**
+     * Sleep a while
+     */
+    static sleep(ms: number): Promise<void>;
+    private static twinklingObjectIds;
+    /**
+     * Twinkle the object several times
+     */
+    static twinkle(obj: THREE.Object3D, ms?: number): Promise<void>;
+    /**
+     * Gets a function to update progress.
+     * @param onProgress onProgress callback.
+     */
+    static getUpdateProgressFunc(onProgress?: (e: ProgressEvent) => void): (progress: number) => void;
+    /**
+     * Gets an async function to update progress.
+     * The reason to use async function is, in order to give UI thread chance to update the progress!
+     * @param onProgress onProgress callback.
+     */
+    static getUpdateProgressFuncAsync(onProgress?: (e: ProgressEvent) => void): (progress: number) => Promise<void>;
+    /**
+     * Gets an async function to update progress for a for/while loop.
+     * @param total Total number of a for/while loop.
+     * @param onProgress onProgress callback.
+     */
+    static getUpdateProgressFuncForLoop(total: number, onProgress?: (e: ProgressEvent) => void): (i: number) => Promise<void>;
+    /**
+     * Gets a function to update sub progress, which has a progress range limitation according to its parent progress.
+     * @param min Min range number between 0-100
+     * @param max Max range number between 0-100
+     * @param onProgress onProgress callback.
+     * @returns
+     */
+    static getUpdateSubProgressFunc(min: number, max: number, onProgress?: (e: ProgressEvent) => void): (e: ProgressEvent) => void;
+}
+/**
+ * @internal
+ */
+export declare const setIcon: (classList: DOMTokenList, iconClass: IconClass, active: boolean) => void;

package/dist/src/dxfViewer/core/utils/CoordinateUtils.d.ts

@@ -0,0 +1,81 @@
+import { EventInfo, IPointerEvent } from '../../core/input-manager/InputManager';
+import * as THREE from "three";
+/**
+ * @internal
+ * Some concepts:
+ *
+ * 1. Screen coordinate:
+ * (0, 0)
+ * ----------------------> x
+ * |                   |
+ * |                   |
+ * |                   |
+ * |                   |
+ * |___________________|
+ * y                   (1024, 768) e.g.
+ *
+ * 2. Normalized screen coordinate:
+ * (0, 0)
+ * ----------------------> x
+ * |                   |
+ * |                   |
+ * |                   |
+ * |                   |
+ * |___________________|
+ * y                   (1, 1)
+ *
+ * 3. NDC: Normalized Device Coordinates
+ *             ^ y       (1, 1)
+ *             |
+ * (-1, 0)     |(0, 0)   (1, 0)
+ * ----------------------> x
+ *             |
+ *             |
+ * (-1, -1)
+ *
+ * 4. World Coordinates
+ *      ^ y
+ *      |
+ *      |     / x
+ *      |   /
+ *      | /
+ * ---------------> z
+ *   (0, 0)
+ */
+export declare class CoordinateUtils {
+    /**
+     * Gets screen coordinate by pointer event.
+     */
+    static getScreenCoordinateByEvent(event: IPointerEvent | EventInfo | MouseEvent | PointerEvent, container: HTMLElement): THREE.Vector2;
+    /**
+     * Gets screen coordinate by touch event.
+     */
+    static getScreenCoordinateByTouchEvent(event: TouchEvent, container: HTMLElement): THREE.Vector2;
+    /**
+     * Converts world to screen coordinate.
+     */
+    static world2Screen(vector: THREE.Vector3, camera: THREE.Camera, container: HTMLElement): THREE.Vector2;
+    /**
+     * Converts a bbox under world coordinate to screen coordinate.
+     */
+    static worldBBox2Screen(bbox: THREE.Box3, camera: THREE.Camera, container: HTMLElement): THREE.Box2;
+    /**
+     * Converts screen to world coordinate.
+     */
+    static screen2World(vector: THREE.Vector2, camera: THREE.Camera, container: HTMLElement): THREE.Vector3;
+    /**
+     * Converts screen point to NDC coordinate.
+     * @description {en} Normalized screen coordinate: bottom-left(-1, -1), top-right(1, 1).
+     * @description {zh} 标准化屏幕坐标：左下角(-1, -1), 右上角(1, 1)。
+     * @description {en} World coordinate to normalized screen coordinate(0-1).
+     * @description {zh} 世界坐标转标准化屏幕坐标（0-1）。
+     */
+    static screen2Ndc(vector: THREE.Vector2, camera: THREE.Camera, container: HTMLElement): THREE.Vector2;
+    /**
+     * @description {en} Normalized screen coordinate: top-left(0, 0), bottom-right(1, 1).
+     * @description {zh} 标准化屏幕坐标：左上角(0, 0), 右下角(1, 1)。
+     * @description {en} World coordinate to normalized screen coordinate(0-1).
+     * @description {zh} 世界坐标转标准化屏幕坐标（0-1）。
+     */
+    static world2NormalizedScreen(worldCoord: THREE.Vector2 | THREE.Vector3, camera: THREE.Camera, container: HTMLElement): THREE.Vector2;
+}

package/dist/src/dxfViewer/core/utils/DecimalPrecisionUtils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+export declare const DecimalPrecisionRange: {
+    "Precision from file": number;
+};
+/**
+ * @internal
+ */
+export declare const showPrecisionValue: (value: number, precistionType: number) => string;

package/dist/src/dxfViewer/core/utils/DeviceUtils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Device util class
+ * @internal
+ */
+export declare class DeviceUtils {
+    /**
+     * Checks if it is opened in touch screen device, like iphone, ipad, etc.
+     */
+    static isTouchScreenDevice(): boolean;
+    static printDeviceInfo(): void;
+    static creatReactNativeCanvas(context: WebGLRenderingContext | WebGL2RenderingContext | CanvasRenderingContext2D): HTMLCanvasElement;
+    static isMobile: boolean;
+    static isBrowser: boolean;
+    static isNode: boolean;
+}

package/dist/src/dxfViewer/core/utils/EdgeUtils.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+export declare class EdgeUtils {
+    /**
+     * reference to buildEdgeIndices from xeokit
+     */
+    static buildEdge(positions: Float32Array, indices: Uint32Array | Uint16Array | Uint8Array, edgeThreshold?: number): Uint32Array | Uint16Array;
+    /**
+     * Calculate the barycentric coordinates of each vertex of the geometry
+     * TODO: Temporarily do not handle the following cases.
+     * - When there is no solution, it is necessary to expand the vertices
+     * The algorithm also has performance issues!
+     */
+    static buildBarycentrics(geometry: THREE.BufferGeometry): boolean;
+}

package/dist/src/dxfViewer/core/utils/Event.d.ts

@@ -0,0 +1,34 @@
+export type Handler<T = any> = (val: T) => void;
+/**
+ * @internal
+ */
+export declare class Event<Events extends Record<string, any> = {}> {
+    private map;
+    constructor();
+    /**
+     * @internal
+     */
+    addEventListener<EventName extends keyof Events>(name: EventName, handler: Handler<Events[EventName]>): void;
+    /**
+     * @internal
+     */
+    dispatchEvent<EventName extends keyof Events>(name: EventName, value?: Events[EventName]): void;
+    /**
+     * Checks if there is a listener
+     * @internal
+     */
+    hasEventListener<EventName extends keyof Events>(name: EventName): boolean;
+    /**
+     * Removes all event listeners
+     * @internal
+     */
+    removeEventListener(): void;
+    /**
+     * @internal
+     */
+    removeEventListener<EventName extends keyof Events>(name: EventName): void;
+    /**
+     * @internal
+     */
+    removeEventListener<EventName extends keyof Events>(name: EventName, handler: Handler<Events[EventName]>): void;
+}

package/dist/src/dxfViewer/core/utils/ExportUtils.d.ts

@@ -0,0 +1,61 @@
+import { DRACOExporterOptions } from 'three/examples/jsm/exporters/DRACOExporter';
+import { GLTFExporterOptions } from 'three/examples/jsm/exporters/GLTFExporter';
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export declare class ExportUtils {
+    static EXTENSION_GLTF: string;
+    static EXTENSION_GLB: string;
+    static EXTENSION_OBJ: string;
+    static EXTENSION_DRACO: string;
+    static EXTENSION_JSON: string;
+    static EXTENSION_STL: string;
+    private static downloadLink;
+    /**
+     * Exports given object to gltf file
+     */
+    static exportToGltf(input: THREE.Object3D, filename: string): void;
+    /**
+     * Exports given object to glb file
+     */
+    static exportToGlb(input: THREE.Object3D, filename: string): void;
+    /**
+     * Exports given object to gltf/glb file
+     * @param input given object
+     * @param filename filename without path, nor extension
+     * @param options
+     */
+    static exportToGltfOrGlb(input: THREE.Object3D, filename: string, options?: GLTFExporterOptions): void;
+    /**
+     * Exports given object to obj file
+     */
+    static exportToObj(input: THREE.Object3D, filename: string): void;
+    /**
+     * Exports given object to draco(drc) file
+     */
+    static exportToDraco(input: THREE.Mesh, filename: string, options?: DRACOExporterOptions): void;
+    /**
+     * Exports given object to stl file
+     */
+    static exportToStl(input: THREE.Object3D, filename: string, binary?: boolean): void;
+    /**
+     * Exports to threejs json
+     * @param input
+     * @param filename
+     */
+    static exportToThreeJsJson(input: THREE.Object3D, filename: string): void;
+    /**
+     * Saves blob as file
+     */
+    static save(blob: Blob, filename: string): void;
+    static saveArrayBuffer(buffer: ArrayBuffer, filename: string): void;
+    static saveJson(json: object, filename: string): void;
+    static saveJsonString(jsonString: string, filename: string): void;
+    static saveString(str: string, filename: string): void;
+    static saveDataView(dataView: DataView, filename: string): void;
+    /**
+     * Adds extention if missing
+     */
+    private static addExtention;
+}

package/dist/src/dxfViewer/core/utils/FpsUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @internal
+ */
+export declare class FpsUtils {
+    private prevTime;
+    private beginTime;
+    private frames;
+    fps: number;
+    constructor();
+    begin(): void;
+    end(): number;
+    update(): void;
+}

package/dist/src/dxfViewer/core/utils/GeometryUtils.d.ts

@@ -0,0 +1,78 @@
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export interface ILine {
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+}
+/**
+ * GeometryUtils class
+ * @internal
+ */
+export declare class GeometryUtils {
+    /**
+     * Compares two materials
+     */
+    static geometriesEqual(g1: THREE.BufferGeometry, g2: THREE.BufferGeometry): boolean;
+    /**
+     * Checks if two types equal each other.
+     * This method requires type T defined 'equals' method.
+     */
+    private static equal;
+    private static attributesEqual;
+    private static bufferAttributesEqual;
+    /**
+     * Converts InterleavedBufferAttribute to BufferAttribute, because mergeGeometries doesn't support InterleavedBufferAttribute.
+     * If it is supported by Three.js one day, we should remove this method.
+     */
+    static tryConvertInterleavedBufferAttributes(geometry: THREE.BufferGeometry): void;
+    /**
+     * Determines if the 2d point is inside the polygon
+     */
+    static isPointInPolygon(point: THREE.Vector2, polygon: THREE.Vector2[], includeOnSide?: boolean): boolean;
+    static caculateGeometryCenter(geometry: THREE.BufferGeometry): THREE.Vector3 | null;
+    static isConvex(polygon: THREE.Vector2[]): boolean;
+    static areLineSegmentsIntersecting(line1: ILine, line2: ILine): boolean;
+    /**
+     * Tries to get intersection point of two line segments.
+     * Returns undefined in case two line segments don't intersect with each other.
+     */
+    static getLineSegmentsIntersectingPoint(line1: ILine, line2: ILine): THREE.Vector3 | null | undefined;
+    static isPointOnLineSegment(point: THREE.Vector3, line: ILine, epsilon?: number): boolean;
+    static isPointOnLineSegments(point: THREE.Vector3, lines: THREE.Vector3[], epsilon?: number): boolean;
+    /**
+     * Checks if we should rebase points in case their values are big, and do rebase if necessary
+     */
+    static checkAndRebasePositionsOnRTC(positions: THREE.Vector3[] | THREE.Vector2[], offset: THREE.Vector3): boolean;
+    /**
+     * Checks if we should rebase a point in case its value is too large
+     */
+    static shouldRebasePositionOnRTC(vector: THREE.Vector3 | THREE.Vector2): boolean;
+    /**
+     * Calculates surface area
+     */
+    static calculateSurfaceArea(geometry: THREE.BufferGeometry): number;
+    /**
+     * Converts indexes of type line_strip to line
+     * for merge
+     */
+    static convertLineStripToLine(geometry: THREE.BufferGeometry, bLoop?: boolean): void;
+    /**
+     * Convert an indexed geometry to a non-indexed geometry. Can be used for dashed line style.
+     */
+    static convertGeometryWithIndexedToNonIndexed(geometry: THREE.BufferGeometry): THREE.BufferGeometry;
+    static createGeometryAttributeByIndex(attribute: THREE.BufferAttribute, indexBuffer: THREE.BufferAttribute): THREE.BufferAttribute;
+    /**
+     * Gets start/end point of a line segment by given index
+     */
+    static getLineEndPointsByIndex(line: THREE.Line, index: number): THREE.Vector3[];
+    static arePolygonsIntersect(polygon1: THREE.Vector2[], polygon2: THREE.Vector2[]): boolean;
+    static getLineLineIntersectionPoint(a: THREE.Vector2, b: THREE.Vector2, c: THREE.Vector2, d: THREE.Vector2, epsilon?: number): THREE.Vector2 | undefined;
+    static getOffsetPoint(a: THREE.Vector2, b: THREE.Vector2, offset: number): THREE.Vector2;
+    static convertSimpleWidthLineToMeshGeometry(points: THREE.Vector2[], width: number): THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined;
+    static convertWidthLineToMeshGeometry(points: THREE.Vector2[], width: number): THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined;
+    static releaseGeometryManually(geometry: THREE.BufferGeometry): void;
+    static getAdjacentNonRepeatPoints(points: THREE.Vector3[], epsilon?: number): THREE.Vector3[];
+    static mergeBBoxes(bboxes: THREE.Box3[]): THREE.Box3[];
+}

package/dist/src/dxfViewer/core/utils/Locale.d.ts

@@ -0,0 +1,22 @@
+import { default as i18next } from 'i18next';
+export declare const en: {
+    ProgressBar: {
+        Loading: string;
+        Comparing: string;
+    };
+    Tooltip: {
+        boxSelect: string;
+        pickMarkup: string;
+    };
+};
+export declare const cn: {
+    ProgressBar: {
+        Loading: string;
+        Comparing: string;
+    };
+    Tooltip: {
+        boxSelect: string;
+        pickMarkup: string;
+    };
+};
+export declare const i18n: ReturnType<typeof i18next.createInstance>;

package/dist/src/dxfViewer/core/utils/LogUtils.d.ts

@@ -0,0 +1,7 @@
+import * as loglevel from "loglevel";
+export declare const log: loglevel.RootLogger;
+/**
+ * Sets log level.
+ * Note that, we limit user to set only some of the levels.
+ */
+export declare const setLogLevel: (level: string) => void;

package/dist/src/dxfViewer/core/utils/MaterialUtils.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from "three";
+/**
+ * MaterialUtils class
+ * @internal
+ */
+export declare class MaterialUtils {
+    /**
+     * Compares two materials
+     */
+    static materialEquals(m1: THREE.Material, m2: THREE.Material): boolean;
+    /**
+     * Compares two materials, which could be material or material array
+     */
+    static materialsEquals(m1: THREE.Material | THREE.Material[], m2: THREE.Material | THREE.Material[]): boolean;
+    /**
+     * Compares two colors
+     */
+    static colorEquals(c1: THREE.Color, c2: THREE.Color): boolean;
+    static clonedHighlightMaterials(mesh: THREE.Mesh | THREE.Line | THREE.Points, options?: {
+        depthTest?: boolean;
+        highlightColor?: THREE.Color;
+        opacity?: number;
+    }): THREE.Material | THREE.Material[] | undefined;
+    static clonedHighlightMaterial(material: THREE.Material, options?: {
+        depthTest?: boolean;
+        highlightColor?: THREE.Color;
+        opacity?: number;
+    }): THREE.Material;
+    /**
+     * Clone given material(s)
+     */
+    static cloneMaterial(material: THREE.Material | THREE.Material[]): THREE.Material | THREE.Material[];
+    static getMaterialColor(material: THREE.Material | THREE.Material[]): THREE.Color;
+    static setMaterialColor(material: THREE.Material | THREE.Material[], color: THREE.Color): void;
+    static setMaterialOpacity(material: THREE.Material | THREE.Material[], opacity: number): void;
+    /**
+     * Clone object's materials
+     */
+    static cloneMaterials(object: THREE.Object3D): void;
+}

package/dist/src/dxfViewer/core/utils/MathUtils.d.ts

@@ -0,0 +1,41 @@
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export declare class MathUtils {
+    static roundNumber(value: number, n: number): number;
+    static floorNumber(value: number, n: number): number;
+    static areNumbersEqual(a: number, b: number, epsilon?: number): boolean;
+    static areVector2sEqual(a: THREE.Vector2, b: THREE.Vector2, epsilon?: number): boolean;
+    static areVector3sEqual(a: THREE.Vector3, b: THREE.Vector3, epsilon?: number): boolean;
+    static areNumbersClose(a: number, b: number, ref_tol?: number, abs_tol?: number): boolean;
+    static areVector2sClose(point1: THREE.Vector2, point2: THREE.Vector2, ref_tol?: number, abs_tol?: number): boolean;
+    static areVectorsClose(point1: THREE.Vector3, point2: THREE.Vector3, ref_tol?: number, abs_tol?: number): boolean;
+    static getArcAngleSpanInRadian(startAngle: number, endAngle: number): number;
+    static getIntegerPartLength(num: number): number;
+    static getRelativeEps(num: number, epsilon?: number): number;
+    static getVector2RelativeEps(vec: THREE.Vector2, epsilon?: number): number;
+    static getControlPointByTwoPoints(p1: THREE.Vector2, p2: THREE.Vector2): THREE.Vector2;
+    static convertPointFromUEToGltf(point: THREE.Vector3): THREE.Vector3;
+    static convertPointFromGltfToUE(point: THREE.Vector3): THREE.Vector3;
+    static convertPointFromUEToRevit(point: THREE.Vector3): THREE.Vector3;
+    static convertPointFromRevitToUE(point: THREE.Vector3): THREE.Vector3;
+    static getBox(point1: THREE.Vector3, point2: THREE.Vector3): number[];
+    static getCenter(box: THREE.Box3): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static convertBoxFromGltfToUE(box: THREE.Box3): number[];
+    static convertBoxFromUEToGltf(box: THREE.Box3): number[];
+    static convertBoxFromRevitToUE(box: THREE.Box3): number[];
+    static convertBoxFromUEToRevit(box: THREE.Box3): number[];
+    static clamp(value: number, min: number, max: number): number;
+    static getLookAtMatrix(eye: THREE.Vector3, target: THREE.Vector3, up: THREE.Vector3): number[];
+    static getLocationFromMatrix(matrix: THREE.Matrix4): THREE.Vector3;
+    static toDegrees(radians: number): number;
+    static toRadians(degrees: number): number;
+    static signNotZero(v: number): 1 | -1;
+    static fromSnorm(value: number, maxRange: number): number;
+    static OctDecode(vec2: THREE.Vector2, vec3: THREE.Vector3, maxRange: number): void;
+}

package/dist/src/dxfViewer/core/utils/MergeUtils.d.ts

@@ -0,0 +1,120 @@
+import * as THREE from "three";
+/**
+ * Used for merged mesh
+ * @internal
+ */
+export interface Batch {
+    batchId: number;
+    name?: string;
+    id?: string;
+    positionStart: number;
+    positionCount: number;
+    indexStart: number;
+    indexCount: number;
+    boundingSphere?: THREE.Sphere;
+    userData?: object;
+    parentUserData?: object;
+}
+/**
+ * MergeHelper class is used to merge child objects for a given object
+ * @internal
+ */
+export declare class MergeUtils {
+    static MergeInfo: {
+        removedObjects: number;
+        mergedMeshes: number;
+        mergedLines: number;
+        mergedPoints: number;
+        mergedUnknownTypeObjects: number;
+        elapsedTime: number;
+    };
+    static resetMergeInfo(): void;
+    /**
+     * Merges child objects for given object.
+     * it tries to merge objects in the same level and with the same parent;
+     * @param saveBatchInfo caller can set saveBatchInfo to true, so that s/he can
+     * get the object's original data before merged.
+     * While this takes some extra space, so, we'd like to add a flag here.
+     */
+    static merge(object: THREE.Object3D, saveBatchInfo?: boolean): void;
+    /**
+     * Merges child objects of given object.
+     * If objects' material are the same, they can be merged.
+     */
+    private static mergeInner;
+    /**
+     * @param object parent object or THREE.Object3D[]
+     * @param i index of for object.children[]
+     * @param k index of for object.children[]
+     * @param dict to store merge-able object
+     * @param nonMergeIndexes used in order to improve performance
+     */
+    private static tryHandleMergeableObjects;
+    /**
+     * TODO: Filters XC etc.
+     * there are cases where entities with xc and without xc are merged together
+     */
+    /**
+     * Merges all objects of given object, just leaf children.
+     * If objects' material are the same, they can be merged.
+     * Better to call mergeInner first then deepMerge for a better performance.
+     * return { "added": THREE.Object3D[], "removed": THREE.Object3D[] }
+     */
+    static deepMerge(objects: THREE.Object3D[], levelObject?: THREE.Object3D | undefined, bRemovedAndAddedAfterMerge?: boolean, bRemoveEmptyObjectsAfterMerge?: boolean, saveBatchInfo?: boolean): {
+        added: THREE.Object3D[];
+        removed: THREE.Object3D[];
+    };
+    /**
+     * since we'll move geometry to another merged mesh under a group, below is the structure:
+        - root object
+          - merged objects group
+            - merged object 1
+     * need to consider a geomery's matrix for each level of ancestor
+     */
+    private static applyMatrix;
+    /**
+     * Merges geometries for lines
+     */
+    static mergeLineGeometries(geometries: THREE.BufferGeometry[], saveBatchInfo: boolean, isDashedMaterial: boolean, batches?: Batch[]): THREE.BufferGeometry | undefined;
+    private static mergeBufferGeometriesWithLinesToLineSegments;
+    private static mergeBufferAttributesWithLinesToLineSegments;
+    /**
+     * Removes a number from array
+     */
+    private static removeFromArray;
+    /**
+     * Removes object from objects
+     */
+    static removeObjectFromArray(arr: THREE.Object3D[], toBeDeleted: THREE.Object3D): void;
+    /**
+     * Checks if two geometries are mergable.
+     * It requires they have the same type and the same attributes.
+     */
+    static areGeometriesMergeable(g1: THREE.BufferGeometry, g2: THREE.BufferGeometry): boolean;
+    /**
+     * Checks if two objects are mergable.
+     * It requires
+     * - They are with the same masks.
+     * - Their userData.layerName must be the same if there is. This is useful for Dxf.
+     * - They have the same type or the same draw type( Mesh or Line or Point).
+     */
+    static areObjectsMergeable(o1: THREE.Object3D, o2: THREE.Object3D): any;
+    /**
+     * Checks if it is a merged object
+     */
+    static isMergedMesh(mesh: THREE.Mesh): boolean;
+    static isFaceIndexInBatch(geometry: THREE.BufferGeometry, batch: Batch, faceIndex: number): boolean;
+    static getBatchByFaceIndex(mesh: THREE.Mesh, faceIndex: number): Batch | undefined;
+    static getBatchByLineIndex(line: THREE.Line, index: number): Batch | undefined;
+    /**
+     * Gets batchId by faceIndex for a merged mesh
+     */
+    static getBatchIdByFaceIndex(mesh: THREE.Mesh, faceIndex: number): number;
+    static getBatchByBatchId(mesh: THREE.Mesh, batchId: number): Batch | undefined;
+    /**
+     * Clones corresponding geometry for given batch.
+     * To do this, we'll clone the geometry so the matrix, material, normal, uv, etc.
+     * will be correct, and we'll remove extra index and position.
+     */
+    static cloneGeometryForBatch(mesh: THREE.Mesh, batch: Batch): THREE.BufferGeometry | undefined;
+}