@netless/appliance-plugin 1.0.0-beta.0

package/dist/core/mainEngine.d.ts

@@ -0,0 +1,163 @@
+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 { BaseSubWorkModuleProps } from "../plugin/types";
+import type { ImageInformation } from "../plugin/types";
+import { MethodBuilderMain } from "./msgEvent";
+import { EToolsKey, EvevtWorkState } from "./enum";
+export declare abstract class MasterController {
+    /** 异步同步时间间隔 */
+    maxLastSyncTime: number;
+    /** 插件管理器 */
+    readonly abstract control: BaseApplianceManager;
+    readonly abstract internalMsgEmitter: EventEmitter2;
+    /** worker线程管理器 */
+    /** 本地原始点数据批任务数据池 */
+    protected abstract localPointsBatchData: number[];
+    /** 事件任务处理批量池 */
+    abstract taskBatchData: Set<IWorkerMessage>;
+    /** 主线程和工作线程通信机 */
+    protected abstract fullWorker: Worker;
+    /** 子线程和工作线程通信机 */
+    protected abstract subWorker: Worker;
+    /** 当前选中的工具配置数据 */
+    abstract currentToolsData?: IActiveToolsDataType;
+    /** 当前工作任务数据 */
+    protected abstract currentLocalWorkData: IActiveWorkDataType;
+    /** 设置当前选中的工具配置数据 */
+    setCurrentToolsData(currentToolsData: IActiveToolsDataType): void;
+    getCurrentToolsData(): IActiveToolsDataType | undefined;
+    /** 设置当前绘制任务数据 */
+    protected setCurrentLocalWorkData(currentLocalWorkData: IActiveWorkDataType): void;
+    /** 获取当前激活的工作任务id */
+    protected getWorkId(): IworkId | undefined;
+    /** 获取当前work的工作状态 */
+    getWorkState(): EvevtWorkState;
+    /** 用于接收服务端同步的数据 */
+    abstract onServiceDerive(key: string, data: DiffOne<BaseCollectorReducerAction | undefined>): void;
+    /** 消费批处理池数据 */
+    abstract consume(): void;
+    /** 运行异步动画逻辑 */
+    abstract runAnimation(): void;
+    /** 禁止写入 */
+    abstract unWritable(): void;
+    /** 可以使用 */
+    abstract abled(): void;
+    /** 当前状态是否可以写入 */
+    abstract isAbled(): boolean;
+    /** 销毁 */
+    abstract destroy(): void;
+    /** 服务端拉取数据初始化 */
+    abstract pullServiceData(viewId: string, scenePath: string): void;
+    /** 主线程和工作线程通信,推送 */
+    abstract post(msg: Set<IWorkerMessage>): void;
+    /** 主线程和工作线程通信,接收 */
+    abstract on(): void;
+    /** 更新已有node配置 */
+    abstract updateNode(workId: IworkId, updateNodeOpt: IUpdateNodeOpt, viewId: string, scenePath: string): void;
+    /** 清空指定的view场景路径下的所有数据 */
+    abstract clearViewScenePath(viewId: string, justLocal?: boolean): Promise<void>;
+    /** 更新指定view场景路径下的相机参数 */
+    abstract updateCamera(viewId: string, cameraOpt: ICameraOpt): void;
+    /**  创建一个新的viewWorker */
+    abstract createViewWorker(viewId: string, options: ViewWorkerOptions): void;
+    /** 本地发送cursor事件 */
+    abstract sendCursorEvent(point: [number | undefined, number | undefined], viewId: string): void;
+    /** 获取某个场景路径下的包围盒 */
+    abstract getBoundingRect(scenePath: string): Promise<IRectType> | undefined;
+    abstract getSnapshot(scenePath: string, width?: number, height?: number, camera?: Pick<ICameraOpt, "centerX" | "centerY" | "scale">): Promise<ImageBitmap> | undefined;
+    /** 根据查询条件查询事件任务处理批量池中任务 */
+    abstract queryTaskBatchData(query: IqueryTask): IWorkerMessage[];
+    abstract insertImage(imageInfo: ImageInformation): void;
+    abstract lockImage(uuid: string, locked: boolean): void;
+    abstract completeImageUpload(uuid: string, src: string): void;
+    abstract getImagesInformation(scenePath: string): ImageInformation[];
+}
+export declare class MasterControlForWorker extends MasterController {
+    isActive: boolean;
+    currentToolsData?: IActiveToolsDataType;
+    protected currentLocalWorkData: IActiveWorkDataType;
+    control: BaseApplianceManager;
+    internalMsgEmitter: EventEmitter2;
+    taskBatchData: Set<IWorkerMessage>;
+    protected fullWorker: Worker;
+    protected subWorker: Worker;
+    methodBuilder?: MethodBuilderMain;
+    private zIndexNodeMethod?;
+    /** master\fullwoker\subworker 三者高频绘制时队列化参数 */
+    private subWorkerDrawCount;
+    private wokerDrawCount;
+    private maxDrawCount;
+    private cacheDrawCount;
+    private reRenders;
+    private localWorkViewId?;
+    protected localPointsBatchData: number[];
+    /** end */
+    /** 是否任务队列化参数 */
+    private tasksqueue;
+    private useTasksqueue;
+    private useTasksClockId?;
+    private mianTasksqueueCount?;
+    private workerTasksqueueCount?;
+    /** end */
+    private snapshotMap;
+    private boundingRectMap;
+    private clearAllResolve?;
+    private delayWorkStateToDone?;
+    private delayWorkStateToDoneResolve?;
+    private undoTickerId?;
+    private animationId;
+    constructor(props: BaseSubWorkModuleProps);
+    private get viewContainerManager();
+    private get collector();
+    private get isRunSubWork();
+    private get isCanDrawWork();
+    private get isUseZIndex();
+    private get isCanRecordUndoRedo();
+    private get isCanSentCursor();
+    init(): void;
+    on(): void;
+    private collectorSyncData;
+    private collectorAsyncData;
+    private onLocalEventEnd;
+    private onLocalEventDoing;
+    private onLocalEventStart;
+    private pushPoint;
+    private correctStorage;
+    originalEventLintener(workState: EvevtWorkState, point: [number, number], viewId: string): Promise<void>;
+    getLocalWorkViewId(): string | undefined;
+    setLocalWorkViewId(viewId?: string): void;
+    setCurrentToolsData(currentToolsData: IActiveToolsDataType): void;
+    setCurrentLocalWorkData(currentLocalWorkData: IActiveWorkDataType): void;
+    prepareOnceWork(currentLocalWorkData: Required<Pick<IActiveWorkDataType, 'toolsOpt' | 'viewId' | 'workId'>>, toolsType: EToolsKey): void;
+    createViewWorker(viewId: string, options: ViewWorkerOptions): void;
+    destroyViewWorker(viewId: string, isLocal?: boolean): void;
+    onServiceDerive(key: string, data: DiffOne<BaseCollectorReducerAction | undefined>): void;
+    pullServiceData(viewId: string, scenePath: string): void;
+    runAnimation(): void;
+    consume(): void;
+    unWritable(): void;
+    abled(): void;
+    isAbled(): boolean;
+    post(msg: Set<IWorkerMessage>): void;
+    destroy(): void;
+    updateNode(workId: IworkId, updateNodeOpt: IUpdateNodeOpt, viewId: string, scenePath: string): void;
+    updateCamera(viewId: string, cameraOpt: ICameraOpt): void;
+    private consumeQueue;
+    clearViewScenePath(viewId: string, justLocal?: boolean | undefined): Promise<void>;
+    private internalMsgEmitterListener;
+    private setZIndex;
+    clearLocalPointsBatchData(): void;
+    hoverCursor(point: [number, number], viewId: string): void;
+    sendCursorEvent(p: [number | undefined, number | undefined], viewId: string): void;
+    getBoundingRect(scenePath: string): Promise<IRectType> | undefined;
+    getSnapshot(scenePath: string, width?: number, height?: number, camera?: Pick<ICameraOpt, "centerX" | "centerY" | "scale">): Promise<ImageBitmap> | undefined;
+    queryTaskBatchData(query: IqueryTask): IWorkerMessage[];
+    insertImage(imageInfo: ImageInformation): void;
+    lockImage(uuid: string, locked: boolean): void;
+    completeImageUpload(uuid: string, src: string): void;
+    getImagesInformation(scenePath: string): ImageInformation[];
+    setShapeSelectorByWorkId(workId: string, viewId: string, undoTickerId?: number): void;
+    blurSelector(viewId: string, scenePath: string, undoTickerId?: number): void;
+}

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

