@watch-state/async NPM

@watch-state/async

Getting async data with watch-state.

Installation

npm

npm i @watch-state/async

yarn

yarn add @watch-state/async

Using

Async is a Promise like class.

Async constructor expects the first required argument as an async function and the second optional one as a default value.

import Async from '@watch-state/async'

const promise = new Async(() => fetch('/test'))

then, catch, finally

then, catch and finally always return an instance of Promise

const test = new Async(async () => {}).then() instanceof Promise
// test === true

Use then, catch and finally like on Promise

const promise = new Async(async () => 1)

promise
  .then(value => console.log('then', value))
  .finally(value => console.log('finally', value))
  .catch(value => console.log('catch', value))

loading

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

const promise = new Async(async () => {})
// promise.loading === true

await promise
// promise.loading === false

This is observable field, you can use Watch to observe it.

const promise = new Async(async () => {})

new Wathc(() => {
  console.log(promise.loading)
})
// true

await promise
// false

You can use the same way to watch on loaded, value, error

loaded

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

const promise = new Async(async () => {})
// promise.loaded === false

await promise
// promise.loaded === true

value

You may get current result by value field

const promise = new Async(async () => 1)
// promise.value === undefined
await promise
// promise.value === 1

error

You may handle error by error field

const promise = new Async(() => Promise.reject(1))
new Watch(() => {
  console.log(promise.error)
})
// > undefined
// > 1

update

Unlike Promise, you may reuse Async with update method

let i = 0
const promise = new Async(async () => i++)

console.log(await promise)
// > 0
// i === 1

promise.update()

console.log(await promise)
// > 1
// i === 2

You can set timeout to make update only after some time.

let i = 0
const promise = new Async(async () => i++)

console.log(await promise)
// > 0
// i === 1

promise.update(1000)
// nothing happends

await promise
// nothing happends

await new Promise(resolve => setTimeout(resolve, 1000))
// nothing happends

// 1 second passed, if use 1000ms it triggers update
promise.update(1000)

console.log(await promise)
// > 1
// i === 2