@ives_xxz/framework 1.4.3 → 1.4.5

package/FW.d.ts

@@ -34,6 +34,7 @@ declare namespace FW {
     engineMgr: EngineManager;
     taskMgr: TaskManager;
     hotUpdateMgr: HotUpdateManager;
+    promiseMgr: PromiseManager;
     scene: Scene;
     bundleName: string;
     getComponent<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T;
@@ -48,6 +49,17 @@ declare namespace FW {
     onDestroy(): void;
   };
 
+  type PromiseManager = {
+    public execute<T = any>(
+      executor: (
+        resolve: (value: T | PromiseLike<T>) => void,
+        reject: (reason?: any) => void,
+        signal: AbortSignal,
+      ) => void = PromiseExcutor,
+      options: PromiseExecuteOptions = {},
+    ): PromiseProxy<T>;
+  };
+
   type Registry = {
     /** 注册 */
     register(): void;
@@ -1910,6 +1922,41 @@ declare namespace FW {
     percentages: number;
   };
 
+  type PromiseProxy<T = Promise> = {
+    id: number;
+    promise: Promise<T>;
+    status: any;
+    abortController: AbortController;
+    abort?: (reason?: any) => void;
+    addAbortEventListener?: (
+      listener: (this: AbortSignal, ev: Event) => any,
+      options?: boolean | AddEventListenerOptions,
+    ) => void;
+  };
+
+  type PromiseExcutor<T> = (
+    resolve: (value: T | PromiseLike<T>) => void,
+    reject: (reason?: any) => void,
+    signal: AbortSignal,
+  ) => void;
+
+  type PromiseExecuteOptions = {
+    timeout?: number;
+    retryCount?: number;
+    retryInterval?: number;
+    retryCondition?: (error: any, retryCount: number) => boolean;
+  };
+
+  type Promise = (resolve: (value: any) => void, reject: (reason?: any) => void) => void;
+
+  type PromiseResult<T = any> = {
+    success: T[];
+    failed: { id: number; reason: any }[];
+    cancelled: number[];
+  };
+
+  type PromiseStatus = 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
+
   declare function timeScale(scale: number);
   declare let Entry: Entry;
 }

package/define/FWSystemDefine.ts

@@ -130,4 +130,11 @@ export namespace FWSystemDefine {
     SPRITE = 'sprite',
     SKELETON = 'skeleton',
   }
+
+  export enum FWPromiseStatus {
+    PENDING = 'pending',
+    FULFILLED = 'fulfilled',
+    REJECTED = 'rejected',
+    CANCELLED = 'cancelled',
+  }
 }

package/entry/FWEntry.ts

@@ -18,6 +18,7 @@ import { FWEventDefine } from '../define/FWEventDefine';
 import FWTaskManager from '../manager/FWTaskManager';
 import FWEngineManager from '../manager/FWEngineManager';
 import FWHotUpdateManager from '../manager/FWHotUpdateManager';
+import FWPromiseManager from '../manager/FWPromiseManager';
 
 /**
  * 入口脚本
@@ -84,6 +85,10 @@ export default class FWEntry implements FW.Entry {
    * 热更新管理器
    */
   hotUpdateMgr: FW.HotUpdateManager;
+  /**
+   * promise管理器
+   */
+  promiseMgr: FW.PromiseManager;
   /**
    * 当前Scene
    */
