@x-viewer/plugins 0.9.0

package/dist/types/hotpoint/HotpointPlugin.d.ts

@@ -0,0 +1,103 @@
+import { THREE, THREEAddons, BaseViewer, Plugin } from "@x-viewer/core";
+export interface Hotpoint {
+    hotpointId: string;
+    anchorPosition: number[];
+    visible?: boolean;
+    html: string;
+}
+/**
+ * Hotpoint plugin manages hotpoints in a viewer.
+ * It can be used by Viewer2d and Viewer3d.
+ * - A hotpoint is created and stored by user. User define its html and css.
+ * - A hotpoint can be added to, and removed from viewer.
+ * - Caller should set a hotpointId that is unique in the session of current viewer.
+ * - Viewer2d doesn't maintain the relationship between hotpoint and layout.
+ */
+export declare class HotpointPlugin extends Plugin {
+    protected hotpointRoot?: THREE.Group;
+    protected css2dRenderer: THREEAddons.CSS2DRenderer;
+    constructor(viewer: BaseViewer);
+    /**
+     * @description {en} Adds a hotpoint.
+     * Caller should set a hotpointId that is unique in the session of current viewer.
+     * @description {zh} 添加热点。
+     * 调用者应该设置一个在当前Viewer会话中唯一的热点id。
+     * @param hotpoint
+     * - {en} hotpoint data.
+     * - {zh} 热点数据。
+     * @example
+     * ``` typescript
+     * const hotpoint = {
+     *    hotpointId: "c6ea70a3-ddb0-4dd0-87c8-bd2491936428",
+     *    anchorPosition: [0, 0, 0],
+     *    html: "<div>hotpoint</div>",
+     *    visible: true,
+     * };
+     * const plugin = new HotpointPlugin(viewer);
+     * plugin.add(hotpoint);
+     * ```
+     */
+    add(hotpoint: Hotpoint): void;
+    /**
+     * @description {en} Removes a hotpoint by given hotpointId.
+     * @description {zh} 根据热点id删除热点。
+     * @param {string} hotpointId
+     * - {en} hotpoint id.
+     * - {zh} 热点id。
+     * @example
+     * ``` typescript
+     * const hotpointId = "c6ea70a3-ddb0-4dd0-87c8-bd2491936428";
+     * const plugin = new HotpointPlugin(viewer);
+     * plugin.remove(hotpointId);
+     * ```
+     */
+    remove(hotpointId: string): void;
+    /**
+     * @description {en} Clears all hotpoints.
+     * @description {zh} 清除所有热点。
+     * @example
+     * ``` typescript
+     * const plugin = new HotpointPlugin(viewer);
+     * plugin.clear();
+     * ```
+     */
+    clear(): void;
+    /**
+     * Checks if hotpoint with specific id already exist
+     * Caller should set a hotpointId that is unique in the session of current Viewer2d.
+     * @internal
+     */
+    has(hotpointId: string): boolean;
+    /**
+     * @description {en} Moves a hotpoint.
+     * @description {zh} 移动热点的位置。
+     * @example
+     * ``` typescript
+     * const hotpointId = "c6ea70a3-ddb0-4dd0-87c8-bd2491936428";
+     * const plugin = new HotpointPlugin(viewer);
+     * plugin.move(hotpointId, [10, 10, 0]);
+     * ```
+     */
+    move(hotpointId: string, position: THREE.Vector2 | THREE.Vector3): void;
+    /**
+     * @description {en} Hides or show a hotpoint.
+     * @description {zh} 显示或隐藏一个热点。
+     * @example
+     * ``` typescript
+     * const hotpointId = "c6ea70a3-ddb0-4dd0-87c8-bd2491936428";
+     * const plugin = new HotpointPlugin(viewer);
+     * plugin.setVisible(hotpointId, false);
+     * ```
+     */
+    setVisible(hotpointId: string, visible: boolean): void;
+    protected findHotpointObject(hotpointId: string): THREEAddons.CSS2DObject | undefined;
+    /**
+     *
+     * @param hotpointId
+     * @returns
+     * @description Fly to hotpoint by hotpointId.
+     */
+    flyToHotpoint(hotpointId: string): void;
+    destroy(): void;
+    protected onAfterRender: () => void;
+}

