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

package/cjs/utils/useDnDHelpers.js

@@ -2,46 +2,47 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
 var React = require('react');
 var lodash = require('lodash');
 var TreeViewContext = require('../TreeViewContext.js');
-var utils_treeHelpers = require('./tree-helpers.js');
-var utils_dndHelpers = require('./dnd-helpers.js');
-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 useDnDHelpers = function useDnDHelpers() {
-  var ctx = React.useContext(TreeViewContext['default']);
-  var _ctx$props = ctx.props,
-      data = _ctx$props.data,
-      onOrderChange = _ctx$props.onOrderChange,
-      restrictDragAndDrop = _ctx$props.restrictDragAndDrop,
-      relativeMouseCord = ctx.relativeMouseCord,
-      setRelativeMouseCord = ctx.setRelativeMouseCord,
-      visibleItems = ctx.visibleItems,
-      isDragging = ctx.isDragging,
-      setIsDragging = ctx.setIsDragging,
-      isKeyboardDragging = ctx.isKeyboardDragging,
-      setIsKeyboardDragging = ctx.setIsKeyboardDragging,
-      setDraggedItem = ctx.setDraggedItem,
-      setFocusedItem = ctx.setFocusedItem,
-      triggerTreeRerender = ctx.triggerTreeRerender,
-      tree = ctx.tree,
-      treeRoot = ctx.treeRoot,
-      draggedItem = ctx.draggedItem;
-  var onSortEnd = React.useCallback(function (_ref) {
-    var oldIndex = _ref.oldIndex,
-        newIndex = _ref.newIndex,
-        isKeySorting = _ref.isKeySorting;
-    var newItems = lodash.cloneDeep(data);
-    var isBefore = relativeMouseCord.isBefore,
-        isAfter = relativeMouseCord.isAfter,
-        overItem = relativeMouseCord.item,
-        isValid = relativeMouseCord.isValid; // if dropping in same position do nothing
+var treeHelpers = require('./tree-helpers.js');
+var dndHelpers = require('./dnd-helpers.js');
+
+/* eslint-disable max-depth */
+const useDnDHelpers = () => {
+  const ctx = React.useContext(TreeViewContext["default"]);
+  const {
+    props: {
+      data,
+      onOrderChange,
+      restrictDragAndDrop
+    },
+    relativeMouseCord,
+    setRelativeMouseCord,
+    visibleItems,
+    isDragging,
+    setIsDragging,
+    isKeyboardDragging,
+    setIsKeyboardDragging,
+    setDraggedItem,
+    setFocusedItem,
+    triggerTreeRerender,
+    tree,
+    treeRoot,
+    draggedItem
+  } = ctx;
+  const onSortEnd = React.useCallback(({
+    oldIndex,
+    newIndex,
+    isKeySorting
+  }) => {
+    let newItems = lodash.cloneDeep(data);
+    const {
+      isBefore,
+      isAfter,
+      item: overItem,
+      isValid
+    } = relativeMouseCord; // if dropping in same position do nothing
     // if the drop is not allowed do nothing
 
     if (oldIndex === newIndex || !isValid) {
@@ -53,39 +54,38 @@ var useDnDHelpers = function useDnDHelpers() {
     } // if we are moving from topToBottom the offset changes
 
 
-    var movementDirection = newIndex > oldIndex ? 'topToBottom' : 'bottomToTop';
-    var newNestedIndex;
-    var newParentNode;
+    const movementDirection = newIndex > oldIndex ? 'topToBottom' : 'bottomToTop';
+    let newNestedIndex;
+    let newParentNode;
 
     if (isKeySorting) {
-      var kinship = utils_dndHelpers.inferKeyboardKinshipDrop({
+      const kinship = dndHelpers.inferKeyboardKinshipDrop({
         items: visibleItems,
-        newIndex: newIndex,
-        movementDirection: movementDirection
+        newIndex,
+        movementDirection
       });
       newNestedIndex = kinship.newNestedIndex;
       newParentNode = kinship.newParentNode;
     } else {
-      var _kinship = utils_dndHelpers.inferHoverItemKinshipDrop({
-        isBefore: isBefore,
-        isAfter: isAfter,
-        overItem: overItem,
-        movementDirection: movementDirection,
-        draggedItem: draggedItem
+      const kinship = dndHelpers.inferHoverItemKinshipDrop({
+        isBefore,
+        isAfter,
+        overItem,
+        movementDirection,
+        draggedItem
       });
-
-      newNestedIndex = _kinship.newNestedIndex;
-      newParentNode = _kinship.newParentNode;
+      newNestedIndex = kinship.newNestedIndex;
+      newParentNode = kinship.newParentNode;
     }
 
-    var newMovedItemNode = tree.parse(draggedItem.node.model);
-    utils_treeHelpers.getNodeById(treeRoot, draggedItem.id).drop();
+    const newMovedItemNode = tree.parse(draggedItem.node.model);
+    treeHelpers.getNodeById(treeRoot, draggedItem.id).drop();
     newParentNode.addChildAtIndex(newMovedItemNode, newNestedIndex);
 
     if (newParentNode.isRoot()) {
-      newItems = _toConsumableArray__default['default'](newParentNode.model.children);
+      newItems = [...newParentNode.model.children];
     } else {
-      newItems = _toConsumableArray__default['default'](treeRoot.model.children);
+      newItems = [...treeRoot.model.children];
     }
 
     onOrderChange(newItems, data, draggedItem);
@@ -93,7 +93,7 @@ var useDnDHelpers = function useDnDHelpers() {
     setDraggedItem(null);
     triggerTreeRerender();
   }, [data, draggedItem, relativeMouseCord, visibleItems, tree, treeRoot, onOrderChange, triggerTreeRerender, setIsDragging, setDraggedItem, setRelativeMouseCord]);
-  var onSortStart = React.useCallback(function () {}, // ({ node, index, collection, isKeySorting }, event) => {
+  const onSortStart = React.useCallback(() => {}, // ({ node, index, collection, isKeySorting }, event) => {
   // console.log('node :>> ', node);
   // console.log('isKeySorting :>> ', isKeySorting);
   // console.log('event :>> ', event);
@@ -102,72 +102,81 @@ var useDnDHelpers = function useDnDHelpers() {
   // setDraggedItem(item);
   // },
   []);
-  var updateBeforeSortStart = React.useCallback(function (beforeStartArgs) {
-    return new Promise(function (resolve) {
-      var index = beforeStartArgs.index,
-          collection = beforeStartArgs.collection,
-          isKeySorting = beforeStartArgs.isKeySorting;
-      var item = (collection === null || collection === void 0 ? void 0 : collection[index]) || visibleItems[index];
-      var isExpanded = item.node.model.isExpanded;
-
-      if (isExpanded) {
-        item.node.model.isExpanded = false;
-        triggerTreeRerender();
-      }
+  const updateBeforeSortStart = React.useCallback(beforeStartArgs => new Promise(resolve => {
+    const {
+      index,
+      collection,
+      isKeySorting
+    } = beforeStartArgs;
+    const item = (collection === null || collection === void 0 ? void 0 : collection[index]) || visibleItems[index];
+    const {
+      isExpanded
+    } = item.node.model;
+
+    if (isExpanded) {
+      item.node.model.isExpanded = false;
+      triggerTreeRerender();
+    }
 
-      setRelativeMouseCord(TreeViewContext.defaultRelativeMouseCoord);
-      setIsKeyboardDragging(isKeySorting);
-      setIsDragging(true);
-      setDraggedItem(item);
-      utils_treeHelpers.focusItem(null);
-      setFocusedItem(null);
-      document.activeElement.blur();
-      resolve();
-    });
-  }, [visibleItems, isKeyboardDragging, setFocusedItem, setIsKeyboardDragging, setRelativeMouseCord]); // tracks mouse coords relative to an element to check if the drop happens
+    setRelativeMouseCord(TreeViewContext.defaultRelativeMouseCoord);
+    setIsKeyboardDragging(isKeySorting);
+    setIsDragging(true);
+    setDraggedItem(item);
+    treeHelpers.focusItem(null);
+    setFocusedItem(null);
+    document.activeElement.blur();
+    resolve();
+  }), [visibleItems, isKeyboardDragging, setFocusedItem, setIsKeyboardDragging, setRelativeMouseCord]); // tracks mouse coords relative to an element to check if the drop happens
   // at the top/center/bottom of an element to choose where to move the element
   // requested in the specs
 
-  var onMouseDragOverItem = React.useCallback(function (_ref2) {
-    var event = _ref2.event,
-        item = _ref2.item,
-        itemIndex = _ref2.itemIndex,
-        setIsDraggingOverThis = _ref2.setIsDraggingOverThis,
-        openFolderOnHoverTimeout = _ref2.openFolderOnHoverTimeout;
-    var node = item.node;
-    var nodeItemRef = node.model.nodeItemRef;
+  const onMouseDragOverItem = React.useCallback(({
+    event,
+    item,
+    itemIndex,
+    setIsDraggingOverThis,
+    openFolderOnHoverTimeout
+  }) => {
+    const {
+      node
+    } = item;
+    const {
+      nodeItemRef
+    } = node.model;
 
     if (isDragging && !isKeyboardDragging) {
-      var rect = nodeItemRef.current.getBoundingClientRect();
-      var x = event.clientX - rect.left; // x position within the element.
+      const rect = nodeItemRef.current.getBoundingClientRect();
+      const x = event.clientX - rect.left; // x position within the element.
 
-      var y = event.clientY - rect.top; // y position within the element.
+      const y = event.clientY - rect.top; // y position within the element.
       // by spec we need to track where the drop will happens
       // if drop happens on top 25% drop before
       // if drop happens on bottom of 25% drop after
       // if drop happens in the middle 50% either invalid or drop into children
 
-      var elementHeight = rect.height;
-      var dropBeforeMaxY = elementHeight * 0.25;
-      var dropAfterMinY = elementHeight - elementHeight * 0.25;
-      var isBefore = y < dropBeforeMaxY;
-      var isAfter = y > dropAfterMinY;
-      var isInside = !isBefore && !isAfter;
-      var isValid = utils_dndHelpers.isDropValid({
-        isBefore: isBefore,
-        isAfter: isAfter,
-        draggedItem: draggedItem,
+      const {
+        height: elementHeight
+      } = rect;
+      const dropBeforeMaxY = elementHeight * 0.25;
+      const dropAfterMinY = elementHeight - elementHeight * 0.25;
+      const isBefore = y < dropBeforeMaxY;
+      const isAfter = y > dropAfterMinY;
+      const isInside = !isBefore && !isAfter;
+      const isValid = dndHelpers.isDropValid({
+        isBefore,
+        isAfter,
+        draggedItem,
         overItem: item,
-        restrictDragAndDrop: restrictDragAndDrop
+        restrictDragAndDrop
       });
       setRelativeMouseCord({
-        isBefore: isBefore,
-        isAfter: isAfter,
-        isInside: isInside,
-        isValid: isValid,
-        item: item,
-        x: x,
-        y: y,
+        isBefore,
+        isAfter,
+        isInside,
+        isValid,
+        item,
+        x,
+        y,
         relativeElementDOMRect: rect,
         relativeElementIndex: itemIndex
       });
@@ -176,7 +185,7 @@ var useDnDHelpers = function useDnDHelpers() {
       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
       !restrictDragAndDrop) {
-        openFolderOnHoverTimeout.current = setTimeout(function () {
+        openFolderOnHoverTimeout.current = setTimeout(() => {
           item.node.model.isExpanded = true;
           openFolderOnHoverTimeout.current = null;
           triggerTreeRerender();
@@ -187,12 +196,11 @@ var useDnDHelpers = function useDnDHelpers() {
     }
   }, [isDragging, setRelativeMouseCord, draggedItem, restrictDragAndDrop, isKeyboardDragging]);
   return {
-    updateBeforeSortStart: updateBeforeSortStart,
-    onSortStart: onSortStart,
-    onSortEnd: onSortEnd,
-    onMouseDragOverItem: onMouseDragOverItem
+    updateBeforeSortStart,
+    onSortStart,
+    onSortEnd,
+    onMouseDragOverItem
   };
 };
 
 exports.useDnDHelpers = useDnDHelpers;
-//# sourceMappingURL=useDnDHelpers.js.map

package/cjs/utils/useInstanceRefActions.js

@@ -2,90 +2,77 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var React = require('react');
-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');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
-
-var useInstanceRefActions = function useInstanceRefActions(_ref, ctx) {
-  var actions = _ref.actions;
-  var onItemFocus = ctx.props.onItemFocus,
-      virtualListHelpers = ctx.virtualListHelpers,
-      treeRoot = ctx.treeRoot,
-      visibleItems = ctx.visibleItems,
-      triggerTreeRerender = ctx.triggerTreeRerender,
-      setSelectedItem = ctx.setSelectedItem,
-      setFocusedItem = ctx.setFocusedItem,
-      setLatestToggledItem = ctx.setLatestToggledItem;
-
-  var _useRef = React.useRef({}),
-      promises = _useRef.current;
-
-  var _useMemo = React.useMemo(function () {
-    return virtualListHelpers;
-  }, [virtualListHelpers]),
-      scrollToIndex = _useMemo.scrollToIndex;
-
-  var _useState = React.useState(),
-      _useState2 = _slicedToArray__default['default'](_useState, 2),
-      expandPromise = _useState2[0],
-      setPromise = _useState2[1];
-
-  React.useEffect(function () {
+const useInstanceRefActions = ({
+  actions
+}, ctx) => {
+  const {
+    props: {
+      onItemFocus
+    },
+    virtualListHelpers,
+    treeRoot,
+    visibleItems,
+    triggerTreeRerender,
+    setSelectedItem,
+    setFocusedItem,
+    setLatestToggledItem
+  } = ctx;
+  const {
+    current: promises
+  } = React.useRef({});
+  const {
+    scrollToIndex
+  } = React.useMemo(() => virtualListHelpers, [virtualListHelpers]);
+  const [expandPromise, setPromise] = React.useState();
+  React.useEffect(() => {
     if (expandPromise && promises.expandResolve) {
       promises.expandResolve(visibleItems);
       promises.expandResolve = null;
       setPromise(null);
     }
   }, [visibleItems, expandPromise, promises]);
-  actions.toggleExpandAll = React.useCallback(function (isExpand) {
-    var p = new Promise(function (resolve) {
+  actions.toggleExpandAll = React.useCallback(isExpand => {
+    const p = new Promise(resolve => {
       promises.expandResolve = resolve;
-      utils_groupExpandsHelpers.toggleExpandAllHelper(isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem);
+      groupExpandsHelpers.toggleExpandAllHelper(isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem);
     });
     setPromise(p);
     return p;
   }, [promises, treeRoot, triggerTreeRerender, setLatestToggledItem]);
-  actions.scrollTo = React.useCallback(function (indx) {
-    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      align: 'start'
-    };
+  actions.scrollTo = React.useCallback((indx, opts = {
+    align: 'start'
+  }) => {
     if (scrollToIndex) scrollToIndex(indx, opts);
   }, [scrollToIndex]);
-  actions.setSelectedItemByVirtualIndex = React.useCallback(function (index) {
-    var itemByIndex = visibleItems[index];
+  actions.setSelectedItemByVirtualIndex = React.useCallback(index => {
+    const itemByIndex = visibleItems[index];
     setSelectedItem(itemByIndex);
   }, [visibleItems, setSelectedItem]);
-  actions.setFocusedItemByVirtualIndex = React.useCallback(function (index) {
-    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      align: 'start',
-      withScroll: false
-    };
-    var itemByIndex = visibleItems[index];
-    var onItemFocusParams = {
+  actions.setFocusedItemByVirtualIndex = React.useCallback((index, opts = {
+    align: 'start',
+    withScroll: false
+  }) => {
+    const itemByIndex = visibleItems[index];
+    const onItemFocusParams = {
       itemIndex: itemByIndex.virtualIndex,
-      scrollToItem: function scrollToItem() {
-        return scrollToIndex(index, opts);
-      },
+      scrollToItem: () => scrollToIndex(index, opts),
       item: itemByIndex
     };
 
     if (opts.withScroll && scrollToIndex) {
       scrollToIndex(index, opts);
-      setTimeout(function () {
+      setTimeout(() => {
         setFocusedItem(itemByIndex);
-        utils_treeHelpers.focusItem(itemByIndex);
+        treeHelpers.focusItem(itemByIndex);
         onItemFocus(onItemFocusParams);
       }, 300);
     } else {
       setFocusedItem(itemByIndex);
-      utils_treeHelpers.focusItem(itemByIndex);
+      treeHelpers.focusItem(itemByIndex);
       onItemFocus(onItemFocusParams);
     }
   }, [visibleItems, scrollToIndex, setFocusedItem, onItemFocus]);
@@ -93,4 +80,3 @@ var useInstanceRefActions = function useInstanceRefActions(_ref, ctx) {
 };
 
 exports.useInstanceRefActions = useInstanceRefActions;
-//# sourceMappingURL=useInstanceRefActions.js.map

package/cjs/utils/useTree.js

@@ -3,43 +3,32 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var React = require('react');
 var TreeModel = require('tree-model');
 var lodash = require('lodash');
-var utils_treeHelpers = require('./tree-helpers.js');
-require('@babel/runtime/helpers/toConsumableArray');
-require('./string-helpers.js');
+var treeHelpers = require('./tree-helpers.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
 var TreeModel__default = /*#__PURE__*/_interopDefaultLegacy(TreeModel);
 
 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 useTree = function useTree(data, props, states) {
-  var setExpandedGroups = states.setExpandedGroups;
-  var unfrozenData = React.useMemo(function () {
-    return lodash.cloneDeep(data);
-  }, [data]); // convert data into a TreeModel with extra isExpanded prop
+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 useTree = (data, props, states) => {
+  const {
+    setExpandedGroups
+  } = states;
+  const unfrozenData = React.useMemo(() => lodash.cloneDeep(data), [data]); // convert data into a TreeModel with extra isExpanded prop
 
-  var tree = React.useMemo(function () {
-    return new TreeModel__default['default']();
-  }, []);
-
-  var _useState = React.useState({
+  const tree = React.useMemo(() => new TreeModel__default["default"](), []);
+  const [treeData, setTreeData] = React.useState({
     name: '__root',
     isExpanded: true,
     children: unfrozenData
-  }),
-      _useState2 = _slicedToArray__default['default'](_useState, 2),
-      treeData = _useState2[0],
-      setTreeData = _useState2[1];
-
-  React.useEffect(function () {
+  });
+  React.useEffect(() => {
     setTreeData({
       name: '__root',
       isExpanded: true,
@@ -48,43 +37,32 @@ var useTree = function useTree(data, props, states) {
   }, [unfrozenData]); // expose a way to rerender the tree
   //   used for expand functionality
 
-  var _useState3 = React.useState({}),
-      _useState4 = _slicedToArray__default['default'](_useState3, 2),
-      rerenderItems = _useState4[0],
-      setRerenderItems = _useState4[1];
-
-  var triggerTreeRerender = React.useCallback(function () {
+  const [rerenderItems, setRerenderItems] = React.useState({});
+  const triggerTreeRerender = React.useCallback(() => {
     setRerenderItems({});
   }, []); // when re-rendering we re-parse the list
 
-  var _useState5 = React.useState(tree.parse(treeData)),
-      _useState6 = _slicedToArray__default['default'](_useState5, 2),
-      treeRoot = _useState6[0],
-      setTreeRoot = _useState6[1];
-
-  React.useEffect(function () {
+  const [treeRoot, setTreeRoot] = React.useState(tree.parse(treeData));
+  React.useEffect(() => {
     setTreeRoot(tree.parse(treeData));
   }, [treeData, rerenderItems]);
-
-  var _useState7 = React.useState([]),
-      _useState8 = _slicedToArray__default['default'](_useState7, 2),
-      visibleItems = _useState8[0],
-      setVisibleItems = _useState8[1];
-
-  var searchQuery = props.searchQuery,
-      highlightOnlyQuery = props.highlightOnlyQuery,
-      onVisibleItemsChange = props.onVisibleItemsChange,
-      selection = props.selection;
-  React.useEffect(function () {
-    var parsedVisibleItems = [];
-    var newExpandedHashMap = {};
-    treeRoot.walk(function (node) {
-      utils_treeHelpers.enrichNodeModelInPlace(node, searchQuery, selection);
+  const [visibleItems, setVisibleItems] = React.useState([]);
+  const {
+    searchQuery,
+    highlightOnlyQuery,
+    onVisibleItemsChange,
+    selection
+  } = props;
+  React.useEffect(() => {
+    const parsedVisibleItems = [];
+    const newExpandedHashMap = {};
+    treeRoot.walk(node => {
+      treeHelpers.enrichNodeModelInPlace(node, searchQuery, selection);
       if (node.model.id && node.model.isGroup && node.model.isExpanded) newExpandedHashMap[node.model.id] = true;
     });
-    utils_treeHelpers.walkVisibles(treeRoot, function (node) {
+    treeHelpers.walkVisibles(treeRoot, node => {
       parsedVisibleItems.push(_objectSpread(_objectSpread({}, node.model), {}, {
-        node: node
+        node
       }));
     }, true, highlightOnlyQuery);
     setVisibleItems(parsedVisibleItems);
@@ -92,13 +70,12 @@ var useTree = function useTree(data, props, states) {
     setExpandedGroups(newExpandedHashMap);
   }, [treeRoot, rerenderItems, searchQuery]);
   return {
-    visibleItems: visibleItems,
-    tree: tree,
-    treeRoot: treeRoot,
-    rerenderItems: rerenderItems,
-    triggerTreeRerender: triggerTreeRerender
+    visibleItems,
+    tree,
+    treeRoot,
+    rerenderItems,
+    triggerTreeRerender
   };
 };
 
 exports.useTree = useTree;
-//# sourceMappingURL=useTree.js.map