dxfview 0.0.2

package/dist/types/core/indexeddb/IndexedDbManager.d.ts

@@ -0,0 +1,29 @@
+export declare class IndexedDbManager {
+    readonly DATABASE_NAME = "dxfview_db";
+    readonly TABLES: {
+        name: string;
+        options: {
+            keyPath: string;
+            autoIncrement: boolean;
+        };
+        indexArray: never[];
+    }[];
+    private db?;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): IndexedDbManager;
+    /**
+     * Make sure to open database, and the table is already created before add/put/delete, etc.
+     */
+    getDatabase(): Promise<IDBDatabase>;
+    /**
+     * Close database.
+     */
+    closeDatabase(): void;
+    private deleteDataBase;
+    private getDB;
+    private getUpgradedDB;
+    private createTable;
+}

package/dist/types/core/indexeddb/ViewpointTable.d.ts

@@ -0,0 +1,14 @@
+import { BaseTable } from "./BaseTable";
+/**
+ * ViewpointTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class ViewpointTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): ViewpointTable;
+    query(projectId: string, successCallback?: any, errorCallback?: any): void;
+}

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

@@ -0,0 +1,6 @@
+export * from "./AnnotationTable";
+export * from "./BaseTable";
+export * from "./IndexedDbManager";
+export * from "./ViewpointTable";
+export * from "./DxfDataTable";
+export * from "./FontDataTable";

package/dist/types/core/input/InputManager.d.ts

@@ -0,0 +1,161 @@
+import * as THREE from "three";
+import { Event } from "../../core/utils";
+declare 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
+}
+export declare enum MouseButtons {
+    None = 0,
+    /** Left Click or Touch */
+    Left = 1,
+    /** Right Click */
+    Right = 2,
+    /** Middle Click */
+    Middle = 4
+}
+declare type MouseButtonType = MouseButton | MouseButtons;
+/**
+ *
+ */
+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;
+    raycastCache?: {
+        ndc?: THREE.Vector2;
+        objects?: THREE.Object3D[];
+        intersections?: {
+            [key: string]: THREE.Intersection[];
+        };
+        frame?: number;
+    };
+}
+export declare 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;
+    constructor(element: HTMLElement);
+    getEnabled(): boolean;
+    setEnabled(enable: boolean): void;
+    getkKeyboardEnabled(): boolean;
+    setkKeyboardEnabled(enable: boolean): void;
+    setCursor(cursorStyle: string): void;
+    bindEvents(): void;
+    private handleClick;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private handleMouseWheel;
+    private handleContextMenu;
+    private handlePointerEnter;
+    private handlePointerLeave;
+    private handleResize;
+    private handleKeydown;
+    private handleKeyup;
+    unBindEvents(): void;
+    private getBaseEvent;
+    private stop;
+    private updatePointers;
+    private removePointers;
+    style: {};
+    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/types/core/input/index.d.ts

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

package/dist/types/core/license/AutoConfig.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 读取全局配置并自动设置 LicenseManager。
+ *
+ * 约定全局变量（任选其一，优先级从上至下）：
+ * - window.__DXF_LICENSE_PUBLIC_KEY_HEX
+ * - globalThis.__DXF_LICENSE_PUBLIC_KEY_HEX
+ *
+ * - window.__DXF_LICENSE_STRING
+ * - globalThis.__DXF_LICENSE_STRING
+ *
+ * - window.__DXF_LICENSE_ENFORCE (boolean)
+ * - globalThis.__DXF_LICENSE_ENFORCE (boolean)
+ *
+ * - window.__DXF_LICENSE_TIME_ENDPOINT (string) 可信时间接口，例如 "/api/time"
+ * - window.__DXF_LICENSE_RENEW_ENDPOINT (string) 续签接口，例如 "/api/renew"
+ */
+export declare function applyAutoConfig(): void;

package/dist/types/core/license/LicenseManager.d.ts

