fix enum names

Author: Khartir

packages/react-async-devtools/src/index.js

@@ -1,5 +1,5 @@
 import React from "react"
-import { actionTypes, reducer, globalScope } from "react-async"
+import { ActionTypes, reducer, globalScope } from "react-async"
 
 import { Root, Range, Checkbox, Label, Small, Ol, Li, Button } from "./components"
 
@@ -17,14 +17,14 @@ globalScope.__REACT_ASYNC__.devToolsDispatcher = (action, dispatch) => {
     state.update(action)
   }
   switch (action.type) {
-    case actionTypes.start:
+    case ActionTypes.start:
       if (state.intercept) {
         dispatch({ ...action, payload: undefined })
         state.update(action, run)
       } else run()
       break
-    case actionTypes.fulfill:
-    case actionTypes.reject:
+    case ActionTypes.fulfill:
+    case ActionTypes.reject:
       setTimeout(run, state.latency * 1000)
       break
     default:

packages/react-async/src/Async.tsx

@@ -3,7 +3,7 @@ import React from "react"
 import globalScope from "./globalScope"
 import { IfInitial, IfPending, IfFulfilled, IfRejected, IfSettled } from "./helpers"
 import propTypes from "./propTypes"
-import { actionTypes, init, dispatchMiddleware, reducer as asyncReducer } from "./reducer"
+import { ActionTypes, init, dispatchMiddleware, reducer as asyncReducer } from "./reducer"
 import {
   AsyncProps,
   AsyncState,
@@ -176,7 +176,7 @@ export const createInstance = <T extends {}>(
       return (this.promise = new Promise((resolve, reject) => {
         if (!this.mounted) return
         const executor = () => promiseFn().then(resolve, reject)
-        this.dispatch({ type: actionTypes.start, payload: executor, meta: this.getMeta() })
+        this.dispatch({ type: ActionTypes.start, payload: executor, meta: this.getMeta() })
       }))
     }
 
@@ -212,7 +212,7 @@ export const createInstance = <T extends {}>(
       onCancel && onCancel()
       this.counter++
       this.abortController.abort()
-      this.mounted && this.dispatch({ type: actionTypes.cancel, meta: this.getMeta() })
+      this.mounted && this.dispatch({ type: ActionTypes.cancel, meta: this.getMeta() })
     }
 
     onResolve(counter: Number) {
@@ -237,14 +237,14 @@ export const createInstance = <T extends {}>(
 
     setData(data: T, callback?: () => void) {
       this.mounted &&
-        this.dispatch({ type: actionTypes.fulfill, payload: data, meta: this.getMeta() }, callback)
+        this.dispatch({ type: ActionTypes.fulfill, payload: data, meta: this.getMeta() }, callback)
       return data
     }
 
     setError(error: Error, callback?: () => void) {
       this.mounted &&
         this.dispatch(
-          { type: actionTypes.reject, payload: error, error: true, meta: this.getMeta() },
+          { type: ActionTypes.reject, payload: error, error: true, meta: this.getMeta() },
           callback
         )
       return error

packages/react-async/src/index.ts

@@ -3,7 +3,7 @@ export { default as Async, createInstance } from "./Async"
 export * from "./types"
 export { default as useAsync, useFetch, FetchOptions, FetchError } from "./useAsync"
 export default Async
-export { statusTypes } from "./status"
+export { StatusTypes } from "./status"
 export { default as globalScope } from "./globalScope"
 export * from "./helpers"
 export * from "./reducer"

packages/react-async/src/reducer.ts

@@ -1,4 +1,4 @@
-import { getInitialStatus, getIdleStatus, getStatusProps, statusTypes } from "./status"
+import { getInitialStatus, getIdleStatus, getStatusProps, StatusTypes } from "./status"
 import {
   PromiseFn,
   AsyncAction,
@@ -18,7 +18,7 @@ import {
  */
 declare type ImportWorkaround<T> = AbstractState<T>
 
-export enum actionTypes {
+export enum ActionTypes {
   start = "start",
   cancel = "cancel",
   fulfill = "fulfill",
@@ -48,16 +48,16 @@ export const init = <T>({
 
 export const reducer = <T>(state: ReducerAsyncState<T>, action: AsyncAction<T>) => {
   switch (action.type) {
-    case actionTypes.start:
+    case ActionTypes.start:
       return {
         ...state,
         startedAt: new Date(),
         finishedAt: undefined,
-        ...getStatusProps(statusTypes.pending),
+        ...getStatusProps(StatusTypes.pending),
         counter: action.meta.counter,
         promise: action.meta.promise,
       } as AsyncPending<T, ReducerBaseState<T>>
-    case actionTypes.cancel:
+    case ActionTypes.cancel:
       return {
         ...state,
         startedAt: undefined,
@@ -69,23 +69,23 @@ export const reducer = <T>(state: ReducerAsyncState<T>, action: AsyncAction<T>)
         | AsyncInitial<T, ReducerBaseState<T>>
         | AsyncFulfilled<T, ReducerBaseState<T>>
         | AsyncRejected<T, ReducerBaseState<T>>
-    case actionTypes.fulfill:
+    case ActionTypes.fulfill:
       return {
         ...state,
         data: action.payload,
         value: action.payload,
         error: undefined,
         finishedAt: new Date(),
-        ...getStatusProps(statusTypes.fulfilled),
+        ...getStatusProps(StatusTypes.fulfilled),
         promise: action.meta.promise,
       } as AsyncFulfilled<T, ReducerBaseState<T>>
-    case actionTypes.reject:
+    case ActionTypes.reject:
       return {
         ...state,
         error: action.payload,
         value: action.payload,
         finishedAt: new Date(),
-        ...getStatusProps(statusTypes.rejected),
+        ...getStatusProps(StatusTypes.rejected),
         promise: action.meta.promise,
       } as AsyncRejected<T, ReducerBaseState<T>>
     default:
@@ -97,7 +97,7 @@ export const dispatchMiddleware = <T>(
   dispatch: (action: AsyncAction<T>, ...args: any[]) => void
 ) => (action: AsyncAction<T>, ...args: unknown[]) => {
   dispatch(action, ...args)
-  if (action.type === actionTypes.start && typeof action.payload === "function") {
+  if (action.type === ActionTypes.start && typeof action.payload === "function") {
     action.payload()
   }
 }

packages/react-async/src/status.spec.js

@@ -2,31 +2,31 @@
 
 import "@testing-library/jest-dom/extend-expect"
 
-import { getInitialStatus, getIdleStatus, statusTypes } from "./status"
+import { getInitialStatus, getIdleStatus, StatusTypes } from "./status"
 
 describe("getInitialStatus", () => {
   test("returns 'initial' when given an undefined value", () => {
-    expect(getInitialStatus(undefined)).toEqual(statusTypes.initial)
+    expect(getInitialStatus(undefined)).toEqual(StatusTypes.initial)
   })
   test("returns 'pending' when given only a promise", () => {
-    expect(getInitialStatus(undefined, Promise.resolve("foo"))).toEqual(statusTypes.pending)
+    expect(getInitialStatus(undefined, Promise.resolve("foo"))).toEqual(StatusTypes.pending)
   })
   test("returns 'rejected' when given an Error value", () => {
-    expect(getInitialStatus(new Error("oops"))).toEqual(statusTypes.rejected)
+    expect(getInitialStatus(new Error("oops"))).toEqual(StatusTypes.rejected)
   })
   test("returns 'fulfilled' when given any other value", () => {
-    expect(getInitialStatus(null)).toEqual(statusTypes.fulfilled)
+    expect(getInitialStatus(null)).toEqual(StatusTypes.fulfilled)
   })
 })
 
 describe("getIdleStatus", () => {
   test("returns 'initial' when given an undefined value", () => {
-    expect(getIdleStatus(undefined)).toEqual(statusTypes.initial)
+    expect(getIdleStatus(undefined)).toEqual(StatusTypes.initial)
   })
   test("returns 'rejected' when given an Error value", () => {
-    expect(getIdleStatus(new Error("oops"))).toEqual(statusTypes.rejected)
+    expect(getIdleStatus(new Error("oops"))).toEqual(StatusTypes.rejected)
   })
   test("returns 'fulfilled' when given any other value", () => {
-    expect(getIdleStatus(null)).toEqual(statusTypes.fulfilled)
+    expect(getIdleStatus(null)).toEqual(StatusTypes.fulfilled)
   })
 })

packages/react-async/src/status.ts

@@ -1,32 +1,32 @@
 import { PromiseFn } from "./types"
 
-export enum statusTypes {
+export enum StatusTypes {
   initial = "initial",
   pending = "pending",
   fulfilled = "fulfilled",
   rejected = "rejected",
 }
 
 export const getInitialStatus = <T>(value?: T | Error, promise?: Promise<T> | PromiseFn<T>) => {
-  if (value instanceof Error) return statusTypes.rejected
-  if (value !== undefined) return statusTypes.fulfilled
-  if (promise) return statusTypes.pending
-  return statusTypes.initial
+  if (value instanceof Error) return StatusTypes.rejected
+  if (value !== undefined) return StatusTypes.fulfilled
+  if (promise) return StatusTypes.pending
+  return StatusTypes.initial
 }
 
 export const getIdleStatus = <T>(value?: T | Error) => {
-  if (value instanceof Error) return statusTypes.rejected
-  if (value !== undefined) return statusTypes.fulfilled
-  return statusTypes.initial
+  if (value instanceof Error) return StatusTypes.rejected
+  if (value !== undefined) return StatusTypes.fulfilled
+  return StatusTypes.initial
 }
 
-export const getStatusProps = (status: statusTypes) => ({
+export const getStatusProps = (status: StatusTypes) => ({
   status,
-  isInitial: status === statusTypes.initial,
-  isPending: status === statusTypes.pending,
-  isLoading: status === statusTypes.pending, // alias
-  isFulfilled: status === statusTypes.fulfilled,
-  isResolved: status === statusTypes.fulfilled, // alias
-  isRejected: status === statusTypes.rejected,
-  isSettled: status === statusTypes.fulfilled || status === statusTypes.rejected,
+  isInitial: status === StatusTypes.initial,
+  isPending: status === StatusTypes.pending,
+  isLoading: status === StatusTypes.pending, // alias
+  isFulfilled: status === StatusTypes.fulfilled,
+  isResolved: status === StatusTypes.fulfilled, // alias
+  isRejected: status === StatusTypes.rejected,
+  isSettled: status === StatusTypes.fulfilled || status === StatusTypes.rejected,
 })

packages/react-async/src/useAsync.tsx

@@ -1,7 +1,7 @@
 import React, { useCallback, useDebugValue, useEffect, useMemo, useRef, useReducer } from "react"
 
 import globalScope from "./globalScope"
-import { actionTypes, init, dispatchMiddleware, reducer as asyncReducer } from "./reducer"
+import { ActionTypes, init, dispatchMiddleware, reducer as asyncReducer } from "./reducer"
 
 import {
   AsyncOptions,
@@ -88,7 +88,7 @@ function useAsync<T extends {}>(
     (data, callback = noop) => {
       if (isMounted.current) {
         dispatch({
-          type: actionTypes.fulfill,
+          type: ActionTypes.fulfill,
           payload: data,
           meta: getMeta(),
         })
@@ -103,7 +103,7 @@ function useAsync<T extends {}>(
     (error, callback = noop) => {
       if (isMounted.current) {
         dispatch({
-          type: actionTypes.reject,
+          type: ActionTypes.reject,
           payload: error,
           error: true,
           meta: getMeta(),
@@ -138,7 +138,7 @@ function useAsync<T extends {}>(
         if (!isMounted.current) return
         const executor = () => promiseFn().then(resolve, reject)
         dispatch({
-          type: actionTypes.start,
+          type: ActionTypes.start,
           payload: executor,
           meta: getMeta(),
         })
@@ -185,7 +185,7 @@ function useAsync<T extends {}>(
     abortController.current.abort()
     isMounted.current &&
       dispatch({
-        type: actionTypes.cancel,
+        type: ActionTypes.cancel,
         meta: getMeta(),
       })
   }, [onCancel, dispatch, getMeta])