@ives_xxz/framework 2.1.23 → 2.1.24

package/manager/FWPromiseManager.ts

@@ -13,170 +13,228 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     this.promiseRegistry.clear();
   }
 
-  /** 创建Promise执行器 */
   public execute<T = any>(
     executor: FW.PromiseExcutor<T>,
     options: FW.PromiseExecuteOptions = {},
   ): FW.PromiseProxy<T> {
     const id = this.uniqueId++;
-    const abortController = new AbortController();
     const maxRetryTimes = options.retryCount || 0;
     const retryInterval = options.retryInterval || 0;
     let retryCount = 0;
     let timerSchedule: FW.TimerSchedule;
+    let cancelResolve: (() => void) | null = null;
+    let isCancelled = false;
+    let abortListeners: Array<(this: any, ev: Event) => any> = [];
 
     const createPromise = (): Promise<T> => {
       return new Promise<T>((resolve, reject) => {
+        let cancelPromiseResolve: (() => void) | null = null;
+        const cancelPromise = new Promise<never>((resolve, reject) => {
+          cancelResolve = () => {
+            isCancelled = true;
+            if (cancelPromiseResolve) {
+              cancelPromiseResolve();
+            } else {
+              FW.Entry.timeMgr.scheduleOnce(() => {
+                if (cancelPromiseResolve) cancelPromiseResolve();
+              });
+            }
+          };
+        }).then(() => {
+          return new Promise<never>(() => {});
+        });
+
+        const mainPromise = new Promise<T>((innerResolve, innerReject) => {
+          try {
+            const signal = {
+              aborted: isCancelled,
+              onabort: null as ((this: any, ev: Event) => any) | null,
+              addEventListener: (type: string, listener: (this: any, ev: Event) => any) => {
+                if (type === 'abort') {
+                  signal.onabort = listener;
+                }
+              },
+              removeEventListener: () => {
+                signal.onabort = null;
+              },
+            };
+
+            executor(
+              (value) => {
+                if (!isCancelled) innerResolve(value);
+              },
+              (reason) => {
+                if (!isCancelled) innerReject(reason);
+              },
+              signal as any,
+              options.reason,
+            );
+
+            cancelPromiseResolve = () => {
+              if (signal.onabort) {
+                signal.onabort.call(signal, { type: 'abort' } as Event);
+              }
+              abortListeners.forEach((listener) => {
+                try {
+                  listener.call({ type: 'abort' }, { type: 'abort' } as Event);
+                } catch (error) {
+                  FW.Log.error('Error in abort listener:', error);
+                }
+              });
+            };
+          } catch (error) {
+            if (!isCancelled) innerReject(error);
+          }
+        });
+
+        let timeoutPromise: Promise<T> | null = null;
         if (options.timeout && options.timeout > 0) {
-          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++;
-              FW.Log.debug(`Promise ${id} timeout, retrying (${retryCount}/${maxRetryTimes})`);
-              if (retryInterval > 0) {
-                FW.Entry.timeMgr.scheduleOnce(() => {
+          timeoutPromise = new Promise<T>((_, timeoutReject) => {
+            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++;
+                FW.Log.debug(`Promise ${id} timeout, retrying (${retryCount}/${maxRetryTimes})`);
+
+                if (retryInterval > 0) {
+                  FW.Entry.timeMgr.scheduleOnce(() => {
+                    createPromise().then(resolve, reject);
+                  }, retryInterval);
+                } else {
                   createPromise().then(resolve, reject);
-                }, retryInterval);
+                }
               } else {
-                createPromise().then(resolve, reject);
+                timeoutReject(timeoutError);
               }
-            } else {
-              abortController.abort(timeoutError.message);
-              timerSchedule?.unSchedule();
-            }
-          }, options.timeout);
+            }, options.timeout);
+          });
         }
 
-        const onAbort = () => {
-          FW.Log.debug('promise abort');
-          timerSchedule?.unSchedule();
-          this.removePromise(id);
-        };
+        const racePromises: Promise<T>[] = [mainPromise];
 
