@netless/window-manager 0.4.30 → 1.0.0-canary.0

package/src/InternalEmitter.ts

@@ -1,31 +1,29 @@
 import Emittery from "emittery";
+import type { TeleBoxRect } from "@netless/telebox-insider";
 import type { AppInitState, CursorMovePayload } from "./index";
 
 export type RemoveSceneParams = {
-    scenePath: string, index?: number
-}
+    scenePath: string;
+    index?: number;
+};
 
 export type EmitterEvent = {
     onCreated: undefined;
     InitReplay: AppInitState;
-    move: { appId: string; x: number; y: number };
-    focus: { appId: string };
-    close: { appId: string };
-    resize: { appId: string; width: number; height: number; x?: number; y?: number };
     error: Error;
     seekStart: undefined;
     seek: number;
     mainViewMounted: undefined;
     observerIdChange: number;
     boxStateChange: string;
-    playgroundSizeChange: DOMRect;
+    playgroundSizeChange: TeleBoxRect;
     startReconnect: undefined;
     onReconnected: undefined;
     removeScenes: RemoveSceneParams;
     cursorMove: CursorMovePayload;
     updateManagerRect: undefined;
     focusedChange: { focused: string | undefined; prev: string | undefined };
-    rootDirRemoved: undefined;  // 根目录整个被删除
+    rootDirRemoved: undefined; // 根目录整个被删除
     rootDirSceneRemoved: string; // 根目录下的场景被删除
     setReadonly: boolean;
     changePageState: undefined;

package/src/Utils/AppCreateQueue.ts

@@ -1,8 +1,7 @@
 import { callbacks } from "../callback";
 import { SETUP_APP_DELAY } from "../constants";
-import type { AppProxy } from "../App";
 
-export type Invoker = () => Promise<AppProxy | undefined>;
+export type Invoker<T = any> = () => Promise<T | undefined>;
 
 export class AppCreateQueue {
     private list: Invoker[] = [];
@@ -16,7 +15,7 @@ export class AppCreateQueue {
         }, 50);
     }
 
