@rio-cloud/rio-uikit 0.16.1-beta.21 → 0.16.1-beta.22

package/components/assetTree/Tree.js

@@ -4,11 +4,8 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 var _excluded = ["groups", "items", "selectedGroups", "selectedItems", "onSelectionChange", "hasMultiselect", "showRadioButtons", "hideSearch", "hideTreeHead", "summary", "hideSummary", "search", "searchPlaceholder", "onSearchChange", "className", "scrollHeight", "expandedGroups", "onExpandGroupsChange", "showEmptyGroups", "treeOptions"];
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 /* eslint-disable no-use-before-define */
 import React, { useReducer, useEffect, useRef } from 'react';
 import PropTypes from 'prop-types';
@@ -46,47 +43,38 @@ var SEARCH_DEBOUNCE = 100;
 var otherwise = stubTrue;
 var notEqual = negate(isEqual);
 var notEmpty = negate(isEmpty);
-
 var Divider = function Divider() {
   return /*#__PURE__*/React.createElement("div", {
     className: 'TreeSelectAllDivider bg-light width-2 height-15 ' + 'margin-top-2 margin-bottom-0 margin-left-10 margin-right-10'
   });
 };
-
 var isNameObject = function isNameObject(item) {
   return isObject(item.name);
 };
-
 var getFullName = function getFullName(item) {
   return "".concat(item.name.firstName, " ").concat(item.name.lastName);
 };
-
 var getName = function getName(item) {
   return isNameObject(item) ? getFullName(item) : item.name;
 };
-
 var getLowerCaseName = function getLowerCaseName(item) {
   return getOr('', 'name')(item).toLowerCase();
 };
-
 var getLowerCaseLastName = function getLowerCaseLastName(item) {
   return getOr('', 'name.lastName')(item).toLowerCase();
 };
-
 var orderByName = orderBy([function (item) {
   return isNameObject(item) ? getLowerCaseLastName(item) : getLowerCaseName(item);
 }], ['asc']);
 var filterEmptyGroups = filter(function (group) {
   return notEmpty(group.items);
 });
-
 var filterAssetByType = function filterAssetByType() {
   var types = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return filter(function (asset) {
     return types.includes(asset.type);
   });
 };
