bkui-vue 2.1.0-dev-beta.10 → 2.1.0-dev-beta.11

package/lib/tree/props.d.ts

@@ -19,6 +19,49 @@ export type TreeNode = {
  */
 export type DropType = 'child' | 'move' | 'sort';
 export type DisableDropHandler = (data: TreeNode, type: DropType, target: TreeNode) => boolean;
+export type TreeDataChangeTrigger = 'async' | 'drag';
+export type TreeDataChangePayload = {
+    trigger: TreeDataChangeTrigger;
+    data: TreeNode[];
+    node: TreeNode;
+    targetNode?: TreeNode;
+    parentNode?: TreeNode | null;
+    oldParentNode?: TreeNode | null;
+    dropType?: DropType;
+    sourceIndex?: number;
+    targetIndex?: number;
+};
+export type TreeDataChangeHandler = (payload: TreeDataChangePayload) => void;
+export type TreeCheckedPayload = {
+    checkedNodes: TreeNode[];
+    indeterminateNodes: TreeNode[];
+};
+export type TreeSelectedPayload = {
+    selected: boolean;
+    node: TreeNode;
+};
+export type TreeDropPayload = {
+    event: unknown;
+    element: HTMLElement;
+    targetNode: TreeNode;
+    sourceNode: TreeNode;
+    data: TreeNode[];
+    parentNode?: TreeNode | null;
+    oldParentNode?: TreeNode | null;
+    dropType?: DropType;
+    sourceIndex?: number;
+    targetIndex?: number;
+};
+export type TreeDragSortPayload = {
+    sourceNode: TreeNode;
+    targetNode: TreeNode;
+    data: TreeNode[];
+    parentNode?: TreeNode | null;
+    oldParentNode?: TreeNode | null;
+    dropType?: DropType;
+    sourceIndex?: number;
+    targetIndex?: number;
+};
 /**
  * Tree Prop: prefixIcon function
  * @param {} isRoot 是否为分跟节点
@@ -102,6 +145,10 @@ export declare const treeProps: {
     prefixIcon: import("vue-types").VueTypeDef<any> & {
         default: any;
     };
+    /**
+     * 当树数据需要由外部接管更新时的统一回调
+     */
+    onDataChange: PropType<TreeDataChangeHandler>;
     /**
      * 异步加载节点数据配置
      * @param callback 请求数据回调函数，函数返回 Promise
@@ -275,6 +322,14 @@ export declare const treeProps: {
     } & {
         default: boolean;
     };
+    /**
+     * 是否开启父子勾选级联；未传时沿用 checkStrictly 历史语义
+     */
+    cascade: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
     /**
      * 是否开启监听Tree节点进入Tree容器可视区域
      */
@@ -282,8 +337,9 @@ export declare const treeProps: {
         default: boolean | (() => IIntersectionObserver);
     };
 };
+type AsyncLoadCallback = (item: TreeNode, cb: (data: TreeNode | TreeNode[]) => Promise<unknown> | unknown, data?: unknown) => Promise<TreeNode | TreeNode[]> | TreeNode | TreeNode[];
 type AsyncOption = {
-    callback: (item: any, cb: any) => Promise<VNode | string>;
+    callback: AsyncLoadCallback;
     cache: boolean;
     deepAutoOpen?: string;
     trigger?: string[];

package/lib/tree/tree.css

@@ -189,6 +189,29 @@
 .bk-tree .bk-node-row.is-selected:hover {
   background-color: #e1ecff;
 }
+.bk-tree .bk-node-row.drop-before::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background-color: #2196F3;
+}
+.bk-tree .bk-node-row.drop-after::before {
+  content: '';
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background-color: #2196F3;
+}
+.bk-tree .bk-node-row.drop-inner {
+  background-color: rgba(33, 150, 243, 0.1);
+  outline: 1px dashed #2196F3;
+  outline-offset: -1px;
+}
 .bk-tree-node {
   position: relative;
   display: flex;
@@ -299,6 +322,14 @@
   cursor: no-drop;
   opacity: 0.5;
 }
