ep-craft 0.1.34 → 0.1.36

package/dist/components/tree/src/model/useDragNode.d.ts

@@ -0,0 +1,459 @@
+import type { InjectionKey, Ref, SetupContext } from 'vue';
+import type { AllowDragFunction, AllowDropFunction, FakeNode, NodeDropType } from '../tree.type';
+import type TreeStore from './tree-store';
+import type Node from './node';
+import type { treeEmits } from '../tree';
+export interface TreeNode {
+    node: Node;
+    $el?: HTMLElement;
+}
+interface DragOptions {
+    event: DragEvent;
+    treeNode: TreeNode;
+}
+interface Props {
+    props: {
+        allowDrag?: AllowDragFunction;
+        allowDrop?: AllowDropFunction;
+    };
+    ctx: SetupContext<typeof treeEmits>;
+    el$: Ref<HTMLElement | null>;
+    dropIndicator$: Ref<HTMLElement | null>;
+    store: Ref<TreeStore>;
+}
+export interface DragEvents {
+    treeNodeDragStart: (options: DragOptions) => void;
+    treeNodeDragOver: (options: DragOptions) => void;
+    treeNodeDragEnd: (event: DragEvent) => void;
+}
+export declare const dragEventsKey: InjectionKey<DragEvents>;
+export declare function useDragNodeHandler({ props, ctx, el$, dropIndicator$, store, }: Props): {
+    dragState: Ref<{
+        allowDrop: boolean;
+        dropType: NodeDropType | null;
+        draggingNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: import("../tree.type").TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: import("../tree.type").TreeKey | null;
+                    nodesMap: import("../tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: import("../tree.type").TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("../tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("../tree.type").FilterNodeMethodFunction | undefined;
+                    key: import("../tree.type").TreeKey;
+                    defaultCheckedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: import("../tree.type").TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: import("../tree.type").FilterValue) => void;
+                    setData: (newVal: import("../tree.type").TreeData) => void;
+                    getNode: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => Node;
+                    insertBefore: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    insertAfter: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    remove: (data: import("../tree.type").TreeNodeData | Node) => void;
+                    append: (data: import("../tree.type").TreeNodeData, parentData: import("../tree.type").TreeNodeData | import("../tree.type").TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: import("../tree.type").TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("../tree.type").TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => import("../tree.type").TreeKey[];
+                    getHalfCheckedNodes: () => import("../tree.type").TreeNodeData[];
+                    getHalfCheckedKeys: () => import("../tree.type").TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: import("../tree.type").TreeKey, data: import("../tree.type").TreeData) => void;
+                    _setCheckedKeys: (key: import("../tree.type").TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: import("../tree.type").TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: import("../tree.type").TreeKey[]) => void;
+                    setChecked: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: import("../tree.type").TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: import("../tree.type").TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("../tree.type").TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: import("../tree.type").TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: import("../tree.type").TreeNodeData[], defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => import("../tree.type").TreeNodeData | import("../tree.type").TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: import("../tree.type").TreeNodeData[]) => void, defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+        showDropIndicator: boolean;
+        dropNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: import("../tree.type").TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: import("../tree.type").TreeKey | null;
+                    nodesMap: import("../tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: import("../tree.type").TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("../tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("../tree.type").FilterNodeMethodFunction | undefined;
+                    key: import("../tree.type").TreeKey;
+                    defaultCheckedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: import("../tree.type").TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: import("../tree.type").FilterValue) => void;
+                    setData: (newVal: import("../tree.type").TreeData) => void;
+                    getNode: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => Node;
+                    insertBefore: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    insertAfter: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    remove: (data: import("../tree.type").TreeNodeData | Node) => void;
+                    append: (data: import("../tree.type").TreeNodeData, parentData: import("../tree.type").TreeNodeData | import("../tree.type").TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: import("../tree.type").TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("../tree.type").TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => import("../tree.type").TreeKey[];
+                    getHalfCheckedNodes: () => import("../tree.type").TreeNodeData[];
+                    getHalfCheckedKeys: () => import("../tree.type").TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: import("../tree.type").TreeKey, data: import("../tree.type").TreeData) => void;
+                    _setCheckedKeys: (key: import("../tree.type").TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: import("../tree.type").TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: import("../tree.type").TreeKey[]) => void;
+                    setChecked: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: import("../tree.type").TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: import("../tree.type").TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("../tree.type").TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: import("../tree.type").TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: import("../tree.type").TreeNodeData[], defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => import("../tree.type").TreeNodeData | import("../tree.type").TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: import("../tree.type").TreeNodeData[]) => void, defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+    }, {
+        allowDrop: boolean;
+        dropType: NodeDropType | null;
+        draggingNode: TreeNode | null;
+        showDropIndicator: boolean;
+        dropNode: TreeNode | null;
+    } | {
+        allowDrop: boolean;
+        dropType: NodeDropType | null;
+        draggingNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: import("../tree.type").TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: import("../tree.type").TreeKey | null;
+                    nodesMap: import("../tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: import("../tree.type").TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("../tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("../tree.type").FilterNodeMethodFunction | undefined;
+                    key: import("../tree.type").TreeKey;
+                    defaultCheckedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: import("../tree.type").TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: import("../tree.type").FilterValue) => void;
+                    setData: (newVal: import("../tree.type").TreeData) => void;
+                    getNode: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => Node;
+                    insertBefore: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    insertAfter: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    remove: (data: import("../tree.type").TreeNodeData | Node) => void;
+                    append: (data: import("../tree.type").TreeNodeData, parentData: import("../tree.type").TreeNodeData | import("../tree.type").TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: import("../tree.type").TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("../tree.type").TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => import("../tree.type").TreeKey[];
+                    getHalfCheckedNodes: () => import("../tree.type").TreeNodeData[];
+                    getHalfCheckedKeys: () => import("../tree.type").TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: import("../tree.type").TreeKey, data: import("../tree.type").TreeData) => void;
+                    _setCheckedKeys: (key: import("../tree.type").TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: import("../tree.type").TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: import("../tree.type").TreeKey[]) => void;
+                    setChecked: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: import("../tree.type").TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: import("../tree.type").TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("../tree.type").TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: import("../tree.type").TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: import("../tree.type").TreeNodeData[], defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => import("../tree.type").TreeNodeData | import("../tree.type").TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: import("../tree.type").TreeNodeData[]) => void, defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+        showDropIndicator: boolean;
+        dropNode: {
+            node: {
+                id: number;
+                text: string | null;
+                checked: boolean;
+                indeterminate: boolean;
+                data: import("../tree.type").TreeNodeData;
+                expanded: boolean;
+                parent: /*elided*/ any | null;
+                visible: boolean;
+                isCurrent: boolean;
+                store: {
+                    currentNode: /*elided*/ any | null;
+                    currentNodeKey: import("../tree.type").TreeKey | null;
+                    nodesMap: import("../tree.type").TreeStoreNodesMap;
+                    root: /*elided*/ any;
+                    data: import("../tree.type").TreeNodeData[];
+                    lazy: boolean;
+                    load?: import("../tree.type").LoadFunction | undefined;
+                    filterNodeMethod?: import("../tree.type").FilterNodeMethodFunction | undefined;
+                    key: import("../tree.type").TreeKey;
+                    defaultCheckedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: import("../tree.type").TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => string) | undefined;
+                        disabled?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        isLeaf?: string | ((data: import("../tree.type").TreeNodeData, node: Node) => boolean) | undefined;
+                        class?: ((data: import("../tree.type").TreeNodeData, node: Node) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: import("../tree.type").FilterValue) => void;
+                    setData: (newVal: import("../tree.type").TreeData) => void;
+                    getNode: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => Node;
+                    insertBefore: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    insertAfter: (data: import("../tree.type").TreeNodeData, refData: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData | Node) => void;
+                    remove: (data: import("../tree.type").TreeNodeData | Node) => void;
+                    append: (data: import("../tree.type").TreeNodeData, parentData: import("../tree.type").TreeNodeData | import("../tree.type").TreeKey | Node) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: Node) => void;
+                    setDefaultCheckedKey: (newVal: import("../tree.type").TreeKey[]) => void;
+                    registerNode: (node: Node) => void;
+                    deregisterNode: (node: Node) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => import("../tree.type").TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => import("../tree.type").TreeKey[];
+                    getHalfCheckedNodes: () => import("../tree.type").TreeNodeData[];
+                    getHalfCheckedKeys: () => import("../tree.type").TreeKey[];
+                    _getAllNodes: () => Node[];
+                    updateChildren: (key: import("../tree.type").TreeKey, data: import("../tree.type").TreeData) => void;
+                    _setCheckedKeys: (key: import("../tree.type").TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: Node[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: import("../tree.type").TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: import("../tree.type").TreeKey[]) => void;
+                    setChecked: (data: import("../tree.type").TreeKey | import("../tree.type").TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => Node | null;
+                    setCurrentNode: (currentNode: Node) => void;
+                    setUserCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: import("../tree.type").TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                };
+                isLeafByUser: boolean | undefined;
+                isLeaf: boolean | undefined;
+                canFocus: boolean;
+                level: number;
+                loaded: boolean;
+                childNodes: /*elided*/ any[];
+                loading: boolean;
+                isEffectivelyChecked: boolean;
+                initialize: () => void;
+                setData: (data: import("../tree.type").TreeNodeData) => void;
+                readonly label: string;
+                readonly key: import("../tree.type").TreeKey | null | undefined;
+                readonly disabled: boolean;
+                readonly nextSibling: /*elided*/ any | null;
+                readonly previousSibling: /*elided*/ any | null;
+                contains: (target: Node, deep?: boolean) => boolean;
+                remove: () => void;
+                insertChild: (child?: FakeNode | Node, index?: number, batch?: boolean) => void;
+                insertBefore: (child: FakeNode | Node, ref: Node) => void;
+                insertAfter: (child: FakeNode | Node, ref: Node) => void;
+                removeChild: (child: Node) => void;
+                removeChildByData: (data: import("../tree.type").TreeNodeData | null) => void;
+                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                doCreateChildren: (array: import("../tree.type").TreeNodeData[], defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                collapse: () => void;
+                shouldLoadData: () => boolean;
+                updateLeafState: () => void;
+                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                getChildren: (forceInit?: boolean) => import("../tree.type").TreeNodeData | import("../tree.type").TreeNodeData[] | null;
+                updateChildren: () => void;
+                loadData: (callback: (data?: import("../tree.type").TreeNodeData[]) => void, defaultProps?: import("../tree.type").TreeNodeLoadedDefaultProps) => void;
+                eachNode: (callback: (node: Node) => void) => void;
+                reInitChecked: () => void;
+            };
+            $el?: HTMLElement | undefined;
+        } | null;
+    }>;
+};
+export {};

