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

package/dist/component/textEditor/types.d.ts

@@ -47,4 +47,5 @@ export type TextEditorInfo = {
     dataType?: EDataType;
     translate?: [number, number];
     justLocal?: boolean;
+    waitWorker?: boolean;
 };

package/dist/component/textEditor/view.d.ts

@@ -1,18 +1,20 @@
 import React, { FocusEventHandler, KeyboardEventHandler } from "react";
 import { TextEditorInfo, TextOptions } from "./types";
-import { ApplianceViewManagerLike } from "../../plugin/types";
+import { ApplianceViewManagerLike, EmitEventType } from "../../plugin/types";
 export interface TextSelectorManagerProps {
     selectIds: string[];
     className?: string;
     editors?: Map<string, TextEditorInfo>;
     activeTextId?: string;
-    position?: {
+    box?: {
         x: number;
         y: number;
+        w: number;
+        h: number;
     };
-    textRef?: React.RefObject<HTMLDivElement>;
     manager: ApplianceViewManagerLike;
     showFloatBtns?: boolean;
+    operationType?: EmitEventType;
 }
 export interface TextViewProps {
     workId: string;
@@ -22,10 +24,8 @@ export interface TextViewProps {
     manager: ApplianceViewManagerLike;
 }
 export interface TextSelectorViewProps extends TextViewProps {
-    position?: {
-        x: number;
-        y: number;
-    };
+    left: string;
+    top: string;
     selectIds?: string[];
     updateOptInfo: (param: {
         activeTextId: string;
@@ -37,6 +37,7 @@ export interface TextEditorProps extends TextViewProps {
     showFloatBtns: boolean;
     handleKeyUp: KeyboardEventHandler<HTMLDivElement>;
     handleFocus: FocusEventHandler<HTMLDivElement>;
+    handleBlur: FocusEventHandler<HTMLDivElement>;
     updateOptInfo: (param: {
         activeTextId: string;
         update: Partial<TextOptions>;
@@ -60,6 +61,7 @@ export declare class TextViewInSelector extends React.Component<TextSelectorMana
     render(): React.JSX.Element;
 }
 export declare class TextEditorContainer extends TextViewInSelector {
+    ref: React.RefObject<HTMLDivElement> | undefined;
     constructor(props: TextSelectorManagerProps);
     handleKeyUp(e: any): void;
     handleFocus(e: any): void;

package/dist/core/enum.d.ts

@@ -103,15 +103,15 @@ export declare enum ECanvasContextType {
     Canvas2d = "2d"
 }
 export declare enum ECanvasShowType {
-    /** 本地前置画布 */
-    Float = 1,
+    None = 0,
     /** 背景画布 */
-    Bg = 2,
-    /** 选择框中的画布 */
-    Selector = 3,
+    Bg = 1,
     /** 服务端前置画布 */
-    ServiceFloat = 4,
-    None = 5
+    ServiceFloat = 2,
+    /** 本地前置画布 */
+    Float = 3,
+    /** 绝对最顶层 */
+    TopFloat = 4
 }
 export declare enum EventMessageType {
     /** cursor事件 */

package/dist/core/mainEngine.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter2 from "eventemitter2";
 import { BaseCollectorReducerAction, DiffOne } from "../collector";
 import { BaseApplianceManager } from "../plugin/baseApplianceManager";
-import { IActiveToolsDataType, IActiveWorkDataType, ICameraOpt, IRectType, IUpdateNodeOpt, IWorkerMessage, IqueryTask, IworkId, ViewWorkerOptions } from "./types";
+import { IActiveToolsDataType, IActiveWorkDataType, ICameraOpt, IMainMessage, IRectType, IUpdateNodeOpt, IWorkerMessage, IqueryTask, IworkId, ViewWorkerOptions } from "./types";
 import { BaseSubWorkModuleProps } from "../plugin/types";
 import type { ImageInformation } from "../plugin/types";
 import { MethodBuilderMain } from "./msgEvent";
@@ -108,8 +108,9 @@ export declare class MasterControlForWorker extends MasterController {
     private clearAllResolve?;
     private delayWorkStateToDone?;
     private delayWorkStateToDoneResolve?;
-    private undoTickerId?;
     private animationId;
+    private tmpImageConfigMap;
+    private mainThread?;
     constructor(props: BaseSubWorkModuleProps);
     private get viewContainerManager();
     private get collector();
@@ -118,9 +119,11 @@ export declare class MasterControlForWorker extends MasterController {
     private get isUseZIndex();
     private get isCanRecordUndoRedo();
     private get isCanSentCursor();
-    init(): void;
-    on(): void;
-    private collectorSyncData;
+    init(): Promise<void>;
+    on(): Promise<void>;
+    setMaxDrawCount(num: number): void;
+    setWorkerTasksqueueCount(num: number): void;
+    collectorSyncData(sp: IMainMessage[]): void;
     private collectorAsyncData;
     private onLocalEventEnd;
     private onLocalEventDoing;

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

@@ -0,0 +1,81 @@
+import { Group } from "spritejs";
+import { IBatchMainMessage, ICameraOpt, ILayerOptionType, IMainMessage, IOffscreenCanvasOptionType, IWorkerMessage } from "../types";
+import { VNodeManager } from "./vNodeManager";
+import type { MasterControlForWorker } from '../mainEngine';
+import type { AppViewDisplayerManager, MainViewDisplayerManager } from "../../plugin/baseViewContainerManager";
+import { EDataType } from "../enum";
+import { SubTopThread } from "./subTopThread";
+import { SubLocalThread } from "./subLocalThread";
+import { SubServiceThread } from "./subServiceThread";
+export type ICanvasOptionType = IOffscreenCanvasOptionType;
+export interface IMainThreadInitOption {
+    container: HTMLDivElement;
+    canvasOpt: ICanvasOptionType;
+    layerOpt: ILayerOptionType;
+    master: MasterControlForWorker;
+    displayer: MainViewDisplayerManager | AppViewDisplayerManager;
+    post(sp: Omit<IBatchMainMessage, 'render'>): void;
+}
+export interface ISubThreadInitOption {
+    thread: MainThreadEngineImpl;
+    vNodes: VNodeManager;
+}
+export interface ISubWorkerInitOption {
+    thread: MainThreadEngine;
+    viewId: string;
+    vNodes: VNodeManager;
+    topLayer: Group;
+    localLayer: Group;
+    serviceLayer: Group;
+    fullLayer: Group;
+}
+export interface MainThreadEngine {
+    readonly viewId: string;
+    readonly fullLayer: Group;
+    readonly topLayer: Group;
+    readonly localLayer: Group;
+    readonly serviceLayer: Group;
+    readonly vNodes: VNodeManager;
+    readonly master: MasterControlForWorker;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
+    on(msg: IWorkerMessage, workerTasksqueueCount?: number): Promise<void>;
+    post(sp: IMainMessage): void;
+    destroy(): void;
+}
+export declare class MainThreadEngineImpl implements MainThreadEngine {
+    viewId: string;
+    fullLayer: Group;
+    topLayer: Group;
+    localLayer: Group;
+    serviceLayer: Group;
+    snapshotFullLayer?: Group;
+    vNodes: VNodeManager;
+    master: MasterControlForWorker;
+    private opt;
+    private cameraOpt?;
+    private scene;
+    localWork: SubLocalThread;
+    serviceWork: SubServiceThread;
+    topWork: SubTopThread;
+    private mainThreadPostId?;
+    private combinePostMsg;
+    private methodBuilder;
+    constructor(viewId: string, opt: IMainThreadInitOption);
+    post(msg: Omit<IBatchMainMessage, 'render'>): void;
+    on(msg: IWorkerMessage, workerTasksqueueCount?: number | undefined): Promise<void>;
+    private removeNode;
+    consumeFull(type: EDataType, data: IWorkerMessage): Promise<void>;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
+    private runBatchPostData;
+    private combinePostData;
+    combinePost(): void;
+    clearAll(): void;
+    private consumeDrawAll;
+    private consumeDraw;
+    private updateCamera;
+    private createScene;
+    private createLayer;
+    private updateScene;
+    private updateLayer;
+    destroy(): void;
+}

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

@@ -0,0 +1,23 @@
+import { MasterControlForWorker } from "../mainEngine";
+import { IBatchMainMessage, IWorkerMessage } from "../types";
+import { IMainThreadInitOption, MainThreadEngineImpl } from "./base";
+import { SnapshotThreadImpl } from "./snapshotThread";
+export interface MainThreadManager {
+    master: MasterControlForWorker;
+    mainThreadMap: Map<string, MainThreadEngineImpl>;
+    createMainThread(viewId: string, opt: IMainThreadInitOption): MainThreadEngineImpl;
+    consume(msg: Set<IWorkerMessage>): void;
+    post(sp: Omit<IBatchMainMessage, 'render'>): void;
+    destroy(): void;
+}
+export declare class MainThreadManagerImpl implements MainThreadManager {
+    mainThreadMap: Map<string, MainThreadEngineImpl>;
+    private snapshotThread?;
+    master: MasterControlForWorker;
+    constructor(master: MasterControlForWorker);
+    post(msg: Omit<IBatchMainMessage, 'render'>): void;
+    destroy(): void;
+    createMainThread(viewId: string, opt: IMainThreadInitOption): MainThreadEngineImpl;
+    createSnapshotThread(viewId: string, opt: IMainThreadInitOption): SnapshotThreadImpl;
+    consume(msg: Set<IWorkerMessage>): void;
+}

package/dist/core/mainThread/snapshotThread.d.ts

@@ -0,0 +1,40 @@
+import { Group } from "spritejs";
+import { IMainThreadInitOption } from "./base";
+import { MasterControlForWorker } from "../mainEngine";
+import { IActiveToolsDataType, IBatchMainMessage, ICameraOpt, IRectType, IWorkerMessage, IworkId } from "../types";
+import type { BaseShapeTool } from "../tools/base";
+import type { ImageShape } from "../tools/image";
+export declare class SnapshotThreadImpl {
+    viewId: string;
+    fullLayer: Group;
+    master: MasterControlForWorker;
+    private opt;
+    private scene;
+    private mainThreadPostId?;
+    private combinePostMsg;
+    workShapes: Map<IworkId, BaseShapeTool>;
+    constructor(viewId: string, opt: IMainThreadInitOption);
+    post(msg: Omit<IBatchMainMessage, 'render'>): void;
+    on(msg: IWorkerMessage): Promise<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 | ImageShape | undefined;
+    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | import("../tools/text").TextShape | import("../tools").LaserPenShape | undefined;
+    runFullWork(data: IWorkerMessage, isDrawLabel?: boolean): Promise<IRectType | undefined>;
+    private getSnapshot;
+    private updateLabels;
+    private willRenderSpecialLabel;
+    private getSceneRect;
+    private getRectImageBitmap;
+    private getSnapshotRender;
+    private getBoundingRect;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
+    private runBatchPostData;
+    private combinePostData;
+    combinePost(): void;
+    private createScene;
+    private createLayer;
+    private updateScene;
+    private updateLayer;
+    destroy(): void;
+}

package/dist/core/mainThread/subLocalThread.d.ts

@@ -0,0 +1,101 @@
+import { IworkId, IActiveToolsDataType, IWorkerMessage, IMainMessage, IUpdateSelectorPropsType, IBatchMainMessage } from "../types";
+import type { BaseShapeTool, BaseShapeOptions, SelectorShape, ImageShape, ShapeToolsClass, PencilShape } from "../tools";
+import { MainThreadEngineImpl, ISubThreadInitOption } from "./base";
+import { VNodeManager } from "./vNodeManager";
+import { EToolsKey } from "../enum";
+import { Scene } from "spritejs";
+import { SubServiceThread } from "./subServiceThread";
+export interface SubLocalThread {
+    readonly vNodes: VNodeManager;
+    readonly thread: MainThreadEngineImpl;
+    workShapes: Map<IworkId, BaseShapeTool>;
+    effectSelectNodeData: Set<IWorkerMessage>;
+    destroy(): void;
+    clearAll(): void;
+    clearWorkShapeNodeCache(workId: IworkId): void;
+    setToolsOpt(opt: IActiveToolsDataType): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: IworkId;
+    }): void;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: SubServiceThread): void;
+    consumeDraw(data: IWorkerMessage, serviceWork: SubServiceThread): void;
+    colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;
+    reRenderSelector(willSyncService?: boolean): void;
+    blurSelector(data?: IWorkerMessage): Promise<void>;
+    getWorkShape(workId: IworkId): BaseShapeTool | undefined;
+    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): ShapeToolsClass | undefined;
+    consumeFull(data: IWorkerMessage, scene?: Scene): Promise<void>;
+    removeWork(data: IWorkerMessage): void;
+    updateFullSelectWork(data: IWorkerMessage): void;
+    cursorHover(msg: IWorkerMessage): void;
+    checkTextActive(data: IWorkerMessage): Promise<void>;
+    removeNode(key: string): void;
+    updateSelector(params: IUpdateSelectorPropsType & {
+        callback?: (props: {
+            res?: IMainMessage;
+            param: IUpdateSelectorPropsType;
+            postData: Pick<IBatchMainMessage, 'sp' | 'render'>;
+            workShapeNode: SelectorShape;
+            newServiceStore: Map<string, {
+                opt: BaseShapeOptions;
+                toolsType: EToolsKey;
+                ops?: string;
+            }>;
+        }) => void;
+    }): Promise<IMainMessage | undefined>;
+}
+export declare class SubLocalThreadImpl implements SubLocalThread {
+    readonly vNodes: VNodeManager;
+    readonly thread: MainThreadEngineImpl;
+    workShapes: Map<IworkId, BaseShapeTool>;
+    effectSelectNodeData: Set<IWorkerMessage>;
+    private batchEraserRemoveNodes;
+    private batchEraserWorks;
+    private tmpOpt?;
+    private tmpWorkShapeNode?;
+    private drawCount;
+    constructor(opt: ISubThreadInitOption);
+    updateSelector(params: IUpdateSelectorPropsType & {
+        callback?: ((props: {
+            res?: IMainMessage | undefined;
+            param: IUpdateSelectorPropsType;
+            postData: Pick<IBatchMainMessage, "sp">;
+            workShapeNode: SelectorShape;
+            newServiceStore: Map<string, {
+                opt: BaseShapeOptions;
+                toolsType: EToolsKey;
+                ops?: string | undefined;
+            }>;
+        }) => void) | undefined;
+    }): Promise<IMainMessage | undefined>;
+    destroy(): void;
+    private clearAllWorkShapesCache;
+    clearAll(): void;
+    checkTextActive(data: IWorkerMessage): Promise<void>;
+    cursorHover(msg: IWorkerMessage): void;
+    updateFullSelectWork(data: IWorkerMessage): void;
+    removeWork(data: IWorkerMessage): void;
+    removeNode(key: string): void;
+    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | import("../tools/text").TextShape | import("../tools").LaserPenShape | undefined;
+    consumeFull(data: IWorkerMessage, scene?: Scene): Promise<void>;
+    colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;
+    private runEffectSelectWork;
+    reRenderSelector(willSyncService?: boolean): Promise<void> | undefined;
+    blurSelector(data?: IWorkerMessage): Promise<void>;
+    clearWorkShapeNodeCache(workId: IworkId): void;
+    private drawEraser;
+    private updateBatchEraserCombineNode;
+    private batchEraserCombine;
+    getWorkShape(workId: IworkId): BaseShapeTool | undefined;
+    consumeDraw(data: IWorkerMessage, serviceWork: SubServiceThread): void;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: SubServiceThread): void;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    setToolsOpt(opt: IActiveToolsDataType): void;
+    setTmpWorkId(workId: IworkId | undefined): void;
+    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: IworkId;
+    }): import("../tools").ArrowShape | 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 | SelectorShape | ImageShape | undefined;
+}

package/dist/core/mainThread/subServiceThread.d.ts

@@ -0,0 +1,42 @@
+import { IServiceWorkItem, IWorkerMessage } from "../types";
+import { MainThreadEngineImpl, ISubThreadInitOption } from "./base";
+import { VNodeManager } from "./vNodeManager";
+export interface SubServiceThread {
+    workShapes: Map<string, IServiceWorkItem>;
+    selectorWorkShapes: Map<string, IServiceWorkItem>;
+    destroy(): void;
+    clearAll(): void;
+    consumeDraw(data: IWorkerMessage): void;
+    runReverseSelectWork(selectIds: string[]): void;
+    consumeFull(data: IWorkerMessage): void;
+    removeWork(data: IWorkerMessage): void;
+    runSelectWork(data: IWorkerMessage): void;
+}
+export declare class SubServiceThreadImpl implements SubServiceThread {
+    readonly vNodes: VNodeManager;
+    readonly thread: MainThreadEngineImpl;
+    workShapes: Map<string, IServiceWorkItem>;
+    selectorWorkShapes: Map<string, IServiceWorkItem>;
+    private willRunEffectSelectorIds;
+    private runEffectId?;
+    private animationId?;
+    constructor(opt: ISubThreadInitOption);
+    destroy(): void;
+    clearAll(): void;
+    private runEffect;
+    private effectRunSelector;
+    runSelectWork(data: IWorkerMessage): void;
+    removeWork(data: IWorkerMessage): void;
+    consumeFull(data: IWorkerMessage): void;
+    runReverseSelectWork(selectIds: string[]): void;
+    consumeDraw(data: IWorkerMessage): void;
+    private computNextAnimationIndex;
+    private animationDraw;
+    private runAnimation;
+    private hasDiffData;
+    private activeWorkShape;
+    private removeNode;
+    private removeSelectWork;
+    private activeSelectorShape;
+    private setNodeKey;
+}

package/dist/core/mainThread/subTopThread.d.ts

@@ -0,0 +1,46 @@
+import { IServiceWorkItem, IworkId, ILocalWorkItem, IActiveToolsDataType, IWorkerMessage } from "../types";
+import { BaseShapeTool, BaseShapeOptions } from "../tools";
+import { MainThreadEngineImpl, ISubThreadInitOption } from "./base";
+import { VNodeManager } from "./vNodeManager";
+export interface SubTopThread {
+    readonly vNodes: VNodeManager;
+    readonly thread: MainThreadEngineImpl;
+    serviceWorkShapes: Map<string, IServiceWorkItem>;
+    localWorkShapes: Map<IworkId, ILocalWorkItem>;
+    destroy(): void;
+    clearAll(): void;
+    setToolsOpt(opt: IActiveToolsDataType): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: IworkId;
+    }): BaseShapeTool | undefined;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    consumeDrawAll(data: IWorkerMessage): void;
+    consumeDraw(data: IWorkerMessage): void;
+}
+export declare class SubTopThreadImpl implements SubTopThread {
+    readonly vNodes: VNodeManager;
+    readonly thread: MainThreadEngineImpl;
+    serviceWorkShapes: Map<string, IServiceWorkItem>;
+    localWorkShapes: Map<IworkId, ILocalWorkItem>;
+    private tmpOpt?;
+    private tmpWorkShapeNode?;
+    private animationId?;
+    constructor(opt: ISubThreadInitOption);
+    destroy(): void;
+    clearAll(): void;
+    consumeDraw(data: IWorkerMessage): void;
+    setToolsOpt(opt: IActiveToolsDataType): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: IworkId | undefined;
+    }): BaseShapeTool | undefined;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    private setTmpWorkId;
+    private setNodeKey;
+    private activeServiceWorkShape;
+    private computNextAnimationIndex;
+    private animationDraw;
+    private runAnimation;
+    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    consumeDrawAll(data: IWorkerMessage): void;
+}

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