+.bk-tree .insert-line {
+  position: absolute;
+  height: 2px;
+  background: #2196F3;
+  display: none;
+  pointer-events: none;
+  z-index: 999;
+}
 .bk-tree-drop-indicator {
   position: fixed;
   pointer-events: none;

package/lib/tree/tree.d.ts

@@ -1,4 +1,4 @@
-import { TreePropTypes as defineTypes } from './props';
+import { TreePropTypes as defineTypes, TreeNode } from './props';
 export type TreePropTypes = defineTypes;
 export type ITreeScrollTopOption = {
     id?: string;
@@ -43,10 +43,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     prefixIcon: import("vue-types").VueTypeDef<any> & {
         default: any;
     };
+    onDataChange: import("vue").PropType<import("./props").TreeDataChangeHandler>;
     async: import("vue-types").VueTypeShape<{
-        callback: (item: any, cb: any) => Promise<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>>;
+        callback: (item: TreeNode, cb: (data: TreeNode | TreeNode[]) => unknown, data?: unknown) => TreeNode | TreeNode[] | Promise<TreeNode | TreeNode[]>;
         cache: boolean;
         deepAutoOpen?: string;
         trigger?: string[];
@@ -139,14 +138,22 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     } & {
         default: boolean;
     };
+    cascade: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
     intersectionObserver: import("vue-types").VueTypeDef<boolean | import("./props").IIntersectionObserver> & {
         default: boolean | (() => import("./props").IIntersectionObserver);
     };
 }>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    nodeAsyncLoad: (..._args: any[]) => boolean;
+    nodeAsyncLoadError: (..._args: any[]) => boolean;
     nodeClick: (..._args: any[]) => boolean;
     nodeCollapse: (..._args: any[]) => boolean;
     nodeExpand: (..._args: any[]) => boolean;
     nodeChecked: (..._args: any[]) => boolean;
+    nodeDataChange: (..._args: any[]) => boolean;
     nodeDragStart: (..._args: any[]) => boolean;
     nodeDragOver: (..._args: any[]) => boolean;
     nodeDragLeave: (..._args: any[]) => boolean;
@@ -193,10 +200,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     prefixIcon: import("vue-types").VueTypeDef<any> & {
         default: any;
     };
+    onDataChange: import("vue").PropType<import("./props").TreeDataChangeHandler>;
     async: import("vue-types").VueTypeShape<{
-        callback: (item: any, cb: any) => Promise<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>>;
+        callback: (item: TreeNode, cb: (data: TreeNode | TreeNode[]) => unknown, data?: unknown) => TreeNode | TreeNode[] | Promise<TreeNode | TreeNode[]>;
         cache: boolean;
         deepAutoOpen?: string;
         trigger?: string[];
@@ -289,13 +295,21 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     } & {
         default: boolean;
     };
+    cascade: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
     intersectionObserver: import("vue-types").VueTypeDef<boolean | import("./props").IIntersectionObserver> & {
         default: boolean | (() => import("./props").IIntersectionObserver);
     };
 }>> & Readonly<{
+    onNodeAsyncLoad?: (...args: any[]) => any;
+    onNodeAsyncLoadError?: (...args: any[]) => any;
     onNodeChecked?: (...args: any[]) => any;
     onNodeClick?: (...args: any[]) => any;
     onNodeCollapse?: (...args: any[]) => any;
+    onNodeDataChange?: (...args: any[]) => any;
     onNodeDragLeave?: (...args: any[]) => any;
     onNodeDragOver?: (...args: any[]) => any;
     onNodeDragSort?: (...args: any[]) => any;
@@ -335,5 +349,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     nodeContentAction: any;
     keepSlotData: boolean;
     checkStrictly: boolean;
+    cascade: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/tree/tree.less

@@ -22,6 +22,35 @@
         background-color: #e1ecff;
       }
     }
