customPromise.ts

export default class MyPromise<T> {
  private status = "pending";
  private thenCallBacks: ((value: T) => any)[] = [];
  private catchCallBacks: ((error: Error) => any)[] = [];
  private successData?: T;
  private failureData?: Error;

  constructor(executor:(resolve:(data:T)=>any, reject:(err:Error)=>any)){
    try{
      executor(this.resolve,this.reject);
    }
    catch(e){
      this.reject(e)
    }
  }

  private resolve(data: T) {
    if (data instanceof MyPromise) {
      // call then method
    } else {
      queueMicrotask(() => {
        if (this.status === "pending") {
          (this.status = "fulfilled"), (this.successData = data);

          this.thenCallBacks.forEach((cb) => cb(data));
        }
      });
    }
  }

  private reject(error: Error) {
    if (error instanceof MyPromise) {
      // call then
    } else {
      queueMicrotask(() => {
        if (this.status === "pending") {
          this.status = "rejected";
          this.failureData = error;

          this.catchCallBacks.forEach((cb) => cb(error));
        }
      });
    }
  }

  public then(
    onFullFilled?: (data: T) => any,
    onRejected?: (error: Error) => any
  ) {
    const successCallBack = onFullFilled
      ? onFullFilled
      : (data: unknown) => data;
    const failureData = onRejected
      ? onRejected
      : (err: Error) => {
          throw err;
        };

      return new MyPromise((resolve,reject)=>{

        const handle = (callback, args)=>{
          try{
            resolve(callback(args));
          }
          catch(e){
            reject(e)
          }
        }

        if(this.status==="pending"){
          this.thenCallBacks.push(())
        }

      })
  }
}