package/dist/types/hotpoint/index.d.ts

@@ -0,0 +1 @@
+export * from "./HotpointPlugin";

package/dist/types/index.d.ts

@@ -0,0 +1,27 @@
+export * from "./axis-gizmo";
+export * from "./bottom-bar";
+export * from "./context-menu";
+export * from "./dat-gui";
+export * from "./layer-manager";
+export * from "./explode";
+export * from "./export";
+export * from "./ground-grass";
+export * from "./ground-grid";
+export * from "./ground-shaow";
+export * from "./hotpoint";
+export * from "./local-model-uploader";
+export * from "./markups";
+export * from "./measurements";
+export * from "./nav-cube";
+export * from "./pdf";
+export * from "./property";
+export * from "./screenshot";
+export * from "./stats";
+export * from "./skybox";
+export * from "./sections";
+export * from "./settings-2d";
+export * from "./settings-3d";
+export * from "./toolbars";
+export * from "./tree-view";
+export * from "./view-cube";
+export * from "./overview-map";

package/dist/types/layer-manager/LayerManagerPlugin.d.ts

@@ -0,0 +1,51 @@
+import { DxfLayers, Viewer2d, PdfLayers, Plugin, PluginConfig } from "@x-viewer/core";
+import { BasePanel } from "@x-viewer/ui";
+/**
+ * Dxf layer manager config.
+ */
+export interface LayerManagerPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Container div id.
+     */
+    containerId: string;
+    /**
+     * If panel is visible. It is visible by default.
+     */
+    visible?: boolean;
+}
+/**
+ * Layer manager plugin events.
+ */
+type LayerManagerPluginEvents = {
+    /**
+     * Panel visibility change event.
+     */
+    visibilitychange: boolean;
+};
+/**
+ * Dxf layer manager.
+ * Can be used by Viewer2d.
+ */
+export declare class LayerManagerPlugin extends Plugin<LayerManagerPluginEvents> {
+    static readonly DEFAULT_ID = "LayerManagerPlugin";
+    protected cfg: LayerManagerPluginConfig;
+    protected basePanel?: BasePanel;
+    protected container?: HTMLDivElement;
+    protected content?: HTMLDivElement;
+    protected layerList?: HTMLDivElement;
+    protected dxfLayersArray?: (DxfLayers | PdfLayers)[];
+    protected checkboxes?: HTMLInputElement[];
+    constructor(viewer: Viewer2d, cfg?: LayerManagerPluginConfig);
+    protected init(): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    private onClose;
+    destroy(): void;
+    addContent(): void;
+    generateListItem(layer: string, visible: boolean, color?: string): string;
+    checkboxHandler(checkbox: HTMLInputElement): void;
+    updatePage(): void;
+    updateHeaderText(): void;
+    convertDecimalToHex(decimal: number): string | undefined;
+}
+export {};

package/dist/types/layer-manager/index.d.ts

@@ -0,0 +1,2 @@
+import "./LayerManager.scss";
+export * from "./LayerManagerPlugin";

package/dist/types/local-model-uploader/IUploader.d.ts

@@ -0,0 +1,19 @@
+import { BaseViewer } from "@x-viewer/core";
+/**
+ * @internal
+ */
+export declare class IUploader {
+    protected viewer: BaseViewer;
+    protected input: HTMLInputElement;
+    protected dropZone: HTMLDivElement;
+    protected _formats: string[];
+    constructor(viewer: BaseViewer, elementId?: string, formats?: string[]);
+    protected formats(): string[];
+    protected uploadFiles(files: FileList): void;
+    openFileBrowserToUpload(): void;
+    destroy(): void;
+    protected handleDragEnter: (e: DragEvent) => void;
+    protected handleDragLeave: (e: DragEvent) => void;
+    protected handleDragOver: (e: DragEvent) => void;
+    protected handleDrop: (e: DragEvent) => void;
+}

