@netless/window-manager 1.0.0-canary.24 → 1.0.0-canary.27

package/dist/src/App/AppContext.d.ts

@@ -0,0 +1,78 @@
+import { Storage } from "./Storage";
+import { autorun, listenDisposed, listenUpdated, reaction, unlistenDisposed, unlistenUpdated, toJS } from "white-web-sdk";
+import type { Room, SceneDefinition, View } from "white-web-sdk";
+import type { ReadonlyTeleBox } from "@netless/telebox-insider";
+import type Emittery from "emittery";
+import type { AppEmitterEvent, Member } from "../index";
+import type { AppManager } from "../AppManager";
+import type { AppProxy } from "./AppProxy";
+import type { MagixEventAddListener, MagixEventDispatcher, MagixEventRemoveListener } from "./MagixEvent";
+import { WhiteBoardView } from "./WhiteboardView";
+export declare type CreateWhiteBoardViewParams = {
+    size?: number;
+    syncCamera?: boolean;
+};
+export declare class AppContext<TAttributes = any, TMagixEventPayloads = any, TAppOptions = any> {
+    private manager;
+    appId: string;
+    private appProxy;
+    private appOptions?;
+    readonly emitter: Emittery<AppEmitterEvent<TAttributes>>;
+    readonly mobxUtils: {
+        autorun: typeof autorun;
+        reaction: typeof reaction;
+        toJS: typeof toJS;
+    };
+    readonly objectUtils: {
+        listenUpdated: typeof listenUpdated;
+        unlistenUpdated: typeof unlistenUpdated;
+        listenDisposed: typeof listenDisposed;
+        unlistenDisposed: typeof unlistenDisposed;
+    };
+    private store;
+    readonly isAddApp: boolean;
+    readonly isReplay: boolean;
+    whiteBoardView?: WhiteBoardView;
+    _viewWrapper?: HTMLElement;
+    constructor(manager: AppManager, appId: string, appProxy: AppProxy, appOptions?: TAppOptions | (() => TAppOptions) | undefined);
+    get displayer(): import("white-web-sdk").Displayer<import("white-web-sdk").DisplayerCallbacks>;
+    get destroyed(): boolean;
+    /** @deprecated Use context.storage.state instead. */
+    getAttributes: () => TAttributes | undefined;
+    getScenes: () => SceneDefinition[] | undefined;
+    get view(): View | undefined;
+    createWhiteBoardView: (params?: CreateWhiteBoardViewParams | undefined) => WhiteBoardView;
+    private ensurePageSize;
+    getInitScenePath: () => string | undefined;
+    /** Get App writable status. */
+    get isWritable(): boolean;
+    /** Get the App Window UI box. */
+    get box(): ReadonlyTeleBox;
+    get room(): Room | undefined;
+    get members(): Member[];
+    get currentMember(): Member;
+    /** @deprecated Use context.storage.setState instead. */
+    setAttributes: (attributes: TAttributes) => void;
+    /** @deprecated Use context.storage.setState instead. */
+    updateAttributes: (keys: string[], value: any) => void;
+    /** @deprecated Use Pages api instead. */
+    setScenePath: (scenePath: string) => Promise<void>;
+    /** Get the local App options. */
+    getAppOptions: () => TAppOptions | undefined;
+    private _storage?;
+    /** Main Storage for attributes. */
+    get storage(): Storage<TAttributes>;
+    /**
+     * Create separated storages for flexible state management.
+     * @param storeId Namespace for the storage. Storages of the same namespace share the same data.
+     * @param defaultState Default state for initial storage creation.
+     * @returns
+     */
+    createStorage: <TState>(storeId: string, defaultState?: TState | undefined) => Storage<TState>;
+    /** Dispatch events to other clients (and self). */
+    dispatchMagixEvent: MagixEventDispatcher<TMagixEventPayloads>;
+    /** Listen to events from others clients (and self messages). */
+    addMagixEventListener: MagixEventAddListener<TMagixEventPayloads>;
+    /** Remove a Magix event listener. */
+    removeMagixEventListener: MagixEventRemoveListener<TMagixEventPayloads>;
+}

package/dist/src/App/AppPageStateImpl.d.ts

