ivue-material-plus/dist/unplugin-vue-components/es/components/ivue-tree/index.vue.d.ts

A high quality UI components Library with Vue.js

import { ComponentInternalInstance, PropType } from 'vue';
import type Node from './store/node';
import type { TreeNodeData, TreeKey, TreeData } from './types/tree';
declare const _sfc_main: import("vue").DefineComponent<{
    /**
     * tree数据
     *
     * @type {Array}
     */
    data: {
        type: ArrayConstructor;
        default: () => any[];
    };
    /**
     * 是否懒加载子节点，需与 load 方法结合使用
     *
     * @type {Boolean}
     */
    lazy: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * tree 配置选项
     *
     * @type {Object}
     */
    props: {
        type: PropType<import("./types/tree").TreeOptionProps>;
        default: () => {
            children: string;
            label: string;
            disabled: string;
        };
    };
    /**
     * 暂无数据文案
     *
     * @type {String}
     */
    emptyText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 每个树节点用来作为唯一标识的属性，整棵树应该是唯一的
     *
     * @type {String}
     */
    nodeKey: {
        type: StringConstructor;
    };
    /**
     * 相邻级节点间的水平缩进，单位为像素
     *
     * @type {Number}
     */
    indent: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 自定义树节点扩展图标
     *
     * @type {IconPropType}
     */
    icon: {
        type: PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
        default: string;
    };
    /**
     * 树节点的内容区的渲染方法
     *
     * @type {Function}
     */
    renderContent: {
        type: PropType<import("./types/tree").RenderContentFunction>;
    };
    /**
     * 是否在点击节点的时候展开或者收缩节点
     *
     * @type {Boolean}
     */
    expandOnClickNode: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否每次只打开一个同级树节点展开
     *
     * @type {Boolean}
     */
    accordion: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 设置节点是否被选中
     *
     * @type {Boolean}
     */
    showCheckbox: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 在显示复选框的情况下，是否严格的遵循父子不互相关联的做法
     *
     * @type {Boolean}
     */
    checkBoxStrictly: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 加载子树数据的方法，仅当 lazy 属性为true 时生效
     *
     * @type {Function}
     */
    load: {
        type: PropType<import("./types/tree").LoadFunction>;
    };
    /**
     * 默认勾选的节点的 key 的数组
     *
     * @type {Array}
     */
    defaultCheckedKeys: {
        type: PropType<TreeKey[]>;
    };
    /**
     * 默认展开的节点的 key 的数组
     *
     * @type {Array}
     */
    defaultExpandedKeys: {
        type: PropType<TreeKey[]>;
    };
    /**
     * 展开子节点的时候是否自动展开父节点
     *
     * @type {Boolean}
     */
    autoExpandParent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否默认展开所有节点
     *
     * @type {Boolean}
     */
    defaultExpandAll: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否在第一次展开某个树节点后才渲染其子节点
     *
     * @type {Boolean}
     */
    renderAfterExpand: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否高亮当前选中节点
     *
     * @type {Boolean}
     */
    highlightCurrent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 当前选中的节点
     *
     * @type {String | Number}
     */
    currentNodeKey: {
        type: (NumberConstructor | StringConstructor)[];
    };
    /**
     * 对树节点进行筛选时执行的方法， 返回 false 则表示这个节点会被隐藏
     *
     * @type {Function}
     */
    filterNodeMethod: {
        type: PropType<import("./types/tree").FilterNodeMethodFunction>;
    };
    /**
     * 是否在点击节点的时候选中节点
     *
     * @type {Boolean}
     */
    checkOnClickNode: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否开启拖拽节点功能
     *
     * @type {Boolean}
     */
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 判断节点能否被拖拽 如果返回 false ，节点不能被拖动
     *
     * @type {Function}
     */
    allowDrag: {
        type: PropType<import("./types/tree").AllowDragFunction>;
    };
    /**
     * 拖拽时判定目标节点能否成为拖动目标位置
     *
     * @type {Function}
     */
    allowDrop: {
        type: PropType<import("./types/tree").AllowDropFunction>;
    };
}, {
    prefixCls: string;
    treeRef: import("vue").Ref<HTMLElement>;
    dropIndicator: import("vue").Ref<HTMLElement>;
    root: import("vue").Ref<{
        data: TreeNodeData;
        store: {
            currentNodeKey: TreeKey;
            currentNode: any;
            root: any;
            data: TreeNodeData[];
            key: TreeKey;
            nodesMap: import("./types/tree").TreeStoreNodesMap;
            lazy: boolean;
            props: {
                children?: string;
                label?: string | ((data: TreeNodeData, node: Node) => string);
                disabled?: string | ((data: TreeNodeData, node: Node) => string);
                isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean);
                class?: (data: TreeNodeData, node: Node) => string | {
                    [key: string]: boolean;
                };
            };
            checkBoxStrictly: boolean;
            load: import("./types/tree").LoadFunction;
            defaultCheckedKeys: TreeKey[];
            defaultExpandedKeys: TreeKey[];
            autoExpandParent: boolean;
            defaultExpandAll: boolean;
            filterNodeMethod: import("./types/tree").FilterNodeMethodFunction;
            initialize: () => void;
            registerNode: (node: Node) => void;
            setCurrentNode: (currentNode: Node) => void;
            getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
            getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
            getHalfCheckedNodes: () => TreeNodeData[];
            getHalfCheckedKeys: () => TreeKey[];
            initDefaultCheckedNodes: () => void;
            initDefaultCheckedNode: (node: Node) => void;
            setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
            setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
            _setCheckedKeys: (key: TreeKey, leafOnly: boolean, checkedKeys: {
                [key: string]: boolean;
            }) => void;
            getAllNodes: () => Node[];
            setData: (value: TreeData) => void;
            updateChildren: (key: TreeKey, data: TreeData) => void;
            remove: (data: Node | TreeNodeData) => void;
            append: (data: TreeNodeData, parentData: TreeKey | Node | TreeNodeData) => void;
            getNode: (data: TreeKey | TreeNodeData) => Node;
            deregisterNode: (node: Node) => void;
            setDefaultCheckedKey: (value: TreeKey[]) => void;
            setDefaultExpandedKeys: (keys: TreeKey[]) => void;
            setCurrentNodeKey: (key?: TreeKey, shouldAutoExpandParent?: boolean) => void;
            setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
            filter: (value: any) => void;
            insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData) => void;
            insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData) => void;
            setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
            getCurrentNode: () => Node;
        };
        id: number;
        childNodes: any[];
        level: number;
        parent: any;
        visible: boolean;
        expanded: boolean;
        isCurrent: boolean;
        canFocus: boolean;
        isLeaf: boolean;
        isLeafByUser: boolean;
        loaded: boolean;
        loading: boolean;
        checked: boolean;
        indeterminate: boolean;
        readonly key: TreeKey;
        readonly label: string;
        readonly disabled: boolean;
        readonly nextSibling: any;
        readonly prevSibling: any;
        initialize: () => void;
        setData: (data: TreeNodeData) => void;
        insertChild: (child?: Node | import("./types/tree").FakeNode, index?: number, batch?: boolean) => void;
        getChildren: (init?: boolean) => TreeNodeData | TreeNodeData[];
        collapse: () => void;
        expand: (callback?: () => void, expandParent?: boolean) => void;
        updateLeafState: () => void;
        setChecked: (value?: string | boolean, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
        shouldLoadData: () => boolean;
        createChildren: (array: TreeNodeData[], defaultProps?: import("./types/node").TreeNodeLoadedDefaultProps) => void;
        loadData: (callback: (node: Node) => void, defaultProps?: import("./types/node").TreeNodeLoadedDefaultProps) => void;
        removeChild: (child: Node) => void;
        updateChildren: () => void;
        contains: (target: Node, deep?: boolean) => boolean;
        remove: () => void;
        insertBefore: (child: Node | import("./types/tree").FakeNode, ref: Node) => void;
        insertAfter: (child: Node | import("./types/tree").FakeNode, ref: Node) => void;
        removeChildByData: (data: TreeNodeData) => void;
    }>;
    dragState: {
        showDropIndicator: boolean;
        draggingStartNode: any;
        dropNode: any;
        allowDrop: boolean;
        dropType: any;
    };
    wrapperClasses: import("vue").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    isEmpty: import("vue").ComputedRef<boolean>;
    handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
    getTreeNodeKey: (node: Node) => any;
    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
    getHalfCheckedNodes: () => TreeNodeData[];
    getHalfCheckedKeys: () => TreeKey[];
    getCurrentNode: () => TreeNodeData;
    getCurrentKey: () => any;
    getNode: (data: TreeKey | TreeNodeData) => Node;
    setCheckedNodes: (nodes: Node[], leafOnly?: boolean) => void;
    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
    setCurrentKey: (key?: TreeKey, shouldAutoExpandParent?: boolean) => void;
    setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
    remove: (data: TreeNodeData | Node) => void;
    append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | Node) => void;
    updateKeyChildren: (key: TreeKey, data: TreeData) => void;
    insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData) => void;
    insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData) => void;
    filter: (value: any) => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("on-current-change" | "on-node-collapse" | "on-node-expand" | "on-node-click" | "on-check" | "on-check-change" | "on-node-drag-start" | "on-node-drag-leave" | "on-node-drag-enter" | "on-node-drag-over" | "on-node-drag-end" | "on-node-drop")[], "on-current-change" | "on-node-collapse" | "on-node-expand" | "on-node-click" | "on-check" | "on-check-change" | "on-node-drag-start" | "on-node-drag-leave" | "on-node-drag-enter" | "on-node-drag-over" | "on-node-drag-end" | "on-node-drop", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    /**
     * tree数据
     *
     * @type {Array}
     */
    data: {
        type: ArrayConstructor;
        default: () => any[];
    };
    /**
     * 是否懒加载子节点，需与 load 方法结合使用
     *
     * @type {Boolean}
     */
    lazy: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * tree 配置选项
     *
     * @type {Object}
     */
    props: {
        type: PropType<import("./types/tree").TreeOptionProps>;
        default: () => {
            children: string;
            label: string;
            disabled: string;
        };
    };
    /**
     * 暂无数据文案
     *
     * @type {String}
     */
    emptyText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * 每个树节点用来作为唯一标识的属性，整棵树应该是唯一的
     *
     * @type {String}
     */
    nodeKey: {
        type: StringConstructor;
    };
    /**
     * 相邻级节点间的水平缩进，单位为像素
     *
     * @type {Number}
     */
    indent: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * 自定义树节点扩展图标
     *
     * @type {IconPropType}
     */
    icon: {
        type: PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
        default: string;
    };
    /**
     * 树节点的内容区的渲染方法
     *
     * @type {Function}
     */
    renderContent: {
        type: PropType<import("./types/tree").RenderContentFunction>;
    };
    /**
     * 是否在点击节点的时候展开或者收缩节点
     *
     * @type {Boolean}
     */
    expandOnClickNode: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否每次只打开一个同级树节点展开
     *
     * @type {Boolean}
     */
    accordion: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 设置节点是否被选中
     *
     * @type {Boolean}
     */
    showCheckbox: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 在显示复选框的情况下，是否严格的遵循父子不互相关联的做法
     *
     * @type {Boolean}
     */
    checkBoxStrictly: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 加载子树数据的方法，仅当 lazy 属性为true 时生效
     *
     * @type {Function}
     */
    load: {
        type: PropType<import("./types/tree").LoadFunction>;
    };
    /**
     * 默认勾选的节点的 key 的数组
     *
     * @type {Array}
     */
    defaultCheckedKeys: {
        type: PropType<TreeKey[]>;
    };
    /**
     * 默认展开的节点的 key 的数组
     *
     * @type {Array}
     */
    defaultExpandedKeys: {
        type: PropType<TreeKey[]>;
    };
    /**
     * 展开子节点的时候是否自动展开父节点
     *
     * @type {Boolean}
     */
    autoExpandParent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否默认展开所有节点
     *
     * @type {Boolean}
     */
    defaultExpandAll: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否在第一次展开某个树节点后才渲染其子节点
     *
     * @type {Boolean}
     */
    renderAfterExpand: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否高亮当前选中节点
     *
     * @type {Boolean}
     */
    highlightCurrent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 当前选中的节点
     *
     * @type {String | Number}
     */
    currentNodeKey: {
        type: (NumberConstructor | StringConstructor)[];
    };
    /**
     * 对树节点进行筛选时执行的方法， 返回 false 则表示这个节点会被隐藏
     *
     * @type {Function}
     */
    filterNodeMethod: {
        type: PropType<import("./types/tree").FilterNodeMethodFunction>;
    };
    /**
     * 是否在点击节点的时候选中节点
     *
     * @type {Boolean}
     */
    checkOnClickNode: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 是否开启拖拽节点功能
     *
     * @type {Boolean}
     */
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * 判断节点能否被拖拽 如果返回 false ，节点不能被拖动
     *
     * @type {Function}
     */
    allowDrag: {
        type: PropType<import("./types/tree").AllowDragFunction>;
    };
    /**
     * 拖拽时判定目标节点能否成为拖动目标位置
     *
     * @type {Function}
     */
    allowDrop: {
        type: PropType<import("./types/tree").AllowDropFunction>;
    };
}>> & {
    "onOn-current-change"?: (...args: any[]) => any;
    "onOn-node-expand"?: (...args: any[]) => any;
    "onOn-node-collapse"?: (...args: any[]) => any;
    "onOn-node-click"?: (...args: any[]) => any;
    "onOn-check"?: (...args: any[]) => any;
    "onOn-check-change"?: (...args: any[]) => any;
    "onOn-node-drag-start"?: (...args: any[]) => any;
    "onOn-node-drag-leave"?: (...args: any[]) => any;
    "onOn-node-drag-enter"?: (...args: any[]) => any;
    "onOn-node-drag-over"?: (...args: any[]) => any;
    "onOn-node-drag-end"?: (...args: any[]) => any;
    "onOn-node-drop"?: (...args: any[]) => any;
}, {
    props: {
        children: string;
        label: string;
        disabled: string;
    };
    data: unknown[];
    icon: string;
    accordion: boolean;
    defaultExpandAll: boolean;
    indent: number;
    lazy: boolean;
    draggable: boolean;
    showCheckbox: boolean;
    renderAfterExpand: boolean;
    emptyText: string;
    expandOnClickNode: boolean;
    checkBoxStrictly: boolean;
    autoExpandParent: boolean;
    highlightCurrent: boolean;
    checkOnClickNode: boolean;
}>;
export default _sfc_main;