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

package/cjs/utils/keyboard-helpers.js

@@ -4,10 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
 var TreeViewContext = require('../TreeViewContext.js');
-var utils_treeHelpers = require('./tree-helpers.js');
-var utils_groupExpandsHelpers = require('./group-expands-helpers.js');
-require('@babel/runtime/helpers/toConsumableArray');
-require('./string-helpers.js');
+var treeHelpers = require('./tree-helpers.js');
+var groupExpandsHelpers = require('./group-expands-helpers.js');
 
 /* eslint-disable max-lines */
 // 13 enter
@@ -21,32 +19,37 @@ require('./string-helpers.js');
 // 56 number 8
 // 106 (NumPad) *
 
-var useOnItemKeyDown = function useOnItemKeyDown(item) {
-  var ctx = React.useContext(TreeViewContext['default']);
-  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 = React.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 = React.useCallback(function (e) {
-    var keyCode = e.keyCode;
+const useOnItemKeyDown = item => {
+  const ctx = React.useContext(TreeViewContext["default"]);
+  const {
+    props: {
+      onItemFocus
+    },
+    triggerTreeRerender,
+    isDragging,
+    visibleItems,
+    setFocusedItem,
+    setSelectedItem,
+    setLatestToggledItem,
+    virtualListHelpers: {
+      scrollToIndex
+    }
+  } = ctx;
+  const {
+    isGroup,
+    isExpanded
+  } = item;
+  const onItemFocusCurry = React.useCallback(newFocusItem => onItemFocus({
+    itemIndex: newFocusItem.virtualIndex,
+    scrollToItem: (opts = {
+      align: 'start'
+    }) => scrollToIndex(newFocusItem.virtualIndex, opts),
+    item: newFocusItem
+  }), [onItemFocus]);
+  const onItemKeyDown = React.useCallback(e => {
+    const {
+      keyCode
+    } = e;
 
     if (!isDragging) {
       if (keyCode !== 9) e.preventDefault(); // allow tab/shift+tab
@@ -55,83 +58,83 @@ var useOnItemKeyDown = function useOnItemKeyDown(item) {
 
       if (keyCode === 37) {
         if (isGroup && isExpanded) {
-          utils_groupExpandsHelpers.toggleItemExpand(item, triggerTreeRerender, scrollToIndex);
+          groupExpandsHelpers.toggleItemExpand(item, triggerTreeRerender, scrollToIndex);
           setLatestToggledItem(item);
         }
       }
 
       if (keyCode === 39) {
         if (isGroup && !isExpanded) {
-          utils_groupExpandsHelpers.toggleItemExpand(item, triggerTreeRerender, scrollToIndex);
+          groupExpandsHelpers.toggleItemExpand(item, triggerTreeRerender, scrollToIndex);
           setLatestToggledItem(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);
-            utils_treeHelpers.focusItem(newFocusItem);
+            treeHelpers.focusItem(newFocusItem);
             onItemFocusCurry(newFocusItem);
           }, 300);
         } else {
           setFocusedItem(newFocusItem);
           onItemFocusCurry(newFocusItem);
-          utils_treeHelpers.focusItem(newFocusItem);
+          treeHelpers.focusItem(newFocusItem);
         }
       }
 
       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);
-            utils_treeHelpers.focusItem(_newFocusItem);
+          setTimeout(() => {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            treeHelpers.focusItem(newFocusItem);
           }, 300);
         } else {
-          setFocusedItem(_newFocusItem);
-          onItemFocusCurry(_newFocusItem);
-          utils_treeHelpers.focusItem(_newFocusItem);
+          setFocusedItem(newFocusItem);
+          onItemFocusCurry(newFocusItem);
+          treeHelpers.focusItem(newFocusItem);
         }
       }
 
       if (keyCode === 35) {
         if (virtualIndex !== lastItemIndex) {
-          var _newFocusItem2 = visibleItems[lastItemIndex];
+          const newFocusItem = visibleItems[lastItemIndex];
           scrollToIndex(lastItemIndex);
-          setTimeout(function () {
-            setFocusedItem(_newFocusItem2);
-            onItemFocusCurry(_newFocusItem2);
-            utils_treeHelpers.focusItem(_newFocusItem2);
+          setTimeout(() => {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            treeHelpers.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);
-            utils_treeHelpers.focusItem(_newFocusItem3);
+          setTimeout(() => {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            treeHelpers.focusItem(newFocusItem);
           }, 300);
         }
       }
@@ -139,21 +142,21 @@ var useOnItemKeyDown = function useOnItemKeyDown(item) {
   }, [item, visibleItems, isGroup, isDragging, onItemFocusCurry, setFocusedItem, setSelectedItem]);
   return onItemKeyDown;
 };
-var useGlobalKeyboardListener = function useGlobalKeyboardListener(func) {
-  React.useEffect(function () {
+const useGlobalKeyboardListener = func => {
+  React.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 = React.useCallback(function (e) {
-    var shiftKey = e.shiftKey,
-        keyCode = e.keyCode;
+const useGlobalToggleAllExpandShortcut = (treeRoot, triggerTreeRerender, setLatestToggledItem) => {
+  const memoizedToggleAllKeyboardShortcut = React.useCallback(e => {
+    const {
+      shiftKey,
+      keyCode
+    } = e;
 
     if (shiftKey && keyCode === 56) {
-      utils_groupExpandsHelpers.toggleExpandAllHelper('toggle', treeRoot, triggerTreeRerender, setLatestToggledItem);
+      groupExpandsHelpers.toggleExpandAllHelper('toggle', treeRoot, triggerTreeRerender, setLatestToggledItem);
     }
   }, [treeRoot, triggerTreeRerender]);
   return useGlobalKeyboardListener(memoizedToggleAllKeyboardShortcut);
@@ -162,4 +165,3 @@ var useGlobalToggleAllExpandShortcut = function useGlobalToggleAllExpandShortcut
 exports.useGlobalKeyboardListener = useGlobalKeyboardListener;
 exports.useGlobalToggleAllExpandShortcut = useGlobalToggleAllExpandShortcut;
 exports.useOnItemKeyDown = useOnItemKeyDown;
-//# sourceMappingURL=keyboard-helpers.js.map

package/cjs/utils/object-helpers.js

@@ -2,12 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _typeof = require('@babel/runtime/helpers/typeof');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
-
 /* eslint-disable no-sequences */
 
 /* eslint-disable no-return-assign */
@@ -15,8 +9,8 @@ var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_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;
@@ -26,15 +20,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__default['default'](o) === 'object') {
+  } else if (typeof o === 'object') {
     oo = {};
 
-    for (var property in o) {
+    for (const property in o) {
       oo[property] = o[property];
     }
   } else {
@@ -43,14 +37,7 @@ 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), {});
 
 exports.filterObject = filterObject;
 exports.unfreeze = unfreeze;
-//# sourceMappingURL=object-helpers.js.map

package/cjs/utils/refs-helpers.js

@@ -3,16 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 // 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) {
@@ -23,4 +19,3 @@ var setMultipleRefs = function setMultipleRefs() {
 };
 
 exports.setMultipleRefs = setMultipleRefs;
-//# sourceMappingURL=refs-helpers.js.map

package/cjs/utils/selectable-helper.js

@@ -3,10 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var utils_treeHelpers = require('./tree-helpers.js');
-require('@babel/runtime/helpers/toConsumableArray');
-require('react');
-require('./string-helpers.js');
+var treeHelpers = require('./tree-helpers.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -14,51 +11,59 @@ var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_definePropert
 
 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__default['default'](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;
-  utils_treeHelpers.walkAllNodeChildren(node, function (childNode) {
-    var isChecked = childNode.model.isChecked;
+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__default["default"](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; }
+const getGroupCheckState = node => {
+  let childAllChecked = true;
+  let anyChildChecked = false;
+  treeHelpers.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;
-  utils_treeHelpers.walkParents(nodePath, function (parentNode) {
-    var nextState = getGroupCheckState(parentNode);
+const selectCheckboxItemModelParentsTillRoot = (modelToCheck, triggerTreeRerender = null) => {
+  const newSelections = {};
+  const {
+    nodePath
+  } = modelToCheck;
+  treeHelpers.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)) {
-    utils_treeHelpers.walkAllNodeChildren(itemToSelect.node, function (childNode) {
+    treeHelpers.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);
 };
@@ -66,4 +71,3 @@ var toggleCheckboxItem = function toggleCheckboxItem(itemToSelect) {
 exports.getGroupCheckState = getGroupCheckState;
 exports.selectCheckboxItemModelParentsTillRoot = selectCheckboxItemModelParentsTillRoot;
 exports.toggleCheckboxItem = toggleCheckboxItem;
-//# sourceMappingURL=selectable-helper.js.map

package/cjs/utils/string-helpers.js

@@ -2,9 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var standardizeSearchQueryString = function standardizeSearchQueryString(input) {
-  return input.trim().toLowerCase();
-};
+const standardizeSearchQueryString = input => input.trim().toLowerCase();
 
 exports.standardizeSearchQueryString = standardizeSearchQueryString;
-//# sourceMappingURL=string-helpers.js.map

package/cjs/utils/tree-helpers.js

@@ -2,133 +2,113 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
 var React = require('react');
-var utils_stringHelpers = require('./string-helpers.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
-
-var walkVisibles = function walkVisibles(node, callback) {
-  var skipRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  var highlightOnlyQuery = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var children = node.children,
-      model = node.model;
-  var name = model.name,
-      isExpanded = model.isExpanded,
-      childrenMatchesSearchQuery = model.childrenMatchesSearchQuery,
-      matchesSearchQuery = model.matchesSearchQuery;
-  var shouldSkipBecauseIsRoot = skipRoot && name === '__root';
-  var queryRestrictionsPassed = highlightOnlyQuery || childrenMatchesSearchQuery || matchesSearchQuery;
+var stringHelpers = require('./string-helpers.js');
+
+/* eslint-disable max-params */
+const walkVisibles = (node, callback, skipRoot = true, highlightOnlyQuery = false) => {
+  const {
+    children,
+    model
+  } = node;
+  const {
+    name,
+    isExpanded,
+    childrenMatchesSearchQuery,
+    matchesSearchQuery
+  } = model;
+  const shouldSkipBecauseIsRoot = skipRoot && name === '__root';
+  const queryRestrictionsPassed = highlightOnlyQuery || childrenMatchesSearchQuery || matchesSearchQuery;
   if (!shouldSkipBecauseIsRoot && queryRestrictionsPassed) callback(node);
-  var shouldWalkChildren = children.length && isExpanded && queryRestrictionsPassed;
+  const shouldWalkChildren = children.length && isExpanded && queryRestrictionsPassed;
 
   if (shouldWalkChildren) {
-    children.forEach(function (childNode) {
+    children.forEach(childNode => {
       walkVisibles(childNode, callback, skipRoot, highlightOnlyQuery);
     });
   }
 };
-var walkParents = function walkParents(nodePath, callback) {
-  var skipRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
-  var parents = _toConsumableArray__default['default'](nodePath).reverse();
-
+const walkParents = (nodePath, callback, skipRoot = true) => {
+  const parents = [...nodePath].reverse();
   parents.shift(); // remove current node from the parents array
 
   if (skipRoot) parents.pop(); // remove the root from the parents if skipping root
 
   parents.forEach(callback);
 };
-var walkAllNodeChildren = function walkAllNodeChildren(node, callback) {
-  var isFirst = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  var _node$children = node.children,
-      children = _node$children === void 0 ? [] : _node$children;
-  var shouldWalkChildren = children.length;
+const walkAllNodeChildren = (node, callback, isFirst = true) => {
+  const {
+    children = []
+  } = node;
+  const shouldWalkChildren = children.length;
   if (!isFirst) callback(node);
 
   if (shouldWalkChildren) {
-    children.forEach(function (childNode) {
+    children.forEach(childNode => {
       walkAllNodeChildren(childNode, callback, false);
     });
   }
 };
-var getNodeById = function getNodeById(treeRoot, id) {
-  var nodes = treeRoot.all(function (node) {
-    return node.model.id === id;
-  });
+const getNodeById = (treeRoot, id) => {
+  const nodes = treeRoot.all(node => node.model.id === id);
   return nodes[0];
 };
-var cloneNode = function cloneNode(tree, node) {
-  return tree.parse(node.model);
-};
-var getItemsParentNode = function getItemsParentNode() {
-  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  var skipSameParentCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+const cloneNode = (tree, node) => tree.parse(node.model);
+const getItemsParentNode = (items = [], skipSameParentCheck = false) => {
   if (items.length === 0) throw new Error("Received empty items, can't retrieve parent"); // in case we already know the items compared shares the same parent
 
   if (!skipSameParentCheck) if (!itemsShareSameParent(items)) // if we don't know (default, we don't) check if they share the parent
     throw new Error("Received items don't share the same parent, can't retrieve parent"); // when moving in first position we receive [undefined,...{items}]
   // when moving in last position we receive [...{items}, undefined]
 
-  var firstExistingItem = items.find(function (item) {
-    return !!item;
-  });
+  const firstExistingItem = items.find(item => !!item);
   if (!firstExistingItem) throw new Error("Received no items, can't retrieve parent");
-  var firstExistingItemPath = firstExistingItem.node.getPath(); // path is like [rootParent, ...[parentsNodes], currentNode]
+  const firstExistingItemPath = firstExistingItem.node.getPath(); // path is like [rootParent, ...[parentsNodes], currentNode]
   // length -1 is the current-node
   // length -2 is the parent-node
   // root node is not printed and is always present so minimum path length is 2 (root + currentNode)
 
-  var directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];
+  const directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];
   return directParentNode;
 };
-var itemsShareSameParent = function itemsShareSameParent() {
-  var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+const itemsShareSameParent = (items = []) => {
   if (items.length === 0) throw new Error('Received empty items for comparison');
   if (items.length === 1) return true; // when moving in first position we receive [undefined,...{items}]
   // when moving in last position we receive [...{items}, undefined]
 
-  var firstExistingItem = items.find(function (item) {
-    return !!item;
-  });
+  const firstExistingItem = items.find(item => !!item);
   if (!firstExistingItem) throw new Error("Received no items, can't retrieve parent");
-  var firstExistingItemPath = firstExistingItem.node.getPath(); // path is like [rootParent, ...[parentsNodes], currentNode]
+  const firstExistingItemPath = firstExistingItem.node.getPath(); // path is like [rootParent, ...[parentsNodes], currentNode]
   // length -1 is the current-node
   // length -2 is the parent-node
   // root node is not printed and is always present so minimum path length is 2 (root + currentNode)
 
-  var directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];
-  return items.every(function (item) {
+  const directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];
+  return items.every(item => {
     // undefined nodes count as having the same parent
     if (!item) return true;
-    var itemPath = item.node.getPath();
-    var itemDirectParent = itemPath[itemPath.length - 2];
+    const itemPath = item.node.getPath();
+    const itemDirectParent = itemPath[itemPath.length - 2];
     return directParentNode === itemDirectParent;
   });
 };
-var getNodeMatchesSearchQuery = function getNodeMatchesSearchQuery(node) {
-  var searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var standardizedName = utils_stringHelpers.standardizeSearchQueryString(node.model.name);
-  var standardizedSearchQuery = utils_stringHelpers.standardizeSearchQueryString(searchQuery);
+const getNodeMatchesSearchQuery = (node, searchQuery = '') => {
+  const standardizedName = stringHelpers.standardizeSearchQueryString(node.model.name);
+  const standardizedSearchQuery = stringHelpers.standardizeSearchQueryString(searchQuery);
   return standardizedName.includes(standardizedSearchQuery);
 };
-var getChildrenMatchesSearchQuery = function getChildrenMatchesSearchQuery(parentNode) {
-  var searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var anyChildMatch = false;
-  walkAllNodeChildren(parentNode, function (node) {
+const getChildrenMatchesSearchQuery = (parentNode, searchQuery = '') => {
+  let anyChildMatch = false;
+  walkAllNodeChildren(parentNode, node => {
     if (getNodeMatchesSearchQuery(node, searchQuery)) anyChildMatch = true;
   });
   return anyChildMatch;
 };
-var enrichNodeModelInPlace = function enrichNodeModelInPlace(node) {
+const enrichNodeModelInPlace = (node, searchQuery = '', selection = null) => {
   var _node$model, _node$model$children;
 
-  var searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var selection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-  var path = node.getPath();
-  var depth = path.length - 1;
+  const path = node.getPath();
+  const depth = path.length - 1;
   node.model.nodePath = path;
   node.model.treeDepth = depth;
 
@@ -162,7 +142,7 @@ var enrichNodeModelInPlace = function enrichNodeModelInPlace(node) {
     node.model.isChecked = selection[node.model.id];
   }
 };
-var focusItem = function focusItem(item) {
+const focusItem = item => {
   var _item$nodeItemRef, _item$nodeItemRef$cur;
 
   item === null || item === void 0 ? void 0 : (_item$nodeItemRef = item.nodeItemRef) === null || _item$nodeItemRef === void 0 ? void 0 : (_item$nodeItemRef$cur = _item$nodeItemRef.current) === null || _item$nodeItemRef$cur === void 0 ? void 0 : _item$nodeItemRef$cur.focus();
@@ -179,4 +159,3 @@ exports.itemsShareSameParent = itemsShareSameParent;
 exports.walkAllNodeChildren = walkAllNodeChildren;
 exports.walkParents = walkParents;
 exports.walkVisibles = walkVisibles;
-//# sourceMappingURL=tree-helpers.js.map