@netless/appliance-plugin 1.0.0-beta.0

package/dist/core/utils/primitives/Vec2d.d.ts

@@ -0,0 +1,146 @@
+export interface Vec2dSimple {
+    x: number;
+    y: number;
+}
+/**
+ * A serializable model for 2D vectors.
+ *
+ * @public */
+export interface Vec2dModel extends Vec2dSimple {
+    z: number;
+}
+/** @public */
+export type VecLike = Vec2d | Vec2dModel | Vec2dSimple;
+/** @public */
+export type StrictVecLike = Vec2d | Vec2dModel;
+/** @public */
+export declare class Vec2d {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    get XY(): [number, number];
+    setz(z: number): this;
+    setXY(x?: number, y?: number): this;
+    set(x?: number, y?: number, z?: number): this;
+    setTo({ x, y, z }: StrictVecLike): this;
+    rot(r: number): this;
+    rotWith(C: VecLike, r: number): this;
+    clone(): Vec2d;
+    sub(V: VecLike): this;
+    subXY(x: number, y: number): this;
+    subScalar(n: number): this;
+    add(V: VecLike): this;
+    addXY(x: number, y: number): this;
+    addScalar(n: number): this;
+    clamp(min: number, max?: number): this;
+    div(t: number): this;
+    divV(V: VecLike): this;
+    mul(t: number): this;
+    mulV(V: VecLike): this;
+    abs(): this;
+    nudge(B: VecLike, distance: number): this;
+    neg(): this;
+    cross(V: StrictVecLike): this;
+    dpr(V: VecLike): number;
+    cpr(V: VecLike): number;
+    len2(): number;
+    len(): number;
+    pry(V: VecLike): number;
+    per(): this;
+    uni(): Vec2d;
+    tan(V: VecLike): Vec2d;
+    dist(V: VecLike): number;
+    distanceToLineSegment(A: VecLike, B: VecLike): number;
+    slope(B: VecLike): number;
+    snapToGrid(gridSize: number): this;
+    angle(B: VecLike): number;
+    toAngle(): number;
+    lrp(B: VecLike, t: number): Vec2d;
+    equals(B: VecLike, tolerance?: number): boolean;
+    equalsXY(x: number, y: number): boolean;
+    norm(): this;
+    toFixed(): Vec2d;
+    toString(): string;
+    toJson(): Vec2dModel;
+    toArray(): number[];
+    static Add(A: VecLike, B: VecLike): Vec2d;
+    static AddXY(A: VecLike, x: number, y: number): Vec2d;
+    static Sub(A: VecLike, B: VecLike): Vec2d;
+    static SubXY(A: VecLike, x: number, y: number): Vec2d;
+    static AddScalar(A: VecLike, n: number): Vec2d;
+    static SubScalar(A: VecLike, n: number): Vec2d;
+    static Div(A: VecLike, t: number): Vec2d;
+    static Mul(A: VecLike, t: number): Vec2d;
+    static DivV(A: VecLike, B: VecLike): Vec2d;
+    static MulV(A: VecLike, B: VecLike): Vec2d;
+    static Neg(A: VecLike): Vec2d;
+    static Per(A: VecLike): Vec2d;
+    static Dist2(A: VecLike, B: VecLike): number;
+    static Abs(A: VecLike): Vec2d;
+    static Dist(A: VecLike, B: VecLike): number;
+    static Dpr(A: VecLike, B: VecLike): number;
+    static Cross(A: StrictVecLike, V: StrictVecLike): Vec2d;
+    static Cpr(A: VecLike, B: VecLike): number;
+    static Len2(A: VecLike): number;
+    static Len(A: VecLike): number;
+    static Pry(A: VecLike, B: VecLike): number;
+    static Uni(A: VecLike): Vec2d;
+    static Tan(A: VecLike, B: VecLike): Vec2d;
+    static Min(A: VecLike, B: VecLike): Vec2d;
+    static Max(A: VecLike, B: VecLike): Vec2d;
+    static From(A: Vec2dModel | Vec2dSimple): Vec2d;
+    static FromArray(v: number[]): Vec2d;
+    static Rot(A: VecLike, r?: number): Vec2d;
+    static RotWith(A: VecLike, C: VecLike, r: number): Vec2d;
+    /**
+     * Get the nearest point on a line with a known unit vector that passes through point A
+     *
+     * ```ts
+     * Vec.nearestPointOnLineThroughPoint(A, u, Point)
+     * ```
+     *
+     * @param A - Any point on the line
+     * @param u - The unit vector for the line.
+     * @param P - A point not on the line to test.
+     */
+    static NearestPointOnLineThroughPoint(A: VecLike, u: VecLike, P: VecLike): Vec2d;
+    static NearestPointOnLineSegment(A: VecLike, B: VecLike, P: VecLike, clamp?: boolean): Vec2d;
+    static DistanceToLineThroughPoint(A: VecLike, u: VecLike, P: VecLike): number;
+    static DistanceToLineSegment(A: VecLike, B: VecLike, P: VecLike, clamp?: boolean): number;
+    static Snap(A: VecLike, step?: number): Vec2d;
+    static Cast(A: VecLike): Vec2d;
+    static Slope(A: VecLike, B: VecLike): number;
+    static Angle(A: VecLike, B: VecLike): number;
+    static Lrp(A: VecLike, B: VecLike, t: number): Vec2d;
+    static Med(A: VecLike, B: VecLike): Vec2d;
+    static Equals(A: VecLike, B: VecLike, tolerance?: number): boolean;
+    static EqualsXY(A: VecLike, x: number, y: number): boolean;
+    static EqualsXYZ(A: StrictVecLike, B: StrictVecLike, tolerance?: number): boolean;
+    static Clockwise(A: VecLike, B: VecLike, C: VecLike): boolean;
+    static Rescale(A: VecLike, n: number): Vec2d;
+    static ScaleWithOrigin(A: VecLike, scale: number, origin: VecLike): Vec2d;
+    static ScaleWOrigin(A: VecLike, scale: VecLike, origin: VecLike): Vec2d;
+    static ToFixed(A: StrictVecLike, n?: number): Vec2d;
+    static Nudge(A: VecLike, B: VecLike, distance: number): Vec2d;
+    static ToString(A: VecLike): string;
+    static ToAngle(A: VecLike): number;
+    static FromAngle(r: number, length?: number): Vec2d;
+    static ToArray(A: StrictVecLike): number[];
+    static ToJson(A: StrictVecLike): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static Average(arr: VecLike[]): Vec2d;
+    static Clamp(A: Vec2d, min: number, max?: number): Vec2d;
+    /**
+     * Get an array of points (with simulated pressure) between two points.
+     *
+     * @param A - The first point.
+     * @param B - The second point.
+     * @param steps - The number of points to return.
+     */
+    static PointsBetween(A: Vec2dModel, B: Vec2dModel, steps?: number): Vec2d[];
+    static SnapToGrid(A: VecLike, gridSize?: number): Vec2d;
+}

