@netless/appliance-plugin 1.0.0-beta.0

package/dist/core/tools/base.d.ts

@@ -0,0 +1,82 @@
+import { Point2d } from "../utils/primitives/Point2d";
+import { EScaleType, EToolsKey } from "../enum";
+import { BaseNodeMapItem, IMainMessage, IRectType, IUpdateNodeOpt, IWorkerMessage } from "../types";
+import { Group } from "spritejs";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes, ShapeOptions } from "./utils";
+import { TextOptions } from "../../component/textEditor/types";
+export interface BaseShapeOptions {
+    isOpacity?: boolean;
+    fontColor?: string;
+    fontBgColor?: string;
+    strokeColor?: string;
+    fillColor?: string;
+    vertex?: string;
+    fragment?: string;
+    syncUnitTime?: number;
+    zIndex?: number;
+    scale?: [number, number];
+    rotate?: number;
+    thickness?: number;
+    textOpt?: TextOptions;
+    translate?: [number, number];
+}
+export interface BaseShapeToolProps {
+    vNodes: VNodeManager;
+    toolsOpt: ShapeOptions;
+    fullLayer: Group;
+    drawLayer?: Group;
+}
+export declare abstract class BaseShapeTool {
+    static SafeBorderPadding: number;
+    protected abstract tmpPoints: Array<Point2d | number>;
+    readonly abstract toolsType: EToolsKey;
+    readonly abstract canRotate: boolean;
+    readonly abstract scaleType: EScaleType;
+    syncUnitTime: number;
+    vNodes: VNodeManager;
+    protected drawLayer?: Group;
+    protected fullLayer: Group;
+    protected workId: number | string | undefined;
+    protected abstract workOptions: ShapeOptions;
+    constructor(props: BaseShapeToolProps);
+    /** 消费本地数据，返回绘制结果 */
+    abstract consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+    }): IMainMessage;
+    /** 消费本地完整数据，返回绘制结果 */
+    abstract consumeAll(props: {
+        data?: IWorkerMessage;
+        hoverId?: string;
+    }): IMainMessage;
+    /** 消费服务端数据，返回绘制结果 */
+    abstract consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+        replaceId?: string;
+        isClearAll?: boolean;
+    }): IRectType | undefined;
+    /** 清除临时数据 */
+    abstract clearTmpPoints(): void;
+    /** 设置工作id */
+    setWorkId(id: number | string | undefined): void;
+    getWorkId(): string | number | undefined;
+    /** 获取工作选项配置 */
+    getWorkOptions(): ShapeOptions;
+    /** 设置工作选项配置 */
+    setWorkOptions(workOptions: BaseShapeOptions): void;
+    /** 更新服务端同步配置,返回绘制结果 */
+    updataOptService(opt?: IUpdateNodeOpt): IRectType | undefined;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+        targetNode?: BaseNodeMapItem;
+    }): IRectType | undefined;
+    static getCenterPos(r: IRectType, layer: Group): [number, number];
+    static getRectFromLayer(layer: Group, name: string): IRectType | undefined;
+}

package/dist/core/tools/ellipse.d.ts

@@ -0,0 +1,44 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface EllipseOptions extends BaseShapeOptions {
+    thickness: number;
+    strokeColor: string;
+    fillColor: string;
+}
+export declare class EllipseShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: EllipseOptions;
+    oldRect?: IRectType;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+    }): IMainMessage;
+    private draw;
+    private computDrawPoints;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}

package/dist/core/tools/eraser.d.ts

@@ -0,0 +1,41 @@
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IMainMessage, IRectType } from "../types";
+import type { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+export interface EraserOptions extends BaseShapeOptions {
+    thickness: number;
+    isLine: boolean;
+}
+export declare class EraserShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    readonly serviceWork?: ServiceWorkForFullWorker;
+    private static readonly eraserSizes;
+    protected tmpPoints: Array<number>;
+    protected workOptions: EraserOptions;
+    worldPosition: [number, number];
+    worldScaling: [number, number];
+    eraserRect: IRectType | undefined;
+    eraserPolyline?: [number, number, number, number];
+    constructor(props: BaseShapeToolProps, serviceWork?: ServiceWorkForFullWorker);
+    combineConsume(): undefined;
+    consumeService(): IRectType | undefined;
+    setWorkOptions(setWorkOptions: EraserOptions): void;
+    private createEraserRect;
+    private computRectCenterPoints;
+    private isNear;
+    private cutPolyline;
+    private isSamePoint;
+    private translateIntersect;
+    private isLineEraser;
+    private remove;
+    consume(props: {
+        data: IWorkerMessage;
+    }): IMainMessage;
+    consumeAll(props: {
+        data: IWorkerMessage;
+    }): IMainMessage;
+    clearTmpPoints(): void;
+    private getUnLockNodeMap;
+}

package/dist/core/tools/image.d.ts

