@elliemae/ds-drag-and-drop 2.0.0-rc.10

package/esm/tree/useTreeActionHandlers.js

@@ -0,0 +1,71 @@
+import { arrayMove } from '@dnd-kit/sortable';
+import { cloneDeep } from 'lodash';
+import { useCallback } from 'react';
+import { DropIndicatorPosition } from './constants.js';
+
+const useTreeActionHandlers = _ref => {
+  let {
+    handlePreviewDragStart,
+    handlePreviewDragMove,
+    handlePreviewDragOver,
+    handlePreviewDragEnd,
+    handlePreviewDragCancel,
+    onReorder,
+    flattenedItems,
+    projected,
+    dropIndicatorPosition
+  } = _ref;
+  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 (projected && (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/tree/useTreeAnnouncements.js

@@ -0,0 +1,51 @@
+import { useCallback } from 'react';
+import { DropIndicatorPosition } from './constants.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/tree/useTreeDndkitConfig.js

@@ -0,0 +1,134 @@
+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 { 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 { DropIndicatorPosition } from './constants.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 = isHorizontalDnD => _ref => {
+  let {
+    transform
+  } = _ref;
+
+  const newTransform = _objectSpread({}, transform);
+
+  if (isHorizontalDnD) {
+    newTransform.x = transform.x + 25;
+  } else {
+    newTransform.x = transform.x + 15;
+  }
+
+  return newTransform;
+};
+
+const measuring = {
+  droppable: {
+    strategy: MeasuringStrategy.BeforeDragging
+  }
+};
+const useTreeDndkitConfig = _ref2 => {
+  var _visibleItemsDictiona, _visibleItemsDictiona2;
+
+  let {
+    flattenedItems,
+    visibleItems: preVisibleItems,
+    isHorizontalDnD = false,
+    isExpandable = false,
+    onReorder,
+    maxDragAndDropLevel
+  } = _ref2;
+  const [activeId, setActiveId] = useState('');
+  const [overId, setOverId] = useState('');
+  const [dropIndicatorPosition, setDropIndicatorPosition] = useState(DropIndicatorPosition.None);
+  const [lastPosition, setLastPosition] = useState(''); // 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(() => [adjustTranslate(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,
+    measuring,
+    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 };

package/esm/tree/useTreePreviewHandlers.js

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

package/esm/tree/utilities.js

@@ -0,0 +1,47 @@
+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 { DropIndicatorPosition } from './constants.js';
+
+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/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "@elliemae/ds-drag-and-drop",
+  "version": "2.0.0-rc.10",
+  "license": "MIT",
+  "description": "ICE MT - Dimsum - Drag And Drop",
+  "module": "./esm/index.js",
+  "main": "./cjs/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./tree/utilities": {
+      "import": "./esm/tree/utilities.js",
+      "require": "./cjs/tree/utilities.js"
+    },
+    "./tree/useTreePreviewHandlers": {
+      "import": "./esm/tree/useTreePreviewHandlers.js",
+      "require": "./cjs/tree/useTreePreviewHandlers.js"
+    },
+    "./tree/useTreeDndkitConfig": {
+      "import": "./esm/tree/useTreeDndkitConfig.js",
+      "require": "./cjs/tree/useTreeDndkitConfig.js"
+    },
+    "./tree/useTreeAnnouncements": {
+      "import": "./esm/tree/useTreeAnnouncements.js",
+      "require": "./cjs/tree/useTreeAnnouncements.js"
+    },
+    "./tree/useTreeActionHandlers": {
+      "import": "./esm/tree/useTreeActionHandlers.js",
+      "require": "./cjs/tree/useTreeActionHandlers.js"
+    },
+    "./tree/types": {
+      "import": "./esm/tree/types.js",
+      "require": "./cjs/tree/types.js"
+    },
+    "./tree": {
+      "import": "./esm/tree/index.js",
+      "require": "./cjs/tree/index.js"
+    },
+    "./tree/getTreeKeyboardCoordinates": {
+      "import": "./esm/tree/getTreeKeyboardCoordinates.js",
+      "require": "./cjs/tree/getTreeKeyboardCoordinates.js"
+    },
+    "./tree/customCollisionDetection": {
+      "import": "./esm/tree/customCollisionDetection.js",
+      "require": "./cjs/tree/customCollisionDetection.js"
+    },
+    "./tree/constants": {
+      "import": "./esm/tree/constants.js",
+      "require": "./cjs/tree/constants.js"
+    },
+    "./hierarchy/useHierarchyPreviewHandlers": {
+      "import": "./esm/hierarchy/useHierarchyPreviewHandlers.js",
+      "require": "./cjs/hierarchy/useHierarchyPreviewHandlers.js"
+    },
+    "./hierarchy/useHierarchyDndkitConfig": {
+      "import": "./esm/hierarchy/useHierarchyDndkitConfig.js",
+      "require": "./cjs/hierarchy/useHierarchyDndkitConfig.js"
+    },
+    "./hierarchy/useHierarchyAnnouncements": {
+      "import": "./esm/hierarchy/useHierarchyAnnouncements.js",
+      "require": "./cjs/hierarchy/useHierarchyAnnouncements.js"
+    },
+    "./hierarchy/useHierarchyActionHandlers": {
+      "import": "./esm/hierarchy/useHierarchyActionHandlers.js",
+      "require": "./cjs/hierarchy/useHierarchyActionHandlers.js"
+    },
+    "./hierarchy/types": {
+      "import": "./esm/hierarchy/types.js",
+      "require": "./cjs/hierarchy/types.js"
+    },
+    "./hierarchy": {
+      "import": "./esm/hierarchy/index.js",
+      "require": "./cjs/hierarchy/index.js"
+    },
+    "./hierarchy/getHierarchyKeyboardCoordinates": {
+      "import": "./esm/hierarchy/getHierarchyKeyboardCoordinates.js",
+      "require": "./cjs/hierarchy/getHierarchyKeyboardCoordinates.js"
+    },
+    "./hierarchy/customCollisionDetection": {
+      "import": "./esm/hierarchy/customCollisionDetection.js",
+      "require": "./cjs/hierarchy/customCollisionDetection.js"
+    }
+  },
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://git.elliemae.io/platform-ui/dimsum.git"
+  },
+  "engines": {
+    "npm": ">=7",
+    "node": ">=14"
+  },
+  "author": "ICE MT",
+  "scripts": {
+    "dev": "cross-env NODE_ENV=development && node ../../scripts/build/build.js -w",
+    "prebuild": "exit 0",
+    "predev": "exit 0",
+    "build": "node ../../scripts/build/build.js"
+  },
+  "dependencies": {
+    "@dnd-kit/core": "~4.0.1",
+    "@dnd-kit/sortable": "~5.0.0",
+    "react-desc": "~4.1.3"
+  },
+  "devDependencies": {
+    "styled-components": "~5.3.3"
+  },
+  "peerDependencies": {
+    "lodash": "^4.17.21",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "styled-components": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist",
+    "generateSubmodules": true
+  }
+}