-        if (abortController.signal.aborted) {
-          onAbort();
-          return;
+        if (timeoutPromise) {
+          racePromises.push(timeoutPromise);
         }
 
-        abortController.signal.addEventListener('abort', onAbort);
+        if (!isCancelled) {
+          const raceCancelPromise = cancelPromise as unknown as Promise<T>;
+          racePromises.push(raceCancelPromise);
+        }
 
-        const wrappedResolve = (value: T | PromiseLike<T>) => {
-          abortController.signal.removeEventListener('abort', onAbort);
-          this.removePromise(id);
-          timerSchedule?.unSchedule();
-          resolve(value);
-        };
+        Promise.race(racePromises)
+          .then((value) => {
+            if (isCancelled) return;
+            timerSchedule?.unSchedule();
+            resolve(value);
+            this.removePromise(id);
+          })
+          .catch((error) => {
+            if (isCancelled) return;
 
-        const wrappedReject = (reason?: any) => {
-          timerSchedule?.unSchedule();
-          if (
-            retryCount < maxRetryTimes &&
-            (!options.retryCondition || options.retryCondition(reason, retryCount))
-          ) {
-            retryCount++;
-            FW.Log.debug(
-              `Promise ${id} failed, retrying (${retryCount}/${maxRetryTimes}):`,
-              reason,
-            );
-            if (retryInterval > 0) {
-              FW.Entry.timeMgr.scheduleOnce(() => {
+            timerSchedule?.unSchedule();
+
+            if (
+              retryCount < maxRetryTimes &&
+              (!options.retryCondition || options.retryCondition(error, retryCount))
+            ) {
+              retryCount++;
+              FW.Log.debug(
+                `Promise ${id} failed, retrying (${retryCount}/${maxRetryTimes}):`,
+                error,
+              );
+
+              if (retryInterval > 0) {
+                FW.Entry.timeMgr.scheduleOnce(() => {
+                  createPromise().then(resolve, reject);
+                }, retryInterval);
+              } else {
                 createPromise().then(resolve, reject);
-              }, retryInterval);
+              }
             } else {
-              createPromise().then(resolve, reject);
+              reject(error);
+              this.removePromise(id);
             }
-          } else {
-            abortController.signal.removeEventListener('abort', onAbort);
-            this.removePromise(id);
-            reject(reason);
-          }
-        };
-        try {
-          executor(wrappedResolve, wrappedReject, abortController.signal, options.reason);
-        } catch (error) {
-          wrappedReject(error);
-        }
+          });
       });
     };
+
     const promise = createPromise();
     const promiseProxy: FW.PromiseProxy<T> = {
       id,
       promise,
       status: FW.SystemDefine.FWPromiseStatus.PENDING,
-      abortController,
       abort: (reason?: any) => {
         if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
           FW.Log.debug(reason || 'promise cancelled');
-          abortController.abort(reason);
+          cancelResolve?.();
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.CANCELLED;
         }
       },
-
       addAbortEventListener: (
-        listener: (this: AbortSignal, ev: Event) => any,
+        listener: (this: any, ev: Event) => any,
         options?: boolean | AddEventListenerOptions,
       ) => {
-        abortController.signal.addEventListener('abort', listener, options);
+        abortListeners.push(listener);
+        return () => {
+          const index = abortListeners.indexOf(listener);
+          if (index > -1) {
+            abortListeners.splice(index, 1);
+          }
+        };
       },
     };
+
     this.promiseRegistry.set(id, promiseProxy);
+
+    promise
+      .then(() => {
+        if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.FULFILLED;
+        }
+      })
+      .catch((error) => {
+        if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.REJECTED;
+        }
+      });
+
     return promiseProxy;
   }
 
