@elliemae/ds-drag-and-drop 2.0.0-alpha.12

package/esm/hierarchy/getHierarchyKeyboardCoordinates.js

@@ -0,0 +1,113 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { KeyboardCode, getViewRect, closestCorners } from '@dnd-kit/core';
+
+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 vertical = [KeyboardCode.Up, KeyboardCode.Down];
+
+const getHorizontalKeyboardCoordinates = _ref => {
+  var _droppableContainers$, _droppableContainers$2, _droppableContainers$3, _droppableContainers$4;
+
+  let {
+    items,
+    active,
+    over,
+    event,
+    currentCoordinates,
+    droppableContainers,
+    collisionRect
+  } = _ref;
+  if (vertical.includes(event.code) || !active || !over) return undefined;
+  const activeItem = items.find(item => item.id === active.id);
+  const overRect = over.rect;
+  const layoutRects = []; // Get the reacheable rects depending on the arrow key pressed
+
+  droppableContainers.forEach(container => {
+    var _items$find;
+
+    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 itemParent = (_items$find = items.find(item => item.id === container.id)) === null || _items$find === void 0 ? void 0 : _items$find.parentId;
+    if (itemParent !== (activeItem === null || activeItem === void 0 ? void 0 : activeItem.parentId)) return;
+    const rect = getViewRect(node);
+
+    if (event.code === KeyboardCode.Left && collisionRect.left > rect.right - 10) {
+      layoutRects.push(container);
+    } else if (event.code === KeyboardCode.Right && collisionRect.left < rect.left) {
+      layoutRects.push(container);
+    }
+  });
+  const closestId = closestCorners({
+    droppableContainers: layoutRects,
+    collisionRect,
+    active
+  });
+  if (!closestId) return undefined;
+  const closestDroppableContainer = (_droppableContainers$ = droppableContainers.get(closestId)) === null || _droppableContainers$ === void 0 ? void 0 : (_droppableContainers$2 = _droppableContainers$.node) === null || _droppableContainers$2 === void 0 ? void 0 : _droppableContainers$2.current;
+  const activeDroppableContainer = (_droppableContainers$3 = droppableContainers.get(active === null || active === void 0 ? void 0 : active.id)) === null || _droppableContainers$3 === void 0 ? void 0 : (_droppableContainers$4 = _droppableContainers$3.node) === null || _droppableContainers$4 === void 0 ? void 0 : _droppableContainers$4.current;
+  if (!closestDroppableContainer || !activeDroppableContainer) return undefined;
+  const closestRect = getViewRect(closestDroppableContainer);
+  const activeRect = getViewRect(activeDroppableContainer);
+  return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
+    x: closestRect.left + (closestRect.width - collisionRect.width) / 2 + (closestRect.offsetLeft < activeRect.left ? -1 : 1)
+  });
+};
+
+const getHierarchyKeyboardCoordinates = (context, dragOverlayDataTestid, isHorizontalDnD) => (event, _ref2) => {
+  let {
+    currentCoordinates,
+    context: {
+      active,
+      over,
+      collisionRect,
+      droppableContainers
+    }
+  } = _ref2;
+
+  if (directions.includes(event.code)) {
+    event.preventDefault();
+
+    if (!collisionRect) {
+      return undefined;
+    }
+
+    const {
+      current: {
+        items
+      }
+    } = context;
+    const args = {
+      dragOverlayDataTestid,
+      items,
+      active,
+      over,
+      event,
+      currentCoordinates,
+      droppableContainers,
+      collisionRect
+    };
+    if (isHorizontalDnD) return getHorizontalKeyboardCoordinates(args);
+    return undefined;
+  }
+
+  return undefined;
+};
+
+export { getHierarchyKeyboardCoordinates };

package/esm/hierarchy/index.js

@@ -0,0 +1 @@
+export { useHierarchyDndkitConfig } from './useHierarchyDndkitConfig.js';

package/esm/hierarchy/types.js

@@ -0,0 +1 @@
+

package/esm/hierarchy/useHierarchyActionHandlers.js

