@qsxy/element-plus-react 1.0.0-next.5 → 1.0.0-next.7

package/dist/Tree/contextTypes.d.ts

@@ -1,21 +1,23 @@
-import React, { Context } from 'react';
 /**
  * Webpack has bug for import loop, which is not the same behavior as ES module.
  * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
  */
-import { DraggableConfig } from './RCTree';
-import { BasicDataNode, DataEntity, DataNode, Direction, EventDataNode, IconType, Key, NodeInstance } from './typings';
-export type NodeMouseEventParams = {
-    event: React.MouseEvent;
-    node: EventDataNode;
+import * as React from 'react';
+import type { DraggableConfig, SemanticName } from './RCTree';
+import type { BasicDataNode, DataNode, Direction, EventDataNode, IconType, Key, KeyEntities, TreeNodeProps } from './typings';
+export type NodeMouseEventParams<TreeDataType extends BasicDataNode = DataNode, T = HTMLSpanElement> = {
+    event: React.MouseEvent<T>;
+    node: EventDataNode<TreeDataType>;
 };
-export type NodeDragEventParams = {
-    event: DragEvent;
-    node: EventDataNode;
+export type NodeDragEventParams<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = {
+    event: React.DragEvent<T>;
+    node: EventDataNode<TreeDataType>;
 };
-export type NodeMouseEventHandler = (e: React.MouseEvent<HTMLSpanElement>, node: EventDataNode) => void;
-export type NodeDragEventHandler<T = HTMLDivElement, TreeDataType extends BasicDataNode = DataNode> = (e: any, node: NodeInstance<TreeDataType>, outsideTree?: boolean) => void;
-export interface TreeContextProps {
+export type NodeMouseEventHandler<TreeDataType extends BasicDataNode = DataNode, T = HTMLSpanElement> = (e: React.MouseEvent<T>, node: EventDataNode<TreeDataType>) => void;
+export type NodeDragEventHandler<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = (e: React.DragEvent<T>, nodeProps: TreeNodeProps<TreeDataType>, outsideTree?: boolean) => void;
+export interface TreeContextProps<TreeDataType extends BasicDataNode = DataNode> {
+    styles?: Partial<Record<SemanticName, React.CSSProperties>>;
+    classNames?: Partial<Record<SemanticName, string>>;
     prefixCls: string;
     selectable: boolean;
     showIcon: boolean;
@@ -23,10 +25,10 @@ export interface TreeContextProps {
     switcherIcon: IconType;
     draggable?: DraggableConfig;
     draggingNodeKey?: Key;
-    checkable: boolean | React.ReactElement;
+    checkable: boolean | React.ReactNode;
     checkStrictly: boolean;
     disabled: boolean;
-    keyEntities: Record<Key, DataEntity<any>>;
+    keyEntities: KeyEntities;
     dropLevelOffset?: number;
     dropContainerKey: Key | null;
     dropTargetKey: Key | null;
@@ -35,24 +37,24 @@ export interface TreeContextProps {
     dropIndicatorRender: (props: {
         dropPosition: -1 | 0 | 1;
         dropLevelOffset: number;
-        indent: any;
-        prefixCls: any;
+        indent: number;
+        prefixCls: string;
         direction: Direction;
-    }) => React.ReactElement;
+    }) => React.ReactNode;
     dragOverNodeKey: Key | null;
     direction: Direction;
-    loadData: (treeNode: EventDataNode) => Promise<void>;
-    filterTreeNode: (treeNode: EventDataNode) => boolean;
-    titleRender?: (node: any) => React.ReactElement | string;
-    onNodeClick: NodeMouseEventHandler;
-    onNodeDoubleClick: NodeMouseEventHandler;
-    onNodeExpand: NodeMouseEventHandler;
-    onNodeSelect: NodeMouseEventHandler;
-    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode, checked: boolean) => void;
-    onNodeLoad: (treeNode: EventDataNode) => void;
-    onNodeMouseEnter: NodeMouseEventHandler;
-    onNodeMouseLeave: NodeMouseEventHandler;
-    onNodeContextMenu: NodeMouseEventHandler;
+    loadData: (treeNode: EventDataNode<TreeDataType>) => Promise<void>;
+    filterTreeNode: (treeNode: EventDataNode<TreeDataType>) => boolean;
+    titleRender?: (node: any) => React.ReactNode;
+    onNodeClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeDoubleClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeExpand: NodeMouseEventHandler<TreeDataType>;
+    onNodeSelect: NodeMouseEventHandler<TreeDataType>;
+    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode<TreeDataType>, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode<TreeDataType>) => void;
+    onNodeMouseEnter: NodeMouseEventHandler<TreeDataType>;
+    onNodeMouseLeave: NodeMouseEventHandler<TreeDataType>;
+    onNodeContextMenu: NodeMouseEventHandler<TreeDataType>;
     onNodeDragStart: NodeDragEventHandler<any, any>;
     onNodeDragEnter: NodeDragEventHandler<any, any>;
     onNodeDragOver: NodeDragEventHandler<any, any>;
@@ -60,4 +62,8 @@ export interface TreeContextProps {
     onNodeDragEnd: NodeDragEventHandler<any, any>;
     onNodeDrop: NodeDragEventHandler<any, any>;
 }
-export declare const TreeContext: Context<TreeContextProps | null>;
+export declare const TreeContext: React.Context<TreeContextProps<any>>;
+/** Internal usage, safe to remove. Do not use in prod */
+export declare const UnstableContext: React.Context<{
+    nodeDisabled?: (n: DataNode) => boolean;
+}>;

package/dist/Tree/contextTypes.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,17 +16,28 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/Tree/contextTypes.ts
 var contextTypes_exports = {};
 __export(contextTypes_exports, {
-  TreeContext: () => TreeContext
+  TreeContext: () => TreeContext,
+  UnstableContext: () => UnstableContext
 });
 module.exports = __toCommonJS(contextTypes_exports);
-var import_react = require("react");
-var TreeContext = (0, import_react.createContext)(null);
+var React = __toESM(require("react"));
+var TreeContext = React.createContext(null);
+var UnstableContext = React.createContext({});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TreeContext
+  TreeContext,
+  UnstableContext
 });

