@elliemae/ds-data-table 2.0.0-next.8 → 2.0.0-rc.11

package/esm/helpers/dndkit/hierarchy/useHierarchyPreviewHandlers.js

@@ -1,74 +0,0 @@
-import { useCallback } from 'react';
-import { DATA_TESTID } from '../../../configs/constants.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import 'react-virtual';
-import '../../../configs/useRowFlattenization.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@babel/runtime/helpers/esm/jsx';
-import '@elliemae/ds-icons';
-import 'styled-components';
-import '../../../styled.js';
-import 'react/jsx-runtime';
-import '@elliemae/ds-form/Checkbox';
-import '@elliemae/ds-form/Radio';
-import '../../../parts/TableContent.js';
-import '@elliemae/ds-grid';
-import '@elliemae/ds-circular-progress-indicator';
-import '@elliemae/ds-icons/WarningTriangle';
-import '@elliemae/ds-system';
-import '@elliemae/ds-button';
-import '../../../DataTableContext.js';
-import '../../../parts/Row.js';
-import '../../../parts/Footer.js';
-import '@elliemae/ds-icons/GripperVertical';
-import '../../../parts/HoC/SortableItemContext.js';
-
-const useHierarchyPreviewHandlers = ({
-  setOverId,
-  setActiveId
-}) => {
-  const resetState = useCallback(() => {
-    setOverId(null);
-    setActiveId(null);
-    document.body.style.setProperty('cursor', '');
-    const el = document.querySelector("[data-testid=\"".concat(DATA_TESTID.DATA_TABLE_SCROLLABLE_CONTAINER, "\"]"));
-
-    el.onscroll = () => null;
-  }, [setOverId, setActiveId]);
-  const handlePreviewDragStart = useCallback(({
-    active: {
-      id
-    }
-  }) => {
-    setActiveId(id);
-    setOverId(id);
-    document.body.style.setProperty('cursor', 'grabbing');
-    const el = document.querySelector("[data-testid=\"".concat(DATA_TESTID.DATA_TABLE_SCROLLABLE_CONTAINER, "\"]"));
-    const y = el.scrollTop;
-
-    el.onscroll = () => el.scrollTo(0, y);
-  }, [setActiveId, setOverId]);
-  const handlePreviewDragMove = useCallback(() => null, []);
-  const handlePreviewDragOver = useCallback(({
-    over
-  }) => {
-    var _over$id;
-
-    setOverId((_over$id = over === null || over === void 0 ? void 0 : over.id) !== null && _over$id !== void 0 ? _over$id : null);
-  }, [setOverId]);
-  const handlePreviewDragEnd = useCallback(() => {
-    resetState();
-  }, [resetState]);
-  const handlePreviewDragCancel = useCallback(() => {
-    resetState();
-  }, [resetState]);
-  return {
-    handlePreviewDragStart,
-    handlePreviewDragMove,
-    handlePreviewDragOver,
-    handlePreviewDragEnd,
-    handlePreviewDragCancel
-  };
-};
-
-export { useHierarchyPreviewHandlers };

package/esm/helpers/dndkit/tree/customCollisionDetection.js

