dnd-kit-tree/dist/index.d.ts

A sortable tree component for React

import { UniqueIdentifier } from '@dnd-kit/core';
import { RefObject, CSSProperties, ForwardedRef, HTMLAttributes, ReactNode } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';

type TreeItem<T = unknown> = {
    data?: T;
    id: UniqueIdentifier;
    children: TreeItem<T>[];
    collapsed?: boolean;
};
type TreeItems<T = unknown> = TreeItem<T>[];
interface FlattenedItem<T> extends TreeItem<T> {
    parentId: UniqueIdentifier | null;
    depth: number;
    index: number;
}
type SensorContext = RefObject<{
    items: FlattenedItem<unknown>[];
    offset: number;
}>;
interface RenderItemProps<T> {
    node: FlattenedItem<T>;
    depth: number;
    clone: boolean;
    childCount: number;
    isSorting: boolean;
    isDragging: boolean;
    isRemovable: boolean;
    isCollapsible: boolean;
    containerStyle?: CSSProperties;
    wrapperRef?: (node: HTMLDivElement) => void;
    containerRef: ForwardedRef<HTMLDivElement>;
    handleProps?: HTMLAttributes<HTMLButtonElement>;
    onRemove: () => void;
    onCollapse: () => void;
}

declare const isSafari: boolean;
declare function getProjection(items: FlattenedItem<unknown>[], activeId: UniqueIdentifier, overId: UniqueIdentifier, dragOffset: number, indentationWidth: number, depthLimit?: number): {
    depth: number;
    maxDepth: number;
    minDepth: number;
    parentId: UniqueIdentifier | null;
};
declare function flattenTree<T>(items: TreeItems<T>): FlattenedItem<T>[];
declare function buildTree(flattenedItems: FlattenedItem<unknown>[]): TreeItems<unknown>;
declare function findItem(items: TreeItem[], itemId: UniqueIdentifier): TreeItem | undefined;
declare function findItemDeep(items: TreeItems<unknown>, itemId: UniqueIdentifier): TreeItem | undefined;
declare function removeItem(items: TreeItems<unknown>, id: UniqueIdentifier): TreeItem<unknown>[];
declare function setProperty<T extends keyof TreeItem>(items: TreeItems<unknown>, id: UniqueIdentifier, property: T, setter: (value: TreeItem[T]) => TreeItem[T]): TreeItem<unknown>[];
declare function getChildCount(items: TreeItems<unknown>, id: UniqueIdentifier): number;
declare function removeChildrenOf(items: FlattenedItem<unknown>[], ids: UniqueIdentifier[]): FlattenedItem<unknown>[];

interface SortableTreeVirtualProps {
    height: number;
    itemSize: number;
    hideScrollbar?: boolean;
}
interface SortableTreeMove {
    id: string;
    afterId?: string;
    parentId?: string;
}
interface SortableTreeProps<T> {
    maxDepth?: number;
    removable?: boolean;
    value: TreeItems<T>;
    collapsible?: boolean;
    adjustTranslateY?: number;
    indentationWidth?: number;
    virtual?: SortableTreeVirtualProps;
    grabbingCursor?: CSSProperties["cursor"];
    onMove?: (action: SortableTreeMove) => void;
    onChange?: (items: TreeItems<T>) => void;
    renderItem?: (props: RenderItemProps<T>) => ReactNode;
    renderItemContent?: (item: FlattenedItem<T>) => ReactNode;
}
declare function SortableTree<T>({ value, virtual, maxDepth, removable, collapsible, onMove, onChange, renderItem, indentationWidth, adjustTranslateY, grabbingCursor, renderItemContent, }: SortableTreeProps<T>): react_jsx_runtime.JSX.Element;

export { SortableTree, buildTree, findItem, findItemDeep, flattenTree, getChildCount, getProjection, isSafari, removeChildrenOf, removeItem, setProperty };
export type { FlattenedItem, RenderItemProps, SensorContext, SortableTreeMove, SortableTreeProps, SortableTreeVirtualProps, TreeItem, TreeItems };