@@ -0,0 +1,21 @@
+import type { Displayer, ScenesCallbacksNode, View } from "white-web-sdk";
+import type { PageState } from "../Page";
+export declare type AppPageStateParams = {
+    displayer: Displayer;
+    scenePath: string | undefined;
+    view: View | undefined;
+    notifyPageStateChange: () => void;
+};
+export declare class AppPageStateImpl {
+    private params;
+    sceneNode: ScenesCallbacksNode | null;
+    private scenePath?;
+    private view?;
+    constructor(params: AppPageStateParams);
+    createSceneNode: (scenePath: string) => ScenesCallbacksNode | null;
+    setView(view: View): void;
+    private onSceneChange;
+    getFullPath(index: number): string | undefined;
+    toObject(): PageState;
+    destroy(): void;
+}

package/dist/src/App/AppProxy.d.ts

@@ -0,0 +1,98 @@
+import Emittery from "emittery";
+import { AppContext } from "./AppContext";
+import { AppPageStateImpl } from "./AppPageStateImpl";
+import { Val } from "value-enhancer";
+import { SideEffectManager } from "side-effect-manager";
+import type { ICamera, ISize } from "../AttributesDelegate";
+import type { AppEmitterEvent, BaseInsertParams } from "../index";
+import type { SceneState, View, SceneDefinition } from "white-web-sdk";
+import type { AppManager } from "../AppManager";
+import type { NetlessApp } from "../typings";
+import type { ReadonlyTeleBox } from "@netless/telebox-insider";
+import type { PageRemoveService, PageState } from "../Page";
+import type { AppState } from "./type";
+export declare type AppEmitter = Emittery<AppEmitterEvent>;
+export declare class AppProxy implements PageRemoveService {
+    private params;
+    private manager;
+    kind: string;
+    id: string;
+    scenePath?: string;
+    private appScenePath;
+    appEmitter: AppEmitter;
+    scenes?: SceneDefinition[];
+    private appListener;
+    private boxManager;
+    private appProxies;
+    private viewManager;
+    private store;
+    uid: string;
+    isAddApp: boolean;
+    status: "normal" | "destroyed";
+    private stateKey;
+    _pageState: AppPageStateImpl;
+    appResult?: NetlessApp;
+    appContext?: AppContext;
+    sideEffectManager: SideEffectManager;
+    private valManager;
+    private fullPath$;
+    private viewSync?;
+    camera$: Val<{
+        id: string;
+        centerX: number | null;
+        centerY: number | null;
+        scale: number;
+    } | undefined, any>;
+    size$: Val<ISize | undefined, any>;
+    box$: Val<ReadonlyTeleBox | undefined, any>;
+    view$: Val<View | undefined, any>;
+    syncCamera$: Val<boolean, any>;
+    whiteBoardViewCreated$: Val<boolean, any>;
+    constructor(params: BaseInsertParams, manager: AppManager, appId: string, isAddApp: boolean);
+    fireMemberStateChange: () => void;
+    private onMemberStateChange;
+    private computedInitialRect;
+    createAppDir(): View;
+    private initScenes;
+    get view(): View | undefined;
+    get viewIndex(): number | undefined;
+    get isWritable(): boolean;
+    get attributes(): any;
+    get appAttributes(): import("../index").AppSyncAttributes;
+    getFullScenePath(): string | undefined;
+    private getFullScenePathFromScenes;
+    setFullPath(path: string): void;
+    baseInsertApp(skipUpdate?: boolean): Promise<{
+        appId: string;
+        app: NetlessApp;
+    }>;
+    get box(): ReadonlyTeleBox | undefined;
+    private setupApp;
+    private fixMobileSize;
+    onSeek(time: number): Promise<void>;
+    onReconnected(): Promise<void>;
+    onRemoveScene(scenePath: string): Promise<void>;
+    getAppInitState: (id: string) => AppState | undefined;
+    emitAppSceneStateChange(sceneState: SceneState): void;
+    emitAppIsWritableChange(): void;
+    private makeAppEventListener;
+    private appAttributesUpdateListener;
+    private setFocusScenePathHandler;
+    setScenePath(): void;
+    setViewFocusScenePath(): string | undefined;
+    private createView;
+    notifyPageStateChange: import("lodash").DebouncedFunc<() => void>;
+    get pageState(): PageState;
+    removeSceneByIndex(index: number): Promise<boolean>;
+    setSceneIndexWithoutSync(index: number): void;
+    setSceneIndex(index: number): void;
+    storeCamera: (camera: ICamera) => void;
+    storeSize: (size: ISize) => void;
+    updateSize: (width: number, height: number) => void;
+    moveCamera: (camera: Partial<ICamera>) => void;
+    destroy(needCloseBox: boolean, cleanAttrs: boolean, skipUpdate: boolean, error?: Error): Promise<void>;
+    private addCameraReaction;
+    private addSizeReaction;
+    onFocus: () => void;
+    close(): Promise<void>;
+}