@@ -1,82 +0,0 @@
-import 'core-js/modules/web.dom-collections.iterator.js';
-import { DropIndicatorPosition } from '../../../parts/HoC/SortableItemContext.js';
-
-const DUMMY_ID = 'DUMMY_ID_INTERNAL_USE_ONLY';
-const RECT_UP = {
-  offsetTop: -Infinity,
-  offsetLeft: 0,
-  // Doesn't matter,
-  width: 0,
-  // Doesn't matter
-  height: 0 // Doesn't matter
-
-};
-const RECT_DOWN = {
-  offsetTop: Infinity,
-  offsetLeft: 0,
-  // Doesn't matter,
-  width: 0,
-  // Doesn't matter
-  height: 0 // Doesn't matter
-
-}; // Percentage of height to take into consideration when looking for colliding rects
-
-const thresholdRatio = 0.2; // Percentage to be inside
-
-const insideThreshold = 0.7;
-const customCollisionDetection = (activeId, visibleItemsDictionary, setDropIndicatorPosition, maxDragAndDropLevel, lastPosition, setLastPosition) => (rects, rect) => {
-  const originalRect = rects.find(([rectId]) => rectId === activeId); // We first check if the item was moved up or down
-  // This modifies how to search the matching colliding rect
-
-  let isUp = lastPosition === 'up';
-
-  if (originalRect) {
-    isUp = originalRect[1].offsetTop > rect.top;
-  } // Threshold
-
-
-  const threshold = rect.height * thresholdRatio;
-  let collidingRect = null;
-
-  if (isUp) {
-    // Up -- We need to find the first rectangle downwards
-    collidingRect = rects.reduce((acc, [rectID, rectData]) => {
-      if (rectData.offsetTop + threshold > rect.top && rectData.offsetTop < acc[1].offsetTop) {
-        return [rectID, rectData];
-      }
-
-      return acc;
-    }, [DUMMY_ID, RECT_DOWN]);
-  } else {
-    // Down -- We need to find the first rectangle upwards
-    collidingRect = rects.reduce((acc, [rectID, rectData]) => {
-      if (rectData.offsetTop - threshold < rect.top && rectData.offsetTop > acc[1].offsetTop) {
-        return [rectID, rectData];
-      }
-
-      return acc;
-    }, [DUMMY_ID, RECT_UP]);
-  } // If we didn't find a match, return null
-
-
-  if (collidingRect[0] === DUMMY_ID) {
-    return null;
-  } // Calculate the intersection interval
-
-
-  const [top, bottom] = [Math.max(rect.top, collidingRect[1].offsetTop), Math.min(rect.bottom, collidingRect[1].offsetTop + collidingRect[1].height)]; // Calculate the percentage of intersection
-
-  const intersectionPercentage = Math.abs(bottom - top) / collidingRect[1].height;
-
-  if (intersectionPercentage > insideThreshold && visibleItemsDictionary[collidingRect[0]].depth + 1 <= maxDragAndDropLevel && collidingRect[0] !== activeId) {
-    setDropIndicatorPosition(DropIndicatorPosition.Inside);
-  } else {
-    setDropIndicatorPosition(isUp ? DropIndicatorPosition.Before : DropIndicatorPosition.After);
-  }
-
-  if (isUp && lastPosition !== 'up') setLastPosition('up');else if (!isUp && lastPosition !== 'down') setLastPosition('down'); // Return the id of the match rectangle
-
-  return collidingRect[0];
-};
-
-export { customCollisionDetection };

package/esm/helpers/dndkit/tree/getTreeKeyboardCoordinates.js