@@ -0,0 +1,12 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+export type ZIndexActiveEmtData = {
+    workId: IworkId;
+    isActive: boolean;
+    viewId: string;
+};
+export declare class ZIndexActiveMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    collect(data: ZIndexActiveEmtData): void;
+}

package/dist/core/msgEvent/activeZIndex/forWorker.d.ts

@@ -0,0 +1,8 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethodForWorker } from "../baseForWorker";
+import { IWorkerMessage } from "../../types";
+export declare class ZIndexActiveMethodForWorker extends BaseMsgMethodForWorker {
+    readonly emitEventType: EmitEventType;
+    consume(data: IWorkerMessage): boolean | undefined;
+    consumeForLocalWorker(data: IWorkerMessage): void;
+}

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

@@ -0,0 +1,18 @@
+import { EmitEventType, InternalMsgEmitterType } from "../../plugin/types";
+import { IWorkerMessage, IqueryTask } from "../types";
+import { BaseCollectorReducerAction } from "../../collector/types";
+import { BaseApplianceManager } from "../../plugin/baseApplianceManager";
+import { MasterController } from "../mainEngine";
+export declare abstract class BaseMsgMethod {
+    static dispatch(emtType: InternalMsgEmitterType, emitEventType: EmitEventType, value: unknown): void;
+    abstract readonly emitEventType: EmitEventType;
+    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;
+    collectForServiceWorker(actions: BaseCollectorReducerAction[]): void;
+    abstract collect(data: unknown): void;
+}

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

