@elliemae/ds-treeview 2.0.0-alpha.1 → 2.0.0-alpha.13

package/esm/parts/TreeItem.js

@@ -1,9 +1,15 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import { useRef, useState, useContext, useMemo, useCallback } from 'react';
 import { SortableHandle, SortableElement } from '@elliemae/react-sortable-hoc';
 import { aggregatedClasses } from '@elliemae/ds-classnames';
-import GripperVertical from '@elliemae/ds-icons/GripperVertical';
+import { GripperVertical } from '@elliemae/ds-icons';
 import RadioSelectable from './RadioSelectable.js';
 import CheckboxSelectable from './CheckboxSelectable.js';
 import TreeViewContext from '../TreeViewContext.js';
@@ -24,20 +30,23 @@ const TreeListItem = aggregatedClasses('li', {
   role: 'treeitem'
 })(treeItemBlockName);
 const TreeListItemAddonsWrapper = aggregatedClasses('div')(treeItemBlockName, 'addons');
-const DnDHandle = SortableHandle(({
-  id
-}) => /*#__PURE__*/_jsx(GripperVertical, {
-  "data-testid": "drag-handle",
-  className: "drag-handle",
-  size: "s",
-  onMouseDown: e => {
-    // prevent focusing the drag-handle to avoid borders
-    if (e) {
-      e.preventDefault();
-    }
-  },
-  tabIndex: "0"
-}, `${id}-drag-handle`));
+const DnDHandle = SortableHandle(_ref => {
+  let {
+    id
+  } = _ref;
+  return /*#__PURE__*/_jsx(GripperVertical, {
+    "data-testid": "drag-handle",
+    className: "drag-handle",
+    size: "s",
+    onMouseDown: e => {
+      // prevent focusing the drag-handle to avoid borders
+      if (e) {
+        e.preventDefault();
+      }
+    },
+    tabIndex: "0"
+  }, "".concat(id, "-drag-handle"));
+});
 const TreeItem = props => {
   const {
     item,
@@ -96,7 +105,7 @@ const TreeItem = props => {
       isAfter,
       isValid
     } = relativeMouseCord;
-    let className = `${DSTreeViewPrefix}-${treeItemBlockName}${isValid ? '--valid' : '--invalid'}`;
+    let className = "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName).concat(isValid ? '--valid' : '--invalid');
     if (isBefore) className += '-drop-before';else if (isAfter) className += '-drop-after';else className += '-drop-in';
     return className;
   }, [withDragAndDrop, relativeMouseCord, isDraggingOverThis]);
@@ -104,22 +113,25 @@ const TreeItem = props => {
   const hoverClassName = useMemo(() => (hoverItem === null || hoverItem === void 0 ? void 0 : hoverItem.id) !== item.id || withDragAndDrop && isDragging ? '' : 'hover', [hoverItem, withDragAndDrop, isDragging]);
   const fixedHeightClassname = useMemo(() => {
     if (labelOverflow === 'truncate') {
-      if (rowSize === 'compact') return `${DSTreeViewPrefix}-${treeItemBlockName}--fixed-height-compact`;
-      return `${DSTreeViewPrefix}-${treeItemBlockName}--fixed-height`;
+      if (rowSize === 'compact') return "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "--fixed-height-compact");
+      return "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "--fixed-height");
     }
 
     return '';
   }, [labelOverflow, rowSize]);
-  const finalClassName = useMemo(() => `${dropPreviewClassName} ${fixedHeightClassname} ${selectedClassName} ${hoverClassName}`, [dropPreviewClassName, selectedClassName, hoverClassName, fixedHeightClassname]);
+  const finalClassName = useMemo(() => "".concat(dropPreviewClassName, " ").concat(fixedHeightClassname, " ").concat(selectedClassName, " ").concat(hoverClassName), [dropPreviewClassName, selectedClassName, hoverClassName, fixedHeightClassname]);
   const handleItemClick = useCallback(e => {
     onItemClick(item, e);
     setFocusedItem(item);
     setSelectedItem(item);
     onItemFocus({
       itemIndex: item.virtualIndex,
-      scrollToItem: (opts = {
-        align: 'start'
-      }) => scrollToIndex(item.virtualIndex, opts),
+      scrollToItem: function () {
+        let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          align: 'start'
+        };
+        return scrollToIndex(item.virtualIndex, opts);
+      },
       item
     });
   }, [item, scrollToIndex, onItemClick, onItemFocus, setSelectedItem, setFocusedItem]);