@@ -1,119 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import { KeyboardCode, getViewRect, closestCorners } from '@dnd-kit/core';
-import { DropIndicatorPosition } from '../../../parts/HoC/SortableItemContext.js';
-
-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 directions = [KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left];
-const horizontal = [KeyboardCode.Left, KeyboardCode.Right]; // const vertical: string[] = [KeyboardCode.Up, KeyboardCode.Down];
-
-const getVerticalKeyboardCoordinates = ({
-  items,
-  active,
-  over,
-  event,
-  currentCoordinates,
-  droppableContainers,
-  translatedRect,
-  dropIndicatorPosition,
-  maxDragAndDropLevel
-}) => {
-  if (horizontal.includes(event.code)) return undefined;
-  const activeRect = droppableContainers[active].rect.current;
-  const overRect = over.rect;
-  const layoutRects = []; // Get the reacheable rects depending on the arrow key pressed
-
-  Object.entries(droppableContainers).forEach(([id, container]) => {
-    if (container !== null && container !== void 0 && container.disabled || !overRect) {
-      return;
-    }
-
-    const node = container === null || container === void 0 ? void 0 : container.node.current;
-
-    if (!node) {
-      return;
-    }
-
-    const rect = getViewRect(node);
-
-    if (event.code === KeyboardCode.Down && translatedRect.top - 2 <= rect.top) {
-      layoutRects.push([id, rect]);
-    } else if (event.code === KeyboardCode.Up && translatedRect.top >= rect.top) {
-      layoutRects.push([id, rect]);
-    }
-  });
-  const closestId = closestCorners(layoutRects, translatedRect);
-  if (!closestId) return undefined;
-  const closestItem = items.find(item => item.uid === closestId);
-  const closestRect = getViewRect(droppableContainers[closestId].node.current);
-
-  if (event.code === KeyboardCode.Up) {
-    // If the drop indicator is inside (or over ourselves)
-    // We are gonna go to the before position
-    // Else we are gonna go inside the over rect
-    if (dropIndicatorPosition === DropIndicatorPosition.Inside || closestId === active || closestItem.depth + 1 > maxDragAndDropLevel) {
-      return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
-        y: closestRect.top - translatedRect.height / 2
-      });
-    }
-
-    return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
-      y: closestRect.top + Math.abs(closestRect.height - activeRect.height) / 2
-    });
-  } // If the drop indicator is inside (or over ourselves)
-  // We are gonna go to the after position
-  // Else we are gonna go inside the over rect
-
-
-  if (dropIndicatorPosition === DropIndicatorPosition.Inside || closestId === active || closestItem.depth + 1 > maxDragAndDropLevel) {
-    return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
-      y: closestRect.top + translatedRect.height / 2
-    });
-  }
-
-  return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
-    y: closestRect.top + Math.abs(closestRect.height - activeRect.height) / 2
-  });
-};
-
-const getTreeKeyboardCoordinates = (context, isHorizontalDnD, maxDragAndDropLevel) => (event, {
-  active,
-  currentCoordinates,
-  context: {
-    over,
-    translatedRect,
-    droppableContainers
-  }
-}) => {
-  if (directions.includes(event.code)) {
-    if (!translatedRect) {
-      return undefined;
-    }
-
-    const {
-      current: {
-        items,
-        dropIndicatorPosition
-      }
-    } = context;
-    const args = {
-      items,
-      active,
-      over,
-      event,
-      currentCoordinates,
-      droppableContainers,
-      translatedRect,
-      dropIndicatorPosition,
-      maxDragAndDropLevel
-    };
-    if (isHorizontalDnD) return undefined;
-    return getVerticalKeyboardCoordinates(args);
-  }
-
-  return undefined;
-};
-
-export { getTreeKeyboardCoordinates };

package/esm/helpers/dndkit/tree/types.js

@@ -1 +0,0 @@
-

package/esm/helpers/dndkit/tree/useTreeActionHandlers.js

