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

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

@@ -6,13 +6,17 @@ import { MasterController } from "../mainEngine";
 export declare abstract class BaseMsgMethod {
     static dispatch(emtType: InternalMsgEmitterType, emitEventType: EmitEventType, value: unknown): void;
     abstract readonly emitEventType: EmitEventType;
+    protected abstract lastEmtData?: unknown;
+    private useEmtMsg?;
     emtType: InternalMsgEmitterType;
     control: BaseApplianceManager;
     mainEngine: MasterController;
     get serviceColloctor(): import("../../collector").Collector | undefined;
     registerForMainEngine(emtType: InternalMsgEmitterType, control: BaseApplianceManager): this;
     destroy(): void;
-    collectForLocalWorker(data: [IWorkerMessage, IqueryTask][]): void;
+    collectForLocalWorker(data: [IWorkerMessage, IqueryTask][], isSync?: boolean): void;
     collectForServiceWorker(actions: BaseCollectorReducerAction[]): void;
-    abstract collect(data: unknown): void;
+    abstract collect(data: unknown, isSync?: boolean): void;
+    pause(): void;
+    recover(): 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/forMain.d.ts

@@ -8,6 +8,7 @@ export type CopyNodeEmtData = {
     viewId: string;
 };
 export declare class CopyNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     collect(data: CopyNodeEmtData): void;
     copyText(param: {
@@ -24,6 +25,7 @@ export declare class CopyNodeMethod extends BaseMsgMethod {
         store: BaseCollectorReducerAction;
         bgCenter?: [number, number];
         textCenter?: [number, number];
+        undoTickerId?: number;
     }): void;
     copySelector(param: {
         viewId: string;
@@ -43,5 +45,6 @@ export declare class CopyNodeMethod extends BaseMsgMethod {
             offset: Point;
             cameraOpt: Pick<ICameraOpt, 'centerX' | 'centerY' | 'scale'>;
         };
+        undoTickerId?: number;
     }): void;
 }

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/forMain.d.ts

@@ -6,6 +6,7 @@ export type DeleteNodeEmtData = {
     viewId: string;
 };
 export declare class DeleteNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     collect(data: DeleteNodeEmtData): void;
 }

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

@@ -0,0 +1,10 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForMainThread } from "../baseForMainThread";
+import { IWorkerMessage } from "../../types";
+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/deleteNode/forWorker.d.ts

@@ -1,9 +1,6 @@
 import { EmitEventType } from "../../../plugin/types";
 import { BaseMsgMethodForWorker } from "../baseForWorker";
-import { IWorkerMessage, IworkId } from "../../types";
-export type DeleteNodeEmtData = {
-    workIds: IworkId[];
-};
+import { IWorkerMessage } from "../../types";
 export declare class DeleteNodeMethodForWorker extends BaseMsgMethodForWorker {
     readonly emitEventType: EmitEventType;
     consume(data: IWorkerMessage): boolean | undefined;

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/index.d.ts

@@ -11,5 +11,9 @@ export declare class MethodBuilderMain {
     getBuilder(type: EmitEventType): BaseMsgMethod | undefined;
     registerForMainEngine(emtType: InternalMsgEmitterType, control: BaseApplianceManager): this;
     destroy(): void;
+    pause(): this;
+    recover(): this;
     static emitMethod(emtType: InternalMsgEmitterType, type: EmitEventType, data: unknown): undefined;
+    static activeListener(callback: (isActive: boolean) => void): void;
+    static unmountActiveListener(callback: (isActive: boolean) => void): void;
 }

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

@@ -9,8 +9,8 @@ export type RotateNodeEmtData = {
     viewId: string;
 };
 export declare class RotateNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: RotateNodeEmtData;
     readonly emitEventType: EmitEventType;
-    private undoTickerId?;
     private cacheOriginRotate;
-    collect(data: RotateNodeEmtData): void;
+    collect(data: RotateNodeEmtData, isSync?: boolean): void;
 }

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/forMain.d.ts

