dzkcc-mflow 0.0.18 → 0.0.20

package/README.md

@@ -12,6 +12,7 @@ Cocos模块化流程框架（Modular Flow Framework）是一个为Cocos Creator
 - **UI管理系统**：完整的UI界面管理方案
 - **事件系统**：强大的事件广播和监听机制
 - **资源加载系统**：统一的资源加载和释放管理
+- **HTTP网络请求系统**：简洁易用的HTTP客户端
 - **开发工具**：配套的Cocos Creator编辑器插件
 
 ### 1.3 安装说明
@@ -176,7 +177,87 @@ const spineData = await mf.res.loadSpine(spineComponent, 'path/to/spine');
 mf.res.release('path/to/asset');
 ```
 
-## 6. 开发工具
+## 6. HTTP网络请求系统
+
+### 6.1 HttpManager HTTP管理器
+
+HttpManager提供了简洁易用的HTTP客户端功能，支持常见的HTTP方法：
+
+```typescript
+// GET 请求
+const userData = await mf.http.get('/api/users/123', { includeProfile: true });
+
+// POST 请求
+const newUser = await mf.http.post('/api/users', { 
+    name: 'John', 
+    email: 'john@example.com' 
+});
+
+// PUT 请求
+const updatedUser = await mf.http.put('/api/users/123', { 
+    name: 'John Doe' 
+});
+
+// DELETE 请求
+await mf.http.delete('/api/users/123');
+
+// 自定义请求
+const result = await mf.http.request({
+    url: '/api/upload',
+    method: 'POST',
+    data: formData,
+    headers: {
+        'Authorization': 'Bearer token'
+    },
+    timeout: 30000
+});
+```
+
+### 6.2 功能特性
+
+1. **Promise-based API**：所有请求都返回Promise，支持async/await
+2. **超时控制**：默认10秒超时，可自定义
+3. **自动JSON解析**：自动解析JSON响应
+4. **错误处理**：统一的错误处理机制
+5. **请求拦截**：支持自定义请求头
+6. **URL参数处理**：自动处理GET请求的查询参数
+
+### 6.3 使用示例
+
+```typescript
+// 在Manager中使用
+@manager()
+export class UserManager extends AbstractManager {
+    async getUserProfile(userId: string): Promise<any> {
+        try {
+            const profile = await mf.http.get(`/api/users/${userId}/profile`);
+            return profile;
+        } catch (error) {
+            console.error('Failed to fetch user profile:', error);
+            throw error;
+        }
+    }
+    
+    async updateUser(userId: string, data: any): Promise<any> {
+        try {
+            const result = await mf.http.put(`/api/users/${userId}`, data, {
+                'Authorization': `Bearer ${this.getAuthToken()}`
+            });
+            return result;
+        } catch (error) {
+            console.error('Failed to update user:', error);
+            throw error;
+        }
+    }
+    
+    private getAuthToken(): string {
+        // 获取认证令牌的逻辑
+        return 'your-auth-token';
+    }
+}
+```
+
+## 7. 开发工具
 
 框架配套了Cocos Creator编辑器插件`mflow-tools`，可以：
 
@@ -184,7 +265,7 @@ mf.res.release('path/to/asset');
 2. 自动引用Prefab上需要操作的元素
 3. 自动挂载脚本组件
 
-### 6.1 使用方法
+### 7.1 使用方法
 
 1. 在Prefab中，将需要引用的节点重命名为`#属性名#组件类型`格式，例如：
    - `#titleLabel#Label` 表示引用Label组件
@@ -195,9 +276,9 @@ mf.res.release('path/to/asset');
 
 3. 插件会自动生成基础脚本和业务脚本，并自动设置引用关系
 
-## 7. 完整示例
+## 8. 完整示例
 
-### 7.1 创建Manager
+### 8.1 创建Manager
 
 ```typescript
 @manager()
@@ -220,7 +301,7 @@ export class GameManager extends AbstractManager {
 }
 ```
 
