{`There are five distinct states to any data fetching request:`}
\n| {`State`} | \n{`Data`} | \n
|---|---|
| {`Empty`} | \n{`Nothing has been requested`} | \n
| {`Fetching`} | \n{`Request is in process for the first time`} | \n
| {`Refetching`} | \n{`Request has already returned data but is in process for a second time`} | \n
| {`Success`} | \n{`Request has completed and returned requested data`} | \n
| {`Error`} | \n{`Request has failed and returned an error`} | \n
{`RequestState is a variant that allows the user to render the different states of a request in a declarative manner. It's api gives you a clear way of handling each possible state and makes sure your app is never rendering an unpredicted state.`}
\n{`class RequestState {\n\n // Map\n emptyMap(mapper: RequestStateMapper) => RequestState\n fetchingMap(mapper: RequestStateMapper) => RequestState\n refetchingMap(mapper: RequestStateMapper) => RequestState\n successMap(mapper: RequestStateMapper) => RequestState\n errorMap(mapper: RequestStateMapper) => RequestState\n \n // FlatMap\n emptyFlatMap(mapper: RequestStateFlatMapper) => RequestState\n fetchingFlatMap(mapper: RequestStateFlatMapper) => RequestState\n refetchingFlatMap(mapper: RequestStateFlatMapper) => RequestState\n successFlatMap(mapper: RequestStateFlatMapper) => RequestState\n errorFlatMap(mapper: RequestStateFlatMapper) => RequestState\n\n // Casting\n toEmpty() => RequestState\n toFetching() => RequestState\n toRefetching() => RequestState\n toSuccess() => RequestState\n toError() => RequestState\n\n // States\n isEmpty: boolean;\n isFetching: boolean;\n isRefetching: boolean;\n isSuccess: boolean;\n isError: boolean;\n\n value(defaultValue: *) => *\n}\n`}{`Properties`}
\n{`.is{State}`}
\n{`State properties hold the raw booleans to describe the request state. `}
\n{`They are easy to access but map functions or `}{`[LoadingBoundary]`}{` make your code more predictable.`}
\n{`isEmpty: boolean;\nisFetching: boolean;\nisRefetching: boolean;\nisSuccess: boolean;\nisError: boolean;\n`}{`function User({message}) {\n if(message.requestState.isFetching) {\n return 
\n}\n\n`}{`Methods`}
\n{`RequestState seems to have a lot of methods but in reality it is three methods duplicated for each\nof the five possible states of a request: Empty, Fetching, Refetching, Success & Error.`}
\n{`.{state}Map()`}
\n{`type:`}{` `}
{`Map functions will call their mapper with the current value of the variant and update it with the\nresult. The useful part is that they will only call the functions that match the current state of\nthe variant. This means you can describe what should happen for all states of the request but\nonly action on the current state.`}
\n{`function User({message}) {\n return message.requestState\n .emptyMap(() => null)\n .fetchingMap(() => })
)\n .successMap(() => )\n .errorMap(() => {`.{state}FlatMap()`}
\n{`type:`}{` `}
{`FlatMap is similar to Map except instead of your mapper returning a value that is stored inside the\ncurrent request state, your mapper returns a new RequestState. `}{`This is useful if you want to\nreplace the state from a different source.`}
\n{`function validateData(data) {\n if(data.hasErrors) {\n return RequestState.error();\n }\n return RequestState.success();\n}\n\nreturn requestState\n .successFlatMap(() => validateData(message.response))\n .errorMap(() => 'Error!')\n .successMap(() => 'Success.')\n .value();\n`}{`With the above example we can wait until the response is a success until we validate a portion of\nthe data. But we can still maintain single purpose functions for how to render the data and how to\nrespond to an error.`}
\n{`.to{state}()`}
\n{`type:`}{` `}
{`Casts a request state to a different type.`}
\n{`RequestState.fetching('foo')\n .toError()\n .fetchingMap(() => 'bar')\n .value() // foo\n`}{`.value()`}
\n{`type:`}{` `}
{`Returns either the current state of the variant.`}
\n{`Unit Functions`}
\n{`The request state class has static unit functions for creating requestStates in different forms.`}
\n{`import {RequestState} from 'react-enty';\n\nRequestState.empty();\nRequestState.fetching();\nRequestState.refetching();\nRequestState.success();\nRequestState.error();\n`}{`Examples`}
\n{`Becuase the request state is a concrete data type, rather than just a series of booleans, it\nis very easy to abstract common loading situations away behind a function or a hoc.`}
\n{`ApplyLoader`}
\n{`Writing all cases of a variant can become time consuming so we can abstract a common loading style\ninto an applyLoader function.`}
\n{`function applyLoader(message) {\n const {requestError} = message;\n const {response} = message;\n const {requestState} = message;\n\n return message.requestState\n .fetchingMap(() => )\n}\n\nfunction User({userMessage}) {\n return applyLoader(userMessage)\n .successMap(() => })
)\n .value();\n}\n`} {`Merging RequestStates`}
\n{`You can even use a reduce to combine multiple request states together.\nAt each iteration if the previous requestState is a success it will replace it with the next.\nThis means that all must be true for the final state to render.\nBut if any are fetching or errored we will still get the right state.`}
\n{`return this.props[config.messages]\n .reduce((previous, next) => previous.successFlatMap(() => next))\n .fetchingMap(() => )\n .successMap(() => {`Any Success`}
\n{`@TODO`}
\n\n