@x-viewer/core 0.9.0

package/dist/types/core/compare/DxfCompareMarkupManager.d.ts

@@ -0,0 +1,11 @@
+import type { Viewer2d } from "../viewers";
+import { DxfChange } from "../../core/dxf";
+import { Event } from "../../core/utils";
+export declare class DxfCompareMarkupManager extends Event {
+    private viewer;
+    private overlayRender?;
+    private drawableList;
+    constructor(viewer: Viewer2d);
+    drawCompareDrawable(changes: Record<string, DxfChange>): void;
+    setCompareDrawableVisible(visilbe: boolean): void;
+}

package/dist/types/core/compare/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./CompareDrawable";
+export * from "./DxfCompareMarkupManager";
+export * from "./DxfCompareHelper";
+export * from "./BaseDxfCompareHelper";

package/dist/types/core/components/Container.d.ts

@@ -0,0 +1,38 @@
+export declare class Container {
+    width: number;
+    height: number;
+    /**
+     * The root container which will be created to under the container user passed in,
+     * it typically contains a viewer container and a widget container.
+     */
+    container: HTMLDivElement;
+    /**
+     * The viewer container, which contains
+     * - canvas of three.js
+     * - canvas for overlay renderer
+     * - css2d object renderer
+     */
+    viewerContainer?: HTMLDivElement;
+    /**
+     * The vidget container, may contain:
+     * - Axis gizmo
+     * - Progress bar
+     * - Toolbar ui
+     * - Context menu
+     */
+    widgetContainer?: HTMLDivElement;
+    constructor(containerId: string);
+    /**
+     * Creates a viewerContainer under the container that user passed in.
+     * There are some benefits to create a new one. e.g., its style won't affect
+     * the container div user passed in.
+     */
+    private initViewerContainer;
+    /**
+     *
+     * @description Create a div for ui widget, if widget need position, just relative container, maybe remove later.
+     */
+    private initWidgetContainer;
+    get needResize(): boolean;
+    destroy(): void;
+}

package/dist/types/core/components/ProgressBar.d.ts

@@ -0,0 +1,31 @@
+import type { Container } from "./Container";
+export interface ProgressItem {
+    div: HTMLDivElement;
+    onProgress?: (event: ProgressEvent) => void;
+}
+/**
+ * Build in ProgressBar, used to indicate current progress.
+ */
+export declare class ProgressBar {
+    private element;
+    private progressItems;
+    private replaceReg;
+    constructor(container: Container);
+    addProgressItem(id: string, message?: string, onProgress?: (event: ProgressEvent) => void): void;
+    removeProgressItem(id: string): void;
+    /**
+     * Updates a progress item
+     * @param progressItemId
+     * @param message
+     * @param progress number between 0-100
+     */
+    updateProgress(progressItemId: string, message?: string, progress?: number): void;
+    updateProgressBar(id: string, progress: number | ProgressEvent, min?: number, max?: number): void;
+    setVisible(visible: boolean): void;
+    /**
+     * Removes a progress item after some time
+     * @param progressItemId
+     */
+    delayRemoveProgressItem(progressItemId: string, delayInMs?: number): void;
+    destroy(): void;
+}

package/dist/types/core/components/Spinner.d.ts

@@ -0,0 +1,16 @@
+import type { Container } from "./Container";
+/**
+ * Build in Spinner, used to indicate the progress is busy.
+ */
+export declare class Spinner {
+    private element;
+    private jobCount;
+    constructor(container: Container);
+    /**
+     * Sets spinner visibility
+     */
+    private setSpinnerVisibility;
+    increaseJobCount(): void;
+    decreaseJobCount(): void;
+    destroy(): void;
+}

package/dist/types/core/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Spinner";
+export * from "./Container";
+export * from "./ProgressBar";

package/dist/types/core/controls/CameraControlsEx.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from "three";
+import { CameraControls } from "../camera-controls/CameraControls";
+/**
+ * @deprecated
+ */
+export declare class CameraControlsEx extends CameraControls {
+    minZoom: number;
+    draggingSmoothTime: number;
+    private dollySpeedBackup;
+    private azimuthRotateSpeedBackup;
+    private polarRotateSpeedBackup;
+    private truckSpeedBackup;
+    private domElementKeyEvents?;
+    keyTruckSpeed: number;
+    keys: {
+        left: string;
+        up: string;
+        right: string;
+        bottom: string;
+    };
+    constructor(object: THREE.PerspectiveCamera | THREE.OrthographicCamera, domElement?: HTMLElement);
+    get enableZoom(): boolean;
+    set enableZoom(value: boolean);
+    get enableRotate(): boolean;
+    set enableRotate(value: boolean);
+    get enableTruck(): boolean;
+    set enableTruck(value: boolean);
+    private onKeyDown;
+    private onKeyUp;
+    listenToKeyEvents(): void;
+    stopListenToKeyEvents(): void;
+    /**
+     * Dispose the OrbitControls instance itself, remove all eventListeners.
+     * @category Methods
+     */
+    dispose(): void;
+}