package/dist/src/App/MagixEvent/index.d.ts

@@ -0,0 +1,29 @@
+import type { MagixEventListenerOptions as WhiteMagixListenerOptions, Event as WhiteEvent, EventPhase as WhiteEventPhase, Scope as WhiteScope } from "white-web-sdk";
+export interface MagixEventListenerOptions extends WhiteMagixListenerOptions {
+    /**
+     * Rapid emitted callbacks will be slowed down to this interval (in ms).
+     */
+    fireInterval?: number;
+    /**
+     * If `true`, sent events will reach self-listeners after committed to server.
+     * Otherwise the events will reach self-listeners immediately.
+     */
+    fireSelfEventAfterCommit?: boolean;
+}
+export interface MagixEventMessage<TPayloads = any, TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>> extends Omit<WhiteEvent, "scope" | "phase"> {
+    /** Event name */
+    event: TEvent;
+    /** Event Payload */
+    payload: TPayloads[TEvent];
+    /** Whiteboard ID of the client who dispatched the event. It will be AdminObserverId for system events. */
+    authorId: number;
+    scope: `${WhiteScope}`;
+    phase: `${WhiteEventPhase}`;
+}
+export declare type MagixEventTypes<TPayloads = any> = Extract<keyof TPayloads, string>;
+export declare type MagixEventPayload<TPayloads = any, TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>> = TPayloads[TEvent];
+export declare type MagixEventDispatcher<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, payload: TPayloads[TEvent]) => void;
+export declare type MagixEventHandler<TPayloads = any, TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>> = (message: MagixEventMessage<TPayloads, TEvent>) => void;
+export declare type MagixEventListenerDisposer = () => void;
+export declare type MagixEventAddListener<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, handler: MagixEventHandler<TPayloads, TEvent>, options?: MagixEventListenerOptions | undefined) => MagixEventListenerDisposer;
+export declare type MagixEventRemoveListener<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, handler?: MagixEventHandler<TPayloads, TEvent>) => void;

package/dist/src/App/Storage/StorageEvent.d.ts

@@ -0,0 +1,8 @@
+export declare type StorageEventListener<T> = (event: T) => void;
+export declare class StorageEvent<TMessage> {
+    listeners: Set<StorageEventListener<TMessage>>;
+    get length(): number;
+    dispatch(message: TMessage): void;
+    addListener(listener: StorageEventListener<TMessage>): void;
+    removeListener(listener: StorageEventListener<TMessage>): void;
+}

package/dist/src/App/Storage/index.d.ts

@@ -0,0 +1,39 @@
+import type { AppContext } from "../AppContext";
+import type { Diff, StorageStateChangedListener, StorageStateChangedListenerDisposer } from "./typings";
+import { StorageEvent } from "./StorageEvent";
+export * from './typings';
+export declare const STORAGE_NS = "_WM-STORAGE_";
+export declare class Storage<TState extends Record<string, any> = any> implements Storage<TState> {
+    readonly id: string | null;
+    private readonly _context;
+    private readonly _sideEffect;
+    private _state;
+    private _destroyed;
+    private _refMap;
+    /**
+     * `setState` alters local state immediately before sending to server. This will cache the old value for onStateChanged diffing.
+     */
+    private _lastValue;
+    constructor(context: AppContext, id?: string, defaultState?: TState);
+    get state(): Readonly<TState>;
+    readonly onStateChanged: StorageEvent<Diff<TState>>;
+    addStateChangedListener(handler: StorageStateChangedListener<TState>): StorageStateChangedListenerDisposer;
+    ensureState(state: Partial<TState>): void;
+    setState(state: Partial<TState>): void;
+    /**
+     * Empty storage data.
+     */
+    emptyStorage(): void;
+    /**
+     * Delete storage index with all of its data and destroy the Storage instance.
+     */
+    deleteStorage(): void;
+    get destroyed(): boolean;
+    /**
+     * Destroy the Storage instance. The data will be kept.
+     */
+    destroy(): void;
+    private _getRawState;
+    private _setRawState;
+    private _updateProperties;
+}

package/dist/src/App/Storage/typings.d.ts