@@ -0,0 +1,32 @@
+import { Group, Scene } from "spritejs";
+import { BaseNodeMapItem, IRectType } from "../types";
+export declare class VNodeManager {
+    viewId: string;
+    scene: Scene;
+    fullLayer?: Group;
+    curNodeMap: Map<string, BaseNodeMapItem>;
+    targetNodeMap: Map<string, BaseNodeMapItem>[];
+    constructor(viewId: string, scene: Scene);
+    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;
+    getRectIntersectRange(rect: IRectType, filterLock?: boolean): {
+        rectRange: IRectType | undefined;
+        nodeRange: Map<string, BaseNodeMapItem>;
+    };
+    getNodeRectFormShape(name: string, value: BaseNodeMapItem): IRectType | undefined;
+    updateNodesRect(): void;
+    combineIntersectRect(rect: IRectType): IRectType;
+    setTarget(): number;
+    getLastTarget(): Map<string, BaseNodeMapItem>;
+    deleteLastTarget(): void;
+    getTarget(i: number): Map<string, BaseNodeMapItem>;
+    deleteTarget(i: number): void;
+}

package/dist/core/msgEvent/baseForMainThread.d.ts

@@ -0,0 +1,13 @@
+import type { Scene } from "spritejs";
+import { EmitEventType } from "../../plugin/types";
+import { IWorkerMessage } from "../types";
+import { SubLocalThread } from "../mainThread/subLocalThread";
+import { SubServiceThread } from "../mainThread/subServiceThread";
+export declare abstract class BaseMsgMethodForMainThread {
+    abstract readonly emitEventType: EmitEventType;
+    localWork?: SubLocalThread;
+    serviceWork?: SubServiceThread;
+    scene: Scene | undefined;
+    registerMainThread(localWork: SubLocalThread, serviceWork?: SubServiceThread, scene?: Scene): this;
+    abstract consume(data: IWorkerMessage): Promise<boolean | undefined>;
+}

