手写Promise

type resolve<T> = (value: T | PromiseLike<T>) => void;  
type reject = (reason?: any) => void;  
type executor<T> = (resolve: resolve<T>, reject: reject) => void;  
  
class MyPromise<T> {  
  private result: T | PromiseLike<T> | undefined;  
  private status: 'pending' | 'resolved' | 'rejected' = 'pending';  
  private onResolvedCallbacks: Array<(value: T) => any> = [];  
  private onRejectedCallbacks: Array<(reason: any) => any> = [];  
  
  private resolve(value: T | PromiseLike<T>) {  
    if (this.status !== 'pending') return;  
  
    // If the value is a promise, wait for it to resolve before continuing  
    if (value instanceof Promise || typeof value === 'object' && typeof (value as any).then === 'function') {  
      (value as Promise<T>).then(this.resolve.bind(this), this.reject.bind(this));  
    } else {  
      this.result = value;  
      this.status = 'resolved';  
      this.onResolvedCallbacks.forEach(fn => fn(this.result as T));  
    }  
  }  
  
  private reject(reason: any) {  
    if (this.status !== 'pending') return;  
  
    this.status = 'rejected';  
    this.onRejectedCallbacks.forEach(fn => fn(reason));  
  }  
  
  constructor(executor: executor<T>) {  
    executor(this.resolve.bind(this), this.reject.bind(this));  
  }  
  
  then(onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => any): MyPromise<T> {  
    return new MyPromise((resolve, reject) => {  
      // Handle resolved case  
      const fulfilled = (value: T) => {  
        try {  
          let result = onfulfilled ? onfulfilled(value) : value;  
          result instanceof Promise ? result.then(resolve, reject) : resolve(result);  
        } catch (err) {  
          reject(err);  
        }  
      };  
  
      // Handle rejected case  
      const rejected = (reason: any) => {  
        try {  
          let result = onrejected ? onrejected(reason) : reject(reason);  
          result instanceof Promise ? result.then(resolve, reject) : (result !== undefined && resolve(result)) || reject(reason);  
        } catch (err) {  
          reject(err);  
        }  
      };  
  
      switch (this.status) {  
        case 'resolved':  
          fulfilled(this.result as T);  
          break;  
        case 'rejected':  
          rejected(this.result as any);  
          break;  
        case 'pending':  
          this.onResolvedCallbacks.push(fulfilled);  
          this.onRejectedCallbacks.push(rejected);  
          break;  
      }  
    });  
  }  
}  
  
// Example usage:  
new MyPromise<number>((resolve, reject) => {  
  console.log(11);  
  resolve(110);  
}).then(e => {  
  console.log(e);  
  return e + 10; // Chaining example  
}).then(e => {  
  console.log(e); // Should print 120  
});