@@ -0,0 +1,107 @@
+import type { BaseViewer } from "../../core/viewers/BaseViewer";
+declare type LicensePayload = {
+    name: string;
+    exp?: number;
+    issuedAt?: number;
+    domains?: string[];
+    features?: string[];
+    versionRange?: string;
+};
+declare type ValidateContext = {
+    now?: number;
+    domain?: string;
+    version?: string;
+};
+export declare type InvalidReason = "NO_PUBLIC_KEY" | "NO_LICENSE" | "BAD_SIGNATURE" | "EXPIRED" | "DOMAIN_NOT_ALLOWED" | "INVALID_LICENSE";
+declare type ValidateResult = {
+    ok: true;
+    payload: LicensePayload;
+} | {
+    ok: false;
+    reason: InvalidReason;
+};
+export declare class LicenseManager {
+    private static publicKey;
+    private static enforce;
+    private static licenseRaw;
+    private static payload;
+    private static lastResult;
+    private static lastCheckedAt;
+    private static timeProvider?;
+    private static renewHandler?;
+    private static overlayEl?;
+    private static overlayObserver?;
+    private static overlayObserverRoot?;
+    private static blockersInstalled;
+    /**
+     * 设置验证用公钥（十六进制字符串）。私钥请仅在你的后端保管。
+     */
+    static setPublicKeyHex(publicKeyHex: string): void;
+    /**
+     * 设置许可证字符串，格式：base64url(payload).base64url(signature)
+     */
+    static setLicense(license: string): void;
+    /**
+     * 设置是否强制执行（为 true 时将阻断交互）。默认 false。
+     */
+    static setEnforce(flag: boolean): void;
+    static getEnforce(): boolean;
+    static getPayload(): LicensePayload | null;
+    /**
+     * 设置可信时间源提供者，返回毫秒时间戳。若未设置则使用 Date.now()。
+     */
+    /**
+     * 设置可信时间源提供者
+     * - 未设置时默认使用 Date.now()
+     */
+    static setTimeProvider(provider: () => Promise<number>): void;
+    /**
+     * 设置续签处理函数：在临近过期时调用，返回新的许可证串。
+     */
+    /**
+     * 设置自动续签处理函数
+     * - 当许可证接近过期时触发，返回新的许可证字符串
+     */
+    static setRenewHandler(handler: (payload: LicensePayload) => Promise<string>): void;
+    /**
+     * 获取可信时间戳（毫秒）
+     * - 优先使用外部注入的 timeProvider，失败则回退到本地时间
+     */
+    private static getTrustedNowMs;
+    /**
+     * 解析许可证字符串
+     * 格式：base64url(payload).base64url(signature)
+     */
+    private static parse;
+    /**
+     * 校验许可证有效性
+     * - 验签（ed25519）/ 过期检查 / 域名白名单
+     */
+    static validate(context: ValidateContext): Promise<ValidateResult>;
+    /**
+     * 断言许可证有效，无效则抛出错误。
+     */
+    /**
+     * 断言许可证有效（无效则抛错）
+     */
+    static assertValid(context: ValidateContext): Promise<LicensePayload>;
+    /**
+     * 为当前查看器安排一次异步验证；验证失败时展示水印。若 enforce=true，则拦截交互。
+     */
+    /**
+     * 为指定 Viewer 安排一次异步验证
+     * - 验证失败：显示水印/可选阻断
+     * - 验证成功：在接近过期时尝试自动续签
+     */
+    static scheduleValidationForViewer(viewer: BaseViewer): void;
+    /**
+     * 应用降级 UI 到 Viewer（水印/拦截层）
+     */
+    private static applyFallbackToViewer;
+    /**
+     * 在接近过期时尝试自动续签
+     * - thresholdMs 默认 3 天
+     */
+    private static maybeAutoRenew;
+}
+export {};

package/dist/types/core/license/PublicKey.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_PUBLIC_KEY_HEX = "0xe93f27a3147a0e2f67b718dffbf7553981ec8d9bb8bf7d18a4ba1f491736ea78";

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

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

package/dist/types/core/markup/ArrowMarkup.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { BaseMarkup } from "../../core/markup/BaseMarkup";
+import { MarkupType } from "../../core/markup/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;
+    getVertexes(): THREE.Vector3[];
+    update(points: THREE.Vector3[]): this;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getClassType(): string;
+}

package/dist/types/core/markup/BaseMarkup.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from "three";
+import { DrawableData } from "../../core/canvas/Constants";
+import { Drawable } from "../../core/canvas/Drawable";
+import type { TextMarkup } from "../../core/markup/TextMarkup";
+export declare abstract class BaseMarkup extends Drawable {
+    protected editPointSize: number;
+    protected editPointFillColor: string;
+    protected editPointStrokeColor: string;
+    protected ctx?: CanvasRenderingContext2D;
+    leaderText?: TextMarkup;
+    parent?: BaseMarkup;
+    constructor(id: string);
+    isSelected(): boolean;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    private drawPoints;
+    setEditPointSize(size: number): void;
+    setEditPointFillColor(color: string): void;
+    setEditPointStrokeColor(color: string): void;
+    getCenter(): THREE.Vector3;
+    isPointInPath(p: THREE.Vector3): boolean;
+    setData(data: DrawableData): void;
+    setParent(parent: BaseMarkup): void;
+    setLeaderText(textMarkup: TextMarkup): void;
+    update(points: THREE.Vector3[]): this;
+    translate(tx: number, ty: number): this;
+    rotate(): this;
+    scale(): this;
+}