@@ -1,70 +0,0 @@
-import { arrayMove } from '@dnd-kit/sortable';
-import { cloneDeep } from 'lodash';
-import { useCallback } from 'react';
-import { DropIndicatorPosition } from '../../../parts/HoC/SortableItemContext.js';
-
-const useTreeActionHandlers = ({
-  handlePreviewDragStart,
-  handlePreviewDragMove,
-  handlePreviewDragOver,
-  handlePreviewDragEnd,
-  handlePreviewDragCancel,
-  onReorder,
-  flattenedItems,
-  projected,
-  dropIndicatorPosition
-}) => {
-  const onDragStart = useCallback(e => {
-    handlePreviewDragStart(e);
-  }, [handlePreviewDragStart]);
-  const onDragMove = useCallback(e => {
-    handlePreviewDragMove(e);
-  }, [handlePreviewDragMove]);
-  const onDragOver = useCallback(e => {
-    handlePreviewDragOver(e);
-  }, [handlePreviewDragOver]);
-  const onDragEnd = useCallback(e => {
-    handlePreviewDragEnd(e);
-    const {
-      active,
-      over
-    } = e;
-    if (over === null) return;
-    const activeIndex = flattenedItems.findIndex(item => item.uid === active.id);
-    let considerExpanding = null;
-    let overIndex = flattenedItems.findIndex(item => item.uid === over.id); // If drop indicator is inside, then put it last,
-    // It will be reconstructed well later
-
-    if (dropIndicatorPosition === DropIndicatorPosition.Inside) {
-      var _flattenedItems$overI, _flattenedItems$overI2;
-
-      considerExpanding = over.id;
-      overIndex = flattenedItems[overIndex].realIndex + ((_flattenedItems$overI = (_flattenedItems$overI2 = flattenedItems[overIndex].original.subRows) === null || _flattenedItems$overI2 === void 0 ? void 0 : _flattenedItems$overI2.length) !== null && _flattenedItems$overI !== void 0 ? _flattenedItems$overI : 0) + 1;
-    } // If we are dropping the item in a new position, or new depth
-
-
-    if (activeIndex !== overIndex || flattenedItems[activeIndex].depth !== projected.depth) {
-      // Change parent and depth from projected data
-      flattenedItems[activeIndex].parentId = projected.parentId;
-      flattenedItems[activeIndex].depth = projected.depth; // If same index, don't move the array, just copy it
-
-      const newFlattenedData = activeIndex !== overIndex ? arrayMove(flattenedItems, activeIndex, overIndex) : cloneDeep(flattenedItems);
-      onReorder(newFlattenedData, {
-        targetIndex: overIndex,
-        fromIndex: activeIndex
-      }, considerExpanding);
-    }
-  }, [handlePreviewDragEnd, flattenedItems, projected, onReorder, dropIndicatorPosition]);
-  const onDragCancel = useCallback(e => {
-    handlePreviewDragCancel(e);
-  }, [handlePreviewDragCancel]);
-  return {
-    onDragStart,
-    onDragMove,
-    onDragOver,
-    onDragEnd,
-    onDragCancel
-  };
-};
-
-export { useTreeActionHandlers };

package/esm/helpers/dndkit/tree/useTreeAnnouncements.js

@@ -1,51 +0,0 @@
-import { useCallback } from 'react';
-import { DropIndicatorPosition } from '../../../parts/HoC/SortableItemContext.js';
-
-const useTreeAnnouncements = (visibleItemsDictionary, dropIndicatorPosition) => {
-  const onDragStart = useCallback(id => "Picked up draggable item from position ".concat(visibleItemsDictionary[id].realIndex + 1, "."), [visibleItemsDictionary]);
-  const onDragMove = useCallback((id, overId) => {
-    if (overId) {
-      const overIndex = visibleItemsDictionary[overId].realIndex + 1;
-
-      if (dropIndicatorPosition === DropIndicatorPosition.Inside) {
-        return "Draggable item was moved inside the item at position ".concat(overIndex, ".");
-      }
-
-      if (dropIndicatorPosition === DropIndicatorPosition.Before) {
-        return "Draggable item was moved to position ".concat(overIndex - 1, ".");
-      }
-
-      return "Draggable item was moved to position ".concat(overIndex, ".");
-    }
-
-    return "Draggable item is no longer over a droppable area.";
-  }, [visibleItemsDictionary, dropIndicatorPosition]);
-  const onDragOver = onDragMove;
-  const onDragEnd = useCallback((id, overId) => {
-    if (overId) {
-      const overIndex = visibleItemsDictionary[overId].realIndex + 1;
-
-      if (dropIndicatorPosition === DropIndicatorPosition.Inside) {
-        return "Draggable item was dropped inside the item at position ".concat(overIndex, ".");
-      }
-
-      if (dropIndicatorPosition === DropIndicatorPosition.Before) {
-        return "Draggable item was dropped over position ".concat(overIndex - 1, ".");
-      }
-
-      return "Draggable item was dropped over position ".concat(overIndex, ".");
-    }
-
-    return "Draggable item was dropped at it's original position.";
-  }, [dropIndicatorPosition, visibleItemsDictionary]);
-  const onDragCancel = useCallback(id => "Dragging was cancelled. Draggable item from position ".concat(visibleItemsDictionary[id].realIndex + 1, " was dropped at it's initial position."), [visibleItemsDictionary]);
-  return {
-    onDragStart,
-    onDragOver,
-    onDragMove,
-    onDragEnd,
-    onDragCancel
-  };
-};
-
-export { useTreeAnnouncements };