@@ -0,0 +1,53 @@
+import { Scene } from "spritejs";
+import { IMainMessage, IRectType, IUpdateNodeOpt, BaseNodeMapItem } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface ImageOptions extends BaseShapeOptions {
+    /** 图片的唯一识别符 */
+    uuid: string;
+    /** 图片中点在世界坐标系中的 x 坐标 */
+    centerX: number;
+    /** 图片中点在世界坐标系中的 y 坐标 */
+    centerY: number;
+    /** 图片中点在世界坐标系中的宽 */
+    width: number;
+    /** 图片中点在世界坐标系中的高 */
+    height: number;
+    /** 图片是否被锁定 */
+    locked: boolean;
+    /** 图片是否禁止非等比放缩 */
+    uniformScale?: boolean;
+    /** 是否以跨域方式加载图片 */
+    crossOrigin?: boolean | string;
+    /** 图片地址 */
+    src: string;
+}
+export declare class ImageShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: ImageOptions;
+    oldRect?: IRectType;
+    constructor(props: BaseShapeToolProps);
+    consume(): IMainMessage;
+    consumeAll(): IMainMessage;
+    private draw;
+    consumeService(): IRectType | undefined;
+    consumeServiceAsync(props: {
+        isFullWork: boolean;
+        scene: Scene;
+        replaceId?: string;
+    }): Promise<IRectType | undefined>;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+        targetNode?: BaseNodeMapItem;
+    }): IRectType | undefined;
+}

package/dist/core/tools/index.d.ts

@@ -0,0 +1,13 @@
+export * from './base';
+export * from './pencil';
+export * from './laserPen';
+export * from './eraser';
+export * from './selector';
+export * from './arrow';
+export * from './ellipse';
+export * from './rectangle';
+export * from './star';
+export * from './polygon';
+export * from './speechBalloon';
+export * from './image';
+export * from './utils';

package/dist/core/tools/laserPen.d.ts

@@ -0,0 +1,42 @@
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IMainMessage, IRectType } from "../types";
+import { EStrokeType } from "../../plugin/types";
+import { Point2d } from "../utils/primitives/Point2d";
+export interface LaserPenOptions extends BaseShapeOptions {
+    thickness: number;
+    duration: number;
+    strokeColor: string;
+    strokeType: Omit<EStrokeType, 'Stroke'>;
+}
+export declare class LaserPenShape extends BaseShapeTool {
+    readonly toolsType: EToolsKey;
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    protected syncTimestamp: number;
+    private syncIndex;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: LaserPenOptions;
+    private consumeIndex;
+    constructor(props: BaseShapeToolProps);
+    combineConsume(): undefined;
+    setWorkOptions(workOptions: LaserPenOptions): void;
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork: boolean;
+        isSubWorker?: boolean;
+    }): IMainMessage;
+    consumeAll(): IMainMessage;
+    clearTmpPoints(): void;
+    consumeService(props: {
+        op: number[];
+        isFullWork?: boolean;
+        replaceId?: string;
+    }): IRectType | undefined;
+    private computDotStroke;
+    private updateTempPoints;
+    private draw;
+    private getTaskPoints;
+    removeLocal(): undefined;
+    removeService(key: string): IRectType | undefined;
+}

package/dist/core/tools/pencil.d.ts

@@ -0,0 +1,66 @@
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EStrokeType } from "../../plugin/types";
+import { ShapeNodes } from "./utils";
+import { VNodeManager } from "../worker/vNodeManager";
+export interface PencilOptions extends BaseShapeOptions {
+    thickness: number;
+    strokeColor: string;
+    strokeType: EStrokeType;
+}
+export declare class PencilShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    private syncTimestamp;
+    private syncIndex;
+    protected tmpPoints: Array<Point2d>;
+    private MAX_REPEAR;
+    /** 合并原始点的灵敏度 */
+    private uniThickness;
+    protected workOptions: PencilOptions;
+    private centerPos;
+    constructor(props: BaseShapeToolProps);
+    /** 批量合并消费本地数据,返回绘制结果 */
+    combineConsume(): IMainMessage | undefined;
+    setWorkOptions(workOptions: PencilOptions): void;
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage;
+    }): IMainMessage;
+    clearTmpPoints(): void;
+    consumeService(params: {
+        op: number[];
+        isFullWork?: boolean;
+        replaceId?: string;
+        isClearAll?: boolean;
+    }): IRectType | undefined;
+    private transformDataAll;
+    private draw;
+    private computDrawPoints;
+    private computNomal;
+    private computStroke;
+    private computLineStroke;
+    private computDotStroke;
+    private transformData;
+    /** 压力渐变公式 */
+    private computRadius;
+    private getMinZ;
+    private getTaskPoints;
+    private updateTempPointsWithPressure;
+    private updateTempPoints;
+    private updateTempPointsWithPressureWhenDone;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}

package/dist/core/tools/polygon.d.ts

@@ -0,0 +1,45 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface PolygonOptions extends BaseShapeOptions {
+    thickness: number;
+    vertices: number;
+    strokeColor: string;
+    fillColor: string;
+}
+export declare class PolygonShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: PolygonOptions;
+    oldRect?: IRectType;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+    }): IMainMessage;
+    private draw;
+    private computDrawPoints;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}

