@gongxh/bit-ui 0.0.1 → 0.0.2

package/dist/bit-ui.mjs

@@ -1,6 +1,6 @@
-import { Screen, debug } from '@gongxh/bit-core';
-import { GComponent, UIObjectFactory, GGraph, UIPackage, GRoot } from 'fairygui-cc';
-import { Color, resources, assetManager, _decorator, Component } from 'cc';
+import { UIObjectFactory, UIPackage, GComponent, GRoot, GGraph } from 'fairygui-cc';
+import { debug, Screen, Module, Adapter } from '@gongxh/bit-core';
+import { assetManager, resources, Color, _decorator, Component, JsonAsset } from 'cc';
 
 /**
  * @Author: Gongxh
@@ -32,97 +32,20 @@ var AdapterType;
     /** 固定的 不适配 */
     AdapterType[AdapterType["Fixed"] = 2] = "Fixed";
 })(AdapterType || (AdapterType = {}));
-
-/**
- * @Author: Gongxh
- * @Date: 2025-01-11
- * @Description: 窗口顶边栏
- * 窗口顶边资源栏 同组中只会有一个显示
- */
-class UIHeader extends GComponent {
-    constructor() {
-        super(...arguments);
-        /** 窗口适配类型 */
-        this.adapterType = AdapterType.Full;
-        /** 引用计数 @internal */
-        this._refCount = 0;
-    }
-    onHide() {
-    }
-    onAdapted() {
-    }
-    /**
-     * 初始化 (内部方法)
-     * @internal
-     */
-    _init() {
-        this.onInit();
-    }
-    /**
-     * 窗口适配 (内部方法)
-     * @internal
-     */
-    _adapted() {
-        this.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
-        this.setPivot(0.5, 0.5, true);
-        switch (this.adapterType) {
-            case AdapterType.Full:
-                this.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
-                break;
-            case AdapterType.Bang:
-                this.setSize(Screen.SafeWidth, Screen.SafeHeight, true);
-                break;
-        }
-        this.onAdapted();
-    }
-    /**
-     * 显示 (内部方法)
-     * @param {IWindow} window 所属窗口
-     * @internal
-     */
-    _show(window) {
-        var _a;
-        this.visible = true;
-        this.onShow(window, (_a = window.getHeaderInfo()) === null || _a === void 0 ? void 0 : _a.userdata);
-    }
-    /**
-     * 隐藏 (内部方法)
-     * @internal
-     */
-    _hide() {
-        this.visible = false;
-        this.onHide();
-    }
-    /**
-     * 关闭 (内部方法)
-     * @internal
-     */
-    _close() {
-        this.onClose();
-        this.dispose();
-    }
-    /**
-     * 增加引用计数 (内部方法)
-     * @internal
-     */
-    _addRef() {
-        this._refCount++;
-    }
-    /**
-     * 减少引用计数 (内部方法)
-     * @internal
-     */
-    _decRef() {
-        return --this._refCount;
-    }
-    /**
-     * 屏幕大小改变时被调用 (内部方法)
-     * @internal
-     */
-    _screenResize() {
-        this._adapted();
-    }
-}
+/** 定义装饰器元数据的key */
+var MetadataKey;
+(function (MetadataKey) {
+    /** 属性 */
+    MetadataKey["prop"] = "__uipropmeta__";
+    /** 回调 */
+    MetadataKey["callback"] = "__uicbmeta__";
+    /** 控制器 */
+    MetadataKey["control"] = "__uicontrolmeta__";
+    /** 动画 */
+    MetadataKey["transition"] = "__uitransitionmeta__";
+    /** 原始名称 */
+    MetadataKey["originalName"] = "__UI_ORIGINAL_NAME__";
+})(MetadataKey || (MetadataKey = {}));
 
 /**
  * @Author: Gongxh
@@ -240,373 +163,1514 @@ PropsHelper._config = {};
 
 /**
  * @Author: Gongxh
- * @Date: 2024-12-26
- * @Description: 自定义组件扩展帮助类
+ * @Date: 2025-12-25
+ * @Description: 信息池 注册的窗口、header、自定义组件的信息
  */