package/dist/components/tree/src/model/useDragNode.js

@@ -0,0 +1,98 @@
+import { ref as $, provide as k } from "vue";
+import { isFunction as S } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { removeClass as I, addClass as A } from "../../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { useNamespace as B } from "../../../../hooks/use-namespace/index.js";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+const x = Symbol("dragEvents");
+function W({
+  props: p,
+  ctx: f,
+  el$: h,
+  dropIndicator$: E,
+  store: c
+}) {
+  const u = B("tree"), d = $({
+    showDropIndicator: !1,
+    draggingNode: null,
+    dropNode: null,
+    allowDrop: !0,
+    dropType: null
+  });
+  return k(x, {
+    treeNodeDragStart: ({ event: o, treeNode: n }) => {
+      if (o.dataTransfer) {
+        if (S(p.allowDrag) && !p.allowDrag(n.node))
+          return o.preventDefault(), !1;
+        o.dataTransfer.effectAllowed = "move";
+        try {
+          o.dataTransfer.setData("text/plain", "");
+        } catch {
+        }
+        d.value.draggingNode = n, f.emit("node-drag-start", n.node, o);
+      }
+    },
+    treeNodeDragOver: ({ event: o, treeNode: n }) => {
+      if (!o.dataTransfer) return;
+      const e = n, r = d.value.dropNode;
+      r && r.node.id !== e.node.id && I(r.$el, u.is("drop-inner"));
+      const t = d.value.draggingNode;
+      if (!t || !e) return;
+      let i = !0, a = !0, l = !0, g = !0;
+      S(p.allowDrop) && (i = p.allowDrop(t.node, e.node, "prev"), g = a = p.allowDrop(
+        t.node,
+        e.node,
+        "inner"
+      ), l = p.allowDrop(t.node, e.node, "next")), o.dataTransfer.dropEffect = a || i || l ? "move" : "none", (i || a || l) && (r == null ? void 0 : r.node.id) !== e.node.id && (r && f.emit("node-drag-leave", t.node, r.node, o), f.emit("node-drag-enter", t.node, e.node, o)), i || a || l ? d.value.dropNode = e : d.value.dropNode = null, e.node.nextSibling === t.node && (l = !1), e.node.previousSibling === t.node && (i = !1), e.node.contains(t.node, !1) && (a = !1), (t.node === e.node || t.node.contains(e.node)) && (i = !1, a = !1, l = !1);
+      const m = e.$el, N = m.querySelector(`.${u.be("node", "content")}`).getBoundingClientRect(), v = h.value.getBoundingClientRect(), w = h.value.scrollTop;
+      let s;
+      const C = i ? a ? 0.25 : l ? 0.45 : 1 : Number.NEGATIVE_INFINITY, P = l ? a ? 0.75 : i ? 0.55 : 0 : Number.POSITIVE_INFINITY;
+      let D = -9999;
+      const y = o.clientY - N.top;
+      y < N.height * C ? s = "before" : y > N.height * P ? s = "after" : a ? s = "inner" : s = "none";
+      const T = m.querySelector(`.${u.be("node", "expand-icon")}`).getBoundingClientRect(), b = E.value;
+      s === "before" ? D = T.top - v.top + w : s === "after" && (D = T.bottom - v.top + w), b.style.top = `${D}px`, b.style.left = `${T.right - v.left}px`, s === "inner" ? A(m, u.is("drop-inner")) : I(m, u.is("drop-inner")), d.value.showDropIndicator = s === "before" || s === "after", d.value.allowDrop = d.value.showDropIndicator || g, d.value.dropType = s, f.emit("node-drag-over", t.node, e.node, o);
+    },
+    treeNodeDragEnd: (o) => {
+      var t, i;
+      const { draggingNode: n, dropType: e, dropNode: r } = d.value;
+      if (o.preventDefault(), o.dataTransfer && (o.dataTransfer.dropEffect = "move"), n != null && n.node.data && r) {
+        const a = { data: n.node.data };
+        e !== "none" && n.node.remove(), e === "before" ? (t = r.node.parent) == null || t.insertBefore(a, r.node) : e === "after" ? (i = r.node.parent) == null || i.insertAfter(a, r.node) : e === "inner" && r.node.insertChild(a), e !== "none" && (c.value.registerNode(a), c.value.key && n.node.eachNode((l) => {
+          var g;
+          (g = c.value.nodesMap[l.data[c.value.key]]) == null || g.setChecked(
+            l.checked,
+            !c.value.checkStrictly
+          );
+        })), I(r.$el, u.is("drop-inner")), f.emit(
+          "node-drag-end",
+          n.node,
+          r.node,
+          e,
+          o
+        ), e !== "none" && f.emit(
+          "node-drop",
+          n.node,
+          r.node,
+          e,
+          o
+        );
+      }
+      n && !r && f.emit("node-drag-end", n.node, null, e, o), d.value.showDropIndicator = !1, d.value.draggingNode = null, d.value.dropNode = null, d.value.allowDrop = !0;
+    }
+  }), {
+    dragState: d
+  };
+}
+export {
+  x as dragEventsKey,
+  W as useDragNodeHandler
+};

package/dist/components/tree/src/model/useKeydown.d.ts

@@ -0,0 +1,7 @@
+import type TreeStore from './tree-store';
+import type { Ref } from 'vue';
+interface UseKeydownOption {
+    el$: Ref<HTMLElement | null>;
+}
+export declare function useKeydown({ el$ }: UseKeydownOption, store: Ref<TreeStore>): void;
+export {};