@elliemae/ds-treeview 2.2.0-next.6 → 2.3.0-alpha.1

package/cjs/utils/tree-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/tree-helpers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-statements */\n/* eslint-disable max-params */\n/* eslint-disable complexity */\n/* eslint-disable max-lines */\nimport { createRef } from 'react';\nimport type TreeModel from 'tree-model';\nimport { standardizeSearchQueryString } from './string-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\n\nexport const walkVisibles = (\n  node: DSTreeviewT.Item['node'],\n  callback: (node: DSTreeviewT.Item['node']) => void,\n  skipRoot = true,\n  highlightOnlyQuery = false,\n) => {\n  const { children, model } = node;\n  const { name, isExpanded, childrenMatchesSearchQuery, matchesSearchQuery } = model;\n\n  const shouldSkipBecauseIsRoot = skipRoot && name === '__root';\n  const queryRestrictionsPassed = !!(highlightOnlyQuery || childrenMatchesSearchQuery || matchesSearchQuery);\n\n  if (!shouldSkipBecauseIsRoot && queryRestrictionsPassed) callback(node);\n\n  const shouldWalkChildren = !!(children.length > 0 && isExpanded && queryRestrictionsPassed);\n  if (shouldWalkChildren) {\n    children.forEach((childNode) => {\n      walkVisibles(childNode, callback, skipRoot, highlightOnlyQuery);\n    });\n  }\n};\n\nexport const walkParents = (\n  nodePath: DSTreeviewT.Item['nodePath'],\n  callback: (currParent: DSTreeviewT.Item['node']) => void,\n  skipRoot = true,\n) => {\n  const parents = [...nodePath].reverse();\n  parents.shift(); // remove current node from the parents array\n  if (skipRoot) parents.pop(); // remove the root from the parents if skipping root\n  parents.forEach(callback);\n};\n\ntype RecursiveCallbackT = (childNode: DSTreeviewT.Item['node'], cb?: RecursiveCallbackT, isFirst?: boolean) => void;\nexport const walkAllNodeChildren = (node: DSTreeviewT.Item['node'], callback: RecursiveCallbackT, isFirst = true) => {\n  const { children = [] } = node;\n  const shouldWalkChildren = children.length;\n\n  if (!isFirst) callback(node);\n\n  if (shouldWalkChildren) {\n    children.forEach((childNode) => {\n      walkAllNodeChildren(childNode, callback, false);\n    });\n  }\n};\n\nexport const getNodeById = (treeRoot: DSTreeviewT.Item['node'], id: DSTreeviewT.StringOrNum) => {\n  const nodes = treeRoot.all((node) => (node as unknown as DSTreeviewT.Item).model.id === id);\n  return nodes[0];\n};\n\nexport const cloneNode = (tree: TreeModel, node: DSTreeviewT.Item) => tree.parse(node.model);\n\nexport const itemsShareSameParent = (items: DSTreeviewT.Item[] = []) => {\n  if (items.length === 0) throw new Error('Received empty items for comparison');\n  if (items.length === 1) return true;\n\n  // when moving in first position we receive [undefined,...{items}]\n  // when moving in last position we receive [...{items}, undefined]\n  const firstExistingItem = items.find((item) => !!item);\n  if (!firstExistingItem) throw new Error(\"Received no items, can't retrieve parent\");\n\n  const firstExistingItemPath = firstExistingItem.node.getPath();\n  // path is like [rootParent, ...[parentsNodes], currentNode]\n  // length -1 is the current-node\n  // length -2 is the parent-node\n  // root node is not printed and is always present so minimum path length is 2 (root + currentNode)\n  const directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];\n\n  return items.every((item) => {\n    // undefined nodes count as having the same parent\n    if (!item) return true;\n    const itemPath = item.node.getPath();\n    const itemDirectParent = itemPath[itemPath.length - 2];\n    return directParentNode === itemDirectParent;\n  });\n};\n\nexport const getItemsParentNode = (items: DSTreeviewT.Item[] = [], skipSameParentCheck = false) => {\n  if (items.length === 0) throw new Error(\"Received empty items, can't retrieve parent\");\n\n  // in case we already know the items compared shares the same parent\n  if (!skipSameParentCheck)\n    if (!itemsShareSameParent(items))\n      // if we don't know (default, we don't) check if they share the parent\n      throw new Error(\"Received items don't share the same parent, can't retrieve parent\");\n\n  // when moving in first position we receive [undefined,...{items}]\n  // when moving in last position we receive [...{items}, undefined]\n  const firstExistingItem = items.find((item) => !!item);\n  if (!firstExistingItem) throw new Error(\"Received no items, can't retrieve parent\");\n\n  const firstExistingItemPath = firstExistingItem.node.getPath();\n  // path is like [rootParent, ...[parentsNodes], currentNode]\n  // length -1 is the current-node\n  // length -2 is the parent-node\n  // root node is not printed and is always present so minimum path length is 2 (root + currentNode)\n  const directParentNode = firstExistingItemPath[firstExistingItemPath.length - 2];\n  return directParentNode as unknown as DSTreeviewT.Item['node'];\n};\n\nexport const getNodeMatchesSearchQuery = (node: DSTreeviewT.Item['node'], searchQuery = '') => {\n  const standardizedName = standardizeSearchQueryString(node.model.name);\n  const standardizedSearchQuery = standardizeSearchQueryString(searchQuery);\n  return standardizedName.includes(standardizedSearchQuery);\n};\n\nexport const getChildrenMatchesSearchQuery = (parentNode: DSTreeviewT.Item['node'], searchQuery = '') => {\n  let anyChildMatch = false;\n  walkAllNodeChildren(parentNode, (node) => {\n    if (getNodeMatchesSearchQuery(node, searchQuery)) anyChildMatch = true;\n  });\n  return anyChildMatch;\n};\n\n/**\n * Mutate in place a node from tree-model normalizing object properties like \"isGroup\" even if user didn't specify it explicitly,\n * after execution the node will have \"nodePath\" \"treeDepth\" \"nodeItemRef\" \"isGroup\" \"isExpanded\"\n * (optionally, based on the provided arguments) \"matchesSearchQuery\" \"childrenMatchesSearchQuery\" \"isChecked\"\n *\n * @param {Object} node - node (based on 'tree-model' lib) that you wish to mutate with extra props\n * @param {string} [searchQuery=''] - optional string used to parse \"matchesSearchQuery\"/\"childrenMatchesSearchQuery\" properties\n * @param {Object} [selection=null] - optional selection hashmap used to parse \"isChecked\" properties\n * @param {Object} [expanded=null] - optional expanded hashmap used to parse \"isExpanded\" properties\n */\nexport const enrichNodeModelInPlace = (\n  node: TreeModel.Node<DSTreeviewT.SimpleItem>,\n  searchQuery = '',\n  selection: DSTreeviewT.SelectionItems | null = null,\n  expanded: DSTreeviewT.ExpandedItems | null = null,\n) => {\n  const path = node.getPath();\n  const depth = path.length - 1;\n  node.model.nodePath = path;\n  node.model.treeDepth = depth;\n\n  if (!node.model.nodeItemRef) {\n    node.model.nodeItemRef = createRef();\n  }\n\n  // if a node has children but was not marked as isGroup, force-mark as group\n  // this is useful to avoid having to always check both the flag and the children.length...\n  if (typeof node.model.isGroup !== 'boolean' && node.model?.children?.length > 0) {\n    node.model.isGroup = true;\n  }\n\n  if (node.model.isGroup && node.model.id !== '__ds_tree_root') {\n    if (expanded) node.model.isExpanded = !!expanded[node.model.id];\n    else if (typeof node.model.isExpanded !== 'boolean') {\n      node.model.isExpanded = false;\n    }\n  }\n\n  node.model.matchesSearchQuery = true;\n  node.model.childrenMatchesSearchQuery = false;\n  const partiallyEnrichedNode = node as unknown as TreeModel.Node<DSTreeviewT.Item>;\n  if (searchQuery) {\n    partiallyEnrichedNode.model.matchesSearchQuery = getNodeMatchesSearchQuery(partiallyEnrichedNode, searchQuery);\n\n    if (partiallyEnrichedNode.model.isGroup === true) {\n      partiallyEnrichedNode.model.childrenMatchesSearchQuery = getChildrenMatchesSearchQuery(\n        partiallyEnrichedNode,\n        searchQuery,\n      );\n      if (partiallyEnrichedNode.model.childrenMatchesSearchQuery) partiallyEnrichedNode.model.isExpanded = true;\n    }\n  }\n  if (selection && selection[partiallyEnrichedNode.model.id]) {\n    partiallyEnrichedNode.model.isChecked = selection[partiallyEnrichedNode.model.id];\n  }\n};\n\nexport const focusItem = (item: DSTreeviewT.Item | null) => {\n  item?.nodeItemRef?.current?.focus();\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}

