@elliemae/ds-treeview 3.13.1-rc.1 → 3.13.1

package/dist/types/TreeView.d.ts

@@ -0,0 +1,7 @@
+import type { DSTreeviewT } from './react-desc-prop-types';
+export declare const TreeView: {
+    (props: DSTreeviewT.Props): JSX.Element;
+    displayName: string;
+};
+declare const TreeViewWithSchema: import("@elliemae/ds-utilities/dist/types/props-helpers/propTypes/types").DocumentedReactComponent<DSTreeviewT.Props>;
+export { TreeViewWithSchema };

package/dist/types/TreeViewContext.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { DSTreeviewT } from './react-desc-prop-types';
+import type { DSTreeviewInternalsT } from './sharedTypes';
+export declare const defaultProps: DSTreeviewT.Props;
+export declare const defaultRelativeMouseCoord: {
+    isBefore: boolean;
+    isAfter: boolean;
+    isValid: boolean;
+    item: null;
+    x: null;
+    y: null;
+    relativeElementDOMRect: null;
+    relativeElementIndex: null;
+};
+/** Context for cross component communication */
+declare const TreeViewContext: import("react").Context<DSTreeviewInternalsT.CTX>;
+export default TreeViewContext;

package/dist/types/config/cssClassesConstants.d.ts

@@ -0,0 +1,4 @@
+export declare const DSTreeViewPrefix = "em-ds";
+export declare const treeItemBlockName = "tree-item";
+export declare const treeListBlockName = "tree-list";
+export declare const treeListNoItemsBn: string;

package/dist/types/config/useTreeview.d.ts

@@ -0,0 +1,7 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+type UseTreeviewT = (props: DSTreeviewT.Props) => {
+    ctx: DSTreeviewInternalsT.CTX;
+};
+export declare const useTreeview: UseTreeviewT;
+export {};

package/dist/types/hoc/DnDTreeContext.d.ts

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

package/dist/types/hoc/SortableItemContext.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { useSortable } from '@elliemae/ds-drag-and-drop';
+export declare enum DropIndicatorPosition {
+    None = 0,
+    Before = 1,
+    After = 2,
+    Inside = 3
+}
+export type SortableItemContextType = {
+    draggableProps: false | (ReturnType<typeof useSortable> & {
+        dropIndicatorPosition: DropIndicatorPosition;
+        shouldShowDropIndicatorPosition: boolean;
+        isDropValid: boolean;
+    });
+};
+/** Context for cross component communication */
+export declare const SortableItemContext: import("react").Context<SortableItemContextType>;

package/dist/types/hoc/WithConditionalDnDContext.d.ts

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

package/dist/types/hoc/WithDnDSortableItemContext.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TreeView';
+export * from './plugins';
+export { TreeViewSearchBar } from './related-components/TreeViewSearchBar';

package/dist/types/parts/CheckboxSelectable.d.ts

@@ -0,0 +1,7 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+interface PropsT {
+    item: DSTreeviewT.Item;
+    itemIndex: number;
+}
+declare const CheckboxSelectable: (props: PropsT) => JSX.Element | null;
+export default CheckboxSelectable;

package/dist/types/parts/ChildrenCountDisplayer.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+interface PropsT {
+    item: DSTreeviewT.Item;
+}
+export declare const ChildrenCountDisplayer: React.ComponentType<PropsT>;
+export {};

package/dist/types/parts/DnDHandle.d.ts

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

package/dist/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/dist/types/parts/ExpandCaret.d.ts

@@ -0,0 +1,6 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+interface PropsT {
+    item: DSTreeviewT.Item;
+}
+export declare const ExpandCaret: (props: PropsT) => JSX.Element | null;
+export {};

package/dist/types/parts/Icon.d.ts

@@ -0,0 +1,6 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+interface PropsT {
+    item: DSTreeviewT.Item;
+}
+export declare const Icon: (props: PropsT) => JSX.Element | null;
+export {};