@@ -0,0 +1,46 @@
+import { useCallback } from 'react';
+
+const useHierarchyActionHandlers = _ref => {
+  let {
+    handlePreviewDragStart,
+    handlePreviewDragMove,
+    handlePreviewDragEnd,
+    handlePreviewDragCancel,
+    onReorder,
+    dndItems
+  } = _ref;
+  const onDragStart = useCallback(e => {
+    handlePreviewDragStart(e);
+  }, [handlePreviewDragStart]);
+  const onDragMove = useCallback(e => {
+    handlePreviewDragMove(e);
+  }, [handlePreviewDragMove]);
+  const onDragEnd = useCallback(e => {
+    handlePreviewDragEnd(e);
+    const {
+      active,
+      over
+    } = e;
+    if (!over) return;
+
+    if (active.id !== over.id) {
+      const activeIndex = dndItems.findIndex(item => item.id === active.id);
+      const overIndex = dndItems.findIndex(item => item.id === over.id);
+      onReorder(dndItems[activeIndex], {
+        targetIndex: overIndex,
+        fromIndex: activeIndex
+      });
+    }
+  }, [handlePreviewDragEnd, dndItems, onReorder]);
+  const onDragCancel = useCallback(e => {
+    handlePreviewDragCancel(e);
+  }, [handlePreviewDragCancel]);
+  return {
+    onDragStart,
+    onDragMove,
+    onDragEnd,
+    onDragCancel
+  };
+};
+
+export { useHierarchyActionHandlers };

package/esm/hierarchy/useHierarchyAnnouncements.js

@@ -0,0 +1,32 @@
+import { useCallback } from 'react';
+
+const useHierarchyAnnouncements = visibleItemsDictionary => {
+  const onDragStart = useCallback(id => "Picked up draggable item from position ".concat(visibleItemsDictionary[id].index + 1, "."), [visibleItemsDictionary]);
+  const onDragMove = useCallback((id, overId) => {
+    if (overId) {
+      const overIndex = visibleItemsDictionary[overId].index + 1;
+      return "Draggable item was moved to position ".concat(overIndex, ".");
+    }
+
+    return "Draggable item is no longer over a droppable area.";
+  }, [visibleItemsDictionary]);
+  const onDragOver = onDragMove;
+  const onDragEnd = useCallback((id, overId) => {
+    if (overId) {
+      const overIndex = visibleItemsDictionary[overId].index + 1;
+      return "Draggable item was dropped over position ".concat(overIndex, ".");
+    }
+
+    return "Draggable item was dropped at it's original position.";
+  }, [visibleItemsDictionary]);
+  const onDragCancel = useCallback(id => "Dragging was cancelled. Draggable item from position ".concat(visibleItemsDictionary[id].index + 1, " was dropped at it's initial position."), [visibleItemsDictionary]);
+  return {
+    onDragStart,
+    onDragOver,
+    onDragMove,
+    onDragEnd,
+    onDragCancel
+  };
+};
+
+export { useHierarchyAnnouncements };

package/esm/hierarchy/useHierarchyDndkitConfig.js

