redux-paginator-immutable 17.0.50 → 17.1.0

package/src/actions.ts

@@ -1,156 +0,0 @@
-
-import agent from "superagent";
-import { EndPointCb, Action } from "./types";
-
-type RequestPageArgsTypes = {
-  endpoint: string;
-  endpointCb: EndPointCb;
-  manageEntity: any;
-  resultsKey: string;
-  totalKey: string;
-  pageArgName: string;
-  idKey: string;
-  page: number;
-  token: string;
-};
-
-type ReceivePageArgsTypes = {
-  endpoint: string;
-  endpointCb: EndPointCb;
-  manageEntity: any;
-  pageArgName: string;
-  idKey: string;
-  page: number;
-  token: string;
-  items: Array<any>;
-  total: number;
-  error: boolean;
-};
-
-const requestPage = ({
-    endpoint,
-    endpointCb,
-    manageEntity,
-    resultsKey,
-    totalKey,
-    pageArgName,
-    idKey,
-    page,
-    token,
-  }: RequestPageArgsTypes): Action => ({
-    type : "@@redux-paginator-immutable/REQUEST_PAGE",
-    meta : {
-      endpoint,
-      endpointCb,
-      manageEntity,
-      resultsKey,
-      totalKey,
-      pageArgName,
-      idKey,
-    },
-    payload: {
-      page,
-      token,
-    },
-  }),
-
-  receivePage = ({
-    endpoint,
-    endpointCb,
-    manageEntity,
-    pageArgName,
-    idKey,
-    page,
-    token,
-    items,
-    error,
-    total,
-  }: ReceivePageArgsTypes): Action => ({
-    type : "@@redux-paginator-immutable/RECEIVE_PAGE",
-    meta : {
-      endpoint,
-      endpointCb,
-      manageEntity,
-      pageArgName,
-      idKey,
-    },
-    payload: {
-      page,
-      token,
-      items,
-      error,
-      total,
-    },
-  }),
-
-  resetView = (endpoint: string, token: string): Action => ({
-    type : "@@redux-paginator-immutable/RESET_VIEW",
-    meta : {
-      endpoint,
-    },
-    payload: {
-      token,
-    },
-  }),
-
-  changeView = (endpoint: string, {
-    token,
-    view,
-  }: {
-  token: string;
-  view: number;
-}): Action => ({
-    type : "@@redux-paginator-immutable/CHANGE_VIEW",
-    meta : {
-      endpoint,
-    },
-    payload: {
-      token,
-      view,
-    },
-  }),
-
-  clearData = (endpoint: string): Action => ({
-    type : "@@redux-paginator-immutable/CLEAR_DATA",
-    meta : {
-      endpoint,
-    },
-  });
-
-// data info
-type FetchDataItem = {
-  dataItemURL: string;
-  endpoint: string;
-  normalizeDataItem: any;
-  id: string;
-};
-
-const fetchDataItemRequest = ({
-  dataItemURL,
-  normalizeDataItem,
-  id,
-}: FetchDataItem): Promise<any> => (
-  new Promise((resolve, reject) => (
-    agent.
-      get(`${dataItemURL}/${id}`).
-      set("Accept", "application/json").
-      end(normalizeDataItem(resolve, reject))
-  )) as Promise<any>
-);
-
-export const fetchItem = (things: FetchDataItem): any => ({
-  type    : "@@redux-paginator-immutable/FETCH_ITEM_DATA",
-  payload : fetchDataItemRequest(things),
-  meta    : {
-    id       : things.id,
-    endpoint : things.endpoint,
-  },
-});
-
-export default {
-  clearData,
-  requestPage,
-  receivePage,
-  resetView,
-  changeView,
-};

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 };