@qwik.dev/devtools 0.1.0 → 0.1.2

package/dist/ui/node_modules/.pnpm/react-complex-tree@2.4.6_react@18.2.0/node_modules/react-complex-tree/lib/esm/drag/DragAndDropProvider.qwik.cjs

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../../../../_virtual/index.qwik2.cjs");
+const ControlledTreeEnvironment = require("../controlledEnvironment/ControlledTreeEnvironment.qwik.cjs");
+const useCanDropAt = require("./useCanDropAt.qwik.cjs");
+const useGetViableDragPositions = require("./useGetViableDragPositions.qwik.cjs");
+const useSideEffect = require("../useSideEffect.qwik.cjs");
+const utils = require("../utils.qwik.cjs");
+const useCallSoon = require("../useCallSoon.qwik.cjs");
+const useStableHandler = require("../useStableHandler.qwik.cjs");
+const useGetOriginalItemOrder = require("../useGetOriginalItemOrder.qwik.cjs");
+const useDraggingPosition = require("./useDraggingPosition.qwik.cjs");
+const layoutUtils = require("../controlledEnvironment/layoutUtils.qwik.cjs");
+var DragAndDropContext = index.reactExports.createContext(null);
+var useDragAndDrop = function() {
+  return index.reactExports.useContext(DragAndDropContext);
+};
+var DragAndDropProvider = function(_a) {
+  var children = _a.children;
+  var environment = ControlledTreeEnvironment.useTreeEnvironment();
+  var _b = index.reactExports.useState(false), isProgrammaticallyDragging = _b[0], setIsProgrammaticallyDragging = _b[1];
+  var _c = index.reactExports.useState({}), viableDragPositions = _c[0], setViableDragPositions = _c[1];
+  var _d = index.reactExports.useState(0), programmaticDragIndex = _d[0], setProgrammaticDragIndex = _d[1];
+  var _e = index.reactExports.useState(), draggingPosition = _e[0], setDraggingPosition = _e[1];
+  var getViableDragPositions = useGetViableDragPositions.useGetViableDragPositions();
+  var callSoon = useCallSoon.useCallSoon();
+  var getOriginalItemOrder = useGetOriginalItemOrder.useGetOriginalItemOrder();
+  var _f = useDraggingPosition.useDraggingPosition(), initiateDraggingPosition = _f.initiateDraggingPosition, resetDraggingPosition = _f.resetDraggingPosition, draggingItems = _f.draggingItems, getDraggingPosition = _f.getDraggingPosition, itemHeight = _f.itemHeight;
+  var resetProgrammaticDragIndexForCurrentTree = index.reactExports.useCallback(function(viableDragPositions2, draggingItems2) {
+    var _a2;
+    if (environment.activeTreeId && ((_a2 = environment.viewState[environment.activeTreeId]) === null || _a2 === void 0 ? void 0 : _a2.focusedItem) && environment.linearItems && draggingItems2) {
+      var focusItem_1 = environment.viewState[environment.activeTreeId].focusedItem;
+      var treeDragPositions = getViableDragPositions(environment.activeTreeId, draggingItems2);
+      var newPos = treeDragPositions.findIndex(function(pos) {
+        if (pos.targetType === "item") {
+          return pos.targetItem === focusItem_1;
+        }
+        if (pos.targetType === "between-items") {
+          return environment.items[pos.parentItem].children[pos.childIndex] === focusItem_1;
+        }
+        return false;
+      });
+      if (newPos) {
+        setProgrammaticDragIndex(Math.min(newPos + 1, treeDragPositions.length - 1));
+      } else {
+        setProgrammaticDragIndex(0);
+      }
+    } else {
+      setProgrammaticDragIndex(0);
+    }
+  }, [
+    environment.activeTreeId,
+    environment.items,
+    environment.linearItems,
+    environment.viewState,
+    getViableDragPositions
+  ]);
+  var resetState = useStableHandler.useStableHandler(function() {
+    setIsProgrammaticallyDragging(false);
+    setViableDragPositions({});
+    setProgrammaticDragIndex(0);
+    setDraggingPosition(void 0);
+    resetDraggingPosition();
+  });
+  useSideEffect.useSideEffect(function() {
+    if (environment.activeTreeId && environment.linearItems[environment.activeTreeId] && viableDragPositions[environment.activeTreeId]) {
+      resetProgrammaticDragIndexForCurrentTree(viableDragPositions[environment.activeTreeId], draggingItems);
+    }
+  }, [
+    draggingItems,
+    environment.activeTreeId,
+    environment.linearItems,
+    resetProgrammaticDragIndexForCurrentTree,
+    viableDragPositions
+  ], [environment.activeTreeId]);
+  useSideEffect.useSideEffect(function() {
+    if (isProgrammaticallyDragging && environment.activeTreeId) {
+      setDraggingPosition(viableDragPositions[environment.activeTreeId][programmaticDragIndex]);
+    }
+  }, [
+    programmaticDragIndex,
+    environment.activeTreeId,
+    isProgrammaticallyDragging,
+    viableDragPositions
+  ], [programmaticDragIndex, environment.activeTreeId]);
+  var canDropAt = useCanDropAt.useCanDropAt();
+  var performDrag = function(draggingPosition2) {
+    var _a2;
+    if (draggingItems && !canDropAt(draggingPosition2, draggingItems)) {
+      return;
+    }
+    setDraggingPosition(draggingPosition2);
+    environment.setActiveTree(draggingPosition2.treeId);
+    if (draggingItems && environment.activeTreeId !== draggingPosition2.treeId) {
+      (_a2 = environment.onSelectItems) === null || _a2 === void 0 ? void 0 : _a2.call(environment, draggingItems.map(function(item) {
+        return item.index;
+      }), draggingPosition2.treeId);
+    }
+  };
+  var onDragOverTreeHandler = useStableHandler.useStableHandler(function(e, treeId, containerRef) {
+    if (!draggingItems)
+      return;
+    var newDraggingPosition = getDraggingPosition(e, treeId, containerRef);
+    if (!newDraggingPosition)
+      return;
+    if (newDraggingPosition === "invalid") {
+      setDraggingPosition(void 0);
+      return;
+    }
+    performDrag(newDraggingPosition);
+  });
+  var onDragLeaveContainerHandler = useStableHandler.useStableHandler(function(e, containerRef) {
+    if (!containerRef.current)
+      return;
+    if (layoutUtils.isOutsideOfContainer(e, containerRef.current.getBoundingClientRect())) {
+      setDraggingPosition(void 0);
+    }
+  });
+  var onDropHandler = useStableHandler.useStableHandler(function() {
+    if (!draggingItems || !draggingPosition || !environment.onDrop) {
+      return;
+    }
+    environment.onDrop(draggingItems, draggingPosition);
+    callSoon(function() {
+      var _a2;
+      (_a2 = environment.onFocusItem) === null || _a2 === void 0 ? void 0 : _a2.call(environment, draggingItems[0], draggingPosition.treeId);
+      resetState();
+    });
+  });
+  var onStartDraggingItems = index.reactExports.useCallback(function(items, treeId) {
+    var treeViableDragPositions = utils.buildMapForTrees(environment.treeIds, function(treeId2) {
+      return getViableDragPositions(treeId2, items);
+    });
+    initiateDraggingPosition(treeId, items);
+    setViableDragPositions(treeViableDragPositions);
+    if (environment.activeTreeId) {
+      resetProgrammaticDragIndexForCurrentTree(treeViableDragPositions[environment.activeTreeId], items);
+    }
+  }, [
+    environment.activeTreeId,
+    environment.treeIds,
+    getViableDragPositions,
+    initiateDraggingPosition,
+    resetProgrammaticDragIndexForCurrentTree
+  ]);
+  var startProgrammaticDrag = index.reactExports.useCallback(function() {
+    var _a2, _b2, _c2;
+    if (!environment.canDragAndDrop) {
+      return;
+    }
+    if (environment.activeTreeId) {
+      var draggingItems_1 = (_b2 = (_a2 = environment.viewState[environment.activeTreeId]) === null || _a2 === void 0 ? void 0 : _a2.selectedItems) !== null && _b2 !== void 0 ? _b2 : [
+        (_c2 = environment.viewState[environment.activeTreeId]) === null || _c2 === void 0 ? void 0 : _c2.focusedItem
+      ];
+      if (draggingItems_1.length === 0 || draggingItems_1[0] === void 0) {
+        return;
+      }
+      var resolvedDraggingItems = getOriginalItemOrder(environment.activeTreeId, draggingItems_1.map(function(id) {
+        return environment.items[id];
+      }));
+      if (environment.canDrag && !environment.canDrag(resolvedDraggingItems)) {
+        return;
+      }
+      onStartDraggingItems(resolvedDraggingItems, environment.activeTreeId);
+      setTimeout(function() {
+        setIsProgrammaticallyDragging(true);
+      });
+    }
+  }, [environment, getOriginalItemOrder, onStartDraggingItems]);
+  var abortProgrammaticDrag = index.reactExports.useCallback(function() {
+    resetState();
+  }, [resetState]);
+  var completeProgrammaticDrag = index.reactExports.useCallback(function() {
+    onDropHandler();
+    resetState();
+  }, [onDropHandler, resetState]);
+  var programmaticDragUp = index.reactExports.useCallback(function() {
+    setProgrammaticDragIndex(function(oldIndex) {
+      return Math.max(0, oldIndex - 1);
+    });
+  }, []);
+  var programmaticDragDown = index.reactExports.useCallback(function() {
+    if (environment.activeTreeId) {
+      setProgrammaticDragIndex(function(oldIndex) {
+        return Math.min(viableDragPositions[environment.activeTreeId].length, oldIndex + 1);
+      });
+    }
+  }, [environment.activeTreeId, viableDragPositions]);
+  var dnd = index.reactExports.useMemo(function() {
+    return {
+      onStartDraggingItems,
+      startProgrammaticDrag,
+      abortProgrammaticDrag,
+      completeProgrammaticDrag,
+      programmaticDragUp,
+      programmaticDragDown,
+      draggingItems,
+      draggingPosition,
+      itemHeight: itemHeight.current,
+      isProgrammaticallyDragging,
+      onDragOverTreeHandler,
+      onDragLeaveContainerHandler,
+      viableDragPositions
+    };
+  }, [
+    abortProgrammaticDrag,
+    completeProgrammaticDrag,
+    draggingItems,
+    draggingPosition,
+    isProgrammaticallyDragging,
+    itemHeight,
+    onDragOverTreeHandler,
+    onDragLeaveContainerHandler,
+    onStartDraggingItems,
+    programmaticDragDown,
+    programmaticDragUp,
+    startProgrammaticDrag,
+    viableDragPositions
+  ]);
+  index.reactExports.useEffect(function() {
+    window.addEventListener("dragend", resetState);
+    window.addEventListener("drop", onDropHandler);
+    return function() {
+      window.removeEventListener("dragend", resetState);
+      window.removeEventListener("drop", onDropHandler);
+    };
+  }, [onDropHandler, resetState]);
+  return index.reactExports.createElement(DragAndDropContext.Provider, { value: dnd }, children);
+};
+exports.DragAndDropProvider = DragAndDropProvider;
+exports.useDragAndDrop = useDragAndDrop;