package/dist/types/core/controls/Control.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+/**
+ * Controls mode.
+ */
+export declare enum ControlsMode {
+    Orbit = 0,
+    FirstPerson = 1,
+    Plan = 2
+}
+/**
+ * Base class for controls.
+ */
+export interface BaseControls {
+    mode: ControlsMode;
+    setupControl(): void;
+    adjustCameraByBBox(bbox: THREE.Box3): void;
+}

package/dist/types/core/controls/OrbitControls.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { BaseControls, ControlsMode } from "./Control";
+import type { CameraManager } from "../../core/camera/CameraManager";
+/**
+ * Controls for 3d viewers.
+ */
+export declare class OrbitControls implements BaseControls {
+    readonly mode = ControlsMode.Orbit;
+    private cameraManager;
+    constructor(cameraManager: CameraManager);
+    setupControl(): void;
+    adjustCameraByBBox(box: THREE.Box3): void;
+}

package/dist/types/core/controls/PlanControls.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { BaseControls, ControlsMode } from "./Control";
+import type { CameraManager } from "../../core/camera";
+/**
+ * Controls for 2d viewers.
+ */
+export declare class PlanControls implements BaseControls {
+    readonly mode = ControlsMode.Plan;
+    private cameraManager;
+    constructor(cameraManager: CameraManager);
+    setupControl(): void;
+    adjustCameraByBBox(box: THREE.Box3): void;
+}

package/dist/types/core/controls/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Control";
+export * from "./OrbitControls";
+export * from "./PlanControls";
+export * from "./CameraControlsEx";

package/dist/types/core/dxf/DxfCompare.d.ts