@@ -0,0 +1,13 @@
+import type { Scene } from "spritejs";
+import { EmitEventType } from "../../plugin/types";
+import { IWorkerMessage } from "../types";
+import { LocalWorkForFullWorker } from "../worker/fullWorkerLocal";
+import { ServiceWorkForFullWorker } from "../worker/fullWorkerService";
+export declare abstract class BaseMsgMethodForWorker {
+    abstract readonly emitEventType: EmitEventType;
+    localWork: LocalWorkForFullWorker | undefined;
+    serviceWork: ServiceWorkForFullWorker | undefined;
+    scene: Scene | undefined;
+    registerForWorker(localWork: LocalWorkForFullWorker, serviceWork?: ServiceWorkForFullWorker, scene?: Scene): this;
+    abstract consume(data: IWorkerMessage): boolean | undefined;
+}

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

@@ -0,0 +1,47 @@
+import { EmitEventType } from "../../../plugin/types";
+import type { Point } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { ICameraOpt, IworkId } from "../../types";
+import { BaseCollectorReducerAction } from "../../../collector/types";
+export type CopyNodeEmtData = {
+    workIds: IworkId[];
+    viewId: string;
+};
+export declare class CopyNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    collect(data: CopyNodeEmtData): void;
+    copyText(param: {
+        viewId: string;
+        store: BaseCollectorReducerAction;
+    }): {
+        bgCenter?: [number, number];
+        textCenter?: [number, number];
+    } | undefined;
+    pasteText(param: {
+        viewId: string;
+        scenePath: string;
+        key: string;
+        store: BaseCollectorReducerAction;
+        bgCenter?: [number, number];
+        textCenter?: [number, number];
+    }): void;
+    copySelector(param: {
+        viewId: string;
+        store: BaseCollectorReducerAction;
+    }): {
+        copyStores: Map<string, BaseCollectorReducerAction>;
+        copyCoordInfo: {
+            offset: Point;
+            cameraOpt: Pick<ICameraOpt, 'centerX' | 'centerY' | 'scale'>;
+        };
+    } | undefined;
+    pasteSelector(param: {
+        viewId: string;
+        scenePath: string;
+        copyStores: Map<string, BaseCollectorReducerAction>;
+        copyCoordInfo: {
+            offset: Point;
+            cameraOpt: Pick<ICameraOpt, 'centerX' | 'centerY' | 'scale'>;
+        };
+    }): void;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+export type DeleteNodeEmtData = {
+    workIds: IworkId[];
+    viewId: string;
+};
+export declare class DeleteNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    collect(data: DeleteNodeEmtData): void;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { EmitEventType } from '../../plugin/types';
+import { BaseMsgMethodForWorker } from './baseForWorker';
+import { IWorkerMessage } from '../types';
+import { LocalWorkForFullWorker } from '../worker/fullWorkerLocal';
+import { ServiceWorkForFullWorker } from '../worker/fullWorkerService';
+import type { Scene } from 'spritejs';
+export type MsgMethodForWorker<T extends BaseMsgMethodForWorker> = T;
+export declare class MethodBuilderWorker {
+    builders: Map<EmitEventType, MsgMethodForWorker<BaseMsgMethodForWorker> | undefined>;
+    constructor(emitTypes: EmitEventType[]);
+    build(type: EmitEventType): MsgMethodForWorker<BaseMsgMethodForWorker> | undefined;
+    registerForWorker(localWork: LocalWorkForFullWorker, serviceWork?: ServiceWorkForFullWorker, scene?: Scene): this;
+    consumeForWorker(data: IWorkerMessage): boolean;
+}

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

