antd3-esm 1.0.1

package/dist/Pagination.js

@@ -0,0 +1,1106 @@
+import * as React from 'react';
+import React__default from 'react';
+import { d as _defineProperty, _ as _inherits$2, a as _classCallCheck$2, b as _possibleConstructorReturn$2, c as _createClass$2, e as _extends$2, I as Icon } from './icon.js';
+import { c as classNames, P as PropTypes, C as ConfigConsumer, L as LocaleReceiver, k as Pagination$3 } from './config-provider.js';
+import { P as Pagination$2 } from './zh_CN.js';
+import { p as polyfill } from './menu.js';
+import { S as Select } from './index12.js';
+
+var Pager = function Pager(props) {
+  var _classNames;
+
+  var prefixCls = props.rootPrefixCls + '-item';
+  var cls = classNames(prefixCls, prefixCls + '-' + props.page, (_classNames = {}, _defineProperty(_classNames, prefixCls + '-active', props.active), _defineProperty(_classNames, props.className, !!props.className), _defineProperty(_classNames, prefixCls + '-disabled', !props.page), _classNames));
+
+  var handleClick = function handleClick() {
+    props.onClick(props.page);
+  };
+
+  var handleKeyPress = function handleKeyPress(e) {
+    props.onKeyPress(e, props.onClick, props.page);
+  };
+
+  return React__default.createElement(
+    'li',
+    {
+      title: props.showTitle ? props.page : null,
+      className: cls,
+      onClick: handleClick,
+      onKeyPress: handleKeyPress,
+      tabIndex: '0'
+    },
+    props.itemRender(props.page, 'page', React__default.createElement(
+      'a',
+      null,
+      props.page
+    ))
+  );
+};
+
+Pager.propTypes = {
+  page: PropTypes.number,
+  active: PropTypes.bool,
+  last: PropTypes.bool,
+  locale: PropTypes.object,
+  className: PropTypes.string,
+  showTitle: PropTypes.bool,
+  rootPrefixCls: PropTypes.string,
+  onClick: PropTypes.func,
+  onKeyPress: PropTypes.func,
+  itemRender: PropTypes.func
+};
+
+var KEYCODE = {
+  ENTER: 13,
+
+  ARROW_UP: 38,
+  ARROW_DOWN: 40
+};
+
+var Options = function (_React$Component) {
+  _inherits$2(Options, _React$Component);
+
+  function Options() {
+    var _ref;
+
+    var _temp, _this, _ret;
+
+    _classCallCheck$2(this, Options);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this = _possibleConstructorReturn$2(this, (_ref = Options.__proto__ || Object.getPrototypeOf(Options)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
+      goInputText: ''
+    }, _this.buildOptionText = function (value) {
+      return value + ' ' + _this.props.locale.items_per_page;
+    }, _this.changeSize = function (value) {
+      _this.props.changeSize(Number(value));
+    }, _this.handleChange = function (e) {
+      _this.setState({
+        goInputText: e.target.value
+      });
+    }, _this.handleBlur = function (e) {
+      var _this$props = _this.props,
+          goButton = _this$props.goButton,
+          quickGo = _this$props.quickGo,
+          rootPrefixCls = _this$props.rootPrefixCls;
+
+      if (goButton) {
+        return;
+      }
+      if (e.relatedTarget && (e.relatedTarget.className.indexOf(rootPrefixCls + '-prev') >= 0 || e.relatedTarget.className.indexOf(rootPrefixCls + '-next') >= 0)) {
+        return;
+      }
+      quickGo(_this.getValidValue());
+    }, _this.go = function (e) {
+      var goInputText = _this.state.goInputText;
+
+      if (goInputText === '') {
+        return;
+      }
+      if (e.keyCode === KEYCODE.ENTER || e.type === 'click') {
+        _this.setState({
+          goInputText: ''
+        });
+        _this.props.quickGo(_this.getValidValue());
+      }
+    }, _temp), _possibleConstructorReturn$2(_this, _ret);
+  }
+
+  _createClass$2(Options, [{
+    key: 'getValidValue',
+    value: function getValidValue() {
+      var _state = this.state,
+          goInputText = _state.goInputText,
+          current = _state.current;
+
+      return !goInputText || isNaN(goInputText) ? current : Number(goInputText);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _this2 = this;
+
+      var _props = this.props,
+          pageSize = _props.pageSize,
+          pageSizeOptions = _props.pageSizeOptions,
+          locale = _props.locale,
+          rootPrefixCls = _props.rootPrefixCls,
+          changeSize = _props.changeSize,
+          quickGo = _props.quickGo,
+          goButton = _props.goButton,
+          selectComponentClass = _props.selectComponentClass,
+          buildOptionText = _props.buildOptionText,
+          selectPrefixCls = _props.selectPrefixCls,
+          disabled = _props.disabled;
+      var goInputText = this.state.goInputText;
+
+      var prefixCls = rootPrefixCls + '-options';
+      var Select = selectComponentClass;
+      var changeSelect = null;
+      var goInput = null;
+      var gotoButton = null;
+
+      if (!changeSize && !quickGo) {
+        return null;
+      }
+
+      if (changeSize && Select) {
+        var options = pageSizeOptions.map(function (opt, i) {
+          return React__default.createElement(
+            Select.Option,
+            { key: i, value: opt },
+            (buildOptionText || _this2.buildOptionText)(opt)
+          );
+        });
+
+        changeSelect = React__default.createElement(
+          Select,
+          {
+            disabled: disabled,
+            prefixCls: selectPrefixCls,
+            showSearch: false,
+            className: prefixCls + '-size-changer',
+            optionLabelProp: 'children',
+            dropdownMatchSelectWidth: false,
+            value: (pageSize || pageSizeOptions[0]).toString(),
+            onChange: this.changeSize,
+            getPopupContainer: function getPopupContainer(triggerNode) {
+              return triggerNode.parentNode;
+            }
+          },
+          options
+        );
+      }
+
+      if (quickGo) {
+        if (goButton) {
+          gotoButton = typeof goButton === 'boolean' ? React__default.createElement(
+            'button',
+            {
+              type: 'button',
+              onClick: this.go,
+              onKeyUp: this.go,
+              disabled: disabled
+            },
+            locale.jump_to_confirm
+          ) : React__default.createElement(
+            'span',
+            {
+              onClick: this.go,
+              onKeyUp: this.go
+            },
+            goButton
+          );
+        }
+        goInput = React__default.createElement(
+          'div',
+          { className: prefixCls + '-quick-jumper' },
+          locale.jump_to,
+          React__default.createElement('input', {
+            disabled: disabled,
+            type: 'text',
+            value: goInputText,
+            onChange: this.handleChange,
+            onKeyUp: this.go,
+            onBlur: this.handleBlur
+          }),
+          locale.page,
+          gotoButton
+        );
+      }
+
+      return React__default.createElement(
+        'li',
+        { className: '' + prefixCls },
+        changeSelect,
+        goInput
+      );
+    }
+  }]);
+
+  return Options;
+}(React__default.Component);
+
+Options.propTypes = {
+  disabled: PropTypes.bool,
+  changeSize: PropTypes.func,
+  quickGo: PropTypes.func,
+  selectComponentClass: PropTypes.func,
+  current: PropTypes.number,
+  pageSizeOptions: PropTypes.arrayOf(PropTypes.string),
+  pageSize: PropTypes.number,
+  buildOptionText: PropTypes.func,
+  locale: PropTypes.object,
+  rootPrefixCls: PropTypes.string,
+  selectPrefixCls: PropTypes.string,
+  goButton: PropTypes.oneOfType([PropTypes.bool, PropTypes.node])
+};
+Options.defaultProps = {
+  pageSizeOptions: ['10', '20', '30', '40']
+};
+
+function noop() {}
+
+function isInteger(value) {
+  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+}
+
+function defaultItemRender(page, type, element) {
+  return element;
+}
+
+function calculatePage(p, state, props) {
+  var pageSize = p;
+  if (typeof pageSize === 'undefined') {
+    pageSize = state.pageSize;
+  }
+  return Math.floor((props.total - 1) / pageSize) + 1;
+}
+
+var Pagination$1 = function (_React$Component) {
+  _inherits$2(Pagination, _React$Component);
+
+  function Pagination(props) {
+    _classCallCheck$2(this, Pagination);
+
+    var _this = _possibleConstructorReturn$2(this, (Pagination.__proto__ || Object.getPrototypeOf(Pagination)).call(this, props));
+
+    _initialiseProps.call(_this);
+
+    var hasOnChange = props.onChange !== noop;
+    var hasCurrent = 'current' in props;
+    if (hasCurrent && !hasOnChange) {
+      console.warn('Warning: You provided a `current` prop to a Pagination component without an `onChange` handler. This will render a read-only component.'); // eslint-disable-line
+    }
+
+    var current = props.defaultCurrent;
+    if ('current' in props) {
+      current = props.current;
+    }
+
+    var pageSize = props.defaultPageSize;
+    if ('pageSize' in props) {
+      pageSize = props.pageSize;
+    }
+
+    current = Math.min(current, calculatePage(pageSize, undefined, props));
+
+    _this.state = {
+      current: current,
+      currentInputValue: current,
+      pageSize: pageSize
+    };
+    return _this;
+  }
+
+  _createClass$2(Pagination, [{
+    key: 'componentDidUpdate',
+    value: function componentDidUpdate(prevProps, prevState) {
+      // When current page change, fix focused style of prev item
+      // A hacky solution of https://github.com/ant-design/ant-design/issues/8948
+      var prefixCls = this.props.prefixCls;
+
+      if (prevState.current !== this.state.current && this.paginationNode) {
+        var lastCurrentNode = this.paginationNode.querySelector('.' + prefixCls + '-item-' + prevState.current);
+        if (lastCurrentNode && document.activeElement === lastCurrentNode) {
+          lastCurrentNode.blur();
+        }
+      }
+    }
+  }, {
+    key: 'getValidValue',
+    value: function getValidValue(e) {
+      var inputValue = e.target.value;
+      var allPages = calculatePage(undefined, this.state, this.props);
+      var currentInputValue = this.state.currentInputValue;
+
+      var value = void 0;
+      if (inputValue === '') {
+        value = inputValue;
+      } else if (isNaN(Number(inputValue))) {
+        value = currentInputValue;
+      } else if (inputValue >= allPages) {
+        value = allPages;
+      } else {
+        value = Number(inputValue);
+      }
+      return value;
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          prefixCls = _props.prefixCls,
+          className = _props.className,
+          disabled = _props.disabled;
+
+      // When hideOnSinglePage is true and there is only 1 page, hide the pager
+
+      if (this.props.hideOnSinglePage === true && this.props.total <= this.state.pageSize) {
+        return null;
+      }
+
+      var props = this.props;
+      var locale = props.locale;
+
+      var allPages = calculatePage(undefined, this.state, this.props);
+      var pagerList = [];
+      var jumpPrev = null;
+      var jumpNext = null;
+      var firstPager = null;
+      var lastPager = null;
+      var gotoButton = null;
+
+      var goButton = props.showQuickJumper && props.showQuickJumper.goButton;
+      var pageBufferSize = props.showLessItems ? 1 : 2;
+      var _state = this.state,
+          current = _state.current,
+          pageSize = _state.pageSize;
+
+
+      var prevPage = current - 1 > 0 ? current - 1 : 0;
+      var nextPage = current + 1 < allPages ? current + 1 : allPages;
+
+      var dataOrAriaAttributeProps = Object.keys(props).reduce(function (prev, key) {
+        if (key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-' || key === 'role') {
+          prev[key] = props[key];
+        }
+        return prev;
+      }, {});
+
+      if (props.simple) {
+        if (goButton) {
+          if (typeof goButton === 'boolean') {
+            gotoButton = React__default.createElement(
+              'button',
+              {
+                type: 'button',
+                onClick: this.handleGoTO,
+                onKeyUp: this.handleGoTO
+              },
+              locale.jump_to_confirm
+            );
+          } else {
+            gotoButton = React__default.createElement(
+              'span',
+              {
+                onClick: this.handleGoTO,
+                onKeyUp: this.handleGoTO
+              },
+              goButton
+            );
+          }
+          gotoButton = React__default.createElement(
+            'li',
+            {
+              title: props.showTitle ? '' + locale.jump_to + this.state.current + '/' + allPages : null,
+              className: prefixCls + '-simple-pager'
+            },
+            gotoButton
+          );
+        }
+
+        return React__default.createElement(
+          'ul',
+          _extends$2({
+            className: prefixCls + ' ' + prefixCls + '-simple ' + props.className,
+            style: props.style,
+            ref: this.savePaginationNode
+          }, dataOrAriaAttributeProps),
+          React__default.createElement(
+            'li',
+            {
+              title: props.showTitle ? locale.prev_page : null,
+              onClick: this.prev,
+              tabIndex: this.hasPrev() ? 0 : null,
+              onKeyPress: this.runIfEnterPrev,
+              className: (this.hasPrev() ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-prev',
+              'aria-disabled': !this.hasPrev()
+            },
+            props.itemRender(prevPage, 'prev', this.getItemIcon(props.prevIcon))
+          ),
+          React__default.createElement(
+            'li',
+            {
+              title: props.showTitle ? this.state.current + '/' + allPages : null,
+              className: prefixCls + '-simple-pager'
+            },
+            React__default.createElement('input', {
+              type: 'text',
+              value: this.state.currentInputValue,
+              onKeyDown: this.handleKeyDown,
+              onKeyUp: this.handleKeyUp,
+              onChange: this.handleKeyUp,
+              size: '3'
+            }),
+            React__default.createElement(
+              'span',
+              { className: prefixCls + '-slash' },
+              '/'
+            ),
+            allPages
+          ),
+          React__default.createElement(
+            'li',
+            {
+              title: props.showTitle ? locale.next_page : null,
+              onClick: this.next,
+              tabIndex: this.hasPrev() ? 0 : null,
+              onKeyPress: this.runIfEnterNext,
+              className: (this.hasNext() ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-next',
+              'aria-disabled': !this.hasNext()
+            },
+            props.itemRender(nextPage, 'next', this.getItemIcon(props.nextIcon))
+          ),
+          gotoButton
+        );
+      }
+
+      if (allPages <= 5 + pageBufferSize * 2) {
+        var pagerProps = {
+          locale: locale,
+          rootPrefixCls: prefixCls,
+          onClick: this.handleChange,
+          onKeyPress: this.runIfEnter,
+          showTitle: props.showTitle,
+          itemRender: props.itemRender
+        };
+        if (!allPages) {
+          pagerList.push(React__default.createElement(Pager, _extends$2({}, pagerProps, {
+            key: 'noPager',
+            page: allPages,
+            className: prefixCls + '-disabled'
+          })));
+        }
+        for (var i = 1; i <= allPages; i++) {
+          var active = this.state.current === i;
+          pagerList.push(React__default.createElement(Pager, _extends$2({}, pagerProps, {
+            key: i,
+            page: i,
+            active: active
+          })));
+        }
+      } else {
+        var prevItemTitle = props.showLessItems ? locale.prev_3 : locale.prev_5;
+        var nextItemTitle = props.showLessItems ? locale.next_3 : locale.next_5;
+        if (props.showPrevNextJumpers) {
+          var jumpPrevClassString = prefixCls + '-jump-prev';
+          if (props.jumpPrevIcon) {
+            jumpPrevClassString += ' ' + prefixCls + '-jump-prev-custom-icon';
+          }
+          jumpPrev = React__default.createElement(
+            'li',
+            {
+              title: props.showTitle ? prevItemTitle : null,
+              key: 'prev',
+              onClick: this.jumpPrev,
+              tabIndex: '0',
+              onKeyPress: this.runIfEnterJumpPrev,
+              className: jumpPrevClassString
+            },
+            props.itemRender(this.getJumpPrevPage(), 'jump-prev', this.getItemIcon(props.jumpPrevIcon))
+          );
+          var jumpNextClassString = prefixCls + '-jump-next';
+          if (props.jumpNextIcon) {
+            jumpNextClassString += ' ' + prefixCls + '-jump-next-custom-icon';
+          }
+          jumpNext = React__default.createElement(
+            'li',
+            {
+              title: props.showTitle ? nextItemTitle : null,
+              key: 'next',
+              tabIndex: '0',
+              onClick: this.jumpNext,
+              onKeyPress: this.runIfEnterJumpNext,
+              className: jumpNextClassString
+            },
+            props.itemRender(this.getJumpNextPage(), 'jump-next', this.getItemIcon(props.jumpNextIcon))
+          );
+        }
+        lastPager = React__default.createElement(Pager, {
+          locale: props.locale,
+          last: true,
+          rootPrefixCls: prefixCls,
+          onClick: this.handleChange,
+          onKeyPress: this.runIfEnter,
+          key: allPages,
+          page: allPages,
+          active: false,
+          showTitle: props.showTitle,
+          itemRender: props.itemRender
+        });
+        firstPager = React__default.createElement(Pager, {
+          locale: props.locale,
+          rootPrefixCls: prefixCls,
+          onClick: this.handleChange,
+          onKeyPress: this.runIfEnter,
+          key: 1,
+          page: 1,
+          active: false,
+          showTitle: props.showTitle,
+          itemRender: props.itemRender
+        });
+
+        var left = Math.max(1, current - pageBufferSize);
+        var right = Math.min(current + pageBufferSize, allPages);
+
+        if (current - 1 <= pageBufferSize) {
+          right = 1 + pageBufferSize * 2;
+        }
+
+        if (allPages - current <= pageBufferSize) {
+          left = allPages - pageBufferSize * 2;
+        }
+
+        for (var _i = left; _i <= right; _i++) {
+          var _active = current === _i;
+          pagerList.push(React__default.createElement(Pager, {
+            locale: props.locale,
+            rootPrefixCls: prefixCls,
+            onClick: this.handleChange,
+            onKeyPress: this.runIfEnter,
+            key: _i,
+            page: _i,
+            active: _active,
+            showTitle: props.showTitle,
+            itemRender: props.itemRender
+          }));
+        }
+
+        if (current - 1 >= pageBufferSize * 2 && current !== 1 + 2) {
+          pagerList[0] = React__default.cloneElement(pagerList[0], {
+            className: prefixCls + '-item-after-jump-prev'
+          });
+          pagerList.unshift(jumpPrev);
+        }
+        if (allPages - current >= pageBufferSize * 2 && current !== allPages - 2) {
+          pagerList[pagerList.length - 1] = React__default.cloneElement(pagerList[pagerList.length - 1], {
+            className: prefixCls + '-item-before-jump-next'
+          });
+          pagerList.push(jumpNext);
+        }
+
+        if (left !== 1) {
+          pagerList.unshift(firstPager);
+        }
+        if (right !== allPages) {
+          pagerList.push(lastPager);
+        }
+      }
+
+      var totalText = null;
+
+      if (props.showTotal) {
+        totalText = React__default.createElement(
+          'li',
+          { className: prefixCls + '-total-text' },
+          props.showTotal(props.total, [props.total === 0 ? 0 : (current - 1) * pageSize + 1, current * pageSize > props.total ? props.total : current * pageSize])
+        );
+      }
+      var prevDisabled = !this.hasPrev() || !allPages;
+      var nextDisabled = !this.hasNext() || !allPages;
+      return React__default.createElement(
+        'ul',
+        _extends$2({
+          className: classNames(prefixCls, className, _defineProperty({}, prefixCls + '-disabled', disabled)),
+          style: props.style,
+          unselectable: 'unselectable',
+          ref: this.savePaginationNode
+        }, dataOrAriaAttributeProps),
+        totalText,
+        React__default.createElement(
+          'li',
+          {
+            title: props.showTitle ? locale.prev_page : null,
+            onClick: this.prev,
+            tabIndex: prevDisabled ? null : 0,
+            onKeyPress: this.runIfEnterPrev,
+            className: (!prevDisabled ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-prev',
+            'aria-disabled': prevDisabled
+          },
+          props.itemRender(prevPage, 'prev', this.getItemIcon(props.prevIcon))
+        ),
+        pagerList,
+        React__default.createElement(
+          'li',
+          {
+            title: props.showTitle ? locale.next_page : null,
+            onClick: this.next,
+            tabIndex: nextDisabled ? null : 0,
+            onKeyPress: this.runIfEnterNext,
+            className: (!nextDisabled ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-next',
+            'aria-disabled': nextDisabled
+          },
+          props.itemRender(nextPage, 'next', this.getItemIcon(props.nextIcon))
+        ),
+        React__default.createElement(Options, {
+          disabled: disabled,
+          locale: props.locale,
+          rootPrefixCls: prefixCls,
+          selectComponentClass: props.selectComponentClass,
+          selectPrefixCls: props.selectPrefixCls,
+          changeSize: this.props.showSizeChanger ? this.changePageSize : null,
+          current: this.state.current,
+          pageSize: this.state.pageSize,
+          pageSizeOptions: this.props.pageSizeOptions,
+          quickGo: this.shouldDisplayQuickJumper() ? this.handleChange : null,
+          goButton: goButton
+        })
+      );
+    }
+  }], [{
+    key: 'getDerivedStateFromProps',
+    value: function getDerivedStateFromProps(props, prevState) {
+      var newState = {};
+
+      if ('current' in props) {
+        newState.current = props.current;
+
+        if (props.current !== prevState.current) {
+          newState.currentInputValue = newState.current;
+        }
+      }
+
+      if ('pageSize' in props && props.pageSize !== prevState.pageSize) {
+        var current = prevState.current;
+        var newCurrent = calculatePage(props.pageSize, prevState, props);
+        current = current > newCurrent ? newCurrent : current;
+
+        if (!('current' in props)) {
+          newState.current = current;
+          newState.currentInputValue = current;
+        }
+        newState.pageSize = props.pageSize;
+      }
+
+      return newState;
+    }
+
+    /**
+     * computed icon node that need to be rendered.
+     * @param {React.ReactNode | React.ComponentType<PaginationProps>} icon received icon.
+     * @returns {React.ReactNode}
+     */
+
+  }]);
+
+  return Pagination;
+}(React__default.Component);
+
+Pagination$1.propTypes = {
+  disabled: PropTypes.bool,
+  prefixCls: PropTypes.string,
+  className: PropTypes.string,
+  current: PropTypes.number,
+  defaultCurrent: PropTypes.number,
+  total: PropTypes.number,
+  pageSize: PropTypes.number,
+  defaultPageSize: PropTypes.number,
+  onChange: PropTypes.func,
+  hideOnSinglePage: PropTypes.bool,
+  showSizeChanger: PropTypes.bool,
+  showLessItems: PropTypes.bool,
+  onShowSizeChange: PropTypes.func,
+  selectComponentClass: PropTypes.func,
+  showPrevNextJumpers: PropTypes.bool,
+  showQuickJumper: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
+  showTitle: PropTypes.bool,
+  pageSizeOptions: PropTypes.arrayOf(PropTypes.string),
+  showTotal: PropTypes.func,
+  locale: PropTypes.object,
+  style: PropTypes.object,
+  itemRender: PropTypes.func,
+  prevIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),
+  nextIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),
+  jumpPrevIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),
+  jumpNextIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.node])
+};
+Pagination$1.defaultProps = {
+  defaultCurrent: 1,
+  total: 0,
+  defaultPageSize: 10,
+  onChange: noop,
+  className: '',
+  selectPrefixCls: 'rc-select',
+  prefixCls: 'rc-pagination',
+  selectComponentClass: null,
+  hideOnSinglePage: false,
+  showPrevNextJumpers: true,
+  showQuickJumper: false,
+  showSizeChanger: false,
+  showLessItems: false,
+  showTitle: true,
+  onShowSizeChange: noop,
+  locale: Pagination$2,
+  style: {},
+  itemRender: defaultItemRender
+};
+
+var _initialiseProps = function _initialiseProps() {
+  var _this2 = this;
+
+  this.getJumpPrevPage = function () {
+    return Math.max(1, _this2.state.current - (_this2.props.showLessItems ? 3 : 5));
+  };
+
+  this.getJumpNextPage = function () {
+    return Math.min(calculatePage(undefined, _this2.state, _this2.props), _this2.state.current + (_this2.props.showLessItems ? 3 : 5));
+  };
+
+  this.getItemIcon = function (icon) {
+    var prefixCls = _this2.props.prefixCls;
+
+    var iconNode = icon || React__default.createElement('a', { className: prefixCls + '-item-link' });
+    if (typeof icon === 'function') {
+      iconNode = React__default.createElement(icon, _extends$2({}, _this2.props));
+    }
+    return iconNode;
+  };
+
+  this.savePaginationNode = function (node) {
+    _this2.paginationNode = node;
+  };
+
+  this.isValid = function (page) {
+    return isInteger(page) && page !== _this2.state.current;
+  };
+
+  this.shouldDisplayQuickJumper = function () {
+    var _props2 = _this2.props,
+        showQuickJumper = _props2.showQuickJumper,
+        pageSize = _props2.pageSize,
+        total = _props2.total;
+
+    if (total <= pageSize) {
+      return false;
+    }
+    return showQuickJumper;
+  };
+
+  this.handleKeyDown = function (e) {
+    if (e.keyCode === KEYCODE.ARROW_UP || e.keyCode === KEYCODE.ARROW_DOWN) {
+      e.preventDefault();
+    }
+  };
+
+  this.handleKeyUp = function (e) {
+    var value = _this2.getValidValue(e);
+    var currentInputValue = _this2.state.currentInputValue;
+
+    if (value !== currentInputValue) {
+      _this2.setState({
+        currentInputValue: value
+      });
+    }
+    if (e.keyCode === KEYCODE.ENTER) {
+      _this2.handleChange(value);
+    } else if (e.keyCode === KEYCODE.ARROW_UP) {
+      _this2.handleChange(value - 1);
+    } else if (e.keyCode === KEYCODE.ARROW_DOWN) {
+      _this2.handleChange(value + 1);
+    }
+  };
+
+  this.changePageSize = function (size) {
+    var current = _this2.state.current;
+    var newCurrent = calculatePage(size, _this2.state, _this2.props);
+    current = current > newCurrent ? newCurrent : current;
+    // fix the issue:
+    // Once 'total' is 0, 'current' in 'onShowSizeChange' is 0, which is not correct.
+    if (newCurrent === 0) {
+      current = _this2.state.current;
+    }
+
+    if (typeof size === 'number') {
+      if (!('pageSize' in _this2.props)) {
+        _this2.setState({
+          pageSize: size
+        });
+      }
+      if (!('current' in _this2.props)) {
+        _this2.setState({
+          current: current,
+          currentInputValue: current
+        });
+      }
+    }
+    _this2.props.onShowSizeChange(current, size);
+  };
+
+  this.handleChange = function (p) {
+    var disabled = _this2.props.disabled;
+
+
+    var page = p;
+    if (_this2.isValid(page) && !disabled) {
+      var currentPage = calculatePage(undefined, _this2.state, _this2.props);
+      if (page > currentPage) {
+        page = currentPage;
+      } else if (page < 1) {
+        page = 1;
+      }
+
+      if (!('current' in _this2.props)) {
+        _this2.setState({
+          current: page,
+          currentInputValue: page
+        });
+      }
+
+      var pageSize = _this2.state.pageSize;
+      _this2.props.onChange(page, pageSize);
+
+      return page;
+    }
+
+    return _this2.state.current;
+  };
+
+  this.prev = function () {
+    if (_this2.hasPrev()) {
+      _this2.handleChange(_this2.state.current - 1);
+    }
+  };
+
+  this.next = function () {
+    if (_this2.hasNext()) {
+      _this2.handleChange(_this2.state.current + 1);
+    }
+  };
+
+  this.jumpPrev = function () {
+    _this2.handleChange(_this2.getJumpPrevPage());
+  };
+
+  this.jumpNext = function () {
+    _this2.handleChange(_this2.getJumpNextPage());
+  };
+
+  this.hasPrev = function () {
+    return _this2.state.current > 1;
+  };
+
+  this.hasNext = function () {
+    return _this2.state.current < calculatePage(undefined, _this2.state, _this2.props);
+  };
+
+  this.runIfEnter = function (event, callback) {
+    for (var _len = arguments.length, restParams = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      restParams[_key - 2] = arguments[_key];
+    }
+
+    if (event.key === 'Enter' || event.charCode === 13) {
+      callback.apply(undefined, restParams);
+    }
+  };
+
+  this.runIfEnterPrev = function (e) {
+    _this2.runIfEnter(e, _this2.prev);
+  };
+
+  this.runIfEnterNext = function (e) {
+    _this2.runIfEnter(e, _this2.next);
+  };
+
+  this.runIfEnterJumpPrev = function (e) {
+    _this2.runIfEnter(e, _this2.jumpPrev);
+  };
+
+  this.runIfEnterJumpNext = function (e) {
+    _this2.runIfEnter(e, _this2.jumpNext);
+  };
+
+  this.handleGoTO = function (e) {
+    if (e.keyCode === KEYCODE.ENTER || e.type === 'click') {
+      _this2.handleChange(_this2.state.currentInputValue);
+    }
+  };
+};
+
+polyfill(Pagination$1);
+
+function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+
+function _extends$1() { _extends$1 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$1.apply(this, arguments); }
+
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1(subClass, superClass); }
+
+function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); }
+
+function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf$1(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1(this, result); }; }
+
+function _possibleConstructorReturn$1(self, call) { if (call && (_typeof$1(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1(self); }
+
+function _assertThisInitialized$1(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf$1(o) { _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1(o); }
+
+var MiniSelect = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(MiniSelect, _React$Component);
+
+  var _super = _createSuper$1(MiniSelect);
+
+  function MiniSelect() {
+    _classCallCheck$1(this, MiniSelect);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass$1(MiniSelect, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(Select, _extends$1({
+        size: "small"
+      }, this.props));
+    }
+  }]);
+
+  return MiniSelect;
+}(React.Component);
+MiniSelect.Option = Select.Option;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var __rest = undefined && undefined.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var Pagination = /*#__PURE__*/function (_React$Component) {
+  _inherits(Pagination, _React$Component);
+
+  var _super = _createSuper(Pagination);
+
+  function Pagination() {
+    var _this;
+
+    _classCallCheck(this, Pagination);
+
+    _this = _super.apply(this, arguments);
+
+    _this.getIconsProps = function (prefixCls) {
+      var prevIcon = /*#__PURE__*/React.createElement("a", {
+        className: "".concat(prefixCls, "-item-link")
+      }, /*#__PURE__*/React.createElement(Icon, {
+        type: "left"
+      }));
+      var nextIcon = /*#__PURE__*/React.createElement("a", {
+        className: "".concat(prefixCls, "-item-link")
+      }, /*#__PURE__*/React.createElement(Icon, {
+        type: "right"
+      }));
+      var jumpPrevIcon = /*#__PURE__*/React.createElement("a", {
+        className: "".concat(prefixCls, "-item-link")
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-item-container")
+      }, /*#__PURE__*/React.createElement(Icon, {
+        className: "".concat(prefixCls, "-item-link-icon"),
+        type: "double-left"
+      }), /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-item-ellipsis")
+      }, "\u2022\u2022\u2022")));
+      var jumpNextIcon = /*#__PURE__*/React.createElement("a", {
+        className: "".concat(prefixCls, "-item-link")
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "".concat(prefixCls, "-item-container")
+      }, /*#__PURE__*/React.createElement(Icon, {
+        className: "".concat(prefixCls, "-item-link-icon"),
+        type: "double-right"
+      }), /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-item-ellipsis")
+      }, "\u2022\u2022\u2022")));
+      return {
+        prevIcon: prevIcon,
+        nextIcon: nextIcon,
+        jumpPrevIcon: jumpPrevIcon,
+        jumpNextIcon: jumpNextIcon
+      };
+    };
+
+    _this.renderPagination = function (contextLocale) {
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          customizeSelectPrefixCls = _a.selectPrefixCls,
+          className = _a.className,
+          size = _a.size,
+          customLocale = _a.locale,
+          restProps = __rest(_a, ["prefixCls", "selectPrefixCls", "className", "size", "locale"]);
+
+      var locale = _extends(_extends({}, contextLocale), customLocale);
+
+      var isSmall = size === 'small';
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, function (_ref) {
+        var getPrefixCls = _ref.getPrefixCls;
+        var prefixCls = getPrefixCls('pagination', customizePrefixCls);
+        var selectPrefixCls = getPrefixCls('select', customizeSelectPrefixCls);
+        return /*#__PURE__*/React.createElement(Pagination$1, _extends({}, restProps, {
+          prefixCls: prefixCls,
+          selectPrefixCls: selectPrefixCls
+        }, _this.getIconsProps(prefixCls), {
+          className: classNames(className, {
+            mini: isSmall
+          }),
+          selectComponentClass: isSmall ? MiniSelect : Select,
+          locale: locale
+        }));
+      });
+    };
+
+    return _this;
+  }
+
+  _createClass(Pagination, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(LocaleReceiver, {
+        componentName: "Pagination",
+        defaultLocale: Pagination$3
+      }, this.renderPagination);
+    }
+  }]);
+
+  return Pagination;
+}(React.Component);
+
+export { Pagination as P };