Async component that waits on promises to resolve!
npm install react-async-awaitAsync component that waits on promises to resolve!
Creating a promise is a synchronous action. If you hold a reference to a promise, you can eventually get the future value that it resolves to. Calling setState asynchronously in a component can cause a lot of headaches because of race conditions. The promise could still be in a pending state when the component unmounts or the props change. The Async component allows you to never worry about these race conditions and enables you to write your asynchronous react code as if it was synchronous.
``
yarn add react-async-await react
* ReactAsyncAwait
* ~Async ⇒ ReactElement
* [~createLoader(loader, [resolver])](#module_ReactAsyncAwait..createLoader) ⇒ ReactComponent
Component that takes a promise and injects the render callback with the resolved value.
Kind: inner property of ReactAsyncAwait
Extends: ReactComponent
| Param | Type | Description |
| ---------------- | --------------------- | ----------------------------------------- |
| props | object | |
| [props.await] | \* | |
| [props.waiting] | function | map promise to value |
| [props.then] | function | map result to value |
| [props.catch] | function | map error to value (default throws error) |
| [props.children] | function | render callback |
Example
`js
import React from "react";
import ReactDOM from "react-dom";
import { Async } from "react-async-await";
class LoadUser extends React.Component {
componentWillMount() {
this.setState({
error: undefined,
promise: undefined
});
}
componentDidMount() {
this.setState({
promise: fetch(/api/users/${this.props.id}).then(r => r.json())
});
}
componentWillReceiveProps(nextProps) {
if (this.props.id !== nextProps.id) {
this.setState({
error: undefined,
promise: fetch(/api/users/${nextProps.id}).then(r => r.json())
});
}
}
componentDidCatch(error) {
this.setState({ error });
}
render() {
return this.state.error ? (
ReactDOM.render(
{user =>
typeof user === undefined ? (
Loading...
) : (
Hello {user.name}!
)
}
document.getElementById("root")
);
`
Create a wrapper component around Async that maps props to a promise when the component mounts.
Kind: inner method of ReactAsyncAwait
| Param | Type | Description |
| ---------- | --------------------- | ------------------------------ |
| loader | function | loader maps props to a promise |
| [resolver] | function | resolver maps props to a key |
Example
`js
import React from "react";
import ReactDOM from "react-dom";
import { createLoader } from "react-async-await";
const LoadUser = createLoader(
props => fetch(/api/users/${props.id}).then(r => r.json()),
props => props.id // when key changes the loader is called again
);
ReactDOM.render(
{user =>
typeof user === undefined ? (
Loading...
) : (
Hello {user.name}!
)
}
document.getElementById("root")
);
`
Example _(memoized loader)_
`js
import React from "react";
import ReactDOM from "react-dom";
import { createLoader } from "react-async-await";
// https://lodash.com/docs/4.17.5#memoize
import memoize from "lodash/memoize";
const loader = memoize(
props => fetch(/api/users/${props.id}).then(r => r.json()),
props => props.id // key is used to resolve to cached value
);
const LoadUser = createLoader(
loader,
props => props.id // when key changes the loader is called again
);
ReactDOM.render(
{user =>
typeof user === undefined ? (
Loading...
) : (
Hello {user.name}!
)
}
document.getElementById("root")
);
``