@netless/appliance-plugin 1.0.0-beta.0

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

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

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

@@ -0,0 +1,11 @@
+import React from "react";
+import { TextOptions } from "../../component/textEditor";
+export declare const FloatBtns: React.MemoExoticComponent<(props: {
+    position?: {
+        x: number;
+        y: number;
+    };
+    textOpt?: TextOptions;
+    workIds?: string[];
+    noLayer?: boolean;
+}) => React.JSX.Element>;

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

@@ -0,0 +1,3 @@
+import React from "react";
+import { SubButProps } from "../types";
+export declare const Layer: (props: SubButProps) => React.JSX.Element;

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

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

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

@@ -0,0 +1,3 @@
+import React from "react";
+import { ShapeOptButProps } from "../types";
+export declare const ShapeOpt: (props: ShapeOptButProps) => React.JSX.Element;

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

@@ -0,0 +1,5 @@
+import React from "react";
+export declare const HighlightBox: () => React.JSX.Element;
+export declare const HighlightTwoBox: () => React.JSX.Element;
+export declare const HighlightFourBox: () => React.JSX.Element;
+export declare const LockedBox: () => React.JSX.Element;

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

@@ -0,0 +1,4 @@
+export type IconConfig = {
+    [key: string]: string;
+};
+export declare function IconURL(name: string): string;

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

@@ -0,0 +1,16 @@
+import React from "react";
+export declare const ResizableBox: (props: {
+    className: string;
+}) => React.JSX.Element;
+export declare const ResizableTwoBtn: (props: {
+    id: string;
+    pos: {
+        x: number;
+        y: number;
+    };
+    pointMap: Map<string, [number, number][]>;
+    type: 'start' | 'end';
+}) => React.JSX.Element;
+export declare const ResizableTwoBox: (props: {
+    className: string;
+}) => React.JSX.Element;

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

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const RotateBtn: (props: {
+    className: string;
+}) => React.JSX.Element;

package/dist/displayer/types.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="react" />
+import { TextOptions } from "../component/textEditor";
+import { EScaleType, EToolsKey } from "../core";
+import { SpeechBalloonPlacement } from "../plugin/types";
+export type Color = [number, number, number];
+export type ShowFloatBarMsgValue = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    padding?: number;
+    selectorColor?: string;
+    translate?: [number, number];
+    selectIds?: string[];
+    canvasWidth?: number;
+    canvasHeight?: number;
+    strokeColor?: string;
+    fillColor?: string;
+    thickness?: number;
+    lineDash?: number[];
+    canTextEdit?: boolean;
+    textOpt?: TextOptions;
+    scaleType?: EScaleType;
+    canRotate?: boolean;
+    canLock?: boolean;
+    isLocked?: boolean;
+    points?: [number, number][];
+    shapeOpt?: ShapeOptType;
+    toolsTypes?: Array<EToolsKey>;
+};
+export type SubButProps = {
+    open: boolean;
+    floatBarRef?: React.RefObject<HTMLDivElement>;
+    style?: React.CSSProperties;
+    setOpen: (bol: boolean) => void;
+};
+export type TextButProps = SubButProps & {
+    textOpt?: TextOptions;
+    workIds?: string[];
+};
+export type ShapeOptType = {
+    placement?: SpeechBalloonPlacement;
+    vertices?: number;
+    innerVerticeStep?: number;
+    innerRatio?: number;
+};
+export type ShapeOptButProps = SubButProps & {
+    toolsTypes?: Array<EToolsKey>;
+    shapeOpt?: ShapeOptType;
+    workIds?: string[];
+};

package/dist/hotkey/index.d.ts