-### 7.2 创建Model
+### 8.2 创建Model
 
 ```typescript
 @model()
@@ -241,7 +322,7 @@ export class GameModel implements IModel {
 }
 ```
 
-### 7.3 创建UI界面
+### 8.3 创建UI界面
 
 ```typescript
 // BaseHomeView.ts (由工具自动生成)
@@ -299,7 +380,7 @@ export class HomeView extends BaseHomeView {
 }
 ```
 
-### 7.4 在场景中使用
+### 8.4 在场景中使用
 
 ```typescript
 // 在游戏启动时
@@ -311,18 +392,20 @@ export class GameApp extends Component {
 }
 ```
 
-## 8. 最佳实践
+## 9. 最佳实践
 
 1. **模块化设计**：将相关的业务逻辑封装在对应的Manager中
 2. **数据驱动**：使用Model管理数据状态
 3. **事件解耦**：通过事件系统实现模块间通信
 4. **资源管理**：使用BaseView自动管理资源加载和释放
 5. **依赖注入**：使用装饰器简化依赖管理
-6. **工具辅助**：使用mflow-tools提高开发效率
+6. **网络请求**：使用HttpManager统一管理网络请求
+7. **工具辅助**：使用mflow-tools提高开发效率
 
-## 9. 注意事项
+## 10. 注意事项
 
 1. 确保在使用框架功能前Core已经初始化
 2. 注意资源的正确加载和释放，避免内存泄漏
 3. 合理使用事件系统，避免事件监听过多影响性能
-4. 使用BaseView的子类时，确保正确实现所有抽象方法
+4. 使用BaseView的子类时，确保正确实现所有抽象方法
+5. 网络请求时注意错误处理和超时设置

package/dist/App.d.ts

