redux-paginator-immutable 17.0.4 → 17.0.18

package/src/paginatorMiddleware.ts

@@ -0,0 +1,93 @@
+/* eslint-disable no-console, max-lines-per-function */
+import type { Dispatch, Action } from "./types";
+import { REQUEST_PAGE } from "./actionTypes";
+import actions from "./actions";
+import { fetchPage } from "./agent";
+
+const
+  { receivePage } = actions,
+
+  paginatorMiddleware = ({ dispatch }: { dispatch: Dispatch;}) => (next: any) => (action: Action) => {
+    if (action.type === REQUEST_PAGE) {
+      const {
+        meta: {
+          endpoint,
+          endpointCb,
+          manageEntity,
+          resultsKey,
+          totalKey,
+          pageArgName,
+          idKey,
+        },
+        payload: {
+          page,
+          token,
+        },
+      } = action;
+
+      dispatch((dispatch2) => {
+        const
+          markAsError = () => {
+            dispatch2(receivePage({
+              endpoint,
+              endpointCb,
+              manageEntity,
+              pageArgName,
+              idKey,
+              page,
+              error : true,
+              token,
+              items : [],
+              total : 0,
+            }));
+          },
+
+          rawPath = typeof endpointCb === "function" ? endpointCb(token) : endpoint,
+          path = rawPath === null ? "" : rawPath;
+
+        try {
+          fetchPage({
+            endpoint: path,
+            pageArgName,
+            page,
+            token,
+          }).then((res: { response: any; }) => {
+            const { response } = res;
+
+            let
+              results = [],
+              total = 0;
+
+            if (typeof resultsKey === "undefined") {
+              results = response;
+            } else {
+              results = response[resultsKey];
+              total = response[totalKey];
+            }
+
+            dispatch2(receivePage({
+              endpoint,
+              endpointCb,
+              manageEntity,
+              pageArgName,
+              idKey,
+              page,
+              error : false,
+              token,
+              items : results,
+              total,
+            }));
+          }).
+            catch(() => {
+              markAsError();
+            });
+        } catch (err) {
+          markAsError();
+        }
+      });
+    }
+
+    return next(action);
+  };
+
+export default paginatorMiddleware;

package/src/reducerItemData.ts

@@ -0,0 +1,74 @@
+type FetchItemDataFulFilledProps = {
+  payload: {
+    Data: any;
+  };
+  meta: {
+    id: string;
+  };
+};
+import * as Immutable from "immutable";
+
+const
+  defaultOptions = Immutable.Map({
+    fetching : true,
+    fetched  : false,
+    error    : false,
+  }),
+
+  fetchItemDataPending = (state: any, {
+    meta: {
+      id,
+    },
+  }: {
+  meta: {
+    id: string;
+  };
+}) => (
+    state.update(id, (current : any) => {
+      if (typeof current === "undefined") {
+        return defaultOptions;
+      }
+
+      return current.mergeDeep(defaultOptions);
+    })
+  ),
+  fetchItemDataRejected = (state: any, {
+    meta: {
+      id,
+    },
+  }: {
+  meta: {
+    id: string;
+  };
+}) => state.update(id, (current : any) => {
+    if (typeof current === "undefined") {
+      return current;
+    }
+
+    return current.mergeDeep(Immutable.Map({
+      fetching : false,
+      fetched  : false,
+      error    : true,
+    }));
+  }),
+  fetchItemDataFulFilled = (state: any, {
+    payload: {
+      Data,
+    },
+    meta: {
+      id,
+    },
+  }: FetchItemDataFulFilledProps) => state.update(id, (current : any) => {
+    if (typeof current === "undefined") {
+      return current;
+    }
+
+    return current.mergeDeep(Immutable.Map({
+      Data,
+      fetching : false,
+      fetched  : true,
+      error    : false,
+    }));
+  });
+
+export { fetchItemDataPending, fetchItemDataRejected, fetchItemDataFulFilled };

package/src/reducerOperations.ts

