@elliemae/ds-treeview 1.57.1-rc.0 → 2.0.0-alpha.11

package/esm/parts/ChildrenCountDisplayer.js

@@ -1,23 +1,22 @@
-import React from 'react';
-import { TreeViewItemPropType } from '../prop-types.js';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
 import { DSTreeViewPrefix, treeItemBlockName } from '../config/cssClassesConstants.js';
-import 'prop-types';
 
-var className = "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "-children-count-displayer");
-var ChildrenCountDisplayer = function ChildrenCountDisplayer(props) {
-  var item = props.item;
-  var isGroup = item.isGroup,
-      children = item.children;
+const className = "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "-children-count-displayer");
+const ChildrenCountDisplayer = props => {
+  const {
+    item
+  } = props;
+  const {
+    isGroup,
+    children
+  } = item;
   if (!isGroup) return null; // return ` | ${children.length} Items`;
 
-  return /*#__PURE__*/React.createElement("span", {
+  return /*#__PURE__*/_jsx("span", {
     "data-testid": "tree-item-children-count-displayer",
     className: className
-  }, " | ".concat(children.length, " Items"));
-};
-ChildrenCountDisplayer.propTypes = {
-  item: TreeViewItemPropType.isRequired
+  }, void 0, " | ".concat(children.length, " Items"));
 };
 
 export { ChildrenCountDisplayer };
-//# sourceMappingURL=ChildrenCountDisplayer.js.map

package/esm/parts/ExpandCaret.js

@@ -1,75 +1,77 @@
-import React, { useCallback, useContext } from 'react';
-import Button from '@elliemae/ds-button';
-import { ArrowheadDown, ArrowheadRight } from '@elliemae/ds-icons';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useCallback, useContext } from 'react';
+import Button from '@elliemae/ds-basic/Button';
+import ArrowheadDown from '@elliemae/ds-icons/ArrowheadDown';
+import ArrowheadRight from '@elliemae/ds-icons/ArrowheadRight';
 import { toggleItemExpand } from '../utils/group-expands-helpers.js';
 import { focusItem } from '../utils/tree-helpers.js';
 import TreeViewContext from '../TreeViewContext.js';
-import { TreeItemExpandCaretPropTypes } from '../prop-types.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '../utils/string-helpers.js';
-import 'prop-types';
 
