@netless/appliance-plugin 1.0.0 → 1.0.2

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

@@ -1,8 +1,8 @@
-import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
-import { EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
-import { VNodeManager } from "../worker/vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import type { SpeechBalloonPlacement } from "../../plugin/types";
 import { ShapeNodes } from "./utils";
 export interface SpeechBalloonOptions extends BaseShapeOptions {
@@ -27,11 +27,39 @@ export declare class SpeechBalloonShape extends BaseShapeTool {
         isClearAll?: boolean;
         isSubWorker?: boolean;
         isMainThread?: boolean;
-    }): IMainMessage;
-    consumeAll(props: {
-        data?: IWorkerMessage | undefined;
-        vNodes: VNodeManager;
-    }): IMainMessage;
+    }): {
+        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;
+    };
+    consumeAll(): {
+        type: EPostMessageType;
+        removeIds: string[];
+    } | {
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
+        rect: IRectType;
+        type: EPostMessageType;
+        dataType: EDataType;
+        ops: string;
+        isSync: boolean;
+        removeIds?: undefined;
+    };
     private draw;
     private transformControlPoints;
     private computDrawPoints;

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

@@ -1,8 +1,8 @@
-import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
-import { EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
-import { VNodeManager } from "../worker/vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import { ShapeNodes } from "./utils";
 export interface StarOptions extends BaseShapeOptions {
     thickness: number;
@@ -26,10 +26,39 @@ export declare class StarShape extends BaseShapeTool {
         isFullWork?: boolean;
         isSubWorker?: boolean;
         isMainThread?: boolean;
-    }): IMainMessage;
-    consumeAll(props: {
-        data?: IWorkerMessage | undefined;
-    }): IMainMessage;
+    }): {
+        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;
+    };
+    consumeAll(): {
+        type: EPostMessageType;
+        removeIds: string[];
+    } | {
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
+        rect: IRectType;
+        type: EPostMessageType;
+        dataType: EDataType;
+        ops: string;
+        isSync: boolean;
+        removeIds?: undefined;
+    };
     private draw;
     private computDrawPoints;
     private updateTempPoints;

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

@@ -1,8 +1,8 @@
-import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
-import { EScaleType, EToolsKey } from "../enum";
+import { IWorkerMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
-import { VNodeManager } from "../worker/vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import { ShapeNodes } from "./utils";
 export interface StraightOptions extends BaseShapeOptions {
     thickness: number;
@@ -24,10 +24,39 @@ export declare class StraightShape extends BaseShapeTool {
         isClearAll?: boolean;
         isSubWorker?: boolean;
         isMainThread?: boolean;
-    }): IMainMessage;
-    consumeAll(props: {
-        data?: IWorkerMessage | undefined;
-    }): IMainMessage;
+    }): {
+        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;
+    };
+    consumeAll(): {
+        type: EPostMessageType;
+        removeIds: string[];
+    } | {
+        workId: string;
+        toolsType: EToolsKey;
+        opt: import("./utils").ShapeOptions;
+        rect: IRectType;
+        type: EPostMessageType;
+        dataType: EDataType;
+        ops: string;
+        isSync: boolean;
+        removeIds?: undefined;
+    };
     private draw;
     private computDrawPoints;
     private computFullPoints;

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

