redux-paginator-immutable 17.0.16 → 17.0.18

package/src/createDataReducer.js

@@ -1,94 +0,0 @@
-// @flow
-/* eslint-disable max-lines-per-function,  */
-
-import type { PaginatorSettings } from "./types";
-
-import { createSelector } from "reselect";
-import * as Immutable from "immutable";
-
-/*
-  Use to create a complex list where you need more information about
-  the item. For instance, if you DO need to fetch more data or to
-  manipulate it
-*/
-const createDataReducer = ({ key } : PaginatorSettings) => {
-  const
-    getItems = (state : any) => state.getIn([
-      "entities",
-      key,
-    ]),
-    getItem = createSelector(
-      getItems,
-      (state, id) => id,
-      (data, id) => data.get(id) || Immutable.Map()
-    ),
-    getItemsList = createSelector(
-      getItems,
-      (data) => data.map((current) => current.get("Data")).toList()
-    ),
-    getItemData = createSelector(
-      getItems,
-      (state, id) => id,
-      (data, id) => {
-        if (typeof data === "undefined") {
-          return Immutable.Map();
-        }
-
-        return data.getIn([
-          id,
-          "Data",
-        ]);
-      }
-    ),
-    getItemHasError = createSelector(
-      getItem,
-      (data) => {
-        if (typeof data === "undefined") {
-          return false;
-        }
-
-        return data.get("error") === true;
-      }
-    ),
-    getIsFetchingItemInfo = createSelector(
-      getItem,
-      (data) => {
-        if (typeof data === "undefined") {
-          return false;
-        }
-
-        return data.get("fetching");
-      }
-    ),
-    getItemIsFetched = createSelector(
-      getItem,
-      (data) => {
-        if (typeof data === "undefined") {
-          return false;
-        }
-
-        return data.get("fetched");
-      }
-    ),
-    getShouldFetchItemInfo = createSelector(
-      getIsFetchingItemInfo,
-      getItemIsFetched,
-      getItemHasError,
-      (isFetching, isFetched, hasError) => (
-        !isFetched && !isFetching && !hasError
-      )
-    );
-
-  return {
-    getItems,
-    getItem,
-    getItemsList,
-    getItemData,
-    getItemHasError,
-    getIsFetchingItemInfo,
-    getItemIsFetched,
-    getShouldFetchItemInfo,
-  };
-};
-
-export default createDataReducer;

package/src/createPaginator.js

@@ -1,131 +0,0 @@
-// @flow
-/* eslint-disable max-lines-per-function,  */
-
-import type { PaginatorSettings } from "./types";
-
-type EndpointData = {
-  path : string;
-  cb : () => string;
-};
-
-
-/*
-if (typeof Endpoint === "object") {
-  return {
-    path : Endpoint.path,
-    cb   : Endpoint.cb,
-  };
-}
-
-return {
-  path : Endpoint,
-};
-*/
-type Endpoint = EndpointData | string;
-
-type CreatePaginator = (endpoint: Endpoint, info: PaginatorSettings) => any;
-
-type OnlyForEndpoint = (endpoint : string, reducer : any) =>
-(state? : any, action : { meta: { endpoint : string }}) => any;
-
-import {
-  pages as pagesReducer,
-  items as itemsReducer,
-  dataItems as dataItemsReducer,
-} from "./reducers";
-
-import actions from "./actions";
-
-import * as Immutable from "immutable";
-
-import { rowsPerLoad as defaultRowsPerLoad } from "x25/utility/others";
-
-export const onlyForEndpoint : OnlyForEndpoint = (endpoint, reducer) => (
-  (state = Immutable.Map(), action) => {
-    if (typeof action.meta === "undefined" || action.meta.endpoint !== endpoint) {
-      return state;
-    }
-
-    return reducer(state, action);
-  }
-);
-
-const getEndpoint = (data : Endpoint) => {
-  if (typeof data === "object") {
-    return {
-      path : data.path,
-      cb   : data.cb,
-    };
-  }
-
-  return {
-    path : data,
-    cb   : null,
-  };
-};
-
-export const createPaginator : CreatePaginator = (
-  (endpointData : Endpoint, settings : PaginatorSettings) => {
-    const {
-      path: endpoint,
-      cb: endpointCb,
-    } = getEndpoint(endpointData);
-
-    const {
-      key,
-      normalizeDataItem,
-      dataItemURL,
-      manageEntity,
-      resultsKey,
-      totalKey = "Total",
-      pageArgName = "page",
-      idKey = "ID",
-      rowsPerLoad = defaultRowsPerLoad,
-      manipulateItems = (items) => items,
-    } = settings;
-
-    const endpointedActions = ({
-      requestPage: (page : number, token : string) => actions.requestPage({
-        endpoint,
-        endpointCb,
-        manageEntity,
-        resultsKey,
-        totalKey,
-        pageArgName,
-        idKey,
-        page,
-        token,
-      }),
-      resetView (token) {
-        return actions.resetView(endpoint, token);
-      },
-      changeView ({ view, token } : { view : number; token : string; }) {
-        return actions.changeView(endpoint, {
-          view,
-          token,
-        });
-      },
-      clearData () {
-        return actions.clearData(endpoint);
-      },
-    });
-
-    return ({
-      key,
-      normalizeDataItem,
-      dataItemURL,
-      manipulateItems,
-      rowsPerLoad,
-      manageEntity,
-      resultsKey,
-      endpoint,
-
-      pagesReducer : onlyForEndpoint(endpoint, pagesReducer),
-      itemsReducer : onlyForEndpoint(endpoint, itemsReducer),
-
-      dataItemsReducer: onlyForEndpoint(endpoint, dataItemsReducer),
-
-      ...endpointedActions,
-    });
-  }
-);