package/dist/types/local-model-uploader/LocalDxfUploader.d.ts

@@ -0,0 +1,22 @@
+import { Viewer2d, ModelConfig } from "@x-viewer/core";
+import { IUploader } from "./IUploader";
+/**
+ * @internal
+ */
+export declare class LocalDxfUploader extends IUploader {
+    private pdfWorker;
+    onSuccess?: (event: any) => void;
+    readonly defaultModelConfig: ModelConfig;
+    constructor(viewer: Viewer2d, elementId?: string, formats?: string[]);
+    setPdfWorker(pdfWorker: string): void;
+    protected formats(): string[];
+    protected uploadFiles(files: FileList): void;
+    /**
+     * Upload single dxf file.
+     */
+    private uploadSingleDxf;
+    /**
+     * Upload single dxf file.
+     */
+    private uploadSinglePdf;
+}

package/dist/types/local-model-uploader/LocalModelUploader.d.ts

@@ -0,0 +1,24 @@
+import type { ModelConfig, Viewer3d } from "@x-viewer/core";
+import { IUploader } from "./IUploader";
+/**
+ * @internal
+ */
+export declare class LocalModelUploader extends IUploader {
+    readonly defaultModelConfig: ModelConfig;
+    constructor(viewer: Viewer3d, elementId?: string);
+    protected formats(): string[];
+    /**
+     * Uploads model files. There are several cases:
+     * - Upload a single file, a glTF, obj, etc.
+     * - Upload a model with external (bin, texture) files.
+     * - Upload many model files with the same format, a number of glTF without external bin or texture.
+     * It doesn't support the case to upload many model files, and one or more of them contains external files.
+     */
+    protected uploadFiles(files: FileList): void;
+    private checkAllFilesWithTheSameFormat;
+    /**
+     * Upload single model file without external texture/bin, etc.
+     * With this function, caller can upload many gltf/glb at one time.
+     */
+    private uploadSingleFile;
+}

package/dist/types/local-model-uploader/index.d.ts

@@ -0,0 +1,3 @@
+import "./uploader.scss";
+export * from "./LocalModelUploader";
+export * from "./LocalDxfUploader";

package/dist/types/markups/ArrowMarkup.d.ts