@@ -0,0 +1,15 @@
+import { EmitEventType, InternalMsgEmitterType } from '../../plugin/types';
+import { BaseMsgMethod } from './base';
+import { ZIndexNodeMethod } from './setZIndex/forMain';
+import { BaseApplianceManager } from '../../plugin/baseApplianceManager';
+export { ZIndexNodeMethod };
+export type MsgMethod<T extends BaseMsgMethod> = T;
+export declare class MethodBuilderMain {
+    builders: Map<EmitEventType, MsgMethod<BaseMsgMethod> | undefined>;
+    constructor(emitTypes: EmitEventType[]);
+    build(type: EmitEventType): MsgMethod<BaseMsgMethod> | undefined;
+    getBuilder(type: EmitEventType): BaseMsgMethod | undefined;
+    registerForMainEngine(emtType: InternalMsgEmitterType, control: BaseApplianceManager): this;
+    destroy(): void;
+    static emitMethod(emtType: InternalMsgEmitterType, type: EmitEventType, data: unknown): undefined;
+}

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

@@ -0,0 +1,16 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { EvevtWorkState } from "../../enum";
+export type RotateNodeEmtData = {
+    workIds: IworkId[];
+    angle: number;
+    workState: EvevtWorkState;
+    viewId: string;
+};
+export declare class RotateNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private undoTickerId?;
+    private cacheOriginRotate;
+    collect(data: RotateNodeEmtData): void;
+}

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

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

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

@@ -0,0 +1,20 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IRectType, IworkId } from "../../types";
+import { EvevtWorkState } from "../../enum";
+import type { Direction } from "re-resizable/lib/resizer";
+export type ScaleNodeEmtData = {
+    workIds: IworkId[];
+    workState: EvevtWorkState;
+    box: IRectType;
+    viewId: string;
+    dir?: Direction;
+};
+export declare class ScaleNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private undoTickerId?;
+    private targetBox;
+    private targetText;
+    private cacheTextInfo;
+    collect(data: ScaleNodeEmtData): Promise<void>;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { EvevtWorkState } from "../../enum";
+export type SetColorNodeEmtData = {
+    workIds: IworkId[];
+    strokeColor?: string;
+    fillColor?: string;
+    fontColor?: string;
+    fontBgColor?: string;
+    workState?: EvevtWorkState;
+    viewId: string;
+};
+export declare class SetColorNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private setTextColor;
+    collect(data: SetColorNodeEmtData): void;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { FontStyleType, FontWeightType } from "../../../component/textEditor";
+export type SetFontEmtData = {
+    workIds: IworkId[];
+    bold?: FontWeightType;
+    underline?: boolean;
+    lineThrough?: boolean;
+    italic?: FontStyleType;
+    fontSize?: number;
+    viewId: string;
+};
+export declare class SetFontStyleMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private setTextStyle;
+    collect(data: SetFontEmtData): void;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+export type SetLockEmitData = {
+    workIds: IworkId[];
+    isLocked: boolean;
+    viewId: string;
+};
+export declare class SetLockMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    collect(data: SetLockEmitData): void;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { EvevtWorkState } from "../../enum";
+export type SetPointEmtData = {
+    workId: IworkId;
+    workState: EvevtWorkState;
+    pointMap: Map<string, [number, number][]>;
+    viewId: string;
+};
+export declare class SetPointMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private undoTickerId?;
+    collect(data: SetPointEmtData): void;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { EmitEventType } from "../../../plugin/types";
+import type { SpeechBalloonPlacement } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { EToolsKey } from "../../enum";
+export type SetShapeEmtData = {
+    workIds: IworkId[];
+    viewId: string;
+    toolsType: EToolsKey;
+    vertices?: number;
+    innerVerticeStep?: number;
+    innerRatio?: number;
+    placement?: SpeechBalloonPlacement;
+};
+export declare class SetShapeOptMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    collect(data: SetShapeEmtData): void;
+}

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

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

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

