polestar-ui-kit/lib/Tree/Tree.js

## Install

"use strict";

require("core-js/modules/es.array.concat");

require("core-js/modules/es.array.filter");

require("core-js/modules/es.array.find");

require("core-js/modules/es.array.for-each");

require("core-js/modules/es.array.index-of");

require("core-js/modules/es.array.is-array");

require("core-js/modules/es.array.map");

require("core-js/modules/es.array.some");

require("core-js/modules/es.date.to-string");

require("core-js/modules/es.object.get-prototype-of");

require("core-js/modules/es.object.keys");

require("core-js/modules/es.object.set-prototype-of");

require("core-js/modules/es.object.to-string");

require("core-js/modules/es.promise");

require("core-js/modules/es.reflect.construct");

require("core-js/modules/es.regexp.exec");

require("core-js/modules/es.regexp.to-string");

require("core-js/modules/es.string.search");

require("core-js/modules/es.string.split");

require("core-js/modules/web.dom-collections.for-each");

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

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

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

var _classnames = _interopRequireDefault(require("classnames"));

var _uuid = require("uuid");

var _polestarIcons = _interopRequireDefault(require("polestar-icons"));

var _immutable = require("immutable");

var _tree = _interopRequireDefault(require("antd/lib/tree"));

var _request = _interopRequireDefault(require("../helpers/request"));

var _Header = _interopRequireDefault(require("./components/Header"));

var _Loading = _interopRequireDefault(require("./components/Loading"));

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

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 _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 _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 _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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

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); if (staticProps) _defineProperties(Constructor, staticProps); 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 TreeNode = _tree["default"].TreeNode,
    DirectoryTree = _tree["default"].DirectoryTree;

