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

package/dist/core/vNodeManager.d.ts

@@ -2,13 +2,13 @@ import { Group, Scene } from "spritejs";
 import { BaseNodeMapItem, IRectType } from "./types";
 import { EToolsKey } from ".";
 import { _SetTrue } from "../plugin";
-import type { Uid } from "../collector/types";
+import { ObserverMap } from "./utils/ObserverMap";
 export declare class VNodeManager {
     viewId: string;
     scene: Scene;
     fullLayer?: Group;
-    curNodeMap: Map<string, BaseNodeMapItem>;
-    targetNodeMap: Map<string, BaseNodeMapItem>[];
+    curNodeMap: ObserverMap<string, BaseNodeMapItem>;
+    targetNodeMap: ObserverMap<string, BaseNodeMapItem>[];
     private highLevelIds?;
     private canClearUids?;
     private localUid?;
@@ -17,10 +17,14 @@ export declare class VNodeManager {
     get(name: string): BaseNodeMapItem | undefined;
     setLocalUid(uid: string): void;
     getLocalUid(): string | undefined;
-    setCanClearUids(clearUids?: _SetTrue<Uid>): void;
-    getCanClearUids(): _SetTrue<string> | undefined;
-    getCanEraserNodes(nodeMap: Map<string, BaseNodeMapItem>): Map<string, BaseNodeMapItem>;
+    setCanClearUids(clearUids?: _SetTrue): void;
+    getCanClearUids(): _SetTrue | undefined;
+    getCanEraserNodes(nodeMap: ObserverMap<string, BaseNodeMapItem>, disableErase: {
+        disableEraseImage?: boolean;
+        disableEraseText?: boolean;
+    }): Map<string, BaseNodeMapItem>;
     getNodesByType(type: EToolsKey): Map<string, BaseNodeMapItem>;
+    gethasEraserNodes(): Map<string, BaseNodeMapItem>;
     hasRenderNodes(): boolean;
     has(name: string): boolean;
     setInfo(name: string, info: Partial<BaseNodeMapItem>): void;
@@ -39,11 +43,11 @@ export declare class VNodeManager {
     clearHighLevelIds(): void;
     setTargetAssignKeys(keys: Array<string>): number;
     setTarget(): number;
-    getLastTarget(): Map<string, BaseNodeMapItem>;
+    getLastTarget(): ObserverMap<string, BaseNodeMapItem>;
     deleteLastTarget(): void;
-    getTarget(i: number): Map<string, BaseNodeMapItem>;
+    getTarget(i: number): ObserverMap<string, BaseNodeMapItem>;
     deleteTarget(i: number): void;
     clearTarget(): void;
     isLocalWorkId(workId: string): boolean;
-    isCanClearWorkId(workId: string): boolean;
+    isCanClearWorkId(workId: string): boolean | "" | undefined;
 }

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

@@ -1,20 +1,31 @@
 import { Group, Scene } from "spritejs";
 import { IActiveToolsDataType, IActiveWorkDataType, IBatchMainMessage, ICameraOpt, ILayerOptionType, IOffscreenCanvasOptionType, IRectType, IWorkerMessage } from "../types";
 import { VNodeManager } from "../vNodeManager";
-import { type ECanvasContextType, ECanvasShowType, EDataType, EvevtWorkState } from "../enum";
+import { type ECanvasContextType, ECanvasShowType, EDataType, EventWorkState } from "../enum";
 import { BaseShapeOptions, BaseShapeTool } from "../tools/base";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
 import { LocalWorkForFullWorker } from "./fullWorkerLocal";
 import { LocalWorkForSubWorker } from "./subWorkerLocal";
-import { EWorkThreadType, WorkThreadEngineForFullWorker, WorkThreadEngineForSubWorker } from "./workerManager";
+import { EWorkThreadType, type WorkThreadEngineForFullWorker, type WorkThreadEngineForSubWorker, type WorkThreadEngineForSimpleWorker } from "./workerManager";
 import { EmitEventType } from "../../plugin/types";
 export interface IWorkerInitOption {
     dpr: number;
     offscreenCanvasOpt: IOffscreenCanvasOptionType;
     layerOpt: ILayerOptionType;
+    combineUnitTime?: number;
+    syncUnitTime?: number;
+    maxCombineEraserTime?: number;
+    isUseSimple?: boolean;
+}
+export interface ISimpleWorkerInitOption extends IWorkerInitOption {
+    offscreenCanvas?: {
+        localCanvas: OffscreenCanvas;
+        bgCanvas: OffscreenCanvas;
+        serviceCanvas: OffscreenCanvas;
+    };
 }
 export interface ISubWorkerInitOption {
-    thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker;
+    thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker | WorkThreadEngineForSimpleWorker;
     viewId: string;
     vNodes: VNodeManager;
     fullLayer: Group;
@@ -23,12 +34,12 @@ export interface ISubWorkerInitOption {
 }
 export declare abstract class WorkThreadEngineBase {
     readonly viewId: string;
+    readonly type: EWorkThreadType;
     scene: Scene;
     fullLayer: Group;
     readonly vNodes: VNodeManager;
-    readonly dpr: number;
+    dpr: number;
     readonly contextType?: ECanvasContextType;
-    abstract readonly type: EWorkThreadType;
     protected opt: IWorkerInitOption;
     protected cameraOpt?: ICameraOpt;
     abstract localWork: LocalWorkForFullWorker | LocalWorkForSubWorker;
@@ -40,31 +51,37 @@ export declare abstract class WorkThreadEngineBase {
     protected protectedTask?: {
         isProtected: boolean;
         workName: EmitEventType;
-        workState: EvevtWorkState;
+        workState: EventWorkState;
     };
-    protected hasPriorityDraw: boolean;
     protected delayPostDoneResolve?: (bol: boolean) => void;
-    protected cacheImages: Map<string, ImageBitmap>;
+    protected cacheImages: Map<string, {
+        imageBitmap: ImageBitmap;
+        workId: string;
+    }>;
     protected imageResolveMap: Map<string, {
         timer?: number;
-        resolve?: (workId: string) => void;
+        resolve?: (src: string) => void;
     }>;
+    protected taskUpdateCameraId?: number;
+    protected debounceUpdateCameraId?: number;
     constructor(viewId: string, opt: IWorkerInitOption, workerType: EWorkThreadType);
-    private createRenderLayer;
+    protected createRenderLayer(scene: Scene, opt: IWorkerInitOption): void;
+    updateDpr(dpr: number): Promise<void>;
     getCachedImages(imageSrc: string): ImageBitmap | undefined;
+    getCachedImagesByWorkId(workId: string): ImageBitmap | undefined;
+    deleteCachedImagesByWorkId(workId: string, filter?: string): void;
     clearCacheImages(): void;
     clearImageResolveMap(): void;
-    setHasPriorityDraw(bol: boolean): void;
-    getPriorityDraw(): boolean;
     setIsSafari(isSafari: boolean): void;
     on(msg: IWorkerMessage): Promise<void>;
-    loadImageBitMap(msg: Pick<IWorkerMessage, 'toolsType' | 'opt' | 'workId'>): Promise<ImageBitmap | undefined>;
+    private getIconSize;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "isSubWorker">): Promise<ImageBitmap | undefined>;
     protected createLocalWork(data: IWorkerMessage): void;
-    protected updateScene(offscreenCanvasOpt: IOffscreenCanvasOptionType): void;
-    protected updateLayer(layerOpt: ILayerOptionType): void;
+    protected updateScene(scene: Scene, offscreenCanvasOpt: IOffscreenCanvasOptionType, targetLayer?: Group): void;
+    protected updateLayer(layerOpt: ILayerOptionType, targetLayer?: Group): void;
     private getSupportContextType;
-    protected createScene(opt: IOffscreenCanvasOptionType): Scene;
-    protected createLayer(name: string, scene: Scene, opt: ILayerOptionType): Group;
+    protected createScene(opt: IWorkerInitOption): Scene;
+    protected createLayer(name: string, scene: Scene, opt: ILayerOptionType, offscreenCanvas?: OffscreenCanvas): Group;
     protected clearAll(): Promise<void>;
     protected setToolsOpt(opt: IActiveToolsDataType): void;
     protected setWorkOpt(opt: Partial<IActiveWorkDataType>): void;
@@ -72,7 +89,6 @@ export declare abstract class WorkThreadEngineBase {
     post(msg: IBatchMainMessage): Promise<void>;
     private runBatchPostData;
     protected combinePostData(): IBatchMainMessage;
-    protected safariFixRect(rect: IRectType, dpr: number): IRectType | undefined;
     getSceneRect(): IRectType;
     abstract combinePost(): Promise<void>;
     protected abstract getLayer(workLayer: ECanvasShowType): Group | undefined;
@@ -83,7 +99,7 @@ export declare abstract class WorkThreadEngineBase {
 }
 export declare abstract class LocalWork {
     readonly viewId: string;
-    readonly vNodes: VNodeManager;
+    readonly vNodes?: VNodeManager;
     readonly thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker;
     fullLayer: Group;
     drawLayer?: Group;
@@ -91,7 +107,13 @@ export declare abstract class LocalWork {
     protected tmpOpt?: IActiveToolsDataType;
     workShapes: Map<string, BaseShapeTool>;
     protected drawCount: number;
+    protected consumeCount: number;
     protected syncUnitTime: number;
+    protected combineUnitTime: number;
+    protected maxCombineEraserTime: number;
+    setmaxCombineEraserTime(maxCombineEraserTime: number): void;
+    setCombineUnitTime(combineUnitTime: number): void;
+    setSyncUnitTime(syncUnitTime: number): void;
     constructor(opt: ISubWorkerInitOption);
     destroy(): void;
     getWorkShapes(): Map<string, BaseShapeTool>;
@@ -100,10 +122,10 @@ export declare abstract class LocalWork {
     setWorkOptions(workId: string, opt: BaseShapeOptions): void;
     createWorkShapeNode(opt: IActiveToolsDataType & {
         workId: string;
-    }): import("../tools").PencilShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").StarShape | import("../tools/text").TextShape | import("../tools").SelectorShape | import("../tools/image").ImageShape | import("../tools").ArrowShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools/pencilEraserBitMap").BitMapEraserShape | import("../tools/pencilEraser").PencilEraserShape | 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/pencilEraser").PencilEraserShape | import("../tools").BitMapEraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | import("../tools/shadowSvg").ISvgShadowShape | undefined;
     setToolsOpt(opt: IActiveToolsDataType): void;
     getToolsOpt(): IActiveToolsDataType | undefined;
     clearWorkShapeNodeCache(workId: string): void;
     clearAllWorkShapesCache(): void;
-    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | undefined;
+    setFullWork(data: Pick<IWorkerMessage, "workId" | "opt" | "toolsType">): BaseShapeTool | undefined;
 }

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

@@ -1,26 +1,31 @@
-import { IWorkerMessage, IMainMessage, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType } from "..";
+import { IWorkerMessage, IMainMessage, IRectType, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType } from "..";
 import { BaseShapeOptions, SelectorShape } from "../tools";
 import { ISubWorkerInitOption, LocalWork } from "./base";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
+import { BitMapEraserShape } from "../tools/pencilEraserBitMap";
+import { WorkThreadEngineForFullWorker } from "./workerManager";
+import { PencilEraserShape } from "../tools/pencilEraser";
+import { VNodeManager } from "../vNodeManager";
 export declare class LocalWorkForFullWorker extends LocalWork {
-    private combineUnitTime;
-    private combineTimerId?;
-    private combineDrawResolve?;
-    private combineDrawActiveId?;
+    readonly vNodes: VNodeManager;
+    protected _type: string;
+    protected combineTimerId?: number;
+    protected combineDrawResolve?: (value: boolean) => void;
+    protected combineDrawActiveId?: string;
     protected drawWorkActiveId?: string;
-    private effectSelectNodeData;
-    private batchEraserWorks;
-    private batchEraserRemoveNodes;
+    protected effectSelectNodeData: Set<IWorkerMessage>;
     constructor(opt: ISubWorkerInitOption);
-    loadImageBitMap(msg: Pick<IWorkerMessage, 'toolsType' | 'opt' | 'workId'>): Promise<ImageBitmap | undefined>;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "isSubWorker">): Promise<ImageBitmap | undefined>;
     consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     workShapesDone(scenePath: string, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     consumeFull(data: IWorkerMessage): Promise<void>;
-    private commandDeleteText;
-    removeSelector(data: IWorkerMessage): Promise<void>;
+    removeSelector(data: IWorkerMessage, workEngine?: WorkThreadEngineForFullWorker): Promise<void>;
     removeWork(data: IWorkerMessage): Promise<void>;
-    private removeNode;
+    removeNode(key: string): {
+        fullRect: IRectType | undefined;
+        drawRect: IRectType | undefined;
+    };
     private _removeWork;
     checkTextActive(data: IWorkerMessage): Promise<void>;
     colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;
@@ -28,13 +33,15 @@ export declare class LocalWorkForFullWorker extends LocalWork {
         callback?: (props: {
             res?: IMainMessage;
             param: IUpdateSelectorPropsType;
-            postData: Pick<IBatchMainMessage, 'sp' | 'render'>;
+            postData: Pick<IBatchMainMessage, "sp" | "render">;
             workShapeNode: SelectorShape;
             newServiceStore: Map<string, {
                 opt: BaseShapeOptions;
                 toolsType: EToolsKey;
                 ops?: string;
             }>;
+            smoothSync?: boolean;
+            needUndoTicker?: number;
         }) => void;
     }): Promise<IMainMessage | undefined>;
     blurSelector(data?: IWorkerMessage): Promise<void>;
@@ -43,18 +50,15 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     reRenderSelector(willSyncService?: boolean): Promise<void>;
     updateFullSelectWork(data: IWorkerMessage): Promise<void>;
     destroy(): void;
-    private drawBitMapEraser;
-    private drawBitMapEraserFull;
-    private drawPencilCombine;
-    private drawSelector;
-    private drawPencilEraser;
-    private drawEraser;
-    private batchEraserCombine;
-    private drawShape;
-    private drawPencil;
-    private drawPencilFull;
-    private updateBatchEraserCombineNode;
-    private runEffectSelectWork;
+    protected drawEraserCombine(workId: string, drawCount: number): Promise<void>;
+    protected drawPencilCombine(workId: string, drawCount: number): Promise<void>;
+    protected drawSelector(res: IMainMessage, isLockSentEventCursor?: boolean): Promise<void>;
+    protected drawPencilFull(res: IMainMessage, isLockSentEventCursor?: boolean, needUndoTicker?: number): Promise<void>;
+    protected drawEraserFull(workShapeNode: BitMapEraserShape | PencilEraserShape, res: IMainMessage, isLockSentEventCursor?: boolean, needUndoTicker?: number): Promise<void>;
+    protected drawEraser(result: IMainMessage, isLockSentEventCursor?: boolean, needUndoTicker?: number): Promise<void>;
+    protected drawShape(res: IMainMessage): Promise<void>;
+    protected drawPencil(res: IMainMessage): Promise<void>;
+    protected runEffectSelectWork(willSyncService?: boolean): Promise<void>;
     cursorHover(msg: IWorkerMessage): Promise<void>;
     cursorBlur(): Promise<void>;
 }

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

@@ -1,7 +1,7 @@
 import { Group } from "spritejs";
 import { ISubWorkerInitOption } from "./base";
 import { VNodeManager } from "../vNodeManager";
-import { IBatchMainMessage, IServiceWorkItem, IWorkerMessage } from "../types";
+import { IBatchMainMessage, IRectType, IServiceWorkItem, IWorkerMessage } from "../types";
 import { EToolsKey } from "../enum";
 import { BaseShapeOptions } from "../tools";
 import { WorkThreadEngineForFullWorker } from "./workerManager";
@@ -32,10 +32,10 @@ export declare class ServiceWorkForFullWorker implements ServiceWork {
     selectorWorkShapes: Map<string, IServiceWorkItem>;
     thread: WorkThreadEngineForFullWorker;
     protected animationId?: number | undefined;
-    private willRunEffectSelectorIds;
-    private runEffectId?;
-    private noAnimationRect;
-    private syncUnitTime;
+    protected willRunEffectSelectorIds: Set<string>;
+    protected runEffectId?: number | undefined;
+    protected noAnimationRect: IRectType | undefined;
+    protected syncUnitTime: number;
     post: (msg: IBatchMainMessage) => Promise<void>;
     constructor(opt: ISubWorkerInitOption);
     destroy(): void;
@@ -49,10 +49,10 @@ export declare class ServiceWorkForFullWorker implements ServiceWork {
     private removeNode;
     private activeWorkShape;
     private hasDiffData;
-    private animationDraw;
-    private runAnimation;
-    private computNextAnimationIndex;
-    private runEffect;
+    protected animationDraw(): Promise<void>;
+    protected runAnimation(): void;
+    protected computNextAnimationIndex(workShape: IServiceWorkItem, pointUnit: number): number;
+    protected runEffect(): void;
     private effectRunSelector;
     private activeSelectorShape;
 }

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

@@ -0,0 +1,28 @@
+import { IActiveToolsDataType, IMainMessage, IMainMessageRenderData, IWorkerMessage } from "../index";
+import { ISubWorkerInitOption } from "./base";
+import { LocalWorkForFullWorker } from "./fullWorkerLocal";
+import { ServiceWorkForFullWorker } from "./fullWorkerService";
+import { SelectorShape, BitMapEraserShape, ArrowShape, ImageShape } from "../tools";
+import { PencilEraserShape } from "../tools/pencilEraser";
+import { TextShape } from "../tools/text";
+import { ISvgShadowShape } from "../tools/shadowSvg";
+/** 本地绘制worker 的实现 */
+export declare class LocalWorkForSimpleWorker extends LocalWorkForFullWorker {
+    protected _type: string;
+    constructor(opt: ISubWorkerInitOption);
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId: string;
+    }): ArrowShape | import("../tools").PencilShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").StarShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | TextShape | import("../tools").LaserPenShape | import("../tools").EraserShape | PencilEraserShape | BitMapEraserShape | SelectorShape | ImageShape | ISvgShadowShape | undefined;
+    protected drawPencil(res: IMainMessage, workId?: string): Promise<void>;
+    protected drawShape(res: IMainMessage): Promise<void>;
+    protected drawSelector(res: IMainMessage, isLockSentEventCursor?: boolean, render?: IMainMessageRenderData[]): Promise<void>;
+    protected drawEraserCombine(workId: string): Promise<void>;
+    consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
+}
+/** 服务端同步数据绘制worker 的实现 */
+export declare class ServiceWorkForSimpleWorker extends ServiceWorkForFullWorker {
+    readonly _type = "simple";
+    constructor(opt: ISubWorkerInitOption);
+    protected animationDraw(): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+import { Group, Scene } from "spritejs";
+import { ICameraOpt, ILayerOptionType, IWorkerMessage, IRectType } from "..";
+import { LocalWork, ISubWorkerInitOption, IWorkerInitOption } from "./base";
+import { VNodeManager } from "../vNodeManager";
+export interface ISnapshotWorkInitOption extends ISubWorkerInitOption {
+    createScene(opt: IWorkerInitOption): Scene;
+    createLayer(name: string, scene: Scene, opt: ILayerOptionType, offscreenCanvas?: OffscreenCanvas): Group;
+}
+export declare class SnapshotWork extends LocalWork {
+    protected opt: ISnapshotWorkInitOption;
+    protected scene?: Scene | undefined;
+    protected cameraOpt: ICameraOpt | undefined;
+    vNodes?: VNodeManager;
+    constructor(opt: ISnapshotWorkInitOption);
+    createSnapshotFullLayer(sceneOpt: IWorkerInitOption, opt: ILayerOptionType): void;
+    destroySnapshotFullLayer(): void;
+    private updateScene;
+    private updateLayer;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
+    private getOffscreen;
+    private getRectImageBitmap;
+    getSnapshot(data: IWorkerMessage): Promise<void>;
+    protected runFullWork(data: IWorkerMessage): Promise<IRectType | undefined>;
+    getSceneRect(): IRectType;
+    private getSnapshotRender;
+    getBoundingRect(data: IWorkerMessage): Promise<void>;
+}

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

@@ -1,16 +1,15 @@
-import { IWorkerMessage, IRectType, EToolsKey } from "..";
+import { IWorkerMessage } from "..";
 import { LocalWork, ISubWorkerInitOption } from "./base";
 export declare class LocalWorkForSubWorker extends LocalWork {
     private drawWorkActiveId?;
     constructor(opt: ISubWorkerInitOption);
-    runFullWork(data: IWorkerMessage): Promise<IRectType | undefined>;
     runSelectWork(data: IWorkerMessage): undefined;
     workShapesDone(): void;
-    canUseSubWorker(eToolsKey: EToolsKey): boolean;
     consumeDraw(data: IWorkerMessage): Promise<void>;
     consumeDrawAll(data: IWorkerMessage): Promise<void>;
     removeWork(data: IWorkerMessage): Promise<void>;
     private removeNode;
     private drawPencil;
     private drawShape;
+    private drawSelector;
 }

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

@@ -28,11 +28,11 @@ export declare class TopLayerWorkForSubWorker implements TopLayerWork {
     constructor(opt: ISubWorkerInitOption);
     canUseTopLayer(toolsType: EToolsKey): toolsType is EToolsKey.LaserPen;
     getWorkShape(workId: string): ILocalWorkItem | undefined;
-    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 | import("../tools/pencilEraserBitMap").BitMapEraserShape | import("../tools/pencilEraser").PencilEraserShape | undefined;
+    createWorkShape(workId: string, opt?: BaseShapeOptions): 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/pencilEraser").PencilEraserShape | import("../tools").BitMapEraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | import("../tools/shadowSvg").ISvgShadowShape | undefined;
     setWorkOptions(workId: string, opt: BaseShapeOptions): void;
     createWorkShapeNode(opt: IActiveToolsDataType & {
         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 | import("../tools/pencilEraserBitMap").BitMapEraserShape | import("../tools/pencilEraser").PencilEraserShape | 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/pencilEraser").PencilEraserShape | import("../tools").BitMapEraserShape | import("../tools").SelectorShape | import("../tools").ImageShape | import("../tools/shadowSvg").ISvgShadowShape | undefined;
     clearAllWorkShapesCache(): void;
     setToolsOpt(opt: IActiveToolsDataType): void;
     getToolsOpt(): IActiveToolsDataType | undefined;

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

@@ -1,11 +1,14 @@
-import { Group } from "spritejs";
+import { Group, Scene } from "spritejs";
 import { ECanvasShowType, EDataType } from "../enum";
-import { IBatchMainMessage, ICameraOpt, ILayerOptionType, IWorkerMessage } from "../types";
-import { IWorkerInitOption, WorkThreadEngineBase } from "./base";
+import { MethodBuilderWorker } from "../msgEvent/forWorker";
+import { IBatchMainMessage, ICameraOpt, ILayerOptionType, IMainMessageRenderData, IWorkerMessage } from "../types";
+import { ISimpleWorkerInitOption, IWorkerInitOption, WorkThreadEngineBase } from "./base";
 import { LocalWorkForFullWorker } from "./fullWorkerLocal";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
 import { LocalWorkForSubWorker } from "./subWorkerLocal";
 import { TopLayerWorkForSubWorker } from "./subWorkerTopLayer";
+import { LocalWorkForSimpleWorker, ServiceWorkForSimpleWorker } from "./simpleWorker";
+import { SnapshotWork } from "./snapshotWork";
 export declare enum EWorkThreadType {
     Full = "full",
     Sub = "sub"
@@ -14,25 +17,48 @@ export declare class WorkerManager<T extends WorkThreadEngineBase> {
     readonly _self: Worker;
     readonly version: string;
     protected type: EWorkThreadType;
-    protected hasPriorityDraw: boolean;
     protected workThreadMap: Map<string, T>;
     constructor(worker: Worker, type: EWorkThreadType);
     private init;
+    private setFontFaces;
+    private isFontAvailable;
     private register;
-    post(msg: IBatchMainMessage, transfer?: Transferable[]): void;
+    post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void;
+}
+/** sub worker */
+export declare class WorkThreadEngineForSubWorker extends WorkThreadEngineBase {
+    readonly type: EWorkThreadType;
+    _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
+    topLayer?: Group;
+    serviceWork: undefined;
+    localWork: LocalWorkForSubWorker;
+    topLayerWork?: TopLayerWorkForSubWorker;
+    snapshotWork: SnapshotWork;
+    constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
+    combinePost(): Promise<void>;
+    on(msg: IWorkerMessage): Promise<void>;
+    protected createLocalWork(data: IWorkerMessage): void;
+    removeNode(data: IWorkerMessage): Promise<void>;
+    getLayer(drawCanvas: ECanvasShowType): Group;
+    getOffscreen(drawCanvas: ECanvasShowType): OffscreenCanvas;
+    consumeDraw(dataType: EDataType, data: IWorkerMessage): Promise<void>;
+    consumeDrawAll(_type: EDataType, data: IWorkerMessage): Promise<void>;
+    clearAll(): Promise<void>;
+    private getRectImageBitmap;
+    protected updateLayer(layerOpt: ILayerOptionType): void;
+    updateDpr(dpr: number): Promise<void>;
+    updateCamera(msg: IWorkerMessage): Promise<void>;
+    setCameraOpt(cameraOpt: ICameraOpt, layer?: Group): void;
 }
 /** full worker */
 export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase {
-    readonly type: EWorkThreadType;
     serviceDrawLayer: Group;
     localDrawLayer: Group;
     snapshotFullLayer: undefined;
-    private methodBuilder;
+    protected methodBuilder: MethodBuilderWorker;
     localWork: LocalWorkForFullWorker;
     serviceWork: ServiceWorkForFullWorker;
-    protected _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
-    private taskUpdateCameraId?;
-    private debounceUpdateCameraId?;
+    _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
     private debounceUpdateCache;
     constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
     combinePost(): Promise<void>;
@@ -47,36 +73,26 @@ export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase
     consumeFull(type: EDataType, data: IWorkerMessage): Promise<void>;
     consumeDraw(type: EDataType, data: IWorkerMessage): Promise<void>;
     consumeDrawAll(type: EDataType, data: IWorkerMessage): Promise<void>;
+    updateDpr(dpr: number): Promise<void>;
     updateCamera(msg: IWorkerMessage): Promise<void>;
-    private getRectImageBitmap;
+    protected getRectImageBitmap(renderData: Required<Pick<IMainMessageRenderData, "rect" | "drawCanvas">>): Promise<ImageBitmap>;
     private cursorHover;
     private cursorBlur;
     destroy(): void;
 }
-/** sub worker */
-export declare class WorkThreadEngineForSubWorker extends WorkThreadEngineBase {
-    readonly type: EWorkThreadType;
-    protected _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
-    topLayer: Group;
-    snapshotFullLayer: Group | undefined;
-    serviceWork: undefined;
-    localWork: LocalWorkForSubWorker;
-    topLayerWork: TopLayerWorkForSubWorker;
-    constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
-    combinePost(): Promise<void>;
-    getLayer(drawCanvas: ECanvasShowType, isSnapshot?: boolean): Group;
+/** simple worker */
+export declare class WorkThreadEngineForSimpleWorker extends WorkThreadEngineForFullWorker {
+    private snapshotWork;
+    localDrawScene?: Scene;
+    serviceDrawScene?: Scene;
+    private offscreenCanvas?;
+    localWork: LocalWorkForSimpleWorker;
+    serviceWork: ServiceWorkForSimpleWorker;
+    protected createRenderLayer(scene: Scene, opt: ISimpleWorkerInitOption, targetOffscreenCanvas?: OffscreenCanvas): void;
+    protected createScene(opt: ISimpleWorkerInitOption, targetOffscreenCanvas?: OffscreenCanvas): Scene;
+    protected combinePostData(): IBatchMainMessage;
     on(msg: IWorkerMessage): Promise<void>;
-    protected createLocalWork(data: IWorkerMessage): void;
-    removeNode(data: IWorkerMessage): Promise<void>;
-    getOffscreen(drawCanvas: ECanvasShowType, isSnapshot?: boolean): OffscreenCanvas;
-    consumeDraw(dataType: EDataType, data: IWorkerMessage): Promise<void>;
-    consumeDrawAll(_type: EDataType, data: IWorkerMessage): Promise<void>;
-    clearAll(): Promise<void>;
-    private getRectImageBitmap;
-    protected updateLayer(layerOpt: ILayerOptionType): void;
-    updateCamera(msg: IWorkerMessage): Promise<void>;
-    setCameraOpt(cameraOpt: ICameraOpt, layer?: Group): void;
-    private getSnapshot;
-    private getSnapshotRender;
-    private getBoundingRect;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
+    updateDpr(dpr: number): Promise<void>;
+    constructor(viewId: string, opt: ISimpleWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
 }

package/dist/cursors/index.d.ts

@@ -1,5 +1,4 @@
-import { EventMessageType, EvevtWorkState, IMainMessage } from "../core";
-import { EventCollector } from "../collector/eventCollector";
+import { EventMessageType, EventWorkState, IMainMessage } from "../core";
 import { BaseSubWorkModuleProps, Displayer, RoomMember } from "../plugin/types";
 import { MemberDiff, RoomMemberManager } from "../members";
 import type { BaseApplianceManager } from "../plugin/baseApplianceManager";
@@ -10,7 +9,7 @@ export declare enum CursorColloctSource {
 }
 export type IServiceDrawWorkItem = {
     consumPoint: [number | undefined, number | undefined];
-    workState: EvevtWorkState;
+    workState: EventWorkState;
     viewId: string;
     timestamp: number;
 };
@@ -21,7 +20,7 @@ export type IServiceEventWorkItem = {
 };
 export type IMagixEventType = {
     type: EventMessageType;
-    op: Pick<IServiceEventWorkItem, 'consumPoint' | 'viewId'>[];
+    op: Pick<IServiceEventWorkItem, "consumPoint" | "viewId">[];
     uid: string;
 };
 export type CursorInfo = {
@@ -32,17 +31,17 @@ export type CursorInfo = {
 export type CursorInfoMapItem = CursorInfo & {
     timestamp: number;
     type: CursorColloctSource;
-    workState?: EvevtWorkState;
+    workState?: EventWorkState;
 };
 export declare abstract class CursorManager {
     /** 内部消息管理器 */
     abstract readonly internalMsgEmitter: EventEmitter2;
     /** 插件管理器 */
     abstract readonly control: BaseApplianceManager;
-    /** 事件收集器 */
-    abstract eventCollector?: EventCollector;
     /** 房间成员管理器 */
     abstract readonly roomMember: RoomMemberManager;
+    /** 是否启用cursor */
+    abstract readonly isEnableCursor: boolean;
     /** 激活事件收集器 */
     abstract activeCollector(): void;
     /** 同步事件 */
@@ -59,12 +58,12 @@ export declare abstract class CursorManager {
     abstract updateRoomMembers(diff: MemberDiff): void;
     /** 清空指定view下的所有cursor */
     abstract clearViewCursor(viewId: string): void;
-    /** 同步cursor */
-    abstract dispatchMagixEvent(): void;
 }
 export declare class CursorManagerImpl implements CursorManager {
     readonly expirationTime: number;
+    readonly isEnableCursor: boolean;
     readonly internalMsgEmitter: EventEmitter2;
+    readonly publicMsgEmitter: EventEmitter2;
     readonly control: BaseApplianceManager;
     readonly eventName: string;
     displayer?: Displayer;
@@ -79,7 +78,6 @@ export declare class CursorManagerImpl implements CursorManager {
     private cursorInfoMap;
     private doneRenderCursorInfoMap;
     constructor(props: BaseSubWorkModuleProps);
-    eventCollector?: EventCollector | undefined;
     activeCollector(): void;
     private mainMagixEventListener;
     onFocusViewChange(): void;
@@ -90,7 +88,7 @@ export declare class CursorManagerImpl implements CursorManager {
     private checkDrawWorks;
     private animationCursor;
     sendEvent(point: [number | undefined, number | undefined], viewId: string): void;
-    dispatchMagixEvent(): void;
+    private dispatchMagixEvent;
     collectServiceCursor(data: IMainMessage): void;
     unabled(): void;
     clearViewCursor(viewId: string): void;

package/dist/displayer/const.d.ts

@@ -9,3 +9,4 @@ export declare const BarPadding: Margin;
 export declare const BarMargin: Margin;
 export declare const FontSizeList: readonly number[];
 export declare const SpeechBalloonPlacements: SpeechBalloonPlacement[];
+export declare const DefaultCursorIconMap: Map<string, string>;

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

@@ -8,6 +8,7 @@ export declare const CursorManagerComponent: (props: {
         y?: number;
         roomMember?: RoomMember;
     };
+    isEnableCursor: boolean;
 }) => React.JSX.Element;
 export declare const CursorManager: (props: {
     className: string;