@netless/appliance-plugin 1.0.0-beta.0 → 1.0.0-beta.11

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

@@ -16,21 +16,17 @@ export declare class TextShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(): IMainMessage;
     consumeAll(): IMainMessage;
+    consumeService(): IRectType | undefined;
     private draw;
-    consumeService(props: {
+    consumeServiceAsync(props: {
         isFullWork: boolean;
         replaceId?: string;
-        isDrawLabel?: boolean;
-    }): IRectType | undefined;
-    updataOptService(updateNodeOpt: IUpdateNodeOpt): IRectType | undefined;
+        isDrawLabel?: true;
+    }): Promise<IRectType | undefined>;
+    updataOptService(): IRectType | undefined;
+    updataOptServiceAsync(updateNodeOpt: IUpdateNodeOpt): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
-    static getFontWidth(param: {
-        text: string;
-        ctx: OffscreenCanvasRenderingContext2D;
-        opt: TextOptions;
-        worldScaling: number[];
-    }): number;
-    static createLabels(textOpt: TextOptions, layer: Group): (Polyline | Label)[];
+    static createLabels(textOpt: TextOptions, group: Group): Promise<(Polyline | Label)[]>;
     static updateNodeOpt(param: {
         node: ShapeNodes;
         opt: IUpdateNodeOpt;

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

@@ -30,7 +30,7 @@ export interface IOffscreenCanvasOptionType {
     width: number;
     /** offscreenCanvas 高度 */
     height: number;
-    /** 上下文类型,默认webgl2 */
+    /** 上下文类型 */
     contextType?: ECanvasContextType;
     /** 是否自动渲染,默认自动渲染 */
     autoRender?: boolean;
@@ -120,7 +120,6 @@ export type IWorkerMessage = Omit<Partial<BaseCollectorReducerAction>, 'op'> & {
     }>;
     willSerializeData?: boolean;
     isRunSubWork?: boolean;
-    undoTickerId?: number;
     scenes?: ISerializableStorageData;
     textType?: ETextEditorType;
     mainTasksqueueCount?: number;
@@ -162,7 +161,6 @@ export interface IMainMessage extends INormalPushMsg {
         workId: IworkId;
         toolsType: EToolsKey;
     }>;
-    undoTickerId?: number;
     scenePath?: string;
     canvasWidth?: number;
     canvasHeight?: number;
@@ -179,6 +177,7 @@ export interface IMainMessage extends INormalPushMsg {
     isLocked?: boolean;
     shapeOpt?: ShapeOptType;
     toolsTypes?: EToolsKey[];
+    waitWorker?: boolean;
 }
 export interface IMainMessageRenderData {
     viewId: string;
@@ -191,13 +190,13 @@ export interface IMainMessageRenderData {
     clearCanvas?: ECanvasShowType;
     /** 是否需要销毁imageBitmap */
     isUnClose?: boolean;
-    isFullWork?: boolean;
     workerType?: EDataType.Local | EDataType.Service;
     offset?: {
         x: number;
         y: number;
     };
     translate?: [number, number];
+    workId?: string;
 }
 export interface IBatchMainMessage {
     /** 绘制数据 */
@@ -206,6 +205,7 @@ export interface IBatchMainMessage {
     sp?: Array<IMainMessage>;
     drawCount?: number;
     workerTasksqueueCount?: number;
+    workIds?: Set<string>;
 }
 export interface ICameraOpt {
     centerX: number;
@@ -244,7 +244,6 @@ export interface IActiveWorkDataType {
     toolsOpt?: ShapeOptions;
     viewId?: string;
     workId?: IworkId;
-    undoTickerId?: number;
 }
 export type IServiceWorkItem = {
     toolsType: EToolsKey;
@@ -263,6 +262,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 +281,9 @@ export type BaseNodeMapItem = {
     toolsType: EToolsKey;
     canRotate: boolean;
     scaleType: EScaleType;
+    /** 是否被框选中,框选中的元素不能被其它人操作 */
+    isSelected: boolean;
+    isHid?: 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/utils/math.d.ts

@@ -37,6 +37,7 @@ export declare function getRectTranslated(rect: IRectType, translate: [number, n
     w: number;
     h: number;
 };
+export declare function getRectRotatedPoints(rect: IRectType, angle: number): Vec2d[];
 export declare function getRectRotated(rect: IRectType, angle: number): {
     x: number;
     y: number;
@@ -49,6 +50,8 @@ export declare function getRectScaleed(rect: IRectType, scale: [number, number])
     w: number;
     h: number;
 };
+export declare function getScalePoints(points: Vec2d[], originPos: Vec2d, scale: [number, number]): Vec2d[];
+export declare function getRotatePoints(points: Vec2d[], originPos: Vec2d, angle: number): Vec2d[];
 export declare function rotatePoints(points: number[], originPos: [number, number], angle: number): void;
 export declare function scalePoints(points: number[], originPos: [number, number], scale: [number, number]): void;
 export declare function getNodeRect(key: string, layer?: Group, safeBorderPadding?: number): IRectType | undefined;

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

@@ -1,4 +1,4 @@
 import { Group, Node, Path } from "spritejs";
-import { EToolsKey } from "../enum";
+import { BaseNodeMapItem } from "../types";
 export declare const isSealedGroup: (group: Group | Path | Node) => boolean;
-export declare const isRenderNode: (toolsType: EToolsKey) => boolean;
+export declare const isRenderNode: (param: Pick<BaseNodeMapItem, 'isHid'>) => boolean;

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

@@ -1,13 +1,14 @@
 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 } from "../types";
 import { VNodeManager } from "./vNodeManager";
-import { EDataType, EToolsKey } from "../enum";
+import { 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 type { WorkThreadEngineForFullWorker, WorkThreadEngineForSubWorker } from "./workerManager";
+import { EmitEventType } from "../../plugin/types";
 export interface IWorkerInitOption {
     dpr: number;
     offscreenCanvasOpt: IOffscreenCanvasOptionType;
@@ -18,37 +19,48 @@ 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;
+    protected protectedTask?: {
+        isProtected: boolean;
+        workName: EmitEventType;
+        workState: EvevtWorkState;
+    };
     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;
+    private getSupportContextType;
     protected createScene(opt: IOffscreenCanvasOptionType): Scene;
     protected createLayer(name: string, scene: Scene, opt: ILayerOptionType): Group;
     protected clearAll(): void;
     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,46 +70,24 @@ 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>;
-    workShapeState: Map<IworkId, ShapeStateInfo>;
-    protected effectWorkId?: number;
+    workShapes: Map<string, BaseShapeTool>;
+    workShapeState: Map<string, ShapeStateInfo>;
     protected drawCount: number;
     constructor(opt: ISubWorkerInitOption);
     destroy(): void;
-    getWorkShape(workId: IworkId): BaseShapeTool | undefined;
+    getWorkShapes(): Map<string, BaseShapeTool>;
+    getWorkShape(workId: string): BaseShapeTool | undefined;
     getTmpWorkShapeNode(): BaseShapeTool | undefined;
-    setTmpWorkId(workId: IworkId | undefined): void;
-    setTmpWorkOptions(opt: BaseShapeOptions): void;
-    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    setTmpWorkId(workId: string | undefined): void;
+    setWorkOptions(workId: string, 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;
+        workId?: string;
+    }): 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;
+    clearWorkShapeNodeCache(workId: string): 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/straight").StraightShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools").LaserPenShape | undefined;
 }

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

@@ -12,8 +12,9 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     constructor(opt: ISubWorkerInitOption);
     consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
     consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
+    workShapesDone(scenePath: string, serviceWork: ServiceWorkForFullWorker): void;
     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,16 @@ 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>;
+    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;
-    private runLaserPenAnimation;
+    removeWork(data: IWorkerMessage): void;
+    private removeNode;
     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 } 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<string, ILocalWorkItem>;
+    protected tmpOpt?: IActiveToolsDataType;
+    protected tmpWorkShapeNode?: BaseShapeTool;
+    protected animationId?: number | undefined;
+    constructor(opt: ISubWorkerInitOption);
+    getWorkShape(workId: string): ILocalWorkItem | undefined;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    setTmpWorkId(workId: string | undefined): void;
+    setWorkOptions(workId: string, opt: BaseShapeOptions): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: string;
+    }): 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;
@@ -29,4 +30,5 @@ export declare class VNodeManager {
     deleteLastTarget(): void;
     getTarget(i: number): Map<string, BaseNodeMapItem>;
     deleteTarget(i: number): void;
+    clearTarget(): void;
 }

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

@@ -1,10 +1,11 @@
 import { Group } from "spritejs";
-import { EDataType } from "../enum";
+import { ECanvasShowType, EDataType } from "../enum";
 import { IBatchMainMessage, ICameraOpt, ILayerOptionType, IWorkerMessage } from "../types";
 import { IWorkerInitOption, WorkThreadEngineBase } from "./base";
 import { LocalWorkForFullWorker } from "./fullWorkerLocal";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
 import { LocalWorkForSubWorker } from "./subWorkerLocal";
+import { TopLayerWorkForSubWorker } from "./subWorkerTopLayer";
 export declare enum EWorkThreadType {
     Full = "full",
     Sub = "sub"
@@ -21,51 +22,51 @@ export declare class WorkerManager<T extends WorkThreadEngineBase> {
 /** full worker */
 export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase {
     serviceDrawLayer: Group;
-    drawLayer: Group;
+    localDrawLayer: Group;
     snapshotFullLayer: undefined;
     private methodBuilder;
     localWork: LocalWorkForFullWorker;
     serviceWork: ServiceWorkForFullWorker;
     protected _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
     constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
-    post(msg: IBatchMainMessage, transfer?: Transferable[]): Promise<void>;
-    on(msg: IWorkerMessage): void;
+    combinePost(): Promise<void>;
+    on(msg: IWorkerMessage, workerTasksqueueCount?: number): Promise<void>;
     removeNode(data: IWorkerMessage): Promise<void>;
     checkTextActive(data: IWorkerMessage): void;
     clearAll(): void;
     protected updateLayer(layerOpt: ILayerOptionType): void;
     setCameraOpt(cameraOpt: ICameraOpt): void;
-    getLayer(isFullWork?: boolean, workerType?: EDataType.Local | EDataType.Service): Group;
-    getOffscreen(isFullWork: boolean, workerType?: EDataType.Local | EDataType.Service): OffscreenCanvas;
+    protected getLayer(drawCanvas: ECanvasShowType): Group | undefined;
+    getOffscreen(drawCanvas: ECanvasShowType): OffscreenCanvas;
     consumeFull(type: EDataType, data: IWorkerMessage): Promise<void>;
     consumeDraw(type: EDataType, data: IWorkerMessage): void;
     consumeDrawAll(type: EDataType, data: IWorkerMessage): void;
     private updateCamera;
     private getRectImageBitmap;
-    private safariFixRect;
-    private getSceneRect;
-    private checkRightRectBoundingBox;
     private cursorHover;
 }
 /** sub worker */
 export declare class WorkThreadEngineForSubWorker extends WorkThreadEngineBase {
     protected _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
-    drawLayer: undefined;
+    topLayer: Group;
     snapshotFullLayer: Group | undefined;
     serviceWork: undefined;
     localWork: LocalWorkForSubWorker;
+    topLayerWork: TopLayerWorkForSubWorker;
     constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
-    post(msg: IBatchMainMessage, transfer?: Transferable[]): Promise<void>;
-    on(msg: IWorkerMessage): void;
-    getOffscreen(isSnapshot: boolean): OffscreenCanvas;
-    consumeDraw(type: EDataType, data: IWorkerMessage): void;
+    combinePost(): Promise<void>;
+    getLayer(drawCanvas: ECanvasShowType, isSnapshot?: boolean): Group;
+    on(msg: IWorkerMessage): Promise<void>;
+    removeNode(data: IWorkerMessage): Promise<void>;
+    getOffscreen(drawCanvas: ECanvasShowType, isSnapshot?: boolean): OffscreenCanvas;
+    consumeDraw(_type: EDataType, data: IWorkerMessage): void;
     consumeDrawAll(_type: EDataType, data: IWorkerMessage): void;
+    clearAll(): void;
     private getRectImageBitmap;
-    private safariFixRect;
+    protected updateLayer(layerOpt: ILayerOptionType): void;
     private updateCamera;
     setCameraOpt(cameraOpt: ICameraOpt, layer?: Group): void;
     private getSnapshot;
-    private willRenderSpecialLabel;
     private getSnapshotRender;
     private getBoundingRect;
 }

package/dist/displayer/floatBar/dragBox/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const DraggableBox: (props: {
+    onClickHandle: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}) => React.JSX.Element;

package/dist/displayer/floatBar/index.d.ts

@@ -1,10 +1,6 @@
 import React from "react";
 import { TextEditorInfo } from "../../component/textEditor";
 export declare const FloatBar: React.MemoExoticComponent<React.ForwardRefExoticComponent<{
-    className: string;
     editors?: Map<string, TextEditorInfo> | undefined;
     activeTextId?: string | undefined;
-} & React.RefAttributes<HTMLCanvasElement>>>;
-export declare const FloatBarBtn: (props: {
-    className: string;
-}) => React.JSX.Element | null;
+} & React.RefAttributes<HTMLDivElement>>>;