linear-react-components-ui 0.4.76-rc.9 → 0.4.76

package/lib/treeview/index.js

@@ -78,47 +78,374 @@ var TreeView = /*#__PURE__*/function (_Component) {
 
   var _super = _createSuper(TreeView);
 
-  function TreeView() {
-    var _temp, _this;
+  function TreeView(props) {
+    var _this;
 
     _classCallCheck(this, TreeView);
 
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
+    _this = _super.call(this, props);
+    Object.defineProperty(_assertThisInitialized(_this), "getContextValues", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value() {
+        return _extends({}, _this.props, _this.state, {
+          handlerUpdateSelectedIds: _this.updateSelectedIds,
+          handlerToggleCheckChildren: _this.toggleCheckChildren
+        });
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "handleNewSelectedIds", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(selectedIds) {
+        _this.setState({
+          requiredParentsIds: []
+        }, function () {
+          var requiredIds = [];
+          var newSelectedIds = [];
+          var selectedIdsUpdatedOnMount = _this.state.selectedIdsUpdatedOnMount;
+          selectedIds.forEach(function (id) {
+            var _this$checkAllAncestr = _this.checkAllAncestry(id, [], true, false),
+                requiredParentsIds = _this$checkAllAncestr.requiredParentsIds,
+                updatedIdsWithAncestryIds = _this$checkAllAncestr.updatedIdsWithAncestryIds;
+
+            newSelectedIds = [].concat(_toConsumableArray(newSelectedIds), _toConsumableArray(updatedIdsWithAncestryIds));
+            requiredIds = [].concat(_toConsumableArray(requiredIds), _toConsumableArray(requiredParentsIds));
+          });
 
-    return _possibleConstructorReturn(_this, (_temp = _this = _super.call.apply(_super, [this].concat(args)), Object.defineProperty(_assertThisInitialized(_this), "state", {
+          _this.setState({
+            requiredParentsIds: _lodash["default"].uniq(requiredIds),
+            selectedIds: _lodash["default"].uniq(newSelectedIds),
+            selectedIdsUpdatedOnMount: selectedIdsUpdatedOnMount || true
+          });
+        });
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "returnParentId", {
       configurable: true,
       enumerable: true,
       writable: true,
-      value: {
-        data: _this.props.data,
-        selectedIds: _this.props.selectedIds
+      value: function value(nodeId) {
+        var parentId = Object.keys(_this.idsWithChildren).find(function (id) {
+          return _this.idsWithChildren[id].find(function (childId) {
+            return childId === nodeId;
+          });
+        });
+        return Number(parentId);
       }
-    }), Object.defineProperty(_assertThisInitialized(_this), "getContextValues", {
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "returnAllAncestryIds", {
       configurable: true,
       enumerable: true,
       writable: true,
-      value: function value() {
-        return _extends({}, _this.props, _this.state, {
-          updateSelectedIds: _this.updateSelectedIds
+      value: function value(nodeId) {
+        var ancestryIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+        var parentId = _this.returnParentId(nodeId);
+
+        if (parentId) {
+          var currentAncestryIds = [].concat(_toConsumableArray(ancestryIds), [Number(parentId)]);
+          return _this.returnAllAncestryIds(Number(parentId), currentAncestryIds);
+        }
+
+        return ancestryIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "returnChildrenIds", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId) {
+        var returnRequiredIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        var nodeChildrenIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+        var requiredIds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+
+        if (_this.idsWithChildren[nodeId] !== undefined) {
+          nodeChildrenIds.push(nodeId);
+          if (returnRequiredIds) requiredIds.push(nodeId);
+
+          _this.idsWithChildren[nodeId].forEach(function (childId) {
+            return _this.returnChildrenIds(childId, returnRequiredIds, nodeChildrenIds, requiredIds);
+          });
+        } else nodeChildrenIds.push(nodeId);
+
+        return returnRequiredIds ? {
+          nodeChildrenIds: nodeChildrenIds,
+          requiredIds: requiredIds
+        } : nodeChildrenIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "returnRequiredAncestryIds", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId) {
+        var requiredAncestryIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+        var previousParentId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+        var selectedSiblingsIds = [];
+        var selectedIds = _this.state.selectedIds;
+
+        var parentId = _this.returnParentId(nodeId);
+
+        if (parentId) {
+          var nodeSiblingsIds = _this.idsWithChildren[parentId].filter(function (childId) {
+            return childId !== nodeId;
+          });
+
+          var isPreviousParentSelected = selectedIds.includes(previousParentId);
+
+          if (nodeSiblingsIds && nodeSiblingsIds.length > 0) {
+            selectedSiblingsIds = selectedIds.filter(function (id) {
+              return nodeSiblingsIds.includes(id);
+            });
+          }
+
+          var requiredIds = isPreviousParentSelected || selectedSiblingsIds.length > 0 ? _toConsumableArray(requiredAncestryIds) : [].concat(_toConsumableArray(requiredAncestryIds), [parentId]);
+
+          if (selectedSiblingsIds.length === 0 && !isPreviousParentSelected) {
+            return _this.returnRequiredAncestryIds(parentId, requiredIds, parentId);
+          }
+        }
+
+        return requiredAncestryIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "toggleCheckChildren", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, check) {
+        var required = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+        _this.setState({
+          isHandlingSelectedIds: true
+        }, function () {
+          _this.updateSelectedIds(nodeId, check, true, required);
+        });
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "checkAllAncestry", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, codigos) {
+        var returnRequiredParentsIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+        var updateState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+        var selectedIds = _this.state.selectedIds;
+        var requiredParentsIds = _this.state.requiredParentsIds;
+
+        var nodeAncestryIds = _this.returnAllAncestryIds(nodeId);
+
+        var notRequiredAncestryIds = nodeAncestryIds.filter(function (id) {
+          return !requiredParentsIds.includes(id);
+        });
+        var notSelectedAncestryIds = nodeAncestryIds.filter(function (id) {
+          return !selectedIds.includes(id);
+        });
+        selectedIds = [].concat(_toConsumableArray(selectedIds), _toConsumableArray(codigos), _toConsumableArray(notSelectedAncestryIds));
+        requiredParentsIds = [].concat(_toConsumableArray(requiredParentsIds), _toConsumableArray(notRequiredAncestryIds));
+        if (updateState) _this.setState({
+          requiredParentsIds: requiredParentsIds
+        });
+        return !returnRequiredParentsIds ? selectedIds : {
+          updatedIdsWithAncestryIds: selectedIds,
+          requiredParentsIds: requiredParentsIds
+        };
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "updateAncestryAndSelectedIds", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, codigos, requiredParentsIds) {
+        var selectedIds = _this.state.selectedIds;
+
+        var ancestryIds = _this.returnRequiredAncestryIds(nodeId);
+
+        var remainRequiredParentsIds = requiredParentsIds.filter(function (id) {
+          return !ancestryIds.includes(id);
+        });
+        selectedIds = selectedIds.filter(function (selectedId) {
+          return !codigos.includes(selectedId);
+        });
+
+        _this.setState({
+          requiredParentsIds: remainRequiredParentsIds
         });
+
+        return selectedIds;
       }
-    }), Object.defineProperty(_assertThisInitialized(_this), "updateSelectedIds", {
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "checkAllChildren", {
       configurable: true,
       enumerable: true,
       writable: true,
-      value: function value(ids, checked) {
+      value: function value(nodeId) {
+        var returnRequiredIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        var currentRequiredIds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+        var _this$state = _this.state,
+            selectedIds = _this$state.selectedIds,
+            requiredParentsIds = _this$state.requiredParentsIds;
+        var childrenIds;
+
+        if (returnRequiredIds) {
+          var _this$returnChildrenI = _this.returnChildrenIds(nodeId, returnRequiredIds),
+              nodeChildrenIds = _this$returnChildrenI.nodeChildrenIds,
+              requiredIds = _this$returnChildrenI.requiredIds;
+
+          var newRequiredIds = requiredIds.filter(function (id) {
+            return !currentRequiredIds.includes(id);
+          });
+          requiredParentsIds = [].concat(_toConsumableArray(currentRequiredIds), _toConsumableArray(newRequiredIds));
+          childrenIds = nodeChildrenIds;
+        } else childrenIds = _this.returnChildrenIds(nodeId);
+
+        var notSelectedChildrenIds = childrenIds.filter(function (id) {
+          return !selectedIds.includes(id);
+        });
+        selectedIds = [].concat(_toConsumableArray(selectedIds), _toConsumableArray(notSelectedChildrenIds));
+
+        _this.setState({
+          isHandlingSelectedIds: false,
+          requiredParentsIds: requiredParentsIds
+        });
+
+        return selectedIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "uncheckAllChildren", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId) {
+        var remainSelectedIds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+        var selectedIds = remainSelectedIds.length > 0 ? remainSelectedIds : _this.state.selectedIds;
+
+        var childrenIds = _this.returnChildrenIds(nodeId);
+
+        selectedIds = selectedIds.filter(function (selectedId) {
+          return !childrenIds.includes(selectedId);
+        });
+
+        _this.setState({
+          isHandlingSelectedIds: false
+        });
+
+        return selectedIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "uncheckRequiredChildren", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, codigos, requiredParentsIds) {
+        var childrenIds = _this.returnChildrenIds(nodeId);
+
+        var remainRequiredIds = requiredParentsIds.filter(function (id) {
+          return !childrenIds.includes(id);
+        });
+
+        _this.setState({
+          requiredParentsIds: _toConsumableArray(remainRequiredIds)
+        }, function () {
+          return _this.updateAncestryAndSelectedIds(nodeId, codigos, remainRequiredIds);
+        });
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "handleOnNodeOpen", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(node) {
+        var id = node.id;
+        var onNodeOpen = _this.props.onNodeOpen;
+        var alreadyOpenedIds = _this.state.alreadyOpenedIds;
+
+        if (!alreadyOpenedIds.includes(id) && onNodeOpen) {
+          alreadyOpenedIds = [].concat(_toConsumableArray(alreadyOpenedIds), [id]);
+          onNodeOpen(node);
+        }
+
+        _this.setState({
+          alreadyOpenedIds: alreadyOpenedIds
+        });
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "handleCheck", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, isParent) {
+        var selectedIds = _this.state.selectedIds;
+        var codigos = _lodash["default"].isArray(nodeId) ? nodeId : [nodeId];
+        var isHandlingSelectedIds = _this.state.isHandlingSelectedIds;
+        var _this$props = _this.props,
+            allowCheckAllChildren = _this$props.allowCheckAllChildren,
+            allowCheckAllAncestry = _this$props.allowCheckAllAncestry;
+        selectedIds = [].concat(_toConsumableArray(selectedIds), _toConsumableArray(codigos));
+
+        if (isParent && isHandlingSelectedIds && allowCheckAllChildren) {
+          if (allowCheckAllAncestry) {
+            var _this$checkAllAncestr2 = _this.checkAllAncestry(nodeId, codigos, true),
+                updatedIdsWithAncestryIds = _this$checkAllAncestr2.updatedIdsWithAncestryIds,
+                requiredParentsIds = _this$checkAllAncestr2.requiredParentsIds;
+
+            var updatedIdsWithChidlrenIds = _this.checkAllChildren(nodeId, true, requiredParentsIds);
+
+            selectedIds = [].concat(_toConsumableArray(updatedIdsWithAncestryIds), _toConsumableArray(updatedIdsWithChidlrenIds));
+          } else selectedIds = _this.checkAllChildren(nodeId);
+        } else if (allowCheckAllAncestry) {
+          selectedIds = _this.checkAllAncestry(nodeId, codigos);
+        }
+
+        return selectedIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "handleUncheck", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, isParent, required) {
+        var selectedIds = _this.state.selectedIds;
+        var _this$state2 = _this.state,
+            isHandlingSelectedIds = _this$state2.isHandlingSelectedIds,
+            requiredParentsIds = _this$state2.requiredParentsIds;
+        var _this$props2 = _this.props,
+            allowCheckAllChildren = _this$props2.allowCheckAllChildren,
+            allowCheckAllAncestry = _this$props2.allowCheckAllAncestry;
+        var codigos = _lodash["default"].isArray(nodeId) ? nodeId : [nodeId];
+        selectedIds = selectedIds.filter(function (id) {
+          return !codigos.includes(id);
+        });
+
+        if (isParent && isHandlingSelectedIds && allowCheckAllChildren) {
+          if (allowCheckAllAncestry) {
+            var updatedSelectedIds = _this.updateAncestryAndSelectedIds(nodeId, codigos, requiredParentsIds);
+
+            selectedIds = _this.uncheckAllChildren(nodeId, updatedSelectedIds);
+            if (required) _this.uncheckRequiredChildren(nodeId, codigos, requiredParentsIds);
+          } else selectedIds = _this.uncheckAllChildren(nodeId);
+        } else if (allowCheckAllAncestry) {
+          selectedIds = _this.updateAncestryAndSelectedIds(nodeId, codigos, requiredParentsIds);
+        }
+
+        return selectedIds;
+      }
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "updateSelectedIds", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: function value(nodeId, checked, isParent, required) {
         var selectedIds = _this.state.selectedIds;
         var onSelectedIdsChange = _this.props.onSelectedIdsChange;
-        var codigos = _lodash["default"].isArray(ids) ? ids : [ids];
 
         if (checked) {
-          selectedIds = [].concat(_toConsumableArray(selectedIds), _toConsumableArray(codigos));
+          selectedIds = _this.handleCheck(nodeId, isParent);
         } else {
-          selectedIds = selectedIds.filter(function (id) {
-            return !codigos.includes(id);
-          });
+          selectedIds = _this.handleUncheck(nodeId, isParent, required);
         }
 
         _this.setState({
@@ -127,37 +454,100 @@ var TreeView = /*#__PURE__*/function (_Component) {
 
         if (onSelectedIdsChange) onSelectedIdsChange(selectedIds);
       }
-    }), Object.defineProperty(_assertThisInitialized(_this), "buildTree", {
+    });
+    Object.defineProperty(_assertThisInitialized(_this), "buildTree", {
       configurable: true,
       enumerable: true,
       writable: true,
       value: function value(node) {
         var parentId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
-        var parentPropName = _this.props.parentPropName;
+        var ids = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+        var _this$props3 = _this.props,
+            nodeRightElements = _this$props3.nodeRightElements,
+            onNodeClick = _this$props3.onNodeClick,
+            nodeElementsValidations = _this$props3.nodeElementsValidations,
+            nodeToolbarElements = _this$props3.nodeToolbarElements,
+            nodeMenuButtonSize = _this$props3.nodeMenuButtonSize,
+            alwaysShowArrow = _this$props3.alwaysShowArrow,
+            startNodesOpened = _this$props3.startNodesOpened,
+            idsInLoading = _this$props3.idsInLoading,
+            selectedNodeId = _this$props3.selectedNodeId;
         var childrenIds = [];
-        if (node.itens && node.itens.length > 0) childrenIds = node.itens.map(function (i) {
-          return i.id;
-        });
+
+        if (node.itens && node.itens.length > 0) {
+          childrenIds = node.itens.map(function (i) {
+            return i.id;
+          });
+
+          if (ids) {
+            var idWithChildren = {};
+            idWithChildren[node.id] = childrenIds;
+            Object.assign(ids, idWithChildren);
+          }
+        }
+
         return /*#__PURE__*/_react["default"].createElement(_Node["default"], {
           key: "node-".concat(node.id),
           node: node,
+          idsInLoading: idsInLoading,
+          startNodesOpened: startNodesOpened,
+          alwaysShowArrow: alwaysShowArrow,
           childrenIds: childrenIds,
-          parentId: parentId
+          isParent: node.itens && node.itens.length > 0,
+          parentId: parentId,
+          nodeRightElements: nodeRightElements,
+          nodeToolbarElements: nodeToolbarElements,
+          nodeElementsValidations: nodeElementsValidations,
+          nodeMenuButtonSize: nodeMenuButtonSize,
+          onNodeClick: onNodeClick,
+          selectedNodeId: selectedNodeId,
+          handlerOnNodeOpen: _this.handleOnNodeOpen
         }, childrenIds.length > 0 && node.itens.map(function (nodeitem) {
-          return _this.buildTree(nodeitem, nodeitem[parentPropName]);
+          return _this.buildTree(nodeitem, node.id, ids);
         }));
       }
-    }), _temp));
+    });
+    _this.idsWithChildren = {};
+    _this.state = {
+      data: _this.props.data,
+      propSelectedIds: _this.props.selectedIds,
+      selectedIds: _this.props.selectedIds,
+      isHandlingSelectedIds: false,
+      requiredParentsIds: [],
+      alreadyOpenedIds: [],
+      selectedIdsUpdatedOnMount: false
+    };
+    return _this;
   }
 
   _createClass(TreeView, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.buildTree(this.state.data, undefined, this.idsWithChildren);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      var _this$state3 = this.state,
+          selectedIds = _this$state3.selectedIds,
+          propSelectedIds = _this$state3.propSelectedIds,
+          selectedIdsUpdatedOnMount = _this$state3.selectedIdsUpdatedOnMount;
+      var allowCheckAllAncestry = this.props.allowCheckAllAncestry;
+
+      var isSameSelectedIds = _lodash["default"].isEqual(propSelectedIds.sort(), prevState.propSelectedIds.sort());
+
+      if (allowCheckAllAncestry && (!selectedIdsUpdatedOnMount || !isSameSelectedIds)) {
+        this.handleNewSelectedIds(selectedIds);
+      }
+    }
+  }, {
     key: "render",
     value: function render() {
-      var _this$props = this.props,
-          customClass = _this$props.customClass,
-          bordered = _this$props.bordered,
-          children = _this$props.children,
-          styleForContainer = _this$props.styleForContainer;
+      var _this$props4 = this.props,
+          customClass = _this$props4.customClass,
+          bordered = _this$props4.bordered,
+          children = _this$props4.children,
+          styleForContainer = _this$props4.styleForContainer;
       var data = this.state.data;
       return /*#__PURE__*/_react["default"].createElement(_constants.TreeviewContext.Provider, {
         value: this.getContextValues()
@@ -168,6 +558,29 @@ var TreeView = /*#__PURE__*/function (_Component) {
         className: "treeviewcontainer ".concat(bordered && '-bordered')
       }, this.buildTree(data))));
     }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      var data = props.data,
+          selectedIds = props.selectedIds,
+          enableDynamicData = props.enableDynamicData;
+      var propSelectedIds = state.propSelectedIds;
+
+      var isSameSelectedIds = _lodash["default"].isEqual(propSelectedIds.sort(), selectedIds.sort());
+
+      if (enableDynamicData && data !== state.data) {
+        return {
+          data: data
+        };
+      } else if (!isSameSelectedIds) {
+        return {
+          selectedIds: selectedIds,
+          propSelectedIds: selectedIds
+        };
+      }
+
+      return null;
+    }
   }]);
 
   return TreeView;
@@ -181,23 +594,49 @@ TreeView.propTypes = {
   labelPropName: _propTypes["default"].string.isRequired,
   parentPropName: _propTypes["default"].string.isRequired,
   startNodesOpened: _propTypes["default"].bool,
+  alwaysShowArrow: _propTypes["default"].bool,
   selectedIds: _propTypes["default"].arrayOf(_propTypes["default"].number),
-  requiredIds: _propTypes["default"].arrayOf(_propTypes["default"].number),
+  requiredIds: _propTypes["default"].arrayOf(_propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].number])),
   showCheckBox: _propTypes["default"].bool,
   onSelectedIdsChange: _propTypes["default"].func,
   children: _propTypes["default"].instanceOf(Object),
-  styleForContainer: _propTypes["default"].object
+  styleForContainer: _propTypes["default"].object,
+  allowCheckAllChildren: _propTypes["default"].bool,
+  allowCheckAllAncestry: _propTypes["default"].bool,
+  defaultDisabledTooltip: _propTypes["default"].string,
+  nodeRightElements: _propTypes["default"].oneOfType([_propTypes["default"].arrayOf(_propTypes["default"].object), _propTypes["default"].element, _propTypes["default"].object]),
+  nodeToolbarElements: _propTypes["default"].oneOfType([_propTypes["default"].arrayOf(_propTypes["default"].object), _propTypes["default"].element, _propTypes["default"].object]),
+  nodeMenuButtonSize: _propTypes["default"].oneOf(['mini', 'small', 'medium', 'large', 'default']),
+  onNodeClick: _propTypes["default"].func,
+  onNodeOpen: _propTypes["default"].func,
+  nodeElementsValidations: _propTypes["default"].object,
+  enableDynamicData: _propTypes["default"].bool,
+  idsInLoading: _propTypes["default"].arrayOf(_propTypes["default"].number),
+  selectedNodeId: _propTypes["default"].number
 };
 TreeView.defaultProps = {
   customClass: '',
   bordered: false,
   startNodesOpened: false,
+  alwaysShowArrow: false,
   selectedIds: [],
   requiredIds: [],
   showCheckBox: false,
   onSelectedIdsChange: undefined,
   children: undefined,
-  styleForContainer: {}
+  styleForContainer: {},
+  allowCheckAllChildren: false,
+  allowCheckAllAncestry: false,
+  defaultDisabledTooltip: '',
+  nodeRightElements: undefined,
+  nodeToolbarElements: undefined,
+  nodeMenuButtonSize: 'small',
+  onNodeClick: undefined,
+  onNodeOpen: undefined,
+  nodeElementsValidations: undefined,
+  enableDynamicData: false,
+  idsInLoading: [],
+  selectedNodeId: undefined
 };
 var _default = TreeView;
 exports["default"] = _default;

package/lib/treeview/treeview.spec.js

@@ -257,5 +257,23 @@ describe('Treeview', function () {
 
       expect(container.querySelector('ul')).toHaveStyle('background-color: #000');
     });
+    it('should apply idsInLoading', function () {
+      var _render13 = (0, _react.render)(treeviewRenderMock({
+        idsInLoading: [1]
+      })),
+          container = _render13.container;
+
+      var li = container.querySelector('li').firstChild;
+      expect(li.firstChild).toHaveClass('spinnerloading');
+    });
+    it('should apply selectedNodeId', function () {
+      var _render14 = (0, _react.render)(treeviewRenderMock({
+        selectedNodeId: 1
+      })),
+          container = _render14.container;
+
+      var filhosLi = container.querySelector('li').children;
+      expect(filhosLi[1]).toHaveStyle('background-color: rgb(209, 209, 209)');
+    });
   });
 });

package/lib/uitour/helpers.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STEP_POSITIONS = exports.ARROW_HEIGHT = exports.ARROW_WIDTH = void 0;
+var ARROW_WIDTH = 26;
+exports.ARROW_WIDTH = ARROW_WIDTH;
+var ARROW_HEIGHT = 20;
+exports.ARROW_HEIGHT = ARROW_HEIGHT;
+var STEP_POSITIONS = {
+  right: 'right',
+  left: 'left'
+};
+exports.STEP_POSITIONS = STEP_POSITIONS;