@elliemae/ds-treeview 1.60.0 → 2.0.0-alpha.12

package/cjs/utils/useInstanceRefActions.js

@@ -2,90 +2,81 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+require('core-js/modules/web.dom-collections.iterator.js');
 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 = (_ref, ctx) => {
+  let {
+    actions
+  } = _ref;
+  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] : {
+    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
       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] : {
+    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
       align: 'start',
       withScroll: false
     };
-    var itemByIndex = visibleItems[index];
-    var onItemFocusParams = {
+    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 +84,3 @@ var useInstanceRefActions = function useInstanceRefActions(_ref, ctx) {
 };
 
 exports.useInstanceRefActions = useInstanceRefActions;
-//# sourceMappingURL=useInstanceRefActions.js.map

package/cjs/utils/useTree.js

@@ -3,43 +3,38 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
 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 +43,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 +76,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

package/esm/TreeView.js

@@ -1,6 +1,12 @@
+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 _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
-import React, { useRef, useState, useEffect } from 'react';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useRef, useState, useEffect } from 'react';
 import { useVirtual } from 'react-virtual';
 import { v4 } from 'uuid';
 import { describe } from 'react-desc';
@@ -12,160 +18,87 @@ import { TreeList } from './parts/TreeList.js';
 import { useNotifyExpandedChange } from './utils/group-expands-helpers.js';
 import { useInstanceRefActions } from './utils/useInstanceRefActions.js';
 import { useGlobalToggleAllExpandShortcut } from './utils/keyboard-helpers.js';