package/dist/core/msgEvent/copyNode/forMainThread.d.ts

@@ -0,0 +1,8 @@
+import { EmitEventType } from "../../../plugin/types";
+import { IWorkerMessage } from "../../types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+export declare class CopyNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+}

package/dist/core/msgEvent/deleteNode/forMainThread.d.ts

@@ -0,0 +1,13 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage, IworkId } from "../../types";
+export type DeleteNodeEmtData = {
+    workIds: IworkId[];
+};
+export declare class DeleteNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): void;
+    consumeForServiceWorker(data: IWorkerMessage): void;
+    private commandDeleteText;
+}

package/dist/core/msgEvent/forMainThread.d.ts

@@ -0,0 +1,14 @@
+import { EmitEventType } from '../../plugin/types';
+import { BaseMsgMethodForMainThread } from './baseForMainThread';
+import { IWorkerMessage } from '../types';
+import type { Scene } from 'spritejs';
+import type { SubLocalThread } from '../mainThread/subLocalThread';
+import type { SubServiceThread } from '../mainThread/subServiceThread';
+export type MsgMethodForMainThread<T extends BaseMsgMethodForMainThread> = T;
+export declare class MethodBuilderWorker {
+    builders: Map<EmitEventType, MsgMethodForMainThread<BaseMsgMethodForMainThread> | undefined>;
+    constructor(emitTypes: EmitEventType[]);
+    build(type: EmitEventType): MsgMethodForMainThread<BaseMsgMethodForMainThread> | undefined;
+    registerForMainThread(localWork: SubLocalThread, serviceWork?: SubServiceThread, scene?: Scene): this;
+    consumeForMainThread(data: IWorkerMessage): Promise<boolean>;
+}

package/dist/core/msgEvent/rotateNode/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class RotateNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/scaleNode/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class ScaleNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/setColor/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class SetColorNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/setFont/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class SetFontStyleMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/setLock/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class SetLockMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/setPoint/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class SetPointMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/setShape/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class SetShapeOptMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/setZIndex/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class ZIndexNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}

package/dist/core/msgEvent/translateNode/forMain.d.ts

@@ -14,7 +14,6 @@ export type TranslateNodeEmtData = {
 export declare class TranslateNodeMethod extends BaseMsgMethod {
     readonly emitEventType: EmitEventType;
     private undoTickerId?;
-    private oldRect;
     private cachePosition;
     collect(data: TranslateNodeEmtData): void;
 }

package/dist/core/msgEvent/translateNode/forMainThread.d.ts

@@ -0,0 +1,9 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+export declare class TranslateNodeMethodForMainThread extends BaseMsgMethodForMainThread {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): Promise<boolean | undefined>;
+    consumeForLocalWorker(data: IWorkerMessage): Promise<void>;
+    private updateSelectorCallback;
+}