@kkarum/framework 2.3.17

package/manager/FWPromiseManager.ts

@@ -0,0 +1,504 @@
+import { FWManager } from "./FWManager";
+
+export default class FWPromiseManager
+  extends FWManager
+  implements FW.PromiseManager
+{
+  private promiseRegistry: Map<number, FW.PromiseProxy<any>>;
+  private uniqueId: number = 0;
+
+  public initialize(): void {
+    this.promiseRegistry = new Map<number, FW.PromiseProxy<any>>();
+  }
+
+  public onDestroy(): void {
+    this.cancelAll();
+    this.promiseRegistry.clear();
+  }
+
+  public execute<T = any>(
+    executor: FW.PromiseExcutor<T>,
+    options: FW.PromiseExecuteOptions = {},
+  ): FW.PromiseProxy<T> {
+    const id = this.uniqueId++;
+    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) {
+          timeoutPromise = new Promise<T>((_, timeoutReject) => {
+            timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
+              const timeoutError = new Error(
+                `Promise ${id} timeout after ${options.timeout} ms`,
+              );
+
+              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);
+                }
+              } else {
+                timeoutReject(timeoutError);
+              }
+            }, options.timeout / 1000);
+          });
+        }
+
+        const racePromises: Promise<T>[] = [mainPromise];
+
+        if (timeoutPromise) {
+          racePromises.push(timeoutPromise);
+        }
+
+        if (!isCancelled) {
+          const raceCancelPromise = cancelPromise as unknown as Promise<T>;
+          racePromises.push(raceCancelPromise);
+        }
+
+        Promise.race(racePromises)
+          .then((value) => {
+            if (isCancelled) return;
+            timerSchedule?.unSchedule();
+            resolve(value);
+            this.removePromise(id);
+          })
+          .catch((error) => {
+            if (isCancelled) return;
+
+            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);
+              }
+            } else {
+              reject(error);
+              this.removePromise(id);
+            }
+          });
+      });
+    };
+
+    const promise = createPromise();
+    const promiseProxy: FW.PromiseProxy<T> = {
+      id,
+      promise,
+      status: FW.SystemDefine.FWPromiseStatus.PENDING,
+      abort: (reason?: any) => {
+        if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
+          FW.Log.debug(reason || "promise cancelled");
+          cancelResolve?.();
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.CANCELLED;
+        }
+      },
+      addAbortEventListener: (
+        listener: (this: any, ev: Event) => any,
+        options?: boolean | AddEventListenerOptions,
+      ) => {
+        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;
+  }
+
+  public all<T = any>(
+    promises: FW.PromiseProxy<T>[],
+    options: FW.PromiseExecuteOptions = {},
+  ): FW.PromiseProxy<FW.PromiseAllResult<T>> {
+    const id = this.uniqueId++;
+    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) => {
+        let cancelPromiseResolve: (() => void) | null = null;
+        const cancelPromise = new Promise<never>((_, rejectCancel) => {
+          cancelResolve = () => {
+            isCancelled = true;
+            if (cancelPromiseResolve) {
+              cancelPromiseResolve();
+            } else {
+              setTimeout(() => {
+                if (cancelPromiseResolve) cancelPromiseResolve();
+              }, 0);
+            }
+          };
+        }).then(() => {
+          return new Promise<never>(() => {});
+        });
+
+        const processAll = async (): Promise<FW.PromiseAllResult<T>> => {
+          const result: FW.PromiseAllResult<T> = {
+            success: [],
+            failed: [],
+            cancelled: [],
+          };
+
+          for (const promiseProxy of promises) {
+            if (isCancelled) {
+              const remainingIds = promises
+                .filter(
+                  (p) =>
+                    !result.success.some((s) => s.id === p.id) &&
+                    !result.failed.some((f) => f.id === p.id),
+                )
+                .map((p) => p.id);
+              result.cancelled.push(...remainingIds);
+              break;
+            }
+
+            try {
+              const value = await promiseProxy.promise;
+              result.success.push({
+                id: promiseProxy.id,
+                value: value,
+              });
+            } catch (error) {
+              if (
+                promiseProxy.status ===
+                FW.SystemDefine.FWPromiseStatus.CANCELLED
+              ) {
+                result.cancelled.push(promiseProxy.id);
+              } else {
+                result.failed.push({
+                  id: promiseProxy.id,
+                  reason: error,
+                });
+              }
+            }
+          }
+
+          return result;
+        };
+
+        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} ms`,
+                );
+
+                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 / 1000);
+            },
+          );
+        }
+
+        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) => {
+            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))
+            ) {
+              retryCount++;
+              FW.Log.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 {
+              reject(error);
+              this.removePromise(id);
+            }
+          });
+      });
+    };
+
+    const promise = createPromise();
+    const promiseProxy: FW.PromiseProxy<FW.PromiseAllResult<T>> = {
+      id,
+      promise,
+      status: FW.SystemDefine.FWPromiseStatus.PENDING,
+      abort: (reason?: any) => {
+        if (promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING) {
+          FW.Log.debug(reason || "all promise cancelled");
+          cancelResolve?.();
+          promiseProxy.status = FW.SystemDefine.FWPromiseStatus.CANCELLED;
+        }
+      },
+      addAbortEventListener: (
+        listener: (this: any, ev: Event) => any,
+        options?: boolean | AddEventListenerOptions,
+      ) => {
+        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;
+  }
+
+  public cancel(id: number, reason?: any): boolean {
+    const promiseProxy = this.promiseRegistry.get(id);
+    if (
+      promiseProxy &&
+      promiseProxy.status === FW.SystemDefine.FWPromiseStatus.PENDING
+    ) {
+      promiseProxy.abort(reason);
+      return true;
+    }
+    return false;
+  }
+
+  public cancelMultiple(ids: number[], reason?: any): number[] {
+    const cancelled: number[] = [];
+    ids.forEach((id) => {
+      if (this.cancel(id, reason)) {
+        cancelled.push(id);
+      }
+    });
+    return cancelled;
+  }
+
+  public cancelAll(reason?: any): number[] {
+    const cancelled: number[] = [];
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      promiseProxy.abort(reason);
+      cancelled.push(id);
+    });
+    return cancelled;
+  }
+
+  public getStatus(id: number): FW.SystemDefine.FWPromiseStatus | null {
+    const promiseProxy = this.promiseRegistry.get(id);
+    return promiseProxy ? promiseProxy.status : null;
+  }
+
+  public getAllStatus(): Map<number, FW.SystemDefine.FWPromiseStatus> {
+    const statusMap = new Map<number, FW.SystemDefine.FWPromiseStatus>();
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      statusMap.set(id, promiseProxy.status);
+    });
+    return statusMap;
+  }
+
+  private removePromise(id: number): void {
+    this.promiseRegistry.delete(id);
+  }
+
+  public getActiveCount(): number {
+    return Array.from(this.promiseRegistry.values()).filter(
+      (p) => p.status === FW.SystemDefine.FWPromiseStatus.PENDING,
+    ).length;
+  }
+
+  public clearCompletedPromise(): number {
+    const completedIds: number[] = [];
+
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      if (promiseProxy.status !== FW.SystemDefine.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": {}
+}