@netless/appliance-plugin 1.1.22-beta.1 → 1.1.22-beta.10

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

@@ -6,7 +6,7 @@ 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;
@@ -15,9 +15,17 @@ export interface IWorkerInitOption {
     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;
@@ -26,12 +34,12 @@ export interface ISubWorkerInitOption {
 }
 export declare abstract class WorkThreadEngineBase {
     readonly viewId: string;
+    readonly type: EWorkThreadType;
     scene: Scene;
     fullLayer: Group;
     readonly vNodes: VNodeManager;
     dpr: number;
     readonly contextType?: ECanvasContextType;
-    abstract readonly type: EWorkThreadType;
     protected opt: IWorkerInitOption;
     protected cameraOpt?: ICameraOpt;
     abstract localWork: LocalWorkForFullWorker | LocalWorkForSubWorker;
@@ -45,7 +53,6 @@ export declare abstract class WorkThreadEngineBase {
         workName: EmitEventType;
         workState: EvevtWorkState;
     };
-    protected hasPriorityDraw: boolean;
     protected delayPostDoneResolve?: (bol: boolean) => void;
     protected cacheImages: Map<string, {
         imageBitmap: ImageBitmap;
@@ -58,25 +65,23 @@ export declare abstract class WorkThreadEngineBase {
     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>;
     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;
@@ -94,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;

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

@@ -1,21 +1,31 @@
-import { IWorkerMessage, IMainMessage, IRectType, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType } from "..";
+import { EPostMessageType, IWorkerMessage, IMainMessage, IRectType, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType, EDataType } 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 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;
+    protected effectSelectNodeData: Set<IWorkerMessage>;
     constructor(opt: ISubWorkerInitOption);
     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;
+    protected commandDeleteText(workId: string): {
+        type: EPostMessageType;
+        toolsType: EToolsKey;
+        workId: string;
+        dataType: EDataType;
+    } | undefined;
     removeSelector(data: IWorkerMessage, workEngine?: WorkThreadEngineForFullWorker): Promise<void>;
     removeWork(data: IWorkerMessage): Promise<void>;
     removeNode(key: string): {
@@ -45,15 +55,15 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     reRenderSelector(willSyncService?: boolean): Promise<void>;
     updateFullSelectWork(data: IWorkerMessage): Promise<void>;
     destroy(): void;
-    private drawEraserCombine;
-    private drawPencilCombine;
-    private drawSelector;
-    private drawPencilFull;
-    private drawEraserFull;
-    private drawEraser;
-    private drawShape;
-    private drawPencil;
-    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): Promise<void>;
+    protected drawEraserFull(workShapeNode: BitMapEraserShape | PencilEraserShape, res: IMainMessage, isLockSentEventCursor?: boolean): Promise<void>;
+    protected drawEraser(result: IMainMessage, isLockSentEventCursor?: boolean): 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,27 @@
+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";
+/** 本地绘制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 | 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,12 +1,10 @@
-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>;

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;
+    _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
     private debounceUpdateCache;
     constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
     combinePost(): Promise<void>;
@@ -49,36 +75,24 @@ export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase
     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;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
     updateDpr(dpr: number): Promise<void>;
-    updateCamera(msg: IWorkerMessage): Promise<void>;
-    setCameraOpt(cameraOpt: ICameraOpt, layer?: Group): void;
-    private getSnapshot;
-    private getSnapshotRender;
-    private getBoundingRect;
+    constructor(viewId: string, opt: ISimpleWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
 }