package/esm/helpers/dndkit/tree/useTreeDndkitConfig.js

@@ -1,122 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import { useState, useMemo, useRef, useEffect } from 'react';
-import { LayoutMeasuringStrategy, useSensors, useSensor, PointerSensor, KeyboardSensor } from '@dnd-kit/core';
-import { horizontalListSortingStrategy, verticalListSortingStrategy } from '@dnd-kit/sortable';
-import { useTreePreviewHandlers } from './useTreePreviewHandlers.js';
-import { getTreeKeyboardCoordinates } from './getTreeKeyboardCoordinates.js';
-import { removeChildrenOf, getProjection } from '../utilities.js';
-import { useTreeActionHandlers } from './useTreeActionHandlers.js';
-import { customCollisionDetection } from './customCollisionDetection.js';
-import { useTreeAnnouncements } from './useTreeAnnouncements.js';
-
-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; }
-// if second parameter is true, the space will be done on the horizontal axis
-
-const adjustTranslate = ({
-  transform
-}, isHorizontalDnD = false) => {
-  const newTransform = _objectSpread({}, transform);
-
-  if (isHorizontalDnD) {
-    newTransform.x = transform.x + 25;
-  } else {
-    newTransform.x = transform.x + 15;
-  }
-
-  return newTransform;
-};
-
-const layoutMeasuring = {
-  strategy: LayoutMeasuringStrategy.BeforeDragging
-};
-
-const useTreeDndkitConfig = ({
-  flattenedItems,
-  visibleItems: preVisibleItems,
-  isHorizontalDnD = false,
-  isExpandable = false,
-  onReorder,
-  maxDragAndDropLevel
-}) => {
-  var _visibleItemsDictiona, _visibleItemsDictiona2;
-
-  const [activeId, setActiveId] = useState(null);
-  const [overId, setOverId] = useState(null);
-  const [dropIndicatorPosition, setDropIndicatorPosition] = useState(null);
-  const [lastPosition, setLastPosition] = useState(null); // Remove activeId's children
-
-  const visibleItems = useMemo(() => removeChildrenOf(preVisibleItems, activeId), [preVisibleItems, activeId]); // Sorted ids for the library
-
-  const sortedIds = useMemo(() => visibleItems.map(item => item.uid), [visibleItems]);
-  /**
-   * Dictionary from UID to ITEM
-   * This dictionary is computed since on every DnD move, I need to know the
-   * depth of a particular row, so O(1) per DnD move instead of O(#ITEMS)
-   */
-
-  const visibleItemsDictionary = useMemo(() => {
-    // Using plain for to achieve O(#ITEMS) performance
-    const dictionary = {};
-    visibleItems.forEach(item => {
-      dictionary[item.uid] = item;
-    });
-    return dictionary;
-  }, [visibleItems]);
-  const modifiers = useMemo(() => [options => adjustTranslate(options, isHorizontalDnD)], [isHorizontalDnD]);
-  const sensorContext = useRef({
-    items: visibleItems,
-    dropIndicatorPosition,
-    setDropIndicatorPosition
-  });
-  useEffect(() => {
-    sensorContext.current = {
-      items: visibleItems,
-      dropIndicatorPosition,
-      setDropIndicatorPosition
-    };
-  }, [visibleItems, dropIndicatorPosition, setDropIndicatorPosition]);
-  const coordinateGetter = useMemo(() => getTreeKeyboardCoordinates(sensorContext, isHorizontalDnD, maxDragAndDropLevel), [sensorContext, isHorizontalDnD, maxDragAndDropLevel]);
-  const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, {
-    coordinateGetter
-  })); // where is the activeItem being positioned (depth and parent)
-
-  const projected = useMemo(() => overId ? getProjection(visibleItems, visibleItemsDictionary, overId, dropIndicatorPosition, isExpandable) : null, [overId, visibleItems, visibleItemsDictionary, dropIndicatorPosition, isExpandable]);
-  const dragPreviewHandlers = useTreePreviewHandlers({
-    setActiveId,
-    setOverId,
-    setDropIndicatorPosition
-  });
-  const dragActionHandlers = useTreeActionHandlers(_objectSpread(_objectSpread({}, dragPreviewHandlers), {}, {
-    onReorder,
-    projected,
-    flattenedItems,
-    dropIndicatorPosition
-  }));
-  const announcements = useTreeAnnouncements(visibleItemsDictionary, dropIndicatorPosition);
-  const dndContextProps = useMemo(() => _objectSpread({
-    announcements,
-    modifiers,
-    sensors,
-    layoutMeasuring,
-    collisionDetection: customCollisionDetection(activeId, visibleItemsDictionary, setDropIndicatorPosition, maxDragAndDropLevel, lastPosition, setLastPosition)
-  }, dragActionHandlers), [announcements, modifiers, sensors, dragActionHandlers, visibleItemsDictionary, setDropIndicatorPosition, activeId, maxDragAndDropLevel, lastPosition, setLastPosition]);
-  const sortableContextProps = useMemo(() => ({
-    items: sortedIds,
-    strategy: isHorizontalDnD ? horizontalListSortingStrategy : verticalListSortingStrategy
-  }), [sortedIds, isHorizontalDnD]);
-  return {
-    dndContextProps,
-    sortableContextProps,
-    activeId,
-    activeIndex: (_visibleItemsDictiona = (_visibleItemsDictiona2 = visibleItemsDictionary[activeId]) === null || _visibleItemsDictiona2 === void 0 ? void 0 : _visibleItemsDictiona2.realIndex) !== null && _visibleItemsDictiona !== void 0 ? _visibleItemsDictiona : -1,
-    overId,
-    depth: projected ? projected.depth : 0,
-    dropIndicatorPosition,
-    visibleItems
-  };
-};
-
-export { useTreeDndkitConfig as default };

