@qsxy/element-plus-react 1.0.1 → 1.0.3

package/dist/Tree/contextTypes.d.ts

@@ -1,69 +0,0 @@
-/**
- * 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<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = {
-    event: React.DragEvent<T>;
-    node: EventDataNode<TreeDataType>;
-};
-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;
-    icon: IconType;
-    switcherIcon: IconType;
-    draggable?: DraggableConfig;
-    draggingNodeKey?: Key;
-    checkable: boolean | React.ReactNode;
-    checkStrictly: boolean;
-    disabled: boolean;
-    keyEntities: KeyEntities;
-    dropLevelOffset?: number;
-    dropContainerKey: Key | null;
-    dropTargetKey: Key | null;
-    dropPosition: -1 | 0 | 1 | null;
-    indent: number | null;
-    dropIndicatorRender: (props: {
-        dropPosition: -1 | 0 | 1;
-        dropLevelOffset: number;
-        indent: number;
-        prefixCls: string;
-        direction: Direction;
-    }) => React.ReactNode;
-    dragOverNodeKey: Key | null;
-    direction: Direction;
-    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>;
-    onNodeDragLeave: NodeDragEventHandler<any, any>;
-    onNodeDragEnd: NodeDragEventHandler<any, any>;
-    onNodeDrop: NodeDragEventHandler<any, any>;
-}
-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,9 +0,0 @@
-/**
- * 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);
-
-/** Internal usage, safe to remove. Do not use in prod */
-export var UnstableContext = /*#__PURE__*/React.createContext({});

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

@@ -1,245 +0,0 @@
-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

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

package/dist/Tree/util.d.ts

@@ -1,51 +0,0 @@
-/**
- * Legacy code. Should avoid to use if you are new to import these code.
- */
-import React from 'react';
-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 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, dragNodeProps: TreeNodeProps<TreeDataType>, targetNodeProps: TreeNodeProps<TreeDataType>, indent: number, startMousePosition: {
-    x: number;
-    y: number;
-}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode<TreeDataType>[], keyEntities: KeyEntities<TreeDataType>, expandKeys: Key[], direction: Direction): {
-    dropPosition: -1 | 0 | 1;
-    dropLevelOffset: number;
-    dropTargetKey: Key;
-    dropTargetPos: string;
-    dropContainerKey: Key;
-    dragOverNodeKey: Key;
-    dropAllowed: boolean;
-};
-/**
- * Return selectedKeys according with multiple prop
- * @param selectedKeys
- * @param props
- * @returns [string]
- */
-export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): React.Key[];
-export declare function convertDataToTree(treeData: DataNode[], processor?: {
-    processProps: (prop: DataNode) => any;
-}): NodeElement[];
-/**
- * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
- */
-export declare function parseCheckedKeys(keys: Key[] | {
-    checked: Key[];
-    halfChecked: Key[];
-}): {
-    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: KeyEntities): Key[];

package/dist/Tree/util.js

