@netless/window-manager 1.0.0-canary.5 → 1.0.0-canary.50

package/src/index.ts

@@ -2,21 +2,20 @@ import pRetry from "p-retry";
 import { AppManager } from "./AppManager";
 import { appRegister } from "./Register";
 import { callbacks } from "./callback";
-import { checkVersion, setupWrapper } from "./Helper";
+import { checkVersion, createInvisiblePlugin, setupWrapper } from "./Helper";
 import { createBoxManager } from "./BoxManager";
 import { CursorManager } from "./Cursor";
 import { DEFAULT_CONTAINER_RATIO, Events, INIT_DIR, ROOT_DIR } from "./constants";
 import { emitter } from "./InternalEmitter";
 import { Fields } from "./AttributesDelegate";
 import { initDb } from "./Register/storage";
-import { InvisiblePlugin, isPlayer, isRoom, RoomPhase, ViewMode } from "white-web-sdk";
-import { isEqual, isNull, isObject, omit, isNumber } from "lodash";
+import { AnimationMode, InvisiblePlugin, isPlayer, isRoom, RoomPhase, ViewMode } from "white-web-sdk";
+import { isEqual, isNull, isObject, isNumber } from "lodash";
 import { log } from "./Utils/log";
 import { PageStateImpl } from "./PageState";
 import { ReconnectRefresher } from "./ReconnectRefresher";
 import { replaceRoomFunction } from "./Utils/RoomHacker";
 import { setupBuiltin } from "./BuiltinApps";