-
 var sortGroupsByName = function sortGroupsByName(groups) {
   var fixedGroups = {};
   var sortableGroups = {};
@@ -100,7 +88,6 @@ var sortGroupsByName = function sortGroupsByName(groups) {
   var sortedGroups = orderByName(sortableGroups);
   return isEmpty(fixedGroups) ? sortedGroups : _objectSpread(_objectSpread({}, sortedGroups), fixedGroups);
 };
-
 var sortGroupItemsByName = function sortGroupItemsByName(groups) {
   var sortedGroups = {};
   map(function (group) {
@@ -110,10 +97,10 @@ var sortGroupItemsByName = function sortGroupItemsByName(groups) {
   })(groups);
   return sortedGroups;
 };
-
 var getMappedItemsToGroups = function getMappedItemsToGroups(groups, items) {
-  var mappedGroups = {}; // build an object for listing the groups by id
+  var mappedGroups = {};
 
+  // build an object for listing the groups by id
   groups.forEach(function (group) {
     mappedGroups[group.id] = _objectSpread(_objectSpread({}, group), {}, {
       items: []
@@ -124,7 +111,6 @@ var getMappedItemsToGroups = function getMappedItemsToGroups(groups, items) {
     var groupIds = item.groupIds || [];
     groupIds.forEach(function (groupId) {
       var mappedGroup = mappedGroups[groupId];
-
       if (mappedGroup) {
         mappedGroup.items.push(item);
       }
@@ -132,202 +118,171 @@ var getMappedItemsToGroups = function getMappedItemsToGroups(groups, items) {
   });
   return mappedGroups;
 };
-
 var filterByName = function filterByName(searchValue) {
   return function (item) {
     if (searchValue) {
       return getName(item).toLowerCase().includes(searchValue.toLowerCase());
     }
-
     return true;
   };
 };
-
 var filterOutByItemId = function filterOutByItemId(list) {
   return function (item) {
     return !list.includes(item.id);
   };
 };
-
 var containsItemById = function containsItemById(list) {
   return function (item) {
     return list.includes(item.id);
   };
 };
-
 var getFlatItems = function getFlatItems(items, searchValue) {
   return flow(filter(filterByName(searchValue)), orderByName)(items);
 };
-
 var getListIds = function getListIds(list) {
   return list.map(function (listItem) {
     return listItem.id;
   });
 };
-
 export var excludeFromList = function excludeFromList(list, itemId) {
   return list.filter(function (item) {
     return item !== itemId;
   });
 };
-
 var getAssetTypeCounts = function getAssetTypeCounts(items) {
   return countBy(function (item) {
     return item.type;
   }, items);
 };
-
 var debounceFn = function debounceFn(fn) {
   return debounce(SEARCH_DEBOUNCE, fn);
 };
-
 var filterProps = omit(['expandedGroups', 'onExpandGroupsChange', 'onSearchChange', 'onSelectionChange', 'treeOptions']);
-
 var customCompare = function customCompare(prevProps, nextProps) {
   return isEqual(filterProps(prevProps), filterProps(nextProps));
 };
-
 var assetCounted = function assetCounted(payload) {
   return {
     type: 'assetCounted',
     payload: payload
   };
 };
-
 var allCheckedChanged = function allCheckedChanged(payload) {
   return {
     type: 'allCheckedChanged',
     payload: payload
   };
 };
-
 var searchValueChanged = function searchValueChanged(payload) {
   return {
     type: 'searchValueChanged',
     payload: payload
   };
 };
-
 var flatItemsChanged = function flatItemsChanged(payload) {
   return {
     type: 'flatItemsChanged',
     payload: payload
   };
 };
-
 var groupedItemsChanged = function groupedItemsChanged(payload) {
   return {
     type: 'groupedItemsChanged',
     payload: payload
   };
 };
-
 var typeFilterChanged = function typeFilterChanged(payload) {
   return {
     type: 'typeFilterChanged',
     payload: payload
   };
 };
-
 var visibleTypeCountersChanged = function visibleTypeCountersChanged(payload) {
   return {
     type: 'visibleTypeCountersChanged',
     payload: payload
   };
 };
-
 var emptyGroupsChanged = function emptyGroupsChanged(payload) {
   return {
     type: 'emptyGroupsChanged',
     payload: payload
   };
 };
-
 var treeReducer = function treeReducer(state, action) {
   switch (action.type) {
     case 'assetCounted':
       return _objectSpread(_objectSpread({}, state), {}, {
         assetCounts: action.payload
       });
-
     case 'allCheckedChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         allChecked: action.payload
       });
-
     case 'searchValueChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         searchValue: action.payload,
         allChecked: false
       });
-
     case 'flatItemsChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         flatItems: action.payload
       });
-
     case 'groupedItemsChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         groupedItems: action.payload
       });
-
     case 'typeFilterChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         typeFilter: action.payload
       });
-
     case 'visibleTypeCountersChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         visibleTypeCounters: action.payload
       });
-
     case 'emptyGroupsChanged':
       return _objectSpread(_objectSpread({}, state), {}, {
         emptyGroups: action.payload
       });
-
     default:
       throw new Error();
   }
 };
