redux-paginator-immutable 17.0.49 → 17.0.51

package/src/agent.ts

@@ -1,62 +0,0 @@
-/* eslint-disable no-bitwise*/
-
-type FetchPageArgs = {
-  endpoint: string;
-  pageArgName: string;
-  page: number;
-  token: string;
-};
-
-import agent from "superagent";
-import qs from "query-string";
-
-export const
-  buildSuffix = (pageArgName: string, page: number, params: string) => {
-    const parsedParams = qs.parse(params);
-    let finalParsedParams = {},
-      startString = "";
-
-    for (const key of Object.keys(parsedParams)) {
-      if (parsedParams[key] === null) {
-        startString += key;
-      } else {
-        finalParsedParams = { ...finalParsedParams,
-          [key]: parsedParams[key],
-        };
-      }
-    }
-
-    startString = startString === "" ? "?" : `${startString}?`;
-
-    if (Object.keys(finalParsedParams).length > 0 && qs.extract(params) !== "") {
-      startString = params.replace(qs.extract(params), "");
-    }
-
-    return startString + qs.stringify({ ...finalParsedParams,
-      [pageArgName]: page,
-    }, {
-      encode: false,
-    }).replace(startString, "");
-  },
-  fetchPage = ({
-    endpoint,
-    pageArgName,
-    page,
-    token,
-  }: FetchPageArgs) => {
-    const suffix = buildSuffix(pageArgName, page, token),
-      url = endpoint + suffix,
-      promise: any = new Promise(
-        (resolve: any, reject: any) => (
-          agent.
-            get(url).
-            end((err: any, res: any) => err ? reject(err) : resolve(res))
-        ),
-      );
-
-    return promise.then((res: {
-    body: any;
-  }) => ({
-      response: res.body,
-    }));
-  };

package/src/createDataReducer.ts

@@ -1,90 +0,0 @@
-import { createSelector } from "reselect";
-import * as Immutable from "immutable";
-import { PaginatorSettings } from "./types";
-
-type Selector = (state : any, id : string) => any;
-type ListSelector = (state : any) => any;
-
-/*
-  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) : any => (
-        state.getIn(["entities", key])
-      ),
-      getItem : Selector = createSelector(
-        getItems,
-        (_state : any, id : string) => id,
-        (data : any, id : string) : any => data.get(id) || Immutable.Map(),
-      ),
-      getItemsList : ListSelector = createSelector(
-        getItems,
-        (data : any) => data.map((current : any) => current.get("Data")).toList(),
-      ),
-      getItemData : Selector = createSelector(
-        getItems,
-        (_state : any, id : string) => id,
-        (data : any, id : string) : any => {
-          if (typeof data === "undefined") {
-            return Immutable.Map();
-          }
-
-          return data.getIn([id, "Data"]);
-        },
-      ),
-      getItemHasError : Selector = createSelector(
-        getItem,
-        (data : any) : boolean => {
-          if (typeof data === "undefined") {
-            return false;
-          }
-
-          return data.get("error") === true;
-        },
-      ),
-      getIsFetchingItemInfo : Selector = createSelector(
-        getItem,
-        (data : any) : boolean => {
-          if (typeof data === "undefined") {
-            return false;
-          }
-
-          return data.get("fetching");
-        },
-      ),
-      getItemIsFetched : Selector = createSelector(
-        getItem,
-        (data : any) : boolean => {
-          if (typeof data === "undefined") {
-            return false;
-          }
-
-          return data.get("fetched");
-        },
-      ),
-      getShouldFetchItemInfo : Selector = createSelector(
-        getIsFetchingItemInfo,
-        getItemIsFetched,
-        getItemHasError,
-        (isFetching : boolean, isFetched : boolean, hasError : boolean) : boolean => (
-          !isFetched && !isFetching && !hasError
-        ),
-      );
-
-    return {
-      getItems,
-      getItem,
-      getItemsList,
-      getItemData,
-      getItemHasError,
-      getIsFetchingItemInfo,
-      getItemIsFetched,
-      getShouldFetchItemInfo,
-    };
-  };
-
-export default createDataReducer;

package/src/createItemReducer.ts

@@ -1,29 +0,0 @@
-import { createSelector } from "reselect";
-import { PaginatorSettings } from "./types";
-
-/*
-  Use to create a simple list where you do not need more information about
-  the item. For instance, if you do NOT need to fetch more data or
-  manipulate it
-*/
-const createReducer = ({ key }: PaginatorSettings) => {
-  const
-    getItems = (state: any) => state.getIn(["entities", key]),
-    getItem : (state : any, id : string) => any = createSelector(
-      getItems,
-      (_state : any, id : string) => id,
-      (data : any, id : string) => data.get(id),
-    ),
-    getItemsList = createSelector(
-      getItems,
-      (data : any) => data.toList(),
-    );
-
-  return {
-    getItems,
-    getItem,
-    getItemsList,
-  };
-};
-
-export default createReducer;

package/src/createPaginator.ts

