@qwik.dev/devtools 0.1.1 → 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/DraggingPositionEvaluation.qwik.mjs

@@ -0,0 +1,179 @@
+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;
+  }()
+);
+export {
+  DraggingPositionEvaluation
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../../../../_virtual/index.qwik2.cjs");
+const ControlledTreeEnvironment = require("../controlledEnvironment/ControlledTreeEnvironment.qwik.cjs");
+var useCanDropAt = function() {
+  var environment = ControlledTreeEnvironment.useTreeEnvironment();
+  return index.reactExports.useCallback(function(draggingPosition, draggingItems) {
+    if (draggingPosition.targetType === "between-items") {
+      if (!environment.canReorderItems) {
+        return false;
+      }
+    } else if (draggingPosition.targetType === "root") {
+      if (!environment.canDropOnFolder) {
+        return false;
+      }
+    } else {
+      var resolvedItem = environment.items[draggingPosition.targetItem];
+      if (!resolvedItem || !environment.canDropOnFolder && resolvedItem.isFolder || !environment.canDropOnNonFolder && !resolvedItem.isFolder || draggingItems.some(function(draggingItem) {
+        return draggingItem.index === draggingPosition.targetItem;
+      })) {
+        return false;
+      }
+    }
+    if (environment.canDropAt && (!draggingItems || !environment.canDropAt(draggingItems, draggingPosition))) {
+      return false;
+    }
+    return true;
+  }, [environment]);
+};
+exports.useCanDropAt = useCanDropAt;

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

@@ -0,0 +1,30 @@
+import { r as reactExports } from "../../../../../../../../_virtual/index.qwik2.mjs";
+import { useTreeEnvironment } from "../controlledEnvironment/ControlledTreeEnvironment.qwik.mjs";
+var useCanDropAt = function() {
+  var environment = useTreeEnvironment();
+  return reactExports.useCallback(function(draggingPosition, draggingItems) {
+    if (draggingPosition.targetType === "between-items") {
+      if (!environment.canReorderItems) {
+        return false;
+      }
+    } else if (draggingPosition.targetType === "root") {
+      if (!environment.canDropOnFolder) {
+        return false;
+      }
+    } else {
+      var resolvedItem = environment.items[draggingPosition.targetItem];
+      if (!resolvedItem || !environment.canDropOnFolder && resolvedItem.isFolder || !environment.canDropOnNonFolder && !resolvedItem.isFolder || draggingItems.some(function(draggingItem) {
+        return draggingItem.index === draggingPosition.targetItem;
+      })) {
+        return false;
+      }
+    }
+    if (environment.canDropAt && (!draggingItems || !environment.canDropAt(draggingItems, draggingPosition))) {
+      return false;
+    }
+    return true;
+  }, [environment]);
+};
+export {
+  useCanDropAt
+};

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../../../../_virtual/index.qwik2.cjs");
+const layoutUtils = require("../controlledEnvironment/layoutUtils.qwik.cjs");
+const ControlledTreeEnvironment = require("../controlledEnvironment/ControlledTreeEnvironment.qwik.cjs");
+const useStableHandler = require("../useStableHandler.qwik.cjs");
+const DraggingPositionEvaluation = require("./DraggingPositionEvaluation.qwik.cjs");
+const useGetParentOfLinearItem = require("./useGetParentOfLinearItem.qwik.cjs");
+var useDraggingPosition = function() {
+  var dragCode = index.reactExports.useRef("initial");
+  var _a = index.reactExports.useState(void 0), draggingItems = _a[0], setDraggingItems = _a[1];
+  var itemHeight = index.reactExports.useRef(0);
+  var env = ControlledTreeEnvironment.useTreeEnvironment();
+  var getParentOfLinearItem = useGetParentOfLinearItem.useGetGetParentOfLinearItem();
+  var isNewDragPosition = useStableHandler.useStableHandler(function(e, treeId, hoveringPosition) {
+    if (!hoveringPosition) {
+      return false;
+    }
+    var offset = hoveringPosition.offset, linearIndex = hoveringPosition.linearIndex;
+    var newDragCode = "".concat(treeId, "__").concat(linearIndex, "__").concat(offset !== null && offset !== void 0 ? offset : "", "__").concat(hoveringPosition.indentation);
+    if (newDragCode !== dragCode.current) {
+      dragCode.current = newDragCode;
+      return true;
+    }
+    return false;
+  });
+  var getHoveringPosition = useStableHandler.useStableHandler(function(e, treeId, containerRef) {
+    if (!containerRef.current) {
+      return void 0;
+    }
+    var treeBb = containerRef.current.getBoundingClientRect();
+    if (layoutUtils.isOutsideOfContainer(e, treeBb)) {
+      return void 0;
+    }
+    var hoveringPosition = (e.clientY - treeBb.top) / itemHeight.current;
+    var treeLinearItems = env.linearItems[treeId];
+    var linearIndex = Math.min(Math.max(0, Math.floor(hoveringPosition)), treeLinearItems.length - 1);
+    if (treeLinearItems.length === 0) {
+      return {
+        linearIndex: 0,
+        offset: "bottom",
+        indentation: 0
+      };
+    }
+    var targetLinearItem = treeLinearItems[linearIndex];
+    var targetItem = env.items[targetLinearItem.item];
+    var indentation = !env.renderDepthOffset ? void 0 : Math.max(Math.floor((e.clientX - treeBb.left) / env.renderDepthOffset), 0);
+    var offset;
+    var lineThreshold = !env.canReorderItems ? 0 : (targetItem === null || targetItem === void 0 ? void 0 : targetItem.isFolder) && env.canDropOnFolder || env.canDropOnNonFolder ? 0.2 : 0.5;
+    if (hoveringPosition - 0.5 >= treeLinearItems.length - 1) {
+      offset = "bottom";
+    } else if (hoveringPosition % 1 < lineThreshold) {
+      offset = "top";
+    } else if (hoveringPosition % 1 > 1 - lineThreshold) {
+      offset = "bottom";
+    }
+    return { linearIndex, offset, indentation };
+  });
+  var getDraggingPosition = useStableHandler.useStableHandler(function(e, treeId, containerRef) {
+    var hoveringPosition = getHoveringPosition(e, treeId, containerRef);
+    if (!isNewDragPosition(e, treeId, hoveringPosition)) {
+      return void 0;
+    }
+    if (!draggingItems || !env.canDragAndDrop || !hoveringPosition || e.clientX < 0 || e.clientY < 0) {
+      return "invalid";
+    }
+    return new DraggingPositionEvaluation.DraggingPositionEvaluation(env, e, treeId, hoveringPosition, draggingItems, getParentOfLinearItem).getDraggingPosition();
+  });
+  var initiateDraggingPosition = useStableHandler.useStableHandler(function(treeId, items) {
+    setDraggingItems(items);
+    dragCode.current = "initial";
+    itemHeight.current = layoutUtils.computeItemHeight(treeId);
+  });
+  var resetDraggingPosition = useStableHandler.useStableHandler(function() {
+    setDraggingItems(void 0);
+    dragCode.current = "initial";
+    itemHeight.current = 0;
+  });
+  return {
+    initiateDraggingPosition,
+    resetDraggingPosition,
+    draggingItems,
+    getDraggingPosition,
+    itemHeight
+  };
+};
+exports.useDraggingPosition = useDraggingPosition;

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

@@ -0,0 +1,87 @@
+import { r as reactExports } from "../../../../../../../../_virtual/index.qwik2.mjs";
+import { computeItemHeight, isOutsideOfContainer } from "../controlledEnvironment/layoutUtils.qwik.mjs";
+import { useTreeEnvironment } from "../controlledEnvironment/ControlledTreeEnvironment.qwik.mjs";
+import { useStableHandler } from "../useStableHandler.qwik.mjs";
+import { DraggingPositionEvaluation } from "./DraggingPositionEvaluation.qwik.mjs";
+import { useGetGetParentOfLinearItem } from "./useGetParentOfLinearItem.qwik.mjs";
+var useDraggingPosition = function() {
+  var dragCode = reactExports.useRef("initial");
+  var _a = reactExports.useState(void 0), draggingItems = _a[0], setDraggingItems = _a[1];
+  var itemHeight = reactExports.useRef(0);
+  var env = useTreeEnvironment();
+  var getParentOfLinearItem = useGetGetParentOfLinearItem();
+  var isNewDragPosition = useStableHandler(function(e, treeId, hoveringPosition) {
+    if (!hoveringPosition) {
+      return false;
+    }
+    var offset = hoveringPosition.offset, linearIndex = hoveringPosition.linearIndex;
+    var newDragCode = "".concat(treeId, "__").concat(linearIndex, "__").concat(offset !== null && offset !== void 0 ? offset : "", "__").concat(hoveringPosition.indentation);
+    if (newDragCode !== dragCode.current) {
+      dragCode.current = newDragCode;
+      return true;
+    }
+    return false;
+  });
+  var getHoveringPosition = useStableHandler(function(e, treeId, containerRef) {
+    if (!containerRef.current) {
+      return void 0;
+    }
+    var treeBb = containerRef.current.getBoundingClientRect();
+    if (isOutsideOfContainer(e, treeBb)) {
+      return void 0;
+    }
+    var hoveringPosition = (e.clientY - treeBb.top) / itemHeight.current;
+    var treeLinearItems = env.linearItems[treeId];
+    var linearIndex = Math.min(Math.max(0, Math.floor(hoveringPosition)), treeLinearItems.length - 1);
+    if (treeLinearItems.length === 0) {
+      return {
+        linearIndex: 0,
+        offset: "bottom",
+        indentation: 0
+      };
+    }
+    var targetLinearItem = treeLinearItems[linearIndex];
+    var targetItem = env.items[targetLinearItem.item];
+    var indentation = !env.renderDepthOffset ? void 0 : Math.max(Math.floor((e.clientX - treeBb.left) / env.renderDepthOffset), 0);
+    var offset;
+    var lineThreshold = !env.canReorderItems ? 0 : (targetItem === null || targetItem === void 0 ? void 0 : targetItem.isFolder) && env.canDropOnFolder || env.canDropOnNonFolder ? 0.2 : 0.5;
+    if (hoveringPosition - 0.5 >= treeLinearItems.length - 1) {
+      offset = "bottom";
+    } else if (hoveringPosition % 1 < lineThreshold) {
+      offset = "top";
+    } else if (hoveringPosition % 1 > 1 - lineThreshold) {
+      offset = "bottom";
+    }
+    return { linearIndex, offset, indentation };
+  });
+  var getDraggingPosition = useStableHandler(function(e, treeId, containerRef) {
+    var hoveringPosition = getHoveringPosition(e, treeId, containerRef);
+    if (!isNewDragPosition(e, treeId, hoveringPosition)) {
+      return void 0;
+    }
+    if (!draggingItems || !env.canDragAndDrop || !hoveringPosition || e.clientX < 0 || e.clientY < 0) {
+      return "invalid";
+    }
+    return new DraggingPositionEvaluation(env, e, treeId, hoveringPosition, draggingItems, getParentOfLinearItem).getDraggingPosition();
+  });
+  var initiateDraggingPosition = useStableHandler(function(treeId, items) {
+    setDraggingItems(items);
+    dragCode.current = "initial";
+    itemHeight.current = computeItemHeight(treeId);
+  });
+  var resetDraggingPosition = useStableHandler(function() {
+    setDraggingItems(void 0);
+    dragCode.current = "initial";
+    itemHeight.current = 0;
+  });
+  return {
+    initiateDraggingPosition,
+    resetDraggingPosition,
+    draggingItems,
+    getDraggingPosition,
+    itemHeight
+  };
+};
+export {
+  useDraggingPosition
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../../../../_virtual/index.qwik2.cjs");
+const ControlledTreeEnvironment = require("../controlledEnvironment/ControlledTreeEnvironment.qwik.cjs");
+var useGetGetParentOfLinearItem = function() {
+  var environment = ControlledTreeEnvironment.useTreeEnvironment();
+  return index.reactExports.useCallback(function(itemLinearIndex, treeId) {
+    var linearItems = environment.linearItems[treeId];
+    var depth = linearItems[itemLinearIndex].depth;
+    var parentLinearIndex = itemLinearIndex;
+    for (; !!linearItems[parentLinearIndex] && linearItems[parentLinearIndex].depth !== depth - 1; parentLinearIndex -= 1)
+      ;
+    var parent = linearItems[parentLinearIndex];
+    if (!parent) {
+      parent = { item: environment.trees[treeId].rootItem, depth: 0 };
+      parentLinearIndex = 0;
+    }
+    return { parent, parentLinearIndex };
+  }, [environment.linearItems, environment.trees]);
+};
+exports.useGetGetParentOfLinearItem = useGetGetParentOfLinearItem;

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

@@ -0,0 +1,21 @@
+import { r as reactExports } from "../../../../../../../../_virtual/index.qwik2.mjs";
+import { useTreeEnvironment } from "../controlledEnvironment/ControlledTreeEnvironment.qwik.mjs";
+var useGetGetParentOfLinearItem = function() {
+  var environment = useTreeEnvironment();
+  return reactExports.useCallback(function(itemLinearIndex, treeId) {
+    var linearItems = environment.linearItems[treeId];
+    var depth = linearItems[itemLinearIndex].depth;
+    var parentLinearIndex = itemLinearIndex;
+    for (; !!linearItems[parentLinearIndex] && linearItems[parentLinearIndex].depth !== depth - 1; parentLinearIndex -= 1)
+      ;
+    var parent = linearItems[parentLinearIndex];
+    if (!parent) {
+      parent = { item: environment.trees[treeId].rootItem, depth: 0 };
+      parentLinearIndex = 0;
+    }
+    return { parent, parentLinearIndex };
+  }, [environment.linearItems, environment.trees]);
+};
+export {
+  useGetGetParentOfLinearItem
+};

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../../../../_virtual/index.qwik2.cjs");
+const useGetParentOfLinearItem = require("./useGetParentOfLinearItem.qwik.cjs");
+const ControlledTreeEnvironment = require("../controlledEnvironment/ControlledTreeEnvironment.qwik.cjs");
+const useCanDropAt = require("./useCanDropAt.qwik.cjs");
+var useGetViableDragPositions = function() {
+  var environment = ControlledTreeEnvironment.useTreeEnvironment();
+  var getParentOfLinearItem = useGetParentOfLinearItem.useGetGetParentOfLinearItem();
+  var canDropAt = useCanDropAt.useCanDropAt();
+  var isDescendant = index.reactExports.useCallback(function(treeId, itemLinearIndex, potentialParents) {
+    var _a = getParentOfLinearItem(itemLinearIndex, treeId), parent = _a.parent, parentLinearIndex = _a.parentLinearIndex;
+    if (potentialParents.some(function(p) {
+      return p.index === parent.item;
+    }))
+      return true;
+    if (parent.depth === 0)
+      return false;
+    return isDescendant(treeId, parentLinearIndex, potentialParents);
+  }, [getParentOfLinearItem]);
+  return index.reactExports.useCallback(function(treeId, draggingItems) {
+    var _a, _b;
+    var linearItems = environment.linearItems[treeId];
+    var targets = [];
+    var skipUntilDepthIsLowerThan = -1;
+    for (
+      var linearIndex = 0;
+      linearIndex < linearItems.length;
+      // eslint-disable-next-line no-plusplus
+      linearIndex++
+    ) {
+      var _c = linearItems[linearIndex], item = _c.item, depth = _c.depth;
+      if (skipUntilDepthIsLowerThan !== -1 && depth > skipUntilDepthIsLowerThan) {
+        continue;
+      } else {
+        skipUntilDepthIsLowerThan = -1;
+      }
+      var parent_1 = getParentOfLinearItem(linearIndex, treeId).parent;
+      var childIndex = environment.items[parent_1.item].children.indexOf(item);
+      if (isDescendant(treeId, linearIndex, draggingItems)) {
+        skipUntilDepthIsLowerThan = depth + 1;
+        continue;
+      }
+      var itemPosition = {
+        targetType: "item",
+        parentItem: parent_1.item,
+        targetItem: item,
+        linearIndex,
+        depth,
+        treeId
+      };
+      var topPosition = {
+        targetType: "between-items",
+        parentItem: parent_1.item,
+        linePosition: "top",
+        childIndex,
+        depth,
+        treeId,
+        linearIndex
+      };
+      var bottomPosition = {
+        targetType: "between-items",
+        parentItem: parent_1.item,
+        linePosition: "bottom",
+        linearIndex: linearIndex + 1,
+        childIndex: childIndex + 1,
+        depth,
+        treeId
+      };
+      var skipTopPosition = depth === ((_b = (_a = linearItems[linearIndex - 1]) === null || _a === void 0 ? void 0 : _a.depth) !== null && _b !== void 0 ? _b : -1);
+      if (!skipTopPosition && canDropAt(topPosition, draggingItems)) {
+        targets.push(topPosition);
+      }
+      if (canDropAt(itemPosition, draggingItems)) {
+        targets.push(itemPosition);
+      }
+      if (canDropAt(bottomPosition, draggingItems)) {
+        targets.push(bottomPosition);
+      }
+    }
+    return targets;
+  }, [
+    canDropAt,
+    environment.items,
+    environment.linearItems,
+    getParentOfLinearItem,
+    isDescendant
+  ]);
+};
+exports.useGetViableDragPositions = useGetViableDragPositions;

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

@@ -0,0 +1,90 @@
+import { r as reactExports } from "../../../../../../../../_virtual/index.qwik2.mjs";
+import { useGetGetParentOfLinearItem } from "./useGetParentOfLinearItem.qwik.mjs";
+import { useTreeEnvironment } from "../controlledEnvironment/ControlledTreeEnvironment.qwik.mjs";
+import { useCanDropAt } from "./useCanDropAt.qwik.mjs";
+var useGetViableDragPositions = function() {
+  var environment = useTreeEnvironment();
+  var getParentOfLinearItem = useGetGetParentOfLinearItem();
+  var canDropAt = useCanDropAt();
+  var isDescendant = reactExports.useCallback(function(treeId, itemLinearIndex, potentialParents) {
+    var _a = getParentOfLinearItem(itemLinearIndex, treeId), parent = _a.parent, parentLinearIndex = _a.parentLinearIndex;
+    if (potentialParents.some(function(p) {
+      return p.index === parent.item;
+    }))
+      return true;
+    if (parent.depth === 0)
+      return false;
+    return isDescendant(treeId, parentLinearIndex, potentialParents);
+  }, [getParentOfLinearItem]);
+  return reactExports.useCallback(function(treeId, draggingItems) {
+    var _a, _b;
+    var linearItems = environment.linearItems[treeId];
+    var targets = [];
+    var skipUntilDepthIsLowerThan = -1;
+    for (
+      var linearIndex = 0;
+      linearIndex < linearItems.length;
+      // eslint-disable-next-line no-plusplus
+      linearIndex++
+    ) {
+      var _c = linearItems[linearIndex], item = _c.item, depth = _c.depth;
+      if (skipUntilDepthIsLowerThan !== -1 && depth > skipUntilDepthIsLowerThan) {
+        continue;
+      } else {
+        skipUntilDepthIsLowerThan = -1;
+      }
+      var parent_1 = getParentOfLinearItem(linearIndex, treeId).parent;
+      var childIndex = environment.items[parent_1.item].children.indexOf(item);
+      if (isDescendant(treeId, linearIndex, draggingItems)) {
+        skipUntilDepthIsLowerThan = depth + 1;
+        continue;
+      }
+      var itemPosition = {
+        targetType: "item",
+        parentItem: parent_1.item,
+        targetItem: item,
+        linearIndex,
+        depth,
+        treeId
+      };
+      var topPosition = {
+        targetType: "between-items",
+        parentItem: parent_1.item,
+        linePosition: "top",
+        childIndex,
+        depth,
+        treeId,
+        linearIndex
+      };
+      var bottomPosition = {
+        targetType: "between-items",
+        parentItem: parent_1.item,
+        linePosition: "bottom",
+        linearIndex: linearIndex + 1,
+        childIndex: childIndex + 1,
+        depth,
+        treeId
+      };
+      var skipTopPosition = depth === ((_b = (_a = linearItems[linearIndex - 1]) === null || _a === void 0 ? void 0 : _a.depth) !== null && _b !== void 0 ? _b : -1);
+      if (!skipTopPosition && canDropAt(topPosition, draggingItems)) {
+        targets.push(topPosition);
+      }
+      if (canDropAt(itemPosition, draggingItems)) {
+        targets.push(itemPosition);
+      }
+      if (canDropAt(bottomPosition, draggingItems)) {
+        targets.push(bottomPosition);
+      }
+    }
+    return targets;
+  }, [
+    canDropAt,
+    environment.items,
+    environment.linearItems,
+    getParentOfLinearItem,
+    isDescendant
+  ]);
+};
+export {
+  useGetViableDragPositions
+};