@qsxy/element-plus-react 1.0.0-next.1

package/dist/Tree/RCTree.d.ts

@@ -0,0 +1,231 @@
+import React, { Component } from 'react';
+import DropIndicator from './DropIndicator';
+import { NodeListRef } from './NodeList';
+import { NodeDragEventHandler, NodeDragEventParams, NodeMouseEventHandler, NodeMouseEventParams } from './contextTypes';
+import { BasicDataNode, DataEntity, DataNode, Direction, EventDataNode, FieldNames, FlattenNode, IconType, Key, NodeInstance, ScrollTo } from './typings';
+export interface CheckInfo<TreeDataType extends BasicDataNode = DataNode> {
+    event: 'check';
+    node: EventDataNode;
+    checked: boolean;
+    nativeEvent: MouseEvent;
+    checkedNodes: TreeDataType[];
+    checkedNodesPositions?: {
+        node: TreeDataType;
+        pos: string;
+    }[];
+    halfCheckedKeys?: Key[];
+}
+export interface AllowDropOptions<TreeDataType extends BasicDataNode = DataNode> {
+    dragNode: TreeDataType;
+    dropNode: TreeDataType;
+    dropPosition: -1 | 0 | 1;
+}
+export type AllowDrop<TreeDataType extends BasicDataNode = DataNode> = (options: AllowDropOptions<TreeDataType>) => boolean;
+export type DraggableFn = (node: DataNode) => boolean;
+export type DraggableConfig = {
+    icon?: React.ReactElement | false;
+    nodeDraggable?: DraggableFn;
+};
+export interface TreeProps<TreeDataType extends BasicDataNode = DataNode> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    focusable?: boolean;
+    activeKey?: Key;
+    tabIndex?: number;
+    children?: React.ReactElement;
+    treeData?: TreeDataType[];
+    fieldNames?: FieldNames;
+    showLine?: boolean;
+    showIcon?: boolean;
+    icon?: IconType;
+    selectable?: boolean;
+    disabled?: boolean;
+    multiple?: boolean;
+    checkable?: boolean | React.ReactElement;
+    checkStrictly?: boolean;
+    draggable?: DraggableFn | boolean | DraggableConfig;
+    defaultExpandParent?: boolean;
+    autoExpandParent?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: Key[];
+    expandedKeys?: Key[];
+    defaultCheckedKeys?: Key[];
+    checkedKeys?: Key[] | {
+        checked: Key[];
+        halfChecked: Key[];
+    };
+    defaultSelectedKeys?: Key[];
+    selectedKeys?: Key[];
+    allowDrop?: AllowDrop<TreeDataType>;
+    titleRender?: (node: TreeDataType) => React.ReactElement | string;
+    dropIndicatorRender?: (props: {
+        dropPosition: -1 | 0 | 1;
+        dropLevelOffset: number;
+        indent: number;
+        prefixCls: string;
+        direction: Direction;
+    }) => React.ReactElement;
+    onFocus?: React.FocusEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onContextMenu?: React.MouseEvent<HTMLDivElement>;
+    onClick?: NodeMouseEventHandler;
+    onDoubleClick?: NodeMouseEventHandler;
+    onScroll?: React.UIEventHandler<HTMLElement>;
+    onExpand?: (expandedKeys: Key[], info: {
+        node: EventDataNode;
+        expanded: boolean;
+        nativeEvent: MouseEvent;
+    }) => void;
+    onCheck?: (checked: {
+        checked: Key[];
+        halfChecked: Key[];
+    } | Key[], info: CheckInfo<TreeDataType>) => void;
+    onSelect?: (selectedKeys: Key[], info: {
+        event: 'select';
+        selected: boolean;
+        node: EventDataNode;
+        selectedNodes: TreeDataType[];
+        nativeEvent: MouseEvent;
+    }) => void;
+    onLoad?: (loadedKeys: Key[], info: {
+        event: 'load';
+        node: EventDataNode;
+    }) => void;
+    loadData?: (treeNode: EventDataNode) => Promise<void>;
+    loadedKeys?: Key[];
+    onMouseEnter?: (info: NodeMouseEventParams) => void;
+    onMouseLeave?: (info: NodeMouseEventParams) => void;
+    onRightClick?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onDragStart?: (info: NodeDragEventParams) => void;
+    onDragEnter?: (info: NodeDragEventParams & {
+        expandedKeys: Key[];
+    }) => void;
+    onDragOver?: (info: NodeDragEventParams) => void;
+    onDragLeave?: (info: NodeDragEventParams) => void;
+    onDragEnd?: (info: NodeDragEventParams) => void;
+    onDrop?: (info: NodeDragEventParams & {
+        dragNode: EventDataNode;
+        dragNodesKeys: Key[];
+        dropPosition: number;
+        dropToGap: boolean;
+    }) => void;
+    onActiveChange?: (key: Key) => void;
+    filterTreeNode?: (treeNode: EventDataNode) => boolean;
+    motion?: any;
+    switcherIcon?: IconType;
+    height?: number;
+    itemHeight?: number;
+    virtual?: boolean;
+    direction?: Direction;
+    rootClassName?: string;
+    rootStyle?: React.CSSProperties;
+}
+interface TreeState<TreeDataType extends BasicDataNode = DataNode> {
+    keyEntities: Record<Key, DataEntity<TreeDataType>>;
+    indent: number | null;
+    selectedKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    expandedKeys: Key[];
+    draggingNodeKey: Key;
+    dragChildrenKeys: Key[];
+    dropPosition: -1 | 0 | 1 | null;
+    dropLevelOffset: number | null;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropTargetPos: string | null;
+    dropAllowed: boolean;
+    dragOverNodeKey: Key | null;
+    treeData: DataNode[];
+    flattenNodes: FlattenNode[];
+    focused: boolean;
+    activeKey: Key;
+    listChanging: boolean;
+    prevProps: TreeProps;
+    fieldNames: FieldNames;
+}
+declare class RCTree<TreeDataType extends BasicDataNode = DataNode> extends Component<TreeProps<TreeDataType>, TreeState<TreeDataType>> {
+    static defaultProps: {
+        prefixCls: string;
+        showLine: boolean;
+        showIcon: boolean;
+        selectable: boolean;
+        multiple: boolean;
+        checkable: boolean;
+        disabled: boolean;
+        checkStrictly: boolean;
+        draggable: boolean;
+        defaultExpandParent: boolean;
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        defaultExpandedKeys: any[];
+        defaultCheckedKeys: any[];
+        defaultSelectedKeys: any[];
+        dropIndicatorRender: typeof DropIndicator;
+        allowDrop: () => boolean;
+    };
+    static TreeNode: React.FC<import("./TreeNode").TreeNodeProps<DataNode<any>>>;
+    destroyed: boolean;
+    delayedDragEnterLogic: Record<Key, number>;
+    loadingRetryTimes: Record<Key, number>;
+    state: TreeState<TreeDataType>;
+    dragStartMousePosition: any;
+    dragNode: NodeInstance<TreeDataType>;
+    currentMouseOverDroppableNodeKey: any;
+    listRef: React.RefObject<NodeListRef>;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    onUpdated(): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(props: TreeProps, prevState: TreeState): Partial<TreeState<DataNode<any>>>;
+    onNodeDragStart: NodeDragEventHandler<HTMLDivElement, TreeDataType>;
+    onNodeDragEnter: (event: any, node: NodeInstance<TreeDataType>) => void;
+    onNodeDragOver: (event: any, node: NodeInstance<TreeDataType>) => void;
+    onNodeDragLeave: NodeDragEventHandler;
+    onWindowDragEnd: (event: any) => void;
+    onNodeDragEnd: NodeDragEventHandler;
+    onNodeDrop: (event: any, node: any, outsideTree?: boolean) => void;
+    resetDragState(): void;
+    cleanDragState: () => void;
+    onNodeClick: NodeMouseEventHandler;
+    onNodeDoubleClick: NodeMouseEventHandler;
+    onNodeSelect: NodeMouseEventHandler;
+    onNodeCheck: (e: any, treeNode: EventDataNode, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode) => Promise<void>;
+    onNodeMouseEnter: NodeMouseEventHandler;
+    onNodeMouseLeave: NodeMouseEventHandler;
+    onNodeContextMenu: NodeMouseEventHandler;
+    onFocus: React.FocusEventHandler<HTMLDivElement>;
+    onBlur: React.FocusEventHandler<HTMLDivElement>;
+    getTreeNodeRequiredProps: () => {
+        expandedKeys: Key[];
+        selectedKeys: Key[];
+        loadedKeys: Key[];
+        loadingKeys: Key[];
+        checkedKeys: Key[];
+        halfCheckedKeys: Key[];
+        dragOverNodeKey: Key;
+        dropPosition: 0 | 1 | -1;
+        keyEntities: Record<Key, DataEntity<TreeDataType>>;
+    };
+    setExpandedKeys: (expandedKeys: Key[]) => void;
+    flattenTreeData: (expandedKeys: Key[]) => FlattenNode[];
+    onNodeExpand: (e: any, treeNode: EventDataNode) => void;
+    onListChangeStart: () => void;
+    onListChangeEnd: () => void;
+    onActiveChange: (newActiveKey: Key) => void;
+    getActiveItem: () => FlattenNode;
+    offsetActiveKey: (offset: number) => void;
+    onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    setUncontrolledState: (state: Partial<TreeState>, atomic?: boolean, forceState?: Partial<TreeState<TreeDataType>> | null) => void;
+    scrollTo: ScrollTo;
+    render(): React.JSX.Element;
+}
+export default RCTree;