choerodon-ui/pro/lib/tree/index.js

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

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultRenderer = defaultRenderer;
exports["default"] = void 0;

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _tslib = require("tslib");

var _set = _interopRequireDefault(require("core-js/library/fn/set"));

var _react = _interopRequireWildcard(require("react"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _mobxReact = require("mobx-react");

var _mobx = require("mobx");

var _noop = _interopRequireDefault(require("lodash/noop"));

var _tree = _interopRequireWildcard(require("../../../lib/tree"));

var _autobind = _interopRequireDefault(require("../_util/autobind"));

var _util = require("./util");

var _enum = require("../data-set/enum");

var _spin = _interopRequireDefault(require("../spin"));

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 = (0, _getPrototypeOf2["default"])(Derived),
        result;

    if (isNativeReflectConstruct()) {
      var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor;
      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return (0, _possibleConstructorReturn2["default"])(this, result);
  };
}

function defaultRenderer(_ref) {
  var text = _ref.text;
  return text;
}

function defaultNodeCover() {
  return {};
}

var keyPropType = _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]);

var Tree =
/*#__PURE__*/
function (_Component) {
  (0, _inherits2["default"])(Tree, _Component);

  var _super = _createSuper(Tree);

  function Tree(props, context) {
    var _this;

    (0, _classCallCheck2["default"])(this, Tree);
    _this = _super.call(this, props, context);
    _this.stateForceRenderKeys = [];
    (0, _mobx.runInAction)(function () {
      _this.stateCheckedKeys = [];
      _this.stateExpandedKeys = [];
    });
    return _this;
  }

  (0, _createClass2["default"])(Tree, [{
    key: "componentWillMount",
    value: function componentWillMount() {
      this.handleDataSetLoad();
      this.processDataSetListener(true);
    }
  }, {
    key: "componentWillReceiveProps",
    value: function componentWillReceiveProps(nextProps) {
      var _this$props = this.props,
          defaultExpandAll = _this$props.defaultExpandAll,
          defaultSelectedKeys = _this$props.defaultSelectedKeys,
          defaultExpandedKeys = _this$props.defaultExpandedKeys,
          defaultCheckedKeys = _this$props.defaultCheckedKeys;

      if (defaultExpandAll !== nextProps.defaultExpandAll || defaultExpandedKeys !== nextProps.defaultExpandedKeys || defaultCheckedKeys !== nextProps.defaultCheckKeys || defaultSelectedKeys !== nextProps.defaultSelectedKeys) {
        this.processDataSetListener(false);
        this.processDataSetListener(true);
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.processDataSetListener(false);
    }
  }, {
    key: "processDataSetListener",
    value: function processDataSetListener(flag) {
      var dataSet = this.props.dataSet;

      if (dataSet) {
        var handler = flag ? dataSet.addEventListener : dataSet.removeEventListener;
        handler.call(dataSet, 'load', this.handleDataSetLoad);
      }
    }
  }, {
    key: "handleDataSetLoad",
    value: function handleDataSetLoad() {
      this.initDefaultExpandedRows();
      this.initDefaultCheckRows();
      this.initDefaultSelectRows();
    }
  }, {
    key: "initDefaultExpandedRows",
    value: function initDefaultExpandedRows() {
      var _this$props2 = this.props,
          defaultExpandAll = _this$props2.defaultExpandAll,
          dataSet = _this$props2.dataSet,
          defaultExpandedKeys = _this$props2.defaultExpandedKeys;
      this.stateExpandedKeys = this.dealDefalutCheckExpand(dataSet, defaultExpandedKeys, defaultExpandAll);
    }
  }, {
    key: "initDefaultCheckRows",
    value: function initDefaultCheckRows() {
      var _this$props3 = this.props,
          dataSet = _this$props3.dataSet,
          defaultCheckedKeys = _this$props3.defaultCheckedKeys;
      this.stateCheckedKeys = this.dealDefalutCheckExpand(dataSet, defaultCheckedKeys);
    }
  }, {
    key: "initDefaultSelectRows",
    value: function initDefaultSelectRows() {
      var _this$props4 = this.props,
          dataSet = _this$props4.dataSet,
          defaultSelectedKeys = _this$props4.defaultSelectedKeys;

      if (dataSet && defaultSelectedKeys) {
        var idField = dataSet.props.idField;
        defaultSelectedKeys.map(function (selectKey) {
          var found = dataSet.find(function (record) {
            return selectKey === String(idField ? record.get(idField) : record.id);
          });

          if (found) {
            dataSet.select(found);
          }

          return null;
        });
      }
    }
    /**
     * 处理tree的props expand check的默认事件
     * @param dataSet
     * @param defalutAll
     * @param defalutKeys
     */

  }, {
    key: "dealDefalutCheckExpand",
    value: function dealDefalutCheckExpand(dataSet, defalutKeys, defalutAll) {
      var defalutStateKeys = [];

      if (dataSet) {
        var _dataSet$props = dataSet.props,
            idField = _dataSet$props.idField,
            expandField = _dataSet$props.expandField;

        if (defalutAll && !expandField) {
          defalutStateKeys = dataSet.reduce(function (array, record) {
            if (record.children) {
              array.push((0, _util.getKey)(record, idField));
            }

            return array;
          }, []);
        } else if (defalutKeys && !expandField) {
          defalutStateKeys = dataSet.reduce(function (array, record) {
            defalutKeys.map(function (key) {
              if ((0, _util.getKey)(record, idField) === key) {
                array.push(key);
              }

              return null;
            });
            return array;
          }, []);
        }
      }

      return defalutStateKeys;
    }
  }, {
    key: "setExpand",
    value: function setExpand(eventObj) {
      var dataSet = this.props.dataSet;

      if (dataSet) {
        var _dataSet$props2 = dataSet.props,
            expandField = _dataSet$props2.expandField,
            idField = _dataSet$props2.idField;

        if (expandField) {
          var node = eventObj.node,
              expanded = eventObj.expanded;
          var eventKey = node.eventKey;
          var found = dataSet.find(function (record) {
            return eventKey === (0, _util.getKey)(record, idField);
          });

          if (found) {
            found.isExpanded = !!expanded;
            return false;
          }
        }
      }

      return true;
    }
  }, {
    key: "setCheck",
    value: function setCheck(eventObj) {
      var dataSet = this.props.dataSet;

      if (dataSet) {
        var _dataSet$props3 = dataSet.props,
            checkField = _dataSet$props3.checkField,
            idField = _dataSet$props3.idField;

        if (checkField) {
          var node = eventObj.node,
              checked = eventObj.checked;
          var eventKey = node.eventKey;
          var found = dataSet.find(function (record) {
            return eventKey === String(idField ? record.get(idField) : record.id);
          });

          if (found) {
            var field = found.getField(checkField);
            found.set(checkField, field ? checked ? field.get(_enum.BooleanValue.trueValue) : field.get(_enum.BooleanValue.falseValue) : checked);
            return false;
          }
        }
      }

      return true;
    }
  }, {
    key: "handleExpand",
    value: function handleExpand(expandedKeys, eventObj) {
      var _this2 = this;

      if (this.setExpand(eventObj)) {
        (0, _mobx.runInAction)(function () {
          _this2.stateExpandedKeys = expandedKeys;
        });
      }

      var _this$props$onExpand = this.props.onExpand,
          onExpand = _this$props$onExpand === void 0 ? _noop["default"] : _this$props$onExpand; // @ts-ignore

      onExpand(expandedKeys, eventObj);
    }
  }, {
    key: "handleCheck",
    value: function handleCheck(checkedKeys, eventObj) {
      var _this3 = this;

      if (this.setCheck(eventObj)) {
        (0, _mobx.runInAction)(function () {
          _this3.stateCheckedKeys = checkedKeys;
        });
      }

      var _this$props$onCheck = this.props.onCheck,
          onCheck = _this$props$onCheck === void 0 ? _noop["default"] : _this$props$onCheck;
      onCheck(checkedKeys, eventObj);
    }
  }, {
    key: "handleSelect",
    value: function handleSelect(selectedKeys, eventObj) {
      var _this$props5 = this.props,
          dataSet = _this$props5.dataSet,
          _this$props5$onSelect = _this$props5.onSelect,
          onSelect = _this$props5$onSelect === void 0 ? _noop["default"] : _this$props5$onSelect;

      if (dataSet) {
        var idField = dataSet.props.idField;
        var node = eventObj.node,
            selected = eventObj.selected;
        var eventKey = node.eventKey;
        var found = dataSet.find(function (record) {
          return eventKey === String(idField ? record.get(idField) : record.id);
        });

        if (found) {
          if (selected) {
            dataSet.select(found);
          } else {
            dataSet.unSelect(found);
          }
        }

        onSelect(selectedKeys, eventObj);
      }
    }
  }, {
    key: "handleLoadData",
    value: function handleLoadData(event) {
      var _this$props6 = this.props,
          dataSet = _this$props6.dataSet,
          loadData = _this$props6.loadData;
      var promises = [];

      if (dataSet) {
        var _dataSet$props4 = dataSet.props,
            idField = _dataSet$props4.idField,
            parentField = _dataSet$props4.parentField;
        var record = event.props.record;

        if (idField && parentField && record && !record.children) {
          var id = record.get(idField);
          promises.push(dataSet.queryMore(-1, (0, _defineProperty2["default"])({}, parentField, id)));
        }
      }

      if (loadData) {
        promises.push(loadData(event));
      }

      return Promise.all(promises);
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props7 = this.props,
          dataSet = _this$props7.dataSet,
          _this$props7$renderer = _this$props7.renderer,
          renderer = _this$props7$renderer === void 0 ? defaultRenderer : _this$props7$renderer,
          titleField = _this$props7.titleField,
          treeNodeRenderer = _this$props7.treeNodeRenderer,
          onTreeNode = _this$props7.onTreeNode,
          loadData = _this$props7.loadData,
          async = _this$props7.async,
          otherProps = (0, _objectWithoutProperties2["default"])(_this$props7, ["dataSet", "renderer", "titleField", "treeNodeRenderer", "onTreeNode", "loadData", "async"]);

      if (dataSet) {
        var defaultExpandAll = otherProps.defaultExpandAll;
        var props = {};
        props.treeData = (0, _util.getTreeNodes)(dataSet, dataSet.treeData, defaultExpandAll ? [] : this.forceRenderKeys, renderer, // @ts-ignore
        onTreeNode || treeNodeRenderer || defaultNodeCover, async || !!loadData, titleField, defaultExpandAll) || []; // @ts-ignore

        props.onExpand = this.handleExpand; // @ts-ignore

        props.onCheck = this.handleCheck; // @ts-ignore

        props.onSelect = this.handleSelect;

        if (async) {
          props.loadData = this.handleLoadData;
        } else {
          props.loadData = loadData;
        }

        props.expandedKeys = this.expandedKeys.slice();

        if (!('checkedKeys' in otherProps)) {
          props.checkedKeys = this.checkedKeys.slice();
        }

        if (!('multiple' in otherProps)) {
          props.multiple = dataSet.props.selection === _enum.DataSetSelection.multiple;
        }

        if (!('selectedKeys' in otherProps)) {
          props.selectedKeys = this.selectedKeys.slice();
        }

        return _react["default"].createElement(_spin["default"], {
          dataSet: dataSet
        }, _react["default"].createElement(_tree["default"], (0, _extends2["default"])({}, otherProps, props)));
      }

      return _react["default"].createElement(_tree["default"], (0, _extends2["default"])({}, otherProps));
    }
  }, {
    key: "forceRenderKeys",
    get: function get() {
      return this.stateForceRenderKeys = (0, _toConsumableArray2["default"])(new _set["default"]([].concat((0, _toConsumableArray2["default"])(this.stateForceRenderKeys), (0, _toConsumableArray2["default"])(this.expandedKeys))));
    }
  }, {
    key: "expandedKeys",
    get: function get() {
      var dataSet = this.props.dataSet;

      if (dataSet) {
        var _dataSet$props5 = dataSet.props,
            expandField = _dataSet$props5.expandField,
            idField = _dataSet$props5.idField;

        if (expandField) {
          var keys = [];
          dataSet.forEach(function (record) {
            if (record.isExpanded) {
              keys.push((0, _util.getKey)(record, idField));
            }
          });
          return keys;
        }
      }

      return this.stateExpandedKeys;
    }
  }, {
    key: "checkedKeys",
    get: function get() {
      var dataSet = this.props.dataSet;

      if (dataSet) {
        var _dataSet$props6 = dataSet.props,
            checkField = _dataSet$props6.checkField,
            idField = _dataSet$props6.idField;

        if (checkField) {
          var keys = [];
          dataSet.forEach(function (record) {
            var field = record.getField(checkField);

            if (record.get(checkField) === (field ? field.get(_enum.BooleanValue.trueValue) : true)) {
              keys.push((0, _util.getKey)(record, idField));
            }
          });
          return keys;
        }
      }

      return this.stateCheckedKeys;
    }
  }, {
    key: "selectedKeys",
    get: function get() {
      var dataSet = this.props.dataSet;

      if (dataSet) {
        var idField = dataSet.props.idField;
        return dataSet.selected.map(function (record) {
          return (0, _util.getKey)(record, idField);
        });
      }

      return [];
    }
  }]);
  return Tree;
}(_react.Component);

Tree.displayName = 'Tree<PRO>';
Tree.propTypes = {
  prefixCls: _propTypes["default"].string,
  className: _propTypes["default"].string,
  style: _propTypes["default"].object,
  tabIndex: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number]),
  children: _propTypes["default"].any,
  treeData: _propTypes["default"].array,
  showLine: _propTypes["default"].bool,
  showIcon: _propTypes["default"].bool,
  icon: _propTypes["default"].oneOfType([_propTypes["default"].node, _propTypes["default"].func]),
  selectable: _propTypes["default"].bool,
  disabled: _propTypes["default"].bool,
  multiple: _propTypes["default"].bool,
  checkable: _propTypes["default"].oneOfType([_propTypes["default"].bool, _propTypes["default"].node]),
  checkStrictly: _propTypes["default"].bool,
  draggable: _propTypes["default"].bool,
  defaultExpandParent: _propTypes["default"].bool,
  autoExpandParent: _propTypes["default"].bool,
  defaultExpandAll: _propTypes["default"].bool,
  defaultExpandedKeys: _propTypes["default"].arrayOf(keyPropType),
  expandedKeys: _propTypes["default"].arrayOf(keyPropType),
  defaultCheckedKeys: _propTypes["default"].arrayOf(keyPropType),
  checkedKeys: _propTypes["default"].oneOfType([_propTypes["default"].arrayOf(keyPropType), _propTypes["default"].object]),
  defaultSelectedKeys: _propTypes["default"].arrayOf(keyPropType),
  selectedKeys: _propTypes["default"].arrayOf(keyPropType),
  onClick: _propTypes["default"].func,
  onDoubleClick: _propTypes["default"].func,
  onExpand: _propTypes["default"].func,
  onCheck: _propTypes["default"].func,
  onSelect: _propTypes["default"].func,
  onLoad: _propTypes["default"].func,
  loadData: _propTypes["default"].func,
  loadedKeys: _propTypes["default"].arrayOf(keyPropType),
  onMouseEnter: _propTypes["default"].func,
  onMouseLeave: _propTypes["default"].func,
  onRightClick: _propTypes["default"].func,
  onDragStart: _propTypes["default"].func,
  onDragEnter: _propTypes["default"].func,
  onDragOver: _propTypes["default"].func,
  onDragLeave: _propTypes["default"].func,
  onDragEnd: _propTypes["default"].func,
  onDrop: _propTypes["default"].func,
  filterTreeNode: _propTypes["default"].func,
  motion: _propTypes["default"].object,
  switcherIcon: _propTypes["default"].oneOfType([_propTypes["default"].node, _propTypes["default"].func])
};
Tree.TreeNode = _tree.TreeNode;
(0, _tslib.__decorate)([_mobx.observable], Tree.prototype, "stateCheckedKeys", void 0);
(0, _tslib.__decorate)([_mobx.observable], Tree.prototype, "stateExpandedKeys", void 0);
(0, _tslib.__decorate)([_autobind["default"]], Tree.prototype, "handleDataSetLoad", null);
(0, _tslib.__decorate)([_mobx.action], Tree.prototype, "initDefaultExpandedRows", null);
(0, _tslib.__decorate)([_mobx.action], Tree.prototype, "initDefaultCheckRows", null);
(0, _tslib.__decorate)([_mobx.action], Tree.prototype, "initDefaultSelectRows", null);
(0, _tslib.__decorate)([_mobx.computed], Tree.prototype, "forceRenderKeys", null);
(0, _tslib.__decorate)([_mobx.computed], Tree.prototype, "expandedKeys", null);
(0, _tslib.__decorate)([_mobx.computed], Tree.prototype, "checkedKeys", null);
(0, _tslib.__decorate)([_mobx.computed], Tree.prototype, "selectedKeys", null);
(0, _tslib.__decorate)([_autobind["default"]], Tree.prototype, "handleExpand", null);
(0, _tslib.__decorate)([_autobind["default"]], Tree.prototype, "handleCheck", null);
(0, _tslib.__decorate)([_autobind["default"]], Tree.prototype, "handleSelect", null);
(0, _tslib.__decorate)([_autobind["default"]], Tree.prototype, "handleLoadData", null);
Tree = (0, _tslib.__decorate)([_mobxReact.observer], Tree);
var _default = Tree;
exports["default"] = _default;
//# sourceMappingURL=index.js.map