package/dist/core/utils/primitives/easings.d.ts

@@ -0,0 +1,24 @@
+/** @public */
+export declare const EASINGS: {
+    readonly linear: (t: number) => number;
+    readonly easeInQuad: (t: number) => number;
+    readonly easeOutQuad: (t: number) => number;
+    readonly easeInOutQuad: (t: number) => number;
+    readonly easeInCubic: (t: number) => number;
+    readonly easeOutCubic: (t: number) => number;
+    readonly easeInOutCubic: (t: number) => number;
+    readonly easeInQuart: (t: number) => number;
+    readonly easeOutQuart: (t: number) => number;
+    readonly easeInOutQuart: (t: number) => number;
+    readonly easeInQuint: (t: number) => number;
+    readonly easeOutQuint: (t: number) => number;
+    readonly easeInOutQuint: (t: number) => number;
+    readonly easeInSine: (t: number) => number;
+    readonly easeOutSine: (t: number) => number;
+    readonly easeInOutSine: (t: number) => number;
+    readonly easeInExpo: (t: number) => number;
+    readonly easeOutExpo: (t: number) => number;
+    readonly easeInOutExpo: (t: number) => number;
+};
+/** @public */
+export type EasingType = keyof typeof EASINGS;

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

@@ -0,0 +1,21 @@
+import { EDataType } from "../enum";
+export type InterceptorsType<T, K> = {
+    get(key: T): K;
+    set(key: T, value: K): void;
+    delete(key: T): void;
+    clear(): void;
+    size(): number;
+};
+export declare class ProxyMap<T, K> {
+    static proxyToRaw: WeakMap<WeakKey, any>;
+    static interceptors: {
+        entries(...arg: any[]): any;
+        forEach(...arg: any[]): any;
+        size(): any;
+        get(key: unknown): any;
+        set(key: unknown, value: unknown): any;
+        delete(key: unknown, _dataType?: EDataType): any;
+        clear(): any;
+    };
+    createProxy(map: Map<T, K>): Map<T, K>;
+}

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

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

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