-import './utils/useDnDHelpers.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import 'lodash';
-import './utils/tree-helpers.js';
-import './utils/string-helpers.js';
-import './utils/dnd-helpers.js';
-import 'tree-model';
-import '@babel/runtime/helpers/esm/extends';
-import '@elliemae/react-sortable-hoc';
-import '@elliemae/ds-classnames';
-import '@elliemae/ds-circular-progress-indicator';
-import './prop-types.js';
-import 'prop-types';
-import './parts/TreeItem.js';
-import '@elliemae/ds-icons';
-import './parts/RadioSelectable.js';
-import '@elliemae/ds-form';
-import './parts/CheckboxSelectable.js';
-import 'styled-components';
-import './utils/selectable-helper.js';
-import './utils/object-helpers.js';
-import '@babel/runtime/helpers/esm/typeof';
-import './utils/refs-helpers.js';
-import './parts/NestingSpace.js';
-import './parts/Icon.js';
-import '@elliemae/ds-utilities';
-import './parts/ExpandCaret.js';
-import '@elliemae/ds-button';
-import './parts/TreeItemText.js';
-import 'react-highlight-words';
-import '@elliemae/ds-truncated-tooltip-text';
-import './parts/ChildrenCountDisplayer.js';
-import './config/cssClassesConstants.js';
+
+var _TreeDnD, _TreeList;
 
 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; }
 function TreeView(props) {
-  var treeRef = useRef({
+  const treeRef = useRef({
     actions: {}
   });
-  var data = props.data,
-      plugins = props.plugins,
-      onOrderChange = props.onOrderChange,
-      isMultiSelect = props.isMultiSelect,
-      isSingleSelect = props.isSingleSelect,
-      instanceRef = props.instanceRef,
-      selection = props.selection;
-
-  var _useState = useState(false),
-      _useState2 = _slicedToArray(_useState, 2),
-      isDragging = _useState2[0],
-      setIsDragging = _useState2[1];
-
-  var _useState3 = useState(false),
-      _useState4 = _slicedToArray(_useState3, 2),
-      isKeyboardDragging = _useState4[0],
-      setIsKeyboardDragging = _useState4[1];
-
-  var _useState5 = useState(null),
-      _useState6 = _slicedToArray(_useState5, 2),
-      draggedItem = _useState6[0],
-      setDraggedItem = _useState6[1];
-
-  var _useState7 = useState(null),
-      _useState8 = _slicedToArray(_useState7, 2),
-      hoverItem = _useState8[0],
-      setHoverItem = _useState8[1];
-
-  var _useState9 = useState(defaultRelativeMouseCoord),
-      _useState10 = _slicedToArray(_useState9, 2),
-      relativeMouseCord = _useState10[0],
-      setRelativeMouseCord = _useState10[1];
-
-  var _useState11 = useState(v4()),
-      _useState12 = _slicedToArray(_useState11, 1),
-      uniqueTreeViewUUID = _useState12[0];
-
-  var _useState13 = useState(null),
-      _useState14 = _slicedToArray(_useState13, 2),
-      latestToggledItem = _useState14[0],
-      setLatestToggledItem = _useState14[1];
-
-  var _useState15 = useState(null),
-      _useState16 = _slicedToArray(_useState15, 2),
-      selectedItem = _useState16[0],
-      setSelectedItem = _useState16[1];
-
-  var _useState17 = useState(null),
-      _useState18 = _slicedToArray(_useState17, 2),
-      focusedItem = _useState18[0],
-      setFocusedItem = _useState18[1];
-
-  var _useState19 = useState(_objectSpread({}, selection)),
-      _useState20 = _slicedToArray(_useState19, 2),
-      selectedCheckboxes = _useState20[0],
-      setSelectedCheckboxes = _useState20[1];
-
-  var _useState21 = useState({}),
-      _useState22 = _slicedToArray(_useState21, 2),
-      expandedGroups = _useState22[0],
-      setExpandedGroups = _useState22[1];
-
-  var _useTree = useTree(data, props, {
-    setExpandedGroups: setExpandedGroups
-  }),
-      visibleItems = _useTree.visibleItems,
-      tree = _useTree.tree,
-      treeRoot = _useTree.treeRoot,
-      triggerTreeRerender = _useTree.triggerTreeRerender;
-
-  var virtualListRef = useRef(); // estimateSize should not be really required given what was stated on
+  const {
+    data,
+    plugins,
+    onOrderChange,
+    isMultiSelect,
+    isSingleSelect,
+    instanceRef,
+    selection
+  } = props;
+  const [isDragging, setIsDragging] = useState(false);
+  const [isKeyboardDragging, setIsKeyboardDragging] = useState(false);
+  const [draggedItem, setDraggedItem] = useState(null);
+  const [hoverItem, setHoverItem] = useState(null);
+  const [relativeMouseCord, setRelativeMouseCord] = useState(defaultRelativeMouseCoord);
+  const [uniqueTreeViewUUID] = useState(v4());
+  const [latestToggledItem, setLatestToggledItem] = useState(null);
+  const [selectedItem, setSelectedItem] = useState(null);
+  const [focusedItem, setFocusedItem] = useState(null);
+  const [selectedCheckboxes, setSelectedCheckboxes] = useState(_objectSpread({}, selection));
+  const [expandedGroups, setExpandedGroups] = useState({});
+  const {
+    visibleItems,
+    tree,
+    treeRoot,
+    triggerTreeRerender
+  } = useTree(data, props, {
+    setExpandedGroups
+  });
+  const virtualListRef = useRef(); // estimateSize should not be really required given what was stated on
   // https://github.com/tannerlinsley/react-virtual/issues/23
 
-  var virtualListHelpers = useVirtual({
+  const virtualListHelpers = useVirtual({
     size: visibleItems.length,
     parentRef: virtualListRef,
     overscan: 15
   });
-  var withDragAndDrop = (plugins === null || plugins === void 0 ? void 0 : plugins.includes(TreeDndPlugin)) && onOrderChange;
-  var withRadioChecks = isSingleSelect && !isMultiSelect;
-  var withCheckboxChecks = !isSingleSelect && isMultiSelect;
-  var ctx = {
-    props: props,
-    setRelativeMouseCord: setRelativeMouseCord,
-    relativeMouseCord: relativeMouseCord,
-    virtualListHelpers: virtualListHelpers,
-    virtualListRef: virtualListRef,
-    tree: tree,
-    treeRoot: treeRoot,
-    visibleItems: visibleItems,
-    triggerTreeRerender: triggerTreeRerender,
-    isDragging: isDragging,
-    setIsDragging: setIsDragging,
-    isKeyboardDragging: isKeyboardDragging,
-    setIsKeyboardDragging: setIsKeyboardDragging,
-    draggedItem: draggedItem,
-    setDraggedItem: setDraggedItem,
-    withRadioChecks: withRadioChecks,
-    withCheckboxChecks: withCheckboxChecks,
-    withDragAndDrop: withDragAndDrop,
-    uniqueTreeViewUUID: uniqueTreeViewUUID,
-    selectedCheckboxes: selectedCheckboxes,
-    setSelectedCheckboxes: setSelectedCheckboxes,
-    selectedItem: selectedItem,
-    setSelectedItem: setSelectedItem,
-    expandedGroups: expandedGroups,
-    setExpandedGroups: setExpandedGroups,
-    latestToggledItem: latestToggledItem,
-    setLatestToggledItem: setLatestToggledItem,
-    focusedItem: focusedItem,
-    setFocusedItem: setFocusedItem,
-    hoverItem: hoverItem,
-    setHoverItem: setHoverItem
+  const withDragAndDrop = (plugins === null || plugins === void 0 ? void 0 : plugins.includes(TreeDndPlugin)) && onOrderChange;
+  const withRadioChecks = isSingleSelect && !isMultiSelect;
+  const withCheckboxChecks = !isSingleSelect && isMultiSelect;
+  const ctx = {
+    props,
+    setRelativeMouseCord,
+    relativeMouseCord,
+    virtualListHelpers,
+    virtualListRef,
+    tree,
+    treeRoot,
+    visibleItems,
+    triggerTreeRerender,
+    isDragging,
+    setIsDragging,
+    isKeyboardDragging,
+    setIsKeyboardDragging,
+    draggedItem,
+    setDraggedItem,
+    withRadioChecks,
+    withCheckboxChecks,
+    withDragAndDrop,
+    uniqueTreeViewUUID,
+    selectedCheckboxes,
+    setSelectedCheckboxes,
+    selectedItem,
+    setSelectedItem,
+    expandedGroups,
+    setExpandedGroups,
+    latestToggledItem,
+    setLatestToggledItem,
+    focusedItem,
+    setFocusedItem,
+    hoverItem,
+    setHoverItem
   }; // this hooks can't use the context because the context provider doesn't wrap this
   // as such we manually pass the second parameter as fit
 
@@ -173,19 +106,17 @@ function TreeView(props) {
   useInstanceRefActions(treeRef.current, ctx);
   useGlobalToggleAllExpandShortcut(treeRoot, triggerTreeRerender, setLatestToggledItem);
   useNotifyExpandedChange(props, ctx);
-  useEffect(function () {
-    setTimeout(function () {
+  useEffect(() => {
+    setTimeout(() => {
       ctx.props.onInstanceRefInitialized(treeRef);
     }, 100);
   }, []);
-  return /*#__PURE__*/React.createElement(TreeViewContext.Provider, {
+  return /*#__PURE__*/_jsx(TreeViewContext.Provider, {
     value: ctx
-  }, plugins !== null && plugins !== void 0 && plugins.includes(TreeDndPlugin) ? /*#__PURE__*/React.createElement(TreeDnD, null) : /*#__PURE__*/React.createElement(TreeList, null));
+  }, void 0, plugins !== null && plugins !== void 0 && plugins.includes(TreeDndPlugin) ? _TreeDnD || (_TreeDnD = /*#__PURE__*/_jsx(TreeDnD, {})) : _TreeList || (_TreeList = /*#__PURE__*/_jsx(TreeList, {})));
 }
-TreeView.propTypes = TreeViewPropTypes;
 TreeView.defaultProps = defaultProps;
-var TreeViewWithSchema = describe(TreeView);
+const TreeViewWithSchema = describe(TreeView);
 TreeViewWithSchema.propTypes = TreeViewPropTypes;
 
 export { TreeView, TreeViewWithSchema };
-//# sourceMappingURL=TreeView.js.map

package/esm/TreeViewContext.js

@@ -3,7 +3,7 @@ import { createRef, createContext } from 'react';
 /* eslint-disable no-unused-vars */
 // import FilePdf from '@elliemae/ds-icons/FilePdf';
 
-var defaultProps = {
+const defaultProps = {
   plugins: [],
   selection: {},
   // { [id]:[state] } -> e.g. {1:true, 2:'mixed'}
@@ -19,15 +19,15 @@ var defaultProps = {
   sortable: false,
   isLoading: false,
   highlightOnlyQuery: false,
-  onInstanceRefInitialized: function onInstanceRefInitialized(istanceRef) {},
-  onItemClick: function onItemClick(item, e) {},
-  onItemFocus: function onItemFocus(params) {},
+  onInstanceRefInitialized: istanceRef => {},
+  onItemClick: (item, e) => {},
+  onItemFocus: params => {},
   // { itemIndex: number, scrollToItem: func }
-  onVisibleItemsChange: function onVisibleItemsChange(newVisibleItems) {},
-  onOrderChange: function onOrderChange(newData, oldData, draggedItem) {},
-  onSelectionChange: function onSelectionChange(selectionHasmap, item, indexAndScrollTo) {},
+  onVisibleItemsChange: newVisibleItems => {},
+  onOrderChange: (newData, oldData, draggedItem) => {},
+  onSelectionChange: (selectionHasmap, item, indexAndScrollTo) => {},
   // indexAndScrollTo = { scrollToItem: ()=>{}, itemIndex :number }
-  onExpandChange: function onExpandChange(expandedHashmap, itemToggled) {},
+  onExpandChange: (expandedHashmap, itemToggled) => {},
   // expandedHashmap -> {[id]:true, ...[id]:true} itemToggled -> item that caused the change for being toggled
   rowSize: 'normal',
   // ['normal', 'compact']
@@ -44,7 +44,7 @@ var defaultProps = {
   // <FilePdf />,
   searchQuery: ''
 };
-var defaultRelativeMouseCoord = {
+const defaultRelativeMouseCoord = {
   isBefore: false,
   isAfter: false,
   isValid: true,
@@ -56,49 +56,46 @@ var defaultRelativeMouseCoord = {
 };
 /** Context for cross component communication */
 
-var TreeViewContext = /*#__PURE__*/createContext({
+const TreeViewContext = /*#__PURE__*/createContext({
   props: defaultProps,
   visibleItems: [],
   withRadioChecks: false,
   withCheckboxChecks: false,
   withDragAndDrop: false,
   relativeMouseCord: defaultRelativeMouseCoord,
-  setRelativeMouseCord: function setRelativeMouseCord() {},
-  labelRenderer: function labelRenderer(value) {
-    return value;
-  },
-  triggerTreeRerender: function triggerTreeRerender() {},
+  setRelativeMouseCord: () => {},
+  labelRenderer: value => value,
+  triggerTreeRerender: () => {},
   tree: {},
   virtualListHelpers: {},
   virtualListRef: {},
   treeRoot: {},
   isDragging: false,
-  setIsDragging: function setIsDragging() {},
+  setIsDragging: () => {},
   isKeyboardDragging: false,
-  setIsKeyboardDragging: function setIsKeyboardDragging() {},
+  setIsKeyboardDragging: () => {},
   draggedItem: null,
   // item
-  setDraggedItem: function setDraggedItem() {},
+  setDraggedItem: () => {},
   uniqueTreeViewUUID: '',
   selectedItem: null,
   // item
-  setSelectedItem: function setSelectedItem() {},
+  setSelectedItem: () => {},
   focusedItem: null,
   // item
-  setFocusedItem: function setFocusedItem() {},
+  setFocusedItem: () => {},
   selectedCheckboxes: {},
   // { [id]:[state] } -> e.g. {1:true, 2:'mixed'}
-  setSelectedCheckboxes: function setSelectedCheckboxes() {},
+  setSelectedCheckboxes: () => {},
   expandedGroups: {},
   // { [id]:true } -> e.g. {1:true, 2:true} // false are not listed
-  setExpandedGroups: function setExpandedGroups() {},
+  setExpandedGroups: () => {},
   latestToggledItem: null,
   // item -> if toggle all -> should be undefined
-  setLatestToggledItem: function setLatestToggledItem() {},
+  setLatestToggledItem: () => {},
   hoverItem: null,
   // item
-  setHoverItem: function setHoverItem() {}
+  setHoverItem: () => {}
 });
 
 export { TreeViewContext as default, defaultProps, defaultRelativeMouseCoord };
-//# sourceMappingURL=TreeViewContext.js.map