@nosferatu500/react-sortable-tree/lib/index.d.ts

Drag-and-drop sortable component for nested data and hierarchies

import React, { ReactNode } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { VListHandle } from 'virtua';

interface TreeItem {
    title?: ReactNode;
    subtitle?: ReactNode;
    expanded?: boolean;
    children?: TreeItem[] | GetTreeItemChildrenFn;
    [x: string]: unknown;
}
interface TreeNode {
    node: TreeItem;
}
interface TreePath {
    path: number[];
}
interface TreeIndex {
    treeIndex: number;
}
interface FullTree {
    treeData: TreeItem[];
}
interface NodeData extends TreeNode, TreePath, TreeIndex {
}
interface SearchData extends NodeData {
    searchQuery: string;
}
interface GetTreeItemChildren {
    done: (children: TreeItem[]) => void;
    node: TreeItem;
    path: number[];
    lowerSiblingCounts: number[];
    treeIndex: number;
}
type GetTreeItemChildrenFn = (data: GetTreeItemChildren) => void;
type GetNodeKeyFunction = (data: TreeIndex & TreeNode) => string | number;
interface TreeItemDropResult {
    node: TreeItem;
    path: number[];
    treeIndex: number;
    treeId: string;
    minimumTreeIndex?: number;
    depth?: number;
}

declare const defaultGetNodeKey: ({ treeIndex }: TreeIndex) => number;
declare const defaultSearchMethod: ({ node, path, treeIndex, searchQuery, }: SearchData) => boolean;

type WalkAndMapFunctionParameters = FullTree & {
    getNodeKey: GetNodeKeyFunction;
    callback: Function;
    ignoreCollapsed?: boolean;
};
interface FlatDataItem extends TreeNode, TreePath {
    lowerSiblingCounts: number[];
    parentNode: TreeItem;
}
declare const getDescendantCount: ({ node, ignoreCollapsed, }: TreeNode & {
    ignoreCollapsed?: boolean;
}) => number;
declare const getVisibleNodeCount: ({ treeData }: FullTree) => number;
declare const getVisibleNodeInfoAtIndex: ({ treeData, index: targetIndex, getNodeKey, }: FullTree & {
    index: number;
    getNodeKey: GetNodeKeyFunction;
}) => (TreeNode & TreePath & {
    lowerSiblingCounts: number[];
}) | null;
declare const walk: ({ treeData, getNodeKey, callback, ignoreCollapsed, }: WalkAndMapFunctionParameters) => void;
declare const map: ({ treeData, getNodeKey, callback, ignoreCollapsed, }: WalkAndMapFunctionParameters) => TreeItem[];
declare const toggleExpandedForAll: ({ treeData, expanded, }: FullTree & {
    expanded?: boolean;
}) => TreeItem[];
declare const changeNodeAtPath: ({ treeData, path, newNode, getNodeKey, ignoreCollapsed, }: FullTree & TreePath & {
    newNode: Function | any;
    getNodeKey: GetNodeKeyFunction;
    ignoreCollapsed?: boolean;
}) => TreeItem[];
declare const removeNodeAtPath: ({ treeData, path, getNodeKey, ignoreCollapsed, }: FullTree & TreePath & {
    getNodeKey: GetNodeKeyFunction;
    ignoreCollapsed?: boolean;
}) => TreeItem[];
declare const removeNode: ({ treeData, path, getNodeKey, ignoreCollapsed, }: FullTree & TreePath & {
    getNodeKey: GetNodeKeyFunction;
    ignoreCollapsed?: boolean;
}) => (FullTree & TreeNode & TreeIndex) | undefined;
declare const getNodeAtPath: ({ treeData, path, getNodeKey, ignoreCollapsed, }: FullTree & TreePath & {
    getNodeKey: GetNodeKeyFunction;
    ignoreCollapsed?: boolean;
}) => (TreeNode & TreeIndex) | null;
declare const addNodeUnderParent: ({ treeData, newNode, parentKey, getNodeKey, ignoreCollapsed, expandParent, addAsFirstChild, }: FullTree & {
    newNode: TreeItem;
    parentKey: number | string | undefined | null;
    getNodeKey: GetNodeKeyFunction;
    ignoreCollapsed?: boolean;
    expandParent?: boolean;
    addAsFirstChild?: boolean;
}) => FullTree & TreeIndex;
declare const insertNode: ({ treeData, depth: targetDepth, minimumTreeIndex, newNode, getNodeKey, ignoreCollapsed, expandParent, }: FullTree & {
    depth: number;
    newNode: TreeItem;
    minimumTreeIndex: number;
    ignoreCollapsed?: boolean;
    expandParent?: boolean;
    getNodeKey: GetNodeKeyFunction;
}) => FullTree & TreeIndex & TreePath & {
    parentNode: TreeItem | null;
};
declare const getFlatDataFromTree: ({ treeData, getNodeKey, ignoreCollapsed, }: FullTree & {
    getNodeKey: GetNodeKeyFunction;
    ignoreCollapsed?: boolean;
}) => FlatDataItem[];
declare const getTreeFromFlatData: ({ flatData, getKey, getParentKey, rootKey, }: {
    flatData: any;
    getKey: (node: any) => string;
    getParentKey: (node: any) => string;
    rootKey: string | null;
}) => any[];
declare const isDescendant: (older: TreeItem, younger: TreeItem) => boolean;
declare const getDepth: (node: TreeItem, depth?: number) => number;
declare const find: ({ getNodeKey, treeData, searchQuery, searchMethod, searchFocusOffset, expandAllMatchPaths, expandFocusMatchPaths, }: FullTree & {
    getNodeKey: GetNodeKeyFunction;
    searchQuery?: string | number;
    searchMethod: (data: SearchData) => boolean;
    searchFocusOffset?: number;
    expandAllMatchPaths?: boolean;
    expandFocusMatchPaths?: boolean;
}) => {
    matches: NodeData[];
} & FullTree;