@@ -1,4 +1,4 @@
-import { ICore, IUIManager, IEventManager, ICocosResManager } from "./core";
+import { ICore, IUIManager, IEventManager, ICocosResManager, IHttpManager } from "./core";
 /**
  * 对外暴露的全局app对像，用于访问基础能力，为上层业务提供了简洁的访问方式
  *
@@ -9,7 +9,7 @@ export declare class App {
     static readonly log: any;
     static readonly config: any;
     static get gui(): IUIManager;
-    static readonly http: any;
+    static get http(): IHttpManager;
     static readonly socket: any;
     static get res(): ICocosResManager;
     static get event(): IEventManager;

package/dist/App.js

@@ -13,6 +13,9 @@ class App {
     static get gui() {
         return ServiceLocator.getService('UIManager');
     }
+    static get http() {
+        return ServiceLocator.getService('HttpManager');
+    }
     static get res() {
         return ServiceLocator.getService('ResLoader');
     }
@@ -22,7 +25,6 @@ class App {
 }
 App.log = null;
 App.config = null;
-App.http = null;
 App.socket = null;
 App.storage = null;
 App.audio = null;

package/dist/core/Api.d.ts

@@ -28,6 +28,21 @@ export interface IUIManager {
 }
 export interface IResManager {
 }
+export interface IHttpManager extends IManager {
+    get<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    post<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    put<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    delete<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    request<T = any>(options: HttpRequestOptions): Promise<T>;
+}
+export interface HttpRequestOptions {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+    data?: any;
+    timeout?: number;
+}
 export interface IEventMsgKey {
 }
 export type ToAnyIndexKey<IndexKey, AnyType> = IndexKey extends keyof AnyType ? IndexKey : keyof AnyType;

package/dist/core/Core.d.ts

@@ -1,4 +1,4 @@
-import { ICore, IEventManager, IManager, IModel } from "./Api";
+import { ICore, IEventManager, IManager, IModel, IHttpManager } from "./Api";
 export declare abstract class AbstractCore<T extends AbstractCore<T>> implements ICore {
     private readonly container;
     constructor();
@@ -14,5 +14,6 @@ export declare abstract class AbstractManager implements IManager {
     dispose(): void;
     protected getModel<T extends IModel>(ctor: new () => T): T;
     protected getEventManager(): IEventManager;
+    protected getHttpManager(): IHttpManager;
     private releaseEventManager;
 }

package/dist/core/Core.js

@@ -71,6 +71,10 @@ class AbstractManager {
         }
         return this.eventManager;
     }
+    // HTTP 管理器获取
+    getHttpManager() {
+        return ServiceLocator.getService('HttpManager');
+    }
     releaseEventManager() {
         var _a, _b;
         if (this.eventManager) {

package/dist/core/ICocosResManager.d.ts

@@ -6,6 +6,6 @@ export interface ICocosResManager extends IResManager {
     loadPrefab(path: string, nameOrUrl?: string): Promise<Prefab>;
     loadSpriteFrame(ref: Sprite, path: string, nameOrUrl?: string): Promise<SpriteFrame>;
     loadSpine(ref: sp.Skeleton, path: string, nameOrUrl?: string): Promise<sp.SkeletonData>;
-    release(asset: Asset): void;
-    release(path: string, type?: AssetType<Asset>, nameOrUrl?: string): void;
+    release(asset: Asset, force?: boolean): void;
+    release(path: string, type?: AssetType<Asset>, nameOrUrl?: string, force?: boolean): void;
 }

package/dist/libs/BaseView.js

@@ -65,8 +65,7 @@ class BaseView extends Component {
     onDestroy() {
         // 自动清理加载的资源
         this._loaderHandlers.forEach(({ path, asset }) => {
-            mf.res.release(path, asset.constructor);
-            // mf.res.release(asset);
+            mf.res.release(asset);
         });
         this._loaderHandlers = [];
     }

package/dist/libs/CocosCore.js

@@ -5,6 +5,7 @@ import { ServiceLocator } from '../core/ServiceLocator.js';
 import { UIManager } from './UIManager.js';
 import { ResLoader } from './ResLoader.js';
 import { Broadcaster } from './Broadcaster.js';
+import { HttpManager } from './HttpManager.js';
 import '../App.js';
 
 class Core extends AbstractCore {
@@ -14,6 +15,7 @@ class Core extends AbstractCore {
         ServiceLocator.regService('EventManager', new Broadcaster());
         ServiceLocator.regService('ResLoader', new ResLoader());
         ServiceLocator.regService('UIManager', new UIManager());
+        ServiceLocator.regService('HttpManager', new HttpManager());
         // 注册业务模块（通过装饰器自动注册）
         // 推迟到构造函数执行完毕
         queueMicrotask(() => autoRegister(this));

package/dist/libs/HttpManager.d.ts

@@ -0,0 +1,72 @@
+import { IHttpManager, HttpRequestOptions } from "../core";
+/**
+ * HTTP 管理器实现类
+ *
+ *  发起请求
+    ↓
+    【请求拦截器】修改请求参数（如添加 token、签名等）
+    ↓
+    发送到服务器
+    ↓
+    收到响应
+    ↓
+    【响应拦截器】处理响应数据（如提取数据、转换格式等）
+    ↓
+    返回结果 ✅
+
+    如果出错 ❌
+    ↓
+    【错误拦截器】统一处理错误（如显示提示、记录日志等）
+ */
+export declare class HttpManager implements IHttpManager {
+    private baseURL;
+    private defaultTimeout;
+    private defaultHeaders;
+    private requestInterceptors;
+    private responseInterceptors;
+    private errorInterceptors;
+    private pendingRequests;
+    initialize(): void;
+    dispose(): void;
+    /**
+     * 设置基础 URL
+     */
+    setBaseURL(url: string): void;
+    /**
+     * 设置默认请求头
+     */
+    setDefaultHeader(key: string, value: string): void;
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor: (options: HttpRequestOptions) => HttpRequestOptions | Promise<HttpRequestOptions>): void;
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor: (response: any) => any | Promise<any>): void;
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor: (error: Error) => void | Promise<void>): void;
+    /**
+     * 取消指定请求
+     */
+    cancelRequest(requestKey: string): void;
+    /**
+     * 取消所有请求
+     */
+    cancelAllRequests(): void;
+    get<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    post<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    put<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    delete<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    request<T = any>(options: HttpRequestOptions): Promise<T>;
+    /**
+     * 构建带参数的 URL
+     */
+    private _buildUrlWithParams;
+    /**
+     * 标准化请求头
+     */
+    private _normalizeHeaders;
+}

