# @mazzard/mobx-async

> Asynchronous with mobx

Latest version **1.0.0** (published 2019-09-15) · MIT license · 0 weekly downloads

## Install

```sh
npm install @mazzard/mobx-async
pnpm add @mazzard/mobx-async
yarn add @mazzard/mobx-async
bun add @mazzard/mobx-async
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.0 |
| Published | 2019-09-15 |
| First published | 2019-09-15 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Unpacked size | 11.9 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | Deight |
| Maintainers | deight |
| Keywords | mobx, async, await, promise, asynchronous |

## Links

- npm: https://www.npmjs.com/package/@mazzard/mobx-async
- Homepage: https://github.com/d8corp/mazzard#readme
- npm.io page: https://npm.io/package/@mazzard/mobx-async

## Dependencies (2)

- [mobx](https://npm.io/package/mobx.md) ^5.13.0
- [core-js](https://npm.io/package/core-js.md) ^3.2.1

## Alternatives

- [@commercetools/sync-actions](https://npm.io/package/@commercetools/sync-actions.md) — 25.1K weekly downloads
- [cwait](https://npm.io/package/cwait.md) — 21.4K weekly downloads
- [@ledgerhq/hw-app-cosmos](https://npm.io/package/@ledgerhq/hw-app-cosmos.md) — 4.2K weekly downloads
- [@financial-times/o-loading](https://npm.io/package/@financial-times/o-loading.md) — 2.8K weekly downloads
- [fa](https://npm.io/package/fa.md) — 185 weekly downloads

## Recent versions

- 1.0.0 (latest) — 2019-09-15

## README

#@mazzard/mobx-async
### Install
```bash
npm i @mazzard/mobx-async
```
Next we will use `Async` which means we imported it from `@mazzard/mobx-async`
```javascript
import Async from '@mazzard/mobx-async'
```
Use `Async` like `Promise`
```javascript
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`
```javascript
const test = new Async().then() instanceof Async
// test === true 
```
Use `then`, `catch` and `finally` like for `Promise`
```javascript
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
```javascript
(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`
```javascript
(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
```javascript
(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
```javascript
(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
```javascript
(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`
```javascript
const promise = new Async(resolve => resolve(1))
// promise.value === 1
```
But `value` returns result at the moment
```javascript
(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`
```javascript
const promise = new Async((resolve, reject) => reject(1))
// promise.error === 1
```
### default
You may provide default `value` for `Async`
```javascript
(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
```javascript
(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
```javascript
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
```javascript
const promise = new Async()
promise.resolve(1)
// promise.value === 1
```
### reject
You may use `reject` to say async that loading is finished with error
```javascript
const promise = new Async()
promise.reject(1)
// promise.error === 1
```
### on, once, off
You may add a listener to react on events
```javascript
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`
```javascript
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
```javascript
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
```

---
_Source: https://npm.io/package/@mazzard/mobx-async · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._