-  /** 批量执行Promise并等待所有完成 */
   public all<T = any>(
     promises: FW.PromiseProxy<T>[],
     options: FW.PromiseExecuteOptions = {},
   ): FW.PromiseProxy<FW.PromiseAllResult<T>> {
     const id = this.uniqueId++;
-    const abortController = new AbortController();
     const maxRetryTimes = options.retryCount || 0;
     const retryInterval = options.retryInterval || 0;
     let timerSchedule: FW.TimerSchedule;
     let retryCount = 0;
+    let cancelResolve: (() => void) | null = null;
+    let isCancelled = false;
+    let abortListeners: Array<(this: any, ev: Event) => any> = [];
 
     const createPromise = (): Promise<FW.PromiseAllResult<T>> => {
       return new Promise<FW.PromiseAllResult<T>>((resolve, reject) => {
-        if (options.timeout && options.timeout > 0) {
-          timerSchedule?.unSchedule();
-          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++;
-              FW.Log.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);
-              }
+        let cancelPromiseResolve: (() => void) | null = null;
+        const cancelPromise = new Promise<never>((_, rejectCancel) => {
+          cancelResolve = () => {
+            isCancelled = true;
+            if (cancelPromiseResolve) {
+              cancelPromiseResolve();
             } else {
-              abortController.abort(timeoutError.message);
-              timerSchedule?.unSchedule();
+              setTimeout(() => {
+                if (cancelPromiseResolve) cancelPromiseResolve();
+              }, 0);
             }
-          }, options.timeout);
-        }
-
-        const onAbort = () => {
-          timerSchedule?.unSchedule();
-          if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
-            promiseProxy.status = FW.SystemDefine.FWPromiseStatus.CANCELLED;
-            this.removePromise(id);
-          }
-        };
-
-        if (abortController.signal.aborted) {
-          onAbort();
-          return;
-        }
-
-        abortController.signal.addEventListener('abort', onAbort);
+          };
+        }).then(() => {
+          return new Promise<never>(() => {});
+        });
 
         const processAll = async (): Promise<FW.PromiseAllResult<T>> => {
           const result: FW.PromiseAllResult<T> = {
@@ -186,8 +244,7 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
           };
 
           for (const promiseProxy of promises) {
-            if (abortController.signal.aborted) {
-              // 找出所有尚未处理的任务标记为取消
+            if (isCancelled) {
               const remainingIds = promises
                 .filter(
                   (p) =>
@@ -220,16 +277,72 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
           return result;
         };
 
-        processAll()
+        const mainPromise = processAll();
+
+        cancelPromiseResolve = () => {
+          abortListeners.forEach((listener) => {
+            try {
+              listener.call({ type: 'abort' }, { type: 'abort' } as Event);
+            } catch (error) {
+              FW.Log.error('Error in abort listener:', error);
+            }
+          });
+        };
+
+        let timeoutPromise: Promise<FW.PromiseAllResult<T>> | null = null;
+        if (options.timeout && options.timeout > 0) {
+          timeoutPromise = new Promise<FW.PromiseAllResult<T>>((_, timeoutReject) => {
+            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++;
+                FW.Log.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 {
+                timeoutReject(timeoutError);
+              }
+            }, options.timeout);
+          });
+        }
+
+        const racePromises: Promise<FW.PromiseAllResult<T>>[] = [mainPromise];
+
+        if (timeoutPromise) {
+          racePromises.push(timeoutPromise);
+        }
+
+        if (!isCancelled) {
+          const raceCancelPromise = cancelPromise as unknown as Promise<FW.PromiseAllResult<T>>;
+          racePromises.push(raceCancelPromise);
+        }
+
+        Promise.race(racePromises)
           .then((result) => {
-            promiseProxy.status = FW.SystemDefine.FWPromiseStatus.FULFILLED;
-            abortController.signal.removeEventListener('abort', onAbort);
-            this.removePromise(id);
+            if (isCancelled) return;
             timerSchedule?.unSchedule();
             resolve(result);
+            this.removePromise(id);
           })
           .catch((error) => {
+            if (isCancelled) return;
+
             timerSchedule?.unSchedule();
+
             if (
               retryCount < maxRetryTimes &&
               (!options.retryCondition || options.retryCondition(error, retryCount))
@@ -239,6 +352,7 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
                 `All Promise ${id} failed, retrying (${retryCount}/${maxRetryTimes}):`,
                 error,
               );
+
               if (retryInterval > 0) {
                 FW.Entry.timeMgr.scheduleOnce(() => {
                   createPromise().then(resolve, reject);
@@ -247,12 +361,8 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
                 createPromise().then(resolve, reject);
               }
             } else {
-              if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
-                promiseProxy.status = FW.SystemDefine.FWPromiseStatus.REJECTED;
-                abortController.signal.removeEventListener('abort', onAbort);
-                this.removePromise(id);
-                reject(error);
-              }
+              reject(error);
+              this.removePromise(id);
             }
           });
       });