@@ -0,0 +1,22 @@
+import type { StorageEventListener } from "./StorageEvent";
+export declare type RefValue<TValue = any> = {
+    k: string;
+    v: TValue;
+    __isRef: true;
+};
+export declare type ExtractRawValue<TValue> = TValue extends RefValue<infer TRefValue> ? TRefValue : TValue;
+export declare type AutoRefValue<TValue> = RefValue<ExtractRawValue<TValue>>;
+export declare type MaybeRefValue<TValue> = TValue | AutoRefValue<TValue>;
+export declare type DiffOne<T> = {
+    oldValue?: T;
+    newValue?: T;
+};
+export declare type Diff<T> = {
+    [K in keyof T]?: DiffOne<T[K]>;
+};
+export declare type StorageOnSetStatePayload<TState = unknown> = {
+    [K in keyof TState]?: MaybeRefValue<TState[K]>;
+};
+export declare type StorageStateChangedEvent<TState = any> = Diff<TState>;
+export declare type StorageStateChangedListener<TState = any> = StorageEventListener<StorageStateChangedEvent<TState>>;
+export declare type StorageStateChangedListenerDisposer = () => void;

package/dist/src/App/Storage/utils.d.ts

@@ -0,0 +1,5 @@
+import type { AutoRefValue, RefValue } from "./typings";
+export declare const plainObjectKeys: <T>(o: T) => Extract<keyof T, string>[];
+export declare function isRef<TValue = unknown>(e: unknown): e is RefValue<TValue>;
+export declare function makeRef<TValue>(v: TValue): RefValue<TValue>;
+export declare function makeAutoRef<TValue>(v: TValue): AutoRefValue<TValue>;

package/dist/src/App/WhiteboardView.d.ts

@@ -0,0 +1,27 @@
+import type { ReadonlyVal } from "value-enhancer";
+import type { AddPageParams, PageController, PageState } from "../Page";
+import type { AppProxy } from "./AppProxy";
+import type { AppContext } from "./AppContext";
+import type { View } from "white-web-sdk";
+import type { TeleBoxRect } from "@netless/telebox-insider";
+import type { ICamera, ISize } from "../AttributesDelegate";
+export declare type WhiteBoardViewCamera = Omit<ICamera, "id">;
+export declare type WhiteBoardViewRect = Omit<ISize, "id">;
+export declare class WhiteBoardView implements PageController {
+    view: View;
+    protected appContext: AppContext;
+    protected appProxy: AppProxy;
+    ensureSize: (size: number) => void;
+    readonly pageState$: ReadonlyVal<PageState>;
+    readonly baseCamera$: ReadonlyVal<WhiteBoardViewCamera>;
+    readonly baseRect$: ReadonlyVal<WhiteBoardViewRect | undefined>;
+    constructor(view: View, appContext: AppContext, appProxy: AppProxy, ensureSize: (size: number) => void);
+    get pageState(): PageState;
+    moveCamera(camera: Partial<WhiteBoardViewCamera>): void;
+    nextPage: () => Promise<boolean>;
+    prevPage: () => Promise<boolean>;
+    jumpPage: (index: number) => Promise<boolean>;
+    addPage: (params?: AddPageParams | undefined) => Promise<void>;
+    removePage: (index?: number | undefined) => Promise<boolean>;
+    setBaseRect(rect: Omit<TeleBoxRect, "x" | "y">): void;
+}

package/dist/src/App/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./AppProxy";
+export * from "./AppContext";
+export * from "./WhiteboardView";
+export * from "./type";

package/dist/src/App/type.d.ts

@@ -0,0 +1,21 @@
+export declare type AppState = {
+    id: string;
+    focus?: boolean;
+    SceneIndex?: number;
+    draggable?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    };
+    ratio?: number;
+    resizable?: boolean;
+    size?: {
+        width: number;
+        height: number;
+    };
+    stageRatio?: number;
+    visible?: boolean;
+    zIndex?: number;
+    maximized: boolean | null;
+    minimized: boolean | null;
+};

package/dist/src/AppListener.d.ts

@@ -0,0 +1,19 @@
+import type { AppManager } from "./AppManager";
+export declare class AppListeners {
+    private manager;
+    private displayer;
+    constructor(manager: AppManager);
+    private get boxManager();
+    addListeners(): void;
+    removeListeners(): void;
+    private mainMagixEventListener;
+    private appMoveHandler;
+    private appResizeHandler;
+    private boxStateChangeHandler;
+    private setMainViewScenePathHandler;
+    private cursorMoveHandler;
+    private rootDirRemovedHandler;
+    private refreshHandler;
+    private initMainViewCameraHandler;
+    private setAppFocusViewIndexHandler;
+}