package/dist/libs/HttpManager.js

@@ -0,0 +1,278 @@
+import { __awaiter } from '../_virtual/_tslib.js';
+
+/**
+ * HTTP 管理器实现类
+ *
+ *  发起请求
+    ↓
+    【请求拦截器】修改请求参数（如添加 token、签名等）
+    ↓
+    发送到服务器
+    ↓
+    收到响应
+    ↓
+    【响应拦截器】处理响应数据（如提取数据、转换格式等）
+    ↓
+    返回结果 ✅
+
+    如果出错 ❌
+    ↓
+    【错误拦截器】统一处理错误（如显示提示、记录日志等）
+ */
+class HttpManager {
+    constructor() {
+        this.baseURL = ''; // 基础 URL
+        this.defaultTimeout = 10000; // 默认超时时间 10 秒
+        this.defaultHeaders = {
+            'Content-Type': 'application/json',
+        };
+        // 请求拦截器
+        // 在请求发送之前修改请求参数，可以：
+        // 添加认证信息（Token）
+        // 添加通用参数（时间戳、版本号、签名等）
+        // 修改请求头
+        // 记录请求日志
+        // 加密请求数据
+        // 等等
+        this.requestInterceptors = [];
+        // 响应拦截器
+        // 在收到响应后处理数据，可以：
+        // 提取实际数据（去除包装层）
+        // 统一处理错误码
+        // 转换数据格式
+        // 缓存响应结果
+        // 等等
+        this.responseInterceptors = [];
+        // 错误拦截器
+        // 在请求出错时处理错误，可以：
+        // 显示错误提示
+        // 记录错误日志
+        // 重试请求
+        // 等等
+        this.errorInterceptors = [];
+        // 正在进行的请求管理
+        this.pendingRequests = new Map();
+    }
+    initialize() {
+        // 初始化逻辑（如果需要）
+    }
+    dispose() {
+        // 取消所有正在进行的请求
+        this.cancelAllRequests();
+        // 清空拦截器
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.errorInterceptors = [];
+    }
+    /**
+     * 设置基础 URL
+     */
+    setBaseURL(url) {
+        this.baseURL = url;
+    }
+    /**
+     * 设置默认请求头
+     */
+    setDefaultHeader(key, value) {
+        this.defaultHeaders[key] = value;
+    }
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor) {
+        this.requestInterceptors.push(interceptor);
+    }
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor) {
+        this.responseInterceptors.push(interceptor);
+    }
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor) {
+        this.errorInterceptors.push(interceptor);
+    }
+    /**
+     * 取消指定请求
+     */
+    cancelRequest(requestKey) {
+        const controller = this.pendingRequests.get(requestKey);
+        if (controller) {
+            controller.abort();
+            this.pendingRequests.delete(requestKey);
+        }
+    }
+    /**
+     * 取消所有请求
+     */
+    cancelAllRequests() {
+        this.pendingRequests.forEach(controller => controller.abort());
+        this.pendingRequests.clear();
+    }
+    get(url, params, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullUrl = this._buildUrlWithParams(url, params);
+            return this.request({
+                url: fullUrl,
+                method: 'GET',
+                headers: Object.assign(Object.assign({}, this.defaultHeaders), headers)
+            });
+        });
+    }
+    post(url, data, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request({
+                url,
+                method: 'POST',
+                headers: Object.assign(Object.assign({}, this.defaultHeaders), headers),
+                data
+            });
+        });
+    }
+    put(url, data, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request({
+                url,
+                method: 'PUT',
+                headers: Object.assign(Object.assign({}, this.defaultHeaders), headers),
+                data
+            });
+        });
+    }
+    delete(url, params, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullUrl = this._buildUrlWithParams(url, params);
+            return this.request({
+                url: fullUrl,
+                method: 'DELETE',
+                headers: Object.assign(Object.assign({}, this.defaultHeaders), headers)
+            });
+        });
+    }
+    request(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { url, method, headers = {}, params, data, timeout = this.defaultTimeout } = options;
+            // 应用请求拦截器
+            let requestOptions = Object.assign({}, options);
+            for (const interceptor of this.requestInterceptors) {
+                requestOptions = yield interceptor(requestOptions);
+            }
+            // 更新变量（拦截器可能修改了请求参数）
+            ({ url, method, headers = {}, params, data, timeout = this.defaultTimeout } = requestOptions);
+            // 处理 baseURL
+            let fullUrl = url;
+            if (this.baseURL && !url.startsWith('http')) {
+                fullUrl = this.baseURL + (url.startsWith('/') ? url : '/' + url);
+            }
+            // 构建完整的 URL（如果还有未处理的 params）
+            if (params && (method === 'GET' || method === 'DELETE')) {
+                fullUrl = this._buildUrlWithParams(fullUrl, params);
+            }
+            // 生成请求唯一标识（用于取消请求）
+            const requestKey = `${method}:${fullUrl}`;
+            // 构建 fetch 选项
+            const fetchOptions = {
+                method,
+                headers: this._normalizeHeaders(Object.assign(Object.assign({}, this.defaultHeaders), headers)),
+            };
+            // 添加请求体（仅适用于允许请求体的方法）
+            if (data && ['POST', 'PUT', 'PATCH'].includes(method)) {
+                if (data instanceof FormData) {
+                    // FormData 不需要设置 Content-Type，浏览器会自动设置
+                    fetchOptions.body = data;
+                    // 移除 Content-Type，让浏览器自动设置正确的 boundary
+                    delete fetchOptions.headers['content-type'];
+                }
+                else if (typeof data === 'object') {
+                    fetchOptions.body = JSON.stringify(data);
+                }
+                else {
+                    fetchOptions.body = data.toString();
+                }
+            }
+            try {
+                // 创建 AbortController（每个请求都需要独立的 controller）
+                const controller = new AbortController();
+                this.pendingRequests.set(requestKey, controller);
+                const timeoutId = setTimeout(() => {
+                    controller.abort();
+                    this.pendingRequests.delete(requestKey);
+                }, timeout);
+                fetchOptions.signal = controller.signal;
+                // 发起请求
+                const response = yield fetch(fullUrl, fetchOptions);
+                clearTimeout(timeoutId);
+                this.pendingRequests.delete(requestKey);
+                // 检查响应状态
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                // 尝试解析 JSON，如果失败则返回文本
+                let result;
+                try {
+                    result = yield response.json();
+                }
+                catch (_a) {
+                    result = yield response.text();
+                }
+                // 应用响应拦截器
+                for (const interceptor of this.responseInterceptors) {
+                    result = yield interceptor(result);
+                }
+                return result;
+            }
+            catch (error) {
+                this.pendingRequests.delete(requestKey);
+                let finalError;
+                if (error instanceof Error) {
+                    if (error.name === 'AbortError') {
+                        finalError = new Error(`Request timeout after ${timeout}ms`);
+                    }
+                    else {
+                        finalError = new Error(`Network error: ${error.message}`);
+                    }
+                }
+                else {
+                    finalError = new Error('Unknown network error');
+                }
+                // 应用错误拦截器
+                for (const interceptor of this.errorInterceptors) {
+                    yield interceptor(finalError);
+                }
+                throw finalError;
+            }
+        });
+    }
+    /**
+     * 构建带参数的 URL
+     */
+    _buildUrlWithParams(url, params) {
+        if (!params)
+            return url;
+        const urlObj = new URL(url, typeof window !== 'undefined' ? window.location.href : 'http://localhost');
+        Object.keys(params).forEach(key => {
+            if (params[key] !== undefined && params[key] !== null) {
+                urlObj.searchParams.append(key, String(params[key]));
+            }
+        });
+        // 如果原始 URL 没有协议和主机，只返回路径和查询参数
+        if (!url.startsWith('http')) {
+            return urlObj.pathname + urlObj.search;
+        }
+        return urlObj.toString();
+    }
+    /**
+     * 标准化请求头
+     */
+    _normalizeHeaders(headers) {
+        const normalized = {};
+        Object.keys(headers).forEach(key => {
+            normalized[key.toLowerCase()] = headers[key];
+        });
+        return normalized;
+    }
+}
+
+export { HttpManager };

