@netless/telebox-insider 0.3.0 → 0.3.1

package/src/TeleBoxManager/index.ts

@@ -43,6 +43,7 @@ type ValConfig = {
     readonly: Val<boolean, boolean>;
     minimized: Val<boolean, boolean>;
     maximized: Val<boolean, boolean>;
+    forceMaximized: Val<boolean, boolean>;
     fence: Val<boolean, boolean>;
 };
 export interface TeleBoxManager extends ValEnhancedResult<ValConfig> {}
@@ -57,12 +58,12 @@ export class TeleBoxManager {
         skipUpdate: boolean;
         timer: number | undefined;
         resolve?: (skipUpdate: boolean) => void;
-    }
+    };
     protected effectLastNotMinimizedBoxStatusTimer?: {
         skipUpdate: boolean;
         timer: number | undefined;
         resolve?: (skipUpdate: boolean) => void;
-    }
+    };
 
     public constructor({
         root = document.body,
@@ -79,6 +80,7 @@ export class TeleBoxManager {
         collector,
         namespace = "telebox",
         readonly = false,
+        forceMaximized = false,
         useBoxesStatus = false,
     }: TeleBoxManagerConfig = {}) {
         this._sideEffect = new SideEffectManager();
@@ -96,7 +98,10 @@ export class TeleBoxManager {
                     if (box.forceTop) {
                         return topBox;
                     }
-                    if (box.boxStatus && box.boxStatus === TELE_BOX_STATE.Minimized) {
+                    if (
+                        box.boxStatus &&
+                        box.boxStatus === TELE_BOX_STATE.Minimized
+                    ) {
                         return topBox;
                     }
                     if (!topBox) {
@@ -104,13 +109,16 @@ export class TeleBoxManager {
                         return topBox;
                     }
                     return topBox.zIndex > box.zIndex ? topBox : box;
-                }, currentTopBox as (TeleBox | undefined));
+                }, currentTopBox as TeleBox | undefined);
                 return topBox;
             }
             return;
         });
         this.boxesStatus$ = new Map<string, TeleBoxState>();
-        this.lastNotMinimizedBoxesStatus$ = new Map<string, NotMinimizedBoxState>();
+        this.lastNotMinimizedBoxesStatus$ = new Map<
+            string,
+            NotMinimizedBoxState
+        >();
         const prefersDark = window.matchMedia("(prefers-color-scheme: dark)");
         const prefersDark$ = createVal(false);
 