@@ -0,0 +1,111 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useState, useMemo, useRef, useEffect } from 'react';
+import { MeasuringStrategy, useSensors, useSensor, PointerSensor, KeyboardSensor } from '@dnd-kit/core';
+import { useHierarchyActionHandlers } from './useHierarchyActionHandlers.js';
+import { useHierarchyPreviewHandlers } from './useHierarchyPreviewHandlers.js';
+import { getHierarchyKeyboardCoordinates } from './getHierarchyKeyboardCoordinates.js';
+import { customCollisionDetection } from './customCollisionDetection.js';
+import { useHierarchyAnnouncements } from './useHierarchyAnnouncements.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 = isHorizontalDnD => _ref => {
+  let {
+    transform
+  } = _ref;
+
+  const newTransform = _objectSpread({}, transform);
+
+  if (isHorizontalDnD) {
+    newTransform.y = transform.y + 15;
+  } else {
+    newTransform.y = transform.y - 35;
+  }
+
+  return newTransform;
+};
+
+const measuring = {
+  droppable: {
+    strategy: MeasuringStrategy.Always
+  }
+};
+
+const noop = () => null;
+
+const useHierarchyDndkitConfig = _ref2 => {
+  var _itemsDictionary$acti;
+
+  let {
+    flattenedItems,
+    dragOverlayDataTestid,
+    isHorizontalDnD = false,
+    onReorder,
+    onPreviewResetState = noop,
+    onPreviewDragStart = noop
+  } = _ref2;
+  const [activeId, setActiveId] = useState('');
+  const dndItems = useMemo(() => flattenedItems.map(_ref3 => {
+    let [item] = _ref3;
+    return item;
+  }), [flattenedItems]);
+  const itemsDictionary = useMemo(() => {
+    const dictionary = {};
+    dndItems.forEach(item => {
+      dictionary[item.id] = item;
+    });
+    return dictionary;
+  }, [dndItems]);
+  const modifiers = useMemo(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);
+  const sensorContext = useRef({
+    items: dndItems
+  });
+  useEffect(() => {
+    sensorContext.current = {
+      items: dndItems
+    };
+  }, [dndItems]);
+  const coordinateGetter = useMemo(() => getHierarchyKeyboardCoordinates(sensorContext, dragOverlayDataTestid, isHorizontalDnD), [isHorizontalDnD]);
+  const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, {
+    coordinateGetter
+  }));
+  const dragPreviewHandlers = useHierarchyPreviewHandlers({
+    setActiveId,
+    onPreviewResetState,
+    onPreviewDragStart
+  });
+  const dragActionHandlers = useHierarchyActionHandlers(_objectSpread(_objectSpread({}, dragPreviewHandlers), {}, {
+    dndItems,
+    onReorder
+  }));
+  const announcements = useHierarchyAnnouncements(itemsDictionary);
+  const dndContextProps = useMemo(() => {
+    var _itemsDictionary;
+
+    return _objectSpread({
+      announcements,
+      modifiers,
+      sensors,
+      measuring,
+      collisionDetection: customCollisionDetection(activeId, (_itemsDictionary = itemsDictionary[activeId !== null && activeId !== void 0 ? activeId : '']) === null || _itemsDictionary === void 0 ? void 0 : _itemsDictionary.parentId, dndItems)
+    }, dragActionHandlers);
+  }, [announcements, modifiers, sensors, activeId, itemsDictionary, dndItems, dragActionHandlers]);
+  return {
+    dndContextProps,
+    activeId,
+    activeIndex: activeId ? (_itemsDictionary$acti = itemsDictionary[activeId]) === null || _itemsDictionary$acti === void 0 ? void 0 : _itemsDictionary$acti.index : -1
+  };
+};
+
+export { useHierarchyDndkitConfig };

package/esm/hierarchy/useHierarchyPreviewHandlers.js

@@ -0,0 +1,39 @@
+import { useCallback } from 'react';
+
+const useHierarchyPreviewHandlers = _ref => {
+  let {
+    setActiveId,
+    onPreviewResetState,
+    onPreviewDragStart
+  } = _ref;
+  const resetState = useCallback(() => {
+    setActiveId('');
+    onPreviewResetState();
+    document.body.style.setProperty('cursor', '');
+  }, [setActiveId, onPreviewResetState]);
+  const handlePreviewDragStart = useCallback(_ref2 => {
+    let {
+      active: {
+        id
+      }
+    } = _ref2;
+    setActiveId(id);
+    document.body.style.setProperty('cursor', 'grabbing');
+    onPreviewDragStart();
+  }, [setActiveId, onPreviewDragStart]);
+  const handlePreviewDragMove = useCallback(() => null, []);
+  const handlePreviewDragEnd = useCallback(() => {
+    resetState();
+  }, [resetState]);
+  const handlePreviewDragCancel = useCallback(() => {
+    resetState();
+  }, [resetState]);
+  return {
+    handlePreviewDragStart,
+    handlePreviewDragMove,
+    handlePreviewDragEnd,
+    handlePreviewDragCancel
+  };
+};
+
+export { useHierarchyPreviewHandlers };