-var ExpandCaret = function ExpandCaret(props) {
-  var defaultHandleExpandGroup = useCallback(toggleItemExpand, []);
-  var item = props.item;
-  var id = item.id,
-      isExpanded = item.isExpanded,
-      isGroup = item.isGroup,
-      children = item.children;
-  var isGroupOrHasChildrens = isGroup || Array.isArray(children) && children.length > 0;
-  var ctx = useContext(TreeViewContext);
-  var onItemFocus = ctx.props.onItemFocus,
-      _ctx$handleExpandGrou = ctx.handleExpandGroup,
-      handleExpandGroup = _ctx$handleExpandGrou === void 0 ? defaultHandleExpandGroup : _ctx$handleExpandGrou,
-      triggerTreeRerender = ctx.triggerTreeRerender,
-      setLatestToggledItem = ctx.setLatestToggledItem,
-      setFocusedItem = ctx.setFocusedItem,
-      scrollToIndex = ctx.virtualListHelpers.scrollToIndex;
-  if (isGroupOrHasChildrens) return /*#__PURE__*/React.createElement(Button, {
+var _ArrowheadDown, _ArrowheadRight;
+const ExpandCaret = props => {
+  const defaultHandleExpandGroup = useCallback(toggleItemExpand, []);
+  const {
+    item
+  } = props;
+  const {
+    id,
+    isExpanded,
+    isGroup,
+    children
+  } = item;
+  const isGroupOrHasChildrens = isGroup || Array.isArray(children) && children.length > 0;
+  const ctx = useContext(TreeViewContext);
+  const {
+    props: {
+      onItemFocus
+    },
+    handleExpandGroup = defaultHandleExpandGroup,
+    triggerTreeRerender,
+    setLatestToggledItem,
+    setFocusedItem,
+    virtualListHelpers: {
+      scrollToIndex
+    }
+  } = ctx;
+  if (isGroupOrHasChildrens) return /*#__PURE__*/_jsx(Button, {
     buttonType: "text",
     className: "expandable-arrow",
     "data-testid": "tree-item-expand-toggle",
-    key: "".concat(id, "-expand-addon"),
-    icon: isExpanded ? /*#__PURE__*/React.createElement(ArrowheadDown, {
+    icon: isExpanded ? _ArrowheadDown || (_ArrowheadDown = /*#__PURE__*/_jsx(ArrowheadDown, {
       size: "s",
       "data-testid": "ic-arrow-head-down"
-    }) : /*#__PURE__*/React.createElement(ArrowheadRight, {
+    })) : _ArrowheadRight || (_ArrowheadRight = /*#__PURE__*/_jsx(ArrowheadRight, {
       size: "s",
       "data-testid": "ic-arrow-head-right"
-    }),
-    onMouseDown: function onMouseDown(e) {
+    })),
+    onMouseDown: e => {
       // prevent focusing the caret
       if (e) {
         e.preventDefault();
       }
     },
-    onClick: function onClick(e) {
+    onClick: e => {
       e.stopPropagation();
       handleExpandGroup(item, triggerTreeRerender, scrollToIndex, e);
       setLatestToggledItem(item);
       onItemFocus({
         itemIndex: item.virtualIndex,
-        scrollToItem: function scrollToItem() {
-          var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-            align: 'start'
-          };
-          return scrollToIndex(item.virtualIndex, opts);
-        },
-        item: item
+        scrollToItem: (opts = {
+          align: 'start'
+        }) => scrollToIndex(item.virtualIndex, opts),
+        item
       });
       setFocusedItem(item);
       focusItem(item);
     },
     size: "s",
     tabIndex: -1
-  });
-  return /*#__PURE__*/React.createElement("div", {
+  }, "".concat(id, "-expand-addon"));
+  return /*#__PURE__*/_jsx("div", {
     style: {
       width: '24px'
     }
   });
 };
-ExpandCaret.propTypes = TreeItemExpandCaretPropTypes;
 
 export { ExpandCaret };
-//# sourceMappingURL=ExpandCaret.js.map

package/esm/parts/Icon.js

@@ -1,15 +1,20 @@
 import React, { useContext } from 'react';
-import { cx } from '@elliemae/ds-utilities';
+import { cx } from '@elliemae/ds-utilities/utils';
 import TreeViewContext from '../TreeViewContext.js';
 
-var Icon = function Icon(props) {
-  var item = props.item;
-  var isGroupOrHasChildrens = item.isGroup || Array.isArray(item.children) && item.children.length > 0;
-  var ctx = useContext(TreeViewContext);
-  var _ctx$props = ctx.props,
-      groupIcon = _ctx$props.groupIcon,
-      itemIcon = _ctx$props.itemIcon;
-  var icon = isGroupOrHasChildrens ? groupIcon : itemIcon;
+const Icon = props => {
+  const {
+    item
+  } = props;
+  const isGroupOrHasChildrens = item.isGroup || Array.isArray(item.children) && item.children.length > 0;
+  const ctx = useContext(TreeViewContext);
+  const {
+    props: {
+      groupIcon,
+      itemIcon
+    }
+  } = ctx;
+  const icon = isGroupOrHasChildrens ? groupIcon : itemIcon;
   if (!icon) return null;
   return /*#__PURE__*/React.cloneElement(icon, {
     'data-testid': isGroupOrHasChildrens ? 'tree-item-group-icon' : 'tree-item-icon',
@@ -18,4 +23,3 @@ var Icon = function Icon(props) {
 };
 
 export { Icon };
-//# sourceMappingURL=Icon.js.map

package/esm/parts/NestingSpace.js

@@ -1,39 +1,40 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React from 'react';
-import { TreeItemNestingSpacePropTypes } from '../prop-types.js';
-import 'prop-types';
+import 'react';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-var getItemNestingLeftPadding = function getItemNestingLeftPadding(level, opts) {
-  var _opts = _objectSpread({}, opts),
-      _opts$spaceForNesting = _opts.spaceForNestingLevel,
-      spaceForNestingLevel = _opts$spaceForNesting === void 0 ? 1.5 : _opts$spaceForNesting;
+const getItemNestingLeftPadding = (level, opts) => {
+  const {
+    spaceForNestingLevel = 1.5
+  } = _objectSpread({}, opts);
 
-  var groupLeftPadding = spaceForNestingLevel * (level - 1);
-  var finalLeftPadding = groupLeftPadding + spaceForNestingLevel - 0.1; // root level left-padding would be negative and would not be applied
+  const groupLeftPadding = spaceForNestingLevel * (level - 1);
+  const finalLeftPadding = groupLeftPadding + spaceForNestingLevel - 0.1; // root level left-padding would be negative and would not be applied
   // if "root-level" nesting, then defaults to 0 left-padding.
 
   return finalLeftPadding > 0 ? "".concat(finalLeftPadding, "em") : '0';
 };
 
-var NestingSpace = function NestingSpace(props) {
-  var item = props.item,
-      spaceForNestingLevel = props.spaceForNestingLevel;
-  var treeDepth = item.treeDepth;
-  var itemNestingLeftPadding = getItemNestingLeftPadding(treeDepth - 1, {
-    spaceForNestingLevel: spaceForNestingLevel
+const NestingSpace = props => {
+  const {
+    item,
+    spaceForNestingLevel
+  } = props;
+  const {
+    treeDepth
+  } = item;
+  const itemNestingLeftPadding = getItemNestingLeftPadding(treeDepth - 1, {
+    spaceForNestingLevel
   });
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/_jsx("div", {
     "data-testid": "tree-item-nested-space",
     style: {
       width: itemNestingLeftPadding
     }
   });
 };
-NestingSpace.propTypes = TreeItemNestingSpacePropTypes;
 
 export { NestingSpace };
-//# sourceMappingURL=NestingSpace.js.map

package/esm/parts/RadioSelectable.js

@@ -1,39 +1,47 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React, { useContext, useCallback, useMemo } from 'react';
-import PropTypes from 'prop-types';
-import { DSRadio } from '@elliemae/ds-form';
-import { TreeViewItemPropType } from '../prop-types.js';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useContext, useCallback, useMemo } from 'react';
+import Radio from '@elliemae/ds-basic/form/Radio';
 import TreeViewContext from '../TreeViewContext.js';
 
 function RadioSelectable(props) {
-  var item = props.item,
-      itemIndex = props.itemIndex;
-  var ctx = useContext(TreeViewContext);
-  var _ctx$props = ctx.props,
-      disableGroups = _ctx$props.disableGroups,
-      disableLeafs = _ctx$props.disableLeafs,
-      onSelectionChange = _ctx$props.onSelectionChange,
-      scrollToIndex = ctx.virtualListHelpers.scrollToIndex,
-      uniqueTreeViewUUID = ctx.uniqueTreeViewUUID,
-      selectedCheckboxes = ctx.selectedCheckboxes,
-      setSelectedCheckboxes = ctx.setSelectedCheckboxes;
-  var id = item.id;
-  var onRadioChange = useCallback(function () {
-    var newSelectionHasmap = _defineProperty({}, id, true);
-
+  const {
+    item,
+    itemIndex
+  } = props;
+  const ctx = useContext(TreeViewContext);
+  const {
+    props: {
+      disableGroups,
+      // radio allows disabling this, checkbox doesnt? check specs
+      disableLeafs,
+      // radio allows disabling this, checkbox doesnt? check specs
+      onSelectionChange
+    },
+    virtualListHelpers: {
+      scrollToIndex
+    },
+    uniqueTreeViewUUID,
+    selectedCheckboxes,
+    setSelectedCheckboxes
+  } = ctx;
+  const {
+    id
+  } = item;
+  const onRadioChange = useCallback(() => {
+    const newSelectionHasmap = {
+      [id]: true
+    };
     setSelectedCheckboxes(newSelectionHasmap);
-    var indexAndScrollTo = {
-      scrollToItem: function scrollToItem() {
+    const indexAndScrollTo = {
+      scrollToItem: () => {
         scrollToIndex(item.virtualIndex);
       },
-      itemIndex: itemIndex
+      itemIndex
     };
     if (onSelectionChange) onSelectionChange(newSelectionHasmap, item, indexAndScrollTo);
   }, [item, id, onSelectionChange, scrollToIndex]);
-  var radioName = useMemo(function () {
-    return "radios-".concat(uniqueTreeViewUUID);
-  }, [uniqueTreeViewUUID]);
-  return /*#__PURE__*/React.createElement(DSRadio, {
+  const radioName = useMemo(() => "radios-".concat(uniqueTreeViewUUID), [uniqueTreeViewUUID]);
+  return /*#__PURE__*/_jsx(Radio, {
     checked: selectedCheckboxes[id] === true,
     name: radioName,
     disabled: item.isGroup ? disableGroups : disableLeafs,
@@ -44,10 +52,4 @@ function RadioSelectable(props) {
   });
 }
 
-RadioSelectable.propTypes = {
-  item: TreeViewItemPropType.isRequired,
-  itemIndex: PropTypes.number.isRequired
-};
-
 export { RadioSelectable as default };
-//# sourceMappingURL=RadioSelectable.js.map

package/esm/parts/TreeItem.js

@@ -1,10 +1,10 @@
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
-import React, { useRef, useState, useContext, useMemo, useCallback } from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.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';
-import { TreeItemPropTypes } from '../prop-types.js';
+import GripperVertical from '@elliemae/ds-icons/GripperVertical';
 import RadioSelectable from './RadioSelectable.js';
 import CheckboxSelectable from './CheckboxSelectable.js';
 import TreeViewContext from '../TreeViewContext.js';
@@ -15,109 +15,95 @@ import { Icon } from './Icon.js';
 import { ExpandCaret } from './ExpandCaret.js';
 import { TreeItemText } from './TreeItemText.js';
 import { treeItemBlockName, DSTreeViewPrefix } from '../config/cssClassesConstants.js';
-import 'prop-types';
-import '@elliemae/ds-form';
-import 'styled-components';
-import '../utils/selectable-helper.js';
-import '../utils/tree-helpers.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '../utils/string-helpers.js';
-import '../utils/object-helpers.js';
-import '@babel/runtime/helpers/esm/typeof';
-import '../utils/group-expands-helpers.js';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-button';
-import 'react-highlight-words';
-import '@elliemae/ds-truncated-tooltip-text';
-import './ChildrenCountDisplayer.js';
+import { jsxs } 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; }
-var TreeListItem = aggregatedClasses('li', {
+const TreeListItem = aggregatedClasses('li', {
   'data-testid': treeItemBlockName,
   role: 'treeitem'
 })(treeItemBlockName);
-var TreeListItemAddonsWrapper = aggregatedClasses('div')(treeItemBlockName, 'addons');
-var DnDHandle = SortableHandle(function (_ref) {
-  var id = _ref.id;
-  return /*#__PURE__*/React.createElement(GripperVertical, {
-    "data-testid": "drag-handle",
-    key: "".concat(id, "-drag-handle"),
-    className: "drag-handle",
-    size: "s",
-    onMouseDown: function onMouseDown(e) {
-      // prevent focusing the drag-handle to avoid borders
-      if (e) {
-        e.preventDefault();
-      }
+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"
+}, "".concat(id, "-drag-handle")));
+const TreeItem = props => {
+  const {
+    item,
+    itemIndex,
+    itemWrapperStyle = {},
+    virtualItemRef,
+    spaceForNestingLevel = 1.5,
+    onMouseDragOverItem
+  } = props;
+  const {
+    id,
+    node
+  } = item;
+  const {
+    nodeItemRef
+  } = node.model;
+  const openFolderOnHoverTimeout = useRef();
+  const [isDraggingOverThis, setIsDraggingOverThis] = useState(false);
+  const onItemKeyDown = useOnItemKeyDown(item);
+  const ctx = useContext(TreeViewContext);
+  const {
+    props: {
+      disableIcons,
+      rightAddons,
+      onItemClick,
+      onItemFocus,
+      rowSize,
+      labelOverflow
     },
-    tabIndex: "0"
-  });
-});
-var TreeItem = function TreeItem(props) {
-  var item = props.item,
-      itemIndex = props.itemIndex,
-      _props$itemWrapperSty = props.itemWrapperStyle,
-      itemWrapperStyle = _props$itemWrapperSty === void 0 ? {} : _props$itemWrapperSty,
-      virtualItemRef = props.virtualItemRef,
-      _props$spaceForNestin = props.spaceForNestingLevel,
-      spaceForNestingLevel = _props$spaceForNestin === void 0 ? 1.5 : _props$spaceForNestin,
-      onMouseDragOverItem = props.onMouseDragOverItem;
-  var id = item.id,
-      node = item.node;
-  var nodeItemRef = node.model.nodeItemRef;
-  var openFolderOnHoverTimeout = useRef();
-
-  var _useState = useState(false),
-      _useState2 = _slicedToArray(_useState, 2),
-      isDraggingOverThis = _useState2[0],
-      setIsDraggingOverThis = _useState2[1];
-
-  var onItemKeyDown = useOnItemKeyDown(item);
-  var ctx = useContext(TreeViewContext);
-  var _ctx$props = ctx.props,
-      disableIcons = _ctx$props.disableIcons,
-      rightAddons = _ctx$props.rightAddons,
-      onItemClick = _ctx$props.onItemClick,
-      onItemFocus = _ctx$props.onItemFocus,
-      rowSize = _ctx$props.rowSize,
-      labelOverflow = _ctx$props.labelOverflow,
-      relativeMouseCord = ctx.relativeMouseCord,
-      withRadioChecks = ctx.withRadioChecks,
-      withCheckboxChecks = ctx.withCheckboxChecks,
-      withDragAndDrop = ctx.withDragAndDrop,
-      selectedItem = ctx.selectedItem,
-      selectedCheckboxes = ctx.selectedCheckboxes,
-      hoverItem = ctx.hoverItem,
-      isDragging = ctx.isDragging,
-      scrollToIndex = ctx.virtualListHelpers.scrollToIndex,
-      setHoverItem = ctx.setHoverItem,
-      setSelectedItem = ctx.setSelectedItem,
-      setFocusedItem = ctx.setFocusedItem; // Sortable Items needs to update
+    relativeMouseCord,
+    withRadioChecks,
+    withCheckboxChecks,
+    withDragAndDrop,
+    selectedItem,
+    selectedCheckboxes,
+    hoverItem,
+    isDragging,
+    virtualListHelpers: {
+      scrollToIndex
+    },
+    setHoverItem,
+    setSelectedItem,
+    setFocusedItem
+  } = ctx; // Sortable Items needs to update
   //   - the virtual list ref (for react-virtual requirement)
   //   - nodeItemRef which is a prop avaiable in the TreeModel nodes
 
-  var setItemRefs = function setItemRefs(ref) {
+  const setItemRefs = ref => {
     setMultipleRefs(virtualItemRef, nodeItemRef)(ref);
   };
 
-  var dropPreviewClassName = useMemo(function () {
+  const dropPreviewClassName = useMemo(() => {
     if (!withDragAndDrop || !relativeMouseCord || !isDraggingOverThis) return '';
-    var isBefore = relativeMouseCord.isBefore,
-        isAfter = relativeMouseCord.isAfter,
-        isValid = relativeMouseCord.isValid;
-    var className = "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName).concat(isValid ? '--valid' : '--invalid');
+    const {
+      isBefore,
+      isAfter,
+      isValid
+    } = relativeMouseCord;
+    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]);
-  var selectedClassName = useMemo(function () {
-    return (selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id) === item.id ? 'selected' : '';
-  }, [selectedItem]);
-  var hoverClassName = useMemo(function () {
-    return (hoverItem === null || hoverItem === void 0 ? void 0 : hoverItem.id) !== item.id || withDragAndDrop && isDragging ? '' : 'hover';
-  }, [hoverItem, withDragAndDrop, isDragging]);
-  var fixedHeightClassname = useMemo(function () {
+  const selectedClassName = useMemo(() => (selectedItem === null || selectedItem === void 0 ? void 0 : selectedItem.id) === item.id ? 'selected' : '', [selectedItem]);
+  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 "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "--fixed-height-compact");
       return "".concat(DSTreeViewPrefix, "-").concat(treeItemBlockName, "--fixed-height");
@@ -125,38 +111,33 @@ var TreeItem = function TreeItem(props) {
 
     return '';
   }, [labelOverflow, rowSize]);
-  var finalClassName = useMemo(function () {
-    return "".concat(dropPreviewClassName, " ").concat(fixedHeightClassname, " ").concat(selectedClassName, " ").concat(hoverClassName);
-  }, [dropPreviewClassName, selectedClassName, hoverClassName, fixedHeightClassname]);
-  var handleItemClick = useCallback(function (e) {
+  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: function scrollToItem() {
-        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-          align: 'start'
-        };
-        return scrollToIndex(item.virtualIndex, opts);
-      },
-      item: item
+      scrollToItem: (opts = {
+        align: 'start'
+      }) => scrollToIndex(item.virtualIndex, opts),
+      item
     });
   }, [item, scrollToIndex, onItemClick, onItemFocus, setSelectedItem, setFocusedItem]);
-  return /*#__PURE__*/React.createElement(TreeListItem, {
+  return /*#__PURE__*/jsxs(TreeListItem, {
     tabIndex: "0",
-    onMouseMove: function onMouseMove(event) {
+    onMouseMove: event => {
       if (withDragAndDrop) {
         onMouseDragOverItem({
-          event: event,
-          item: item,
-          itemIndex: itemIndex,
-          setIsDraggingOverThis: setIsDraggingOverThis,
-          openFolderOnHoverTimeout: openFolderOnHoverTimeout
+          event,
+          item,
+          itemIndex,
+          setIsDraggingOverThis,
+          openFolderOnHoverTimeout
         });
       }
     },
-    onMouseLeave: function onMouseLeave() {
+    onMouseLeave: () => {
       if (withDragAndDrop) {
         setIsDraggingOverThis(false);
         if (openFolderOnHoverTimeout !== null && openFolderOnHoverTimeout !== void 0 && openFolderOnHoverTimeout.current) clearTimeout(openFolderOnHoverTimeout.current);
@@ -166,7 +147,7 @@ var TreeItem = function TreeItem(props) {
         setHoverItem(null);
       }
     },
-    onMouseEnter: function onMouseEnter() {
+    onMouseEnter: () => {
       setHoverItem(item);
     },
     onClick: handleItemClick,
@@ -177,28 +158,27 @@ var TreeItem = function TreeItem(props) {
     "aria-selected": selectedCheckboxes[item.id],
     "data-id": item.id,
     "data-index": item.virtualIndex,
-    onKeyDown: onItemKeyDown
-  }, /*#__PURE__*/React.createElement(TreeListItemAddonsWrapper, null, withDragAndDrop ? /*#__PURE__*/React.createElement(DnDHandle, {
-    id: id
-  }) : null, withRadioChecks ? /*#__PURE__*/React.createElement(RadioSelectable, {
-    item: item,
-    itemIndex: itemIndex
-  }) : null, withCheckboxChecks ? /*#__PURE__*/React.createElement(CheckboxSelectable, {
-    item: item,
-    itemIndex: itemIndex
-  }) : null, /*#__PURE__*/React.createElement(NestingSpace, {
-    item: item,
-    spaceForNestingLevel: spaceForNestingLevel
-  }), /*#__PURE__*/React.createElement(ExpandCaret, {
-    item: item
-  }), !disableIcons ? /*#__PURE__*/React.createElement(Icon, {
-    item: item
-  }) : null), /*#__PURE__*/React.createElement(TreeItemText, {
-    item: item
-  }), rightAddons && /*#__PURE__*/React.createElement(TreeListItemAddonsWrapper, null, typeof rightAddons === 'function' ? rightAddons(item) : rightAddons));
+    onKeyDown: onItemKeyDown,
+    children: [/*#__PURE__*/_jsx(TreeListItemAddonsWrapper, {}, void 0, withDragAndDrop ? /*#__PURE__*/_jsx(DnDHandle, {
+      id: id
+    }) : null, withRadioChecks ? /*#__PURE__*/_jsx(RadioSelectable, {
+      item: item,
+      itemIndex: itemIndex
+    }) : null, withCheckboxChecks ? /*#__PURE__*/_jsx(CheckboxSelectable, {
+      item: item,
+      itemIndex: itemIndex
+    }) : null, /*#__PURE__*/_jsx(NestingSpace, {
+      item: item,
+      spaceForNestingLevel: spaceForNestingLevel
+    }), /*#__PURE__*/_jsx(ExpandCaret, {
+      item: item
+    }), !disableIcons ? /*#__PURE__*/_jsx(Icon, {
+      item: item
+    }) : null), /*#__PURE__*/_jsx(TreeItemText, {
+      item: item
+    }), rightAddons && /*#__PURE__*/_jsx(TreeListItemAddonsWrapper, {}, void 0, typeof rightAddons === 'function' ? rightAddons(item) : rightAddons)]
+  });
 };
-TreeItem.propTypes = TreeItemPropTypes;
-var DragAndDropTreeItem = SortableElement(TreeItem);
+const DragAndDropTreeItem = SortableElement(TreeItem);
 
 export { DragAndDropTreeItem, TreeItem, TreeListItem, TreeListItemAddonsWrapper };
-//# sourceMappingURL=TreeItem.js.map