react-paginating/dist/react-paginating.cjs.js

Simple, lightweight, flexible pagination component

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var React = require('react');
var React__default = _interopDefault(React);
var PropTypes = _interopDefault(require('prop-types'));
var pagingAlgorithm = require('paging-algorithm');

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(source, true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(source).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};

  var target = _objectWithoutPropertiesLoose(source, excluded);

  var key, i;

  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }

  return target;
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

function Pagination(props) {
  var _useState = React.useState(1),
      _useState2 = _slicedToArray(_useState, 2),
      currentPage = _useState2[0],
      setCurrentPage = _useState2[1];

  if (props.currentPage && currentPage !== props.currentPage) {
    setCurrentPage(parseInt(props.currentPage, 10));
  }

  var _getPageItemProps = function _getPageItemProps(props) {
    var pageValue = props.pageValue,
        handlePageChange = props.onPageChange,
        rest = _objectWithoutProperties(props, ["pageValue", "onPageChange"]);

    var onPageChange = function onPageChange(e) {
      if (typeof handlePageChange === 'function') {
        handlePageChange(pageValue, e);
      }

      setCurrentPage(pageValue);
    };

    return _objectSpread2({
      onClick: onPageChange
    }, rest);
  };

  var total = props.total,
      limit = props.limit,
      pageCount = props.pageCount,
      className = props.className;
  var pageInfo = pagingAlgorithm.getPageInfo({
    limit: limit,
    pageCount: pageCount,
    total: total,
    page: currentPage
  });
  var firstPage = pageInfo.firstPage,
      lastPage = pageInfo.lastPage,
      hasNextPage = pageInfo.hasNextPage,
      hasPreviousPage = pageInfo.hasPreviousPage,
      previousPage = pageInfo.previousPage,
      nextPage = pageInfo.nextPage,
      totalPages = pageInfo.totalPages;
  var pages = total > 0 ? pagingAlgorithm.getRange(firstPage, lastPage) : [];
  return React__default.createElement("div", {
    className: className
  }, props.children({
    pages: pages,
    previousPage: previousPage,
    nextPage: nextPage,
    totalPages: totalPages,
    currentPage: currentPage,
    hasNextPage: hasNextPage,
    hasPreviousPage: hasPreviousPage,
    getPageItemProps: _getPageItemProps
  }));
}

Pagination.propTypes = {
  total: PropTypes.number.isRequired,
  className: PropTypes.string,
  limit: PropTypes.number,
  pageCount: PropTypes.number,
  currentPage: PropTypes.number,
  pageValue: PropTypes.number,
  children: PropTypes.func.isRequired,
  onPageChange: PropTypes.func
};
Pagination.defaultProps = {
  limit: 10,
  pageCount: 5,
  currentPage: 0,
  pageValue: 0
};

module.exports = Pagination;