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

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/straight").StraightShape | import("../tools").PolygonShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | 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>;
+    runFullWork(data: IWorkerMessage): 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;

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,50 @@ 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>;
+    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>>>;