SOURCE

class myPromise {
    static PENDING = 'pending'; // 这种写法还是提案
    static FULFILLED = 'fulfilled';// 这种写法还是提案
    static REJECTED = 'rejected';// 这种写法还是提案
    static COUNTER = 1;// 这种写法还是提案
    constructor(fn) {
        try {
            this.PromiseState = myPromise.PENDING;
            this.PromiseResult = null
            this.onFulfilledCallbacks = []; // 保存成功回调
            this.onRejectedCallbacks = []; // 保存失败回调
            this.textNode = document.createTextNode(String(myPromise.COUNTER))
            fn(this.resolve.bind(this), this.reject.bind(this))
        } catch (e) {
            this.reject(e)
        }
    }
    resolve(res) {
        if (this.PromiseState === myPromise.PENDING) {
            this.PromiseState = myPromise.FULFILLED
            this.PromiseResult = res
            let observer = new MutationObserver(() => {
                while (this.onFulfilledCallbacks.length) {
                    this.onFulfilledCallbacks.shift()(this.PromiseResult);
                }
                observer.disconnect();
            });
            observer.observe(this.textNode, { characterData: true });
            this.textNode.data = (myPromise.COUNTER + 1) % 2;
        }
    }
    reject(e) {
        if (this.PromiseState === myPromise.PENDING) {
            this.PromiseState = myPromise.REJECTED
            this.PromiseResult = e
            let observer = new MutationObserver(() => {
                while (this.onRejectedCallbacks.length) {
                    this.onRejectedCallbacks.shift()(this.PromiseResult);
                }
                observer.disconnect();
            });
            observer.observe(this.textNode, { characterData: true });
            this.textNode.data = (myPromise.COUNTER + 1) % 2;
        }
    }
    then(onFulfilled, onRejected) {
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : res => res
        onRejected = typeof onRejected === 'function' ? onRejected : e => { throw e }
        if (this.PromiseState === myPromise.PENDING) {
            this.onFulfilledCallbacks.push(onFulfilled); // 保存成功回调
            this.onRejectedCallbacks.push(onRejected); // 保存失败回调
        }
        if (this.PromiseState === myPromise.FULFILLED) {
            //onFulfilled(this.PromiseResult)
            let observer = new MutationObserver(() => {
                onFulfilled(this.PromiseResult)
                observer.disconnect();
            })
            observer.observe(this.textNode, { characterData: true });
            this.textNode.data = (myPromise.COUNTER + 1) % 2;
        }
        if (this.PromiseState === myPromise.REJECTED) {
            let observer = new MutationObserver(() => {
                onRejected(this.PromiseResult)
                observer.disconnect();
            })
            observer.observe(this.textNode, { characterData: true });
            this.textNode.data = (myPromise.COUNTER + 1) % 2;
        }

    }
    catch(onRejected) {
        return this.then(undefined, onRejected)
    }
    finally(callBack) {
        return this.then(callBack, callBack)
    }
    static resolve(result) {
        if (result instanceof myPromise) return result
        if (value instanceof Object && 'then' in result) {
            return new myPromise((resolve, reject) => result.then(resolve, reject))
        }
        return new myPromise((resolve) => resolve(result))
    }
    static reject(e) {
        return new myPromise((resolve, reject) => reject(e))
    }
    static all(promises) {
        return new myPromise((resolve, reject) => {
            if (Array.isArray(promises)) {

            } else {
                return reject(new TypeError('Argument is not iterable'))
            }

        })
    }
    static race(promises) {
        return new myPromise((resolve, reject) => {
            if (Array.isArray(promises)) {

            } else {
                return reject(new TypeError('Argument is not iterable'))
            }
        })
    }
    static allSettled(promises) {
        return new myPromise((resolve, reject) => {
            if (Array.isArray(promises)) {

            } else {
                return reject(new TypeError('Argument is not iterable'))
            }
        })
    }
    static any(promises) {
        return new myPromise((resolve, reject) => {
            if (Array.isArray(promises)) {

            } else {
                return reject(new TypeError('Argument is not iterable'))
            }
        })
    }
}
console.log(1)
let p = new myPromise((r, j) => {
    console.log(2)
    setTimeout(() => {
        j(3)
        console.log(4)
    })
})
p.then((res) => {
    console.log(res)
})
console.log(5)

p.catch((e) => {
    console.log(e)
})

let p =new  Promist((r,j)=>{

})