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

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

@@ -24,6 +24,7 @@ export declare class CopyNodeMethod extends BaseMsgMethod {
         store: BaseCollectorReducerAction;
         bgCenter?: [number, number];
         textCenter?: [number, number];
+        undoTickerId?: number;
     }): void;
     copySelector(param: {
         viewId: string;
@@ -43,5 +44,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/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/forMain.d.ts

@@ -10,7 +10,6 @@ export type RotateNodeEmtData = {
 };
 export declare class RotateNodeMethod extends BaseMsgMethod {
     readonly emitEventType: EmitEventType;
-    private undoTickerId?;
     private cacheOriginRotate;
     collect(data: RotateNodeEmtData): 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,10 +9,11 @@ export type ScaleNodeEmtData = {
     box: IRectType;
     viewId: string;
     dir?: Direction;
+    reverseY?: boolean;
+    reverseX?: boolean;
 };
 export declare class ScaleNodeMethod extends BaseMsgMethod {
     readonly emitEventType: EmitEventType;
-    private undoTickerId?;
     private targetBox;
     private targetText;
     private cacheTextInfo;

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,12 @@ export type SetColorNodeEmtData = {
     fillColor?: string;
     fontColor?: string;
     fontBgColor?: string;
-    workState?: EvevtWorkState;
+    workState: EvevtWorkState;
     viewId: string;
 };
 export declare class SetColorNodeMethod extends BaseMsgMethod {
     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/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;
+}

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,20 +44,19 @@ 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;
@@ -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;

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

@@ -16,13 +16,16 @@ export declare class TextShape extends BaseShapeTool {
     constructor(props: BaseShapeToolProps);
     consume(): IMainMessage;
     consumeAll(): IMainMessage;
+    consumeService(): IRectType | undefined;
     private draw;
-    consumeService(props: {
+    consumeServiceAsync(props: {
         isFullWork: boolean;
         replaceId?: string;
-        isDrawLabel?: boolean;
-    }): IRectType | undefined;
-    updataOptService(updateNodeOpt: IUpdateNodeOpt): IRectType | undefined;
+        isDrawLabel?: true;
+    }): Promise<IRectType | undefined>;
+    updateLabelsWidth(node: Group): void;
+    updataOptService(): IRectType | undefined;
+    updataOptServiceAsync(updateNodeOpt: IUpdateNodeOpt): Promise<IRectType | undefined>;
     clearTmpPoints(): void;
     static getFontWidth(param: {
         text: string;

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

@@ -17,9 +17,13 @@ import { TextShape } from "./text";
 import { TextOptions } from "../../component/textEditor";
 import { ImageOptions, ImageShape } from "./image";
 import type { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+import type { SubServiceThread } from "../mainThread/subServiceThread";
+import { BaseShapeTool } from "./base";
 export type ShapeTools = typeof PencilShape | typeof LaserPenShape | typeof EraserShape | typeof StarShape | typeof SelectorShape | typeof ArrowShape | typeof EllipseShape | typeof RectangleShape | typeof StarShape | typeof PolygonShape | typeof TextShape | typeof SpeechBalloonShape | typeof ImageShape;
+export type ShapeToolsClass = BaseShapeTool | PencilShape | LaserPenShape | EraserShape | StarShape | SelectorShape | ArrowShape | EllipseShape | RectangleShape | StarShape | PolygonShape | TextShape | SpeechBalloonShape | ImageShape;
 export type ShapeOptions = PencilOptions | LaserPenOptions | EraserOptions | StarOptions | SelectorOptions | ArrowOptions | EllipseOptions | RectangleOptions | StarOptions | PolygonOptions | StraightOptions | TextOptions | SpeechBalloonOptions | ImageOptions;
 export type ShapeNodes = Group | Path | Polyline | Rect | Ellipse | Sprite;
+export type ServiceThreadSubWork = SubServiceThread | ServiceWorkForFullWorker;
 export interface CombineConsumeResult {
     type: EPostMessageType;
     rect: IRectType | undefined;
@@ -28,12 +32,12 @@ export interface CombineConsumeResult {
 export interface ShapeStateInfo {
     willClear: boolean;
 }
-export declare function getShapeTools(toolsType: EToolsKey): typeof PencilShape | typeof LaserPenShape | typeof ArrowShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof StarShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof TextShape | typeof EraserShape | typeof SelectorShape | typeof ImageShape | undefined;
+export declare function getShapeTools(toolsType: EToolsKey): typeof ArrowShape | typeof PencilShape | typeof StraightShape | typeof EllipseShape | typeof PolygonShape | typeof StarShape | typeof RectangleShape | typeof SpeechBalloonShape | typeof TextShape | typeof LaserPenShape | typeof EraserShape | typeof SelectorShape | typeof ImageShape | undefined;
 export declare function getShapeInstance(param: {
     toolsType: EToolsKey;
     toolsOpt: ShapeOptions;
-    vNodes: VNodeManager;
+    vNodes?: VNodeManager;
     fullLayer: Group;
     drawLayer?: Group;
-}, serviceWork?: ServiceWorkForFullWorker): SelectorShape | PencilShape | LaserPenShape | ArrowShape | StraightShape | EllipseShape | PolygonShape | StarShape | RectangleShape | SpeechBalloonShape | TextShape | EraserShape | ImageShape | undefined;
+}, serviceWork?: ServiceThreadSubWork): ArrowShape | PencilShape | StraightShape | EllipseShape | PolygonShape | StarShape | RectangleShape | SpeechBalloonShape | TextShape | LaserPenShape | EraserShape | SelectorShape | ImageShape | undefined;
 export declare function findShapeBody(nodes: ShapeNodes[]): ShapeNodes[];

package/dist/core/types.d.ts

@@ -120,7 +120,6 @@ export type IWorkerMessage = Omit<Partial<BaseCollectorReducerAction>, 'op'> & {
     }>;
     willSerializeData?: boolean;
     isRunSubWork?: boolean;
-    undoTickerId?: number;
     scenes?: ISerializableStorageData;
     textType?: ETextEditorType;
     mainTasksqueueCount?: number;
@@ -162,7 +161,6 @@ export interface IMainMessage extends INormalPushMsg {
         workId: IworkId;
         toolsType: EToolsKey;
     }>;
-    undoTickerId?: number;
     scenePath?: string;
     canvasWidth?: number;
     canvasHeight?: number;
@@ -179,6 +177,7 @@ export interface IMainMessage extends INormalPushMsg {
     isLocked?: boolean;
     shapeOpt?: ShapeOptType;
     toolsTypes?: EToolsKey[];
+    waitWorker?: boolean;
 }
 export interface IMainMessageRenderData {
     viewId: string;
@@ -191,13 +190,13 @@ export interface IMainMessageRenderData {
     clearCanvas?: ECanvasShowType;
     /** 是否需要销毁imageBitmap */
     isUnClose?: boolean;
-    isFullWork?: boolean;
     workerType?: EDataType.Local | EDataType.Service;
     offset?: {
         x: number;
         y: number;
     };
     translate?: [number, number];
+    workId?: string;
 }
 export interface IBatchMainMessage {
     /** 绘制数据 */
@@ -206,6 +205,7 @@ export interface IBatchMainMessage {
     sp?: Array<IMainMessage>;
     drawCount?: number;
     workerTasksqueueCount?: number;
+    workIds?: Set<string>;
 }
 export interface ICameraOpt {
     centerX: number;
@@ -244,7 +244,6 @@ export interface IActiveWorkDataType {
     toolsOpt?: ShapeOptions;
     viewId?: string;
     workId?: IworkId;
-    undoTickerId?: number;
 }
 export type IServiceWorkItem = {
     toolsType: EToolsKey;
@@ -263,6 +262,16 @@ export type IServiceWorkItem = {
     totalRect?: IRectType;
     isDiff?: boolean;
 };
+export type ILocalWorkItem = {
+    toolsType: EToolsKey;
+    node: BaseShapeTool;
+    data?: IWorkerMessage;
+    result?: IMainMessage;
+    totalRect?: IRectType;
+    workState: EvevtWorkState;
+    isDel?: boolean;
+    willRefresh?: boolean;
+};
 export type BaseNodeMapItem = {
     name: string;
     rect: IRectType;
@@ -272,6 +281,9 @@ export type BaseNodeMapItem = {
     toolsType: EToolsKey;
     canRotate: boolean;
     scaleType: EScaleType;
+    /** 是否被框选中,框选中的元素不能被其它人操作 */
+    isSelected: boolean;
+    isHid?: boolean;
 };
 export type Size = {
     /**

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

@@ -361,4 +361,4 @@ export declare function toFixed(v: number): number;
  */
 export declare const isSafeFloat: (n: number) => boolean;
 export declare const requestAsyncCallBack: (callBack: () => void, timeout: number) => Promise<void>;
-export declare const getRatioWithContext: (context: CanvasRenderingContext2D) => number;
+export declare const getRatioWithContext: (context?: CanvasRenderingContext2D) => number;

package/dist/core/utils/math.d.ts

@@ -37,6 +37,7 @@ export declare function getRectTranslated(rect: IRectType, translate: [number, n
     w: number;
     h: number;
 };
+export declare function getRectRotatedPoints(rect: IRectType, angle: number): Vec2d[];
 export declare function getRectRotated(rect: IRectType, angle: number): {
     x: number;
     y: number;
@@ -49,6 +50,8 @@ export declare function getRectScaleed(rect: IRectType, scale: [number, number])
     w: number;
     h: number;
 };
+export declare function getScalePoints(points: Vec2d[], originPos: Vec2d, scale: [number, number]): Vec2d[];
+export declare function getRotatePoints(points: Vec2d[], originPos: Vec2d, angle: number): Vec2d[];
 export declare function rotatePoints(points: number[], originPos: [number, number], angle: number): void;
 export declare function scalePoints(points: number[], originPos: [number, number], scale: [number, number]): void;
 export declare function getNodeRect(key: string, layer?: Group, safeBorderPadding?: number): IRectType | undefined;

package/dist/core/utils/spriteNode.d.ts

@@ -1,4 +1,4 @@
 import { Group, Node, Path } from "spritejs";
-import { EToolsKey } from "../enum";
+import { BaseNodeMapItem } from "../types";
 export declare const isSealedGroup: (group: Group | Path | Node) => boolean;
-export declare const isRenderNode: (toolsType: EToolsKey) => boolean;
+export declare const isRenderNode: (param: Pick<BaseNodeMapItem, 'isHid'>) => boolean;