SOURCE

const MyPromise = (executer) => {
    let self = this;
    self.status = 'pending'
    self.data = undefined
    self.onResolveCallback = []
    self.onRejectCallback = []

    const reslove = (value) => {
        if(self.status === 'pending') {
            self.status = 'resolved';
            self.data = value;
            for (let i = 0;i < self.onResolveCallback.length;i++) {
                self.onRejectCallback[i](value)
            }
        }
    }

    const rejcet = (reason) => {
        if (self.status === 'pending') {
            self.status = 'rejected'
            self.data = reason
            for (let i = 0;i < self.onRejectCallback.length;i++) {
                self.onRejectCallback[i](reason)
            }
        }
    }
    const reject = () => {}

    try {
        executer(resolve, reject)
    } catch(e){
        reject(e)
    }
}

MyPromise.prototype.then = (onResolved, onRejected) => {

    onResolved = typeof onResolved === 'function'?onResolved:function(v) {}
    onRejected = typeof onRejected === 'function'? onRejected: function(r) {}

    if (this.status === 'resolved') {
        return new Promise((resolve, reject) => {
            try {
                const x = onResolved(this.data)
                if (x instanceof MyPromise) {
                    x.then(resolve, reject)
                }
                resolve(x)
            } catch(e) {
                rejcet(e) 
            }
        })
    }

    if (self.status === 'rejected') {
        return new Promise((resolve, reject) => {
            try {
                const x = onRejected(this.data)
                if (x instanceof MyPromise) {
                    x.then(resolve, reject)
                }
            } catch(e) {
                rejcet(e) 
            }
        })
    }

    if (self.status === 'pending') {
        return new Promise((resolve, reject) => {

        })
    }
}