@@ -263,26 +373,44 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
       id,
       promise,
       status: FW.SystemDefine.FWPromiseStatus.PENDING,
-      abortController,
       abort: (reason?: any) => {
         if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
           FW.Log.debug(reason || 'all promise cancelled');
-          abortController.abort(reason);
+          cancelResolve?.();
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.CANCELLED;
         }
       },
       addAbortEventListener: (
-        listener: (this: AbortSignal, ev: Event) => any,
+        listener: (this: any, ev: Event) => any,
         options?: boolean | AddEventListenerOptions,
       ) => {
-        abortController.signal.addEventListener('abort', listener, options);
+        abortListeners.push(listener);
+        return () => {
+          const index = abortListeners.indexOf(listener);
+          if (index > -1) {
+            abortListeners.splice(index, 1);
+          }
+        };
       },
     };
 
     this.promiseRegistry.set(id, promiseProxy);
+
+    promise
+      .then(() => {
+        if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.FULFILLED;
+        }
+      })
+      .catch((error) => {
+        if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.REJECTED;
+        }
+      });
+
     return promiseProxy;
   }
 
-  /** 取消指定Promise */
   public cancel(id: number, reason?: any): boolean {
     const promiseProxy = this.promiseRegistry.get(id);
     if (promiseProxy && promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
@@ -292,7 +420,6 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     return false;
   }
 
-  /** 批量取消Promise */
   public cancelMultiple(ids: number[], reason?: any): number[] {
     const cancelled: number[] = [];
     ids.forEach((id) => {
@@ -303,7 +430,6 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     return cancelled;
   }
 
-  /** 取消所有Promise */
   public cancelAll(reason?: any): number[] {
     const cancelled: number[] = [];
     this.promiseRegistry.forEach((promiseProxy, id) => {
@@ -313,13 +439,11 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     return cancelled;
   }
 
-  /** 获取Promise状态 */
   public getStatus(id: number): FW.SystemDefine.FWPromiseStatus | null {
     const promiseProxy = this.promiseRegistry.get(id);
     return promiseProxy ? promiseProxy.status : null;
   }
 
-  /** 获取所有Promise状态 */
   public getAllStatus(): Map<number, FW.SystemDefine.FWPromiseStatus> {
     const statusMap = new Map<number, FW.SystemDefine.FWPromiseStatus>();
     this.promiseRegistry.forEach((promiseProxy, id) => {
@@ -328,19 +452,16 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
     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 === FW.SystemDefine.FWPromiseStatus.PENDING,
     ).length;
   }
 
-  /** 清理已完成的Promise */
   public clearCompletedPromise(): number {
     const completedIds: number[] = [];
 

package/package.json

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

package/types/FW.d.ts

@@ -2261,7 +2261,6 @@ declare namespace FW {
     id: number;
     status: any;
     promise?: Promise<T>;
-    abortController: AbortController;
     abort?: (reason?: any) => void;
     addAbortEventListener?: (
       listener: (this: AbortSignal, ev: Event) => any,