@@ -9,12 +9,14 @@ export type ScaleNodeEmtData = {
     box: IRectType;
     viewId: string;
     dir?: Direction;
+    reverseY?: boolean;
+    reverseX?: boolean;
 };
 export declare class ScaleNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: ScaleNodeEmtData;
     readonly emitEventType: EmitEventType;
-    private undoTickerId?;
     private targetBox;
     private targetText;
     private cacheTextInfo;
-    collect(data: ScaleNodeEmtData): Promise<void>;
+    collect(data: ScaleNodeEmtData, isSync?: boolean): Promise<void>;
 }

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/forMain.d.ts

@@ -8,11 +8,13 @@ export type SetColorNodeEmtData = {
     fillColor?: string;
     fontColor?: string;
     fontBgColor?: string;
-    workState?: EvevtWorkState;
+    workState: EvevtWorkState;
     viewId: string;
 };
 export declare class SetColorNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
+    private undoTickerId?;
     private setTextColor;
     collect(data: SetColorNodeEmtData): void;
 }

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/forMain.d.ts

@@ -12,6 +12,7 @@ export type SetFontEmtData = {
     viewId: string;
 };
 export declare class SetFontStyleMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     private setTextStyle;
     collect(data: SetFontEmtData): void;

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/forMain.d.ts

@@ -7,6 +7,7 @@ export type SetLockEmitData = {
     viewId: string;
 };
 export declare class SetLockMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     collect(data: SetLockEmitData): void;
 }

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/forMain.d.ts

@@ -9,6 +9,7 @@ export type SetPointEmtData = {
     viewId: string;
 };
 export declare class SetPointMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     private undoTickerId?;
     collect(data: SetPointEmtData): void;

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/forMain.d.ts

@@ -13,6 +13,7 @@ export type SetShapeEmtData = {
     placement?: SpeechBalloonPlacement;
 };
 export declare class SetShapeOptMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     collect(data: SetShapeEmtData): void;
 }

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/forMain.d.ts

@@ -8,6 +8,7 @@ export type ZIndexNodeEmtData = {
     viewId: string;
 };
 export declare class ZIndexNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: unknown;
     readonly emitEventType: EmitEventType;
     private zIndexMap;
     clearZIndex(viewId: string): void;

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

@@ -12,9 +12,9 @@ export type TranslateNodeEmtData = {
     viewId: string;
 };
 export declare class TranslateNodeMethod extends BaseMsgMethod {
+    protected lastEmtData?: TranslateNodeEmtData;
     readonly emitEventType: EmitEventType;
     private undoTickerId?;
-    private oldRect;
     private cachePosition;
-    collect(data: TranslateNodeEmtData): void;
+    collect(data: TranslateNodeEmtData, isSync?: boolean): 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;
+}

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