-    public push(item: Invoker) {
+    public push<T>(item: Invoker<T>) {
         this.list.push(item);
         this.invoke();
         if (this.timer === undefined && this.list.length > 0) {

package/src/View/CameraSynchronizer.ts

@@ -0,0 +1,67 @@
+import { AnimationMode } from "white-web-sdk";
+import { delay, throttle } from "lodash";
+import type { TeleBoxRect } from "@netless/telebox-insider";
+import type { Camera, View, Size } from "white-web-sdk";
+import type { MainViewSize } from "../AttributesDelegate";
+
+export type SaveCamera = (camera: Camera) => void;
+
+export class CameraSynchronizer {
+    protected remoteCamera?: Camera;
+    protected remoteSize?: MainViewSize;
+    protected rect?: TeleBoxRect;
+    protected view?: View;
+
+    constructor(protected saveCamera: SaveCamera) {}
+
+    public setRect(rect: TeleBoxRect) {
+        this.rect = rect;
+        if (this.remoteCamera && this.remoteSize) {
+            this.onRemoteUpdate(this.remoteCamera, this.remoteSize);
+        }
+    }
+
+    public setView(view: View) {
+        this.view = view;
+    }
+
+    // 远端 Camera 或者 size 更新
+    public onRemoteUpdate = throttle((camera: Camera, size: MainViewSize) => {
+        this.remoteCamera = camera;
+        this.remoteSize = size;
+        if (this.remoteSize && this.rect) {
+            let scale: number;
+            if (size.width < size.height) {
+                scale = this.rect.width / size.width;
+            } else {
+                scale = this.rect.height / size.height;
+            }
+            const nextScale = camera.scale * scale;
+            const moveCamera = () =>  this.view?.moveCamera({
+                centerX: camera.centerX,
+                centerY: camera.centerY,
+                scale: nextScale,
+                animationMode: AnimationMode.Immediately,
+            });
+            // TODO 直接调用 moveCamera 依然会出现 camera 错误的情况,这里暂时加一个 delay 保证 camera 是对的, 后续需要 SDK 进行修改
+            delay(moveCamera, 10);
+        }
+    }, 50);
+
+
+    public onLocalCameraUpdate(camera: Camera) {
+        this.saveCamera(camera);
+    }
+
+    // 本地 Size 更新, 先匹配 camera 到新的 size 然后再发送 camera 数据到远端
+    public onLocalSizeUpdate(size: Size) {
+        if (this.rect && this.view) {
+            const scale = this.rect.width / size.width;
+            const nextScale = this.view.camera.scale * scale;
+            this.view.moveCamera({
+                scale: nextScale,
+                animationMode: AnimationMode.Immediately
+            });
+        }
+    }
+}

package/src/View/MainView.ts

@@ -1,25 +1,29 @@
-import { AnimationMode, reaction } from "white-web-sdk";
+import { reaction } from "white-web-sdk";
 import { callbacks } from "../callback";
 import { createView } from "./ViewManager";
-import { debounce, get, isEmpty, isEqual } from "lodash";
+import { debounce, get, isEqual } from "lodash";
 import { emitter } from "../InternalEmitter";
+import { Events } from "../constants";
 import { Fields } from "../AttributesDelegate";
 import { setViewFocusScenePath } from "../Utils/Common";
 import { SideEffectManager } from "side-effect-manager";
 import type { Camera, Size, View } from "white-web-sdk";
 import type { AppManager } from "../AppManager";
-import { Events } from "../constants";
+import { CameraSynchronizer } from "./CameraSynchronizer";
 
 export class MainViewProxy {
-    private scale?: number;
     private started = false;
     private mainViewIsAddListener = false;
     private mainView: View;
     private store = this.manager.store;
+    private synchronizer: CameraSynchronizer;
 
     private sideEffectManager = new SideEffectManager();
 
     constructor(private manager: AppManager) {
+        this.synchronizer = new CameraSynchronizer(
+            camera => this.store.setMainViewCamera({ ...camera, id: this.manager.uid })
+        );
         this.mainView = this.createMainView();
         this.moveCameraSizeByAttributes();
         emitter.once("mainViewMounted").then(() => {
@@ -28,18 +32,24 @@ export class MainViewProxy {
             this.ensureCameraAndSize();
             this.startListenWritableChange();
         });
-        const playgroundSizeChangeListener = () => {
-            this.sizeChangeHandler(this.mainViewSize);
-        };
-        this.sideEffectManager.add(() => {
-            return emitter.on("playgroundSizeChange", playgroundSizeChangeListener);
-        });
         this.sideEffectManager.add(() => {
             return emitter.on("containerSizeRatioUpdate", this.onUpdateContainerSizeRatio);
         });
         this.sideEffectManager.add(() => {
             return emitter.on("startReconnect", () => {
-                this.mainView.release();
+                if (!(this.mainView as any).didRelease) {
+                    this.mainView.release();
+                }
+            });
+        });
+        const rect = this.manager.boxManager?.teleBoxManager.stageRect;
+        if (rect) {
+            this.synchronizer.setRect(rect);
+        }
+        this.sideEffectManager.add(() => {
+            return emitter.on("playgroundSizeChange", rect => {
+                this.synchronizer.setRect(rect);
+                this.synchronizer.onLocalSizeUpdate(rect);
             });
         });
     }
@@ -52,7 +62,7 @@ export class MainViewProxy {
                 }
             });
         });
-    }
+    };
 
     public ensureCameraAndSize() {
         if (!this.mainViewCamera || !this.mainViewSize) {
@@ -74,8 +84,7 @@ export class MainViewProxy {
     }
 
     private moveCameraSizeByAttributes() {
-        this.moveCameraToContian(this.mainViewSize);
-        this.moveCamera(this.mainViewCamera);
+        this.synchronizer.onRemoteUpdate(this.mainViewCamera, this.mainViewSize);
     }
 
     public start() {
@@ -91,9 +100,12 @@ export class MainViewProxy {
     };
 
     public setCameraAndSize(): void {
-        const camera = { ...this.mainView.camera, id: this.manager.uid };
-        const size = { ...this.mainView.size, id: this.manager.uid };
-        this.store.setMainViewCameraAndSize(camera, size);
+        const stageSize = this.getStageSize();
+        if (stageSize) {
+            const camera = { ...this.mainView.camera, id: this.manager.uid };
+            const size = { ...stageSize, id: this.manager.uid };
+            this.store.setMainViewCameraAndSize(camera, size);
+        }
     }
 
     private cameraReaction = () => {
@@ -101,8 +113,7 @@ export class MainViewProxy {
             () => this.mainViewCamera,
             camera => {
                 if (camera && camera.id !== this.manager.uid) {
-                    this.moveCameraToContian(this.mainViewSize);
-                    this.moveCamera(camera);
+                    this.synchronizer.onRemoteUpdate(camera, this.mainViewSize);
                 }
             },
             { fireImmediately: true }
@@ -111,8 +122,7 @@ export class MainViewProxy {
 
     public sizeChangeHandler = debounce((size: Size) => {
         if (size) {
-            this.moveCameraToContian(size);
-            this.moveCamera(this.mainViewCamera);
+            this.synchronizer.onLocalSizeUpdate(size);
         }
     }, 30);
 
@@ -122,7 +132,7 @@ export class MainViewProxy {
         if (size.id === this.manager.uid) {
             this.setCameraAndSize();
         }
-    }
+    };
 
     public get view(): View {
         return this.mainView;
@@ -138,6 +148,7 @@ export class MainViewProxy {
         if (mainViewScenePath) {
             setViewFocusScenePath(mainView, mainViewScenePath);
         }
+        this.synchronizer.setView(mainView);
         return mainView;
     }
 
@@ -172,12 +183,20 @@ export class MainViewProxy {
     }
 
     private onCameraUpdatedByDevice = (camera: Camera) => {
-        this.store.setMainViewCamera({ ...camera, id: this.manager.uid });
-        if (!isEqual(this.mainViewSize, { ...this.mainView.size, id: this.manager.uid })) {
-            this.setMainViewSize(this.view.size);
+        this.synchronizer.onLocalCameraUpdate(camera);
+        const size = this.getStageSize();
+        if (size && !isEqual(size, this.mainViewSize)) {
+            this.setMainViewSize(size);
         }
     };
 
+    private getStageSize(): Size | undefined {
+        const stage = this.manager.boxManager?.teleBoxManager.stageRect;
+        if (stage) {
+            return { width: stage.width, height: stage.height };
+        }
+    }
+
     public addMainViewListener(): void {
         if (this.mainViewIsAddListener) return;
         if (this.view.divElement) {
@@ -205,7 +224,7 @@ export class MainViewProxy {
         this.manager.boxManager?.blurAllBox();
     }
 
-    public setMainViewSize = debounce(size => {
+    public setMainViewSize = debounce((size: Size) => {
         this.store.setMainViewSize({ ...size, id: this.manager.uid });
     }, 50);
 
@@ -225,33 +244,6 @@ export class MainViewProxy {
         callbacks.emit("cameraStateChange", this.cameraState);
     };
 
-    public moveCameraToContian(size: Size): void {
-        if (!isEmpty(size)) {
-            this.view.moveCameraToContain({
-                width: size.width,
-                height: size.height,
-                originX: -size.width / 2,
-                originY: -size.height / 2,
-                animationMode: AnimationMode.Immediately,
-            });
-            this.scale = this.view.camera.scale;
-        }
-    }
-
-    public moveCamera(camera: Camera): void {
-        if (!isEmpty(camera)) {
-            if (isEqual(camera, this.view.camera)) return;
-            const { centerX, centerY, scale } = camera;
-            const needScale = scale * (this.scale || 1);
-            this.view.moveCamera({
-                centerX: centerX,
-                centerY: centerY,
-                scale: needScale,
-                animationMode: AnimationMode.Immediately,
-            });
-        }
-    }
-
     public stop() {
         this.removeCameraListener();
         this.manager.refresher?.remove(Fields.MainViewCamera);

package/src/index.ts

@@ -3,7 +3,6 @@ import { AppManager } from "./AppManager";
 import { appRegister } from "./Register";
 import { callbacks } from "./callback";
 import { checkVersion, setupWrapper } from "./Helper";
-import { ContainerResizeObserver } from "./ContainerResizeObserver";
 import { createBoxManager } from "./BoxManager";
 import { CursorManager } from "./Cursor";
 import { DEFAULT_CONTAINER_RATIO, Events, INIT_DIR, ROOT_DIR } from "./constants";
@@ -29,13 +28,7 @@ import {
     wait,
 } from "./Utils/Common";
 import type { TELE_BOX_STATE, BoxManager } from "./BoxManager";
-import {
-    AppCreateError,
-    AppManagerNotInitError,
-    BindContainerRoomPhaseInvalidError,
-    InvalidScenePath,
-    ParamsInvalidError,
-} from "./Utils/error";
+import * as Errors from "./Utils/error";
 import type { Apps, Position } from "./AttributesDelegate";
 import type {
     Displayer,
@@ -54,12 +47,13 @@ import type {
     SceneState,
 } from "white-web-sdk";
 import type { AppListeners } from "./AppListener";
-import type { NetlessApp, RegisterParams } from "./typings";
+import type { ApplianceIcons, NetlessApp, RegisterParams } from "./typings";
 import type { TeleBoxColorScheme, TeleBoxState } from "@netless/telebox-insider";
 import type { AppProxy } from "./App";
 import type { PublicEvent } from "./callback";
 import type Emittery from "emittery";
 import type { PageController, AddPageParams, PageState } from "./Page";
+import { boxEmitter } from "./BoxEmitter";
 
 export type WindowMangerAttributes = {
     modelValue?: string;
@@ -142,6 +136,7 @@ export type MountParams = {
     debug?: boolean;
     disableCameraTransform?: boolean;
     prefersColorScheme?: TeleBoxColorScheme;
+    applianceIcons?: ApplianceIcons;
 };
 
 export const reconnectRefresher = new ReconnectRefresher({ emitter });
@@ -149,7 +144,6 @@ export const reconnectRefresher = new ReconnectRefresher({ emitter });
 export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> implements PageController {
     public static kind = "WindowManager";
     public static displayer: Displayer;
-    public static wrapper?: HTMLElement;
     public static playground?: HTMLElement;
     public static container?: HTMLElement;
     public static debug = false;
@@ -172,7 +166,6 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     private boxManager?: BoxManager;
     private static params?: MountParams;
 
-    private containerResizeObserver?: ContainerResizeObserver;
     public containerSizeRatio = WindowManager.containerSizeRatio;
 
     constructor(context: InvisiblePluginContext) {
@@ -237,11 +230,17 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
 
         manager.appManager = new AppManager(manager);
         manager._pageState = new PageStateImpl(manager.appManager);
-        manager.cursorManager = new CursorManager(manager.appManager, Boolean(cursor));
+        manager.cursorManager = new CursorManager(manager.appManager, Boolean(cursor), params.applianceIcons);
         if (containerSizeRatio) {
             manager.containerSizeRatio = containerSizeRatio;
         }
-
+        manager.boxManager = createBoxManager(manager, callbacks, emitter, boxEmitter, {
+            collectorContainer: params.collectorContainer,
+            collectorStyles: params.collectorStyles,
+            prefersColorScheme: params.prefersColorScheme,
+            stageRatio: params.containerSizeRatio,
+        });
+        manager.appManager?.setBoxManager(manager.boxManager);
         if (params.container) {
             manager.bindContainer(params.container);
         }
@@ -287,31 +286,19 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     }
 
     private static initContainer(
-        manager: WindowManager,
         container: HTMLElement,
-        chessboard: boolean | undefined,
         overwriteStyles: string | undefined
     ) {
         if (!WindowManager.container) {
             WindowManager.container = container;
         }
-        const { playground, wrapper, sizer, mainViewElement } = setupWrapper(container);
+        const { playground, mainViewElement } = setupWrapper(container);
         WindowManager.playground = playground;
-        if (chessboard) {
-            sizer.classList.add("netless-window-manager-chess-sizer");
-        }
         if (overwriteStyles) {
             const style = document.createElement("style");
             style.textContent = overwriteStyles;
             playground.appendChild(style);
         }
-        manager.containerResizeObserver = ContainerResizeObserver.create(
-            playground,
-            sizer,
-            wrapper,
-            emitter
-        );
-        WindowManager.wrapper = wrapper;
         return mainViewElement;
     }
 
@@ -320,8 +307,8 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     }
 
     public bindContainer(container: HTMLElement) {
-        if (this.room.phase !== RoomPhase.Connected) {
-            throw new BindContainerRoomPhaseInvalidError();
+        if (isRoom(this.displayer) && this.room.phase !== RoomPhase.Connected) {
+            throw new Errors.BindContainerRoomPhaseInvalidError();
         }
         if (WindowManager.isCreated && WindowManager.container) {
             if (WindowManager.container.firstChild) {
@@ -331,24 +318,15 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
             if (WindowManager.params) {
                 const params = WindowManager.params;
                 const mainViewElement = WindowManager.initContainer(
-                    this,
                     container,
-                    params.chessboard,
                     params.overwriteStyles
                 );
-                if (this.boxManager) {
-                    this.boxManager.destroy();
+                if (this.boxManager && WindowManager.playground) {
+                    this.boxManager.setRoot(WindowManager.playground);
                 }
-                const boxManager = createBoxManager(this, callbacks, emitter, {
-                    collectorContainer: params.collectorContainer,
-                    collectorStyles: params.collectorStyles,
-                    prefersColorScheme: params.prefersColorScheme,
-                });
-                this.boxManager = boxManager;
-                this.appManager?.setBoxManager(boxManager);
                 this.bindMainView(mainViewElement, params.disableCameraTransform);
-                if (WindowManager.wrapper) {
-                    this.cursorManager?.setupWrapper(WindowManager.wrapper);
+                if (WindowManager.playground) {
+                    this.cursorManager?.setupWrapper(WindowManager.playground);
                 }
             }
         }
@@ -362,7 +340,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
 
     public bindCollectorContainer(container: HTMLElement) {
         if (WindowManager.isCreated && this.boxManager) {
-            this.boxManager.setCollectorContainer(container);
+            this.boxManager.teleBoxManager.collector.set$collector(container)
         } else {
             if (WindowManager.params) {
                 WindowManager.params.collectorContainer = container;
@@ -407,19 +385,19 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
                 return this._addApp(params);
             }
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
     private async _addApp<T = any>(params: AddAppParams<T>): Promise<string | undefined> {
         if (this.appManager) {
             if (!params.kind || typeof params.kind !== "string") {
-                throw new ParamsInvalidError();
+                throw new Errors.ParamsInvalidError();
             }
             const appImpl = await appRegister.appClasses.get(params.kind)?.();
             if (appImpl && appImpl.config?.singleton) {
                 if (this.appManager.appProxies.has(params.kind)) {
-                    throw new AppCreateError();
+                    throw new Errors.AppCreateError();
                 }
             }
             const isDynamicPPT = this.setupScenePath(params, this.appManager);
@@ -432,7 +410,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
             const appId = await this.appManager.addApp(params, Boolean(isDynamicPPT));
             return appId;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -442,7 +420,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
             const { scenePath, scenes } = params.options;
             if (scenePath) {
                 if (!isValidScenePath(scenePath)) {
-                    throw new InvalidScenePath();
+                    throw new Errors.InvalidScenePath();
                 }
                 const apps = Object.keys(this.apps || {});
                 for (const appId of apps) {
@@ -645,7 +623,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this.appManager) {
             return this.appManager.mainViewProxy.view;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -653,7 +631,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this.appManager) {
             return this.appManager.mainViewProxy.view.camera;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -661,7 +639,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this.appManager) {
             return this.appManager.mainViewProxy.cameraState;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -673,7 +651,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this.appManager) {
             return this.appManager.boxManager?.boxState;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -685,7 +663,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this.appManager) {
             return this.appManager.boxManager?.prefersColorScheme;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -705,7 +683,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this.appManager) {
             return this.appManager?.getMainViewSceneDir();
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -730,7 +708,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             return this.appManager.sceneState!;
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -738,7 +716,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (this._pageState) {
             return this._pageState.toObject();
         } else {
-            throw new AppManagerNotInitError();
+            throw new Errors.AppManagerNotInitError();
         }
     }
 
@@ -806,11 +784,9 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     }
 
     private _destroy() {
-        this.containerResizeObserver?.disconnect();
         this.appManager?.destroy();
         this.cursorManager?.destroy();
         WindowManager.container = undefined;
-        WindowManager.wrapper = undefined;
         WindowManager.isCreated = false;
         if (WindowManager.playground) {
             WindowManager.playground.parentNode?.removeChild(WindowManager.playground);

package/src/typings.ts

@@ -1,6 +1,7 @@
 import type Emittery from "emittery";
 import type {
     AnimationMode,
+    ApplianceNames,
     Displayer,
     DisplayerState,
     Player,
@@ -75,6 +76,8 @@ export type RegisterParams<AppOptions = any, SetupResult = any, Attributes = any
 
 export type AppListenerKeys = keyof AppEmitterEvent;
 
+export type ApplianceIcons = Partial<Record<ApplianceNames, string>>;
+
 export type { AppContext } from "./App/AppContext";
 export type { ReadonlyTeleBox, TeleBoxRect };
 export type { SceneState, SceneDefinition, View, AnimationMode, Displayer, Room, Player };

package/vite.config.js

@@ -39,7 +39,6 @@ export default defineConfig(({ mode }) => {
                 fileName: "index"
             },
             outDir: "dist",
-            sourcemap: true,
             rollupOptions: {
                 external: Object.keys({
                     ...omit(dependencies, ["@netless/telebox-insider"]),

package/dist/ContainerResizeObserver.d.ts

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

package/dist/ScenePath/index.d.ts

@@ -1,12 +0,0 @@
-import type { ScenesCallbacks, ScenesCallbacksNode } from "white-web-sdk";
-import type { AppManager } from "../AppManager";
-export declare class ScenesCallbackManager {
-    private manager;
-    private nodes;
-    constructor(manager: AppManager);
-    createNode(path: string, callbacks?: Partial<ScenesCallbacks>): ScenesCallbacksNode | null;
-    getScenes(path: string): readonly string[] | undefined;
-    getScenesOnce(path: string): readonly string[] | undefined;
-    removeNode(path: string): void;
-    destroy(): void;
-}