@@ -113,6 +118,7 @@ export default class FWEntry implements FW.Entry {
     this.componentMgr = new FWComponentManager();
     this.languageMgr = new FWLanguageManager();
     this.hotUpdateMgr = new FWHotUpdateManager();
+    this.promiseMgr = new FWPromiseManager();
 
     this.resMgr.initialize();
     this.layerMgr.initialize();

package/manager/FWAssetManager.ts

@@ -131,41 +131,36 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
 
     assetData.loaded = false;
 
-    return new Promise(
-      (
-        resolve: (value: FW.AssetData | PromiseLike<FW.AssetData>) => void,
-        reject: (reason?: any) => void,
-      ) => {
-        const self = this;
-        bundle.load(
-          path,
-          type,
-          (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
-            progress?.(finish, total, item);
-          },
-          (err: Error, asset: cc.Asset) => {
-            if (err || !asset) {
-              FWLog.error(`加载资源失败:${asset},请检查!`);
-              reject(err);
-            }
-
-            assetData.loaded = true;
-            assetData.dependentBundle = bundleName;
-            assetData.uuid = asset['_uuid'];
-            assetData.autoRelease = autoRelease;
-            assetData.asset = asset;
-            assetData.user = assetProperty.user;
-            assetData.refCount = 1;
-            assetData.assetProperty = assetProperty;
-
-            self.assetsMap.set(key, assetData);
+    return new Promise((resolve, reject) => {
+      const self = this;
+      bundle.load(
+        path,
+        type,
+        (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
+          progress?.(finish, total, item);
+        },
+        (err: Error, asset: cc.Asset) => {
+          if (err || !asset) {
+            reject(err);
+            return;
+          }
 
-            cb?.(assetData);
-            resolve(assetData);
-          },
-        );
-      },
-    );
+          assetData.loaded = true;
+          assetData.dependentBundle = bundleName;
+          assetData.uuid = asset['_uuid'];
+          assetData.autoRelease = autoRelease;
+          assetData.asset = asset;
+          assetData.user = assetProperty.user;
+          assetData.refCount = 1;
+          assetData.assetProperty = assetProperty;
+
+          self.assetsMap.set(key, assetData);
+
+          cb?.(assetData);
+          resolve(assetData);
+        },
+      );
+    });
   }
   /**
    * 加载文件夹

package/manager/FWPromiseManager.ts

@@ -0,0 +1,244 @@
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLog from '../log/FWLog';
+import { FWManager } from './FWManager';
+
+export default class FWPromiseManager extends FWManager implements FW.PromiseManager {
+  private promiseRegistry: Map<number, FW.PromiseProxy>;
+  private uniqueId: number = 0;
+  private timerSchedule: FW.TimerSchedule;
+
+  public initialize(): void {
+    this.promiseRegistry = new Map<number, FW.PromiseProxy>();
+  }
+
+  public onDestroy(): void {
+    this.cancelAll('Manager destroyed');
+    this.promiseRegistry.clear();
+    this.promiseRegistry = null;
+  }
+
+  /** 创建Promise执行器 */
+  public execute<T = any>(
+    executor: FW.PromiseExcutor<T>,
+    options: FW.PromiseExecuteOptions = {},
+  ): FW.PromiseProxy<T> {
+    const id = this.uniqueId++;
+    const abortController = new AbortController();
+    let retryCount = 0;
+    let promise: Promise<T>;
+    const maxRetryTimes = options.retryCount || 0;
+    const retryInterval = options.retryInterval || 0;
+    const promiseProxy: FW.PromiseProxy<T> = {
+      id,
+      promise,
+      status: FWSystemDefine.FWPromiseStatus.PENDING,
+      abortController,
+    };
+
+    const createPromise = (): Promise<T> => {
+      return new Promise<T>((resolve, reject) => {
+        if (options.timeout && options.timeout > 0) {
+          this.timerSchedule?.unSchedule();
+          this.timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
+            const timeoutError = new Error(`Promise ${id} timeout after ${options.timeout} s`);
+            if (
+              retryCount < maxRetryTimes &&
+              (!options.retryCondition || options.retryCondition(timeoutError, retryCount))
+            ) {
+              retryCount++;
+              FWLog.debug(`Promise ${id} timeout, retrying (${retryCount}/${maxRetryTimes})`);
+              if (retryInterval > 0) {
+                FW.Entry.timeMgr.scheduleOnce(() => {
+                  createPromise().then(resolve, reject);
+                }, retryInterval);
+              } else {
+                createPromise().then(resolve, reject);
+              }
+            } else {
+              abortController.abort(timeoutError.message);
+              this.timerSchedule?.unSchedule();
+            }
+          }, options.timeout);
+        }
+
+        const onAbort = () => {
+          this.timerSchedule?.unSchedule();
+          if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+            promiseProxy.status = FWSystemDefine.FWPromiseStatus.CANCELLED;
+            this.removePromise(id);
+          }
+        };
+
+        if (abortController.signal.aborted) {
+          onAbort();
+          return;
+        }
+
+        abortController.signal.addEventListener('abort', onAbort);
+
+        const wrappedResolve = (value: T | PromiseLike<T>) => {
+          this.timerSchedule?.unSchedule();
+          if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+            promiseProxy.status = FWSystemDefine.FWPromiseStatus.FULFILLED;
+            abortController.signal.removeEventListener('abort', onAbort);
+            this.removePromise(id);
+            resolve(value);
+          }
+        };
+
+        const wrappedReject = (reason?: any) => {
+          this.timerSchedule?.unSchedule();
+          if (
+            retryCount < maxRetryTimes &&
+            (!options.retryCondition || options.retryCondition(reason, retryCount))
+          ) {
+            retryCount++;
+            FWLog.debug(`Promise ${id} failed, retrying (${retryCount}/${maxRetryTimes}):`, reason);
+            if (retryInterval > 0) {
+              FW.Entry.timeMgr.scheduleOnce(() => {
+                createPromise().then(resolve, reject);
+              }, retryInterval);
+            } else {
+              createPromise().then(resolve, reject);
+            }
+          } else {
+            if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+              promiseProxy.status = FWSystemDefine.FWPromiseStatus.REJECTED;
+              abortController.signal.removeEventListener('abort', onAbort);
+              this.removePromise(id);
+              reject(reason);
+            }
+          }
+        };
+        try {
+          executor(wrappedResolve, wrappedReject, abortController.signal);
+        } catch (error) {
+          wrappedReject(error);
+        }
+      });
+    };
+
+    promise = createPromise();
+    promiseProxy.abort = (reason?: any) => {
+      if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+        FWLog.debug(reason || 'promise cancelled');
+        abortController.abort(reason);
+      }
+    };
+    promiseProxy.addAbortEventListener = (
+      listener: (this: AbortSignal, ev: Event) => any,
+      options?: boolean | AddEventListenerOptions,
+    ) => {
+      abortController.signal.addEventListener('abort', listener, options);
+    };
+    this.promiseRegistry.set(id, promiseProxy);
+    return promiseProxy;
+  }
+
+  /** 取消指定Promise */
+  public cancel(id: number, reason?: any): boolean {
+    const promiseProxy = this.promiseRegistry.get(id);
+    if (promiseProxy && promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+      promiseProxy.abort(reason);
+      return true;
+    }
+    return false;
+  }
+
+  /** 批量取消Promise */
+  public cancelMultiple(ids: number[], reason?: any): number[] {
+    const cancelled: number[] = [];
+    ids.forEach((id) => {
+      if (this.cancel(id, reason)) {
+        cancelled.push(id);
+      }
+    });
+    return cancelled;
+  }
+
+  /** 取消所有Promise */
+  public cancelAll(reason?: any): number[] {
+    const cancelled: number[] = [];
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+        promiseProxy.abort(reason);
+        cancelled.push(id);
+      }
+    });
+    return cancelled;
+  }
+
+  /** 批量执行Promise并等待所有完成 */
+  public async all<T = any>(
+    promises: FW.PromiseProxy<T>[],
+    options: FW.PromiseExecuteOptions = {},
+  ): Promise<FW.PromiseResult<T>> {
+    const result: FW.PromiseResult<T> = {
+      success: [],
+      failed: [],
+      cancelled: [],
+    };
+
+    for (const promiseProxy of promises) {
+      try {
+        const value = await promiseProxy.promise;
+        result.success.push(value);
+      } catch (error) {
+        if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.CANCELLED) {
+          result.cancelled.push(promiseProxy.id);
+        } else {
+          result.failed.push({
+            id: promiseProxy.id,
+            reason: error,
+          });
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /** 获取Promise状态 */
+  public getStatus(id: number): FWSystemDefine.FWPromiseStatus | null {
+    const promiseProxy = this.promiseRegistry.get(id);
+    return promiseProxy ? promiseProxy.status : null;
+  }
+
+  /** 获取所有Promise状态 */
+  public getAllStatus(): Map<number, FWSystemDefine.FWPromiseStatus> {
+    const statusMap = new Map<number, FWSystemDefine.FWPromiseStatus>();
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      statusMap.set(id, promiseProxy.status);
+    });
+    return statusMap;
+  }
+
+  /** 移除Promise */
+  private removePromise(id: number): void {
+    this.promiseRegistry.delete(id);
+  }
+
+  /** 获取正在执行的Promise数量 */
+  public getActiveCount(): number {
+    return Array.from(this.promiseRegistry.values()).filter(
+      (p) => p.status === FWSystemDefine.FWPromiseStatus.PENDING,
+    ).length;
+  }
+
+  /** 清理已完成的Promise */
+  public clearCompletedPromise(): number {
+    const completedIds: number[] = [];
+
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      if (promiseProxy.status !== FWSystemDefine.FWPromiseStatus.PENDING) {
+        completedIds.push(id);
+      }
+    });
+
+    completedIds.forEach((id) => {
+      this.promiseRegistry.delete(id);
+    });
+
+    return completedIds.length;
+  }
+}

package/manager/FWPromiseManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "efe0f191-ae87-4773-9dbe-5c66f49670db",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ives_xxz/framework",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "cocoscreator 2.x mvc framework",
   "main": "index.js",
   "keywords": ["123456"],