-import "video.js/dist/video-js.css";
 import "./style.css";
 import "@netless/telebox-insider/dist/style.css";
 import {
@@ -27,6 +26,8 @@ import {
     putScenes,
     wait,
 } from "./Utils/Common";
+import { boxEmitter } from "./BoxEmitter";
+import { Val } from "value-enhancer";
 import type { TELE_BOX_STATE, BoxManager } from "./BoxManager";
 import * as Errors from "./Utils/error";
 import type { Apps, Position , ICamera, ISize } from "./AttributesDelegate";
@@ -37,23 +38,22 @@ import type {
     Room,
     InvisiblePluginContext,
     Camera,
-    AnimationMode,
     CameraBound,
     Point,
-    Rectangle,
     CameraState,
     Player,
     ImageInformation,
     SceneState,
+    Size
 } from "white-web-sdk";
 import type { AppListeners } from "./AppListener";
 import type { ApplianceIcons, NetlessApp, RegisterParams } from "./typings";
-import type { TeleBoxColorScheme, TeleBoxState } from "@netless/telebox-insider";
+import type { TeleBoxColorScheme, TeleBoxFullscreen, TeleBoxManager, TeleBoxManagerThemeConfig, 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";
+import { computedMinScale } from "./View/CameraSynchronizer";
 
 export type WindowMangerAttributes = {
     modelValue?: string;
@@ -106,6 +106,7 @@ export type AppSyncAttributes = {
     createdAt?: number;
     camera?: ICamera;
     size?: ISize;
+    setup: boolean;
 };
 
 export type AppInitState = {
@@ -120,6 +121,11 @@ export type AppInitState = {
     sceneIndex?: number;
     boxState?: TeleBoxState; // 兼容旧版 telebox
     zIndex?: number;
+    visible?: boolean;
+    stageRatio?: number;
+    resizable?: boolean;
+    draggable?: boolean;
+    ratio?: number;
 };
 
 export type CursorMovePayload = { uid: string; state?: "leave"; position: Position };
@@ -129,8 +135,6 @@ export type MountParams = {
     container?: HTMLElement;
     /** 白板高宽比例, 默认为 9 / 16 */
     containerSizeRatio?: number;
-    /** 显示 PS 透明背景，默认 true */
-    chessboard?: boolean;
     collectorContainer?: HTMLElement;
     collectorStyles?: Partial<CSSStyleDeclaration>;
     overwriteStyles?: string;
@@ -138,7 +142,18 @@ export type MountParams = {
     debug?: boolean;
     disableCameraTransform?: boolean;
     prefersColorScheme?: TeleBoxColorScheme;
+    /** @deprecated */
+    chessboard?: boolean;
     applianceIcons?: ApplianceIcons;
+    containerStyle?: string;
+    stageStyle?: string;
+    fullscreen?: TeleBoxFullscreen;
+    /** Custom `style` attribute value for content area of all boxes. Can be overwritten by box. */
+    defaultBoxBodyStyle?: string | null;
+    /** Custom `style` attribute value for stage area of all boxes. Can be overwritten by box. */
+    defaultBoxStageStyle?: string | null;
+    /** Theme variable */
+    theme?: TeleBoxManagerThemeConfig;
 };
 
 export const reconnectRefresher = new ReconnectRefresher({ emitter });
@@ -151,6 +166,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     public static debug = false;
     public static containerSizeRatio = DEFAULT_CONTAINER_RATIO;
     private static isCreated = false;
+    public static registry = appRegister;
 
     public version = __APP_VERSION__;
     public dependencies = __APP_DEPENDENCIES__;
@@ -162,12 +178,16 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     public appManager?: AppManager;
     public cursorManager?: CursorManager;
     public viewMode = ViewMode.Broadcaster;
+    public viewMode$ = new Val<ViewMode>(ViewMode.Broadcaster);
     public isReplay = isPlayer(this.displayer);
     private _pageState?: PageStateImpl;
 
     private boxManager?: BoxManager;
     private static params?: MountParams;
 
+    private cameraUpdating = 0;
+    private nextCamera: Camera | null = null;
+
     public containerSizeRatio = WindowManager.containerSizeRatio;
 
     constructor(context: InvisiblePluginContext) {
@@ -179,14 +199,13 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
     public static async mount(params: MountParams): Promise<WindowManager> {
         const room = params.room;
         WindowManager.container = params.container;
-        const containerSizeRatio = params.containerSizeRatio;
         const debug = params.debug;
-
         const cursor = params.cursor;
         WindowManager.params = params;
         WindowManager.displayer = params.room;
-        checkVersion();
         let manager: WindowManager | undefined = undefined;
+
+        checkVersion();
         if (isRoom(room)) {
             if (room.phase !== RoomPhase.Connected) {
                 throw new Error("[WindowManager]: Room only Connected can be mount");
@@ -225,22 +244,25 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
             throw new Error("[WindowManager]: create manager failed");
         }
 
-        if (containerSizeRatio) {
-            WindowManager.containerSizeRatio = containerSizeRatio;
+        if (params.containerSizeRatio) {
+            WindowManager.containerSizeRatio = params.containerSizeRatio;
         }
+        manager.containerSizeRatio = WindowManager.containerSizeRatio;
         await manager.ensureAttributes();
 
         manager.appManager = new AppManager(manager);
         manager._pageState = new PageStateImpl(manager.appManager);
         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,
+            stageRatio: WindowManager.containerSizeRatio,
+            containerStyle: params.containerStyle,
+            stageStyle: params.stageStyle,
+            fullscreen: params.fullscreen,
+            theme: params.theme,
         });
         manager.appManager?.setBoxManager(manager.boxManager);
         if (params.container) {
@@ -251,7 +273,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         emitter.emit("onCreated");
         WindowManager.isCreated = true;
         try {
-            await initDb();
+            await initDb(appRegister);
         } catch (error) {
             console.warn("[WindowManager]: indexedDB open failed");
             console.log(error);
@@ -259,8 +281,8 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         return manager;
     }
 
-    private static async initManager(room: Room): Promise<WindowManager> {
-        let manager = room.getInvisiblePlugin(WindowManager.kind) as WindowManager;
+    private static async initManager(room: Room): Promise<WindowManager | undefined> {
+        let manager = room.getInvisiblePlugin(WindowManager.kind) as WindowManager | undefined;
         if (!manager) {
             if (isRoom(room)) {
                 if (room.isWritable === false) {
@@ -269,18 +291,12 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
                     } catch (error) {
                         throw new Error("[WindowManger]: room must be switched to be writable");
                     }
-                    manager = (await room.createInvisiblePlugin(
-                        WindowManager,
-                        {}
-                    )) as WindowManager;
-                    manager.ensureAttributes();
+                    manager = await createInvisiblePlugin(room);
+                    manager?.ensureAttributes();
                     await wait(500);
                     await room.setWritable(false);
                 } else {
-                    manager = (await room.createInvisiblePlugin(
-                        WindowManager,
-                        {}
-                    )) as WindowManager;
+                    manager = await createInvisiblePlugin(room);
                 }
             }
         }
@@ -289,12 +305,13 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
 
     private static initContainer(
         container: HTMLElement,
+        target: HTMLElement,
         overwriteStyles: string | undefined
     ) {
         if (!WindowManager.container) {
             WindowManager.container = container;
         }
-        const { playground, mainViewElement } = setupWrapper(container);
+        const { playground, mainViewElement } = setupWrapper(container, target);
         WindowManager.playground = playground;
         if (overwriteStyles) {
             const style = document.createElement("style");
@@ -317,10 +334,12 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
                 container.appendChild(WindowManager.container.firstChild);
             }
         } else {
-            if (WindowManager.params) {
+            const teleboxContainer = this.boxManager?.teleBoxManager.$stage;
+            if (WindowManager.params && teleboxContainer) {
                 const params = WindowManager.params;
                 const mainViewElement = WindowManager.initContainer(
                     container,
+                    teleboxContainer,
                     params.overwriteStyles
                 );
                 if (this.boxManager && WindowManager.playground) {
@@ -330,6 +349,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
                 if (WindowManager.playground) {
                     this.cursorManager?.setupWrapper(WindowManager.playground);
                 }
+               
             }
         }
         emitter.emit("updateManagerRect");
@@ -504,15 +524,28 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         }
     }
 
+    public async jumpPage(index: number): Promise<boolean> {
+        if (!this.appManager) {
+            return false;
+        }
+        if (index < 0 || index >= this.pageState.length) {
+            console.warn(`[WindowManager]: index ${index} out of range`);
+            return false;
+        }
+        await this.appManager.setMainViewSceneIndex(index);
+        return true;
+    }
+
     public async addPage(params?: AddPageParams): Promise<void> {
         if (this.appManager) {
             const after = params?.after;
-            const scene = params?.scene;
+            const scene = params?.scene || {};
+            const scenes = Array.isArray(scene) ? scene : [scene];
             if (after) {
                 const nextIndex = this.mainViewSceneIndex + 1;
-                this.room.putScenes(ROOT_DIR, [scene || {}], nextIndex);
+                this.room.putScenes(ROOT_DIR, scenes, nextIndex);
             } else {
-                this.room.putScenes(ROOT_DIR, [scene || {}]);
+                this.room.putScenes(ROOT_DIR, scenes);
             }
         }
     }
@@ -580,16 +613,19 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
      * 设置 ViewMode
      */
     public setViewMode(mode: ViewMode): void {
+        log("setViewMode", mode);
+        const mainViewProxy = this.appManager?.mainViewProxy;
         if (mode === ViewMode.Broadcaster) {
             if (this.canOperate) {
-                this.appManager?.mainViewProxy.setCameraAndSize();
+                mainViewProxy?.storeCurrentCamera();
             }
-            this.appManager?.mainViewProxy.start();
+            mainViewProxy?.start();
         }
         if (mode === ViewMode.Freedom) {
-            this.appManager?.mainViewProxy.stop();
+            mainViewProxy?.stop();
         }
         this.viewMode = mode;
+        this.viewMode$.setValue(mode);
     }
 
     public setBoxState(boxState: TeleBoxState): void {
@@ -637,6 +673,22 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         }
     }
 
+    public get baseCamera() {
+        if (this.appManager) {
+            return this.appManager.mainViewProxy.camera$.value;
+        } else {
+            throw new Errors.AppManagerNotInitError();
+        }
+    }
+
+    public get baseSize() {
+        if (this.appManager) {
+            return this.appManager.mainViewProxy.size$.value;
+        } else {
+            throw new Errors.AppManagerNotInitError();
+        }
+    }
+
     public get cameraState(): CameraState {
         if (this.appManager) {
             return this.appManager.mainViewProxy.cameraState;
@@ -669,6 +721,14 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         }
     }
 
+    public get fullscreen(): TeleBoxFullscreen | undefined {
+        if (this.appManager) {
+            return this.appManager.boxManager?.teleBoxManager.fullscreen;
+        } else {
+            throw new Errors.AppManagerNotInitError();
+        }
+    }
+
     public get focused(): string | undefined {
         return this.attributes.focus;
     }
@@ -722,6 +782,13 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         }
     }
 
+    public get teleboxManager(): TeleBoxManager {
+        if (!this.boxManager) {
+            throw new Errors.BoxManagerNotInitializeError();
+        }
+        return this.boxManager.teleBoxManager;
+    }
+
     /**
      * 查询所有的 App
      */
@@ -743,30 +810,58 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         return this.appManager?.closeApp(appId);
     }
 
-    public moveCamera(
-        camera: Partial<Camera> & { animationMode?: AnimationMode | undefined }
-    ): void {
-        const pureCamera = omit(camera, ["animationMode"]);
+    public moveCamera = (camera: Partial<Camera> & { animationMode?: AnimationMode } ): void => {
         const mainViewCamera = { ...this.mainView.camera };
-        if (isEqual({ ...mainViewCamera, ...pureCamera }, mainViewCamera)) return;
-        this.mainView.moveCamera(camera);
-        this.appManager?.dispatchInternalEvent(Events.MoveCamera, camera);
-        setTimeout(() => {
-            this.appManager?.mainViewProxy.setCameraAndSize();
-        }, 500);
-    }
+        const nextCamera = { ...mainViewCamera, ...camera };
+        if (isEqual(nextCamera, mainViewCamera)) return;
+        if (!this.appManager) return;
+        if (camera.animationMode === AnimationMode.Immediately) {
+            this.appManager.mainViewProxy.storeCamera({
+                id: this.appManager.uid,
+                ...nextCamera
+            });
+        } else {
+            const remoteCamera = this.appManager.mainViewProxy.size$.value;
+            const currentSize = this.boxManager?.stageRect;
+            let nextScale;
+            if (camera.scale &&  remoteCamera && currentSize) {
+                nextScale = camera.scale * computedMinScale(remoteCamera, currentSize);
+            }
+            if (nextScale) {
+                this.mainView.moveCamera({
+                    ...camera,
+                    scale: nextScale,
+                });
+            } else {
+                this.mainView.moveCamera(camera);
+            }
+            this.appManager.dispatchInternalEvent(Events.MoveCamera, camera);
+            this.mainView.callbacks.off("onCameraUpdated", this.onCameraUpdated);
+            clearTimeout(this.cameraUpdating);
+            this.cameraUpdating = 0;
+            this.mainView.callbacks.on("onCameraUpdated", this.onCameraUpdated);
+            if (nextScale) {
+                this.nextCamera = nextCamera;
+            }
+        }
+    };
 
-    public moveCameraToContain(
-        rectangle: Rectangle &
-            Readonly<{
-                animationMode?: AnimationMode;
-            }>
-    ): void {
-        this.mainView.moveCameraToContain(rectangle);
-        this.appManager?.dispatchInternalEvent(Events.MoveCameraToContain, rectangle);
-        setTimeout(() => {
-            this.appManager?.mainViewProxy.setCameraAndSize();
-        }, 500);
+    private onCameraUpdated = () => {
+        if (this.cameraUpdating) {
+            clearTimeout(this.cameraUpdating);
+            this.cameraUpdating = 0;
+        }
+        this.cameraUpdating = setTimeout(() => {
+            this.mainView.callbacks.off("onCameraUpdated", this.onCameraUpdated);
+            clearTimeout(this.cameraUpdating);
+            this.cameraUpdating = 0;
+            if (!this.appManager || !this.nextCamera) return;
+            this.appManager.mainViewProxy.storeCamera({
+                id: this.appManager.uid,
+                ...this.nextCamera
+            });
+            this.nextCamera = null;
+        }, 50);
     }
 
     public convertToPointInWorld(point: Point): Point {
@@ -835,6 +930,10 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         this.appManager?.boxManager?.setPrefersColorScheme(scheme);
     }
 
+    public setFullscreen(fullscreen: TeleBoxFullscreen): void {
+        this.appManager?.boxManager?.teleBoxManager.setFullscreen(fullscreen);
+    }
+
     public cleanCurrentScene(): void {
         this.focusedView?.cleanCurrentScene();
     }
@@ -894,7 +993,7 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         if (WindowManager.container) {
             this.bindContainer(WindowManager.container);
         }
-        this.appManager?.refresher?.refresh();
+        this.appManager?.refresher.refresh();
     }
 
     public setContainerSizeRatio(ratio: number) {
@@ -906,6 +1005,44 @@ export class WindowManager extends InvisiblePlugin<WindowMangerAttributes> imple
         emitter.emit("containerSizeRatioUpdate", ratio);
     }
 
+    public setContainerStyle(style: string) {
+        this.boxManager?.teleBoxManager.setContainerStyle(style);
+    }
+
+    public setStageStyle(style: string) {
+        this.boxManager?.teleBoxManager.setStageStyle(style);
+    }
+
+    public setBaseSize(size: Size) {
+        this.appManager?.mainViewProxy.setMainViewSize(size);
+        setTimeout(() => {
+            if (!this.appManager || !this.appManager.mainViewProxy.camera$.value) return;
+            this.appManager.mainViewProxy.storeCamera({
+                ...this.appManager.mainViewProxy.camera$.value,
+                id: this.appManager.uid,
+                scale: 1
+            });
+        }, 500);
+    }
+
+    public createPPTHandler() {
+        return {
+            onPageJumpTo: (_pptUUID: string, index: number) => {
+                this.appManager?.focusApp?.appContext?.whiteBoardView?.jumpPage(index);
+            },
+            onPageToNext: () => {
+                if (this.focused) {
+                    this.appManager?.focusApp?.appContext?.whiteBoardView?.nextPage();
+                }
+            },
+            onPageToPrev: () => {
+                if (this.focused) {
+                    this.appManager?.focusApp?.appContext?.whiteBoardView?.prevPage();
+                }
+            }
+        }
+    }
+
     private isDynamicPPT(scenes: SceneDefinition[]) {
         const sceneSrc = scenes[0]?.ppt?.src;
         return sceneSrc?.startsWith("pptx://");
@@ -939,5 +1076,6 @@ setupBuiltin();
 
 export * from "./typings";
 
-export { BuiltinApps } from "./BuiltinApps";
+export { BuiltinApps, BuiltinAppsMap } from "./BuiltinApps";
 export type { PublicEvent } from "./callback";
+export type { Member } from "./Helper";

package/src/style.css

@@ -7,48 +7,9 @@
     user-select: none;
 }
 
-.netless-window-manager-sizer {
-    position: absolute;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    z-index: 1;
-    overflow: hidden;
-    display: flex;
-}
-
-.netless-window-manager-sizer-horizontal {
-    flex-direction: column;
-}
-
-.netless-window-manager-sizer::before,
-.netless-window-manager-sizer::after {
-    flex: 1;
-    content: "";
-    display: block;
-}
-
-.netless-window-manager-chess-sizer::before,
-.netless-window-manager-chess-sizer::after {
-    background-image: linear-gradient(45deg, #b0b0b0 25%, transparent 25%),
-        linear-gradient(-45deg, #b0b0b0 25%, transparent 25%),
-        linear-gradient(45deg, transparent 75%, #b0b0b0 75%),
-        linear-gradient(-45deg, transparent 75%, #b0b0b0 75%);
-    background-color: #fff;
-    background-size: 20px 20px;
-    background-position: 0 0, 0 10px, 10px -10px, -10px 0px;
-}
-
-.netless-window-manager-wrapper {
-    position: relative;
-    z-index: 1;
-    width: 100%;
-    height: 100%;
-    overflow: hidden;
-}
 
 .netless-window-manager-main-view {
+    position: absolute;
     width: 100%;
     height: 100%;
 }
@@ -122,7 +83,7 @@
     left: 0;
     top: 0;
     will-change: transform;
-    transition: transform 0.1s;
+    transition: transform 0.12s;
     transform-origin: 0 0;
     user-select: none;
 }
@@ -180,10 +141,6 @@
 }
 
 .window-manager-view-wrapper {
-    z-index: 5000;
-    width: 100%;
-    height: 100%;
     position: absolute;
-    left: 0;
-    top: 0;
+    z-index: 10;
 }

package/src/typings.ts

@@ -11,7 +11,7 @@ import type {
     View,
 } from "white-web-sdk";
 import type { AppContext } from "./App";
-import type { ReadonlyTeleBox, TeleBoxRect } from "@netless/telebox-insider";
+import type { ReadonlyTeleBox, TeleBoxRect, TeleBoxFullscreen } from "@netless/telebox-insider";
 import type { PageState } from "./Page";
 import type { Member } from "./Helper";
 
@@ -30,6 +30,9 @@ export interface NetlessApp<Attributes = any, MagixEventPayloads = any, AppOptio
 
         /** App only single instance. */
         singleton?: boolean;
+
+        /** App box enableShadowDom. Default true */
+        enableShadowDOM?: boolean;
     };
     setup: (context: AppContext<Attributes, MagixEventPayloads, AppOptions>) => SetupResult;
 }
@@ -69,22 +72,30 @@ export type RegisterEvents<SetupResult = any> = {
 
 export type RegisterParams<AppOptions = any, SetupResult = any, Attributes = any> = {
     kind: string;
-    src: NetlessApp<Attributes, SetupResult> | string | (() => Promise<NetlessApp<Attributes, SetupResult>>);
+    src:
+        | NetlessApp<Attributes, SetupResult>
+        | string
+        | (() => Promise<NetlessApp<Attributes, SetupResult>>)
+        | (() => Promise<{ default: NetlessApp<Attributes, SetupResult> }>);
     appOptions?: AppOptions | (() => AppOptions);
     addHooks?: (emitter: Emittery<RegisterEvents<SetupResult>>) => void;
     /** dynamic load app package name */
     name?: string;
+    contentStyles?: string;
 };
 
 export type AppListenerKeys = keyof AppEmitterEvent;
 
 export type ApplianceIcons = Partial<Record<ApplianceNames, string>>;
 
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+
 export type { AppContext } from "./App/AppContext";
 export type { WhiteBoardView } from "./App";
-export type { ReadonlyTeleBox, TeleBoxRect };
+export type { ReadonlyTeleBox, TeleBoxRect, TeleBoxFullscreen };
 export type { SceneState, SceneDefinition, View, AnimationMode, Displayer, Room, Player };
 export type { Storage, StorageStateChangedEvent, StorageStateChangedListener } from "./App/Storage";
 export * from "./Page";
 export * from "./Utils/error";
 export type { Member } from "./Helper";
+export type { TeleBoxManager, TeleBoxManagerQueryConfig } from "@netless/telebox-insider";

package/vite.config.js

@@ -1,11 +1,12 @@
 import path from "path";
+import dts from 'vite-plugin-dts'
 import { defineConfig } from 'vitest/config'
 import { svelte } from "@sveltejs/vite-plugin-svelte";
 import { dependencies, peerDependencies, version, devDependencies } from "./package.json"
 import { omit } from "lodash";
 
-export default defineConfig(({ mode }) => {
-    const isProd = mode === "production";
+export default defineConfig(() => {
+    // const isProd = mode === "production";
 
     return {
         test: {
@@ -14,7 +15,9 @@ export default defineConfig(({ mode }) => {
                 inline: [
                   "@juggle/resize-observer"
                 ]
-            }
+            },
+            setupFiles: "./test/setup.ts",
+            include: ["test/**/*.test.ts"],
         },
         define: {
             __APP_VERSION__: JSON.stringify(version),
@@ -28,7 +31,8 @@ export default defineConfig(({ mode }) => {
                 experimental: {
                     useVitePreprocess: true,
                 },
-            })
+            }),
+            dts()
         ],
         build: {
             lib: {
@@ -36,7 +40,8 @@ export default defineConfig(({ mode }) => {
                 entry: path.resolve(__dirname, "src/index.ts"),
                 formats: ["es", "umd", "cjs"],
                 name: "WindowManager",
-                fileName: "index"
+                fileName: "index",
+
             },
             outDir: "dist",
             rollupOptions: {
@@ -45,7 +50,7 @@ export default defineConfig(({ mode }) => {
                     ...peerDependencies,
                 }),
             },
-            minify: isProd,
+            minify: false
         },
     };
-});
+})