@elliemae/ds-treeview 2.2.0-next.4 → 2.3.0-alpha.2

package/esm/utils/useTree.js

@@ -1,93 +1,67 @@
-import 'core-js/modules/esnext.async-iterator.filter.js';
-import 'core-js/modules/esnext.iterator.constructor.js';
-import 'core-js/modules/esnext.iterator.filter.js';
-import 'core-js/modules/esnext.async-iterator.for-each.js';
-import 'core-js/modules/esnext.iterator.for-each.js';
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import { useMemo, useState, useEffect, useCallback } from 'react';
-import TreeModel from 'tree-model';
-import { cloneDeep } from 'lodash';
-import { enrichNodeModelInPlace, walkVisibles, flattenTreeForDnD } from './tree-helpers.js';
-import { updateExpandedState } from './group-expands-helpers.js';
-
-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(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; }
+import * as React from "react";
+import { useState, useCallback, useMemo, useEffect } from "react";
+import TreeModel from "tree-model";
+import { cloneDeep } from "lodash";
+import { walkVisibles, enrichNodeModelInPlace } from "./tree-helpers";
+import { updateExpandedState } from "./group-expands-helpers";
 const useTree = (data, props, states) => {
-  const {
-    setExpandedGroups
-  } = states;
-  const unfrozenData = useMemo(() => 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 { setExpandedGroups } = states;
+  const unfrozenData = useMemo(() => cloneDeep(data), [data]);
   const tree = useMemo(() => new TreeModel(), []);
   const [treeData, setTreeData] = useState({
-    id: '__ds_tree_root',
-    name: '__root',
+    id: "__ds_tree_root",
+    name: "__root",
     isExpanded: true,
     children: unfrozenData
   });
   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
-
+  }, [unfrozenData]);
   const [rerenderItems, setRerenderItems] = useState({});
   const triggerTreeRerender = useCallback(() => {
     setRerenderItems({});
-  }, []); // when re-rendering we re-parse the list
-
+  }, []);
   const [treeRoot, setTreeRoot] = useState(tree.parse(treeData));
   useEffect(() => {
     setTreeRoot(tree.parse(treeData));
   }, [treeData, rerenderItems, tree]);
   const [visibleItems, setVisibleItems] = useState([]);