+
+    &.drop-before {
+      &::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        height: 1px;
+        background-color: #2196F3;
+      }
+    }
+    &.drop-after {
+      &::before {
+        content: '';
+        position: absolute;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        height: 1px;
+        background-color: #2196F3;
+      }
+    }
+
+    &.drop-inner {
+      background-color: rgba(33, 150, 243, 0.1);
+      outline: 1px dashed #2196F3;
+      outline-offset: -1px;
+    }
   }
 
   &-node {
@@ -143,7 +172,6 @@
     }
   }
 
-  // SortableJS ghost/chosen/drag 样式
   &-ghost {
     opacity: 0.5;
     background: #c8ebfb;
@@ -165,17 +193,22 @@
       opacity: 0.5;
     }
   }
+
+  .insert-line {
+    position: absolute;
+    height: 2px;
+    background: #2196F3;
+    display: none;
+    pointer-events: none;
+    z-index: 999;
+  }
 }
 
-// 拖拽放置指示器（overlay 方式，挂载在 body 上）
-// sort/move 类型：水平线 + 两端圆点，指示同级插入位置
-// child 类型：高亮边框 + 浅色背景，指示嵌入为子节点
 .@{bk-prefix}-tree-drop-indicator {
   position: fixed;
   pointer-events: none;
   z-index: 9999;
 
-  // child 类型：嵌入为子节点的指示器
   &.@{bk-prefix}-tree-drop-inner {
     background: rgba(33, 150, 243, 0.06);
     outline: 2px dashed #3a84ff;
@@ -184,7 +217,6 @@
     box-shadow: inset 0 0 0 1px rgba(58, 132, 255, 0.1);
   }
 
-  // sort/move 类型：同级插入的水平线指示器
   &.@{bk-prefix}-tree-drop-line {
     background: #3a84ff;
     border-radius: 1px;

package/lib/tree/tree.variable.css

@@ -320,6 +320,29 @@
 .bk-tree .bk-node-row.is-selected:hover {
   background-color: #e1ecff;
 }
+.bk-tree .bk-node-row.drop-before::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background-color: #2196F3;
+}
+.bk-tree .bk-node-row.drop-after::before {
+  content: '';
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background-color: #2196F3;
+}
+.bk-tree .bk-node-row.drop-inner {
+  background-color: rgba(33, 150, 243, 0.1);
+  outline: 1px dashed #2196F3;
+  outline-offset: -1px;
+}
 .bk-tree-node {
   position: relative;
   display: flex;
@@ -430,6 +453,14 @@
   cursor: no-drop;
   opacity: 0.5;
 }
+.bk-tree .insert-line {
+  position: absolute;
+  height: 2px;
+  background: #2196F3;
+  display: none;
+  pointer-events: none;
+  z-index: 999;
+}
 .bk-tree-drop-indicator {
   position: fixed;
   pointer-events: none;

package/lib/tree/use-intersection-observer.d.ts

@@ -6,7 +6,7 @@ type IntersectionObserverOptions = {
 };
 type IntersectionObserverResponseValue = {
     level: number;
-    node: Record<string, any>;
+    node: Record<string, unknown>;
     index: number;
     entry: IntersectionObserverEntry;
 };

package/lib/tree/use-node-action.d.ts

@@ -4,13 +4,13 @@ declare const _default: (props: TreePropTypes, ctx: any, flatData: IFlatData, _r
     renderTreeNode: (item: TreeNode, showTree?: boolean) => JSX.Element;
     handleTreeNodeClick: (item: TreeNode, e: MouseEvent, event?: string) => void;
     deepAutoOpen: () => void;
-    asyncNodeClick: (item: TreeNode) => Promise<boolean> | Promise<void | Record<string, unknown>>;
+    asyncNodeClick: (item: TreeNode) => Promise<boolean | (TreeNode | TreeNode[])>;
     setNodeAction: (args: TreeNode | TreeNode[], action: string, value: unknown) => void;
     setNodeOpened: (item: TreeNode, isOpen?: any, e?: MouseEvent, fireEmit?: boolean) => void;
     setSelect: (nodes: TreeNode | TreeNode[], selected?: boolean, autoOpen?: boolean, triggerEvent?: boolean, event?: string) => void;
     setOpen: (item: TreeNode, isOpen?: boolean, autoOpenParents?: boolean) => void;
     setNodeAttribute: (node: TreeNode, attrName: string | string[], value: (boolean | number | string)[] | boolean | number | string, loopParent?: boolean) => void;
-    isIndeterminate: (item: TreeNode) => any;
+    isIndeterminate: (item: TreeNode) => boolean;
     deepUpdateChildNode: (node: TreeNode, attr: string | string[], value: unknown | unknown[]) => void;
     updateParentChecked: (item: TreeNode, isChecked: any) => void;
 };

package/lib/tree/use-node-async.d.ts

@@ -1,6 +1,16 @@
-import { TreeNode } from './props';
-declare const _default: (props: any, flatData: any) => {
-    asyncNodeClick: (item: TreeNode) => Promise<boolean> | Promise<void | Record<string, unknown>>;
+import { EVENTS } from './constant';
+import { TreeDataChangePayload, TreeNode, TreePropTypes } from './props';
+import { IFlatData } from './util';
+type TreeContext = {
+    emit: (event: EVENTS, ...args: unknown[]) => void;
+};
+type AsyncLoadResponse = TreeNode | TreeNode[];
+export type UseNodeAsyncOptions = {
+    getTreeData?: () => TreeNode[];
+    onTreeDataChange?: (payload: TreeDataChangePayload) => void;
+};
+declare const _default: (props: TreePropTypes, flatData: IFlatData, ctx?: TreeContext, options?: UseNodeAsyncOptions) => {
+    asyncNodeClick: (item: TreeNode) => Promise<boolean | AsyncLoadResponse>;
     deepAutoOpen: () => void;
 };
 export default _default;

package/lib/tree/use-node-attribute.d.ts

@@ -1,71 +1,99 @@
+import { NODE_ATTRIBUTES } from './constant';
 import { TreeNode, TreePropTypes } from './props';
+type TreeNodeAttributeMap = {
+    [NODE_ATTRIBUTES.DEPTH]: number;
+    [NODE_ATTRIBUTES.HAS_CHILD]: boolean;
+    [NODE_ATTRIBUTES.INDEX]: number;
+    [NODE_ATTRIBUTES.IS_ASYNC]: boolean;
+    [NODE_ATTRIBUTES.IS_ASYNC_INIT]: boolean;
+    [NODE_ATTRIBUTES.IS_CACHED]: boolean;
+    [NODE_ATTRIBUTES.IS_CHECKED]: boolean;
+    [NODE_ATTRIBUTES.IS_INDETERMINATE]: boolean;
+    [NODE_ATTRIBUTES.IS_LOADING]: boolean;
+    [NODE_ATTRIBUTES.IS_MATCH]: boolean;
+    [NODE_ATTRIBUTES.IS_NULL]: boolean;
+    [NODE_ATTRIBUTES.IS_OPEN]: boolean;
+    [NODE_ATTRIBUTES.IS_ROOT]: boolean;
+    [NODE_ATTRIBUTES.IS_SELECTED]: boolean;
+    [NODE_ATTRIBUTES.ORDER]: number;
+    [NODE_ATTRIBUTES.PARENT]: TreeNode;
+    [NODE_ATTRIBUTES.PATH]: string;
+    [NODE_ATTRIBUTES.TREE_NODE_ATTR]: Record<string, unknown>;
+    [NODE_ATTRIBUTES.UUID]: string | number;
+};
 declare const _default: (flatData: {
     data: TreeNode[];
-    schema: WeakMap<TreeNode, unknown>;
+    schema: WeakMap<TreeNode, Record<string, unknown>>;
+    nodeMap?: Map<number | string, TreeNode>;
+    childMap?: WeakMap<TreeNode, TreeNode[]>;
+    rootNodes?: TreeNode[];
 }, props?: TreePropTypes) => {
-    getSchemaVal: (node: TreeNode) => unknown;
-    getNodeAttr: (node: TreeNode, attr: string) => any;
-    getNodeId: (node: TreeNode) => any;
+    getSchemaVal: (node: TreeNode) => Record<string, unknown>;
+    getNodeAttr: {
+        <T extends NODE_ATTRIBUTES>(node: TreeNode | null | undefined, attr: T): TreeNodeAttributeMap[T];
+        (node: TreeNode | null | undefined, attr: string): unknown;
+    };
+    getNodeId: (node: TreeNode | null | undefined) => string | number;
     getNodeById: (id: string | unknown) => TreeNode;
-    getNodeParentId: (node: TreeNode) => any;
-    getParentNodeData: (node: TreeNode | string) => any;
-    getNodePathById: (id: string) => any;
-    getNodeAttrById: (id: string, attr: string) => any;
-    getNodeParentIdById: (id: string) => any;
+    getNodeParentId: (node: TreeNode) => string | number;
+    getParentNodeData: (node: TreeNode | string) => TreeNode;
+    getNodePathById: (id: string) => string;
+    getNodeAttrById: (id: string, attr: string) => unknown;
+    getNodeParentIdById: (id: string) => string | number;
     getNodeIndexById: (id: string) => number;
     getNodeIndexByNode: (node: TreeNode) => number;
     getRootNodeList: () => TreeNode[];
-    getParentNodeAttr: (node: TreeNode, attrName: string) => any;
-    getParentNode: (node: TreeNode) => any;
+    getParentNodeAttr: (node: TreeNode, attrName: string) => unknown;
+    getParentNode: (node: TreeNode) => TreeNode;
     setNodeAttr: (node: TreeNode, attr: string, val: unknown, id?: any) => void;
     setNodeAttrById: (id: unknown, attr: string, val: unknown) => void;
-    getNodePath: (node: TreeNode) => any;
-    isRootNode: (node: TreeNode | string) => any;
-    isNodeOpened: (node: TreeNode) => any;
-    hasChildNode: (node: TreeNode) => any;
-    isItemOpen: (item: TreeNode) => any;
-    isNodeChecked: (node: TreeNode) => any;
-    isNodeMatched: (node: TreeNode) => any;
-    isNodeLoading: (node: TreeNode) => any;
-    checkNodeIsOpen: (node: TreeNode) => any;
+    getNodePath: (node: TreeNode) => string;
+    isRootNode: (node: TreeNode | string) => boolean;
+    isNodeOpened: (node: TreeNode) => boolean;
+    hasChildNode: (node: TreeNode) => boolean;
+    isItemOpen: (item: TreeNode) => unknown;
+    isNodeChecked: (node: TreeNode) => boolean;
+    isNodeMatched: (node: TreeNode) => boolean;
+    isNodeLoading: (node: TreeNode) => boolean;
+    checkNodeIsOpen: (node: TreeNode) => unknown;
     getSourceNodeByPath: (path: string, uid?: string) => any[];
     getSourceNodeByUID: (uid: string) => TreeNode;
-    isMatchedNode: (node: TreeNode) => any;
+    isMatchedNode: (node: TreeNode) => boolean;
     resolveScopedSlotParam: (item: TreeNode) => {
-        [x: string]: any;
-        fullPath: any;
-        uuid: any;
-        parent: any;
-        parentId: any;
+        [x: string]: string | number | boolean | TreeNode;
+        fullPath: string;
+        uuid: string | number;
+        parent: TreeNode;
+        parentId: string | number;
     };
     setTreeNodeLoading: (node: TreeNode, value: boolean) => void;
     extendNodeAttr: (item: TreeNode) => TreeNode & {
         __attr__: {
-            [x: string]: any;
-            fullPath: any;
-            uuid: any;
-            parent: any;
-            parentId: any;
+            [x: string]: string | number | boolean | TreeNode;
+            fullPath: string;
+            uuid: string | number;
+            parent: TreeNode;
+            parentId: string | number;
         };
     };
     getChildNodes: (node: TreeNode) => TreeNode[];
     extendNodeScopedData: (item: TreeNode) => {
         data: TreeNode;
         attributes: {
-            [x: string]: any;
-            fullPath: any;
-            uuid: any;
-            parent: any;
-            parentId: any;
+            [x: string]: string | number | boolean | TreeNode;
+            fullPath: string;
+            uuid: string | number;
+            parent: TreeNode;
+            parentId: string | number;
         };
     };
     getIntersectionResponse: (target: HTMLElement | TreeNode) => {
-        level: any;
+        level: number;
         target: HTMLElement | TreeNode;
-        index: any;
-        parent: any;
+        index: number;
+        parent: TreeNode;
         node: HTMLElement | TreeNode;
-        isRoot: any;
+        isRoot: boolean;
     };
 };
 export default _default;

package/lib/tree/use-node-drag.d.ts

@@ -1,5 +1,18 @@
-import { TreePropTypes } from './props';
-declare const _default: (props: TreePropTypes, ctx: any, root?: any, flatData?: any) => {
-    isDragging: import("vue").Ref<boolean, boolean>;
+import { Ref, SetupContext } from 'vue';
+import { TreeEmitEventsType } from './constant';
+import { TreeDataChangePayload, TreeNode, TreePropTypes } from './props';
+import { IFlatData } from './util';
+type TreeContext = {
+    emit: SetupContext<typeof TreeEmitEventsType>['emit'];
+};
+type TreeRoot = {
+    $el: HTMLElement;
+};
+type UseNodeDragOptions = {
+    getTreeData?: () => TreeNode[];
+    onTreeDataChange?: (payload: TreeDataChangePayload) => void;
+};
+declare const _default: (props: TreePropTypes, ctx: TreeContext, root: Ref<TreeRoot>, flatData: IFlatData, options?: UseNodeDragOptions) => {
+    isDragging: Ref<boolean, boolean>;
 };
 export default _default;

package/lib/tree/use-tree-init.d.ts

@@ -6,12 +6,25 @@ declare const _default: (props: TreePropTypes) => {
             children?: any[];
         }[];
         schema: WeakMap<TreeNode, Record<string, unknown>> & Omit<WeakMap<TreeNode, Record<string, unknown>>, keyof WeakMap<any, any>>;
+        nodeMap: Map<string, {
+            [x: string]: unknown;
+            children?: any[];
+        }> & Omit<Map<string, TreeNode>, keyof Map<any, any>>;
+        childMap: WeakMap<TreeNode, {
+            [x: string]: unknown;
+            children?: any[];
+        }[]> & Omit<WeakMap<TreeNode, TreeNode[]>, keyof WeakMap<any, any>>;
+        rootNodes: {
+            [x: string]: unknown;
+            children?: any[];
+        }[];
         levelLineSchema: {};
     };
-    asyncNodeClick: (item: TreeNode) => Promise<boolean> | Promise<void | Record<string, unknown>>;
+    asyncNodeClick: (item: TreeNode) => Promise<boolean | (TreeNode | TreeNode[])>;
     deepAutoOpen: () => void;
     afterDataUpdate: (callFn: (d: any) => void) => void;
     registerNextLoop: (key: string, event: any, reset?: boolean) => void;
+    rebuildData: (treeData: TreeNode[], cachedSchema?: WeakMap<TreeNode, Record<string, unknown>> & Omit<WeakMap<TreeNode, Record<string, unknown>>, keyof WeakMap<any, any>>) => void;
     onSelected: (event: (d: any) => void) => void;
 };
 export default _default;

package/lib/tree/util.d.ts

@@ -1,7 +1,11 @@
-import { TreeNode, TreePropTypes } from './props';
+import { TreeDataChangePayload, TreeNode, TreePropTypes } from './props';
+export type TreeNodeKey = number | string;
 export type IFlatData = {
     data: TreeNode[];
     schema: WeakMap<TreeNode, Record<string, unknown>>;
+    nodeMap?: Map<TreeNodeKey, TreeNode>;
+    childMap?: WeakMap<TreeNode, TreeNode[]>;
+    rootNodes?: TreeNode[];
 };
 /**
  * 获取当前节点显示Label
@@ -48,6 +52,7 @@ export declare const getNodeItemClass: (item: TreeNode, schema: WeakMap<TreeNode
 export declare const getNodeRowClass: (item: TreeNode, schema: WeakMap<TreeNode, Record<string, unknown>>) => {
     [x: string]: unknown;
     'is-checked': unknown;
+    'is-indeterminate': unknown;
     'is-selected': unknown;
     'node-folder': unknown;
     'node-leaf': unknown;
@@ -61,6 +66,29 @@ export declare const getNodeRowClass: (item: TreeNode, schema: WeakMap<TreeNode,
  * @param nodeValue 节点值
  */
 export declare const updateTreeNode: (path: string, treeData: TreeNode[], childKey: string, nodekey: string, nodeValue: Record<string, unknown>[]) => void;
+export declare const cloneTreeData: (treeData?: TreeNode[], childKey?: string) => TreeNode[];
+export declare const isSameNodeId: (left: unknown, right: unknown) => boolean;
+export declare const findNodeById: (treeData: TreeNode[], nodeId: number | string, nodeKey: string, childKey: string) => TreeNode | null;
+export declare const mutateTreeById: (treeData: TreeNode[], nodeId: number | string, nodeKey: string, childKey: string, updater: (node: TreeNode) => void) => TreeNode[];
+export declare const removeTreeNodeById: (treeData: TreeNode[], nodeId: number | string, nodeKey: string, childKey: string) => {
+    node: TreeNode | null;
+    data: TreeNode[];
+    parentNode: TreeNode | null;
+    index: number;
+};
+export declare const insertTreeNodeById: (treeData: TreeNode[], node: TreeNode, targetNodeId: number | string, nodeKey: string, childKey: string, options: {
+    dropType: 'child' | 'move' | 'sort';
+    willInsertAfter?: boolean;
+}) => {
+    data: TreeNode[];
+    parentNode: TreeNode | null;
+    targetNode: TreeNode | null;
+    index: number;
+};
+export declare const moveTreeNodeById: (treeData: TreeNode[], nodeId: number | string, targetNodeId: number | string, nodeKey: string, childKey: string, options: {
+    dropType: 'child' | 'move' | 'sort';
+    willInsertAfter?: boolean;
+}) => TreeDataChangePayload | null;
 /**
  * 根据路径更新指定节点Child-Data
  * @param path 节点路径
@@ -72,3 +100,4 @@ export declare const assignTreeNode: (path: string, treeData: TreeNode[], childK
 export declare const resolveNodeItem: (node: TreeNode) => TreeNode;
 export declare const resolvePropIsMatched: (node: any, prop: any, id: any) => any;
 export declare const showCheckbox: (props: TreePropTypes, node?: TreeNode) => any;
+export declare const isCascadeEnabled: (props: TreePropTypes) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bkui-vue",
-  "version": "2.1.0-dev-beta.10",
+  "version": "2.1.0-dev-beta.11",
   "workspaces": [
     "packages/**",
     "scripts/cli",