redux-paginator-immutable/lib/LoadPaginator.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _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; };
// /* eslint-disable no-unused-vars */

var _react = require("react");

var _react2 = _interopRequireDefault(_react);

var _immutable = require("immutable");

var Immutable = _interopRequireWildcard(_immutable);

var _reactRedux = require("react-redux");

var _redux = require("redux");

var _selectors = require("./selectors");

var _selectors2 = _interopRequireDefault(_selectors);

var _LoadingButton = require("./LoadingButton");

var _LoadingButton2 = _interopRequireDefault(_LoadingButton);

var _Messages = require("x25/Messages");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var mapStateToProps = function mapStateToProps(state, _ref) {
  var token = _ref.token,
      settings = _ref.settings;

  var _selectors$getPaginat = _selectors2.default.getPaginators(state, settings.key),
      list = _selectors$getPaginat.list,
      entities = _selectors$getPaginat.entities;

  var currentPage = _selectors2.default.getCurrentView(list, token),
      isFetching = _selectors2.default.isPageFetching(list, token, currentPage),
      isFetched = _selectors2.default.isPageFetched(list, token, currentPage),
      isNextFetching = _selectors2.default.isPageFetching(list, token, currentPage + 1),
      isNextFetched = _selectors2.default.isPageFetched(list, token, currentPage + 1),
      resultsUpTo = _selectors2.default.getResultsUpToPage(list, token, entities, currentPage, settings.rowsPerLoad),
      items = settings.manipulateItems(resultsUpTo),
      total = _selectors2.default.getCurrentTotalResultsCount(list, token),
      hasProblems = _selectors2.default.hasPageProblems(list, token, currentPage);

  var shouldLoadNext = !isNextFetched && !isNextFetching;

  return {
    paginator: Immutable.Map({
      currentPage: currentPage,
      hasProblems: hasProblems,
      isFetched: isFetched,
      isFetching: isFetching,
      items: items,
      shouldLoadNext: shouldLoadNext,
      total: total
    })
  };
},
    mapDispatchToProps = function mapDispatchToProps(dispatch, _ref2) {
  var token = _ref2.token,
      settings = _ref2.settings;
  return _extends({}, (0, _redux.bindActionCreators)({
    resetView: settings.resetView,
    changeView: settings.changeView
  }, dispatch), {
    loadData: function loadData(page) {
      dispatch(settings.requestPage(page, token));
    }
  });
};

var LoadPaginator = function (_Component) {
  _inherits(LoadPaginator, _Component);

  function LoadPaginator(props) {
    _classCallCheck(this, LoadPaginator);

    var _this = _possibleConstructorReturn(this, (LoadPaginator.__proto__ || Object.getPrototypeOf(LoadPaginator)).call(this, props));

    _this.handleLoadMoreClick = function () {
      var _this$props = _this.props,
          paginator = _this$props.paginator,
          token = _this$props.token,
          changeView = _this$props.changeView,
          loadData = _this$props.loadData;


      var currentPage = paginator.get("currentPage"),
          hasProblems = paginator.get("hasProblems"),
          shouldLoadNext = paginator.get("shouldLoadNext");

      if (hasProblems) {
        loadData(currentPage);
      } else {
        changeView({
          token: token,
          view: currentPage + 1
        });

        if (shouldLoadNext) {
          loadData(currentPage + 1);
        }
      }
    };
    return _this;
  }

  _createClass(LoadPaginator, [{
    key: "UNSAFE_componentWillMount",
    value: function UNSAFE_componentWillMount() {
      var _props = this.props,
          paginator = _props.paginator,
          loadData = _props.loadData;


      var isFetched = paginator.get("isFetched"),
          isFetching = paginator.get("isFetching"),
          currentPage = paginator.get("currentPage");

      var shouldFetch = !isFetched && !isFetching;

      if (shouldFetch) {
        loadData(currentPage);
      }
    }
  }, {
    key: "UNSAFE_componentWillReceiveProps",
    value: function UNSAFE_componentWillReceiveProps(nextProps) {
      var loadData = nextProps.loadData,
          paginator = nextProps.paginator;


      var isFetched = paginator.get("isFetched"),
          isFetching = paginator.get("isFetching"),
          currentPage = paginator.get("currentPage");

      var shouldFetch = !isFetched && !isFetching;

      if (shouldFetch) {
        loadData(currentPage);
      }
    }
  }, {
    key: "shouldComponentUpdate",
    value: function shouldComponentUpdate(nextProps) {
      return this.props.paginator !== nextProps.paginator;
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.props.resetView(this.props.token);
    }
  }, {
    key: "render",
    value: function render() {
      var paginator = this.props.paginator;


      var items = paginator.get("items"),
          hasProblems = paginator.get("hasProblems"),
          currentPage = paginator.get("currentPage"),
          isFetching = paginator.get("isFetching"),
          total = paginator.get("total");

      var isEmpty = items.size === 0,
          showLoading = total !== items.size;

      if (isEmpty && isFetching) {
        return _react2.default.createElement(_Messages.LoadingMessage, { message: "Preiau datele..." });
      }

      if (hasProblems && currentPage === 1) {
        return _react2.default.createElement(_Messages.LargeErrorMessage, {
          message: "Nu pot prelua datele",
          onRetry: this.handleLoadMoreClick
        });
      }

      return _react2.default.createElement(
        _react2.default.Fragment,
        null,
        _react2.default.cloneElement(this.props.children, this.props),
        showLoading ? _react2.default.createElement(_LoadingButton2.default, {
          hasProblems: hasProblems,
          isFetching: isFetching,
          onLoadMoreClick: this.handleLoadMoreClick
        }) : null
      );
    }
  }]);

  return LoadPaginator;
}(_react.Component);

exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(LoadPaginator);