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

package/cjs/tree/useTreeActionHandlers.js

@@ -1,75 +1,86 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var sortable = require('@dnd-kit/sortable');
-var lodash = require('lodash');
-var react = require('react');
-var constants = require('./constants.js');
-
-const useTreeActionHandlers = _ref => {
-  let {
-    handlePreviewDragStart,
-    handlePreviewDragMove,
-    handlePreviewDragOver,
-    handlePreviewDragEnd,
-    handlePreviewDragCancel,
-    onReorder,
-    flattenedItems,
-    projected,
-    dropIndicatorPosition
-  } = _ref;
-  const onDragStart = react.useCallback(e => {
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useTreeActionHandlers_exports = {};
+__export(useTreeActionHandlers_exports, {
+  useTreeActionHandlers: () => useTreeActionHandlers
+});
+var React = __toESM(require("react"));
+var import_sortable = require("@dnd-kit/sortable");
+var import_lodash = require("lodash");
+var import_react = require("react");
+var import_constants = require("./constants");
+const useTreeActionHandlers = ({
+  handlePreviewDragStart,
+  handlePreviewDragMove,
+  handlePreviewDragOver,
+  handlePreviewDragEnd,
+  handlePreviewDragCancel,
+  onReorder,
+  flattenedItems,
+  projected,
+  dropIndicatorPosition,
+  isDropValid
+}) => {
+  const onDragStart = (0, import_react.useCallback)((e) => {
     handlePreviewDragStart(e);
   }, [handlePreviewDragStart]);
-  const onDragMove = react.useCallback(e => {
+  const onDragMove = (0, import_react.useCallback)((e) => {
     handlePreviewDragMove(e);
   }, [handlePreviewDragMove]);
-  const onDragOver = react.useCallback(e => {
+  const onDragOver = (0, import_react.useCallback)((e) => {
     handlePreviewDragOver(e);
   }, [handlePreviewDragOver]);
-  const onDragEnd = react.useCallback(e => {
+  const onDragEnd = (0, import_react.useCallback)((e) => {
     handlePreviewDragEnd(e);
-    const {
-      active,
-      over
-    } = e;
-    if (over === null) return;
-    const activeIndex = flattenedItems.findIndex(item => item.uid === active.id);
+    const { active, over } = e;
+    if (over === null || !isDropValid)
+      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 === constants.DropIndicatorPosition.Inside) {
-      var _flattenedItems$overI, _flattenedItems$overI2;
-
+    let overIndex = flattenedItems.findIndex((item) => item.uid === over.id);
+    if (dropIndicatorPosition === import_constants.DropIndicatorPosition.Inside) {
       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
-
-
+      overIndex = flattenedItems[overIndex].realIndex + flattenedItems[overIndex].childrenCount + 1;
+    }
     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 ? sortable.arrayMove(flattenedItems, activeIndex, overIndex) : lodash.cloneDeep(flattenedItems);
+      flattenedItems[activeIndex].depth = projected.depth;
+      const newFlattenedData = activeIndex !== overIndex ? (0, import_sortable.arrayMove)(flattenedItems, activeIndex, overIndex) : (0, import_lodash.cloneDeep)(flattenedItems);
       onReorder(newFlattenedData, {
         targetIndex: overIndex,
         fromIndex: activeIndex
-      }, considerExpanding || '');
+      }, considerExpanding || "");
     }
-  }, [handlePreviewDragEnd, flattenedItems, projected, onReorder, dropIndicatorPosition]);
-  const onDragCancel = react.useCallback(e => {
+  }, [handlePreviewDragEnd, isDropValid, flattenedItems, dropIndicatorPosition, projected, onReorder]);
+  const onDragCancel = (0, import_react.useCallback)((e) => {
     handlePreviewDragCancel(e);
   }, [handlePreviewDragCancel]);
-  return {
-    onDragStart,
-    onDragMove,
-    onDragOver,
-    onDragEnd,
-    onDragCancel
-  };
+  return { onDragStart, onDragMove, onDragOver, onDragEnd, onDragCancel };
 };
-
-exports.useTreeActionHandlers = useTreeActionHandlers;
+module.exports = __toCommonJS(useTreeActionHandlers_exports);
+//# sourceMappingURL=useTreeActionHandlers.js.map

package/cjs/tree/useTreeActionHandlers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tree/useTreeActionHandlers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { arrayMove } from '@dnd-kit/sortable';\nimport { cloneDeep } from 'lodash';\nimport { useCallback } from 'react';\nimport type { DragStartEvent, DragMoveEvent, DragEndEvent, DragOverEvent, DragCancelEvent } from '@dnd-kit/core';\nimport { DropIndicatorPosition } from './constants';\nimport type { UseTreeActionHandlersReturn, UseTreeActionHandlersArgs } from './types';\n\nexport const useTreeActionHandlers = ({\n  handlePreviewDragStart,\n  handlePreviewDragMove,\n  handlePreviewDragOver,\n  handlePreviewDragEnd,\n  handlePreviewDragCancel,\n  onReorder,\n  flattenedItems,\n  projected,\n  dropIndicatorPosition,\n  isDropValid,\n}: UseTreeActionHandlersArgs): UseTreeActionHandlersReturn => {\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 onDragOver = useCallback(\n    (e: DragOverEvent) => {\n      handlePreviewDragOver(e);\n    },\n    [handlePreviewDragOver],\n  );\n\n  const onDragEnd = useCallback(\n    (e: DragEndEvent) => {\n      handlePreviewDragEnd(e);\n      const { active, over } = e;\n\n      if (over === null || !isDropValid) return;\n\n      const activeIndex = flattenedItems.findIndex((item) => item.uid === active.id);\n\n      let considerExpanding = null;\n\n      let overIndex = flattenedItems.findIndex((item) => item.uid === over.id);\n      // If drop indicator is inside, then put it last,\n      // It will be reconstructed well later\n      if (dropIndicatorPosition === DropIndicatorPosition.Inside) {\n        considerExpanding = over.id;\n        overIndex = flattenedItems[overIndex].realIndex + flattenedItems[overIndex].childrenCount + 1;\n      }\n\n      // If we are dropping the item in a new position, or new depth\n      if (projected && (activeIndex !== overIndex || flattenedItems[activeIndex].depth !== projected.depth)) {\n        // Change parent and depth from projected data\n        flattenedItems[activeIndex].parentId = projected.parentId;\n        flattenedItems[activeIndex].depth = projected.depth;\n\n        // If same index, don't move the array, just copy it\n        const newFlattenedData =\n          activeIndex !== overIndex ? arrayMove(flattenedItems, activeIndex, overIndex) : cloneDeep(flattenedItems);\n\n        onReorder(\n          newFlattenedData,\n          {\n            targetIndex: overIndex,\n            fromIndex: activeIndex,\n          },\n          considerExpanding || '',\n        );\n      }\n    },\n    [handlePreviewDragEnd, isDropValid, flattenedItems, dropIndicatorPosition, projected, onReorder],\n  );\n\n  const onDragCancel = useCallback(\n    (e: DragCancelEvent) => {\n      handlePreviewDragCancel(e);\n    },\n    [handlePreviewDragCancel],\n  );\n\n  return { onDragStart, onDragMove, onDragOver, onDragEnd, onDragCancel };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,sBAA0B;AAC1B,oBAA0B;AAC1B,mBAA4B;AAE5B,uBAAsC;AAG/B,MAAM,wBAAwB,CAAC;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,MAC4D;AAC5D,QAAM,cAAc,8BAClB,CAAC,MAAsB;AACrB,2BAAuB;AAAA,KAEzB,CAAC;AAGH,QAAM,aAAa,8BACjB,CAAC,MAAqB;AACpB,0BAAsB;AAAA,KAExB,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,SAAS,QAAQ,CAAC;AAAa;AAEnC,UAAM,cAAc,eAAe,UAAU,CAAC,SAAS,KAAK,QAAQ,OAAO;AAE3E,QAAI,oBAAoB;AAExB,QAAI,YAAY,eAAe,UAAU,CAAC,SAAS,KAAK,QAAQ,KAAK;AAGrE,QAAI,0BAA0B,uCAAsB,QAAQ;AAC1D,0BAAoB,KAAK;AACzB,kBAAY,eAAe,WAAW,YAAY,eAAe,WAAW,gBAAgB;AAAA;AAI9F,QAAI,aAAc,iBAAgB,aAAa,eAAe,aAAa,UAAU,UAAU,QAAQ;AAErG,qBAAe,aAAa,WAAW,UAAU;AACjD,qBAAe,aAAa,QAAQ,UAAU;AAG9C,YAAM,mBACJ,gBAAgB,YAAY,+BAAU,gBAAgB,aAAa,aAAa,6BAAU;AAE5F,gBACE,kBACA;AAAA,QACE,aAAa;AAAA,QACb,WAAW;AAAA,SAEb,qBAAqB;AAAA;AAAA,KAI3B,CAAC,sBAAsB,aAAa,gBAAgB,uBAAuB,WAAW;AAGxF,QAAM,eAAe,8BACnB,CAAC,MAAuB;AACtB,4BAAwB;AAAA,KAE1B,CAAC;AAGH,SAAO,EAAE,aAAa,YAAY,YAAY,WAAW;AAAA;",
+  "names": []
+}

package/cjs/tree/useTreeAnnouncements.js

@@ -1,55 +1,68 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var react = require('react');
-var constants = require('./constants.js');
-
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useTreeAnnouncements_exports = {};
+__export(useTreeAnnouncements_exports, {
+  useTreeAnnouncements: () => useTreeAnnouncements
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_constants = require("./constants");
 const useTreeAnnouncements = (visibleItemsDictionary, dropIndicatorPosition) => {
-  const onDragStart = react.useCallback(id => "Picked up draggable item from position ".concat(visibleItemsDictionary[id].realIndex + 1, "."), [visibleItemsDictionary]);
-  const onDragMove = react.useCallback((id, overId) => {
+  const onDragStart = (0, import_react.useCallback)((id) => `Picked up draggable item from position ${visibleItemsDictionary[id].realIndex + 1}.`, [visibleItemsDictionary]);
+  const onDragMove = (0, import_react.useCallback)((id, overId) => {
     if (overId) {
       const overIndex = visibleItemsDictionary[overId].realIndex + 1;
-
-      if (dropIndicatorPosition === constants.DropIndicatorPosition.Inside) {
-        return "Draggable item was moved inside the item at position ".concat(overIndex, ".");
+      if (dropIndicatorPosition === import_constants.DropIndicatorPosition.Inside) {
+        return `Draggable item was moved inside the item at position ${overIndex}.`;
       }
-
-      if (dropIndicatorPosition === constants.DropIndicatorPosition.Before) {
-        return "Draggable item was moved to position ".concat(overIndex - 1, ".");
+      if (dropIndicatorPosition === import_constants.DropIndicatorPosition.Before) {
+        return `Draggable item was moved to position ${overIndex - 1}.`;
       }
-
-      return "Draggable item was moved to position ".concat(overIndex, ".");
+      return `Draggable item was moved to position ${overIndex}.`;
     }
-
-    return "Draggable item is no longer over a droppable area.";
+    return `Draggable item is no longer over a droppable area.`;
   }, [visibleItemsDictionary, dropIndicatorPosition]);
   const onDragOver = onDragMove;
-  const onDragEnd = react.useCallback((id, overId) => {
+  const onDragEnd = (0, import_react.useCallback)((id, overId) => {
     if (overId) {
       const overIndex = visibleItemsDictionary[overId].realIndex + 1;
-
-      if (dropIndicatorPosition === constants.DropIndicatorPosition.Inside) {
-        return "Draggable item was dropped inside the item at position ".concat(overIndex, ".");
+      if (dropIndicatorPosition === import_constants.DropIndicatorPosition.Inside) {
+        return `Draggable item was dropped inside the item at position ${overIndex}.`;
       }
-
-      if (dropIndicatorPosition === constants.DropIndicatorPosition.Before) {
-        return "Draggable item was dropped over position ".concat(overIndex - 1, ".");
+      if (dropIndicatorPosition === import_constants.DropIndicatorPosition.Before) {
+        return `Draggable item was dropped over position ${overIndex - 1}.`;
       }
-
-      return "Draggable item was dropped over position ".concat(overIndex, ".");
+      return `Draggable item was dropped over position ${overIndex}.`;
     }
-
-    return "Draggable item was dropped at it's original position.";
+    return `Draggable item was dropped at it's original position.`;
   }, [dropIndicatorPosition, visibleItemsDictionary]);
-  const onDragCancel = react.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
-  };
+  const onDragCancel = (0, import_react.useCallback)((id) => `Dragging was cancelled. Draggable item from position ${visibleItemsDictionary[id].realIndex + 1} was dropped at it's initial position.`, [visibleItemsDictionary]);
+  return { onDragStart, onDragOver, onDragMove, onDragEnd, onDragCancel };
 };
-
-exports.useTreeAnnouncements = useTreeAnnouncements;
+module.exports = __toCommonJS(useTreeAnnouncements_exports);
+//# sourceMappingURL=useTreeAnnouncements.js.map

package/cjs/tree/useTreeAnnouncements.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tree/useTreeAnnouncements.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { Announcements } from '@dnd-kit/core';\nimport { useCallback } from 'react';\nimport { DropIndicatorPosition } from './constants';\nimport { Item } from './types';\n\nexport const useTreeAnnouncements = (\n  visibleItemsDictionary: Record<string, Item>,\n  dropIndicatorPosition: DropIndicatorPosition,\n): Announcements => {\n  const onDragStart = useCallback(\n    (id: string) => `Picked up draggable item from position ${visibleItemsDictionary[id].realIndex + 1}.`,\n    [visibleItemsDictionary],\n  );\n\n  const onDragMove = useCallback(\n    (id: string, overId: string) => {\n      if (overId) {\n        const overIndex = visibleItemsDictionary[overId].realIndex + 1;\n        if (dropIndicatorPosition === DropIndicatorPosition.Inside) {\n          return `Draggable item was moved inside the item at position ${overIndex}.`;\n        }\n        if (dropIndicatorPosition === DropIndicatorPosition.Before) {\n          return `Draggable item was moved to position ${overIndex - 1}.`;\n        }\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, dropIndicatorPosition],\n  );\n\n  const onDragOver = onDragMove;\n\n  const onDragEnd = useCallback(\n    (id: string, overId: string) => {\n      if (overId) {\n        const overIndex = visibleItemsDictionary[overId].realIndex + 1;\n        if (dropIndicatorPosition === DropIndicatorPosition.Inside) {\n          return `Draggable item was dropped inside the item at position ${overIndex}.`;\n        }\n        if (dropIndicatorPosition === DropIndicatorPosition.Before) {\n          return `Draggable item was dropped over position ${overIndex - 1}.`;\n        }\n        return `Draggable item was dropped over position ${overIndex}.`;\n      }\n\n      return `Draggable item was dropped at it's original position.`;\n    },\n    [dropIndicatorPosition, visibleItemsDictionary],\n  );\n\n  const onDragCancel = useCallback(\n    (id: string) =>\n      `Dragging was cancelled. Draggable item from position ${\n        visibleItemsDictionary[id].realIndex + 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;AAC5B,uBAAsC;AAG/B,MAAM,uBAAuB,CAClC,wBACA,0BACkB;AAClB,QAAM,cAAc,8BAClB,CAAC,OAAe,0CAA0C,uBAAuB,IAAI,YAAY,MACjG,CAAC;AAGH,QAAM,aAAa,8BACjB,CAAC,IAAY,WAAmB;AAC9B,QAAI,QAAQ;AACV,YAAM,YAAY,uBAAuB,QAAQ,YAAY;AAC7D,UAAI,0BAA0B,uCAAsB,QAAQ;AAC1D,eAAO,wDAAwD;AAAA;AAEjE,UAAI,0BAA0B,uCAAsB,QAAQ;AAC1D,eAAO,wCAAwC,YAAY;AAAA;AAE7D,aAAO,wCAAwC;AAAA;AAGjD,WAAO;AAAA,KAET,CAAC,wBAAwB;AAG3B,QAAM,aAAa;AAEnB,QAAM,YAAY,8BAChB,CAAC,IAAY,WAAmB;AAC9B,QAAI,QAAQ;AACV,YAAM,YAAY,uBAAuB,QAAQ,YAAY;AAC7D,UAAI,0BAA0B,uCAAsB,QAAQ;AAC1D,eAAO,0DAA0D;AAAA;AAEnE,UAAI,0BAA0B,uCAAsB,QAAQ;AAC1D,eAAO,4CAA4C,YAAY;AAAA;AAEjE,aAAO,4CAA4C;AAAA;AAGrD,WAAO;AAAA,KAET,CAAC,uBAAuB;AAG1B,QAAM,eAAe,8BACnB,CAAC,OACC,wDACE,uBAAuB,IAAI,YAAY,2CAE3C,CAAC;AAGH,SAAO,EAAE,aAAa,YAAY,YAAY,WAAW;AAAA;",
+  "names": []
+}

package/cjs/tree/useTreeDndkitConfig.js

@@ -1,142 +1,156 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-require('core-js/modules/web.dom-collections.iterator.js');
-require('core-js/modules/esnext.async-iterator.map.js');
-require('core-js/modules/esnext.iterator.map.js');
-require('core-js/modules/esnext.async-iterator.for-each.js');
-require('core-js/modules/esnext.iterator.constructor.js');
-require('core-js/modules/esnext.iterator.for-each.js');
-require('core-js/modules/esnext.async-iterator.filter.js');
-require('core-js/modules/esnext.iterator.filter.js');
-var react = require('react');
-var core = require('@dnd-kit/core');
-var sortable = require('@dnd-kit/sortable');
-var useTreePreviewHandlers = require('./useTreePreviewHandlers.js');
-var getTreeKeyboardCoordinates = require('./getTreeKeyboardCoordinates.js');
-var utilities = require('./utilities.js');
-var useTreeActionHandlers = require('./useTreeActionHandlers.js');
-var constants = require('./constants.js');
-var customCollisionDetection = require('./customCollisionDetection.js');
-var useTreeAnnouncements = require('./useTreeAnnouncements.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-
-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__default["default"](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 => _ref => {
-  let {
-    transform
-  } = _ref;
-
-  const newTransform = _objectSpread({}, transform);
-
-  if (isHorizontalDnD) {
-    newTransform.x = transform.x + 25;
-  } else {
-    newTransform.x = transform.x + 15;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
   }
-
-  return newTransform;
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useTreeDndkitConfig_exports = {};
+__export(useTreeDndkitConfig_exports, {
+  useTreeDndkitConfig: () => useTreeDndkitConfig
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_core = require("@dnd-kit/core");
+var import_useTreePreviewHandlers = require("./useTreePreviewHandlers");
+var import_getTreeKeyboardCoordinates = require("./getTreeKeyboardCoordinates");
+var import_utilities = require("./utilities");
+var import_useTreeActionHandlers = require("./useTreeActionHandlers");
+var import_constants = require("./constants");
+var import_customCollisionDetection = require("./customCollisionDetection");
+var import_useTreeAnnouncements = require("./useTreeAnnouncements");
+const adjustTranslate = (isHorizontalDnD) => {
+  const func = ({ transform }) => {
+    const newTransform = {
+      ...transform
+    };
+    if (isHorizontalDnD) {
+      newTransform.x = transform.x + 25;
+    } else {
+      newTransform.x = transform.x + 15;
+    }
+    return newTransform;
+  };
+  return func;
 };
-
 const measuring = {
   droppable: {
-    strategy: core.MeasuringStrategy.BeforeDragging
+    strategy: import_core.MeasuringStrategy.Always
   }
 };
-const useTreeDndkitConfig = _ref2 => {
-  var _visibleItemsDictiona, _visibleItemsDictiona2;
-
-  let {
-    flattenedItems,
-    visibleItems: preVisibleItems,
-    isHorizontalDnD = false,
-    isExpandable = false,
-    onReorder,
-    maxDragAndDropLevel
-  } = _ref2;
-  const [activeId, setActiveId] = react.useState('');
-  const [overId, setOverId] = react.useState('');
-  const [dropIndicatorPosition, setDropIndicatorPosition] = react.useState(constants.DropIndicatorPosition.None);
-  const [lastPosition, setLastPosition] = react.useState(''); // Remove activeId's children
-
-  const visibleItems = react.useMemo(() => utilities.removeChildrenOf(preVisibleItems, activeId), [preVisibleItems, activeId]); // Sorted ids for the library
-
-  const sortedIds = react.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 = react.useMemo(() => {
-    // Using plain for to achieve O(#ITEMS) performance
+const useTreeDndkitConfig = ({
+  flattenedItems,
+  visibleItems: preVisibleItems,
+  isHorizontalDnD = false,
+  isExpandable = false,
+  onReorder,
+  getIsDropValid = () => true,
+  maxDragAndDropLevel
+}) => {
+  const [activeId, setActiveId] = (0, import_react.useState)("");
+  const [overId, setOverId] = (0, import_react.useState)("");
+  const [dropIndicatorPosition, setDropIndicatorPosition] = (0, import_react.useState)(import_constants.DropIndicatorPosition.None);
+  const [lastPosition, setLastPosition] = (0, import_react.useState)("");
+  const visibleItems = (0, import_react.useMemo)(() => (0, import_utilities.removeChildrenOf)(preVisibleItems, activeId), [preVisibleItems, activeId]);
+  const sortedIds = (0, import_react.useMemo)(() => visibleItems.map((item) => item.uid), [visibleItems]);
+  const visibleItemsDictionary = (0, import_react.useMemo)(() => {
     const dictionary = {};
-    visibleItems.forEach(item => {
+    visibleItems.forEach((item) => {
       dictionary[item.uid] = item;
     });
     return dictionary;
   }, [visibleItems]);
-  const modifiers = react.useMemo(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);
-  const sensorContext = react.useRef({
+  const isDropValid = (0, import_react.useMemo)(() => {
+    if (!activeId || !overId)
+      return true;
+    return getIsDropValid(visibleItemsDictionary[activeId], visibleItemsDictionary[overId], ["none", "before", "after", "inside"][dropIndicatorPosition]);
+  }, [getIsDropValid, visibleItemsDictionary, activeId, overId, dropIndicatorPosition]);
+  const modifiers = (0, import_react.useMemo)(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);
+  const sensorContext = (0, import_react.useRef)({
     items: visibleItems,
     dropIndicatorPosition,
     setDropIndicatorPosition
   });
-  react.useEffect(() => {
+  (0, import_react.useEffect)(() => {
     sensorContext.current = {
       items: visibleItems,
       dropIndicatorPosition,
       setDropIndicatorPosition
     };
   }, [visibleItems, dropIndicatorPosition, setDropIndicatorPosition]);
-  const coordinateGetter = react.useMemo(() => getTreeKeyboardCoordinates.getTreeKeyboardCoordinates(sensorContext, isHorizontalDnD, maxDragAndDropLevel), [sensorContext, isHorizontalDnD, maxDragAndDropLevel]);
-  const sensors = core.useSensors(core.useSensor(core.PointerSensor), core.useSensor(core.KeyboardSensor, {
+  const coordinateGetter = (0, import_react.useMemo)(() => (0, import_getTreeKeyboardCoordinates.getTreeKeyboardCoordinates)(sensorContext, isHorizontalDnD, maxDragAndDropLevel), [sensorContext, isHorizontalDnD, maxDragAndDropLevel]);
+  const sensors = (0, import_core.useSensors)((0, import_core.useSensor)(import_core.PointerSensor), (0, import_core.useSensor)(import_core.KeyboardSensor, {
     coordinateGetter
-  })); // where is the activeItem being positioned (depth and parent)
-
-  const projected = react.useMemo(() => overId ? utilities.getProjection(visibleItems, visibleItemsDictionary, overId, dropIndicatorPosition, isExpandable) : null, [overId, visibleItems, visibleItemsDictionary, dropIndicatorPosition, isExpandable]);
-  const dragPreviewHandlers = useTreePreviewHandlers.useTreePreviewHandlers({
+  }));
+  const projected = (0, import_react.useMemo)(() => overId ? (0, import_utilities.getProjection)(visibleItems, visibleItemsDictionary, overId, dropIndicatorPosition, isExpandable) : null, [overId, visibleItems, visibleItemsDictionary, dropIndicatorPosition, isExpandable]);
+  const dragPreviewHandlers = (0, import_useTreePreviewHandlers.useTreePreviewHandlers)({
     setActiveId,
     setOverId,
     setDropIndicatorPosition
   });
-  const dragActionHandlers = useTreeActionHandlers.useTreeActionHandlers(_objectSpread(_objectSpread({}, dragPreviewHandlers), {}, {
+  const dragActionHandlers = (0, import_useTreeActionHandlers.useTreeActionHandlers)({
+    ...dragPreviewHandlers,
     onReorder,
     projected,
     flattenedItems,
-    dropIndicatorPosition
-  }));
-  const announcements = useTreeAnnouncements.useTreeAnnouncements(visibleItemsDictionary, dropIndicatorPosition);
-  const dndContextProps = react.useMemo(() => _objectSpread({
+    dropIndicatorPosition,
+    isDropValid
+  });
+  const announcements = (0, import_useTreeAnnouncements.useTreeAnnouncements)(visibleItemsDictionary, dropIndicatorPosition);
+  const dndContextProps = (0, import_react.useMemo)(() => ({
     announcements,
     modifiers,
     sensors,
     measuring,
-    collisionDetection: customCollisionDetection.customCollisionDetection(activeId, visibleItemsDictionary, setDropIndicatorPosition, maxDragAndDropLevel, lastPosition, setLastPosition)
-  }, dragActionHandlers), [announcements, modifiers, sensors, dragActionHandlers, visibleItemsDictionary, setDropIndicatorPosition, activeId, maxDragAndDropLevel, lastPosition, setLastPosition]);
-  const sortableContextProps = react.useMemo(() => ({
+    collisionDetection: (0, import_customCollisionDetection.customCollisionDetection)(activeId, visibleItemsDictionary, setDropIndicatorPosition, maxDragAndDropLevel, lastPosition, setLastPosition),
+    ...dragActionHandlers
+  }), [
+    announcements,
+    modifiers,
+    sensors,
+    dragActionHandlers,
+    visibleItemsDictionary,
+    setDropIndicatorPosition,
+    activeId,
+    maxDragAndDropLevel,
+    lastPosition,
+    setLastPosition
+  ]);
+  const sortableContextProps = (0, import_react.useMemo)(() => ({
     items: sortedIds,
-    strategy: isHorizontalDnD ? sortable.horizontalListSortingStrategy : sortable.verticalListSortingStrategy
-  }), [sortedIds, isHorizontalDnD]);
+    strategy: () => null
+  }), [sortedIds]);
   return {
     dndContextProps,
     sortableContextProps,
+    isDropValid,
     activeId,
-    activeIndex: (_visibleItemsDictiona = (_visibleItemsDictiona2 = visibleItemsDictionary[activeId]) === null || _visibleItemsDictiona2 === void 0 ? void 0 : _visibleItemsDictiona2.realIndex) !== null && _visibleItemsDictiona !== void 0 ? _visibleItemsDictiona : -1,
+    activeIndex: visibleItemsDictionary[activeId]?.realIndex ?? -1,
     overId,
     depth: projected ? projected.depth : 0,
     dropIndicatorPosition,
     visibleItems
   };
 };
-
-exports.useTreeDndkitConfig = useTreeDndkitConfig;
+module.exports = __toCommonJS(useTreeDndkitConfig_exports);
+//# sourceMappingURL=useTreeDndkitConfig.js.map

package/cjs/tree/useTreeDndkitConfig.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tree/useTreeDndkitConfig.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 { useTreePreviewHandlers } from './useTreePreviewHandlers';\nimport { getTreeKeyboardCoordinates } from './getTreeKeyboardCoordinates';\nimport { getProjection, removeChildrenOf } from './utilities';\nimport { useTreeActionHandlers } from './useTreeActionHandlers';\nimport type { UseTreeDndkitConfigType, SensorContext } from './types';\nimport { DropIndicatorPosition } from './constants';\nimport { customCollisionDetection } from './customCollisionDetection';\nimport { useTreeAnnouncements } from './useTreeAnnouncements';\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 = (isHorizontalDnD: boolean): Modifier => {\n  const func: Modifier = ({ transform }) => {\n    const newTransform = {\n      ...transform,\n    };\n    if (isHorizontalDnD) {\n      newTransform.x = transform.x + 25;\n    } else {\n      newTransform.x = transform.x + 15;\n    }\n    return newTransform;\n  };\n  return func;\n};\n\nconst measuring: Partial<MeasuringConfiguration> = {\n  droppable: {\n    strategy: MeasuringStrategy.Always,\n  },\n};\n\nexport const useTreeDndkitConfig: UseTreeDndkitConfigType = ({\n  flattenedItems,\n  visibleItems: preVisibleItems,\n  isHorizontalDnD = false,\n  isExpandable = false,\n  onReorder,\n  getIsDropValid = () => true,\n  maxDragAndDropLevel,\n}) => {\n  const [activeId, setActiveId] = useState<string>('');\n  const [overId, setOverId] = useState<string>('');\n  const [dropIndicatorPosition, setDropIndicatorPosition] = useState<DropIndicatorPosition>(DropIndicatorPosition.None);\n  const [lastPosition, setLastPosition] = useState<string>('');\n\n  // Remove activeId's children\n  const visibleItems = useMemo(() => removeChildrenOf(preVisibleItems, activeId), [preVisibleItems, activeId]);\n\n  // Sorted ids for the library\n  const sortedIds = useMemo(() => visibleItems.map((item) => item.uid), [visibleItems]);\n\n  /**\n   * Dictionary from UID to ITEM\n   * This dictionary is computed since on every DnD move, I need to know the\n   * depth of a particular row, so O(1) per DnD move instead of O(#ITEMS)\n   */\n  const visibleItemsDictionary = useMemo(() => {\n    // Using plain for to achieve O(#ITEMS) performance\n    const dictionary: Record<string, typeof visibleItems[0]> = {};\n    visibleItems.forEach((item) => {\n      dictionary[item.uid] = item;\n    });\n    return dictionary;\n  }, [visibleItems]);\n\n  const isDropValid = useMemo(() => {\n    if (!activeId || !overId) return true;\n    return getIsDropValid(\n      visibleItemsDictionary[activeId],\n      visibleItemsDictionary[overId],\n      ['none', 'before', 'after', 'inside'][dropIndicatorPosition] as Parameters<typeof getIsDropValid>[2],\n    );\n  }, [getIsDropValid, visibleItemsDictionary, activeId, overId, dropIndicatorPosition]);\n\n  const modifiers: Modifier[] = useMemo(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);\n\n  const sensorContext: SensorContext = useRef({\n    items: visibleItems,\n    dropIndicatorPosition,\n    setDropIndicatorPosition,\n  });\n\n  useEffect(() => {\n    sensorContext.current = {\n      items: visibleItems,\n      dropIndicatorPosition,\n      setDropIndicatorPosition,\n    };\n  }, [visibleItems, dropIndicatorPosition, setDropIndicatorPosition]);\n\n  const coordinateGetter = useMemo(\n    () => getTreeKeyboardCoordinates(sensorContext, isHorizontalDnD, maxDragAndDropLevel),\n    [sensorContext, isHorizontalDnD, maxDragAndDropLevel],\n  );\n\n  const sensors = useSensors(\n    useSensor(PointerSensor),\n    useSensor(KeyboardSensor, {\n      coordinateGetter,\n    }),\n  );\n\n  // where is the activeItem being positioned (depth and parent)\n  const projected = useMemo(\n    () =>\n      overId ? getProjection(visibleItems, visibleItemsDictionary, overId, dropIndicatorPosition, isExpandable) : null,\n    [overId, visibleItems, visibleItemsDictionary, dropIndicatorPosition, isExpandable],\n  );\n\n  const dragPreviewHandlers = useTreePreviewHandlers({\n    setActiveId,\n    setOverId,\n    setDropIndicatorPosition,\n  });\n\n  const dragActionHandlers = useTreeActionHandlers({\n    ...dragPreviewHandlers,\n    onReorder,\n    projected,\n    flattenedItems,\n    dropIndicatorPosition,\n    isDropValid,\n  });\n\n  const announcements = useTreeAnnouncements(visibleItemsDictionary, dropIndicatorPosition);\n\n  const dndContextProps = useMemo(\n    () => ({\n      announcements,\n      modifiers,\n      sensors,\n      measuring,\n      collisionDetection: customCollisionDetection(\n        activeId,\n        visibleItemsDictionary,\n        setDropIndicatorPosition,\n        maxDragAndDropLevel,\n        lastPosition,\n        setLastPosition,\n      ),\n      ...dragActionHandlers,\n    }),\n    [\n      announcements,\n      modifiers,\n      sensors,\n      dragActionHandlers,\n      visibleItemsDictionary,\n      setDropIndicatorPosition,\n      activeId,\n      maxDragAndDropLevel,\n      lastPosition,\n      setLastPosition,\n    ],\n  );\n\n  const sortableContextProps = useMemo(\n    () => ({\n      items: sortedIds,\n      strategy: () => null,\n    }),\n    [sortedIds],\n  );\n\n  return {\n    dndContextProps,\n    sortableContextProps,\n    isDropValid,\n    activeId,\n    activeIndex: visibleItemsDictionary[activeId]?.realIndex ?? -1,\n    overId,\n    depth: projected ? projected.depth : 0,\n    dropIndicatorPosition,\n    visibleItems,\n  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}