@ives_xxz/framework 1.4.6 → 1.4.8

package/FW.d.ts

@@ -50,7 +50,7 @@ declare namespace FW {
   };
 
   type PromiseManager = {
-    public execute<T = any>(
+    execute<T = any>(
       executor: (
         resolve: (value: T | PromiseLike<T>) => void,
         reject: (reason?: any) => void,
@@ -58,6 +58,10 @@ declare namespace FW {
       ) => void = PromiseExcutor,
       options: PromiseExecuteOptions = {},
     ): PromiseProxy<T>;
+    all<T = any>(
+      promises: FW.PromiseProxy<T>[],
+      options: FW.PromiseExecuteOptions = {},
+    ): FW.PromiseProxy<FW.PromiseResult<T>>;
   };
 
   type Registry = {
@@ -1950,7 +1954,7 @@ declare namespace FW {
   type Promise = (resolve: (value: any) => void, reject: (reason?: any) => void) => void;
 
   type PromiseResult<T = any> = {
-    success: T[];
+    success: PromiseProxy<T>[];
     failed: { id: number; reason: any }[];
     cancelled: number[];
   };

package/manager/FWAssetManager.ts

@@ -131,37 +131,43 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
 
     assetData.loaded = false;
 
-    const proxy = FW.Entry.promiseMgr.execute((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;
-          }
+    return FW.Entry.promiseMgr.execute(
+      (resolve, reject, signal) => {
+        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;
+            }
 
-          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);
-        },
-      );
-    });
-    return proxy.promise;
+            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);
+          },
+        );
+      },
+      {
+        retryCount: 3,
+        retryInterval: 1,
+        timeout: 10,
+      },
+    ).promise;
   }
   /**
    * 加载文件夹
@@ -173,7 +179,6 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
       FWLog.error(`加载资源失败,请检查参数列表:${assetProperty}!`);
       return undefined;
     }
-
     const bundleName = assetProperty.bundle || FW.Entry.bundleName;
     const type = assetProperty.type;
     const path = assetProperty.path;

package/manager/FWPromiseManager.ts

@@ -27,11 +27,6 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     let retryCount = 0;
     const maxRetryTimes = options.retryCount || 0;
     const retryInterval = options.retryInterval || 0;
-    const promiseProxy: FW.PromiseProxy<T> = {
-      id,
-      status: FWSystemDefine.FWPromiseStatus.PENDING,
-      abortController,
-    };
 
     const createPromise = (): Promise<T> => {
       return new Promise<T>((resolve, reject) => {
@@ -114,19 +109,180 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
       });
     };
 
-    promiseProxy.promise = createPromise();
-    promiseProxy.abort = (reason?: any) => {
-      if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
-        FWLog.debug(reason || 'promise cancelled');
-        abortController.abort(reason);
-      }
+    const promise = createPromise();
+    const promiseProxy: FW.PromiseProxy<T> = {
+      id,
+      promise,
+      status: FWSystemDefine.FWPromiseStatus.PENDING,
+      abortController,
+      abort: (reason?: any) => {
+        if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+          FWLog.debug(reason || 'promise cancelled');
+          abortController.abort(reason);
+        }
+      },
+      addAbortEventListener: (
+        listener: (this: AbortSignal, ev: Event) => any,
+        options?: boolean | AddEventListenerOptions,
+      ) => {
+        abortController.signal.addEventListener('abort', listener, options);
+      },
     };
-    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 all<T = any>(
+    promises: FW.PromiseProxy<T>[],
+    options: FW.PromiseExecuteOptions = {},
+  ): FW.PromiseProxy<FW.PromiseResult<T>> {
+    const id = this.uniqueId++;
+    const abortController = new AbortController();
+    let retryCount = 0;
+    const maxRetryTimes = options.retryCount || 0;
+    const retryInterval = options.retryInterval || 0;
+
+    const createPromise = (): Promise<FW.PromiseResult<T>> => {
+      return new Promise<FW.PromiseResult<T>>((resolve, reject) => {
+        if (options.timeout && options.timeout > 0) {
+          this.timerSchedule?.unSchedule();
+          this.timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
+            const timeoutError = new Error(`All Promise ${id} timeout after ${options.timeout} s`);
+            if (
+              retryCount < maxRetryTimes &&
+              (!options.retryCondition || options.retryCondition(timeoutError, retryCount))
+            ) {
+              retryCount++;
+              FWLog.debug(`All 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 processAll = async () => {
+          const result: FW.PromiseResult<T> = {
+            success: [],
+            failed: [],
+            cancelled: [],
+          };
+
+          for (const promiseProxy of promises) {
+            // 检查是否已取消
+            if (abortController.signal.aborted) {
+              result.cancelled.push(
+                ...promises
+                  .map((p) => p.id)
+                  .filter(
+                    (id) =>
+                      !result.success.some((s) => s.id === id) &&
+                      !result.failed.some((f) => f.id === id),
+                  ),
+              );
+              break;
+            }
+
+            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;
+        };
+
+        processAll()
+          .then((result) => {
+            promiseProxy.status = FWSystemDefine.FWPromiseStatus.FULFILLED;
+            abortController.signal.removeEventListener('abort', onAbort);
+            this.removePromise(id);
+            this.timerSchedule?.unSchedule();
+            resolve(result);
+          })
+          .catch((error) => {
+            this.timerSchedule?.unSchedule();
+            if (
+              retryCount < maxRetryTimes &&
+              (!options.retryCondition || options.retryCondition(error, retryCount))
+            ) {
+              retryCount++;
+              FWLog.debug(
+                `All Promise ${id} failed, retrying (${retryCount}/${maxRetryTimes}):`,
+                error,
+              );
+              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(error);
+              }
+            }
+          });
+      });
+    };
+
+    const promise = createPromise();
+    const promiseProxy: FW.PromiseProxy<FW.PromiseResult<T>> = {
+      id,
+      promise,
+      status: FWSystemDefine.FWPromiseStatus.PENDING,
+      abortController,
+      abort: (reason?: any) => {
+        if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+          FWLog.debug(reason || 'all promise cancelled');
+          abortController.abort(reason);
+        }
+      },
+      addAbortEventListener: (
+        listener: (this: AbortSignal, ev: Event) => any,
+        options?: boolean | AddEventListenerOptions,
+      ) => {
+        abortController.signal.addEventListener('abort', listener, options);
+      },
     };
+
     this.promiseRegistry.set(id, promiseProxy);
     return promiseProxy;
   }
@@ -164,36 +320,6 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     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);

package/package.json

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