@elliemae/ds-drag-and-drop 2.3.1 → 3.0.0-alpha.3

package/dist/cjs/hierarchy/customCollisionDetection.js

@@ -0,0 +1,64 @@
+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 customCollisionDetection_exports = {};
+__export(customCollisionDetection_exports, {
+  customCollisionDetection: () => customCollisionDetection
+});
+var React = __toESM(require("react"));
+const customCollisionDetection = (activeId, activeParent, dndItems) => ({ droppableContainers, collisionRect }) => {
+  const entriesWithSameParent = droppableContainers.filter(({ id }) => dndItems.find((item) => item.id === id)?.parentId === activeParent);
+  const originalContainer = entriesWithSameParent.find(({ id }) => id === activeId);
+  const originalRect = originalContainer?.rect?.current;
+  if (!originalRect)
+    return null;
+  if (originalRect.offsetLeft <= collisionRect.offsetLeft && collisionRect.offsetLeft <= originalRect.offsetLeft + originalRect.width) {
+    return originalContainer.id;
+  }
+  const isLeft = collisionRect.offsetLeft <= originalRect.offsetLeft + collisionRect.width / 2 + 5;
+  let match = null;
+  const collisionPoint = collisionRect.offsetLeft + collisionRect.width / 2;
+  entriesWithSameParent.forEach((entry) => {
+    const {
+      rect: { current: rect }
+    } = entry;
+    if (rect !== null) {
+      const offsetRight = rect.offsetLeft + rect.width;
+      if (!match) {
+        match = entry;
+      } else if (match && match.rect.current && isLeft && Math.abs(collisionPoint - rect.offsetLeft) <= Math.abs(collisionPoint - match.rect.current.offsetLeft)) {
+        match = entry;
+      } else if (match && match.rect.current && !isLeft && Math.abs(collisionPoint - offsetRight) <= Math.abs(collisionPoint - match.rect.current.offsetLeft - match.rect.current.width)) {
+        match = entry;
+      }
+    }
+  });
+  const matchCastedForSomeReason = match;
+  return matchCastedForSomeReason === null ? null : matchCastedForSomeReason.id;
+};
+module.exports = __toCommonJS(customCollisionDetection_exports);
+//# sourceMappingURL=customCollisionDetection.js.map

package/dist/cjs/hierarchy/customCollisionDetection.js.map