@@ -159,7 +167,19 @@ export class TeleBoxManager {
 
         const minimized$ = createVal(minimized);
 
-        const maximized$ = createVal(maximized);
+        const forceMaximized$ = createVal(forceMaximized);
+        const maximized$ = createVal(
+            maximized || forceMaximized,
+            (next, previous) =>
+                next === previous || (forceMaximized$.value && !next)
+        );
+        forceMaximized$.reaction((forceMaximized, _, skipUpdate) => {
+            if (forceMaximized) maximized$.setValue(true, skipUpdate);
+            this.boxes.forEach((box) =>
+                box.setForceMaximized(forceMaximized, skipUpdate)
+            );
+            this.maxTitleBar?.setForceMaximized?.(forceMaximized);
+        });
         maximized$.reaction((maximized, _, skipUpdate) => {
             this.boxes.forEach((box) =>
                 box.setMaximized(maximized, skipUpdate)
@@ -205,7 +225,7 @@ export class TeleBoxManager {
                       new TeleBoxCollector({
                           visible: minimized,
                           readonly: readonly,
-                          namespace
+                          namespace,
                       }).mount(root)
         );
         collector$.subscribe((collector) => {
@@ -313,27 +333,44 @@ export class TeleBoxManager {
                 if (id) {
                     const box = this.getBox(id);
                     if (box) {
+                        if (this.lazyFocusRequestHandler?.(box.id)) return;
                         if (!this.useBoxesStatus) {
                             this.makeBoxTop(box);
                         } else {
-                            if (box.boxStatus && box.boxStatus === TELE_BOX_STATE.Normal) {
-                                const maxNormalBoxZIndex = this.getMaxNormalBoxZIndex();
+                            if (
+                                box.boxStatus &&
+                                box.boxStatus === TELE_BOX_STATE.Normal
+                            ) {
+                                const maxNormalBoxZIndex =
+                                    this.getMaxNormalBoxZIndex();
                                 if (maxNormalBoxZIndex > box.zIndex) {
-                                    this.setBox(box, {
-                                        zIndex: maxNormalBoxZIndex + 1
-                                    }, false);
+                                    this.setBox(
+                                        box,
+                                        {
+                                            zIndex: maxNormalBoxZIndex + 1,
+                                        },
+                                        false
+                                    );
                                 }
-                            } else if(box.boxStatus && box.boxStatus === TELE_BOX_STATE.Maximized){
-                                const maxMaximizedBoxZIndex = this.getMaxMaximizedBoxZIndex();
+                            } else if (
+                                box.boxStatus &&
+                                box.boxStatus === TELE_BOX_STATE.Maximized
+                            ) {
+                                const maxMaximizedBoxZIndex =
+                                    this.getMaxMaximizedBoxZIndex();
                                 if (maxMaximizedBoxZIndex > box.zIndex) {
-                                    this.setBox(box, {
-                                        zIndex: maxMaximizedBoxZIndex + 1
-                                    }, false);
+                                    this.setBox(
+                                        box,
+                                        {
+                                            zIndex: maxMaximizedBoxZIndex + 1,
+                                        },
+                                        false
+                                    );
                                 }
                                 this.makeMaximizedTopBoxFocus();
                             }
-                        } 
-                        this.focusBox(box);
+                        }
+                        this.focusBoxCommitted(box);
                         return;
                     }
                 }
@@ -358,6 +395,7 @@ export class TeleBoxManager {
             readonly: readonly$.value,
             namespace: this.namespace,
             state: state$.value,
+            forceMaximized: forceMaximized$.value,
             boxes: this.boxes$.value,
             containerRect: containerRect$.value,
             getBoxesStatus: () => {
@@ -366,20 +404,33 @@ export class TeleBoxManager {
             onEvent: (event): void => {
                 switch (event.type) {
                     case TELE_BOX_DELEGATE_EVENT.Maximize: {
+                        if (
+                            forceMaximized$.value &&
+                            this.state === TELE_BOX_STATE.Maximized
+                        ) {
+                            return;
+                        }
                         if (this.hasBoxesStatus()) {
                             let targetBox = this.maxTitleBar.focusedBox;
                             if (!targetBox) {
-                               targetBox = this.getMaximizedTopBox();
+                                targetBox = this.getMaximizedTopBox();
                             }
                             if (targetBox?.id) {
                                 const box = this.getBox(targetBox.id);
                                 if (box) {
-                                    this.setBox(box, {
-                                        status: TELE_BOX_STATE.Normal,
-                                        zIndex: this.getMaxNormalBoxZIndex() + 1
-                                    }, false, ()=>{
-                                        this.makeMaximizedTopBoxFocus();
-                                    });
+                                    this.setBox(
+                                        box,
+                                        {
+                                            status: TELE_BOX_STATE.Normal,
+                                            zIndex:
+                                                this.getMaxNormalBoxZIndex() +
+                                                1,
+                                        },
+                                        false,
+                                        () => {
+                                            this.makeMaximizedTopBoxFocus();
+                                        }
+                                    );
                                 }
                             }
                         } else {
@@ -391,9 +442,9 @@ export class TeleBoxManager {
                         if (this.hasBoxesStatus()) {
                             let targetBox = this.maxTitleBar.focusedBox;
                             if (!targetBox) {
-                               targetBox = this.getMaximizedTopBox();
+                                targetBox = this.getMaximizedTopBox();
                             }
-                            if(targetBox?.id){
+                            if (targetBox?.id) {
                                 const box = this.getBox(targetBox.id);
                                 if (box) {
                                     let isFocusChanged = false;
@@ -401,10 +452,14 @@ export class TeleBoxManager {
                                         this.blurBox(box);
                                         isFocusChanged = true;
                                     }
-                                    this.setBox(box, {
-                                        status: TELE_BOX_STATE.Minimized,
-                                        zIndex: -1
-                                    }, false);
+                                    this.setBox(
+                                        box,
+                                        {
+                                            status: TELE_BOX_STATE.Minimized,
+                                            zIndex: -1,
+                                        },
+                                        false
+                                    );
                                     if (isFocusChanged) {
                                         this.focusTopBox();
                                     } else {
@@ -421,7 +476,7 @@ export class TeleBoxManager {
                         if (this.hasBoxesStatus()) {
                             let targetBox = this.maxTitleBar.focusedBox;
                             if (!targetBox) {
-                               targetBox = this.getMaximizedTopBox();
+                                targetBox = this.getMaximizedTopBox();
                             }
                             if (targetBox?.id) {
                                 const box = this.getBox(targetBox.id);
@@ -470,6 +525,7 @@ export class TeleBoxManager {
             fence: fence$,
             minimized: minimized$,
             maximized: maximized$,
+            forceMaximized: forceMaximized$,
         };
 
         withValueEnhancer(this, valConfig);
@@ -532,8 +588,27 @@ export class TeleBoxManager {
         return this._state$.value;
     }
 
+    public setUseBoxesStatus(useBoxesStatus: boolean): void {
+        if (this.useBoxesStatus === useBoxesStatus) return;
+        this.useBoxesStatus = useBoxesStatus;
+        this.boxes.forEach((box) =>
+            box.setBoxStatus(useBoxesStatus ? this.boxesStatus$.get(box.id) : undefined, true)
+        );
+        this.boxes$.setValue([...this.boxes]);
+        if (useBoxesStatus) {
+            this.appMenu ||= this.createMinimizedAppMenu();
+            this.effectBoxStatusChange();
+        } else {
+            this.appMenu?.render(new Map());
+            this.collector?.setVisible(false);
+        }
+    }
+
     /** @deprecated use setMaximized and setMinimized instead */
     public setState(state: TeleBoxState, skipUpdate = false): this {
+        if (state === TELE_BOX_STATE.Normal && this.forceMaximized) {
+            return this;
+        }
         switch (state) {
             case TELE_BOX_STATE.Maximized: {
                 this.setMinimized(false, skipUpdate);
@@ -554,13 +629,27 @@ export class TeleBoxManager {
         return this;
     }
 
-    public setBoxStatus(boxId: string, boxStatus?: TeleBoxState, skipUpdate = false): void {
+    public setBoxStatus(
+        boxId: string,
+        boxStatus?: TeleBoxState,
+        skipUpdate = false
+    ): void {
         if (boxStatus) {
             const oldBoxStatus = this.boxesStatus$.get(boxId);
             this.boxesStatus$.set(boxId, boxStatus);
-            if (boxStatus === TELE_BOX_STATE.Minimized && oldBoxStatus !== TELE_BOX_STATE.Minimized) {
-                this.setLastNotMinimizedBoxStatus(boxId, oldBoxStatus, skipUpdate);
-            } else if (oldBoxStatus === TELE_BOX_STATE.Minimized && boxStatus !== TELE_BOX_STATE.Minimized) {
+            if (
+                boxStatus === TELE_BOX_STATE.Minimized &&
+                oldBoxStatus !== TELE_BOX_STATE.Minimized
+            ) {
+                this.setLastNotMinimizedBoxStatus(
+                    boxId,
+                    oldBoxStatus,
+                    skipUpdate
+                );
+            } else if (
+                oldBoxStatus === TELE_BOX_STATE.Minimized &&
+                boxStatus !== TELE_BOX_STATE.Minimized
+            ) {
                 this.setLastNotMinimizedBoxStatus(boxId, undefined, skipUpdate);
             }
         } else {
@@ -568,7 +657,10 @@ export class TeleBoxManager {
             this.setLastNotMinimizedBoxStatus(boxId, undefined, skipUpdate);
         }
         if (!skipUpdate) {
-            this.events.emit(TELE_BOX_MANAGER_EVENT.BoxStatus, { id: boxId, boxStatus});
+            this.events.emit(TELE_BOX_MANAGER_EVENT.BoxStatus, {
+                id: boxId,
+                boxStatus,
+            });
         }
     }
 
@@ -580,11 +672,17 @@ export class TeleBoxManager {
         return this.boxesStatus$;
     }
 
-    public get lastNotMinimizedBoxesStatus(): ReadonlyMap<string, NotMinimizedBoxState> {
+    public get lastNotMinimizedBoxesStatus(): ReadonlyMap<
+        string,
+        NotMinimizedBoxState
+    > {
         return this.lastNotMinimizedBoxesStatus$;
     }
 
-    public setBoxesStatus(boxesStatus: Map<string, TeleBoxState>, skipUpdate = false) {
+    public setBoxesStatus(
+        boxesStatus: Map<string, TeleBoxState>,
+        skipUpdate = false
+    ) {
         this.boxesStatus$ = boxesStatus;
         this.effectBoxesStatusChange(skipUpdate);
     }
@@ -593,13 +691,13 @@ export class TeleBoxManager {
         return this.boxesStatus$;
     }
 
-    protected effectBoxStatusChange(){
+    protected effectBoxStatusChange() {
         if (!this.useBoxesStatus) {
             return;
         }
-        if(this.collector){
+        if (this.collector) {
             this.collector.updateBoxesStatus();
-            if(this.hasMinimizedBox()){
+            if (this.hasMinimizedBox()) {
                 this._setCollectorRect(this._calcCollectorRect());
             }
         }
@@ -611,16 +709,20 @@ export class TeleBoxManager {
         }
     }
 
-    protected effectBoxesStatusTimerFunc(skipUpdate: boolean){
+    protected effectBoxesStatusTimerFunc(skipUpdate: boolean) {
         if (!this.useBoxesStatus) {
             return;
         }
-        let newTopBox:TeleBox | undefined;
+        let newTopBox: TeleBox | undefined;
         const curTopBox = this.topBox;
         this.boxes.forEach((box) => {
             const boxStatus = this.boxesStatus$.get(box.id);
             if (boxStatus) {
-                if (boxStatus !== TELE_BOX_STATE.Minimized && !this.isForceTop(box) && box.zIndex > (newTopBox?.zIndex ?? 0)) {
+                if (
+                    boxStatus !== TELE_BOX_STATE.Minimized &&
+                    !this.isForceTop(box) &&
+                    box.zIndex > (newTopBox?.zIndex ?? 0)
+                ) {
                     newTopBox = box;
                 }
                 box.setBoxStatus(boxStatus, skipUpdate);
@@ -637,20 +739,27 @@ export class TeleBoxManager {
 
     public async effectBoxesStatusChange(skipUpdate = false): Promise<void> {
         if (!this.useBoxesStatus) {
-            if (this.effectBoxesStatusTimer && this.effectBoxesStatusTimer.timer) {
+            if (
+                this.effectBoxesStatusTimer &&
+                this.effectBoxesStatusTimer.timer
+            ) {
                 clearTimeout(this.effectBoxesStatusTimer.timer);
                 if (this.effectBoxesStatusTimer.resolve) {
-                    this.effectBoxesStatusTimer.resolve(!!this.effectBoxesStatusTimer?.skipUpdate);
+                    this.effectBoxesStatusTimer.resolve(
+                        !!this.effectBoxesStatusTimer?.skipUpdate
+                    );
                 }
             }
-            this.effectBoxesStatusTimer=undefined;
+            this.effectBoxesStatusTimer = undefined;
             return;
         }
         if (this.effectBoxesStatusTimer && this.effectBoxesStatusTimer.timer) {
             if (this.effectBoxesStatusTimer.skipUpdate !== skipUpdate) {
                 clearTimeout(this.effectBoxesStatusTimer.timer);
                 if (this.effectBoxesStatusTimer.resolve) {
-                    this.effectBoxesStatusTimer.resolve(!!this.effectBoxesStatusTimer?.skipUpdate);
+                    this.effectBoxesStatusTimer.resolve(
+                        !!this.effectBoxesStatusTimer?.skipUpdate
+                    );
                 }
                 this.effectBoxesStatusTimer.skipUpdate = skipUpdate;
             } else {
@@ -665,22 +774,27 @@ export class TeleBoxManager {
             } as {
                 skipUpdate: boolean;
                 timer: number | undefined;
-            }
+            };
         }
         if (this.effectBoxesStatusTimer) {
-            const _skipUpdate = await new Promise<boolean>((resolve)=>{
+            const _skipUpdate = await new Promise<boolean>((resolve) => {
                 this.effectBoxesStatusTimer!.resolve = resolve;
-                this.effectBoxesStatusTimer!.timer = setTimeout(()=>{
-                    if (this.effectBoxesStatusTimer && this.effectBoxesStatusTimer.resolve) {
-                        this.effectBoxesStatusTimer.resolve(this.effectBoxesStatusTimer!.skipUpdate);
+                this.effectBoxesStatusTimer!.timer = setTimeout(() => {
+                    if (
+                        this.effectBoxesStatusTimer &&
+                        this.effectBoxesStatusTimer.resolve
+                    ) {
+                        this.effectBoxesStatusTimer.resolve(
+                            this.effectBoxesStatusTimer!.skipUpdate
+                        );
                     }
                 }, 100) as unknown as number;
-            })
-            this.effectBoxesStatusTimerFunc(_skipUpdate)
+            });
+            this.effectBoxesStatusTimerFunc(_skipUpdate);
             this.effectBoxesStatusTimer = undefined;
         }
     }
-    
+
     public hasBoxesStatus(): boolean {
         if (!this.useBoxesStatus) {
             return false;
@@ -692,14 +806,19 @@ export class TeleBoxManager {
         if (!this.useBoxesStatus) {
             return false;
         }
-        return this.boxes.some((box) => box.boxStatus && box.boxStatus === TELE_BOX_STATE.Minimized);
+        return this.boxes.some(
+            (box) => box.boxStatus && box.boxStatus === TELE_BOX_STATE.Minimized
+        );
     }
 
     public getMinimizedBoxesStatus(): Map<string, TELE_BOX_STATE.Minimized> {
         const minimizedBoxes = new Map<string, TELE_BOX_STATE.Minimized>();
         this.boxesStatus$.forEach((boxStatus, boxId) => {
             if (boxStatus === TELE_BOX_STATE.Minimized) {
-                minimizedBoxes.set(boxId, boxStatus as TELE_BOX_STATE.Minimized);
+                minimizedBoxes.set(
+                    boxId,
+                    boxStatus as TELE_BOX_STATE.Minimized
+                );
             }
         });
         return minimizedBoxes;
@@ -719,7 +838,10 @@ export class TeleBoxManager {
         const maximizedBoxes = new Map<string, TELE_BOX_STATE.Maximized>();
         this.boxesStatus$.forEach((boxStatus, boxId) => {
             if (boxStatus === TELE_BOX_STATE.Maximized) {
-                maximizedBoxes.set(boxId, boxStatus as TELE_BOX_STATE.Maximized);
+                maximizedBoxes.set(
+                    boxId,
+                    boxStatus as TELE_BOX_STATE.Maximized
+                );
             }
         });
         return maximizedBoxes;
@@ -735,45 +857,76 @@ export class TeleBoxManager {
         return normalBoxes;
     }
 
-    public getLastNotMinimizedBoxStatus(boxId: string): NotMinimizedBoxState | undefined {
+    public getLastNotMinimizedBoxStatus(
+        boxId: string
+    ): NotMinimizedBoxState | undefined {
         return this.lastNotMinimizedBoxesStatus$.get(boxId);
     }
 
-    public setLastNotMinimizedBoxStatus(boxId: string, lastNotMinimizedBoxStatus?: NotMinimizedBoxState, skipUpdate = false): void {
+    public setLastNotMinimizedBoxStatus(
+        boxId: string,
+        lastNotMinimizedBoxStatus?: NotMinimizedBoxState,
+        skipUpdate = false
+    ): void {
         if (lastNotMinimizedBoxStatus) {
-            this.lastNotMinimizedBoxesStatus$.set(boxId, lastNotMinimizedBoxStatus);
+            this.lastNotMinimizedBoxesStatus$.set(
+                boxId,
+                lastNotMinimizedBoxStatus
+            );
         } else {
             this.lastNotMinimizedBoxesStatus$.delete(boxId);
         }
         if (!skipUpdate) {
-            this.events.emit(TELE_BOX_MANAGER_EVENT.LastNotMinimizedBoxStatus, { id: boxId, boxStatus:lastNotMinimizedBoxStatus});
+            this.events.emit(TELE_BOX_MANAGER_EVENT.LastNotMinimizedBoxStatus, {
+                id: boxId,
+                boxStatus: lastNotMinimizedBoxStatus,
+            });
         }
     }
 
-    public setLastNotMinimizedBoxesStatus(lastNotMinimizedBoxesStatus: Map<string, NotMinimizedBoxState>, skipUpdate = false): void {
+    public setLastNotMinimizedBoxesStatus(
+        lastNotMinimizedBoxesStatus: Map<string, NotMinimizedBoxState>,
+        skipUpdate = false
+    ): void {
         this.lastNotMinimizedBoxesStatus$ = lastNotMinimizedBoxesStatus;
         this.effectLastNotMinimizedBoxStatusChange(skipUpdate);
     }
 
-    protected async effectLastNotMinimizedBoxStatusChange(skipUpdate = false): Promise<void> {
+    protected async effectLastNotMinimizedBoxStatusChange(
+        skipUpdate = false
+    ): Promise<void> {
         if (!this.useBoxesStatus) {
-            if (this.effectLastNotMinimizedBoxStatusTimer && this.effectLastNotMinimizedBoxStatusTimer.timer) {
+            if (
+                this.effectLastNotMinimizedBoxStatusTimer &&
+                this.effectLastNotMinimizedBoxStatusTimer.timer
+            ) {
                 clearTimeout(this.effectLastNotMinimizedBoxStatusTimer.timer);
                 if (this.effectLastNotMinimizedBoxStatusTimer.resolve) {
-                    this.effectLastNotMinimizedBoxStatusTimer.resolve(!!this.effectLastNotMinimizedBoxStatusTimer?.skipUpdate);
+                    this.effectLastNotMinimizedBoxStatusTimer.resolve(
+                        !!this.effectLastNotMinimizedBoxStatusTimer?.skipUpdate
+                    );
                 }
             }
-            this.effectLastNotMinimizedBoxStatusTimer=undefined;
+            this.effectLastNotMinimizedBoxStatusTimer = undefined;
             return;
         }
-        if (this.effectLastNotMinimizedBoxStatusTimer && this.effectLastNotMinimizedBoxStatusTimer.timer) {
+        if (
+            this.effectLastNotMinimizedBoxStatusTimer &&
+            this.effectLastNotMinimizedBoxStatusTimer.timer
+        ) {
             clearTimeout(this.effectLastNotMinimizedBoxStatusTimer.timer);
-            if (this.effectLastNotMinimizedBoxStatusTimer.skipUpdate !== skipUpdate) {
+            if (
+                this.effectLastNotMinimizedBoxStatusTimer.skipUpdate !==
+                skipUpdate
+            ) {
                 // this.effectLastNotMinimizedBoxStatusFunc(this.effectLastNotMinimizedBoxStatusTimer.skipUpdate)
                 if (this.effectLastNotMinimizedBoxStatusTimer.resolve) {
-                    this.effectLastNotMinimizedBoxStatusTimer.resolve(!!this.effectLastNotMinimizedBoxStatusTimer?.skipUpdate);
+                    this.effectLastNotMinimizedBoxStatusTimer.resolve(
+                        !!this.effectLastNotMinimizedBoxStatusTimer?.skipUpdate
+                    );
                 }
-                this.effectLastNotMinimizedBoxStatusTimer.skipUpdate = skipUpdate;
+                this.effectLastNotMinimizedBoxStatusTimer.skipUpdate =
+                    skipUpdate;
             } else {
                 return;
             }
@@ -786,29 +939,38 @@ export class TeleBoxManager {
             } as {
                 skipUpdate: boolean;
                 timer: number | undefined;
-            }
+            };
         }
         if (this.effectLastNotMinimizedBoxStatusTimer) {
-            const _skipUpdate = await new Promise<boolean>((resolve)=>{
+            const _skipUpdate = await new Promise<boolean>((resolve) => {
                 this.effectLastNotMinimizedBoxStatusTimer!.resolve = resolve;
-                this.effectLastNotMinimizedBoxStatusTimer!.timer = setTimeout(()=>{
-                    if (this.effectLastNotMinimizedBoxStatusTimer && this.effectLastNotMinimizedBoxStatusTimer.resolve) {
-                        this.effectLastNotMinimizedBoxStatusTimer.resolve(this.effectLastNotMinimizedBoxStatusTimer!.skipUpdate);
-                    }
-                }, 100) as unknown as number;
-            })
-            this.effectLastNotMinimizedBoxStatusFunc(_skipUpdate)
+                this.effectLastNotMinimizedBoxStatusTimer!.timer = setTimeout(
+                    () => {
+                        if (
+                            this.effectLastNotMinimizedBoxStatusTimer &&
+                            this.effectLastNotMinimizedBoxStatusTimer.resolve
+                        ) {
+                            this.effectLastNotMinimizedBoxStatusTimer.resolve(
+                                this.effectLastNotMinimizedBoxStatusTimer!
+                                    .skipUpdate
+                            );
+                        }
+                    },
+                    100
+                ) as unknown as number;
+            });
+            this.effectLastNotMinimizedBoxStatusFunc(_skipUpdate);
             this.effectLastNotMinimizedBoxStatusTimer = undefined;
         }
     }
 
-    protected effectLastNotMinimizedBoxStatusFunc(skipUpdate = false){
+    protected effectLastNotMinimizedBoxStatusFunc(skipUpdate = false) {
         if (!this.useBoxesStatus) {
             return;
         }
         this.boxes.forEach((box) => {
             const boxStatus = this.lastNotMinimizedBoxesStatus$.get(box.id);
-            if(boxStatus){
+            if (boxStatus) {
                 box.setLastNotMinimizedBoxStatus(boxStatus, skipUpdate);
             }
         });
@@ -824,7 +986,11 @@ export class TeleBoxManager {
             return this.getUnabledBoxesStatusZIndex();
         }
         return this.boxes.reduce((maxZIndex, box) => {
-            if (box.boxStatus && box.boxStatus === TELE_BOX_STATE.Maximized && !this.isForceTop(box)) {
+            if (
+                box.boxStatus &&
+                box.boxStatus === TELE_BOX_STATE.Maximized &&
+                !this.isForceTop(box)
+            ) {
                 return Math.max(maxZIndex, box.zIndex);
             }
             return maxZIndex;
@@ -837,7 +1003,11 @@ export class TeleBoxManager {
             return this.getUnabledBoxesStatusZIndex();
         }
         return this.boxes.reduce((maxZIndex, box) => {
-            if (box.boxStatus && box.boxStatus === TELE_BOX_STATE.Normal && !this.isForceTop(box)) {
+            if (
+                box.boxStatus &&
+                box.boxStatus === TELE_BOX_STATE.Normal &&
+                !this.isForceTop(box)
+            ) {
                 return Math.max(maxZIndex, box.zIndex);
             }
             return maxZIndex;
@@ -869,8 +1039,13 @@ export class TeleBoxManager {
         smartPosition = true
     ): ReadonlyTeleBox {
         const box = new TeleBox({
-            zIndex: config.forceTop ? this.getMaxForceTopBoxZIndex() + 1 : this.getMaxNormalBoxZIndex() + 1,
+            zIndex: config.forceTop
+                ? this.getMaxForceTopBoxZIndex() + 1
+                : this.getMaxNormalBoxZIndex() + 1,
             ...(smartPosition ? this.smartPosition(config) : config),
+            ...(!this.useBoxesStatus
+                ? { boxStatus: undefined, lastNotMinimizedBoxStatus: undefined }
+                : {}),
             darkMode: this.darkMode,
             prefersColorScheme: this.prefersColorScheme,
             maximized: this.maximized,
@@ -879,6 +1054,7 @@ export class TeleBoxManager {
             namespace: this.namespace,
             containerRect: this.containerRect,
             readonly: this.readonly,
+            forceMaximized: this.forceMaximized,
             collectorRect: this.collectorRect,
         });
 
@@ -887,10 +1063,15 @@ export class TeleBoxManager {
         this.boxes$.setValue([...this.boxes, box]);
 
         if (box.boxStatus && this.useBoxesStatus) {
-            this.setBox(box, {
-                status: box.boxStatus,
-                lastNotMinimizedBoxStatus: box._lastNotMinimizedBoxStatus$.value
-            }, true);
+            this.setBox(
+                box,
+                {
+                    status: box.boxStatus,
+                    lastNotMinimizedBoxStatus:
+                        box._lastNotMinimizedBoxStatus$.value,
+                },
+                true
+            );
         }
 
         if (box.focus) {
@@ -906,43 +1087,64 @@ export class TeleBoxManager {
                     return;
                 }
                 if (box.boxStatus === TELE_BOX_STATE.Maximized) {
-                    this.setBox(box.id, {
-                        status: TELE_BOX_STATE.Normal,
-                        zIndex: this.getMaxNormalBoxZIndex() + 1
-                    }, false);
+                    this.setBox(
+                        box.id,
+                        {
+                            status: TELE_BOX_STATE.Normal,
+                            zIndex: this.getMaxNormalBoxZIndex() + 1,
+                        },
+                        false
+                    );
                 } else {
                     // 所有normal box都最大化
-                    [...this.boxes].filter((box) => box.boxStatus === TELE_BOX_STATE.Normal && !this.isForceNormal(box)).sort((a, b) => a.zIndex - b.zIndex).forEach((box) => {
-                        if (box.boxStatus === TELE_BOX_STATE.Normal) {
-                            this.setBox(box.id, {
-                                status: TELE_BOX_STATE.Maximized,
-                                zIndex: this.getMaxMaximizedBoxZIndex() + 1
-                            }, false);
-                        }
-                    });
+                    [...this.boxes]
+                        .filter(
+                            (box) =>
+                                box.boxStatus === TELE_BOX_STATE.Normal &&
+                                !this.isForceNormal(box)
+                        )
+                        .sort((a, b) => a.zIndex - b.zIndex)
+                        .forEach((box) => {
+                            if (box.boxStatus === TELE_BOX_STATE.Normal) {
+                                this.setBox(
+                                    box.id,
+                                    {
+                                        status: TELE_BOX_STATE.Maximized,
+                                        zIndex:
+                                            this.getMaxMaximizedBoxZIndex() + 1,
+                                    },
+                                    false
+                                );
+                            }
+                        });
                     this.makeMaximizedTopBoxFocus();
                 }
             } else {
-                this.setMaximized(!this.maximized);
+                if (!(this.forceMaximized && this.maximized)) {
+                    this.setMaximized(!this.maximized);
+                }
             }
-
         });
         box._delegateEvents.on(TELE_BOX_DELEGATE_EVENT.Minimize, () => {
             if (box.boxStatus && this.useBoxesStatus) {
                 if (box._forceNormal$.value) {
                     return;
                 }
-                if(box.focus) {
+                if (box.focus) {
                     this.blurBox(box);
                 }
-                this.setBox(box, {
-                    status: TELE_BOX_STATE.Minimized,
-                    zIndex: -1
-                }, false, ()=>{
-                    this.focusTopBox();
-                });
-
-            } else{
+                this.setBox(
+                    box,
+                    {
+                        status: TELE_BOX_STATE.Minimized,
+                        zIndex: -1,
+                    },
+                    false,
+                    () => {
+                        this.focusTopBox();
+                    }
+                );
+            } else {
                 this.setMinimized(true);
             }
         });
@@ -985,7 +1187,10 @@ export class TeleBoxManager {
                     if (this.isForceTop(box)) {
                         return topBox;
                     }
-                    if (box.boxStatus && box.boxStatus === TELE_BOX_STATE.Minimized) {
+                    if (
+                        box.boxStatus &&
+                        box.boxStatus === TELE_BOX_STATE.Minimized
+                    ) {
                         return topBox;
                     }
                     if (!topBox) {
@@ -993,7 +1198,7 @@ export class TeleBoxManager {
                         return topBox;
                     }
                     return topBox.zIndex > box.zIndex ? topBox : box;
-                }, currentTopBox as (TeleBox | undefined));
+                }, currentTopBox as TeleBox | undefined);
                 this.topBox$.setValue(topBox);
             }
             if (!skipUpdate) {
@@ -1039,14 +1244,19 @@ export class TeleBoxManager {
         });
     }
 
-    public setBox(boxOrID: string | TeleBox, options: {
-        status?: TeleBoxState;
-        lastNotMinimizedBoxStatus?: NotMinimizedBoxState;
-        zIndex?: number;
-    }, skipUpdate = false, effectFunc?: () => void){
-        const box = this.getBox(boxOrID)
+    public setBox(
+        boxOrID: string | TeleBox,
+        options: {
+            status?: TeleBoxState;
+            lastNotMinimizedBoxStatus?: NotMinimizedBoxState;
+            zIndex?: number;
+        },
+        skipUpdate = false,
+        effectFunc?: () => void
+    ) {
+        const box = this.getBox(boxOrID);
         if (box) {
-            const {status, zIndex, lastNotMinimizedBoxStatus} = options;
+            const { status, zIndex, lastNotMinimizedBoxStatus } = options;
             if (status) {
                 this.setBoxStatus(box.id, status, skipUpdate);
                 box.setBoxStatus(status, skipUpdate);
@@ -1056,8 +1266,15 @@ export class TeleBoxManager {
                 box.setZIndex(zIndex, skipUpdate);
             }
             if (lastNotMinimizedBoxStatus) {
-                this.setLastNotMinimizedBoxStatus(box.id, lastNotMinimizedBoxStatus, skipUpdate);
-                box.setLastNotMinimizedBoxStatus(lastNotMinimizedBoxStatus, skipUpdate);
+                this.setLastNotMinimizedBoxStatus(
+                    box.id,
+                    lastNotMinimizedBoxStatus,
+                    skipUpdate
+                );
+                box.setLastNotMinimizedBoxStatus(
+                    lastNotMinimizedBoxStatus,
+                    skipUpdate
+                );
             }
             effectFunc && effectFunc();
         }
@@ -1077,12 +1294,16 @@ export class TeleBoxManager {
             deletedBoxes.forEach((box) => box.destroy());
             if (box && this.useBoxesStatus) {
                 this.setBoxStatus(box.id, undefined, skipUpdate);
-                this.setLastNotMinimizedBoxStatus(box.id, undefined, skipUpdate);
+                this.setLastNotMinimizedBoxStatus(
+                    box.id,
+                    undefined,
+                    skipUpdate
+                );
                 this.effectBoxStatusChange();
                 effectFunc && effectFunc();
             }
             if (!skipUpdate) {
-                if (this.boxes.length <= 0) {
+                if (this.boxes.length <= 0 && !this.forceMaximized) {
                     this.setMaximized(false);
                     this.setMinimized(false);
                 }
@@ -1107,7 +1328,7 @@ export class TeleBoxManager {
         this.boxesStatus$.clear();
         this.lastNotMinimizedBoxesStatus$.clear();
         if (!skipUpdate) {
-            if (this.boxes.length <= 0) {
+            if (this.boxes.length <= 0 && !this.forceMaximized) {
                 this.setMaximized(false);
                 this.setMinimized(false);
             }
@@ -1133,9 +1354,21 @@ export class TeleBoxManager {
         return `${this.namespace}-${className}`;
     }
 
+    private lazyFocusRequestHandler?: (boxId: string) => boolean;
+    private committedFocusDepth = 0;
+
+    public setLazyFocusRequestHandler(handler?: (boxId: string) => boolean): void {
+        this.lazyFocusRequestHandler = handler;
+    }
+
     public focusBox(boxOrID: string | TeleBox, skipUpdate = false): void {
         const targetBox = this.getBox(boxOrID);
         if (targetBox) {
+            if (
+                !skipUpdate &&
+                !this.committedFocusDepth &&
+                this.lazyFocusRequestHandler?.(targetBox.id)
+            ) return;
             this.boxes.forEach((box) => {
                 if (targetBox === box) {
                     let focusChanged = false;
@@ -1155,12 +1388,24 @@ export class TeleBoxManager {
             });
             if (!this.useBoxesStatus) {
                 this.maxTitleBar.focusBox(targetBox);
-            } else if (this.useBoxesStatus && this.maxTitleBar.hasMaximizedBoxInStatus()) {
+            } else if (
+                this.useBoxesStatus &&
+                this.maxTitleBar.hasMaximizedBoxInStatus()
+            ) {
                 this.makeMaximizedTopBoxFocus();
             }
         }
     }
 
+    public focusBoxCommitted(boxOrID: string | TeleBox, skipUpdate = false): void {
+        this.committedFocusDepth = (this.committedFocusDepth ?? 0) + 1;
+        try {
+            this.focusBox(boxOrID, skipUpdate);
+        } finally {
+            this.committedFocusDepth -= 1;
+        }
+    }
+
     public focusTopBox(): void {
         if (this.topBox && !this.topBox.focus) {
             return this.focusBox(this.topBox);
@@ -1262,11 +1507,18 @@ export class TeleBoxManager {
         if (config.footer != null) {
             box.mountFooter(config.footer);
         }
-        if (this.useBoxesStatus && (config.boxStatus || config.lastNotMinimizedBoxStatus)) {
-            this.setBox(box, {
-                status: config.boxStatus,
-                lastNotMinimizedBoxStatus: config.lastNotMinimizedBoxStatus
-            }, skipUpdate);
+        if (
+            this.useBoxesStatus &&
+            (config.boxStatus || config.lastNotMinimizedBoxStatus)
+        ) {
+            this.setBox(
+                box,
+                {
+                    status: config.boxStatus,
+                    lastNotMinimizedBoxStatus: config.lastNotMinimizedBoxStatus,
+                },
+                skipUpdate
+            );
         }
         if (config.forceTop != null) {
             box.setForceTop(config.forceTop, skipUpdate);
@@ -1288,7 +1540,8 @@ export class TeleBoxManager {
                     vx = forceTopBox.intrinsicX * this.containerRect.width + 20;
                     if (
                         vx >
-                        this.containerRect.width - width * this.containerRect.width
+                        this.containerRect.width -
+                            width * this.containerRect.width
                     ) {
                         vx = 20;
                     }
@@ -1303,9 +1556,21 @@ export class TeleBoxManager {
                 }
             } else if (this.hasMinimizedBox()) {
                 // 如果都最小化，则获取lastNotMinimizedBoxesStatus中normal box的最大x
-                vx = [...this.boxes].filter((box) => box.boxStatus && box.boxStatus === TELE_BOX_STATE.Minimized && box.lastNotMinimizedBoxStatus && box.lastNotMinimizedBoxStatus === TELE_BOX_STATE.Normal).reduce((maxX, box) => {
-                    return Math.max(maxX, box.intrinsicX * this.containerRect.width + 20);
-                }, vx);
+                vx = [...this.boxes]
+                    .filter(
+                        (box) =>
+                            box.boxStatus &&
+                            box.boxStatus === TELE_BOX_STATE.Minimized &&
+                            box.lastNotMinimizedBoxStatus &&
+                            box.lastNotMinimizedBoxStatus ===
+                                TELE_BOX_STATE.Normal
+                    )
+                    .reduce((maxX, box) => {
+                        return Math.max(
+                            maxX,
+                            box.intrinsicX * this.containerRect.width + 20
+                        );
+                    }, vx);
             }
             x = vx / this.containerRect.width;
         }
@@ -1315,7 +1580,8 @@ export class TeleBoxManager {
             if (config.forceTop) {
                 const forceTopBox = this.maxForceTopBox || this.topBox;
                 if (forceTopBox) {
-                    vy = forceTopBox.intrinsicY * this.containerRect.height + 20;
+                    vy =
+                        forceTopBox.intrinsicY * this.containerRect.height + 20;
 
                     if (
                         vy >
@@ -1337,9 +1603,21 @@ export class TeleBoxManager {
                 }
             } else if (this.hasMinimizedBox()) {
                 // 如果都最小化，则获取lastNotMinimizedBoxesStatus中normal box的最大y
-                vy = [...this.boxes].filter((box) => box.boxStatus && box.boxStatus === TELE_BOX_STATE.Minimized && box.lastNotMinimizedBoxStatus && box.lastNotMinimizedBoxStatus === TELE_BOX_STATE.Normal).reduce((maxY, box) => {
-                    return Math.max(maxY, box.intrinsicY * this.containerRect.height + 20);
-                }, vy);
+                vy = [...this.boxes]
+                    .filter(
+                        (box) =>
+                            box.boxStatus &&
+                            box.boxStatus === TELE_BOX_STATE.Minimized &&
+                            box.lastNotMinimizedBoxStatus &&
+                            box.lastNotMinimizedBoxStatus ===
+                                TELE_BOX_STATE.Normal
+                    )
+                    .reduce((maxY, box) => {
+                        return Math.max(
+                            maxY,
+                            box.intrinsicY * this.containerRect.height + 20
+                        );
+                    }, vy);
             }
 
             y = vy / this.containerRect.height;
@@ -1364,12 +1642,16 @@ export class TeleBoxManager {
         }
         let maximizedBox: MaxTitleBarTeleBox | undefined;
         if (this.maxTitleBar.hasMaximizedBoxInStatus()) {
-            maximizedBox = this.maxTitleBar.MaximizedBoxes.reduce((topBox, currentBox) => {
-                if (!topBox) {
-                    return currentBox;
+            maximizedBox = this.maxTitleBar.MaximizedBoxes.reduce(
+                (topBox, currentBox) => {
+                    if (!topBox) {
+                        return currentBox;
+                    }
+                    return topBox.zIndex > currentBox.zIndex
+                        ? topBox
+                        : currentBox;
                 }
-                return topBox.zIndex > currentBox.zIndex ? topBox : currentBox;
-            }, );
+            );
         }
         return maximizedBox;
     }
@@ -1378,7 +1660,8 @@ export class TeleBoxManager {
         if (!this.useBoxesStatus) {
             return;
         }
-        const maximizedBox: MaxTitleBarTeleBox | undefined = this.getMaximizedTopBox();
+        const maximizedBox: MaxTitleBarTeleBox | undefined =
+            this.getMaximizedTopBox();
         this.maxTitleBar.focusBox(maximizedBox);
     }
 
@@ -1394,15 +1677,15 @@ export class TeleBoxManager {
             : boxOrID;
     }
 
-    public createMinimizedAppMenu():AppMenu | undefined {
+    public createMinimizedAppMenu(): AppMenu | undefined {
         if (this.collector?.$appMenuContainer) {
             return new AppMenu({
                 manager: this,
                 container: this.collector?.$appMenuContainer,
-                theme: this.prefersColorScheme ? 'dark' : 'light',
+                theme: this.prefersColorScheme ? "dark" : "light",
                 getBoxesStatus: () => {
                     return this.boxesStatus$;
-                }
+                },
             });
         }
         return;