var Tree = function (_React$Component) {
  _inherits(Tree, _React$Component);

  var _super = _createSuper(Tree);

  function Tree(props) {
    var _this;

    _classCallCheck(this, Tree);

    _this = _super.call(this, props);

    _this.onSelect = function (selectedKeys, info) {
      var _selectedKeys = selectedKeys;

      if (selectedKeys.length === 0) {
        return;
      }

      if (_this.props.draggable && _this.props.checkable) {
        _selectedKeys = _this.state.selectedKeys;
      } else {
        var originNodeData = info.selectedNodes.map(function (node) {
          return node.props.dataRef;
        });
        var hasChildrenNodeData = originNodeData.filter(function (nodeItem) {
          return !!nodeItem.children;
        });
        var selectedItems = originNodeData.filter(function (nodeItem) {
          if (nodeItem.children) return true;
          var b = true;
          var findData;
          hasChildrenNodeData.some(function (data) {
            findData = data.children.find(function (child) {
              return child[_this.props.idKey] === nodeItem[_this.props.idKey];
            });
            b = !findData;
            return !b;
          });
          return b;
        });
        _this.selectedItems = selectedItems;

        if (_this.props.multiple) {
          _selectedKeys = [];
          selectedItems.forEach(function (item) {
            if (item.children) {
              var itemKeys = item.children.map(function (child) {
                return child[_this.props.idKey];
              });
              _selectedKeys = [].concat(_toConsumableArray(_selectedKeys), _toConsumableArray(itemKeys));
            }

            _selectedKeys.push(item[_this.props.idKey]);
          });

          _this.setState({
            selectedKeys: _selectedKeys
          });
        }
      }

      if (_this.props.onSelect) {
        _this.props.onSelect(info.node.props.dataRef, _selectedKeys, info);
      }
    };

    _this.onCheck = function (checkedKeys, info) {
      var originNodeData = info.checkedNodes.map(function (node) {
        return node.props.dataRef;
      });
      var hasChildrenNodeData = originNodeData.filter(function (nodeItem) {
        return !!nodeItem.children;
      });
      var checkedItems = originNodeData.filter(function (nodeItem) {
        if (nodeItem.children) return true;
        var b = true;
        var findData;
        hasChildrenNodeData.some(function (data) {
          findData = data.children.find(function (child) {
            return child[_this.props.idKey] === nodeItem[_this.props.idKey];
          });
          b = !findData;
          return !b;
        });
        return b;
      });
      _this.checkedItems = checkedItems;

      if (_this.props.draggable) {
        _this.selectedItems = checkedItems;

        _this.setState({
          selectedKeys: checkedKeys
        });
      }

      if (_this.props.onCheck) {
        _this.props.onCheck(checkedItems, checkedKeys, info);
      }
    };

    _this.onExpand = function (expandedKeys, _ref) {
      var expanded = _ref.expanded,
          node = _ref.node;

      _this.setState({
        expandedKeys: expandedKeys
      });

      if (_this.props.onExpand) {
        _this.props.onExpand(expandedKeys, {
          expanded: expanded,
          node: node
        });
      }
    };

    _this.onDragStart = function (_ref2) {
      var event = _ref2.event,
          node = _ref2.node;
      var isIE = false;
      var agent = navigator.userAgent.toLowerCase();

      if (navigator.appName === 'Netscape' && agent.indexOf('trident') !== -1 || agent.indexOf('msie') !== -1) {
        isIE = true;
      }

      var _assertThisInitialize = _assertThisInitialized(_this),
          selectedItems = _assertThisInitialize.selectedItems;

      var dragImage;

      if (selectedItems && !isIE) {
        dragImage = document.createElement('div');
        dragImage.id = 'drag-tree-node-image';
        var dragContent = document.createTextNode("".concat(selectedItems.length, " Nodes"));
        dragImage.appendChild(dragContent);
        dragImage.classList.add('ps-tree-drag-node');
        dragImage.style.position = 'absolute';
        dragImage.style.top = '-1000px';
        dragImage.style.paddingTop = '12px';
        dragImage.style.paddingLeft = '18px';
        document.body.appendChild(dragImage);
        event.dataTransfer.setDragImage(dragImage, 0, 0);
        document.addEventListener('dragend', _this.getRemoveEvent);
      }

      if (_this.props.onDragStart) {
        _this.props.onDragStart({
          event: event,
          node: node
        }, selectedItems, dragImage);
      }
    };

    _this.onSearch = function (value) {
      if (_this.props.onSearch) {
        _this.props.onSearch(value);
      }
    };

    _this.getRemoveEvent = function () {
      document.removeEventListener('dragend', _this.getRemoveEvent);
      document.getElementById('drag-tree-node-image').remove();
    };

    _this.getItems = function () {
      return _this.state.items;
    };

    _this.getCheckedItems = function () {
      return _this.checkedItems;
    };

    _this.getSelectedItems = function () {
      return _this.selectedItems;
    };

    _this.getFindFilterKeys = function (nodes, value, parent, expandInfo, isAutoExpand) {
      var _this$props = _this.props,
          parentKey = _this$props.parentKey,
          labelKey = _this$props.labelKey;
      var isMatch = false;
      var matchList = [];
      nodes.forEach(function (item) {
        if (item.children && item.children.length > 0) {
          item.isMatch = false;

          _this.getFindFilterKeys(item.children, value, item, expandInfo, isAutoExpand);
        }

        if (item[labelKey].toUpperCase().indexOf(value.toUpperCase()) > -1) {
            expandInfo.expandItems.push(item);
            matchList.push(item);
            isMatch = true;
          } else if (item.children && item.children.length > 0 && item.isMatch) {
          matchList.push(item);
          isMatch = true;
        }
      });

      if (isMatch) {
        if (parent[parentKey] != null) {
          parent.children = matchList;

          if (isAutoExpand) {
            expandInfo.expandedKeys.push(String(parent.key));
          }
        }

        parent.isMatch = true;
      }

      return expandInfo;
    };

    _this.setEnabledItems = function (nodeItems) {
      var followParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      var items = _toConsumableArray(_this.state.items);

      nodeItems.forEach(function (nodeItem) {
        _this._setDisabledNode(nodeItem, items, false, followParent);
      });

      _this.setState({
        items: items
      });
    };

    _this.setDisabledItems = function (nodeItems) {
      var followParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      var items = _toConsumableArray(_this.state.items);

      nodeItems.forEach(function (nodeItem) {
        _this._setDisabledNode(nodeItem, items, true, followParent);
      });

      _this.setState({
        items: items
      });
    };

    _this.setEnabledCheckbox = function (nodeItems) {
      var followParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

      var items = _toConsumableArray(_this.state.items);

      nodeItems.forEach(function (nodeItem) {
        _this._setDisableCheckbox(nodeItem, items, false, followParent);
      });

      _this.setState({
        items: items
      });
    };

    _this.setDisabledCheckbox = function (nodeItems) {
      var followParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

      var items = _toConsumableArray(_this.state.items);

      nodeItems.forEach(function (nodeItem) {
        _this._setDisableCheckbox(nodeItem, items, true, followParent);
      });

      _this.setState({
        items: items
      });
    };

    _this.setEnabledKeys = function (nodeKeys) {
      var followParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      var items = _toConsumableArray(_this.state.items);

      nodeKeys.forEach(function (nodeKey) {
        _this._setDisabledNode(nodeKey, items, false, followParent);
      });

      _this.setState({
        items: items
      });
    };

    _this.setDisabledKeys = function (nodeKeys) {
      var followParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      var items = _toConsumableArray(_this.state.items);

      nodeKeys.forEach(function (nodeKey) {
        _this._setDisabledNode(nodeKey, items, true, followParent);
      });

      _this.setState({
        items: items
      });
    };

    _this.refresh = function () {
      _this.setState({
        isRemoveTree: true
      }, function () {
        _this._requestItems();
      });
    };

    _this.search = function (params) {
      _this.searchItem = params;

      _this.setState({
        isRemoveTree: true,
        expandedKeys: []
      }, function () {
        _this._requestItems();
      });
    };

    _this.resetSearch = function () {
      _this.searchItem = null;
    };

    _this.expand = function (expandedKeys) {
      _this.setState({
        expandedKeys: expandedKeys
      });
    };

    _this.collapseAll = function () {
      _this.setState({
        expandedKeys: []
      });
    };

    _this._requestItems = function () {
      var fetchObj = _this.fetchObject();

      if (fetchObj) {
        var _this$props2 = _this.props,
            itemsKey = _this$props2.itemsKey,
            dataType = _this$props2.dataType;
        fetchObj.then(function (response) {
          var items = response.data;

          if (itemsKey !== null && itemsKey.length > 0) {
            var itemsKeys = itemsKey.split('.');
            itemsKeys.forEach(function (key) {
              items = items[key];
            });
          }

          if (dataType === 'list') {
            items = _this.convertTreeForList(items);

            _this.setState({
              items: items,
              isRemoveTree: false
            });
          } else {
            _this.setState({
              items: items,
              isRemoveTree: false
            });
          }

          if (_this.props.onLoadComplete) {
            _this.props.onLoadComplete(items);
          }
        })["catch"](function (error) {
          throw new Error(error);
        });
      }
    };

    _this._setDisabledNode = function (nodeItem, items, disabled, followParent) {
      var nodeId = typeof nodeItem === 'string' ? nodeItem : nodeItem[_this.props.idKey];
      items.some(function (item) {
        if (item[_this.props.idKey] === nodeId) {
          item.disabled = disabled;

          if (followParent && item.children) {
            item.children.forEach(function (child) {
              child.disabled = disabled;
            });
          }

          return true;
        }

        if (item.children) {
          _this._setDisabledNode(nodeItem, item.children, disabled, followParent);
        }

        return false;
      });
    };

    _this._setDisableCheckbox = function (nodeItem, items, disableCheckbox, followParent) {
      var nodeId = typeof nodeItem === 'string' ? nodeItem : nodeItem[_this.props.idKey];
      items.some(function (item) {
        if (item[_this.props.idKey] === nodeId) {
          item.disableCheckbox = disableCheckbox;

          if (followParent && item.children) {
            item.children.forEach(function (child) {
              child.disableCheckbox = disableCheckbox;
            });
          }

          return true;
        }

        if (item.children) {
          _this._setDisableCheckbox(nodeItem, item.children, disableCheckbox, followParent);
        }

        return false;
      });
    };

    _this.fetchObject = function (nodeItem) {
      var fetchObj;

      if (typeof _this.props.request === 'function') {
        fetchObj = _this.props.request(nodeItem, _this.searchItem);
      } else if (_this.props.request && _typeof(_this.props.request) === 'object') {
        var _this$props$request = _this.props.request,
            method = _this$props$request.method,
            url = _this$props$request.url,
            params = _this$props$request.params,
            headers = _this$props$request.headers;
        var reqParams = params;

        if (typeof params === 'function') {
          reqParams = params(nodeItem);
        }

        fetchObj = (0, _request["default"])({
          headers: headers,
          method: method,
          url: typeof url === 'function' ? url(nodeItem) : url,
          params: _extends({}, reqParams, _this.searchItem, {
            nodeItem: nodeItem
          })
        });
      }

      return fetchObj;
    };

    _this.appendNodes = function (nodes, parentProps, addNodes) {
      var idKey = _this.props.idKey;
      nodes.some(function (item) {
        if (item.children && item.children.length > 0) {
          _this.appendNodes(item.children, parentProps, addNodes);
        }

        if (parentProps.dataRef[idKey] === item[idKey]) {
          item.children = addNodes;
          return true;
        }

        return false;
      });
    };

    _this.handleLoadData = function (treeNode) {
      return new Promise(function (resolve) {
        if (treeNode.props.children) {
          resolve();
          return;
        }

        _this.childrenRequest(treeNode.props.dataRef).then(function (item) {
          _this.appendNodes(_this.state.items, treeNode.props, item);

          if (_this.props.onLoadData) {
            _this.props.onLoadData(treeNode);
          }

          _this.setState({
            items: _toConsumableArray(_this.state.items)
          });

          resolve();
        });
      });
    };

    _this.childrenRequest = function (nodeItem) {
      return new Promise(function (resolve) {
        var _this$props3 = _this.props,
            itemsKey = _this$props3.itemsKey,
            dataType = _this$props3.dataType;

        var fetchObj = _this.fetchObject(nodeItem);

        fetchObj.then(function (response) {
          var items = response.data;

          if (itemsKey !== null && itemsKey.length > 0) {
            var itemsKeys = itemsKey.split('.');
            itemsKeys.forEach(function (key) {
              items = items[key];
            });
          }

          if (dataType === 'list') {
            resolve(_this.convertTreeForList(items));
          } else {
            resolve(items);
          }
        })["catch"](function (error) {
          throw new Error(error);
        });
      });
    };

    _this.filter = function (items, filterNode) {
      var childrenKey = _this.props.childrenKey;
      var cloneItems = items && items.map(function (item) {
        return (0, _immutable.mergeDeep)({}, item);
      });
      var filterItems = [];
      cloneItems.forEach(function (item) {
        if (filterNode(item) === true) {
          filterItems.push(item);
        }

        if (item[childrenKey]) {
          item[childrenKey] = _this.filter(item[childrenKey], filterNode);

          if (filterNode(item) === false && item[childrenKey] && item[childrenKey].length > 0) {
            filterItems.push(item);
          }
        }
      });
      return filterItems;
    };

    _this.convertTreeForList = function (items) {
      var _this$props4 = _this.props,
          idKey = _this$props4.idKey,
          parentKey = _this$props4.parentKey,
          childrenKey = _this$props4.childrenKey;
      var nodeList = [];
      var lookup = {};
      items.forEach(function (data) {
        lookup[data[idKey]] = data;
        data.key = data[idKey];
        data[childrenKey] = [];
      });
      items.forEach(function (data) {
        if (data[parentKey] !== null && data[parentKey] !== 'null') {
          if (lookup[data[parentKey]]) {
            lookup[data[parentKey]][childrenKey].push(data);
          } else {
            nodeList.push(data);
          }
        } else {
          nodeList.push(data);
        }
      });
      return nodeList;
    };

    _this.renderTreeItems = function (items) {
      if (items === undefined || items === null) {
        return null;
      }

      if (Array.isArray(items)) {
        return items.map(function (item) {
          return _this.renderTreeForHierarchy(item);
        });
      }

      return _this.renderTreeForHierarchy(items);
    };

    _this.renderTreeForHierarchy = function (item) {
      var _this$props5 = _this.props,
          idKey = _this$props5.idKey,
          childrenKey = _this$props5.childrenKey;

      if (item === null || Object.keys(item).length === 0) {
        return null;
      }

      var icon = _this.renderIcon(item);

      var iconEl;

      if (icon) {
        iconEl = typeof icon === 'string' ? _react["default"].createElement(_polestarIcons["default"], {
          name: icon
        }) : icon;
      } else if (item.icon) {
        iconEl = typeof item.icon === 'string' ? _react["default"].createElement(_polestarIcons["default"], {
          name: item.icon
        }) : item.icon;
      }

      var labelEl = _this.renderLabel(item);

      return _react["default"].createElement(TreeNode, {
        key: item[idKey],
        icon: iconEl,
        title: labelEl,
        isLeaf: item.isLeaf,
        dataRef: item,
        disabled: item.disabled,
        disableCheckbox: item.disableCheckbox
      }, item[childrenKey] && item[childrenKey].length > 0 ? item[childrenKey].map(function (childItem) {
        return _this.renderTreeForHierarchy(childItem);
      }) : null);
    };

    _this.renderIcon = function (item) {
      var iconRenderer = _this.props.iconRenderer;
      return iconRenderer ? iconRenderer(item) : null;
    };

    _this.renderLabel = function (item) {
      var _this$props6 = _this.props,
          labelRenderer = _this$props6.labelRenderer,
          labelKey = _this$props6.labelKey;
      return labelRenderer ? labelRenderer(item) : item[labelKey];
    };

    _this.renderHeader = function () {
      var _this$props7 = _this.props,
          onSearch = _this$props7.onSearch,
          header = _this$props7.header;

      if (onSearch) {
        return _react["default"].createElement(_Header["default"], {
          onSearch: _this.onSearch,
          customButtons: Array.isArray(header) ? header : null
        });
      }

      return header;
    };

    var _items = props.items;

    if (_items) {
      if (props.dataType === 'list') {
        _items = _this.convertTreeForList(_items);
      }
    }

    _this.state = {
      items: _items,
      isRemoveTree: false,
      expandedKeys: props.expandedKeys,
      selectedKeys: []
    };
    _this.uuid = (0, _uuid.v4)();
    return _this;
  }

  _createClass(Tree, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this._requestItems();

      var _this$props8 = this.props,
          width = _this$props8.width,
          height = _this$props8.height;
      var treeDom = document.querySelector(".ps-tree[data-id=\"".concat(this.uuid, "\"]"));
      treeDom.style.width = typeof width !== 'undefined' && "".concat(this.props.width, "px");
      treeDom.style.height = typeof height !== 'undefined' && "".concat(this.props.height, "px");
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props9 = this.props,
          className = _this$props9.className,
          ondemand = _this$props9.ondemand,
          width = _this$props9.width,
          height = _this$props9.height,
          filterNode = _this$props9.filterNode,
          showPlus = _this$props9.showPlus,
          iconRenderer = _this$props9.iconRenderer,
          labelRenderer = _this$props9.labelRenderer,
          isDirectoryTree = _this$props9.isDirectoryTree,
          onLoadData = _this$props9.onLoadData,
          rest = _objectWithoutProperties(_this$props9, ["className", "ondemand", "width", "height", "filterNode", "showPlus", "iconRenderer", "labelRenderer", "isDirectoryTree", "onLoadData"]);

      var headerEl = this.renderHeader();
      var TreeComponent = isDirectoryTree === true ? DirectoryTree : _tree["default"];
      return _react["default"].createElement("div", {
        className: "ps-tree-container"
      }, headerEl, !this.state.isRemoveTree ? _react["default"].createElement(TreeComponent, _extends({
        "data-id": this.uuid,
        className: (0, _classnames["default"])('ps-tree', className, {
          'ps-tree-show-plus': showPlus
        }),
        showIcon: !!iconRenderer
      }, rest, {
        expandedKeys: this.state.expandedKeys
      }, this.props.multiple ? {
        selectedKeys: this.state.selectedKeys
      } : null, this.props.draggable && this.props.checkable ? {
        selectedKeys: this.state.selectedKeys,
        multiple: true
      } : null, {
        loadData: ondemand ? this.handleLoadData : null,
        onExpand: this.onExpand,
        onSelect: this.onSelect,
        onCheck: this.onCheck,
        onDragStart: this.onDragStart
      }), this.renderTreeItems(filterNode ? this.filter(this.state.items, filterNode) : this.state.items)) : _react["default"].createElement(_Loading["default"], null));
    }
  }], [{
    key: "getDerivedStateFromProps",
    value: function getDerivedStateFromProps(props) {
      var checkItems = typeof props.items !== 'undefined';
      var checkDrag = props.draggable && props.checkable && typeof props.checkedKeys !== 'undefined';

      if (checkItems || checkDrag) {
        return _extends({}, checkItems ? {
          items: props.items
        } : null, checkDrag ? {
          selectedKeys: props.checkedKeys
        } : null);
      }

      return null;
    }
  }]);

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

