@netless/window-manager 0.4.0-canary.0 → 0.4.0-canary.12

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.0
+
+1. 废弃 `WindowManager.mount` 的多参数类型
+2. 添加 `bindContainer` 接口，`mount` 时 `container` 参数不再是必选
+
+
 ## 0.3.18
 
 1. 修复最小化时刷新页面 box 位置错误的问题

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

@@ -0,0 +1,28 @@
+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 MagixEventAddListener<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, handler: MagixEventHandler<TPayloads, TEvent>, options?: MagixEventListenerOptions | undefined) => void;
+export declare type MagixEventRemoveListener<TPayloads = any> = <TEvent extends MagixEventTypes<TPayloads> = MagixEventTypes<TPayloads>>(event: TEvent, handler?: MagixEventHandler<TPayloads, TEvent>) => void;

package/dist/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/App/Storage/index.d.ts

@@ -0,0 +1,38 @@
+import type { AppContext } from "../../AppContext";
+import type { Diff } 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>>;
+    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/App/Storage/typings.d.ts

@@ -0,0 +1,21 @@
+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>>;

package/dist/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/AppContext.d.ts

@@ -6,13 +6,15 @@ import type { BoxManager } from "./BoxManager";
 import type { AppEmitterEvent } from "./index";
 import type { AppManager } from "./AppManager";
 import type { AppProxy } from "./AppProxy";