package/cjs/utils/useDnDHelpers.js

@@ -0,0 +1,199 @@
+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 useDnDHelpers_exports = {};
+__export(useDnDHelpers_exports, {
+  useDnDHelpers: () => useDnDHelpers
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_lodash = require("lodash");
+var import_TreeViewContext = __toESM(require("../TreeViewContext"));
+var import_tree_helpers = require("./tree-helpers");
+var import_dnd_helpers = require("./dnd-helpers");
+const useDnDHelpers = () => {
+  const ctx = (0, import_react.useContext)(import_TreeViewContext.default);
+  const {
+    props: { data, onOrderChange, restrictDragAndDrop },
+    relativeMouseCord,
+    setRelativeMouseCord,
+    visibleItems,
+    isDragging,
+    setIsDragging,
+    isKeyboardDragging,
+    setIsKeyboardDragging,
+    setDraggedItem,
+    setFocusedItem,
+    triggerTreeRerender,
+    tree,
+    treeRoot,
+    draggedItem
+  } = ctx;
+  const onSortEnd = (0, import_react.useCallback)(({ oldIndex, newIndex, isKeySorting }) => {
+    const { isBefore, isAfter, item: overItem, isValid } = relativeMouseCord;
+    if (draggedItem && tree && treeRoot && overItem) {
+      let newItems = (0, import_lodash.cloneDeep)(data);
+      if (oldIndex === newIndex || !isValid) {
+        setIsDragging(false);
+        setDraggedItem(null);
+        triggerTreeRerender();
+        return;
+      }
+      const movementDirection = newIndex > oldIndex ? "topToBottom" : "bottomToTop";
+      let newNestedIndex;
+      let newParentNode;
+      if (isKeySorting) {
+        const kinship = (0, import_dnd_helpers.inferKeyboardKinshipDrop)({
+          items: visibleItems,
+          newIndex
+        });
+        newNestedIndex = kinship.newNestedIndex;
+        newParentNode = kinship.newParentNode;
+      } else {
+        const kinship = (0, import_dnd_helpers.inferHoverItemKinshipDrop)({
+          isBefore,
+          isAfter,
+          overItem,
+          movementDirection,
+          draggedItem
+        });
+        newNestedIndex = kinship.newNestedIndex;
+        newParentNode = kinship.newParentNode;
+      }
+      const newMovedItemNode = tree.parse(draggedItem.node.model);
+      (0, import_tree_helpers.getNodeById)(treeRoot, draggedItem.id).drop();
+      if (newParentNode && typeof newNestedIndex === "number") {
+        newParentNode.addChildAtIndex(newMovedItemNode, newNestedIndex);
+        if (newParentNode.isRoot()) {
+          newItems = [...newParentNode.model.children];
+        } else {
+          newItems = [...treeRoot.model.children];
+        }
+      }
+      onOrderChange(newItems, data, draggedItem);
+      setIsDragging(false);
+      setDraggedItem(null);
+      triggerTreeRerender();
+    }
+  }, [
+    data,
+    draggedItem,
+    relativeMouseCord,
+    visibleItems,
+    tree,
+    treeRoot,
+    onOrderChange,
+    triggerTreeRerender,
+    setIsDragging,
+    setDraggedItem
+  ]);
+  const onSortStart = (0, import_react.useCallback)(() => {
+  }, []);
+  const updateBeforeSortStart = (0, import_react.useCallback)((beforeStartArgs) => new Promise((resolve) => {
+    const { index, isKeySorting } = beforeStartArgs;
+    const item = visibleItems[index];
+    const { isExpanded } = item.node.model;
+    if (isExpanded) {
+      item.node.model.isExpanded = false;
+      triggerTreeRerender();
+    }
+    setRelativeMouseCord(import_TreeViewContext.defaultRelativeMouseCoord);
+    setIsKeyboardDragging(isKeySorting);
+    setIsDragging(true);
+    setDraggedItem(item);
+    (0, import_tree_helpers.focusItem)(null);
+    setFocusedItem(null);
+    if (document.activeElement && typeof document.activeElement.blur === "function")
+      document.activeElement.blur();
+    resolve(true);
+  }), [
+    visibleItems,
+    setRelativeMouseCord,
+    setIsKeyboardDragging,
+    setIsDragging,
+    setDraggedItem,
+    setFocusedItem,
+    triggerTreeRerender
+  ]);
+  const onMouseDragOverItem = (0, import_react.useCallback)(({
+    event,
+    item,
+    itemIndex,
+    setIsDraggingOverThis,
+    openFolderOnHoverTimeout
+  }) => {
+    const { node } = item;
+    const { nodeItemRef } = node.model;
+    if (isDragging && !isKeyboardDragging && draggedItem) {
+      const rect = nodeItemRef?.current?.getBoundingClientRect();
+      if (rect) {
+        const x = event.clientX - rect.left;
+        const y = event.clientY - rect.top;
+        const { height: elementHeight } = rect;
+        const dropBeforeMaxY = elementHeight * 0.25;
+        const dropAfterMinY = elementHeight - elementHeight * 0.25;
+        const isBefore = y < dropBeforeMaxY;
+        const isAfter = y > dropAfterMinY;
+        const isValid = (0, import_dnd_helpers.isDropValid)({
+          isBefore,
+          isAfter,
+          draggedItem,
+          overItem: item,
+          restrictDragAndDrop
+        });
+        setRelativeMouseCord({
+          isBefore,
+          isAfter,
+          isValid,
+          item,
+          x,
+          y,
+          relativeElementDOMRect: rect,
+          relativeElementIndex: itemIndex
+        });
+        setIsDraggingOverThis(true);
+        if (!openFolderOnHoverTimeout?.current && draggedItem?.id !== item?.id && (item.isGroup || item.children.length > 0) && !restrictDragAndDrop) {
+          openFolderOnHoverTimeout.current = setTimeout(() => {
+            item.node.model.isExpanded = true;
+            openFolderOnHoverTimeout.current = null;
+            triggerTreeRerender();
+          }, 1e3);
+        }
+      }
+    } else {
+      setRelativeMouseCord(import_TreeViewContext.defaultRelativeMouseCoord);
+    }
+  }, [isDragging, isKeyboardDragging, draggedItem, restrictDragAndDrop, setRelativeMouseCord, triggerTreeRerender]);
+  return {
+    updateBeforeSortStart,
+    onSortStart,
+    onSortEnd,
+    onMouseDragOverItem
+  };
+};
+module.exports = __toCommonJS(useDnDHelpers_exports);
+//# sourceMappingURL=useDnDHelpers.js.map

package/cjs/utils/useDnDHelpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/useDnDHelpers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-depth */\n/* eslint-disable no-lonely-if */\n/* eslint-disable max-lines */\n/* eslint-disable complexity */\n/* eslint-disable max-statements */\nimport React, { useContext, useCallback } from 'react';\nimport { cloneDeep } from 'lodash';\n\nimport TreeViewContext, { defaultRelativeMouseCoord } from '../TreeViewContext';\nimport { getNodeById, focusItem } from './tree-helpers';\nimport { inferHoverItemKinshipDrop, inferKeyboardKinshipDrop, isDropValid } from './dnd-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from '../sharedTypes';\n\nexport const useDnDHelpers = () => {\n  const ctx = useContext(TreeViewContext);\n\n  const {\n    props: { data, onOrderChange, restrictDragAndDrop },\n    relativeMouseCord,\n    setRelativeMouseCord,\n    visibleItems,\n    isDragging,\n    setIsDragging,\n    isKeyboardDragging,\n    setIsKeyboardDragging,\n    setDraggedItem,\n    setFocusedItem,\n    triggerTreeRerender,\n    tree,\n    treeRoot,\n    draggedItem,\n  } = ctx;\n\n  const onSortEnd = useCallback(\n    ({ oldIndex, newIndex, isKeySorting }: { oldIndex: number; newIndex: number; isKeySorting: boolean }) => {\n      const { isBefore, isAfter, item: overItem, isValid } = relativeMouseCord;\n      if (draggedItem && tree && treeRoot && overItem) {\n        let newItems = cloneDeep(data);\n        // if dropping in same position do nothing\n        // if the drop is not allowed do nothing\n        if (oldIndex === newIndex || !isValid) {\n          // onOrderChange(newItems, data);\n          setIsDragging(false);\n          setDraggedItem(null);\n          triggerTreeRerender();\n          return;\n        }\n\n        // if we are moving from topToBottom the offset changes\n        const movementDirection = newIndex > oldIndex ? ('topToBottom' as const) : ('bottomToTop' as const);\n\n        let newNestedIndex;\n        let newParentNode;\n        if (isKeySorting) {\n          const kinship = inferKeyboardKinshipDrop({\n            items: visibleItems,\n\n            newIndex,\n          });\n          newNestedIndex = kinship.newNestedIndex;\n          newParentNode = kinship.newParentNode;\n        } else {\n          const kinship = inferHoverItemKinshipDrop({\n            isBefore,\n            isAfter,\n            overItem,\n            movementDirection,\n            draggedItem,\n          });\n          newNestedIndex = kinship.newNestedIndex;\n          newParentNode = kinship.newParentNode;\n        }\n\n        const newMovedItemNode = tree.parse(draggedItem.node.model);\n        getNodeById(treeRoot, draggedItem.id).drop();\n        if (newParentNode && typeof newNestedIndex === 'number') {\n          newParentNode.addChildAtIndex(newMovedItemNode, newNestedIndex);\n\n          if (newParentNode.isRoot()) {\n            newItems = [...newParentNode.model.children];\n          } else {\n            newItems = [...treeRoot.model.children];\n          }\n        }\n\n        onOrderChange(newItems, data, draggedItem);\n        setIsDragging(false);\n        setDraggedItem(null);\n        triggerTreeRerender();\n      }\n    },\n    [\n      data,\n      draggedItem,\n      relativeMouseCord,\n      visibleItems,\n      tree,\n      treeRoot,\n      onOrderChange,\n      triggerTreeRerender,\n      setIsDragging,\n      setDraggedItem,\n    ],\n  );\n\n  const onSortStart = useCallback(\n    () => {},\n    // ({ node, index, collection, isKeySorting }, event) => {\n    // console.log('node :>> ', node);\n    // console.log('isKeySorting :>> ', isKeySorting);\n    // console.log('event :>> ', event);\n    // const item = collection?.[index] || visibleItems[index];\n    // setIsDragging(true);\n    // setDraggedItem(item);\n    // },\n    [],\n  );\n\n  const updateBeforeSortStart = useCallback(\n    (beforeStartArgs: { index: number; isKeySorting: boolean }) =>\n      new Promise((resolve) => {\n        const { index, isKeySorting } = beforeStartArgs;\n\n        const item = visibleItems[index];\n        const { isExpanded } = item.node.model;\n\n        if (isExpanded) {\n          item.node.model.isExpanded = false;\n          triggerTreeRerender();\n        }\n        setRelativeMouseCord(defaultRelativeMouseCoord);\n        setIsKeyboardDragging(isKeySorting);\n        setIsDragging(true);\n        setDraggedItem(item);\n        focusItem(null);\n        setFocusedItem(null);\n        if (document.activeElement && typeof (document.activeElement as HTMLElement).blur === 'function')\n          (document.activeElement as HTMLElement).blur();\n        resolve(true);\n      }),\n    [\n      visibleItems,\n      setRelativeMouseCord,\n      setIsKeyboardDragging,\n      setIsDragging,\n      setDraggedItem,\n      setFocusedItem,\n      triggerTreeRerender,\n    ],\n  );\n\n  // tracks mouse coords relative to an element to check if the drop happens\n  // at the top/center/bottom of an element to choose where to move the element\n  // requested in the specs\n  const onMouseDragOverItem = useCallback(\n    ({\n      event,\n      item,\n      itemIndex,\n      setIsDraggingOverThis,\n      openFolderOnHoverTimeout,\n    }: {\n      event: React.MouseEvent<HTMLLIElement>;\n      item: DSTreeviewT.Item;\n      itemIndex: number;\n      setIsDraggingOverThis: DSTreeviewInternalsT.StateSetter<boolean>;\n      openFolderOnHoverTimeout: React.MutableRefObject<NodeJS.Timeout | null>;\n    }) => {\n      const { node } = item;\n      const { nodeItemRef } = node.model;\n      if (isDragging && !isKeyboardDragging && draggedItem) {\n        const rect = nodeItemRef?.current?.getBoundingClientRect();\n        if (rect) {\n          const x = event.clientX - rect.left; // x position within the element.\n          const y = event.clientY - rect.top; // y position within the element.\n\n          // by spec we need to track where the drop will happens\n          // if drop happens on top 25% drop before\n          // if drop happens on bottom of 25% drop after\n          // if drop happens in the middle 50% either invalid or drop into children\n          const { height: elementHeight } = rect;\n          const dropBeforeMaxY = elementHeight * 0.25;\n          const dropAfterMinY = elementHeight - elementHeight * 0.25;\n          const isBefore = y < dropBeforeMaxY;\n          const isAfter = y > dropAfterMinY;\n          const isValid = isDropValid({\n            isBefore,\n            isAfter,\n            draggedItem,\n            overItem: item,\n            restrictDragAndDrop,\n          });\n          setRelativeMouseCord({\n            isBefore,\n            isAfter,\n            isValid,\n            item,\n            x,\n            y,\n            relativeElementDOMRect: rect,\n            relativeElementIndex: itemIndex,\n          });\n          setIsDraggingOverThis(true);\n\n          if (\n            !openFolderOnHoverTimeout?.current && // only set the interval if it wasn't set already once\n            draggedItem?.id !== item?.id && // don't open ghost element\n            (item.isGroup || item.children.length > 0) && // only open groups\n            !restrictDragAndDrop\n          ) {\n            openFolderOnHoverTimeout.current = setTimeout(() => {\n              item.node.model.isExpanded = true;\n              openFolderOnHoverTimeout.current = null;\n              triggerTreeRerender();\n            }, 1000);\n          }\n        }\n      } else {\n        setRelativeMouseCord(defaultRelativeMouseCoord);\n      }\n    },\n    [isDragging, isKeyboardDragging, draggedItem, restrictDragAndDrop, setRelativeMouseCord, triggerTreeRerender],\n  );\n\n  return {\n    updateBeforeSortStart,\n    onSortStart,\n    onSortEnd,\n    onMouseDragOverItem,\n  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADKvB,mBAA+C;AAC/C,oBAA0B;AAE1B,6BAA2D;AAC3D,0BAAuC;AACvC,yBAAiF;AAI1E,MAAM,gBAAgB,MAAM;AACjC,QAAM,MAAM,6BAAW;AAEvB,QAAM;AAAA,IACJ,OAAO,EAAE,MAAM,eAAe;AAAA,IAC9B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,MACE;AAEJ,QAAM,YAAY,8BAChB,CAAC,EAAE,UAAU,UAAU,mBAAkF;AACvG,UAAM,EAAE,UAAU,SAAS,MAAM,UAAU,YAAY;AACvD,QAAI,eAAe,QAAQ,YAAY,UAAU;AAC/C,UAAI,WAAW,6BAAU;AAGzB,UAAI,aAAa,YAAY,CAAC,SAAS;AAErC,sBAAc;AACd,uBAAe;AACf;AACA;AAAA;AAIF,YAAM,oBAAoB,WAAW,WAAY,gBAA2B;AAE5E,UAAI;AACJ,UAAI;AACJ,UAAI,cAAc;AAChB,cAAM,UAAU,iDAAyB;AAAA,UACvC,OAAO;AAAA,UAEP;AAAA;AAEF,yBAAiB,QAAQ;AACzB,wBAAgB,QAAQ;AAAA,aACnB;AACL,cAAM,UAAU,kDAA0B;AAAA,UACxC;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA;AAEF,yBAAiB,QAAQ;AACzB,wBAAgB,QAAQ;AAAA;AAG1B,YAAM,mBAAmB,KAAK,MAAM,YAAY,KAAK;AACrD,2CAAY,UAAU,YAAY,IAAI;AACtC,UAAI,iBAAiB,OAAO,mBAAmB,UAAU;AACvD,sBAAc,gBAAgB,kBAAkB;AAEhD,YAAI,cAAc,UAAU;AAC1B,qBAAW,CAAC,GAAG,cAAc,MAAM;AAAA,eAC9B;AACL,qBAAW,CAAC,GAAG,SAAS,MAAM;AAAA;AAAA;AAIlC,oBAAc,UAAU,MAAM;AAC9B,oBAAc;AACd,qBAAe;AACf;AAAA;AAAA,KAGJ;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAIJ,QAAM,cAAc,8BAClB,MAAM;AAAA,KASN;AAGF,QAAM,wBAAwB,8BAC5B,CAAC,oBACC,IAAI,QAAQ,CAAC,YAAY;AACvB,UAAM,EAAE,OAAO,iBAAiB;AAEhC,UAAM,OAAO,aAAa;AAC1B,UAAM,EAAE,eAAe,KAAK,KAAK;AAEjC,QAAI,YAAY;AACd,WAAK,KAAK,MAAM,aAAa;AAC7B;AAAA;AAEF,yBAAqB;AACrB,0BAAsB;AACtB,kBAAc;AACd,mBAAe;AACf,uCAAU;AACV,mBAAe;AACf,QAAI,SAAS,iBAAiB,OAAQ,SAAS,cAA8B,SAAS;AACpF,MAAC,SAAS,cAA8B;AAC1C,YAAQ;AAAA,MAEZ;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAOJ,QAAM,sBAAsB,8BAC1B,CAAC;AAAA,IACC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,QAOI;AACJ,UAAM,EAAE,SAAS;AACjB,UAAM,EAAE,gBAAgB,KAAK;AAC7B,QAAI,cAAc,CAAC,sBAAsB,aAAa;AACpD,YAAM,OAAO,aAAa,SAAS;AACnC,UAAI,MAAM;AACR,cAAM,IAAI,MAAM,UAAU,KAAK;AAC/B,cAAM,IAAI,MAAM,UAAU,KAAK;AAM/B,cAAM,EAAE,QAAQ,kBAAkB;AAClC,cAAM,iBAAiB,gBAAgB;AACvC,cAAM,gBAAgB,gBAAgB,gBAAgB;AACtD,cAAM,WAAW,IAAI;AACrB,cAAM,UAAU,IAAI;AACpB,cAAM,UAAU,oCAAY;AAAA,UAC1B;AAAA,UACA;AAAA,UACA;AAAA,UACA,UAAU;AAAA,UACV;AAAA;AAEF,6BAAqB;AAAA,UACnB;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,wBAAwB;AAAA,UACxB,sBAAsB;AAAA;AAExB,8BAAsB;AAEtB,YACE,CAAC,0BAA0B,WAC3B,aAAa,OAAO,MAAM,MACzB,MAAK,WAAW,KAAK,SAAS,SAAS,MACxC,CAAC,qBACD;AACA,mCAAyB,UAAU,WAAW,MAAM;AAClD,iBAAK,KAAK,MAAM,aAAa;AAC7B,qCAAyB,UAAU;AACnC;AAAA,aACC;AAAA;AAAA;AAAA,WAGF;AACL,2BAAqB;AAAA;AAAA,KAGzB,CAAC,YAAY,oBAAoB,aAAa,qBAAqB,sBAAsB;AAG3F,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA;",
+  "names": []
+}

package/cjs/utils/useInstanceRefActions.js

@@ -1,20 +1,41 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-require('core-js/modules/web.dom-collections.iterator.js');
-var React = require('react');
-var treeHelpers = require('./tree-helpers.js');
-var groupExpandsHelpers = require('./group-expands-helpers.js');
-
-const useInstanceRefActions = (_ref, ctx) => {
-  let {
-    actions
-  } = _ref;
+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 useInstanceRefActions_exports = {};
+__export(useInstanceRefActions_exports, {
+  useInstanceRefActions: () => useInstanceRefActions
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_tree_helpers = require("./tree-helpers");
+var import_group_expands_helpers = require("./group-expands-helpers");
+const useInstanceRefActions = ({ actions }, ctx) => {
   const {
-    props: {
-      onItemFocus
-    },
+    props: { onItemFocus },
     virtualListHelpers,
     treeRoot,
     visibleItems,
@@ -24,64 +45,54 @@ const useInstanceRefActions = (_ref, ctx) => {
     setFocusedItem,
     setLatestToggledItem
   } = ctx;
-  const {
-    current: promises
-  } = React.useRef({});
-  const {
-    scrollToIndex
-  } = React.useMemo(() => virtualListHelpers, [virtualListHelpers]);
-  const [expandPromise, setPromise] = React.useState();
-  React.useEffect(() => {
+  const { current: promises } = (0, import_react.useRef)({});
+  const { scrollToIndex } = (0, import_react.useMemo)(() => virtualListHelpers, [virtualListHelpers]);
+  const [expandPromise, setPromise] = (0, import_react.useState)();
+  (0, import_react.useEffect)(() => {
     if (expandPromise && promises.expandResolve) {
       promises.expandResolve(visibleItems);
       promises.expandResolve = null;
       setPromise(null);
     }
   }, [visibleItems, expandPromise, promises]);
-  actions.toggleExpandAll = React.useCallback(isExpand => {
-    const p = new Promise(resolve => {
+  actions.toggleExpandAll = (0, import_react.useCallback)((isExpand) => {
+    const p = new Promise((resolve) => {
       promises.expandResolve = resolve;
-      if (treeRoot) groupExpandsHelpers.toggleExpandAllHelper(isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);
+      if (treeRoot)
+        (0, import_group_expands_helpers.toggleExpandAllHelper)(isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);
     });
     setPromise(p);
     return p;
   }, [promises, treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState]);
-  actions.scrollTo = React.useCallback(function (indx) {
-    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      align: 'start'
-    };
-    if (scrollToIndex) scrollToIndex(indx, opts);
+  actions.scrollTo = (0, import_react.useCallback)((indx, opts = { align: "start" }) => {
+    if (scrollToIndex)
+      scrollToIndex(indx, opts);
   }, [scrollToIndex]);
-  actions.setSelectedItemByVirtualIndex = React.useCallback(index => {
+  actions.setSelectedItemByVirtualIndex = (0, import_react.useCallback)((index) => {
     const itemByIndex = visibleItems[index];
     setSelectedItem(itemByIndex);
   }, [visibleItems, setSelectedItem]);
-  actions.setFocusedItemByVirtualIndex = React.useCallback(function (index) {
-    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      align: 'start',
-      withScroll: false
-    };
+  actions.setFocusedItemByVirtualIndex = (0, import_react.useCallback)((index, opts = { align: "start", withScroll: false }) => {
     const itemByIndex = visibleItems[index];
     const onItemFocusParams = {
       itemIndex: itemByIndex.virtualIndex,
       scrollToItem: () => scrollToIndex(index, opts),
       item: itemByIndex
     };
-
     if (opts.withScroll && scrollToIndex) {
       scrollToIndex(index, opts);
       setTimeout(() => {
         setFocusedItem(itemByIndex);
-        treeHelpers.focusItem(itemByIndex);
+        (0, import_tree_helpers.focusItem)(itemByIndex);
         onItemFocus(onItemFocusParams);
       }, 300);
     } else {
       setFocusedItem(itemByIndex);
-      treeHelpers.focusItem(itemByIndex);
+      (0, import_tree_helpers.focusItem)(itemByIndex);
       onItemFocus(onItemFocusParams);
     }
   }, [visibleItems, scrollToIndex, setFocusedItem, onItemFocus]);
   return actions;
 };
-
-exports.useInstanceRefActions = useInstanceRefActions;
+module.exports = __toCommonJS(useInstanceRefActions_exports);
+//# sourceMappingURL=useInstanceRefActions.js.map

package/cjs/utils/useInstanceRefActions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/useInstanceRefActions.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useEffect, useMemo, useState, useRef, useCallback } from 'react';\nimport { focusItem } from './tree-helpers';\nimport { toggleExpandAllHelper } from './group-expands-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from '../sharedTypes';\n\ninterface PromisesRefT {\n  expandResolve?: null | ((value: DSTreeviewT.Item[] | PromiseLike<DSTreeviewT.Item[]>) => void);\n  scrollTo?: null | ((value: DSTreeviewT.Item[] | PromiseLike<DSTreeviewT.Item[]>) => void);\n}\n\nexport const useInstanceRefActions = ({ actions }: DSTreeviewT.InstanceRef, ctx: DSTreeviewInternalsT.CTX) => {\n  const {\n    props: { onItemFocus },\n    virtualListHelpers,\n    treeRoot,\n    visibleItems,\n    triggerTreeRerender,\n    updateUserExpandedState,\n    setSelectedItem,\n    setFocusedItem,\n    setLatestToggledItem,\n  } = ctx;\n  const { current: promises } = useRef<PromisesRefT>({});\n  const { scrollToIndex } = useMemo(() => virtualListHelpers, [virtualListHelpers]);\n  const [expandPromise, setPromise] = useState<Promise<DSTreeviewT.Item[]> | undefined | null>();\n\n  useEffect(() => {\n    if (expandPromise && promises.expandResolve) {\n      promises.expandResolve(visibleItems);\n      promises.expandResolve = null;\n      setPromise(null);\n    }\n  }, [visibleItems, expandPromise, promises]);\n\n  actions.toggleExpandAll = useCallback(\n    (isExpand) => {\n      const p = new Promise<DSTreeviewT.Item[]>((resolve) => {\n        promises.expandResolve = resolve;\n        if (treeRoot)\n          toggleExpandAllHelper(isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);\n      });\n      setPromise(p);\n      return p;\n    },\n    [promises, treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState],\n  );\n  actions.scrollTo = useCallback(\n    (indx, opts = { align: 'start' }) => {\n      if (scrollToIndex) scrollToIndex(indx, opts);\n    },\n    [scrollToIndex],\n  );\n\n  actions.setSelectedItemByVirtualIndex = useCallback(\n    (index) => {\n      const itemByIndex = visibleItems[index];\n      setSelectedItem(itemByIndex);\n    },\n    [visibleItems, setSelectedItem],\n  );\n\n  actions.setFocusedItemByVirtualIndex = useCallback(\n    (index, opts = { align: 'start', withScroll: false }) => {\n      const itemByIndex = visibleItems[index];\n      const onItemFocusParams = {\n        itemIndex: itemByIndex.virtualIndex as number,\n        scrollToItem: () => scrollToIndex(index, opts),\n        item: itemByIndex,\n      };\n\n      if (opts.withScroll && scrollToIndex) {\n        scrollToIndex(index, opts);\n        setTimeout(() => {\n          setFocusedItem(itemByIndex);\n          focusItem(itemByIndex);\n          onItemFocus(onItemFocusParams);\n        }, 300);\n      } else {\n        setFocusedItem(itemByIndex);\n        focusItem(itemByIndex);\n        onItemFocus(onItemFocusParams);\n      }\n    },\n    [visibleItems, scrollToIndex, setFocusedItem, onItemFocus],\n  );\n\n  return actions;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkE;AAClE,0BAA0B;AAC1B,mCAAsC;AAS/B,MAAM,wBAAwB,CAAC,EAAE,WAAoC,QAAkC;AAC5G,QAAM;AAAA,IACJ,OAAO,EAAE;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,MACE;AACJ,QAAM,EAAE,SAAS,aAAa,yBAAqB;AACnD,QAAM,EAAE,kBAAkB,0BAAQ,MAAM,oBAAoB,CAAC;AAC7D,QAAM,CAAC,eAAe,cAAc;AAEpC,8BAAU,MAAM;AACd,QAAI,iBAAiB,SAAS,eAAe;AAC3C,eAAS,cAAc;AACvB,eAAS,gBAAgB;AACzB,iBAAW;AAAA;AAAA,KAEZ,CAAC,cAAc,eAAe;AAEjC,UAAQ,kBAAkB,8BACxB,CAAC,aAAa;AACZ,UAAM,IAAI,IAAI,QAA4B,CAAC,YAAY;AACrD,eAAS,gBAAgB;AACzB,UAAI;AACF,gEAAsB,UAAU,UAAU,qBAAqB,sBAAsB;AAAA;AAEzF,eAAW;AACX,WAAO;AAAA,KAET,CAAC,UAAU,UAAU,qBAAqB,sBAAsB;AAElE,UAAQ,WAAW,8BACjB,CAAC,MAAM,OAAO,EAAE,OAAO,cAAc;AACnC,QAAI;AAAe,oBAAc,MAAM;AAAA,KAEzC,CAAC;AAGH,UAAQ,gCAAgC,8BACtC,CAAC,UAAU;AACT,UAAM,cAAc,aAAa;AACjC,oBAAgB;AAAA,KAElB,CAAC,cAAc;AAGjB,UAAQ,+BAA+B,8BACrC,CAAC,OAAO,OAAO,EAAE,OAAO,SAAS,YAAY,YAAY;AACvD,UAAM,cAAc,aAAa;AACjC,UAAM,oBAAoB;AAAA,MACxB,WAAW,YAAY;AAAA,MACvB,cAAc,MAAM,cAAc,OAAO;AAAA,MACzC,MAAM;AAAA;AAGR,QAAI,KAAK,cAAc,eAAe;AACpC,oBAAc,OAAO;AACrB,iBAAW,MAAM;AACf,uBAAe;AACf,2CAAU;AACV,oBAAY;AAAA,SACX;AAAA,WACE;AACL,qBAAe;AACf,yCAAU;AACV,kBAAY;AAAA;AAAA,KAGhB,CAAC,cAAc,eAAe,gBAAgB;AAGhD,SAAO;AAAA;",
+  "names": []
+}

package/cjs/utils/useTree.js

@@ -1,102 +1,98 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-require('core-js/modules/web.dom-collections.iterator.js');
-require('core-js/modules/esnext.async-iterator.filter.js');
-require('core-js/modules/esnext.iterator.constructor.js');
-require('core-js/modules/esnext.iterator.filter.js');
-require('core-js/modules/esnext.async-iterator.for-each.js');
-require('core-js/modules/esnext.iterator.for-each.js');
-var React = require('react');
-var TreeModel = require('tree-model');
-var lodash = require('lodash');
-var treeHelpers = require('./tree-helpers.js');
-var groupExpandsHelpers = require('./group-expands-helpers.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var TreeModel__default = /*#__PURE__*/_interopDefaultLegacy(TreeModel);
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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 useTree_exports = {};
+__export(useTree_exports, {
+  useTree: () => useTree
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_tree_model = __toESM(require("tree-model"));
+var import_lodash = require("lodash");
+var import_tree_helpers = require("./tree-helpers");
+var import_group_expands_helpers = require("./group-expands-helpers");
 const useTree = (data, props, states) => {
-  const {
-    setExpandedGroups
-  } = states;
-  const unfrozenData = React.useMemo(() => lodash.cloneDeep(data), [data]); // convert data into a TreeModel with extra isExpanded prop
-  // root element type is an exception, children model is based on what the dev passed on
-  // since root is an excepcion we must typecast
-
-  const tree = React.useMemo(() => new TreeModel__default["default"](), []);
-  const [treeData, setTreeData] = React.useState({
-    id: '__ds_tree_root',
-    name: '__root',
+  const { setExpandedGroups } = states;
+  const unfrozenData = (0, import_react.useMemo)(() => (0, import_lodash.cloneDeep)(data), [data]);
+  const tree = (0, import_react.useMemo)(() => new import_tree_model.default(), []);
+  const [treeData, setTreeData] = (0, import_react.useState)({
+    id: "__ds_tree_root",
+    name: "__root",
     isExpanded: true,
     children: unfrozenData
   });
-  React.useEffect(() => {
+  (0, import_react.useEffect)(() => {
     setTreeData({
-      id: '__ds_tree_root',
-      name: '__root',
+      id: "__ds_tree_root",
+      name: "__root",
       isExpanded: true,
       children: unfrozenData
     });
-  }, [unfrozenData]); // expose a way to rerender the tree
-  //   used for expand functionality
-
-  const [rerenderItems, setRerenderItems] = React.useState({});
-  const triggerTreeRerender = React.useCallback(() => {
+  }, [unfrozenData]);
+  const [rerenderItems, setRerenderItems] = (0, import_react.useState)({});
+  const triggerTreeRerender = (0, import_react.useCallback)(() => {
     setRerenderItems({});
-  }, []); // when re-rendering we re-parse the list
-
-  const [treeRoot, setTreeRoot] = React.useState(tree.parse(treeData));
-  React.useEffect(() => {
+  }, []);
+  const [treeRoot, setTreeRoot] = (0, import_react.useState)(tree.parse(treeData));
+  (0, import_react.useEffect)(() => {
     setTreeRoot(tree.parse(treeData));
   }, [treeData, rerenderItems, tree]);
-  const [visibleItems, setVisibleItems] = React.useState([]);
-  const {
-    searchQuery,
-    highlightOnlyQuery,
-    onVisibleItemsChange,
-    selection,
-    expanded,
-    onExpandChange
-  } = props;
-  const updateUserExpandedState = React.useCallback(() => {
-    groupExpandsHelpers.updateExpandedState(treeRoot, onExpandChange);
-  }, [treeRoot, onExpandChange]); // we add missing properties to the received Items
-  //   not the best of the patterns, but it works
-  //   this is where we convert "SimpleItems" to "Items"
-  //   this was done to avoid breaking changes back in v1
-
-  React.useEffect(() => {
+  const [visibleItems, setVisibleItems] = (0, import_react.useState)([]);
+  const { searchQuery, highlightOnlyQuery, onVisibleItemsChange, selection, expanded, onExpandChange } = props;
+  const updateUserExpandedState = (0, import_react.useCallback)(() => {
+    (0, import_group_expands_helpers.updateExpandedState)(treeRoot, onExpandChange);
+  }, [treeRoot, onExpandChange]);
+  (0, import_react.useEffect)(() => {
     const parsedVisibleItems = [];
     const newExpandedHashMap = {};
-    const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking
-
-    treeRoot.walk(node => {
-      treeHelpers.enrichNodeModelInPlace(node, searchQuery, selection, expanded);
-      if (node.model.id && node.model.isGroup && node.model.isExpanded) newExpandedHashMap[node.model.id] = true;
+    treeRoot.walk((node) => {
+      const shouldContinueWalking = true;
+      (0, import_tree_helpers.enrichNodeModelInPlace)(node, searchQuery, selection, expanded);
+      if (node.model.id && node.model.isGroup && node.model.isExpanded)
+        newExpandedHashMap[node.model.id] = true;
       return shouldContinueWalking;
     });
-    treeHelpers.walkVisibles(treeRoot, node => {
-      parsedVisibleItems.push(_objectSpread(_objectSpread({}, node.model), {}, {
-        node
-      }));
+    (0, import_tree_helpers.walkVisibles)(treeRoot, (node) => {
+      parsedVisibleItems.push({ ...node.model, node });
     }, true, highlightOnlyQuery);
     setVisibleItems(parsedVisibleItems);
     onVisibleItemsChange(parsedVisibleItems);
-    setExpandedGroups(newExpandedHashMap); // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [treeRoot, rerenderItems, searchQuery, highlightOnlyQuery, selection, expanded, setExpandedGroups // onVisibleItemsChange // evaluate potential performance hit?
+    setExpandedGroups(newExpandedHashMap);
+  }, [
+    treeRoot,
+    rerenderItems,
+    searchQuery,
+    highlightOnlyQuery,
+    selection,
+    expanded,
+    setExpandedGroups
   ]);
-  const flattenedItems = React.useMemo(() => treeHelpers.flattenTreeForDnD(data), [data]);
   return {
     visibleItems,
-    flattenedItems,
     tree,
     treeRoot,
     rerenderItems,
@@ -104,5 +100,5 @@ const useTree = (data, props, states) => {
     updateUserExpandedState
   };
 };
-
-exports.useTree = useTree;
+module.exports = __toCommonJS(useTree_exports);
+//# sourceMappingURL=useTree.js.map

package/cjs/utils/useTree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/useTree.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useState, useCallback, useMemo, useEffect } from 'react';\nimport TreeModel from 'tree-model';\nimport { cloneDeep } from 'lodash';\n\nimport { walkVisibles, enrichNodeModelInPlace } from './tree-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from '../sharedTypes';\nimport { updateExpandedState } from './group-expands-helpers';\n\nexport const useTree = (\n  data: DSTreeviewT.SimpleItem[],\n  props: DSTreeviewT.Props,\n  states: {\n    setExpandedGroups: DSTreeviewInternalsT.StateSetter<DSTreeviewT.ExpandedItems>;\n  },\n) => {\n  const { setExpandedGroups } = states;\n  const unfrozenData = useMemo(() => cloneDeep(data), [data]);\n\n  // convert data into a TreeModel with extra isExpanded prop\n  // root element type is an exception, children model is based on what the dev passed on\n  // since root is an excepcion we must typecast\n  const tree = useMemo(() => new TreeModel(), []);\n  const [treeData, setTreeData] = useState({\n    id: '__ds_tree_root',\n    name: '__root',\n    isExpanded: true,\n    children: unfrozenData,\n  } as unknown as DSTreeviewT.Item);\n\n  useEffect(() => {\n    setTreeData({\n      id: '__ds_tree_root',\n      name: '__root',\n      isExpanded: true,\n      children: unfrozenData,\n    } as unknown as DSTreeviewT.Item);\n  }, [unfrozenData]);\n\n  // expose a way to rerender the tree\n  //   used for expand functionality\n  const [rerenderItems, setRerenderItems] = useState({});\n  const triggerTreeRerender = useCallback(() => {\n    setRerenderItems({});\n  }, []);\n\n  // when re-rendering we re-parse the list\n  const [treeRoot, setTreeRoot] = useState(tree.parse(treeData));\n  useEffect(() => {\n    setTreeRoot(tree.parse(treeData));\n  }, [treeData, rerenderItems, tree]);\n\n  const [visibleItems, setVisibleItems] = useState<DSTreeviewT.Item[]>([]);\n\n  const { searchQuery, highlightOnlyQuery, onVisibleItemsChange, selection, expanded, onExpandChange } = props;\n\n  const updateUserExpandedState = useCallback(() => {\n    updateExpandedState(treeRoot, onExpandChange);\n  }, [treeRoot, onExpandChange]);\n  // we add missing properties to the received Items\n  //   not the best of the patterns, but it works\n  //   this is where we convert \"SimpleItems\" to \"Items\"\n  //   this was done to avoid breaking changes back in v1\n  useEffect(() => {\n    const parsedVisibleItems: DSTreeviewT.Item[] = [];\n    const newExpandedHashMap: DSTreeviewT.ExpandedItems = {};\n    treeRoot.walk((node) => {\n      const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking\n      enrichNodeModelInPlace(node, searchQuery, selection, expanded);\n      if (node.model.id && node.model.isGroup && node.model.isExpanded) newExpandedHashMap[node.model.id] = true;\n      return shouldContinueWalking;\n    });\n\n    walkVisibles(\n      treeRoot,\n      (node) => {\n        parsedVisibleItems.push({ ...node.model, node });\n      },\n      true,\n      highlightOnlyQuery,\n    );\n    setVisibleItems(parsedVisibleItems);\n    onVisibleItemsChange(parsedVisibleItems);\n\n    setExpandedGroups(newExpandedHashMap);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [\n    treeRoot,\n    rerenderItems,\n    searchQuery,\n    highlightOnlyQuery,\n    selection,\n    expanded,\n    setExpandedGroups,\n    // onVisibleItemsChange // evaluate potential performance hit?\n  ]);\n\n  return {\n    visibleItems,\n    tree,\n    treeRoot,\n    rerenderItems,\n    triggerTreeRerender,\n    updateUserExpandedState,\n  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA0D;AAC1D,wBAAsB;AACtB,oBAA0B;AAE1B,0BAAqD;AAGrD,mCAAoC;AAE7B,MAAM,UAAU,CACrB,MACA,OACA,WAGG;AACH,QAAM,EAAE,sBAAsB;AAC9B,QAAM,eAAe,0BAAQ,MAAM,6BAAU,OAAO,CAAC;AAKrD,QAAM,OAAO,0BAAQ,MAAM,IAAI,6BAAa;AAC5C,QAAM,CAAC,UAAU,eAAe,2BAAS;AAAA,IACvC,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,UAAU;AAAA;AAGZ,8BAAU,MAAM;AACd,gBAAY;AAAA,MACV,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,UAAU;AAAA;AAAA,KAEX,CAAC;AAIJ,QAAM,CAAC,eAAe,oBAAoB,2BAAS;AACnD,QAAM,sBAAsB,8BAAY,MAAM;AAC5C,qBAAiB;AAAA,KAChB;AAGH,QAAM,CAAC,UAAU,eAAe,2BAAS,KAAK,MAAM;AACpD,8BAAU,MAAM;AACd,gBAAY,KAAK,MAAM;AAAA,KACtB,CAAC,UAAU,eAAe;AAE7B,QAAM,CAAC,cAAc,mBAAmB,2BAA6B;AAErE,QAAM,EAAE,aAAa,oBAAoB,sBAAsB,WAAW,UAAU,mBAAmB;AAEvG,QAAM,0BAA0B,8BAAY,MAAM;AAChD,0DAAoB,UAAU;AAAA,KAC7B,CAAC,UAAU;AAKd,8BAAU,MAAM;AACd,UAAM,qBAAyC;AAC/C,UAAM,qBAAgD;AACtD,aAAS,KAAK,CAAC,SAAS;AACtB,YAAM,wBAAwB;AAC9B,sDAAuB,MAAM,aAAa,WAAW;AACrD,UAAI,KAAK,MAAM,MAAM,KAAK,MAAM,WAAW,KAAK,MAAM;AAAY,2BAAmB,KAAK,MAAM,MAAM;AACtG,aAAO;AAAA;AAGT,0CACE,UACA,CAAC,SAAS;AACR,yBAAmB,KAAK,KAAK,KAAK,OAAO;AAAA,OAE3C,MACA;AAEF,oBAAgB;AAChB,yBAAqB;AAErB,sBAAkB;AAAA,KAEjB;AAAA,IACD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAIF,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA;",
+  "names": []
+}