package/src/paginatorMiddleware.js

@@ -1,94 +0,0 @@
-// @flow
-/* 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;
-
-const 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,
-          }));
-        };
-
-        const rawPath = typeof endpointCb === "function" ? endpointCb(token) : endpoint;
-        const path = rawPath === null ? "" : rawPath;
-
-        try {
-          fetchPage({
-            endpoint: path,
-            pageArgName,
-            page,
-            token,
-          }).
-            then((res) => {
-              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.jsx

@@ -1,64 +0,0 @@
-// @flow
-
-type FetchItemDataFulFilledProps = {
-  payload: {
-    Data: any;
-  };
-  meta: {
-    id: string;
-  };
-};
-
-import * as Immutable from "immutable";
-
-const defaultOptions = Immutable.Map({
-  fetching : true,
-  fetched  : false,
-  error    : false,
-});
-
-const
-  fetchItemDataPending = (state : any, { meta : { id } } : { meta : { id : string }}) => (
-    state.update(id, (current) => {
-      if (typeof current === "undefined") {
-        return defaultOptions;
-      }
-
-      return current.mergeDeep(defaultOptions);
-    })
-  ),
-  fetchItemDataRejected = (state : any, { meta : { id } } : { meta : { id : string }}) => (
-    state.update((id), (current) => {
-      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) => {
-      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.jsx

@@ -1,112 +0,0 @@
-// @flow
-
-import type {
-  ItemsState,
-  PagesState,
-
-  Action,
-  ReceivePageAction,
-  ChangeViewAction,
-  RequestPageAction,
-} from "./types";
-
-import * as Immutable from "immutable";
-
-const
-  requestPage = (state : PagesState, action : RequestPageAction) => {
-    const { payload : { token, page } } = action;
-
-    const elements = Immutable.Map({
-      page,
-      error    : false,
-      fetching : true,
-      fetched  : false,
-    });
-
-    if (state.has(token)) {
-      return state.update(token, (current) => (
-        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) => (
-        current.update((page) => (
-          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;
-
-    const item = state.get(token);
-
-    if (typeof item === "undefined") {
-      return state;
-    }
-
-    return state.update(token, (current) => (
-      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;
-    const { items : payloadItems } = payload;
-    const { idKey, manageEntity } = meta;
-
-    const manage : any = (
-      typeof manageEntity === "function"
-    ) ? manageEntity : (item) => Immutable.Map(item);
-
-    const 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/selectors.js

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

package/src/util.js

@@ -1,71 +0,0 @@
-// @flow
-/* 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, *>;
-
-// 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? : string = "ID") => createSelector(
-    (data) => data,
-    (data) => (
-      data.sortBy((current) => -current.get(sortKey))
-    )
-  );
-
-// data item
-
-const
-  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? : string = "ID") => createSelector(
-    (data) => data,
-    (data) => (
-      data.sortBy((current) => -current.getIn([
-        "Data",
-        sortKey,
-      ]))
-    )
-  );
-
-export {
-  manageDataEntity,
-  manipulateDataItems,
-
-  manipulateItems,
-  manageEntity,
-};