@elliemae/ds-treeview 2.0.1 → 2.1.0-rc.0

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

@@ -1,22 +1,112 @@
 /// <reference path="../../../../shared/typings/react-desc.d.ts" />
+/// <reference types="react" />
+import TreeModel from 'tree-model';
+import { useVirtual } from 'react-virtual';
+export declare namespace DSTreeviewT {
+    type StringOrNum = string | number;
+    type SelectionState = boolean | 'mixed';
+    type SelectionItems = Record<StringOrNum, SelectionState>;
+    type ScrollToFunc = ReturnType<typeof useVirtual>['scrollToIndex'];
+    type ScrollToItemOptions = Parameters<ReturnType<typeof useVirtual>['scrollToIndex']>[1];
+    type ScrollToItemFunc = (options: ScrollToItemOptions) => void;
+    type ExpandedItems = Record<StringOrNum, true>;
+    interface SimpleItem {
+        [key: string]: unknown;
+        name: string;
+        children: SimpleItem[];
+        id: StringOrNum;
+    }
+    interface Item extends SimpleItem {
+        children: Item[];
+        treeDepth?: number;
+        virtualIndex?: number;
+        isChecked?: boolean | 'mixed';
+        isGroup?: boolean;
+        isExpanded?: boolean;
+        childrenMatchesSearchQuery?: boolean;
+        matchesSearchQuery?: boolean;
+        nodeItemRef?: React.RefObject<HTMLLIElement>;
+        model: TreeModel.Node<Item>['model'];
+        node: TreeModel.Node<Item>;
+        nodePath: TreeModel.Node<Item>[];
+    }
+    interface Actions {
+        toggleExpandAll: (isExpand: boolean) => Promise<DSTreeviewT.Item[]>;
+        scrollTo: DSTreeviewT.ScrollToFunc;
+        setSelectedItemByVirtualIndex: (index: number) => void;
+        setFocusedItemByVirtualIndex: (index: number, scrollOpts: DSTreeviewT.ScrollToItemOptions & {
+            withScroll?: boolean;
+        }) => void;
+    }
+    interface InstanceRef {
+        actions: Actions;
+    }
+    interface DefaultProps {
+        plugins: string[];
+        selection: SelectionItems;
+        instanceRef: React.MutableRefObject<InstanceRef>;
+        isItemDisabled: (item: Item) => boolean;
+        disableIcons: boolean;
+        fluid: boolean;
+        isMultiSelect: boolean;
+        isSingleSelect: boolean;
+        restrictDragAndDrop: boolean;
+        showChildrenAmount: boolean;
+        sortable: boolean;
+        isLoading: boolean;
+        highlightOnlyQuery: boolean;
+        onItemClick: (item: Item, e: React.MouseEvent<HTMLLIElement>) => void;
+        onItemFocus: (meta: {
+            scrollToItem: ScrollToItemFunc;
+            itemIndex: number;
+            item: Item;
+        }) => void;
+        onVisibleItemsChange: (newVisibleItems: Item[]) => void;
+        onOrderChange: (newData: Item[], oldData: Item[], draggedItem: Item) => void;
+        onSelectionChange: (selection: SelectionItems, item: Item, meta: {
+            scrollToItem: ScrollToItemFunc;
+            itemIndex: number;
+        }) => void;
+        onExpandChange: (expandedHashmap: ExpandedItems, itemToggled: Item | null | undefined) => void;
+        onInstanceRefInitialized: (instanceRef: React.MutableRefObject<InstanceRef>) => void;
+        rowSize: 'normal' | 'compact';
+        labelOverflow: 'wrap' | 'wrap-all' | 'truncate';
+        noItemsPlaceholder: string;
+        nameKey: string;
+        width: StringOrNum;
+        height: StringOrNum;
+        groupIcon: JSX.Element | null;
+        itemIcon: JSX.Element | null;
+        searchQuery: string;
+    }
+    interface PropsOptional {
+        expanded: ExpandedItems;
+        rightAddons: ((item: Item) => React.ReactNode | React.ReactNode[]) | JSX.Element;
+    }
+    interface PropsRequired {
+        data: Item[];
+    }
+    interface Props extends DefaultProps, PropsOptional, PropsRequired {
+    }
+}
 export declare const TreeViewPropTypes: {
-    data: import("react-desc").PropTypesDescValidator;
+    data: import("react-desc").PropTypesDescValue;
     plugins: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
     selection: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
+    expanded: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
     instanceRef: {
-        defaultValue<T = unknown>(arg: T): {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
             deprecated: import("react-desc").PropTypesDescValidator;
         };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        isRequired: import("react-desc").PropTypesDescValue;
     };
-    disableGroups: {
-        deprecated: import("react-desc").PropTypesDescValidator;
-    };
-    disableLeafs: {
+    isItemDisabled: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
     disableIcons: {
@@ -31,6 +121,9 @@ export declare const TreeViewPropTypes: {
     isSingleSelect: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
+    isLoading: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
     restrictDragAndDrop: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
@@ -40,51 +133,33 @@ export declare const TreeViewPropTypes: {
     sortable: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
-    labelRenderer: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
-    };
     onItemClick: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     onItemFocus: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     onVisibleItemsChange: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     onOrderChange: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     onSelectionChange: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     onExpandChange: {
-        defaultValue<T = unknown>(arg: T): {
-            deprecated: import("react-desc").PropTypesDescValidator;
-        };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onInstanceRefInitialized: {
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     rowSize: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
+    labelOverflow: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
     width: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
@@ -92,22 +167,28 @@ export declare const TreeViewPropTypes: {
         deprecated: import("react-desc").PropTypesDescValidator;
     };
     groupIcon: {
-        defaultValue<T = unknown>(arg: T): {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
             deprecated: import("react-desc").PropTypesDescValidator;
         };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        isRequired: import("react-desc").PropTypesDescValue;
     };
     itemIcon: {
-        defaultValue<T = unknown>(arg: T): {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
             deprecated: import("react-desc").PropTypesDescValidator;
         };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        isRequired: import("react-desc").PropTypesDescValue;
     };
     searchQuery: {
-        defaultValue<T = unknown>(arg: T): {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
             deprecated: import("react-desc").PropTypesDescValidator;
         };
-        isRequired: import("react-desc").PropTypesDescValidator;
+        isRequired: import("react-desc").PropTypesDescValue;
+    };
+    noItemsPlaceholder: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    name: {
+        deprecated: import("react-desc").PropTypesDescValidator;
     };
     highlightOnlyQuery: {
         deprecated: import("react-desc").PropTypesDescValidator;

package/types/related-components/TreeViewSearchBar.d.ts

@@ -1,13 +1,16 @@
 /// <reference types="react" />
-export declare function TreeViewSearchBar(props: any): JSX.Element;
-export declare namespace TreeViewSearchBar {
-    var propTypes: {
-        value: any;
-        handleChange: any;
-        onNext: any;
-        onPrevious: any;
-        onClear: any;
-        currentResultIndex: any;
-        totalResults: any;
-    };
+interface PropsT {
+    handleChange: (opt: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    onNext: () => void;
+    onPrevious: () => void;
+    onClear: () => void;
+    currentResultIndex: number;
+    totalResults: number;
+    value: string;
 }
+export declare function TreeViewSearchBar(props: PropsT): JSX.Element;
+export {};

package/types/sharedTypes.d.ts

@@ -0,0 +1,54 @@
+import TreeModel from 'tree-model';
+import { useVirtual } from 'react-virtual';
+import type { SetStateAction } from 'react';
+import type { DSTreeviewT } from './react-desc-prop-types';
+export declare namespace DSTreeviewInternalsT {
+    type GenericFunc<T extends unknown[]> = (..._args: T) => void;
+    type DnDMovementDirectionT = 'topToBottom' | 'bottomToTop';
+    interface MouseCoord {
+        isBefore: boolean;
+        isAfter: boolean;
+        isValid: boolean;
+        item: DSTreeviewT.Item | null;
+        x: number | null;
+        y: number | null;
+        relativeElementDOMRect: DOMRect | null;
+        relativeElementIndex: number | null;
+    }
+    type StateSetter<T = unknown> = React.Dispatch<SetStateAction<T>>;
+    interface CTX {
+        props: DSTreeviewT.Props;
+        visibleItems: DSTreeviewT.Item[];
+        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>;
+        focusedItem: DSTreeviewT.Item | null;
+        setFocusedItem: StateSetter<DSTreeviewT.Item | null>;
+        selectedCheckboxes: DSTreeviewT.SelectionItems;
+        setSelectedCheckboxes: StateSetter<DSTreeviewT.SelectionItems>;
+        expandedGroups: DSTreeviewT.ExpandedItems;
+        setExpandedGroups: StateSetter<DSTreeviewT.ExpandedItems>;
+        latestToggledItem?: DSTreeviewT.Item | null | undefined;
+        setLatestToggledItem: StateSetter<DSTreeviewT.Item | null>;
+        hoverItem: DSTreeviewT.Item | null;
+        setHoverItem: StateSetter<DSTreeviewT.Item | null>;
+        handleExpandGroup: (itemToToggle: DSTreeviewT.Item, triggerTreeRerender: () => void, updateUserExpandedState: () => void, scrollTo?: DSTreeviewT.ScrollToFunc, e?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+        updateUserExpandedState: () => void;
+    }
+}

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

@@ -1,2 +1,2 @@
-export declare const arrayMoveMutate: (array: any, from: any, to: any) => void;
-export declare const arrayMove: (array: any, from: any, to: any) => any[];
+export declare const arrayMoveMutate: (array: unknown[], from: number, to: number) => void;
+export declare const arrayMove: (array: unknown[], from: number, to: number) => unknown[];

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

@@ -1,3 +1,15 @@
+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[];
@@ -5,34 +17,23 @@ export declare const keyCodes: {
     up: number[];
     down: number[];
 };
-export declare const sameParentAsHoverItemDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: {
-    isBefore: any;
-    isAfter: any;
-    draggedItem: any;
-    overItem: any;
-    movementDirection: any;
+export declare const sameParentAsHoverItemDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: MetaInfoT & {
+    movementDirection: DSTreeviewInternalsT.DnDMovementDirectionT;
 }) => {
-    newNestedIndex: any;
-    newParentNode: any;
+    newNestedIndex: number;
+    newParentNode: import("tree-model/types").Node<DSTreeviewT.Item>;
 };
-export declare const inferHoverItemKinshipDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: {
-    isBefore: any;
-    isAfter: any;
-    draggedItem: any;
-    overItem: any;
-    movementDirection: any;
+export declare const inferHoverItemKinshipDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: MetaInfoT & {
+    movementDirection: DSTreeviewInternalsT.DnDMovementDirectionT;
 }) => {
-    newNestedIndex: any;
-    newParentNode: any;
+    newNestedIndex: number;
+    newParentNode: import("tree-model/types").Node<DSTreeviewT.Item>;
 };
-export declare const isDropValid: ({ isBefore, isAfter, draggedItem, overItem, restrictDragAndDrop, }: {
-    isBefore: any;
-    isAfter: any;
-    draggedItem: any;
-    overItem: any;
-    restrictDragAndDrop: any;
+export declare const isDropValid: ({ isBefore, isAfter, draggedItem, overItem, restrictDragAndDrop, }: MetaInfoT & {
+    restrictDragAndDrop: boolean;
 }) => boolean;
 export declare const inferKeyboardKinshipDrop: ({ items, newIndex, }: {
-    items: any;
-    newIndex: any;
-}) => {};
+    items: DSTreeviewT.Item[];
+    newIndex: number;
+}) => Partial<KinshipT>;
+export {};

package/types/utils/group-expands-helpers.d.ts

@@ -1,11 +1,14 @@
-export declare const toggleItemExpand: (itemToToggle: any, triggerTreeRerender: any, scrollTo?: () => void) => void;
-export declare const expandItemModel: (modelToExpand: any) => void;
-export declare const collapseItemModel: (modelToCollapse: any) => void;
-export declare const expandAll: (treeRoot: any, triggerTreeRerender: any) => void;
-export declare const collapseAll: (treeRoot: any, triggerTreeRerender: any) => void;
-export declare const getToggleExpandShouldExpand: (treeRoot: any) => boolean;
-export declare const toggleExpandAllHelper: (isExpand: any, treeRoot: any, triggerTreeRerender: any, setLatestToggledItem: any) => void;
-export declare const useNotifyExpandedChange: (propsWithDefaults: any, { latestToggledItem, expandedGroups }: {
-    latestToggledItem: any;
-    expandedGroups: any;
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const updateExpandedState: (treeRoot: DSTreeviewT.Item['node'], onExpandChange: DSTreeviewT.Props['onExpandChange'] | null | undefined) => void;
+export declare const toggleItemExpand: (itemToToggle: DSTreeviewT.Item, triggerTreeRerender: () => void, updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState'], scrollTo?: DSTreeviewT.ScrollToFunc) => void;
+export declare const expandItemModel: (modelToExpand: DSTreeviewT.Item['model']) => void;
+export declare const collapseItemModel: (modelToCollapse: DSTreeviewT.Item['model']) => void;
+export declare const expandAll: (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void) => void;
+export declare const collapseAll: (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void) => void;
+export declare const getToggleExpandShouldExpand: (treeRoot: DSTreeviewT.Item['node']) => boolean;
+export declare const toggleExpandAllHelper: (isExpand: boolean | 'toggle', treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void, setLatestToggledItem: DSTreeviewInternalsT.CTX['setLatestToggledItem'], updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState']) => void;
+export declare const useNotifyExpandedChange: (propsWithDefaults: DSTreeviewT.Props, { latestToggledItem, expandedGroups, }: {
+    latestToggledItem?: DSTreeviewInternalsT.CTX['latestToggledItem'];
+    expandedGroups?: DSTreeviewT.ExpandedItems | undefined;
 }) => void;

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

@@ -1,3 +1,5 @@
-export declare const useOnItemKeyDown: (item: any) => (e: any) => void;
-export declare const useGlobalKeyboardListener: (func: any) => void;
-export declare const useGlobalToggleAllExpandShortcut: (treeRoot: any, triggerTreeRerender: any, setLatestToggledItem: any) => void;
+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;
+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/object-helpers.d.ts

@@ -1,2 +1,6 @@
-export declare const unfreeze: (o: any) => any;
-export declare const filterObject: (obj: any, predicate: any) => {};
+export declare const unfreeze: (o: string | number | unknown[] | Date | null | undefined | Record<string, unknown>) => string | number | unknown[] | Date | Record<string, unknown> | null | undefined;
+declare type GenericItemT<T = unknown> = {
+    [key: string]: T;
+};
+export declare function filterObject<T = unknown>(obj: GenericItemT<T>, predicate: (val: T) => boolean): GenericItemT<T>;
+export {};

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

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

package/types/utils/selectable-helper.d.ts

@@ -1,3 +1,7 @@
-export declare const getGroupCheckState: (node: any) => boolean | "mixed";
-export declare const selectCheckboxItemModelParentsTillRoot: (modelToCheck: any, triggerTreeRerender?: null) => {};
-export declare const toggleCheckboxItem: (itemToSelect: any, triggerTreeRerender?: null) => {};
+import type { DSTreeviewT } from '../react-desc-prop-types';
+export declare const getGroupCheckState: (node: DSTreeviewT.Item['node']) => boolean | "mixed";
+export declare const selectCheckboxItemModelParentsTillRoot: (modelToCheck: DSTreeviewT.Item, triggerTreeRerender?: (() => void) | null) => DSTreeviewT.SelectionItems;
+export declare const toggleCheckboxItem: (itemToSelect: DSTreeviewT.Item, triggerTreeRerender?: (() => void) | null) => {
+    [x: string]: DSTreeviewT.SelectionState;
+    [x: number]: DSTreeviewT.SelectionState;
+};

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

@@ -1 +1 @@
-export declare const standardizeSearchQueryString: (input: any) => any;
+export declare const standardizeSearchQueryString: (input: string) => string;

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

@@ -1,11 +1,25 @@
-export declare const walkVisibles: (node: any, callback: any, skipRoot?: boolean, highlightOnlyQuery?: boolean) => void;
-export declare const walkParents: (nodePath: any, callback: any, skipRoot?: boolean) => void;
-export declare const walkAllNodeChildren: (node: any, callback: any, isFirst?: boolean) => void;
-export declare const getNodeById: (treeRoot: any, id: any) => any;
-export declare const cloneNode: (tree: any, node: any) => any;
-export declare const getItemsParentNode: (items?: never[], skipSameParentCheck?: boolean) => any;
-export declare const itemsShareSameParent: (items?: never[]) => boolean;
-export declare const getNodeMatchesSearchQuery: (node: any, searchQuery?: string) => any;
-export declare const getChildrenMatchesSearchQuery: (parentNode: any, searchQuery?: string) => boolean;
-export declare const enrichNodeModelInPlace: (node: any, searchQuery?: string, selection?: null) => void;
-export declare const focusItem: (item: any) => void;
+import type TreeModel from 'tree-model';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+export declare const walkVisibles: (node: DSTreeviewT.Item['node'], callback: (node: DSTreeviewT.Item['node']) => void, skipRoot?: boolean, highlightOnlyQuery?: boolean) => void;
+export declare const walkParents: (nodePath: DSTreeviewT.Item['nodePath'], callback: (currParent: DSTreeviewT.Item['node']) => void, skipRoot?: boolean) => void;
+declare type RecursiveCallbackT = (childNode: DSTreeviewT.Item['node'], cb?: RecursiveCallbackT, isFirst?: boolean) => void;
+export declare const walkAllNodeChildren: (node: DSTreeviewT.Item['node'], callback: RecursiveCallbackT, isFirst?: boolean) => void;
+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 getNodeMatchesSearchQuery: (node: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
+export declare const getChildrenMatchesSearchQuery: (parentNode: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
+/**
+ * Mutate in place a node from tree-model normalizing object properties like "isGroup" even if user didn't specify it explicitly,
+ * after execution the node will have "nodePath" "treeDepth" "nodeItemRef" "isGroup" "isExpanded"
+ * (optionally, based on the provided arguments) "matchesSearchQuery" "childrenMatchesSearchQuery" "isChecked"
+ *
+ * @param {Object} node - node (based on 'tree-model' lib) that you wish to mutate with extra props
+ * @param {string} [searchQuery=''] - optional string used to parse "matchesSearchQuery"/"childrenMatchesSearchQuery" properties
+ * @param {Object} [selection=null] - optional selection hashmap used to parse "isChecked" properties
+ * @param {Object} [expanded=null] - optional expanded hashmap used to parse "isExpanded" properties
+ */
+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 {};

package/types/utils/useDnDHelpers.d.ts

@@ -1,6 +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: any) => Promise<unknown>;
+    updateBeforeSortStart: (beforeStartArgs: {
+        index: number;
+        isKeySorting: boolean;
+    }) => Promise<unknown>;
     onSortStart: () => void;
-    onSortEnd: ({ oldIndex, newIndex, isKeySorting }: any) => void;
-    onMouseDragOverItem: ({ event, item, itemIndex, setIsDraggingOverThis, openFolderOnHoverTimeout }: any) => 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/useInstanceRefActions.d.ts

@@ -1,3 +1,3 @@
-export declare const useInstanceRefActions: ({ actions }: {
-    actions: any;
-}, ctx: any) => any;
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const useInstanceRefActions: ({ actions }: DSTreeviewT.InstanceRef, ctx: DSTreeviewInternalsT.CTX) => DSTreeviewT.Actions;

package/types/utils/useTree.d.ts

@@ -1,12 +1,13 @@
 import TreeModel from 'tree-model';
-export declare const useTree: (data: any, props: any, states: any) => {
-    visibleItems: never[];
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const useTree: (data: DSTreeviewT.SimpleItem[], props: DSTreeviewT.Props, states: {
+    setExpandedGroups: DSTreeviewInternalsT.StateSetter<DSTreeviewT.ExpandedItems>;
+}) => {
+    visibleItems: DSTreeviewT.Item[];
     tree: TreeModel;
-    treeRoot: TreeModel.Node<{
-        name: string;
-        isExpanded: boolean;
-        children: any;
-    }>;
+    treeRoot: TreeModel.Node<DSTreeviewT.Item>;
     rerenderItems: {};
     triggerTreeRerender: () => void;
+    updateUserExpandedState: () => void;
 };

package/cjs/deprecated/TreeView.js

@@ -1,72 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
-var _jsx = require('@babel/runtime/helpers/jsx');
-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');
-require('react');
-var useDataList = require('@elliemae/ds-shared/useDataList');
-var renderers = require('./renderers.js');
-var TreeDataPlugin = require('./plugins/tree/TreeDataPlugin.js');
-var TreeVirtualizationPlugin = require('./plugins/virtualization/TreeVirtualizationPlugin.js');
-var TreeRovingPlugin = require('./plugins/roving/TreeRovingPlugin.js');
-var jsxRuntime = require('react/jsx-runtime');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
-var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
-var useDataList__default = /*#__PURE__*/_interopDefaultLegacy(useDataList);
-
-const _excluded = ["data", "plugins", "children", "roving", "rowSize"];
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-const wrapComponentIfExists = (Wrapper, children) => Wrapper ? /*#__PURE__*/_jsx__default["default"](Wrapper, {}, void 0, children) : children;
-
-function TreeView(_ref) {
-  let {
-    data,
-    plugins = [],
-    children,
-    roving = true,
-    rowSize = 'normal'
-  } = _ref,
-      props = _objectWithoutProperties__default["default"](_ref, _excluded);
-
-  const instance = useDataList__default["default"](_objectSpread(_objectSpread({
-    data,
-    plugins: [TreeDataPlugin.TreePluginList, TreeVirtualizationPlugin.TreeVirtualizationPlugin, roving && TreeRovingPlugin.TreeRovingPlugin, ...plugins],
-    customDecorators: {
-      shouldWalkChildren: []
-    },
-    // adds a new decorator to the useDataList specific for trees
-    renderers: renderers.TreeRenderers
-  }, props), {}, {
-    rowSize
-  }));
-  const {
-    list: ListComponent,
-    listWrapper: Wrapper
-  } = instance.renderers;
-  const {
-    getListProps
-  } = instance;
-  return wrapComponentIfExists(Wrapper, /*#__PURE__*/jsxRuntime.jsx(ListComponent, _objectSpread(_objectSpread({
-    records: instance.records
-  }, getListProps()), {}, {
-    className: "em-ds-tv-row-size-".concat(rowSize)
-  })));
-}
-
-exports.TreeView = TreeView;