package/dist/types/parts/NestingSpace.d.ts

@@ -0,0 +1,7 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+type NestingSpacePropsType = {
+    item: DSTreeviewT.Item;
+    spaceForNestingLevel: number;
+};
+export declare const NestingSpace: (props: NestingSpacePropsType) => JSX.Element | null;
+export {};

package/dist/types/parts/RadioSelectable.d.ts

@@ -0,0 +1,7 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+interface PropsT {
+    item: DSTreeviewT.Item;
+    itemIndex: number;
+}
+declare const RadioSelectable: (props: PropsT) => JSX.Element;
+export default RadioSelectable;

package/dist/types/parts/TreeItem.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+export declare const TreeListItem: React.ComponentType<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>>;
+export declare const TreeListItemAddonsWrapper: React.ComponentType<{}>;
+interface PropsT {
+    item: DSTreeviewT.Item;
+    itemIndex: number;
+    isDragOverlay?: boolean;
+    virtualItemRef?: React.RefObject<HTMLLIElement>;
+    itemWrapperStyle?: {
+        [key: string]: unknown;
+    };
+    spaceForNestingLevel?: number;
+}
+export declare const TreeItem: (props: PropsT) => JSX.Element;
+declare const _default: (props: PropsT) => JSX.Element;
+export default _default;

package/dist/types/parts/TreeItemText.d.ts

@@ -0,0 +1,6 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+interface PropsT {
+    item: DSTreeviewT.Item;
+}
+export declare const TreeItemText: (props: PropsT) => JSX.Element;
+export {};