package/dist/ui/node_modules/.pnpm/react-complex-tree@2.4.6_react@18.2.0/node_modules/react-complex-tree/lib/esm/drag/DragAndDropProvider.qwik.mjs

@@ -0,0 +1,231 @@
+import { r as reactExports } from "../../../../../../../../_virtual/index.qwik2.mjs";
+import { useTreeEnvironment } from "../controlledEnvironment/ControlledTreeEnvironment.qwik.mjs";
+import { useCanDropAt } from "./useCanDropAt.qwik.mjs";
+import { useGetViableDragPositions } from "./useGetViableDragPositions.qwik.mjs";
+import { useSideEffect } from "../useSideEffect.qwik.mjs";
+import { buildMapForTrees } from "../utils.qwik.mjs";
+import { useCallSoon } from "../useCallSoon.qwik.mjs";
+import { useStableHandler } from "../useStableHandler.qwik.mjs";
+import { useGetOriginalItemOrder } from "../useGetOriginalItemOrder.qwik.mjs";
+import { useDraggingPosition } from "./useDraggingPosition.qwik.mjs";
+import { isOutsideOfContainer } from "../controlledEnvironment/layoutUtils.qwik.mjs";
+var DragAndDropContext = reactExports.createContext(null);
+var useDragAndDrop = function() {
+  return reactExports.useContext(DragAndDropContext);
+};
+var DragAndDropProvider = function(_a) {
+  var children = _a.children;
+  var environment = useTreeEnvironment();
+  var _b = reactExports.useState(false), isProgrammaticallyDragging = _b[0], setIsProgrammaticallyDragging = _b[1];
+  var _c = reactExports.useState({}), viableDragPositions = _c[0], setViableDragPositions = _c[1];
+  var _d = reactExports.useState(0), programmaticDragIndex = _d[0], setProgrammaticDragIndex = _d[1];
+  var _e = reactExports.useState(), draggingPosition = _e[0], setDraggingPosition = _e[1];
+  var getViableDragPositions = useGetViableDragPositions();
+  var callSoon = useCallSoon();
+  var getOriginalItemOrder = useGetOriginalItemOrder();
+  var _f = useDraggingPosition(), initiateDraggingPosition = _f.initiateDraggingPosition, resetDraggingPosition = _f.resetDraggingPosition, draggingItems = _f.draggingItems, getDraggingPosition = _f.getDraggingPosition, itemHeight = _f.itemHeight;
+  var resetProgrammaticDragIndexForCurrentTree = reactExports.useCallback(function(viableDragPositions2, draggingItems2) {
+    var _a2;
+    if (environment.activeTreeId && ((_a2 = environment.viewState[environment.activeTreeId]) === null || _a2 === void 0 ? void 0 : _a2.focusedItem) && environment.linearItems && draggingItems2) {
+      var focusItem_1 = environment.viewState[environment.activeTreeId].focusedItem;
+      var treeDragPositions = getViableDragPositions(environment.activeTreeId, draggingItems2);
+      var newPos = treeDragPositions.findIndex(function(pos) {
+        if (pos.targetType === "item") {
+          return pos.targetItem === focusItem_1;
+        }
+        if (pos.targetType === "between-items") {
+          return environment.items[pos.parentItem].children[pos.childIndex] === focusItem_1;
+        }
+        return false;
+      });
+      if (newPos) {
+        setProgrammaticDragIndex(Math.min(newPos + 1, treeDragPositions.length - 1));
+      } else {
+        setProgrammaticDragIndex(0);
+      }
+    } else {
+      setProgrammaticDragIndex(0);
+    }
+  }, [
+    environment.activeTreeId,
+    environment.items,
+    environment.linearItems,
+    environment.viewState,
+    getViableDragPositions
+  ]);
+  var resetState = useStableHandler(function() {
+    setIsProgrammaticallyDragging(false);
+    setViableDragPositions({});
+    setProgrammaticDragIndex(0);
+    setDraggingPosition(void 0);
+    resetDraggingPosition();
+  });
+  useSideEffect(function() {
+    if (environment.activeTreeId && environment.linearItems[environment.activeTreeId] && viableDragPositions[environment.activeTreeId]) {
+      resetProgrammaticDragIndexForCurrentTree(viableDragPositions[environment.activeTreeId], draggingItems);
+    }
+  }, [
+    draggingItems,
+    environment.activeTreeId,
+    environment.linearItems,
+    resetProgrammaticDragIndexForCurrentTree,
+    viableDragPositions
+  ], [environment.activeTreeId]);
+  useSideEffect(function() {
+    if (isProgrammaticallyDragging && environment.activeTreeId) {
+      setDraggingPosition(viableDragPositions[environment.activeTreeId][programmaticDragIndex]);
+    }
+  }, [
+    programmaticDragIndex,
+    environment.activeTreeId,
+    isProgrammaticallyDragging,
+    viableDragPositions
+  ], [programmaticDragIndex, environment.activeTreeId]);
+  var canDropAt = useCanDropAt();
+  var performDrag = function(draggingPosition2) {
+    var _a2;
+    if (draggingItems && !canDropAt(draggingPosition2, draggingItems)) {
+      return;
+    }
+    setDraggingPosition(draggingPosition2);
+    environment.setActiveTree(draggingPosition2.treeId);
+    if (draggingItems && environment.activeTreeId !== draggingPosition2.treeId) {
+      (_a2 = environment.onSelectItems) === null || _a2 === void 0 ? void 0 : _a2.call(environment, draggingItems.map(function(item) {
+        return item.index;
+      }), draggingPosition2.treeId);
+    }
+  };
+  var onDragOverTreeHandler = useStableHandler(function(e, treeId, containerRef) {
+    if (!draggingItems)
+      return;
+    var newDraggingPosition = getDraggingPosition(e, treeId, containerRef);
+    if (!newDraggingPosition)
+      return;
+    if (newDraggingPosition === "invalid") {
+      setDraggingPosition(void 0);
+      return;
+    }
+    performDrag(newDraggingPosition);
+  });
+  var onDragLeaveContainerHandler = useStableHandler(function(e, containerRef) {
+    if (!containerRef.current)
+      return;
+    if (isOutsideOfContainer(e, containerRef.current.getBoundingClientRect())) {
+      setDraggingPosition(void 0);
+    }
+  });
+  var onDropHandler = useStableHandler(function() {
+    if (!draggingItems || !draggingPosition || !environment.onDrop) {
+      return;
+    }
+    environment.onDrop(draggingItems, draggingPosition);
+    callSoon(function() {
+      var _a2;
+      (_a2 = environment.onFocusItem) === null || _a2 === void 0 ? void 0 : _a2.call(environment, draggingItems[0], draggingPosition.treeId);
+      resetState();
+    });
+  });
+  var onStartDraggingItems = reactExports.useCallback(function(items, treeId) {
+    var treeViableDragPositions = buildMapForTrees(environment.treeIds, function(treeId2) {
+      return getViableDragPositions(treeId2, items);
+    });
+    initiateDraggingPosition(treeId, items);
+    setViableDragPositions(treeViableDragPositions);
+    if (environment.activeTreeId) {
+      resetProgrammaticDragIndexForCurrentTree(treeViableDragPositions[environment.activeTreeId], items);
+    }
+  }, [
+    environment.activeTreeId,
+    environment.treeIds,
+    getViableDragPositions,
+    initiateDraggingPosition,
+    resetProgrammaticDragIndexForCurrentTree
+  ]);
+  var startProgrammaticDrag = reactExports.useCallback(function() {
+    var _a2, _b2, _c2;
+    if (!environment.canDragAndDrop) {
+      return;
+    }
+    if (environment.activeTreeId) {
+      var draggingItems_1 = (_b2 = (_a2 = environment.viewState[environment.activeTreeId]) === null || _a2 === void 0 ? void 0 : _a2.selectedItems) !== null && _b2 !== void 0 ? _b2 : [
+        (_c2 = environment.viewState[environment.activeTreeId]) === null || _c2 === void 0 ? void 0 : _c2.focusedItem
+      ];
+      if (draggingItems_1.length === 0 || draggingItems_1[0] === void 0) {
+        return;
+      }
+      var resolvedDraggingItems = getOriginalItemOrder(environment.activeTreeId, draggingItems_1.map(function(id) {
+        return environment.items[id];
+      }));
+      if (environment.canDrag && !environment.canDrag(resolvedDraggingItems)) {
+        return;
+      }
+      onStartDraggingItems(resolvedDraggingItems, environment.activeTreeId);
+      setTimeout(function() {
+        setIsProgrammaticallyDragging(true);
+      });
+    }
+  }, [environment, getOriginalItemOrder, onStartDraggingItems]);
+  var abortProgrammaticDrag = reactExports.useCallback(function() {
+    resetState();
+  }, [resetState]);
+  var completeProgrammaticDrag = reactExports.useCallback(function() {
+    onDropHandler();
+    resetState();
+  }, [onDropHandler, resetState]);
+  var programmaticDragUp = reactExports.useCallback(function() {
+    setProgrammaticDragIndex(function(oldIndex) {
+      return Math.max(0, oldIndex - 1);
+    });
+  }, []);
+  var programmaticDragDown = reactExports.useCallback(function() {
+    if (environment.activeTreeId) {
+      setProgrammaticDragIndex(function(oldIndex) {
+        return Math.min(viableDragPositions[environment.activeTreeId].length, oldIndex + 1);
+      });
+    }
+  }, [environment.activeTreeId, viableDragPositions]);
+  var dnd = reactExports.useMemo(function() {
+    return {
+      onStartDraggingItems,
+      startProgrammaticDrag,
+      abortProgrammaticDrag,
+      completeProgrammaticDrag,
+      programmaticDragUp,
+      programmaticDragDown,
+      draggingItems,
+      draggingPosition,
+      itemHeight: itemHeight.current,
+      isProgrammaticallyDragging,
+      onDragOverTreeHandler,
+      onDragLeaveContainerHandler,
+      viableDragPositions
+    };
+  }, [
+    abortProgrammaticDrag,
+    completeProgrammaticDrag,
+    draggingItems,
+    draggingPosition,
+    isProgrammaticallyDragging,
+    itemHeight,
+    onDragOverTreeHandler,
+    onDragLeaveContainerHandler,
+    onStartDraggingItems,
+    programmaticDragDown,
+    programmaticDragUp,
+    startProgrammaticDrag,
+    viableDragPositions
+  ]);
+  reactExports.useEffect(function() {
+    window.addEventListener("dragend", resetState);
+    window.addEventListener("drop", onDropHandler);
+    return function() {
+      window.removeEventListener("dragend", resetState);
+      window.removeEventListener("drop", onDropHandler);
+    };
+  }, [onDropHandler, resetState]);
+  return reactExports.createElement(DragAndDropContext.Provider, { value: dnd }, children);
+};
+export {
+  DragAndDropProvider,
+  useDragAndDrop
+};