@@ -0,0 +1,51 @@
+import type { HotKeys, BaseSubWorkModuleProps } from "../plugin/types";
+import { BaseApplianceManager } from "../plugin/baseApplianceManager";
+import type EventEmitter2 from "eventemitter2";
+import { Collector } from "../collector";
+import { MasterControlForWorker } from "../core/mainEngine";
+export type HotKeyChecker = (event: HotKeyEvent, kind: KeyboardKind) => boolean;
+export type HotKeyEvent = {
+    readonly nativeEvent?: KeyboardEvent;
+    readonly kind: "KeyDown" | "KeyUp";
+    readonly key: string;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+};
+export declare enum KeyboardKind {
+    Mac = "mac",
+    Windows = "windows"
+}
+export type HotKeyCheckerNode = {
+    readonly kind: keyof HotKeys;
+    readonly checker: HotKeyChecker;
+};
+export interface HotkeyManager {
+    readonly internalMsgEmitter: EventEmitter2;
+    readonly control: BaseApplianceManager;
+    readonly roomHotkeyCheckers: HotKeyCheckerNode[];
+    onActiveHotkey(hotKey: keyof HotKeys): void;
+    onSelfActiveHotkey(hotKey: keyof HotKeys): void;
+    colloctHotkey(e: KeyboardEvent): void;
+}
+export declare class HotkeyManagerImpl implements HotkeyManager {
+    internalMsgEmitter: EventEmitter2;
+    control: BaseApplianceManager;
+    roomHotkeyCheckers: HotKeyCheckerNode[];
+    private tmpCopyStore;
+    private tmpCopyCoordInfo?;
+    constructor(props: BaseSubWorkModuleProps);
+    get isUseSelf(): boolean;
+    get isSelector(): boolean;
+    get collector(): Collector | undefined;
+    get mainEngine(): MasterControlForWorker | undefined;
+    get keyboardKind(): KeyboardKind;
+    private getEventKey;
+    onActiveHotkey(hotKey: keyof HotKeys): void;
+    colloctHotkey(e: KeyboardEvent): void;
+    onSelfActiveHotkey(hotKey: keyof HotKeys): void;
+    private checkHotkey;
+    private copySelectorToTemp;
+    private pasteTempToFocusView;
+    private setMemberState;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./plugin";

package/dist/members/index.d.ts

@@ -0,0 +1,15 @@
+import { RoomMember } from "../plugin/types";
+export type MemberDiff = {
+    online: string[];
+    offline: string[];
+};
+export declare class RoomMemberManager {
+    private roomMembers;
+    private onChangeHooks;
+    setRoomMembers(roomMembers: readonly RoomMember[]): void;
+    private executChangeUidHook;
+    getRoomMember(uid: string): RoomMember | undefined;
+    isOnLine(uid: string): boolean;
+    onUidChangeHook(callBack: (diff: MemberDiff) => void): void;
+    destroy(): void;
+}

package/dist/plugin/applianceMultiPlugin.d.ts

@@ -0,0 +1,24 @@
+import { InvisiblePlugin } from "./external";
+import { Room, Displayer, AppliancePluginAttributes, AppliancePluginOptions, AppliancePluginInstance, Logger, ApplianceAdaptor } from "./types";
+import type { WindowManager } from "./multi/applianceMultiManager";
+import { ApplianceMultiManager } from "./multi/applianceMultiManager";
+/**
+ * 多窗口教具
+ */
+export declare class ApplianceMultiPlugin extends InvisiblePlugin<AppliancePluginAttributes, any> {
+    static readonly kind: string;
+    static currentManager?: ApplianceMultiManager;
+    static logger: Logger;
+    static options: AppliancePluginOptions;
+    static getInstance(remake: WindowManager, adaptor?: ApplianceAdaptor): Promise<AppliancePluginInstance>;
+    static onCreate(plugin: InvisiblePlugin<AppliancePluginAttributes, any>): void;
+    static createApplianceMultiPlugin(d: Room, kind: string): Promise<ApplianceMultiPlugin>;
+    static createCurrentManager: (remake: WindowManager, options: AppliancePluginOptions, plugin: ApplianceMultiPlugin) => void;
+    private get isReplay();
+    private get callbackName();
+    init(displayer: Displayer): void;
+    private onPhaseChanged;
+    private updateRoomWritable;
+    private roomStateChangeListener;
+    destroy(): void;
+}

package/dist/plugin/applianceSinglePlugin.d.ts

@@ -0,0 +1,28 @@
+import { InvisiblePlugin } from "./external";
+import { CursorAdapter, Room, AppliancePluginAttributes, AppliancePluginOptions, AppliancePluginInstance, Logger, ApplianceAdaptor, Displayer } from "./types";
+import { ApplianceSingleManager } from "./single/applianceSingleManager";
+/**
+ * 单白板教具
+ */
+export declare class ApplianceSinglePlugin extends InvisiblePlugin<AppliancePluginAttributes, any> {
+    static readonly kind: string;
+    static cursorAdapter?: CursorAdapter;
+    static currentManager?: ApplianceSingleManager;
+    static logger: Logger;
+    static options: AppliancePluginOptions;
+    static getInstance(remake: Displayer, adaptor?: ApplianceAdaptor): Promise<AppliancePluginInstance>;
+    static onCreate(plugin: InvisiblePlugin<AppliancePluginAttributes, any>): void;
+    static createAppliancePlugin(d: Room, kind: string): Promise<ApplianceSinglePlugin>;
+    static createCurrentManager: (displayer: Displayer, options: AppliancePluginOptions, plugin?: ApplianceSinglePlugin) => void;
+    /**
+     * 房间实例化时，将当前实例对displayer外部API的添加内部处理逻辑;
+     * @param displayer
+     */
+    static effectInstance(): void;
+    private get isReplay();
+    private get callbackName();
+    init(displayer: Displayer): void;
+    private updateRoomWritable;
+    private roomStateChangeListener;
+    destroy(): void;
+}

package/dist/plugin/baseApplianceManager.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="lodash" />
+import EventEmitter2 from "eventemitter2";
+import { MemberState, AppliancePluginLike, AppliancePluginOptions } from "./types";
+import { Collector } from "../collector";
+import { RoomMemberManager } from "../members";
+import { TextEditorManager } from "../component/textEditor";
+import type { Camera, Displayer, DisplayerCallbacks, Player, Rectangle, Room, RoomMember } from "./types";
+import { CursorManager } from "../cursors";
+import { ViewContainerManager } from "./baseViewContainerManager";
+import { MasterControlForWorker } from "../core/mainEngine";
+import { EToolsKey } from "../core/enum";
+import { BaseShapeOptions } from "../core/tools/base";
+import { ICameraOpt } from "../core/types";
+import { HotkeyManager } from "../hotkey";
+export interface BaseApplianceManagerProps {
+    displayer: Displayer<DisplayerCallbacks>;
+    plugin?: AppliancePluginLike;
+    options?: AppliancePluginOptions;
+}
+/** 插件管理器 */
+export declare abstract class BaseApplianceManager {
+    static InternalMsgEmitter: EventEmitter2;
+    plugin?: AppliancePluginLike;
+    room?: Room;
+    play?: Player;
+    collector?: Collector;
+    hasSwitchToSelectorEffect?: boolean;
+    snapshootStateMap?: Map<string, unknown>;
+    effectResolve?: (value: boolean) => void;
+    readonly hotkeyManager: HotkeyManager;
+    readonly pluginOptions?: AppliancePluginOptions;
+    readonly roomMember: RoomMemberManager;
+    readonly cursor: CursorManager;
+    readonly textEditorManager: TextEditorManager;
+    readonly worker: MasterControlForWorker;
+    abstract readonly viewContainerManager: ViewContainerManager;
+    constructor(params: BaseApplianceManagerProps);
+    bindPlugin(plugin: AppliancePluginLike): void;
+    /** 激活 plugin */
+    abstract activePlugin(): void;
+    /** 初始化 */
+    abstract init(): void;
+    /** 激活worker */
+    abstract activeWorker(): void;
+    /** 销毁 */
+    destroy(): void;
+    /** 清空当前获焦路径下的所有内容 */
+    cleanCurrentScene(): void;
+    /** 监听读写状态变更 */
+    onWritableChange(isWritable: boolean): void;
+    /** 监听路径变化 */
+    onSceneChange: (scenePath: string, viewId: string) => Promise<void>;
+    /** 监听房间成员变化 */
+    onRoomMembersChange: (roomMembers: readonly RoomMember[]) => void;
+    /** 监听房间教具变更 */
+    onMemberChange: import("lodash").DebouncedFunc<(memberState: MemberState) => void>;
+    /** 获取当前工具key */
+    protected getToolsKey(memberState: MemberState): EToolsKey.Pencil | EToolsKey.Eraser | EToolsKey.Selector | EToolsKey.Clicker | EToolsKey.Arrow | EToolsKey.LaserPen | EToolsKey.Text | EToolsKey.Straight | EToolsKey.Rectangle | EToolsKey.Ellipse | EToolsKey.Star | EToolsKey.Polygon | EToolsKey.SpeechBalloon;
+    /** 获取当前工具默认配置 */
+    protected getToolsOpt(toolsKey: EToolsKey, memberState: MemberState): {
+        toolsType: EToolsKey;
+        toolsOpt: BaseShapeOptions;
+    };
+    /** 激活当前view容器*/
+    protected effectViewContainer(toolsKey: EToolsKey): void;
+    internalSceneChange: (viewId: string, scenePath: string) => void;
+    internalCameraChange: (viewId: string, cameraOpt: ICameraOpt) => void;
+    /** 异步获取指定路径下绘制内容的区域大小 */
+    getBoundingRect(scenePath: string): Promise<Rectangle | undefined>;
+    /** 异步获取指定路径下的的快照并绘制到指定的画布上 */
+    screenshotToCanvas(context: CanvasRenderingContext2D, scenePath: string, width?: number, height?: number, camera?: Camera, originX?: number, originY?: number): Promise<void>;
+    /** 异步获取指定路径下的缩略图 */
+    scenePreview(scenePath: string, img: HTMLImageElement): Promise<void>;
+    setOriginMemberState(): void;
+    /** 切换到选择工具 */
+    switchToSelector(): void;
+    /** 开始执行副作用 */
+    runEffectWork(callback?: () => void): Promise<void>;
+    setSnapshootData(): void;
+    getSnapshootData(key: string): unknown;
+    clearSnapshootData(): void;
+}

package/dist/plugin/baseViewContainerManager.d.ts

@@ -0,0 +1,174 @@
+/// <reference types="react" />
+/// <reference types="lodash" />
+import type EventEmitter2 from "eventemitter2";
+import { ICameraOpt, ILayerOptionType, IMainMessageRenderData, IOffscreenCanvasOptionType } from "../core/types";
+import { BaseSubWorkModuleProps, ApplianceManagerLike } from "./types";
+import type { CameraState, View } from "./types";
+import { ShowFloatBarMsgValue } from "../displayer/types";
+import { UndoRedoMethod } from "../undo";
+import { BaseViewDisplayer } from "./displayerView";
+export interface ViewInfo {
+    id: string;
+    focusScenePath: string;
+    displayer: MainViewDisplayerManager | AppViewDisplayerManager;
+    container?: HTMLDivElement;
+    cameraOpt?: ICameraOpt;
+    viewData?: View;
+    [key: string]: any;
+}
+/** view容器管理器抽象 */
+export declare abstract class ViewContainerManager {
+    static defaultCameraOpt: Pick<ICameraOpt, 'centerX' | 'centerY' | 'scale'>;
+    static defaultScreenCanvasOpt: Pick<IOffscreenCanvasOptionType, 'autoRender' | 'contextType'>;
+    static defaultLayerOpt: Pick<ILayerOptionType, 'offscreen' | 'handleEvent' | 'depth'>;
+    internalMsgEmitter: EventEmitter2;
+    control: ApplianceManagerLike;
+    abstract focuedViewId?: string;
+    abstract focuedView?: ViewInfo;
+    mainView?: ViewInfo;
+    appViews: Map<string, ViewInfo>;
+    constructor(props: BaseSubWorkModuleProps);
+    undoTickerStart(id: number, viewId: string): void;
+    undoTickerEnd(id: number, viewId: string, isSync?: boolean): void;
+    addExcludeIds(ids: string[], viewId: string): void;
+    undo(): number;
+    redo(): number;
+    protected validator(target: ViewInfo, key: string, value: any): void;
+    abstract mountView(viewIde: string): void;
+    destroyAppView(viewId: string, justLocal?: boolean): void;
+    createMianView(originMainView: ViewInfo): void;
+    createAppView(originAppView: ViewInfo): void;
+    isAppView(viewId: string): boolean;
+    getView(viewId: string): ViewInfo | undefined;
+    getCurScenePath(viewId: string): string | undefined;
+    getAllViews(): (ViewInfo | undefined)[];
+    setViewScenePath(viewId: string, scenePath: string): void;
+    setViewData(viewId: string, viewData: View): void;
+    setFocuedViewId(viewId: string): void;
+    setViewFocusScenePath(viewId: string, scenePath: string): void;
+    /** 销毁 */
+    destroy(): void;
+    setFocuedViewCameraOpt(cameraState: CameraState): void;
+    /** view中心点坐标转换成页面原始坐标 */
+    transformToOriginPoint(p: [number, number], viewId: string): [number, number];
+    /** 页面坐标转换成view中心点坐标 */
+    transformToScenePoint(p: [number, number], viewId: string): [number, number];
+    /** 绘制view */
+    render(renderData: IMainMessageRenderData[]): void;
+    /** 是否绘制浮动选框 */
+    showFloatBar(viewId: string, isShow: boolean, opt?: Partial<ShowFloatBarMsgValue>): void;
+    /** 激活浮动选框 */
+    activeFloatBar(viewId: string): void;
+    /** 销毁浮动选框 */
+    unActiveFloatBar(viewId: string): void;
+    /** 激活刷新文字编辑器 */
+    setActiveTextEditor(viewId: string, activeTextId?: string): void;
+}
+/** appView容器管理器抽象 */
+export declare abstract class AppViewDisplayerManager {
+    viewId: string;
+    abstract dpr: number;
+    abstract width: number;
+    abstract height: number;
+    readonly control: ApplianceManagerLike;
+    readonly internalMsgEmitter: EventEmitter2;
+    readonly commiter: UndoRedoMethod;
+    abstract vDom?: BaseViewDisplayer;
+    abstract eventTragetElement?: HTMLDivElement;
+    abstract canvasServiceFloatRef: React.RefObject<HTMLCanvasElement>;
+    abstract canvasFloatRef: React.RefObject<HTMLCanvasElement>;
+    abstract canvasBgRef: React.RefObject<HTMLCanvasElement>;
+    abstract floatBarRef: React.RefObject<HTMLDivElement>;
+    abstract floatBarCanvasRef: React.RefObject<HTMLCanvasElement>;
+    abstract containerOffset: {
+        x: number;
+        y: number;
+    };
+    private cachePoint?;
+    private cacheCursorPoint?;
+    private active;
+    constructor(viewId: string, control: ApplianceManagerLike, internalMsgEmitter: EventEmitter2);
+    abstract setCanvassStyle(): void;
+    bindToolsClass(): void;
+    mountView(): void;
+    reflashContainerOffset(): void;
+    updateSize(): void;
+    setViewId(viewId: string): void;
+    destroy(): void;
+    getPoint(e: any): [number, number] | undefined;
+    setActive(bol: boolean): void;
+    stopEventHandler(): Promise<void>;
+    private getTranslate;
+    protected getContainerOffset(eventTraget: HTMLDivElement, offset: {
+        x: number;
+        y: number;
+    }): {
+        x: any;
+        y: any;
+    };
+    protected mousedown: (e: MouseEvent) => void;
+    protected mousemove: (e: MouseEvent) => void;
+    protected mouseup: (e: MouseEvent) => void;
+    protected touchstart: (e: TouchEvent) => void;
+    protected touchmove: (e: TouchEvent) => void;
+    protected touchend: (e: TouchEvent) => void;
+    cursorMouseMove: import("lodash").DebouncedFunc<(e: MouseEvent) => void>;
+    protected cursorMouseLeave: import("lodash").DebouncedFunc<() => void>;
+    protected keydown: (e: KeyboardEvent) => void;
+    protected bindDisplayerEvent(div: HTMLDivElement): void;
+    protected removeDisplayerEvent(div: HTMLDivElement): void;
+}
+/** 主容器管理器抽象 */
+export declare abstract class MainViewDisplayerManager {
+    static readonly viewId: string;
+    readonly viewId: string;
+    readonly control: ApplianceManagerLike;
+    readonly internalMsgEmitter: EventEmitter2;
+    readonly commiter: UndoRedoMethod;
+    abstract dpr: number;
+    abstract width: number;
+    abstract height: number;
+    abstract vDom?: BaseViewDisplayer;
+    abstract eventTragetElement?: HTMLDivElement;
+    abstract canvasServiceFloatRef: React.RefObject<HTMLCanvasElement>;
+    abstract canvasFloatRef: React.RefObject<HTMLCanvasElement>;
+    abstract canvasBgRef: React.RefObject<HTMLCanvasElement>;
+    abstract floatBarRef: React.RefObject<HTMLDivElement>;
+    abstract floatBarCanvasRef: React.RefObject<HTMLCanvasElement>;
+    abstract containerOffset: {
+        x: number;
+        y: number;
+    };
+    private cachePoint?;
+    private cacheCursorPoint?;
+    private active;
+    constructor(control: ApplianceManagerLike, internalMsgEmitter: EventEmitter2);
+    abstract setCanvassStyle(): void;
+    bindToolsClass(): void;
+    mountView(): void;
+    updateSize(): void;
+    reflashContainerOffset(): void;
+    destroy(): void;
+    getPoint(e: any): [number, number] | undefined;
+    setActive(bol: boolean): void;
+    stopEventHandler(): Promise<void>;
+    private getTranslate;
+    protected getContainerOffset(eventTraget: HTMLDivElement, offset: {
+        x: number;
+        y: number;
+    }): {
+        x: any;
+        y: any;
+    };
+    protected mousedown: (e: MouseEvent) => void;
+    protected mousemove: (e: MouseEvent) => void;
+    protected mouseup: (e: MouseEvent) => void;
+    protected touchstart: (e: TouchEvent) => void;
+    protected touchmove: (e: TouchEvent) => void;
+    protected touchend: (e: TouchEvent) => void;
+    cursorMouseMove: import("lodash").DebouncedFunc<(e: MouseEvent) => void>;
+    protected cursorMouseLeave: import("lodash").DebouncedFunc<() => void>;
+    protected keydown: (e: KeyboardEvent) => void;
+    protected bindDisplayerEvent(div: HTMLDivElement): void;
+    protected removeDisplayerEvent(div: HTMLDivElement): void;
+}

package/dist/plugin/displayerView.d.ts

@@ -0,0 +1,55 @@
+import React, { ReactNode } from "react";
+import { EmitEventType, ApplianceViewManagerLike } from "./types";
+import { TextEditorInfo } from "../component/textEditor";
+import { ShowFloatBarMsgValue } from "../displayer/types";
+export interface BaseDisplayerProps {
+    viewId: string;
+    maranger: ApplianceViewManagerLike;
+    refs: {
+        canvasServiceFloatRef: React.RefObject<HTMLCanvasElement>;
+        canvasFloatRef: React.RefObject<HTMLCanvasElement>;
+        canvasBgRef: React.RefObject<HTMLCanvasElement>;
+        floatBarRef: React.RefObject<HTMLDivElement>;
+        floatBarCanvasRef: React.RefObject<HTMLCanvasElement>;
+    };
+}
+export interface BaseDisplayerState {
+    showFloatBar: boolean;
+    zIndex: number;
+    floatBarData?: ShowFloatBarMsgValue;
+    dpr: number;
+    position?: {
+        x: number;
+        y: number;
+    };
+    operationType: EmitEventType;
+    angle: number;
+    scale: [number, number];
+    editors?: Map<string, TextEditorInfo>;
+    activeTextId?: string;
+}
+export declare const DisplayerContext: React.Context<Pick<BaseDisplayerState, "scale" | "zIndex" | "dpr" | "position" | "angle" | "floatBarData" | "operationType"> & {
+    maranger?: ApplianceViewManagerLike | undefined;
+    floatBarColors: [number, number, number][];
+    setPosition: (point: {
+        x: number;
+        y: number;
+    }) => void;
+    setAngle: (angle: number) => void;
+    setOperationType: (type: EmitEventType) => void;
+    setFloatBarData: (data: Partial<ShowFloatBarMsgValue>) => void;
+}>;
+export declare class BaseViewDisplayer extends React.Component<BaseDisplayerProps, BaseDisplayerState> {
+    constructor(props: BaseDisplayerProps);
+    private get editors();
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    showFloatBar(show: boolean, value?: Partial<ShowFloatBarMsgValue>): void;
+    setActiveTextEditor(activeTextId?: string): void;
+    setFloatZIndex(zIndex: number): void;
+    setFloatBarData(data: Partial<ShowFloatBarMsgValue>): void;
+    private setPosition;
+    private setAngle;
+    private setOperationType;
+    render(): ReactNode;
+}

package/dist/plugin/external.d.ts

@@ -0,0 +1,2 @@
+import { toJS, autorun, isRoom, isPlayer, InvisiblePlugin, RoomPhase } from "white-web-sdk";
+export { toJS, autorun, isRoom, isPlayer, InvisiblePlugin, RoomPhase };

package/dist/plugin/index.d.ts

@@ -0,0 +1,6 @@
+import { ApplianceAdaptor, AppliancePluginOptions, ApplianceNames, MemberState } from "./types";
+export type { ApplianceAdaptor, AppliancePluginOptions, ApplianceNames, MemberState };
+export { ECanvasContextType } from "../core/enum";
+export { ApplianceMultiPlugin } from "./applianceMultiPlugin";
+export { ApplianceSinglePlugin } from "./applianceSinglePlugin";
+export { ApplianceSigleWrapper } from "../plugin/single/applianceDisplayer";

package/dist/plugin/multi/applianceMultiManager.d.ts

@@ -0,0 +1,14 @@
+import type { AnimationMode, WindowManager } from "@netless/window-manager";
+import { BaseApplianceManager, BaseApplianceManagerProps } from "../baseApplianceManager";
+import { ViewContainerMultiManager } from "./containerManager";
+export type { AnimationMode, WindowManager };
+export declare class ApplianceMultiManager extends BaseApplianceManager {
+    windowManager?: WindowManager;
+    viewContainerManager: ViewContainerMultiManager;
+    constructor(params: BaseApplianceManagerProps);
+    init(): void;
+    destroy(): void;
+    activePlugin(): void;
+    activeWorker(): void;
+    setWindowManager(windowManager: WindowManager): void;
+}

package/dist/plugin/multi/containerManager.d.ts

@@ -0,0 +1,24 @@
+import { ViewContainerManager, ViewInfo } from "../baseViewContainerManager";
+import type { View } from "../types";
+import { BaseSubWorkModuleProps } from "../types";
+import { ApplianceMultiManager } from "./applianceMultiManager";
+import type { WindowManager } from './applianceMultiManager';
+export declare class ViewContainerMultiManager extends ViewContainerManager {
+    focuedViewId?: string;
+    focuedView?: ViewInfo;
+    control: ApplianceMultiManager;
+    /** 针对windowmanager的focusedChange先于onAppViewMounted*/
+    tmpFocusedViewId?: string;
+    private checkScaleTimer?;
+    constructor(props: BaseSubWorkModuleProps);
+    mountView(viewId: string): void;
+    listenerWindowManager(windowManager: WindowManager): void;
+    private onMainViewRelease;
+    onMainViewMounted: (bindMainView: View) => void;
+    private onMainViewSizeUpdated;
+    private onMainViewCameraUpdated;
+    onAppViewMounted: (payload: any) => void;
+    private onAppViewSizeUpdated;
+    private onAppViewCameraUpdated;
+    private onActiveHotkeyChange;
+}

package/dist/plugin/multi/displayer/appViewDisplayerManager.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import { BaseViewDisplayer } from "../../displayerView";
+import { AppViewDisplayerManager } from "../../baseViewContainerManager";
+import { EventEmitter2 } from "eventemitter2";
+import { ApplianceMultiManager } from "../applianceMultiManager";
+export declare class AppViewDisplayerManagerImpl extends AppViewDisplayerManager {
+    dpr: number;
+    width: number;
+    height: number;
+    vDom?: BaseViewDisplayer;
+    eventTragetElement?: HTMLDivElement;
+    canvasServiceFloatRef: React.RefObject<HTMLCanvasElement>;
+    canvasFloatRef: React.RefObject<HTMLCanvasElement>;
+    canvasBgRef: React.RefObject<HTMLCanvasElement>;
+    floatBarRef: React.RefObject<HTMLDivElement>;
+    floatBarCanvasRef: React.RefObject<HTMLCanvasElement>;
+    containerOffset: {
+        x: number;
+        y: number;
+    };
+    constructor(viewId: string, control: ApplianceMultiManager, internalMsgEmitter: EventEmitter2);
+    setCanvassStyle(): void;
+    createAppViewDisplayer(viewId: string, appViewContainer: HTMLDivElement): AppViewDisplayerManager;
+}