package/esm/index.js

@@ -0,0 +1,2 @@
+export { useHierarchyDndkitConfig } from './hierarchy/useHierarchyDndkitConfig.js';
+export { useTreeDndkitConfig } from './tree/useTreeDndkitConfig.js';

package/esm/tree/constants.js

@@ -0,0 +1,10 @@
+let DropIndicatorPosition;
+
+(function (DropIndicatorPosition) {
+  DropIndicatorPosition[DropIndicatorPosition["None"] = 0] = "None";
+  DropIndicatorPosition[DropIndicatorPosition["Before"] = 1] = "Before";
+  DropIndicatorPosition[DropIndicatorPosition["After"] = 2] = "After";
+  DropIndicatorPosition[DropIndicatorPosition["Inside"] = 3] = "Inside";
+})(DropIndicatorPosition || (DropIndicatorPosition = {}));
+
+export { DropIndicatorPosition };

package/esm/tree/customCollisionDetection.js

@@ -0,0 +1,133 @@
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { DropIndicatorPosition } from './constants.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) => _ref => {
+  var _originalContainer$re;
+
+  let {
+    droppableContainers,
+    collisionRect
+  } = _ref;
+  const originalContainer = droppableContainers.find(_ref2 => {
+    let {
+      id
+    } = _ref2;
+    return id === activeId;
+  });
+  const originalRect = originalContainer === null || originalContainer === void 0 ? void 0 : (_originalContainer$re = originalContainer.rect) === null || _originalContainer$re === void 0 ? void 0 : _originalContainer$re.current; // 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.offsetTop > collisionRect.top;
+  } // Threshold
+
+
+  const threshold = collisionRect.height * thresholdRatio;
+  let collidingContainer = null;
+
+  if (isUp) {
+    // Up -- We need to find the first rectangle downwards
+    collidingContainer = droppableContainers.reduce((firstRectDown, container) => {
+      const rect = container.rect.current;
+
+      if (rect && firstRectDown.rect.current) {
+        const {
+          offsetTop: rectOffsetTop
+        } = rect;
+        const {
+          offsetTop: firstRectDownOffsetTop
+        } = firstRectDown.rect.current;
+
+        if (rectOffsetTop + threshold > collisionRect.top && rectOffsetTop < firstRectDownOffsetTop) {
+          return container;
+        }
+      }
+
+      return firstRectDown;
+    }, {
+      id: DUMMY_ID,
+      rect: {
+        current: RECT_DOWN
+      }
+    });
+  } else {
+    // Down -- We need to find the first rectangle upwards
+    collidingContainer = droppableContainers.reduce((firstRectUp, container) => {
+      const rect = container.rect.current;
+
+      if (rect && firstRectUp.rect.current) {
+        const {
+          offsetTop: rectOffsetTop
+        } = rect;
+        const {
+          offsetTop: firstRectUpOffsetTop
+        } = firstRectUp.rect.current;
+
+        if (rectOffsetTop - threshold < collisionRect.top && rectOffsetTop > firstRectUpOffsetTop) {
+          return container;
+        }
+      }
+
+      return firstRectUp;
+    }, {
+      id: DUMMY_ID,
+      rect: {
+        current: RECT_UP
+      }
+    });
+  } // If we didn't find a match, return null
+
+
+  if (collidingContainer.id === DUMMY_ID) {
+    return null;
+  }
+
+  const collidingRect = collidingContainer.rect.current;
+  if (!collidingRect) return null; // Calculate the intersection interval
+
+  const [top, bottom] = [Math.max(collisionRect.top, collidingRect.offsetTop), Math.min(collisionRect.bottom, collidingRect.offsetTop + collidingRect.height)]; // Calculate the percentage of intersection
+
+  const intersectionPercentage = Math.abs(bottom - top) / collidingRect.height;
+
+  if (intersectionPercentage > insideThreshold && visibleItemsDictionary[collidingContainer.id].depth + 1 <= maxDragAndDropLevel && collidingContainer.id !== 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 collidingContainer.id;
+};
+
+export { customCollisionDetection };