@@ -0,0 +1,22 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { ElayerType } from "../../enum";
+export type ZIndexNodeEmtData = {
+    workIds: IworkId[];
+    layer: ElayerType;
+    viewId: string;
+};
+export declare class ZIndexNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private zIndexMap;
+    clearZIndex(viewId: string): void;
+    getMinZIndex(viewId: string): number;
+    getMaxZIndex(viewId: string): number;
+    setMaxZIndex(max: number, viewId: string): void;
+    setMinZIndex(min: number, viewId: string): void;
+    addMaxLayer(viewId: string): void;
+    addMinLayer(viewId: string): void;
+    correct(data: Array<[string, number]>): Array<[string, number]>;
+    collect(data: ZIndexNodeEmtData): void;
+}

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

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

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

@@ -0,0 +1,20 @@
+import { EmitEventType } from "../../../plugin/types";
+import { BaseMsgMethod } from "../base";
+import { IworkId } from "../../types";
+import { EvevtWorkState } from "../../enum";
+export type TranslateNodeEmtData = {
+    workIds: IworkId[];
+    position: {
+        x: number;
+        y: number;
+    };
+    workState: EvevtWorkState;
+    viewId: string;
+};
+export declare class TranslateNodeMethod extends BaseMsgMethod {
+    readonly emitEventType: EmitEventType;
+    private undoTickerId?;
+    private oldRect;
+    private cachePosition;
+    collect(data: TranslateNodeEmtData): void;
+}

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

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

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

@@ -0,0 +1,46 @@
+import { IWorkerMessage, IMainMessage, IRectType, IUpdateNodeOpt } from "../types";
+import { EScaleType, EToolsKey } from "../enum";
+import { Point2d } from "../utils/primitives/Point2d";
+import { BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
+import { VNodeManager } from "../worker/vNodeManager";
+import { ShapeNodes } from "./utils";
+export interface ArrowOptions extends BaseShapeOptions {
+    thickness: number;
+    strokeColor: string;
+}
+export declare class ArrowShape extends BaseShapeTool {
+    readonly canRotate: boolean;
+    readonly scaleType: EScaleType;
+    readonly toolsType: EToolsKey;
+    protected tmpPoints: Array<Point2d>;
+    protected workOptions: ArrowOptions;
+    oldRect?: IRectType;
+    private arrowTipWidth;
+    private syncTimestamp;
+    constructor(props: BaseShapeToolProps);
+    consume(props: {
+        data: IWorkerMessage;
+        isFullWork?: boolean | undefined;
+        isClearAll?: boolean | undefined;
+        isSubWorker?: boolean | undefined;
+    }): IMainMessage;
+    consumeAll(props: {
+        data?: IWorkerMessage | undefined;
+    }): IMainMessage;
+    private draw;
+    private computDrawPoints;
+    private computFullArrowPoints;
+    private computTrianglePoints;
+    private updateTempPoints;
+    consumeService(props: {
+        op: number[];
+        isFullWork: boolean;
+    }): IRectType | undefined;
+    clearTmpPoints(): void;
+    static updateNodeOpt(param: {
+        node: ShapeNodes;
+        opt: IUpdateNodeOpt;
+        vNodes: VNodeManager;
+        willSerializeData?: boolean;
+    }): IRectType | undefined;
+}