package/dist/src/AppManager.d.ts

@@ -0,0 +1,107 @@
+import { AppStatus, Events } from "./constants";
+import { AppProxy } from "./App";
+import { MainViewProxy } from "./View/MainView";
+import { WindowManager } from "./index";
+import { ViewManager } from "./View/ViewManager";
+import type { ReconnectRefresher } from "./ReconnectRefresher";
+import type { BoxManager } from "./BoxManager";
+import type { Displayer, Room, SceneState } from "white-web-sdk";
+import type { AddAppParams, TeleBoxRect } from "./index";
+import type { Member } from "./Helper";
+export declare class AppManager {
+    windowManger: WindowManager;
+    displayer: Displayer;
+    viewManager: ViewManager;
+    appProxies: Map<string, AppProxy>;
+    appStatus: Map<string, AppStatus>;
+    store: import("./AttributesDelegate").AttributesDelegate;
+    mainViewProxy: MainViewProxy;
+    refresher: ReconnectRefresher;
+    isReplay: boolean;
+    mainViewScenesLength: number;
+    private appListeners;
+    boxManager?: BoxManager;
+    private callbacksNode;
+    private appCreateQueue;
+    private sceneIndex$;
+    private focused$;
+    private sideEffectManager;
+    sceneState: SceneState | null;
+    rootDirRemoving: boolean;
+    constructor(windowManger: WindowManager);
+    private onRemoveScenes;
+    /**
+     * 根目录被删除时所有的 scene 都会被删除.
+     * 所以需要关掉所有开启了 view 的 app
+     */
+    onRootDirRemoved(needClose?: boolean): Promise<void>;
+    private onReadonlyChanged;
+    private onPlayerSeekStart;
+    private onPlayerSeekDone;
+    createRootDirScenesCallback: () => void;
+    removeSceneByIndex: (index: number) => Promise<boolean>;
+    setSceneIndexWithoutSync: (index: number) => void;
+    private onSceneChange;
+    private emitMainViewScenesChange;
+    private updateSceneState;
+    private get eventName();
+    get attributes(): import("./index").WindowMangerAttributes;
+    get canOperate(): boolean;
+    get room(): Room | undefined;
+    get mainView(): import("white-web-sdk").View;
+    get focusApp(): AppProxy | undefined;
+    get uid(): string;
+    get members(): Member[];
+    getMainViewSceneDir(): string;
+    private onCreated;
+    private onBoxMove;
+    private onBoxResize;
+    private onBoxFocus;
+    private onBoxClose;
+    private onBoxStateChange;
+    addAppsChangeListener: () => void;
+    addAppCloseListener: () => void;
+    private onMainViewIndexChange;
+    private onFocusChange;
+    attributesUpdateCallback: import("lodash").DebouncedFunc<(apps: any) => Promise<void>>;
+    /**
+     * 插件更新 apps 时的回调
+     *
+     * @param {*} apps
+     * @memberof WindowManager
+     */
+    _attributesUpdateCallback(apps: any): Promise<void>;
+    private onRegisteredChange;
+    private onMinimized;
+    refresh(): void;
+    setBoxManager(boxManager: BoxManager): void;
+    resetMaximized(): void;
+    resetMinimized(): void;
+    private onAppDelete;
+    private closeAll;
+    bindMainView(divElement: HTMLDivElement, disableCameraTransform: boolean): void;
+    setMainViewFocusPath(scenePath?: string): boolean | undefined;
+    private resetScenePath;
+    addApp(params: AddAppParams, isDynamicPPT: boolean): Promise<string | undefined>;
+    private beforeAddApp;
+    private afterAddApp;
+    closeApp(appId: string, needClose?: boolean): Promise<void>;
+    private baseInsertApp;
+    private displayerStateListener;
+    displayerWritableListener: (isReadonly: boolean) => void;
+    safeSetAttributes(attributes: any): void;
+    safeUpdateAttributes(keys: string[], value: any): void;
+    setMainViewScenePath(scenePath: string): Promise<void>;
+    private _setMainViewScenePath;
+    private updateSceneIndex;
+    setMainViewSceneIndex(index: number): Promise<void>;
+    private dispatchSetMainViewScenePath;
+    getAppInitPath(appId: string): string | undefined;
+    safeDispatchMagixEvent(event: string, payload: any): void;
+    focusByAttributes(apps: any): void;
+    onReconnected(): Promise<void>;
+    notifyContainerRectUpdate(rect: TeleBoxRect): void;
+    updateRootDirRemoving: (removing: boolean) => void;
+    dispatchInternalEvent(event: Events, payload?: any): void;
+    destroy(): void;
+}