@@ -0,0 +1,103 @@
+import { Group, Scene } from "spritejs";
+import { IActiveToolsDataType, IActiveWorkDataType, IBatchMainMessage, ICameraOpt, ILayerOptionType, IMainMessage, IOffscreenCanvasOptionType, IServiceWorkItem, IWorkerMessage, IworkId } from "../types";
+import { VNodeManager } from "./vNodeManager";
+import { EDataType, EToolsKey } from "../enum";
+import { ShapeStateInfo } from "../tools/utils";
+import { BaseShapeOptions, BaseShapeTool } from "../tools/base";
+import { ServiceWorkForFullWorker } from "./fullWorkerService";
+import { LocalWorkForFullWorker } from "./fullWorkerLocal";
+import { LocalWorkForSubWorker } from "./subWorkerLocal";
+import type { WorkThreadEngineForFullWorker, WorkThreadEngineForSubWorker } from "./workerManager";
+export interface IWorkerInitOption {
+    dpr: number;
+    offscreenCanvasOpt: IOffscreenCanvasOptionType;
+    layerOpt: ILayerOptionType;
+}
+export interface ISubWorkerInitOption {
+    thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker;
+    viewId: string;
+    vNodes: VNodeManager;
+    fullLayer: Group;
+    drawLayer?: Group;
+    post: (msg: IBatchMainMessage) => Promise<void>;
+}
+export declare abstract class WorkThreadEngineBase {
+    readonly viewId: string;
+    readonly fullLayer: Group;
+    readonly vNodes: VNodeManager;
+    readonly dpr: number;
+    readonly abstract drawLayer?: Group;
+    readonly abstract snapshotFullLayer?: Group;
+    protected opt: IWorkerInitOption;
+    protected cameraOpt?: ICameraOpt;
+    protected scene: Scene;
+    abstract localWork: LocalWorkForFullWorker | LocalWorkForSubWorker;
+    abstract serviceWork?: ServiceWorkForFullWorker;
+    protected isSafari: boolean;
+    protected abstract _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void;
+    constructor(viewId: string, opt: IWorkerInitOption);
+    setIsSafari(isSafari: boolean): void;
+    on(msg: IWorkerMessage): void;
+    protected updateScene(offscreenCanvasOpt: IOffscreenCanvasOptionType): void;
+    protected updateLayer(layerOpt: ILayerOptionType): void;
+    protected createScene(opt: IOffscreenCanvasOptionType): Scene;
+    protected createLayer(name: string, scene: Scene, opt: ILayerOptionType): Group;
+    protected clearAll(): void;
+    protected setToolsOpt(opt: IActiveToolsDataType): void;
+    protected setWorkOpt(opt: Partial<IActiveWorkDataType>): void;
+    protected destroy(): void;
+    abstract setCameraOpt(cameraOpt: ICameraOpt): void;
+    abstract getOffscreen(isFullWork: boolean): OffscreenCanvas;
+    abstract post(msg: IBatchMainMessage): Promise<void>;
+    abstract consumeDraw(type: EDataType, data: IWorkerMessage): void;
+    abstract consumeDrawAll(type: EDataType, data: IWorkerMessage): void;
+}
+export declare abstract class LocalWork {
+    readonly viewId: string;
+    readonly vNodes: VNodeManager;
+    readonly thread: WorkThreadEngineForFullWorker | WorkThreadEngineForSubWorker;
+    fullLayer: Group;
+    drawLayer?: Group;
+    readonly _post: (msg: IBatchMainMessage) => Promise<void>;
+    protected tmpWorkShapeNode?: BaseShapeTool;
+    protected tmpOpt?: IActiveToolsDataType;
+    workShapes: Map<IworkId, BaseShapeTool>;
+    workShapeState: Map<IworkId, ShapeStateInfo>;
+    protected effectWorkId?: number;
+    protected drawCount: number;
+    constructor(opt: ISubWorkerInitOption);
+    destroy(): void;
+    getWorkShape(workId: IworkId): BaseShapeTool | undefined;
+    getTmpWorkShapeNode(): BaseShapeTool | undefined;
+    setTmpWorkId(workId: IworkId | undefined): void;
+    setTmpWorkOptions(opt: BaseShapeOptions): void;
+    setWorkOptions(workId: IworkId, opt: BaseShapeOptions): void;
+    createWorkShapeNode(opt: IActiveToolsDataType & {
+        workId?: IworkId;
+    }): import("../tools").SelectorShape | import("../tools").PencilShape | import("../tools").LaserPenShape | import("../tools").ArrowShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").StarShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools/text").TextShape | import("../tools").EraserShape | import("../tools").ImageShape | undefined;
+    setToolsOpt(opt: IActiveToolsDataType): void;
+    clearWorkShapeNodeCache(workId: IworkId): void;
+    clearAllWorkShapesCache(): void;
+    setFullWork(data: Pick<IWorkerMessage, 'workId' | 'opt' | 'toolsType'>): BaseShapeTool | import("../tools").LaserPenShape | import("../tools").SpeechBalloonShape | import("../tools/text").TextShape | import("../tools").EraserShape | undefined;
+    abstract consumeDraw(data: IWorkerMessage, serviceWork?: ServiceWork): IMainMessage | undefined;
+    abstract consumeDrawAll(data: IWorkerMessage, serviceWork?: ServiceWork): IMainMessage | undefined;
+}
+export interface ServiceWork {
+    readonly viewId: string;
+    readonly vNodes: VNodeManager;
+    readonly fullLayer: Group;
+    readonly drawLayer: Group;
+    readonly post: (msg: IBatchMainMessage) => Promise<void>;
+    selectorWorkShapes: Map<string, IServiceWorkItem>;
+    clearAllWorkShapesCache(): void;
+    runSelectWork(data: IWorkerMessage): void;
+    consumeDraw(data: IWorkerMessage): void;
+    setNodeKey(workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
+    runReverseSelectWork(selectIds: string[]): void;
+    removeWork(data: IWorkerMessage): void;
+    removeSelectWork(data: IWorkerMessage): void;
+    runSelectWork(data: IWorkerMessage): void;
+    consumeFull(data: IWorkerMessage): void;
+    consumeDraw(data: IWorkerMessage): void;
+    destroy(): void;
+}

package/dist/core/worker/fullWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/worker/fullWorkerLocal.d.ts

@@ -0,0 +1,46 @@
+import { IWorkerMessage, IMainMessage, IRectType, EToolsKey, IBatchMainMessage, IUpdateSelectorPropsType } from "..";
+import { BaseShapeOptions, SelectorShape } from "../tools";
+import { ISubWorkerInitOption, LocalWork } from "./base";
+import { ServiceWorkForFullWorker } from "./fullWorkerService";
+import { Scene } from "spritejs";
+export declare class LocalWorkForFullWorker extends LocalWork {
+    private combineUnitTime;
+    private combineTimerId?;
+    private effectSelectNodeData;
+    private batchEraserWorks;
+    private batchEraserRemoveNodes;
+    constructor(opt: ISubWorkerInitOption);
+    consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
+    consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): IMainMessage | undefined;
+    consumeFull(data: IWorkerMessage, scene?: Scene): Promise<void>;
+    removeWork(data: IWorkerMessage): Promise<void>;
+    removeNode(key: string): IRectType | undefined;
+    checkTextActive(data: IWorkerMessage): Promise<void>;
+    colloctEffectSelectWork(data: IWorkerMessage): Promise<IWorkerMessage | undefined>;
+    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>;
+    blurSelector(data?: IWorkerMessage): Promise<void>;
+    reRenderSelector(willSyncService?: boolean): Promise<void> | undefined;
+    updateFullSelectWork(data: IWorkerMessage): void;
+    destroy(): void;
+    private drawPencilCombine;
+    private drawSelector;
+    private drawEraser;
+    private batchEraserCombine;
+    private drawPencil;
+    private drawPencilFull;
+    private updateBatchEraserCombineNode;
+    private runEffectSelectWork;
+    cursorHover(msg: IWorkerMessage): void;
+}