@@ -0,0 +1,151 @@
+import * as THREE from "three";
+import type { DxfEntity } from "./DxfLoader";
+import type { DxfCompareConfig } from "../../core/Configs";
+import { IDxf } from "../../core/dxf-parser";
+/**
+ * Dxf change type, which can be "Added", "Removed" or "Modified".
+ *
+ * Note that a "Modified" change can be represented as a "Removed" and an "Added" types.
+ *
+ * The system can display "Added" object in a specific color (green, etc.),
+ * and "Removed" in another color (red, etc.).
+ */
+export declare enum DxfChangeType {
+    Added = "Added",
+    Removed = "Removed",
+    Modified = "Modified",
+    NoChange = "NoChange"
+}
+/**
+ * Dxf compare detail changes.
+ * It supports:
+ * - color
+ * - lineType
+ * - constantWidth (polyline width)
+ */
+export type DxfDetailChanges = {
+    [propName: string]: {
+        /**
+         * The old value.
+         */
+        old: unknown;
+        /**
+         * The new value.
+         */
+        new: unknown;
+    };
+};
+/**
+ * Describes a dxf change
+ */
+export interface DxfChange {
+    /**
+     * An integer type id. It is unique in the lifecycle of a Viewer2d.
+     */
+    id: number;
+    /**
+     * Change type, which can be "Added", "Removed", "Modified" or "NoChange".
+     */
+    type: DxfChangeType;
+    /**
+     * AutoCAD entity handle as hex string.
+     */
+    handle: string;
+    /**
+     * AutoCAD entity handle as hex string.
+     * @internal
+     */
+    parentHandles?: string[];
+    /**
+     * @internal
+     */
+    box?: THREE.Box3;
+    detailChanges?: DxfDetailChanges;
+}
+/**
+ * Used to compare two drawings/dxfs.
+ * - Consider model space only.
+ * - Consider entity's geometry, position, scale, etc.
+ * - Ignore layer's visibility, freeze settings.
+ * - Ignore entity's properties like linetype, fill pattern, font, color, etc.
+ * - Ignore spatial filter (xclip) of block reference.
+ * - We compare entities with the same handle and type. e.g.
+ *   - if line A from dxf1 has the same handle with arc A from dxf2, then line A is "Removed", arc A is "Added".
+ * - For color, it compares color setting rather than the actual color. E.g.
+ *   - If a color setting is "ByLayer", but the layer's color is changed. We take this case as unchanged.
+ *   - If a color setting is "ByLayer", the setting is changed to "ByBlock", while the layer and block actually have the same color. We take this case as changed.
+ * @internal
+ */
+export declare class DxfCompare {
+    static readonly ENTITY_COLOR_ADDED = 65280;
+    static readonly ENTITY_COLOR_REMOVED = 16711680;
+    static readonly ENTITY_COLOR_NO_CHANGE = 10066329;
+    static readonly ENTITY_COLOR_MARKUP = 16744231;
+    private dxf1;
+    private dxf2;
+    private changes;
+    private comparedBlocks;
+    private isComparingBlock;
+    private isComparingDimension;
+    private enableDetailComparision;
+    static readonly ENTITY_TYPES_TO_IGNORE: string[];
+    constructor(dxf1: IDxf, dxf2: IDxf, compareCfg?: DxfCompareConfig);
+    private getLayerFrozen;
+    /**
+     * Compares model spaces of two dxf files.
+     * Returns DxfChange map, the key is incremental integer starts from 1.
+     * It is unique in the lifecycle of a Viewer2d.
+     */
+    compare(onProgress?: (event: ProgressEvent) => void): Promise<Record<number, DxfChange>>;
+    private isDimensionBlock;
+    compareInsertOrDemensionEntities(a: DxfEntity, b: DxfEntity, parentHandle1?: string, parentHandle2?: string): {
+        type: DxfChangeType;
+        handle: string;
+        parentHandles?: string[] | undefined;
+    }[] | undefined;
+    private compareBlock;
+    private compareEntities;
+    private bIgnoreChildEntitiesOriginalType;
+    private entitiesEqual;
+    private getColor;
+    private getLineType;
+    private addModificationItem;
+    private baseEntitiesEqual;
+    private arcsEqual;
+    private linesEqual;
+    private polylinesEqual;
+    private textsEqual;
+    private solidsEqual;
+    private pointEntitiesEqual;
+    private splinesEqual;
+    private mtextsEqual;
+    private ellipsesEqual;
+    private attDefsEqual;
+    private attribsEqual;
+    private hatchesEqual;
+    private viewportsEqual;
+    private leadersEqual;
+    private mleadersEqual;
+    private ole2framesEqual;
+    private insertsEqual;
+    private dimensionsEqual;
+    private regionsEqual;
+    private vectorsEqual;
+    private pointsEqual;
+    private vertexEntityEqual;
+    private numbersEqual;
+    private numberEqual;
+    private vectorArraysEqual;
+    private verticesEqual;
+    private verticesArrayEqual;
+    private vertexEntitiesEqual;
+    private hatchEdgesEqual;
+    private hatchEdgeArraysEqual;
+    private hatchBoundaryPathsEqual;
+    private hatchBoundaryPathArraysEqual;
+    private mleaderLineEqual;
+    private mleaderLinesEqual;
+    private mleaderLeaderEqual;
+    private mleaderLeadersEqual;
+    private mleaderContextEqual;
+}

package/dist/types/core/dxf/DxfConstants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Constants used by dxf
+ */
+export declare const ByLayer = "BYLAYER";
+export declare const ByBlock = "BYBLOCK";
+export declare const DefaultLineType = "CONTINUOUS";
+export declare const ColorIndexByBlock = 0;
+export declare const ColorIndexByLayer = 256;
+export declare const DefaultLayer = "0";
+/**
+ * The Model space viewport, aka, the default viewport id is 1.
+ * Paper space viewports are 2, 3, ...
+ */
+export declare const DefaultViewportId = 1;
+/**
+ * The render order for entities.
+ * AutoCAD has well defined render order for each entity. But we have trouble
+ * to make the order the same as in AutoCAD. If we cannot, we'll simply make
+ * entities follow this order.
+ */
+export declare enum DxfRenderOrder {
+    Mesh = -1,
+    MeshWithPattern = 0,
+    LineWithWidth = 1,
+    Line = 2,
+    LineWithPattern = 3,
+    Point = 4,
+    Text = 5
+}
+/**
+ * For nested types, we need to compare their inner entities.
+ */
+export declare const NestedCompareTypes: string[];