dzkcc-mflow 0.0.30 → 0.0.32

package/dist/core/Api.d.ts

@@ -1,79 +1,64 @@
 /**
- * Model 类型映射接口（由业务层扩展）
- */
-export interface ModelTypeMap extends Record<string, any> {
-}
-/**
- * Manager 类型映射接口（由业务层扩展）
- */
-export interface ManagerTypeMap extends Record<string, any> {
-}
-/**
- * View 类型映射接口（由业务层扩展）
- */
-export interface ViewTypeMap extends Record<string, any> {
-}
-/**
- * ModelNames 接口（由业务层扩展）
+ * ModelNames 接口（由业务层扩展以提供代码补全和类型推断）
+ * @example
+ * ```typescript
+ * // 在 .d.ts 文件中扩展
+ * interface ModelNamesType {
+ *     readonly User: unique symbol;
+ * }
+ * ```
  */
 export interface ModelNamesType extends Record<string, symbol> {
 }
 /**
- * ManagerNames 接口（由业务层扩展）
+ * ManagerNames 接口（由业务层扩展以提供代码补全和类型推断）
+ * @example
+ * ```typescript
+ * // 在 .d.ts 文件中扩展
+ * interface ManagerNamesType {
+ *     readonly Home: unique symbol;
+ * }
+ * ```
  */
 export interface ManagerNamesType extends Record<string, symbol> {
 }
 /**
- * View 名称接口（用于类型推断，通过生成的 d.ts 文件扩展）
- * */
+ * ViewNames 接口（由业务层扩展以提供代码补全和类型推断）
+ */
 export interface ViewNamesType extends Record<string, symbol> {
 }
-/**
- * 从 symbol 推断对应的字符串 key
- */
-type GetKeyFromSymbol<S extends symbol, Names extends Record<string, symbol>> = {
-    [K in keyof Names]: Names[K] extends S ? K : never;
-}[keyof Names];
-/**
- * 从 Model Symbol 推断类型
- */
-export type InferModelType<S extends symbol> = GetKeyFromSymbol<S, ModelNamesType> extends keyof ModelTypeMap ? ModelTypeMap[GetKeyFromSymbol<S, ModelNamesType>] : IModel;
-/**
- * 从 Manager Symbol 推断类型
- */
-export type InferManagerType<S extends symbol> = GetKeyFromSymbol<S, ManagerNamesType> extends keyof ManagerTypeMap ? ManagerTypeMap[GetKeyFromSymbol<S, ManagerNamesType>] : IManager;
 /**
  * 核心接口 - 管理 Model 和 Manager 的生命周期
  *
- * 支持通过 Symbol 自动推断返回类型
+ * 类型推断由业务层的 .d.ts 文件通过函数重载提供
  */
 export interface ICore {
     /** 注册 Model - 通过 Symbol 自动实例化 */
     regModel(modelSymbol: symbol): void;
     /**
-     * 获取 Model（支持类型自动推断）
+     * 获取 Model 实例
      * @param modelSymbol Model 的 Symbol，使用 ModelNames.XXX
-     * @returns Model 实例，类型会根据 symbol 自动推断为具体的 Model 类型
+     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
      * @example
      * ```typescript
-     * // 自动推断为 UserModel 类型
+     * // 类型由 .d.ts 文件的重载自动推断
      * const userModel = core.getModel(ModelNames.User);
      * ```
      */
-    getModel<S extends symbol>(modelSymbol: S): InferModelType<S>;
+    getModel(modelSymbol: symbol): any;
     /** 注册 Manager - 通过 Symbol 自动实例化 */
     regManager(managerSymbol: symbol): void;
     /**
-     * 获取 Manager（支持类型自动推断）
+     * 获取 Manager 实例
      * @param managerSymbol Manager 的 Symbol，使用 ManagerNames.XXX
-     * @returns Manager 实例，类型会根据 symbol 自动推断为具体的 Manager 类型
+     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
      * @example
      * ```typescript
-     * // 自动推断为 GameManager 类型
+     * // 类型由 .d.ts 文件的重载自动推断
      * const gameManager = core.getManager(ManagerNames.Game);
      * ```
      */
-    getManager<S extends symbol>(managerSymbol: S): InferManagerType<S>;
+    getManager(managerSymbol: symbol): any;
 }
 /**
  * Model 基接口 - 数据模型
@@ -268,4 +253,3 @@ export interface IRedDotManager extends IManager {
     /** 移除红点监听 */
     off(path: string, listener: Function): void;
 }
-export {};

package/dist/core/Core.d.ts