package/dist/core/worker/fullWorkerService.d.ts

@@ -0,0 +1,41 @@
+import { Group } from "spritejs";
+import { ISubWorkerInitOption, ServiceWork } from "./base";
+import { VNodeManager } from "./vNodeManager";
+import { IBatchMainMessage, IServiceWorkItem, IWorkerMessage } from "../types";
+import { EToolsKey } from "../enum";
+import { BaseShapeOptions } from "../tools";
+export declare class ServiceWorkForFullWorker implements ServiceWork {
+    viewId: string;
+    vNodes: VNodeManager;
+    fullLayer: Group;
+    drawLayer: Group;
+    serviceDrawLayer: Group;
+    workShapes: Map<string, IServiceWorkItem>;
+    selectorWorkShapes: Map<string, IServiceWorkItem>;
+    protected animationId?: number | undefined;
+    private willRunEffectSelectorIds;
+    private runEffectId?;
+    private noAnimationRect;
+    post: (msg: IBatchMainMessage, transfer?: Transferable[]) => Promise<void>;
+    constructor(opt: ISubWorkerInitOption & {
+        serviceDrawLayer: Group;
+    });
+    destroy(): void;
+    consumeDraw(data: IWorkerMessage): void;
+    consumeFull(data: IWorkerMessage): void;
+    clearAllWorkShapesCache(): void;
+    runSelectWork(data: IWorkerMessage): void;
+    setNodeKey(workShape: IServiceWorkItem, tools: EToolsKey, opt: BaseShapeOptions): IServiceWorkItem;
+    runReverseSelectWork(selectIds: string[]): void;
+    removeWork(data: IWorkerMessage): Promise<void>;
+    removeSelectWork(data: IWorkerMessage): void;
+    private removeNode;
+    private activeWorkShape;
+    private hasDiffData;
+    private animationDraw;
+    private runAnimation;
+    private computNextAnimationIndex;
+    private runEffect;
+    private effectRunSelector;
+    private activeSelectorShape;
+}