@@ -1,12 +1,14 @@
-import { Group, Label, Polyline } from "spritejs";
-import { BaseNodeMapItem, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
-import { EScaleType, EToolsKey } from "../enum";
+import { Group, Label, Polyline, Sprite } from "spritejs";
+import { BaseNodeMapItem, IRectType, IUpdateNodeOpt } from "../types";
+import { EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { Point2d } from "../utils/primitives/Point2d";
 import { BaseShapeTool, BaseShapeToolProps } from "./base";
 import { TextOptions } from "../../component/textEditor";
 import { ShapeNodes } from "./utils";
-import { VNodeManager } from "../worker/vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 export declare class TextShape extends BaseShapeTool {
+    static textImageSnippetSize: number;
+    static SafeBorderPadding: number;
     readonly canRotate: boolean;
     readonly scaleType: EScaleType;
     readonly toolsType: EToolsKey;
@@ -14,20 +16,28 @@ export declare class TextShape extends BaseShapeTool {
     protected workOptions: TextOptions;
     oldRect?: IRectType;
     constructor(props: BaseShapeToolProps);
-    consume(): IMainMessage;
-    consumeAll(): IMainMessage;
+    consume(): {
+        type: EPostMessageType;
+    };
+    consumeAll(): {
+        type: EPostMessageType;
+    };
     consumeService(): IRectType | undefined;
     private draw;
     consumeServiceAsync(props: {
         isFullWork: boolean;
         replaceId?: string;
-        isDrawLabel?: true;
+        isDrawLabel?: boolean;
     }): Promise<IRectType | undefined>;
     updataOptService(): IRectType | undefined;
-    updataOptServiceAsync(updateNodeOpt: IUpdateNodeOpt): Promise<IRectType | undefined>;
+    updataOptServiceAsync(updateNodeOpt: IUpdateNodeOpt, isDrawLabel?: boolean): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
-    static createLabels(textOpt: TextOptions, group: Group, layer?: Group): Promise<(Polyline | Label)[]>;
-    static updateLabels(vNode: BaseNodeMapItem, group: Group, layer?: Group): Promise<void>;
+    static getSafetySnippetRatio(layer: Group): number;
+    static getSafetySnippetFontLength(fontSize: number): number;
+    static createLabels(textOpt: TextOptions, layer: Group, groupRect: IRectType): Promise<{
+        labels: (Group | Polyline | Sprite | Label)[];
+        maxWidth: number;
+    }>;
     static updateNodeOpt(param: {
         node: ShapeNodes;
         opt: IUpdateNodeOpt;

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

@@ -1,6 +1,6 @@
 import { EPostMessageType, EToolsKey } from "../enum";
 import { IRectType } from "../types";
-import type { Ellipse, Group, Path, Polyline, Rect, Sprite } from "spritejs";
+import type { Ellipse, Group, Label, Path, Polyline, Rect, Sprite } from "spritejs";
 import { PencilOptions, PencilShape } from "./pencil";
 import { LaserPenOptions, LaserPenShape } from "./laserPen";
 import { EraserOptions, EraserShape } from "./eraser";
@@ -11,7 +11,7 @@ import { StraightOptions, StraightShape } from "./straight";
 import { EllipseOptions, EllipseShape } from "./ellipse";
 import { PolygonOptions, PolygonShape } from "./polygon";
 import { RectangleOptions, RectangleShape } from "./rectangle";
-import { VNodeManager } from "../worker/vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import { SpeechBalloonOptions, SpeechBalloonShape } from "./speechBalloon";
 import { TextShape } from "./text";
 import { TextOptions } from "../../component/textEditor";
@@ -22,7 +22,7 @@ import { BaseShapeTool } from "./base";
 export type ShapeTools = typeof PencilShape | typeof LaserPenShape | typeof EraserShape | typeof StarShape | typeof SelectorShape | typeof ArrowShape | typeof EllipseShape | typeof RectangleShape | typeof StarShape | typeof PolygonShape | typeof TextShape | typeof SpeechBalloonShape | typeof ImageShape;
 export type ShapeToolsClass = BaseShapeTool | PencilShape | LaserPenShape | EraserShape | StarShape | SelectorShape | ArrowShape | EllipseShape | RectangleShape | StarShape | PolygonShape | TextShape | SpeechBalloonShape | ImageShape;
 export type ShapeOptions = PencilOptions | LaserPenOptions | EraserOptions | StarOptions | SelectorOptions | ArrowOptions | EllipseOptions | RectangleOptions | StarOptions | PolygonOptions | StraightOptions | TextOptions | SpeechBalloonOptions | ImageOptions;
-export type ShapeNodes = Group | Path | Polyline | Rect | Ellipse | Sprite;
+export type ShapeNodes = Group | Path | Polyline | Rect | Ellipse | Sprite | Label;
 export type ServiceThreadSubWork = SubServiceThread | ServiceWorkForFullWorker;
 export interface CombineConsumeResult {
     type: EPostMessageType;
@@ -32,12 +32,13 @@ export interface CombineConsumeResult {
 export interface ShapeStateInfo {
     willClear: boolean;
 }
-export declare function getShapeTools(toolsType: EToolsKey): typeof TextShape | typeof ArrowShape | typeof PencilShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof StarShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof LaserPenShape | typeof EraserShape | typeof SelectorShape | typeof ImageShape | undefined;
+export declare function getShapeTools(toolsType: EToolsKey): typeof PencilShape | typeof LaserPenShape | typeof EraserShape | typeof StarShape | typeof TextShape | typeof SelectorShape | typeof ArrowShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof ImageShape | undefined;
 export declare function getShapeInstance(param: {
+    workId: string;
     toolsType: EToolsKey;
     toolsOpt: ShapeOptions;
     vNodes?: VNodeManager;
     fullLayer: Group;
     drawLayer?: Group;
-}, serviceWork?: ServiceThreadSubWork): TextShape | ArrowShape | PencilShape | StraightShape | EllipseShape | PolygonShape | StarShape | RectangleShape | SpeechBalloonShape | LaserPenShape | EraserShape | SelectorShape | ImageShape | undefined;
+}, serviceWork?: ServiceThreadSubWork): PencilShape | LaserPenShape | EraserShape | StarShape | TextShape | SelectorShape | ImageShape | ArrowShape | StraightShape | EllipseShape | PolygonShape | RectangleShape | SpeechBalloonShape | undefined;
 export declare function findShapeBody(nodes: ShapeNodes[]): ShapeNodes[];

package/dist/core/types.d.ts

@@ -177,7 +177,7 @@ export interface IMainMessage extends INormalPushMsg {
     isLocked?: boolean;
     shapeOpt?: ShapeOptType;
     toolsTypes?: EToolsKey[];
-    waitWorker?: boolean;
+    isLockSentEventCursor?: boolean;
 }
 export interface IMainMessageRenderData {
     viewId: string;

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

@@ -1,3 +1,5 @@
+import { EMatrixrRelationType } from '../enum';
+import { IRectType } from '../types';
 import { Box2d } from './primitives/Box2d';
 import { Vec2d, VecLike } from './primitives/Vec2d';
 export * from "./math";
@@ -362,3 +364,11 @@ export declare function toFixed(v: number): number;
 export declare const isSafeFloat: (n: number) => boolean;
 export declare const requestAsyncCallBack: (callBack: () => void, timeout: number) => Promise<void>;
 export declare const getRatioWithContext: (context?: CanvasRenderingContext2D) => number;
+export declare const getRectMatrixrRelation: (rect: IRectType, BoxRect: IRectType) => EMatrixrRelationType;
+export declare function strlen(str: string): number;
+export declare const getInSertRect: (rect: IRectType, boxRect: IRectType) => {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+} | undefined;

package/dist/core/utils/math.d.ts

@@ -58,3 +58,4 @@ export declare function getNodeRect(key: string, layer?: Group, safeBorderPaddin
 export declare function isIntersectForPoint(point: [number, number], rect: IRectType): boolean;
 export declare const getLineSegIntersection: (p1: [number, number], p2: [number, number], p3: [number, number], p4: [number, number]) => [number, number] | null;
 export declare function getWHRatio(w: number, h: number): [number, number];
+export declare function checkOp(op: number[]): boolean;

package/dist/core/{mainThread/vNodeManager.d.ts → vNodeManager.d.ts}

@@ -1,14 +1,17 @@
 import { Group, Scene } from "spritejs";
-import { BaseNodeMapItem, IRectType } from "../types";
+import { BaseNodeMapItem, IRectType } from "./types";
+import { EToolsKey } from ".";
 export declare class VNodeManager {
     viewId: string;
     scene: Scene;
     fullLayer?: Group;
     curNodeMap: Map<string, BaseNodeMapItem>;
     targetNodeMap: Map<string, BaseNodeMapItem>[];
+    private highLevelIds?;
     constructor(viewId: string, scene: Scene);
     init(fullLayer: Group): void;
     get(name: string): BaseNodeMapItem | undefined;
+    getNodesByType(type: EToolsKey): Map<string, BaseNodeMapItem>;
     hasRenderNodes(): boolean;
     has(name: string): boolean;
     setInfo(name: string, info: Partial<BaseNodeMapItem>): void;
@@ -17,12 +20,15 @@ export declare class VNodeManager {
     delete(name: string): void;
     clear(): void;
     hasRectIntersectRange(rect: IRectType, filterLock?: boolean): boolean;
-    getRectIntersectRange(rect: IRectType, filterLock?: boolean): {
+    getRectIntersectRange(rect: IRectType, filterLock?: boolean, filterEditor?: boolean): {
         rectRange: IRectType | undefined;
         nodeRange: Map<string, BaseNodeMapItem>;
     };
     getNodeRectFormShape(name: string, value: BaseNodeMapItem): IRectType | undefined;
-    updateNodesRect(): void;
+    updateNodeRect(key: string): void;
+    updateHighLevelNodesRect(highLevelIds: Set<string>): void;
+    updateLowLevelNodesRect(): void;
+    clearHighLevelIds(): void;
     combineIntersectRect(rect: IRectType): IRectType;
     setTarget(): number;
     getLastTarget(): Map<string, BaseNodeMapItem>;

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

@@ -1,13 +1,12 @@
 import { Group, Scene } from "spritejs";
 import { IActiveToolsDataType, IActiveWorkDataType, IBatchMainMessage, ICameraOpt, ILayerOptionType, IOffscreenCanvasOptionType, IRectType, IWorkerMessage } from "../types";
-import { VNodeManager } from "./vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import { ECanvasContextType, ECanvasShowType, EDataType, EvevtWorkState } from "../enum";
-import { ShapeStateInfo } from "../tools/utils";
 import { BaseShapeOptions, BaseShapeTool } from "../tools/base";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
 import { LocalWorkForFullWorker } from "./fullWorkerLocal";
 import { LocalWorkForSubWorker } from "./subWorkerLocal";
-import { WorkThreadEngineForFullWorker, WorkThreadEngineForSubWorker } from "./workerManager";
+import { EWorkThreadType, WorkThreadEngineForFullWorker, WorkThreadEngineForSubWorker } from "./workerManager";
 import { EmitEventType } from "../../plugin/types";
 export interface IWorkerInitOption {
     dpr: number;
@@ -28,6 +27,7 @@ export declare abstract class WorkThreadEngineBase {
     readonly vNodes: VNodeManager;
     readonly dpr: number;
     readonly contextType?: ECanvasContextType;
+    abstract readonly type: EWorkThreadType;
     protected opt: IWorkerInitOption;
     protected cameraOpt?: ICameraOpt;
     protected scene: Scene;
@@ -42,19 +42,21 @@ export declare abstract class WorkThreadEngineBase {
         workName: EmitEventType;
         workState: EvevtWorkState;
     };
-    constructor(viewId: string, opt: IWorkerInitOption);
+    protected delayPostDoneResolve?: (bol: boolean) => void;
+    constructor(viewId: string, opt: IWorkerInitOption, workerType: EWorkThreadType);
     setIsSafari(isSafari: boolean): void;
     on(msg: IWorkerMessage): Promise<void>;
+    protected createLocalWork(data: IWorkerMessage): void;
     protected updateScene(offscreenCanvasOpt: IOffscreenCanvasOptionType): void;
     protected updateLayer(layerOpt: ILayerOptionType): void;
     private getSupportContextType;
     protected createScene(opt: IOffscreenCanvasOptionType): Scene;
     protected createLayer(name: string, scene: Scene, opt: ILayerOptionType): Group;
-    protected clearAll(): void;
+    protected clearAll(): Promise<void>;
     protected setToolsOpt(opt: IActiveToolsDataType): void;
     protected setWorkOpt(opt: Partial<IActiveWorkDataType>): void;
     protected destroy(): void;
-    post(msg: IBatchMainMessage): void;
+    post(msg: IBatchMainMessage): Promise<void>;
     private runBatchPostData;
     protected combinePostData(): IBatchMainMessage;
     protected safariFixRect(rect: IRectType): IRectType | undefined;
@@ -62,8 +64,9 @@ export declare abstract class WorkThreadEngineBase {
     abstract combinePost(): Promise<void>;
     protected abstract getLayer(workLayer: ECanvasShowType): Group | undefined;
     abstract setCameraOpt(cameraOpt: ICameraOpt): void;
-    abstract consumeDraw(type: EDataType, data: IWorkerMessage): void;
-    abstract consumeDrawAll(type: EDataType, data: IWorkerMessage): void;
+    abstract consumeDraw(type: EDataType, data: IWorkerMessage): Promise<void>;
+    abstract consumeDrawAll(type: EDataType, data: IWorkerMessage): Promise<void>;
+    abstract updateCamera(msg: IWorkerMessage): Promise<void>;
 }
 export declare abstract class LocalWork {
     readonly viewId: string;
@@ -71,24 +74,23 @@ export declare abstract class LocalWork {
     readonly thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker;
     fullLayer: Group;
     drawLayer?: Group;
-    readonly _post: (msg: IBatchMainMessage) => void;
-    protected tmpWorkShapeNode?: BaseShapeTool;
+    readonly _post: (msg: IBatchMainMessage) => Promise<void>;
     protected tmpOpt?: IActiveToolsDataType;
     workShapes: Map<string, BaseShapeTool>;
-    workShapeState: Map<string, ShapeStateInfo>;
     protected drawCount: number;
+    protected syncUnitTime: number;
     constructor(opt: ISubWorkerInitOption);
     destroy(): void;
     getWorkShapes(): Map<string, BaseShapeTool>;
     getWorkShape(workId: string): BaseShapeTool | undefined;
-    getTmpWorkShapeNode(): BaseShapeTool | undefined;
-    setTmpWorkId(workId: string | undefined): void;
+    createWorkShape(workId: string, opt?: BaseShapeOptions): void;
     setWorkOptions(workId: string, opt: BaseShapeOptions): void;
     createWorkShapeNode(opt: IActiveToolsDataType & {
-        workId?: string;
-    }): import("../tools/text").TextShape | import("../tools").ArrowShape | import("../tools").PencilShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").StarShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | undefined;
+        workId: string;
+    }): import("../tools").PencilShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").StarShape | import("../tools/text").TextShape | import("../tools").SelectorShape | import("../tools").ImageShape | import("../tools").ArrowShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | undefined;
     setToolsOpt(opt: IActiveToolsDataType): void;
+    getToolsOpt(): IActiveToolsDataType | undefined;
     clearWorkShapeNodeCache(workId: string): void;
     clearAllWorkShapesCache(): void;
-    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | import("../tools/straight").StraightShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools").LaserPenShape | undefined;
+    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | undefined;
 }

package/dist/core/worker/fullWorkerLocal.d.ts

@@ -1,4 +1,4 @@
-import { IWorkerMessage, IMainMessage, IRectType, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType } from "..";
+import { IWorkerMessage, IMainMessage, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType } from "..";
 import { BaseShapeOptions, SelectorShape } from "../tools";
 import { ISubWorkerInitOption, LocalWork } from "./base";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
@@ -6,16 +6,22 @@ import { Scene } from "spritejs";
 export declare class LocalWorkForFullWorker extends LocalWork {
     private combineUnitTime;
     private combineTimerId?;
+    private combineDrawResolve?;
+    private combineDrawActiveId?;
+    protected drawWorkActiveId?: string;
     private effectSelectNodeData;
     private batchEraserWorks;
     private batchEraserRemoveNodes;
     constructor(opt: ISubWorkerInitOption);
-    consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
-    consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
-    workShapesDone(scenePath: string, serviceWork: ServiceWorkForFullWorker): void;
+    consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
+    workShapesDone(scenePath: string, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     consumeFull(data: IWorkerMessage, scene?: Scene): Promise<void>;
-    removeWork(data: IWorkerMessage): void;
-    removeNode(key: string): IRectType | undefined;
+    private commandDeleteText;
+    removeSelector(data: IWorkerMessage): Promise<void>;
+    removeWork(data: IWorkerMessage): Promise<void>;
+    private removeNode;
+    private _removeWork;
     checkTextActive(data: IWorkerMessage): Promise<void>;
     colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;
     updateSelector(params: IUpdateSelectorPropsType & {
@@ -32,8 +38,10 @@ export declare class LocalWorkForFullWorker extends LocalWork {
         }) => void;
     }): Promise<IMainMessage | undefined>;
     blurSelector(data?: IWorkerMessage): Promise<void>;
-    reRenderSelector(willSyncService?: boolean): Promise<void> | undefined;
-    updateFullSelectWork(data: IWorkerMessage): void;
+    hasSelector(): boolean;
+    getSelector(): SelectorShape;
+    reRenderSelector(willSyncService?: boolean): Promise<void>;
+    updateFullSelectWork(data: IWorkerMessage): Promise<void>;
     destroy(): void;
     private drawPencilCombine;
     private drawSelector;
@@ -43,5 +51,6 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     private drawPencilFull;
     private updateBatchEraserCombineNode;
     private runEffectSelectWork;
-    cursorHover(msg: IWorkerMessage): void;
+    cursorHover(msg: IWorkerMessage): Promise<void>;
+    cursorBlur(): Promise<void>;
 }

package/dist/core/worker/fullWorkerService.d.ts

@@ -1,9 +1,10 @@
 import { Group } from "spritejs";
 import { ISubWorkerInitOption } from "./base";
-import { VNodeManager } from "./vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import { IBatchMainMessage, IServiceWorkItem, IWorkerMessage } from "../types";
 import { EToolsKey } from "../enum";
 import { BaseShapeOptions } from "../tools";
+import { WorkThreadEngineForFullWorker } from "./workerManager";
 export interface ServiceWork {
     readonly viewId: string;
     readonly vNodes: VNodeManager;
@@ -11,12 +12,11 @@ export interface ServiceWork {
     readonly drawLayer: Group;
     readonly post: (msg: IBatchMainMessage) => void;
     selectorWorkShapes: Map<string, IServiceWorkItem>;
-    clearAllWorkShapesCache(): void;
     runSelectWork(data: IWorkerMessage): void;
     consumeDraw(data: IWorkerMessage): void;
-    setNodeKey(workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
+    setNodeKey(workId: string, workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
     runReverseSelectWork(selectIds: string[]): void;
-    removeWork(data: IWorkerMessage): void;
+    removeWork(data: IWorkerMessage): Promise<void>;
     removeSelectWork(data: IWorkerMessage): void;
     runSelectWork(data: IWorkerMessage): void;
     consumeFull(data: IWorkerMessage): void;
@@ -30,20 +30,21 @@ export declare class ServiceWorkForFullWorker implements ServiceWork {
     drawLayer: Group;
     workShapes: Map<string, IServiceWorkItem>;
     selectorWorkShapes: Map<string, IServiceWorkItem>;
+    thread: WorkThreadEngineForFullWorker;
     protected animationId?: number | undefined;
     private willRunEffectSelectorIds;
     private runEffectId?;
     private noAnimationRect;
-    post: (msg: IBatchMainMessage) => void;
+    private syncUnitTime;
+    post: (msg: IBatchMainMessage) => Promise<void>;
     constructor(opt: ISubWorkerInitOption);
     destroy(): void;
-    consumeDraw(data: IWorkerMessage): void;
+    consumeDraw(data: IWorkerMessage): Promise<void>;
     consumeFull(data: IWorkerMessage): void;
-    clearAllWorkShapesCache(): void;
     runSelectWork(data: IWorkerMessage): void;
-    setNodeKey(workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
+    setNodeKey(workId: string, workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
     runReverseSelectWork(selectIds: string[]): void;
-    removeWork(data: IWorkerMessage): void;
+    removeWork(data: IWorkerMessage): Promise<void>;
     removeSelectWork(data: IWorkerMessage): void;
     private removeNode;
     private activeWorkShape;

package/dist/core/worker/subWorkerLocal.d.ts

@@ -1,17 +1,14 @@
-import { Group } from "spritejs";
-import { IWorkerMessage, IRectType, IMainMessage } from "..";
-import { BaseCollectorReducerAction } from "../../collector/types";
+import { IWorkerMessage, IRectType } from "..";
 import { LocalWork, ISubWorkerInitOption } from "./base";
 export declare class LocalWorkForSubWorker extends LocalWork {
-    protected combineDrawTimer?: number;
+    private drawWorkActiveId?;
     constructor(opt: ISubWorkerInitOption);
     runFullWork(data: IWorkerMessage): Promise<IRectType | undefined>;
     runSelectWork(data: IWorkerMessage): undefined;
     workShapesDone(): void;
-    consumeDraw(data: IWorkerMessage): IMainMessage | undefined;
-    consumeDrawAll(data: IWorkerMessage): undefined;
-    updateLabels(labelGroup: Group, value: BaseCollectorReducerAction): void;
-    removeWork(data: IWorkerMessage): void;
+    consumeDraw(data: IWorkerMessage): Promise<void>;
+    consumeDrawAll(data: IWorkerMessage): Promise<void>;
+    removeWork(data: IWorkerMessage): Promise<void>;
     private removeNode;
     private drawPencil;
     private drawArrow;

package/dist/core/worker/subWorkerTopLayer.d.ts

@@ -1,13 +1,15 @@
 import { Group } from "spritejs";
-import { BaseShapeOptions, BaseShapeTool } from "../tools";
+import { BaseShapeOptions } from "../tools";
 import { ISubWorkerInitOption } from "./base";
-import { VNodeManager } from "./vNodeManager";
+import { VNodeManager } from "../vNodeManager";
 import { IActiveToolsDataType, IBatchMainMessage, ILocalWorkItem, IServiceWorkItem, IWorkerMessage } from "../types";
+import { EToolsKey } from "../enum";
+import { WorkThreadEngineForSubWorker } from "./workerManager";
 export interface TopLayerWork {
     readonly viewId: string;
     readonly vNodes: VNodeManager;
     readonly topLayer: Group;
-    readonly post: (msg: IBatchMainMessage) => void;
+    readonly post: (msg: IBatchMainMessage) => Promise<void>;
     consumeDraw(data: IWorkerMessage): void;
     consumeDrawAll(data: IWorkerMessage): void;
     destroy(): void;
@@ -16,22 +18,24 @@ export declare class TopLayerWorkForSubWorker implements TopLayerWork {
     viewId: string;
     vNodes: VNodeManager;
     topLayer: Group;
-    post: (msg: IBatchMainMessage) => void;
+    readonly thread: WorkThreadEngineForSubWorker;
+    post: (msg: IBatchMainMessage) => Promise<void>;
     serviceWorkShapes: Map<string, IServiceWorkItem>;
     localWorkShapes: Map<string, ILocalWorkItem>;
     protected tmpOpt?: IActiveToolsDataType;
-    protected tmpWorkShapeNode?: BaseShapeTool;
+    private syncUnitTime;
     protected animationId?: number | undefined;
     constructor(opt: ISubWorkerInitOption);
+    canUseTopLayer(toolsType: EToolsKey): boolean;
     getWorkShape(workId: string): ILocalWorkItem | undefined;
-    getTmpWorkShapeNode(): BaseShapeTool | undefined;
-    setTmpWorkId(workId: string | undefined): void;
+    createWorkShape(workId: string, opt?: BaseShapeOptions): import("../tools").PencilShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").StarShape | import("../tools/text").TextShape | import("../tools").SelectorShape | import("../tools").ImageShape | import("../tools").ArrowShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | undefined;
     setWorkOptions(workId: string, opt: BaseShapeOptions): void;
     createWorkShapeNode(opt: IActiveToolsDataType & {
-        workId?: string;
-    }): import("../tools/text").TextShape | import("../tools").ArrowShape | import("../tools").PencilShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").StarShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | undefined;
+        workId: string;
+    }): import("../tools").PencilShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").StarShape | import("../tools/text").TextShape | import("../tools").SelectorShape | import("../tools").ImageShape | import("../tools").ArrowShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | undefined;
     clearAllWorkShapesCache(): void;
     setToolsOpt(opt: IActiveToolsDataType): void;
+    getToolsOpt(): IActiveToolsDataType | undefined;
     consumeDraw(data: IWorkerMessage): void;
     consumeDrawAll(data: IWorkerMessage): void;
     destroy(): void;