package/dist/types/core/markup/CircleMarkup.d.ts

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

package/dist/types/core/markup/CloudLineMarkup.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { BaseMarkup } from "../../core/markup/BaseMarkup";
+import { MarkupType } from "../../core/markup/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/core/markup/CloudRectMarkup.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from "three";
+import { BaseMarkup } from "../../core/markup/BaseMarkup";
+import { MarkupType } from "../../core/markup/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/core/markup/CloudRectWithTextMarkup.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from "three";
+import type { MarkupManager } from "./MarkupManager";
+import { DrawableData } from "../../core/canvas";
+import { MarkupType } from "../../core/markup/Constants";
+import { TextMarkup } from "../../core/markup/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: MarkupManager, x: number, y: number): void;
+    updateInputPosition(p1: THREE.Vector2, p2: THREE.Vector2): void;
+    handleClick: () => void;
+    handleInput: () => void;
+    handleCompositionEnd: () => void;
+    private calcInputPositionByText;
+}

package/dist/types/core/markup/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/core/markup/DotMarkup.d.ts

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

package/dist/types/core/markup/EllipseMarkup.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+import { BaseMarkup } from "../../core/markup/BaseMarkup";
+import { MarkupType } from "../../core/markup/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/core/markup/LeaderLineMarkup.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from "three";
+import { MarkupType } from "./Constants";
+import type { MarkupManager } from "./MarkupManager";
+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: MarkupManager, x: number, y: number): void;
+    handleInput: () => void;
+    handleCompositionEnd: () => void;
+    private calcuTextInputPositionByText;
+}

package/dist/types/core/markup/MarkupManager.d.ts

@@ -0,0 +1,91 @@
+import * as THREE from "three";
+import { BaseMarkup } from "./BaseMarkup";
+import { MarkupType } from "./Constants";
+import { CanvasRender, DrawableData } from "../../core/canvas";
+import type { EventInfo, InputManager } from "../../core/input/InputManager";
+import { Event } from "../../core/utils";
+import type { BaseViewer } from "../../core/viewers";
+declare type MarkupEvents = {
+    StartDraw: BaseMarkup;
+    EndDraw: BaseMarkup;
+    EndEdit: BaseMarkup;
+};
+export declare class MarkupManager extends Event<MarkupEvents> {
+    private viewer;
+    private inputManager;
+    overlayRender?: CanvasRender;
+    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 tempKey?;
+    private tempTouch?;
+    private tempArrowKeys?;
+    private selectedShape?;
+    private type?;
+    private isDrawing;
+    private initialDataForEditing?;
+    private creatingShape?;
+    private tempPoints;
+    private activated;
+    protected exitButton?: HTMLButtonElement;
+    constructor(viewer: BaseViewer, input: InputManager);
+    get viewerCanvas(): HTMLCanvasElement;
+    get camera(): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+    get raycaster(): THREE.Raycaster;
+    setMarkupVisibility(id: string, visible: boolean): boolean;
+    setMarkupsVisibility(visible: boolean): void;
+    clearAll(): void;
+    isMarkupActive(): boolean;
+    protected createMobileExitButton(): HTMLButtonElement;
+    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;
+    pickPositionByScreenPoint(p: THREE.Vector2): THREE.Vector3 | undefined;
+    pickThreejsPositionByMouse(e: EventInfo): 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;
+    getMarkupData(): DrawableData[];
+    setMarkupData(markupDatas: DrawableData[]): void;
+    private isCreateLineMode;
+    private isCreateDotMode;
+    private isCreateTextMode;
+    private isCreateShapeMode;
+    private drawShape;
+    private drawLine;
+    private drawText;
+    destroy(): void;
+}
+export {};

package/dist/types/core/markup/PolylineMarkup.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from "three";
+import { BaseMarkup } from "../../core/markup/BaseMarkup";
+import { MarkupType } from "../../core/markup/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;
+    getVertexes(): THREE.Vector3[];
+    getClassType(): string;
+}

package/dist/types/core/markup/RectMarkup.d.ts

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