dzkcc-mflow 0.0.35 → 0.0.37

package/README.md

@@ -168,7 +168,7 @@ mf.reddot.on('main/bag', (totalCount) => {
 
 ```typescript
 // 只需要一次性配置类型映射
-// types/core-types.d.ts
+// types/api-type-hints.d.ts
 declare module 'dzkcc-mflow/core' {
     interface ModelTypeMap {
         [ModelNames.User]: UserModel;
@@ -184,7 +184,7 @@ userModel.name;  // ✅ 有完整的代码补全
 
 框架提供了自动类型生成工具，在 Cocos Creator 编辑器中使用：
 
-**编辑器菜单**：**mflow-tools -> generate-types**
+**编辑器菜单**：**mflow-tools -> Generate API type hints/生成API类型提示**
 
 > ⚠️ **如果 getManager/getModel 没有类型提示**？
 > 

package/dist/core/Api.d.ts

@@ -1,64 +1,41 @@
 /**
- * ModelNames 接口（由业务层扩展以提供代码补全和类型推断）
- * @example
- * ```typescript
- * // 在 .d.ts 文件中扩展
- * interface ModelNamesType {
- *     readonly User: 'User';
- * }
- * ```
+ * 全局类型声明 - 由业务层通过 .d.ts 扩展
+ * 用于泛型约束的类型推断
  */
-export interface ModelNamesType extends Record<string, string> {
-}
-/**
- * ManagerNames 接口（由业务层扩展以提供代码补全和类型推断）
- * @example
- * ```typescript
- * // 在 .d.ts 文件中扩展
- * interface ManagerNamesType {
- *     readonly Home: 'Home';
- * }
- * ```
- */
-export interface ManagerNamesType extends Record<string, string> {
-}
-/**
- * ViewNames 接口（由业务层扩展以提供代码补全和类型推断）
- */
-export interface ViewNamesType extends Record<string, string> {
+declare global {
+    interface ModelRegistry {
+    }
+    interface ManagerRegistry {
+    }
+    interface UIRegistry {
+    }
 }
 /**
  * 核心接口 - 管理 Model 和 Manager 的生命周期
  *
- * 类型推断由业务层的 .d.ts 文件通过函数重载提供
+ * 类型推断由业务层的全局类型声明提供
  */
 export interface ICore {
-    /** 注册 Model - 通过 Key 自动实例化 */
-    regModel<T extends keyof ModelNamesType>(modelKey: T): void;
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const userModel = core.getModel(ModelNames.User);
+     * const userModel = core.getModel(UserModel);
      * ```
      */
-    getModel<T extends keyof ModelNamesType>(modelKey: T): any;
-    /** 注册 Manager - 通过 Key 自动实例化 */
-    regManager<T extends keyof ManagerNamesType>(managerKey: T): void;
+    getModel<T extends keyof ModelRegistry>(modelClass: T): InstanceType<ModelRegistry[T]>;
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const gameManager = core.getManager(ManagerNames.Game);
+     * const gameManager = core.getManager(GameManager);
      * ```
      */
-    getManager<T extends keyof ManagerNamesType>(managerKey: T): any;
+    getManager<T extends keyof ManagerRegistry>(managerClass: T): InstanceType<ManagerRegistry[T]>;
 }
 /**
  * Model 基接口 - 数据模型
@@ -92,15 +69,15 @@ export interface IView {
 /**
  * UI 管理器接口 - 管理视图的打开、关闭和栈操作
  *
- * 注意：open 和 openAndPush 的返回类型由 .d.ts 文件的函数重载提供
+ * 注意：open 和 openAndPush 的返回类型由全局类型声明提供
  */
 export interface IUIManager {
     /** 打开视图 */
-    open<T extends keyof ViewNamesType>(viewKey: T, args?: any): Promise<IView>;
+    open<T extends keyof UIRegistry>(viewClass: T, args?: any): Promise<InstanceType<UIRegistry[T]>>;
     /** 关闭视图 */
-    close<T extends keyof ViewNamesType>(viewKey: T | IView, destory?: boolean): void;
+    close<T extends keyof UIRegistry>(viewClass: T): void;
     /** 打开视图并入栈 */
-    openAndPush<T extends keyof ViewNamesType>(viewKey: T, group: string, args?: any): Promise<IView>;
+    openAndPush<T extends keyof UIRegistry>(viewClass: T, group: string, args?: any): Promise<InstanceType<UIRegistry[T]>>;
     /** 关闭栈顶视图并弹出 */
     closeAndPop(group: string, destroy?: boolean): void;
     /** 获取栈顶视图 */

package/dist/core/Core.d.ts

@@ -1,46 +1,42 @@
-import { ICore, IManager, ModelNamesType, ManagerNamesType } from "./Api";
+import { ICore, IManager } from "./Api";
 export declare abstract class AbstractCore<T extends AbstractCore<T>> implements ICore {
     private readonly container;
     constructor();
     protected abstract initialize(): void;
-    regModel<T extends keyof ModelNamesType>(modelKey: T): void;
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const userModel = core.getModel(ModelNames.User);
+     * const userModel = core.getModel(UserModel);
      * ```
      */
-    getModel<T extends keyof ModelNamesType>(modelKey: T): any;
-    regManager<T extends keyof ManagerNamesType>(managerKey: T): void;
+    getModel<T extends keyof ModelRegistry>(modelClass: T): InstanceType<ModelRegistry[T]>;
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const gameManager = core.getManager(ManagerNames.Game);
+     * const gameManager = core.getManager(GameManager);
      * ```
      */
-    getManager<T extends keyof ManagerNamesType>(managerKey: T): any;
+    getManager<T extends keyof ManagerRegistry>(managerClass: T): InstanceType<ManagerRegistry[T]>;
 }
 export declare abstract class AbstractManager implements IManager {
     abstract initialize(): void;
     dispose(): void;
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      */
-    protected getModel<T extends keyof ModelNamesType>(modelKey: T): any;
+    protected getModel<T extends keyof ModelRegistry>(modelClass: T): InstanceType<ModelRegistry[T]>;
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      */
-    protected getManager<T extends keyof ManagerNamesType>(managerKey: T): any;
+    protected getManager<T extends keyof ManagerRegistry>(managerClass: T): InstanceType<ManagerRegistry[T]>;
 }

package/dist/core/Core.js

@@ -14,53 +14,58 @@ class Container {
             throw new Error(`${key} not registered!`);
         return ins;
     }
+    has(key) {
+        return this.key2ins.has(key);
+    }
 }
 class AbstractCore {
     constructor() {
         this.container = new Container();
         this.initialize();
     }
-    // 注册与获取模型
-    regModel(modelKey) {
-        const modelKeyStr = modelKey;
-        const ModelClass = getModelClass(modelKeyStr);
-        const model = new ModelClass();
-        this.container.reg(modelKeyStr, model);
-        model.initialize();
-    }
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const userModel = core.getModel(ModelNames.User);
+     * const userModel = core.getModel(UserModel);
      * ```
      */
-    getModel(modelKey) {
-        return this.container.get(modelKey);
-    }
-    // 注册与获取管理器
-    regManager(managerKey) {
-        const managerKeyStr = managerKey;
-        const ManagerClass = getManagerClass(managerKeyStr);
-        const manager = new ManagerClass();
-        this.container.reg(managerKeyStr, manager);
-        manager.initialize();
+    getModel(modelClass) {
+        const className = modelClass.name;
+        // 如果已存在实例，直接返回
+        if (this.container.has(className)) {
+            return this.container.get(className);
+        }
+        // 创建新实例
+        const ModelClass = getModelClass(className);
+        const instance = new ModelClass();
+        this.container.reg(className, instance);
+        instance.initialize();
+        return instance;
     }
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const gameManager = core.getManager(ManagerNames.Game);
+     * const gameManager = core.getManager(GameManager);
      * ```
      */
-    getManager(managerKey) {
-        return this.container.get(managerKey);
+    getManager(managerClass) {
+        const className = managerClass.name;
+        // 如果已存在实例，直接返回
+        if (this.container.has(className)) {
+            return this.container.get(className);
+        }
+        // 创建新实例
+        const ManagerClass = getManagerClass(className);
+        const instance = new ManagerClass();
+        this.container.reg(className, instance);
+        instance.initialize();
+        return instance;
     }
 }
 class AbstractManager {
@@ -68,21 +73,21 @@ class AbstractManager {
     }
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      */
-    getModel(modelKey) {
+    getModel(modelClass) {
         // 保持框架独立性，不与具体应用入口(app类)耦合
         // 框架高内聚，使用ServiceLocator获取core
-        return ServiceLocator.getService('core').getModel(modelKey);
+        return ServiceLocator.getService('core').getModel(modelClass);
     }
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      */
-    getManager(managerKey) {
-        return ServiceLocator.getService('core').getManager(managerKey);
+    getManager(managerClass) {
+        return ServiceLocator.getService('core').getManager(managerClass);
     }
 }
 

package/dist/core/Decorators.d.ts

@@ -1,10 +1,3 @@
-import { ICore, ModelNamesType, ManagerNamesType, ViewNamesType } from "./Api";
-/** Model 名称常量对象，用于代码补全和类型推断 */
-export declare const ModelNames: ModelNamesType;
-/** Manager 名称常量对象，用于代码补全和类型推断 */
-export declare const ManagerNames: ManagerNamesType;
-/** View 名称常量对象，用于代码补全和类型推断 */
-export declare const ViewNames: ViewNamesType;
 /**
  * Model 装饰器，用于注册 Model 到全局注册表
  * @param name 可选的 Model 名称，如果不提供则使用类名
@@ -16,7 +9,7 @@ export declare const ViewNames: ViewNamesType;
  * }
  *
  * // 使用
- * const user = mf.core.getModel(ModelNames.User);
+ * const user = mf.core.getModel(UserModel);
  * ```
  */
 export declare function model(name?: string): (ctor: Function) => void;
@@ -32,13 +25,6 @@ export declare function getRegisteredModelNames(): string[];
  * @throws 如果 Model 未注册则抛出错误
  */
 export declare function getModelClass<T>(modelKey: string): new () => T;
-/**
- * 通过类构造函数获取 Model 的 Key
- * @param ctor Model 类构造函数
- * @returns Model 的 Key
- * @internal 内部使用
- */
-export declare function getModelKey(ctor: Function): string | undefined;
 /**
  * Manager 装饰器，用于注册 Manager 到全局注册表
  * @param name 可选的 Manager 名称，如果不提供则使用类名
@@ -63,13 +49,6 @@ export declare function getRegisteredManagerNames(): string[];
  * @throws 如果 Manager 未注册则抛出错误
  */
 export declare function getManagerClass<T>(managerKey: string): new () => T;
-/**
- * 通过类构造函数获取 Manager 的 Key
- * @param ctor Manager 类构造函数
- * @returns Manager 的 Key
- * @internal 内部使用
- */
-export declare function getManagerKey(ctor: Function): string | undefined;
 /**
  * View 装饰器，用于注册 View 到全局注册表
  * @param name 可选的 View 名称，如果不提供则使用类名
@@ -84,7 +63,7 @@ export declare function getManagerKey(ctor: Function): string | undefined;
  * }
  *
  * // 使用
- * await mf.ui.open(ViewNames.Home);
+ * await mf.ui.open(HomeView);
  * ```
  */
 export declare function view(name?: string): (ctor: Function) => void;
@@ -100,17 +79,3 @@ export declare function getRegisteredViewNames(): string[];
  * @throws 如果 View 未注册则抛出错误
  */
 export declare function getViewClass<T>(viewKey: string): new () => T;
-/**
- * 自动注册所有使用装饰器标记的 Model 和 Manager
- * @param core Core 实例
- * @example
- * ```typescript
- * // 导入所有 Model 和 Manager
- * import '@/models/UserModel';
- * import '@/managers/GameManager';
- *
- * // 自动注册
- * autoRegister(mf.core);
- * ```
- */
-export declare function autoRegister(core: ICore): void;

package/dist/core/Decorators.js

@@ -1,21 +1,10 @@
 // ============================================================================
-// Key 注册系统 - Names 对象（提供代码补全和类型推断）
-// ============================================================================
-/** Model 名称常量对象，用于代码补全和类型推断 */
-const ModelNames = {};
-/** Manager 名称常量对象，用于代码补全和类型推断 */
-const ManagerNames = {};
-/** View 名称常量对象，用于代码补全和类型推断 */
-const ViewNames = {};
-// ============================================================================
 // 内部注册表
 // ============================================================================
 // Model 注册表
 const modelRegistry = new Map(); // Key → 类
-const ctorToModelKey = new Map(); // 类 → Key
 // Manager 注册表
 const managerRegistry = new Map(); // Key → 类
-const ctorToManagerKey = new Map(); // 类 → Key
 // View 注册表
 const viewRegistry = new Map(); // Key → 类
 // ============================================================================
@@ -32,7 +21,7 @@ const viewRegistry = new Map(); // Key → 类
  * }
  *
  * // 使用
- * const user = mf.core.getModel(ModelNames.User);
+ * const user = mf.core.getModel(UserModel);
  * ```
  */
 function model(name) {
@@ -40,8 +29,6 @@ function model(name) {
         const modelName = name || ctor.name;
         // 注册到映射表
         modelRegistry.set(modelName, ctor);
-        ctorToModelKey.set(ctor, modelName);
-        ModelNames[modelName] = modelName;
         console.log(`Model registered: ${modelName}`);
     };
 }
@@ -50,7 +37,7 @@ function model(name) {
  * @returns Model 名称数组
  */
 function getRegisteredModelNames() {
-    return Object.keys(ModelNames);
+    return Array.from(modelRegistry.keys());
 }
 /**
  * 通过 Key 获取 Model 类构造函数
@@ -65,15 +52,6 @@ function getModelClass(modelKey) {
     }
     return modelClass;
 }
-/**
- * 通过类构造函数获取 Model 的 Key
- * @param ctor Model 类构造函数
- * @returns Model 的 Key
- * @internal 内部使用
- */
-function getModelKey(ctor) {
-    return ctorToModelKey.get(ctor);
-}
 // ============================================================================
 // Manager 装饰器
 // ============================================================================
@@ -93,8 +71,6 @@ function manager(name) {
         const managerName = name || ctor.name;
         // 注册到映射表
         managerRegistry.set(managerName, ctor);
-        ctorToManagerKey.set(ctor, managerName);
-        ManagerNames[managerName] = managerName;
         console.log(`Manager registered: ${managerName}`);
     };
 }
@@ -103,7 +79,7 @@ function manager(name) {
  * @returns Manager 名称数组
  */
 function getRegisteredManagerNames() {
-    return Object.keys(ManagerNames);
+    return Array.from(managerRegistry.keys());
 }
 /**
  * 通过 Key 获取 Manager 类构造函数
@@ -118,15 +94,6 @@ function getManagerClass(managerKey) {
     }
     return managerClass;
 }
-/**
- * 通过类构造函数获取 Manager 的 Key
- * @param ctor Manager 类构造函数
- * @returns Manager 的 Key
- * @internal 内部使用
- */
-function getManagerKey(ctor) {
-    return ctorToManagerKey.get(ctor);
-}
 // ============================================================================
 // View 装饰器
 // ============================================================================
@@ -144,7 +111,7 @@ function getManagerKey(ctor) {
  * }
  *
  * // 使用
- * await mf.ui.open(ViewNames.Home);
+ * await mf.ui.open(HomeView);
  * ```
  */
 function view(name) {
@@ -152,7 +119,6 @@ function view(name) {
         const viewName = name || ctor.name;
         // 注册到映射表
         viewRegistry.set(viewName, ctor);
-        ViewNames[viewName] = viewName;
         console.log(`View registered: ${viewName}`);
     };
 }
@@ -161,7 +127,7 @@ function view(name) {
  * @returns View 名称数组
  */
 function getRegisteredViewNames() {
-    return Object.keys(ViewNames);
+    return Array.from(viewRegistry.keys());
 }
 /**
  * 通过 Key 获取 View 类构造函数
@@ -175,34 +141,6 @@ function getViewClass(viewKey) {
         throw new Error(`View not registered: ${viewKey}`);
     }
     return viewClass;
-}
-// ============================================================================
-// 自动注册
-// ============================================================================
-/**
- * 自动注册所有使用装饰器标记的 Model 和 Manager
- * @param core Core 实例
- * @example
- * ```typescript
- * // 导入所有 Model 和 Manager
- * import '@/models/UserModel';
- * import '@/managers/GameManager';
- *
- * // 自动注册
- * autoRegister(mf.core);
- * ```
- */
-function autoRegister(core) {
-    // 注册所有 Model
-    ctorToModelKey.forEach((modelKey, ctor) => {
-        console.log(`${ctor.name} initialize`);
-        core.regModel(modelKey);
-    });
-    // 注册所有 Manager
-    ctorToManagerKey.forEach((managerKey, ctor) => {
-        console.log(`${ctor.name} initialize`);
-        core.regManager(managerKey);
-    });
 }
 
-export { ManagerNames, ModelNames, ViewNames, autoRegister, getManagerClass, getManagerKey, getModelClass, getModelKey, getRegisteredManagerNames, getRegisteredModelNames, getRegisteredViewNames, getViewClass, manager, model, view };
+export { getManagerClass, getModelClass, getRegisteredManagerNames, getRegisteredModelNames, getRegisteredViewNames, getViewClass, manager, model, view };

package/dist/core/index.js

@@ -1,3 +1,3 @@
 export { AbstractCore, AbstractManager } from './Core.js';
-export { ManagerNames, ModelNames, ViewNames, autoRegister, getManagerClass, getManagerKey, getModelClass, getModelKey, getRegisteredManagerNames, getRegisteredModelNames, getRegisteredViewNames, getViewClass, manager, model, view } from './Decorators.js';
+export { getManagerClass, getModelClass, getRegisteredManagerNames, getRegisteredModelNames, getRegisteredViewNames, getViewClass, manager, model, view } from './Decorators.js';
 export { ServiceLocator } from './ServiceLocator.js';

package/dist/libs/BaseView.d.ts

@@ -1,6 +1,5 @@
 import { Component } from 'cc';
 import { IView, IEventManager, ICocosResManager } from '../core';
-import { ModelNamesType, ManagerNamesType } from '../core';
 export declare abstract class BaseView extends Component implements IView {
     /** @internal */
     private readonly __isIView__;
@@ -19,24 +18,22 @@ export declare abstract class BaseView extends Component implements IView {
     protected onDestroy(): void;
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const userModel = this.getModel(ModelNames.User);
+     * const userModel = this.getModel(UserModel);
      * ```
      */
-    protected getModel<T extends keyof ModelNamesType>(modelKey: T): any;
+    protected getModel<T extends keyof ModelRegistry>(modelClass: T): InstanceType<ModelRegistry[T]>;
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const gameManager = this.getManager(ManagerNames.Game);
+     * const gameManager = this.getManager(GameManager);
      * ```
      */
-    protected getManager<T extends keyof ManagerNamesType>(managerKey: T): any;
+    protected getManager<T extends keyof ManagerRegistry>(managerClass: T): InstanceType<ManagerRegistry[T]>;
 }

package/dist/libs/BaseView.js

@@ -71,29 +71,27 @@ class BaseView extends Component {
     }
     /**
      * 获取 Model 实例
-     * @param modelKey Model 的 Key，使用 ModelNames.XXX
-     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param modelClass Model 类构造函数
+     * @returns Model 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const userModel = this.getModel(ModelNames.User);
+     * const userModel = this.getModel(UserModel);
      * ```
      */
-    getModel(modelKey) {
-        return mf.core.getModel(modelKey);
+    getModel(modelClass) {
+        return mf.core.getModel(modelClass);
     }
     /**
      * 获取 Manager 实例
-     * @param managerKey Manager 的 Key，使用 ManagerNames.XXX
-     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
+     * @param managerClass Manager 类构造函数
+     * @returns Manager 实例（类型由泛型参数推断）
      * @example
      * ```typescript
-     * // 类型由 .d.ts 文件的重载自动推断
-     * const gameManager = this.getManager(ManagerNames.Game);
+     * const gameManager = this.getManager(GameManager);
      * ```
      */
-    getManager(managerKey) {
-        return mf.core.getManager(managerKey);
+    getManager(managerClass) {
+        return mf.core.getManager(managerClass);
     }
 }
 

package/dist/libs/CocosCore.js

@@ -1,6 +1,5 @@
 import { Component } from 'cc';
 import { AbstractCore } from '../core/Core.js';
-import { autoRegister } from '../core/Decorators.js';
 import { ServiceLocator } from '../core/ServiceLocator.js';
 import { UIManager } from './UIManager.js';
 import { ResLoader } from './ResLoader.js';
@@ -20,9 +19,6 @@ class Core extends AbstractCore {
         ServiceLocator.regService('HttpManager', new HttpManager());
         ServiceLocator.regService('WebSocketManager', new WebSocketManager());
         ServiceLocator.regService('RedDotManager', new RedDotManager());
-        // 注册业务模块（通过装饰器自动注册）
-        // 推迟到构造函数执行完毕
-        queueMicrotask(() => autoRegister(this));
     }
 }
 class CocosCore extends Component {

package/dist/libs/UIManager.d.ts

@@ -1,12 +1,11 @@
 import { Component } from "cc";
 import { IUIManager, IView } from "../core";
-import { ViewNamesType } from "../core";
 type ICocosView = IView & Component;
 declare abstract class CcocosUIManager implements IUIManager {
     getTopView(): IView | undefined;
-    open<T extends keyof ViewNamesType>(viewKey: T, args?: any): Promise<IView>;
-    close<T extends keyof ViewNamesType>(viewKey: T | IView, destory?: boolean): void;
-    openAndPush<T extends keyof ViewNamesType>(viewKey: T, group: string, args?: any): Promise<IView>;
+    open<T extends keyof UIRegistry>(viewClass: T, args?: any): Promise<InstanceType<UIRegistry[T]>>;
+    close<T extends keyof UIRegistry>(viewClass: T): void;
+    openAndPush<T extends keyof UIRegistry>(viewClass: T, group: string, args?: any): Promise<InstanceType<UIRegistry[T]>>;
     closeAndPop(group: string, destroy?: boolean): void;
     clearStack(group: string, destroy?: boolean): void;
     protected abstract internalOpen(viewKey: string, args?: any): Promise<ICocosView>;

package/dist/libs/UIManager.js

@@ -60,14 +60,17 @@ class CcocosUIManager {
     getTopView() {
         return this.internalGetTopView();
     }
-    open(viewKey, args) {
-        return this.internalOpen(viewKey, args);
+    open(viewClass, args) {
+        const className = viewClass.name;
+        return this.internalOpen(className, args);
     }
-    close(viewKey, destory) {
-        this.internalClose(viewKey, destory);
+    close(viewClass) {
+        const className = viewClass.name;
+        this.internalClose(className);
     }
-    openAndPush(viewKey, group, args) {
-        return this.internalOpenAndPush(viewKey, group, args);
+    openAndPush(viewClass, group, args) {
+        const className = viewClass.name;
+        return this.internalOpenAndPush(className, group, args);
     }
     closeAndPop(group, destroy) {
         this.internalCloseAndPop(group, destroy);
@@ -88,7 +91,8 @@ class UIManager extends CcocosUIManager {
                     this.closeAndPop(view.__group__, false);
                 }
                 else {
-                    this.close(view, false);
+                    // 对于直接关闭视图，我们需要通过内部方法处理
+                    this.internalClose(view, false);
                 }
             }
         });

package/package.json

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