Pomise

function _Promise(excutor) {
    let _this = this;
    this.status = "pending";
    this.onResolveCallbackedFun = [];
    this.onRejectCallbackedFun = [];
    this.reslut = null;
    this.reason = null;
    function resolve(value) {
        setTimeout(() => {
            if (_this.status === 'pending') {
                _this.status = "resolve";
                _this.reslut = value;
                _this.onResolveCallbackedFun.forEach((fn) => fn(value));
            }
        }, 0);

    }
    function reject(reason) {
        setTimeout(() => {
            if (_this.status === "pending") {
                _this.status = "reject";
                _this.reason = reason;
                _this.onRejectCallbackedFun.forEach((fn) => fn(reason))
            }
        }, 0);
    }
    try {
        excutor(resolve, reject);
    } catch (e) {
        throw e;
    }
}

_Promise.prototype.then = function (onFulfilled, onRejected) {
    let that = this;
    let newPromise = null;
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };
    if (that.status === 'resolve') {
        setTimeout(() => {
            try {
                console.log('resolven');
                let x = onFulfilled(that.reslut);
                return newPromise = new _Promise((resolve, reject) => {
                    resolvePromise(newPromise, x, resolve, reject);
                })
            }
            catch (e) {
                throw e;
            }
        }, 0);
    }
    if (that.status === 'reject') {
        setTimeout(() => {
            try {
                console.log('reject');
                let x = onRejected(that.reason);
                return newPromise = new _Promise((resolve, reject) => {
                    resolvePromise(newPromise, x, resolve, reject);
                })
            }
            catch (e) {
                throw e;
            }
        }, 0);

    }
    if (that.status === 'pending') {
        return newPromise = new _Promise((resolve, reject) => {
            that.onResolveCallbackedFun.push(() => {
                try {
                    setTimeout(() => {
                        x = onFulfilled(that.reslut);
                        resolvePromise(newPromise, x, resolve, reject);
                    }, 0);
                }
                catch (e) {
                    throw e;
                }
            });
            that.onRejectCallbackedFun.push(() => {
                try {
                    setTimeout(() => {
                        x = onRejected(that.reason);
                        resolvePromise(newPromise, x, resolve, reject)
                    }, 0);
                } catch (e) {
                    throw e;
                }
            });
        })

    }
}
let p = new _Promise((resolve, reject) => {
    let r = Math.floor(Math.random() * 10);
    if (r < 5) {
        resolve(r);
    }
    else {
        reject(r);
    }
})
p.then((values) => {
    console.log('p values', values);
    return new _Promise((resolve, reject) => {
        let r = Math.floor(Math.random() * 10);
        if (r < 5) {
            resolve(r);
        }
        else {
            reject(r);
        }
    })
}).then((value) => {
    console.log('second', value);
    return new Person('sdj', 14);
}, (reason) => {
    console.log('second reject', reason);
}).then((values) => {
    console.log('last', values);
}, err => {
    console.log(err);
})
function resolvePromise(newPromise, x, resolve, reject) {
    if (newPromise === x) return;
    if (x !== null && (typeof x === 'function' || typeof x === "object")) {
        try {
            let then = x.then;
            if (typeof then === "function") {
                x.then((value) => {
                    resolve(value);
                }, err => {
                    reject(err);
                })
            }
            else {
                resolve(x);
            }
        }
        catch (e) {
            reject(e);
        }
    }
    else {
        resolve(x);
    }
}

function Person(name, age) {
    this.name = name;
    this.age = age;
}

 function myAll(promises) {
        if (!Array.isArray(promises)) {
            throw TypeError;
        }

        return new Promise((resolve, reject) => {
            let result = [];
            promises.forEach((promise, index) => {
                promise.then((value) => {
                    result.push(value);
                    if (index === promises.length - 1) {
                        resolve(result)
                    }
                }, (err) => {
                    reject(err)
                })
            })

        })

    }