package/esm/parts/TreeItemText.js

@@ -1,25 +1,28 @@
 import _jsx from '@babel/runtime/helpers/esm/jsx';
 import { useContext, useMemo } from 'react';
 import Highlighter from 'react-highlight-words';
-import { SimpleTruncatedTooltipText } from '@elliemae/ds-basic';
+import { SimpleTruncatedTooltipText } from '@elliemae/ds-truncated-tooltip-text';
 import { aggregatedClasses } from '@elliemae/ds-classnames';
 import { ChildrenCountDisplayer } from './ChildrenCountDisplayer.js';
 import { treeItemBlockName, DSTreeViewPrefix } from '../config/cssClassesConstants.js';
 import TreeViewContext from '../TreeViewContext.js';
 import { jsxs, Fragment } from 'react/jsx-runtime';
 
-const ItemContent = aggregatedClasses('div')(`${treeItemBlockName}-content`);
+const ItemContent = aggregatedClasses('div')("".concat(treeItemBlockName, "-content"));
 const ItemValue = aggregatedClasses('span')(treeItemBlockName, 'value'); // const wrapperClassName = `${DSTreeViewPrefix}-${treeItemBlockName}-content`;
 
-const classNameModifierWrapAll = `${DSTreeViewPrefix}-${treeItemBlockName}__value--wrap-all`;
-const classNameModifierTruncate = `${DSTreeViewPrefix}-${treeItemBlockName}__value--truncate`; // eslint-disable-next-line react/prop-types
+const classNameModifierWrapAll = "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "__value--wrap-all");
+const classNameModifierTruncate = "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "__value--truncate"); // eslint-disable-next-line react/prop-types
 
-const CustomHighlight = ({
-  children
-}) => /*#__PURE__*/_jsx("mark", {
-  className: "tree-text-highlight",
-  "data-testid": "tree-text-highlight"
-}, void 0, children);
+const CustomHighlight = _ref => {
+  let {
+    children
+  } = _ref;
+  return /*#__PURE__*/_jsx("mark", {
+    className: "tree-text-highlight",
+    "data-testid": "tree-text-highlight"
+  }, void 0, children);
+};
 
 function TreeItemText(props) {
   var _ChildrenCountDisplay, _ChildrenCountDisplay2, _ChildrenCountDisplay3, _ChildrenCountDisplay4;
@@ -84,10 +87,10 @@ function TreeItemText(props) {
     });
   }, [item, searchQuery, nameKey, showChildrenAmount, labelOverflow]);
   let className = '';
-  if (labelOverflow === 'wrap-all') className += `${classNameModifierWrapAll} `;
-  if (labelOverflow === 'truncate') className += `${classNameModifierTruncate} `;
+  if (labelOverflow === 'wrap-all') className += "".concat(classNameModifierWrapAll, " ");
+  if (labelOverflow === 'truncate') className += "".concat(classNameModifierTruncate, " ");
   return /*#__PURE__*/_jsx(ItemContent, {
-    "data-testid": `${treeItemBlockName}-content`
+    "data-testid": "".concat(treeItemBlockName, "-content")
   }, void 0, /*#__PURE__*/_jsx(ItemValue, {
     className: className
   }, void 0, Text));

package/esm/parts/TreeList.js

@@ -1,9 +1,16 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import { useContext } from 'react';
 import { SortableContainer } from '@elliemae/react-sortable-hoc';
 import { aggregatedClasses } from '@elliemae/ds-classnames';
-import { DSCircularProgressIndicator } from '@elliemae/ds-basic/CircularProgressIndicator';
+import { DSCircularProgressIndicator } from '@elliemae/ds-circular-progress-indicator';
 import TreeViewContext from '../TreeViewContext.js';
 import { DragAndDropTreeItem, TreeItem } from './TreeItem.js';
 import { treeListBlockName, DSTreeViewPrefix } from '../config/cssClassesConstants.js';
@@ -12,20 +19,23 @@ import { jsxs, jsx } from 'react/jsx-runtime';
 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; }