-
 var Tree = /*#__PURE__*/React.memo(function (props) {
   var groups = props.groups,
-      items = props.items,
-      selectedGroups = props.selectedGroups,
-      selectedItems = props.selectedItems,
-      onSelectionChange = props.onSelectionChange,
-      hasMultiselect = props.hasMultiselect,
-      showRadioButtons = props.showRadioButtons,
-      hideSearch = props.hideSearch,
-      hideTreeHead = props.hideTreeHead,
-      summary = props.summary,
-      hideSummary = props.hideSummary,
-      search = props.search,
-      searchPlaceholder = props.searchPlaceholder,
-      onSearchChange = props.onSearchChange,
-      className = props.className,
-      scrollHeight = props.scrollHeight,
-      expandedGroups = props.expandedGroups,
-      onExpandGroupsChange = props.onExpandGroupsChange,
-      showEmptyGroups = props.showEmptyGroups,
-      treeOptions = props.treeOptions,
-      remainingProps = _objectWithoutProperties(props, _excluded);
-
+    items = props.items,
+    selectedGroups = props.selectedGroups,
+    selectedItems = props.selectedItems,
+    onSelectionChange = props.onSelectionChange,
+    hasMultiselect = props.hasMultiselect,
+    showRadioButtons = props.showRadioButtons,
+    hideSearch = props.hideSearch,
+    hideTreeHead = props.hideTreeHead,
+    summary = props.summary,
+    hideSummary = props.hideSummary,
+    search = props.search,
+    searchPlaceholder = props.searchPlaceholder,
+    onSearchChange = props.onSearchChange,
+    className = props.className,
+    scrollHeight = props.scrollHeight,
+    expandedGroups = props.expandedGroups,
+    onExpandGroupsChange = props.onExpandGroupsChange,
+    showEmptyGroups = props.showEmptyGroups,
+    treeOptions = props.treeOptions,
+    remainingProps = _objectWithoutProperties(props, _excluded);
   var _useReducer = useReducer(treeReducer, {
-    groupedItems: [],
-    flatItems: [],
-    allChecked: false,
-    searchValue: '',
-    assetCounts: {},
-    typeFilter: [],
-    visibleTypeCounters: [],
-    emptyGroups: []
-  }),
-      _useReducer2 = _slicedToArray(_useReducer, 2),
-      state = _useReducer2[0],
-      dispatch = _useReducer2[1];
-
+      groupedItems: [],
+      flatItems: [],
+      allChecked: false,
+      searchValue: '',
+      assetCounts: {},
+      typeFilter: [],
+      visibleTypeCounters: [],
+      emptyGroups: []
+    }),
+    _useReducer2 = _slicedToArray(_useReducer, 2),
+    state = _useReducer2[0],
+    dispatch = _useReducer2[1];
   var treeRef = useRef();
   var previousItems = useRef();
   var previousGroups = useRef();
@@ -346,9 +301,10 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
         selectedItems: selectedItems,
         selectedGroups: selectedGroups
       }, state.flatItems);
-      dispatch(allCheckedChanged(allChecked)); // Get the distinct asset types from the asset list that is passed into the component
-      // to know which asset type counter to render
+      dispatch(allCheckedChanged(allChecked));
 
+      // Get the distinct asset types from the asset list that is passed into the component
+      // to know which asset type counter to render
       dispatch(visibleTypeCountersChanged(Object.keys(typeCounts)));
       makeTree(groups, items);
     }
@@ -365,34 +321,32 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
   }, [state.searchValue]);
   useEffect(function () {
     return makeTree(groups, items);
-  }, [state.typeFilter]); // Update tree when empty groups are toggled from outside
+  }, [state.typeFilter]);
 
+  // Update tree when empty groups are toggled from outside
   useEffect(function () {
     return makeTree(groups, items);
-  }, [showEmptyGroups]); // Update "select all" state from outside when groups are selected outside programatically
-  // without using the "select all" checkbox
+  }, [showEmptyGroups]);
 
+  // Update "select all" state from outside when groups are selected outside programatically
+  // without using the "select all" checkbox
   useEffect(function () {
     var numOfAllGroups = size(groups);
     var numOfSelectedGroups = size(selectedGroups);
-
     if (numOfSelectedGroups !== numOfAllGroups && state.allChecked) {
       dispatch(allCheckedChanged(false));
     } else if (numOfSelectedGroups === numOfAllGroups && !state.allChecked) {
       dispatch(allCheckedChanged(true));
     }
   }, [selectedGroups]);
-
   var checkAllSelected = function checkAllSelected(updatedProps, flatItems) {
     var updatedItems = updatedProps.items,
-        updatedGroups = updatedProps.groups,
-        updatedSelectedItems = updatedProps.selectedItems,
-        updatedSelectedGroups = updatedProps.selectedGroups;
-
+      updatedGroups = updatedProps.groups,
+      updatedSelectedItems = updatedProps.selectedItems,
+      updatedSelectedGroups = updatedProps.selectedGroups;
     if (!hasGroups() && isEmpty(updatedSelectedItems) || hasNoSearchAndGroups() && isEmpty(updatedSelectedGroups) || hasSearchAndGroups() && isEmpty(updatedSelectedItems)) {
       return false;
     }
-
     if (hasNoSearchAndGroups()) {
       var unselectedGroups = filter(filterOutByItemId(updatedSelectedGroups))(updatedGroups);
       return isEmpty(unselectedGroups);
@@ -400,34 +354,29 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
       var unselectedSearchItems = filter(filterOutByItemId(updatedSelectedItems))(flatItems);
       return isEmpty(unselectedSearchItems);
     }
-
     var unselectedItems = updatedItems.filter(filterOutByItemId(updatedSelectedItems));
     return isEmpty(unselectedItems);
   };
