用typescript写一个promise

以下是一个简单的 TypeScript Promise 的实现：

class MyPromise<T> {
  private state: "pending" | "fulfilled" | "rejected" = "pending";
  private value?: T;
  private reason?: any;
  private onFulfilledCallbacks: ((value: T) => void)[] = [];
  private onRejectedCallbacks: ((reason: any) => void)[] = [];

  constructor(executor: (resolve: (value?: T) => void, reject: (reason?: any) => void) => void) {
    try {
      executor(this.resolve.bind(this), this.reject.bind(this));
    } catch (error) {
      this.reject(error);
    }
  }

  private resolve(value?: T): void {
    if (this.state === "pending") {
      this.state = "fulfilled";
      this.value = value;
      this.onFulfilledCallbacks.forEach((callback) => callback(value));
    }
  }

  private reject(reason?: any): void {
    if (this.state === "pending") {
      this.state = "rejected";
      this.reason = reason;
      this.onRejectedCallbacks.forEach((callback) => callback(reason));
    }
  }

  then<U>(onFulfilled?: (value: T) => U, onRejected?: (reason: any) => U): MyPromise<U> {
    const promise2 = new MyPromise<U>((resolve, reject) => {
      if (this.state === "fulfilled") {
        try {
          const result = onFulfilled?.(this.value as T);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      } else if (this.state === "rejected") {
        try {
          const result = onRejected?.(this.reason);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      } else {
        this.onFulfilledCallbacks.push((value) => {
          try {
            const result = onFulfilled?.(value);
            if (result instanceof MyPromise) {
              result.then(resolve, reject);
            } else {
              resolve(result);
            }
          } catch (error) {
            reject(error);
          }
        });
        this.onRejectedCallbacks.push((reason) => {
          try {
            const result = onRejected?.(reason);
            if (result instanceof MyPromise) {
              result.then(resolve, reject);
            } else {
              resolve(result);
            }
          } catch (error) {
            reject(error);
          }
        });
      }
    });
    return promise2;
  }

  catch<U>(onRejected: (reason: any) => U): MyPromise<U> {
    return this.then(undefined, onRejected);
  }

  static resolve<T>(value?: T): MyPromise<T> {
    return new MyPromise<T>((resolve) => {
      resolve(value);
    });
  }

  static reject(reason?: any): MyPromise<any> {
    return new MyPromise<any>((_, reject) => {
      reject(reason);
    });
  }

  static all<T>(promises: MyPromise<T>[] | Iterable<MyPromise<T>>): MyPromise<T[]> {
    const promiseArr = Array.from(promises);
    return new MyPromise<T[]>((resolve, reject) => {
      if (promiseArr.length === 0) {
        resolve([]);
        return;
      }
      const results: T[] = [];
      let completedCount = 0;
      promiseArr.forEach((promise, index) => {
        promise
          .then((value) => {
            results[index] = value;
            completedCount++;
            if (completedCount === promiseArr.length) {
              resolve(results);
            }
          })
          .catch((reason) => {
            reject(reason);
          });
      });
    });
  }

  static race<T>(promises: MyPromise<T>[] | Iterable<MyPromise<T>>): MyPromise<T> {
    const promiseArr = Array.from(promises);
    return new MyPromise<T>((resolve, reject) => {
      if (promiseArr.length === 0) {
        return;
      }
      promiseArr.forEach((promise) => {
        promise.then(resolve, reject);
      });
    });
  }
}

这个 MyPromise 类实现了 Promise 的基本功能，包括 then、catch、resolve、reject、all 和 race 方法。在 then 方法中，它会返回一个新的 MyPromise 对象，可以实现链式调用。