package/esm/tree/getTreeKeyboardCoordinates.js

@@ -0,0 +1,131 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { KeyboardCode, closestCorners, getViewRect } from '@dnd-kit/core';
+import { DropIndicatorPosition } from './constants.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];
+[KeyboardCode.Up, KeyboardCode.Down];
+
+const getVerticalKeyboardCoordinates = _ref => {
+  var _droppableContainers$, _droppableContainers$2;
+
+  let {
+    items,
+    active,
+    over,
+    event,
+    currentCoordinates,
+    droppableContainers,
+    collisionRect,
+    dropIndicatorPosition,
+    maxDragAndDropLevel
+  } = _ref;
+  if (horizontal.includes(event.code)) return undefined;
+  const overRect = over.rect;
+  const layoutRects = []; // Get the reacheable rects depending on the arrow key pressed
+
+  droppableContainers.forEach(container => {
+    if (container !== null && container !== void 0 && container.disabled || !overRect) {
+      return;
+    }
+
+    const rect = container.rect.current;
+
+    if (rect && event.code === KeyboardCode.Down && collisionRect.top - 2 <= rect.offsetTop) {
+      layoutRects.push(container);
+    } else if (rect && event.code === KeyboardCode.Up && collisionRect.top >= rect.offsetTop) {
+      layoutRects.push(container);
+    }
+  });
+  const closestId = closestCorners({
+    collisionRect,
+    droppableContainers: layoutRects,
+    active
+  });
+  const closestItem = items.find(item => item.uid === closestId);
+  const closestElement = (_droppableContainers$ = droppableContainers.get(closestId)) === null || _droppableContainers$ === void 0 ? void 0 : (_droppableContainers$2 = _droppableContainers$.node) === null || _droppableContainers$2 === void 0 ? void 0 : _droppableContainers$2.current;
+  if (!closestId || !closestItem || !closestElement) return undefined;
+  const closestRect = getViewRect(closestElement);
+
+  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.id || closestItem.depth + 1 > maxDragAndDropLevel) {
+      return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
+        y: closestRect.top - collisionRect.height / 2
+      });
+    }
+
+    return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
+      y: closestRect.top + Math.abs(closestRect.height - collisionRect.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.id || closestItem.depth + 1 > maxDragAndDropLevel) {
+    return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
+      y: closestRect.top + collisionRect.height / 2
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, currentCoordinates), {}, {
+    y: closestRect.top + Math.abs(closestRect.height - collisionRect.height) / 2
+  });
+};
+
+const getTreeKeyboardCoordinates = (context, isHorizontalDnD, maxDragAndDropLevel) => (event, _ref2) => {
+  let {
+    currentCoordinates,
+    context: {
+      over,
+      translatedRect,
+      droppableContainers,
+      active,
+      collisionRect
+    }
+  } = _ref2;
+
+  if (directions.includes(event.code)) {
+    if (!translatedRect) {
+      return undefined;
+    }
+
+    const {
+      current: {
+        items,
+        dropIndicatorPosition
+      }
+    } = context;
+    if (!over || !active || !collisionRect) return undefined;
+    const args = {
+      items,
+      active,
+      over,
+      event,
+      currentCoordinates,
+      droppableContainers,
+      collisionRect,
+      dropIndicatorPosition,
+      maxDragAndDropLevel
+    };
+    if (isHorizontalDnD) return undefined;
+    return getVerticalKeyboardCoordinates(args);
+  }
+
+  return undefined;
+};
+
+export { getTreeKeyboardCoordinates };

package/esm/tree/index.js

@@ -0,0 +1 @@
+export { useTreeDndkitConfig } from './useTreeDndkitConfig.js';

package/esm/tree/types.js

@@ -0,0 +1 @@
+