package/dist/core/worker/subWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/worker/subWorkerLocal.d.ts

@@ -0,0 +1,20 @@
+import { Group } from "spritejs";
+import { IWorkerMessage, IRectType, IMainMessage } from "..";
+import { BaseCollectorReducerAction } from "../../collector/types";
+import { LocalWork, ISubWorkerInitOption } from "./base";
+export declare class LocalWorkForSubWorker extends LocalWork {
+    private animationWorkRects?;
+    protected combineDrawTimer?: number;
+    private animationId?;
+    private closeAnimationTime;
+    private runLaserPenStep;
+    constructor(opt: ISubWorkerInitOption);
+    runFullWork(data: IWorkerMessage, isDrawLabel?: boolean): Promise<IRectType | undefined>;
+    runSelectWork(data: IWorkerMessage): undefined;
+    consumeDraw(data: IWorkerMessage): IMainMessage | undefined;
+    consumeDrawAll(data: IWorkerMessage): undefined;
+    updateLabels(labelGroup: Group, value: BaseCollectorReducerAction): void;
+    private runLaserPenAnimation;
+    private drawPencil;
+    private drawArrow;
+}

package/dist/core/worker/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;
+    scenePath?: string;
+    drawLayer?: Group;
+    fullLayer?: Group;
+    curNodeMap: Map<string, BaseNodeMapItem>;
+    targetNodeMap: Map<string, BaseNodeMapItem>[];
+    constructor(viewId: string, scene: Scene);
+    init(fullLayer: Group, drawLayer?: Group): void;
+    get(name: string): BaseNodeMapItem | undefined;
+    hasRenderNodes(): boolean;
+    has(name: string): void;
+    setInfo(name: string, info: Partial<BaseNodeMapItem>): 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/worker/workerManager.d.ts