-
   var handleToggleNode = function handleToggleNode(nodeId) {
     var newExpandedNodes = internalExpandedGroups.current.includes(nodeId) ? internalExpandedGroups.current.filter(function (item) {
       return item !== nodeId;
-    }) : [].concat(_toConsumableArray(internalExpandedGroups.current), [nodeId]); // Performance improvement to skip on render cycle and change "open" class directly
+    }) : [].concat(_toConsumableArray(internalExpandedGroups.current), [nodeId]);
 
+    // Performance improvement to skip on render cycle and change "open" class directly
     if (internalExpandedGroups.current.includes(nodeId)) {
       getNodeContainerDomElementById(nodeId).classList.remove('open');
     } else {
       getNodeContainerDomElementById(nodeId).classList.add('open');
     }
-
     internalExpandedGroups.current = newExpandedNodes;
     onExpandGroupsChange(newExpandedNodes);
   };
-
   var getNodeContainerDomElementById = function getNodeContainerDomElementById(nodeId) {
     return treeRef.current.querySelector(".TreeNodeContainer[data-id=\"".concat(nodeId, "\"]"));
   };
-
   var selectAllSearchResultItems = function selectAllSearchResultItems(shouldSelect) {
     return selectAllFlatItems(shouldSelect);
   };
-
   var handeSelectAll = function handeSelectAll(shouldSelect, isIndeterminate) {
     var shouldSelectAll = shouldSelect && !isIndeterminate;
     dispatch(allCheckedChanged(shouldSelectAll));
@@ -439,37 +388,36 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
       return selectAllFlatItems(shouldSelectAll);
     }]])();
   };
-
   var selectAllGroups = function selectAllGroups(shouldSelect) {
     return respondSelection([], shouldSelect ? getListIds(groups) : []);
   };
-
   var selectAllFlatItems = function selectAllFlatItems(shouldSelect) {
     return respondSelection(shouldSelect ? getListIds(state.flatItems) : [], []);
   };
-
   var respondSelection = function respondSelection(updatedSelectedItems, updatedSelectedGroups) {
     onSelectionChange({
       items: updatedSelectedItems,
       groups: updatedSelectedGroups
     });
   };
-
   var handleGroupSelection = function handleGroupSelection(group, isIndeterminate) {
     var groupId = group.id;
     var isSelected = selectedGroups.includes(groupId);
-    var shouldSelectGroup = !isSelected && !isIndeterminate; // handle group selection
+    var shouldSelectGroup = !isSelected && !isIndeterminate;
 
-    var newSelectedGroups = shouldSelectGroup ? [].concat(_toConsumableArray(selectedGroups), [groupId]) : excludeFromList(selectedGroups, groupId); // deselect all items of a node since they will be selected inherently via the group itself
+    // handle group selection
+    var newSelectedGroups = shouldSelectGroup ? [].concat(_toConsumableArray(selectedGroups), [groupId]) : excludeFromList(selectedGroups, groupId);
 
+    // deselect all items of a node since they will be selected inherently via the group itself
     var itemsInGroup = find(function (entry) {
       return entry.id === groupId;
     })(state.groupedItems);
     var itemIdsOfGroup = map(function (item) {
       return item.id;
     })(itemsInGroup.items);
-    var updatedSelectedItems = without(itemIdsOfGroup, selectedItems); // check if all groups are selected to change the state of TreeSelectAll
+    var updatedSelectedItems = without(itemIdsOfGroup, selectedItems);
 
+    // check if all groups are selected to change the state of TreeSelectAll
     var groupAmount = groups.length;
     var emptyGroupAmount = showEmptyGroups ? 0 : state.emptyGroups.length;
     var totalGroupAmount = groupAmount - emptyGroupAmount;
@@ -477,37 +425,32 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
     dispatch(allCheckedChanged(areAllGroupsChecked));
     respondSelection(updatedSelectedItems, newSelectedGroups);
   };
