@elliemae/ds-treeview 1.55.0-next.7 → 2.0.0-alpha.10

package/esm/utils/dnd-helpers.js

@@ -1,32 +1,34 @@
 import { getItemsParentNode, itemsShareSameParent } from './tree-helpers.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import 'react';
-import './string-helpers.js';
 
 /* eslint-disable max-lines */
-var keyCodes = {
+const keyCodes = {
   lift: [32, 13],
   drop: [32, 13],
   cancel: [27],
   up: [38, 37],
   down: [40, 39]
 };
-var sameParentAsHoverItemDrop = function sameParentAsHoverItemDrop(_ref) {
-  var isBefore = _ref.isBefore,
-      isAfter = _ref.isAfter,
-      draggedItem = _ref.draggedItem,
-      overItem = _ref.overItem,
-      movementDirection = _ref.movementDirection;
-  var hoveredItemNodeNestedIndex = overItem.node.getIndex();
-  var newParentNode = getItemsParentNode([overItem], true);
-  var draggedItemTreeDepth = draggedItem.treeDepth;
-  var overItemTreeDepth = overItem.treeDepth;
-  var directionOffset = // we don't apply the offset for direction
+const sameParentAsHoverItemDrop = ({
+  isBefore,
+  isAfter,
+  draggedItem,
+  overItem,
+  movementDirection
+}) => {
+  const hoveredItemNodeNestedIndex = overItem.node.getIndex();
+  let newParentNode = getItemsParentNode([overItem], true);
+  const {
+    treeDepth: draggedItemTreeDepth
+  } = draggedItem;
+  const {
+    treeDepth: overItemTreeDepth
+  } = overItem;
+  const directionOffset = // we don't apply the offset for direction
   //  if moving from less nested to more nested
   //  or moving bottom to top
   // the offset is required when moving elemnts down in their nest level
   draggedItemTreeDepth <= overItemTreeDepth && movementDirection === 'topToBottom' ? -1 : 0;
-  var newNestedIndex;
+  let newNestedIndex;
   if (isBefore) newNestedIndex = hoveredItemNodeNestedIndex + directionOffset;else if (isAfter) newNestedIndex = hoveredItemNodeNestedIndex + 1 + directionOffset;else {
     newNestedIndex = overItem.children.length; // append as last child of the group
 
@@ -34,18 +36,19 @@ var sameParentAsHoverItemDrop = function sameParentAsHoverItemDrop(_ref) {
   }
   if (newNestedIndex < 0) newNestedIndex = 0;
   return {
-    newNestedIndex: newNestedIndex,
-    newParentNode: newParentNode
+    newNestedIndex,
+    newParentNode
   };
 };
-var inferHoverItemKinshipDrop = function inferHoverItemKinshipDrop(_ref2) {
-  var isBefore = _ref2.isBefore,
-      isAfter = _ref2.isAfter,
-      draggedItem = _ref2.draggedItem,
-      overItem = _ref2.overItem,
-      movementDirection = _ref2.movementDirection;
-  var hoverItemModel = overItem.node.model;
-  var isGroupAndIsExpanded = hoverItemModel.isExpanded && hoverItemModel.children.length > 0;
+const inferHoverItemKinshipDrop = ({
+  isBefore,
+  isAfter,
+  draggedItem,
+  overItem,
+  movementDirection
+}) => {
+  const hoverItemModel = overItem.node.model;
+  const isGroupAndIsExpanded = hoverItemModel.isExpanded && hoverItemModel.children.length > 0;
 
   if (isAfter && isGroupAndIsExpanded) {
     return {
@@ -57,11 +60,11 @@ var inferHoverItemKinshipDrop = function inferHoverItemKinshipDrop(_ref2) {
 
   if (isBefore || isAfter && !isGroupAndIsExpanded) {
     return sameParentAsHoverItemDrop({
-      isBefore: isBefore,
-      isAfter: isAfter,
-      draggedItem: draggedItem,
-      overItem: overItem,
-      movementDirection: movementDirection
+      isBefore,
+      isAfter,
+      draggedItem,
+      overItem,
+      movementDirection
     });
   } // drop inside
 
@@ -72,15 +75,20 @@ var inferHoverItemKinshipDrop = function inferHoverItemKinshipDrop(_ref2) {
     newParentNode: overItem.node
   };
 };
-var isDropValid = function isDropValid(_ref3) {
-  var isBefore = _ref3.isBefore,
-      isAfter = _ref3.isAfter,
-      draggedItem = _ref3.draggedItem,
-      overItem = _ref3.overItem,
-      restrictDragAndDrop = _ref3.restrictDragAndDrop;
-  var movedId = draggedItem.id;
-  var hoverId = overItem.id;
-  var isInside = !isBefore && !isAfter;
+const isDropValid = ({
+  isBefore,
+  isAfter,
+  draggedItem,
+  overItem,
+  restrictDragAndDrop
+}) => {
+  const {
+    id: movedId
+  } = draggedItem;
+  const {
+    id: hoverId
+  } = overItem;
+  const isInside = !isBefore && !isAfter;
   if (movedId === hoverId) return false;
 
   if (isInside && !overItem.isGroup) {
@@ -90,21 +98,23 @@ var isDropValid = function isDropValid(_ref3) {
   if (restrictDragAndDrop) {
     if (isInside) return false; // in this mode we can't drop inside another element
 
-    var sameParent = itemsShareSameParent([draggedItem, overItem]);
+    const sameParent = itemsShareSameParent([draggedItem, overItem]);
     if (overItem.node.model.isExpanded && isAfter) return false;
     if (!sameParent) return false;
   }
 
   return true;
 };
-var inferKeyboardKinshipDrop = function inferKeyboardKinshipDrop(_ref4) {
-  var items = _ref4.items,
-      newIndex = _ref4.newIndex;
-  var kinship = {}; // const directionOffset = movementDirection === 'topToBottom' ? 0 : 0;
+const inferKeyboardKinshipDrop = ({
+  items,
+  newIndex // movementDirection,
 
-  var itemBefore = items[newIndex];
-  var itemBeforeModel = itemBefore.node.model;
-  var isGroupAndIsExpanded = itemBeforeModel.isExpanded && itemBeforeModel.children.length > 0;
+}) => {
+  const kinship = {}; // const directionOffset = movementDirection === 'topToBottom' ? 0 : 0;
+
+  const itemBefore = items[newIndex];
+  const itemBeforeModel = itemBefore.node.model;
+  const isGroupAndIsExpanded = itemBeforeModel.isExpanded && itemBeforeModel.children.length > 0;
 
   if (isGroupAndIsExpanded) {
     kinship.newParentNode = itemBefore.node;
@@ -118,4 +128,3 @@ var inferKeyboardKinshipDrop = function inferKeyboardKinshipDrop(_ref4) {
 };
 
 export { inferHoverItemKinshipDrop, inferKeyboardKinshipDrop, isDropValid, keyCodes, sameParentAsHoverItemDrop };
-//# sourceMappingURL=dnd-helpers.js.map

package/esm/utils/group-expands-helpers.js

@@ -1,42 +1,47 @@
 import { useCallback, useEffect } from 'react';
 
 /* eslint-disable max-params */
-var toggleItemExpand = function toggleItemExpand(itemToToggle, triggerTreeRerender) {
-  var scrollTo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
-  var isExpanded = itemToToggle.node.model.isExpanded,
-      virtualIndex = itemToToggle.virtualIndex;
+const toggleItemExpand = (itemToToggle, triggerTreeRerender, scrollTo = () => {}) => {
+  const {
+    node: {
+      model: {
+        isExpanded
+      }
+    },
+    virtualIndex
+  } = itemToToggle;
 
   if (itemToToggle.node.model.isGroup) {
     itemToToggle.node.model.isExpanded = !isExpanded;
     triggerTreeRerender();
-    setTimeout(function () {
+    setTimeout(() => {
       scrollTo(virtualIndex, {
         align: 'start'
       });
     });
   }
 };
-var expandItemModel = function expandItemModel(modelToExpand) {
+const expandItemModel = modelToExpand => {
   if (modelToExpand.isGroup) modelToExpand.isExpanded = true;
 };
-var collapseItemModel = function collapseItemModel(modelToCollapse) {
+const collapseItemModel = modelToCollapse => {
   if (modelToCollapse.isGroup) modelToCollapse.isExpanded = false;
 };
-var expandAll = function expandAll(treeRoot, triggerTreeRerender) {
-  treeRoot.walk(function (node) {
+const expandAll = (treeRoot, triggerTreeRerender) => {
+  treeRoot.walk(node => {
     if (!node.isRoot()) expandItemModel(node.model);
   });
   triggerTreeRerender();
 };
-var collapseAll = function collapseAll(treeRoot, triggerTreeRerender) {
-  treeRoot.walk(function (node) {
+const collapseAll = (treeRoot, triggerTreeRerender) => {
+  treeRoot.walk(node => {
     if (!node.isRoot()) collapseItemModel(node.model);
   });
   triggerTreeRerender();
 };
-var getToggleExpandShouldExpand = function getToggleExpandShouldExpand(treeRoot) {
-  var shouldExpand = false;
-  treeRoot.walk(function (node) {
+const getToggleExpandShouldExpand = treeRoot => {
+  let shouldExpand = false;
+  treeRoot.walk(node => {
     if (!node.isRoot()) {
       if (!node.model.isExpanded && node.model.isGroup) {
         shouldExpand = true; // eslint-disable-next-line no-useless-return
@@ -47,23 +52,21 @@ var getToggleExpandShouldExpand = function getToggleExpandShouldExpand(treeRoot)
   });
   return shouldExpand;
 };
-var toggleExpandAllHelper = function toggleExpandAllHelper(isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem) {
+const toggleExpandAllHelper = (isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem) => {
   if (isExpand === true) expandAll(treeRoot, triggerTreeRerender);else if (isExpand === false) collapseAll(treeRoot, triggerTreeRerender);else {
-    var shouldExpand = getToggleExpandShouldExpand(treeRoot);
+    const shouldExpand = getToggleExpandShouldExpand(treeRoot);
     if (shouldExpand === true) expandAll(treeRoot, triggerTreeRerender);else collapseAll(treeRoot, triggerTreeRerender);
   }
   setLatestToggledItem(null);
 };
-var useNotifyExpandedChange = function useNotifyExpandedChange(propsWithDefaults, _ref) {
-  var latestToggledItem = _ref.latestToggledItem,
-      expandedGroups = _ref.expandedGroups;
-  var notifyExpandedChange = useCallback(function (expandedGroupHashmap) {
-    return propsWithDefaults.onExpandChange(expandedGroupHashmap, latestToggledItem);
-  }, [propsWithDefaults, latestToggledItem]);
-  useEffect(function () {
+const useNotifyExpandedChange = (propsWithDefaults, {
+  latestToggledItem,
+  expandedGroups
+}) => {
+  const notifyExpandedChange = useCallback(expandedGroupHashmap => propsWithDefaults.onExpandChange(expandedGroupHashmap, latestToggledItem), [propsWithDefaults, latestToggledItem]);
+  useEffect(() => {
     notifyExpandedChange(expandedGroups);
   }, [expandedGroups]);
 };
 
 export { collapseAll, collapseItemModel, expandAll, expandItemModel, getToggleExpandShouldExpand, toggleExpandAllHelper, toggleItemExpand, useNotifyExpandedChange };
-//# sourceMappingURL=group-expands-helpers.js.map

package/esm/utils/keyboard-helpers.js

@@ -2,8 +2,6 @@ import { useContext, useCallback, useEffect } from 'react';
 import TreeViewContext from '../TreeViewContext.js';
 import { focusItem } from './tree-helpers.js';
 import { toggleItemExpand, toggleExpandAllHelper } from './group-expands-helpers.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import './string-helpers.js';
 
 /* eslint-disable max-lines */
 // 13 enter
@@ -17,32 +15,37 @@ import './string-helpers.js';
 // 56 number 8
 // 106 (NumPad) *
 
-var useOnItemKeyDown = function useOnItemKeyDown(item) {
-  var ctx = useContext(TreeViewContext);
-  var onItemFocus = ctx.props.onItemFocus,
-      triggerTreeRerender = ctx.triggerTreeRerender,
-      isDragging = ctx.isDragging,
-      visibleItems = ctx.visibleItems,
-      setFocusedItem = ctx.setFocusedItem,
-      setSelectedItem = ctx.setSelectedItem,
-      setLatestToggledItem = ctx.setLatestToggledItem,
-      scrollToIndex = ctx.virtualListHelpers.scrollToIndex;
-  var isGroup = item.isGroup,
-      isExpanded = item.isExpanded;
-  var onItemFocusCurry = useCallback(function (newFocusItem) {
-    return onItemFocus({
-      itemIndex: newFocusItem.virtualIndex,
-      scrollToItem: function scrollToItem() {
-        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-          align: 'start'
-        };
-        return scrollToIndex(newFocusItem.virtualIndex, opts);
-      },
-      item: newFocusItem
-    });
-  }, [onItemFocus]);
-  var onItemKeyDown = useCallback(function (e) {
-    var keyCode = e.keyCode;
+const useOnItemKeyDown = item => {
+  const ctx = useContext(TreeViewContext);
+  const {
+    props: {
+      onItemFocus
+    },
+    triggerTreeRerender,
+    isDragging,
+    visibleItems,
+    setFocusedItem,
+    setSelectedItem,
+    setLatestToggledItem,
+    virtualListHelpers: {
+      scrollToIndex
+    }
+  } = ctx;
+  const {
+    isGroup,
+    isExpanded
+  } = item;
+  const onItemFocusCurry = useCallback(newFocusItem => onItemFocus({
+    itemIndex: newFocusItem.virtualIndex,
+    scrollToItem: (opts = {
+      align: 'start'
+    }) => scrollToIndex(newFocusItem.virtualIndex, opts),
+    item: newFocusItem
+  }), [onItemFocus]);
+  const onItemKeyDown = useCallback(e => {
+    const {
+      keyCode
+    } = e;
 
     if (!isDragging) {
       if (keyCode !== 9) e.preventDefault(); // allow tab/shift+tab
@@ -63,18 +66,20 @@ var useOnItemKeyDown = function useOnItemKeyDown(item) {
         }
       }
 
-      var virtualIndex = item.virtualIndex;
-      var lastItemIndex = visibleItems.length - 1;
+      const {
+        virtualIndex
+      } = item;
+      const lastItemIndex = visibleItems.length - 1;
 
       if (keyCode === 38) {
-        var isLoopedFocus = virtualIndex === 0;
-        var newFocusIndex = isLoopedFocus ? lastItemIndex : virtualIndex - 1;
-        var newFocusItem = visibleItems[newFocusIndex];
+        const isLoopedFocus = virtualIndex === 0;
+        const newFocusIndex = isLoopedFocus ? lastItemIndex : virtualIndex - 1;
+        const newFocusItem = visibleItems[newFocusIndex];
         scrollToIndex(newFocusIndex);
 
         if (isLoopedFocus) {
           // when looping the list from start to end we need to wait a bit before focusing
-          setTimeout(function () {
+          setTimeout(() => {
             setFocusedItem(newFocusItem);
             focusItem(newFocusItem);
             onItemFocusCurry(newFocusItem);
@@ -87,47 +92,45 @@ var useOnItemKeyDown = function useOnItemKeyDown(item) {
       }
 
       if (keyCode === 40) {
-        var _isLoopedFocus = virtualIndex === lastItemIndex;
-
-        var _newFocusIndex = _isLoopedFocus ? 0 : virtualIndex + 1;
-
-        var _newFocusItem = visibleItems[_newFocusIndex];
-        scrollToIndex(_newFocusIndex);
+        const isLoopedFocus = virtualIndex === lastItemIndex;
+        const newFocusIndex = isLoopedFocus ? 0 : virtualIndex + 1;
+        const newFocusItem = visibleItems[newFocusIndex];
+        scrollToIndex(newFocusIndex);
 
-        if (_isLoopedFocus) {
+        if (isLoopedFocus) {
           // when looping the list from start to end we need to wait a bit before focusing
-          setTimeout(function () {
-            setFocusedItem(_newFocusItem);
-            onItemFocusCurry(_newFocusItem);
-            focusItem(_newFocusItem);
+          setTimeout(() => {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            focusItem(newFocusItem);
           }, 300);
         } else {
-          setFocusedItem(_newFocusItem);
-          onItemFocusCurry(_newFocusItem);
-          focusItem(_newFocusItem);
+          setFocusedItem(newFocusItem);
+          onItemFocusCurry(newFocusItem);
+          focusItem(newFocusItem);
         }
       }
 
       if (keyCode === 35) {
         if (virtualIndex !== lastItemIndex) {
-          var _newFocusItem2 = visibleItems[lastItemIndex];
+          const newFocusItem = visibleItems[lastItemIndex];
           scrollToIndex(lastItemIndex);
-          setTimeout(function () {
-            setFocusedItem(_newFocusItem2);
-            onItemFocusCurry(_newFocusItem2);
-            focusItem(_newFocusItem2);
+          setTimeout(() => {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            focusItem(newFocusItem);
           }, 300);
         }
       }
 
       if (keyCode === 36) {
         if (virtualIndex !== 0) {
-          var _newFocusItem3 = visibleItems[0];
+          const newFocusItem = visibleItems[0];
           scrollToIndex(0);
-          setTimeout(function () {
-            setFocusedItem(_newFocusItem3);
-            onItemFocusCurry(_newFocusItem3);
-            focusItem(_newFocusItem3);
+          setTimeout(() => {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            focusItem(newFocusItem);
           }, 300);
         }
       }
@@ -135,18 +138,18 @@ var useOnItemKeyDown = function useOnItemKeyDown(item) {
   }, [item, visibleItems, isGroup, isDragging, onItemFocusCurry, setFocusedItem, setSelectedItem]);
   return onItemKeyDown;
 };
-var useGlobalKeyboardListener = function useGlobalKeyboardListener(func) {
-  useEffect(function () {
+const useGlobalKeyboardListener = func => {
+  useEffect(() => {
     document.addEventListener('keydown', func);
-    return function () {
-      return document.removeEventListener('keydown', func);
-    };
+    return () => document.removeEventListener('keydown', func);
   }, [func]);
 };
-var useGlobalToggleAllExpandShortcut = function useGlobalToggleAllExpandShortcut(treeRoot, triggerTreeRerender, setLatestToggledItem) {
-  var memoizedToggleAllKeyboardShortcut = useCallback(function (e) {
-    var shiftKey = e.shiftKey,
-        keyCode = e.keyCode;
+const useGlobalToggleAllExpandShortcut = (treeRoot, triggerTreeRerender, setLatestToggledItem) => {
+  const memoizedToggleAllKeyboardShortcut = useCallback(e => {
+    const {
+      shiftKey,
+      keyCode
+    } = e;
 
     if (shiftKey && keyCode === 56) {
       toggleExpandAllHelper('toggle', treeRoot, triggerTreeRerender, setLatestToggledItem);
@@ -156,4 +159,3 @@ var useGlobalToggleAllExpandShortcut = function useGlobalToggleAllExpandShortcut
 };
 
 export { useGlobalKeyboardListener, useGlobalToggleAllExpandShortcut, useOnItemKeyDown };
-//# sourceMappingURL=keyboard-helpers.js.map

package/esm/utils/object-helpers.js

@@ -1,5 +1,3 @@
-import _typeof from '@babel/runtime/helpers/esm/typeof';
-
 /* eslint-disable no-sequences */
 
 /* eslint-disable no-return-assign */
@@ -7,8 +5,8 @@ import _typeof from '@babel/runtime/helpers/esm/typeof';
 /* eslint-disable no-restricted-syntax */
 
 /* eslint-disable guard-for-in */
-var unfreeze = function unfreeze(o) {
-  var oo;
+const unfreeze = o => {
+  let oo;
 
   if (o === null) {
     oo = null;
@@ -18,15 +16,15 @@ var unfreeze = function unfreeze(o) {
     oo = new Date(o);
   } else if (o instanceof Array) {
     oo = [];
-    o.forEach(function (v) {
+    o.forEach(v => {
       oo.push(v);
     });
   } else if (o instanceof String) {
     oo = String(o);
-  } else if (_typeof(o) === 'object') {
+  } else if (typeof o === 'object') {
     oo = {};
 
-    for (var property in o) {
+    for (const property in o) {
       oo[property] = o[property];
     }
   } else {
@@ -35,13 +33,6 @@ var unfreeze = function unfreeze(o) {
 
   return oo;
 };
-var filterObject = function filterObject(obj, predicate) {
-  return Object.keys(obj).filter(function (key) {
-    return predicate(obj[key]);
-  }).reduce(function (res, key) {
-    return res[key] = obj[key], res;
-  }, {});
-};
+const filterObject = (obj, predicate) => Object.keys(obj).filter(key => predicate(obj[key])).reduce((res, key) => (res[key] = obj[key], res), {});
 
 export { filterObject, unfreeze };
-//# sourceMappingURL=object-helpers.js.map

package/esm/utils/refs-helpers.js

@@ -1,14 +1,10 @@
 // allow multiple refs to be set to point to the same DOM element
-var setMultipleRefs = function setMultipleRefs() {
-  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
-    refs[_key] = arguments[_key];
-  }
-
-  var filteredRefs = refs.filter(Boolean);
+const setMultipleRefs = (...refs) => {
+  const filteredRefs = refs.filter(Boolean);
   if (!filteredRefs.length) return null;
   if (filteredRefs.length === 0) return filteredRefs[0];
-  return function (newRef) {
-    filteredRefs.forEach(function (refToBeUpdated) {
+  return newRef => {
+    filteredRefs.forEach(refToBeUpdated => {
       if (typeof refToBeUpdated === 'function') {
         refToBeUpdated(newRef);
       } else if (refToBeUpdated) {
@@ -19,4 +15,3 @@ var setMultipleRefs = function setMultipleRefs() {
 };
 
 export { setMultipleRefs };
-//# sourceMappingURL=refs-helpers.js.map

package/esm/utils/selectable-helper.js

@@ -1,59 +1,63 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import { walkAllNodeChildren, walkParents } from './tree-helpers.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import 'react';
-import './string-helpers.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-var getGroupCheckState = function getGroupCheckState(node) {
-  var childAllChecked = true;
-  var anyChildChecked = false;
-  walkAllNodeChildren(node, function (childNode) {
-    var isChecked = childNode.model.isChecked;
+const getGroupCheckState = node => {
+  let childAllChecked = true;
+  let anyChildChecked = false;
+  walkAllNodeChildren(node, childNode => {
+    const {
+      model: {
+        isChecked
+      }
+    } = childNode;
     if (isChecked === 'mixed' || isChecked === true) anyChildChecked = true;else childAllChecked = false;
   });
   if (childAllChecked) return true;
   if (anyChildChecked) return 'mixed';
   return false;
 };
-var selectCheckboxItemModelParentsTillRoot = function selectCheckboxItemModelParentsTillRoot(modelToCheck) {
-  var triggerTreeRerender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  var newSelections = {};
-  var nodePath = modelToCheck.nodePath;
-  walkParents(nodePath, function (parentNode) {
-    var nextState = getGroupCheckState(parentNode);
+const selectCheckboxItemModelParentsTillRoot = (modelToCheck, triggerTreeRerender = null) => {
+  const newSelections = {};
+  const {
+    nodePath
+  } = modelToCheck;
+  walkParents(nodePath, parentNode => {
+    const nextState = getGroupCheckState(parentNode);
     parentNode.model.isChecked = nextState;
     newSelections[parentNode.model.id] = nextState;
   });
   if (triggerTreeRerender) triggerTreeRerender();
   return newSelections;
 };
-var toggleCheckboxItem = function toggleCheckboxItem(itemToSelect) {
-  var triggerTreeRerender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  var _itemToSelect$node$mo = itemToSelect.node.model,
-      id = _itemToSelect$node$mo.id,
-      isChecked = _itemToSelect$node$mo.isChecked,
-      _itemToSelect$node$mo2 = _itemToSelect$node$mo.children,
-      children = _itemToSelect$node$mo2 === void 0 ? [] : _itemToSelect$node$mo2;
-  var newSelections = {}; // 'mixed' -> true -> false -> true [...->false -> true]
+const toggleCheckboxItem = (itemToSelect, triggerTreeRerender = null) => {
+  const {
+    node: {
+      model: {
+        id,
+        isChecked,
+        children = []
+      }
+    }
+  } = itemToSelect;
+  const newSelections = {}; // 'mixed' -> true -> false -> true [...->false -> true]
 
-  var nextState = isChecked === 'mixed' ? true : !isChecked;
+  const nextState = isChecked === 'mixed' ? true : !isChecked;
   itemToSelect.node.model.isChecked = nextState;
   newSelections[id] = nextState;
 
   if (children.length > 0 && (nextState === true || nextState === false)) {
-    walkAllNodeChildren(itemToSelect.node, function (childNode) {
+    walkAllNodeChildren(itemToSelect.node, childNode => {
       childNode.model.isChecked = nextState;
       newSelections[childNode.model.id] = nextState;
     });
   }
 
-  var parentsNewSelections = selectCheckboxItemModelParentsTillRoot(itemToSelect);
+  const parentsNewSelections = selectCheckboxItemModelParentsTillRoot(itemToSelect);
   if (triggerTreeRerender) triggerTreeRerender();
   return _objectSpread(_objectSpread({}, parentsNewSelections), newSelections);
 };
 
 export { getGroupCheckState, selectCheckboxItemModelParentsTillRoot, toggleCheckboxItem };
-//# sourceMappingURL=selectable-helper.js.map

package/esm/utils/string-helpers.js

@@ -1,6 +1,3 @@
-var standardizeSearchQueryString = function standardizeSearchQueryString(input) {
-  return input.trim().toLowerCase();
-};
+const standardizeSearchQueryString = input => input.trim().toLowerCase();
 
 export { standardizeSearchQueryString };
-//# sourceMappingURL=string-helpers.js.map