@@ -1,46 +1,46 @@
-import { ICore, IManager, InferModelType, InferManagerType } 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(modelSymbol: symbol): void;
     /**
-     * 获取 Model 实例（支持类型自动推断）
+     * 获取 Model 实例
      * @param modelSymbol Model 的 Symbol，使用 ModelNames.XXX
-     * @returns Model 实例，类型会根据 symbol 自动推断
+     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
      * @example
      * ```typescript
-     * // 自动推断为 UserModel 类型，无需手动指定泛型
+     * // 类型由 .d.ts 文件的重载自动推断
      * const userModel = core.getModel(ModelNames.User);
      * ```
      */
-    getModel<S extends symbol>(modelSymbol: S): InferModelType<S>;
+    getModel(modelSymbol: symbol): any;
     regManager(managerSymbol: symbol): void;
     /**
-     * 获取 Manager 实例（支持类型自动推断）
+     * 获取 Manager 实例
      * @param managerSymbol Manager 的 Symbol，使用 ManagerNames.XXX
-     * @returns Manager 实例，类型会根据 symbol 自动推断
+     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
      * @example
      * ```typescript
-     * // 自动推断为 GameManager 类型，无需手动指定泛型
+     * // 类型由 .d.ts 文件的重载自动推断
      * const gameManager = core.getManager(ManagerNames.Game);
      * ```
      */
-    getManager<S extends symbol>(managerSymbol: S): InferManagerType<S>;
+    getManager(managerSymbol: symbol): any;
 }
 export declare abstract class AbstractManager implements IManager {
     abstract initialize(): void;
     dispose(): void;
     /**
-     * 获取 Model 实例（支持类型自动推断）
+     * 获取 Model 实例
      * @param modelSymbol Model 的 Symbol，使用 ModelNames.XXX
-     * @returns Model 实例，类型会根据 symbol 自动推断
+     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
      */
-    protected getModel<S extends symbol>(modelSymbol: S): InferModelType<S>;
+    protected getModel(modelSymbol: symbol): any;
     /**
-     * 获取 Manager 实例（支持类型自动推断）
+     * 获取 Manager 实例
      * @param managerSymbol Manager 的 Symbol，使用 ManagerNames.XXX
-     * @returns Manager 实例，类型会根据 symbol 自动推断
+     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
      */
-    protected getManager<S extends symbol>(managerSymbol: S): InferManagerType<S>;
+    protected getManager(managerSymbol: symbol): any;
 }

package/dist/core/Core.js

@@ -28,12 +28,12 @@ class AbstractCore {
         model.initialize();
     }
     /**
-     * 获取 Model 实例（支持类型自动推断）
+     * 获取 Model 实例
      * @param modelSymbol Model 的 Symbol，使用 ModelNames.XXX
-     * @returns Model 实例，类型会根据 symbol 自动推断
+     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
      * @example
      * ```typescript
-     * // 自动推断为 UserModel 类型，无需手动指定泛型
+     * // 类型由 .d.ts 文件的重载自动推断
      * const userModel = core.getModel(ModelNames.User);
      * ```
      */
@@ -48,12 +48,12 @@ class AbstractCore {
         manager.initialize();
     }
     /**
-     * 获取 Manager 实例（支持类型自动推断）
+     * 获取 Manager 实例
      * @param managerSymbol Manager 的 Symbol，使用 ManagerNames.XXX
-     * @returns Manager 实例，类型会根据 symbol 自动推断
+     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
      * @example
      * ```typescript
-     * // 自动推断为 GameManager 类型，无需手动指定泛型
+     * // 类型由 .d.ts 文件的重载自动推断
      * const gameManager = core.getManager(ManagerNames.Game);
      * ```
      */
@@ -65,9 +65,9 @@ class AbstractManager {
     dispose() {
     }
     /**
-     * 获取 Model 实例（支持类型自动推断）
+     * 获取 Model 实例
      * @param modelSymbol Model 的 Symbol，使用 ModelNames.XXX
-     * @returns Model 实例，类型会根据 symbol 自动推断
+     * @returns Model 实例（具体类型由 .d.ts 文件的函数重载推断）
      */
     getModel(modelSymbol) {
         // 保持框架独立性，不与具体应用入口(app类)耦合
@@ -75,9 +75,9 @@ class AbstractManager {
         return ServiceLocator.getService('core').getModel(modelSymbol);
     }
     /**
-     * 获取 Manager 实例（支持类型自动推断）
+     * 获取 Manager 实例
      * @param managerSymbol Manager 的 Symbol，使用 ManagerNames.XXX
-     * @returns Manager 实例，类型会根据 symbol 自动推断
+     * @returns Manager 实例（具体类型由 .d.ts 文件的函数重载推断）
      */
     getManager(managerSymbol) {
         return ServiceLocator.getService('core').getManager(managerSymbol);

package/package.json

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