-
   var handleSearchChange = function handleSearchChange(updatedSearchValue) {
     onSearchChange(updatedSearchValue);
     dispatch(searchValueChanged(updatedSearchValue));
   };
-
   var hasGroups = function hasGroups() {
     return groups && notEmpty(groups);
   };
-
   var hasSearchAndGroups = function hasSearchAndGroups() {
     return hasInternalSearchValue() && hasGroups();
   };
-
   var hasNoSearchAndGroups = function hasNoSearchAndGroups() {
     return !hasInternalSearchValue() && hasGroups();
   };
-
   var setFlatItemList = function setFlatItemList(updtedItems, searchValue) {
     var flatItems = getFlatItems(updtedItems, searchValue);
     dispatch(assetCounted(getAssetTypeCounts(flatItems)));
     dispatch(flatItemsChanged(flatItems));
   };
-
   var setGroupedItemList = function setGroupedItemList(groupsToProcess, itemsToProcess, considerEmptyGroups) {
     // Map items to groups with filtered items
     var mappedItemsToGroups = getMappedItemsToGroups(groupsToProcess, itemsToProcess);
     var newGroupedItems = flow(sortGroupsByName, sortGroupItemsByName)(mappedItemsToGroups);
-    var groupedItems = considerEmptyGroups ? newGroupedItems : filterEmptyGroups(newGroupedItems); // Keep the empty groups in memory for later access in select all, without re-iterating on every
-    // group selection
+    var groupedItems = considerEmptyGroups ? newGroupedItems : filterEmptyGroups(newGroupedItems);
 
+    // Keep the empty groups in memory for later access in select all, without re-iterating on every
+    // group selection
     var emptyGroups = filter(function (group) {
       return isEmpty(group.items);
     })(newGroupedItems);
@@ -515,45 +458,34 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
     dispatch(assetCounted(getAssetTypeCounts(items)));
     dispatch(groupedItemsChanged(groupedItems));
   };
-
   var makeTree = function makeTree(updatedGroups, updatedItems) {
     var internalSearchValue = state.searchValue;
     var internalTypeFilter = state.typeFilter;
     var groupsToProcess = updatedGroups;
     var itemsToProcess = updatedItems;
-
     var hasGroupList = function hasGroupList(groupList) {
       return groupList && notEmpty(groupList);
     };
-
     var hasNoInternalSearchAndGroups = function hasNoInternalSearchAndGroups() {
       return isEmpty(internalSearchValue) && hasGroupList(groupsToProcess);
     };
-
     var hasInternalSearchAndGroups = function hasInternalSearchAndGroups() {
       return notEmpty(internalSearchValue) && hasGroupList(groupsToProcess);
     };
-
     var filteredItems = isEmpty(internalTypeFilter) ? itemsToProcess : filterAssetByType(internalTypeFilter)(itemsToProcess);
-
     var setGroupedItems = function setGroupedItems() {
       return setGroupedItemList(groupsToProcess, filteredItems, showEmptyGroups);
     };
-
     var setFlatItems = function setFlatItems() {
       return setFlatItemList(filteredItems, internalSearchValue);
     };
-
     cond([[hasNoInternalSearchAndGroups, setGroupedItems], [hasInternalSearchAndGroups, setFlatItems], [otherwise, setFlatItems]])();
   };
-
   var renderTree = function renderTree() {
     var groupedItems = state.groupedItems;
-
     if (isEmpty(groupedItems)) {
       return /*#__PURE__*/React.createElement(TreeNothingFound, null);
     }
-
     var result = map(function (group) {
       var groupId = group.id;
       var groupItems = group.items;
@@ -583,11 +515,9 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
     })(groupedItems);
     return result;
   };
