choerodon-ui/pro/es/performance-table/SelectionCheckboxAll.js

An enterprise-class UI design language and React-based implementation

import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _inherits from "@babel/runtime/helpers/inherits";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";

function _createSuper(Derived) {
  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;
    }
  }

  return function () {
    var Super = _getPrototypeOf(Derived),
        result;

    if (isNativeReflectConstruct()) {
      var NewTarget = _getPrototypeOf(this).constructor;

      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return _possibleConstructorReturn(this, result);
  };
}

import { __decorate } from "tslib";
import * as React from 'react';
import classNames from 'classnames';
import { polyfill } from 'react-lifecycles-compat';
import { observer } from 'mobx-react';
import Checkbox from '../../../es/checkbox';
import Dropdown from '../dropdown';
import Menu from '../menu';
import Icon from '../icon';

function checkSelection(_ref) {
  var store = _ref.store,
      getCheckboxPropsByItem = _ref.getCheckboxPropsByItem,
      getRecordKey = _ref.getRecordKey,
      data = _ref.data,
      type = _ref.type,
      byDefaultChecked = _ref.byDefaultChecked;
  return byDefaultChecked ? data[type](function (item, i) {
    return getCheckboxPropsByItem(item, i).defaultChecked;
  }) : data[type](function (item, i) {
    return store.selectedRowKeys.indexOf(getRecordKey(item, i)) >= 0;
  });
}

function getIndeterminateState(props) {
  var store = props.store,
      data = props.data;

  if (!data.length) {
    return false;
  }

  var someCheckedNotByDefaultChecked = checkSelection(_objectSpread({}, props, {
    data: data,
    type: 'some',
    byDefaultChecked: false
  })) && !checkSelection(_objectSpread({}, props, {
    data: data,
    type: 'every',
    byDefaultChecked: false
  }));
  var someCheckedByDefaultChecked = checkSelection(_objectSpread({}, props, {
    data: data,
    type: 'some',
    byDefaultChecked: true
  })) && !checkSelection(_objectSpread({}, props, {
    data: data,
    type: 'every',
    byDefaultChecked: true
  }));

  if (store.selectionDirty) {
    return someCheckedNotByDefaultChecked;
  }

  return someCheckedNotByDefaultChecked || someCheckedByDefaultChecked;
}

function getCheckState(props) {
  var store = props.store,
      data = props.data;

  if (!data.length) {
    return false;
  }

  if (store.selectionDirty) {
    return checkSelection(_objectSpread({}, props, {
      data: data,
      type: 'every',
      byDefaultChecked: false
    }));
  }

  return checkSelection(_objectSpread({}, props, {
    data: data,
    type: 'every',
    byDefaultChecked: false
  })) || checkSelection(_objectSpread({}, props, {
    data: data,
    type: 'every',
    byDefaultChecked: true
  }));
}

var SelectionCheckboxAll =
/*#__PURE__*/
function (_React$Component) {
  _inherits(SelectionCheckboxAll, _React$Component);

  var _super = _createSuper(SelectionCheckboxAll);

  function SelectionCheckboxAll(props) {
    var _this;

    _classCallCheck(this, SelectionCheckboxAll);

    _this = _super.call(this, props);

    _this.handleSelectAllChange = function (e) {
      var checked = e.target.checked;

      _this.props.onSelect(checked ? 'all' : 'removeAll', 0, null);
    };

    _this.defaultSelections = props.hideDefaultSelections ? [] : [{
      key: 'all',
      text: 'SelectAll'
    }, {
      key: 'invert',
      text: 'SelectInvert'
    }];
    return _this;
  }

  _createClass(SelectionCheckboxAll, [{
    key: "setCheckState",
    value: function setCheckState(props) {
      var checked = getCheckState(props);
      var indeterminate = getIndeterminateState(props);
      this.setState(function (prevState) {
        var newState = {};

        if (indeterminate !== prevState.indeterminate) {
          newState.indeterminate = indeterminate;
        }

        if (checked !== prevState.checked) {
          newState.checked = checked;
        }

        return newState;
      });
    }
  }, {
    key: "renderMenus",
    value: function renderMenus(selections) {
      var _this2 = this;

      return selections.map(function (selection, index) {
        return React.createElement(Menu.Item, {
          key: selection.key || index
        }, React.createElement("div", {
          onClick: function onClick() {
            _this2.props.onSelect(selection.key, index, selection.onSelect);
          }
        }, selection.text));
      });
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props = this.props,
          disabled = _this$props.disabled,
          prefixCls = _this$props.prefixCls,
          selections = _this$props.selections;
      var checked = getCheckState(this.props);
      var indeterminate = getIndeterminateState(this.props);
      var selectionPrefixCls = "".concat(prefixCls, "-selection");
      var customSelections = null;

      if (selections) {
        var newSelections = Array.isArray(selections) ? this.defaultSelections.concat(selections) : this.defaultSelections;
        var menu = React.createElement(Menu, {
          className: "".concat(selectionPrefixCls, "-menu"),
          selectedKeys: []
        }, this.renderMenus(newSelections));
        customSelections = newSelections.length > 0 ? React.createElement(Dropdown, {
          overlay: menu
        }, React.createElement("div", {
          className: "".concat(selectionPrefixCls, "-down")
        }, React.createElement(Icon, {
          type: "down"
        }))) : null;
      }

      return React.createElement("div", {
        className: selectionPrefixCls
      }, React.createElement(Checkbox, {
        className: classNames(_defineProperty({}, "".concat(selectionPrefixCls, "-select-all-custom"), customSelections)),
        checked: checked,
        indeterminate: indeterminate,
        disabled: disabled,
        onChange: this.handleSelectAllChange
      }), customSelections);
    }
  }]);

  return SelectionCheckboxAll;
}(React.Component);

SelectionCheckboxAll = __decorate([observer], SelectionCheckboxAll);
polyfill(SelectionCheckboxAll);
export default SelectionCheckboxAll;
//# sourceMappingURL=SelectionCheckboxAll.js.map