package/esm/helpers/dndkit/tree/useTreePreviewHandlers.js

@@ -1,47 +0,0 @@
-import { useCallback } from 'react';
-import { DropIndicatorPosition } from '../../../parts/HoC/SortableItemContext.js';
-
-const useTreePreviewHandlers = ({
-  setOverId,
-  setActiveId,
-  setDropIndicatorPosition
-}) => {
-  const resetState = useCallback(() => {
-    setOverId(null);
-    setActiveId(null);
-    document.body.style.setProperty('cursor', '');
-  }, [setOverId, setActiveId]);
-  const handlePreviewDragStart = useCallback(({
-    active: {
-      id
-    }
-  }) => {
-    setActiveId(id);
-    setOverId(id);
-    setDropIndicatorPosition(DropIndicatorPosition.Inside);
-    document.body.style.setProperty('cursor', 'grabbing');
-  }, [setActiveId, setDropIndicatorPosition, setOverId]);
-  const handlePreviewDragMove = useCallback(() => null, []);
-  const handlePreviewDragOver = useCallback(({
-    over
-  }) => {
-    var _over$id;
-
-    setOverId((_over$id = over === null || over === void 0 ? void 0 : over.id) !== null && _over$id !== void 0 ? _over$id : null);
-  }, [setOverId]);
-  const handlePreviewDragEnd = useCallback(() => {
-    resetState();
-  }, [resetState]);
-  const handlePreviewDragCancel = useCallback(() => {
-    resetState();
-  }, [resetState]);
-  return {
-    handlePreviewDragStart,
-    handlePreviewDragMove,
-    handlePreviewDragOver,
-    handlePreviewDragEnd,
-    handlePreviewDragCancel
-  };
-};
-
-export { useTreePreviewHandlers };