-const treeListNoItemsBn = `${treeListBlockName}-no-items`;
+const treeListNoItemsBn = "".concat(treeListBlockName, "-no-items");
 const TreeListNoItems = aggregatedClasses('div', {
   'data-testid': treeListNoItemsBn
 })(treeListNoItemsBn);
 const TreeListWrapper = aggregatedClasses('ul', {
   'data-testid': treeListBlockName,
   role: 'tree'
-})(treeListBlockName, null, ({
-  rowSize
-}) => ({
-  [`rowsize-${rowSize}`]: rowSize
-}));
-const compactRowClass = `${DSTreeViewPrefix}-tv-row-size-compact`;
-const normaRowClass = `${DSTreeViewPrefix}-tv-row-size-normal`;
+})(treeListBlockName, null, _ref => {
+  let {
+    rowSize
+  } = _ref;
+  return {
+    ["rowsize-".concat(rowSize)]: rowSize
+  };
+});
+const compactRowClass = "".concat(DSTreeViewPrefix, "-tv-row-size-compact");
+const normaRowClass = "".concat(DSTreeViewPrefix, "-tv-row-size-normal");
 const TreeList = props => {
   const {
     onMouseDragOverItem
@@ -48,13 +58,13 @@ const TreeList = props => {
     totalSize,
     virtualItems
   } = virtualListHelpers;
-  const className = `${rowSize === 'compact' ? `${compactRowClass}` : `${normaRowClass}`}`;
+  const className = "".concat(rowSize === 'compact' ? "".concat(compactRowClass) : "".concat(normaRowClass));
   return /*#__PURE__*/jsxs(TreeListWrapper, {
     ref: virtualListRef,
     className: className,
     style: {
-      height: `${typeof height === 'number' ? `${height}px` : height}`,
-      width: `${typeof width === 'number' ? `${width}px` : width}`,
+      height: "".concat(typeof height === 'number' ? "".concat(height, "px") : height),
+      width: "".concat(typeof width === 'number' ? "".concat(width, "px") : width),
       overflow: 'auto'
     },
     children: [isLoading ? /*#__PURE__*/_jsx("div", {
@@ -73,7 +83,7 @@ const TreeList = props => {
       showTooltip: false
     })) : null, !isLoading && virtualItems.length === 0 ? /*#__PURE__*/_jsx(TreeListNoItems, {}, void 0, noItemsPlaceholder) : null, !isLoading && virtualItems.length !== 0 ? /*#__PURE__*/_jsx("div", {
       style: {
-        height: `${totalSize}px`,
+        height: "".concat(totalSize, "px"),
         width: '100%',
         position: 'relative'
       }
@@ -93,10 +103,10 @@ const TreeList = props => {
         top: 0,
         left: 0,
         width: '100%',
-        transform: `translateY(${start}px)`
+        transform: "translateY(".concat(start, "px)")
       };
       const listItemProps = {
-        key: `DS-TreeView-List-Item-${id}`,
+        key: "DS-TreeView-List-Item-".concat(id),
         virtualItemRef: measureRef,
         index,
         // this is consumed by the DnD HOC

package/esm/related-components/TreeViewSearchBar.js

@@ -1,6 +1,6 @@
 import _jsx from '@babel/runtime/helpers/esm/jsx';
 import 'react';
-import { DSNavSearchBox } from '@elliemae/ds-basic';
+import { DSNavSearchBox } from '@elliemae/ds-form';
 
 function TreeViewSearchBar(props) {
   const {

package/esm/utils/array-helpers.js

@@ -1,3 +1,5 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+
 // https://github.com/sindresorhus/array-move/blob/master/index.js
 const arrayMoveMutate = (array, from, to) => {
   const startIndex = from < 0 ? array.length + from : from;

package/esm/utils/dnd-helpers.js

@@ -8,13 +8,14 @@ const keyCodes = {
   up: [38, 37],
   down: [40, 39]
 };
-const sameParentAsHoverItemDrop = ({
-  isBefore,
-  isAfter,
-  draggedItem,
-  overItem,
-  movementDirection
-}) => {
+const sameParentAsHoverItemDrop = _ref => {
+  let {
+    isBefore,
+    isAfter,
+    draggedItem,
+    overItem,
+    movementDirection
+  } = _ref;
   const hoveredItemNodeNestedIndex = overItem.node.getIndex();
   let newParentNode = getItemsParentNode([overItem], true);
   const {
@@ -40,13 +41,14 @@ const sameParentAsHoverItemDrop = ({
     newParentNode
   };
 };
-const inferHoverItemKinshipDrop = ({
-  isBefore,
-  isAfter,
-  draggedItem,
-  overItem,
-  movementDirection
-}) => {
+const inferHoverItemKinshipDrop = _ref2 => {
+  let {
+    isBefore,
+    isAfter,
+    draggedItem,
+    overItem,
+    movementDirection
+  } = _ref2;
   const hoverItemModel = overItem.node.model;
   const isGroupAndIsExpanded = hoverItemModel.isExpanded && hoverItemModel.children.length > 0;
 
@@ -75,13 +77,14 @@ const inferHoverItemKinshipDrop = ({
     newParentNode: overItem.node
   };
 };
-const isDropValid = ({
-  isBefore,
-  isAfter,
-  draggedItem,
-  overItem,
-  restrictDragAndDrop
-}) => {
+const isDropValid = _ref3 => {
+  let {
+    isBefore,
+    isAfter,
+    draggedItem,
+    overItem,
+    restrictDragAndDrop
+  } = _ref3;
   const {
     id: movedId
   } = draggedItem;
@@ -105,11 +108,12 @@ const isDropValid = ({
 
   return true;
 };
-const inferKeyboardKinshipDrop = ({
-  items,
-  newIndex // movementDirection,
+const inferKeyboardKinshipDrop = _ref4 => {
+  let {
+    items,
+    newIndex // movementDirection,
 
-}) => {
+  } = _ref4;
   const kinship = {}; // const directionOffset = movementDirection === 'topToBottom' ? 0 : 0;
 
   const itemBefore = items[newIndex];

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

@@ -1,7 +1,8 @@
 import { useCallback, useEffect } from 'react';
 
 /* eslint-disable max-params */
-const toggleItemExpand = (itemToToggle, triggerTreeRerender, scrollTo = () => {}) => {
+const toggleItemExpand = function (itemToToggle, triggerTreeRerender) {
+  let scrollTo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};
   const {
     node: {
       model: {
@@ -59,10 +60,11 @@ const toggleExpandAllHelper = (isExpand, treeRoot, triggerTreeRerender, setLates
   }
   setLatestToggledItem(null);
 };
-const useNotifyExpandedChange = (propsWithDefaults, {
-  latestToggledItem,
-  expandedGroups
-}) => {
+const useNotifyExpandedChange = (propsWithDefaults, _ref) => {
+  let {
+    latestToggledItem,
+    expandedGroups
+  } = _ref;
   const notifyExpandedChange = useCallback(expandedGroupHashmap => propsWithDefaults.onExpandChange(expandedGroupHashmap, latestToggledItem), [propsWithDefaults, latestToggledItem]);
   useEffect(() => {
     notifyExpandedChange(expandedGroups);

package/esm/utils/keyboard-helpers.js

@@ -37,9 +37,12 @@ const useOnItemKeyDown = item => {
   } = item;
   const onItemFocusCurry = useCallback(newFocusItem => onItemFocus({
     itemIndex: newFocusItem.virtualIndex,
-    scrollToItem: (opts = {
-      align: 'start'
-    }) => scrollToIndex(newFocusItem.virtualIndex, opts),
+    scrollToItem: function () {
+      let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        align: 'start'
+      };
+      return scrollToIndex(newFocusItem.virtualIndex, opts);
+    },
     item: newFocusItem
   }), [onItemFocus]);
   const onItemKeyDown = useCallback(e => {

package/esm/utils/object-helpers.js

@@ -1,3 +1,11 @@
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+
 /* eslint-disable no-sequences */
 
 /* eslint-disable no-return-assign */

package/esm/utils/refs-helpers.js

@@ -1,5 +1,15 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+
 // allow multiple refs to be set to point to the same DOM element
-const setMultipleRefs = (...refs) => {
+const setMultipleRefs = function () {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+
   const filteredRefs = refs.filter(Boolean);
   if (!filteredRefs.length) return null;
   if (filteredRefs.length === 0) return filteredRefs[0];

package/esm/utils/selectable-helper.js

@@ -1,3 +1,8 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import { walkAllNodeChildren, walkParents } from './tree-helpers.js';
 
@@ -19,7 +24,8 @@ const getGroupCheckState = node => {
   if (anyChildChecked) return 'mixed';
   return false;
 };
-const selectCheckboxItemModelParentsTillRoot = (modelToCheck, triggerTreeRerender = null) => {
+const selectCheckboxItemModelParentsTillRoot = function (modelToCheck) {
+  let triggerTreeRerender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   const newSelections = {};
   const {
     nodePath
@@ -32,7 +38,8 @@ const selectCheckboxItemModelParentsTillRoot = (modelToCheck, triggerTreeRerende
   if (triggerTreeRerender) triggerTreeRerender();
   return newSelections;
 };
-const toggleCheckboxItem = (itemToSelect, triggerTreeRerender = null) => {
+const toggleCheckboxItem = function (itemToSelect) {
+  let triggerTreeRerender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   const {
     node: {
       model: {

package/esm/utils/tree-helpers.js

@@ -1,8 +1,17 @@
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.every.js';
+import 'core-js/modules/esnext.iterator.every.js';
 import { createRef } from 'react';
 import { standardizeSearchQueryString } from './string-helpers.js';
 
-/* eslint-disable max-params */
-const walkVisibles = (node, callback, skipRoot = true, highlightOnlyQuery = false) => {
+const walkVisibles = function (node, callback) {
+  let skipRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  let highlightOnlyQuery = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   const {
     children,
     model
@@ -24,7 +33,8 @@ const walkVisibles = (node, callback, skipRoot = true, highlightOnlyQuery = fals
     });
   }
 };
-const walkParents = (nodePath, callback, skipRoot = true) => {
+const walkParents = function (nodePath, callback) {
+  let skipRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
   const parents = [...nodePath].reverse();
   parents.shift(); // remove current node from the parents array
 
@@ -32,7 +42,8 @@ const walkParents = (nodePath, callback, skipRoot = true) => {
 
   parents.forEach(callback);
 };
-const walkAllNodeChildren = (node, callback, isFirst = true) => {
+const walkAllNodeChildren = function (node, callback) {
+  let isFirst = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
   const {
     children = []
   } = node;
@@ -50,7 +61,9 @@ const getNodeById = (treeRoot, id) => {
   return nodes[0];
 };
 const cloneNode = (tree, node) => tree.parse(node.model);
-const getItemsParentNode = (items = [], skipSameParentCheck = false) => {
+const getItemsParentNode = function () {
+  let items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let skipSameParentCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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
@@ -67,7 +80,8 @@ const getItemsParentNode = (items = [], skipSameParentCheck = false) => {
   const directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];
   return directParentNode;
 };
-const itemsShareSameParent = (items = []) => {
+const itemsShareSameParent = function () {
+  let items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   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]
@@ -88,21 +102,25 @@ const itemsShareSameParent = (items = []) => {
     return directParentNode === itemDirectParent;
   });
 };
-const getNodeMatchesSearchQuery = (node, searchQuery = '') => {
+const getNodeMatchesSearchQuery = function (node) {
+  let searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
   const standardizedName = standardizeSearchQueryString(node.model.name);
   const standardizedSearchQuery = standardizeSearchQueryString(searchQuery);
   return standardizedName.includes(standardizedSearchQuery);
 };
-const getChildrenMatchesSearchQuery = (parentNode, searchQuery = '') => {
+const getChildrenMatchesSearchQuery = function (parentNode) {
+  let searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
   let anyChildMatch = false;
   walkAllNodeChildren(parentNode, node => {
     if (getNodeMatchesSearchQuery(node, searchQuery)) anyChildMatch = true;
   });
   return anyChildMatch;
 };
-const enrichNodeModelInPlace = (node, searchQuery = '', selection = null) => {
+const enrichNodeModelInPlace = function (node) {
   var _node$model, _node$model$children;
 
+  let searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let selection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
   const path = node.getPath();
   const depth = path.length - 1;
   node.model.nodePath = path;

package/esm/utils/useDnDHelpers.js

@@ -1,10 +1,14 @@
+import 'core-js/modules/esnext.async-iterator.constructor.js';
+import 'core-js/modules/esnext.async-iterator.drop.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.drop.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { useContext, useCallback } from 'react';
 import { cloneDeep } from 'lodash';
 import TreeViewContext, { defaultRelativeMouseCoord } from '../TreeViewContext.js';
 import { getNodeById, focusItem } from './tree-helpers.js';
 import { inferKeyboardKinshipDrop, inferHoverItemKinshipDrop, isDropValid } from './dnd-helpers.js';
 
-/* eslint-disable max-depth */
 const useDnDHelpers = () => {
   const ctx = useContext(TreeViewContext);
   const {
@@ -27,11 +31,12 @@ const useDnDHelpers = () => {
     treeRoot,
     draggedItem
   } = ctx;
-  const onSortEnd = useCallback(({
-    oldIndex,
-    newIndex,
-    isKeySorting
-  }) => {
+  const onSortEnd = useCallback(_ref => {
+    let {
+      oldIndex,
+      newIndex,
+      isKeySorting
+    } = _ref;
     let newItems = cloneDeep(data);
     const {
       isBefore,
@@ -126,13 +131,14 @@ const useDnDHelpers = () => {
   // at the top/center/bottom of an element to choose where to move the element
   // requested in the specs
 
-  const onMouseDragOverItem = useCallback(({
-    event,
-    item,
-    itemIndex,
-    setIsDraggingOverThis,
-    openFolderOnHoverTimeout
-  }) => {
+  const onMouseDragOverItem = useCallback(_ref2 => {
+    let {
+      event,
+      item,
+      itemIndex,
+      setIsDraggingOverThis,
+      openFolderOnHoverTimeout
+    } = _ref2;
     const {
       node
     } = item;
@@ -179,7 +185,8 @@ const useDnDHelpers = () => {
       setIsDraggingOverThis(true);
 
       if (!(openFolderOnHoverTimeout !== null && openFolderOnHoverTimeout !== void 0 && openFolderOnHoverTimeout.current) && // only set the interval if it wasn't set already once
-      (draggedItem === null || draggedItem === void 0 ? void 0 : draggedItem.id) !== (item === null || item === void 0 ? void 0 : item.id) && (item.isGroup || item.children.length > 0) && // only open groups
+      (draggedItem === null || draggedItem === void 0 ? void 0 : draggedItem.id) !== (item === null || item === void 0 ? void 0 : item.id) && ( // don't open ghost element
+      item.isGroup || item.children.length > 0) && // only open groups
       !restrictDragAndDrop) {
         openFolderOnHoverTimeout.current = setTimeout(() => {
           item.node.model.isExpanded = true;

package/esm/utils/useInstanceRefActions.js

@@ -1,10 +1,12 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
 import { useRef, useMemo, useState, useEffect, useCallback } from 'react';
 import { focusItem } from './tree-helpers.js';
 import { toggleExpandAllHelper } from './group-expands-helpers.js';
 
-const useInstanceRefActions = ({
-  actions
-}, ctx) => {
+const useInstanceRefActions = (_ref, ctx) => {
+  let {
+    actions
+  } = _ref;
   const {
     props: {
       onItemFocus
@@ -39,19 +41,21 @@ const useInstanceRefActions = ({
     setPromise(p);
     return p;
   }, [promises, treeRoot, triggerTreeRerender, setLatestToggledItem]);
-  actions.scrollTo = useCallback((indx, opts = {
-    align: 'start'
-  }) => {
+  actions.scrollTo = useCallback(function (indx) {
+    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      align: 'start'
+    };
     if (scrollToIndex) scrollToIndex(indx, opts);
   }, [scrollToIndex]);
   actions.setSelectedItemByVirtualIndex = useCallback(index => {
     const itemByIndex = visibleItems[index];
     setSelectedItem(itemByIndex);
   }, [visibleItems, setSelectedItem]);
-  actions.setFocusedItemByVirtualIndex = useCallback((index, opts = {
-    align: 'start',
-    withScroll: false
-  }) => {
+  actions.setFocusedItemByVirtualIndex = useCallback(function (index) {
+    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      align: 'start',
+      withScroll: false
+    };
     const itemByIndex = visibleItems[index];
     const onItemFocusParams = {
       itemIndex: itemByIndex.virtualIndex,