<pre><code>class MyPromise {
  constructor(executor) {
    this.status = 'pending';
    this.value = undefined;
    this.isInvoked = false;
    this.callback = [];
    try {
      executor(this._resolve.bind(this), this._reject.bind(this))
    } catch (error) {
      this._reject(error)
    }
  }

  _resolve(value) {
    if (this.status !== 'pending') return;

    if (value instanceof MyPromise) {
      return value.then(
        val =&gt; this._resolve(val),
        err =&gt; this._reject(err)
      );
    }

    if (value &amp;&amp; typeof value.then === 'function') {
      return value.then(
        val =&gt; this._resolve(val),
        err =&gt; this._reject(err)
      );
    }

    this.status = 'fulfilled';
    this.value = value;
    this.handleSettled('onFulfilled');
  }

  _reject(error) {
    if (this.status !== 'pending') return;

    this.status = 'rejected';
    this.value = error;
    this.handleSettled('onRejected');
  }


  handleSettled(settledValue) {
    queueMicrotask(() =&gt; {
      for(let cb of this.callback) {
        try {
          const returnValue = cb[settledValue](this.value)

          if(returnValue instanceof MyPromise) {
            returnValue.then(cb.resolve, cb.reject)
          } else {
            cb.resolve(returnValue);
          }
        } catch(error) {
          cb.reject(error)
        }
      }
      this.callback = [];
    })
  }

  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) =&gt; {
      const fulfilled = onFulfilled ?? (val =&gt; val);
      const rejected = onRejected ?? (err =&gt; { throw err });

      if (this.status === "fulfilled") {
       queueMicrotask(() =&gt; {
          try {
            const result = fulfilled(this.value);
            resolve(result);
          } catch (e) {
            reject(e);
          }
        });
      } else if (this.status === "rejected") {
         queueMicrotask(() =&gt; {
            try {
              const result = rejected(this.value);
              resolve(result);
            } catch (e) {
              reject(e);
            }
          });
      } else {
        this.callback.push({ onFulfilled: fulfilled, onRejected: rejected, resolve, reject });
      }
    });
  }
  
  catch(onRejected) {
    return this.then(null, onRejected);
  }
  
  static resolve(value) {
    if (value instanceof MyPromise) return value;
    return new MyPromise(res =&gt; res(value))
  }
  
  static reject(value) {
    if (value instanceof MyPromise) return value;
     return new MyPromise((_,rej) =&gt; rej(value))
  }
}

</code></pre>

1 test case failing -` Promise could only be resolved once spec  , expects [["resolve",1]] but got [["reject",3]]`. Could someone please help ?

Amazon

Airbnb

LinkedIn

Promise is widely used nowadays, hard to think how we handled Callback Hell in the old times. Can you implement a MyPromise Class by yourself? At leas…