@@ -1,303 +0,0 @@
-var _excluded = ["children"];
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-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 _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-/* eslint-disable no-lonely-if */
-/**
- * Legacy code. Should avoid to use if you are new to import these code.
- */
-
-import warning from 'rc-util/lib/warning';
-import React from 'react';
-import TreeNode from "./TreeNode";
-import getEntity from "./utils/keyUtil";
-export { getPosition, isTreeNode } from "./utils/treeUtil";
-export function arrDel(list, value) {
-  if (!list) {
-    return [];
-  }
-  var clone = list.slice();
-  var index = clone.indexOf(value);
-  if (index >= 0) {
-    clone.splice(index, 1);
-  }
-  return clone;
-}
-export function arrAdd(list, value) {
-  var clone = (list || []).slice();
-  if (clone.indexOf(value) === -1) {
-    clone.push(value);
-  }
-  return clone;
-}
-export function posToArr(pos) {
-  return pos.split('-');
-}
-export function getDragChildrenKeys(dragNodeKey, keyEntities) {
-  // not contains self
-  // self for left or right drag
-  var dragChildrenKeys = [];
-  var entity = getEntity(keyEntities, dragNodeKey);
-  function dig() {
-    var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    list.forEach(function (_ref) {
-      var key = _ref.key,
-        children = _ref.children;
-      dragChildrenKeys.push(key);
-      dig(children);
-    });
-  }
-  dig(entity.children);
-  return dragChildrenKeys;
-}
-export function isLastChild(treeNodeEntity) {
-  if (treeNodeEntity.parent) {
-    var posArr = posToArr(treeNodeEntity.pos);
-    return Number(posArr[posArr.length - 1]) === treeNodeEntity.parent.children.length - 1;
-  }
-  return false;
-}
-export function isFirstChild(treeNodeEntity) {
-  var posArr = posToArr(treeNodeEntity.pos);
-  return Number(posArr[posArr.length - 1]) === 0;
-}
-
-// Only used when drag, not affect SSR.
-export function calcDropPosition(event, dragNodeProps, targetNodeProps, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, expandKeys, direction) {
-  var _abstractDropNodeEnti;
-  var clientX = event.clientX,
-    clientY = event.clientY;
-  var _getBoundingClientRec = event.target.getBoundingClientRect(),
-    top = _getBoundingClientRec.top,
-    height = _getBoundingClientRec.height;
-  // optional chain for testing
-  var horizontalMouseOffset = (direction === 'rtl' ? -1 : 1) * (((startMousePosition === null || startMousePosition === void 0 ? void 0 : startMousePosition.x) || 0) - clientX);
-  var rawDropLevelOffset = (horizontalMouseOffset - 12) / indent;
-
-  // Filter the expanded keys to exclude the node that not has children currently (like async nodes).
-  var filteredExpandKeys = expandKeys.filter(function (key) {
-    var _keyEntities$key;
-    return (_keyEntities$key = keyEntities[key]) === null || _keyEntities$key === void 0 || (_keyEntities$key = _keyEntities$key.children) === null || _keyEntities$key === void 0 ? void 0 : _keyEntities$key.length;
-  });
-
-  // find abstract drop node by horizontal offset
-  var abstractDropNodeEntity = getEntity(keyEntities, targetNodeProps.eventKey);
-  if (clientY < top + height / 2) {
-    // first half, set abstract drop node to previous node
-    var nodeIndex = flattenedNodes.findIndex(function (flattenedNode) {
-      return flattenedNode.key === abstractDropNodeEntity.key;
-    });
-    var prevNodeIndex = nodeIndex <= 0 ? 0 : nodeIndex - 1;
-    var prevNodeKey = flattenedNodes[prevNodeIndex].key;
-    abstractDropNodeEntity = getEntity(keyEntities, prevNodeKey);
-  }
-  var initialAbstractDropNodeKey = abstractDropNodeEntity.key;
-  var abstractDragOverEntity = abstractDropNodeEntity;
-  var dragOverNodeKey = abstractDropNodeEntity.key;
-  var dropPosition = 0;
-  var dropLevelOffset = 0;
-
-  // Only allow cross level drop when dragging on a non-expanded node
-  if (!filteredExpandKeys.includes(initialAbstractDropNodeKey)) {
-    for (var i = 0; i < rawDropLevelOffset; i += 1) {
-      if (isLastChild(abstractDropNodeEntity)) {
-        abstractDropNodeEntity = abstractDropNodeEntity.parent;
-        dropLevelOffset += 1;
-      } else {
-        break;
-      }
-    }
-  }
-  var abstractDragDataNode = dragNodeProps.data;
-  var abstractDropDataNode = abstractDropNodeEntity.node;
-  var dropAllowed = true;
-  if (isFirstChild(abstractDropNodeEntity) && abstractDropNodeEntity.level === 0 && clientY < top + height / 2 && allowDrop({
-    dragNode: abstractDragDataNode,
-    dropNode: abstractDropDataNode,
-    dropPosition: -1
-  }) && abstractDropNodeEntity.key === targetNodeProps.eventKey) {
-    // first half of first node in first level
-    dropPosition = -1;
-  } else if ((abstractDragOverEntity.children || []).length && filteredExpandKeys.includes(dragOverNodeKey)) {
-    // drop on expanded node
-    // only allow drop inside
-    if (allowDrop({
-      dragNode: abstractDragDataNode,
-      dropNode: abstractDropDataNode,
-      dropPosition: 0
-    })) {
-      dropPosition = 0;
-    } else {
-      dropAllowed = false;
-    }
-  } else if (dropLevelOffset === 0) {
-    if (rawDropLevelOffset > -1.5) {
-      // | Node     | <- abstractDropNode
-      // | -^-===== | <- mousePosition
-      // 1. try drop after
-      // 2. do not allow drop
-      if (allowDrop({
-        dragNode: abstractDragDataNode,
-        dropNode: abstractDropDataNode,
-        dropPosition: 1
-      })) {
-        dropPosition = 1;
-      } else {
-        dropAllowed = false;
-      }
-    } else {
-      // | Node     | <- abstractDropNode
-      // | ---==^== | <- mousePosition
-      // whether it has children or doesn't has children
-      // always
-      // 1. try drop inside
-      // 2. try drop after
-      // 3. do not allow drop
-      if (allowDrop({
-        dragNode: abstractDragDataNode,
-        dropNode: abstractDropDataNode,
-        dropPosition: 0
-      })) {
-        dropPosition = 0;
-      } else if (allowDrop({
-        dragNode: abstractDragDataNode,
-        dropNode: abstractDropDataNode,
-        dropPosition: 1
-      })) {
-        dropPosition = 1;
-      } else {
-        dropAllowed = false;
-      }
-    }
-  } else {
-    // | Node1 | <- abstractDropNode
-    //      |  Node2  |
-    // --^--|----=====| <- mousePosition
-    // 1. try insert after Node1
-    // 2. do not allow drop
-    if (allowDrop({
-      dragNode: abstractDragDataNode,
-      dropNode: abstractDropDataNode,
-      dropPosition: 1
-    })) {
-      dropPosition = 1;
-    } else {
-      dropAllowed = false;
-    }
-  }
-  return {
-    dropPosition: dropPosition,
-    dropLevelOffset: dropLevelOffset,
-    dropTargetKey: abstractDropNodeEntity.key,
-    dropTargetPos: abstractDropNodeEntity.pos,
-    dragOverNodeKey: dragOverNodeKey,
-    dropContainerKey: dropPosition === 0 ? null : ((_abstractDropNodeEnti = abstractDropNodeEntity.parent) === null || _abstractDropNodeEnti === void 0 ? void 0 : _abstractDropNodeEnti.key) || null,
-    dropAllowed: dropAllowed
-  };
-}
-
-/**
- * Return selectedKeys according with multiple prop
- * @param selectedKeys
- * @param props
- * @returns [string]
- */
-export function calcSelectedKeys(selectedKeys, props) {
-  if (!selectedKeys) {
-    return undefined;
-  }
-  var multiple = props.multiple;
-  if (multiple) {
-    return selectedKeys.slice();
-  }
-  if (selectedKeys.length) {
-    return [selectedKeys[0]];
-  }
-  return selectedKeys;
-}
-var internalProcessProps = function internalProcessProps(props) {
-  return props;
-};
-export function convertDataToTree(treeData, processor) {
-  if (!treeData) {
-    return [];
-  }
-  var _ref2 = processor || {},
-    _ref2$processProps = _ref2.processProps,
-    processProps = _ref2$processProps === void 0 ? internalProcessProps : _ref2$processProps;
-  var list = Array.isArray(treeData) ? treeData : [treeData];
-  return list.map(function (_ref3) {
-    var children = _ref3.children,
-      props = _objectWithoutProperties(_ref3, _excluded);
-    var childrenNodes = convertDataToTree(children, processor);
-    return /*#__PURE__*/React.createElement(TreeNode, _extends({
-      key: props.key
-    }, processProps(props)), childrenNodes);
-  });
-}
-
-/**
- * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
- */
-export function parseCheckedKeys(keys) {
-  if (!keys) {
-    return null;
-  }
-
-  // Convert keys to object format
-  var keyProps;
-  if (Array.isArray(keys)) {
-    // [Legacy] Follow the api doc
-    keyProps = {
-      checkedKeys: keys,
-      halfCheckedKeys: undefined
-    };
-  } else if (_typeof(keys) === 'object') {
-    keyProps = {
-      checkedKeys: keys.checked || undefined,
-      halfCheckedKeys: keys.halfChecked || undefined
-    };
-  } else {
-    warning(false, '`checkedKeys` is not an array or an object');
-    return null;
-  }
-  return keyProps;
-}
-
-/**
- * If user use `autoExpandParent` we should get the list of parent node
- * @param keyList
- * @param keyEntities
- */
-export function conductExpandParent(keyList, keyEntities) {
-  var expandedKeys = new Set();
-  function conductUp(key) {
-    if (expandedKeys.has(key)) {
-      return;
-    }
-    var entity = getEntity(keyEntities, key);
-    if (!entity) {
-      return;
-    }
-    expandedKeys.add(key);
-    var parent = entity.parent,
-      node = entity.node;
-    if (node.disabled) {
-      return;
-    }
-    if (parent) {
-      conductUp(parent.key);
-    }
-  }
-  (keyList || []).forEach(function (key) {
-    conductUp(key);
-  });
-  return _toConsumableArray(expandedKeys);
-}