@@ -0,0 +1,71 @@
+import { Group } from "spritejs";
+import { EDataType } from "../enum";
+import { IBatchMainMessage, ICameraOpt, ILayerOptionType, IWorkerMessage } from "../types";
+import { IWorkerInitOption, WorkThreadEngineBase } from "./base";
+import { LocalWorkForFullWorker } from "./fullWorkerLocal";
+import { ServiceWorkForFullWorker } from "./fullWorkerService";
+import { LocalWorkForSubWorker } from "./subWorkerLocal";
+export declare enum EWorkThreadType {
+    Full = "full",
+    Sub = "sub"
+}
+export declare class WorkerManager<T extends WorkThreadEngineBase> {
+    _self: Worker;
+    protected type: EWorkThreadType;
+    protected workThreadMap: Map<string, T>;
+    constructor(worker: Worker, type: EWorkThreadType);
+    private init;
+    private register;
+    post(msg: IBatchMainMessage, transfer?: Transferable[]): void;
+}
+/** full worker */
+export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase {
+    serviceDrawLayer: Group;
+    drawLayer: Group;
+    snapshotFullLayer: undefined;
+    private methodBuilder;
+    localWork: LocalWorkForFullWorker;
+    serviceWork: ServiceWorkForFullWorker;
+    protected _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
+    constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
+    post(msg: IBatchMainMessage, transfer?: Transferable[]): Promise<void>;
+    on(msg: IWorkerMessage): void;
+    removeNode(data: IWorkerMessage): Promise<void>;
+    checkTextActive(data: IWorkerMessage): void;
+    clearAll(): void;
+    protected updateLayer(layerOpt: ILayerOptionType): void;
+    setCameraOpt(cameraOpt: ICameraOpt): void;
+    getLayer(isFullWork?: boolean, workerType?: EDataType.Local | EDataType.Service): Group;
+    getOffscreen(isFullWork: boolean, workerType?: EDataType.Local | EDataType.Service): OffscreenCanvas;
+    consumeFull(type: EDataType, data: IWorkerMessage): Promise<void>;
+    consumeDraw(type: EDataType, data: IWorkerMessage): void;
+    consumeDrawAll(type: EDataType, data: IWorkerMessage): void;
+    private updateCamera;
+    private getRectImageBitmap;
+    private safariFixRect;
+    private getSceneRect;
+    private checkRightRectBoundingBox;
+    private cursorHover;
+}
+/** sub worker */
+export declare class WorkThreadEngineForSubWorker extends WorkThreadEngineBase {
+    protected _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
+    drawLayer: undefined;
+    snapshotFullLayer: Group | undefined;
+    serviceWork: undefined;
+    localWork: LocalWorkForSubWorker;
+    constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
+    post(msg: IBatchMainMessage, transfer?: Transferable[]): Promise<void>;
+    on(msg: IWorkerMessage): void;
+    getOffscreen(isSnapshot: boolean): OffscreenCanvas;
+    consumeDraw(type: EDataType, data: IWorkerMessage): void;
+    consumeDrawAll(_type: EDataType, data: IWorkerMessage): void;
+    private getRectImageBitmap;
+    private safariFixRect;
+    private updateCamera;
+    setCameraOpt(cameraOpt: ICameraOpt, layer?: Group): void;
+    private getSnapshot;
+    private willRenderSpecialLabel;
+    private getSnapshotRender;
+    private getBoundingRect;
+}

package/dist/cursors/index.d.ts

