@resourge/react-fetch/dist/hooks/usePagination.js

[](LICENSE)

/**
 * react-fetch v1.43.1
 *
 * Copyright (c) resourge.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.md file in the root directory of this source tree.
 *
 * @license MIT
 */
import { useRef } from 'react';
import { HistoryStore } from '@resourge/history-store';
import { createNewUrlWithSearch, parseParams } from '@resourge/history-store/utils';
import { DEFAULT_PAGE, DEFAULT_PER_PAGE } from '../utils/constants';
import { createProxy } from '../utils/createProxy';
import { calculateTotalPages } from '../utils/utils';
import { useFetch } from './useFetch';
import { useFilterSearchParams } from './useFilterSearchParams';
import { usePreload } from './usePreload';

const usePagination = (method, {
  initialState,
  filter: defaultFilter = {},
  sort: defaultSort,
  hash,
  deps = [],
  initialPage = DEFAULT_PAGE,
  initialPerPage = DEFAULT_PER_PAGE,
  preload,
  fId,
  enable,
  ...config
}) => {
  const {
    getMethod,
    preloadRef
  } = usePreload({
    method,
    preload,
    initialPage,
    deps
  });
  const filterKeysRef = useRef({
    keys: new Set()
  });
  const fetchData = useFetch(async (metadata = {
    pagination,
    filter,
    sort
  }) => {
    const {
      data,
      totalItems
    } = await getMethod(createProxy(metadata, filterKeysRef.current));
    changeTotalPages(totalItems != null ? totalItems : 0);
    return data;
  }, {
    initialState,
    ...config,
    enable,
    deps
  });
  const {
    pagination,
    filter,
    sort,
    setFilter,
    sortTable,
    setParams
  } = useFilterSearchParams({
    fetch: fetchData.fetch,
    preloadRef,
    defaultFilter,
    defaultSort,
    initialPage,
    initialPerPage,
    hash,
    deps,
    fId,
    filterKeysRef,
    enable
  });
  function getPaginationHref(page) {
    const [url] = HistoryStore.getValue();
    return createNewUrlWithSearch(url, parseParams({
      page,
      perPage: pagination.perPage,
      sort,
      ...filter
    }), hash).href;
  }
  const changePage = (page, perPage = pagination.perPage) => {
    setFilter({
      page,
      perPage
    });
  };
  const changeTotalPages = totalItems => {
    const totalPages = calculateTotalPages(pagination.perPage, totalItems);
    pagination.totalItems = totalItems;
    pagination.totalPages = totalPages;
    if (totalPages < pagination.page) {
      changePage(initialPage);
    }
  };
  const reset = ({
    filter,
    pagination = {},
    sort = []
  } = {}) => {
    var _pagination$page, _pagination$perPage;
    setParams({
      page: (_pagination$page = pagination.page) != null ? _pagination$page : initialPage,
      perPage: (_pagination$perPage = pagination.perPage) != null ? _pagination$perPage : initialPerPage,
      sort: sort != null ? sort : defaultSort,
      ...defaultFilter,
      ...filter
    });
  };
  return {
    get data() {
      return fetchData.data;
    },
    get error() {
      return fetchData.error;
    },
    get isLoading() {
      return fetchData.isLoading;
    },
    setPaginationState: fetchData.setFetchState,
    fetch: () => {
      preloadRef.current = {};
      return fetchData.fetch();
    },
    sort,
    filter,
    pagination,
    changeTotalPages,
    changePage,
    changeItemsPerPage(perPage) {
      changePage(initialPage, perPage);
    },
    changePagination(page, perPage) {
      changePage(page, perPage);
    },
    resetPagination() {
      changePage(initialPage, initialPerPage);
    },
    getPaginationHref,
    setFilter,
    sortTable,
    reset
  };
};

export { usePagination };
//# sourceMappingURL=usePagination.js.map