Tree.propTypes = {
  className: _propTypes["default"].string,
  header: _propTypes["default"].oneOfType([_propTypes["default"].bool, _propTypes["default"].array, _propTypes["default"].element]),
  width: _propTypes["default"].number,
  height: _propTypes["default"].number,
  showPlus: _propTypes["default"].bool,
  request: _propTypes["default"].oneOfType([_propTypes["default"].func, _propTypes["default"].shape({
    headers: _propTypes["default"].object,
    url: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].func]),
    method: _propTypes["default"].oneOf(['get', 'post', 'GET', 'POST']),
    params: _propTypes["default"].oneOfType([_propTypes["default"].object, _propTypes["default"].func]),
    responseType: _propTypes["default"].oneOf(['json', 'text'])
  })]),
  items: _propTypes["default"].array,
  itemsKey: _propTypes["default"].string,
  idKey: _propTypes["default"].string,
  labelKey: _propTypes["default"].string,
  childrenKey: _propTypes["default"].string,
  parentKey: _propTypes["default"].string,
  dataType: _propTypes["default"].oneOf(['list', 'hierarchy']),
  ondemand: _propTypes["default"].bool,
  filterNode: _propTypes["default"].func,
  iconRenderer: _propTypes["default"].func,
  labelRenderer: _propTypes["default"].func,
  isDirectoryTree: _propTypes["default"].bool,
  onSelect: _propTypes["default"].func,
  onCheck: _propTypes["default"].func,
  onExpand: _propTypes["default"].func,
  onSearch: _propTypes["default"].func,
  onLoadComplete: _propTypes["default"].func,
  onLoadData: _propTypes["default"].func
};
Tree.defaultProps = {
  itemsKey: 'data',
  idKey: 'id',
  labelKey: 'label',
  childrenKey: 'children',
  parentKey: 'parentId',
  dataType: 'hierarchy',
  showPlus: false,
  ondemand: false,
  isDirectoryTree: false
};
var TreeTreeNode = TreeNode;
exports.TreeTreeNode = TreeTreeNode;
var TreeDirectoryTree = DirectoryTree;
exports.TreeDirectoryTree = TreeDirectoryTree;
var _default = Tree;
exports["default"] = _default;