linear-react-components-ui 0.4.76-beta.12 → 0.4.76-beta.13

package/lib/treeview/index.js

@@ -78,47 +78,368 @@ 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) {
+        var requiredIds = [];
+        var newSelectedIds = [];
+        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)
+        });
+      }
+    });
+    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 +448,92 @@ 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;
         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,
+          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,
+          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: []
+    };
+    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;
+      var allowCheckAllAncestry = this.props.allowCheckAllAncestry;
+
+      var isSameSelectedIds = _lodash["default"].isEqual(propSelectedIds.sort(), prevState.propSelectedIds.sort());
+
+      if (allowCheckAllAncestry && !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 +544,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 +580,45 @@ 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
 };
 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
 };
 var _default = TreeView;
 exports["default"] = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linear-react-components-ui",
-  "version": "0.4.76-beta.12",
+  "version": "0.4.76-beta.13",
   "description": "Linear Sistemas ReactJs Components",
   "main": "lib/index.js",
   "scripts": {
@@ -11,6 +11,7 @@
     "check:js": "./node_modules/.bin/eslint ./src/* --ext .js, --ext .jsx",
     "deploy:heroku": "npm run demo:prod && cd demo && git commit -am 'Deploy' && git push heroku master",
     "publish:npm": "npm run lib && npm publish",
+    "publish:npm:beta": "npm run lib && npm publish --tag beta",
     "prepare": "husky install",
     "test": "jest --env=jsdom",
     "test:watch": "jest --watchAll --env=jsdom",
@@ -19,10 +20,10 @@
   "keywords": [],
   "license": "MIT",
   "peerDependencies": {
-    "react": "^16.6.0",
-    "react-dom": "^16.6.0",
-    "react-router-dom": "^4.2.2",
-    "react-transition-group": "^2.2.1"
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "react-router-dom": "^5.2.0",
+    "react-transition-group": "^4.4.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.5.5",
@@ -65,11 +66,11 @@
   },
   "dependencies": {
     "attach-dom-events": "^1.0.0",
-    "history": "^4.10.1",
+    "history": "^5.0.0",
     "imask": "^3.1.1",
     "init": "^0.1.2",
-    "lodash": "^4.17.15",
-    "moment": "^2.24.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.1",
     "node-sass": "^4.13.0",
     "prop-types": "^15.7.2",
     "react-syntax-highlighter": "^6.1.1",