@netless/appliance-plugin 1.1.2 → 1.1.3-4.beta.0

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

@@ -1,15 +1,19 @@
 import { IRectType, IUpdateNodeOpt, BaseNodeMapItem } from "../types";
-import { EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { EImageType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { VNodeManager } from "../vNodeManager";
 import { ShapeNodes } from "./utils";
 import type { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
-import type { SubLocalThreadImpl } from "../mainThread/subLocalThread";
+import type { SubLocalMainThreadImpl } from "../mainThread/subLocalThread";
 import type { SnapshotThreadImpl } from "../mainThread/snapshotThread";
-import type { SubServiceThreadImpl } from "../mainThread/subServiceThread";
-import type { WorkThreadEngineForFullWorker, WorkThreadEngineForSubWorker } from "../worker/workerManager";
+import type { SubServiceMainThreadImpl } from "../mainThread/subServiceThread";
+import { type WorkThreadEngineForFullWorker, type WorkThreadEngineForSimpleWorker, WorkThreadEngineForSubWorker } from "../worker/workerManager";
 export interface ImageOptions extends BaseShapeOptions {
+    /** 图片地址 */
+    src: string;
+    /** 图片类型  */
+    type: EImageType;
     /** 图片的唯一识别符 */
     uuid: string;
     /** 图片中点在世界坐标系中的 x 坐标 */
@@ -26,8 +30,6 @@ export interface ImageOptions extends BaseShapeOptions {
     uniformScale?: boolean;
     /** 是否以跨域方式加载图片 */
     crossOrigin?: boolean | string;
-    /** 图片地址 */
-    src: string;
 }
 export declare class ImageShape extends BaseShapeTool {
     readonly canRotate: boolean;
@@ -47,7 +49,7 @@ export declare class ImageShape extends BaseShapeTool {
     consumeService(): IRectType | undefined;
     consumeServiceAsync(props: {
         isFullWork: boolean;
-        worker: LocalWorkForFullWorker | WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker | SubLocalThreadImpl | SnapshotThreadImpl | SubServiceThreadImpl;
+        worker: WorkThreadEngineForSimpleWorker | LocalWorkForFullWorker | WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker | SubLocalMainThreadImpl | SnapshotThreadImpl | SubServiceMainThreadImpl;
         replaceId?: string;
     }): Promise<IRectType | undefined>;
     clearTmpPoints(): void;

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

@@ -1,13 +1,14 @@
-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';
+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";
+export * from "./pencilEraserBitMap";

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

@@ -7,7 +7,7 @@ export interface LaserPenOptions extends BaseShapeOptions {
     thickness: number;
     duration: number;
     strokeColor: string;
-    strokeType: Omit<EStrokeType, 'Stroke'>;
+    strokeType: Omit<EStrokeType, "Stroke">;
 }
 export declare class LaserPenShape extends BaseShapeTool {
     readonly toolsType: EToolsKey;

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

@@ -1,5 +1,5 @@
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
-import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey, EventWorkState } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
 import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
 import { EStrokeType } from "../../plugin/types";
@@ -9,10 +9,13 @@ export interface PencilOptions extends BaseShapeOptions {
     thickness: number;
     strokeColor: string;
     strokeType: EStrokeType;
+    autoShape?: boolean;
+    /** 仅用于本地预览，不向 collector 同步中间态 */
+    previewLocalOnly?: boolean;
 }
 export declare class PencilShape extends BaseShapeTool {
     readonly canRotate: boolean;
-    readonly scaleType: EScaleType;
+    scaleType: EScaleType;
     readonly toolsType: EToolsKey;
     private syncTimestamp;
     private syncIndex;
@@ -30,25 +33,26 @@ export declare class PencilShape extends BaseShapeTool {
         data: IWorkerMessage;
         isFullWork?: boolean;
         isSubWorker?: boolean;
+        isSimpleWorker?: boolean;
         drawCount?: number;
         isMainThread?: boolean;
-        replaceId?: string;
+        removeDrawCount?: number;
     }): {
-        rect: IRectType | undefined;
-        type: EPostMessageType;
-        dataType: EDataType;
-    } | {
         type: EPostMessageType;
         dataType: EDataType;
-        rect: IRectType | undefined;
         op: number[] | undefined;
         index: number | undefined;
+        rect: IRectType | undefined;
         updateNodeOpt: {
             useAnimation: boolean;
         };
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
+    } | {
+        rect: IRectType | undefined;
+        type: EPostMessageType;
+        dataType: EDataType;
     };
     consumeAll(props: {
         data?: IWorkerMessage;
@@ -75,7 +79,13 @@ export declare class PencilShape extends BaseShapeTool {
         op: number[];
         isFullWork?: boolean;
         replaceId?: string;
+        workState?: EventWorkState;
     }): IRectType | undefined;
+    computPencilPoints(params: {
+        op: number[];
+        eraserPolylines: number[][];
+        eraserThickness: number;
+    }): number[][] | undefined;
     private transformDataAll;
     private draw;
     private computDrawPoints;

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

@@ -1,7 +1,10 @@
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
-import { EPostMessageType, EScaleType, EToolsKey } from "../enum";
-import { IWorkerMessage, IRectType, IworkId } from "../types";
-import type { ServiceThreadSubWork } from "./utils";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IRectType, BaseNodeMapItem } from "../types";
+import type { IMainMessage } from "../types";
+import { Point2d } from "../utils/primitives/Point2d";
+import type { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
+import type { SubLocalMainThreadImpl } from "../mainThread/subLocalThread";
 export interface PencilEraserOptions extends BaseShapeOptions {
     thickness: number;
 }
@@ -9,66 +12,58 @@ export declare class PencilEraserShape extends BaseShapeTool {
     readonly canRotate: boolean;
     readonly scaleType: EScaleType;
     readonly toolsType: EToolsKey;
-    readonly serviceWork?: ServiceThreadSubWork;
     private static readonly eraserSizes;
-    protected tmpPoints: Array<number>;
+    protected tmpPoints: Array<Point2d>;
     protected workOptions: PencilEraserOptions;
     worldPosition: [number, number];
     worldScaling: [number, number];
     eraserRect: IRectType | undefined;
     eraserPolyline?: [number, number, number, number];
-    constructor(props: BaseShapeToolProps, serviceWork?: ServiceThreadSubWork);
-    consumeService(): IRectType | undefined;
-    private createEraserRect;
-    private computRectCenterPoints;
-    private isNear;
-    private cutPolyline;
-    private isSamePoint;
-    private translateIntersect;
-    private isLineEraser;
-    private remove;
+    constructor(props: BaseShapeToolProps);
+    /** 批量合并消费本地数据,返回绘制结果 */
+    combineConsume(props: {
+        workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
+    }): IMainMessage | undefined;
+    consumeService(): undefined;
+    private updateTempPoints;
+    private getChangeNodes;
     consume(props: {
         data: IWorkerMessage;
+        isFullWork: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
+        drawCount?: number;
+        removeDrawCount?: number;
     }): {
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
         type: EPostMessageType;
-        rect?: undefined;
-        removeIds?: undefined;
-        newWorkDatas?: undefined;
-    } | {
-        type: EPostMessageType;
-        rect: IRectType;
-        removeIds: string[];
-        newWorkDatas: Map<string, {
-            op: number[];
-            opt: BaseShapeOptions;
-            workId: IworkId;
-            toolsType: EToolsKey;
-        }>;
     };
+    private computEraserPointLines;
     consumeAll(props: {
-        data: IWorkerMessage;
+        workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
     }): {
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
         type: EPostMessageType;
-        rect?: undefined;
-        removeIds?: undefined;
-        newWorkDatas?: undefined;
     } | {
+        rect: IRectType | undefined;
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
         type: EPostMessageType;
-        rect: IRectType;
-        removeIds: string[];
-        newWorkDatas: Map<string, {
-            op: number[];
-            opt: BaseShapeOptions;
-            workId: IworkId;
-            toolsType: EToolsKey;
-        }>;
+    } | {
+        type: EPostMessageType;
+        dataType: EDataType;
+        rect: IRectType | undefined;
+        ops: string;
+        willNewNodes: Map<string, BaseNodeMapItem>;
+        willDeleteNodes: Set<string>;
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
     };
     clearTmpPoints(): void;
-    private getCanEraserNodeMap;
 }

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

@@ -1,14 +1,16 @@
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { IWorkerMessage, IRectType, BaseNodeMapItem } from "../types";
+import type { IMainMessage } from "../types";
 import { Point2d } from "../utils/primitives/Point2d";
 import type { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
-import type { SubLocalThreadImpl } from "../mainThread/subLocalThread";
-export type SerializerEraserLines = Array<SerializerEraserItem>;
+import type { SubLocalMainThreadImpl } from "../mainThread/subLocalThread";
 export interface SerializerEraserItem {
     op: number[][];
     thickness: number;
+    workId: string;
 }
+export type SerializerEraserLines = Array<SerializerEraserItem>;
 export interface BitMapEraserOptions extends BaseShapeOptions {
     thickness: number;
 }
@@ -23,42 +25,32 @@ export declare class BitMapEraserShape extends BaseShapeTool {
     worldScaling: [number, number];
     eraserRect: IRectType | undefined;
     eraserPolyline?: [number, number, number, number];
-    syncUnitTime: number;
-    private syncIndex;
-    private syncTimestamp;
+    oldRect: IRectType | undefined;
     constructor(props: BaseShapeToolProps);
-    consumeService(params: {
-        op: number[];
-        isFullWork?: boolean;
-    }): IRectType | undefined;
+    /** 批量合并消费本地数据,返回绘制结果 */
+    combineConsume(props: {
+        workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
+    }): IMainMessage | undefined;
+    consumeService(): undefined;
     private updateTempPoints;
     private getChangeNodes;
-    reRenderEffectNodes(props: {
-        willUpdateNodes: Map<string, BaseNodeMapItem>;
-        worker: LocalWorkForFullWorker | SubLocalThreadImpl;
-    }): Promise<IRectType | undefined>;
     consume(props: {
         data: IWorkerMessage;
+        isFullWork: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
+        drawCount?: number;
+        removeDrawCount?: number;
     }): {
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
         type: EPostMessageType;
-    } | {
-        type: EPostMessageType;
-        dataType: EDataType;
-        rect: IRectType | undefined;
-        op: number[] | undefined;
-        index: number | undefined;
-        updateNodeOpt: {
-            useAnimation: boolean;
-        };
-        workId: string;
-        toolsType: EToolsKey;
-        opt: import("./utils").ShapeOptions;
     };
-    private draw;
-    consumeAll(): {
+    private computEraserPointLines;
+    consumeAll(props: {
+        workerEngine?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
+    }): {
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
@@ -75,6 +67,7 @@ export declare class BitMapEraserShape extends BaseShapeTool {
         rect: IRectType | undefined;
         ops: string;
         willUpdateNodes: Map<string, BaseNodeMapItem>;
+        willDeleteNodes: Set<string>;
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;

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

@@ -1,7 +1,7 @@
 import { IWorkerMessage, IRectType, IUpdateNodeOpt } from "../types";
-import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey, EventWorkState } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
-import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { BaseConsumeResultType, BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { VNodeManager } from "../vNodeManager";
 import { ShapeNodes } from "./utils";
 import { EStrokeType } from "../../plugin/types";
@@ -14,7 +14,7 @@ export interface PolygonOptions extends BaseShapeOptions {
 }
 export declare class PolygonShape extends BaseShapeTool {
     readonly canRotate: boolean;
-    readonly scaleType: EScaleType;
+    scaleType: EScaleType;
     readonly toolsType: EToolsKey;
     protected tmpPoints: Array<Point2d>;
     protected workOptions: PolygonOptions;
@@ -27,29 +27,16 @@ export declare class PolygonShape extends BaseShapeTool {
         isClearAll?: boolean;
         isSubWorker?: boolean;
         isMainThread?: boolean;
-    }): {
-        type: EPostMessageType;
-    } | {
-        workId: string;
-        toolsType: EToolsKey;
-        opt: import("./utils").ShapeOptions;
-        type: EPostMessageType;
-        dataType: EDataType;
-        op: number[];
-        isSync: boolean;
-        index: number;
-    } | {
-        workId: string;
-        toolsType: EToolsKey;
-        opt: import("./utils").ShapeOptions;
-        rect: IRectType | undefined;
-        type: EPostMessageType;
-        dataType: EDataType;
-    };
+        smoothSync?: boolean;
+        isSimpleWorker?: boolean;
+    }): BaseConsumeResultType;
     consumeAll(): {
         type: EPostMessageType;
         removeIds: string[];
     } | {
+        updateNodeOpt: {
+            useAnimation: boolean;
+        };
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
@@ -66,6 +53,7 @@ export declare class PolygonShape extends BaseShapeTool {
     consumeService(props: {
         op: number[];
         isFullWork: boolean;
+        workState?: EventWorkState;
     }): IRectType | undefined;
     clearTmpPoints(): void;
     static updateNodeOpt(param: {

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

@@ -1,7 +1,7 @@
 import { IWorkerMessage, IRectType, IUpdateNodeOpt } from "../types";
-import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey, EventWorkState } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
-import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { BaseConsumeResultType, BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { VNodeManager } from "../vNodeManager";
 import { ShapeNodes } from "./utils";
 import { EStrokeType } from "../../plugin/types";
@@ -13,7 +13,7 @@ export interface RectangleOptions extends BaseShapeOptions {
 }
 export declare class RectangleShape extends BaseShapeTool {
     readonly canRotate: boolean;
-    readonly scaleType: EScaleType;
+    scaleType: EScaleType;
     readonly toolsType: EToolsKey;
     protected tmpPoints: Array<Point2d>;
     protected workOptions: RectangleOptions;
@@ -28,29 +28,16 @@ export declare class RectangleShape extends BaseShapeTool {
         isClearAll?: boolean;
         isSubWorker?: boolean;
         isMainThread?: boolean;
-    }): {
-        type: EPostMessageType;
-    } | {
-        workId: string;
-        toolsType: EToolsKey;
-        opt: import("./utils").ShapeOptions;
-        type: EPostMessageType;
-        dataType: EDataType;
-        op: number[];
-        isSync: boolean;
-        index: number;
-    } | {
-        workId: string;
-        toolsType: EToolsKey;
-        opt: import("./utils").ShapeOptions;
-        rect: IRectType | undefined;
-        type: EPostMessageType;
-        dataType: EDataType;
-    };
+        smoothSync?: boolean;
+        isSimpleWorker?: boolean;
+    }): BaseConsumeResultType;
     consumeAll(): {
         type: EPostMessageType;
         removeIds: string[];
     } | {
+        updateNodeOpt: {
+            useAnimation: boolean;
+        };
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
@@ -67,6 +54,7 @@ export declare class RectangleShape extends BaseShapeTool {
         op: number[];
         isFullWork: boolean;
         replaceId?: string;
+        workState?: EventWorkState;
     }): IRectType | undefined;
     clearTmpPoints(): void;
     static updateNodeOpt(param: {

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

@@ -1,4 +1,4 @@
-import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { BaseConsumeResultType, 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";
@@ -6,7 +6,7 @@ import type { VNodeManager } from "../vNodeManager";
 import { TextOptions } from "../../component/textEditor/types";
 import { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
 import { ShapeOptType } from "../../displayer/types";
-import type { SubLocalThreadImpl } from "../mainThread/subLocalThread";
+import type { SubLocalMainThreadImpl } from "../mainThread/subLocalThread";
 import { EStrokeType } from "../../plugin";
 export interface SelectorOptions extends BaseShapeOptions {
 }
@@ -14,6 +14,7 @@ export declare class SelectorShape extends BaseShapeTool {
     readonly toolsType: EToolsKey;
     static selectorBorderId: string;
     protected tmpPoints: Array<Point2d>;
+    protected subTmpPoints: Array<Point2d>;
     protected workOptions: BaseShapeOptions;
     vNodes: VNodeManager;
     selectIds?: string[];
@@ -21,6 +22,7 @@ export declare class SelectorShape extends BaseShapeTool {
     strokeColor?: string;
     fillColor?: string;
     oldSelectRect?: IRectType;
+    oldSubSelectRect?: IRectType;
     canRotate: boolean;
     canTextEdit: boolean;
     canLock: boolean;
@@ -41,33 +43,18 @@ export declare class SelectorShape extends BaseShapeTool {
     getChildrenPoints(): [number, number][] | undefined;
     consume(props: {
         data: IWorkerMessage;
-    }): {
+        isSubWorker?: boolean;
+        isSimpleWorker?: boolean;
+    }): BaseConsumeResultType | {
         type: EPostMessageType;
+        rect: undefined;
     } | {
         workId: string;
         toolsType: EToolsKey;
         opt: import("./utils").ShapeOptions;
+        rect: IRectType | undefined;
         type: EPostMessageType;
         dataType: EDataType;
-        rect: IRectType | undefined;
-        selectIds: never[] | string[];
-        selectRect: IRectType | undefined;
-        selectorColor: string | undefined;
-        strokeColor: string | undefined;
-        fillColor: string | undefined;
-        textOpt: TextOptions | undefined;
-        canTextEdit: boolean;
-        canRotate: boolean;
-        canLock: boolean;
-        scaleType: EScaleType;
-        willSyncService: boolean;
-        points: [number, number][] | undefined;
-        isLocked: boolean | undefined;
-        toolsTypes: EToolsKey[] | undefined;
-        shapeOpt: ShapeOptType | undefined;
-        thickness: number | undefined;
-        useStroke: boolean | undefined;
-        strokeType: EStrokeType | undefined;
     };
     consumeAll(): {
         workId: string;
@@ -98,7 +85,38 @@ export declare class SelectorShape extends BaseShapeTool {
         type: EPostMessageType;
     };
     consumeService(): undefined;
+    private updateTempPointsForSubWorker;
+    private computDrawPoints;
+    private drawForSubWorker;
+    private transformData;
+    subWorkerConsume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean;
+    }): {
+        type: EPostMessageType;
+        rect: undefined;
+    } | {
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
+        rect: IRectType | undefined;
+        type: EPostMessageType;
+        dataType: EDataType;
+    };
+    subWorkerConsumeAll(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean;
+    }): {
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
+        rect: IRectType | undefined;
+        type: EPostMessageType;
+        dataType: EDataType;
+    };
+    clearSubTmpPoints(): void;
     clearTmpPoints(): void;
+    clearSubSelectData(): void;
     clearSelectData(): void;
     private selectSingleTool;
     private unSelectedAllIds;
@@ -111,7 +129,7 @@ export declare class SelectorShape extends BaseShapeTool {
         vNodes: VNodeManager;
         selectIds?: string[];
         willSerializeData?: boolean;
-        worker?: LocalWorkForFullWorker | SubLocalThreadImpl;
+        worker?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
         offset?: [number, number];
     }): Promise<IMainMessage | undefined>;
     blurSelector(): {
@@ -122,7 +140,7 @@ export declare class SelectorShape extends BaseShapeTool {
         willSyncService: boolean;
     };
     getRightServiceId(serviceWorkId: string): string;
-    selectServiceNode(workId: string, workItem: Pick<IServiceWorkItem, 'selectIds'>, isService: boolean): IRectType | undefined;
+    selectServiceNode(workId: string, workItem: Pick<IServiceWorkItem, "selectIds">, isService: boolean): IRectType | undefined;
     reRenderSelector(): IRectType | undefined;
     updateSelectIds(nextSelectIds: string[]): {
         bgRect: IRectType | undefined;

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

@@ -0,0 +1,36 @@
+import { IRectType, IUpdateNodeOpt, BaseNodeMapItem, ISVGOptions } from "../types";
+import { EPostMessageType, EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeTool } from "./base";
+import { VNodeManager } from "../vNodeManager";
+import { ShapeNodes } from "./utils";
+import { ISVGShadowShapeToolProps } from "../../component/svg/base";
+export declare class ISvgShadowShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: ISVGOptions;
+    oldRect?: IRectType;
+    constructor(props: ISVGShadowShapeToolProps);
+    consume(): {
+        type: EPostMessageType;
+    };
+    consumeAll(): {
+        type: EPostMessageType;
+    };
+    private draw;
+    consumeService(props: {
+        isFullWork: boolean;
+        replaceId?: string;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static getScaleType(opt: ISVGOptions): EScaleType.all | EScaleType.proportional;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+        targetNode?: BaseNodeMapItem;
+    }): IRectType | undefined;
+}