package/dist/core/tools/rectangle.d.ts

@@ -0,0 +1,46 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface RectangleOptions extends BaseShapeOptions {
+    thickness: number;
+    strokeColor: string;
+    fillColor: string;
+}
+export declare class RectangleShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: RectangleOptions;
+    oldRect?: IRectType;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    private transformData;
+    private computDrawPoints;
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+    }): IMainMessage;
+    private draw;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+        replaceId?: string;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}

package/dist/core/tools/selector.d.ts

@@ -0,0 +1,83 @@
+import { Scene } from "spritejs";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt, IServiceWorkItem } from "../types";
+import { Point2d } from "../utils/primitives/Point2d";
+import { VNodeManager } from "../worker/vNodeManager";
+import { TextOptions } from "../../component/textEditor/types";
+import { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
+import { ShapeOptType } from "../../displayer/types";
+export interface SelectorOptions extends BaseShapeOptions {
+}
+export declare class SelectorShape extends BaseShapeTool {
+    readonly toolsType: EToolsKey;
+    static selectorId: string;
+    static selectorBorderId: string;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: BaseShapeOptions;
+    selectIds?: string[];
+    selectorColor?: string;
+    strokeColor?: string;
+    fillColor?: string;
+    oldSelectRect?: IRectType;
+    canRotate: boolean;
+    canTextEdit: boolean;
+    canLock: boolean;
+    scaleType: EScaleType;
+    toolsTypes?: EToolsKey[];
+    shapeOpt?: ShapeOptType;
+    textOpt?: TextOptions;
+    isLocked?: boolean;
+    constructor(props: BaseShapeToolProps);
+    private computSelector;
+    private updateTempPoints;
+    private drawSelector;
+    private draw;
+    private getSelecteorInfo;
+    getChildrenPoints(): [number, number][] | undefined;
+    consume(props: {
+        data: IWorkerMessage;
+    }): IMainMessage;
+    consumeAll(props?: {
+        hoverId?: string;
+    }): IMainMessage;
+    consumeService(): undefined;
+    clearTmpPoints(): void;
+    clearSelectData(): void;
+    private selectSingleTool;
+    private backToFullLayer;
+    private sealToDrawLayer;
+    private getSelectorRect;
+    isCanFillColor(toolsType?: EToolsKey): boolean;
+    updateSelector(param: {
+        updateSelectorOpt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        selectIds?: string[];
+        willSerializeData?: boolean;
+        worker?: LocalWorkForFullWorker;
+        offset?: [number, number];
+        scene?: Scene;
+    }): Promise<IMainMessage | undefined>;
+    blurSelector(): {
+        type: EPostMessageType;
+        dataType: EDataType;
+        rect: IRectType | undefined;
+        selectIds: never[];
+        willSyncService: boolean;
+    };
+    private getRightServiceId;
+    selectServiceNode(workId: string, workItem: Pick<IServiceWorkItem, 'selectIds'>, isService: boolean): IRectType | undefined;
+    reRenderSelector(): IRectType | undefined;
+    updateSelectIds(nextSelectIds: string[]): {
+        bgRect: IRectType | undefined;
+        selectRect: IRectType | undefined;
+    };
+    cursorHover(point: [number, number]): {
+        type: EPostMessageType;
+        dataType: EDataType;
+        rect: IRectType | undefined;
+        selectorColor: string | undefined;
+        willSyncService: boolean;
+    } | undefined;
+    cursorBlur(): void;
+}

package/dist/core/tools/speechBalloon.d.ts

@@ -0,0 +1,49 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import type { SpeechBalloonPlacement } from "../../plugin/types";
+import { ShapeNodes } from "./utils";
+export interface SpeechBalloonOptions extends BaseShapeOptions {
+    thickness: number;
+    placement: SpeechBalloonPlacement;
+    strokeColor: string;
+    fillColor: string;
+}
+export declare class SpeechBalloonShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    readonly ratio: number;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: SpeechBalloonOptions;
+    oldRect?: IRectType;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+        vNodes: VNodeManager;
+    }): IMainMessage;
+    private draw;
+    private transformControlPoints;
+    private computDrawPoints;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}

package/dist/core/tools/star.d.ts

@@ -0,0 +1,47 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface StarOptions extends BaseShapeOptions {
+    thickness: number;
+    vertices: number;
+    innerVerticeStep: number;
+    innerRatio: number;
+    strokeColor: string;
+    fillColor: string;
+}
+export declare class StarShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: StarOptions;
+    oldRect?: IRectType;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+    }): IMainMessage;
+    private draw;
+    private computDrawPoints;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}

package/dist/core/tools/straight.d.ts

@@ -0,0 +1,46 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface StraightOptions extends BaseShapeOptions {
+    thickness: number;
+    strokeColor: string;
+}
+export declare class StraightShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: StraightOptions;
+    oldRect?: IRectType;
+    private straightTipWidth;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+    }): IMainMessage;
+    private draw;
+    private computDrawPoints;
+    private computFullPoints;
+    private computDotPoints;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}