package/dist/ui/node_modules/.pnpm/react-complex-tree@2.4.6_react@18.2.0/node_modules/react-complex-tree/lib/esm/drag/DraggingPositionEvaluation.qwik.cjs

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var DraggingPositionEvaluation = (
+  /** @class */
+  function() {
+    function DraggingPositionEvaluation2(env, e, treeId, hoveringPosition, draggingItems, getParentOfLinearItem) {
+      this.env = env;
+      this.e = e;
+      this.treeId = treeId;
+      this.linearIndex = hoveringPosition.linearIndex;
+      this.offset = hoveringPosition.offset;
+      this.indentation = hoveringPosition.indentation;
+      this.targetItem = this.env.linearItems[this.treeId][this.linearIndex];
+      this.getParentOfLinearItem = getParentOfLinearItem;
+      this.draggingItems = draggingItems;
+    }
+    DraggingPositionEvaluation2.prototype.getEmptyTreeDragPosition = function() {
+      return {
+        targetType: "root",
+        treeId: this.treeId,
+        depth: 0,
+        linearIndex: 0,
+        targetItem: this.env.trees[this.treeId].rootItem
+      };
+    };
+    DraggingPositionEvaluation2.prototype.maybeRedirectToParent = function() {
+      var redirectTargetToParent = !this.env.canReorderItems && !this.env.canDropOnNonFolder && !this.env.items[this.targetItem.item].isFolder;
+      if (redirectTargetToParent) {
+        var _a = this.getParentOfLinearItem(this.linearIndex, this.treeId), parentLinearIndex = _a.parentLinearIndex, parent_1 = _a.parent;
+        this.targetItem = parent_1;
+        this.linearIndex = parentLinearIndex;
+      }
+    };
+    DraggingPositionEvaluation2.prototype.maybeReparentUpwards = function() {
+      var _a, _b;
+      if (this.indentation === void 0) {
+        return void 0;
+      }
+      var treeLinearItems = this.env.linearItems[this.treeId];
+      var deepestDepth = treeLinearItems[this.linearIndex].depth;
+      var legalDropDepthCount = (
+        // itemDepthDifferenceToNextItem/isLastInGroup
+        deepestDepth - ((_b = (_a = treeLinearItems[this.linearIndex + 1]) === null || _a === void 0 ? void 0 : _a.depth) !== null && _b !== void 0 ? _b : 0)
+      );
+      var canReparentUpwards = this.offset === "bottom" && legalDropDepthCount > 0;
+      if (!canReparentUpwards) {
+        return void 0;
+      }
+      var droppingIndent = Math.max(deepestDepth - legalDropDepthCount, this.indentation);
+      var newParent = {
+        parentLinearIndex: this.linearIndex,
+        parent: this.targetItem
+      };
+      var insertionItemAbove;
+      for (var i = deepestDepth; i >= droppingIndent; i -= 1) {
+        insertionItemAbove = newParent;
+        newParent = this.getParentOfLinearItem(newParent.parentLinearIndex, this.treeId);
+      }
+      if (this.indentation === treeLinearItems[this.linearIndex].depth) {
+        return void 0;
+      }
+      if (!insertionItemAbove) {
+        return void 0;
+      }
+      var reparentedChildIndex = this.env.items[newParent.parent.item].children.indexOf(insertionItemAbove.parent.item) + 1;
+      if (this.draggingItems && this.isDescendant(this.treeId, newParent.parentLinearIndex + 1, this.draggingItems)) {
+        return void 0;
+      }
+      return {
+        targetType: "between-items",
+        treeId: this.treeId,
+        parentItem: newParent.parent.item,
+        depth: droppingIndent,
+        linearIndex: this.linearIndex + 1,
+        childIndex: reparentedChildIndex,
+        linePosition: "bottom"
+      };
+    };
+    DraggingPositionEvaluation2.prototype.maybeRedirectInsideOpenFolder = function() {
+      var nextItem = this.env.linearItems[this.treeId][this.linearIndex + 1];
+      var redirectInsideOpenFolder = !this.env.canDropBelowOpenFolders && nextItem && this.targetItem.depth === nextItem.depth - 1 && this.offset === "bottom";
+      if (redirectInsideOpenFolder) {
+        this.targetItem = nextItem;
+        this.linearIndex += 1;
+        this.offset = "top";
+      }
+    };
+    DraggingPositionEvaluation2.prototype.maybeMapToBottomOffset = function() {
+      var priorItem = this.env.linearItems[this.treeId][this.linearIndex - 1];
+      if (!priorItem || (priorItem === null || priorItem === void 0 ? void 0 : priorItem.depth) === void 0)
+        return;
+      var depthDistanceToPrior = priorItem.depth - this.targetItem.depth;
+      if (this.offset === "top" && (depthDistanceToPrior === 0 || depthDistanceToPrior > 0 && this.indentation !== void 0)) {
+        this.offset = "bottom";
+        this.linearIndex -= 1;
+        this.targetItem = this.env.linearItems[this.treeId][this.linearIndex];
+      }
+    };
+    DraggingPositionEvaluation2.prototype.canDropAtCurrentTarget = function() {
+      var _this = this;
+      var _a;
+      var targetItemData = this.env.items[this.targetItem.item];
+      if (!this.offset && !this.env.canDropOnNonFolder && !targetItemData.isFolder) {
+        return false;
+      }
+      if (!this.offset && !this.env.canDropOnFolder && targetItemData.isFolder) {
+        return false;
+      }
+      if (this.offset && !this.env.canReorderItems) {
+        return false;
+      }
+      if ((_a = this.draggingItems) === null || _a === void 0 ? void 0 : _a.some(function(draggingItem) {
+        return draggingItem.index === _this.targetItem.item;
+      })) {
+        return false;
+      }
+      return true;
+    };
+    DraggingPositionEvaluation2.prototype.getDraggingPosition = function() {
+      if (this.env.linearItems[this.treeId].length === 0) {
+        return this.getEmptyTreeDragPosition();
+      }
+      if (!this.draggingItems || this.linearIndex < 0 || this.linearIndex >= this.env.linearItems[this.treeId].length) {
+        return void 0;
+      }
+      this.maybeRedirectToParent();
+      this.maybeRedirectInsideOpenFolder();
+      this.maybeMapToBottomOffset();
+      var reparented = this.maybeReparentUpwards();
+      if (reparented) {
+        return reparented;
+      }
+      if (this.areDraggingItemsDescendantOfTarget()) {
+        return "invalid";
+      }
+      if (!this.canDropAtCurrentTarget()) {
+        return "invalid";
+      }
+      var parent = this.getParentOfLinearItem(this.linearIndex, this.treeId).parent;
+      var newChildIndex = this.env.items[parent.item].children.indexOf(this.targetItem.item) + (this.offset === "top" ? 0 : 1);
+      if (this.offset) {
+        return {
+          targetType: "between-items",
+          treeId: this.treeId,
+          parentItem: parent.item,
+          depth: this.targetItem.depth,
+          linearIndex: this.linearIndex + (this.offset === "top" ? 0 : 1),
+          childIndex: newChildIndex,
+          linePosition: this.offset
+        };
+      }
+      return {
+        targetType: "item",
+        treeId: this.treeId,
+        parentItem: parent.item,
+        targetItem: this.targetItem.item,
+        depth: this.targetItem.depth,
+        linearIndex: this.linearIndex
+      };
+    };
+    DraggingPositionEvaluation2.prototype.isDescendant = function(treeId, itemLinearIndex, potentialParents) {
+      var _a = this.getParentOfLinearItem(itemLinearIndex, treeId), parentLinearIndex = _a.parentLinearIndex, parent = _a.parent;
+      if (potentialParents.some(function(p) {
+        return p.index === parent.item;
+      })) {
+        return true;
+      }
+      if (parent.depth === 0) {
+        return false;
+      }
+      return this.isDescendant(treeId, parentLinearIndex, potentialParents);
+    };
+    DraggingPositionEvaluation2.prototype.areDraggingItemsDescendantOfTarget = function() {
+      return this.draggingItems && this.isDescendant(this.treeId, this.linearIndex, this.draggingItems);
+    };
+    return DraggingPositionEvaluation2;
+  }()
+);
+exports.DraggingPositionEvaluation = DraggingPositionEvaluation;