-class ComponentExtendHelper {
-    static register() {
-        for (const { ctor, res } of _uidecorator.getComponentMaps().values()) {
-            const componentKey = `${res.pkg}/${res.name}`;
-            if (this._registeredComponents.has(componentKey)) {
-                console.debug(`自定义组件已注册，跳过  组件名:${res.name} 包名:${res.pkg}`);
-                continue;
+/** @internal */
+class InfoPool {
+    /**
+     * 添加窗口信息
+     * @param ctor 类的构造函数
+     * @param group 窗口组名
+     * @param pkg 包名
+     * @param name 窗口名
+     * @param bundleName bundle名
+     * @internal
+     */
+    static add(ctor, group, pkg, name, pkgs) {
+        if (this.has(name)) {
+            console.warn(`窗口【${name}】已注册，跳过，请检查是否重复注册`);
+            return;
+        }
+        debug(`窗口注册  窗口名:${name} 包名:${pkg} 组名:${group}`);
+        this._windowInfos.set(name, {
+            ctor: ctor,
+            group: group,
+            pkgName: pkg,
+            name: name
+        });
+        // 窗口组件扩展
+        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+        this.addWindowPkg(name, pkg);
+        if (pkgs.length > 0) {
+            for (const pkg of pkgs) {
+                this.addWindowPkg(name, pkg);
             }
-            console.debug(`自定义组件注册  组件名:${res.name} 包名:${res.pkg}`);
-            this.registerComponent(ctor, res.pkg, res.name);
-            this._registeredComponents.add(componentKey);
         }
     }
     /**
-     * 动态注册自定义组件
+     * 注册窗口header信息
+     * @param ctor 类的构造函数
+     * @param pkg 包名
+     * @param name 窗口名
+     * @param bundleName bundle名
+     * @internal
+     */
+    static addHeader(ctor, pkg, name) {
+        if (this.hasHeader(name)) {
+            console.warn(`header【${name}】已注册，跳过，请检查是否重复注册`);
+            return;
+        }
+        debug(`header注册  header名:${name} 包名:${pkg}`);
+        this._headerInfos.set(name, {
+            ctor: ctor,
+            pkgName: pkg
+        });
+        // 窗口header扩展
+        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    }
+    /**
+     * 注册自定义组件信息
      * @param ctor 组件构造函数
      * @param pkg 包名
      * @param name 组件名
+     * @internal
      */
-    static dynamicRegister(ctor, pkg, name) {
+    static addComponent(ctor, pkg, name) {
         const componentKey = `${pkg}/${name}`;
-        if (this._registeredComponents.has(componentKey)) {
-            console.debug(`自定义组件已注册，跳过  组件名:${name} 包名:${pkg}`);
+        if (this._customComponents.has(componentKey)) {
+            console.debug(`自定义组件【${name}】已注册，跳过，请检查是否重复注册`);
             return;
         }
         debug(`自定义组件注册  组件名:${name} 包名:${pkg}`);
+        this._customComponents.add(componentKey);
         this.registerComponent(ctor, pkg, name);
-        this._registeredComponents.add(componentKey);
     }
     /**
-     * 注册自定义组件信息
-     * @param info
+     * 是否存在窗口信息
+     * @param name 窗口名
+     * @returns 是否存在
      * @internal
      */
-    static registerComponent(ctor, pkg, name) {
-        // 自定义组件扩展
-        const onConstruct = function () {
-            PropsHelper.serializeProps(this, pkg, name);
-            this.onInit && this.onInit();
-        };
-        ctor.prototype.onConstruct = onConstruct;
-        // 自定义组件扩展
-        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    static has(name) {
+        return this._windowInfos.has(name);
     }
-}
-/** 已注册的组件集合 @internal */
-ComponentExtendHelper._registeredComponents = new Set();
-
-/**
- * @Author: Gongxh
- * @Date: 2024-12-07
- * @Description: 窗口管理类
- */
-class UIManager {
-    /** 配置UI包的一些信息 (可以不配置 完全手动管理) */
-    static initPackageConfig(res) {
-        this._resPool.initPackageConfig(res);
+    /**
+     * 获取窗口信息
+     * @param name 窗口名
+     * @returns 窗口信息
+     * @internal
+     */
+    static get(name) {
+        if (!this.has(name)) {
+            throw new Error(`窗口【${name}】未注册，请使用 _uidecorator.uiclass 注册窗口`);
+        }
+        return this._windowInfos.get(name);
     }
     /**
-     * 异步打开一个窗口 (如果UI包的资源未加载, 会自动加载 配合 UIManager.initPackageConfig一起使用)
-     * @param windowName 窗口名
-     * @param userdata 用户数据
+     * 是否存在窗口header信息
+     * @param name 窗口header名
+     * @returns 是否存在
+     * @internal
      */
-    static showWindow(windowName, userdata) {
-        return new Promise((resolve, reject) => {
-            this._resPool.loadWindowRes(windowName, {
-                complete: () => {
-                    this.showWindowIm(windowName, userdata);
-                    resolve();
-                },
-                fail: (pkgs) => {
-                    reject(pkgs);
-                }
-            });
-        });
+    static hasHeader(name) {
+        return this._headerInfos.has(name);
     }
     /**
-     * 显示指定名称的窗口，并传递可选的用户数据。(用于已加载过资源的窗口)
-     * @param windowName - 窗口的名称。
-     * @param userdata - 可选参数，用于传递给窗口的用户数据。
+     * 获取窗口header信息
+     * @param name 窗口header名
+     * @returns 窗口header信息
+     * @internal
      */
-    static showWindowIm(windowName, userdata) {
-        const info = this._resPool.get(windowName);
-        const windowGroup = this.getWindowGroup(info.group);
-        this._resPool.addResRef(windowName);
-        windowGroup.showWindow(info, userdata);
+    static getHeader(name) {
+        if (!this.hasHeader(name)) {
+            throw new Error(`窗口header【${name}】未注册，请使用 _uidecorator.uiheader 注册窗口header`);
+        }
+        return this._headerInfos.get(name);
     }
     /**
-     * 关闭窗口
-     * @param windowName 窗口名
+     * 设置UI包所在的bundle名
+     * @param pkg 包名
+     * @param bundleName bundle名
+     * @internal
      */
-    static closeWindow(windowName) {
-        if (!this._windows.has(windowName)) {
-            console.warn(`窗口不存在 ${windowName} 不需要关闭`);
+    static addBundleName(pkg, bundleName) {
+        if (this._customPackageBundle.has(pkg)) {
+            console.warn(`UI包【${pkg}】已设置过包名`);
             return;
         }
-        // 先在窗口组中移除
-        let info = this._resPool.get(windowName);
-        const windowGroup = this.getWindowGroup(info.group);
-        windowGroup._removeWindow(windowName);
-        // 窗口组中没有窗口了
-        if (windowGroup.size == 0) {
-            let index = this._queryGroupNames.indexOf(windowGroup.name);
-            if (index > 0 && windowGroup.name == this.getTopGroupName()) {
-                do {
-                    const groupName = this._queryGroupNames[--index];
-                    let group = this.getWindowGroup(groupName);
-                    if (group.size > 0) {
-                        this.getWindow(group.getTopWindowName())._recover();
-                        break;
-                    }
-                } while (index >= 0);
-            }
-        }
+        this._customPackageBundle.set(pkg, bundleName);
     }
     /**
-     * 关闭所有窗口
-     * @param ignoreNames 忽略关闭的窗口名
+     * 获取UI包所在的bundle名
+     * @param pkg 包名
+     * @returns bundle名
+     * @internal
      */
-    static closeAllWindow(ignoreNames = []) {
-        let existIgnore = ignoreNames.length > 0;
-        this._windows.forEach((window, name) => {
-            if (!existIgnore) {
-                this.closeWindow(name);
-            }
-            else if (!ignoreNames.includes(name)) {
-                this.closeWindow(name);
-            }
-        });
-        if (!existIgnore) {
-            this._windows.clear();
-        }
+    static getBundleName(pkg) {
+        return this._customPackageBundle.get(pkg) || "resources";
     }
     /**
-     * 获取当前最顶层的窗口实例。
-     * @template T - 窗口实例的类型，必须继承自 IWindow 接口。
-     * @returns {T | null} - 返回最顶层的窗口实例，如果没有找到则返回 null。
-     * @description 该方法会遍历所有窗口组，找到最顶层的窗口并返回其实例。
-     */
-    static getTopWindow() {
-        let len = this._queryGroupNames.length;
-        for (let i = len; i > 0;) {
-            let group = this.getWindowGroup(this._queryGroupNames[--i]);
-            if (group.size > 0) {
-                return this.getWindow(group.getTopWindowName());
-            }
+     * UI包所在的自定义路径
+     * @param pkg 包名
+     * @param path 路径
+     * @internal
+     */
+    static addPackagePath(pkg, path) {
+        if (this._customPackagePath.has(pkg)) {
+            console.warn(`UI包【${pkg}】已设置过自定义路径`);
+            return;
         }
-        return null;
+        this._customPackagePath.set(pkg, path);
     }
     /**
-     * 根据窗口名称获取窗口实例。
-     * @template T 窗口类型，必须继承自IWindow接口。
-     * @param name 窗口的名称。
-     * @returns 如果找到窗口，则返回对应类型的窗口实例；否则返回null。
+     * 获取UI包所在的路径
+     * @param pkg 包名
+     * @returns 路径
+     * @internal
      */
-    static getWindow(name) {
-        return this._windows.get(name);
+    static getPackagePath(pkg) {
+        return `${this._customPackagePath.get(pkg) || 'ui'}/${pkg}`;
     }
     /**
-     * 检查是否存在指定名称的窗口。
-     * @param name 窗口的名称。
-     * @returns 如果存在指定名称的窗口，则返回 true，否则返回 false。
+     * 添加窗口需要的包名
+     * @param windowName 窗口名
+     * @param pkg 包名
+     * @internal
      */
-    static hasWindow(name) {
-        return this._windows.has(name);
+    static addWindowPkg(windowName, pkg) {
+        this._dirty = true;
+        if (!this._windowPkgs.has(windowName)) {
+            this._windowPkgs.set(windowName, [pkg]);
+        }
+        else {
+            this._windowPkgs.get(windowName).push(pkg);
+        }
     }
     /**
-     * 根据给定的组名获取窗口组。如果组不存在，则抛出错误。
-     * @param groupName 窗口组的名称。
-     * @returns 返回找到的窗口组。
+     * 获取窗口需要的包名列表
+     * @param windowName 窗口名
+     * @returns 包名列表
+     * @internal
      */
-    static getWindowGroup(groupName) {
-        if (this._groups.has(groupName)) {
-            return this._groups.get(groupName);
+    static getWindowPkg(windowName) {
+        if (this._dirty) {
+            this.refreshWindowPackages();
+            this._dirty = false;
         }
-        throw new Error(`UIManager.getWindowGroup: window group 【${groupName}】 not found`);
+        return this._windowPkgs.get(windowName) || [];
     }
     /**
-     * 获取当前顶层窗口组的名称。
-     * 返回第一个包含至少一个窗口的窗口组名称。(该方法只检查不忽略查询的窗口组)
-     * 如果没有找到任何包含窗口的组，则返回空字符串。
+     * 添加手动管理资源加载 和 卸载的包名
+     * @param pkgName 包名
+     * @internal
      */
-    static getTopGroupName() {
-        let len = this._queryGroupNames.length;
-        for (let i = len - 1; i >= 0; i--) {
-            let name = this._queryGroupNames[i];
-            let group = this._groups.get(name);
-            if (group.size > 0) {
-                return name;
-            }
-        }
-        return "";
+    static addManualPackage(pkgName) {
+        this._dirty = true;
+        this._manualPackages.add(pkgName);
     }
     /**
-     * 初始化窗口管理器，设置资源池。 （框架内部使用）
-     * @param resPool - 窗口资源池实例。
+     * 注册自定义组件信息
+     * @param info
      * @internal
      */
-    static _init(resPool) {
-        this._resPool = resPool;
+    static registerComponent(ctor, pkg, name) {
+        // 自定义组件扩展
+        const onConstruct = function () {
+            PropsHelper.serializeProps(this, pkg, name);
+            this.onInit && this.onInit();
+        };
+        ctor.prototype.onConstruct = onConstruct;
+        // 自定义组件扩展
+        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    }
+    /** 刷新窗口需要的包名信息 */
+    static refreshWindowPackages() {
+        for (const packages of this._windowPkgs.values()) {
+            let len = packages.length;
+            for (let index = len - 1; index >= 0; index--) {
+                const name = packages[index];
+                if (this._manualPackages.has(name)) {
+                    packages.splice(index, 1);
+                }
+            }
+        }
     }
+}
+/** @internal */
+InfoPool._windowInfos = new Map(); // 窗口信息池 窗口名 -> 窗口信息
+/** @internal */
+InfoPool._headerInfos = new Map(); // 窗口header信息池 窗口header名 -> header信息
+/** @internal */
+InfoPool._customComponents = new Set(); // 自定义组件信息池 自定义组件名 -> 组件信息
+/** @internal */
+InfoPool._customPackageBundle = new Map(); // UI包所在的bundle名 1对1 默认: resources
+/** @internal */
+InfoPool._customPackagePath = new Map(); // 自定义UI包所在的路径 1对1
+/** @internal */
+InfoPool._windowPkgs = new Map(); // 窗口名对应的包名列表 窗口名 -> 包名列表
+/** @internal */
+InfoPool._manualPackages = new Set(); // 需要手动管理的资源包名
+/** @internal */
+InfoPool._dirty = true;
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-13
+ * @Description:
+ */
+/** @internal */
+class ResLoader {
     /**
-     * 向窗口管理器添加一个新窗口。 (框架内部使用)
-     * @param name 窗口的唯一标识符。
-     * @param window 要添加的窗口对象，需实现 IWindow 接口。
+     * 设置UI包加载相关回调函数
      * @internal
      */
-    static _addWindow(name, window) {
-        this._windows.set(name, window);
+    static setCallbacks(callbacks) {
+        this._showWaitWindow = callbacks.showWaitWindow;
+        this._hideWaitWindow = callbacks.hideWaitWindow;
+        this._onLoadFail = callbacks.fail;
+    }
+    /** @internal */
+    static setAutoRelease(auto) {
+        this.autoRelease = auto;
     }
     /**
-     * 移除指定名称的窗口。 (框架内部使用)
-     * @param name 窗口的名称。
+     * 增加等待窗的引用计数
      * @internal
      */
-    static _removeWindow(name) {
-        if (this.hasWindow(name)) {
-            this._windows.get(name)._close();
-            this._windows.delete(name);
-            this._resPool.releaseWindowRes(name);
+    static addWaitRef() {
+        var _a;
+        if (this.waitRef++ === 0) {
+            (_a = this._showWaitWindow) === null || _a === void 0 ? void 0 : _a.call(this);
         }
     }
     /**
-     * 注册所有UI窗口类到资源池中。 （框架内部使用）
-     * 该方法遍历所有通过_uidecorator.getWindowMaps()获取的窗口映射，
-     * 并将每个窗口的资源名称、构造函数、分组和包信息添加到资源池中。
+     * 减少等待窗的引用计数
      * @internal
      */
-    static registerUI() {
-        // 窗口注册
-        for (const { ctor, res } of _uidecorator.getWindowMaps().values()) {
-            debug(`窗口注册  窗口名:${res.name} 包名:${res.pkg} 组名:${res.group}`);
-            this._resPool.add(ctor, res.group, res.pkg, res.name, res.bundle);
-        }
-        // 窗口header注册
-        for (const { ctor, res } of _uidecorator.getHeaderMaps().values()) {
-            debug(`header注册  header名:${res.name} 包名:${res.pkg}`);
-            this._resPool.addHeader(ctor, res.pkg, res.name, res.bundle);
+    static decWaitRef() {
+        var _a;
+        if (--this.waitRef === 0) {
+            (_a = this._hideWaitWindow) === null || _a === void 0 ? void 0 : _a.call(this);
         }
-        // 组件注册
-        ComponentExtendHelper.register();
     }
-    /** 动态注册窗口到资源池中 */
-    static dynamicRegisterWindow(ctor, group, pkg, name, bundle) {
-        debug(`窗口注册  窗口名:${name} 包名:${pkg} 组名:${group}`);
-        this._resPool.add(ctor, group, pkg, name, bundle);
+    /** @internal */
+    static getRef(pkg) {
+        return this.pkgRefs.get(pkg) || 0;
     }
-    /** 动态注册窗口header到资源池中 */
-    static dynamicRegisterHeader(ctor, pkg, name, bundle) {
-        debug(`header注册  header名:${name} 包名:${pkg}`);
-        this._resPool.addHeader(ctor, pkg, name, bundle);
+    /** @internal */
+    static addRef(pkg) {
+        this.pkgRefs.set(pkg, this.getRef(pkg) + 1);
+    }
+    /** @internal */
+    static subRef(pkg) {
+        let ref = this.getRef(pkg) - 1;
+        this.pkgRefs.set(pkg, ref);
+        return ref;
     }
     /**
-     * 向窗口管理器添加一个窗口组 如果窗口组名称已存在，则抛出错误. (内部方法)
-     * @param group 要添加的窗口组
-     * @internal
+     * 加载窗口需要的包
+     * @param windowName 窗口名
      */
-    static _addWindowGroup(group) {
-        if (this._groups.has(group.name)) {
-            throw new Error(`UIManager._addWindowGroup: window group 【${group.name}】 already exists`);
+    static loadWindowRes(windowName) {
+        // 获取窗口需要的资源包
+        let packageNames = InfoPool.getWindowPkg(windowName);
+        if (packageNames.length <= 0) {
+            return Promise.resolve();
         }
-        this._groups.set(group.name, group);
-        // 不忽略查询 加到列表中
-        !group.isIgnore && this._queryGroupNames.push(group.name);
+        return this.loadUIPackages(packageNames, windowName);
     }
     /**
-     * 屏幕大小改变时 调用所有窗口的screenResize方法 (内部方法)
+     * 卸载窗口需要的包
+     * @param windowName 窗口名
+     */
+    static unloadWindowRes(windowName) {
+        // 获取窗口需要的资源包
+        let packageNames = InfoPool.getWindowPkg(windowName);
+        if (packageNames.length <= 0) {
+            return;
+        }
+        this.unloadUIPackages(packageNames);
+    }
+    /**
+     * 根据传入的UIPackage名称集合 加载多个UI包资源
+     * @param packages 包名列表
+     * @param windowName 窗口名（用于失败回调）
      * @internal
      */
-    static _screenResize() {
-        this._windows.forEach((window) => {
-            window.screenResize();
-        });
-        this._groups.forEach((group) => {
-            group._screenResize();
+    static loadUIPackages(packages, windowName) {
+        // 先找出来所有需要加载的包名
+        let list = packages.filter(pkg => this.getRef(pkg) <= 0);
+        if (list.length <= 0) {
+            // 增加引用计数
+            packages.forEach(pkg => this.addRef(pkg));
+            return Promise.resolve();
+        }
+        // 一定有需要加载的资源
+        this.addWaitRef();
+        // 获取包对应的bundle名
+        let bundleNames = list.map(pkg => InfoPool.getBundleName(pkg));
+        // 加载bundle
+        return this.loadBundles(bundleNames, windowName).then(() => {
+            // 顺序加载每个UI包
+            return this.loadUIPackagesSequentially(list, windowName);
+        }).then(() => {
+            // 所有包加载成功后，减少等待窗引用计数
+            this.decWaitRef();
+            // 增加包资源的引用计数
+            packages.forEach(pkg => this.addRef(pkg));
+        }).catch((err) => {
+            // 减少等待窗的引用计数
+            this.decWaitRef();
+            throw err;
         });
     }
     /**
-     * 获取资源池实例 (内部方法)
-     * @returns {WindowResPool} 资源池实例
+     * 加载多个bundle（顺序加载）
+     * @param bundleNames bundle名集合
+     * @param windowName 窗口名（用于失败回调）
      * @internal
      */
-    static _getResPool() {
-        return this._resPool;
+    static loadBundles(bundleNames, windowName) {
+        let unloadedBundleNames = bundleNames.filter(bundleName => bundleName !== "resources" && !assetManager.getBundle(bundleName));
+        if (unloadedBundleNames.length <= 0) {
+            return Promise.resolve();
+        }
+        // 递归方式实现顺序加载
+        const loadNext = (index) => {
+            if (index >= unloadedBundleNames.length) {
+                return Promise.resolve();
+            }
+            const bundleName = unloadedBundleNames[index];
+            return new Promise((resolve, reject) => {
+                assetManager.loadBundle(bundleName, (err, bundle) => {
+                    if (err) {
+                        // 调用失败回调
+                        if (this._onLoadFail) {
+                            this._onLoadFail(windowName, 1, bundleName);
+                        }
+                        reject(new Error(`bundle【${bundleName}】加载失败`));
+                    }
+                    else {
+                        resolve(null);
+                    }
+                });
+            }).then(() => {
+                // 加载下一个
+                return loadNext(index + 1);
+            });
+        };
+        return loadNext(0);
+    }
+    /**
+     * 顺序加载多个 UI 包
+     * @param packages 包名列表
+     * @param windowName 窗口名（用于失败回调）
+     * @internal
+     */
+    static loadUIPackagesSequentially(packages, windowName) {
+        // 递归方式实现顺序加载
+        const loadNext = (index) => {
+            if (index >= packages.length) {
+                return Promise.resolve();
+            }
+            const pkg = packages[index];
+            return this.loadSingleUIPackage(pkg, windowName).then(() => {
+                // 加载下一个
+                return loadNext(index + 1);
+            });
+        };
+        return loadNext(0);
+    }
+    /**
+     * 加载单个 UI 包
+     * @param pkg 包名
+     * @param windowName 窗口名（用于失败回调）
+     * @internal
+     */
+    static loadSingleUIPackage(pkg, windowName) {
+        return new Promise((resolve, reject) => {
+            let bundleName = InfoPool.getBundleName(pkg);
+            let bundle = bundleName === "resources" ? resources : assetManager.getBundle(bundleName);
+            UIPackage.loadPackage(bundle, InfoPool.getPackagePath(pkg), (err) => {
+                if (err) {
+                    // 调用失败回调
+                    if (windowName && this._onLoadFail) {
+                        this._onLoadFail(windowName, 2, pkg);
+                    }
+                    reject(new Error(`UI包【${pkg}】加载失败`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * 根据传入的UIPackage名称集合 卸载多个UI包资源
+     * @param pkgNames UIPackage名称集合
+     * @internal
+     */
+    static unloadUIPackages(packages) {
+        for (const pkg of packages) {
+            if (this.subRef(pkg) === 0 && this.autoRelease) {
+                UIPackage.removePackage(pkg);
+            }
+        }
+    }
+    /**
+     * 释放不再使用中的自动加载的UI资源
+     * 释放所有引用计数 <= 0 的UI资源
+     * @internal
+     */
+    static releaseUnusedRes() {
+        let keys = Array.from(this.pkgRefs.keys());
+        for (const key of keys) {
+            if (this.getRef(key) <= 0) {
+                UIPackage.removePackage(key);
+                this.pkgRefs.delete(key);
+            }
+        }
+    }
+}
+/**
+ * 等待窗口的引用计数
+ * 每次加载开始时 +1 每次加载完成时 -1
+ * @internal
+ */
+ResLoader.waitRef = 0;
+/** 包的引用计数 包名 -> 引用计数 */
+ResLoader.pkgRefs = new Map();
+/**
+ * 自动释放UI资源
+ * @internal
+ */
+ResLoader.autoRelease = true;
+/** UI包加载回调 - 显示加载等待窗 @internal */
+ResLoader._showWaitWindow = null;
+/** UI包加载回调 - 隐藏加载等待窗 @internal */
+ResLoader._hideWaitWindow = null;
+/** UI包加载回调 - 打开窗口时UI包加载失败 @internal */
+ResLoader._onLoadFail = null;
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 窗口管理类
+ */
+class WindowManager {
+    /** @internal */
+    static get bgAlpha() {
+        return this._bgAlpha;
+    }
+    /** @internal */
+    static set bgAlpha(value) {
+        this._bgAlpha = value;
+    }
+    /**
+     * 屏幕大小改变时 调用所有窗口的screenResize方法 (内部方法)
+     * @internal
+     */
+    static onScreenResize() {
+        // 半透明遮罩适配
+        if (this._alphaGraph) {
+            this._alphaGraph.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+            this._alphaGraph.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+        }
+        // 所有窗口适配
+        this._windows.forEach((window) => {
+            window._adapted();
+        });
+        // 所有header适配
+        HeaderManager.onScreenResize();
+    }
+    /**
+     * 添加手动管理资源加载 和 卸载的包名
+     * @param pkgName 包名
+     */
+    static addManualPackage(pkgName) {
+        InfoPool.addManualPackage(pkgName);
+    }
+    /**
+     * 提供一种特殊需求 用来手动设置包所在的 bundle名 以及包在bundle中的路径
+     * @param name 窗口名称
+     * @param bundleName bundle名 默认: resources
+     * @param path 包在bundle中的路径 默认: ui目录
+     */
+    static setPackageInfo(pkgName, bundleName = "resources", path = "ui") {
+        if (bundleName !== "resources") {
+            InfoPool.addBundleName(pkgName, bundleName);
+        }
+        if (path !== "ui") {
+            InfoPool.addPackagePath(pkgName, path);
+        }
+    }
+    /**
+     * 用于手动设置UI导出数据
+     * @param config UI导出数据
+     */
+    static setUIConfig(config) {
+        PropsHelper.setConfig(config);
+    }
+    /**
+     * 设置UI包加载相关回调函数
+     * @param callbacks 包含加载回调的对象
+     * @param callbacks.showWaitWindow 显示加载等待窗的回调
+     * @param callbacks.hideWaitWindow 隐藏加载等待窗的回调
+     * @param callbacks.fail 打开窗口时资源加载失败的回调 code( 1:bundle加载失败 2:包加载失败 )
+     */
+    static setPackageCallbacks(callbacks) {
+        ResLoader.setCallbacks(callbacks);
+    }
+    /**
+     * 向窗口管理器添加一个窗口组 如果窗口组名称已存在，则抛出错误. (内部方法)
+     * @param group 要添加的窗口组
+     * @internal
+     */
+    static addWindowGroup(group) {
+        if (this._groups.has(group.name)) {
+            throw new Error(`窗口组【${group.name}】已存在`);
+        }
+        this._groups.set(group.name, group);
+        this._groupNames.push(group.name);
+    }
+    /**
+     * 设置半透明遮罩
+     * @param alphaGraph 半透明遮罩
+     * @internal
+     */
+    static setAlphaGraph(alphaGraph) {
+        this._alphaGraph = alphaGraph;
+    }
+    /**
+     * 异步打开一个窗口 (如果UI包的资源未加载, 会自动加载 可以配合 WindowManager.setPackageCallbacks一起使用)
+     * @param 窗口类
+     * @param userdata 用户数据
+     */
+    static showWindow(window, userdata) {
+        // 优先使用装饰器设置的静态属性，避免代码混淆后 constructor.name 变化
+        const name = window[MetadataKey.originalName];
+        if (!name) {
+            throw new Error(`窗口【${window.name}】未注册，请使用 _uidecorator.uiclass 注册窗口`);
+        }
+        return this.showWindowByName(name, userdata);
+    }
+    /**
+     * 通过窗口名称打开一个窗口
+     * @param name 窗口名称
+     * @param userdata 用户数据
+     * @internal
+     */
+    static showWindowByName(name, userdata) {
+        // 找到他所属的窗口组
+        const info = InfoPool.get(name);
+        const group = this.getWindowGroup(info.group);
+        return group.showWindow(info, userdata);
+    }
+    /**
+     * 关闭一个窗口
+     * @param ctor 窗口类
+     */
+    static closeWindow(window) {
+        // 取到窗口的名称，优先使用装饰器设置的静态属性
+        const name = window[MetadataKey.originalName];
+        this.closeWindowByName(name);
+    }
+    /**
+     * 通过窗口名称关闭一个窗口
+     * @param name 窗口名称
+     */
+    static closeWindowByName(name) {
+        if (!this.hasWindow(name)) {
+            console.warn(`窗口不存在 ${name} 不需要关闭`);
+            return;
+        }
+        const info = InfoPool.get(name);
+        const group = this.getWindowGroup(info.group);
+        group.removeWindow(name);
+        // 调整半透明遮罩
+        this.adjustAlphaGraph();
+        // 找到最上层的窗口 调用toTop方法
+        let topWindow = this.getTopWindow();
+        if (topWindow && !topWindow.isTop()) {
+            topWindow._toTop();
+        }
+    }
+    /**
+     * 是否存在窗口
+     * @param name 窗口名称
+     */
+    static hasWindow(name) {
+        return this._windows.has(name);
+    }
+    /**
+     * 添加窗口
+     * @param name 窗口名称
+     * @param window 要添加的窗口对象，需实现 IWindow 接口。
+     * @internal
+     */
+    static addWindow(name, window) {
+        this._windows.set(name, window);
+    }
+    /**
+     * 移除窗口
+     * @param name 窗口名称
+     * @internal
+     */
+    static removeWindow(name) {
+        this._windows.delete(name);
+    }
+    /**
+     * 根据窗口名称获取窗口实例。
+     * @template T 窗口类型，必须继承自IWindow接口。
+     * @param name 窗口名称
+     * @returns 如果找到窗口，则返回对应类型的窗口实例；否则返回null。
+     */
+    static getWindow(name) {
+        return this._windows.get(name);
+    }
+    /**
+     * 获取当前最顶层的窗口实例。
+     * 默认会忽略掉忽略查询的窗口组
+     * @returns {T | null} - 返回最顶层的窗口实例，如果没有找到则返回 null。
+     */
+    static getTopWindow(isAll = true) {
+        const names = this._groupNames;
+        for (let i = names.length - 1; i >= 0; i--) {
+            const group = this.getWindowGroup(names[i]);
+            if (group.isIgnore && !isAll) {
+                continue;
+            }
+            if (group.size === 0) {
+                continue;
+            }
+            return group.getTopWindow();
+        }
+        return null;
+    }
+    /**
+     * 获取所有窗口组的名称列表（按层级顺序）
+     * @returns 窗口组的名称列表
+     */
+    static getGroupNames() {
+        return this._groupNames;
+    }
+    /**
+     * 根据给定的组名获取窗口组。如果组不存在，则抛出错误。
+     * @param name 窗口组名称
+     * @returns 返回找到的窗口组。
+     */
+    static getWindowGroup(name) {
+        if (this._groups.has(name)) {
+            return this._groups.get(name);
+        }
+        throw new Error(`窗口组【${name}】不存在`);
+    }
+    /**
+     * 关闭所有窗口
+     * @param ignores 不关闭的窗口
+     */
+    static closeAllWindow(ignores = []) {
+        let len = this._groupNames.length;
+        for (let i = len - 1; i >= 0; i--) {
+            let group = this.getWindowGroup(this._groupNames[i]);
+            group.closeAllWindow(ignores);
+        }
+        // 找到最上层的窗口 调用toTop方法
+        let topWindow = this.getTopWindow();
+        if (topWindow && !topWindow.isTop()) {
+            topWindow._toTop();
+        }
+    }
+    /**
+     * 调整半透明遮罩的显示层级
+     * 从上到下（从所有窗口组）查找第一个bgAlpha不为0的窗口，将遮罩放到该窗口下方
+     * @internal
+     */
+    static adjustAlphaGraph() {
+        let topWindow = null;
+        // 从后往前遍历窗口组（后面的窗口组层级更高）
+        for (let i = this._groupNames.length - 1; i >= 0; i--) {
+            const group = this._groups.get(this._groupNames[i]);
+            if (group.size === 0) {
+                continue;
+            }
+            // 在当前窗口组中从上到下查找第一个bgAlpha不为0的窗口
+            for (let j = group.windowNames.length - 1; j >= 0; j--) {
+                const name = group.windowNames[j];
+                const win = WindowManager.getWindow(name);
+                if (win.bgAlpha > 0) {
+                    topWindow = win;
+                    break;
+                }
+            }
+            if (topWindow) {
+                break;
+            }
+        }
+        // 如果找到了需要遮罩的窗口
+        if (topWindow) {
+            // 获取窗口组的根节点
+            const parent = topWindow.parent;
+            // 将遮罩设置到目标窗口的下方
+            const windowIndex = parent.getChildIndex(topWindow);
+            let gIndex = 0;
+            // 确保遮罩在目标窗口组的根节点下
+            if (this._alphaGraph.parent !== parent) {
+                this._alphaGraph.removeFromParent();
+                parent.addChild(this._alphaGraph);
+                gIndex = parent.numChildren - 1;
+            }
+            else {
+                gIndex = parent.getChildIndex(this._alphaGraph);
+            }
+            let newIndex = gIndex >= windowIndex ? windowIndex : windowIndex - 1;
+            parent.setChildIndex(this._alphaGraph, newIndex);
+            // 显示遮罩
+            this._alphaGraph.visible = true;
+            // 半透明遮罩绘制
+            this._bgColor.a = topWindow.bgAlpha * 255;
+            this._alphaGraph.clearGraphics();
+            this._alphaGraph.drawRect(0, this._bgColor, this._bgColor);
+        }
+        else {
+            // 没有找到需要遮罩的窗口，隐藏遮罩
+            this._alphaGraph.visible = false;
+        }
+    }
+    /**
+     * 释放不再使用中的自动加载的UI资源
+     * 针对在 UIModule 中设置了不自动释放资源的场景
+     */
+    static releaseUnusedRes() {
+        ResLoader.releaseUnusedRes();
+    }
+}
+WindowManager._bgAlpha = 0.75;
+WindowManager._bgColor = new Color(0, 0, 0, 0);
+/** @internal */
+WindowManager._alphaGraph = null; // 半透明的遮罩
+/** @internal */
+WindowManager._groups = new Map(); // 窗口组
+/** @internal */
+WindowManager._groupNames = []; // 窗口组的名称列表
+/** @internal */
+WindowManager._windows = new Map(); // 所有窗口的引用
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-12-29
+ * @Description: header(资源栏)管理类
+ */
+class HeaderManager {
+    /**
+     * 屏幕适配
+     * @internal
+     */
+    static onScreenResize() {
+        for (const header of this._headers.values()) {
+            header._adapted();
+        }
+    }
+    /**
+     * 为窗口请求一个header
+     * @param windowName 窗口名
+     * @param headerInfo header信息
+     */
+    static requestHeader(windowName, headerInfo) {
+        // 保存header的信息
+        if (!headerInfo) {
+            return;
+        }
+        this._headerInfos.set(windowName, headerInfo);
+        const headerName = headerInfo.name;
+        // 如果header不存在，创建它
+        if (!this._headers.has(headerName)) {
+            const header = this.createHeader(headerInfo);
+            this._headers.set(headerName, header);
+            this._refCounts.set(headerName, 0);
+            this._headerWindowsMap.set(headerName, new Set());
+        }
+        // 增加引用计数
+        this._refCounts.set(headerName, this._refCounts.get(headerName) + 1);
+        // 记录窗口和header的关系
+        this._headerWindowsMap.get(headerName).add(windowName);
+    }
+    /**
+     * 显示指定窗口的header
+     * @param windowName 窗口名
+     * @param fromHide 窗口是否从隐藏状态恢复显示
+     */
+    static showHeader(windowName) {
+        if (!this.hasHeader(windowName)) {
+            return;
+        }
+        const headerName = this.getHeaderName(windowName);
+        const header = this.getHeader(headerName);
+        // 更新最上层窗口（智能判断，只在必要时重新计算）
+        this.updateTopWindow(headerName, windowName, true);
+        // 只有当前窗口是最上层时才显示
+        const currentTopWindow = this._cacheHeaderTopWindow.get(headerName);
+        if (currentTopWindow === windowName) {
+            header._show(this.getHeaderUserData(windowName));
+        }
+    }
+    /**
+     * 隐藏指定窗口的header
+     * @param windowName 窗口名
+     */
+    static hideHeader(windowName) {
+        if (!this.hasHeader(windowName)) {
+            return;
+        }
+        const headerName = this.getHeaderName(windowName);
+        const header = this.getHeader(headerName);
+        // 更新最上层窗口（会自动处理切换逻辑）
+        this.updateTopWindow(headerName, windowName, false);
+        // 如果切换到了新的窗口，传递新的userdata0
+        if (this._cacheHeaderTopWindow.has(headerName)) {
+            const newTopWindowName = this._cacheHeaderTopWindow.get(headerName);
+            header._show(this.getHeaderUserData(newTopWindowName));
+        }
+        else if (header.isShowing()) {
+            header._hide();
+        }
+    }
+    /**
+     * 释放窗口的header（减少引用计数）
+     * @param windowName 窗口名
+     */
+    static releaseHeader(windowName) {
+        if (!this.hasHeader(windowName)) {
+            return;
+        }
+        const headerName = this.getHeaderName(windowName);
+        // 减少引用计数
+        const refCount = this._refCounts.get(headerName) - 1;
+        // 移除映射关系
+        this._headerWindowsMap.get(headerName).delete(windowName);
+        // 清除窗口的header信息
+        this._headerInfos.delete(windowName);
+        const header = this.getHeader(headerName);
+        // 如果引用计数为0，销毁header
+        if (refCount === 0) {
+            header._close();
+            this._headers.delete(headerName);
+            this._refCounts.delete(headerName);
+            this._headerWindowsMap.delete(headerName);
+            this._cacheHeaderTopWindow.delete(headerName);
+        }
+        else {
+            // 更新引用计数
+            this._refCounts.set(headerName, refCount);
+            // 查找新的最上层窗口 并显示
+            const newTopWindowName = this.findTopWindowForHeader(headerName, windowName);
+            if (newTopWindowName) {
+                this._cacheHeaderTopWindow.set(headerName, newTopWindowName);
+                this.adjustHeaderPosition(headerName, newTopWindowName);
+                header._show(this.getHeaderUserData(newTopWindowName));
+            }
+            else {
+                // 没找到需要显示的 隐藏掉
+                this._cacheHeaderTopWindow.delete(headerName);
+                header.isShowing() && header._hide();
+            }
+        }
+    }
+    /**
+     * 获取窗口关联的header
+     * @param windowName 窗口名
+     * @returns header实例，如果没有则返回null
+     */
+    static getHeaderByWindow(windowName) {
+        if (!this.hasHeader(windowName)) {
+            return null;
+        }
+        const headerName = this.getHeaderName(windowName);
+        return this._headers.get(headerName) || null;
+    }
+    /**
+     * 刷新窗口的header
+     * 如果新的header和旧的header不是同一个，先释放旧的，再创建新的
+     * 如果是同一个，更新userdata并重新显示
+     * @param windowName 窗口名
+     * @param newHeaderInfo 新的header信息
+     */
+    static refreshWindowHeader(windowName, newHeaderInfo) {
+        const oldHeaderName = this.getHeaderName(windowName);
+        const newHeaderName = newHeaderInfo === null || newHeaderInfo === void 0 ? void 0 : newHeaderInfo.name;
+        // 情况1：新旧 header 名称相同，只需要更新 userdata 并重新显示
+        if (oldHeaderName === newHeaderName) {
+            if (newHeaderInfo) {
+                // 更新保存的 userdata
+                this._headerInfos.set(windowName, newHeaderInfo);
+                // 重新显示 header（如果当前窗口是最上层）
+                const currentTopWindow = this._cacheHeaderTopWindow.get(newHeaderName);
+                if (currentTopWindow === windowName) {
+                    const header = this.getHeader(newHeaderName);
+                    header._show(newHeaderInfo.userdata);
+                }
+            }
+            return;
+        }
+        // 情况2：header 名称不同，先释放旧的，再创建新的
+        // 释放旧的 header
+        if (oldHeaderName) {
+            this.releaseHeader(windowName);
+        }
+        // 请求新的 header 并显示
+        if (newHeaderInfo) {
+            this.requestHeader(windowName, newHeaderInfo);
+            this.showHeader(windowName);
+        }
+    }
+    static createHeader(headerInfo) {
+        // 创建header实例
+        const info = InfoPool.getHeader(headerInfo.name);
+        const header = UIPackage.createObject(info.pkgName, headerInfo.name);
+        header.name = headerInfo.name;
+        PropsHelper.serializeProps(header, info.pkgName);
+        header._init();
+        header._adapted();
+        return header;
+    }
+    /**
+     * 获取窗口记录的header userdata
+     * @internal
+     */
+    static getHeaderUserData(windowName) {
+        var _a;
+        return (_a = this._headerInfos.get(windowName)) === null || _a === void 0 ? void 0 : _a.userdata;
+    }
+    /**
+     * 根据窗口名字获取header名称
+     * @internal
+     */
+    static getHeaderName(windowName) {
+        var _a;
+        return (_a = this._headerInfos.get(windowName)) === null || _a === void 0 ? void 0 : _a.name;
+    }
+    /**
+     * 窗口上是否存在header
+     * @internal
+     */
+    static hasHeader(windowName) {
+        return this._headerInfos.has(windowName);
+    }
+    /** 通过名称直接获取header实例 */
+    static getHeader(name) {
+        return this._headers.get(name);
+    }
+    /**
+     * 更新header的最上层窗口（智能判断是否需要重新计算）
+     * @internal
+     */
+    static updateTopWindow(headerName, changedWindowName, isShowing) {
+        // 记录的最上层窗口名
+        const topWindowName = this._cacheHeaderTopWindow.get(headerName);
+        if (isShowing) {
+            // 情况1：新窗口显示，且它在更高层级
+            if (!topWindowName || this.isWindowAbove(changedWindowName, topWindowName)) {
+                // 新窗口更靠上, 调整header位置并缓存
+                this._cacheHeaderTopWindow.set(headerName, changedWindowName);
+                this.adjustHeaderPosition(headerName, changedWindowName);
+                return;
+            }
+        }
+        else if (topWindowName === changedWindowName) {
+            // 最上层的窗口需要隐藏, 查找新的最上层窗口
+            const newTopWindowName = this.findTopWindowForHeader(headerName, changedWindowName);
+            if (newTopWindowName) {
+                this._cacheHeaderTopWindow.set(headerName, newTopWindowName);
+                this.adjustHeaderPosition(headerName, newTopWindowName);
+            }
+            else {
+                this._cacheHeaderTopWindow.delete(headerName);
+                const header = this.getHeader(headerName);
+                if (header && header.isShowing()) {
+                    header._hide();
+                }
+            }
+        }
+    }
+    /**
+     * 判断窗口A是否在窗口B的上层 (如果是同一个窗口，返回false)
+     * @internal
+     */
+    static isWindowAbove(windowA, windowB) {
+        if (windowA === windowB) {
+            return false;
+        }
+        const infoA = InfoPool.get(windowA);
+        const infoB = InfoPool.get(windowB);
+        // 先比较窗口组
+        const groupNames = WindowManager.getGroupNames();
+        const groupIndexA = groupNames.indexOf(infoA.group);
+        const groupIndexB = groupNames.indexOf(infoB.group);
+        if (groupIndexA !== groupIndexB) {
+            return groupIndexA > groupIndexB;
+        }
+        // 同一个组，比较窗口在组内的位置
+        const group = WindowManager.getWindowGroup(infoA.group);
+        const indexA = group.windowNames.indexOf(windowA);
+        const indexB = group.windowNames.indexOf(windowB);
+        return indexA > indexB;
+    }
+    /**
+     * 为header查找新的最上层窗口（排除指定窗口）
+     * @internal
+     */
+    static findTopWindowForHeader(headerName, excludeWindow) {
+        const windowNames = this._headerWindowsMap.get(headerName);
+        if (!windowNames || windowNames.size === 0) {
+            return null;
+        }
+        // 从上到下遍历窗口组
+        const groupNames = WindowManager.getGroupNames();
+        for (let i = groupNames.length - 1; i >= 0; i--) {
+            // 从上到下遍历组内窗口
+            const group = WindowManager.getWindowGroup(groupNames[i]);
+            for (let j = group.windowNames.length - 1; j >= 0; j--) {
+                const wName = group.windowNames[j];
+                if (wName === excludeWindow) {
+                    continue;
+                }
+                if (!windowNames.has(wName)) {
+                    continue;
+                }
+                const win = WindowManager.getWindow(wName);
+                if (win && win.isShowing()) {
+                    return wName; // 找到就返回，不继续遍历
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 调整header到指定窗口的位置
+     * @internal
+     */
+    static adjustHeaderPosition(headerName, windowName) {
+        const header = this._headers.get(headerName);
+        const window = WindowManager.getWindow(windowName);
+        const info = InfoPool.get(windowName);
+        const group = WindowManager.getWindowGroup(info.group);
+        const parent = group.root;
+        // 移动header到对应的group
+        if (header.parent !== parent) {
+            header.removeFromParent();
+            parent.addChild(header);
+        }
+        // 调整层级：找到该组中最上层的显示窗口
+        let maxWindowIndex = parent.getChildIndex(window);
+        for (let i = group.windowNames.length - 1; i >= 0; i--) {
+            const win = WindowManager.getWindow(group.windowNames[i]);
+            if (win && win.isShowing()) {
+                maxWindowIndex = Math.max(maxWindowIndex, parent.getChildIndex(win));
+            }
+        }
+        parent.setChildIndex(header, maxWindowIndex + 1);
+    }
+}
+/** @internal */
+HeaderManager._headers = new Map(); // header名 > header实例
+/** @internal */
+HeaderManager._refCounts = new Map(); // header名 > 引用计数
+/** @internal */
+HeaderManager._headerWindowsMap = new Map(); // header名 > 窗口名列表
+/** @internal */
+HeaderManager._headerInfos = new Map(); // 窗口名 > header的数据
+/** @internal */
+HeaderManager._cacheHeaderTopWindow = new Map(); // header名 > 缓存的当前显示该header的最上层窗口名
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 窗口组 (在同一个窗口容器的上的窗口)
+ */
+class WindowGroup {
+    /**
+     * 获取窗口组的名称。
+     * @returns {string} 窗口组的名称。
+     */
+    get name() { return this._name; }
+    /** 获取窗口组的根节点 */
+    get root() { return this._root; }
+    /**
+     * 获取当前窗口组中窗口的数量。
+     * @returns 窗口数量
+     */
+    get size() { return this._windowNames.length; }
+    /** 获取窗口组中窗口的名称列表 */
+    get windowNames() { return this._windowNames; }
+    /**
+     * 获取是否忽略查询的状态。
+     * @returns {boolean} 如果忽略查询，则返回 true，否则返回 false。
+     */
+    get isIgnore() { return this._ignore; }
+    /**
+     * 实例化
+     * @param name 组名
+     * @param root 窗口组的根节点 一个fgui的组件
+     * @param ignoreQuery 是否忽略顶部窗口查询
+     * @param swallowTouch 是否吞掉触摸事件
+     * @param bgAlpha 半透明遮罩的透明度
+     * @internal
+     */
+    constructor(name, root, ignoreQuery, swallowTouch) {
+        /** @internal */
+        this._name = ""; // 窗口组的名字
+        /** @internal */
+        this._ignore = false; // 忽略查询
+        /** @internal */
+        this._swallowTouch = false; // 吞噬触摸事件
+        /** @internal */
+        this._windowNames = []; // 窗口名列表 顺序为窗口显示的层级 (最后一个显示在最上层)
+        this._name = name;
+        this._root = root;
+        this._ignore = ignoreQuery;
+        this._swallowTouch = swallowTouch;
+        this._windowNames = [];
+    }
+    /**
+     * 显示一个窗口
+     * @param info 窗口信息
+     * @param userdata
+     * @internal
+     */
+    showWindow(info, userdata) {
+        return new Promise((resolve, reject) => {
+            let lastTopWindow = WindowManager.getTopWindow();
+            if (WindowManager.hasWindow(info.name)) {
+                const window = WindowManager.getWindow(info.name);
+                this.showAdjustment(window, userdata);
+                if (lastTopWindow && lastTopWindow.name !== window.name) {
+                    lastTopWindow._toBottom();
+                }
+                window._toTop();
+                resolve(window);
+            }
+            else {
+                ResLoader.loadWindowRes(info.name).then(() => {
+                    const window = this.createWindow(info.pkgName, info.name);
+                    this.showAdjustment(window, userdata);
+                    if (lastTopWindow && lastTopWindow.name !== window.name) {
+                        lastTopWindow._toBottom();
+                    }
+                    resolve(window);
+                }).catch((err) => {
+                    reject(new Error(`窗口【${info.name}】打开失败: ${err.message}`));
+                });
+            }
+        });
+    }
+    /**
+     * show一个界面后的调整
+     * @param window
+     * @internal
+     */
+    showAdjustment(window, userdata) {
+        // 如果窗口不在最上层 则调整层级
+        this.moveWindowToTop(window);
+        // 显示窗口
+        window._show(userdata);
+        // 尝试显示header
+        HeaderManager.showHeader(window.name);
+        // 调整半透明遮罩
+        WindowManager.adjustAlphaGraph();
+    }
+    /**
+     * 将指定名称的窗口移动到窗口组的最顶层。
+     * @param name 窗口的名称。
+     * @internal
+     */
+    moveWindowToTop(window) {
+        if (window.name !== this._windowNames[this.size - 1]) {
+            const index = this._windowNames.indexOf(window.name);
+            if (index < 0) {
+                console.error(`[BUG] 窗口【${window.name}】不在数组中，数据结构已损坏`);
+                return;
+            }
+            this._windowNames.splice(index, 1);
+            // 放到数组的末尾
+            this._windowNames.push(window.name);
+        }
+        // 根据窗口的type, 处理上一个窗口的关闭状态
+        this._processWindowCloseStatus(window);
+        // 调整窗口的显示层级
+        window.setDepth(this._root.numChildren - 1);
+        // 处理窗口显示和隐藏状态
+        this.processWindowHideStatus(this.size - 1);
+    }
+    /**
+     * 根据窗口名创建窗口 并添加到显示节点
+     * @param windowName 窗口名
+     * @internal
+     */
+    createWindow(pkg, name) {
+        let window = UIPackage.createObject(pkg, name);
+        window.name = name;
+        PropsHelper.serializeProps(window, pkg);
+        window._init(this._swallowTouch);
+        window._adapted();
+        // 添加到显示节点
+        this._root.addChild(window);
+        // 窗口组之前没有窗口, 显示窗口组节点
+        if (this.size === 0) {
+            this._root.visible = true;
+        }
+        this._windowNames.push(name);
+        WindowManager.addWindow(name, window);
+        // 处理header（只请求，不立即添加到节点，由adjustHeaderDepth动态管理）
+        HeaderManager.requestHeader(name, window.getHeaderInfo());
+        return window;
+    }
+    /**
+     * 处理index下层窗口的隐藏状态的私有方法。递归调用
+     * @param index - 窗口索引
+     */
+    processWindowHideStatus(startIndex) {
+        let curWindow = WindowManager.getWindow(this._windowNames[startIndex]);
+        // 如果当前是当前组中的最后一个窗口并且当前窗口是隐藏状态 则恢复隐藏
+        if (curWindow && startIndex == this.size - 1 && !curWindow.isShowing()) {
+            curWindow._showFromHide();
+            // 恢复显示header
+            HeaderManager.showHeader(curWindow.name);
+        }
+        // 已经是最后一个了
+        if (startIndex <= 0) {
+            return;
+        }
+        // 遍历到倒数第二个窗口停止
+        for (let index = startIndex; index > 0; index--) {
+            let window = WindowManager.getWindow(this._windowNames[index]);
+            if (!window) {
+                console.error(`[BUG] 窗口【${this._windowNames[index]}】不存在，数据结构已损坏`);
+                return;
+            }
+            if (window.type === WindowType.HideAll) {
+                // 隐藏所有
+                for (let i = index - 1; i >= 0; i--) {
+                    let name = this._windowNames[i];
+                    const window = WindowManager.getWindow(name);
+                    if (window && window.isShowing()) {
+                        window._hide();
+                        // 隐藏header
+                        HeaderManager.hideHeader(name);
+                    }
+                }
+                break;
+            }
+            else if (window.type === WindowType.HideOne) {
+                // 隐藏前一个窗口
+                let prevWindowName = this._windowNames[index - 1];
+                let prevWindow = WindowManager.getWindow(prevWindowName);
+                if (prevWindow && prevWindow.isShowing()) {
+                    prevWindow._hide();
+                    // 隐藏header
+                    HeaderManager.hideHeader(prevWindowName);
+                }
+            }
+            else {
+                // 如果前一个窗口是隐藏状态 需要恢复显示
+                let prevWindowName = this._windowNames[index - 1];
+                let prevWindow = WindowManager.getWindow(prevWindowName);
+                if (prevWindow && !prevWindow.isShowing()) {
+                    prevWindow._showFromHide();
+                    // 恢复显示header（使用记录的userdata）
+                    HeaderManager.showHeader(prevWindowName);
+                }
+            }
+        }
+    }
+    /**
+     * 根据传入窗口的关闭类型, 处理上一个窗口或者所有窗口的关闭
+     * @param window 新创建的窗口
+     * @internal
+     */
+    _processWindowCloseStatus(window) {
+        // 最后一个是新显示上来的窗口
+        if (window.type === WindowType.CloseOne) {
+            // 关闭上一个窗口（倒数第二个，因为最后一个是当前窗口）
+            if (this.size <= 1) {
+                return;
+            }
+            const name = this._windowNames[this.size - 2];
+            this._windowNames.splice(this.size - 2, 1);
+            const win = WindowManager.getWindow(name);
+            if (!win) {
+                console.error(`[BUG] 窗口【${name}】不存在，数据结构已损坏`);
+                return;
+            }
+            // 释放header
+            HeaderManager.releaseHeader(name);
+            win._close();
+            WindowManager.removeWindow(name);
+        }
+        else if (window.type === WindowType.CloseAll) {
+            // 关闭所有窗口 从后向前依次删除
+            for (let i = this.size - 2; i >= 0; i--) {
+                const name = this._windowNames[i];
+                const win = WindowManager.getWindow(name);
+                if (!win) {
+                    console.error(`[BUG] 窗口【${name}】不存在，数据结构已损坏`);
+                    return;
+                }
+                // 释放header
+                HeaderManager.releaseHeader(name);
+                win._close();
+                WindowManager.removeWindow(name);
+            }
+            // 清理数组，只保留最后一个（当前窗口）
+            this._windowNames.splice(0, this.size - 1);
+        }
+    }
+    /**
+     * 移除指定名称的窗口。
+     * @param name 窗口的名称。
+     * @internal
+     */
+    removeWindow(name) {
+        let window = WindowManager.getWindow(name);
+        if (!window) {
+            console.error(`[BUG] 窗口【${name}】不存在，数据结构已损坏`);
+            return;
+        }
+        // 释放header引用
+        HeaderManager.releaseHeader(name);
+        window._close();
+        // 先删除窗口组中记录的窗口名称
+        let index = this._windowNames.lastIndexOf(name);
+        if (index < 0) {
+            console.error(`[BUG] 窗口【${name}】不在数组中，数据结构已损坏`);
+            return;
+        }
+        this._windowNames.splice(index, 1);
+        // 删除WindowManager中记录的窗口
+        WindowManager.removeWindow(name);
+        // 释放资源
+        ResLoader.unloadWindowRes(name);
+        if (this.size == 0) {
+            this._root.visible = false;
+        }
+        else {
+            this.processWindowHideStatus(this.size - 1);
+        }
+    }
+    hasWindow(name) {
+        return this._windowNames.indexOf(name) >= 0;
+    }
+    /**
+     * 获取窗口组顶部窗口实例
+     * @returns {IWindow} 顶部窗口实例
+     */
+    getTopWindow() {
+        if (this.size > 0) {
+            return WindowManager.getWindow(this._windowNames[this.size - 1]);
+        }
+        console.warn(`窗口组【${this._name}】中不存在窗口`);
+        return null;
+    }
+    /**
+     * 关闭窗口组中的所有窗口
+     * @param ignores 不关闭的窗口名
+     * @internal
+     */
+    closeAllWindow(ignores = []) {
+        let len = this.size - 1;
+        for (let i = len; i >= 0; i--) {
+            let name = this._windowNames[i];
+            // 如果当前窗口在ignores列表中，跳过
+            if (ignores.some(ignore => ignore.name === name)) {
+                continue;
+            }
+            const window = WindowManager.getWindow(name);
+            if (!window) {
+                console.error(`[BUG] 窗口【${name}】不存在，数据结构已损坏`);
+                return;
+            }
+            // 释放header
+            HeaderManager.releaseHeader(name);
+            window._close();
+            WindowManager.removeWindow(name);
+            // 从数组中删除
+            this._windowNames.splice(i, 1);
+        }
+        // 统一处理窗口的显示状态
+        if (this.size == 0) {
+            this._root.visible = false;
+        }
+        else {
+            this.processWindowHideStatus(this.size - 1);
+        }
     }
 }
-/** 窗口组 @internal */
-UIManager._groups = new Map();
-/** 不忽略查询的窗口组名 @internal */
-UIManager._queryGroupNames = [];
-/** 所有窗口全部放到这个map中 @internal */
-UIManager._windows = new Map();
 
 /**
  * @Author: Gongxh
  * @Date: 2024-12-11
  * @Description: UI 装饰器
  */
+/**
+ * 获取对象属性
+ * @param obj 对象
+ * @param key 属性名
+ * @returns 属性值
+ */
+function getObjectProp(obj, key) {
+    if (obj.hasOwnProperty(key)) {
+        return obj[key];
+    }
+    return (obj[key] = Object.assign({}, obj[key]));
+}
 var _uidecorator;
 (function (_uidecorator) {
     /** @internal */
-    const UIPropMeta = "__uipropmeta__";
+    const uiclassMap = new Map(); // 窗口注册信息
     /** @internal */
-    const UICBMeta = "__uicbmeta__";
+    const uicomponentMap = new Map(); // 组件注册信息
     /** @internal */
-    const UIControlMeta = "__uicontrolmeta__";
-    /** @internal */
-    const UITransitionMeta = "__uitransitionmeta__";
-    /** 用来存储窗口注册信息 @internal */
-    const uiclassMap = new Map();
-    /**
-     * 获取对象属性
-     * @param obj 对象
-     * @param key 属性名
-     * @returns 属性值
-     */
-    function getObjectProp(obj, key) {
-        if (obj.hasOwnProperty(key)) {
-            return obj[key];
-        }
-        return (obj[key] = Object.assign({}, obj[key]));
-    }
+    const uiheaderMap = new Map(); // header注册信息
     /** 获取窗口注册信息 */
-    function getWindowMaps() {
-        return uiclassMap;
-    }
+    function getWindowMaps() { return uiclassMap; }
     _uidecorator.getWindowMaps = getWindowMaps;
+    /** 获取组件注册信息 */
+    function getComponentMaps() { return uicomponentMap; }
+    _uidecorator.getComponentMaps = getComponentMaps;
+    /** 获取header注册信息 */
+    function getHeaderMaps() { return uiheaderMap; }
+    _uidecorator.getHeaderMaps = getHeaderMaps;
     /**
      * 窗口装饰器
      * @param {string} groupName 窗口组名称
      * @param {string} pkgName fgui包名
      * @param {string} name 窗口名 (与fgui中的组件名一一对应)
+     * @param {string[] | string} inlinePkgs 内联的包名 当前界面需要引用其他包中的资源时使用 引用多个包用数组 引用单个包用字符串
+     *
+     * @example @uiclass("窗口组", "UI包名", "MyWindow", ["包名1", "包名2"])
+     * @example @uiclass("窗口组", "UI包名", "MyWindow", "包名1")
      */
-    function uiclass(groupName, pkgName, name, bundle) {
+    function uiclass(groupName, pkgName, name, inlinePkgs) {
         /** target 类的构造函数 */
         return function (ctor) {
             // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
             const originalCtor = ctor;
+            // 给构造函数添加静态属性，存储窗口名称（避免混淆后 constructor.name 变化）
+            ctor[MetadataKey.originalName] = name;
             uiclassMap.set(originalCtor, {
                 ctor: ctor, // 存储实际的构造函数（可能被包装过）
-                props: ctor[UIPropMeta] || null,
-                callbacks: ctor[UICBMeta] || null,
-                controls: ctor[UIControlMeta] || null,
-                transitions: ctor[UITransitionMeta] || null,
+                props: ctor[MetadataKey.prop] || null,
+                callbacks: ctor[MetadataKey.callback] || null,
+                controls: ctor[MetadataKey.control] || null,
+                transitions: ctor[MetadataKey.transition] || null,
                 res: {
                     group: groupName,
                     pkg: pkgName,
                     name: name,
-                    bundle: bundle || "",
                 },
             });
-            // 首次引擎注册完成后 动态注册窗口，使用实际的构造函数
-            _registerFinish && UIManager.dynamicRegisterWindow(ctor, groupName, pkgName, name, bundle || "");
+            let pkgs = [];
+            if (Array.isArray(inlinePkgs)) {
+                pkgs = inlinePkgs;
+            }
+            else if (typeof inlinePkgs === "string") {
+                pkgs = [inlinePkgs];
+            }
+            InfoPool.add(ctor, groupName, pkgName, name, pkgs);
             return ctor;
         };
     }
     _uidecorator.uiclass = uiclass;
-    /** 用来存储组件注册信息 @internal */
-    let uicomponentMap = new Map();
-    /** 获取组件注册信息 */
-    function getComponentMaps() {
-        return uicomponentMap;
-    }
-    _uidecorator.getComponentMaps = getComponentMaps;
     /**
      * UI组件装饰器
      * @param {string} pkg 包名
@@ -617,54 +1681,46 @@ var _uidecorator;
             // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
             const originalCtor = ctor;
             // log(`pkg:【${pkg}】 uicom prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            ctor[MetadataKey.originalName] = name;
             uicomponentMap.set(originalCtor, {
                 ctor: ctor, // 存储实际的构造函数（可能被包装过）
-                props: ctor[UIPropMeta] || null,
-                callbacks: ctor[UICBMeta] || null,
-                controls: ctor[UIControlMeta] || null,
-                transitions: ctor[UITransitionMeta] || null,
+                props: ctor[MetadataKey.prop] || null,
+                callbacks: ctor[MetadataKey.callback] || null,
+                controls: ctor[MetadataKey.control] || null,
+                transitions: ctor[MetadataKey.transition] || null,
                 res: {
                     pkg: pkg,
                     name: name,
                 }
             });
-            // 首次引擎注册完成后 动态注册自定义组件，使用实际的构造函数
-            _registerFinish && ComponentExtendHelper.dynamicRegister(ctor, pkg, name);
+            InfoPool.addComponent(ctor, pkg, name);
             return ctor;
         };
     }
     _uidecorator.uicom = uicom;
-    /** 用来存储组件注册信息 @internal */
-    let uiheaderMap = new Map();
-    /** 获取header注册信息 */
-    function getHeaderMaps() {
-        return uiheaderMap;
-    }
-    _uidecorator.getHeaderMaps = getHeaderMaps;
     /**
      * UI header装饰器
      * @param {string} pkg 包名
      * @param {string} name 组件名
      */
-    function uiheader(pkg, name, bundle) {
+    function uiheader(pkg, name) {
         return function (ctor) {
             // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
             const originalCtor = ctor;
             // log(`pkg:【${pkg}】 uiheader prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            ctor[MetadataKey.originalName] = name;
             uiheaderMap.set(originalCtor, {
                 ctor: ctor, // 存储实际的构造函数（可能被包装过）
-                props: ctor[UIPropMeta] || null,
-                callbacks: ctor[UICBMeta] || null,
-                controls: ctor[UIControlMeta] || null,
-                transitions: ctor[UITransitionMeta] || null,
+                props: ctor[MetadataKey.prop] || null,
+                callbacks: ctor[MetadataKey.callback] || null,
+                controls: ctor[MetadataKey.control] || null,
+                transitions: ctor[MetadataKey.transition] || null,
                 res: {
                     pkg: pkg,
                     name: name,
-                    bundle: bundle || "",
                 }
             });
-            // 首次引擎注册完成后 动态注册窗口header，使用实际的构造函数
-            _registerFinish && UIManager.dynamicRegisterHeader(ctor, pkg, name, bundle || "");
+            InfoPool.addHeader(ctor, pkg, name);
             return ctor;
         };
     }
@@ -678,7 +1734,7 @@ var _uidecorator;
      */
     function uiprop(target, name) {
         // debug("属性装饰器:", target.constructor, name);
-        getObjectProp(target.constructor, UIPropMeta)[name] = 1;
+        getObjectProp(target.constructor, MetadataKey.prop)[name] = 1;
     }
     _uidecorator.uiprop = uiprop;
     /**
@@ -690,7 +1746,7 @@ var _uidecorator;
      */
     function uicontrol(target, name) {
         // debug("属性装饰器:", target.constructor, name);
-        getObjectProp(target.constructor, UIControlMeta)[name] = 1;
+        getObjectProp(target.constructor, MetadataKey.control)[name] = 1;
     }
     _uidecorator.uicontrol = uicontrol;
     /**
@@ -702,7 +1758,7 @@ var _uidecorator;
      */
     function uitransition(target, name) {
         // debug("属性装饰器:", target.constructor, name);
-        getObjectProp(target.constructor, UITransitionMeta)[name] = 1;
+        getObjectProp(target.constructor, MetadataKey.transition)[name] = 1;
     }
     _uidecorator.uitransition = uitransition;
     /**
@@ -712,15 +1768,9 @@ var _uidecorator;
      */
     function uiclick(target, name, descriptor) {
         // debug("方法装饰器:", target.constructor, name, descriptor);
-        getObjectProp(target.constructor, UICBMeta)[name] = descriptor.value;
+        getObjectProp(target.constructor, MetadataKey.callback)[name] = descriptor.value;
     }
     _uidecorator.uiclick = uiclick;
-    let _registerFinish = false;
-    /** 首次UI注册完成 */
-    function setRegisterFinish() {
-        _registerFinish = true;
-    }
-    _uidecorator.setRegisterFinish = setRegisterFinish;
 })(_uidecorator || (_uidecorator = {}));
 const _global = (globalThis || window || global);
 _global["getKunpoRegisterWindowMaps"] = function () {
@@ -735,55 +1785,51 @@ _global["getKunpoRegisterHeaderMaps"] = function () {
 
 /**
  * @Author: Gongxh
- * @Date: 2024-12-14
- * @Description: 窗口基类和fgui组件对接
+ * @Date: 2025-01-11
+ * @Description: 窗口顶边栏
+ * 窗口顶边资源栏 同组中只会有一个显示
  */
-class UIWindow extends GComponent {
+class Header extends GComponent {
     constructor() {
         super(...arguments);
-        /** 窗口类型 */
-        this.type = WindowType.Normal;
         /** 窗口适配类型 */
         this.adapterType = AdapterType.Full;
-        /** header (内部使用) @internal */
-        this._header = null;
-        /** 窗口是否被遮挡了 @internal */
-        this._isCover = false;
-        /** 吞噬触摸的节点 @internal */
-        this._swallowComponent = null;
     }
+    onAdapted() { }
+    ;
+    onClose() { }
+    ;
+    onHide() { }
+    ;
+    onShowFromHide() { }
+    ;
     /**
-     * 初始化方法 (框架内部使用)
-     * @param swallowTouch 是否吞噬触摸事件
-     * @param bgAlpha 底部遮罩的透明度
+     * 是否显示中
+     */
+    isShowing() {
+        return this.visible;
+    }
+    /**
+     * 初始化 (内部方法)
      * @internal
      */
-    _init(swallowTouch, bgAlpha) {
-        if (swallowTouch) {
-            // 吞噬触摸事件，需要一个全屏的节点, 窗口本身可能留有安全区的边
-            let bgNode = new GComponent();
-            bgNode.name = "swallow";
-            bgNode.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
-            bgNode.setPivot(0.5, 0.5, true);
-            bgNode.setPosition(this.width * 0.5, this.height * 0.5);
-            this.addChild(bgNode);
-            // 调整显示层级
-            bgNode.parent.setChildIndex(bgNode, 0);
-            bgNode.onClick(this.onEmptyAreaClick, this);
-            bgNode.opaque = swallowTouch;
-            this._swallowComponent = bgNode;
-        }
-        // 窗口自身也要设置是否吞噬触摸
-        this.opaque = swallowTouch;
-        this.bgAlpha = bgAlpha;
+    _init() {
+        this.opaque = false;
         this.onInit();
     }
     /**
-     * 适配窗口
+     * 关闭 (内部方法)
+     * @internal
+     */
+    _close() {
+        this.onClose();
+        this.dispose();
+    }
+    /**
+     * 窗口适配
      * @internal
      */
     _adapted() {
-        var _a, _b;
         this.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
         this.setPivot(0.5, 0.5, true);
         switch (this.adapterType) {
@@ -794,21 +1840,11 @@ class UIWindow extends GComponent {
                 this.setSize(Screen.SafeWidth, Screen.SafeHeight, true);
                 break;
         }
-        (_a = this._swallowComponent) === null || _a === void 0 ? void 0 : _a.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
-        (_b = this._swallowComponent) === null || _b === void 0 ? void 0 : _b.setPosition(this.width * 0.5, +this.height * 0.5);
         this.onAdapted();
     }
     /**
-     * 窗口关闭 (框架内部使用)
-     * @internal
-     */
-    _close() {
-        this.onClose();
-        this.dispose();
-    }
-    /**
-     * 显示窗口 (框架内部使用)
-     * @param userdata 用户自定义数据
+     * 显示
+     * @param userdata 用户数据
      * @internal
      */
     _show(userdata) {
@@ -816,530 +1852,203 @@ class UIWindow extends GComponent {
         this.onShow(userdata);
     }
     /**
-     * 隐藏窗口 (框架内部使用)
+     * 隐藏
      * @internal
      */
     _hide() {
         this.visible = false;
         this.onHide();
     }
-    /**
-     * 从隐藏状态恢复显示
-     * @internal
-     */
-    _showFromHide() {
-        this.visible = true;
-        this.onShowFromHide();
-    }
-    /**
-     * 遮挡窗口 被同组或者不同组的其他窗口覆盖 (框架内部使用)
-     * @internal
-     */
-    _cover() {
-        this._isCover = true;
-        this.onCover();
-    }
-    /**
-     * 遮挡恢复窗口 被同组或者不同组的其他窗口覆盖恢复 (框架内部使用)
-     * @internal
-     */
-    _recover() {
-        this._isCover = false;
-        this.onRecover();
-    }
-    /**
-     * 设置窗口深度
-     * @param depth 深度
-     * @internal
-     */
-    _setDepth(depth) {
-        this.parent.setChildIndex(this, depth);
-    }
-    isShowing() {
-        return this.visible;
-    }
-    isCover() {
-        return this._isCover;
-    }
-    /** @internal */
-    screenResize() {
-        this._adapted();
-    }
-    /**
-     * 获取窗口顶部资源栏数据 默认返回空数组
-     * @returns {WindowHeaderInfo[]}
-     */
-    getHeaderInfo() {
-        return null;
-    }
-    getHeader() {
-        return this._header;
-    }
-    /** @internal */
-    _setHeader(header) {
-        this._header = header;
-    }
 }
 
 /**
  * @Author: Gongxh
- * @Date: 2024-12-14
- * @Description:
+ * @Date: 2025-01-10
+ * @Description: 窗口顶部资源栏信息
  */
-class Window extends UIWindow {
-    onAdapted() {
-    }
-    /**
-     * 窗口关闭时的处理逻辑。
-     * 子类可以重写此方法以实现自定义的关闭行为。
-     */
-    onClose() {
-    }
-    /**
-     * 窗口显示时的回调函数。
-     * @param userdata 可选参数，传递给窗口显示时的用户数据。
-     */
-    onShow(userdata) {
-    }
-    /**
-     * 隐藏窗口时的处理逻辑。
-     * 重写此方法以实现自定义的隐藏行为。
-     */
-    onHide() {
-    }
-    /**
-     * 当窗口从隐藏状态变为显示状态时调用。
-     * 这个方法可以被子类重写以实现特定的显示逻辑。
-     */
-    onShowFromHide() {
-    }
-    /**
-     * 当窗口被覆盖时触发的事件处理函数。
-     * 子类可以重写此方法以添加自定义行为。
-     */
-    onCover() {
-    }
-    /**
-     * 恢复窗口状态时的处理逻辑。
-     * 此方法在窗口从隐藏或最小化状态恢复时被调用。
-     */
-    onRecover() {
-    }
+class HeaderInfo {
     /**
-     * 空白区域点击事件处理函数。
-     * 当用户点击窗口的空白区域时触发此方法。
+     * 创建 WindowHeaderInfo
+     * @param {string} name header窗口名
+     * @param {*} [userdata] 自定义数据
+     * @returns {HeaderInfo}
      */
-    onEmptyAreaClick() {
+    static create(ctor, userdata) {
+        // 优先使用装饰器设置的静态属性，避免代码混淆后 constructor.name 变化
+        const name = ctor[MetadataKey.originalName];
+        if (!name) {
+            throw new Error(`header【${ctor.name}】未注册，请使用 _uidecorator.uiheader 注册header`);
+        }
+        const info = new HeaderInfo();
+        info.name = name;
+        info.userdata = userdata;
+        return info;
     }
 }
 
 /**
  * @Author: Gongxh
- * @Date: 2024-12-08
- * @Description: 窗口组 (在同一个窗口容器的上的窗口)
+ * @Date: 2024-12-14
+ * @Description: 窗口基类和fgui组件对接
  */
-class WindowGroup {
-    /**
-     * 获取窗口组的名称。
-     * @returns {string} 窗口组的名称。
-     */
-    get name() {
-        return this._name;
-    }
-    /**
-     * 获取当前窗口组中窗口的数量。
-     * @returns 窗口数量
-     */
-    get size() {
-        return this._windowNames.length;
-    }
-    /**
-     * 获取是否忽略查询的状态。
-     * @returns {boolean} 如果忽略查询，则返回 true，否则返回 false。
-     */
-    get isIgnore() {
-        return this._ignoreQuery;
-    }
-    /**
-     * 实例化
-     * @param name 组名
-     * @param root 窗口组的根节点 一个fgui的组件
-     * @param ignoreQuery 是否忽略顶部窗口查询
-     * @param swallowTouch 是否吞掉触摸事件
-     * @param bgAlpha 半透明遮罩的透明度
-     * @internal
-     */
-    constructor(name, root, ignoreQuery, swallowTouch, bgAlpha) {
-        /** 窗口组的名字 @internal */
-        this._name = "";
-        /** 忽略顶部窗口查询 @internal */
-        this._ignoreQuery = false;
-        /** 吞噬触摸事件 @internal */
-        this._swallowTouch = false;
-        /** 窗口容器中的窗口名列表 @internal */
-        this._windowNames = [];
-        /** 窗口顶部资源栏 @internal */
-        this._headers = new Map();
-        /** 半透明遮罩的透明度 @internal */
-        this._bgAlpha = 0;
-        /** 半透明遮罩的颜色 @internal */
-        this._color = new Color(0, 0, 0, 255);
-        this._name = name;
-        this._root = root;
-        this._ignoreQuery = ignoreQuery;
-        this._swallowTouch = swallowTouch;
-        this._bgAlpha = bgAlpha;
-        const alphaGraph = new GGraph();
-        alphaGraph.touchable = false;
-        alphaGraph.name = "bgAlpha";
-        alphaGraph.setPosition(root.width * 0.5, root.height * 0.5);
-        alphaGraph.setSize(root.width, root.height, true);
-        alphaGraph.setPivot(0.5, 0.5, true);
-        root.addChild(alphaGraph);
-        this._alphaGraph = alphaGraph;
-    }
-    /**
-     * 根据窗口名创建窗口 并添加到显示节点
-     * @param windowName 窗口名
-     * @internal
-     */
-    _createWindow(pkg, name) {
-        let window = UIPackage.createObject(pkg, name);
-        window.name = name;
-        PropsHelper.serializeProps(window, pkg);
-        window._init(this._swallowTouch, this._bgAlpha);
-        window._adapted();
-        this._createHeader(window);
-        // 添加到显示节点
-        this._addWindow(window);
-        return window;
+class WindowBase extends GComponent {
+    constructor() {
+        super(...arguments);
+        /** 窗口类型 */
+        this.type = WindowType.Normal;
+        /** 窗口适配类型 */
+        this.adapterType = AdapterType.Full;
+        /** @internal */
+        this._swallowNode = null; // 吞噬触摸的节点
+        /** @internal */
+        this._isTop = true;
     }
     /**
-     * 添加窗口到显示节点
-     * @param window 窗口
+     * 初始化方法 (框架内部使用)
+     * @param swallowTouch 是否吞噬触摸事件
+     * @param bgAlpha 底部遮罩的透明度
      * @internal
      */
-    _addWindow(window) {
-        this._root.addChild(window);
-        UIManager._addWindow(window.name, window);
-    }
-    showWindow(info, userdata) {
-        let name = info.name;
-        let window = UIManager.getWindow(name);
-        if (window) {
-            window._show(userdata);
-        }
-        else {
-            window = this._createWindow(info.pkg, name);
-            this._processWindowCloseStatus(window);
-            this._windowNames.push(name);
-            window._show(userdata);
-        }
-        this._moveWindowToTop(name);
-        // 处理header的显示
-        this._processHeaderStatus();
-        // 显示窗口组
-        this._root.visible = true;
+    _init(swallowTouch) {
+        // 窗口本身可能留有安全区的边, 所以需要一个全屏的节点来吞噬触摸事件
+        let bgNode = new GComponent();
+        bgNode.name = "swallow";
+        bgNode.setPivot(0.5, 0.5, true);
+        this.addChild(bgNode);
+        bgNode.parent.setChildIndex(bgNode, 0); // 调整显示层级
+        bgNode.onClick(this.onEmptyAreaClick, this); // 空白区域点击事件
+        bgNode.opaque = swallowTouch;
+        this._swallowNode = bgNode;
+        // 窗口自身也要设置是否吞噬触摸
+        this.opaque = swallowTouch;
+        this._isTop = true;
+        this.bgAlpha = WindowManager.bgAlpha;
+        this.onInit();
     }
     /**
-     * 移除指定名称的窗口。
-     * @param name 窗口的名称。
+     * 适配窗口
      * @internal
      */
-    _removeWindow(name) {
-        let index = this._windowNames.lastIndexOf(name);
-        let lastIndex = this.size - 1;
-        if (index < 0) {
-            console.warn(`窗口组${this._name}中未找到窗口${name} 删除失败`);
-            return;
-        }
-        let window = UIManager.getWindow(name);
-        let header = window.getHeader();
-        header && this._removeHeader(header);
-        this._windowNames.splice(index, 1);
-        // 关闭窗口 并从窗口map中移除
-        UIManager._removeWindow(name);
-        // 处理窗口显示和隐藏状态
-        this._processWindowHideStatus(this.size - 1, true);
-        if (this.size == 0) {
-            // 窗口组中不存在窗口时 隐藏窗口组节点
-            this._root.visible = false;
-        }
-        else if (lastIndex == index && index > 0) {
-            // 删除的窗口是最后一个 并且前边还有窗口 调整半透明节点的显示层级
-            let topName = this.getTopWindowName();
-            let window = UIManager.getWindow(topName);
-            // 调整半透明遮罩
-            this._adjustAlphaGraph(window);
-            // 调整窗口的显示层级
-            window._setDepth(this._root.numChildren - 1);
+    _adapted() {
+        this.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+        this.setPivot(0.5, 0.5, true);
+        switch (this.adapterType) {
+            case AdapterType.Full:
+                this.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+                break;
+            case AdapterType.Bang:
+                this.setSize(Screen.SafeWidth, Screen.SafeHeight, true);
+                break;
         }
-        this._processHeaderStatus();
+        // 屏幕的宽高
+        this._swallowNode.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+        // 位置放在窗口的中心
+        this._swallowNode.setPosition(this.width * 0.5, this.height * 0.5);
+        this.onAdapted();
     }
     /**
-     * 将指定名称的窗口移动到窗口组的最顶层。
-     * @param name 窗口的名称。
+     * 窗口关闭
      * @internal
      */
-    _moveWindowToTop(name) {
-        let isMoved = false;
-        if (this.size == 0) {
-            console.warn(`WindowGroup.moveWindowToTop: window group 【${this._name}】 is empty`);
-            return false;
-        }
-        if (this._windowNames[this.size - 1] == name) ;
-        else {
-            const index = this._windowNames.indexOf(name);
-            if (index == -1) {
-                console.warn(`WindowGroup.moveWindowToTop: window 【${name}】 not found in window group 【${this._name}】`);
-                return false;
-            }
-            if (index < this._windowNames.length - 1) {
-                this._windowNames.splice(index, 1);
-                // 放到数组的末尾
-                this._windowNames.push(name);
-                isMoved = true;
-            }
-        }
-        let window = UIManager.getWindow(name);
-        // 先调整半透明遮罩
-        this._adjustAlphaGraph(window);
-        // 再调整窗口的显示层级
-        window._setDepth(this._root.numChildren - 1);
-        // 处理窗口显示和隐藏状态
-        this._processWindowHideStatus(this.size - 1, isMoved);
-        return true;
+    _close() {
+        this.onClose();
+        this.dispose();
     }
     /**
-     * 处理index下层窗口的隐藏状态的私有方法。递归调用
-     * @param index - 窗口索引
-     * @param isRecursion - 是否递归调用
+     * 显示窗口 (框架内部使用)
+     * @param userdata 用户自定义数据
      * @internal
      */
-    _processWindowHideStatus(index, isRecursion = true) {
-        if (index < 0) {
-            return;
-        }
-        let windowName = this._windowNames[index];
-        let curWindow = UIManager.getWindow(windowName);
-        // 如果当前是当前组中的最后一个窗口并且当前窗口是隐藏状态 则恢复隐藏
-        if (index == this.size - 1 && !curWindow.isShowing()) {
-            curWindow._showFromHide();
-        }
-        if (index == 0) {
-            return;
-        }
-        let windowType = curWindow.type;
-        if (windowType == WindowType.HideAll) {
-            for (let i = index - 1; i >= 0; --i) {
-                let name = this._windowNames[i];
-                const window = UIManager.getWindow(name);
-                window.isShowing() && window._hide();
-            }
-            return;
-        }
-        else if (windowType == WindowType.HideOne) {
-            // 隐藏前一个
-            let prevWindowName = this._windowNames[index - 1];
-            let prevWindow = UIManager.getWindow(prevWindowName);
-            prevWindow.isShowing() && prevWindow._hide();
-        }
-        else {
-            // 如果前一个窗口被隐藏了 需要恢复显示
-            let prevWindowName = this._windowNames[index - 1];
-            let prevWindow = UIManager.getWindow(prevWindowName);
-            !prevWindow.isShowing() && prevWindow._showFromHide();
-        }
-        isRecursion && this._processWindowHideStatus(index - 1, isRecursion);
+    _show(userdata) {
+        this.visible = true;
+        this.onShow(userdata);
     }
     /**
-     * 新创建窗口时，根据新创建的窗口类型
-     * 处理上一个窗口或者所有窗口的关闭
-     * @param window 新创建的窗口
+     * 隐藏窗口 (框架内部使用)
      * @internal
      */
-    _processWindowCloseStatus(window) {
-        // 新创建窗口 如果需要关闭窗口或者关闭所有窗口 处理窗口的关闭
-        if (window.type == WindowType.CloseOne) {
-            let size = this.size;
-            while (size > 0) {
-                let name = this._windowNames.pop();
-                let window = UIManager.getWindow(name);
-                let header = window.getHeader();
-                header && this._removeHeader(header);
-                UIManager._removeWindow(name);
-                break;
-            }
-        }
-        else if (window.type == WindowType.CloseAll) {
-            let size = this.size;
-            for (let i = size; i > 0;) {
-                let name = this._windowNames[--i];
-                let window = UIManager.getWindow(name);
-                let header = window.getHeader();
-                header && this._removeHeader(header);
-                UIManager._removeWindow(name);
-            }
-            this._windowNames.length = 0;
-        }
+    _hide() {
+        this.visible = false;
+        this.onHide();
     }
     /**
-     * 处理header的显示状态 并调整层级
+     * 从隐藏状态恢复显示
      * @internal
      */
-    _processHeaderStatus() {
-        // 找到第一个要显示的header
-        let firstHeader = null;
-        let firstWindow = null;
-        let index = this.size - 1;
-        for (let i = this.size - 1; i >= 0; --i) {
-            let name = this._windowNames[i];
-            let window = UIManager.getWindow(name);
-            if (window.isShowing() && window.getHeader()) {
-                firstWindow = window;
-                firstHeader = window.getHeader();
-                index = i;
-                break;
-            }
-        }
-        this._headers.forEach((header, name) => {
-            this._root.setChildIndex(header, 0);
-            if (!firstHeader && header.visible) {
-                header._hide();
-            }
-            else if (firstHeader) {
-                if (firstHeader.name == name && !header.visible) {
-                    header._show(firstWindow);
-                }
-                else if (firstHeader.name != name && header.visible) {
-                    header._hide();
-                }
-            }
-        });
-        if (firstHeader) {
-            if (index == this.size - 1) {
-                this._root.setChildIndex(firstHeader, this._root.numChildren - 1);
-            }
-            else {
-                this._root.setChildIndex(firstHeader, this._root.numChildren - this.size + index - 1);
-            }
-        }
+    _showFromHide() {
+        this.visible = true;
+        this.onShowFromHide();
     }
     /**
-     * 调整指定窗口的透明度图形。并根据窗口的背景透明度绘制半透明遮罩。
-     * @param window - 需要调整透明度的窗口对象。
+     * 除忽略的窗口组外, 显示到最上层时
      * @internal
      */
-    _adjustAlphaGraph(window) {
-        this._root.setChildIndex(this._alphaGraph, this._root.numChildren - 1);
-        // 半透明遮罩绘制
-        this._color.a = window.bgAlpha * 255;
-        this._alphaGraph.clearGraphics();
-        this._alphaGraph.drawRect(0, this._color, this._color);
-    }
-    hasWindow(name) {
-        return this._windowNames.indexOf(name) >= 0;
+    _toTop() {
+        this._isTop = true;
+        this.onToTop();
     }
     /**
-     * 获取窗口组中顶部窗口的名称。
-     * @returns {string} 顶部窗口的名称。
-     */
-    getTopWindowName() {
-        if (this.size > 0) {
-            return this._windowNames[this.size - 1];
-        }
-        console.warn(`WindowGroup.getTopWindowName: window group 【${this._name}】 is empty`);
-        return "";
-    }
-    /** 根据窗口 创建顶部资源栏 (内部方法) @internal */
-    _createHeader(window) {
-        // 只有创建界面的时候, 才会尝试创建顶部资源栏
-        let headerInfo = window.getHeaderInfo();
-        if (!headerInfo) {
-            return;
-        }
-        let name = headerInfo.name;
-        let header = this._getHeader(name);
-        if (header) {
-            window._setHeader(header);
-            header._addRef();
-        }
-        else {
-            // 创建header节点
-            let { pkg } = UIManager._getResPool().getHeader(name);
-            let newHeader = UIPackage.createObject(pkg, name);
-            newHeader.name = name;
-            newHeader.opaque = false;
-            window._setHeader(newHeader);
-            newHeader.visible = false;
-            PropsHelper.serializeProps(newHeader, pkg);
-            newHeader._init();
-            newHeader._adapted();
-            this._root.addChild(newHeader);
-            // 添加到显示节点
-            newHeader._addRef();
-            this._headers.set(newHeader.name, newHeader);
-        }
-    }
-    /**
-     * 顶部资源栏窗口 从管理器中移除 (内部方法)
-     * @param header 资源栏
+     * 除忽略的窗口组外, 被上层窗口覆盖时
      * @internal
      */
-    _removeHeader(header) {
-        if (this._headers.has(header.name)) {
-            let refCount = header._decRef();
-            if (refCount <= 0) {
-                this._headers.delete(header.name);
-                header._close();
-            }
-        }
+    _toBottom() {
+        this._isTop = false;
+        this.onToBottom();
     }
     /**
-     * 获取顶部资源栏 (内部方法)
-     * @param name 资源栏的名称
+     * 设置窗口深度
+     * @param depth 深度
      * @internal
      */
-    _getHeader(name) {
-        return this._headers.get(name);
+    setDepth(depth) {
+        this.parent.setChildIndex(this, depth);
     }
-    /** 屏幕大小改变时被调用 (内部方法) @internal */
-    _screenResize() {
-        this._headers.forEach((header) => {
-            header._screenResize();
-        });
-        this._alphaGraph.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
-        this._alphaGraph.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
-        this._alphaGraph.setPivot(0.5, 0.5, true);
+    isShowing() {
+        return this.visible;
+    }
+    /** 是否在最上层显示 (除忽略的窗口组外, 显示到最上层时) */
+    isTop() {
+        return this._isTop;
+    }
+    /** @internal */
+    screenResize() {
+        this._adapted();
     }
     /**
-     * 关闭窗口组中的所有窗口
+     * 刷新顶部资源栏
+     * 调用这个方法会重新创建 或者 刷新header
+     * 用来在同一个界面显示不同的header
      */
-    closeAllWindow() {
-        while (this.size > 0) {
-            let name = this.getTopWindowName();
-            UIManager.closeWindow(name);
-        }
+    refreshHeader() {
+        HeaderManager.refreshWindowHeader(this.name, this.getHeaderInfo());
+    }
+    /**
+     * 用于在界面中关闭自己
+     */
+    removeSelf() {
+        WindowManager.closeWindowByName(this.name);
     }
 }
 
-/**
- * @Author: Gongxh
- * @Date: 2025-01-10
- * @Description: 窗口顶部资源栏信息
- */
-class WindowHeaderInfo {
+class Window extends WindowBase {
+    onAdapted() {
+    }
+    onHide() { }
+    onShowFromHide() { }
+    onToTop() { }
+    onToBottom() { }
     /**
-     * 创建 WindowHeaderInfo
-     * @param {string} name header窗口名
-     * @param {*} [userdata] 自定义数据
-     * @returns {WindowHeaderInfo}
+     * 空白区域点击事件处理函数。
+     * 当用户点击窗口的空白区域时触发此方法。
      */
-    static create(name, userdata) {
-        const info = new WindowHeaderInfo();
-        info.name = name;
-        info.userdata = userdata;
-        return info;
+    onEmptyAreaClick() {
+    }
+    /**
+     * 获取窗口顶部资源栏数据 默认返回空数组
+     * @returns {HeaderInfo}
+     */
+    getHeaderInfo() {
+        return null;
     }
 }
 
@@ -1372,294 +2081,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-/**
- * @Author: Gongxh
- * @Date: 2024-12-13
- * @Description:
- */
-/** @internal */
-class WindowResPool {
-    constructor() {
-        /** 窗口信息池 @internal */
-        this._windowInfos = new Map();
-        /** 窗口header信息池 @internal */
-        this._headerInfos = new Map();
-        /** UI包所在的bundle名 */
-        this._pkgBundles = new Map();
-        /** 是否设置过配置内容 @internal */
-        this._isInit = false;
-        /** 窗口名对应的包名列表 @internal */
-        this._windowPkgs = new Map();
-        /** 包的引用计数 @internal */
-        this._pkgRefs = {};
-        /** UI包路径 @internal */
-        // private _uipath: string = "";
-        /** UI包在bundle中的路径 @internal */
-        this._uiPaths = {};
-        /** 手动管理的包 @internal */
-        this._manualPackages = new Set();
-        /** 立即释放的包 @internal */
-        this._imReleasePackages = new Set();
-        /** 注册的回调函数 @internal */
-        this._showWaitWindow = null;
-        /** 隐藏等待窗口的回调函数 @internal */
-        this._hideWaitWindow = null;
-        /** 加载失败回调函数 @internal */
-        this._fail = null;
-        /** 等待窗口的引用计数 @internal */
-        this._waitRef = 0;
-    }
-    /**
-     * 注册窗口信息
-     * @param info
-     */
-    add(ctor, group, pkg, name, bundle) {
-        if (this.has(name)) {
-            return;
-        }
-        this._windowInfos.set(name, {
-            ctor: ctor,
-            group: group,
-            pkg: pkg,
-            name: name,
-            bundle: bundle
-        });
-        this._pkgBundles.set(pkg, bundle || "resources");
-        this.addWindowPkg(name, pkg);
-        // 窗口组件扩展
-        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
-    }
-    has(name) {
-        return this._windowInfos.has(name);
-    }
-    get(name) {
-        if (!this.has(name)) {
-            throw new Error(`窗口【${name}】未注册，请使用 _uidecorator.uiclass 注册窗口`);
-        }
-        return this._windowInfos.get(name);
-    }
-    /**
-     * 注册窗口header信息
-     * @param info
-     */
-    addHeader(ctor, pkg, name, bundle) {
-        if (this.hasHeader(name)) {
-            return;
-        }
-        this._headerInfos.set(name, {
-            ctor: ctor,
-            pkg: pkg,
-            bundle: bundle
-        });
-        this._pkgBundles.set(pkg, bundle || "resources");
-        // 窗口header扩展
-        UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
-    }
-    hasHeader(name) {
-        return this._headerInfos.has(name);
-    }
-    getHeader(name) {
-        if (!this.hasHeader(name)) {
-            throw new Error(`窗口header【${name}】未注册，请使用 _uidecorator.uiheader 注册窗口header`);
-        }
-        return this._headerInfos.get(name);
-    }
-    /** 资源配置相关接口 */
-    initPackageConfig(res) {
-        var _a, _b;
-        if (!res || !res.config) {
-            return;
-        }
-        if (this._isInit) {
-            throw new Error("资源配置已初始化，请勿重复设置");
-        }
-        this._isInit = true;
-        this._showWaitWindow = res === null || res === void 0 ? void 0 : res.showWaitWindow;
-        this._hideWaitWindow = res === null || res === void 0 ? void 0 : res.hideWaitWindow;
-        this._fail = res === null || res === void 0 ? void 0 : res.fail;
-        this._uiPaths = ((_a = res.config) === null || _a === void 0 ? void 0 : _a.bundlePaths) || {};
-        this._uiPaths["resources"] = ((_b = res.config) === null || _b === void 0 ? void 0 : _b.uiPath) || "";
-        for (const bundle in this._uiPaths) {
-            if (this._uiPaths[bundle] != "" && !this._uiPaths[bundle].endsWith("/")) {
-                this._uiPaths[bundle] += "/";
-            }
-        }
-        this._manualPackages = new Set(res.config.manualPackages || []);
-        this._imReleasePackages = new Set(res.config.imReleasePackages || []);
-        let windowPkgs = res.config.linkPackages || {};
-        for (const windowName in windowPkgs) {
-            let pkgs = windowPkgs[windowName];
-            for (const pkg of pkgs || []) {
-                this.addWindowPkg(windowName, pkg);
-            }
-        }
-        // 遍历一遍，剔除手动管理的包
-        this._windowPkgs.forEach((pkgs, windowName) => {
-            for (let i = pkgs.length - 1; i >= 0; i--) {
-                if (this._manualPackages.has(pkgs[i])) {
-                    pkgs.splice(i, 1);
-                }
-            }
-            if (pkgs.length <= 0) {
-                this._windowPkgs.delete(windowName);
-            }
-        });
-    }
-    /** 添加窗口对应的包名 */
-    addWindowPkg(windowName, pkgName) {
-        if (!this._windowPkgs.has(windowName)) {
-            this._windowPkgs.set(windowName, [pkgName]);
-        }
-        else {
-            this._windowPkgs.get(windowName).push(pkgName);
-        }
-    }
-    /**
-     * 加载窗口需要的包资源
-     * @param windowName 窗口名
-     */
-    loadWindowRes(windowName, listenter) {
-        var _a;
-        // 资源配置未初始化 直接返回成功
-        if (!this._isInit) {
-            console.warn(`UI包信息未配置 将手动管理所有UI包资源的加载，如果需要配置，请使用 【UIManager.initPackageConfig】接口`);
-            listenter.complete();
-            return;
-        }
-        // 不需要包资源 直接返回成功
-        if (!this.hasWindowPkg(windowName)) {
-            listenter.complete();
-            return;
-        }
-        if (this._waitRef++ <= 0) {
-            // 调用注入的回调函数 用来显示等待窗
-            (_a = this._showWaitWindow) === null || _a === void 0 ? void 0 : _a.call(this);
-        }
-        this.loadPackages({
-            pkgs: this.getWindowPkgs(windowName),
-            complete: () => {
-                var _a;
-                if (--this._waitRef <= 0) {
-                    // 调用注入的回调函数 关闭等待窗
-                    listenter.complete();
-                    (_a = this._hideWaitWindow) === null || _a === void 0 ? void 0 : _a.call(this);
-                }
-            },
-            fail: (pkgs) => {
-                var _a, _b;
-                console.warn(`界面${windowName}打开失败`);
-                listenter.fail(pkgs);
-                (_a = this._fail) === null || _a === void 0 ? void 0 : _a.call(this, windowName, "UI包加载失败", pkgs);
-                if (--this._waitRef <= 0) {
-                    // 调用注入的回调函数 关闭等待窗
-                    (_b = this._hideWaitWindow) === null || _b === void 0 ? void 0 : _b.call(this);
-                }
-            }
-        });
-    }
-    addResRef(windowName) {
-        if (!this._isInit) {
-            return;
-        }
-        // 不需要包资源 直接返回成功
-        if (!this.hasWindowPkg(windowName)) {
-            return;
-        }
-        let pkgs = this.getWindowPkgs(windowName);
-        for (const pkg of pkgs) {
-            this.addRef(pkg);
-        }
-    }
-    /**
-     * 释放窗口资源
-     * @param windowName 窗口名
-     */
-    releaseWindowRes(windowName) {
-        if (!this._isInit || !this.hasWindowPkg(windowName)) {
-            return;
-        }
-        let pkgs = this.getWindowPkgs(windowName);
-        for (const pkg of pkgs) {
-            this.decRef(pkg);
-        }
-    }
-    /**
-     * 加载fgui包
-     * @param pkgs 包名集合
-     * @param progress 进度回调
-     * @param complete 加载完成回调
-     */
-    loadPackages(res) {
-        // 过滤已经加载的包
-        let needLoadPkgs = res.pkgs.filter(pkg => this.getRef(pkg) <= 0);
-        let successPkgs = [];
-        let failPkgs = [];
-        let total = needLoadPkgs.length;
-        if (total <= 0) {
-            res.complete();
-            return;
-        }
-        for (const pkg of needLoadPkgs) {
-            let bundleName = this.getPkgBundle(pkg);
-            let bundle = bundleName === "resources" ? resources : assetManager.getBundle(bundleName);
-            if (!bundle) {
-                throw new Error(`UI包【${pkg}】所在的bundle【${bundleName}】未加载`);
-            }
-            UIPackage.loadPackage(bundle, this.getPkgPath(pkg), (err) => {
-                total--;
-                err ? failPkgs.push(pkg) : successPkgs.push(pkg);
-                if (total > 0) {
-                    return;
-                }
-                if (failPkgs.length > 0) {
-                    res.fail(failPkgs);
-                }
-                else {
-                    res.complete();
-                }
-            });
-        }
-    }
-    /** 获取UI包所在的bundle名 */
-    getPkgBundle(pkg) {
-        return this._pkgBundles.get(pkg) || "resources";
-    }
-    /** 获取UI包在bundle中的路径 */
-    getPkgPath(pkg) {
-        let bundle = this._pkgBundles.get(pkg);
-        return this._uiPaths[bundle] + pkg;
-    }
-    /** 获取窗口对应的包名列表 */
-    getWindowPkgs(windowName) {
-        if (this._windowPkgs.has(windowName)) {
-            return this._windowPkgs.get(windowName);
-        }
-        return [];
-    }
-    hasWindowPkg(windowName) {
-        return this._windowPkgs.has(windowName);
-    }
-    /** 获取包的引用计数 */
-    getRef(pkg) {
-        return this._pkgRefs[pkg] ? this._pkgRefs[pkg] : 0;
-    }
-    /** 增加包的引用计数 */
-    addRef(pkg) {
-        this._pkgRefs[pkg] = this.getRef(pkg) + 1;
-    }
-    /** 减少包的引用计数 */
-    decRef(pkg) {
-        this._pkgRefs[pkg] = this.getRef(pkg) - 1;
-        if (this.getRef(pkg) <= 0) {
-            delete this._pkgRefs[pkg];
-            // 如果需要立即释放 释放包资源
-            if (this._imReleasePackages.has(pkg)) {
-                UIPackage.removePackage(pkg);
-            }
-        }
-    }
-}
-
 /**
  * @Author: Gongxh
  * @Date: 2024-12-08
@@ -1671,7 +2092,6 @@ let CocosWindowContainer = class CocosWindowContainer extends Component {
         super(...arguments);
         this.ignoreQuery = false;
         this.swallowTouch = false;
-        this.bgAlpha = 0.75;
     }
     /**
      * 初始化窗口容器
@@ -1687,7 +2107,7 @@ let CocosWindowContainer = class CocosWindowContainer extends Component {
         root.opaque = this.swallowTouch;
         root.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
         GRoot.inst.addChild(root);
-        UIManager._addWindowGroup(new WindowGroup(name, root, this.ignoreQuery, this.swallowTouch, this.bgAlpha));
+        WindowManager.addWindowGroup(new WindowGroup(name, root, this.ignoreQuery, this.swallowTouch));
     }
 };
 __decorate([
@@ -1696,48 +2116,64 @@ __decorate([
 __decorate([
     property$1({ displayName: "吞噬触摸事件", tooltip: "窗口组是否会吞噬触摸事件，防止层级下的窗口接收触摸事件" })
 ], CocosWindowContainer.prototype, "swallowTouch", void 0);
-__decorate([
-    property$1({ displayName: "底部遮罩透明度", tooltip: "底部半透明遮罩的默认透明度", min: 0, max: 1, step: 0.01 })
-], CocosWindowContainer.prototype, "bgAlpha", void 0);
 CocosWindowContainer = __decorate([
     ccclass$1("CocosWindowContainer"),
-    menu$1("kunpo/UI/UIContainer")
+    menu$1("bit/UIContainer")
 ], CocosWindowContainer);
 
 const { ccclass, menu, property } = _decorator;
-let UIModule = class UIModule extends Component {
+let UIModule = class UIModule extends Module {
     constructor() {
         super(...arguments);
+        this.ui_config = null;
+        this.bgAlpha = 0.75;
+        this.autoReleaseUIRes = true;
         /** 模块名称 */
         this.moduleName = "UI模块";
     }
-    /** 模块初始化 (内部使用) @internal */
-    init() {
+    onInit() {
+        this.ui_config && PropsHelper.setConfig(this.ui_config.json);
+        ResLoader.setAutoRelease(this.autoReleaseUIRes);
+        // 设置底部遮罩的默认透明度
+        WindowManager.bgAlpha = this.bgAlpha;
         /** 初始化窗口管理系统 */
-        UIManager._init(new WindowResPool());
         GRoot.create();
         debug("初始化 WindowContainers");
-        for (const child of this.node.children) {
-            const containerComponent = child.getComponent(CocosWindowContainer);
-            containerComponent === null || containerComponent === void 0 ? void 0 : containerComponent.init();
+        const alphaGraph = new GGraph();
+        alphaGraph.touchable = false;
+        alphaGraph.name = "bgAlpha";
+        alphaGraph.setPosition(Screen.ScreenWidth * 0.5, Screen.ScreenHeight * 0.5);
+        alphaGraph.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+        alphaGraph.setPivot(0.5, 0.5, true);
+        alphaGraph.visible = false;
+        GRoot.inst.addChild(alphaGraph);
+        WindowManager.setAlphaGraph(alphaGraph);
+        for (const container of this.getComponentsInChildren(CocosWindowContainer)) {
+            container.init();
         }
-        // fgui.UIObjectFactory.setLoaderExtension(GLoader);
-        // this._uiInitializer = new UIInitializer(this.node, this.getPackageLoader());
-        // this._uiInitializer.init(this.reAdaptWhenScreenResize, this.fullIfWideScreen);
         this.node.destroyAllChildren();
-        /** 注册窗口信息 */
-        UIManager.registerUI();
-        _uidecorator.setRegisterFinish();
-        this.onInit();
+        Adapter.instance.addResizeListener(this.onScreenResize.bind(this));
     }
-    /** 模块初始化完成后调用的函数 */
-    onInit() {
-        debug("UIModule init complete");
+    /**
+     * 屏幕大小改变时被调用
+     * @internal
+     */
+    onScreenResize(...args) {
+        WindowManager.onScreenResize();
     }
 };
+__decorate([
+    property({ type: JsonAsset, displayName: "配置文件", tooltip: "编辑器:https://store.cocos.com/app/detail/7213 导出的配置文件" })
+], UIModule.prototype, "ui_config", void 0);
+__decorate([
+    property({ displayName: "底部遮罩透明度", tooltip: "半透明遮罩的默认透明度", min: 0, max: 1, step: 0.01 })
+], UIModule.prototype, "bgAlpha", void 0);
+__decorate([
+    property({ displayName: "自动释放UI资源", tooltip: "界面关闭时自动释放加载的资源" })
+], UIModule.prototype, "autoReleaseUIRes", void 0);
 UIModule = __decorate([
     ccclass("UIModule"),
-    menu("kunpo/UIModule")
+    menu("bit/UIModule")
 ], UIModule);
 
-export { AdapterType, UIHeader, UIManager, UIModule, Window, WindowGroup, WindowHeaderInfo, WindowType, _uidecorator };
+export { AdapterType, Header, HeaderInfo, UIModule, Window, WindowGroup, WindowManager, WindowType, _uidecorator };