package/dist/src/AttributesDelegate.d.ts

@@ -0,0 +1,83 @@
+import { AppAttributes } from "./constants";
+import type { AddAppParams, AppSyncAttributes } from "./index";
+import type { Size, View } from "white-web-sdk";
+import type { Cursor } from "./Cursor/Cursor";
+export declare enum Fields {
+    Apps = "apps",
+    Focus = "focus",
+    State = "state",
+    BoxState = "boxState",
+    MainViewCamera = "mainViewCamera",
+    MainViewSize = "mainViewSize",
+    Broadcaster = "broadcaster",
+    Cursors = "cursors",
+    Position = "position",
+    CursorState = "cursorState",
+    FullPath = "fullPath",
+    Registered = "registered",
+    Camera = "camera",
+    Size = "size"
+}
+export declare type Apps = {
+    [key: string]: AppSyncAttributes;
+};
+export declare type Position = {
+    x: number;
+    y: number;
+    type: PositionType;
+    id?: string;
+};
+export declare type PositionType = "main" | "app";
+export declare type StoreContext = {
+    getAttributes: () => any;
+    safeUpdateAttributes: (keys: string[], value: any) => void;
+    safeSetAttributes: (attributes: any) => void;
+};
+export declare type ICamera = {
+    id: string;
+    centerX: number | null;
+    centerY: number | null;
+    scale: number;
+};
+export declare type ISize = Size & {
+    id: string;
+};
+export declare class AttributesDelegate {
+    private context;
+    constructor(context: StoreContext);
+    setContext(context: StoreContext): void;
+    get attributes(): any;
+    apps(): Apps;
+    get focus(): string | undefined;
+    getAppAttributes(id: string): AppSyncAttributes;
+    getAppState(id: string): any;
+    getMaximized(): any;
+    getMinimized(): any;
+    setupAppAttributes(params: AddAppParams, id: string, isDynamicPPT: boolean): void;
+    updateAppState(appId: string, stateName: AppAttributes, state: any): void;
+    updateAppAttributes(appId: string, key: string, value: any): void;
+    cleanAppAttributes(id: string): void;
+    cleanFocus(): void;
+    getAppSceneIndex(id: string): any;
+    getAppScenePath(id: string): any;
+    getMainViewScenePath(): string | undefined;
+    getMainViewSceneIndex(): any;
+    getBoxState(): any;
+    setMainViewScenePath(scenePath: string): void;
+    setMainViewSceneIndex(index: number): void;
+    getMainViewCamera(): ICamera;
+    getMainViewSize(): ISize;
+    setMainViewCamera(camera: ICamera): void;
+    setMainViewSize(size: ISize): void;
+    setMainViewCameraAndSize(camera: ICamera, size: ISize): void;
+    setAppFocus: (appId: string, focus: boolean) => void;
+    updateCursor(uid: string, position: Position): void;
+    updateCursorState(uid: string, cursorState: string | undefined): void;
+    getCursorState(uid: string): any;
+    cleanCursor(uid: string): void;
+    setMainViewFocusPath(mainView: View): void;
+}
+export declare type Cursors = {
+    [key: string]: Cursor;
+};
+export declare const store: AttributesDelegate;

package/dist/src/BoxEmitter.d.ts

@@ -0,0 +1,34 @@
+import type { TELE_BOX_STATE } from "@netless/telebox-insider";
+import Emittery from "emittery";
+export declare type BoxMovePayload = {
+    appId: string;
+    x: number;
+    y: number;
+};
+export declare type BoxFocusPayload = {
+    appId: string;
+};
+export declare type BoxResizePayload = {
+    appId: string;
+    width: number;
+    height: number;
+    x?: number;
+    y?: number;
+};
+export declare type BoxClosePayload = {
+    appId: string;
+    error?: Error;
+};
+export declare type BoxStateChangePayload = {
+    appId: string;
+    state: TELE_BOX_STATE;
+};
+export declare type BoxEvent = {
+    move: BoxMovePayload;
+    focus: BoxFocusPayload;
+    resize: BoxResizePayload;
+    close: BoxClosePayload;
+    boxStateChange: BoxStateChangePayload;
+};
+export declare type BoxEmitterType = Emittery<BoxEvent>;
+export declare const boxEmitter: BoxEmitterType;