@xiacg/exia-fgui 1.0.2

package/dist/exia-fgui.cjs

@@ -0,0 +1,2245 @@
+'use strict';
+
+var fairyguiCc = require('fairygui-cc');
+var exiaCore = require('@xiacg/exia-core');
+var cc = require('cc');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * @Description: 窗口的一些类型配置
+ */
+/** 是否开启调试模式 */
+/** 窗口显示时，对其他窗口的隐藏处理类型 */
+exports.WindowType = void 0;
+(function (WindowType) {
+    /** 不做任何处理 */
+    WindowType[WindowType["Normal"] = 0] = "Normal";
+    /** 关闭所有 */
+    WindowType[WindowType["CloseAll"] = 1] = "CloseAll";
+    /** 关闭上一个 */
+    WindowType[WindowType["CloseOne"] = 2] = "CloseOne";
+    /** 隐藏所有 */
+    WindowType[WindowType["HideAll"] = 4] = "HideAll";
+    /** 隐藏上一个 */
+    WindowType[WindowType["HideOne"] = 8] = "HideOne";
+})(exports.WindowType || (exports.WindowType = {}));
+/** 窗口适配类型，默认全屏 */
+exports.AdapterType = void 0;
+(function (AdapterType) {
+    /** 全屏适配 */
+    AdapterType[AdapterType["Full"] = 0] = "Full";
+    /** 空出刘海 */
+    AdapterType[AdapterType["Bang"] = 1] = "Bang";
+    /** 固定的 不适配 */
+    AdapterType[AdapterType["Fixed"] = 2] = "Fixed";
+})(exports.AdapterType || (exports.AdapterType = {}));
+/** 定义装饰器元数据的key */
+var MetadataKey;
+(function (MetadataKey) {
+    /** 属性 */
+    MetadataKey["prop"] = "__uipropmeta__";
+    /** 回调 */
+    MetadataKey["callback"] = "__uicbmeta__";
+    /** 控制器 */
+    MetadataKey["control"] = "__uicontrolmeta__";
+    /** 动画 */
+    MetadataKey["transition"] = "__uitransitionmeta__";
+    /** 原始名称 */
+    MetadataKey["originalName"] = "__UI_ORIGINAL_NAME__";
+})(MetadataKey || (MetadataKey = {}));
+
+/**
+ * @Description: 属性辅助类
+ */
+/** @internal */
+class PropsHelper {
+    /** @internal */
+    static setConfig(config) {
+        this._config = config;
+    }
+    /** 序列化属性 @internal */
+    static serializeProps(component, packageName, componentName) {
+        if (!this._config) {
+            return;
+        }
+        const config = this._config[packageName];
+        if (!config) {
+            return;
+        }
+        componentName = componentName || component.name;
+        const propsInfo = config[componentName];
+        if (!propsInfo) {
+            return;
+        }
+        // 设置属性
+        const props = propsInfo.props;
+        this.serializationPropsNode(component, props);
+        // 设置回调
+        const callbacks = propsInfo.callbacks;
+        this.serializationCallbacksNode(component, callbacks);
+        // 设置控制器
+        const controls = propsInfo.controls;
+        this.serializationControlsNode(component, controls);
+        // 设置动画
+        const transitions = propsInfo.transitions;
+        this.serializationTransitionsNode(component, transitions);
+    }
+    /** 给界面中定义的属性赋值 @internal */
+    static serializationPropsNode(component, props) {
+        const propsCount = props.length;
+        // [name1, len, ...props1, name2, len, ...props2, ...]
+        let index = 0;
+        while (index < propsCount) {
+            const propName = props[index++];
+            const endIndex = index + props[index];
+            let uinode = component;
+            while (++index <= endIndex) {
+                uinode = uinode.getChildAt(props[index]);
+                if (!uinode) {
+                    console.warn(`无法对UI类（${component.name}）属性（${propName}）赋值，请检查节点配置是否正确`);
+                    break;
+                }
+            }
+            component[propName] = uinode == component ? null : uinode;
+        }
+    }
+    /** 给界面中定义的回调赋值 @internal */
+    static serializationCallbacksNode(component, callbacks) {
+        const propsCount = callbacks.length;
+        // [name1, len, ...props1, name2, len, ...props2, ...]
+        let index = 0;
+        while (index < propsCount) {
+            const propName = callbacks[index++];
+            const endIndex = index + callbacks[index];
+            let uinode = component;
+            while (++index <= endIndex) {
+                uinode = uinode.getChildAt(callbacks[index]);
+                if (!uinode) {
+                    console.warn(`无法对UI类（${component.name}）的（${propName}）设置回调，请检查节点配置是否正确`);
+                    break;
+                }
+            }
+            if (uinode != component) {
+                uinode.onClick(component[propName], component);
+            }
+        }
+    }
+    /** 给界面中定义的控制器赋值 @internal */
+    static serializationControlsNode(component, controls) {
+        const controlsCount = controls.length;
+        let index = 0;
+        while (index < controlsCount) {
+            const propName = controls[index];
+            const controlName = controls[index + 1];
+            const controller = component.getController(controlName);
+            if (!controller) {
+                console.warn(`无法对UI类（${component.name}）的（${propName}）设置控制器，请检查配置是否正确`);
+                break;
+            }
+            component[propName] = controller;
+            index += 2;
+        }
+    }
+    /** 给界面中定义的动画赋值 @internal */
+    static serializationTransitionsNode(component, transitions) {
+        const transitionsCount = transitions.length;
+        let index = 0;
+        while (index < transitionsCount) {
+            const propName = transitions[index];
+            const transitionName = transitions[index + 1];
+            const transition = component.getTransition(transitionName);
+            if (!transition) {
+                console.warn(`无法对UI类（${component.name}）的（${propName}）设置动画，请检查配置是否正确`);
+                break;
+            }
+            component[propName] = transition;
+            index += 2;
+        }
+    }
+}
+/** @internal */
+PropsHelper._config = {};
+
+/**
+ * @Description: 信息池 注册的窗口、header、自定义组件的信息
+ */
+/** @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;
+        }
+        exiaCore.debug(`窗口注册  窗口名:${name} 包名:${pkg} 组名:${group}`);
+        this._windowInfos.set(name, {
+            ctor: ctor,
+            group: group,
+            pkgName: pkg,
+            name: name,
+        });
+        // 窗口组件扩展
+        fairyguiCc.UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+        this.addWindowPkg(name, pkg);
+        if (pkgs.length > 0) {
+            for (const pkg of pkgs) {
+                this.addWindowPkg(name, pkg);
+            }
+        }
+    }
+    /**
+     * 注册窗口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;
+        }
+        exiaCore.debug(`header注册  header名:${name} 包名:${pkg}`);
+        this._headerInfos.set(name, {
+            ctor: ctor,
+            pkgName: pkg,
+        });
+        // 窗口header扩展
+        fairyguiCc.UIObjectFactory.setExtension(`ui://${pkg}/${name}`, ctor);
+    }
+    /**
+     * 注册自定义组件信息
+     * @param ctor 组件构造函数
+     * @param pkg 包名
+     * @param name 组件名
+     * @internal
+     */
+    static addComponent(ctor, pkg, name) {
+        const componentKey = `${pkg}/${name}`;
+        if (this._customComponents.has(componentKey)) {
+            console.debug(`自定义组件【${name}】已注册，跳过，请检查是否重复注册`);
+            return;
+        }
+        exiaCore.debug(`自定义组件注册  组件名:${name} 包名:${pkg}`);
+        this._customComponents.add(componentKey);
+        this.registerComponent(ctor, pkg, name);
+    }
+    /**
+     * 是否存在窗口信息
+     * @param name 窗口名
+     * @returns 是否存在
+     * @internal
+     */
+    static has(name) {
+        return this._windowInfos.has(name);
+    }
+    /**
+     * 获取窗口信息
+     * @param name 窗口名
+     * @returns 窗口信息
+     * @internal
+     */
+    static get(name) {
+        if (!this.has(name)) {
+            throw new Error(`窗口【${name}】未注册，请使用 _uidecorator.uiclass 注册窗口`);
+        }
+        return this._windowInfos.get(name);
+    }
+    /**
+     * 是否存在窗口header信息
+     * @param name 窗口header名
+     * @returns 是否存在
+     * @internal
+     */
+    static hasHeader(name) {
+        return this._headerInfos.has(name);
+    }
+    /**
+     * 获取窗口header信息
+     * @param name 窗口header名
+     * @returns 窗口header信息
+     * @internal
+     */
+    static getHeader(name) {
+        if (!this.hasHeader(name)) {
+            throw new Error(`窗口header【${name}】未注册，请使用 _uidecorator.uiheader 注册窗口header`);
+        }
+        return this._headerInfos.get(name);
+    }
+    /**
+     * 设置UI包所在的bundle名
+     * @param pkg 包名
+     * @param bundleName bundle名
+     * @internal
+     */
+    static addBundleName(pkg, bundleName) {
+        if (this._customPackageBundle.has(pkg)) {
+            console.warn(`UI包【${pkg}】已设置过包名`);
+            return;
+        }
+        this._customPackageBundle.set(pkg, bundleName);
+    }
+    /**
+     * 获取UI包所在的bundle名
+     * @param pkg 包名
+     * @returns bundle名
+     * @internal
+     */
+    static getBundleName(pkg) {
+        return this._customPackageBundle.get(pkg) || "resources";
+    }
+    /**
+     * UI包所在的自定义路径
+     * @param pkg 包名
+     * @param path 路径
+     * @internal
+     */
+    static addPackagePath(pkg, path) {
+        if (this._customPackagePath.has(pkg)) {
+            console.warn(`UI包【${pkg}】已设置过自定义路径`);
+            return;
+        }
+        this._customPackagePath.set(pkg, path);
+    }
+    /**
+     * 获取UI包所在的路径
+     * @param pkg 包名
+     * @returns 路径
+     * @internal
+     */
+    static getPackagePath(pkg) {
+        return `${this._customPackagePath.get(pkg) || "ui"}/${pkg}`;
+    }
+    /**
+     * 添加窗口需要的包名
+     * @param windowName 窗口名
+     * @param pkg 包名
+     * @internal
+     */
+    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 windowName 窗口名
+     * @returns 包名列表
+     * @internal
+     */
+    static getWindowPkg(windowName) {
+        if (this._dirty) {
+            this.refreshWindowPackages();
+            this._dirty = false;
+        }
+        return this._windowPkgs.get(windowName) || [];
+    }
+    /**
+     * 添加手动管理资源加载 和 卸载的包名
+     * @param pkgName 包名
+     * @internal
+     */
+    static addManualPackage(pkgName) {
+        this._dirty = true;
+        this._manualPackages.add(pkgName);
+    }
+    /**
+     * 注册自定义组件信息
+     * @param info
+     * @internal
+     */
+    static registerComponent(ctor, pkg, name) {
+        // 自定义组件扩展
+        const onConstruct = function () {
+            PropsHelper.serializeProps(this, pkg, name);
+            this.onInit && this.onInit();
+        };
+        ctor.prototype.onConstruct = onConstruct;
+        const oldDispose = ctor.prototype.dispose;
+        ctor.prototype.dispose = function () {
+            this.onClose && this.onClose();
+            oldDispose.call(this);
+        };
+        // 自定义组件扩展
+        fairyguiCc.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;
+
+/** @internal */
+class ResLoader {
+    /**
+     * 设置UI包加载相关回调函数
+     * @internal
+     */
+    static setCallbacks(callbacks) {
+        this._showWaitWindow = callbacks.showWaitWindow;
+        this._hideWaitWindow = callbacks.hideWaitWindow;
+        this._onLoadFail = callbacks.fail;
+    }
+    /** @internal */
+    static setAutoRelease(auto) {
+        this.autoRelease = auto;
+    }
+    /**
+     * 增加等待窗的引用计数
+     * @internal
+     */
+    static addWaitRef() {
+        var _a;
+        if (this.waitRef++ === 0) {
+            (_a = this._showWaitWindow) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+    }
+    /**
+     * 减少等待窗的引用计数
+     * @internal
+     */
+    static decWaitRef() {
+        var _a;
+        // 修复：防止waitRef变为负数
+        this.waitRef = Math.max(0, this.waitRef - 1);
+        if (this.waitRef === 0) {
+            (_a = this._hideWaitWindow) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+    }
+    /** @internal */
+    static getRef(pkg) {
+        return this.pkgRefs.get(pkg) || 0;
+    }
+    /** @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 windowName 窗口名
+     */
+    static loadWindowRes(windowName) {
+        // 获取窗口需要的资源包
+        let packageNames = InfoPool.getWindowPkg(windowName);
+        if (packageNames.length <= 0) {
+            return Promise.resolve();
+        }
+        return this.loadUIPackages(packageNames, windowName);
+    }
+    /**
+     * 卸载窗口需要的包
+     * @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 loadUIPackages(packages, windowName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 修复：防止并发加载相同的包
+            // 检查是否有包正在加载，如果有则等待其完成
+            const waitPromises = [];
+            for (const pkg of packages) {
+                const loadingPromise = this.loadingPromises.get(pkg);
+                if (loadingPromise) {
+                    waitPromises.push(loadingPromise);
+                }
+            }
+            // 等待所有正在加载的包完成
+            if (waitPromises.length > 0) {
+                yield Promise.all(waitPromises);
+            }
+            // 先找出来所有需要加载的包名
+            let list = packages.filter((pkg) => this.getRef(pkg) <= 0);
+            if (list.length <= 0) {
+                // 增加引用计数
+                packages.forEach((pkg) => this.addRef(pkg));
+                return;
+            }
+            // 一定有需要加载的资源
+            this.addWaitRef();
+            // 记录成功加载的包，用于失败时回滚
+            const loadedPackages = [];
+            // 创建加载Promise并记录
+            const loadPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // 获取包对应的bundle名
+                    let bundleNames = list.map((pkg) => InfoPool.getBundleName(pkg));
+                    // 加载bundle
+                    yield this.loadBundles(bundleNames, windowName);
+                    // 顺序加载每个UI包，每加载成功一个就记录
+                    for (const pkg of list) {
+                        yield this.loadSingleUIPackage(pkg, windowName);
+                        loadedPackages.push(pkg);
+                    }
+                    // 所有包加载成功后，减少等待窗引用计数
+                    this.decWaitRef();
+                    // 增加包资源的引用计数
+                    packages.forEach((pkg) => this.addRef(pkg));
+                }
+                catch (err) {
+                    // 减少等待窗的引用计数
+                    this.decWaitRef();
+                    // 回滚：卸载已经加载成功的包
+                    loadedPackages.forEach((pkg) => {
+                        fairyguiCc.UIPackage.removePackage(pkg);
+                    });
+                    throw err;
+                }
+                finally {
+                    // 清理加载状态
+                    list.forEach((pkg) => this.loadingPromises.delete(pkg));
+                }
+            }))();
+            // 记录正在加载的包
+            list.forEach((pkg) => this.loadingPromises.set(pkg, loadPromise));
+            yield loadPromise;
+        });
+    }
+    /**
+     * 加载多个bundle（顺序加载）
+     * @param bundleNames bundle名集合
+     * @param windowName 窗口名（用于失败回调）
+     * @internal
+     */
+    static loadBundles(bundleNames, windowName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let unloadedBundleNames = bundleNames.filter((bundleName) => bundleName !== "resources" && !cc.assetManager.getBundle(bundleName));
+            if (unloadedBundleNames.length <= 0) {
+                return;
+            }
+            // 顺序加载每个bundle
+            for (const bundleName of unloadedBundleNames) {
+                yield new Promise((resolve, reject) => {
+                    cc.assetManager.loadBundle(bundleName, (err, bundle) => {
+                        if (err) {
+                            // 调用失败回调
+                            if (this._onLoadFail) {
+                                this._onLoadFail(windowName, 1, bundleName);
+                            }
+                            reject(new Error(`bundle【${bundleName}】加载失败`));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        });
+    }
+    /**
+     * 加载单个 UI 包
+     * @param pkg 包名
+     * @param windowName 窗口名（用于失败回调）
+     * @internal
+     */
+    static loadSingleUIPackage(pkg, windowName) {
+        return new Promise((resolve, reject) => {
+            let bundleName = InfoPool.getBundleName(pkg);
+            let bundle = bundleName === "resources"
+                ? cc.resources
+                : cc.assetManager.getBundle(bundleName);
+            fairyguiCc.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) {
+                fairyguiCc.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) {
+                fairyguiCc.UIPackage.removePackage(key);
+                this.pkgRefs.delete(key);
+            }
+        }
+    }
+}
+/**
+ * 等待窗口的引用计数
+ * 每次加载开始时 +1 每次加载完成时 -1
+ * @internal
+ */
+ResLoader.waitRef = 0;
+/** 包的引用计数 包名 -> 引用计数 */
+ResLoader.pkgRefs = new Map();
+/** 包的加载状态 包名 -> 加载中的Promise，用于防止并发加载 */
+ResLoader.loadingPromises = new Map();
+/**
+ * 自动释放UI资源
+ * @internal
+ */
+ResLoader.autoRelease = true;
+/** UI包加载回调 - 显示加载等待窗 @internal */
+ResLoader._showWaitWindow = null;
+/** UI包加载回调 - 隐藏加载等待窗 @internal */
+ResLoader._hideWaitWindow = null;
+/** UI包加载回调 - 打开窗口时UI包加载失败 @internal */
+ResLoader._onLoadFail = null;
+
+/**
+ * @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(exiaCore.Screen.ScreenWidth * 0.5, exiaCore.Screen.ScreenHeight * 0.5);
+            this._alphaGraph.setSize(exiaCore.Screen.ScreenWidth, exiaCore.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 && win.bgAlpha > 0) {
+                    topWindow = win;
+                    break;
+                }
+            }
+            if (topWindow) {
+                break;
+            }
+        }
+        // 如果找到了需要遮罩的窗口
+        if (topWindow && topWindow.parent) {
+            // 获取窗口组的根节点
+            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 cc.Color(0, 0, 0, 0);
+/** @internal */
+WindowManager._alphaGraph = null; // 半透明的遮罩
+/** @internal */
+WindowManager._groups = new Map(); // 窗口组
+/** @internal */
+WindowManager._groupNames = []; // 窗口组的名称列表
+/** @internal */
+WindowManager._windows = new Map(); // 所有窗口的引用
+
+/**
+ * @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) || 0) + 1);
+        // 记录窗口和header的关系
+        const windowsSet = this._headerWindowsMap.get(headerName);
+        if (windowsSet) {
+            windowsSet.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) - 1;
+        // 移除映射关系
+        const windowsSet = this._headerWindowsMap.get(headerName);
+        if (windowsSet) {
+            windowsSet.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 = fairyguiCc.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 true;
+        }
+        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的最上层窗口名
+
+/**
+ * @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 __awaiter(this, void 0, void 0, function* () {
+            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();
+                }
+                return window;
+            }
+            else {
+                try {
+                    yield ResLoader.loadWindowRes(info.name);
+                    const window = this.createWindow(info.pkgName, info.name);
+                    this.showAdjustment(window, userdata);
+                    if (lastTopWindow && lastTopWindow.name !== window.name) {
+                        lastTopWindow._toBottom();
+                    }
+                    return window;
+                }
+                catch (err) {
+                    throw 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 = fairyguiCc.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 === exports.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 === exports.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 === exports.WindowType.CloseOne) {
+            // 关闭上一个窗口（倒数第二个，因为最后一个是当前窗口）
+            // 修复：明确检查边界，避免数组越界
+            if (this.size < 2) {
+                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 === exports.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}】不存在，数据结构已损坏`);
+                    continue; // 继续处理其他窗口，而不是直接返回
+                }
+                try {
+                    // 释放header
+                    HeaderManager.releaseHeader(name);
+                    win._close();
+                    WindowManager.removeWindow(name);
+                }
+                catch (err) {
+                    console.error(`关闭窗口【${name}】时发生异常:`, err);
+                    // 即使出错也继续处理其他窗口
+                }
+            }
+            // 清理数组，只保留最后一个（当前窗口）
+            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);
+        }
+    }
+}
+
+/**
+ * @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]));
+}
+exports._uidecorator = void 0;
+(function (_uidecorator) {
+    /** @internal */
+    const uiclassMap = new Map(); // 窗口注册信息
+    /** @internal */
+    const uicomponentMap = new Map(); // 组件注册信息
+    /** @internal */
+    const uiheaderMap = new Map(); // header注册信息
+    /** 获取窗口注册信息 */
+    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, inlinePkgs) {
+        /** target 类的构造函数 */
+        return function (ctor) {
+            // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
+            const originalCtor = ctor;
+            // 给构造函数添加静态属性，存储窗口名称（避免混淆后 constructor.name 变化）
+            ctor[MetadataKey.originalName] = name;
+            uiclassMap.set(originalCtor, {
+                ctor: ctor, // 存储实际的构造函数（可能被包装过）
+                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,
+                },
+            });
+            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;
+    /**
+     * UI组件装饰器
+     * @param {string} pkg 包名
+     * @param {string} name 组件名
+     */
+    function uicom(pkg, name) {
+        return function (ctor) {
+            // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
+            const originalCtor = ctor;
+            // log(`pkg:【${pkg}】 uicom prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            ctor[MetadataKey.originalName] = name;
+            uicomponentMap.set(originalCtor, {
+                ctor: ctor, // 存储实际的构造函数（可能被包装过）
+                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,
+                },
+            });
+            InfoPool.addComponent(ctor, pkg, name);
+            return ctor;
+        };
+    }
+    _uidecorator.uicom = uicom;
+    /**
+     * UI header装饰器
+     * @param {string} pkg 包名
+     * @param {string} name 组件名
+     */
+    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[MetadataKey.prop] || null,
+                callbacks: ctor[MetadataKey.callback] || null,
+                controls: ctor[MetadataKey.control] || null,
+                transitions: ctor[MetadataKey.transition] || null,
+                res: {
+                    pkg: pkg,
+                    name: name,
+                },
+            });
+            InfoPool.addHeader(ctor, pkg, name);
+            return ctor;
+        };
+    }
+    _uidecorator.uiheader = uiheader;
+    /**
+     * UI属性装饰器
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 属性名
+     *
+     * example: @uiprop node: GObject
+     */
+    function uiprop(target, name) {
+        // debug("属性装饰器:", target.constructor, name);
+        getObjectProp(target.constructor, MetadataKey.prop)[name] = 1;
+    }
+    _uidecorator.uiprop = uiprop;
+    /**
+     * UI控制器装饰器
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 属性名
+     *
+     * example: @uicontrol node: GObject
+     */
+    function uicontrol(target, name) {
+        // debug("属性装饰器:", target.constructor, name);
+        getObjectProp(target.constructor, MetadataKey.control)[name] = 1;
+    }
+    _uidecorator.uicontrol = uicontrol;
+    /**
+     * UI动画装饰器
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 属性名
+     *
+     * example: @uitransition node: GObject
+     */
+    function uitransition(target, name) {
+        // debug("属性装饰器:", target.constructor, name);
+        getObjectProp(target.constructor, MetadataKey.transition)[name] = 1;
+    }
+    _uidecorator.uitransition = uitransition;
+    /**
+     * 方法装饰器 (给点击事件用)
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 方法名
+     */
+    function uiclick(target, name, descriptor) {
+        // debug("方法装饰器:", target.constructor, name, descriptor);
+        getObjectProp(target.constructor, MetadataKey.callback)[name] =
+            descriptor.value;
+    }
+    _uidecorator.uiclick = uiclick;
+})(exports._uidecorator || (exports._uidecorator = {}));
+const _global = (globalThis || window || global);
+_global["getKunpoRegisterWindowMaps"] = function () {
+    return exports._uidecorator.getWindowMaps();
+};
+_global["getKunpoRegisterComponentMaps"] = function () {
+    return exports._uidecorator.getComponentMaps();
+};
+_global["getKunpoRegisterHeaderMaps"] = function () {
+    return exports._uidecorator.getHeaderMaps();
+};
+
+/**
+ * @Description: 窗口顶边栏
+ * 窗口顶边资源栏 同组中只会有一个显示
+ */
+class Header extends fairyguiCc.GComponent {
+    constructor() {
+        super(...arguments);
+        /** 窗口适配类型 */
+        this.adapterType = exports.AdapterType.Full;
+    }
+    onAdapted() { }
+    onClose() { }
+    onHide() { }
+    onShowFromHide() { }
+    /**
+     * 是否显示中
+     */
+    isShowing() {
+        return this.visible;
+    }
+    /**
+     * 初始化 (内部方法)
+     * @internal
+     */
+    _init() {
+        this.opaque = false;
+        this.onInit();
+    }
+    /**
+     * 关闭 (内部方法)
+     * @internal
+     */
+    _close() {
+        this.onClose();
+        this.dispose();
+    }
+    /**
+     * 窗口适配
+     * @internal
+     */
+    _adapted() {
+        this.setPosition(exiaCore.Screen.ScreenWidth * 0.5, exiaCore.Screen.ScreenHeight * 0.5);
+        this.setPivot(0.5, 0.5, true);
+        switch (this.adapterType) {
+            case exports.AdapterType.Full:
+                this.setSize(exiaCore.Screen.ScreenWidth, exiaCore.Screen.ScreenHeight, true);
+                break;
+            case exports.AdapterType.Bang:
+                this.setSize(exiaCore.Screen.SafeWidth, exiaCore.Screen.SafeHeight, true);
+                break;
+        }
+        this.onAdapted();
+    }
+    /**
+     * 显示
+     * @param userdata 用户数据
+     * @internal
+     */
+    _show(userdata) {
+        this.visible = true;
+        this.onShow(userdata);
+    }
+    /**
+     * 隐藏
+     * @internal
+     */
+    _hide() {
+        this.visible = false;
+        this.onHide();
+    }
+}
+
+/**
+ * @Description: 窗口顶部资源栏信息
+ */
+class HeaderInfo {
+    /**
+     * 创建 HeaderInfo (类型安全)
+     * @param ctor Header类构造函数
+     * @param userdata 自定义数据
+     * @returns {HeaderInfo}
+     */
+    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;
+    }
+    /**
+     * 通过名称创建 HeaderInfo (非类型安全)
+     * @param name header名称
+     * @param userdata 自定义数据
+     * @returns {HeaderInfo}
+     */
+    static createByName(name, userdata) {
+        const info = new HeaderInfo();
+        info.name = name;
+        info.userdata = userdata;
+        return info;
+    }
+}
+
+/**
+ * @Description: 窗口基类和fgui组件对接
+ */
+class WindowBase extends fairyguiCc.GComponent {
+    constructor() {
+        super(...arguments);
+        /** 窗口类型 */
+        this.type = exports.WindowType.Normal;
+        /** 窗口适配类型 */
+        this.adapterType = exports.AdapterType.Full;
+        /** @internal */
+        this._swallowNode = null; // 吞噬触摸的节点
+        /** @internal */
+        this._isTop = true;
+    }
+    /**
+     * 初始化方法 (框架内部使用)
+     * @param swallowTouch 是否吞噬触摸事件
+     * @param bgAlpha 底部遮罩的透明度
+     * @internal
+     */
+    _init(swallowTouch) {
+        // 窗口本身可能留有安全区的边, 所以需要一个全屏的节点来吞噬触摸事件
+        let bgNode = new fairyguiCc.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();
+    }
+    /**
+     * 适配窗口
+     * @internal
+     */
+    _adapted() {
+        this.setPosition(exiaCore.Screen.ScreenWidth * 0.5, exiaCore.Screen.ScreenHeight * 0.5);
+        this.setPivot(0.5, 0.5, true);
+        switch (this.adapterType) {
+            case exports.AdapterType.Full:
+                this.setSize(exiaCore.Screen.ScreenWidth, exiaCore.Screen.ScreenHeight, true);
+                break;
+            case exports.AdapterType.Bang:
+                this.setSize(exiaCore.Screen.SafeWidth, exiaCore.Screen.SafeHeight, true);
+                break;
+        }
+        // 屏幕的宽高
+        this._swallowNode.setSize(exiaCore.Screen.ScreenWidth, exiaCore.Screen.ScreenHeight, true);
+        // 位置放在窗口的中心
+        this._swallowNode.setPosition(this.width * 0.5, this.height * 0.5);
+        this.onAdapted();
+    }
+    /**
+     * 窗口关闭
+     * @internal
+     */
+    _close() {
+        this.onClose();
+        this.dispose();
+    }
+    /**
+     * 显示窗口 (框架内部使用)
+     * @param userdata 用户自定义数据
+     * @internal
+     */
+    _show(userdata) {
+        this.visible = true;
+        this.onShow(userdata);
+    }
+    /**
+     * 隐藏窗口 (框架内部使用)
+     * @internal
+     */
+    _hide() {
+        this.visible = false;
+        this.onHide();
+    }
+    /**
+     * 从隐藏状态恢复显示
+     * @internal
+     */
+    _showFromHide() {
+        this.visible = true;
+        this.onShowFromHide();
+    }
+    /**
+     * 除忽略的窗口组外, 显示到最上层时
+     * @internal
+     */
+    _toTop() {
+        this._isTop = true;
+        this.onToTop();
+    }
+    /**
+     * 除忽略的窗口组外, 被上层窗口覆盖时
+     * @internal
+     */
+    _toBottom() {
+        this._isTop = false;
+        this.onToBottom();
+    }
+    /**
+     * 设置窗口深度
+     * @param depth 深度
+     * @internal
+     */
+    setDepth(depth) {
+        this.parent.setChildIndex(this, depth);
+    }
+    isShowing() {
+        return this.visible;
+    }
+    /** 是否在最上层显示 (除忽略的窗口组外, 显示到最上层时) */
+    isTop() {
+        return this._isTop;
+    }
+    /** @internal */
+    screenResize() {
+        this._adapted();
+    }
+    /**
+     * 刷新顶部资源栏
+     * 调用这个方法会重新创建 或者 刷新header
+     * 用来在同一个界面显示不同的header
+     */
+    refreshHeader() {
+        HeaderManager.refreshWindowHeader(this.name, this.getHeaderInfo());
+    }
+    /**
+     * 用于在界面中关闭自己
+     */
+    removeSelf() {
+        WindowManager.closeWindowByName(this.name);
+    }
+}
+
+class Window extends WindowBase {
+    onAdapted() { }
+    onHide() { }
+    onShowFromHide() { }
+    onToTop() { }
+    onToBottom() { }
+    /**
+     * 空白区域点击事件处理函数。
+     * 当用户点击窗口的空白区域时触发此方法。
+     */
+    onEmptyAreaClick() { }
+    /**
+     * 获取窗口顶部资源栏数据 默认返回空数组
+     * @returns {HeaderInfo}
+     */
+    getHeaderInfo() {
+        return null;
+    }
+}
+
+const { ccclass: ccclass$1, property: property$1, menu: menu$1 } = cc._decorator;
+let CocosWindowContainer = class CocosWindowContainer extends cc.Component {
+    constructor() {
+        super(...arguments);
+        this.ignoreQuery = false;
+        this.swallowTouch = false;
+    }
+    /**
+     * 初始化窗口容器
+     * @internal
+     */
+    init() {
+        let name = this.node.name;
+        exiaCore.debug(`\tUIContainer name:${name} 忽略顶部窗口查询:${this.ignoreQuery} 吞噬触摸事件:${this.swallowTouch}`);
+        const root = new fairyguiCc.GComponent();
+        root.name = name;
+        root.node.name = name;
+        root.visible = false;
+        root.opaque = this.swallowTouch;
+        root.setSize(exiaCore.Screen.ScreenWidth, exiaCore.Screen.ScreenHeight, true);
+        fairyguiCc.GRoot.inst.addChild(root);
+        WindowManager.addWindowGroup(new WindowGroup(name, root, this.ignoreQuery, this.swallowTouch));
+    }
+};
+__decorate([
+    property$1({
+        displayName: "忽略顶部窗口查询",
+        tooltip: "当通过窗口管理器获取顶部窗口时，是否忽略查询",
+    })
+], CocosWindowContainer.prototype, "ignoreQuery", void 0);
+__decorate([
+    property$1({
+        displayName: "吞噬触摸事件",
+        tooltip: "窗口组是否会吞噬触摸事件，防止层级下的窗口接收触摸事件",
+    })
+], CocosWindowContainer.prototype, "swallowTouch", void 0);
+CocosWindowContainer = __decorate([
+    ccclass$1("CocosWindowContainer"),
+    menu$1("exia/UIContainer")
+], CocosWindowContainer);
+
+const { ccclass, menu, property } = cc._decorator;
+exports.UIModule = class UIModule extends exiaCore.Module {
+    constructor() {
+        super(...arguments);
+        this.ui_config = null;
+        this.bgAlpha = 0.75;
+        this.autoReleaseUIRes = true;
+        /** 模块名称 */
+        this.moduleName = "UI模块";
+    }
+    onInit() {
+        this.ui_config &&
+            PropsHelper.setConfig(this.ui_config.json);
+        ResLoader.setAutoRelease(this.autoReleaseUIRes);
+        // 设置底部遮罩的默认透明度
+        WindowManager.bgAlpha = this.bgAlpha;
+        /** 初始化窗口管理系统 */
+        fairyguiCc.GRoot.create();
+        exiaCore.debug("初始化 WindowContainers");
+        const alphaGraph = new fairyguiCc.GGraph();
+        alphaGraph.touchable = false;
+        alphaGraph.name = "bgAlpha";
+        alphaGraph.setPosition(exiaCore.Screen.ScreenWidth * 0.5, exiaCore.Screen.ScreenHeight * 0.5);
+        alphaGraph.setSize(exiaCore.Screen.ScreenWidth, exiaCore.Screen.ScreenHeight, true);
+        alphaGraph.setPivot(0.5, 0.5, true);
+        alphaGraph.visible = false;
+        fairyguiCc.GRoot.inst.addChild(alphaGraph);
+        WindowManager.setAlphaGraph(alphaGraph);
+        for (const container of this.getComponentsInChildren(CocosWindowContainer)) {
+            container.init();
+        }
+        this.node.destroyAllChildren();
+        exiaCore.Adapter.instance.addResizeListener(this.onScreenResize.bind(this));
+    }
+    /**
+     * 屏幕大小改变时被调用
+     * @internal
+     */
+    onScreenResize(...args) {
+        WindowManager.onScreenResize();
+    }
+};
+__decorate([
+    property({
+        type: cc.JsonAsset,
+        displayName: "配置文件",
+        tooltip: "编辑器导出的配置文件",
+    })
+], exports.UIModule.prototype, "ui_config", void 0);
+__decorate([
+    property({
+        displayName: "底部遮罩透明度",
+        tooltip: "半透明遮罩的默认透明度",
+        min: 0,
+        max: 1,
+        step: 0.01,
+    })
+], exports.UIModule.prototype, "bgAlpha", void 0);
+__decorate([
+    property({
+        displayName: "自动释放UI资源",
+        tooltip: "界面关闭时自动释放加载的资源",
+    })
+], exports.UIModule.prototype, "autoReleaseUIRes", void 0);
+exports.UIModule = __decorate([
+    ccclass("UIModule"),
+    menu("exia/UIIModule")
+], exports.UIModule);
+
+exports.Header = Header;
+exports.HeaderInfo = HeaderInfo;
+exports.Window = Window;
+exports.WindowGroup = WindowGroup;
+exports.WindowManager = WindowManager;