@@ -20,9 +20,9 @@ export declare class ArrowShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -22,7 +22,7 @@ export interface BaseShapeOptions {
     translate?: [number, number];
 }
 export interface BaseShapeToolProps {
-    vNodes: VNodeManager;
+    vNodes?: VNodeManager;
     toolsOpt: ShapeOptions;
     fullLayer: Group;
     drawLayer?: Group;
@@ -34,7 +34,7 @@ export declare abstract class BaseShapeTool {
     readonly abstract canRotate: boolean;
     readonly abstract scaleType: EScaleType;
     syncUnitTime: number;
-    vNodes: VNodeManager;
+    vNodes?: VNodeManager;
     protected drawLayer?: Group;
     protected fullLayer: Group;
     protected workId: number | string | undefined;
@@ -44,25 +44,24 @@ export declare abstract class BaseShapeTool {
     abstract consume(props: {
         data: IWorkerMessage;
         isFullWork?: boolean;
-        isClearAll?: boolean;
         isSubWorker?: boolean;
+        drawCount?: number;
+        isMainThread?: boolean;
     }): IMainMessage;
     /** 消费本地完整数据，返回绘制结果 */
     abstract consumeAll(props: {
         data?: IWorkerMessage;
-        hoverId?: string;
     }): IMainMessage;
     /** 消费服务端数据，返回绘制结果 */
     abstract consumeService(props: {
         op: number[];
         isFullWork: boolean;
         replaceId?: string;
-        isClearAll?: boolean;
     }): IRectType | undefined;
     /** 清除临时数据 */
     abstract clearTmpPoints(): void;
     /** 设置工作id */
-    setWorkId(id: number | string | undefined): void;
+    setWorkId(id: string | undefined): void;
     getWorkId(): string | number | undefined;
     /** 获取工作选项配置 */
     getWorkOptions(): ShapeOptions;
@@ -70,6 +69,7 @@ export declare abstract class BaseShapeTool {
     setWorkOptions(workOptions: BaseShapeOptions): void;
     /** 更新服务端同步配置,返回绘制结果 */
     updataOptService(opt?: IUpdateNodeOpt): IRectType | undefined;
+    replace(layer: Group, replaceId: string, newNode: ShapeNodes): void;
     static updateNodeOpt(param: {
         node: ShapeNodes;
         opt: IUpdateNodeOpt;

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

@@ -20,9 +20,9 @@ export declare class EllipseShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -1,7 +1,7 @@
 import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { EScaleType, EToolsKey } from "../enum";
 import { IWorkerMessage, IMainMessage, IRectType } from "../types";
-import type { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+import type { ServiceThreadSubWork } from "./utils";
 export interface EraserOptions extends BaseShapeOptions {
     thickness: number;
     isLine: boolean;
@@ -10,7 +10,7 @@ export declare class EraserShape extends BaseShapeTool {
     readonly canRotate: boolean;
     readonly scaleType: EScaleType;
     readonly toolsType: EToolsKey;
-    readonly serviceWork?: ServiceWorkForFullWorker;
+    readonly serviceWork?: ServiceThreadSubWork;
     private static readonly eraserSizes;
     protected tmpPoints: Array<number>;
     protected workOptions: EraserOptions;
@@ -18,7 +18,7 @@ export declare class EraserShape extends BaseShapeTool {
     worldScaling: [number, number];
     eraserRect: IRectType | undefined;
     eraserPolyline?: [number, number, number, number];
-    constructor(props: BaseShapeToolProps, serviceWork?: ServiceWorkForFullWorker);
+    constructor(props: BaseShapeToolProps, serviceWork?: ServiceThreadSubWork);
     combineConsume(): undefined;
     consumeService(): IRectType | undefined;
     setWorkOptions(setWorkOptions: EraserOptions): void;

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

@@ -41,8 +41,10 @@ export declare class ImageShape extends BaseShapeTool {
         isFullWork: boolean;
         scene: Scene;
         replaceId?: string;
+        isMainThread?: boolean;
     }): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
+    static getScaleType(opt: ImageOptions): EScaleType.all | EScaleType.proportional;
     static updateNodeOpt(param: {
         node: ShapeNodes;
         opt: IUpdateNodeOpt;

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

@@ -29,8 +29,10 @@ export declare class PencilShape extends BaseShapeTool {
     consume(props: {
         data: IWorkerMessage;
         isFullWork?: boolean;
-        isClearAll?: boolean;
         isSubWorker?: boolean;
+        drawCount?: number;
+        isMainThread?: boolean;
+        replaceId?: string;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage;
@@ -40,7 +42,6 @@ export declare class PencilShape extends BaseShapeTool {
         op: number[];
         isFullWork?: boolean;
         replaceId?: string;
-        isClearAll?: boolean;
     }): IRectType | undefined;
     private transformDataAll;
     private draw;

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

@@ -21,9 +21,10 @@ export declare class PolygonShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -22,9 +22,10 @@ export declare class RectangleShape extends BaseShapeTool {
     private computDrawPoints;
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -3,10 +3,11 @@ import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
 import { EDataType, EPostMessageType, EScaleType, EToolsKey } from "../enum";
 import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt, IServiceWorkItem } from "../types";
 import { Point2d } from "../utils/primitives/Point2d";
-import { VNodeManager } from "../worker/vNodeManager";
+import type { VNodeManager } from "../worker/vNodeManager";
 import { TextOptions } from "../../component/textEditor/types";
 import { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
 import { ShapeOptType } from "../../displayer/types";
+import type { SubLocalThread } from "../mainThread/subLocalThread";
 export interface SelectorOptions extends BaseShapeOptions {
 }
 export declare class SelectorShape extends BaseShapeTool {
@@ -15,6 +16,7 @@ export declare class SelectorShape extends BaseShapeTool {
     static selectorBorderId: string;
     protected tmpPoints: Array<Point2d>;
     protected workOptions: BaseShapeOptions;
+    vNodes: VNodeManager;
     selectIds?: string[];
     selectorColor?: string;
     strokeColor?: string;
@@ -28,7 +30,7 @@ export declare class SelectorShape extends BaseShapeTool {
     shapeOpt?: ShapeOptType;
     textOpt?: TextOptions;
     isLocked?: boolean;
-    constructor(props: BaseShapeToolProps);
+    constructor(props: Required<BaseShapeToolProps>);
     private computSelector;
     private updateTempPoints;
     private drawSelector;
@@ -38,15 +40,14 @@ export declare class SelectorShape extends BaseShapeTool {
     consume(props: {
         data: IWorkerMessage;
     }): IMainMessage;
-    consumeAll(props?: {
-        hoverId?: string;
-    }): IMainMessage;
+    consumeAll(): IMainMessage;
     consumeService(): undefined;
     clearTmpPoints(): void;
     clearSelectData(): void;
     private selectSingleTool;
-    private backToFullLayer;
-    private sealToDrawLayer;
+    private unSelectedAllIds;
+    private unSelectedByIds;
+    private selectedByIds;
     private getSelectorRect;
     isCanFillColor(toolsType?: EToolsKey): boolean;
     updateSelector(param: {
@@ -54,9 +55,10 @@ export declare class SelectorShape extends BaseShapeTool {
         vNodes: VNodeManager;
         selectIds?: string[];
         willSerializeData?: boolean;
-        worker?: LocalWorkForFullWorker;
+        worker?: LocalWorkForFullWorker | SubLocalThread;
         offset?: [number, number];
         scene?: Scene;
+        isMainThread?: boolean;
     }): Promise<IMainMessage | undefined>;
     blurSelector(): {
         type: EPostMessageType;
@@ -65,7 +67,7 @@ export declare class SelectorShape extends BaseShapeTool {
         selectIds: never[];
         willSyncService: boolean;
     };
-    private getRightServiceId;
+    getRightServiceId(serviceWorkId: string): string;
     selectServiceNode(workId: string, workItem: Pick<IServiceWorkItem, 'selectIds'>, isService: boolean): IRectType | undefined;
     reRenderSelector(): IRectType | undefined;
     updateSelectIds(nextSelectIds: string[]): {

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

@@ -23,9 +23,10 @@ export declare class SpeechBalloonShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -23,9 +23,9 @@ export declare class StarShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;

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

@@ -20,9 +20,10 @@ export declare class StraightShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(props: {
         data: IWorkerMessage;
-        isFullWork?: boolean | undefined;
-        isClearAll?: boolean | undefined;
-        isSubWorker?: boolean | undefined;
+        isFullWork?: boolean;
+        isClearAll?: boolean;
+        isSubWorker?: boolean;
+        isMainThread?: boolean;
     }): IMainMessage;
     consumeAll(props: {
         data?: IWorkerMessage | undefined;