package/dist/types/parts/TreeList.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import React from 'react';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+export declare const treeListNoItemsBn: string;
+export declare const TreeListNoItems: React.ComponentType<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+interface UlProps extends Omit<React.ComponentProps<'ul'>, 'ref'> {
+    ref: React.MutableRefObject<HTMLUListElement | undefined> | undefined;
+}
+export declare const TreeListWrapper: React.ComponentType<UlProps>;
+interface PropsT {
+    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 TreeList: (props: PropsT) => JSX.Element;
+export {};

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

@@ -0,0 +1 @@
+export declare const TreeDndPlugin = "tree-dnd";

package/dist/types/plugins/dnd/index.d.ts

@@ -0,0 +1 @@
+export * from './TreeDndPlugin';

package/dist/types/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from './dnd';

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

@@ -0,0 +1,101 @@
+import type { WeakValidationMap } from 'react';
+import type React from 'react';
+import type TreeModel from 'tree-model';
+import type { 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> & {
+            parent?: TreeModel.Node<Item>;
+        };
+        nodePath: TreeModel.Node<Item>[];
+    }
+    interface DndItem {
+        uid: string;
+        depth: number;
+        realIndex: number;
+        childrenCount: number;
+        parentId: string | null;
+        original: DSTreeviewT.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;
+        isMultiSelect: boolean;
+        isSingleSelect: boolean;
+        getIsDropValid: (active: DndItem, over: DndItem, dropIndicatorPosition: 'none' | 'before' | 'after' | 'inside') => boolean;
+        showChildrenAmount: boolean;
+        isLoading: boolean;
+        highlightOnlyQuery: boolean;
+        onItemClick: (item: Item, e: React.MouseEvent<HTMLLIElement>) => void;
+        onItemActivate: (item: Item, e?: React.MouseEvent<HTMLLIElement> | React.KeyboardEvent<HTMLLIElement>) => void;
+        onItemFocus: (meta: {
+            scrollToItem: ScrollToItemFunc;
+            itemIndex: number;
+            item: Item;
+        }) => void;
+        onVisibleItemsChange: (newVisibleItems: Item[]) => void;
+        onOrderChange: (newData: SimpleItem[], oldData: SimpleItem[], draggedItem: DndItem) => 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: WeakValidationMap<unknown>;

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

@@ -0,0 +1,15 @@
+interface PropsT {
+    handleChange: (opt: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    onNext: () => void;
+    onPrevious: () => void;
+    onClear: () => void;
+    currentResultIndex: number;
+    totalResults: number;
+    value: string;
+}
+export declare const TreeViewSearchBar: (props: PropsT) => JSX.Element;
+export {};

package/dist/types/sharedTypes.d.ts

@@ -0,0 +1,47 @@
+import type TreeModel from 'tree-model';
+import type { 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[];
+        flattenedItems: DSTreeviewT.DndItem[];
+        withRadioChecks: boolean;
+        withCheckboxChecks: boolean;
+        withDragAndDrop: boolean;
+        triggerTreeRerender: () => void;
+        tree?: TreeModel;
+        treeRoot?: TreeModel.Node<DSTreeviewT.Item>;
+        virtualListHelpers: ReturnType<typeof useVirtual>;
+        virtualListRef?: React.MutableRefObject<HTMLUListElement | undefined>;
+        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/dist/types/tests/Callbacks/TreeViewMultiSelection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/Callbacks/TreeViewSingleSelection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/Callbacks/TreeViewTestExpandable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/Render/TreeViewBasicTests.test.d.ts

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,14 @@
+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/dist/types/utils/keyboard-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+import type { 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/dist/types/utils/object-helpers.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+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/dist/types/utils/string-helpers.d.ts

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

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

@@ -0,0 +1,28 @@
+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;
+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> & {
+    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;
+/**
+ * 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 declare const flattenTreeForDnD: (data: TreeModel.Node<DSTreeviewT.Item>, shouldDescend?: (datum: TreeModel.Node<DSTreeviewT.Item>) => boolean) => DSTreeviewT.DndItem[];
+export {};

package/dist/types/utils/useInstanceRefActions.d.ts

@@ -0,0 +1,3 @@
+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/dist/types/utils/useTree.d.ts

@@ -0,0 +1,14 @@
+import TreeModel from 'tree-model';
+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[];
+    flattenedItems: DSTreeviewT.DndItem[];
+    tree: TreeModel;
+    treeRoot: TreeModel.Node<DSTreeviewT.Item>;
+    rerenderItems: {};
+    triggerTreeRerender: () => void;
+    updateUserExpandedState: () => void;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-treeview",
-  "version": "3.13.1-rc.1",
+  "version": "3.13.1",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Tree View",
   "files": [
@@ -231,15 +231,15 @@
     "react-virtual": "~2.10.4",
     "tree-model": "~1.0.7",
     "uid": "~2.0.1",
-    "@elliemae/ds-button": "3.13.1-rc.1",
-    "@elliemae/ds-circular-progress-indicator": "3.13.1-rc.1",
-    "@elliemae/ds-classnames": "3.13.1-rc.1",
-    "@elliemae/ds-drag-and-drop": "3.13.1-rc.1",
-    "@elliemae/ds-form": "3.13.1-rc.1",
-    "@elliemae/ds-icons": "3.13.1-rc.1",
-    "@elliemae/ds-system": "3.13.1-rc.1",
-    "@elliemae/ds-truncated-tooltip-text": "3.13.1-rc.1",
-    "@elliemae/ds-utilities": "3.13.1-rc.1"
+    "@elliemae/ds-button": "3.13.1",
+    "@elliemae/ds-circular-progress-indicator": "3.13.1",
+    "@elliemae/ds-classnames": "3.13.1",
+    "@elliemae/ds-form": "3.13.1",
+    "@elliemae/ds-icons": "3.13.1",
+    "@elliemae/ds-system": "3.13.1",
+    "@elliemae/ds-truncated-tooltip-text": "3.13.1",
+    "@elliemae/ds-utilities": "3.13.1",
+    "@elliemae/ds-drag-and-drop": "3.13.1"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "~5.16.4",