@netless/appliance-plugin 1.0.0-beta.3 → 1.0.0-beta.4

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

@@ -20,9 +20,10 @@ export declare class ArrowShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -22,7 +22,7 @@ export interface BaseShapeOptions {
     translate?: [number, number];
 }
 export interface BaseShapeToolProps {
-    vNodes: VNodeManager;
+    vNodes?: VNodeManager;
     toolsOpt: ShapeOptions;
     fullLayer: Group;
     drawLayer?: Group;
@@ -34,7 +34,7 @@ export declare abstract class BaseShapeTool {
     readonly abstract canRotate: boolean;
     readonly abstract scaleType: EScaleType;
     syncUnitTime: number;
-    vNodes: VNodeManager;
+    vNodes?: VNodeManager;
     protected drawLayer?: Group;
     protected fullLayer: Group;
     protected workId: number | string | undefined;
@@ -46,11 +46,11 @@ export declare abstract class BaseShapeTool {
         isFullWork?: boolean;
         isClearAll?: boolean;
         isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     /** 消费本地完整数据，返回绘制结果 */
     abstract consumeAll(props: {
         data?: IWorkerMessage;
-        hoverId?: string;
     }): IMainMessage;
     /** 消费服务端数据，返回绘制结果 */
     abstract consumeService(props: {

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

@@ -20,9 +20,10 @@ export declare class EllipseShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -1,7 +1,7 @@
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { EScaleType, EToolsKey } from "../enum";
 import { IWorkerMessage, IMainMessage, IRectType } from "../types";
-import type { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+import type { ServiceThreadSubWork } from "./utils";
 export interface EraserOptions extends BaseShapeOptions {
     thickness: number;
     isLine: boolean;
@@ -10,7 +10,7 @@ export declare class EraserShape extends BaseShapeTool {
     readonly canRotate: boolean;
     readonly scaleType: EScaleType;
     readonly toolsType: EToolsKey;
-    readonly serviceWork?: ServiceWorkForFullWorker;
+    readonly serviceWork?: ServiceThreadSubWork;
     private static readonly eraserSizes;
     protected tmpPoints: Array<number>;
     protected workOptions: EraserOptions;
@@ -18,7 +18,7 @@ export declare class EraserShape extends BaseShapeTool {
     worldScaling: [number, number];
     eraserRect: IRectType | undefined;
     eraserPolyline?: [number, number, number, number];
-    constructor(props: BaseShapeToolProps, serviceWork?: ServiceWorkForFullWorker);
+    constructor(props: BaseShapeToolProps, serviceWork?: ServiceThreadSubWork);
     combineConsume(): undefined;
     consumeService(): IRectType | undefined;
     setWorkOptions(setWorkOptions: EraserOptions): void;

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

@@ -41,6 +41,7 @@ export declare class ImageShape extends BaseShapeTool {
         isFullWork: boolean;
         scene: Scene;
         replaceId?: string;
+        isMainThread?: boolean;
     }): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
     static updateNodeOpt(param: {

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

@@ -31,6 +31,7 @@ export declare class PencilShape extends BaseShapeTool {
         isFullWork?: boolean;
         isClearAll?: boolean;
         isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage;

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

@@ -21,9 +21,10 @@ export declare class PolygonShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -22,9 +22,10 @@ export declare class RectangleShape extends BaseShapeTool {
     private computDrawPoints;
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -3,10 +3,11 @@ 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 type { VNodeManager } from "../worker/vNodeManager";
 import { TextOptions } from "../../component/textEditor/types";
 import { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
 import { ShapeOptType } from "../../displayer/types";
+import type { SubLocalThread } from "../mainThread/subLocalThread";
 export interface SelectorOptions extends BaseShapeOptions {
 }
 export declare class SelectorShape extends BaseShapeTool {
@@ -15,6 +16,7 @@ export declare class SelectorShape extends BaseShapeTool {
     static selectorBorderId: string;
     protected tmpPoints: Array<Point2d>;
     protected workOptions: BaseShapeOptions;
+    vNodes: VNodeManager;
     selectIds?: string[];
     selectorColor?: string;
     strokeColor?: string;
@@ -28,7 +30,7 @@ export declare class SelectorShape extends BaseShapeTool {
     shapeOpt?: ShapeOptType;
     textOpt?: TextOptions;
     isLocked?: boolean;
-    constructor(props: BaseShapeToolProps);
+    constructor(props: Required<BaseShapeToolProps>);
     private computSelector;
     private updateTempPoints;
     private drawSelector;
@@ -38,15 +40,14 @@ export declare class SelectorShape extends BaseShapeTool {
     consume(props: {
         data: IWorkerMessage;
     }): IMainMessage;
-    consumeAll(props?: {
-        hoverId?: string;
-    }): IMainMessage;
+    consumeAll(): IMainMessage;
     consumeService(): undefined;
     clearTmpPoints(): void;
     clearSelectData(): void;
     private selectSingleTool;
-    private backToFullLayer;
-    private sealToDrawLayer;
+    private unSelectedAllIds;
+    private unSelectedByIds;
+    private selectedByIds;
     private getSelectorRect;
     isCanFillColor(toolsType?: EToolsKey): boolean;
     updateSelector(param: {
@@ -54,9 +55,10 @@ export declare class SelectorShape extends BaseShapeTool {
         vNodes: VNodeManager;
         selectIds?: string[];
         willSerializeData?: boolean;
-        worker?: LocalWorkForFullWorker;
+        worker?: LocalWorkForFullWorker | SubLocalThread;
         offset?: [number, number];
         scene?: Scene;
+        isMainThread?: boolean;
     }): Promise<IMainMessage | undefined>;
     blurSelector(): {
         type: EPostMessageType;
@@ -65,7 +67,7 @@ export declare class SelectorShape extends BaseShapeTool {
         selectIds: never[];
         willSyncService: boolean;
     };
-    private getRightServiceId;
+    getRightServiceId(serviceWorkId: string): string;
     selectServiceNode(workId: string, workItem: Pick<IServiceWorkItem, 'selectIds'>, isService: boolean): IRectType | undefined;
     reRenderSelector(): IRectType | undefined;
     updateSelectIds(nextSelectIds: string[]): {

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

@@ -23,9 +23,10 @@ export declare class SpeechBalloonShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -23,9 +23,10 @@ export declare class StarShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -20,9 +20,10 @@ export declare class StraightShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -17,9 +17,13 @@ import { TextShape } from "./text";
 import { TextOptions } from "../../component/textEditor";
 import { ImageOptions, ImageShape } from "./image";
 import type { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+import type { SubServiceThread } from "../mainThread/subServiceThread";
+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 ServiceThreadSubWork = SubServiceThread | ServiceWorkForFullWorker;
 export interface CombineConsumeResult {
     type: EPostMessageType;
     rect: IRectType | undefined;
@@ -28,12 +32,12 @@ export interface CombineConsumeResult {
 export interface ShapeStateInfo {
     willClear: boolean;
 }
-export declare function getShapeTools(toolsType: EToolsKey): typeof PencilShape | typeof LaserPenShape | typeof ArrowShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof StarShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof TextShape | typeof EraserShape | typeof SelectorShape | typeof ImageShape | undefined;
+export declare function getShapeTools(toolsType: EToolsKey): typeof ArrowShape | typeof PencilShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof StarShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof TextShape | typeof LaserPenShape | typeof EraserShape | typeof SelectorShape | typeof ImageShape | undefined;
 export declare function getShapeInstance(param: {
     toolsType: EToolsKey;
     toolsOpt: ShapeOptions;
-    vNodes: VNodeManager;
+    vNodes?: VNodeManager;
     fullLayer: Group;
     drawLayer?: Group;
-}, serviceWork?: ServiceWorkForFullWorker): SelectorShape | PencilShape | LaserPenShape | ArrowShape | StraightShape | EllipseShape | PolygonShape | StarShape | RectangleShape | SpeechBalloonShape | TextShape | EraserShape | ImageShape | undefined;
+}, serviceWork?: ServiceThreadSubWork): ArrowShape | PencilShape | StraightShape | EllipseShape | PolygonShape | StarShape | RectangleShape | SpeechBalloonShape | TextShape | LaserPenShape | EraserShape | SelectorShape | ImageShape | undefined;
 export declare function findShapeBody(nodes: ShapeNodes[]): ShapeNodes[];

package/dist/core/types.d.ts

@@ -179,6 +179,7 @@ export interface IMainMessage extends INormalPushMsg {
     isLocked?: boolean;
     shapeOpt?: ShapeOptType;
     toolsTypes?: EToolsKey[];
+    waitWorker?: boolean;
 }
 export interface IMainMessageRenderData {
     viewId: string;
@@ -191,7 +192,6 @@ export interface IMainMessageRenderData {
     clearCanvas?: ECanvasShowType;
     /** 是否需要销毁imageBitmap */
     isUnClose?: boolean;
-    isFullWork?: boolean;
     workerType?: EDataType.Local | EDataType.Service;
     offset?: {
         x: number;
@@ -263,6 +263,16 @@ export type IServiceWorkItem = {
     totalRect?: IRectType;
     isDiff?: boolean;
 };
+export type ILocalWorkItem = {
+    toolsType: EToolsKey;
+    node: BaseShapeTool;
+    data?: IWorkerMessage;
+    result?: IMainMessage;
+    totalRect?: IRectType;
+    workState: EvevtWorkState;
+    isDel?: boolean;
+    willRefresh?: boolean;
+};
 export type BaseNodeMapItem = {
     name: string;
     rect: IRectType;
@@ -272,6 +282,8 @@ export type BaseNodeMapItem = {
     toolsType: EToolsKey;
     canRotate: boolean;
     scaleType: EScaleType;
+    /** 是否被框选中,框选中的元素不能被其它人操作 */
+    isSelected: boolean;
 };
 export type Size = {
     /**

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

@@ -361,4 +361,4 @@ 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 getRatioWithContext: (context?: CanvasRenderingContext2D) => number;

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

@@ -1,7 +1,7 @@
 import { Group, Scene } from "spritejs";
-import { IActiveToolsDataType, IActiveWorkDataType, IBatchMainMessage, ICameraOpt, ILayerOptionType, IMainMessage, IOffscreenCanvasOptionType, IServiceWorkItem, IWorkerMessage, IworkId } from "../types";
+import { IActiveToolsDataType, IActiveWorkDataType, IBatchMainMessage, ICameraOpt, ILayerOptionType, IOffscreenCanvasOptionType, IRectType, IWorkerMessage, IworkId } from "../types";
 import { VNodeManager } from "./vNodeManager";
-import { EDataType, EToolsKey } from "../enum";
+import { ECanvasShowType, EDataType } from "../enum";
 import { ShapeStateInfo } from "../tools/utils";
 import { BaseShapeOptions, BaseShapeTool } from "../tools/base";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
@@ -18,26 +18,26 @@ export interface ISubWorkerInitOption {
     viewId: string;
     vNodes: VNodeManager;
     fullLayer: Group;
+    topLayer?: Group;
     drawLayer?: Group;
-    post: (msg: IBatchMainMessage) => Promise<void>;
 }
 export declare abstract class WorkThreadEngineBase {
     readonly viewId: string;
     readonly fullLayer: Group;
     readonly vNodes: VNodeManager;
     readonly dpr: number;
-    readonly abstract drawLayer?: Group;
-    readonly abstract snapshotFullLayer?: Group;
     protected opt: IWorkerInitOption;
     protected cameraOpt?: ICameraOpt;
     protected scene: Scene;
     abstract localWork: LocalWorkForFullWorker | LocalWorkForSubWorker;
     abstract serviceWork?: ServiceWorkForFullWorker;
     protected isSafari: boolean;
-    protected abstract _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void;
+    protected abstract _post: (msg: IBatchMainMessage) => void;
+    combinePostMsg: Set<IBatchMainMessage>;
+    protected workerTaskId?: number | undefined;
     constructor(viewId: string, opt: IWorkerInitOption);
     setIsSafari(isSafari: boolean): void;
-    on(msg: IWorkerMessage): void;
+    on(msg: IWorkerMessage, workerTasksqueueCount?: number): Promise<void>;
     protected updateScene(offscreenCanvasOpt: IOffscreenCanvasOptionType): void;
     protected updateLayer(layerOpt: ILayerOptionType): void;
     protected createScene(opt: IOffscreenCanvasOptionType): Scene;
@@ -46,9 +46,14 @@ export declare abstract class WorkThreadEngineBase {
     protected setToolsOpt(opt: IActiveToolsDataType): void;
     protected setWorkOpt(opt: Partial<IActiveWorkDataType>): void;
     protected destroy(): void;
+    post(msg: IBatchMainMessage): void;
+    private runBatchPostData;
+    protected combinePostData(): IBatchMainMessage;
+    protected safariFixRect(rect: IRectType): IRectType | undefined;
+    protected getSceneRect(): IRectType;
+    abstract combinePost(): Promise<void>;
+    protected abstract getLayer(workLayer: ECanvasShowType): Group | undefined;
     abstract setCameraOpt(cameraOpt: ICameraOpt): void;
-    abstract getOffscreen(isFullWork: boolean): OffscreenCanvas;
-    abstract post(msg: IBatchMainMessage): Promise<void>;
     abstract consumeDraw(type: EDataType, data: IWorkerMessage): void;
     abstract consumeDrawAll(type: EDataType, data: IWorkerMessage): void;
 }
@@ -58,7 +63,7 @@ export declare abstract class LocalWork {
     readonly thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker;
     fullLayer: Group;
     drawLayer?: Group;
-    readonly _post: (msg: IBatchMainMessage) => Promise<void>;
+    readonly _post: (msg: IBatchMainMessage) => void;
     protected tmpWorkShapeNode?: BaseShapeTool;
     protected tmpOpt?: IActiveToolsDataType;
     workShapes: Map<IworkId, BaseShapeTool>;
@@ -70,34 +75,12 @@ export declare abstract class LocalWork {
     getWorkShape(workId: IworkId): BaseShapeTool | undefined;
     getTmpWorkShapeNode(): BaseShapeTool | undefined;
     setTmpWorkId(workId: IworkId | undefined): void;
-    setTmpWorkOptions(opt: BaseShapeOptions): void;
     setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
     createWorkShapeNode(opt: IActiveToolsDataType & {
         workId?: IworkId;
-    }): import("../tools").SelectorShape | import("../tools").PencilShape | import("../tools").LaserPenShape | import("../tools").ArrowShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").StarShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools/text").TextShape | import("../tools").EraserShape | import("../tools").ImageShape | undefined;
+    }): 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/text").TextShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | undefined;
     setToolsOpt(opt: IActiveToolsDataType): void;
     clearWorkShapeNodeCache(workId: IworkId): void;
     clearAllWorkShapesCache(): void;
-    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | import("../tools").LaserPenShape | import("../tools").SpeechBalloonShape | import("../tools/text").TextShape | import("../tools").EraserShape | undefined;
-    abstract consumeDraw(data: IWorkerMessage, serviceWork?: ServiceWork): IMainMessage | undefined;
-    abstract consumeDrawAll(data: IWorkerMessage, serviceWork?: ServiceWork): IMainMessage | undefined;
-}
-export interface ServiceWork {
-    readonly viewId: string;
-    readonly vNodes: VNodeManager;
-    readonly fullLayer: Group;
-    readonly drawLayer: Group;
-    readonly post: (msg: IBatchMainMessage) => Promise<void>;
-    selectorWorkShapes: Map<string, IServiceWorkItem>;
-    clearAllWorkShapesCache(): void;
-    runSelectWork(data: IWorkerMessage): void;
-    consumeDraw(data: IWorkerMessage): void;
-    setNodeKey(workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
-    runReverseSelectWork(selectIds: string[]): void;
-    removeWork(data: IWorkerMessage): void;
-    removeSelectWork(data: IWorkerMessage): void;
-    runSelectWork(data: IWorkerMessage): void;
-    consumeFull(data: IWorkerMessage): void;
-    consumeDraw(data: IWorkerMessage): void;
-    destroy(): void;
+    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | import("../tools/text").TextShape | import("../tools").LaserPenShape | undefined;
 }

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

@@ -13,7 +13,7 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
     consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
     consumeFull(data: IWorkerMessage, scene?: Scene): Promise<void>;
-    removeWork(data: IWorkerMessage): Promise<void>;
+    removeWork(data: IWorkerMessage): void;
     removeNode(key: string): IRectType | undefined;
     checkTextActive(data: IWorkerMessage): Promise<void>;
     colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;

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

@@ -1,25 +1,41 @@
 import { Group } from "spritejs";
-import { ISubWorkerInitOption, ServiceWork } from "./base";
+import { ISubWorkerInitOption } from "./base";
 import { VNodeManager } from "./vNodeManager";
 import { IBatchMainMessage, IServiceWorkItem, IWorkerMessage } from "../types";
 import { EToolsKey } from "../enum";
 import { BaseShapeOptions } from "../tools";
+export interface ServiceWork {
+    readonly viewId: string;
+    readonly vNodes: VNodeManager;
+    readonly fullLayer: Group;
+    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;
+    runReverseSelectWork(selectIds: string[]): void;
+    removeWork(data: IWorkerMessage): void;
+    removeSelectWork(data: IWorkerMessage): void;
+    runSelectWork(data: IWorkerMessage): void;
+    consumeFull(data: IWorkerMessage): void;
+    consumeDraw(data: IWorkerMessage): void;
+    destroy(): void;
+}
 export declare class ServiceWorkForFullWorker implements ServiceWork {
     viewId: string;
     vNodes: VNodeManager;
     fullLayer: Group;
     drawLayer: Group;
-    serviceDrawLayer: Group;
     workShapes: Map<string, IServiceWorkItem>;
     selectorWorkShapes: Map<string, IServiceWorkItem>;
     protected animationId?: number | undefined;
     private willRunEffectSelectorIds;
     private runEffectId?;
     private noAnimationRect;
-    post: (msg: IBatchMainMessage, transfer?: Transferable[]) => Promise<void>;
-    constructor(opt: ISubWorkerInitOption & {
-        serviceDrawLayer: Group;
-    });
+    post: (msg: IBatchMainMessage) => void;
+    constructor(opt: ISubWorkerInitOption);
     destroy(): void;
     consumeDraw(data: IWorkerMessage): void;
     consumeFull(data: IWorkerMessage): void;
@@ -27,7 +43,7 @@ export declare class ServiceWorkForFullWorker implements ServiceWork {
     runSelectWork(data: IWorkerMessage): void;
     setNodeKey(workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
     runReverseSelectWork(selectIds: string[]): void;
-    removeWork(data: IWorkerMessage): Promise<void>;
+    removeWork(data: IWorkerMessage): void;
     removeSelectWork(data: IWorkerMessage): void;
     private removeNode;
     private activeWorkShape;

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

@@ -3,18 +3,13 @@ import { IWorkerMessage, IRectType, IMainMessage } from "..";
 import { BaseCollectorReducerAction } from "../../collector/types";
 import { LocalWork, ISubWorkerInitOption } from "./base";
 export declare class LocalWorkForSubWorker extends LocalWork {
-    private animationWorkRects?;
     protected combineDrawTimer?: number;
-    private animationId?;
-    private closeAnimationTime;
-    private runLaserPenStep;
     constructor(opt: ISubWorkerInitOption);
     runFullWork(data: IWorkerMessage, isDrawLabel?: boolean): Promise<IRectType | undefined>;
     runSelectWork(data: IWorkerMessage): undefined;
     consumeDraw(data: IWorkerMessage): IMainMessage | undefined;
     consumeDrawAll(data: IWorkerMessage): undefined;
     updateLabels(labelGroup: Group, value: BaseCollectorReducerAction): void;
-    private runLaserPenAnimation;
     private drawPencil;
     private drawArrow;
 }

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

@@ -0,0 +1,43 @@
+import { Group } from "spritejs";
+import { BaseShapeOptions, BaseShapeTool } from "../tools";
+import { ISubWorkerInitOption } from "./base";
+import { VNodeManager } from "./vNodeManager";
+import { IActiveToolsDataType, IBatchMainMessage, ILocalWorkItem, IServiceWorkItem, IWorkerMessage, IworkId } from "../types";
+export interface TopLayerWork {
+    readonly viewId: string;
+    readonly vNodes: VNodeManager;
+    readonly topLayer: Group;
+    readonly post: (msg: IBatchMainMessage) => void;
+    consumeDraw(data: IWorkerMessage): void;
+    consumeDrawAll(data: IWorkerMessage): void;
+    destroy(): void;
+}
+export declare class TopLayerWorkForSubWorker implements TopLayerWork {
+    viewId: string;
+    vNodes: VNodeManager;
+    topLayer: Group;
+    post: (msg: IBatchMainMessage) => void;
+    serviceWorkShapes: Map<string, IServiceWorkItem>;
+    localWorkShapes: Map<IworkId, ILocalWorkItem>;
+    protected tmpOpt?: IActiveToolsDataType;
+    protected tmpWorkShapeNode?: BaseShapeTool;
+    protected animationId?: number | undefined;
+    constructor(opt: ISubWorkerInitOption);
+    getWorkShape(workId: IworkId): ILocalWorkItem | undefined;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    setTmpWorkId(workId: IworkId | undefined): void;
+    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: IworkId;
+    }): 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/text").TextShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | undefined;
+    clearAllWorkShapesCache(): void;
+    setToolsOpt(opt: IActiveToolsDataType): void;
+    consumeDraw(data: IWorkerMessage): void;
+    consumeDrawAll(data: IWorkerMessage): void;
+    destroy(): void;
+    private setNodeKey;
+    private activeServiceWorkShape;
+    private computNextAnimationIndex;
+    private animationDraw;
+    private runAnimation;
+}

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

@@ -4,16 +4,17 @@ export declare class VNodeManager {
     viewId: string;
     scene: Scene;
     scenePath?: string;
-    drawLayer?: Group;
     fullLayer?: Group;
     curNodeMap: Map<string, BaseNodeMapItem>;
     targetNodeMap: Map<string, BaseNodeMapItem>[];
     constructor(viewId: string, scene: Scene);
-    init(fullLayer: Group, drawLayer?: Group): void;
+    init(fullLayer: Group): void;
     get(name: string): BaseNodeMapItem | undefined;
     hasRenderNodes(): boolean;
     has(name: string): void;
     setInfo(name: string, info: Partial<BaseNodeMapItem>): void;
+    selected(name: string): void;
+    unSelected(name: string): void;
     delete(name: string): void;
     clear(): void;
     hasRectIntersectRange(rect: IRectType, filterLock?: boolean): boolean;