package/types/hierarchy/customCollisionDetection.d.ts

@@ -0,0 +1,3 @@
+import { CollisionDetection } from '@dnd-kit/core';
+import { Item } from './types';
+export declare const customCollisionDetection: (activeId: string | null, activeParent: string | undefined, dndItems: Item[]) => CollisionDetection;

package/types/hierarchy/getHierarchyKeyboardCoordinates.d.ts

@@ -0,0 +1,3 @@
+import { KeyboardCoordinateGetter } from '@dnd-kit/core';
+import { SensorContext } from './types';
+export declare const getHierarchyKeyboardCoordinates: (context: SensorContext, dragOverlayDataTestid: string, isHorizontalDnD: boolean) => KeyboardCoordinateGetter;

package/types/hierarchy/index.d.ts

@@ -0,0 +1 @@
+export * from './useHierarchyDndkitConfig';

package/types/hierarchy/types.d.ts

@@ -0,0 +1,82 @@
+import type { Active, Announcements, CollisionDetection, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, MeasuringConfiguration, Modifier, Over, SensorDescriptor, SensorOptions } from '@dnd-kit/core';
+import { DroppableContainers } from '@dnd-kit/core/dist/store';
+import { Coordinates, DragCancelEvent, ViewRect } from '@dnd-kit/core/dist/types';
+import { MutableRefObject } from 'react';
+export declare type Item = {
+    id: string;
+    depth: number;
+    parentId: string;
+    index: number;
+};
+export declare type DndContextPropsType = {
+    announcements: Announcements;
+    modifiers: Modifier[];
+    sensors: SensorDescriptor<SensorOptions>[];
+    measuring: Partial<MeasuringConfiguration>;
+    collisionDetection: CollisionDetection;
+    onDragStart: (e: DragStartEvent) => void;
+    onDragMove: (e: DragMoveEvent) => void;
+    onDragOver: (e: DragOverEvent) => void;
+    onDragEnd: (e: DragEndEvent) => void;
+    onDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type useHierarchyPreviewHandlersReturn = {
+    handlePreviewDragStart: (e: DragStartEvent) => void;
+    handlePreviewDragMove: (e: DragMoveEvent) => void;
+    handlePreviewDragOver: (e: DragOverEvent) => void;
+    handlePreviewDragEnd: (e: DragEndEvent) => void;
+    handlePreviewDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type useHierarchyPreviewHandlersArgs = {
+    setOverId: React.Dispatch<React.SetStateAction<string>>;
+    setActiveId: React.Dispatch<React.SetStateAction<string>>;
+    onPreviewResetState: () => void;
+    onPreviewDragStart: () => void;
+};
+export declare type useHierarchyActionHandlersArgs = useHierarchyPreviewHandlersReturn & {
+    dndItems: Item[];
+    onReorder: (movedItem: Item, indexes: {
+        targetIndex: number;
+        fromIndex: number;
+    }) => void;
+};
+export declare type useHierarchyActionHandlersReturn = {
+    onDragStart: (e: DragStartEvent) => void;
+    onDragMove: (e: DragMoveEvent) => void;
+    onDragOver: (e: DragOverEvent) => void;
+    onDragEnd: (e: DragEndEvent) => void;
+    onDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type useHierarchyDndkitConfigArgs = {
+    indentationWidth?: number;
+    dragOverlayDataTestid: string;
+    flattenedItems: [Item, unknown][];
+    isHorizontalDnD?: boolean;
+    onReorder: (movedItem: Item, indexes: {
+        targetIndex: number;
+        fromIndex: number;
+    }) => void;
+    onPreviewResetState: () => void;
+    onPreviewDragStart: () => void;
+};
+export declare type useHierarchyDndkitConfigType = (args: useHierarchyDndkitConfigArgs) => useHierarchyDndkitConfigReturn;
+export declare type useHierarchyDndkitConfigReturn = {
+    dndContextProps: DndContextPropsType;
+    activeId: string | null;
+    overId: string | null;
+    activeIndex: number | undefined;
+};
+export declare type getKeyboardCoordinatesArgs = {
+    items: Item[];
+    active: Active | null;
+    over: Over | null;
+    event: KeyboardEvent;
+    currentCoordinates: Coordinates;
+    droppableContainers: DroppableContainers;
+    collisionRect: ViewRect;
+    dragOverlayDataTestid: string;
+};
+export declare type SensorContext = MutableRefObject<{
+    items: Item[];
+    offset?: number;
+}>;

package/types/hierarchy/useHierarchyActionHandlers.d.ts

@@ -0,0 +1,2 @@
+import { useHierarchyActionHandlersReturn, useHierarchyActionHandlersArgs } from './types';
+export declare const useHierarchyActionHandlers: ({ handlePreviewDragStart, handlePreviewDragMove, handlePreviewDragOver, handlePreviewDragEnd, handlePreviewDragCancel, onReorder, dndItems, }: useHierarchyActionHandlersArgs) => useHierarchyActionHandlersReturn;

package/types/hierarchy/useHierarchyAnnouncements.d.ts

@@ -0,0 +1,3 @@
+import { Announcements } from '@dnd-kit/core';
+import { Item } from './types';
+export declare const useHierarchyAnnouncements: (visibleItemsDictionary: Record<string, Item>) => Announcements;

package/types/hierarchy/useHierarchyDndkitConfig.d.ts

@@ -0,0 +1,2 @@
+import type { useHierarchyDndkitConfigType } from './types';
+export declare const useHierarchyDndkitConfig: useHierarchyDndkitConfigType;

package/types/hierarchy/useHierarchyPreviewHandlers.d.ts

@@ -0,0 +1,2 @@
+import type { useHierarchyPreviewHandlersReturn, useHierarchyPreviewHandlersArgs } from './types';
+export declare const useHierarchyPreviewHandlers: ({ setOverId, setActiveId, onPreviewResetState, onPreviewDragStart, }: useHierarchyPreviewHandlersArgs) => useHierarchyPreviewHandlersReturn;

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hierarchy';
+export * from './tree';

package/types/tree/constants.d.ts

@@ -0,0 +1,6 @@
+export declare enum DropIndicatorPosition {
+    None = 0,
+    Before = 1,
+    After = 2,
+    Inside = 3
+}

package/types/tree/customCollisionDetection.d.ts

@@ -0,0 +1,4 @@
+import { CollisionDetection } from '@dnd-kit/core';
+import { DropIndicatorPosition } from './constants';
+import { Item } from './types';
+export declare const customCollisionDetection: (activeId: string, visibleItemsDictionary: Record<string, Item>, setDropIndicatorPosition: React.Dispatch<React.SetStateAction<DropIndicatorPosition>>, maxDragAndDropLevel: number, lastPosition: string, setLastPosition: React.Dispatch<React.SetStateAction<string>>) => CollisionDetection;

package/types/tree/getTreeKeyboardCoordinates.d.ts

@@ -0,0 +1,3 @@
+import { KeyboardCoordinateGetter } from '@dnd-kit/core';
+import type { SensorContext } from './types';
+export declare const getTreeKeyboardCoordinates: (context: SensorContext, isHorizontalDnD: boolean, maxDragAndDropLevel: number) => KeyboardCoordinateGetter;

package/types/tree/index.d.ts

@@ -0,0 +1 @@
+export * from './useTreeDndkitConfig';