-export declare class AppContext<TAttrs extends Record<string, any>, AppOptions = any> {
+import { Storage } from './App/Storage';
+import type { MagixEventAddListener, MagixEventDispatcher, MagixEventRemoveListener } from './App/MagixEvent';
+export declare class AppContext<TAttributes = any, TMagixEventPayloads = any, TAppOptions = any> {
     private manager;
     private boxManager;
     appId: string;
     private appProxy;
     private appOptions?;
-    readonly emitter: Emittery<AppEmitterEvent<TAttrs>>;
+    readonly emitter: Emittery<AppEmitterEvent<TAttributes>>;
     readonly mobxUtils: {
         autorun: typeof autorun;
         reaction: typeof reaction;
@@ -27,18 +29,40 @@ export declare class AppContext<TAttrs extends Record<string, any>, AppOptions =
     private store;
     readonly isAddApp: boolean;
     readonly isReplay: boolean;
-    constructor(manager: AppManager, boxManager: BoxManager, appId: string, appProxy: AppProxy, appOptions?: AppOptions | (() => AppOptions) | undefined);
-    getDisplayer(): import("white-web-sdk").Displayer<import("white-web-sdk").DisplayerCallbacks>;
-    getAttributes(): TAttrs | undefined;
-    getScenes(): SceneDefinition[] | undefined;
-    getView(): View | undefined;
-    getInitScenePath(): string | undefined;
-    getIsWritable(): boolean;
-    getBox(): ReadonlyTeleBox;
-    getRoom(): Room | undefined;
-    setAttributes(attributes: TAttrs): void;
-    updateAttributes(keys: string[], value: any): void;
-    setScenePath(scenePath: string): Promise<void>;
-    mountView(dom: HTMLDivElement): void;
-    getAppOptions(): AppOptions | undefined;
+    constructor(manager: AppManager, boxManager: BoxManager, appId: string, appProxy: AppProxy, appOptions?: TAppOptions | (() => TAppOptions) | undefined);
+    getDisplayer: () => import("white-web-sdk").Displayer<import("white-web-sdk").DisplayerCallbacks>;
+    /** @deprecated Use context.storage.state instead. */
+    getAttributes: () => TAttributes | undefined;
+    getScenes: () => SceneDefinition[] | undefined;
+    getView: () => View | undefined;
+    getInitScenePath: () => string | undefined;
+    /** Get App writable status. */
+    getIsWritable: () => boolean;
+    /** Get the App Window UI box. */
+    getBox: () => ReadonlyTeleBox;
+    getRoom: () => Room | undefined;
+    /** @deprecated Use context.storage.setState instead. */
+    setAttributes: (attributes: TAttributes) => void;
+    /** @deprecated Use context.storage.setState instead. */
+    updateAttributes: (keys: string[], value: any) => void;
+    setScenePath: (scenePath: string) => Promise<void>;
+    mountView: (dom: HTMLDivElement) => 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/AppListener.d.ts

@@ -9,7 +9,7 @@ export declare class AppListeners {
     private mainMagixEventListener;
     private appMoveHandler;
     private appResizeHandler;
-    private switchViewsToFreedomHandler;
     private boxStateChangeHandler;
     private setMainViewScenePathHandler;
+    private moveCameraToContainHandler;
 }

package/dist/AppManager.d.ts

@@ -1,17 +1,15 @@
 import { AppStatus, Events } from "./constants";
 import { AppProxy } from "./AppProxy";
 import { WindowManager } from "./index";
-import { CameraStore } from "./Utils/CameraStore";
-import { MainViewProxy } from "./MainView";
-import { ReconnectRefresher } from "./ReconnectRefresher";
-import { ViewManager } from "./ViewManager";
+import { MainViewProxy } from "./View/MainView";
+import { ViewManager } from "./View/ViewManager";
+import type { ReconnectRefresher } from "./ReconnectRefresher";
 import type { BoxManager } from "./BoxManager";
 import type { Displayer, Room } from "white-web-sdk";
 import type { AddAppParams, TeleBoxRect } from "./index";
 export declare class AppManager {
     windowManger: WindowManager;
     displayer: Displayer;
-    cameraStore: CameraStore;
     viewManager: ViewManager;
     appProxies: Map<string, AppProxy>;
     appStatus: Map<string, AppStatus>;
@@ -21,6 +19,8 @@ export declare class AppManager {
     isReplay: boolean;
     private appListeners;
     boxManager?: BoxManager;
+    private _prevSceneIndex;
+    private _prevFocused;
     constructor(windowManger: WindowManager);
     private onCreated;
     /**
@@ -36,13 +36,14 @@ export declare class AppManager {
     resetMinimized(): void;
     private onAppDelete;
     bindMainView(divElement: HTMLDivElement, disableCameraTransform: boolean): void;
+    setMainViewFocusPath(): void;
     addApp(params: AddAppParams, isDynamicPPT: boolean): Promise<string | undefined>;
     private beforeAddApp;
     private afterAddApp;
     closeApp(appId: string): Promise<void>;
     private baseInsertApp;
     private displayerStateListener;
-    private displayerWritableListener;
+    displayerWritableListener: (isReadonly: boolean) => void;
     private get eventName();
     get attributes(): import("./index").WindowMangerAttributes;
     get canOperate(): boolean;
@@ -58,7 +59,7 @@ export declare class AppManager {
     safeDispatchMagixEvent(event: string, payload: any): void;
     private boxEventListener;
     focusByAttributes(apps: any): void;
-    notifyReconnected(): Promise<void>;
+    onReconnected(): Promise<void>;
     notifyContainerRectUpdate(rect: TeleBoxRect): void;
     dispatchInternalEvent(event: Events, payload: any): void;
     destroy(): void;

package/dist/AppProxy.d.ts

@@ -15,12 +15,11 @@ export declare class AppProxy extends Base {
     private boxManager;
     private appProxies;
     private viewManager;
-    private cameraStore;
     private kind;
     isAddApp: boolean;
     private status;
     private stateKey;
-    private setupResult?;
+    private appResult?;
     private appContext?;
     constructor(params: BaseInsertParams, manager: AppManager, appId: string, isAddApp: boolean);
     private initScenes;
@@ -29,8 +28,9 @@ export declare class AppProxy extends Base {
     get attributes(): any;
     get appAttributes(): import("./index").AppSyncAttributes;
     getFullScenePath(): string | undefined;
+    private getFullScenePathFromScenes;
     setFullPath(path: string): void;
-    baseInsertApp(skipUpdate?: boolean, focus?: boolean): Promise<{
+    baseInsertApp(skipUpdate?: boolean): Promise<{
         appId: string;
         app: NetlessApp;
     }>;
@@ -42,12 +42,12 @@ export declare class AppProxy extends Base {
     private afterSetupApp;
     onSeek(time: number): void;
     onReconnected(): Promise<void>;
-    switchToWritable(): void;
     getAppInitState: (id: string) => AppInitState | undefined;
     emitAppSceneStateChange(sceneState: SceneState): void;
     emitAppIsWritableChange(): void;
     private makeAppEventListener;
     private appAttributesUpdateListener;
+    private setFocusScenePathHandler;
     setScenePath(): void;
     setViewFocusScenePath(): void;
     private createView;

package/dist/Base/Context.d.ts

@@ -8,6 +8,5 @@ export declare class Context {
     findMemberByUid: (uid: string) => import("white-web-sdk").RoomMember | undefined;
     updateManagerRect(): void;
     blurFocusBox(): void;
-    switchAppToWriter(id: string): void;
 }
 export declare const createContext: (manager: AppManager) => Context;

package/dist/BoxManager.d.ts

@@ -56,6 +56,7 @@ export declare class BoxManager {
     private createTeleBoxManagerConfig?;
     teleBoxManager: TeleBoxManager;
     constructor(context: BoxManagerContext, createTeleBoxManagerConfig?: CreateTeleBoxManagerConfig | undefined);
+    private playgroundSizeChangeListener;
     private get mainView();
     private get canOperate();
     get boxState(): "normal" | "minimized" | "maximized";

package/dist/BuiltinApps.d.ts

@@ -0,0 +1,6 @@
+import "@netless/app-docs-viewer/dist/style.css";
+export declare const setupBuiltin: () => void;
+export declare const BuiltinApps: {
+    DocsViewer: string;
+    MediaPlayer: string;
+};

package/dist/ContainerResizeObserver.d.ts

@@ -0,0 +1,10 @@
+import type { EmitterType } from "./index";
+export declare class ContainerResizeObserver {
+    private emitter;
+    private containerResizeObserver?;
+    constructor(emitter: EmitterType);
+    static create(container: HTMLElement, sizer: HTMLElement, wrapper: HTMLDivElement, emitter: EmitterType): ContainerResizeObserver;
+    observePlaygroundSize(container: HTMLElement, sizer: HTMLElement, wrapper: HTMLDivElement): void;
+    private updateSizer;
+    disconnect(): void;
+}

package/dist/Cursor/Cursor.d.ts

@@ -13,11 +13,10 @@ export declare class Cursor extends Base {
     private cursorManager;
     private wrapper?;
     private member?;
-    private disposer;
     private timer?;
     private component?;
-    constructor(manager: AppManager, cursors: any, memberId: string, cursorManager: CursorManager, wrapper?: HTMLElement | undefined);
-    private startReaction;
+    constructor(manager: AppManager, addCursorChangeListener: (uid: string, callback: (position: Position, state: CursorState) => void) => void, cursors: any, memberId: string, cursorManager: CursorManager, wrapper?: HTMLElement | undefined);
+    private onCursorChange;
     private moveCursor;
     get memberApplianceName(): ApplianceNames | undefined;
     get memberColor(): string;

package/dist/Cursor/index.d.ts

@@ -1,6 +1,7 @@
-import { Base } from '../Base';
-import { Cursor } from './Cursor';
-import type { PositionType } from "../AttributesDelegate";
+import { Base } from "../Base";
+import { Cursor } from "./Cursor";
+import { CursorState } from "../constants";
+import type { PositionType, Position } from "../AttributesDelegate";
 import type { RoomMember, View } from "white-web-sdk";
 import type { AppManager } from "../AppManager";
 export declare type EventType = {
@@ -19,6 +20,7 @@ export declare class CursorManager extends Base {
     cursorInstances: Map<string, Cursor>;
     roomMembers?: readonly RoomMember[];
     private mainViewElement?;
+    private sideEffectManager;
     constructor(appManager: AppManager);
     setupWrapper(wrapper: HTMLElement): void;
     setMainViewDivElement(div: HTMLDivElement): void;
@@ -29,7 +31,6 @@ export declare class CursorManager extends Base {
     get boxState(): any;
     get focusView(): View | undefined;
     private mouseMoveListener;
-    private touchMoveListener;
     private updateCursor;
     private getPoint;
     /**
@@ -44,5 +45,7 @@ export declare class CursorManager extends Base {
     deleteCursor(uid: string): void;
     hideCursor(uid: string): void;
     cleanMemberAttributes(members: readonly RoomMember[]): void;
+    onReconnect(): void;
+    addCursorChangeListener: (uid: string, callback: (position: Position, state: CursorState) => void) => void;
     destroy(): void;
 }

package/dist/Helper.d.ts

@@ -0,0 +1,6 @@
+export declare const setupWrapper: (root: HTMLElement) => {
+    playground: HTMLDivElement;
+    wrapper: HTMLDivElement;
+    sizer: HTMLDivElement;
+    mainViewElement: HTMLDivElement;
+};

package/dist/ReconnectRefresher.d.ts

@@ -1,12 +1,17 @@
 import type { Room } from "white-web-sdk";
-import type { AppManager } from "./AppManager";
+import type { EmitterType } from "./index";
+export declare type ReconnectRefresherContext = {
+    emitter: EmitterType;
+};
 export declare class ReconnectRefresher {
-    private manager;
+    private ctx;
     private phase?;
     private room;
     private reactors;
     private disposers;
-    constructor(room: Room | undefined, manager: AppManager);
+    constructor(ctx: ReconnectRefresherContext);
+    setRoom(room: Room | undefined): void;
+    setContext(ctx: ReconnectRefresherContext): void;
     private onPhaseChanged;
     private onReconnected;
     private releaseDisposers;

package/dist/Utils/Common.d.ts

@@ -4,11 +4,13 @@ import type Emittery from "emittery";
 export declare const genAppId: (kind: string) => Promise<string>;
 export declare const setViewFocusScenePath: (view: View, focusScenePath: string) => void;
 export declare const setScenePath: (room: Room | undefined, scenePath: string) => void;
+export declare const getScenePath: (room: Room | undefined, dir: string | undefined, index: number) => string | undefined;
 export declare const setViewMode: (view: View, mode: ViewVisionMode) => void;
 export declare const emitError: (error: Error) => void;
 export declare const addEmitterOnceListener: (event: any, listener: any) => void;
 export declare const notifyMainViewModeChange: import("lodash").DebouncedFunc<(callbacks: Emittery<PublicEvent>, mode: ViewVisionMode) => void>;
-export declare const makeValidScenePath: (displayer: Displayer, scenePath: string) => string;
+export declare const makeValidScenePath: (displayer: Displayer, scenePath: string, index?: number) => string | undefined;
+export declare const entireScenes: (displayer: Displayer) => import("white-web-sdk").SceneMap;
 export declare const isValidScenePath: (scenePath: string) => boolean;
 export declare const ensureValidScenePath: (scenePath: string) => string;
 export declare const getVersionNumber: (version: string) => number;

package/dist/Utils/Reactive.d.ts

@@ -1,6 +1,6 @@
 import { UpdateEventKind } from "white-web-sdk";
 import type { AkkoObjectUpdatedListener } from "white-web-sdk";
 export declare const onObjectByEvent: (event: UpdateEventKind) => (object: any, func: () => void) => (() => void) | undefined;
-export declare const safeListenPropsUpdated: <T>(getProps: () => T, callback: AkkoObjectUpdatedListener<T>) => () => void;
+export declare const safeListenPropsUpdated: <T>(getProps: () => T, callback: AkkoObjectUpdatedListener<T>, onDestroyed?: ((props: unknown) => void) | undefined) => () => void;
 export declare const onObjectRemoved: (object: any, func: () => void) => (() => void) | undefined;
 export declare const onObjectInserted: (object: any, func: () => void) => (() => void) | undefined;

package/dist/{MainView.d.ts → View/MainView.d.ts}

@@ -1,13 +1,13 @@
-import { Base } from "./Base";
+import { Base } from "../Base";
 import type { Camera, Size, View } from "white-web-sdk";
-import type { AppManager } from "./AppManager";
+import type { AppManager } from "../AppManager";
 export declare class MainViewProxy extends Base {
     private scale?;
-    private cameraStore;
     private started;
     private mainViewIsAddListener;
     private mainView;
     private viewId;
+    private sideEffectManager;
     constructor(manager: AppManager);
     private get mainViewCamera();
     private get mainViewSize();
@@ -34,7 +34,6 @@ export declare class MainViewProxy extends Base {
     private addCameraListener;
     private removeCameraListener;
     private onCameraOrSizeUpdated;
-    switchViewModeToWriter(): void;
     moveCameraToContian(size: Size): void;
     moveCamera(camera: Camera): void;
     stop(): void;

package/dist/View/ViewManager.d.ts

@@ -0,0 +1,13 @@
+import type { View, Displayer } from "white-web-sdk";
+export declare class ViewManager {
+    private displayer;
+    views: Map<string, View>;
+    constructor(displayer: Displayer);
+    createView(id: string): View;
+    getView(id: string): View | undefined;
+    destroyView(id: string): void;
+    setViewScenePath(id: string, scenePath: string): void;
+    destroy(): void;
+}
+export declare const createView: (displayer: Displayer) => View;
+export declare const setDefaultCameraBound: (view: View) => void;

package/dist/constants.d.ts

@@ -9,7 +9,8 @@ export declare enum Events {
     WindowCreated = "WindowCreated",
     SetMainViewScenePath = "SetMainViewScenePath",
     SetMainViewSceneIndex = "SetMainViewSceneIndex",
-    SwitchViewsToFreedom = "SwitchViewsToFreedom"
+    SwitchViewsToFreedom = "SwitchViewsToFreedom",
+    MoveCameraToContain = "MoveCameraToContain"
 }
 export declare const MagixEventName = "__WindowManger";
 export declare enum AppAttributes {
@@ -30,13 +31,8 @@ export declare enum CursorState {
     Leave = "leave",
     Normal = "normal"
 }
-export declare const REQUIRE_VERSION = "2.13.16";
+export declare const REQUIRE_VERSION = "2.16.0";
 export declare const MIN_WIDTH: number;
 export declare const MIN_HEIGHT: number;
 export declare const SET_SCENEPATH_DELAY = 100;
-export declare const DEFAULT_COLLECTOR_STYLE: {
-    right: string;
-    bottom: string;
-    position: string;
-};
 export declare const DEFAULT_CONTAINER_RATIO: number;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import Emittery from "emittery";
 import { AppManager } from "./AppManager";
 import { CursorManager } from "./Cursor";
+import { ReconnectRefresher } from "./ReconnectRefresher";
 import "./style.css";
 import "@netless/telebox-insider/dist/style.css";
 import type { TELE_BOX_STATE } from "./BoxManager";
@@ -29,11 +30,11 @@ export declare type AddAppOptions = {
 export declare type setAppOptions = AddAppOptions & {
     appOptions?: any;
 };
-export declare type AddAppParams = {
+export declare type AddAppParams<TAttributes = any> = {
     kind: string;
     src?: string;
     options?: AddAppOptions;
-    attributes?: any;
+    attributes?: TAttributes;
 };
 export declare type BaseInsertParams = {
     kind: string;
@@ -91,6 +92,7 @@ export declare type EmitterEvent = {
     observerIdChange: number;
     boxStateChange: string;
     playgroundSizeChange: DOMRect;
+    onReconnected: void;
 };
 export declare type EmitterType = Emittery<EmitterEvent>;
 export declare const emitter: EmitterType;
@@ -100,6 +102,9 @@ export declare type PublicEvent = {
     darkModeChange: boolean;
     prefersColorSchemeChange: TeleBoxColorScheme;
     cameraStateChange: CameraState;
+    mainViewScenePathChange: string;
+    mainViewSceneIndexChange: number;
+    focusedChange: string | undefined;
 };
 export declare type MountParams = {
     room: Room;
@@ -118,6 +123,7 @@ export declare type MountParams = {
 };
 export declare type CallbacksType = Emittery<PublicEvent>;
 export declare const callbacks: CallbacksType;
+export declare const reconnectRefresher: ReconnectRefresher;
 export declare class WindowManager extends InvisiblePlugin<WindowMangerAttributes> {
     static kind: string;
     static displayer: Displayer;
@@ -137,21 +143,21 @@ export declare class WindowManager extends InvisiblePlugin<WindowMangerAttribute
     isReplay: boolean;
     private boxManager?;
     private static params?;
+    private containerResizeObserver?;
     constructor(context: InvisiblePluginContext);
     static mount(params: MountParams): Promise<WindowManager>;
     private static initManager;
     private static initContainer;
-    bindContainer(container: HTMLElement, collectorContainer?: HTMLElement): void;
+    bindContainer(container: HTMLElement): void;
+    bindCollectorContainer(container: HTMLElement): void;
     /**
      * 注册插件
      */
     static register<AppOptions = any, SetupResult = any, Attributes = any>(params: RegisterParams<AppOptions, SetupResult, Attributes>): Promise<void>;
-    static setContainer(container: HTMLElement): void;
-    static setCollectorContainer(container: HTMLElement): void;
     /**
      * 创建一个 app 至白板
      */
-    addApp(params: AddAppParams): Promise<string | undefined>;
+    addApp<T = any>(params: AddAppParams<T>): Promise<string | undefined>;
     private setupScenePath;
     /**
      * 设置 mainView 的 ScenePath, 并且切换白板为可写状态
@@ -192,6 +198,7 @@ export declare class WindowManager extends InvisiblePlugin<WindowMangerAttribute
     get boxState(): TeleBoxState | undefined;
     get darkMode(): boolean;
     get prefersColorScheme(): TeleBoxColorScheme | undefined;
+    get focused(): string | undefined;
     /**
      * 查询所有的 App
      */
@@ -224,13 +231,6 @@ export declare class WindowManager extends InvisiblePlugin<WindowMangerAttribute
     private isDynamicPPT;
     private static checkVersion;
     private ensureAttributes;
-    private containerResizeObserver?;
-    private observePlaygroundSize;
-    private updateSizer;
 }
-export declare const BuiltinApps: {
-    DocsViewer: string;
-    MediaPlayer: string;
-};
 export * from "./typings";
-export { WhiteWindowSDK } from "./sdk";
+export { BuiltinApps } from "./BuiltinApps";