@@ -1,104 +0,0 @@
-const defaultRowsPerLoad = 25;
-
-import * as Immutable from "immutable";
-import { pages as pagesReducer, items as itemsReducer, dataItems as dataItemsReducer } from "./reducers";
-import actions from "./actions";
-import { PaginatorSettings } from "./types";
-
-type EndpointData = {
-  path: string;
-  cb: () => string;
-};
-
-type Endpoint = EndpointData | string;
-
-type Action = {
-  meta?: {
-    endpoint: string;
-  }
-}
-
-const getEndpoint = (data: Endpoint) => {
-  if (typeof data === "object") {
-    return {
-      path : data.path,
-      cb   : data.cb,
-    };
-  }
-
-  return {
-    path : data,
-    cb   : null,
-  };
-};
-
-export const
-  onlyForEndpoint = (endpoint : string, reducer : any) => (state = Immutable.Map(), action : Action) => {
-    if (typeof action.meta === "undefined" || action.meta.endpoint !== endpoint) {
-      return state;
-    }
-
-    return reducer(state, action);
-  },
-  createPaginator = (endpointData: Endpoint, settings: PaginatorSettings) => {
-    const
-      {
-        path: endpoint,
-        cb: endpointCb,
-      } = getEndpoint(endpointData),
-      {
-        key,
-        normalizeDataItem,
-        dataItemURL,
-        manageEntity,
-        resultsKey,
-        totalKey = "Total",
-        pageArgName = "page",
-        idKey = "ID",
-        rowsPerLoad = defaultRowsPerLoad,
-        manipulateItems = (items) => items,
-      } = settings,
-      endpointedActions = {
-        requestPage: (page: number, token: string) => actions.requestPage({
-          endpoint,
-          endpointCb,
-          manageEntity,
-          resultsKey,
-          totalKey,
-          pageArgName,
-          idKey,
-          page,
-          token,
-        }),
-
-        resetView (token : any) {
-          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/index.ts

@@ -1,26 +0,0 @@
-import { createPaginator } from "./createPaginator";
-import paginatorMiddleware from "./paginatorMiddleware";
-import paginatorSelectors from "./selectors";
-import { manageDataEntity, manipulateDataItems, manipulateItems, manageEntity } from "./util";
-import Info from "./Info";
-import LoadingButton from "./LoadingButton";
-import LoadPaginator from "./LoadPaginator";
-import LoadDataItem from "./LoadDataItem";
-import createDataReducer from "./createDataReducer";
-import createItemReducer from "./createItemReducer";
-
-export {
-  Info,
-  LoadingButton,
-  LoadPaginator,
-  LoadDataItem,
-  createPaginator,
-  paginatorMiddleware,
-  paginatorSelectors,
-  createDataReducer,
-  manageDataEntity,
-  manipulateDataItems,
-  createItemReducer,
-  manipulateItems,
-  manageEntity,
-};

package/src/paginatorMiddleware.ts

@@ -1,93 +0,0 @@
-/* eslint-disable no-console, max-lines-per-function */
-import { REQUEST_PAGE } from "./actionTypes";
-import actions from "./actions";
-import { fetchPage } from "./agent";
-import { Action, Dispatch } from "./types";
-
-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

@@ -1,74 +0,0 @@
-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

@@ -1,92 +0,0 @@
-import * as Immutable from "immutable";
-import { Action } from "redux";
-import { PagesState, RequestPageAction, ReceivePageAction, ChangeViewAction, ItemsState } from "./types";
-
-const requestPage = (state: PagesState, action: RequestPageAction) => {
-    const
-      { payload: { token, page } } = action,
-      // it is the type any because ts apparently has a problem
-      elements : any = 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.ts

@@ -1,77 +0,0 @@
-import * as Immutable from "immutable";
-import { Action, PagesState, ItemsState } from "./types";
-
-import {
-  REQUEST_PAGE,
-  RECEIVE_PAGE,
-  RESET_VIEW,
-  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 reducerItemData from "./reducerItemData";
-import * as reducerOperations from "./reducerOperations";
-
-
-export const
-  pages = (state: PagesState = Immutable.Map(), action: Action) => {
-    switch (action.type) {
-      case REQUEST_PAGE:
-        return reducerOperations.requestPage(state, action);
-
-      case RECEIVE_PAGE:
-        return reducerOperations.receivePage(state, action);
-
-      case RESET_VIEW:
-        return reducerOperations.resetView(state, action);
-
-      case CHANGE_VIEW:
-        return reducerOperations.changeView(state, action);
-
-      case FETCH_CURRENT_COMPANY_INFO_PENDING:
-      case CLEAR_DATA:
-        return state.clear();
-
-      default:
-        return state;
-    }
-  },
-  items = (state: ItemsState = Immutable.Map(), action: Action) => {
-    switch (action.type) {
-      case RECEIVE_PAGE:
-        return reducerOperations.receivePageItems(state, action);
-
-      case FETCH_CURRENT_COMPANY_INFO_PENDING:
-      case CLEAR_DATA:
-        return state.clear();
-
-      default:
-        return state;
-    }
-  },
-  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;
-    }
-  };