@@ -0,0 +1,73 @@
+import { EvevtWorkState, IMainMessage } from "../core";
+import { EventCollector } from "../collector/eventCollector";
+import { BaseSubWorkModuleProps, RoomMember } from "../plugin/types";
+import { RoomMemberManager } from "../members";
+import type { BaseApplianceManager } from "../plugin/baseApplianceManager";
+import EventEmitter2 from "eventemitter2";
+export declare enum CursorColloctSource {
+    Event = 0,
+    Storage = 1
+}
+export type IServiceWorkItem = {
+    freeze?: boolean;
+    willHid?: boolean;
+    animationIndex: number;
+    animationWorkData: Array<number | undefined>;
+    workState?: EvevtWorkState;
+};
+export type CursorInfo = {
+    x?: number;
+    y?: number;
+    roomMember?: RoomMember;
+};
+export type CursorInfoMapItem = CursorInfo & {
+    timestamp: number;
+};
+export declare abstract class CursorManager {
+    /** 内部消息管理器 */
+    abstract readonly internalMsgEmitter: EventEmitter2;
+    /** 插件管理器 */
+    abstract readonly control: BaseApplianceManager;
+    /** 事件收集器 */
+    abstract eventCollector?: EventCollector;
+    /** 房间成员管理器 */
+    abstract readonly roomMember: RoomMemberManager;
+    /** 激活事件收集器 */
+    abstract activeCollector(): void;
+    /** 同步事件 */
+    abstract sendEvent(point: [number | undefined, number | undefined], viewId: string): void;
+    /** 收集服务端cursor事件 */
+    abstract collectServiceCursor(data: IMainMessage): void;
+    /** 同步服务端失效 cursor事件 */
+    abstract unabled(): void;
+    /** 销毁cursor管理器 */
+    abstract destroy(): void;
+    /** 激活获焦的focusViewId */
+    abstract onFocusViewChange(): void;
+}
+export declare class CursorManagerImpl implements CursorManager {
+    readonly expirationTime = 5000;
+    readonly internalMsgEmitter: EventEmitter2;
+    readonly control: BaseApplianceManager;
+    eventCollector?: EventCollector;
+    readonly roomMember: RoomMemberManager;
+    private animationId?;
+    private removeTimerId?;
+    private asyncEndInfo?;
+    private animationPointWorkers;
+    private animationDrawWorkers;
+    private cursorInfoMap;
+    constructor(props: BaseSubWorkModuleProps);
+    activeCollector(): void;
+    onFocusViewChange(): void;
+    private activePointWorkShape;
+    private getKey;
+    private getUidAndviewId;
+    private animationCursor;
+    private activeDrawWorkShape;
+    private runAnimation;
+    sendEvent(point: [number | undefined, number | undefined], viewId: string): void;
+    collectServiceCursor(data: IMainMessage): void;
+    unabled(): void;
+    destroy(): void;
+}

package/dist/displayer/const.d.ts

@@ -0,0 +1,11 @@
+import { SpeechBalloonPlacement } from "../plugin/types";
+export declare type Margin = {
+    readonly top: number;
+    readonly bottom: number;
+    readonly left: number;
+    readonly right: number;
+};
+export declare const BarPadding: Margin;
+export declare const BarMargin: Margin;
+export declare const FontSizeList: readonly number[];
+export declare const SpeechBalloonPlacements: SpeechBalloonPlacement[];

package/dist/displayer/cursor/index.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { type RoomMember, type ApplianceViewManagerLike } from "../../plugin/types";
+import "./index.less";
+export declare const CursorManagerComponent: (props: {
+    className: string;
+    info: {
+        x?: number;
+        y?: number;
+        roomMember?: RoomMember;
+    };
+}) => React.JSX.Element;
+export declare const CursorManager: (props: {
+    className: string;
+    manager: ApplianceViewManagerLike;
+}) => React.JSX.Element | null;

package/dist/displayer/floatBar/index.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { TextEditorInfo } from "../../component/textEditor";
+export declare const FloatBar: React.MemoExoticComponent<React.ForwardRefExoticComponent<{
+    className: string;
+    editors?: Map<string, TextEditorInfo> | undefined;
+    activeTextId?: string | undefined;
+} & React.RefAttributes<HTMLCanvasElement>>>;
+export declare const FloatBarBtn: (props: {
+    className: string;
+}) => React.JSX.Element | null;

package/dist/displayer/floatBtns/colors.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { SubButProps, TextButProps } from "../types";
+export declare const StrokeColors: (props: SubButProps) => React.JSX.Element;
+export declare const FillColors: (props: SubButProps) => React.JSX.Element;
+export declare const TextColors: (props: TextButProps) => React.JSX.Element;
+export declare const TextBgColors: (props: TextButProps) => React.JSX.Element;

package/dist/displayer/floatBtns/del.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { ApplianceViewManagerLike } from "../../plugin/types";
+export declare const Del: (props: {
+    workIds?: string[];
+    maranger: ApplianceViewManagerLike;
+}) => React.JSX.Element;

package/dist/displayer/floatBtns/duplicate.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare const Duplicate: (props: {
+    workIds?: string[];
+    viewId: string;
+}) => React.JSX.Element;

package/dist/displayer/floatBtns/fontSize.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { TextButProps } from "../types";
+export type FontSizeProps = TextButProps;
+export declare const FontSizeBtn: (props: FontSizeProps) => React.JSX.Element;