Updated types

types/react-sortable-tree/index.d.ts

@@ -46,6 +46,11 @@ export interface FullTree {
 
 export interface NodeData extends TreeNode, TreePath, TreeIndex { }
 
+export interface FlatDataItem extends TreeNode, TreePath {
+    lowerSiblingsCounts: number[];
+    parentNode: TreeItem;
+}
+
 export interface SearchData extends NodeData {
     searchQuery: any;
 }
@@ -61,6 +66,11 @@ export interface OnVisibilityToggleData extends FullTree, TreeNode {
     expanded: boolean;
 }
 
+export interface OnDragStateChangedData {
+    isDragging: boolean;
+    draggedNode: TreeItem;
+}
+
 interface PreviousAndNextLocation {
     prevTreeIndex: number;
     prevPath: NumberOrStringArray;
@@ -96,7 +106,7 @@ export interface NodeRendererProps {
     toggleChildrenVisibility?(data: NodeData): void;
     buttons?: JSX.Element[];
     className?: string;
-    style?: { [index: string]: any };
+    style?: React.CSSProperties;
     title?: (data: NodeData) => JSX.Element | JSX.Element;
     subtitle?: (data: NodeData) => JSX.Element | JSX.Element;
     icons?: JSX.Element[];
@@ -109,12 +119,12 @@ export interface NodeRendererProps {
 
     connectDragPreview: ConnectDragPreview;
     connectDragSource: ConnectDragSource;
-    parentNode?: { [index: string]: any };
+    parentNode?: TreeItem;
     startDrag: any;
     endDrag: any;
     isDragging: boolean;
     didDrop: boolean;
-    draggedNode?: { [index: string]: any };
+    draggedNode?: TreeItem;
     isOver: boolean;
     canDrop?: boolean;
 }
@@ -124,7 +134,7 @@ export type PlaceholderRenderer = React.ComponentClass<PlaceholderRendererProps>
 export interface PlaceholderRendererProps {
     isOver: boolean;
     canDrop: boolean;
-    draggedNode: { [index: string]: any };
+    draggedNode: TreeItem;
 }
 
 type NumberOrStringArray = Array<string | number>;
@@ -147,54 +157,52 @@ export interface TreeRendererProps {
     connectDropTarget: ConnectDropTarget;
     isOver: boolean;
     canDrop?: boolean;
-    draggedNode?: { [index: string]: any };
+    draggedNode?: TreeItem;
 
     // used in dndManager
-    getPrevRow: any; // @TODO what is this method?
+    getPrevRow: () => FlatDataItem | null;
     node: TreeItem;
     path: NumberOrStringArray;
 }
 
-export interface ThemeProps {
-    style?: { [index: string]: any };
-    innerStyle?: { [index: string]: any };
+interface ThemeTreeProps {
+    style?: React.CSSProperties
+    innerStyle?: React.CSSProperties
     reactVirtualizedListProps?: Partial<ListProps>;
     scaffoldBlockPxWidth?: number;
     slideRegionSize?: number;
     rowHeight?: ((info: Index) => number) | number;
-    treeNodeRenderer?: TreeRenderer;
     nodeContentRenderer?: NodeRenderer;
     placeholderRenderer?: PlaceholderRenderer;
 }
 
-export interface ReactSortableTreeProps {
+export interface ThemeProps extends ThemeTreeProps {
+    treeNodeRenderer?: TreeRenderer;
+}
+
+export interface ReactSortableTreeProps extends ThemeTreeProps {
     treeData: TreeItem[];
     onChange(treeData: TreeItem[]): void;
-    style?: { [index: string]: any };
-    className?: string;
-    innerStyle?: { [index: string]: any };
+    getNodeKey?(data: TreeNode & TreeIndex): string | number;
+    generateNodeProps?(data: ExtendedNodeData): { [index: string]: any };
+    onMoveNode?(data: NodeData & FullTree & OnMovePreviousAndNextLocation): void;
+    onVisibilityToggle?(data: OnVisibilityToggleData): void;
+    onDragStateChanged?(data: OnDragStateChangedData): void;
     maxDepth?: number;
+    rowDirection?: 'ltr' | 'rtl';
+    canDrag?: ((data: ExtendedNodeData) => boolean) | boolean;
+    canDrop?(data: OnDragPreviousAndNextLocation & NodeData): boolean;
+    canNodeHaveChildren?(node: TreeItem): boolean;
+    theme?: ThemeProps;
     searchMethod?(data: SearchData): boolean;
     searchQuery?: string | any;
     searchFocusOffset?: number;
-    searchFinishCallback?(matches: NodeData[]): void;
-    generateNodeProps?(data: ExtendedNodeData): { [index: string]: any };
-    getNodeKey?(data: TreeNode & TreeIndex): string | number;
-    onMoveNode?(data: NodeData & FullTree & OnMovePreviousAndNextLocation): void;
-    onVisibilityToggle?(data: OnVisibilityToggleData): void;
-    canDrag?: ((data: ExtendedNodeData) => boolean) | boolean;
-    canDrop?(data: OnDragPreviousAndNextLocation & NodeData): boolean;
-    reactVirtualizedListProps?: Partial<ListProps>;
-    rowHeight?: ((info: Index) => number) | number;
-    slideRegionSize?: number;
-    scaffoldBlockPxWidth?: number;
-    isVirtualized?: boolean;
-    nodeContentRenderer?: NodeRenderer;
-    dndType?: string;
-    placeholderRenderer?: PlaceholderRenderer;
-    theme?: ThemeProps;
-    shouldCopyOnOutsideDrop?: boolean | ((data: ShouldCopyData) => boolean);
     onlyExpandSearchedNodes?: boolean;
+    searchFinishCallback?(matches: NodeData[]): void;
+    dndType?: string;
+    shouldCopyOnOutsideDrop?: boolean | ((data: ShouldCopyData) => boolean);
+    className?: string;
+    isVirtualized?: boolean;
 }
 
 declare const SortableTree: React.ComponentClass<ReactSortableTreeProps>;

types/react-sortable-tree/utils/tree-data-utils.d.ts

@@ -1,4 +1,4 @@
-import { FullTree, TreePath, TreeItem, TreeIndex, SearchData, NodeData, TreeNode } from '..';
+import { FullTree, TreePath, TreeItem, TreeIndex, SearchData, NodeData, TreeNode, FlatDataItem } from '..';
 
 export type GetNodeKeyFunction = (data: TreeIndex & TreeNode) => string | number;
 export type WalkAndMapFunctionParameters = FullTree & {getNodeKey: GetNodeKeyFunction, callback: Function, ignoreCollapsed?: boolean};
@@ -13,6 +13,11 @@ export function getVisibleNodeInfoAtIndex(
     }): TreeNode & TreePath & {lowerSiblingsCounts: number[]} | null;
 export function walk(data: WalkAndMapFunctionParameters): void;
 export function map(data: WalkAndMapFunctionParameters): TreeItem[];
+export function toggleExpandedForAll(
+    data: FullTree & {
+        expanded?: boolean,
+    },
+): TreeItem[];
 export function changeNodeAtPath(
     data: FullTree & TreePath & {
         newNode: Function | any,
@@ -26,12 +31,18 @@ export function removeNodeAtPath(
         ignoreCollapsed?: boolean,
     },
 ): TreeItem[];
+export function removeNode(
+    data: FullTree & TreePath & {
+        getNodeKey: GetNodeKeyFunction,
+        ignoreCollapsed?: boolean,
+    },
+): (FullTree & TreeNode & TreeIndex) | null;
 export function getNodeAtPath(
     data: FullTree & TreePath & {
         getNodeKey: GetNodeKeyFunction,
         ignoreCollapsed?: boolean,
     },
-): TreeNode & TreeIndex | null;
+): (TreeNode & TreeIndex) | null;
 export function addNodeUnderParent(
     data: FullTree & {
         newNode: TreeItem,
@@ -39,6 +50,7 @@ export function addNodeUnderParent(
         getNodeKey: GetNodeKeyFunction,
         ignoreCollapsed?: boolean,
         expandParent?: boolean,
+        addAsFirstChild?: boolean,
     },
 ): FullTree & TreeIndex;
 export function insertNode(
@@ -56,7 +68,7 @@ export function getFlatDataFromTree(
         getNodeKey: GetNodeKeyFunction,
         ignoreCollapsed?: boolean,
     },
-): Array<TreeNode & TreePath & {lowerSiblingsCounts: number[], parentNode: TreeItem}>;
+): Array<FlatDataItem>;
 export function getTreeFromFlatData(
     data: {
         flatData: FlattenedData,