package/dist/libs/ResLoader.d.ts

@@ -5,6 +5,6 @@ export declare class ResLoader implements ICocosResManager {
     loadPrefab(path: string, nameOrUrl?: string): Promise<Prefab>;
     loadSpriteFrame(ref: Sprite, path: string, nameOrUrl?: string): Promise<SpriteFrame>;
     loadSpine(ref: sp.Skeleton, path: string, nameOrUrl?: string): Promise<sp.SkeletonData>;
-    release(asset: Asset): void;
-    release(path: string, type?: AssetType<Asset>, nameOrUrl?: string): void;
+    release(asset: Asset, force?: boolean): void;
+    release(path: string, type?: AssetType<Asset>, nameOrUrl?: string, force?: boolean): void;
 }

package/dist/libs/ResLoader.js

@@ -4,8 +4,6 @@ import { assetManager, Prefab, Asset, SpriteFrame, sp } from 'cc';
 const DefaultBundle = "resources";
 class ResLoader {
     loadAsset(path, type, nameOrUrl = DefaultBundle) {
-        //TODO: bundle.release和assetManager.releaseAsset的区别?
-        //TODO: prefab是否需要addRef，prefab被克隆出来的节点被销毁时，对应的prefab如何处理?
         if (assetManager.assets.has(path)) {
             const asset = assetManager.assets.get(path);
             asset.addRef();
@@ -31,6 +29,7 @@ class ResLoader {
         });
     }
     loadPrefab(path, nameOrUrl = DefaultBundle) {
+        //refCount 记录的是持有者数量，不是资源份数，所以prefab也需要addRef
         return this.loadAsset(path, Prefab, nameOrUrl);
     }
     loadSpriteFrame(ref, path, nameOrUrl = DefaultBundle) {
@@ -41,7 +40,7 @@ class ResLoader {
                 return Promise.resolve(sf);
             }
             else {
-                // 没有引用到的资源，释放掉
+                // 没有引用对象，释放掉资源
                 this.release(path, SpriteFrame, nameOrUrl);
                 return Promise.reject(new Error("Sprite is not valid"));
             }
@@ -55,26 +54,37 @@ class ResLoader {
                 return Promise.resolve(spine);
             }
             else {
-                // 没有引用到的资源，释放掉
+                // 没有引用对象，释放掉资源
                 this.release(path, sp.SkeletonData, nameOrUrl);
                 return Promise.reject(new Error("Spine is not valid"));
             }
         });
     }
