@btst/stack 4.6.0 → 5.1.0

package/dist/node_modules/.pnpm/he-tree-react@1.3.1_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/he-tree-react/dist/index.mjs

@@ -0,0 +1,799 @@
+import { useMemo, useState, useRef, useLayoutEffect, createElement } from 'react';
+import { findParent, arrayFirst, binarySearch, between, arrayLast } from '../../../../helper-js@3.1.7/node_modules/helper-js/dist/index.esm.mjs';
+import { VirtualList as X } from '../../../../react-base-virtual-list@1.2.9_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/react-base-virtual-list/dist/index.mjs';
+import { jsx } from 'react/jsx-runtime';
+
+// src/HeTree.tsx
+var dragOverInfo = {
+  id: null,
+  x: 0,
+  y: 0,
+  time: 0
+};
+var defaultProps = {
+  /**
+   * 
+   */
+  idKey: "id",
+  parentIdKey: "parent_id",
+  childrenKey: "children",
+  indent: 20,
+  dragOpen: false,
+  dragOpenDelay: 600,
+  placeholderId: "__DRAG_PLACEHOLDER__",
+  dataType: "flat",
+  direction: "ltr",
+  rootId: null,
+  virtual: false
+};
+function useHeTree(props0) {
+  const props = { ...defaultProps, ...props0 };
+  const { idKey: ID, parentIdKey: PID, childrenKey: CHILDREN, placeholderId, isFunctionReactive } = props;
+  const flatOpt = { idKey: ID, parentIdKey: PID };
+  if (!props.renderNode && !props.renderNodeBox) {
+    throw new Error("Either renderNodeBox or renderNode is required.");
+  }
+  const rtl = props.direction === "rtl";
+  const openIdsStr = useMemo(() => props.openIds ? [...props.openIds].sort().toString() : void 0, [props.openIds]);
+  const openIdSet = useMemo(() => new Set(props.openIds), [openIdsStr]);
+  const checkedIdsStr = useMemo(() => props.checkedIds ? [...props.checkedIds].sort().toString() : "", [props.checkedIds]);
+  const checkedIdSet = useMemo(() => new Set(props.checkedIds), [checkedIdsStr]);
+  const mainCache = useMemo(
+    () => {
+      const stats = {};
+      const nodes = {};
+      const rootIds2 = [];
+      const rootNodes = [];
+      const rootStats2 = [];
+      const allIds = [];
+      function* simpleWalk() {
+        if (props.dataType === "flat") {
+          for (const node of props.data) {
+            yield [node];
+          }
+        } else {
+          for (const t of walkTreeDataGenerator(props.data, CHILDREN)) {
+            yield t;
+          }
+        }
+      }
+      let count = 0;
+      for (const [node, info] of simpleWalk()) {
+        const id = node[ID] ?? count;
+        allIds.push(id);
+        let pid = node[PID];
+        if (props.dataType === "tree") {
+          pid = info.parent?.[ID] ?? null;
+        }
+        let parent = nodes[pid] || null;
+        const parentStat = stats[pid] || null;
+        const childIds = [];
+        const children = [];
+        const childStats = [];
+        let siblingIds, siblings, siblingStats;
+        if (!parentStat) {
+          siblingIds = rootIds2;
+          siblings = rootNodes;
+          siblingStats = rootStats2;
+        } else {
+          siblingIds = parentStat.childIds;
+          siblings = parentStat.children;
+          siblingStats = parentStat.childStats;
+        }
+        const index = siblingIds.length;
+        const level = parentStat?.level + 1 || 1;
+        const stat = {
+          _isStat: true,
+          id,
+          pid,
+          childIds,
+          siblingIds,
+          node,
+          parent,
+          parentStat,
+          children,
+          childStats,
+          siblings,
+          siblingStats,
+          index,
+          level,
+          open: props.openIds ? openIdSet.has(id) : true,
+          checked: checkedIdSet.has(id),
+          draggable: false
+        };
+        stats[id] = stat;
+        nodes[id] = node;
+        siblingIds.push(id);
+        siblings.push(node);
+        siblingStats.push(stat);
+        count++;
+      }
+      for (const [stat] of walkTreeDataGenerator(rootStats2, "childStats")) {
+        let draggable = props.canDrag?.(stat) ?? null;
+        if (draggable === null) {
+          draggable = stat.parentStat ? stat.parentStat.draggable : true;
+        }
+        stat.draggable = draggable;
+      }
+      const getStat2 = (idOrNodeOrStat) => {
+        let id;
+        if (typeof idOrNodeOrStat === "object") {
+          id = idOrNodeOrStat._isStat ? idOrNodeOrStat.id : idOrNodeOrStat[ID];
+        } else {
+          id = idOrNodeOrStat;
+        }
+        return stats[id];
+      };
+      return {
+        // root
+        rootIds: rootIds2,
+        rootNodes,
+        rootStats: rootStats2,
+        // 
+        allIds,
+        // methods
+        getStat: getStat2
+      };
+    },
+    [
+      props.data,
+      props.dataType,
+      ID,
+      PID,
+      openIdSet,
+      checkedIdSet,
+      isFunctionReactive && props.canDrag
+    ]
+  );
+  const { rootIds, rootStats, getStat } = mainCache;
+  const indent = props.indent;
+  const [draggingStat, setDraggingStat] = useState();
+  const [dragOverStat, setDragOverStat] = useState();
+  const virtualListRef = useRef(null);
+  const rootRef = useRef(null);
+  const [placeholder, setPlaceholder] = useState();
+  const isExternal = !draggingStat;
+  const cacheForVisible = useMemo(
+    () => {
+      const visibleIds2 = [];
+      const attrsList2 = [];
+      for (const [stat, { skipChildren }] of walkTreeDataGenerator(rootStats, "childStats")) {
+        const attrs = createAttrs(stat);
+        if (stat === draggingStat) {
+          Object.assign(attrs.style, {
+            position: "fixed",
+            top: 0,
+            left: 0,
+            pointerEvents: "none",
+            zIndex: "-999999999",
+            visibility: "hidden"
+          });
+          attrs["data-dragging"] = true;
+        }
+        attrsList2.push(attrs);
+        visibleIds2.push(stat.id);
+        if (!stat.open || stat === draggingStat) {
+          skipChildren();
+        }
+      }
+      if (placeholder) {
+        const toIndexInVisible = (parentStat, index) => {
+          let find = (parentStat?.childStats || rootStats)[index];
+          let finalIndex;
+          if (find) {
+            finalIndex = visibleIds2.indexOf(find.id);
+          } else {
+            const getNext = (stat) => stat.siblingStats[stat.siblingStats.indexOf(stat) + 1];
+            let next;
+            if (parentStat) {
+              for (const stat of walkParentsGenerator(parentStat, "parentStat", { withSelf: true })) {
+                next = getNext(stat);
+                if (next) {
+                  break;
+                }
+              }
+            }
+            if (next) {
+              finalIndex = visibleIds2.indexOf(next.id);
+            } else {
+              finalIndex = visibleIds2.length;
+            }
+          }
+          return finalIndex;
+        };
+        const indexInVisible = toIndexInVisible(placeholder.parentStat, placeholder.index);
+        visibleIds2.splice(indexInVisible, 0, placeholderId);
+        const placeholderAttrs = createAttrs({
+          id: placeholderId,
+          level: placeholder.level
+        }, true);
+        placeholderAttrs["data-drag-placeholder"] = true;
+        attrsList2.splice(indexInVisible, 0, placeholderAttrs);
+      }
+      function createAttrs(stat, isPlaceholder = false) {
+        return {
+          key: stat.id,
+          draggable: stat.draggable,
+          style: { [`padding${!rtl ? "Left" : "Right"}`]: (stat.level - 1) * indent + "px" },
+          "data-key": stat.id + "",
+          "data-level": stat.level + "",
+          "data-node-box": true,
+          onDragStart(e) {
+            if (isPlaceholder) {
+              e.preventDefault();
+              return;
+            }
+            let trigger;
+            const nodeBox = findParent(e.target, (el) => {
+              if (!trigger && el.hasAttribute("draggable")) {
+                trigger = el;
+              }
+              return el.hasAttribute("data-node-box");
+            }, { withSelf: true });
+            let hasChildTrigger = nodeBox.querySelector(`[draggable]`);
+            if (hasChildTrigger && trigger === nodeBox) {
+              e.preventDefault();
+              return;
+            }
+            e.dataTransfer.setData("text/plain", "he-tree he-tree-react");
+            e.dataTransfer.dropEffect = "move";
+            if (props.customDragImage) {
+              props.customDragImage(e, stat);
+            } else {
+              const node = nodeBox.children[0];
+              e.dataTransfer.setDragImage(node, !rtl ? 0 : node.offsetWidth, 0);
+            }
+            setTimeout(() => {
+              setDraggingStat(stat);
+              setPlaceholder({
+                ...placeholder,
+                parentStat: stat.parentStat,
+                level: stat.level,
+                index: (stat.parentStat?.childIds || rootIds).indexOf(stat.id)
+              });
+            }, 0);
+            props.onDragStart?.(e, stat);
+          },
+          onDragLeave(e) {
+          }
+        };
+      }
+      const onDragOverRoot2 = (e) => {
+        if (isExternal && !props.onExternalDragOver?.(e)) {
+          return;
+        }
+        const el = getClosestEl();
+        if (el) {
+          const stat = getStat(el.getAttribute("data-key"));
+          const isPlaceholder = !!el.getAttribute("data-drag-placeholder");
+          if (shouldDragOpen(stat, isPlaceholder)) {
+            props.onDragOpen(stat);
+          }
+          let t = findClosestAndNext(stat, isPlaceholder);
+          const { closest, next } = t;
+          let { atTop } = t;
+          const rootEl = rootRef.current;
+          const nodeBox = el;
+          const getPlaceholderLevel = () => {
+            let rect = nodeBox.getBoundingClientRect();
+            let pl;
+            if (!rtl) {
+              pl = Math.ceil((e.clientX - rect.x) / indent);
+            } else {
+              pl = Math.ceil((rect.right - e.clientX) / indent);
+            }
+            return between(pl, 0, (closest?.level || 0) + 1);
+          };
+          let placeholderLevel = getPlaceholderLevel();
+          if (!atTop && !isPlaceholder && closest.id === rootIds[0]) {
+            const topNodeElement = rootEl.querySelector(`[data-key="${closest.id}"]`);
+            if (topNodeElement) {
+              const rect = topNodeElement.getBoundingClientRect();
+              atTop = rect.y + rect.height / 2 > e.clientY;
+            }
+          }
+          if (atTop) {
+            placeholderLevel = 0;
+          }
+          let newPlaceholder;
+          if (atTop) {
+            if (getDroppable(null, 0)) {
+              newPlaceholder = {
+                ...placeholder,
+                parentStat: null,
+                level: 1,
+                index: 0
+              };
+            }
+          } else {
+            const parentMinLevel = next ? next.level - 1 : 0;
+            const availablePositionsLeft = [];
+            const availablePositionsRight = [];
+            let cur = closest;
+            const curLevel = () => cur ? cur.level : 0;
+            while (curLevel() >= parentMinLevel) {
+              const index = getTargetIndex(cur, next);
+              if (getDroppable(cur, index)) {
+                (placeholderLevel > curLevel() ? availablePositionsLeft : availablePositionsRight).unshift({
+                  parentStat: cur,
+                  index
+                });
+              }
+              if (!cur) {
+                break;
+              }
+              cur = cur.parentStat;
+            }
+            let placeholderPosition = arrayLast(availablePositionsLeft);
+            if (!placeholderPosition) {
+              placeholderPosition = arrayFirst(availablePositionsRight);
+            }
+            if (placeholderPosition) {
+              newPlaceholder = {
+                ...placeholder,
+                parentStat: placeholderPosition.parentStat,
+                level: (placeholderPosition.parentStat?.level ?? 0) + 1,
+                index: placeholderPosition.index
+              };
+            }
+          }
+          setPlaceholder(newPlaceholder);
+          if (newPlaceholder) {
+            e.preventDefault();
+          }
+          setDragOverStat(isPlaceholder ? void 0 : stat);
+          props.onDragOver?.(e, stat, isExternal);
+        } else {
+          if (getDroppable(null, 0)) {
+            setPlaceholder({
+              ...placeholder,
+              parentStat: null,
+              level: 1,
+              index: 0
+            });
+            e.preventDefault();
+          }
+        }
+        function getClosestEl() {
+          const rootEl = rootRef.current;
+          const nodeEls = rootEl.querySelectorAll(`[data-node-box]:not([data-dragging])`);
+          const t = binarySearch(
+            // @ts-ignore
+            nodeEls,
+            (nodeEl) => nodeEl.getBoundingClientRect().top - e.clientY,
+            { returnNearestIfNoHit: true }
+          );
+          let index;
+          if (t.hit) ; else {
+            if (t.greater) {
+              index = t.index - 1;
+              if (index < 0) {
+                index = 0;
+              }
+            }
+          }
+          if (index == null) {
+            index = t.index;
+          }
+          return nodeEls[index];
+        }
+        function shouldDragOpen(stat, isPlaceholder) {
+          if (!props.dragOpen) {
+            return false;
+          }
+          if (isPlaceholder) {
+            return false;
+          }
+          if (stat.open) {
+            return false;
+          }
+          const refresh = () => Object.assign(dragOverInfo, { id: stat.id, x: e.clientX, y: e.clientY, time: Date.now() });
+          if (dragOverInfo.id !== stat.id) {
+            refresh();
+            return false;
+          }
+          if (calculateDistance(e.clientX, e.clientY, dragOverInfo.x, dragOverInfo.y) > 10) {
+            refresh();
+            return false;
+          }
+          const now = Date.now();
+          if (now - dragOverInfo.time >= props.dragOpenDelay) {
+            return true;
+          }
+        }
+      };
+      const onDropToRoot2 = (e) => {
+        if (isExternal && !props.onExternalDragOver?.(e)) {
+          return;
+        }
+        if (placeholder) {
+          e.preventDefault();
+          if (isExternal) {
+            const { index: targetIndexInSiblings } = placeholder;
+            props.onExternalDrop?.(e, placeholder.parentStat, targetIndexInSiblings);
+            reset();
+          }
+        }
+      };
+      function onDragEndOnRoot2(e) {
+        if (!draggingStat) {
+          return;
+        }
+        let isOutside = !placeholder;
+        if (!isOutside) {
+          const rootEl = rootRef.current;
+          let rect = rootEl.getBoundingClientRect();
+          isOutside = !(e.clientX >= rect.left && e.clientX <= rect.right && e.clientY >= rect.top && e.clientY <= rect.bottom);
+        }
+        const customized = props.onDragEnd?.(e, draggingStat, isOutside) === false;
+        if (!customized && placeholder) {
+          let targetIndexInSiblings = placeholder.index;
+          if (placeholder.parentStat === draggingStat.parentStat && draggingStat.index < targetIndexInSiblings) {
+            targetIndexInSiblings--;
+          }
+          const newData = [...props.data];
+          if (props.dataType === "flat") {
+            const targetParentId = placeholder.parentStat?.id ?? props.rootId;
+            const removed = removeByIdInFlatData(newData, draggingStat.id, flatOpt);
+            const newNode = { ...draggingStat.node, [PID]: targetParentId };
+            removed[0] = newNode;
+            const targetTreeIndex = convertIndexToTreeIndexInFlatData(newData, targetParentId, targetIndexInSiblings, flatOpt);
+            newData.splice(targetTreeIndex, 0, ...removed);
+          } else {
+            const newNodeCache = /* @__PURE__ */ new Map();
+            const copyNode = (stat) => {
+              if (!stat) {
+                return newData;
+              }
+              const siblings = copyNode(stat.parentStat);
+              let children = [...stat.children];
+              const newNode = newNodeCache.get(stat.node) || { ...stat.node, [CHILDREN]: children };
+              newNodeCache.set(stat.node, newNode);
+              children = newNode[CHILDREN];
+              siblings[stat.index] = newNode;
+              return children;
+            };
+            const newSiblingsOfDragged = copyNode(draggingStat.parentStat);
+            const newSiblingsOfTarget = placeholder.parentStat === draggingStat.parentStat ? newSiblingsOfDragged : copyNode(placeholder.parentStat);
+            newSiblingsOfDragged.splice(draggingStat.index, 1);
+            newSiblingsOfTarget.splice(targetIndexInSiblings, 0, draggingStat.node);
+          }
+          props.onChange(newData);
+        }
+        reset();
+      }
+      function reset() {
+        setDragOverStat(void 0);
+        setDraggingStat(void 0);
+        setPlaceholder(void 0);
+      }
+      function getDroppable(stat, index) {
+        if (!stat) {
+          return props.canDropToRoot?.(index) ?? true;
+        }
+        if (!stat.open) {
+          return false;
+        }
+        let droppable = props.canDrop?.(stat, index);
+        if (droppable == void 0) {
+          droppable = getDroppable(stat.parentStat);
+        }
+        return droppable;
+      }
+      function findClosestAndNext(stat, isPlaceholder) {
+        let closest = stat;
+        let index = visibleIds2.indexOf(!isPlaceholder ? stat.id : props.placeholderId);
+        let atTop = false;
+        const isPlaceholderOrDraggedNode = (id) => id === placeholderId || getStat(id) === draggingStat;
+        const find = (startIndex, step) => {
+          let i = startIndex, cur;
+          do {
+            i += step;
+            cur = visibleIds2[i];
+          } while (cur && isPlaceholderOrDraggedNode(cur));
+          return { id: cur, i };
+        };
+        const findAndAssign = (startIndex, dir) => {
+          const t = find(startIndex, dir);
+          closest = getStat(t.id);
+          index = t.i;
+        };
+        const NEXT = 1, PREV = -1;
+        if (isPlaceholder) {
+          findAndAssign(index, PREV);
+          if (!closest) {
+            atTop = true;
+            findAndAssign(-1, NEXT);
+          }
+        }
+        const next = getStat(find(index, NEXT).id);
+        return { closest, atTop, next };
+      }
+      function getTargetIndex(targetParentStat, next) {
+        const siblingStats = targetParentStat ? targetParentStat.childStats : rootStats;
+        let index = siblingStats.length;
+        if (next && next.siblingStats === siblingStats) {
+          index = siblingStats.indexOf(next);
+        }
+        return index;
+      }
+      function scrollToNode2(idOrNodeOrStat, block = "start") {
+        const stat = getStat(idOrNodeOrStat);
+        if (!stat) {
+          return false;
+        }
+        let index = visibleIds2.indexOf(stat.id);
+        if (index === -1) {
+          return false;
+        }
+        if (virtualListRef.current) {
+          virtualListRef.current.scrollToIndex(index, block);
+          return true;
+        } else {
+          return false;
+        }
+      }
+      return { visibleIds: visibleIds2, attrsList: attrsList2, onDragOverRoot: onDragOverRoot2, onDropToRoot: onDropToRoot2, onDragEndOnRoot: onDragEndOnRoot2, scrollToNode: scrollToNode2 };
+    },
+    [
+      mainCache,
+      indent,
+      draggingStat,
+      // watch placeholder position
+      placeholder?.parentStat,
+      placeholder?.index,
+      // watch props
+      indent,
+      placeholderId,
+      rtl,
+      props.rootId,
+      // watch func
+      ...[props.canDrop, props.canDropToRoot, props.customDragImage, props.onDragStart, props.onDragOver, props.onExternalDragOver, props.onExternalDrop, props.onDragEnd, props.onChange, props.onDragOpen].map((func) => isFunctionReactive && func)
+    ]
+  );
+  const t2 = useMemo(() => {
+    return {
+      getEl: () => window,
+      onDragOverWindow: (e) => {
+        if (!isInTree()) {
+          setDragOverStat(void 0);
+          if (!props.keepPlaceholder) {
+            setPlaceholder(void 0);
+          }
+        }
+        function isInTree() {
+          let inTree = false;
+          let el = e.target;
+          if (el) {
+            for (const parent of walkParentsGenerator(el, "parentElement", { withSelf: true })) {
+              if (parent === rootRef.current) {
+                inTree = true;
+                break;
+              }
+            }
+          }
+          return inTree;
+        }
+      }
+    };
+  }, [props.keepPlaceholder]);
+  useAddEventListener(t2.getEl, "dragover", t2.onDragOverWindow);
+  const { visibleIds, attrsList, onDragOverRoot, onDropToRoot, onDragEndOnRoot, scrollToNode } = cacheForVisible;
+  const persistentIndices = useMemo(() => draggingStat ? [visibleIds.indexOf(draggingStat.id)] : [], [draggingStat, visibleIds]);
+  const renderTree = (options) => {
+    let renderNodeBox = props.renderNodeBox;
+    if (!renderNodeBox) {
+      const placeholder2 = /* @__PURE__ */ jsx("div", { className: "he-tree-drag-placeholder", style: { minHeight: "20px", border: "1px dashed blue" } });
+      renderNodeBox = ({ stat, attrs, isPlaceholder }) => /* @__PURE__ */ createElement("div", { ...attrs, key: attrs.key }, isPlaceholder ? placeholder2 : props.renderNode(stat));
+    }
+    return /* @__PURE__ */ jsx("div", { className: `he-tree ${options?.className || ""}`, style: options?.style, ref: rootRef, onDragOver: onDragOverRoot, onDrop: onDropToRoot, onDragEnd: onDragEndOnRoot, children: /* @__PURE__ */ jsx(
+      X,
+      {
+        ref: virtualListRef,
+        className: options?.listClassName || "",
+        innerClassName: options?.listInnerClassName || "",
+        items: visibleIds,
+        virtual: props.virtual,
+        persistentIndices,
+        style: { height: "100%" },
+        renderItem: (id, index) => renderNodeBox({
+          stat: getStat(id),
+          attrs: attrsList[index],
+          isPlaceholder: id === placeholderId
+        })
+      }
+    ) });
+  };
+  return {
+    ...mainCache,
+    // 
+    visibleIds,
+    attrsList,
+    // ref
+    virtualListRef,
+    // drag states
+    draggingStat,
+    dragOverStat,
+    placeholder,
+    // render
+    renderTree,
+    renderHeTree: renderTree,
+    // methods
+    scrollToNode
+  };
+}
+function* walkTreeDataGenerator(treeData, childrenKey = "children") {
+  let _skipChildren = false;
+  let _exit = false;
+  const skipChildren = () => {
+    _skipChildren = true;
+  };
+  const exitWalk = () => {
+    _exit = true;
+  };
+  yield* walk(treeData, null, []);
+  function* walk(arr, parent, parents) {
+    let index = 0;
+    for (const node of arr) {
+      const siblings = arr;
+      yield [node, { parent, parents, siblings, index, skipChildren, exitWalk }];
+      if (_exit) {
+        return;
+      }
+      index++;
+      if (_skipChildren) {
+        _skipChildren = false;
+      } else {
+        const children = node[childrenKey];
+        if (children) {
+          yield* walk(children, node, [...parents, node]);
+          if (_exit) {
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+function* walkParentsGenerator(node, parentKeyOrGetter, options = { withSelf: false }) {
+  let cur = node;
+  while (cur) {
+    if (cur !== node || options.withSelf) {
+      yield cur;
+    }
+    cur = typeof parentKeyOrGetter === "function" ? parentKeyOrGetter(cur) : cur[parentKeyOrGetter];
+  }
+}
+var flatDataDefaultOptions = {
+  idKey: "id",
+  parentIdKey: "parent_id"
+};
+function* walkFlatDataGenerator(flatData, options0) {
+  const options = { ...flatDataDefaultOptions, ...options0 };
+  const { idKey: ID, parentIdKey: PID } = options;
+  let _skipChildren = false;
+  let _exit = false;
+  const skipChildren = () => {
+    _skipChildren = true;
+  };
+  const exitWalk = () => {
+    _exit = true;
+  };
+  const nodes = {};
+  const stats = {};
+  const childIdsById = {};
+  const rootIds = [];
+  let skipIds;
+  let treeIndex = 0;
+  for (const node of flatData) {
+    const id = node[ID];
+    const pid = node[PID] ?? null;
+    nodes[id] = node;
+    const parent = nodes[pid] || null;
+    childIdsById[id] = [];
+    const siblingIds = parent ? childIdsById[pid] : rootIds;
+    const index = siblingIds.length;
+    siblingIds.push(id);
+    const stat = {
+      parent,
+      parents: parent ? [...stats[pid].parents, parent] : [],
+      index,
+      id,
+      pid,
+      treeIndex,
+      skipChildren,
+      exitWalk
+    };
+    stats[id] = stat;
+    let skipped = false;
+    if (_skipChildren && skipIds) {
+      if (skipIds.has(pid)) {
+        skipIds.add(id);
+        skipped = true;
+      } else {
+        _skipChildren = false;
+        skipIds = void 0;
+      }
+    }
+    if (!skipped) {
+      yield [node, stat];
+      if (_exit) {
+        break;
+      }
+      if (_skipChildren) {
+        skipIds = /* @__PURE__ */ new Set([id]);
+      }
+    }
+    treeIndex++;
+  }
+}
+function convertIndexToTreeIndexInFlatData(flatData, parentId, indexInSiblings, options0) {
+  const options = { ...flatDataDefaultOptions, ...options0 };
+  const { idKey: ID, parentIdKey: PID } = options;
+  let parentFound = false;
+  let resultIndex = -1;
+  for (const [node, { treeIndex, skipChildren, index: curNodeIndexInSiblings }] of walkFlatDataGenerator(flatData, options)) {
+    if (parentId != null && !parentFound) {
+      if (node[ID] === parentId) {
+        parentFound = true;
+      }
+    } else {
+      if (parentId == null || node[PID] === parentId) {
+        if (indexInSiblings != null && indexInSiblings === curNodeIndexInSiblings) {
+          resultIndex = treeIndex;
+          break;
+        } else {
+          skipChildren();
+        }
+      } else {
+        resultIndex = treeIndex;
+        break;
+      }
+    }
+  }
+  if (resultIndex === -1) {
+    resultIndex = flatData.length;
+  }
+  return resultIndex;
+}
+function removeByIdInFlatData(flatData, removeId, options0) {
+  if (removeId == null) {
+    return flatData.splice(0, flatData.length);
+  }
+  const options = { ...flatDataDefaultOptions, ...options0 };
+  const { idKey: ID, parentIdKey: PID } = options;
+  let startIndex = -1;
+  let endIndex = -1;
+  for (const [node, { treeIndex, skipChildren }] of walkFlatDataGenerator(flatData, options)) {
+    if (startIndex === -1) {
+      if (node[ID] === removeId) {
+        startIndex = treeIndex;
+        skipChildren();
+      }
+    } else {
+      endIndex = treeIndex;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    endIndex = flatData.length;
+  }
+  if (startIndex === -1) {
+    return [];
+  }
+  return flatData.splice(startIndex, endIndex - startIndex);
+}
+function calculateDistance(x1, y1, x2, y2) {
+  return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+}
+function useAddEventListener(targetGetter, listenerName, listener) {
+  useLayoutEffect(() => {
+    const target = targetGetter();
+    target?.addEventListener(listenerName, listener);
+    return () => {
+      target?.removeEventListener(listenerName, listener);
+    };
+  }, [targetGetter, listenerName, listener]);
+}
+
+export { convertIndexToTreeIndexInFlatData, defaultProps, removeByIdInFlatData, useHeTree, walkFlatDataGenerator, walkParentsGenerator, walkTreeDataGenerator };