package/dist/Tree/index.d.ts

@@ -1,9 +1,9 @@
 export { default as DirectoryTree } from './DirectoryTree';
 export type { ExpandAction as DirectoryTreeExpandAction, DirectoryTreeProps } from './DirectoryTree';
 export { default as RCTree } from './RCTree';
-export type { CheckInfo, TreeProps } from './RCTree';
+export type { CheckInfo } from './RCTree';
 export { default as Tree } from './Tree';
-export type { AntTreeNode, AntTreeNodeCheckedEvent, AntTreeNodeExpandedEvent, AntTreeNodeMouseEvent, AntTreeNodeProps, AntTreeNodeSelectedEvent, AntdTreeNodeAttribute, } from './Tree';
+export type { TreeProps } from './Tree';
 export { default as TreeNode } from './TreeNode';
 export type { TreeNodeProps } from './TreeNode';
 export type { BasicDataNode, DataNode, EventDataNode, Key } from './typings';

package/dist/Tree/typings.d.ts

@@ -1,7 +1,38 @@
-import React, { Component } from 'react';
-import { IconName } from '../Icon';
-import { TreeNodeProps } from './TreeNode';
-export { ScrollTo } from '../VirtualList';
+import React from 'react';
+export type { ScrollTo } from 'rc-virtual-list/lib/List';
+export interface TreeNodeProps<TreeDataType extends BasicDataNode = DataNode> {
+    eventKey?: Key;
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    id?: string;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    halfChecked?: boolean;
+    title?: React.ReactNode | ((data: TreeDataType) => React.ReactNode);
+    dragOver?: boolean;
+    dragOverGapTop?: boolean;
+    dragOverGapBottom?: boolean;
+    pos?: string;
+    domRef?: React.Ref<HTMLDivElement>;
+    /** New added in Tree for easy data access */
+    data?: TreeDataType;
+    isStart?: boolean[];
+    isEnd?: boolean[];
+    active?: boolean;
+    onMouseMove?: React.MouseEventHandler<HTMLDivElement>;
+    isLeaf?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    switcherIcon?: IconType;
+    children?: React.ReactNode;
+}
 /** For fieldNames, we provides a abstract interface */
 export interface BasicDataNode {
     checkable?: boolean;
@@ -15,12 +46,23 @@ export interface BasicDataNode {
     className?: string;
     style?: React.CSSProperties;
 }
-export interface DataNode<T = any> extends BasicDataNode {
-    children?: T[];
-    key?: string | number;
-    title?: string | React.ReactElement;
-}
-export interface EventDataNode extends DataNode {
+/** Provide a wrap type define for developer to wrap with customize fieldNames data type */
+export type FieldDataNode<T, ChildFieldName extends string = 'children'> = BasicDataNode & T & Partial<Record<ChildFieldName, FieldDataNode<T, ChildFieldName>[]>>;
+export type Key = React.Key;
+/**
+ * Typescript not support `bigint` as index type yet.
+ * We use this to mark the `bigint` type is for `Key` usage.
+ * It's safe to remove this when typescript fix:
+ * https://github.com/microsoft/TypeScript/issues/50217
+ */
+export type SafeKey = Exclude<Key, bigint>;
+export type KeyEntities<DateType extends BasicDataNode = any> = Record<SafeKey, DataEntity<DateType>>;
+export type DataNode = FieldDataNode<{
+    key: Key;
+    title?: React.ReactNode | ((data: DataNode) => React.ReactNode);
+}>;
+export type EventDataNode<TreeDataType> = {
+    key: Key;
     expanded: boolean;
     selected: boolean;
     checked: boolean;
@@ -32,16 +74,15 @@ export interface EventDataNode extends DataNode {
     dragOverGapBottom: boolean;
     pos: string;
     active: boolean;
-}
-export type IconType = React.ReactElement | ((props: TreeNodeProps) => React.ReactElement) | IconName;
-export type Key = string | number;
+} & TreeDataType & BasicDataNode;
+export type IconType = React.ReactNode | ((props: TreeNodeProps) => React.ReactNode);
 export type NodeElement = React.ReactElement<TreeNodeProps> & {
     selectHandle?: HTMLSpanElement;
     type: {
         isTreeNode: boolean;
     };
 };
-export type NodeInstance<TreeDataType extends BasicDataNode = DataNode> = Component<TreeNodeProps<TreeDataType>> & {
+export type NodeInstance<TreeDataType extends BasicDataNode = DataNode> = React.Component<TreeNodeProps<TreeDataType>> & {
     selectHandle?: HTMLSpanElement;
 };
 export interface Entity {
@@ -59,12 +100,12 @@ export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> exten
     children?: DataEntity<TreeDataType>[];
     level: number;
 }
-export interface FlattenNode {
-    parent: FlattenNode | null;
-    children: FlattenNode[];
+export interface FlattenNode<TreeDataType extends BasicDataNode = DataNode> {
+    parent: FlattenNode<TreeDataType> | null;
+    children: FlattenNode<TreeDataType>[];
     pos: string;
-    data: DataNode;
-    title: React.ReactElement;
+    data: TreeDataType;
+    title: React.ReactNode;
     key: Key;
     isStart: boolean[];
     isEnd: boolean[];

package/dist/Tree/typings.js

@@ -2,10 +2,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -16,14 +12,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/Tree/typings.tsx
+// src/Tree/typings.ts
 var typings_exports = {};
-__export(typings_exports, {
-  ScrollTo: () => import_VirtualList.ScrollTo
-});
 module.exports = __toCommonJS(typings_exports);
-var import_VirtualList = require("../VirtualList");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ScrollTo
-});

package/dist/Tree/typings.tsx--bak

@@ -0,0 +1,245 @@
+import React, { Component } from 'react';
+import { IconName } from '../Icon';
+import { TreeProps as RcTreeProps } from './RCTree';
+import { TreeNodeProps } from './TreeNode';
+
+export interface AntdTreeNodeAttribute {
+    eventKey: string;
+    prefixCls: string;
+    className: string;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    children: React.ReactElement;
+    title: React.ReactElement;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    isLeaf: boolean;
+    selectable: boolean;
+    disabled: boolean;
+    disableCheckbox: boolean;
+}
+
+export interface AntTreeNodeProps {
+    className?: string;
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    title?: string | React.ReactElement;
+    key?: Key;
+    eventKey?: string;
+    isLeaf?: boolean;
+    checked?: boolean;
+    expanded?: boolean;
+    loading?: boolean;
+    selected?: boolean;
+    selectable?: boolean;
+    icon?: ((treeNode: AntdTreeNodeAttribute) => React.ReactElement) | React.ReactElement;
+    children?: React.ReactElement;
+    [customProp: string]: any;
+}
+
+export type AntTreeNode = Component<AntTreeNodeProps, {}>;
+
+export interface AntTreeNodeBaseEvent {
+    node: AntTreeNode;
+    nativeEvent: MouseEvent;
+}
+
+export interface AntTreeNodeCheckedEvent extends AntTreeNodeBaseEvent {
+    event: 'check';
+    checked?: boolean;
+    checkedNodes?: AntTreeNode[];
+}
+
+export interface AntTreeNodeSelectedEvent extends AntTreeNodeBaseEvent {
+    event: 'select';
+    selected?: boolean;
+    selectedNodes?: DataNode[];
+}
+
+export interface AntTreeNodeExpandedEvent extends AntTreeNodeBaseEvent {
+    expanded?: boolean;
+}
+
+export interface AntTreeNodeMouseEvent {
+    node: AntTreeNode;
+    event: any;
+}
+
+export interface AntTreeNodeDragEnterEvent extends AntTreeNodeMouseEvent {
+    expandedKeys: Key[];
+}
+
+export interface AntTreeNodeDropEvent {
+    node: AntTreeNode;
+    dragNode: AntTreeNode;
+    dragNodesKeys: Key[];
+    dropPosition: number;
+    dropToGap?: boolean;
+    event: React.MouseEventHandler<HTMLElement>;
+}
+
+// [Legacy] Compatible for v3
+export type TreeNodeNormal = DataNode;
+
+type DraggableFn = (node: AntTreeNode) => boolean;
+interface DraggableConfig {
+    icon?: React.ReactElement | false;
+    nodeDraggable?: DraggableFn;
+}
+
+export interface TreeProps<T> extends Omit<RcTreeProps<T>, 'prefixCls' | 'showLine' | 'direction' | 'draggable'> {
+    showLine?: boolean | { showLeafIcon: boolean };
+    className?: string;
+
+    /** 是否支持多选 */
+    multiple?: boolean;
+
+    /** 是否自动展开父节点 */
+    autoExpandParent?: boolean;
+
+    /** Checkable状态下节点选择完全受控（父子节点选中状态不再关联） */
+    checkStrictly?: boolean;
+
+    /** 是否支持选中 */
+    checkable?: boolean;
+
+    /** 是否禁用树 */
+    disabled?: boolean;
+
+    /** 默认展开所有树节点 */
+    defaultExpandAll?: boolean;
+
+    /** 默认展开对应树节点 */
+    defaultExpandParent?: boolean;
+
+    /** 默认展开指定的树节点 */
+    defaultExpandedKeys?: Key[];
+
+    /** （受控）展开指定的树节点 */
+    expandedKeys?: Key[];
+
+    /** （受控）选中复选框的树节点 */
+    checkedKeys?: Key[] | { checked: Key[]; halfChecked: Key[] };
+
+    /** 默认选中复选框的树节点 */
+    defaultCheckedKeys?: Key[];
+
+    /** （受控）设置选中的树节点 */
+    selectedKeys?: Key[];
+
+    /** 默认选中的树节点 */
+    defaultSelectedKeys?: Key[];
+    selectable?: boolean;
+
+    /** 点击树节点触发 */
+    filterAntTreeNode?: (node: AntTreeNode) => boolean;
+    loadedKeys?: Key[];
+
+    /** 设置节点可拖拽（IE>8） */
+    draggable?: DraggableFn | boolean | DraggableConfig;
+    style?: React.CSSProperties;
+    showIcon?: boolean;
+    icon?: ((nodeProps: AntdTreeNodeAttribute) => React.ReactElement) | React.ReactElement;
+    switcherIcon?: React.ReactElement<any>;
+    prefixCls?: string;
+    children?: React.ReactElement;
+    blockNode?: boolean;
+}
+
+/** For fieldNames, we provides a abstract interface */
+export interface BasicDataNode {
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    isLeaf?: boolean;
+    selectable?: boolean;
+    switcherIcon?: IconType;
+
+    /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
+    className?: string;
+    style?: React.CSSProperties;
+}
+
+export interface DataNode<T = any> extends BasicDataNode {
+    children?: T[];
+    key?: string | number;
+    title?: string | React.ReactElement;
+}
+
+export interface EventDataNode extends DataNode {
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    loaded: boolean;
+    loading: boolean;
+    halfChecked: boolean;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    pos: string;
+    active: boolean;
+}
+
+export type IconType = React.ReactElement | ((props: TreeNodeProps) => React.ReactElement) | IconName;
+
+export type Key = React.Key;
+
+export type NodeElement = React.ReactElement<TreeNodeProps> & {
+    selectHandle?: HTMLSpanElement;
+    type: {
+        isTreeNode: boolean;
+    };
+};
+
+export type NodeInstance<TreeDataType extends BasicDataNode = DataNode> = Component<TreeNodeProps<TreeDataType>> & {
+    selectHandle?: HTMLSpanElement;
+};
+
+export interface Entity {
+    node: NodeElement;
+    index: number;
+    key: Key;
+    pos: string;
+    parent?: Entity;
+    children?: Entity[];
+}
+
+export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> extends Omit<Entity, 'node' | 'parent' | 'children'> {
+    node: TreeDataType;
+    nodes: TreeDataType[];
+    parent?: DataEntity<TreeDataType>;
+    children?: DataEntity<TreeDataType>[];
+    level: number;
+}
+
+export interface FlattenNode {
+    parent: FlattenNode | null;
+    children: FlattenNode[];
+    pos: string;
+    data: DataNode;
+    title: React.ReactElement;
+    key: Key;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+
+export type GetKey<RecordType> = (record: RecordType, index?: number) => Key;
+
+export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+
+export type Direction = 'ltr' | 'rtl' | undefined;
+
+export interface FieldNames {
+    title?: string;
+
+    /** @private Internal usage for `rc-tree-select`, safe to remove if no need */
+    _title?: string[];
+    key?: string;
+    children?: string;
+}

package/dist/Tree/useUnmount.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Trigger only when component unmount
+ */
+declare function useUnmount(triggerStart: () => void, triggerEnd: () => void): void;
+export default useUnmount;

package/dist/{VirtualList/index.js → Tree/useUnmount.js}

@@ -26,14 +26,29 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/VirtualList/index.ts
-var VirtualList_exports = {};
-__export(VirtualList_exports, {
-  VirtualList: () => import_VirtualList.default
-});
-module.exports = __toCommonJS(VirtualList_exports);
-var import_VirtualList = __toESM(require("./VirtualList"));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  VirtualList
+// src/Tree/useUnmount.ts
+var useUnmount_exports = {};
+__export(useUnmount_exports, {
+  default: () => useUnmount_default
 });
+module.exports = __toCommonJS(useUnmount_exports);
+var import_useLayoutEffect = __toESM(require("rc-util/lib/hooks/useLayoutEffect"));
+var React = __toESM(require("react"));
+function useUnmount(triggerStart, triggerEnd) {
+  const [firstMount, setFirstMount] = React.useState(false);
+  (0, import_useLayoutEffect.default)(() => {
+    if (firstMount) {
+      triggerStart();
+      return () => {
+        triggerEnd();
+      };
+    }
+  }, [firstMount]);
+  (0, import_useLayoutEffect.default)(() => {
+    setFirstMount(true);
+    return () => {
+      setFirstMount(false);
+    };
+  }, []);
+}
+var useUnmount_default = useUnmount;

package/dist/Tree/util.d.ts

@@ -1,23 +1,20 @@
+/**
+ * Legacy code. Should avoid to use if you are new to import these code.
+ */
 import React from 'react';
-import { ComponentChildren } from '../types/common';
-import { AllowDrop, TreeProps } from './RCTree';
-import { BasicDataNode, DataEntity, DataNode, Direction, FlattenNode, Key, NodeElement, NodeInstance } from './typings';
-export interface Option {
-    keepEmpty?: boolean;
-}
-export declare function toArray(children: ComponentChildren, option?: Option): React.ReactElement[];
-export declare function arrDel(list: Key[], value: Key): Key[];
-export declare function arrAdd(list: Key[], value: Key): Key[];
+import type { AllowDrop, TreeProps } from './RCTree';
+import type { BasicDataNode, DataEntity, DataNode, Direction, FlattenNode, Key, KeyEntities, NodeElement, TreeNodeProps } from './typings';
+export { getPosition, isTreeNode } from './utils/treeUtil';
+export declare function arrDel(list: Key[], value: Key): React.Key[];
+export declare function arrAdd(list: Key[], value: Key): React.Key[];
 export declare function posToArr(pos: string): string[];
-export declare function getPosition(level: string | number, index: number): string;
-export declare function isTreeNode(node: NodeElement): boolean;
-export declare function getDragChildrenKeys<TreeDataType extends BasicDataNode = DataNode>(dragNodeKey: Key, keyEntities: Record<Key, DataEntity<TreeDataType>>): Key[];
+export declare function getDragChildrenKeys<TreeDataType extends BasicDataNode = DataNode>(dragNodeKey: Key, keyEntities: KeyEntities<TreeDataType>): Key[];
 export declare function isLastChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
 export declare function isFirstChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
-export declare function calcDropPosition<TreeDataType extends BasicDataNode = DataNode>(event: React.MouseEvent<HTMLElement>, dragNode: NodeInstance<TreeDataType>, targetNode: NodeInstance<TreeDataType>, indent: number, startMousePosition: {
+export declare function calcDropPosition<TreeDataType extends BasicDataNode = DataNode>(event: React.MouseEvent, dragNodeProps: TreeNodeProps<TreeDataType>, targetNodeProps: TreeNodeProps<TreeDataType>, indent: number, startMousePosition: {
     x: number;
     y: number;
-}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode[], keyEntities: Record<Key, DataEntity<TreeDataType>>, expandKeys: Key[], direction: Direction): {
+}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode<TreeDataType>[], keyEntities: KeyEntities<TreeDataType>, expandKeys: Key[], direction: Direction): {
     dropPosition: -1 | 0 | 1;
     dropLevelOffset: number;
     dropTargetKey: Key;
@@ -32,7 +29,7 @@ export declare function calcDropPosition<TreeDataType extends BasicDataNode = Da
  * @param props
  * @returns [string]
  */
-export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): Key[];
+export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): React.Key[];
 export declare function convertDataToTree(treeData: DataNode[], processor?: {
     processProps: (prop: DataNode) => any;
 }): NodeElement[];
@@ -42,14 +39,13 @@ export declare function convertDataToTree(treeData: DataNode[], processor?: {
 export declare function parseCheckedKeys(keys: Key[] | {
     checked: Key[];
     halfChecked: Key[];
-}): any;
+}): {
+    checkedKeys?: Key[];
+    halfCheckedKeys?: Key[];
+};
 /**
  * If user use `autoExpandParent` we should get the list of parent node
  * @param keyList
  * @param keyEntities
  */
-export declare function conductExpandParent(keyList: Key[], keyEntities: Record<Key, DataEntity>): Key[];
-/**
- * omit prop
- */
-export declare function omit<T extends object, K extends keyof T>(obj: T, fields: K[]): Omit<T, K>;
+export declare function conductExpandParent(keyList: Key[], keyEntities: KeyEntities): Key[];