const isFunction = variable => typeof variable === 'function'
const PENDING = 'PENDING'
const FULFILLED = 'FULFILLED'
const REJECTED = 'REJECTED'
class MyPromise {
constructor(handle) {
if (!isFunction(handle)) {
throw new Error('MyPromise must accept a function as a parameter')
}
this._status = PENDING
this._value = undefined
this._fulfilledQueues = []
this._rejectedQueues = []
try {
handle(this._resolve.bind(this), this._reject.bind(this))
} catch (err) {
this._reject(err)
}
}
_resolve(val) {
const run = () => {
if(this._status !== PENDING) return
const runFulfilled = (value) => {
let cb;
while(cb = this._fulfilledQueues.shift()) {
cb(value)
}
}
const runRejected = (error) => {
let cb;
while(cb = this._rejectedQueues.shift()) {
cb(error)
}
}
if(val instanceof MyPromise) {
val.then(value => {
this._value = value
this._status = FULFILLED
runFulfilled(value)
}, err => {
this._value = err
this._status = REJECTED
runRejected(err)
})
} else {
this._value = val
this._status = FULFILLED
runFulfilled(val)
}
}
setTimeout(() => run(), 0)
}
_reject(err) {
if(this._status !== PENDING) return
const run = () => {
this._status = REJECTED
this._value = err
let cb;
while(cb = this._rejectedQueues.shift()) {
cb(err)
}
}
setTimeout(run, 0)
}
then(onFulfilled, onRejected) {
const {_value, _status } = this
return new Promise((onFulfilledNext, onRejectedNext) => {
let fulfilled = value => {
try {
if(!isFunction(onFulfilled)) {
onFulfilledNext(value)
} else {
let res = onRejected(value);
if(res instanceof MyPromise) {
res.then(onFulfilledNext, onRejectedNext)
} else {
onFulfilledNext(res)
}
}
} catch (err) {
onRejectedNext(err)
}
}
let rejected = error => {
try {
if(!isFunction(onRejected)){
onRejectedNext(error)
} else {
let res = onRejected(error)
if(res instanceof MyPromise) {
onFulfilledNext(res)
}
}
} catch (error) {
onRejectedNext(error)
}
}
switch (_status) {
case PENDING:
this._fulfilledQueues.push(onFulfilled)
this._rejectedQueues.push(onRejected)
break
case FULFILLED:
onFulfilled(_value)
break
case REJECTED:
onRejected(_value)
break
}
})
}
catch(onRejected) {
return this.then(undefined, onRejected)
}
static resolve(value) {
if(value instanceof MyPromise) return value
return new MyPromise(resolve => resolve(value))
}
static reject (value) {
return new MyPromise((resolve, reject) => reject(value))
}
static all (list) {
return new MyPromise((resolve, reject) => {
let values = []
let count = 0
for(let [i, p] of list.entries()) {
this.resolve(p).then(res => {
values[i] = res
count++
if(count === list.length) resolve(values)
}, err => {
rejected(err)
})
}
})
}
static race (list) {
return new MyPromise((resolve, reject) => {
for(let p of list) {
this.resolve(p).then(res => {
resolve(res)
}, err => {
reject(err)
})
}
})
}
finally(cb) {
return this.then(
value => MyPromise.resolve(cb()).then(() => value),
reason => MyPromise.resolve((cb)).then(() => { throw reason})
)
}
}
const name = new MyPromise((resolve, reject) => {
console.log(1)
resolve()
})
name.then((res, rej) => {
console.log(2)
})