@mazzard/mobx-async v1.0.0

#@mazzard/mobx-async

Install

npm i @mazzard/mobx-async

Next we will use Async which means we imported it from @mazzard/mobx-async

import Async from '@mazzard/mobx-async'

Use Async like Promise

const promise = new Async((resolve, reject) => {
  try {
    resolve(doSomethink)
  } catch (e) {
    reject(e)
  }
})

then, catch, finally

then, catch and finally always return instance of Async

const test = new Async().then() instanceof Async
// test === true 

Use then, catch and finally like for Promise

const promise = new Async(resolve => resolve(1))
promise
  .finally(value => console.log('finally', value))
  .then(value => console.log('then', value))
  .catch(value => console.log('catch', value))

But we have one specific think for mobx, if you return a function to resolve or reject then the function will be called when you need to get the result

(async () => {
  let test = true
  const promise = new Async(resolve => resolve(() => test = false))
  // test still equals true
  await promise
  // test is false
})()

The same happens if you return a function in then, catch or finally

(async () => {
  let test = true
  const promise = new Async(resolve => resolve()).then(() => () => test = false)
  // test still equals true
  await promise
  // test is false
})()

You may override the result at function to fix it

(async () => {
  function test () {}
  const promise = new Async(resolve => resolve(() => test))
  const result = await promise
  return result === test // true
})()

loading

You may check status of Async with loading, it's true when data is loading

(async () => {
  const promise = new Async(resolve => setTimeout(resolve))
  // promise.loading === true
  await promise
  // promise.loading === false
})()

loaded

You may check status of Async with loaded, it's true when data was loaded at least one time

(async () => {
  const promise = new Async(resolve => setTimeout(resolve))
  // promise.loaded === false
  await promise
  // promise.loaded === true
})()

value

You may get result without await synchronously with value

const promise = new Async(resolve => resolve(1))
// promise.value === 1

But value returns result at the moment

(async () => {
  const promise = new Async(resolve => setTimeout(() => resolve(1)))
  // promise.value === undefined
  await promise
  // promise.value === 1
})()

error

You may handle error without await synchronously with error like value with resolve

const promise = new Async((resolve, reject) => reject(1))
// promise.error === 1

default

You may provide default value for Async

(async () => {
  const promise = new Async({
    request: resolve => setTimeout(() => resolve(2)),
    default: 1
  })
  // promise.value === 1
  await promise
  // promise.value === 2
})()

response

response is the same value but without default value

(async () => {
  const promise = new Async({
    request: resolve => setTimeout(() => resolve(2)),
    default: 1
  })
  // promise.value === 1
  // promise.response === undefined
  await promise
  // promise.value === 2
  // promise.response === 2
})()

update

Unlike Promise, you may reuse Async with update method

let i = 0
const promise = new Async(resolve => resolve(i++))
// i === 1
promise.update()
// i === 2

resolve

You may use resolve to say async that loading is finished successfully

const promise = new Async()
promise.resolve(1)
// promise.value === 1

reject

You may use reject to say async that loading is finished with error

const promise = new Async()
promise.reject(1)
// promise.error === 1

on, once, off

You may add a listener to react on events

const promise = new Async()
let test = false
promise.on('resolve', value => test = value)
// test === false
promise.resolve(true)
// test === true
promise.resolve(false)
// test === false

You may add a listener which reacts only once with once

const promise = new Async()
let test = false
promise.once('resolve', value => test = value)
// test === false
promise.resolve(true)
// test === true
promise.resolve(false)
// test === true

You may off a listener

const promise = new Async()
let test = false
const listener = value => test = value
promise.on('resolve', listener)
// test === false
promise.resolve(true)
// test === true
promise.off('resolve', listener)
promise.resolve(false)
// test === true