@@ -0,0 +1,101 @@
+import * as Immutable from "immutable";
+import type {
+  ItemsState,
+  PagesState,
+  Action,
+  ReceivePageAction,
+  ChangeViewAction,
+  RequestPageAction,
+} from "./types";
+
+const requestPage = (state: PagesState, action: RequestPageAction) => {
+    const {
+        payload: {
+          token,
+          page,
+        },
+      } = action,
+      elements = Immutable.Map({
+        page,
+        error    : false,
+        fetching : true,
+        fetched  : false,
+      });
+
+    if (state.has(token)) {
+      return state.update(token, (current : any) => current.merge(elements));
+    }
+
+    const init = elements.merge({
+      view : 1,
+      token,
+      ids  : Immutable.List(),
+    });
+
+    return state.set(token, init);
+  },
+  receivePage = (state: PagesState, action: ReceivePageAction) => {
+    const {
+      meta: {
+        idKey,
+      },
+      payload: {
+        token,
+        items,
+        total,
+        error,
+      },
+    } = action;
+
+    if (state.has(token)) {
+      const hasError = error === true;
+
+      return state.update(token, (
+        (current : any) => current.update((page : any) => current.merge(Immutable.Map({
+          ids      : page.get("ids").concat(Immutable.List(items.map((item) => String(item[idKey])))),
+          fetching : false,
+          error    : hasError,
+          fetched  : true,
+          total    : hasError ? page.get("total") : total,
+        })))
+      ));
+    }
+
+    return state;
+  },
+  performChangeView = (state: PagesState, action: any, view: number) => {
+    const {
+        payload: {
+          token,
+        },
+      } = action,
+      item = state.get(token);
+
+    if (typeof item === "undefined") {
+      return state;
+    }
+
+    return state.update(token, (current : any) => current.set("view", view));
+  },
+  changeView = (state: PagesState, action: ChangeViewAction) => (
+    performChangeView(state, action, action.payload.view)
+  ),
+  resetView = (state: PagesState, action: Action) => performChangeView(state, action, 1),
+  receivePageItems = (state: ItemsState, action: ReceivePageAction) => {
+    const
+      { payload, meta } = action,
+      { items: payloadItems } = payload,
+      { idKey, manageEntity } = meta,
+      manage = typeof manageEntity === "function" ? manageEntity : (
+        (item : any) => Immutable.Map(item)
+      ),
+      newItems = payloadItems.reduce(
+        (previous, item) => (
+          previous.set(String(item[idKey]), manage(item, state, idKey))
+        ), Immutable.Map(),
+      );
+
+    return state.merge(newItems);
+  };
+
+export { requestPage, receivePage, performChangeView, changeView, resetView, receivePageItems };

package/src/{reducers.js → reducers.ts}