-  const {
-    searchQuery,
-    highlightOnlyQuery,
-    onVisibleItemsChange,
-    selection,
-    expanded,
-    onExpandChange
-  } = props;
+  const { searchQuery, highlightOnlyQuery, onVisibleItemsChange, selection, expanded, onExpandChange } = props;
   const updateUserExpandedState = useCallback(() => {
     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
-
+  }, [treeRoot, onExpandChange]);
   useEffect(() => {
     const parsedVisibleItems = [];
     const newExpandedHashMap = {};
-    const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking
-
-    treeRoot.walk(node => {
+    treeRoot.walk((node) => {
+      const shouldContinueWalking = true;
       enrichNodeModelInPlace(node, searchQuery, selection, expanded);
-      if (node.model.id && node.model.isGroup && node.model.isExpanded) newExpandedHashMap[node.model.id] = true;
+      if (node.model.id && node.model.isGroup && node.model.isExpanded)
+        newExpandedHashMap[node.model.id] = true;
       return shouldContinueWalking;
     });
-    walkVisibles(treeRoot, node => {
-      parsedVisibleItems.push(_objectSpread(_objectSpread({}, node.model), {}, {
-        node
-      }));
+    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 = useMemo(() => flattenTreeForDnD(data), [data]);
   return {
     visibleItems,
-    flattenedItems,
     tree,
     treeRoot,
     rerenderItems,
@@ -95,5 +69,7 @@ const useTree = (data, props, states) => {
     updateUserExpandedState
   };
 };
-
-export { useTree };
+export {
+  useTree
+};
+//# sourceMappingURL=useTree.js.map

package/esm/utils/useTree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../scripts/build/transpile/react-shim.js", "../../../src/utils/useTree.tsx"],
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "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"],
+  "mappings": "AAAA;ACAA;AACA;AACA;AAEA;AAGA;AAEO,MAAM,UAAU,CACrB,MACA,OACA,WAGG;AACH,QAAM,EAAE,sBAAsB;AAC9B,QAAM,eAAe,QAAQ,MAAM,UAAU,OAAO,CAAC;AAKrD,QAAM,OAAO,QAAQ,MAAM,IAAI,aAAa;AAC5C,QAAM,CAAC,UAAU,eAAe,SAAS;AAAA,IACvC,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,UAAU;AAAA;AAGZ,YAAU,MAAM;AACd,gBAAY;AAAA,MACV,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,UAAU;AAAA;AAAA,KAEX,CAAC;AAIJ,QAAM,CAAC,eAAe,oBAAoB,SAAS;AACnD,QAAM,sBAAsB,YAAY,MAAM;AAC5C,qBAAiB;AAAA,KAChB;AAGH,QAAM,CAAC,UAAU,eAAe,SAAS,KAAK,MAAM;AACpD,YAAU,MAAM;AACd,gBAAY,KAAK,MAAM;AAAA,KACtB,CAAC,UAAU,eAAe;AAE7B,QAAM,CAAC,cAAc,mBAAmB,SAA6B;AAErE,QAAM,EAAE,aAAa,oBAAoB,sBAAsB,WAAW,UAAU,mBAAmB;AAEvG,QAAM,0BAA0B,YAAY,MAAM;AAChD,wBAAoB,UAAU;AAAA,KAC7B,CAAC,UAAU;AAKd,YAAU,MAAM;AACd,UAAM,qBAAyC;AAC/C,UAAM,qBAAgD;AACtD,aAAS,KAAK,CAAC,SAAS;AACtB,YAAM,wBAAwB;AAC9B,6BAAuB,MAAM,aAAa,WAAW;AACrD,UAAI,KAAK,MAAM,MAAM,KAAK,MAAM,WAAW,KAAK,MAAM;AAAY,2BAAmB,KAAK,MAAM,MAAM;AACtG,aAAO;AAAA;AAGT,iBACE,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": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-treeview",
-  "version": "2.2.0-next.4",
+  "version": "2.3.0-alpha.2",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Tree View",
   "module": "./esm/index.js",
@@ -19,6 +19,10 @@
       "import": "./esm/utils/useInstanceRefActions.js",
       "require": "./cjs/utils/useInstanceRefActions.js"
     },
+    "./utils/useDnDHelpers": {
+      "import": "./esm/utils/useDnDHelpers.js",
+      "require": "./cjs/utils/useDnDHelpers.js"
+    },
     "./utils/tree-helpers": {
       "import": "./esm/utils/tree-helpers.js",
       "require": "./cjs/utils/tree-helpers.js"
@@ -47,6 +51,10 @@
       "import": "./esm/utils/group-expands-helpers.js",
       "require": "./cjs/utils/group-expands-helpers.js"
     },
+    "./utils/dnd-helpers": {
+      "import": "./esm/utils/dnd-helpers.js",
+      "require": "./cjs/utils/dnd-helpers.js"
+    },
     "./utils/array-helpers": {
       "import": "./esm/utils/array-helpers.js",
       "require": "./cjs/utils/array-helpers.js"
@@ -159,14 +167,6 @@
       "import": "./esm/parts/ExpandCaret.js",
       "require": "./cjs/parts/ExpandCaret.js"
     },
-    "./parts/DropIndicator": {
-      "import": "./esm/parts/DropIndicator.js",
-      "require": "./cjs/parts/DropIndicator.js"
-    },
-    "./parts/DnDHandle": {
-      "import": "./esm/parts/DnDHandle.js",
-      "require": "./cjs/parts/DnDHandle.js"
-    },
     "./parts/ChildrenCountDisplayer": {
       "import": "./esm/parts/ChildrenCountDisplayer.js",
       "require": "./cjs/parts/ChildrenCountDisplayer.js"
@@ -175,22 +175,6 @@
       "import": "./esm/parts/CheckboxSelectable.js",
       "require": "./cjs/parts/CheckboxSelectable.js"
     },
-    "./hoc/WithDnDSortableItemContext": {
-      "import": "./esm/hoc/WithDnDSortableItemContext.js",
-      "require": "./cjs/hoc/WithDnDSortableItemContext.js"
-    },
-    "./hoc/WithConditionalDnDContext": {
-      "import": "./esm/hoc/WithConditionalDnDContext.js",
-      "require": "./cjs/hoc/WithConditionalDnDContext.js"
-    },
-    "./hoc/SortableItemContext": {
-      "import": "./esm/hoc/SortableItemContext.js",
-      "require": "./cjs/hoc/SortableItemContext.js"
-    },
-    "./hoc/DnDTreeContext": {
-      "import": "./esm/hoc/DnDTreeContext.js",
-      "require": "./cjs/hoc/DnDTreeContext.js"
-    },
     "./config/useTreeview": {
       "import": "./esm/config/useTreeview.js",
       "require": "./cjs/config/useTreeview.js"
@@ -227,16 +211,16 @@
     "generateSubmodules": true
   },
   "dependencies": {
-    "@elliemae/ds-button": "2.2.0-next.4",
-    "@elliemae/ds-circular-progress-indicator": "2.2.0-next.4",
-    "@elliemae/ds-classnames": "2.2.0-next.4",
-    "@elliemae/ds-drag-and-drop": "2.2.0-next.4",
-    "@elliemae/ds-form": "2.2.0-next.4",
-    "@elliemae/ds-icons": "2.2.0-next.4",
-    "@elliemae/ds-props-helpers": "2.2.0-next.4",
-    "@elliemae/ds-shared": "2.2.0-next.4",
-    "@elliemae/ds-truncated-tooltip-text": "2.2.0-next.4",
-    "@elliemae/ds-utilities": "2.2.0-next.4",
+    "@elliemae/ds-button": "2.3.0-alpha.2",
+    "@elliemae/ds-circular-progress-indicator": "2.3.0-alpha.2",
+    "@elliemae/ds-classnames": "2.3.0-alpha.2",
+    "@elliemae/ds-form": "2.3.0-alpha.2",
+    "@elliemae/ds-icons": "2.3.0-alpha.2",
+    "@elliemae/ds-props-helpers": "2.3.0-alpha.2",
+    "@elliemae/ds-shared": "2.3.0-alpha.2",
+    "@elliemae/ds-truncated-tooltip-text": "2.3.0-alpha.2",
+    "@elliemae/ds-utilities": "2.3.0-alpha.2",
+    "@elliemae/react-sortable-hoc": "^1.0.0",
     "react-desc": "~4.1.3",
     "react-highlight-words": "~0.17.0",
     "react-virtual": "~2.3.2",

package/types/TreeView.d.ts

@@ -6,7 +6,7 @@ export declare namespace TreeView {
     var propTypes: React.WeakValidationMap<unknown>;
 }
 declare const TreeViewWithSchema: {
-    (props?: DSTreeviewT.Props | undefined): JSX.Element;
+    (props?: unknown): JSX.Element;
     propTypes: unknown;
     toTypescript: () => import("react-desc").TypescriptSchema;
 };

package/types/parts/TreeItem.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import React from 'react';
 import type { DSTreeviewT } from '../react-desc-prop-types';
 export declare const TreeListItem: React.ComponentType<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>>;
@@ -5,13 +6,19 @@ export declare const TreeListItemAddonsWrapper: React.ComponentType<{}>;
 interface PropsT {
     item: DSTreeviewT.Item;
     itemIndex: number;
-    isDragOverlay?: boolean;
-    virtualItemRef?: React.RefObject<HTMLLIElement>;
+    virtualItemRef: React.RefObject<HTMLLIElement>;
     itemWrapperStyle?: {
         [key: string]: unknown;
     };
     spaceForNestingLevel?: number;
+    onMouseDragOverItem?: (opts: {
+        event: React.MouseEvent<HTMLLIElement>;
+        item: DSTreeviewT.Item;
+        itemIndex: number;
+        setIsDraggingOverThis: React.Dispatch<React.SetStateAction<boolean>>;
+        openFolderOnHoverTimeout: React.MutableRefObject<NodeJS.Timeout | null>;
+    }) => void;
 }
 export declare const TreeItem: (props: PropsT) => JSX.Element;
-declare const _default: (props: PropsT) => JSX.Element;
-export default _default;
+export declare const DragAndDropTreeItem: React.ComponentClass<PropsT & import("@elliemae/react-sortable-hoc").SortableElementProps, any>;
+export {};

package/types/parts/TreeList.d.ts

@@ -17,4 +17,8 @@ interface PropsT {
     }) => void;
 }
 export declare const TreeList: (props: PropsT) => JSX.Element;
+export declare const DragAndDropTreeList: React.ComponentClass<PropsT & {
+    disableAnimation?: boolean | undefined;
+    getContainer: (element: React.ReactElement<unknown>) => HTMLElement | Promise<HTMLElement>;
+} & import("@elliemae/react-sortable-hoc").SortableContainerProps, any>;
 export {};

package/types/plugins/dnd/TreeDndPlugin.d.ts

@@ -1 +1,3 @@
+/// <reference types="react" />
+export declare const TreeDnD: () => JSX.Element;
 export declare const TreeDndPlugin = "tree-dnd";

package/types/react-desc-prop-types.d.ts

@@ -13,7 +13,7 @@ export declare namespace DSTreeviewT {
     interface SimpleItem {
         [key: string]: unknown;
         name: string;
-        children?: SimpleItem[];
+        children: SimpleItem[];
         id: StringOrNum;
     }
     interface Item extends SimpleItem {
@@ -27,19 +27,9 @@ export declare namespace DSTreeviewT {
         matchesSearchQuery?: boolean;
         nodeItemRef?: React.RefObject<HTMLLIElement>;
         model: TreeModel.Node<Item>['model'];
-        node: TreeModel.Node<Item> & {
-            parent?: TreeModel.Node<Item>;
-        };
+        node: TreeModel.Node<Item>;
         nodePath: TreeModel.Node<Item>[];
     }
-    interface DndItem {
-        uid: string;
-        depth: number;
-        realIndex: number;
-        childrenCount: number;
-        parentId: string | null;
-        original: SimpleItem;
-    }
     interface Actions {
         toggleExpandAll: (isExpand: boolean) => Promise<DSTreeviewT.Item[]>;
         scrollTo: DSTreeviewT.ScrollToFunc;
@@ -60,7 +50,6 @@ export declare namespace DSTreeviewT {
         fluid: boolean;
         isMultiSelect: boolean;
         isSingleSelect: boolean;
-        getIsDropValid: (active: DndItem, over: DndItem, dropIndicatorPosition: 'none' | 'before' | 'after' | 'inside') => boolean;
         restrictDragAndDrop: boolean;
         showChildrenAmount: boolean;
         sortable: boolean;
@@ -73,7 +62,7 @@ export declare namespace DSTreeviewT {
             item: Item;
         }) => void;
         onVisibleItemsChange: (newVisibleItems: Item[]) => void;
-        onOrderChange: (newData: SimpleItem[], oldData: SimpleItem[], draggedItem: DndItem) => void;
+        onOrderChange: (newData: Item[], oldData: Item[], draggedItem: Item) => void;
         onSelectionChange: (selection: SelectionItems, item: Item, meta: {
             scrollToItem: ScrollToItemFunc;
             itemIndex: number;
@@ -135,9 +124,6 @@ export declare const TreeViewPropTypes: {
     isLoading: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
-    getIsDropValid: {
-        deprecated: import("react-desc").PropTypesDescValidator;
-    };
     restrictDragAndDrop: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };

package/types/sharedTypes.d.ts

@@ -19,15 +19,22 @@ export declare namespace DSTreeviewInternalsT {
     interface CTX {
         props: DSTreeviewT.Props;
         visibleItems: DSTreeviewT.Item[];
-        flattenedItems: DSTreeviewT.DndItem[];
         withRadioChecks: boolean;
         withCheckboxChecks: boolean;
         withDragAndDrop: boolean;
+        relativeMouseCord: MouseCoord;
+        setRelativeMouseCord: StateSetter<MouseCoord>;
         triggerTreeRerender: () => void;
         tree?: TreeModel;
         treeRoot?: TreeModel.Node<DSTreeviewT.Item>;
         virtualListHelpers: ReturnType<typeof useVirtual>;
         virtualListRef?: React.MutableRefObject<HTMLUListElement | undefined>;
+        isDragging: boolean;
+        setIsDragging: StateSetter<boolean>;
+        isKeyboardDragging: boolean;
+        setIsKeyboardDragging: StateSetter<boolean>;
+        draggedItem: DSTreeviewT.Item | null;
+        setDraggedItem: StateSetter<DSTreeviewT.Item | null>;
         uniqueTreeViewUUID: string;
         selectedItem: DSTreeviewT.Item | null;
         setSelectedItem: StateSetter<DSTreeviewT.Item | null>;

package/types/utils/dnd-helpers.d.ts

@@ -0,0 +1,39 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+interface MetaInfoT {
+    isBefore: boolean;
+    isAfter: boolean;
+    draggedItem: DSTreeviewT.Item;
+    overItem: DSTreeviewT.Item;
+}
+interface KinshipT {
+    newParentNode: DSTreeviewT.Item['node'];
+    newNestedIndex: number;
+}
+export declare const keyCodes: {
+    lift: number[];
+    drop: number[];
+    cancel: number[];
+    up: number[];
+    down: number[];
+};
+export declare const sameParentAsHoverItemDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: MetaInfoT & {
+    movementDirection: DSTreeviewInternalsT.DnDMovementDirectionT;
+}) => {
+    newNestedIndex: number;
+    newParentNode: import("tree-model/types").Node<DSTreeviewT.Item>;
+};
+export declare const inferHoverItemKinshipDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: MetaInfoT & {
+    movementDirection: DSTreeviewInternalsT.DnDMovementDirectionT;
+}) => {
+    newNestedIndex: number;
+    newParentNode: import("tree-model/types").Node<DSTreeviewT.Item>;
+};
+export declare const isDropValid: ({ isBefore, isAfter, draggedItem, overItem, restrictDragAndDrop, }: MetaInfoT & {
+    restrictDragAndDrop: boolean;
+}) => boolean;
+export declare const inferKeyboardKinshipDrop: ({ items, newIndex, }: {
+    items: DSTreeviewT.Item[];
+    newIndex: number;
+}) => Partial<KinshipT>;
+export {};

package/types/utils/keyboard-helpers.d.ts

@@ -1,6 +1,5 @@
 import type { DSTreeviewT } from '../react-desc-prop-types';
 import type { DSTreeviewInternalsT } from '../sharedTypes';
-import { SortableItemContextType } from '../hoc/SortableItemContext';
-export declare const useOnItemKeyDown: (item: DSTreeviewT.Item, draggableProps: SortableItemContextType['draggableProps']) => (e: React.KeyboardEvent<HTMLLIElement>) => void;
+export declare const useOnItemKeyDown: (item: DSTreeviewT.Item) => (e: React.KeyboardEvent<HTMLLIElement>) => void;
 export declare const useGlobalKeyboardListener: (func: (e: KeyboardEvent) => void) => void;
 export declare const useGlobalToggleAllExpandShortcut: (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void, setLatestToggledItem: DSTreeviewInternalsT.CTX['setLatestToggledItem'], updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState']) => void;

package/types/utils/refs-helpers.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
-declare type GenericMergeableRef = null | undefined | React.MutableRefObject<unknown> | ((ref: HTMLElement) => void) | false;
+declare type GenericMergeableRef = null | undefined | React.MutableRefObject<unknown> | ((ref: HTMLElement) => void);
 export declare const setMultipleRefs: (...refs: GenericMergeableRef[]) => (ref: HTMLElement) => void;
 export {};

package/types/utils/tree-helpers.d.ts

@@ -7,9 +7,7 @@ export declare const walkAllNodeChildren: (node: DSTreeviewT.Item['node'], callb
 export declare const getNodeById: (treeRoot: DSTreeviewT.Item['node'], id: DSTreeviewT.StringOrNum) => TreeModel.Node<DSTreeviewT.Item>;
 export declare const cloneNode: (tree: TreeModel, node: DSTreeviewT.Item) => TreeModel.Node<DSTreeviewT.Item>;
 export declare const itemsShareSameParent: (items?: DSTreeviewT.Item[]) => boolean;
-export declare const getItemsParentNode: (items?: DSTreeviewT.Item[], skipSameParentCheck?: boolean) => TreeModel.Node<DSTreeviewT.Item> & {
-    parent?: TreeModel.Node<DSTreeviewT.Item> | undefined;
-};
+export declare const getItemsParentNode: (items?: DSTreeviewT.Item[], skipSameParentCheck?: boolean) => TreeModel.Node<DSTreeviewT.Item>;
 export declare const getNodeMatchesSearchQuery: (node: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
 export declare const getChildrenMatchesSearchQuery: (parentNode: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
 /**
@@ -24,5 +22,4 @@ export declare const getChildrenMatchesSearchQuery: (parentNode: DSTreeviewT.Ite
  */
 export declare const enrichNodeModelInPlace: (node: TreeModel.Node<DSTreeviewT.SimpleItem>, searchQuery?: string, selection?: DSTreeviewT.SelectionItems | null, expanded?: DSTreeviewT.ExpandedItems | null) => void;
 export declare const focusItem: (item: DSTreeviewT.Item | null) => void;
-export declare const flattenTreeForDnD: (data: DSTreeviewT.SimpleItem[], shouldDescend?: (datum: DSTreeviewT.SimpleItem) => boolean) => DSTreeviewT.DndItem[];
 export {};

package/types/utils/useDnDHelpers.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="mocha" />
+/// <reference types="webpack-env" />
+/// <reference types="styled-components" />
+import React from 'react';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const useDnDHelpers: () => {
+    updateBeforeSortStart: (beforeStartArgs: {
+        index: number;
+        isKeySorting: boolean;
+    }) => Promise<unknown>;
+    onSortStart: () => void;
+    onSortEnd: ({ oldIndex, newIndex, isKeySorting }: {
+        oldIndex: number;
+        newIndex: number;
+        isKeySorting: boolean;
+    }) => void;
+    onMouseDragOverItem: ({ event, item, itemIndex, setIsDraggingOverThis, openFolderOnHoverTimeout, }: {
+        event: React.MouseEvent<HTMLLIElement>;
+        item: DSTreeviewT.Item;
+        itemIndex: number;
+        setIsDraggingOverThis: DSTreeviewInternalsT.StateSetter<boolean>;
+        openFolderOnHoverTimeout: React.MutableRefObject<NodeJS.Timeout | null>;
+    }) => void;
+};

package/types/utils/useTree.d.ts

@@ -5,7 +5,6 @@ export declare const useTree: (data: DSTreeviewT.SimpleItem[], props: DSTreeview
     setExpandedGroups: DSTreeviewInternalsT.StateSetter<DSTreeviewT.ExpandedItems>;
 }) => {
     visibleItems: DSTreeviewT.Item[];
-    flattenedItems: DSTreeviewT.DndItem[];
     tree: TreeModel;
     treeRoot: TreeModel.Node<DSTreeviewT.Item>;
     rerenderItems: {};

package/cjs/hoc/DnDTreeContext.js

@@ -1,18 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var React = require('react');
-var SortableItemContext = require('./SortableItemContext.js');
-
-const DnDTreeContext = /*#__PURE__*/React.createContext({
-  depth: undefined,
-  activeIndex: undefined,
-  visibleItems: undefined,
-  dropIndicatorPosition: SortableItemContext.DropIndicatorPosition.None,
-  lastActiveId: undefined,
-  setLastActiveId: undefined,
-  isDropValid: false
-});
-
-exports.DnDTreeContext = DnDTreeContext;

package/cjs/hoc/SortableItemContext.js

@@ -1,21 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var React = require('react');
-
-exports.DropIndicatorPosition = void 0;
-
-(function (DropIndicatorPosition) {
-  DropIndicatorPosition[DropIndicatorPosition["None"] = 0] = "None";
-  DropIndicatorPosition[DropIndicatorPosition["Before"] = 1] = "Before";
-  DropIndicatorPosition[DropIndicatorPosition["After"] = 2] = "After";
-  DropIndicatorPosition[DropIndicatorPosition["Inside"] = 3] = "Inside";
-})(exports.DropIndicatorPosition || (exports.DropIndicatorPosition = {}));
-
-/** Context for cross component communication */
-const SortableItemContext = /*#__PURE__*/React.createContext({
-  draggableProps: false
-});
-
-exports.SortableItemContext = SortableItemContext;