@elliemae/ds-drag-and-drop 2.2.0-alpha.3 → 2.2.0-next.2

package/esm/tree/useTreeDndkitConfig.js

@@ -1,57 +1,90 @@
-import * as React from "react";
-import { useState, useEffect, useMemo, useRef } from "react";
-import {
-  useSensor,
-  useSensors,
-  KeyboardSensor,
-  PointerSensor,
-  MeasuringStrategy
-} from "@dnd-kit/core";
-import { horizontalListSortingStrategy, verticalListSortingStrategy } from "@dnd-kit/sortable";
-import { useTreePreviewHandlers } from "./useTreePreviewHandlers";
-import { getTreeKeyboardCoordinates } from "./getTreeKeyboardCoordinates";
-import { getProjection, removeChildrenOf } from "./utilities";
-import { useTreeActionHandlers } from "./useTreeActionHandlers";
-import { DropIndicatorPosition } from "./constants";
-import { customCollisionDetection } from "./customCollisionDetection";
-import { useTreeAnnouncements } from "./useTreeAnnouncements";
-const adjustTranslate = (isHorizontalDnD) => ({ transform }) => {
-  const newTransform = {
-    ...transform
+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 { 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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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 => {
+  const func = _ref => {
+    let {
+      transform
+    } = _ref;
+
+    const newTransform = _objectSpread({}, transform);
+
+    if (isHorizontalDnD) {
+      newTransform.x = transform.x + 25;
+    } else {
+      newTransform.x = transform.x + 15;
+    }
+
+    return newTransform;
   };
-  if (isHorizontalDnD) {
-    newTransform.x = transform.x + 25;
-  } else {
-    newTransform.x = transform.x + 15;
-  }
-  return newTransform;
+
+  return func;
 };
+
 const measuring = {
   droppable: {
-    strategy: MeasuringStrategy.BeforeDragging
+    strategy: MeasuringStrategy.Always
   }
 };
-const useTreeDndkitConfig = ({
-  flattenedItems,
-  visibleItems: preVisibleItems,
-  isHorizontalDnD = false,
-  isExpandable = false,
-  onReorder,
-  maxDragAndDropLevel
-}) => {
-  const [activeId, setActiveId] = useState("");
-  const [overId, setOverId] = useState("");
+const useTreeDndkitConfig = _ref2 => {
+  var _visibleItemsDictiona, _visibleItemsDictiona2;
+
+  let {
+    flattenedItems,
+    visibleItems: preVisibleItems,
+    isHorizontalDnD = false,
+    isExpandable = false,
+    onReorder,
+    getIsDropValid = () => true,
+    maxDragAndDropLevel
+  } = _ref2;
+  const [activeId, setActiveId] = useState('');
+  const [overId, setOverId] = useState('');
   const [dropIndicatorPosition, setDropIndicatorPosition] = useState(DropIndicatorPosition.None);
-  const [lastPosition, setLastPosition] = useState("");
-  const visibleItems = useMemo(() => removeChildrenOf(preVisibleItems, activeId), [preVisibleItems, activeId]);
-  const sortedIds = useMemo(() => visibleItems.map((item) => item.uid), [visibleItems]);
+  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) => {
+    visibleItems.forEach(item => {
       dictionary[item.uid] = item;
     });
     return dictionary;
   }, [visibleItems]);
+  const isDropValid = useMemo(() => {
+    if (!activeId || !overId) return true;
+    return getIsDropValid(visibleItemsDictionary[activeId], visibleItemsDictionary[overId], ['none', 'before', 'after', 'inside'][dropIndicatorPosition]);
+  }, [getIsDropValid, visibleItemsDictionary, activeId, overId, dropIndicatorPosition]);
   const modifiers = useMemo(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);
   const sensorContext = useRef({
     items: visibleItems,
@@ -68,56 +101,44 @@ const useTreeDndkitConfig = ({
   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({
-    ...dragPreviewHandlers,
+  const dragActionHandlers = useTreeActionHandlers(_objectSpread(_objectSpread({}, dragPreviewHandlers), {}, {
     onReorder,
     projected,
     flattenedItems,
-    dropIndicatorPosition
-  });
+    dropIndicatorPosition,
+    isDropValid
+  }));
   const announcements = useTreeAnnouncements(visibleItemsDictionary, dropIndicatorPosition);
-  const dndContextProps = useMemo(() => ({
+  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
-  ]);
+    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]);
+    strategy: () => null
+  }), [sortedIds]);
   return {
     dndContextProps,
     sortableContextProps,
+    isDropValid,
     activeId,
-    activeIndex: visibleItemsDictionary[activeId]?.realIndex ?? -1,
+    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
-};
-//# sourceMappingURL=useTreeDndkitConfig.js.map
+
+export { useTreeDndkitConfig };

package/esm/tree/useTreePreviewHandlers.js

@@ -1,25 +1,36 @@
-import * as React from "react";
-import { useCallback } from "react";
-import { DropIndicatorPosition } from "./constants";
-const useTreePreviewHandlers = ({
-  setOverId,
-  setActiveId,
-  setDropIndicatorPosition
-}) => {
+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('');
+    document.body.style.setProperty('cursor', '');
   }, [setOverId, setActiveId]);
-  const handlePreviewDragStart = useCallback(({ active: { id } }) => {
+  const handlePreviewDragStart = useCallback(_ref2 => {
+    let {
+      active: {
+        id
+      }
+    } = _ref2;
     setActiveId(id);
     setOverId(id);
     setDropIndicatorPosition(DropIndicatorPosition.Inside);
-    document.body.style.setProperty("cursor", "grabbing");
+    document.body.style.setProperty('cursor', 'grabbing');
   }, [setActiveId, setDropIndicatorPosition, setOverId]);
   const handlePreviewDragMove = useCallback(() => null, []);
-  const handlePreviewDragOver = useCallback(({ over }) => {
-    setOverId(over?.id ?? "");
+  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();
@@ -35,7 +46,5 @@ const useTreePreviewHandlers = ({
     handlePreviewDragCancel
   };
 };
-export {
-  useTreePreviewHandlers
-};
-//# sourceMappingURL=useTreePreviewHandlers.js.map
+
+export { useTreePreviewHandlers };

package/esm/tree/utilities.js

@@ -1,37 +1,47 @@
-import * as React from "react";
-import { DropIndicatorPosition } from "./constants";
-const getMinDepth = (item) => {
-  if (item)
-    return item.depth;
+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(previousItem),
+      parentId: previousItem.parentId
+    };
   }
-  return { depth: getMinDepth(nextItem), parentId: nextItem?.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) => {
+  return items.filter(item => {
     if (item.parentId !== null && excludeParentIds.includes(item.parentId)) {
       excludeParentIds.push(item.uid);
       return false;
     }
+
     return true;
   });
 };
-export {
-  getProjection,
-  removeChildrenOf
-};
-//# sourceMappingURL=utilities.js.map
+
+export { getProjection, removeChildrenOf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-drag-and-drop",
-  "version": "2.2.0-alpha.3",
+  "version": "2.2.0-next.2",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Drag And Drop",
   "module": "./esm/index.js",

package/types/hierarchy/types.d.ts

@@ -64,7 +64,7 @@ export declare type useHierarchyDndkitConfigReturn = {
     overId: string | null;
     activeIndex: number | undefined;
 };
-export declare type getKeyboardCoordinatesArgs = {
+export declare type GetKeyboardCoordinatesArgs = {
     items: Item[];
     active: Active | null;
     over: Over | null;

package/types/tree/types.d.ts

@@ -4,12 +4,13 @@ import type { SortingStrategy } from '@dnd-kit/sortable';
 import { Coordinates } from '@dnd-kit/core/dist/types';
 import React, { MutableRefObject } from 'react';
 import { DropIndicatorPosition } from './constants';
-export declare type Item = {
+export declare type Item<T = unknown> = {
     uid: string;
     depth: number;
-    parentId: string;
+    parentId: string | null;
     realIndex: number;
-    original: Record<string, Record<string, any>>;
+    childrenCount: number;
+    original: T;
 };
 export declare type DndContextPropsType = {
     announcements: Announcements;
@@ -27,49 +28,51 @@ export declare type SortableContextPropsType = {
     items: string[];
     strategy: SortingStrategy;
 };
-export declare type useTreePreviewHandlersReturn = {
+export declare type UseTreePreviewHandlersReturn = {
     handlePreviewDragStart: (e: DragStartEvent) => void;
     handlePreviewDragMove: (e: DragMoveEvent) => void;
     handlePreviewDragOver: (e: DragOverEvent) => void;
     handlePreviewDragEnd: (e: DragEndEvent) => void;
     handlePreviewDragCancel: (e: DragCancelEvent) => void;
 };
-export declare type useTreePreviewHandlersArgs = {
+export declare type UseTreePreviewHandlersArgs = {
     setOverId: React.Dispatch<React.SetStateAction<string>>;
     setActiveId: React.Dispatch<React.SetStateAction<string>>;
     setDropIndicatorPosition: React.Dispatch<React.SetStateAction<DropIndicatorPosition>>;
 };
-export declare type useTreeActionHandlersArgs = useTreePreviewHandlersReturn & {
+export declare type UseTreeActionHandlersArgs<T = unknown> = UseTreePreviewHandlersReturn & {
     dropIndicatorPosition: DropIndicatorPosition;
     flattenedItems: Item[];
     projected: {
         depth: number;
         parentId: string;
     } | null;
-    onReorder: (newData: Item[], indexes: {
+    onReorder: <S = T>(newData: Item<S>[], indexes: {
         targetIndex: number;
         fromIndex: number;
     }, considerExpanding: string) => void;
+    isDropValid: boolean;
 };
-export declare type useTreeActionHandlersReturn = {
+export declare type UseTreeActionHandlersReturn = {
     onDragStart: (e: DragStartEvent) => void;
     onDragMove: (e: DragMoveEvent) => void;
     onDragOver: (e: DragOverEvent) => void;
     onDragEnd: (e: DragEndEvent) => void;
     onDragCancel: (e: DragCancelEvent) => void;
 };
-export declare type useTreeDndkitConfigArgs = {
+export declare type UseTreeDndkitConfigArgs<T> = {
     flattenedItems: Item[];
     visibleItems: Item[];
     isHorizontalDnD?: boolean;
     isExpandable: boolean;
-    onReorder: (newData: Item[], indexes: {
+    onReorder: <S = T>(newData: Item<S>[], indexes: {
         targetIndex: number;
         fromIndex: number;
     }, considerExpanding: string) => void;
+    getIsDropValid: <S = T>(active: Item<S>, over: Item<S>, dropIndicatorPosition: 'none' | 'before' | 'after' | 'inside') => boolean;
     maxDragAndDropLevel: number;
 };
-export declare type useTreeDndkitConfigReturn = {
+export declare type UseTreeDndkitConfigReturn = {
     dndContextProps: DndContextPropsType;
     sortableContextProps: SortableContextPropsType;
     activeId: string;
@@ -77,10 +80,11 @@ export declare type useTreeDndkitConfigReturn = {
     overId: string;
     depth: number;
     dropIndicatorPosition: DropIndicatorPosition;
+    isDropValid: boolean;
     visibleItems: Item[];
 };
-export declare type useTreeDndkitConfigType = (args: useTreeDndkitConfigArgs) => useTreeDndkitConfigReturn;
-export declare type getKeyboardCoordinatesArgs = {
+export declare type UseTreeDndkitConfigType = <T = unknown>(args: UseTreeDndkitConfigArgs<T>) => UseTreeDndkitConfigReturn;
+export declare type GetKeyboardCoordinatesArgs = {
     items: Item[];
     active: Active;
     over: Over;

package/types/tree/useTreeActionHandlers.d.ts

@@ -1,2 +1,2 @@
-import type { useTreeActionHandlersReturn, useTreeActionHandlersArgs } from './types';
-export declare const useTreeActionHandlers: ({ handlePreviewDragStart, handlePreviewDragMove, handlePreviewDragOver, handlePreviewDragEnd, handlePreviewDragCancel, onReorder, flattenedItems, projected, dropIndicatorPosition, }: useTreeActionHandlersArgs) => useTreeActionHandlersReturn;
+import type { UseTreeActionHandlersReturn, UseTreeActionHandlersArgs } from './types';
+export declare const useTreeActionHandlers: ({ handlePreviewDragStart, handlePreviewDragMove, handlePreviewDragOver, handlePreviewDragEnd, handlePreviewDragCancel, onReorder, flattenedItems, projected, dropIndicatorPosition, isDropValid, }: UseTreeActionHandlersArgs) => UseTreeActionHandlersReturn;

package/types/tree/useTreeDndkitConfig.d.ts

@@ -1,2 +1,2 @@
-import type { useTreeDndkitConfigType } from './types';
-export declare const useTreeDndkitConfig: useTreeDndkitConfigType;
+import type { UseTreeDndkitConfigType } from './types';
+export declare const useTreeDndkitConfig: UseTreeDndkitConfigType;

package/types/tree/useTreePreviewHandlers.d.ts

@@ -1,2 +1,2 @@
-import type { useTreePreviewHandlersReturn, useTreePreviewHandlersArgs } from './types';
-export declare const useTreePreviewHandlers: ({ setOverId, setActiveId, setDropIndicatorPosition, }: useTreePreviewHandlersArgs) => useTreePreviewHandlersReturn;
+import type { UseTreePreviewHandlersReturn, UseTreePreviewHandlersArgs } from './types';
+export declare const useTreePreviewHandlers: ({ setOverId, setActiveId, setDropIndicatorPosition, }: UseTreePreviewHandlersArgs) => UseTreePreviewHandlersReturn;

package/cjs/hierarchy/customCollisionDetection.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/customCollisionDetection.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { CollisionDetection, DroppableContainer } from '@dnd-kit/core';\nimport { Item } from './types';\n\nexport const customCollisionDetection =\n  (activeId: string | null, activeParent: string | undefined, dndItems: Item[]): CollisionDetection =>\n  ({ droppableContainers, collisionRect }) => {\n    const entriesWithSameParent = droppableContainers.filter(\n      ({ id }) => dndItems.find((item) => item.id === id)?.parentId === activeParent,\n    );\n\n    const originalContainer = entriesWithSameParent.find(({ id }) => id === activeId);\n    const originalRect = originalContainer?.rect?.current;\n\n    if (!originalRect) return null;\n\n    if (\n      originalRect.offsetLeft <= collisionRect.offsetLeft &&\n      collisionRect.offsetLeft <= originalRect.offsetLeft + originalRect.width\n    ) {\n      return originalContainer.id;\n    }\n\n    const isLeft = collisionRect.offsetLeft <= originalRect.offsetLeft + collisionRect.width / 2 + 5;\n\n    let match: DroppableContainer | null = null;\n    // If going to the left, search the closest offset left\n    // Otherwise, get the closest offset right\n    const collisionPoint = collisionRect.offsetLeft + collisionRect.width / 2;\n    entriesWithSameParent.forEach((entry) => {\n      const {\n        rect: { current: rect },\n      } = entry;\n\n      if (rect !== null) {\n        const offsetRight = rect.offsetLeft + rect.width;\n\n        if (!match) {\n          match = entry;\n        } else if (\n          match &&\n          match.rect.current &&\n          isLeft &&\n          Math.abs(collisionPoint - rect.offsetLeft) <= Math.abs(collisionPoint - match.rect.current.offsetLeft)\n        ) {\n          match = entry;\n        } else if (\n          match &&\n          match.rect.current &&\n          !isLeft &&\n          Math.abs(collisionPoint - offsetRight) <=\n            Math.abs(collisionPoint - match.rect.current.offsetLeft - match.rect.current.width)\n        ) {\n          match = entry;\n        }\n      }\n    });\n    // Typescript believes match is always null for some reason\n    const matchCastedForSomeReason = match as DroppableContainer | null;\n    return matchCastedForSomeReason === null ? null : matchCastedForSomeReason.id;\n  };\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADGhB,MAAM,2BACX,CAAC,UAAyB,cAAkC,aAC5D,CAAC,EAAE,qBAAqB,oBAAoB;AAC1C,QAAM,wBAAwB,oBAAoB,OAChD,CAAC,EAAE,SAAS,SAAS,KAAK,CAAC,SAAS,KAAK,OAAO,KAAK,aAAa;AAGpE,QAAM,oBAAoB,sBAAsB,KAAK,CAAC,EAAE,SAAS,OAAO;AACxE,QAAM,eAAe,mBAAmB,MAAM;AAE9C,MAAI,CAAC;AAAc,WAAO;AAE1B,MACE,aAAa,cAAc,cAAc,cACzC,cAAc,cAAc,aAAa,aAAa,aAAa,OACnE;AACA,WAAO,kBAAkB;AAAA;AAG3B,QAAM,SAAS,cAAc,cAAc,aAAa,aAAa,cAAc,QAAQ,IAAI;AAE/F,MAAI,QAAmC;AAGvC,QAAM,iBAAiB,cAAc,aAAa,cAAc,QAAQ;AACxE,wBAAsB,QAAQ,CAAC,UAAU;AACvC,UAAM;AAAA,MACJ,MAAM,EAAE,SAAS;AAAA,QACf;AAEJ,QAAI,SAAS,MAAM;AACjB,YAAM,cAAc,KAAK,aAAa,KAAK;AAE3C,UAAI,CAAC,OAAO;AACV,gBAAQ;AAAA,iBAER,SACA,MAAM,KAAK,WACX,UACA,KAAK,IAAI,iBAAiB,KAAK,eAAe,KAAK,IAAI,iBAAiB,MAAM,KAAK,QAAQ,aAC3F;AACA,gBAAQ;AAAA,iBAER,SACA,MAAM,KAAK,WACX,CAAC,UACD,KAAK,IAAI,iBAAiB,gBACxB,KAAK,IAAI,iBAAiB,MAAM,KAAK,QAAQ,aAAa,MAAM,KAAK,QAAQ,QAC/E;AACA,gBAAQ;AAAA;AAAA;AAAA;AAKd,QAAM,2BAA2B;AACjC,SAAO,6BAA6B,OAAO,OAAO,yBAAyB;AAAA;",
-  "names": []
-}

package/cjs/hierarchy/getHierarchyKeyboardCoordinates.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/getHierarchyKeyboardCoordinates.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { closestCorners, getViewRect, KeyboardCode, KeyboardCoordinateGetter, DroppableContainer } from '@dnd-kit/core';\nimport { Coordinates } from '@dnd-kit/core/dist/types';\n\nimport { GetKeyboardCoordinatesArgs, SensorContext } from './types';\n\nconst directions: string[] = [KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left];\n\nconst vertical: string[] = [KeyboardCode.Up, KeyboardCode.Down];\n\nconst getHorizontalKeyboardCoordinates = ({\n  items,\n  active,\n  over,\n  event,\n  currentCoordinates,\n  droppableContainers,\n  collisionRect,\n}: GetKeyboardCoordinatesArgs): Coordinates | undefined => {\n  if (vertical.includes(event.code) || !active || !over) return undefined;\n\n  const activeItem = items.find((item) => item.id === active.id);\n\n  const overRect = over.rect;\n\n  const layoutRects: DroppableContainer[] = [];\n\n  // Get the reacheable rects depending on the arrow key pressed\n  droppableContainers.forEach((container) => {\n    if (container?.disabled || !overRect) {\n      return;\n    }\n    const node = container?.node.current;\n    if (!node) {\n      return;\n    }\n    const itemParent = items.find((item) => item.id === container.id)?.parentId;\n    if (itemParent !== activeItem?.parentId) return;\n    const rect = getViewRect(node);\n    if (event.code === KeyboardCode.Left && collisionRect.left > rect.right - 10) {\n      layoutRects.push(container);\n    } else if (event.code === KeyboardCode.Right && collisionRect.left < rect.left) {\n      layoutRects.push(container);\n    }\n  });\n\n  const closestId = closestCorners({ droppableContainers: layoutRects, collisionRect, active });\n\n  if (!closestId) return undefined;\n\n  const closestDroppableContainer = droppableContainers.get(closestId)?.node?.current;\n  const activeDroppableContainer = droppableContainers.get(active?.id)?.node?.current;\n\n  if (!closestDroppableContainer || !activeDroppableContainer) return undefined;\n\n  const closestRect = getViewRect(closestDroppableContainer);\n  const activeRect = getViewRect(activeDroppableContainer);\n  return {\n    ...currentCoordinates,\n    x:\n      closestRect.left +\n      (closestRect.width - collisionRect.width) / 2 +\n      (closestRect.offsetLeft < activeRect.left ? -1 : 1),\n  };\n};\n\nexport const getHierarchyKeyboardCoordinates: (\n  context: SensorContext,\n  dragOverlayDataTestid: string,\n  isHorizontalDnD: boolean,\n) => KeyboardCoordinateGetter =\n  (context, dragOverlayDataTestid, isHorizontalDnD) =>\n  (event, { currentCoordinates, context: { active, over, collisionRect, droppableContainers } }) => {\n    if (directions.includes(event.code)) {\n      event.preventDefault();\n      if (!collisionRect) {\n        return undefined;\n      }\n\n      const {\n        current: { items },\n      } = context;\n\n      const args = {\n        dragOverlayDataTestid,\n        items,\n        active,\n        over,\n        event,\n        currentCoordinates,\n        droppableContainers,\n        collisionRect,\n      };\n\n      if (isHorizontalDnD) return getHorizontalKeyboardCoordinates(args);\n      return undefined;\n    }\n    return undefined;\n  };\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,kBAAwG;AAKxG,MAAM,aAAuB,CAAC,yBAAa,MAAM,yBAAa,OAAO,yBAAa,IAAI,yBAAa;AAEnG,MAAM,WAAqB,CAAC,yBAAa,IAAI,yBAAa;AAE1D,MAAM,mCAAmC,CAAC;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,MACyD;AACzD,MAAI,SAAS,SAAS,MAAM,SAAS,CAAC,UAAU,CAAC;AAAM,WAAO;AAE9D,QAAM,aAAa,MAAM,KAAK,CAAC,SAAS,KAAK,OAAO,OAAO;AAE3D,QAAM,WAAW,KAAK;AAEtB,QAAM,cAAoC;AAG1C,sBAAoB,QAAQ,CAAC,cAAc;AACzC,QAAI,WAAW,YAAY,CAAC,UAAU;AACpC;AAAA;AAEF,UAAM,OAAO,WAAW,KAAK;AAC7B,QAAI,CAAC,MAAM;AACT;AAAA;AAEF,UAAM,aAAa,MAAM,KAAK,CAAC,SAAS,KAAK,OAAO,UAAU,KAAK;AACnE,QAAI,eAAe,YAAY;AAAU;AACzC,UAAM,OAAO,6BAAY;AACzB,QAAI,MAAM,SAAS,yBAAa,QAAQ,cAAc,OAAO,KAAK,QAAQ,IAAI;AAC5E,kBAAY,KAAK;AAAA,eACR,MAAM,SAAS,yBAAa,SAAS,cAAc,OAAO,KAAK,MAAM;AAC9E,kBAAY,KAAK;AAAA;AAAA;AAIrB,QAAM,YAAY,gCAAe,EAAE,qBAAqB,aAAa,eAAe;AAEpF,MAAI,CAAC;AAAW,WAAO;AAEvB,QAAM,4BAA4B,oBAAoB,IAAI,YAAY,MAAM;AAC5E,QAAM,2BAA2B,oBAAoB,IAAI,QAAQ,KAAK,MAAM;AAE5E,MAAI,CAAC,6BAA6B,CAAC;AAA0B,WAAO;AAEpE,QAAM,cAAc,6BAAY;AAChC,QAAM,aAAa,6BAAY;AAC/B,SAAO;AAAA,OACF;AAAA,IACH,GACE,YAAY,OACX,aAAY,QAAQ,cAAc,SAAS,IAC3C,aAAY,aAAa,WAAW,OAAO,KAAK;AAAA;AAAA;AAIhD,MAAM,kCAKX,CAAC,SAAS,uBAAuB,oBACjC,CAAC,OAAO,EAAE,oBAAoB,SAAS,EAAE,QAAQ,MAAM,eAAe,4BAA4B;AAChG,MAAI,WAAW,SAAS,MAAM,OAAO;AACnC,UAAM;AACN,QAAI,CAAC,eAAe;AAClB,aAAO;AAAA;AAGT,UAAM;AAAA,MACJ,SAAS,EAAE;AAAA,QACT;AAEJ,UAAM,OAAO;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAGF,QAAI;AAAiB,aAAO,iCAAiC;AAC7D,WAAO;AAAA;AAET,SAAO;AAAA;",
-  "names": []
-}

package/cjs/hierarchy/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/index.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["export * from './useHierarchyDndkitConfig';\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;ACAA,YAAuB;ADAvB,8BAAc;",
-  "names": []
-}

package/cjs/hierarchy/types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/types.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import type {\n  Active,\n  Announcements,\n  CollisionDetection,\n  DragEndEvent,\n  DragMoveEvent,\n  DragOverEvent,\n  DragStartEvent,\n  MeasuringConfiguration,\n  Modifier,\n  Over,\n  SensorDescriptor,\n  SensorOptions,\n} from '@dnd-kit/core';\nimport { DroppableContainers } from '@dnd-kit/core/dist/store';\nimport { Coordinates, DragCancelEvent, ViewRect } from '@dnd-kit/core/dist/types';\nimport { MutableRefObject } from 'react';\n\nexport type Item = {\n  id: string;\n  depth: number;\n  parentId: string;\n  index: number;\n};\n\nexport type DndContextPropsType = {\n  announcements: Announcements;\n  modifiers: Modifier[];\n  sensors: SensorDescriptor<SensorOptions>[];\n  measuring: Partial<MeasuringConfiguration>;\n  collisionDetection: CollisionDetection;\n  onDragStart: (e: DragStartEvent) => void;\n  onDragMove: (e: DragMoveEvent) => void;\n  onDragOver: (e: DragOverEvent) => void;\n  onDragEnd: (e: DragEndEvent) => void;\n  onDragCancel: (e: DragCancelEvent) => void;\n};\n\nexport type useHierarchyPreviewHandlersReturn = {\n  handlePreviewDragStart: (e: DragStartEvent) => void;\n  handlePreviewDragMove: (e: DragMoveEvent) => void;\n  handlePreviewDragEnd: (e: DragEndEvent) => void;\n  handlePreviewDragCancel: (e: DragCancelEvent) => void;\n};\n\nexport type useHierarchyPreviewHandlersArgs = {\n  setActiveId: React.Dispatch<React.SetStateAction<string>>;\n  onPreviewResetState: () => void;\n  onPreviewDragStart: () => void;\n};\n\nexport type useHierarchyActionHandlersArgs = useHierarchyPreviewHandlersReturn & {\n  dndItems: Item[];\n  onReorder: (movedItem: Item, indexes: { targetIndex: number; fromIndex: number }) => void;\n};\n\nexport type useHierarchyActionHandlersReturn = {\n  onDragStart: (e: DragStartEvent) => void;\n  onDragMove: (e: DragMoveEvent) => void;\n  onDragOver: (e: DragOverEvent) => void;\n  onDragEnd: (e: DragEndEvent) => void;\n  onDragCancel: (e: DragCancelEvent) => void;\n};\n\nexport type useHierarchyDndkitConfigArgs = {\n  indentationWidth?: number;\n  dragOverlayDataTestid: string;\n  flattenedItems: [Item, unknown][];\n  isHorizontalDnD?: boolean;\n  onReorder: (movedItem: Item, indexes: { targetIndex: number; fromIndex: number }) => void;\n  onPreviewResetState: () => void;\n  onPreviewDragStart: () => void;\n};\n\nexport type useHierarchyDndkitConfigType = (args: useHierarchyDndkitConfigArgs) => useHierarchyDndkitConfigReturn;\n\nexport type useHierarchyDndkitConfigReturn = {\n  dndContextProps: DndContextPropsType;\n  activeId: string | null;\n  overId: string | null;\n  activeIndex: number | undefined;\n};\n\nexport type getKeyboardCoordinatesArgs = {\n  items: Item[];\n  active: Active | null;\n  over: Over | null;\n  event: KeyboardEvent;\n  currentCoordinates: Coordinates;\n  droppableContainers: DroppableContainers;\n  collisionRect: ViewRect;\n  dragOverlayDataTestid: string;\n};\n\nexport type SensorContext = MutableRefObject<{\n  items: Item[];\n  offset?: number;\n}>;\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;ACAA,YAAuB;",
-  "names": []
-}

package/cjs/hierarchy/useHierarchyActionHandlers.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/useHierarchyActionHandlers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { useCallback } from 'react';\nimport { DragStartEvent, DragMoveEvent, DragEndEvent, DragCancelEvent } from '@dnd-kit/core';\nimport { UseHierarchyActionHandlersReturn, UseHierarchyActionHandlersArgs } from './types';\n\nexport const useHierarchyActionHandlers = ({\n  handlePreviewDragStart,\n  handlePreviewDragMove,\n  handlePreviewDragEnd,\n  handlePreviewDragCancel,\n  onReorder,\n  dndItems,\n}: UseHierarchyActionHandlersArgs): UseHierarchyActionHandlersReturn => {\n  const onDragStart = useCallback(\n    (e: DragStartEvent) => {\n      handlePreviewDragStart(e);\n    },\n    [handlePreviewDragStart],\n  );\n\n  const onDragMove = useCallback(\n    (e: DragMoveEvent) => {\n      handlePreviewDragMove(e);\n    },\n    [handlePreviewDragMove],\n  );\n\n  const onDragEnd = useCallback(\n    (e: DragEndEvent) => {\n      handlePreviewDragEnd(e);\n      const { active, over } = e;\n\n      if (!over) return;\n\n      if (active.id !== over.id) {\n        const activeIndex = dndItems.findIndex((item) => item.id === active.id);\n        const overIndex = dndItems.findIndex((item) => item.id === over.id);\n\n        onReorder(dndItems[activeIndex], {\n          targetIndex: overIndex,\n          fromIndex: activeIndex,\n        });\n      }\n    },\n    [handlePreviewDragEnd, dndItems, onReorder],\n  );\n\n  const onDragCancel = useCallback(\n    (e: DragCancelEvent) => {\n      handlePreviewDragCancel(e);\n    },\n    [handlePreviewDragCancel],\n  );\n\n  return { onDragStart, onDragMove, onDragEnd, onDragCancel };\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA4B;AAIrB,MAAM,6BAA6B,CAAC;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,MACsE;AACtE,QAAM,cAAc,8BAClB,CAAC,MAAsB;AACrB,2BAAuB;AAAA,KAEzB,CAAC;AAGH,QAAM,aAAa,8BACjB,CAAC,MAAqB;AACpB,0BAAsB;AAAA,KAExB,CAAC;AAGH,QAAM,YAAY,8BAChB,CAAC,MAAoB;AACnB,yBAAqB;AACrB,UAAM,EAAE,QAAQ,SAAS;AAEzB,QAAI,CAAC;AAAM;AAEX,QAAI,OAAO,OAAO,KAAK,IAAI;AACzB,YAAM,cAAc,SAAS,UAAU,CAAC,SAAS,KAAK,OAAO,OAAO;AACpE,YAAM,YAAY,SAAS,UAAU,CAAC,SAAS,KAAK,OAAO,KAAK;AAEhE,gBAAU,SAAS,cAAc;AAAA,QAC/B,aAAa;AAAA,QACb,WAAW;AAAA;AAAA;AAAA,KAIjB,CAAC,sBAAsB,UAAU;AAGnC,QAAM,eAAe,8BACnB,CAAC,MAAuB;AACtB,4BAAwB;AAAA,KAE1B,CAAC;AAGH,SAAO,EAAE,aAAa,YAAY,WAAW;AAAA;",
-  "names": []
-}

package/cjs/hierarchy/useHierarchyAnnouncements.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/useHierarchyAnnouncements.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { Announcements } from '@dnd-kit/core';\nimport { useCallback } from 'react';\nimport { Item } from './types';\n\nexport const useHierarchyAnnouncements = (visibleItemsDictionary: Record<string, Item>): Announcements => {\n  const onDragStart = useCallback(\n    (id: string) => `Picked up draggable item from position ${visibleItemsDictionary[id].index + 1}.`,\n    [visibleItemsDictionary],\n  );\n\n  const onDragMove = useCallback(\n    (id: string, overId: string) => {\n      if (overId) {\n        const overIndex = visibleItemsDictionary[overId].index + 1;\n        return `Draggable item was moved to position ${overIndex}.`;\n      }\n\n      return `Draggable item is no longer over a droppable area.`;\n    },\n    [visibleItemsDictionary],\n  );\n\n  const onDragOver = onDragMove;\n\n  const onDragEnd = useCallback(\n    (id: string, overId: string) => {\n      if (overId) {\n        const overIndex = visibleItemsDictionary[overId].index + 1;\n        return `Draggable item was dropped over position ${overIndex}.`;\n      }\n\n      return `Draggable item was dropped at it's original position.`;\n    },\n    [visibleItemsDictionary],\n  );\n\n  const onDragCancel = useCallback(\n    (id: string) =>\n      `Dragging was cancelled. Draggable item from position ${\n        visibleItemsDictionary[id].index + 1\n      } was dropped at it's initial position.`,\n    [visibleItemsDictionary],\n  );\n\n  return { onDragStart, onDragOver, onDragMove, onDragEnd, onDragCancel };\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAA4B;AAGrB,MAAM,4BAA4B,CAAC,2BAAgE;AACxG,QAAM,cAAc,8BAClB,CAAC,OAAe,0CAA0C,uBAAuB,IAAI,QAAQ,MAC7F,CAAC;AAGH,QAAM,aAAa,8BACjB,CAAC,IAAY,WAAmB;AAC9B,QAAI,QAAQ;AACV,YAAM,YAAY,uBAAuB,QAAQ,QAAQ;AACzD,aAAO,wCAAwC;AAAA;AAGjD,WAAO;AAAA,KAET,CAAC;AAGH,QAAM,aAAa;AAEnB,QAAM,YAAY,8BAChB,CAAC,IAAY,WAAmB;AAC9B,QAAI,QAAQ;AACV,YAAM,YAAY,uBAAuB,QAAQ,QAAQ;AACzD,aAAO,4CAA4C;AAAA;AAGrD,WAAO;AAAA,KAET,CAAC;AAGH,QAAM,eAAe,8BACnB,CAAC,OACC,wDACE,uBAAuB,IAAI,QAAQ,2CAEvC,CAAC;AAGH,SAAO,EAAE,aAAa,YAAY,YAAY,WAAW;AAAA;",
-  "names": []
-}

package/cjs/hierarchy/useHierarchyDndkitConfig.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/useHierarchyDndkitConfig.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable max-lines */\nimport { useState, useEffect, useMemo, useRef } from 'react';\nimport {\n  useSensor,\n  useSensors,\n  KeyboardSensor,\n  PointerSensor,\n  MeasuringConfiguration,\n  MeasuringStrategy,\n  Modifier,\n} from '@dnd-kit/core';\nimport { useHierarchyActionHandlers } from './useHierarchyActionHandlers';\nimport { useHierarchyPreviewHandlers } from './useHierarchyPreviewHandlers';\nimport type { UseHierarchyDndkitConfigType, SensorContext, Item } from './types';\nimport { getHierarchyKeyboardCoordinates } from './getHierarchyKeyboardCoordinates';\nimport { customCollisionDetection } from './customCollisionDetection';\nimport { useHierarchyAnnouncements } from './useHierarchyAnnouncements';\n\n// we make space for the drop indicator\n// if second parameter is true, the space will be done on the horizontal axis\nconst adjustTranslate =\n  (isHorizontalDnD: boolean): Modifier =>\n  ({ transform }) => {\n    const newTransform = {\n      ...transform,\n    };\n    if (isHorizontalDnD) {\n      newTransform.y = transform.y + 15;\n    } else {\n      newTransform.y = transform.y - 35;\n    }\n    return newTransform;\n  };\n\nconst measuring: Partial<MeasuringConfiguration> = {\n  droppable: {\n    strategy: MeasuringStrategy.Always,\n  },\n};\n\nconst noop = () => null;\n\nexport const useHierarchyDndkitConfig: UseHierarchyDndkitConfigType = ({\n  flattenedItems,\n  dragOverlayDataTestid,\n  isHorizontalDnD = false,\n  onReorder,\n  onPreviewResetState = noop,\n  onPreviewDragStart = noop,\n}) => {\n  const [activeId, setActiveId] = useState('');\n\n  const dndItems = useMemo(() => flattenedItems.map(([item]) => item), [flattenedItems]);\n\n  const itemsDictionary = useMemo(() => {\n    const dictionary: Record<string, Item> = {};\n    dndItems.forEach((item) => {\n      dictionary[item.id] = item;\n    });\n    return dictionary;\n  }, [dndItems]);\n\n  const modifiers: Modifier[] = useMemo(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);\n\n  const sensorContext: SensorContext = useRef({\n    items: dndItems,\n  });\n\n  useEffect(() => {\n    sensorContext.current = {\n      items: dndItems,\n    };\n  }, [dndItems]);\n\n  const coordinateGetter = useMemo(\n    () => getHierarchyKeyboardCoordinates(sensorContext, dragOverlayDataTestid, isHorizontalDnD),\n    [isHorizontalDnD],\n  );\n\n  const sensors = useSensors(\n    useSensor(PointerSensor),\n    useSensor(KeyboardSensor, {\n      coordinateGetter,\n    }),\n  );\n\n  const dragPreviewHandlers = useHierarchyPreviewHandlers({\n    setActiveId,\n    onPreviewResetState,\n    onPreviewDragStart,\n  });\n\n  const dragActionHandlers = useHierarchyActionHandlers({\n    ...dragPreviewHandlers,\n    dndItems,\n    onReorder,\n  });\n\n  const announcements = useHierarchyAnnouncements(itemsDictionary);\n\n  const dndContextProps = useMemo(\n    () => ({\n      announcements,\n      modifiers,\n      sensors,\n      measuring,\n      collisionDetection: customCollisionDetection(activeId, itemsDictionary[activeId ?? '']?.parentId, dndItems),\n      ...dragActionHandlers,\n    }),\n    [announcements, modifiers, sensors, activeId, itemsDictionary, dndItems, dragActionHandlers],\n  );\n\n  return {\n    dndContextProps,\n    activeId,\n    activeIndex: activeId ? itemsDictionary[activeId]?.index : -1,\n  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAqD;AACrD,kBAQO;AACP,wCAA2C;AAC3C,yCAA4C;AAE5C,6CAAgD;AAChD,sCAAyC;AACzC,uCAA0C;AAI1C,MAAM,kBACJ,CAAC,oBACD,CAAC,EAAE,gBAAgB;AACjB,QAAM,eAAe;AAAA,OAChB;AAAA;AAEL,MAAI,iBAAiB;AACnB,iBAAa,IAAI,UAAU,IAAI;AAAA,SAC1B;AACL,iBAAa,IAAI,UAAU,IAAI;AAAA;AAEjC,SAAO;AAAA;AAGX,MAAM,YAA6C;AAAA,EACjD,WAAW;AAAA,IACT,UAAU,8BAAkB;AAAA;AAAA;AAIhC,MAAM,OAAO,MAAM;AAEZ,MAAM,2BAAyD,CAAC;AAAA,EACrE;AAAA,EACA;AAAA,EACA,kBAAkB;AAAA,EAClB;AAAA,EACA,sBAAsB;AAAA,EACtB,qBAAqB;AAAA,MACjB;AACJ,QAAM,CAAC,UAAU,eAAe,2BAAS;AAEzC,QAAM,WAAW,0BAAQ,MAAM,eAAe,IAAI,CAAC,CAAC,UAAU,OAAO,CAAC;AAEtE,QAAM,kBAAkB,0BAAQ,MAAM;AACpC,UAAM,aAAmC;AACzC,aAAS,QAAQ,CAAC,SAAS;AACzB,iBAAW,KAAK,MAAM;AAAA;AAExB,WAAO;AAAA,KACN,CAAC;AAEJ,QAAM,YAAwB,0BAAQ,MAAM,CAAC,gBAAgB,mBAAmB,CAAC;AAEjF,QAAM,gBAA+B,yBAAO;AAAA,IAC1C,OAAO;AAAA;AAGT,8BAAU,MAAM;AACd,kBAAc,UAAU;AAAA,MACtB,OAAO;AAAA;AAAA,KAER,CAAC;AAEJ,QAAM,mBAAmB,0BACvB,MAAM,4EAAgC,eAAe,uBAAuB,kBAC5E,CAAC;AAGH,QAAM,UAAU,4BACd,2BAAU,4BACV,2BAAU,4BAAgB;AAAA,IACxB;AAAA;AAIJ,QAAM,sBAAsB,oEAA4B;AAAA,IACtD;AAAA,IACA;AAAA,IACA;AAAA;AAGF,QAAM,qBAAqB,kEAA2B;AAAA,OACjD;AAAA,IACH;AAAA,IACA;AAAA;AAGF,QAAM,gBAAgB,gEAA0B;AAEhD,QAAM,kBAAkB,0BACtB,MAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,oBAAoB,8DAAyB,UAAU,gBAAgB,YAAY,KAAK,UAAU;AAAA,OAC/F;AAAA,MAEL,CAAC,eAAe,WAAW,SAAS,UAAU,iBAAiB,UAAU;AAG3E,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,aAAa,WAAW,gBAAgB,WAAW,QAAQ;AAAA;AAAA;",
-  "names": []
-}

package/cjs/hierarchy/useHierarchyPreviewHandlers.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/hierarchy/useHierarchyPreviewHandlers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { useCallback } from 'react';\nimport { DragStartEvent, DragOverEvent } from '@dnd-kit/core';\nimport type { useHierarchyPreviewHandlersReturn, useHierarchyPreviewHandlersArgs } from './types';\n\nexport const useHierarchyPreviewHandlers = ({\n  setActiveId,\n  onPreviewResetState,\n  onPreviewDragStart,\n}: useHierarchyPreviewHandlersArgs): useHierarchyPreviewHandlersReturn => {\n  const resetState = useCallback(() => {\n    setActiveId('');\n    onPreviewResetState();\n\n    document.body.style.setProperty('cursor', '');\n  }, [setActiveId, onPreviewResetState]);\n\n  const handlePreviewDragStart = useCallback(\n    ({ active: { id } }: DragStartEvent) => {\n      setActiveId(id);\n      document.body.style.setProperty('cursor', 'grabbing');\n      onPreviewDragStart();\n    },\n    [setActiveId, onPreviewDragStart],\n  );\n\n  const handlePreviewDragMove = useCallback(() => null, []);\n\n  const handlePreviewDragEnd = useCallback(() => {\n    resetState();\n  }, [resetState]);\n\n  const handlePreviewDragCancel = useCallback(() => {\n    resetState();\n  }, [resetState]);\n\n  return {\n    handlePreviewDragStart,\n    handlePreviewDragMove,\n    handlePreviewDragEnd,\n    handlePreviewDragCancel,\n  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA4B;AAIrB,MAAM,8BAA8B,CAAC;AAAA,EAC1C;AAAA,EACA;AAAA,EACA;AAAA,MACwE;AACxE,QAAM,aAAa,8BAAY,MAAM;AACnC,gBAAY;AACZ;AAEA,aAAS,KAAK,MAAM,YAAY,UAAU;AAAA,KACzC,CAAC,aAAa;AAEjB,QAAM,yBAAyB,8BAC7B,CAAC,EAAE,QAAQ,EAAE,WAA2B;AACtC,gBAAY;AACZ,aAAS,KAAK,MAAM,YAAY,UAAU;AAC1C;AAAA,KAEF,CAAC,aAAa;AAGhB,QAAM,wBAAwB,8BAAY,MAAM,MAAM;AAEtD,QAAM,uBAAuB,8BAAY,MAAM;AAC7C;AAAA,KACC,CAAC;AAEJ,QAAM,0BAA0B,8BAAY,MAAM;AAChD;AAAA,KACC,CAAC;AAEJ,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA;",
-  "names": []
-}

package/cjs/index.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/index.tsx", "../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["export * from './hierarchy';\nexport * from './tree';\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;ACAA,YAAuB;ADAvB,wBAAc;AACd,wBAAc;",
-  "names": []
-}

package/cjs/tree/constants.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/tree/constants.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["export enum DropIndicatorPosition {\n  None = 0,\n  Before = 1,\n  After = 2,\n  Inside = 3,\n}", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,IAAK,wBAAL,kBAAK,2BAAL;AACL,0DAAO,KAAP;AACA,4DAAS,KAAT;AACA,2DAAQ,KAAR;AACA,4DAAS,KAAT;AAJU;AAAA;",
-  "names": []
-}

package/cjs/tree/customCollisionDetection.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/tree/customCollisionDetection.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable complexity */\n/* eslint-disable @typescript-eslint/indent */\n/* eslint-disable max-params */\nimport { CollisionDetection, DroppableContainer, LayoutRect } from '@dnd-kit/core';\nimport { DropIndicatorPosition } from './constants';\nimport { Item } from './types';\n\nconst DUMMY_ID = 'DUMMY_ID_INTERNAL_USE_ONLY';\nconst RECT_UP: LayoutRect = {\n  offsetTop: -Infinity,\n  offsetLeft: 0, // Doesn't matter,\n  width: 0, // Doesn't matter\n  height: 0, // Doesn't matter\n};\nconst RECT_DOWN: LayoutRect = {\n  offsetTop: Infinity,\n  offsetLeft: 0, // Doesn't matter,\n  width: 0, // Doesn't matter\n  height: 0, // Doesn't matter\n};\n\n// Percentage of height to take into consideration when looking for colliding rects\nconst thresholdRatio = 0.2;\n// Percentage to be inside\nconst insideThreshold = 0.7;\n\nexport const customCollisionDetection =\n  (\n    activeId: string,\n    visibleItemsDictionary: Record<string, Item>,\n    setDropIndicatorPosition: React.Dispatch<React.SetStateAction<DropIndicatorPosition>>,\n    maxDragAndDropLevel: number,\n    lastPosition: string,\n    setLastPosition: React.Dispatch<React.SetStateAction<string>>,\n  ): CollisionDetection =>\n  ({ droppableContainers, collisionRect }) => {\n    const originalContainer = droppableContainers.find(({ id }) => id === activeId);\n    const originalRect = originalContainer?.rect?.current;\n\n    // We first check if the item was moved up or down\n    // This modifies how to search the matching colliding rect\n    let isUp = lastPosition === 'up';\n    if (originalRect) {\n      isUp = originalRect.offsetTop > collisionRect.top;\n    }\n\n    // Threshold\n    const threshold = collisionRect.height * thresholdRatio;\n\n    let collidingContainer: DroppableContainer | null = null;\n\n    if (isUp) {\n      // Up -- We need to find the first rectangle downwards\n      collidingContainer = droppableContainers.reduce(\n        (firstRectDown, container) => {\n          const rect = container.rect.current;\n          if (rect && firstRectDown.rect.current) {\n            const { offsetTop: rectOffsetTop } = rect;\n            const { offsetTop: firstRectDownOffsetTop } = firstRectDown.rect.current;\n            if (rectOffsetTop + threshold > collisionRect.top && rectOffsetTop < firstRectDownOffsetTop) {\n              return container;\n            }\n          }\n          return firstRectDown;\n        },\n        { id: DUMMY_ID, rect: { current: RECT_DOWN } } as DroppableContainer,\n      );\n    } else {\n      // Down -- We need to find the first rectangle upwards\n      collidingContainer = droppableContainers.reduce(\n        (firstRectUp, container) => {\n          const rect = container.rect.current;\n          if (rect && firstRectUp.rect.current) {\n            const { offsetTop: rectOffsetTop } = rect;\n            const { offsetTop: firstRectUpOffsetTop } = firstRectUp.rect.current;\n            if (rectOffsetTop - threshold < collisionRect.top && rectOffsetTop > firstRectUpOffsetTop) {\n              return container;\n            }\n          }\n          return firstRectUp;\n        },\n        { id: DUMMY_ID, rect: { current: RECT_UP } } as DroppableContainer,\n      );\n    }\n\n    // If we didn't find a match, return null\n    if (collidingContainer.id === DUMMY_ID) {\n      return null;\n    }\n\n    const collidingRect = collidingContainer.rect.current;\n\n    if (!collidingRect) return null;\n\n    // Calculate the intersection interval\n    const [top, bottom] = [\n      Math.max(collisionRect.top, collidingRect.offsetTop),\n      Math.min(collisionRect.bottom, collidingRect.offsetTop + collidingRect.height),\n    ];\n\n    // Calculate the percentage of intersection\n    const intersectionPercentage = Math.abs(bottom - top) / collidingRect.height;\n\n    if (\n      intersectionPercentage > insideThreshold &&\n      visibleItemsDictionary[collidingContainer.id].depth + 1 <= maxDragAndDropLevel &&\n      collidingContainer.id !== activeId\n    ) {\n      setDropIndicatorPosition(DropIndicatorPosition.Inside);\n    } else {\n      setDropIndicatorPosition(isUp ? DropIndicatorPosition.Before : DropIndicatorPosition.After);\n    }\n\n    if (isUp && lastPosition !== 'up') setLastPosition('up');\n    else if (!isUp && lastPosition !== 'down') setLastPosition('down');\n\n    // Return the id of the match rectangle\n    return collidingContainer.id;\n  };\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADIvB,uBAAsC;AAGtC,MAAM,WAAW;AACjB,MAAM,UAAsB;AAAA,EAC1B,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,QAAQ;AAAA;AAEV,MAAM,YAAwB;AAAA,EAC5B,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,QAAQ;AAAA;AAIV,MAAM,iBAAiB;AAEvB,MAAM,kBAAkB;AAEjB,MAAM,2BACX,CACE,UACA,wBACA,0BACA,qBACA,cACA,oBAEF,CAAC,EAAE,qBAAqB,oBAAoB;AAC1C,QAAM,oBAAoB,oBAAoB,KAAK,CAAC,EAAE,SAAS,OAAO;AACtE,QAAM,eAAe,mBAAmB,MAAM;AAI9C,MAAI,OAAO,iBAAiB;AAC5B,MAAI,cAAc;AAChB,WAAO,aAAa,YAAY,cAAc;AAAA;AAIhD,QAAM,YAAY,cAAc,SAAS;AAEzC,MAAI,qBAAgD;AAEpD,MAAI,MAAM;AAER,yBAAqB,oBAAoB,OACvC,CAAC,eAAe,cAAc;AAC5B,YAAM,OAAO,UAAU,KAAK;AAC5B,UAAI,QAAQ,cAAc,KAAK,SAAS;AACtC,cAAM,EAAE,WAAW,kBAAkB;AACrC,cAAM,EAAE,WAAW,2BAA2B,cAAc,KAAK;AACjE,YAAI,gBAAgB,YAAY,cAAc,OAAO,gBAAgB,wBAAwB;AAC3F,iBAAO;AAAA;AAAA;AAGX,aAAO;AAAA,OAET,EAAE,IAAI,UAAU,MAAM,EAAE,SAAS;AAAA,SAE9B;AAEL,yBAAqB,oBAAoB,OACvC,CAAC,aAAa,cAAc;AAC1B,YAAM,OAAO,UAAU,KAAK;AAC5B,UAAI,QAAQ,YAAY,KAAK,SAAS;AACpC,cAAM,EAAE,WAAW,kBAAkB;AACrC,cAAM,EAAE,WAAW,yBAAyB,YAAY,KAAK;AAC7D,YAAI,gBAAgB,YAAY,cAAc,OAAO,gBAAgB,sBAAsB;AACzF,iBAAO;AAAA;AAAA;AAGX,aAAO;AAAA,OAET,EAAE,IAAI,UAAU,MAAM,EAAE,SAAS;AAAA;AAKrC,MAAI,mBAAmB,OAAO,UAAU;AACtC,WAAO;AAAA;AAGT,QAAM,gBAAgB,mBAAmB,KAAK;AAE9C,MAAI,CAAC;AAAe,WAAO;AAG3B,QAAM,CAAC,KAAK,UAAU;AAAA,IACpB,KAAK,IAAI,cAAc,KAAK,cAAc;AAAA,IAC1C,KAAK,IAAI,cAAc,QAAQ,cAAc,YAAY,cAAc;AAAA;AAIzE,QAAM,yBAAyB,KAAK,IAAI,SAAS,OAAO,cAAc;AAEtE,MACE,yBAAyB,mBACzB,uBAAuB,mBAAmB,IAAI,QAAQ,KAAK,uBAC3D,mBAAmB,OAAO,UAC1B;AACA,6BAAyB,uCAAsB;AAAA,SAC1C;AACL,6BAAyB,OAAO,uCAAsB,SAAS,uCAAsB;AAAA;AAGvF,MAAI,QAAQ,iBAAiB;AAAM,oBAAgB;AAAA,WAC1C,CAAC,QAAQ,iBAAiB;AAAQ,oBAAgB;AAG3D,SAAO,mBAAmB;AAAA;",
-  "names": []
-}