react-paginating/dist/react-paginating.umd.js

Simple, lightweight, flexible pagination component

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react'), require('prop-types'), require('paging-algorithm')) :
  typeof define === 'function' && define.amd ? define(['react', 'prop-types', 'paging-algorithm'], factory) :
  (global = global || self, global['react-paginating-umd'] = factory(global.React, global.PropTypes, global.pagingAlgorithm));
}(this, function (React, PropTypes, pagingAlgorithm) { 'use strict';

  var React__default = 'default' in React ? React['default'] : React;
  PropTypes = PropTypes && PropTypes.hasOwnProperty('default') ? PropTypes['default'] : PropTypes;

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

  return Pagination;

}));
//# sourceMappingURL=react-paginating.umd.js.map