dzkcc-mflow 0.0.1 → 0.0.2

package/dist/core/Decorators.js

@@ -1,105 +1,105 @@
 import { ServiceLocator } from './ServiceLocator.js';
 import 'reflect-metadata';
 
-// 通过symbol实现接口标识
-const interfaceSymbols = new Map();
-// 装饰器，方便自动注册manager和model
-const modelRegistry = [];
-const managerRegistry = [];
-function getInterface(ctor) {
-    let sym = interfaceSymbols.get(ctor);
-    if (!sym)
-        throw new Error(`Manager ${ctor.name} not registered! Please use @manager() decorator to register it.`);
-    return sym;
-}
-function manager() {
-    return function (ctor) {
-        // 自动生成并注册Symbol
-        if (!interfaceSymbols.has(ctor)) {
-            interfaceSymbols.set(ctor, Symbol(ctor.name));
-        }
-        managerRegistry.push(ctor);
-    };
-}
-function model() {
-    return function (ctor) {
-        modelRegistry.push(ctor);
-    };
-}
-function autoRegister(core) {
-    modelRegistry.forEach(ctor => {
-        console.log(`${ctor.name} initialize`);
-        core.regModel(new ctor());
-    });
-    managerRegistry.forEach(ctor => {
-        console.log(`${ctor.name} initialize`);
-        core.regManager(new ctor());
-    });
-}
-// 依赖注入
-// ------------------------------------------------------------------------------------
-const INJECTED_PROPERTIES_KEY = 'injectedProperties';
-// 因为明文定义的属性会覆盖injectManager（通过defineProperty定义）注入的属性，所以需要在编译时删除明文定义的属性
-function CleanInjectedProperties(constructor) {
-    return class extends constructor {
-        constructor(...args) {
-            super(...args);
-            // 递归收集当前类及其所有父类的注入属性
-            const collectInjectedProperties = (klass) => {
-                if (klass === null || klass === Object)
-                    return [];
-                const parentProperties = collectInjectedProperties(Object.getPrototypeOf(klass));
-                const currentProperties = Reflect.getMetadata(INJECTED_PROPERTIES_KEY, klass) || [];
-                // const currentProperties :any[] = []
-                return [...parentProperties, ...currentProperties];
-            };
-            // 合并并去重属性名
-            const injectedProperties = [
-                ...new Set(collectInjectedProperties(constructor))
-            ];
-            // 删除实例上的所有注入属性
-            injectedProperties.forEach(prop => {
-                if (this.hasOwnProperty(prop)) {
-                    delete this[prop];
-                }
-            });
-        }
-    };
-}
-function managedWithClean() {
-    return function (ctor) {
-        // 先执行清理逻辑
-        const decoratedCtor = CleanInjectedProperties(ctor);
-        // 后执行注册逻辑
-        manager()(decoratedCtor);
-        return decoratedCtor;
-    };
-}
-// 懒加载依赖注入manager
-function injectManager(sym) {
-    return function (target, prop) {
-        const injectionKey = Symbol.for(prop);
-        Object.defineProperty(target, prop, {
-            get: function () {
-                console.log(`[属性访问] 触发getter：${injectionKey.toString()}`);
-                if (!this[injectionKey]) {
-                    this[injectionKey] = ServiceLocator.getService('core').getManager(sym);
-                }
-                return this[injectionKey];
-            },
-            set: function (val) {
-                throw new Error('InjectManager property is read-only');
-            },
-            enumerable: true,
-            configurable: false // 禁止修改属性描述符
-        });
-        // 2. 将属性名记录到元数据
-        const injectedProperties = Reflect.getMetadata(INJECTED_PROPERTIES_KEY, target.constructor) || [];
-        if (!injectedProperties.includes(prop)) {
-            injectedProperties.push(prop);
-        }
-        Reflect.defineMetadata(INJECTED_PROPERTIES_KEY, injectedProperties, target.constructor);
-    };
+// 通过symbol实现接口标识
+const interfaceSymbols = new Map();
+// 装饰器，方便自动注册manager和model
+const modelRegistry = [];
+const managerRegistry = [];
+function getInterface(ctor) {
+    let sym = interfaceSymbols.get(ctor);
+    if (!sym)
+        throw new Error(`Manager ${ctor.name} not registered! Please use @manager() decorator to register it.`);
+    return sym;
+}
+function manager() {
+    return function (ctor) {
+        // 自动生成并注册Symbol
+        if (!interfaceSymbols.has(ctor)) {
+            interfaceSymbols.set(ctor, Symbol(ctor.name));
+        }
+        managerRegistry.push(ctor);
+    };
+}
+function model() {
+    return function (ctor) {
+        modelRegistry.push(ctor);
+    };
+}
+function autoRegister(core) {
+    modelRegistry.forEach(ctor => {
+        console.log(`${ctor.name} initialize`);
+        core.regModel(new ctor());
+    });
+    managerRegistry.forEach(ctor => {
+        console.log(`${ctor.name} initialize`);
+        core.regManager(new ctor());
+    });
+}
+// 依赖注入
+// ------------------------------------------------------------------------------------
+const INJECTED_PROPERTIES_KEY = 'injectedProperties';
+// 因为明文定义的属性会覆盖injectManager（通过defineProperty定义）注入的属性，所以需要在编译时删除明文定义的属性
+function CleanInjectedProperties(constructor) {
+    return class extends constructor {
+        constructor(...args) {
+            super(...args);
+            // 递归收集当前类及其所有父类的注入属性
+            const collectInjectedProperties = (klass) => {
+                if (klass === null || klass === Object)
+                    return [];
+                const parentProperties = collectInjectedProperties(Object.getPrototypeOf(klass));
+                const currentProperties = Reflect.getMetadata(INJECTED_PROPERTIES_KEY, klass) || [];
+                // const currentProperties :any[] = []
+                return [...parentProperties, ...currentProperties];
+            };
+            // 合并并去重属性名
+            const injectedProperties = [
+                ...new Set(collectInjectedProperties(constructor))
+            ];
+            // 删除实例上的所有注入属性
+            injectedProperties.forEach(prop => {
+                if (this.hasOwnProperty(prop)) {
+                    delete this[prop];
+                }
+            });
+        }
+    };
+}
+function managedWithClean() {
+    return function (ctor) {
+        // 先执行清理逻辑
+        const decoratedCtor = CleanInjectedProperties(ctor);
+        // 后执行注册逻辑
+        manager()(decoratedCtor);
+        return decoratedCtor;
+    };
+}
+// 懒加载依赖注入manager
+function injectManager(sym) {
+    return function (target, prop) {
+        const injectionKey = Symbol.for(prop);
+        Object.defineProperty(target, prop, {
+            get: function () {
+                console.log(`[属性访问] 触发getter：${injectionKey.toString()}`);
+                if (!this[injectionKey]) {
+                    this[injectionKey] = ServiceLocator.getService('core').getManager(sym);
+                }
+                return this[injectionKey];
+            },
+            set: function (val) {
+                throw new Error('InjectManager property is read-only');
+            },
+            enumerable: true,
+            configurable: false // 禁止修改属性描述符
+        });
+        // 2. 将属性名记录到元数据
+        const injectedProperties = Reflect.getMetadata(INJECTED_PROPERTIES_KEY, target.constructor) || [];
+        if (!injectedProperties.includes(prop)) {
+            injectedProperties.push(prop);
+        }
+        Reflect.defineMetadata(INJECTED_PROPERTIES_KEY, injectedProperties, target.constructor);
+    };
 }
 
 export { autoRegister, getInterface, injectManager, managedWithClean, model };

package/dist/core/ICocosResManager.d.ts

@@ -1,11 +1,11 @@
-import { IResManager } from "./Api";
-import { Asset, Prefab, sp, Sprite, SpriteFrame } from "cc";
-export type AssetType<T> = new (...args: any[]) => T;
-export interface ICocosResManager extends IResManager {
-    loadAsset<T extends Asset>(path: string, type: AssetType<T>, nameOrUrl?: string): Promise<T>;
-    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;
-}
+import { IResManager } from "./Api";
+import { Asset, Prefab, sp, Sprite, SpriteFrame } from "cc";
+export type AssetType<T> = new (...args: any[]) => T;
+export interface ICocosResManager extends IResManager {
+    loadAsset<T extends Asset>(path: string, type: AssetType<T>, nameOrUrl?: string): Promise<T>;
+    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;
+}

package/dist/core/ServiceLocator.d.ts

@@ -1,7 +1,7 @@
-export declare class ServiceLocator {
-    private static services;
-    static regService<T>(key: string, provider: T): void;
-    static getService<T>(key: string): T;
-    static remove(key: string): void;
-    static clear(): void;
-}
+export declare class ServiceLocator {
+    private static services;
+    static regService<T>(key: string, provider: T): void;
+    static getService<T>(key: string): T;
+    static remove(key: string): void;
+    static clear(): void;
+}

package/dist/core/ServiceLocator.js

@@ -1,34 +1,34 @@
-//ServiceLocator：管理跨领域基础服务
-class ServiceLocator {
-    static regService(key, provider) {
-        if (typeof provider === 'function') {
-            // 注册工厂函数（延迟执行）
-            this.services.set(key, { factory: provider });
-        }
-        else {
-            // 直接注册实例
-            this.services.set(key, { factory: () => provider, instance: provider });
-        }
-    }
-    static getService(key) {
-        const entry = this.services.get(key);
-        if (!entry)
-            throw new Error(`Service ${key} not registered!`);
-        // 单例模式：若已有实例，直接返回
-        if (entry.instance)
-            return entry.instance;
-        // 执行工厂函数，创建实例并缓存
-        const instance = entry.factory();
-        entry.instance = instance; // 缓存实例（单例）
-        return instance;
-    }
-    static remove(key) {
-        this.services.delete(key);
-    }
-    static clear() {
-        this.services.clear();
-    }
-}
+//ServiceLocator：管理跨领域基础服务
+class ServiceLocator {
+    static regService(key, provider) {
+        if (typeof provider === 'function') {
+            // 注册工厂函数（延迟执行）
+            this.services.set(key, { factory: provider });
+        }
+        else {
+            // 直接注册实例
+            this.services.set(key, { factory: () => provider, instance: provider });
+        }
+    }
+    static getService(key) {
+        const entry = this.services.get(key);
+        if (!entry)
+            throw new Error(`Service ${key} not registered!`);
+        // 单例模式：若已有实例，直接返回
+        if (entry.instance)
+            return entry.instance;
+        // 执行工厂函数，创建实例并缓存
+        const instance = entry.factory();
+        entry.instance = instance; // 缓存实例（单例）
+        return instance;
+    }
+    static remove(key) {
+        this.services.delete(key);
+    }
+    static clear() {
+        this.services.clear();
+    }
+}
 ServiceLocator.services = new Map();
 
 export { ServiceLocator };

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
-export * from './Core';
-export * from './Api';
-export * from './Decorators';
-export * from './ServiceLocator';
-export * from './ICocosResManager';
+export * from './Core';
+export * from './Api';
+export * from './Decorators';
+export * from './ServiceLocator';
+export * from './ICocosResManager';

package/dist/libs/BaseView.d.ts

@@ -1,21 +1,21 @@
-import { Component } from 'cc';
-import { IView, IManager, IModel, IEventManager, ICocosResManager } from '../core';
-export declare abstract class BaseView extends Component implements IView {
-    /** @internal */
-    private readonly __isIView__;
-    /** @internal */
-    private __group__;
-    private _eventProxy?;
-    private _eventHandlers;
-    protected get event(): IEventManager;
-    private _loaderProxy?;
-    private _loaderHandlers;
-    protected get res(): ICocosResManager;
-    abstract onPause(): void;
-    abstract onResume(): void;
-    abstract onEnter(args?: any): void;
-    onExit(): void;
-    protected onDestroy(): void;
-    protected getManager<T extends IManager>(ctor: new () => T): T;
-    protected getModel<T extends IModel>(ctor: new () => T): T;
-}
+import { Component } from 'cc';
+import { IView, IManager, IModel, IEventManager, ICocosResManager } from '../core';
+export declare abstract class BaseView extends Component implements IView {
+    /** @internal */
+    private readonly __isIView__;
+    /** @internal */
+    private __group__;
+    private _eventProxy?;
+    private _eventHandlers;
+    protected get event(): IEventManager;
+    private _loaderProxy?;
+    private _loaderHandlers;
+    protected get res(): ICocosResManager;
+    abstract onPause(): void;
+    abstract onResume(): void;
+    abstract onEnter(args?: any): void;
+    onExit(): void;
+    protected onDestroy(): void;
+    protected getManager<T extends IManager>(ctor: new () => T): T;
+    protected getModel<T extends IModel>(ctor: new () => T): T;
+}

package/dist/libs/BaseView.js

@@ -1,83 +1,83 @@
 import { _decorator, Component } from 'cc';
 
-const { ccclass, property } = _decorator;
-class BaseView extends Component {
-    constructor() {
-        super(...arguments);
-        /** @internal */
-        this.__isIView__ = true;
-        /** @internal */
-        this.__group__ = undefined;
-        this._eventHandlers = [];
-        this._loaderHandlers = [];
-    }
-    get event() {
-        if (!this._eventProxy) {
-            this._eventProxy = new Proxy(mf.event, {
-                get: (target, prop) => {
-                    if (prop === 'on' || prop === 'once') {
-                        return (keyOrHandler, listener, context, args) => {
-                            const handlers = Array.isArray(keyOrHandler) ? keyOrHandler : [keyOrHandler];
-                            handlers.forEach(handler => {
-                                if (typeof handler === 'object') {
-                                    this._eventHandlers.push({ key: handler.key, listener: handler.listener });
-                                }
-                                else {
-                                    this._eventHandlers.push({ key: keyOrHandler, listener: listener });
-                                }
-                            });
-                            return Reflect.get(target, prop).apply(target, [keyOrHandler, listener, context, args]);
-                        };
-                    }
-                    return Reflect.get(target, prop);
-                }
-            });
-        }
-        return this._eventProxy;
-    }
-    get res() {
-        if (!this._loaderProxy) {
-            this._loaderProxy = new Proxy(mf.res, {
-                get: (target, prop) => {
-                    //劫持所有load相关方法
-                    if (prop.startsWith('load')) {
-                        return (path, type, nameOrUrl) => {
-                            return Reflect.get(target, prop).apply(target, [path, type, nameOrUrl]).then((asset) => {
-                                this._loaderHandlers.push({ path, asset });
-                                return asset;
-                            });
-                        };
-                    }
-                    return Reflect.get(target, prop);
-                }
-            });
-        }
-        return this._loaderProxy;
-    }
-    onExit() {
-        // 自动清理所有事件监听
-        this._eventHandlers.forEach(({ key, listener }) => {
-            //@ts-ignore
-            mf.event.off(key, listener);
-        });
-        this._eventHandlers = [];
-    }
-    onDestroy() {
-        // 自动清理加载的资源
-        this._loaderHandlers.forEach(({ path, asset }) => {
-            mf.res.release(path, asset.constructor);
-            // mf.res.release(asset);
-        });
-        this._loaderHandlers = [];
-    }
-    getManager(ctor) {
-        // 业务组件避免直接依赖底层服务定位器，所以使用app.core统一对外接口，方便后续架构演进
-        return mf.core.getManager(ctor);
-    }
-    getModel(ctor) {
-        // 业务组件避免直接依赖底层服务定位器，所以使用app.core统一对外接口，方便后续架构演进
-        return mf.core.getModel(ctor);
-    }
+const { ccclass, property } = _decorator;
+class BaseView extends Component {
+    constructor() {
+        super(...arguments);
+        /** @internal */
+        this.__isIView__ = true;
+        /** @internal */
+        this.__group__ = undefined;
+        this._eventHandlers = [];
+        this._loaderHandlers = [];
+    }
+    get event() {
+        if (!this._eventProxy) {
+            this._eventProxy = new Proxy(mf.event, {
+                get: (target, prop) => {
+                    if (prop === 'on' || prop === 'once') {
+                        return (keyOrHandler, listener, context, args) => {
+                            const handlers = Array.isArray(keyOrHandler) ? keyOrHandler : [keyOrHandler];
+                            handlers.forEach(handler => {
+                                if (typeof handler === 'object') {
+                                    this._eventHandlers.push({ key: handler.key, listener: handler.listener });
+                                }
+                                else {
+                                    this._eventHandlers.push({ key: keyOrHandler, listener: listener });
+                                }
+                            });
+                            return Reflect.get(target, prop).apply(target, [keyOrHandler, listener, context, args]);
+                        };
+                    }
+                    return Reflect.get(target, prop);
+                }
+            });
+        }
+        return this._eventProxy;
+    }
+    get res() {
+        if (!this._loaderProxy) {
+            this._loaderProxy = new Proxy(mf.res, {
+                get: (target, prop) => {
+                    //劫持所有load相关方法
+                    if (prop.startsWith('load')) {
+                        return (path, type, nameOrUrl) => {
+                            return Reflect.get(target, prop).apply(target, [path, type, nameOrUrl]).then((asset) => {
+                                this._loaderHandlers.push({ path, asset });
+                                return asset;
+                            });
+                        };
+                    }
+                    return Reflect.get(target, prop);
+                }
+            });
+        }
+        return this._loaderProxy;
+    }
+    onExit() {
+        // 自动清理所有事件监听
+        this._eventHandlers.forEach(({ key, listener }) => {
+            //@ts-ignore
+            mf.event.off(key, listener);
+        });
+        this._eventHandlers = [];
+    }
+    onDestroy() {
+        // 自动清理加载的资源
+        this._loaderHandlers.forEach(({ path, asset }) => {
+            mf.res.release(path, asset.constructor);
+            // mf.res.release(asset);
+        });
+        this._loaderHandlers = [];
+    }
+    getManager(ctor) {
+        // 业务组件避免直接依赖底层服务定位器，所以使用app.core统一对外接口，方便后续架构演进
+        return mf.core.getManager(ctor);
+    }
+    getModel(ctor) {
+        // 业务组件避免直接依赖底层服务定位器，所以使用app.core统一对外接口，方便后续架构演进
+        return mf.core.getModel(ctor);
+    }
 }
 
 export { BaseView };