@@ -0,0 +1,7 @@
+{
+  "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/dist/cjs/hierarchy/getHierarchyKeyboardCoordinates.js

@@ -0,0 +1,124 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 getHierarchyKeyboardCoordinates_exports = {};
+__export(getHierarchyKeyboardCoordinates_exports, {
+  getHierarchyKeyboardCoordinates: () => getHierarchyKeyboardCoordinates
+});
+var React = __toESM(require("react"));
+var import_core = require("@dnd-kit/core");
+const directions = [import_core.KeyboardCode.Down, import_core.KeyboardCode.Right, import_core.KeyboardCode.Up, import_core.KeyboardCode.Left];
+const vertical = [import_core.KeyboardCode.Up, import_core.KeyboardCode.Down];
+const getHorizontalKeyboardCoordinates = ({
+  items,
+  active,
+  over,
+  event,
+  currentCoordinates,
+  droppableContainers,
+  collisionRect
+}) => {
+  if (vertical.includes(event.code) || !active || !over)
+    return void 0;
+  const activeItem = items.find((item) => item.id === active.id);
+  const overRect = over.rect;
+  const layoutRects = [];
+  droppableContainers.forEach((container) => {
+    if (container?.disabled || !overRect) {
+      return;
+    }
+    const node = container?.node.current;
+    if (!node) {
+      return;
+    }
+    const itemParent = items.find((item) => item.id === container.id)?.parentId;
+    if (itemParent !== activeItem?.parentId)
+      return;
+    const rect = (0, import_core.getViewRect)(node);
+    if (event.code === import_core.KeyboardCode.Left && collisionRect.left > rect.right - 10) {
+      layoutRects.push(container);
+    } else if (event.code === import_core.KeyboardCode.Right && collisionRect.left < rect.left) {
+      layoutRects.push(container);
+    }
+  });
+  const closestId = (0, import_core.closestCorners)({ droppableContainers: layoutRects, collisionRect, active });
+  if (!closestId)
+    return void 0;
+  const closestDroppableContainer = droppableContainers.get(closestId)?.node?.current;
+  const activeDroppableContainer = droppableContainers.get(active?.id)?.node?.current;
+  if (!closestDroppableContainer || !activeDroppableContainer)
+    return void 0;
+  const closestRect = (0, import_core.getViewRect)(closestDroppableContainer);
+  const activeRect = (0, import_core.getViewRect)(activeDroppableContainer);
+  return __spreadProps(__spreadValues({}, currentCoordinates), {
+    x: closestRect.left + (closestRect.width - collisionRect.width) / 2 + (closestRect.offsetLeft < activeRect.left ? -1 : 1)
+  });
+};
+const getHierarchyKeyboardCoordinates = (context, dragOverlayDataTestid, isHorizontalDnD) => (event, { currentCoordinates, context: { active, over, collisionRect, droppableContainers } }) => {
+  if (directions.includes(event.code)) {
+    event.preventDefault();
+    if (!collisionRect) {
+      return void 0;
+    }
+    const {
+      current: { items }
+    } = context;
+    const args = {
+      dragOverlayDataTestid,
+      items,
+      active,
+      over,
+      event,
+      currentCoordinates,
+      droppableContainers,
+      collisionRect
+    };
+    if (isHorizontalDnD)
+      return getHorizontalKeyboardCoordinates(args);
+    return void 0;
+  }
+  return void 0;
+};
+module.exports = __toCommonJS(getHierarchyKeyboardCoordinates_exports);
+//# sourceMappingURL=getHierarchyKeyboardCoordinates.js.map

package/dist/cjs/hierarchy/getHierarchyKeyboardCoordinates.js.map

@@ -0,0 +1,7 @@
+{
+  "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,iCACF,qBADE;AAAA,IAEL,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/dist/cjs/hierarchy/index.js

@@ -0,0 +1,28 @@
+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 __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 hierarchy_exports = {};
+var React = __toESM(require("react"));
+__reExport(hierarchy_exports, require("./useHierarchyDndkitConfig"));
+module.exports = __toCommonJS(hierarchy_exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/hierarchy/index.js.map

@@ -0,0 +1,7 @@
+{
+  "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/dist/cjs/hierarchy/types.js

@@ -0,0 +1,27 @@
+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 __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 types_exports = {};
+var React = __toESM(require("react"));
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/cjs/hierarchy/types.js.map

@@ -0,0 +1,7 @@
+{
+  "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/dist/cjs/hierarchy/useHierarchyActionHandlers.js

@@ -0,0 +1,68 @@
+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 useHierarchyActionHandlers_exports = {};
+__export(useHierarchyActionHandlers_exports, {
+  useHierarchyActionHandlers: () => useHierarchyActionHandlers
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useHierarchyActionHandlers = ({
+  handlePreviewDragStart,
+  handlePreviewDragMove,
+  handlePreviewDragEnd,
+  handlePreviewDragCancel,
+  onReorder,
+  dndItems
+}) => {
+  const onDragStart = (0, import_react.useCallback)((e) => {
+    handlePreviewDragStart(e);
+  }, [handlePreviewDragStart]);
+  const onDragMove = (0, import_react.useCallback)((e) => {
+    handlePreviewDragMove(e);
+  }, [handlePreviewDragMove]);
+  const onDragEnd = (0, import_react.useCallback)((e) => {
+    handlePreviewDragEnd(e);
+    const { active, over } = e;
+    if (!over)
+      return;
+    if (active.id !== over.id) {
+      const activeIndex = dndItems.findIndex((item) => item.id === active.id);
+      const overIndex = dndItems.findIndex((item) => item.id === over.id);
+      onReorder(dndItems[activeIndex], {
+        targetIndex: overIndex,
+        fromIndex: activeIndex
+      });
+    }
+  }, [handlePreviewDragEnd, dndItems, onReorder]);
+  const onDragCancel = (0, import_react.useCallback)((e) => {
+    handlePreviewDragCancel(e);
+  }, [handlePreviewDragCancel]);
+  return { onDragStart, onDragMove, onDragEnd, onDragCancel };
+};
+module.exports = __toCommonJS(useHierarchyActionHandlers_exports);
+//# sourceMappingURL=useHierarchyActionHandlers.js.map

package/dist/cjs/hierarchy/useHierarchyActionHandlers.js.map

@@ -0,0 +1,7 @@
+{
+  "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/dist/cjs/hierarchy/useHierarchyAnnouncements.js

@@ -0,0 +1,55 @@
+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 useHierarchyAnnouncements_exports = {};
+__export(useHierarchyAnnouncements_exports, {
+  useHierarchyAnnouncements: () => useHierarchyAnnouncements
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useHierarchyAnnouncements = (visibleItemsDictionary) => {
+  const onDragStart = (0, import_react.useCallback)((id) => `Picked up draggable item from position ${visibleItemsDictionary[id].index + 1}.`, [visibleItemsDictionary]);
+  const onDragMove = (0, import_react.useCallback)((id, overId) => {
+    if (overId) {
+      const overIndex = visibleItemsDictionary[overId].index + 1;
+      return `Draggable item was moved to position ${overIndex}.`;
+    }
+    return `Draggable item is no longer over a droppable area.`;
+  }, [visibleItemsDictionary]);
+  const onDragOver = onDragMove;
+  const onDragEnd = (0, import_react.useCallback)((id, overId) => {
+    if (overId) {
+      const overIndex = visibleItemsDictionary[overId].index + 1;
+      return `Draggable item was dropped over position ${overIndex}.`;
+    }
+    return `Draggable item was dropped at it's original position.`;
+  }, [visibleItemsDictionary]);
+  const onDragCancel = (0, import_react.useCallback)((id) => `Dragging was cancelled. Draggable item from position ${visibleItemsDictionary[id].index + 1} was dropped at it's initial position.`, [visibleItemsDictionary]);
+  return { onDragStart, onDragOver, onDragMove, onDragEnd, onDragCancel };
+};
+module.exports = __toCommonJS(useHierarchyAnnouncements_exports);
+//# sourceMappingURL=useHierarchyAnnouncements.js.map

package/dist/cjs/hierarchy/useHierarchyAnnouncements.js.map

@@ -0,0 +1,7 @@
+{
+  "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/dist/cjs/hierarchy/useHierarchyDndkitConfig.js

@@ -0,0 +1,126 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 useHierarchyDndkitConfig_exports = {};
+__export(useHierarchyDndkitConfig_exports, {
+  useHierarchyDndkitConfig: () => useHierarchyDndkitConfig
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_core = require("@dnd-kit/core");
+var import_useHierarchyActionHandlers = require("./useHierarchyActionHandlers");
+var import_useHierarchyPreviewHandlers = require("./useHierarchyPreviewHandlers");
+var import_getHierarchyKeyboardCoordinates = require("./getHierarchyKeyboardCoordinates");
+var import_customCollisionDetection = require("./customCollisionDetection");
+var import_useHierarchyAnnouncements = require("./useHierarchyAnnouncements");
+const adjustTranslate = (isHorizontalDnD) => ({ transform }) => {
+  const newTransform = __spreadValues({}, transform);
+  if (isHorizontalDnD) {
+    newTransform.y = transform.y + 15;
+  } else {
+    newTransform.y = transform.y - 35;
+  }
+  return newTransform;
+};
+const measuring = {
+  droppable: {
+    strategy: import_core.MeasuringStrategy.Always
+  }
+};
+const noop = () => null;
+const useHierarchyDndkitConfig = ({
+  flattenedItems,
+  dragOverlayDataTestid,
+  isHorizontalDnD = false,
+  onReorder,
+  onPreviewResetState = noop,
+  onPreviewDragStart = noop
+}) => {
+  const [activeId, setActiveId] = (0, import_react.useState)("");
+  const dndItems = (0, import_react.useMemo)(() => flattenedItems.map(([item]) => item), [flattenedItems]);
+  const itemsDictionary = (0, import_react.useMemo)(() => {
+    const dictionary = {};
+    dndItems.forEach((item) => {
+      dictionary[item.id] = item;
+    });
+    return dictionary;
+  }, [dndItems]);
+  const modifiers = (0, import_react.useMemo)(() => [adjustTranslate(isHorizontalDnD)], [isHorizontalDnD]);
+  const sensorContext = (0, import_react.useRef)({
+    items: dndItems
+  });
+  (0, import_react.useEffect)(() => {
+    sensorContext.current = {
+      items: dndItems
+    };
+  }, [dndItems]);
+  const coordinateGetter = (0, import_react.useMemo)(() => (0, import_getHierarchyKeyboardCoordinates.getHierarchyKeyboardCoordinates)(sensorContext, dragOverlayDataTestid, isHorizontalDnD), [isHorizontalDnD]);
+  const sensors = (0, import_core.useSensors)((0, import_core.useSensor)(import_core.PointerSensor), (0, import_core.useSensor)(import_core.KeyboardSensor, {
+    coordinateGetter
+  }));
+  const dragPreviewHandlers = (0, import_useHierarchyPreviewHandlers.useHierarchyPreviewHandlers)({
+    setActiveId,
+    onPreviewResetState,
+    onPreviewDragStart
+  });
+  const dragActionHandlers = (0, import_useHierarchyActionHandlers.useHierarchyActionHandlers)(__spreadProps(__spreadValues({}, dragPreviewHandlers), {
+    dndItems,
+    onReorder
+  }));
+  const announcements = (0, import_useHierarchyAnnouncements.useHierarchyAnnouncements)(itemsDictionary);
+  const dndContextProps = (0, import_react.useMemo)(() => __spreadValues({
+    announcements,
+    modifiers,
+    sensors,
+    measuring,
+    collisionDetection: (0, import_customCollisionDetection.customCollisionDetection)(activeId, itemsDictionary[activeId ?? ""]?.parentId, dndItems)
+  }, dragActionHandlers), [announcements, modifiers, sensors, activeId, itemsDictionary, dndItems, dragActionHandlers]);
+  return {
+    dndContextProps,
+    activeId,
+    activeIndex: activeId ? itemsDictionary[activeId]?.index : -1
+  };
+};
+module.exports = __toCommonJS(useHierarchyDndkitConfig_exports);
+//# sourceMappingURL=useHierarchyDndkitConfig.js.map

package/dist/cjs/hierarchy/useHierarchyDndkitConfig.js.map

@@ -0,0 +1,7 @@
+{
+  "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,mBAChB;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,iCACjD,sBADiD;AAAA,IAEpD;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,KAC/F,qBAEL,CAAC,eAAe,WAAW,SAAS,UAAU,iBAAiB,UAAU;AAG3E,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,aAAa,WAAW,gBAAgB,WAAW,QAAQ;AAAA;AAAA;",
+  "names": []
+}