type SearchParams = {
    node: TreeItem;
    path: number[];
    treeIndex: number;
    searchQuery: string;
};
type SearchFinishCallbackParams = {
    node: TreeItem;
    path: number[];
    treeIndex: number;
}[];
type GenerateNodePropsParams = {
    node: TreeItem;
    path: number[];
    treeIndex: number;
    lowerSiblingCounts: number[];
    isSearchMatch: boolean;
    isSearchFocus: boolean;
};
type ShouldCopyOnOutsideDropParams = {
    node: TreeItem;
    prevPath: number[];
    prevTreeIndex: number;
};
type OnMoveNodeParams = {
    treeData: TreeItem[];
    node: TreeItem;
    nextParentNode: TreeItem | null;
    prevPath: number[];
    prevTreeIndex: number;
    nextPath?: number[];
    nextTreeIndex?: number;
};
type CanDropParams = {
    node: TreeItem;
    prevPath: number[];
    prevParent: TreeItem;
    prevTreeIndex: number;
    nextPath: number[];
    nextParent: TreeItem;
    nextTreeIndex: number;
};
type OnVisibilityToggleParams = {
    treeData: TreeItem[];
    node: TreeItem;
    expanded: boolean;
    path: number[];
};
type OnDragStateChangedParams = {
    isDragging: boolean;
    draggedNode: TreeItem | undefined;
};
type ThemeProps = {
    style?: React.CSSProperties;
    innerStyle?: React.CSSProperties;
    scaffoldBlockPxWidth?: number;
    slideRegionSize?: number;
    treeNodeRenderer?: React.ComponentType<any>;
    nodeContentRenderer?: React.ComponentType<any>;
    placeholderRenderer?: React.ComponentType<any>;
    dndType?: string;
};
type ReactSortableTreeProps = {
    children?: ReactNode;
    dragDropManager?: {
        getMonitor: () => unknown;
    };
    treeData: TreeItem[];
    style?: React.CSSProperties;
    className?: string;
    virtuaRef?: React.RefObject<VListHandle>;
    innerStyle?: React.CSSProperties;
    slideRegionSize?: number;
    scaffoldBlockPxWidth?: number;
    maxDepth?: number;
    searchMethod?: (params: SearchParams) => boolean;
    searchQuery?: string;
    searchFocusOffset?: number;
    searchFinishCallback?: (params: SearchFinishCallbackParams) => void;
    generateNodeProps?: (params: GenerateNodePropsParams) => Record<string, unknown>;
    treeNodeRenderer?: React.ComponentType<any>;
    nodeContentRenderer?: React.ComponentType<any>;
    placeholderRenderer?: React.ComponentType<any>;
    theme?: ThemeProps;
    rowHeight?: number | ((treeIndex: number, node: TreeItem, path: number[]) => number);
    getNodeKey?: GetNodeKeyFunction;
    onChange: (treeData: TreeItem[]) => void;
    onMoveNode?: (params: OnMoveNodeParams) => void;
    canDrag?: boolean | ((params: GenerateNodePropsParams) => boolean);
    canDrop?: (params: CanDropParams) => boolean;
    canNodeHaveChildren?: (node: TreeItem) => boolean;
    shouldCopyOnOutsideDrop?: ((params: ShouldCopyOnOutsideDropParams) => boolean) | boolean;
    onVisibilityToggle?: (params: OnVisibilityToggleParams) => void;
    dndType?: string;
    onDragStateChanged?: (params: OnDragStateChangedParams) => void;
    onlyExpandSearchedNodes?: boolean;
    rowDirection?: string;
    loadCollapsedLazyChildren?: boolean;
};
declare const SortableTreeWithoutDndContext: (props: ReactSortableTreeProps) => react_jsx_runtime.JSX.Element;
declare const SortableTree: (props: ReactSortableTreeProps) => react_jsx_runtime.JSX.Element;

export { SortableTree, SortableTreeWithoutDndContext, addNodeUnderParent, changeNodeAtPath, defaultGetNodeKey, defaultSearchMethod, find, getDepth, getDescendantCount, getFlatDataFromTree, getNodeAtPath, getTreeFromFlatData, getVisibleNodeCount, getVisibleNodeInfoAtIndex, insertNode, isDescendant, map, removeNode, removeNodeAtPath, toggleExpandedForAll, walk };
export type { FlatDataItem, FullTree, GetNodeKeyFunction, GetTreeItemChildren, GetTreeItemChildrenFn, NodeData, SearchData, TreeIndex, TreeItem, TreeItemDropResult, TreeNode, TreePath, WalkAndMapFunctionParameters };