@elliemae/ds-treeview 2.2.0 → 2.2.2

package/esm/utils/keyboard-helpers.js

@@ -15,14 +15,13 @@ import { toggleItemExpand, toggleExpandAllHelper } from './group-expands-helpers
 // 36 home
 // 56 number 8
 // 106 (NumPad) *
-const useOnItemKeyDown = item => {
+const useOnItemKeyDown = (item, draggableProps) => {
   const ctx = useContext(TreeViewContext);
   const {
     props: {
       onItemFocus
     },
     triggerTreeRerender,
-    isDragging,
     visibleItems,
     setFocusedItem,
     setSelectedItem,
@@ -51,10 +50,12 @@ const useOnItemKeyDown = item => {
       keyCode
     } = e;
 
-    if (!isDragging) {
+    if (!(draggableProps && draggableProps.active)) {
       if (keyCode !== 9) e.preventDefault(); // allow tab/shift+tab
 
-      if (keyCode === 13 || keyCode === 32) setSelectedItem(item);
+      if ((keyCode === 13 || keyCode === 32) && e.target.tagName === 'LI') {
+        setSelectedItem(item);
+      }
 
       if (keyCode === 37) {
         if (isGroup && isExpanded) {
@@ -142,7 +143,7 @@ const useOnItemKeyDown = item => {
         }
       }
     }
-  }, [isDragging, setSelectedItem, item, isGroup, isExpanded, triggerTreeRerender, scrollToIndex, setLatestToggledItem, visibleItems, setFocusedItem, onItemFocusCurry, updateUserExpandedState]);
+  }, [draggableProps, setSelectedItem, item, isGroup, isExpanded, triggerTreeRerender, updateUserExpandedState, scrollToIndex, setLatestToggledItem, visibleItems, setFocusedItem, onItemFocusCurry]);
   return onItemKeyDown;
 };
 const useGlobalKeyboardListener = func => {

package/esm/utils/tree-helpers.js

@@ -128,7 +128,7 @@ const getChildrenMatchesSearchQuery = function (parentNode) {
  */
 
 const enrichNodeModelInPlace = function (node) {
-  var _node$model, _node$model$children;
+  var _node$model$children$, _node$model, _node$model$children;
 
   let searchQuery = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
   let selection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
@@ -144,7 +144,7 @@ const enrichNodeModelInPlace = function (node) {
   // this is useful to avoid having to always check both the flag and the children.length...
 
 
-  if (typeof node.model.isGroup !== 'boolean' && ((_node$model = node.model) === null || _node$model === void 0 ? void 0 : (_node$model$children = _node$model.children) === null || _node$model$children === void 0 ? void 0 : _node$model$children.length) > 0) {
+  if (typeof node.model.isGroup !== 'boolean' && ((_node$model$children$ = (_node$model = node.model) === null || _node$model === void 0 ? void 0 : (_node$model$children = _node$model.children) === null || _node$model$children === void 0 ? void 0 : _node$model$children.length) !== null && _node$model$children$ !== void 0 ? _node$model$children$ : 0) > 0) {
     node.model.isGroup = true;
   }
 
@@ -176,5 +176,30 @@ const focusItem = item => {
 
   item === null || item === void 0 ? void 0 : (_item$nodeItemRef = item.nodeItemRef) === null || _item$nodeItemRef === void 0 ? void 0 : (_item$nodeItemRef$cur = _item$nodeItemRef.current) === null || _item$nodeItemRef$cur === void 0 ? void 0 : _item$nodeItemRef$cur.focus();
 };
+const flattenTreeForDnD = function (data) {
+  let shouldDescend = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => true;
+  const flattenedTree = [];
+  let index = 0;
+
+  const doit = function (node) {
+    var _node$children$length, _node$children, _node$children2;
+
+    let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let parentId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    flattenedTree.push({
+      uid: node.id.toString(),
+      depth,
+      realIndex: index,
+      childrenCount: (_node$children$length = (_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children.length) !== null && _node$children$length !== void 0 ? _node$children$length : 0,
+      parentId: parentId !== null ? parentId.toString() : null,
+      original: node
+    });
+    index += 1;
+    if (shouldDescend(node)) (_node$children2 = node.children) === null || _node$children2 === void 0 ? void 0 : _node$children2.forEach(child => doit(child, depth + 1, node.id.toString()));
+  };
+
+  data.forEach(datum => doit(datum));
+  return flattenedTree;
+};
 
-export { cloneNode, enrichNodeModelInPlace, focusItem, getChildrenMatchesSearchQuery, getItemsParentNode, getNodeById, getNodeMatchesSearchQuery, itemsShareSameParent, walkAllNodeChildren, walkParents, walkVisibles };
+export { cloneNode, enrichNodeModelInPlace, flattenTreeForDnD, focusItem, getChildrenMatchesSearchQuery, getItemsParentNode, getNodeById, getNodeMatchesSearchQuery, itemsShareSameParent, walkAllNodeChildren, walkParents, walkVisibles };

package/esm/utils/useTree.js

@@ -8,7 +8,7 @@ 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 } from './tree-helpers.js';
+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; }
@@ -67,9 +67,9 @@ const useTree = (data, props, states) => {
   useEffect(() => {
     const parsedVisibleItems = [];
     const newExpandedHashMap = {};
-    treeRoot.walk(node => {
-      const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking
+    const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking
 
+    treeRoot.walk(node => {
       enrichNodeModelInPlace(node, searchQuery, selection, expanded);
       if (node.model.id && node.model.isGroup && node.model.isExpanded) newExpandedHashMap[node.model.id] = true;
       return shouldContinueWalking;
@@ -84,8 +84,10 @@ const useTree = (data, props, states) => {
     setExpandedGroups(newExpandedHashMap); // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [treeRoot, rerenderItems, searchQuery, highlightOnlyQuery, selection, expanded, setExpandedGroups // onVisibleItemsChange // evaluate potential performance hit?
   ]);
+  const flattenedItems = useMemo(() => flattenTreeForDnD(data), [data]);
   return {
     visibleItems,
+    flattenedItems,
     tree,
     treeRoot,
     rerenderItems,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-treeview",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Tree View",
   "module": "./esm/index.js",
@@ -19,10 +19,6 @@
       "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"
@@ -51,10 +47,6 @@
       "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"
@@ -167,6 +159,14 @@
       "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,6 +175,22 @@
       "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"
@@ -211,15 +227,15 @@
     "generateSubmodules": true
   },
   "dependencies": {
-    "@elliemae/ds-button": "2.2.0",
-    "@elliemae/ds-circular-progress-indicator": "2.2.0",
-    "@elliemae/ds-classnames": "2.2.0",
-    "@elliemae/ds-form": "2.2.0",
-    "@elliemae/ds-icons": "2.2.0",
-    "@elliemae/ds-props-helpers": "2.2.0",
-    "@elliemae/ds-shared": "2.2.0",
-    "@elliemae/ds-truncated-tooltip-text": "2.2.0",
-    "@elliemae/ds-utilities": "2.2.0",
+    "@elliemae/ds-button": "2.2.2",
+    "@elliemae/ds-circular-progress-indicator": "2.2.2",
+    "@elliemae/ds-classnames": "2.2.2",
+    "@elliemae/ds-form": "2.2.2",
+    "@elliemae/ds-icons": "2.2.2",
+    "@elliemae/ds-props-helpers": "2.2.2",
+    "@elliemae/ds-shared": "2.2.2",
+    "@elliemae/ds-truncated-tooltip-text": "2.2.2",
+    "@elliemae/ds-utilities": "2.2.2",
     "@elliemae/react-sortable-hoc": "^1.0.0",
     "react-desc": "~4.1.3",
     "react-highlight-words": "~0.17.0",

package/types/hoc/DnDTreeContext.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { DSTreeviewT } from '../react-desc-prop-types';
+import { DropIndicatorPosition } from './SortableItemContext';
+declare type DnDTreeContextType = {
+    depth: number | undefined;
+    activeIndex: number | undefined;
+    visibleItems: DSTreeviewT.Item[] | undefined;
+    dropIndicatorPosition: DropIndicatorPosition;
+    lastActiveId: string | undefined;
+    setLastActiveId: React.Dispatch<React.SetStateAction<string>> | undefined;
+    isDropValid: boolean;
+};
+export declare const DnDTreeContext: import("react").Context<DnDTreeContextType>;
+export {};

package/types/hoc/SortableItemContext.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { useSortable } from '@dnd-kit/sortable';
+export declare enum DropIndicatorPosition {
+    None = 0,
+    Before = 1,
+    After = 2,
+    Inside = 3
+}
+export declare type SortableItemContextType = {
+    draggableProps: false | (ReturnType<typeof useSortable> & {
+        dropIndicatorPosition: DropIndicatorPosition;
+        shouldShowDropIndicatorPosition: boolean;
+        lastActiveId?: string;
+        setLastActiveId?: React.Dispatch<React.SetStateAction<string>>;
+        isDropValid: boolean;
+    });
+};
+/** Context for cross component communication */
+export declare const SortableItemContext: import("react").Context<SortableItemContextType>;

package/types/hoc/WithConditionalDnDContext.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare type FunctionalHOC = <T = unknown>(Component: React.ComponentType<T>, ...other: unknown[]) => (props: T) => JSX.Element;
+export declare const withConditionalDnDRowContext: FunctionalHOC;
+export {};

package/types/hoc/WithDnDSortableItemContext.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare type FunctionalHOC = <T = unknown>(Component: React.ComponentType<T>, ...other: unknown[]) => (props: T) => JSX.Element;
+export declare const withDnDSortableItemContext: FunctionalHOC;
+export {};

package/types/parts/DnDHandle.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DSTreeviewT } from '../react-desc-prop-types';
+export declare const DnDHandle: ({ id, isDragOverlay }: {
+    id: DSTreeviewT.StringOrNum;
+    isDragOverlay: boolean;
+}) => JSX.Element;

package/types/parts/DropIndicator.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { DropIndicatorPosition } from '../hoc/SortableItemContext';
+interface DropIndicatorProps {
+    vertical?: boolean;
+    dropIndicatorPosition: DropIndicatorPosition | false;
+    isLast?: boolean;
+    isDropValid?: boolean;
+}
+declare const DropIndicator: React.ComponentType<DropIndicatorProps>;
+export default DropIndicator;

package/types/parts/TreeItem.d.ts

@@ -1,4 +1,3 @@
-/// <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>>;
@@ -6,19 +5,13 @@ export declare const TreeListItemAddonsWrapper: React.ComponentType<{}>;
 interface PropsT {
     item: DSTreeviewT.Item;
     itemIndex: number;
-    virtualItemRef: React.RefObject<HTMLLIElement>;
+    isDragOverlay?: boolean;
+    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;
-export declare const DragAndDropTreeItem: React.ComponentClass<PropsT & import("@elliemae/react-sortable-hoc").SortableElementProps, any>;
-export {};
+declare const _default: (props: PropsT) => JSX.Element;
+export default _default;

package/types/parts/TreeList.d.ts

@@ -17,8 +17,4 @@ 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,3 +1 @@
-/// <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,9 +27,19 @@ export declare namespace DSTreeviewT {
         matchesSearchQuery?: boolean;
         nodeItemRef?: React.RefObject<HTMLLIElement>;
         model: TreeModel.Node<Item>['model'];
-        node: TreeModel.Node<Item>;
+        node: TreeModel.Node<Item> & {
+            parent?: 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;
@@ -50,6 +60,7 @@ 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;
@@ -62,7 +73,7 @@ export declare namespace DSTreeviewT {
             item: Item;
         }) => void;
         onVisibleItemsChange: (newVisibleItems: Item[]) => void;
-        onOrderChange: (newData: Item[], oldData: Item[], draggedItem: Item) => void;
+        onOrderChange: (newData: SimpleItem[], oldData: SimpleItem[], draggedItem: DndItem) => void;
         onSelectionChange: (selection: SelectionItems, item: Item, meta: {
             scrollToItem: ScrollToItemFunc;
             itemIndex: number;
@@ -124,6 +135,9 @@ 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,22 +19,15 @@ 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/keyboard-helpers.d.ts

@@ -1,5 +1,6 @@
 import type { DSTreeviewT } from '../react-desc-prop-types';
 import type { DSTreeviewInternalsT } from '../sharedTypes';
-export declare const useOnItemKeyDown: (item: DSTreeviewT.Item) => (e: React.KeyboardEvent<HTMLLIElement>) => void;
+import { SortableItemContextType } from '../hoc/SortableItemContext';
+export declare const useOnItemKeyDown: (item: DSTreeviewT.Item, draggableProps: SortableItemContextType['draggableProps']) => (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);
+declare type GenericMergeableRef = null | undefined | React.MutableRefObject<unknown> | ((ref: HTMLElement) => void) | false;
 export declare const setMultipleRefs: (...refs: GenericMergeableRef[]) => (ref: HTMLElement) => void;
 export {};

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

@@ -7,7 +7,9 @@ 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>;
+export declare const getItemsParentNode: (items?: DSTreeviewT.Item[], skipSameParentCheck?: boolean) => TreeModel.Node<DSTreeviewT.Item> & {
+    parent?: TreeModel.Node<DSTreeviewT.Item> | undefined;
+};
 export declare const getNodeMatchesSearchQuery: (node: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
 export declare const getChildrenMatchesSearchQuery: (parentNode: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
 /**
@@ -22,4 +24,5 @@ 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/useTree.d.ts

@@ -5,6 +5,7 @@ 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/utils/dnd-helpers.js

@@ -1,140 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var treeHelpers = require('./tree-helpers.js');
-
-/* eslint-disable max-lines */
-const keyCodes = {
-  lift: [32, 13],
-  drop: [32, 13],
-  cancel: [27],
-  up: [38, 37],
-  down: [40, 39]
-};
-const sameParentAsHoverItemDrop = _ref => {
-  let {
-    isBefore,
-    isAfter,
-    draggedItem,
-    overItem,
-    movementDirection
-  } = _ref;
-  const hoveredItemNodeNestedIndex = overItem.node.getIndex();
-  let newParentNode = treeHelpers.getItemsParentNode([overItem], true);
-  const {
-    treeDepth: draggedItemTreeDepth
-  } = draggedItem;
-  const {
-    treeDepth: overItemTreeDepth
-  } = overItem;
-  const directionOffset = // we don't apply the offset for direction
-  //  if moving from less nested to more nested
-  //  or moving bottom to top
-  // the offset is required when moving elemnts down in their nest level
-  draggedItemTreeDepth <= overItemTreeDepth && movementDirection === 'topToBottom' ? -1 : 0;
-  let newNestedIndex;
-  if (isBefore) newNestedIndex = hoveredItemNodeNestedIndex + directionOffset;else if (isAfter) newNestedIndex = hoveredItemNodeNestedIndex + 1 + directionOffset;else {
-    newNestedIndex = overItem.children.length; // append as last child of the group
-
-    newParentNode = overItem.node;
-  }
-  if (newNestedIndex < 0) newNestedIndex = 0;
-  return {
-    newNestedIndex,
-    newParentNode
-  };
-};
-const inferHoverItemKinshipDrop = _ref2 => {
-  let {
-    isBefore,
-    isAfter,
-    draggedItem,
-    overItem,
-    movementDirection
-  } = _ref2;
-  const hoverItemModel = overItem.node.model;
-  const isGroupAndIsExpanded = hoverItemModel.isExpanded && hoverItemModel.children.length > 0;
-
-  if (isAfter && isGroupAndIsExpanded) {
-    return {
-      newNestedIndex: 0,
-      // append after the group, so basically as first child
-      newParentNode: overItem.node
-    };
-  }
-
-  if (isBefore || isAfter && !isGroupAndIsExpanded) {
-    return sameParentAsHoverItemDrop({
-      isBefore,
-      isAfter,
-      draggedItem,
-      overItem,
-      movementDirection
-    });
-  } // drop inside
-
-
-  return {
-    newNestedIndex: overItem.children.length,
-    // append as last child of the group
-    newParentNode: overItem.node
-  };
-};
-const isDropValid = _ref3 => {
-  let {
-    isBefore,
-    isAfter,
-    draggedItem,
-    overItem,
-    restrictDragAndDrop
-  } = _ref3;
-  const {
-    id: movedId
-  } = draggedItem;
-  const {
-    id: hoverId
-  } = overItem;
-  const isInside = !isBefore && !isAfter;
-  if (movedId === hoverId) return false;
-
-  if (isInside && !overItem.isGroup) {
-    return false; // we can't drop inside an item that isn't a group
-  }
-
-  if (restrictDragAndDrop) {
-    if (isInside) return false; // in this mode we can't drop inside another element
-
-    const sameParent = treeHelpers.itemsShareSameParent([draggedItem, overItem]);
-    if (overItem.node.model.isExpanded && isAfter) return false;
-    if (!sameParent) return false;
-  }
-
-  return true;
-};
-const inferKeyboardKinshipDrop = _ref4 => {
-  let {
-    items,
-    newIndex
-  } = _ref4;
-  const kinship = {};
-  const itemBefore = items[newIndex];
-  const itemBeforeModel = itemBefore.node.model;
-  const isGroupAndIsExpanded = itemBeforeModel.isExpanded && itemBeforeModel.children.length > 0;
-
-  if (isGroupAndIsExpanded) {
-    kinship.newParentNode = itemBefore.node;
-    kinship.newNestedIndex = 0;
-  } else {
-    kinship.newParentNode = treeHelpers.getItemsParentNode([itemBefore], true);
-    kinship.newNestedIndex = itemBefore.node.getIndex();
-  }
-
-  return kinship;
-};
-
-exports.inferHoverItemKinshipDrop = inferHoverItemKinshipDrop;
-exports.inferKeyboardKinshipDrop = inferKeyboardKinshipDrop;
-exports.isDropValid = isDropValid;
-exports.keyCodes = keyCodes;
-exports.sameParentAsHoverItemDrop = sameParentAsHoverItemDrop;