Rename 'waiting' to 'initial'.

Author: ghengeveld

README.md

@@ -384,12 +384,12 @@ is set to `"application/json"`.
 - `initialValue` The data or error that was provided through the `initialValue` prop.
 - `startedAt` When the current/last promise was started.
 - `finishedAt` When the last promise was resolved or rejected.
-- `status` One of: `waiting`, `pending`, `fulfilled`, `rejected`.
-- `isWaiting` true when no promise has ever started, or one started but was cancelled.
+- `status` One of: `initial`, `pending`, `fulfilled`, `rejected`.
+- `isInitial` true when no promise has ever started, or one started but was cancelled.
 - `isPending` true when a promise is currently awaiting settlement. Alias: `isLoading`
 - `isFulfilled` true when the last promise was fulfilled with a value. Alias: `isResolved`
 - `isRejected` true when the last promise was rejected with a reason.
-- `isSettled` true when the last promise was fulfilled or rejected (not waiting or pending).
+- `isSettled` true when the last promise was fulfilled or rejected (not initial or pending).
 - `counter` The number of times a promise was started.
 - `cancel` Cancel any pending promise.
 - `run` Invokes the `deferFn`.
@@ -431,10 +431,10 @@ Tracks when the last promise was resolved or rejected.
 
 > `string`
 
-One of: `waiting`, `pending`, `fulfilled`, `rejected`.
+One of: `initial`, `pending`, `fulfilled`, `rejected`.
 These are available for import as `statusTypes`.
 
-#### `isWaiting`
+#### `isInitial`
 
 > `boolean`
 
@@ -466,7 +466,7 @@ Alias: `isResolved`
 
 > `boolean`
 
-`true` when the last promise was either fulfilled or rejected (i.e. not waiting or pending)
+`true` when the last promise was either fulfilled or rejected (i.e. not initial or pending)
 
 #### `counter`
 
@@ -511,7 +511,7 @@ invoked after the state update is completed. Returns the error to enable chainin
 React Async provides several helper components that make your JSX more declarative and less cluttered.
 They don't have to be direct children of `<Async>` and you can use the same component several times.
 
-### `<Async.Waiting>`
+### `<Async.Initial>`
 
 Renders only while the deferred promise is still waiting to be run, or you have not provided any promise.
 
@@ -524,14 +524,14 @@ Renders only while the deferred promise is still waiting to be run, or you have
 
 ```js
 <Async deferFn={deferFn}>
-  <Async.Waiting>
+  <Async.Initial>
     <p>This text is only rendered while `run` has not yet been invoked on `deferFn`.</p>
-  </Async.Waiting>
+  </Async.Initial>
 </Async>
 ```
 
 ```js
-<Async.Waiting persist>
+<Async.Initial persist>
   {({ error, isLoading, run }) => (
     <div>
       <p>This text is only rendered while the promise has not resolved yet.</p>
@@ -541,7 +541,7 @@ Renders only while the deferred promise is still waiting to be run, or you have
       {error && <p>{error.message}</p>}
     </div>
   )}
-</Async.Waiting>
+</Async.Initial>
 ```
 
 ### `<Async.Pending>`

src/Async.js

@@ -179,12 +179,12 @@ export const createInstance = (defaultProps = {}, displayName = "Async") => {
   }
 
   /**
-   * Renders only when deferred promise is waiting (promise has not yet run).
+   * Renders only when no promise has started or completed yet.
    *
    * @prop {Function|Node} children Function (passing state) or React node
    * @prop {boolean} persist Show until we have data, even while pending (loading) or when an error occurred
    */