-    release(pathOrAsset, type, nameOrUrl = DefaultBundle) {
+    release(pathOrAsset, typeOrForce, nameOrUrl = DefaultBundle, forceParam = false) {
+        var _a;
+        let asset;
+        let force = false;
         if (typeof pathOrAsset === "string") {
-            const bundle = assetManager.getBundle(nameOrUrl);
-            const asset = bundle === null || bundle === void 0 ? void 0 : bundle.get(pathOrAsset, type);
-            asset === null || asset === void 0 ? void 0 : asset.decRef();
-            if ((asset === null || asset === void 0 ? void 0 : asset.refCount) === 0) {
-                bundle === null || bundle === void 0 ? void 0 : bundle.release(pathOrAsset, type);
+            if (!typeOrForce || typeof typeOrForce === "boolean") {
+                throw new Error('typeOrForce is undefined, or typeOrForce is boolean! typeOrForce must be AssetType<Asset>!');
             }
+            force = forceParam;
+            asset = (_a = assetManager.getBundle(nameOrUrl)) === null || _a === void 0 ? void 0 : _a.get(pathOrAsset, typeOrForce);
         }
         else if (pathOrAsset instanceof Asset) {
-            pathOrAsset.decRef();
-            if (pathOrAsset.refCount === 0) {
-                assetManager.releaseAsset(pathOrAsset);
-            }
+            asset = pathOrAsset;
+            force = typeof typeOrForce === 'boolean' ? typeOrForce : forceParam;
+        }
+        if (!asset) {
+            console.warn(`${pathOrAsset} Release asset failed, asset is null or undefined`);
+            return;
+        }
+        if (force) {
+            assetManager.releaseAsset(asset);
+        }
+        else {
+            // decRef原型：decRef (autoRelease = true)，所以引用数量为 0，则将自动释放该资源。
+            asset.decRef();
         }
     }
 }

package/dist/libs/UIManager.js

@@ -1,5 +1,5 @@
 import { __awaiter } from '../_virtual/_tslib.js';
-import { director, Node, Sprite, Widget, Input, input, instantiate } from 'cc';
+import { director, Node, Sprite, Widget, Input, input, Prefab, instantiate } from 'cc';
 import { ServiceLocator } from '../core/ServiceLocator.js';
 import 'reflect-metadata';
 
@@ -144,6 +144,7 @@ class UIManager extends CcocosUIManager {
                 target = instantiate(prefab);
                 this._cache.set(viewType.name, target);
             }
+            target.active = true;
             return target.getComponent(viewType);
         });
     }