package/esm/helpers/dndkit/types.js

@@ -1 +0,0 @@
-

package/esm/helpers/dndkit/utilities.js

@@ -1,46 +0,0 @@
-import { DropIndicatorPosition } from '../../parts/HoC/SortableItemContext.js';
-
-/* eslint-disable max-params */
-
-const getMinDepth = item => {
-  if (item) return item.depth;
-  return 0;
-};
-
-const getProjection = (items, visibleItemsDictionary, overId, dropIndicatorPosition, isExpandable) => {
-  const overItemIndex = visibleItemsDictionary[overId].realIndex;
-  const previousItem = items[overItemIndex];
-  const nextItem = items[overItemIndex + 1];
-
-  if (dropIndicatorPosition === DropIndicatorPosition.Inside && isExpandable) {
-    return {
-      depth: visibleItemsDictionary[overId].depth + 1,
-      parentId: overId
-    };
-  }
-
-  if (dropIndicatorPosition === DropIndicatorPosition.Before) {
-    return {
-      depth: getMinDepth(previousItem),
-      parentId: previousItem.parentId
-    };
-  }
-
-  return {
-    depth: getMinDepth(nextItem),
-    parentId: nextItem === null || nextItem === void 0 ? void 0 : nextItem.parentId
-  };
-};
-const removeChildrenOf = (items, id) => {
-  const excludeParentIds = [id];
-  return items.filter(item => {
-    if (item.parentId !== null && excludeParentIds.includes(item.parentId)) {
-      excludeParentIds.push(item.uid);
-      return false;
-    }
-
-    return true;
-  });
-};
-
-export { getProjection, removeChildrenOf };

package/esm/parts/FilterBar/components/TextPill.js

@@ -1,30 +0,0 @@
-import _jsx from '@babel/runtime/helpers/esm/jsx';
-import { useCallback } from 'react';
-import { DSPillGroupV2, DSPillV2 } from '@elliemae/ds-pills';
-
-const TextPill = ({
-  columnHeader,
-  column,
-  value,
-  filters,
-  onFiltersChange,
-  prevRef,
-  innerRef,
-  nextRef
-}) => {
-  const handleOnRemove = useCallback(() => {
-    if (prevRef !== null && prevRef !== void 0 && prevRef.current) prevRef.current.focus();else nextRef.current.focus();
-    onFiltersChange(filters.filter(filter => filter.id !== column));
-  }, [onFiltersChange, filters, prevRef, nextRef, column]);
-  return value ? /*#__PURE__*/_jsx(DSPillGroupV2, {}, void 0, /*#__PURE__*/_jsx(DSPillV2, {
-    type: "label",
-    label: columnHeader
-  }), /*#__PURE__*/_jsx(DSPillV2, {
-    type: "removable",
-    label: value,
-    onRemove: handleOnRemove,
-    innerRef: innerRef
-  })) : null;
-};
-
-export { TextPill };

package/esm/parts/HoC/DragOverlayContext.js

@@ -1,7 +0,0 @@
-import { createContext } from 'react';
-
-const DragOverlayContext = /*#__PURE__*/createContext({
-  setPureDraggedJSX: () => null
-});
-
-export { DragOverlayContext };

package/types/addons/Pagination/ActiveZoneButtons.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-interface ActiveZoneButtonsProps {
-    pageIndex: number;
-    pageCount: number;
-    onPageChange: (n: number) => void;
-    ButtonComponent: any;
-}
-declare const ActiveZoneButtons: React.ComponentType<ActiveZoneButtonsProps>;
-export default ActiveZoneButtons;

package/types/addons/Pagination/PagesButtons.d.ts

@@ -1,4 +0,0 @@
-import React from 'react';
-import { TypescriptPagination } from '../../types/props';
-declare const PagesButtons: React.ComponentType<TypescriptPagination>;
-export default PagesButtons;