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

package/esm/deprecated/plugins/dnd/renderers/DroppableList.js

@@ -1,159 +1,172 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
-import React, { useContext, useState, useRef, useCallback } from 'react';
+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 { useContext, useState, useRef, useCallback, createElement } from 'react';
 import { DragDropContext, Droppable } from 'react-beautiful-dnd';
 import { cx, mergeRefs } from '@elliemae/ds-utilities';
 import { GripperVertical } from '@elliemae/ds-icons';
 import FocusGroupContext from '@elliemae/ds-shared/FocusGroup/FocusGroupContext';
 import { findItemById, findItemOnDocument } from '../../tree/utils.js';
 import { getDraggableProps } from '../utils.js';
-import 'lodash/get';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@babel/runtime/helpers/esm/defineProperty';
-
-var _excluded = ["records"];
-
-var DroppableList = function DroppableList(renderers, instance) {
-  return function (_ref) {
-    var records = _ref.records,
-        rest = _objectWithoutProperties(_ref, _excluded);
-
-    var _instance$getInstance = instance.getInstance(),
-        _instance$getInstance2 = _instance$getInstance.props,
-        _instance$getInstance3 = _instance$getInstance2.expandTimerDelay,
-        expandTimerDelay = _instance$getInstance3 === void 0 ? 1000 : _instance$getInstance3,
-        restrictDragAndDrop = _instance$getInstance2.restrictDragAndDrop,
-        _instance$getInstance4 = _instance$getInstance.actions,
-        setDraggedRecord = _instance$getInstance4.setDraggedRecord,
-        changeRecordsPosition = _instance$getInstance4.changeRecordsPosition,
-        toggleExpand = _instance$getInstance4.toggleExpand,
-        draggedRecord = _instance$getInstance.state.draggedRecord,
-        itemRenderer = _instance$getInstance.itemRenderer;
-
-    var focusContext = useContext(FocusGroupContext);
-
-    var _useState = useState(false),
-        _useState2 = _slicedToArray(_useState, 2),
-        focusedItemWasDragged = _useState2[0],
-        setFocusedItemWasDragged = _useState2[1];
-
-    var preDragFocusedNode = useRef();
-    var expandTimerRef = useRef();
-    var draggedRecordShouldExpand = useRef(false);
-    var currTargetRef = useRef({});
-    var onDragUpdate = useCallback(function (data) {
-      var destination = data.destination,
-          combine = data.combine;
-      clearTimeout(expandTimerRef.current);
-
-      if (combine) {
-        var draggableId = combine.draggableId;
-        var targetRecord = findItemById(records, draggableId);
-
-        if (targetRecord && targetRecord.isGroup && !targetRecord.expanded) {
-          expandTimerRef.current = setTimeout(function () {
-            return toggleExpand(targetRecord);
-          }, expandTimerDelay);
-        }
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["records"];
+
+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 DroppableList = (renderers, instance) => _ref => {
+  let {
+    records
+  } = _ref,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  const {
+    props: {
+      expandTimerDelay = 1000,
+      restrictDragAndDrop
+    },
+    actions: {
+      setDraggedRecord,
+      changeRecordsPosition,
+      toggleExpand
+    },
+    state: {
+      draggedRecord
+    },
+    itemRenderer
+  } = instance.getInstance();
+  const focusContext = useContext(FocusGroupContext);
+  const [focusedItemWasDragged, setFocusedItemWasDragged] = useState(false);
+  const preDragFocusedNode = useRef();
+  const expandTimerRef = useRef();
+  const draggedRecordShouldExpand = useRef(false);
+  const currTargetRef = useRef({});
+  const onDragUpdate = useCallback(data => {
+    const {
+      destination,
+      combine
+    } = data;
+    clearTimeout(expandTimerRef.current);
+
+    if (combine) {
+      const {
+        draggableId
+      } = combine;
+      const targetRecord = findItemById(records, draggableId);
+
+      if (targetRecord && targetRecord.isGroup && !targetRecord.expanded) {
+        expandTimerRef.current = setTimeout(() => toggleExpand(targetRecord), expandTimerDelay);
       }
-
-      currTargetRef.current = destination || currTargetRef.current;
-    }, [records]);
-    var onDragStart = useCallback(function (_ref2) {
-      var source = _ref2.source;
-      preDragFocusedNode.current = document.activeElement; // when we move the currently focused item, preDragFocusedNode is the body of the doc
-
-      setFocusedItemWasDragged(preDragFocusedNode.current.tagName === 'BODY');
-      var draggingRecord = records[source.index];
-
-      if (draggingRecord.expanded) {
-        draggedRecordShouldExpand.current = true;
-        toggleExpand(draggingRecord);
-      }
-
-      setDraggedRecord(draggingRecord);
-    }, [records]);
-    var onDragEnd = useCallback( // eslint-disable-next-line complexity
-    // eslint-disable-next-line max-statements
-    function (_ref3) {
-      var _sourceRecord$parentN, _targetRecord$parentN;
-
-      var destination = _ref3.destination,
-          source = _ref3.source,
-          combine = _ref3.combine;
-      clearTimeout(expandTimerRef.current);
-      var sourceIndex = source.index;
-      var destinationIndex = destination && destination.index;
-      if (sourceIndex === destinationIndex) return;
-      var sourceRecord = records[sourceIndex];
-      var targetRecord = destination && records[destinationIndex];
-      var combineWith = combine && findItemById(records, combine.draggableId);
-      var down = sourceIndex < destinationIndex;
-      if (restrictDragAndDrop && (sourceRecord === null || sourceRecord === void 0 ? void 0 : (_sourceRecord$parentN = sourceRecord.parentNode) === null || _sourceRecord$parentN === void 0 ? void 0 : _sourceRecord$parentN.id) !== (targetRecord === null || targetRecord === void 0 ? void 0 : (_targetRecord$parentN = targetRecord.parentNode) === null || _targetRecord$parentN === void 0 ? void 0 : _targetRecord$parentN.id)) return; // TODO check if we can change the records Immutable, this makes the DOM inconsistent on first renderers
-
-      changeRecordsPosition({
-        sourceRecord: sourceRecord,
-        targetRecord: targetRecord,
-        combineWith: combineWith,
-        down: down
-      });
-
-      if (draggedRecordShouldExpand.current) {
-        draggedRecordShouldExpand.current = false;
-        toggleExpand(sourceRecord);
-      }
-
-      if (focusContext) {
-        // TODO if we fix the mutable/immutable records handling this work-around should not be required anymore
-        setTimeout(function () {
-          var postDragFocusedNode = focusedItemWasDragged ? findItemOnDocument(sourceRecord.id) : findItemOnDocument(preDragFocusedNode.current.dataset.id);
-          focusContext.focusItemByNode(postDragFocusedNode);
-        }, 0);
-      }
-
-      currTargetRef.current = null;
-      setDraggedRecord(null);
-    }, [records, focusedItemWasDragged]);
-    var ItemComponent = renderers.item,
-        ListComponent = renderers.list;
-    var renderClone = useCallback(function (provided, snapshot, rubric) {
-      var targetRecord = currTargetRef.current && records[currTargetRef.current.index] || {};
-      var record = records[rubric.source.index];
-      return /*#__PURE__*/React.createElement(ItemComponent, _extends({}, provided.draggableProps, {
-        key: rubric.source.index,
-        record: record
-      }, getDraggableProps({
-        className: 'item-cloned'
-      }, provided, snapshot)), /*#__PURE__*/React.createElement(GripperVertical, _extends({}, provided.dragHandleProps, {
-        className: "drag-handle"
-      })), itemRenderer({
-        record: record,
-        nestingLevel: targetRecord.nestingLevel
-      }));
-    }, [currTargetRef, records, itemRenderer]);
-    return /*#__PURE__*/React.createElement(DragDropContext, {
-      onDragEnd: onDragEnd,
-      onDragStart: onDragStart,
-      onDragUpdate: onDragUpdate
-    }, /*#__PURE__*/React.createElement(Droppable, {
-      droppableId: "droppableId",
-      isCombineEnabled: true,
-      mode: "virtual",
-      renderClone: renderClone
-    }, function (droppableProvided, snapshot) {
-      // Add an extra item to our list to make space for a dragging item
-      // work in a virtual list
-      var itemCount = snapshot.isUsingPlaceholder ? records.length + 1 : records.length;
-      return /*#__PURE__*/React.createElement(ListComponent, _extends({}, rest, {
-        className: cx(rest.className, draggedRecord && 'dragging'),
-        innerRef: mergeRefs(droppableProvided.innerRef, rest.innerRef, rest.ref),
-        itemCount: itemCount,
-        records: records
-      }));
+    }
+
+    currTargetRef.current = destination || currTargetRef.current;
+  }, [records]);
+  const onDragStart = useCallback(_ref2 => {
+    let {
+      source
+    } = _ref2;
+    preDragFocusedNode.current = document.activeElement; // when we move the currently focused item, preDragFocusedNode is the body of the doc
+
+    setFocusedItemWasDragged(preDragFocusedNode.current.tagName === 'BODY');
+    const draggingRecord = records[source.index];
+
+    if (draggingRecord.expanded) {
+      draggedRecordShouldExpand.current = true;
+      toggleExpand(draggingRecord);
+    }
+
+    setDraggedRecord(draggingRecord);
+  }, [records]);
+  const onDragEnd = useCallback( // eslint-disable-next-line complexity
+  // eslint-disable-next-line max-statements
+  _ref3 => {
+    var _sourceRecord$parentN, _targetRecord$parentN;
+
+    let {
+      destination,
+      source,
+      combine
+    } = _ref3;
+    clearTimeout(expandTimerRef.current);
+    const sourceIndex = source.index;
+    const destinationIndex = destination && destination.index;
+    if (sourceIndex === destinationIndex) return;
+    const sourceRecord = records[sourceIndex];
+    const targetRecord = destination && records[destinationIndex];
+    const combineWith = combine && findItemById(records, combine.draggableId);
+    const down = sourceIndex < destinationIndex;
+    if (restrictDragAndDrop && (sourceRecord === null || sourceRecord === void 0 ? void 0 : (_sourceRecord$parentN = sourceRecord.parentNode) === null || _sourceRecord$parentN === void 0 ? void 0 : _sourceRecord$parentN.id) !== (targetRecord === null || targetRecord === void 0 ? void 0 : (_targetRecord$parentN = targetRecord.parentNode) === null || _targetRecord$parentN === void 0 ? void 0 : _targetRecord$parentN.id)) return; // TODO check if we can change the records Immutable, this makes the DOM inconsistent on first renderers
+
+    changeRecordsPosition({
+      sourceRecord,
+      targetRecord,
+      combineWith,
+      down
+    });
+
+    if (draggedRecordShouldExpand.current) {
+      draggedRecordShouldExpand.current = false;
+      toggleExpand(sourceRecord);
+    }
+
+    if (focusContext) {
+      // TODO if we fix the mutable/immutable records handling this work-around should not be required anymore
+      setTimeout(() => {
+        const postDragFocusedNode = focusedItemWasDragged ? findItemOnDocument(sourceRecord.id) : findItemOnDocument(preDragFocusedNode.current.dataset.id);
+        focusContext.focusItemByNode(postDragFocusedNode);
+      }, 0);
+    }
+
+    currTargetRef.current = null;
+    setDraggedRecord(null);
+  }, [records, focusedItemWasDragged]);
+  const {
+    item: ItemComponent,
+    list: ListComponent
+  } = renderers;
+  const renderClone = useCallback((provided, snapshot, rubric) => {
+    const targetRecord = currTargetRef.current && records[currTargetRef.current.index] || {};
+    const record = records[rubric.source.index];
+    return /*#__PURE__*/createElement(ItemComponent, _objectSpread(_objectSpread({}, provided.draggableProps), {}, {
+      key: rubric.source.index,
+      record: record
+    }, getDraggableProps({
+      className: 'item-cloned'
+    }, provided, snapshot)), /*#__PURE__*/jsx(GripperVertical, _objectSpread(_objectSpread({}, provided.dragHandleProps), {}, {
+      className: "drag-handle"
+    })), itemRenderer({
+      record,
+      nestingLevel: targetRecord.nestingLevel
+    }));
+  }, [currTargetRef, records, itemRenderer]);
+  return /*#__PURE__*/_jsx(DragDropContext, {
+    onDragEnd: onDragEnd,
+    onDragStart: onDragStart,
+    onDragUpdate: onDragUpdate
+  }, void 0, /*#__PURE__*/_jsx(Droppable, {
+    droppableId: "droppableId",
+    isCombineEnabled: true,
+    mode: "virtual",
+    renderClone: renderClone
+  }, void 0, (droppableProvided, snapshot) => {
+    // Add an extra item to our list to make space for a dragging item
+    // work in a virtual list
+    const itemCount = snapshot.isUsingPlaceholder ? records.length + 1 : records.length;
+    return /*#__PURE__*/jsx(ListComponent, _objectSpread(_objectSpread({}, rest), {}, {
+      className: cx(rest.className, draggedRecord && 'dragging'),
+      innerRef: mergeRefs(droppableProvided.innerRef, rest.innerRef, rest.ref),
+      itemCount: itemCount,
+      records: records
     }));
-  };
+  }));
 };
 
 export { DroppableList as default };
-//# sourceMappingURL=DroppableList.js.map

package/esm/deprecated/plugins/dnd/utils.js

@@ -1,5 +1,10 @@
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
+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 'core-js/modules/web.dom-collections.iterator.js';
 import { cx, mergeRefs, set, get, cloneDeep, arrayMove } from '@elliemae/ds-utilities';
 
 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; }
@@ -13,7 +18,7 @@ function getStyle(provided, style) {
   return _objectSpread(_objectSpread({}, provided.draggableProps.style), style);
 }
 function getDraggableProps(props, provided, snapshot) {
-  var isGroupedOver = Boolean(snapshot.combineTargetFor);
+  const isGroupedOver = Boolean(snapshot.combineTargetFor);
   return _objectSpread(_objectSpread(_objectSpread({}, props), provided.draggableProps), {}, {
     className: cx(props.className, isGroupedOver && 'can-group-over'),
     // provided,
@@ -24,8 +29,8 @@ function getDraggableProps(props, provided, snapshot) {
     }))
   });
 }
-var setTreeArrayInPath = function setTreeArrayInPath(treeData, path, data) {
-  var nextTreeData = _toConsumableArray(treeData);
+const setTreeArrayInPath = (treeData, path, data) => {
+  const nextTreeData = [...treeData];
 
   if (path.length) {
     set(nextTreeData, path, data);
@@ -35,14 +40,14 @@ var setTreeArrayInPath = function setTreeArrayInPath(treeData, path, data) {
   return data;
 }; // check if at the earliest possible different nest level the source is before the target or not
 
-var isSourceBeforeTarget = function isSourceBeforeTarget(sourcePath, targetPath) {
-  var sourceIsBeforeTarget = false;
+const isSourceBeforeTarget = (sourcePath, targetPath) => {
+  let sourceIsBeforeTarget = false;
 
   if (sourcePath.length <= targetPath.length) {
     // we increase by 2 beacuse every other position is 'children'
-    for (var i = 0; i < sourcePath.length; i += 2) {
-      var source = sourcePath[i];
-      var target = targetPath[i]; // since we skip by 2 source/target can be out of bounds
+    for (let i = 0; i < sourcePath.length; i += 2) {
+      const source = sourcePath[i];
+      const target = targetPath[i]; // since we skip by 2 source/target can be out of bounds
       // if source/target are the same we are at same nest level
 
       if (!Number.isInteger(source) || // check to see if it's a number because 0 == false in javascript
@@ -55,55 +60,58 @@ var isSourceBeforeTarget = function isSourceBeforeTarget(sourcePath, targetPath)
 
   return sourceIsBeforeTarget;
 };
-var updateTargetPath = function updateTargetPath(sourcePath, targetPath) {
-  var incr = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-
-  var nextTargetPath = _toConsumableArray(targetPath);
-
-  var posToUpdate = sourcePath.length ? sourcePath.length - 1 : 0;
+const updateTargetPath = function (sourcePath, targetPath) {
+  let incr = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+  const nextTargetPath = [...targetPath];
+  const posToUpdate = sourcePath.length ? sourcePath.length - 1 : 0;
   nextTargetPath.splice(posToUpdate, 1, targetPath[posToUpdate] + incr);
   return nextTargetPath;
 };
-var getParentPath = function getParentPath(path) {
-  return path.slice(0, -1);
-};
-var getParentChildrenByPath = function getParentChildrenByPath(treeData, path) {
-  return path && path.length ? get(treeData, path) : treeData;
-};
-var getTreePosition = function getTreePosition(recordPath) {
-  return {
-    parentPath: getParentPath(recordPath),
-    index: recordPath.slice(-1)[0]
-  };
-};
-var changePositionBetweenDifferentArrays = function changePositionBetweenDifferentArrays(_ref) {
-  var sourceTreePosition = _ref.sourceTreePosition,
-      targetTreePosition = _ref.targetTreePosition,
-      combineWith = _ref.combineWith,
-      sourceRecord = _ref.sourceRecord,
-      targetRecord = _ref.targetRecord,
-      down = _ref.down,
-      data = _ref.data,
-      _ref$childrenKey = _ref.childrenKey,
-      childrenKey = _ref$childrenKey === void 0 ? 'children' : _ref$childrenKey;
-  var nextTreeData = cloneDeep(data);
+const getParentPath = path => path.slice(0, -1);
+const getParentChildrenByPath = (treeData, path) => path && path.length ? get(treeData, path) : treeData;
+const getTreePosition = recordPath => ({
+  parentPath: getParentPath(recordPath),
+  index: recordPath.slice(-1)[0]
+});
+const changePositionBetweenDifferentArrays = _ref => {
+  let {
+    sourceTreePosition,
+    // already extracted sourceRecord.path
+    targetTreePosition,
+    // already extracted targetRecord.path
+    // combineWith the element we want to append to the children of (this is null when the drag doesn't result in adding children)
+    combineWith,
+    sourceRecord,
+    // what we are dragging
+    targetRecord,
+    // what we are dropping on top of
+    down,
+    // ???
+    data,
+    // tree before dragEnd changes
+    childrenKey = 'children' // constant -> 'children'
+
+  } = _ref;
+  let nextTreeData = cloneDeep(data);
   if (!sourceRecord || !sourceRecord.data) throw new Error('error while dragging, no dragged item received');
-  var sourceTreeChildren = getParentChildrenByPath(nextTreeData, sourceTreePosition.parentPath); // When moving an item we remove the item from it's former parent children array
+  const sourceTreeChildren = getParentChildrenByPath(nextTreeData, sourceTreePosition.parentPath); // When moving an item we remove the item from it's former parent children array
 
   sourceTreeChildren.splice(sourceTreePosition.index, 1);
   nextTreeData = setTreeArrayInPath(nextTreeData, sourceTreePosition.parentPath, sourceTreeChildren); // if source is at previous position than the target children
   // then the index should decrease
 
-  var shouldUpdateTarget = isSourceBeforeTarget(sourceRecord.path, targetRecord.path);
-  var nextTargetPosition = shouldUpdateTarget ? combineWith ? {
+  const shouldUpdateTarget = isSourceBeforeTarget(sourceRecord.path, targetRecord.path);
+  const nextTargetPosition = shouldUpdateTarget ? combineWith ? {
     parentPath: updateTargetPath(sourceRecord.path, combineWith.path)
   } : getTreePosition(updateTargetPath(sourceRecord.path, targetRecord.path)) : targetTreePosition; // add to target
 
-  var parentPath = nextTargetPosition.parentPath;
-  var targetTreeChildren = getParentChildrenByPath(nextTreeData, parentPath) || (combineWith === null || combineWith === void 0 ? void 0 : combineWith.data) || (targetRecord === null || targetRecord === void 0 ? void 0 : targetRecord.data);
+  const {
+    parentPath
+  } = nextTargetPosition;
+  const targetTreeChildren = getParentChildrenByPath(nextTreeData, parentPath) || (combineWith === null || combineWith === void 0 ? void 0 : combineWith.data) || (targetRecord === null || targetRecord === void 0 ? void 0 : targetRecord.data);
 
   if (combineWith && targetTreeChildren) {
-    var targetChildrensArray = targetTreeChildren[childrenKey];
+    const targetChildrensArray = targetTreeChildren[childrenKey];
     targetChildrensArray.push(sourceRecord.data);
   } else if (targetTreeChildren) {
     targetTreeChildren.splice(targetTreePosition.index + (down ? 1 : 0), 0, sourceRecord.data);
@@ -112,19 +120,20 @@ var changePositionBetweenDifferentArrays = function changePositionBetweenDiffere
   nextTreeData = setTreeArrayInPath(nextTreeData, parentPath, targetTreeChildren);
   return nextTreeData;
 };
-var combineWithTarget = function combineWithTarget() {};
-var changePositionSameArray = function changePositionSameArray(_ref2) {
-  var targetTreePosition = _ref2.targetTreePosition,
-      sourceRecord = _ref2.sourceRecord,
-      targetRecord = _ref2.targetRecord,
-      data = _ref2.data;
-  var nextTreeData = cloneDeep(data);
-  var targetTreeChildren = getParentChildrenByPath(nextTreeData, targetTreePosition.parentPath);
-  var nextChildren = arrayMove(targetTreeChildren, sourceRecord.index, targetRecord.index); // mutates the tree. That's the reason of the clone above
+const combineWithTarget = () => {};
+const changePositionSameArray = _ref2 => {
+  let {
+    targetTreePosition,
+    sourceRecord,
+    targetRecord,
+    data
+  } = _ref2;
+  let nextTreeData = cloneDeep(data);
+  const targetTreeChildren = getParentChildrenByPath(nextTreeData, targetTreePosition.parentPath);
+  const nextChildren = arrayMove(targetTreeChildren, sourceRecord.index, targetRecord.index); // mutates the tree. That's the reason of the clone above
 
   nextTreeData = setTreeArrayInPath(nextTreeData, targetTreePosition.parentPath, nextChildren);
   return nextTreeData;
 };
 
 export { changePositionBetweenDifferentArrays, changePositionSameArray, combineWithTarget, getDraggableProps, getParentChildrenByPath, getParentPath, getStyle, getTreePosition, isSourceBeforeTarget, setTreeArrayInPath, updateTargetPath };
-//# sourceMappingURL=utils.js.map

package/esm/deprecated/plugins/index.js

@@ -5,33 +5,3 @@ export { TreeToolbarPlugin } from './toolbar/TreeToolbarPlugin.js';
 export { TreePluginList } from './tree/TreeDataPlugin.js';
 export { TreeVirtualizationPlugin } from './virtualization/TreeVirtualizationPlugin.js';
 export { SearchableTreePlugin } from './searchable/SearchableTreePlugin.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import 'react';
-import '@elliemae/ds-utilities';
-import '@elliemae/ds-shared/createDataInstance/createInstancePlugin';
-import './dnd/renderers/DraggableItem.js';
-import '@babel/runtime/helpers/esm/extends';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import 'react-beautiful-dnd';
-import '@elliemae/ds-icons';
-import './dnd/utils.js';
-import './dnd/renderers/DroppableList.js';
-import '@elliemae/ds-shared/FocusGroup/FocusGroupContext';
-import './tree/utils.js';
-import 'lodash/get';
-import '@elliemae/ds-shared/FocusGroup/FocusGroupManager';
-import '@elliemae/ds-shared/FocusGroup/useFocusGroupItem';
-import '@elliemae/ds-form';
-import './tree/walkTreeStrategy.js';
-import './selectable/utils.js';
-import '@elliemae/ds-button';
-import '@elliemae/ds-shared/toolbar/ToolbarProvider';
-import '@elliemae/ds-classnames';
-import '../renderers.js';
-import './tree/useExpandTreeState.js';
-import '@john-osullivan/react-window-dynamic-fork';
-import '@elliemae/ds-shared/virtualization';
-import 'react-highlight-words';
-//# sourceMappingURL=index.js.map