@@ -1,12 +1,4 @@
-// @flow
-
-import type {
-  ItemsState,
-  PagesState,
-
-  Action,
-} from "./types";
-
+import * as Immutable from "immutable";
 import {
   REQUEST_PAGE,
   RECEIVE_PAGE,
@@ -14,18 +6,15 @@ import {
   CHANGE_VIEW,
   CLEAR_DATA,
   FETCH_CURRENT_COMPANY_INFO_PENDING,
-
   FETCH_ITEM_DATA_PENDING,
   FETCH_ITEM_DATA_REJECTED,
   FETCH_ITEM_DATA_FULFILLED,
 } from "./actionTypes";
-
-import * as Immutable from "immutable";
-
+import type { ItemsState, PagesState, Action } from "./types";
 import * as reducerItemData from "./reducerItemData";
 import * as reducerOperations from "./reducerOperations";
 
-export const pages = (state : PagesState = Immutable.Map(), action : Action) => {
+export const pages = (state: PagesState = Immutable.Map(), action: Action) => {
   switch (action.type) {
     case REQUEST_PAGE:
       return reducerOperations.requestPage(state, action);
@@ -47,8 +36,7 @@ export const pages = (state : PagesState = Immutable.Map(), action : Action) =>
       return state;
   }
 };
-
-export const items = (state : ItemsState = Immutable.Map(), action : Action) => {
+export const items = (state: ItemsState = Immutable.Map(), action: Action) => {
   switch (action.type) {
     case RECEIVE_PAGE:
       return reducerOperations.receivePageItems(state, action);
@@ -56,26 +44,29 @@ export const items = (state : ItemsState = Immutable.Map(), action : Action) =>
     case FETCH_CURRENT_COMPANY_INFO_PENDING:
     case CLEAR_DATA:
       return state.clear();
+
     default:
       return state;
   }
 };
-
-export const dataItems = (state : ItemsState = Immutable.Map(), action : Action) => {
+export const dataItems = (state: ItemsState = Immutable.Map(), action: Action) => {
   switch (action.type) {
     case RECEIVE_PAGE:
       return reducerOperations.receivePageItems(state, action);
 
     case FETCH_ITEM_DATA_PENDING:
       return reducerItemData.fetchItemDataPending(state, action);
+
     case FETCH_ITEM_DATA_REJECTED:
       return reducerItemData.fetchItemDataRejected(state, action);
+
     case FETCH_ITEM_DATA_FULFILLED:
       return reducerItemData.fetchItemDataFulFilled(state, action);
 
     case FETCH_CURRENT_COMPANY_INFO_PENDING:
     case CLEAR_DATA:
       return state.clear();
+
     default:
       return state;
   }

package/src/selectors.ts

@@ -0,0 +1,113 @@
+import * as Immutable from "immutable";
+import { createSelector } from "reselect";
+import type { State, PagesState } from "./types";
+
+const
+  pagesSelector = (state: State) => state,
+
+  rowsPerPage = 50,
+  pageSelector = createSelector(
+    pagesSelector,
+    (_state: State, token: string) => token,
+    (pages: PagesState, token: string) => pages.get(token),
+  ),
+  getAllResults = createSelector(
+    pageSelector,
+    (_state : State, _token : string, items : any) => items,
+    (page : any, items : any) => {
+      if (typeof page === "undefined") {
+        return Immutable.List();
+      }
+
+      return page.get("ids").map((id : number) => items.get(String(id)));
+    },
+  ),
+  getResultsUpToPage = createSelector(
+    pageSelector,
+    (_state : State, _token : string, items : any) => items,
+    (_state : State, _token : string, _items: any, target: any) => target,
+    (_state : State, _token : string, _items : any, _target : any, perPage : number) => (
+      perPage || rowsPerPage
+    ),
+    (page : any, items : any, target : any, perPage : any) => {
+      if (typeof page === "undefined") {
+        return Immutable.List();
+      }
+
+      const ids = page.get("ids").slice(0, perPage * target);
+
+      return ids.map((id : number) => items.get(String(id)));
+    }),
+  getCurrentTotalResultsCount = createSelector(
+    pageSelector,
+    (page : any) => {
+      if (typeof page === "undefined") {
+        return 0;
+      }
+
+      return page.get("total");
+    }),
+  isPageFetching = createSelector(
+    pageSelector,
+    (_state : State, _token : string, target : any) => target,
+    (page : any, target : any) => {
+      if (typeof page === "undefined") {
+        return false;
+      }
+
+      return page.get("fetching") && target === page.get("page");
+    }),
+  isPageFetched = createSelector(
+    pageSelector,
+    (_state : State, _token : string, target : any) => target,
+    (page : any, target : any) => {
+      if (typeof page === "undefined") {
+        return false;
+      }
+
+      return page.get("fetched") && target <= page.get("page");
+    }),
+  hasPageProblems = createSelector(
+    pageSelector,
+    (page : any) => {
+      if (typeof page === "undefined") {
+        return false;
+      }
+
+      return page.get("error");
+    }),
+  getCurrentView = createSelector(
+    pageSelector,
+    (page : any) => {
+      if (typeof page === "undefined") {
+        return 1;
+      }
+
+      return page.get("view");
+    }),
+
+  // these selectors are used for the entire app
+  getPaginatorPaginations = (state: any, name: string) => state.getIn(["paginations", name]),
+  getPaginatorEntities = (state: any, name: string) => state.getIn(["entities", name]),
+  getPaginators = createSelector(
+    getPaginatorPaginations,
+    getPaginatorEntities,
+    (list : any, entities : any) => ({
+      list,
+      entities,
+    }),
+  );
+
+export default {
+  getAllResults,
+  getCurrentTotalResultsCount,
+  getResultsUpToPage,
+  isPageFetching,
+  isPageFetched,
+  hasPageProblems,
+  getCurrentView,
+  // for state
+  getPaginatorPaginations,
+  getPaginatorEntities,
+  getPaginators,
+};

package/src/types/{actions.js → actions.ts}

@@ -1,10 +1,8 @@
-// @flow
-
 import type { EndPointCb } from "./index";
 
 export type RequestPageAction = {
-  type : "@@redux-paginator-immutable/REQUEST_PAGE";
-  meta : {
+  type: "@@redux-paginator-immutable/REQUEST_PAGE";
+  meta: {
     endpoint: string;
     endpointCb: EndPointCb;
     manageEntity: any;
@@ -18,10 +16,9 @@ export type RequestPageAction = {
     token: string;
   };
 };
-
 export type ReceivePageAction = {
-  type : "@@redux-paginator-immutable/RECEIVE_PAGE";
-  meta : {
+  type: "@@redux-paginator-immutable/RECEIVE_PAGE";
+  meta: {
     endpoint: string;
     endpointCb: EndPointCb;
     manageEntity: any;
@@ -33,14 +30,13 @@ export type ReceivePageAction = {
     token: string;
     items: Array<any>;
     total: number;
-    error: bool;
+    error: boolean;
     raw?: string;
   };
 };
-
 export type ChangeViewAction = {
-  type : "@@redux-paginator-immutable/CHANGE_VIEW";
-  meta : {
+  type: "@@redux-paginator-immutable/CHANGE_VIEW";
+  meta: {
     endpoint: string;
   };
   payload: {
@@ -48,44 +44,38 @@ export type ChangeViewAction = {
     token: string;
   };
 };
-
 export type ResetViewAction = {
-  type : "@@redux-paginator-immutable/RESET_VIEW";
-  meta : {
+  type: "@@redux-paginator-immutable/RESET_VIEW";
+  meta: {
     endpoint: string;
   };
   payload: {
     token: string;
   };
 };
-
 export type ClearDataAction = {
-  type : "@@redux-paginator-immutable/CLEAR_DATA";
-  meta : {
+  type: "@@redux-paginator-immutable/CLEAR_DATA";
+  meta: {
     endpoint: string;
   };
 };
-
 export type FetchCurrentCompanyInfoPending = {
-  type : "FETCH_CURRENT_COMPANY_INFO_PENDING";
+  type: "FETCH_CURRENT_COMPANY_INFO_PENDING";
 };
-
 export type FetchItemDataPending = {
-  type : "@@redux-paginator-immutable/FETCH_ITEM_DATA_PENDING";
+  type: "@@redux-paginator-immutable/FETCH_ITEM_DATA_PENDING";
   meta: {
     id: string;
-  }
+  };
 };
-
 export type FetchItemDataRejected = {
-  type : "@@redux-paginator-immutable/FETCH_ITEM_DATA_REJECTED";
+  type: "@@redux-paginator-immutable/FETCH_ITEM_DATA_REJECTED";
   meta: {
     id: string;
-  }
+  };
 };
-
 export type FetchItemDataFulFilled = {
-  type : "@@redux-paginator-immutable/FETCH_ITEM_DATA_FULFILLED";
+  type: "@@redux-paginator-immutable/FETCH_ITEM_DATA_FULFILLED";
   payload: {
     Data: any;
   };
@@ -93,15 +83,13 @@ export type FetchItemDataFulFilled = {
     id: string;
   };
 };
-
-export type Action = RequestPageAction
-| ReceivePageAction
-| ResetViewAction
-| ChangeViewAction
-| ClearDataAction
-
-| FetchCurrentCompanyInfoPending
-
-|FetchItemDataPending
-|FetchItemDataRejected
-|FetchItemDataFulFilled;
+export type Action =
+RequestPageAction |
+ReceivePageAction |
+ResetViewAction |
+ChangeViewAction |
+ClearDataAction |
+FetchCurrentCompanyInfoPending |
+FetchItemDataPending |
+FetchItemDataRejected |
+FetchItemDataFulFilled;

package/src/types/{index.js → index.ts}

@@ -1,9 +1,6 @@
-// @flow
 /* eslint-disable no-use-before-define */
-
 export * from "./actions";
 export * from "./state";
-
 import type { State } from "./state";
 import type { Action } from "./actions";
 
@@ -11,28 +8,21 @@ export type GetState = () => State;
 export type PromiseAction = Promise<Action>;
 export type ThunkAction = (dispatch: Dispatch, getState: GetState) => any;
 export type Dispatch = (action: Action | ThunkAction | PromiseAction | Array<Action>) => any;
-
-export type EndPointCb = ((token? : string) => string) | null;
-
+export type EndPointCb = ((token?: string) => string) | null;
 export type PaginatorSettings = {
   key: string;
   manageEntity: any;
   resultsKey: string;
   dataItemURL: string;
   normalizeDataItem: any;
-
   // by default "{rowsPerLoad} from x25/utility/others"
   rowsPerLoad?: number;
-
   // by default "(items) => items"
   manipulateItems?: (items: any) => any;
-
   // by default "Total"
   totalKey?: string;
-
-   // by default "page"
+  // by default "page"
   pageArgName?: string;
-
   // default "ID"
   idKey?: string;
-}
+};

package/src/types/{state.js → state.ts}

@@ -1,9 +1,6 @@
-// @flow
-
 export type PagesState = any;
 export type ItemsState = any;
-
 export type State = {
-  +pages: PagesState;
-  +itemsReducer: ItemsState;
-}
+  readonly pages: PagesState;
+  readonly itemsReducer: ItemsState;
+};

package/src/util.ts

@@ -0,0 +1,51 @@
+/* eslint-disable no-duplicate-imports */
+type NormalizrEntity = (data: any) => any;
+
+import type { Map as ImmutableMap } from "immutable";
+import * as Immutable from "immutable";
+import { createSelector } from "reselect";
+
+type ManageDataEntity = ImmutableMap<string, any>;
+
+// simple item
+const
+  manageEntity = (normalizrEntity: NormalizrEntity) => (
+    (item: any, state: any, keyID: string): ManageDataEntity => {
+      // prevent rewrite
+      const old = state.get(String(item[keyID]));
+
+      if (typeof old === "undefined") {
+        return Immutable.Map(normalizrEntity(item));
+      }
+
+      return old;
+    }
+  ),
+  manipulateItems = (sortKey = "ID") => createSelector(
+    (data : any) => data,
+    (data : any) => data.sortBy((current : any) => -current.get(sortKey)),
+  ),
+
+  // data item
+  manageDataEntity = (normalizrEntity: NormalizrEntity) => (
+    (item: any, state: any, keyID: string): ManageDataEntity => {
+      // prevent rewrite
+      const old = state.get(String(item[keyID]));
+
+      if (typeof old === "undefined") {
+        return Immutable.Map({
+          Data: normalizrEntity(item),
+        });
+      }
+
+      return old;
+    }
+  ),
+  manipulateDataItems = (sortKey = "ID") => (
+    createSelector(
+      (data : any) => data,
+      (data : any) => data.sortBy((current : any) => -current.getIn(["Data", sortKey])),
+    )
+  );
+
+export { manageDataEntity, manipulateDataItems, manipulateItems, manageEntity };

package/src/{words.js → words.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 const words = {
   ThereWasAProblem : "There was a problem. Try again",
   Showing          : "Showing",