-  const Waiting = ({ children, persist }) => (
+  const Initial = ({ children, persist }) => (
     <Consumer>
       {state => {
         if (state.data !== undefined) return null
@@ -196,7 +196,7 @@ export const createInstance = (defaultProps = {}, displayName = "Async") => {
   )
 
   if (PropTypes) {
-    Waiting.propTypes = {
+    Initial.propTypes = {
       children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]).isRequired,
       persist: PropTypes.bool,
     }
@@ -281,7 +281,7 @@ export const createInstance = (defaultProps = {}, displayName = "Async") => {
   const Settled = ({ children, persist }) => (
     <Consumer>
       {state => {
-        if (state.isWaiting) return null
+        if (state.isInitial) return null
         if (state.isPending && !persist) return null
         return isFunction(children) ? children(state) : children || null
       }}
@@ -295,14 +295,14 @@ export const createInstance = (defaultProps = {}, displayName = "Async") => {
     }
   }
 
-  Waiting.displayName = `${displayName}.Waiting`
+  Initial.displayName = `${displayName}.Initial`
   Pending.displayName = `${displayName}.Pending`
   Fulfilled.displayName = `${displayName}.Fulfilled`
   Rejected.displayName = `${displayName}.Rejected`
   Settled.displayName = `${displayName}.Settled`
 
   Async.displayName = displayName
-  Async.Waiting = Waiting
+  Async.Initial = Initial
   Async.Pending = Pending
   Async.Loading = Pending // alias
   Async.Fulfilled = Fulfilled

src/Async.spec.js

@@ -31,20 +31,20 @@ describe("Async", () => {
     let two
     const { rerender } = render(
       <Async>
-        <Async.Waiting>
+        <Async.Initial>
           {value => {
             one = value
           }}
-        </Async.Waiting>
+        </Async.Initial>
       </Async>
     )
     rerender(
       <Async someProp>
-        <Async.Waiting>
+        <Async.Initial>
           {value => {
             two = value
           }}
-        </Async.Waiting>
+        </Async.Initial>
       </Async>
     )
     expect(one).toBe(two)
@@ -132,19 +132,19 @@ describe("Async.Pending", () => {
   })
 })
 
-describe("Async.Waiting", () => {
-  test("renders only while the deferred promise is waiting", async () => {
+describe("Async.Initial", () => {
+  test("renders only while the deferred promise has not started yet", async () => {
     const deferFn = () => resolveTo("ok")
     const { getByText, queryByText } = render(
       <Async deferFn={deferFn}>
-        <Async.Waiting>{({ run }) => <button onClick={run}>waiting</button>}</Async.Waiting>
+        <Async.Initial>{({ run }) => <button onClick={run}>initial</button>}</Async.Initial>
         <Async.Pending>pending</Async.Pending>
         <Async.Fulfilled>done</Async.Fulfilled>
       </Async>
     )
-    expect(queryByText("waiting")).toBeInTheDocument()
-    fireEvent.click(getByText("waiting"))
-    expect(queryByText("waiting")).toBeNull()
+    expect(queryByText("initial")).toBeInTheDocument()
+    fireEvent.click(getByText("initial"))
+    expect(queryByText("initial")).toBeNull()
     expect(queryByText("pending")).toBeInTheDocument()
     await waitForElement(() => getByText("done"))
     expect(queryByText("pending")).toBeNull()

src/index.d.ts

@@ -30,13 +30,13 @@ interface AbstractState<T> {
   setError: (error: Error, callback?: () => void) => Error
 }
 
-export type AsyncWaiting<T> = AbstractState<T> & {
+export type AsyncInitial<T> = AbstractState<T> & {
   data: undefined
   error: undefined
   startedAt: undefined
   finishedAt: undefined
-  status: "waiting"
-  isWaiting: false
+  status: "initial"
+  isInitial: false
   isPending: false
   isLoading: false
   isFulfilled: false
@@ -50,7 +50,7 @@ export type AsyncPending<T> = AbstractState<T> & {
   startedAt: Date
   finishedAt: undefined
   status: "pending"
-  isWaiting: false
+  isInitial: false
   isPending: true
   isLoading: true
   isFulfilled: false
@@ -64,7 +64,7 @@ export type AsyncFulfilled<T> = AbstractState<T> & {
   startedAt: Date
   finishedAt: Date
   status: "fulfilled"
-  isWaiting: false
+  isInitial: false
   isPending: false
   isLoading: false
   isFulfilled: true
@@ -78,20 +78,20 @@ export type AsyncRejected<T> = AbstractState<T> & {
   startedAt: Date
   finishedAt: Date
   status: "rejected"
-  isWaiting: false
+  isInitial: false
   isPending: false
   isLoading: false
   isFulfilled: false
   isResolved: false
   isRejected: true
   isSettled: true
 }
-export type AsyncState<T> = AsyncWaiting<T> | AsyncPending<T> | AsyncFulfilled<T> | AsyncRejected<T>
+export type AsyncState<T> = AsyncInitial<T> | AsyncPending<T> | AsyncFulfilled<T> | AsyncRejected<T>
 
 declare class Async<T> extends React.Component<AsyncProps<T>, AsyncState<T>> {}
 
 declare namespace Async {
-  export function Waiting<T>(props: {
+  export function Initial<T>(props: {
     children?: AsyncChildren<T>
     persist?: boolean
   }): React.ReactNode

src/specs.js

@@ -19,7 +19,7 @@ export const common = Async => () => {
           expect(renderProps).toHaveProperty("initialValue")
           expect(renderProps).toHaveProperty("startedAt")
           expect(renderProps).toHaveProperty("finishedAt")
-          expect(renderProps).toHaveProperty("isWaiting")
+          expect(renderProps).toHaveProperty("isInitial")
           expect(renderProps).toHaveProperty("isPending")
           expect(renderProps).toHaveProperty("isLoading")
           expect(renderProps).toHaveProperty("isFulfilled")

src/status.js

@@ -1,5 +1,5 @@
 export const statusTypes = {
-  waiting: "waiting",
+  initial: "initial",
   pending: "pending",
   fulfilled: "fulfilled",
   rejected: "rejected",
@@ -9,18 +9,18 @@ export const getInitialStatus = (value, promise) => {
   if (value instanceof Error) return statusTypes.rejected
   if (value !== undefined) return statusTypes.fulfilled
   if (promise) return statusTypes.pending
-  return statusTypes.waiting
+  return statusTypes.initial
 }
 
 export const getIdleStatus = value => {
   if (value instanceof Error) return statusTypes.rejected
   if (value !== undefined) return statusTypes.fulfilled
-  return statusTypes.waiting
+  return statusTypes.initial
 }
 
 export const getStatusProps = status => ({
   status,
-  isWaiting: status === statusTypes.waiting,
+  isInitial: status === statusTypes.initial,
   isPending: status === statusTypes.pending,
   isLoading: status === statusTypes.pending, // alias
   isFulfilled: status === statusTypes.fulfilled,

src/status.spec.js

@@ -5,8 +5,8 @@ import "jest-dom/extend-expect"
 import { getInitialStatus, getIdleStatus, statusTypes } from "./status"
 
 describe("getInitialStatus", () => {
-  test("returns 'waiting' when given an undefined value", () => {
-    expect(getInitialStatus(undefined)).toEqual(statusTypes.waiting)
+  test("returns 'initial' when given an undefined value", () => {
+    expect(getInitialStatus(undefined)).toEqual(statusTypes.initial)
   })
   test("returns 'pending' when given only a promise", () => {
     expect(getInitialStatus(undefined, Promise.resolve("foo"))).toEqual(statusTypes.pending)
@@ -20,8 +20,8 @@ describe("getInitialStatus", () => {
 })
 
 describe("getIdleStatus", () => {
-  test("returns 'waiting' when given an undefined value", () => {
-    expect(getIdleStatus(undefined)).toEqual(statusTypes.waiting)
+  test("returns 'initial' when given an undefined value", () => {
+    expect(getIdleStatus(undefined)).toEqual(statusTypes.initial)
   })
   test("returns 'rejected' when given an Error value", () => {
     expect(getIdleStatus(new Error("oops"))).toEqual(statusTypes.rejected)