-
   var renderFlatList = function renderFlatList() {
     var flatItems = state.flatItems;
     var hasLeafs = isEmpty(flatItems);
-
     var getLeafs = function getLeafs() {
       return /*#__PURE__*/React.createElement(TreeLeafList, {
         leafList: flatItems,
@@ -598,64 +528,50 @@ var Tree = /*#__PURE__*/React.memo(function (props) {
         onSelectionChange: respondSelection
       });
     };
-
     return /*#__PURE__*/React.createElement(TreeNodeContainer, {
       isOpen: true
     }, hasLeafs ? /*#__PURE__*/React.createElement(TreeNothingFound, null) : getLeafs());
   };
-
   var hasExternalGroups = notEmpty(groups);
-
   var hasInternalSearchValue = function hasInternalSearchValue() {
     return notEmpty(state.searchValue);
   };
-
   var hasSelectedAllItems = function hasSelectedAllItems() {
     return isEqual(size(selectedItems), size(state.flatItems));
   };
-
   var hasPartialySelectedItems = function hasPartialySelectedItems() {
     return notEmpty(selectedItems) && !hasSelectedAllItems();
   };
-
   var hasSelectedAllGroups = function hasSelectedAllGroups() {
     var emptyGroupAmount = showEmptyGroups ? 0 : state.emptyGroups.length;
     return isEqual(size(selectedGroups), size(groups) - emptyGroupAmount);
   };
-
   var hasPartialySelectedGroups = function hasPartialySelectedGroups() {
     return hasExternalGroups && notEmpty(selectedGroups) && !hasSelectedAllGroups();
   };
-
   var hasSearchAndNoItems = hasInternalSearchValue() && isEmpty(state.flatItems);
   var hasSearchAndNoGroups = hasInternalSearchValue() && isEmpty(state.groupedItems) && hasExternalGroups;
   var hideSelectAll = hasSearchAndNoItems || hasSearchAndNoGroups;
   var isIndeterminate = hasPartialySelectedGroups() || hasPartialySelectedItems();
   var treeClassNames = classNames('Tree', className);
   var treeHeadClasses = classNames('TreeHead', 'display-flex align-items-center', 'padding-15');
-
   var shouldRenderTree = function shouldRenderTree() {
     return hasGroups() && !hasInternalSearchValue();
   };
-
   var content = cond([[shouldRenderTree, function () {
     return renderTree();
   }], [otherwise, function () {
     return renderFlatList();
   }]])();
-
   var handleFilterByType = function handleFilterByType(type) {
     var currentTypeFilter = new Set(state.typeFilter);
-
     if (currentTypeFilter.has(type)) {
       currentTypeFilter["delete"](type);
     } else {
       currentTypeFilter.add(type);
     }
-
     dispatch(typeFilterChanged(_toConsumableArray(currentTypeFilter)));
   };
-
   var isClickable = size(keys(state.assetCounts)) > 1;
   var isFilterActive = notEmpty(state.typeFilter);
   var showTreeHead = !hideTreeHead;

package/components/assetTree/TreeCategory.js

@@ -1,9 +1,7 @@
 import PropTypes from 'prop-types';
-
 var TreeCategory = function TreeCategory(props) {
   return props.children || null;
 };
-
 TreeCategory.displayName = 'TreeCategory';
 TreeCategory.propTypes = {
   id: PropTypes.string.isRequired,

package/components/assetTree/TreeLeaf.js

@@ -6,11 +6,11 @@ import Checkbox from '../checkbox/Checkbox';
 import RadioButton from '../radiobutton/RadioButton';
 var TreeLeaf = /*#__PURE__*/React.memo(function (props) {
   var item = props.item,
-      hasMultiselect = props.hasMultiselect,
-      showRadioButtons = props.showRadioButtons,
-      isSelected = props.isSelected,
-      onSelectItem = props.onSelectItem,
-      onActiveItem = props.onActiveItem;
+    hasMultiselect = props.hasMultiselect,
+    showRadioButtons = props.showRadioButtons,
+    isSelected = props.isSelected,
+    onSelectItem = props.onSelectItem,
+    onActiveItem = props.onActiveItem;
   var treeNodeClassNames = classNames('TreeLeaf', 'form-group margin-bottom-0', isSelected && 'active', item.className && item.className);
   return /*#__PURE__*/React.createElement("div", {
     className: treeNodeClassNames,