@gongxh/bit-ui 0.0.1

package/dist/bit-ui.mjs

@@ -0,0 +1,1743 @@
+import { Screen, debug } from '@gongxh/bit-core';
+import { GComponent, UIObjectFactory, GGraph, UIPackage, GRoot } from 'fairygui-cc';
+import { Color, resources, assetManager, _decorator, Component } from 'cc';
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 窗口的一些类型配置
+ */
+/** 是否开启调试模式 */
+/** 窗口显示时，对其他窗口的隐藏处理类型 */
+var WindowType;
+(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";
+})(WindowType || (WindowType = {}));
+/** 窗口适配类型，默认全屏 */
+var AdapterType;
+(function (AdapterType) {
+    /** 全屏适配 */
+    AdapterType[AdapterType["Full"] = 0] = "Full";
+    /** 空出刘海 */
+    AdapterType[AdapterType["Bang"] = 1] = "Bang";
+    /** 固定的 不适配 */
+    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();
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-09
+ * @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 = {};
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-26
+ * @Description: 自定义组件扩展帮助类
+ */
+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;
+            }
+            console.debug(`自定义组件注册  组件名:${res.name} 包名:${res.pkg}`);
+            this.registerComponent(ctor, res.pkg, res.name);
+            this._registeredComponents.add(componentKey);
+        }
+    }
+    /**
+     * 动态注册自定义组件
+     * @param ctor 组件构造函数
+     * @param pkg 包名
+     * @param name 组件名
+     */
+    static dynamicRegister(ctor, pkg, name) {
+        const componentKey = `${pkg}/${name}`;
+        if (this._registeredComponents.has(componentKey)) {
+            console.debug(`自定义组件已注册，跳过  组件名:${name} 包名:${pkg}`);
+            return;
+        }
+        debug(`自定义组件注册  组件名:${name} 包名:${pkg}`);
+        this.registerComponent(ctor, pkg, name);
+        this._registeredComponents.add(componentKey);
+    }
+    /**
+     * 注册自定义组件信息
+     * @param info
+     * @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);
+    }
+}
+/** 已注册的组件集合 @internal */
+ComponentExtendHelper._registeredComponents = new Set();
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-07
+ * @Description: 窗口管理类
+ */
+class UIManager {
+    /** 配置UI包的一些信息 (可以不配置 完全手动管理) */
+    static initPackageConfig(res) {
+        this._resPool.initPackageConfig(res);
+    }
+    /**
+     * 异步打开一个窗口 (如果UI包的资源未加载, 会自动加载 配合 UIManager.initPackageConfig一起使用)
+     * @param windowName 窗口名
+     * @param userdata 用户数据
+     */
+    static showWindow(windowName, userdata) {
+        return new Promise((resolve, reject) => {
+            this._resPool.loadWindowRes(windowName, {
+                complete: () => {
+                    this.showWindowIm(windowName, userdata);
+                    resolve();
+                },
+                fail: (pkgs) => {
+                    reject(pkgs);
+                }
+            });
+        });
+    }
+    /**
+     * 显示指定名称的窗口，并传递可选的用户数据。(用于已加载过资源的窗口)
+     * @param windowName - 窗口的名称。
+     * @param userdata - 可选参数，用于传递给窗口的用户数据。
+     */
+    static showWindowIm(windowName, userdata) {
+        const info = this._resPool.get(windowName);
+        const windowGroup = this.getWindowGroup(info.group);
+        this._resPool.addResRef(windowName);
+        windowGroup.showWindow(info, userdata);
+    }
+    /**
+     * 关闭窗口
+     * @param windowName 窗口名
+     */
+    static closeWindow(windowName) {
+        if (!this._windows.has(windowName)) {
+            console.warn(`窗口不存在 ${windowName} 不需要关闭`);
+            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);
+            }
+        }
+    }
+    /**
+     * 关闭所有窗口
+     * @param ignoreNames 忽略关闭的窗口名
+     */
+    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();
+        }
+    }
+    /**
+     * 获取当前最顶层的窗口实例。
+     * @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());
+            }
+        }
+        return null;
+    }
+    /**
+     * 根据窗口名称获取窗口实例。
+     * @template T 窗口类型，必须继承自IWindow接口。
+     * @param name 窗口的名称。
+     * @returns 如果找到窗口，则返回对应类型的窗口实例；否则返回null。
+     */
+    static getWindow(name) {
+        return this._windows.get(name);
+    }
+    /**
+     * 检查是否存在指定名称的窗口。
+     * @param name 窗口的名称。
+     * @returns 如果存在指定名称的窗口，则返回 true，否则返回 false。
+     */
+    static hasWindow(name) {
+        return this._windows.has(name);
+    }
+    /**
+     * 根据给定的组名获取窗口组。如果组不存在，则抛出错误。
+     * @param groupName 窗口组的名称。
+     * @returns 返回找到的窗口组。
+     */
+    static getWindowGroup(groupName) {
+        if (this._groups.has(groupName)) {
+            return this._groups.get(groupName);
+        }
+        throw new Error(`UIManager.getWindowGroup: window group 【${groupName}】 not found`);
+    }
+    /**
+     * 获取当前顶层窗口组的名称。
+     * 返回第一个包含至少一个窗口的窗口组名称。(该方法只检查不忽略查询的窗口组)
+     * 如果没有找到任何包含窗口的组，则返回空字符串。
+     */
+    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 "";
+    }
+    /**
+     * 初始化窗口管理器，设置资源池。 （框架内部使用）
+     * @param resPool - 窗口资源池实例。
+     * @internal
+     */
+    static _init(resPool) {
+        this._resPool = resPool;
+    }
+    /**
+     * 向窗口管理器添加一个新窗口。 (框架内部使用)
+     * @param name 窗口的唯一标识符。
+     * @param window 要添加的窗口对象，需实现 IWindow 接口。
+     * @internal
+     */
+    static _addWindow(name, window) {
+        this._windows.set(name, window);
+    }
+    /**
+     * 移除指定名称的窗口。 (框架内部使用)
+     * @param name 窗口的名称。
+     * @internal
+     */
+    static _removeWindow(name) {
+        if (this.hasWindow(name)) {
+            this._windows.get(name)._close();
+            this._windows.delete(name);
+            this._resPool.releaseWindowRes(name);
+        }
+    }
+    /**
+     * 注册所有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);
+        }
+        // 组件注册
+        ComponentExtendHelper.register();
+    }
+    /** 动态注册窗口到资源池中 */
+    static dynamicRegisterWindow(ctor, group, pkg, name, bundle) {
+        debug(`窗口注册  窗口名:${name} 包名:${pkg} 组名:${group}`);
+        this._resPool.add(ctor, group, pkg, name, bundle);
+    }
+    /** 动态注册窗口header到资源池中 */
+    static dynamicRegisterHeader(ctor, pkg, name, bundle) {
+        debug(`header注册  header名:${name} 包名:${pkg}`);
+        this._resPool.addHeader(ctor, pkg, name, bundle);
+    }
+    /**
+     * 向窗口管理器添加一个窗口组 如果窗口组名称已存在，则抛出错误. (内部方法)
+     * @param group 要添加的窗口组
+     * @internal
+     */
+    static _addWindowGroup(group) {
+        if (this._groups.has(group.name)) {
+            throw new Error(`UIManager._addWindowGroup: window group 【${group.name}】 already exists`);
+        }
+        this._groups.set(group.name, group);
+        // 不忽略查询 加到列表中
+        !group.isIgnore && this._queryGroupNames.push(group.name);
+    }
+    /**
+     * 屏幕大小改变时 调用所有窗口的screenResize方法 (内部方法)
+     * @internal
+     */
+    static _screenResize() {
+        this._windows.forEach((window) => {
+            window.screenResize();
+        });
+        this._groups.forEach((group) => {
+            group._screenResize();
+        });
+    }
+    /**
+     * 获取资源池实例 (内部方法)
+     * @returns {WindowResPool} 资源池实例
+     * @internal
+     */
+    static _getResPool() {
+        return this._resPool;
+    }
+}
+/** 窗口组 @internal */
+UIManager._groups = new Map();
+/** 不忽略查询的窗口组名 @internal */
+UIManager._queryGroupNames = [];
+/** 所有窗口全部放到这个map中 @internal */
+UIManager._windows = new Map();
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-11
+ * @Description: UI 装饰器
+ */
+var _uidecorator;
+(function (_uidecorator) {
+    /** @internal */
+    const UIPropMeta = "__uipropmeta__";
+    /** @internal */
+    const UICBMeta = "__uicbmeta__";
+    /** @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]));
+    }
+    /** 获取窗口注册信息 */
+    function getWindowMaps() {
+        return uiclassMap;
+    }
+    _uidecorator.getWindowMaps = getWindowMaps;
+    /**
+     * 窗口装饰器
+     * @param {string} groupName 窗口组名称
+     * @param {string} pkgName fgui包名
+     * @param {string} name 窗口名 (与fgui中的组件名一一对应)
+     */
+    function uiclass(groupName, pkgName, name, bundle) {
+        /** target 类的构造函数 */
+        return function (ctor) {
+            // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
+            const originalCtor = ctor;
+            uiclassMap.set(originalCtor, {
+                ctor: ctor, // 存储实际的构造函数（可能被包装过）
+                props: ctor[UIPropMeta] || null,
+                callbacks: ctor[UICBMeta] || null,
+                controls: ctor[UIControlMeta] || null,
+                transitions: ctor[UITransitionMeta] || null,
+                res: {
+                    group: groupName,
+                    pkg: pkgName,
+                    name: name,
+                    bundle: bundle || "",
+                },
+            });
+            // 首次引擎注册完成后 动态注册窗口，使用实际的构造函数
+            _registerFinish && UIManager.dynamicRegisterWindow(ctor, groupName, pkgName, name, bundle || "");
+            return ctor;
+        };
+    }
+    _uidecorator.uiclass = uiclass;
+    /** 用来存储组件注册信息 @internal */
+    let uicomponentMap = new Map();
+    /** 获取组件注册信息 */
+    function getComponentMaps() {
+        return uicomponentMap;
+    }
+    _uidecorator.getComponentMaps = getComponentMaps;
+    /**
+     * 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] || {})}<`);
+            uicomponentMap.set(originalCtor, {
+                ctor: ctor, // 存储实际的构造函数（可能被包装过）
+                props: ctor[UIPropMeta] || null,
+                callbacks: ctor[UICBMeta] || null,
+                controls: ctor[UIControlMeta] || null,
+                transitions: ctor[UITransitionMeta] || null,
+                res: {
+                    pkg: pkg,
+                    name: name,
+                }
+            });
+            // 首次引擎注册完成后 动态注册自定义组件，使用实际的构造函数
+            _registerFinish && ComponentExtendHelper.dynamicRegister(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) {
+        return function (ctor) {
+            // 检查是否有原始构造函数引用（由其他装饰器如 @dataclass 提供）
+            const originalCtor = ctor;
+            // log(`pkg:【${pkg}】 uiheader prop >${JSON.stringify(ctor[UIPropMeta] || {})}<`);
+            uiheaderMap.set(originalCtor, {
+                ctor: ctor, // 存储实际的构造函数（可能被包装过）
+                props: ctor[UIPropMeta] || null,
+                callbacks: ctor[UICBMeta] || null,
+                controls: ctor[UIControlMeta] || null,
+                transitions: ctor[UITransitionMeta] || null,
+                res: {
+                    pkg: pkg,
+                    name: name,
+                    bundle: bundle || "",
+                }
+            });
+            // 首次引擎注册完成后 动态注册窗口header，使用实际的构造函数
+            _registerFinish && UIManager.dynamicRegisterHeader(ctor, pkg, name, bundle || "");
+            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, UIPropMeta)[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, UIControlMeta)[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, UITransitionMeta)[name] = 1;
+    }
+    _uidecorator.uitransition = uitransition;
+    /**
+     * 方法装饰器 (给点击事件用)
+     * @param {Object} target 实例成员的类的原型
+     * @param {string} name 方法名
+     */
+    function uiclick(target, name, descriptor) {
+        // debug("方法装饰器:", target.constructor, name, descriptor);
+        getObjectProp(target.constructor, UICBMeta)[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 () {
+    return _uidecorator.getWindowMaps();
+};
+_global["getKunpoRegisterComponentMaps"] = function () {
+    return _uidecorator.getComponentMaps();
+};
+_global["getKunpoRegisterHeaderMaps"] = function () {
+    return _uidecorator.getHeaderMaps();
+};
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-14
+ * @Description: 窗口基类和fgui组件对接
+ */
+class UIWindow 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;
+    }
+    /**
+     * 初始化方法 (框架内部使用)
+     * @param swallowTouch 是否吞噬触摸事件
+     * @param bgAlpha 底部遮罩的透明度
+     * @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;
+        this.onInit();
+    }
+    /**
+     * 适配窗口
+     * @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) {
+            case AdapterType.Full:
+                this.setSize(Screen.ScreenWidth, Screen.ScreenHeight, true);
+                break;
+            case AdapterType.Bang:
+                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 用户自定义数据
+     * @internal
+     */
+    _show(userdata) {
+        this.visible = true;
+        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:
+ */
+class Window extends UIWindow {
+    onAdapted() {
+    }
+    /**
+     * 窗口关闭时的处理逻辑。
+     * 子类可以重写此方法以实现自定义的关闭行为。
+     */
+    onClose() {
+    }
+    /**
+     * 窗口显示时的回调函数。
+     * @param userdata 可选参数，传递给窗口显示时的用户数据。
+     */
+    onShow(userdata) {
+    }
+    /**
+     * 隐藏窗口时的处理逻辑。
+     * 重写此方法以实现自定义的隐藏行为。
+     */
+    onHide() {
+    }
+    /**
+     * 当窗口从隐藏状态变为显示状态时调用。
+     * 这个方法可以被子类重写以实现特定的显示逻辑。
+     */
+    onShowFromHide() {
+    }
+    /**
+     * 当窗口被覆盖时触发的事件处理函数。
+     * 子类可以重写此方法以添加自定义行为。
+     */
+    onCover() {
+    }
+    /**
+     * 恢复窗口状态时的处理逻辑。
+     * 此方法在窗口从隐藏或最小化状态恢复时被调用。
+     */
+    onRecover() {
+    }
+    /**
+     * 空白区域点击事件处理函数。
+     * 当用户点击窗口的空白区域时触发此方法。
+     */
+    onEmptyAreaClick() {
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2024-12-08
+ * @Description: 窗口组 (在同一个窗口容器的上的窗口)
+ */
+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;
+    }
+    /**
+     * 添加窗口到显示节点
+     * @param window 窗口
+     * @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;
+    }
+    /**
+     * 移除指定名称的窗口。
+     * @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);
+        }
+        this._processHeaderStatus();
+    }
+    /**
+     * 将指定名称的窗口移动到窗口组的最顶层。
+     * @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;
+    }
+    /**
+     * 处理index下层窗口的隐藏状态的私有方法。递归调用
+     * @param index - 窗口索引
+     * @param isRecursion - 是否递归调用
+     * @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);
+    }
+    /**
+     * 新创建窗口时，根据新创建的窗口类型
+     * 处理上一个窗口或者所有窗口的关闭
+     * @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;
+        }
+    }
+    /**
+     * 处理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);
+            }
+        }
+    }
+    /**
+     * 调整指定窗口的透明度图形。并根据窗口的背景透明度绘制半透明遮罩。
+     * @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;
+    }
+    /**
+     * 获取窗口组中顶部窗口的名称。
+     * @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();
+            }
+        }
+    }
+    /**
+     * 获取顶部资源栏 (内部方法)
+     * @param name 资源栏的名称
+     * @internal
+     */
+    _getHeader(name) {
+        return this._headers.get(name);
+    }
+    /** 屏幕大小改变时被调用 (内部方法) @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);
+    }
+    /**
+     * 关闭窗口组中的所有窗口
+     */
+    closeAllWindow() {
+        while (this.size > 0) {
+            let name = this.getTopWindowName();
+            UIManager.closeWindow(name);
+        }
+    }
+}
+
+/**
+ * @Author: Gongxh
+ * @Date: 2025-01-10
+ * @Description: 窗口顶部资源栏信息
+ */
+class WindowHeaderInfo {
+    /**
+     * 创建 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;
+    }
+}
+
+/******************************************************************************
+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;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    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
+ * @Description:
+ */
+const { ccclass: ccclass$1, property: property$1, menu: menu$1 } = _decorator;
+let CocosWindowContainer = class CocosWindowContainer extends Component {
+    constructor() {
+        super(...arguments);
+        this.ignoreQuery = false;
+        this.swallowTouch = false;
+        this.bgAlpha = 0.75;
+    }
+    /**
+     * 初始化窗口容器
+     * @internal
+     */
+    init() {
+        let name = this.node.name;
+        debug(`\tUIContainer name:${name} 忽略顶部窗口查询:${this.ignoreQuery} 吞噬触摸事件:${this.swallowTouch}`);
+        const root = new GComponent();
+        root.name = name;
+        root.node.name = name;
+        root.visible = false;
+        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));
+    }
+};
+__decorate([
+    property$1({ displayName: "忽略顶部窗口查询", tooltip: "当通过窗口管理器获取顶部窗口时，是否忽略查询" })
+], CocosWindowContainer.prototype, "ignoreQuery", void 0);
+__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")
+], CocosWindowContainer);
+
+const { ccclass, menu, property } = _decorator;
+let UIModule = class UIModule extends Component {
+    constructor() {
+        super(...arguments);
+        /** 模块名称 */
+        this.moduleName = "UI模块";
+    }
+    /** 模块初始化 (内部使用) @internal */
+    init() {
+        /** 初始化窗口管理系统 */
+        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();
+        }
+        // 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();
+    }
+    /** 模块初始化完成后调用的函数 */
+    onInit() {
+        debug("UIModule init complete");
+    }
+};
+UIModule = __decorate([
+    ccclass("UIModule"),
+    menu("kunpo/UIModule")
+], UIModule);
+
+export { AdapterType, UIHeader, UIManager, UIModule, Window, WindowGroup, WindowHeaderInfo, WindowType, _uidecorator };