@qsxy/element-plus-react 1.0.0-next.2 → 1.0.0-next.21

package/dist/Tree/contextTypes.d.ts

@@ -1,17 +1,23 @@
-import React, { Context } from 'react';
-import { DraggableConfig } from './RCTree';
-import { BasicDataNode, DataEntity, DataNode, Direction, EventDataNode, IconType, Key, NodeInstance } from './typings';
-export type NodeMouseEventParams = {
-    event: React.MouseEvent;
-    node: EventDataNode;
+/**
+ * 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 * 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;
@@ -19,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;
@@ -31,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>;
@@ -56,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,30 +1,9 @@
-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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+/**
+ * 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 * as React from 'react';
+export var TreeContext = /*#__PURE__*/React.createContext(null);
 
-// src/Tree/contextTypes.ts
-var contextTypes_exports = {};
-__export(contextTypes_exports, {
-  TreeContext: () => TreeContext
-});
-module.exports = __toCommonJS(contextTypes_exports);
-var import_react = require("react");
-var TreeContext = (0, import_react.createContext)(null);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TreeContext
-});
+/** Internal usage, safe to remove. Do not use in prod */
+export var UnstableContext = /*#__PURE__*/React.createContext({});

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/index.js

@@ -1,48 +1,4 @@
-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)
-    __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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  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/index.ts
-var Tree_exports = {};
-__export(Tree_exports, {
-  DirectoryTree: () => import_DirectoryTree.default,
-  RCTree: () => import_RCTree.default,
-  Tree: () => import_Tree.default,
-  TreeNode: () => import_TreeNode.default
-});
-module.exports = __toCommonJS(Tree_exports);
-var import_DirectoryTree = __toESM(require("./DirectoryTree"));
-var import_RCTree = __toESM(require("./RCTree"));
-var import_Tree = __toESM(require("./Tree"));
-var import_TreeNode = __toESM(require("./TreeNode"));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DirectoryTree,
-  RCTree,
-  Tree,
-  TreeNode
-});
+export { default as DirectoryTree } from "./DirectoryTree";
+export { default as RCTree } from "./RCTree";
+export { default as Tree } from "./Tree";
+export { default as TreeNode } from "./TreeNode";

package/dist/Tree/typings.d.ts

@@ -1,7 +1,39 @@
-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;
     disabled?: boolean;
@@ -10,15 +42,27 @@ export interface BasicDataNode {
     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 {
+/** 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;
@@ -30,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 {
@@ -57,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[];
@@ -72,6 +115,7 @@ 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/typings.js

@@ -1,29 +1 @@
-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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Tree/typings.tsx
-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
-});
+export {};

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/Tree/useUnmount.js

@@ -0,0 +1,34 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import useLayoutEffect from 'rc-util/lib/hooks/useLayoutEffect';
+import * as React from 'react';
+
+/**
+ * Trigger only when component unmount
+ */
+function useUnmount(triggerStart, triggerEnd) {
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    firstMount = _React$useState2[0],
+    setFirstMount = _React$useState2[1];
+  useLayoutEffect(function () {
+    if (firstMount) {
+      triggerStart();
+      return function () {
+        triggerEnd();
+      };
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [firstMount]);
+  useLayoutEffect(function () {
+    setFirstMount(true);
+    return function () {
+      setFirstMount(false);
+    };
+  }, []);
+}
+export default useUnmount;