@@ -163,10 +164,21 @@ class UIManager extends CcocosUIManager {
         }
         viewortype.onExit();
         viewortype.node.removeFromParent();
+        viewortype.node.active = false;
         if (destroy) {
             let cacheKey = viewortype.constructor.name;
             (_a = this._cache.get(cacheKey)) === null || _a === void 0 ? void 0 : _a.destroy();
             this._cache.delete(cacheKey);
+            // 销毁被克隆出的UI后Node后，尝试释放 Prefab 资源
+            try {
+                const viewType = viewortype.constructor;
+                const prefabPath = this._getPrefabPath(viewType);
+                const ResMgr = ServiceLocator.getService('ResLoader');
+                ResMgr.release(prefabPath, Prefab);
+            }
+            catch (error) {
+                console.error(`Failed to release prefab for ${cacheKey}:`, error);
+            }
         }
     }
     internalGetTopView() {

package/dist/libs/index.d.ts

@@ -4,3 +4,4 @@ export * from './CocosCore';
 export * from './ResLoader';
 export * from './UIManager';
 export * from './UIRoot';
+export * from './HttpManager';

package/dist/libs/index.js

@@ -4,3 +4,4 @@ export { CocosCore } from './CocosCore.js';
 export { ResLoader } from './ResLoader.js';
 export { UIManager } from './UIManager.js';
 export { UIRoot } from './UIRoot.js';
+export { HttpManager } from './HttpManager.js';

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from './ArrayExt';
 export * from './ArrayUtil';
 export * from './CameraUtil';
 export * from './ImageUtil';

package/dist/utils/index.js

@@ -1,3 +1,4 @@
+import './ArrayExt.js';
 export { ArrayUtil } from './ArrayUtil.js';
 export { CameraUtil } from './CameraUtil.js';
 export { ImageUtil } from './ImageUtil.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dzkcc-mflow",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "description": "A modular design and process management framework developed for the cocos engine, suitable for decoupling and dependency injection.",
     "author": "duanzhk",
     "license": "MIT",