@@ -0,0 +1,12 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class ArrowMarkup extends BaseMarkup {
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    private drawArrowLine;
+    private drawArrowHead;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/BaseMarkup.d.ts

@@ -0,0 +1,33 @@
+import { THREE, DrawableData, PathDrawable } from "@x-viewer/core";
+import type { TextMarkup } from "../markups/TextMarkup";
+/**
+ * Markup for Viewer2d contains additional information, e.g. layoutName.
+ *
+ * Viewer2d doesn't maintain the relationship between model and markup data,
+ * business logic should knows which model a set of markup data belong to.
+ */
+export type MarkupData = DrawableData;
+export declare abstract class BaseMarkup extends PathDrawable {
+    protected editPointSize: number;
+    protected editPointFillColor: string;
+    protected editPointStrokeColor: string;
+    protected x: number;
+    protected y: number;
+    protected width: number;
+    protected height: number;
+    protected ctx?: CanvasRenderingContext2D;
+    leaderText?: TextMarkup;
+    parent?: BaseMarkup;
+    constructor(id: string);
+    isSelected(): boolean;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    private drawPoints;
+    isPointInPath(p: THREE.Vector3): boolean;
+    setData(data: DrawableData): void;
+    getData(): DrawableData;
+    setParent(parent: BaseMarkup): void;
+    setLeaderText(textMarkup: TextMarkup): void;
+    getVertexes(): THREE.Vector3[];
+    update(points: THREE.Vector3[]): this;
+    translate(tx: number, ty: number): this;
+}

package/dist/types/markups/CircleMarkup.d.ts

@@ -0,0 +1,12 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class CircleMarkup extends BaseMarkup {
+    radius: number;
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    getVertexes(): THREE.Vector3[];
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/CloudLineMarkup.d.ts

@@ -0,0 +1,10 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class CloudLineMarkup extends BaseMarkup {
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    static getControlPointByTwoPoints(p1: THREE.Vector2, p2: THREE.Vector2): THREE.Vector2;
+    getClassType(): string;
+}

package/dist/types/markups/CloudRectMarkup.d.ts

@@ -0,0 +1,11 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class CloudRectMarkup extends BaseMarkup {
+    type: MarkupType;
+    private vertexes?;
+    constructor(id: string, points: THREE.Vector3[]);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/CloudRectWithTextMarkup.d.ts

@@ -0,0 +1,42 @@
+import { THREE, DrawableData } from "@x-viewer/core";
+import type { MarkupPlugin } from "./MarkupPlugin";
+import { MarkupType } from "../markups/Constants";
+import { TextMarkup } from "../markups/TextMarkup";
+export interface CloudRectWithTextShape extends DrawableData {
+    text: string;
+    fontSize: number;
+    textPosition: number[];
+}
+export declare class CloudRectWithTextMarkup extends TextMarkup {
+    type: MarkupType;
+    private textPosition;
+    private controlPoints?;
+    private vertexes?;
+    private textBounds;
+    text: string;
+    fontSize: number;
+    static LEADER_LINE_WIDTH: number;
+    constructor(id: string, points: THREE.Vector3[], text?: string);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    private drawCloudRect;
+    private drawLeaderLine;
+    protected drawText(ctx: CanvasRenderingContext2D, camera: THREE.Camera, text: string): void;
+    translate(tx: number, ty: number): this;
+    update(points: THREE.Vector3[]): this;
+    getCloudPoints(): THREE.Vector3[];
+    getBounds(): THREE.Box3;
+    getVertexes(): THREE.Vector3[];
+    isLeaderTextSelected(p: THREE.Vector3): boolean;
+    translateLeaderText(tx: number, ty: number): this;
+    isPointInPath(p: THREE.Vector3): boolean;
+    setData(data: CloudRectWithTextShape): void;
+    updateText(text: string): void;
+    getData(): CloudRectWithTextShape;
+    getClassType(): string;
+    addInput(manager: MarkupPlugin, x: number, y: number): void;
+    updateInputPosition(p1: THREE.Vector2, p2: THREE.Vector2): void;
+    handleClick: () => void;
+    handleInput: () => void;
+    handleCompositionEnd: () => void;
+    private calcInputPositionByText;
+}

package/dist/types/markups/Constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Markup type, including Arrow, Circle, Rectangle, Text, etc.
+ */
+export declare enum MarkupType {
+    Arrow = "ArrowMarkup",
+    Circle = "CircleMarkup",
+    CloudLine = "CloudLineMarkup",
+    CloudLineRectangle = "CloudRectMarkup",
+    CloudRectWithText = "CloudRectWithTextMarkup",
+    Dot = "DotMarkup",
+    Ellipse = "EllipseMarkup",
+    LeaderLine = "LeaderLineMarkup",
+    PolyLine = "PolylineMarkup",
+    Rectangle = "RectMarkup",
+    Text = "TextMarkup",
+    X = "XMarkup"
+}

package/dist/types/markups/DotMarkup.d.ts

@@ -0,0 +1,9 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+export declare class DotMarkup extends BaseMarkup {
+    radius: number;
+    constructor(id: string, points: THREE.Vector3[]);
+    getVertexes(): THREE.Vector3[];
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    getClassType(): string;
+}

package/dist/types/markups/EllipseMarkup.d.ts

@@ -0,0 +1,12 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class EllipseMarkup extends BaseMarkup {
+    radiusX: number;
+    radiusY: number;
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/LeaderLineMarkup.d.ts

@@ -0,0 +1,25 @@
+import { THREE } from "@x-viewer/core";
+import { MarkupType } from "./Constants";
+import type { MarkupPlugin } from "./MarkupPlugin";
+import { TextShape, TextMarkup } from "./TextMarkup";
+export declare class LeaderLineMarkup extends TextMarkup {
+    type: MarkupType;
+    text: string;
+    fontSize: number;
+    private textBounds;
+    constructor(id: string, points: THREE.Vector3[], text: string);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    private drawArrowHead;
+    private drawArrowLine;
+    protected drawText(ctx: CanvasRenderingContext2D, camera: THREE.Camera, text: string): void;
+    getVertexes(): THREE.Vector3[];
+    update(points: THREE.Vector3[]): this;
+    getData(): TextShape;
+    isPointInPath(p: THREE.Vector3): boolean;
+    updateText(text: string): void;
+    getClassType(): string;
+    addInput(manager: MarkupPlugin, x: number, y: number): void;
+    handleInput: () => void;
+    handleCompositionEnd: () => void;
+    private calcuTextInputPositionByText;
+}

package/dist/types/markups/MarkupPlugin.d.ts

@@ -0,0 +1,91 @@
+import { THREE } from "@x-viewer/core";
+import { CanvasRender, DrawableData, UndoManager, Plugin, type BaseViewer, EventInfo } from "@x-viewer/core";
+import { BaseMarkup } from "./BaseMarkup";
+import { MarkupType } from "./Constants";
+export declare enum MarkupPluginEvent {
+    StartDraw = "StartDraw",
+    EndDraw = "EndDraw",
+    EndEdit = "EndEdit"
+}
+export declare class MarkupPlugin extends Plugin<Record<MarkupPluginEvent, any>> {
+    static readonly DEFAULT_ID = "MarkupPlugin";
+    overlayRender: CanvasRender;
+    private inputManager;
+    private drawableList;
+    private lineWidth;
+    private lineColor;
+    private fillColor;
+    private fontSize;
+    protected mouseDown: boolean;
+    protected mouseDownPositionX?: number;
+    protected mouseDownPositionY?: number;
+    protected mousedownPoint?: THREE.Vector2;
+    private isSelectLeaderText;
+    private selectedShape?;
+    private type?;
+    private isDrawing;
+    private initialDataForEditing?;
+    private creatingShape?;
+    private tempPoints;
+    private activated;
+    constructor(viewer: BaseViewer);
+    get viewerCanvas(): HTMLCanvasElement;
+    get camera(): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+    get raycaster(): THREE.Raycaster;
+    get undoMgr(): UndoManager;
+    setMarkupVisibility(id: string, visible: boolean): boolean;
+    setMarkupsVisibility(visible: boolean): void;
+    clear(): void;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    getActiveMarkupType(): MarkupType | undefined;
+    setDrawType(type: MarkupType): void;
+    setLineWidth(linewidth: number): void;
+    getLineWidth(): number;
+    setLineColor(color: number[]): void;
+    getLineColor(): number[];
+    setFillColor(color: number[]): void;
+    getFillColor(): number[];
+    setFontSize(fontSize: number): void;
+    getFontSize(): number;
+    /**
+     * Picks and get world position by screen position.
+     */
+    protected pickPositionByScreenPoint(p: THREE.Vector2): THREE.Vector3 | undefined;
+    handleDbClick: () => void;
+    handleInputMousemove: (e: MouseEvent) => void;
+    mousedown: (e: EventInfo) => void;
+    mousemove: (e: EventInfo) => void;
+    mouseup: (e: EventInfo) => void;
+    keydown: (e: EventInfo) => void;
+    confirmToRemove(isConfirm: boolean): void;
+    isEditing(): boolean;
+    endEdit(selectMarkup: BaseMarkup): void;
+    endDraw(createdMarkup?: BaseMarkup): void;
+    cancelDraw(createdMarkup?: BaseMarkup): void;
+    reset(): void;
+    render(): void;
+    addMarkup(markup: BaseMarkup, needFireEvent?: boolean): void;
+    updateMarkup(markup: BaseMarkup, newData: DrawableData, needFireEvent?: boolean): void;
+    removeMarkup(markup: BaseMarkup, needFireEvent?: boolean): void;
+    removeMarkupById(id: string): boolean;
+    createMarkup(data: DrawableData): BaseMarkup;
+    getMarkupById(id: string): BaseMarkup;
+    /**
+     * Gets markup data.
+     */
+    getData(): DrawableData[];
+    /**
+     * Sets markup data.
+     */
+    setData(markupDatas: DrawableData[]): void;
+    private isCreateLineMode;
+    private isCreateDotMode;
+    private isCreateTextMode;
+    private isCreateShapeMode;
+    private drawShape;
+    private drawLine;
+    private drawText;
+    destroy(): void;
+}

package/dist/types/markups/PolylineMarkup.d.ts

@@ -0,0 +1,10 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class PolylineMarkup extends BaseMarkup {
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/RectMarkup.d.ts

@@ -0,0 +1,11 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class RectMarkup extends BaseMarkup {
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    getVertexes(): THREE.Vector3[];
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/TextMarkup.d.ts

@@ -0,0 +1,44 @@
+import { THREE, DrawableData } from "@x-viewer/core";
+import { BaseMarkup } from "./BaseMarkup";
+import type { MarkupPlugin } from "./MarkupPlugin";
+import { MarkupType } from "../markups/Constants";
+export declare enum TextMarkupEvent {
+    EnterEditing = "enterediting",
+    ExitEditing = "exitediting"
+}
+export interface TextShape extends DrawableData {
+    text: string;
+    fontSize: number;
+}
+export declare class TextMarkup extends BaseMarkup {
+    text: string;
+    fontSize: number;
+    type: MarkupType;
+    protected padding: number;
+    static readonly DEFAULT_INPUT_WIDTH = 50;
+    protected manager?: MarkupPlugin;
+    protected textInput?: HTMLTextAreaElement;
+    protected inputStatus: string;
+    isEditing: boolean;
+    constructor(id: string, points: THREE.Vector3[], text: string);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    protected drawText(ctx: CanvasRenderingContext2D, camera: THREE.Camera, text: string): void;
+    setFontSize(fontSize: number): void;
+    update(points: THREE.Vector3[]): this;
+    getVertexes(): THREE.Vector3[];
+    setData(data: TextShape): void;
+    updateText(text: string): void;
+    getData(): TextShape;
+    getClassType(): string;
+    addInput(manager: MarkupPlugin, x?: number, y?: number): void;
+    addInputEvents(): void;
+    handleClick: () => void;
+    handleKeydown: (e: KeyboardEvent) => void;
+    handleInput: () => void;
+    handleCompositionStart: () => void;
+    handleCompositionEnd: () => void;
+    handleBlur: () => void;
+    handleFoucs: () => void;
+    enterEditing(): void;
+    exitEditing(): void;
+}

package/dist/types/markups/XMarkup.d.ts

@@ -0,0 +1,10 @@
+import { THREE } from "@x-viewer/core";
+import { BaseMarkup } from "../markups/BaseMarkup";
+import { MarkupType } from "../markups/Constants";
+export declare class XMarkup extends BaseMarkup {
+    type: MarkupType;
+    constructor(id: string, points: THREE.Vector3[]);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/markups/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./BaseMarkup";
+export * from "./ArrowMarkup";
+export * from "./CircleMarkup";
+export * from "./CloudLineMarkup";
+export * from "./CloudRectMarkup";
+export * from "./DotMarkup";
+export * from "./EllipseMarkup";
+export * from "./LeaderLineMarkup";
+export * from "./PolylineMarkup";
+export * from "./RectMarkup";
+export * from "./TextMarkup";
+export * from "./XMarkup";
+export * from "./MarkupPlugin";
+export * from "./Constants";

package/dist/types/markups/undo/AddMarkupCommand.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@x-viewer/core";
+import { MarkupData } from "../BaseMarkup";
+import { type MarkupPlugin } from "../MarkupPlugin";
+export declare class AddMarkupCommand extends Command {
+    private manager;
+    private data;
+    constructor(manager: MarkupPlugin, data: MarkupData);
+    undo(): boolean;
+    redo(): boolean;
+}