Latest updates from IceHrmPro

web/node_modules/rc-tree/es/Indent.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface IndentProps {
+    prefixCls: string;
+    level: number;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+declare const Indent: React.FC<IndentProps>;
+export default Indent;

web/node_modules/rc-tree/es/Indent.js

@@ -0,0 +1,34 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import * as React from 'react';
+import classNames from 'classnames';
+
+var Indent = function Indent(_ref) {
+  var prefixCls = _ref.prefixCls,
+      level = _ref.level,
+      isStart = _ref.isStart,
+      isEnd = _ref.isEnd;
+
+  if (!level) {
+    return null;
+  }
+
+  var baseClassName = "".concat(prefixCls, "-indent-unit");
+  var list = [];
+
+  for (var i = 0; i < level; i += 1) {
+    var _classNames;
+
+    list.push(React.createElement("span", {
+      key: i,
+      className: classNames(baseClassName, (_classNames = {}, _defineProperty(_classNames, "".concat(baseClassName, "-start"), isStart[i + 1]), _defineProperty(_classNames, "".concat(baseClassName, "-end"), isEnd[i + 1]), _classNames))
+    }));
+  }
+
+  return React.createElement("span", {
+    "aria-hidden": "true",
+    className: "".concat(prefixCls, "-indent")
+  }, list);
+};
+
+export default Indent;

web/node_modules/rc-tree/es/MotionTreeNode.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { TreeNodeProps } from './TreeNode';
+import { FlattenNode } from './interface';
+import { TreeNodeRequiredProps } from './utils/treeUtil';
+interface MotionTreeNodeProps extends Omit<TreeNodeProps, 'domRef'> {
+    active: boolean;
+    motion?: any;
+    motionNodes?: FlattenNode[];
+    onMotionEnd: () => void;
+    motionType?: 'show' | 'hide';
+    treeNodeRequiredProps: TreeNodeRequiredProps;
+}
+declare const RefMotionTreeNode: React.ForwardRefExoticComponent<MotionTreeNodeProps & React.RefAttributes<any>>;
+export default RefMotionTreeNode;

web/node_modules/rc-tree/es/MotionTreeNode.js

@@ -0,0 +1,92 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+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; }
+
+import * as React from 'react';
+import classNames from 'classnames'; // @ts-ignore
+
+import CSSMotion from "rc-animate/es/CSSMotion";
+import TreeNode from './TreeNode';
+import { getTreeNodeProps } from './utils/treeUtil';
+import { TreeContext } from './contextTypes';
+
+var MotionTreeNode = function MotionTreeNode(_ref, ref) {
+  var className = _ref.className,
+      style = _ref.style,
+      motion = _ref.motion,
+      motionNodes = _ref.motionNodes,
+      motionType = _ref.motionType,
+      onMotionEnd = _ref.onMotionEnd,
+      active = _ref.active,
+      treeNodeRequiredProps = _ref.treeNodeRequiredProps,
+      props = _objectWithoutProperties(_ref, ["className", "style", "motion", "motionNodes", "motionType", "onMotionEnd", "active", "treeNodeRequiredProps"]);
+
+  var _React$useState = React.useState(true),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      visible = _React$useState2[0],
+      setVisible = _React$useState2[1];
+
+  var _React$useContext = React.useContext(TreeContext),
+      prefixCls = _React$useContext.prefixCls;
+
+  React.useEffect(function () {
+    if (motionNodes && motionType === 'hide' && visible) {
+      setVisible(false);
+    }
+  }, [motionNodes]);
+
+  if (motionNodes) {
+    return React.createElement(CSSMotion, Object.assign({
+      ref: ref,
+      visible: visible
+    }, motion, {
+      motionAppear: motionType === 'show',
+      onAppearEnd: onMotionEnd,
+      onLeaveEnd: onMotionEnd
+    }), function (_ref2, motionRef) {
+      var motionClassName = _ref2.className,
+          motionStyle = _ref2.style;
+      return React.createElement("div", {
+        ref: motionRef,
+        className: classNames("".concat(prefixCls, "-treenode-motion"), motionClassName),
+        style: motionStyle
+      }, motionNodes.map(function (treeNode) {
+        var _treeNode$data = treeNode.data,
+            key = _treeNode$data.key,
+            restProps = _objectWithoutProperties(_treeNode$data, ["key"]),
+            isStart = treeNode.isStart,
+            isEnd = treeNode.isEnd;
+
+        delete restProps.children;
+        var treeNodeProps = getTreeNodeProps(key, treeNodeRequiredProps);
+        return React.createElement(TreeNode, Object.assign({}, restProps, treeNodeProps, {
+          active: active,
+          data: treeNode.data,
+          key: key,
+          isStart: isStart,
+          isEnd: isEnd
+        }));
+      }));
+    });
+  }
+
+  return React.createElement(TreeNode, Object.assign({
+    domRef: ref,
+    className: className,
+    style: style
+  }, props, {
+    active: active
+  }));
+};
+
+MotionTreeNode.displayName = 'MotionTreeNode';
+var RefMotionTreeNode = React.forwardRef(MotionTreeNode);
+export default RefMotionTreeNode;

web/node_modules/rc-tree/es/NodeList.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Handle virtual list of the TreeNodes.
+ */
+import * as React from 'react';
+import { FlattenNode, Key, DataEntity, ScrollTo } from './interface';
+export declare const MOTION_KEY: string;
+export declare const MotionEntity: DataEntity;
+export interface NodeListRef {
+    scrollTo: ScrollTo;
+}
+interface NodeListProps {
+    prefixCls: string;
+    style: React.CSSProperties;
+    data: FlattenNode[];
+    motion: any;
+    focusable?: boolean;
+    activeItem: FlattenNode;
+    focused?: boolean;
+    tabIndex: number;
+    checkable?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    checkedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    halfCheckedKeys: Key[];
+    keyEntities: Record<Key, DataEntity>;
+    dragging: boolean;
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    height: number;
+    itemHeight: number;
+    virtual?: boolean;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onFocus?: React.FocusEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    onActiveChange: (key: Key) => void;
+}
+/**
+ * We only need get visible content items to play the animation.
+ */
+export declare function getMinimumRangeTransitionRange(list: FlattenNode[], height: number, itemHeight: number): FlattenNode[];
+declare const NodeList: React.ForwardRefExoticComponent<NodeListProps & React.RefAttributes<NodeListRef>>;
+export default NodeList;

web/node_modules/rc-tree/es/NodeList.js

@@ -0,0 +1,279 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+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; }
+
+/**
+ * Handle virtual list of the TreeNodes.
+ */
+import * as React from 'react';
+import VirtualList from 'rc-virtual-list';
+import MotionTreeNode from './MotionTreeNode';
+import { findExpandedKeys, getExpandRange } from './utils/diffUtil';
+import { getTreeNodeProps, getKey } from './utils/treeUtil';
+var HIDDEN_STYLE = {
+  width: 0,
+  height: 0,
+  display: 'flex',
+  overflow: 'hidden',
+  opacity: 0,
+  border: 0,
+  padding: 0,
+  margin: 0
+};
+
+var noop = function noop() {};
+
+export var MOTION_KEY = "RC_TREE_MOTION_".concat(Math.random());
+var MotionNode = {
+  key: MOTION_KEY
+};
+export var MotionEntity = {
+  key: MOTION_KEY,
+  level: 0,
+  index: 0,
+  pos: '0',
+  node: MotionNode
+};
+var MotionFlattenData = {
+  parent: null,
+  children: [],
+  pos: MotionEntity.pos,
+  data: MotionNode,
+
+  /** Hold empty list here since we do not use it */
+  isStart: [],
+  isEnd: []
+};
+/**
+ * We only need get visible content items to play the animation.
+ */
+
+export function getMinimumRangeTransitionRange(list, height, itemHeight) {
+  if (!height) {
+    return list;
+  }
+
+  return list.slice(0, Math.ceil(height / itemHeight) + 1);
+}
+
+function itemKey(item) {
+  var key = item.data.key,
+      pos = item.pos;
+  return getKey(key, pos);
+}
+
+function getAccessibilityPath(item) {
+  var path = String(item.data.key);
+  var current = item;
+
+  while (current.parent) {
+    current = current.parent;
+    path = "".concat(current.data.key, " > ").concat(path);
+  }
+
+  return path;
+}
+
+var RefNodeList = function RefNodeList(props, ref) {
+  var prefixCls = props.prefixCls,
+      data = props.data,
+      selectable = props.selectable,
+      checkable = props.checkable,
+      expandedKeys = props.expandedKeys,
+      selectedKeys = props.selectedKeys,
+      checkedKeys = props.checkedKeys,
+      loadedKeys = props.loadedKeys,
+      loadingKeys = props.loadingKeys,
+      halfCheckedKeys = props.halfCheckedKeys,
+      keyEntities = props.keyEntities,
+      disabled = props.disabled,
+      dragging = props.dragging,
+      dragOverNodeKey = props.dragOverNodeKey,
+      dropPosition = props.dropPosition,
+      motion = props.motion,
+      height = props.height,
+      itemHeight = props.itemHeight,
+      virtual = props.virtual,
+      focusable = props.focusable,
+      activeItem = props.activeItem,
+      focused = props.focused,
+      tabIndex = props.tabIndex,
+      onKeyDown = props.onKeyDown,
+      onFocus = props.onFocus,
+      onBlur = props.onBlur,
+      onActiveChange = props.onActiveChange,
+      domProps = _objectWithoutProperties(props, ["prefixCls", "data", "selectable", "checkable", "expandedKeys", "selectedKeys", "checkedKeys", "loadedKeys", "loadingKeys", "halfCheckedKeys", "keyEntities", "disabled", "dragging", "dragOverNodeKey", "dropPosition", "motion", "height", "itemHeight", "virtual", "focusable", "activeItem", "focused", "tabIndex", "onKeyDown", "onFocus", "onBlur", "onActiveChange"]); // =============================== Ref ================================
+
+
+  var listRef = React.useRef(null);
+  React.useImperativeHandle(ref, function () {
+    return {
+      scrollTo: function scrollTo(scroll) {
+        listRef.current.scrollTo(scroll);
+      }
+    };
+  }); // ============================== Motion ==============================
+
+  var _React$useState = React.useState(false),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      disableVirtual = _React$useState2[0],
+      setDisableVirtual = _React$useState2[1];
+
+  var _React$useState3 = React.useState(expandedKeys),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      prevExpandedKeys = _React$useState4[0],
+      setPrevExpandedKeys = _React$useState4[1];
+
+  var _React$useState5 = React.useState(data),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      prevData = _React$useState6[0],
+      setPrevData = _React$useState6[1];
+
+  var _React$useState7 = React.useState(data),
+      _React$useState8 = _slicedToArray(_React$useState7, 2),
+      transitionData = _React$useState8[0],
+      setTransitionData = _React$useState8[1];
+
+  var _React$useState9 = React.useState([]),
+      _React$useState10 = _slicedToArray(_React$useState9, 2),
+      transitionRange = _React$useState10[0],
+      setTransitionRange = _React$useState10[1];
+
+  var _React$useState11 = React.useState(null),
+      _React$useState12 = _slicedToArray(_React$useState11, 2),
+      motionType = _React$useState12[0],
+      setMotionType = _React$useState12[1];
+
+  function onMotionEnd() {
+    setPrevData(data);
+    setTransitionData(data);
+    setTransitionRange([]);
+    setMotionType(null);
+    setDisableVirtual(false);
+  } // Do animation if expanded keys changed
+
+
+  React.useEffect(function () {
+    setPrevExpandedKeys(expandedKeys);
+    var diffExpanded = findExpandedKeys(prevExpandedKeys, expandedKeys);
+
+    if (diffExpanded.key !== null) {
+      if (diffExpanded.add) {
+        var keyIndex = prevData.findIndex(function (_ref) {
+          var key = _ref.data.key;
+          return key === diffExpanded.key;
+        });
+        if (motion) setDisableVirtual(true);
+        var rangeNodes = getMinimumRangeTransitionRange(getExpandRange(prevData, data, diffExpanded.key), height, itemHeight);
+        var newTransitionData = prevData.slice();
+        newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData);
+        setTransitionData(newTransitionData);
+        setTransitionRange(rangeNodes);
+        setMotionType('show');
+      } else {
+        var _keyIndex = data.findIndex(function (_ref2) {
+          var key = _ref2.data.key;
+          return key === diffExpanded.key;
+        });
+
+        if (motion) setDisableVirtual(true);
+
+        var _rangeNodes = getMinimumRangeTransitionRange(getExpandRange(data, prevData, diffExpanded.key), height, itemHeight);
+
+        var _newTransitionData = data.slice();
+
+        _newTransitionData.splice(_keyIndex + 1, 0, MotionFlattenData);
+
+        setTransitionData(_newTransitionData);
+        setTransitionRange(_rangeNodes);
+        setMotionType('hide');
+      }
+    } else if (prevData !== data) {
+      // If whole data changed, we just refresh the list
+      setPrevData(data);
+      setTransitionData(data);
+    }
+  }, [expandedKeys, data]); // We should clean up motion if is changed by dragging
+
+  React.useEffect(function () {
+    if (!dragging) {
+      onMotionEnd();
+    }
+  }, [dragging]);
+  var mergedData = motion ? transitionData : data;
+  var treeNodeRequiredProps = {
+    expandedKeys: expandedKeys,
+    selectedKeys: selectedKeys,
+    loadedKeys: loadedKeys,
+    loadingKeys: loadingKeys,
+    checkedKeys: checkedKeys,
+    halfCheckedKeys: halfCheckedKeys,
+    dragOverNodeKey: dragOverNodeKey,
+    dropPosition: dropPosition,
+    keyEntities: keyEntities
+  };
+  return React.createElement(React.Fragment, null, focused && activeItem && React.createElement("span", {
+    style: HIDDEN_STYLE,
+    "aria-live": "assertive"
+  }, getAccessibilityPath(activeItem)), React.createElement("div", {
+    role: "tree"
+  }, React.createElement("input", {
+    style: HIDDEN_STYLE,
+    disabled: focusable === false || disabled,
+    tabIndex: focusable !== false ? tabIndex : null,
+    onKeyDown: onKeyDown,
+    onFocus: onFocus,
+    onBlur: onBlur,
+    value: "",
+    onChange: noop
+  })), React.createElement(VirtualList, Object.assign({}, domProps, {
+    disabled: disableVirtual,
+    data: mergedData,
+    itemKey: itemKey,
+    height: height,
+    fullHeight: false,
+    virtual: virtual,
+    itemHeight: itemHeight,
+    onSkipRender: onMotionEnd,
+    prefixCls: "".concat(prefixCls, "-list"),
+    ref: listRef
+  }), function (treeNode) {
+    var pos = treeNode.pos,
+        _treeNode$data = treeNode.data,
+        key = _treeNode$data.key,
+        restProps = _objectWithoutProperties(_treeNode$data, ["key"]),
+        isStart = treeNode.isStart,
+        isEnd = treeNode.isEnd;
+
+    var mergedKey = getKey(key, pos);
+    delete restProps.children;
+    var treeNodeProps = getTreeNodeProps(mergedKey, treeNodeRequiredProps);
+    return React.createElement(MotionTreeNode, Object.assign({}, restProps, treeNodeProps, {
+      active: activeItem && key === activeItem.data.key,
+      pos: pos,
+      data: treeNode.data,
+      isStart: isStart,
+      isEnd: isEnd,
+      motion: motion,
+      motionNodes: key === MOTION_KEY ? transitionRange : null,
+      motionType: motionType,
+      onMotionEnd: onMotionEnd,
+      treeNodeRequiredProps: treeNodeRequiredProps,
+      onMouseMove: function onMouseMove() {
+        onActiveChange(null);
+      }
+    }));
+  }));
+};
+
+var NodeList = React.forwardRef(RefNodeList);
+NodeList.displayName = 'NodeList';
+export default NodeList;

web/node_modules/rc-tree/es/Tree.d.ts

@@ -0,0 +1,261 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { DataNode, IconType, Key, FlattenNode, DataEntity, EventDataNode, NodeInstance, ScrollTo } from './interface';
+import { NodeListRef } from './NodeList';
+interface CheckInfo {
+    event: 'check';
+    node: EventDataNode;
+    checked: boolean;
+    nativeEvent: MouseEvent;
+    checkedNodes: DataNode[];
+    checkedNodesPositions?: {
+        node: DataNode;
+        pos: string;
+    }[];
+    halfCheckedKeys?: Key[];
+}
+export interface TreeProps {
+    prefixCls: string;
+    className?: string;
+    style?: React.CSSProperties;
+    focusable?: boolean;
+    tabIndex?: number;
+    children?: React.ReactNode;
+    treeData?: DataNode[];
+    showLine?: boolean;
+    showIcon?: boolean;
+    icon?: IconType;
+    selectable?: boolean;
+    disabled?: boolean;
+    multiple?: boolean;
+    checkable?: boolean | React.ReactNode;
+    checkStrictly?: boolean;
+    draggable?: boolean;
+    defaultExpandParent?: boolean;
+    autoExpandParent?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: Key[];
+    expandedKeys?: Key[];
+    defaultCheckedKeys?: Key[];
+    checkedKeys?: Key[] | {
+        checked: Key[];
+        halfChecked: Key[];
+    };
+    defaultSelectedKeys?: Key[];
+    selectedKeys?: Key[];
+    onFocus?: React.FocusEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onClick?: (e: React.MouseEvent, treeNode: EventDataNode) => void;
+    onDoubleClick?: (e: React.MouseEvent, treeNode: EventDataNode) => void;
+    onExpand?: (expandedKeys: Key[], info: {
+        node: EventDataNode;
+        expanded: boolean;
+        nativeEvent: MouseEvent;
+    }) => void;
+    onCheck?: (checked: {
+        checked: Key[];
+        halfChecked: Key[];
+    } | Key[], info: CheckInfo) => void;
+    onSelect?: (selectedKeys: Key[], info: {
+        event: 'select';
+        selected: boolean;
+        node: EventDataNode;
+        selectedNodes: DataNode[];
+        nativeEvent: MouseEvent;
+    }) => void;
+    onLoad?: (loadedKeys: Key[], info: {
+        event: 'load';
+        node: EventDataNode;
+    }) => void;
+    loadData?: (treeNode: EventDataNode) => Promise<void>;
+    loadedKeys?: Key[];
+    onMouseEnter?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onMouseLeave?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onRightClick?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onDragStart?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onDragEnter?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+        expandedKeys: Key[];
+    }) => void;
+    onDragOver?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onDragLeave?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onDragEnd?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+    }) => void;
+    onDrop?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode;
+        dragNode: EventDataNode;
+        dragNodesKeys: Key[];
+        dropPosition: number;
+        dropToGap: boolean;
+    }) => void;
+    /**
+     * Used for `rc-tree-select` only.
+     * Do not use in your production code directly since this will be refactor.
+     */
+    onActiveChange?: (key: Key) => void;
+    filterTreeNode?: (treeNode: EventDataNode) => boolean;
+    motion?: any;
+    switcherIcon?: IconType;
+    height?: number;
+    itemHeight?: number;
+    virtual?: boolean;
+}
+interface TreeState {
+    keyEntities: Record<Key, DataEntity>;
+    selectedKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    expandedKeys: Key[];
+    dragging: boolean;
+    dragNodesKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    treeData: DataNode[];
+    flattenNodes: FlattenNode[];
+    focused: boolean;
+    activeKey: Key;
+    prevProps: TreeProps;
+}
+declare class Tree extends React.Component<TreeProps, TreeState> {
+    static propTypes: {
+        prefixCls: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        tabIndex: PropTypes.Requireable<string | number>;
+        children: PropTypes.Requireable<any>;
+        treeData: PropTypes.Requireable<any[]>;
+        showLine: PropTypes.Requireable<boolean>;
+        showIcon: PropTypes.Requireable<boolean>;
+        icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        selectable: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        multiple: PropTypes.Requireable<boolean>;
+        checkable: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        checkStrictly: PropTypes.Requireable<boolean>;
+        draggable: PropTypes.Requireable<boolean>;
+        defaultExpandParent: PropTypes.Requireable<boolean>;
+        autoExpandParent: PropTypes.Requireable<boolean>;
+        defaultExpandAll: PropTypes.Requireable<boolean>;
+        defaultExpandedKeys: PropTypes.Requireable<(string | number)[]>;
+        expandedKeys: PropTypes.Requireable<(string | number)[]>;
+        defaultCheckedKeys: PropTypes.Requireable<(string | number)[]>;
+        checkedKeys: PropTypes.Requireable<object>;
+        defaultSelectedKeys: PropTypes.Requireable<(string | number)[]>;
+        selectedKeys: PropTypes.Requireable<(string | number)[]>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onDoubleClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onExpand: PropTypes.Requireable<(...args: any[]) => any>;
+        onCheck: PropTypes.Requireable<(...args: any[]) => any>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        onLoad: PropTypes.Requireable<(...args: any[]) => any>;
+        loadData: PropTypes.Requireable<(...args: any[]) => any>;
+        loadedKeys: PropTypes.Requireable<(string | number)[]>;
+        onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        onRightClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragOver: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragEnd: PropTypes.Requireable<(...args: any[]) => any>;
+        onDrop: PropTypes.Requireable<(...args: any[]) => any>;
+        filterTreeNode: PropTypes.Requireable<(...args: any[]) => any>;
+        motion: PropTypes.Requireable<object>;
+        switcherIcon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    static defaultProps: {
+        prefixCls: string;
+        showLine: boolean;
+        showIcon: boolean;
+        selectable: boolean;
+        multiple: boolean;
+        checkable: boolean;
+        disabled: boolean;
+        checkStrictly: boolean;
+        draggable: boolean;
+        defaultExpandParent: boolean;
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        defaultExpandedKeys: any[];
+        defaultCheckedKeys: any[];
+        defaultSelectedKeys: any[];
+    };
+    static TreeNode: React.FC<import("./TreeNode").TreeNodeProps>;
+    delayedDragEnterLogic: Record<Key, number>;
+    state: TreeState;
+    dragNode: NodeInstance;
+    listRef: React.RefObject<NodeListRef>;
+    static getDerivedStateFromProps(props: TreeProps, prevState: TreeState): Partial<TreeState>;
+    onNodeDragStart: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: NodeInstance) => void;
+    /**
+     * [Legacy] Select handler is less small than node,
+     * so that this will trigger when drag enter node or select handler.
+     * This is a little tricky if customize css without padding.
+     * Better for use mouse move event to refresh drag state.
+     * But let's just keep it to avoid event trigger logic change.
+     */
+    onNodeDragEnter: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: NodeInstance) => void;
+    onNodeDragOver: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: NodeInstance) => void;
+    onNodeDragLeave: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: NodeInstance) => void;
+    onNodeDragEnd: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: NodeInstance) => void;
+    onNodeDrop: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: NodeInstance) => void;
+    cleanDragState: () => void;
+    onNodeClick: (e: React.MouseEvent<HTMLDivElement, MouseEvent>, treeNode: EventDataNode) => void;
+    onNodeDoubleClick: (e: React.MouseEvent<HTMLDivElement, MouseEvent>, treeNode: EventDataNode) => void;
+    onNodeSelect: (e: React.MouseEvent<HTMLDivElement, MouseEvent>, treeNode: EventDataNode) => void;
+    onNodeCheck: (e: React.MouseEvent<HTMLDivElement, MouseEvent>, treeNode: EventDataNode, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode) => Promise<unknown>;
+    onNodeExpand: (e: React.MouseEvent<HTMLDivElement, MouseEvent>, treeNode: EventDataNode) => Promise<void>;
+    onNodeMouseEnter: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: EventDataNode) => void;
+    onNodeMouseLeave: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: EventDataNode) => void;
+    onNodeContextMenu: (event: React.MouseEvent<HTMLDivElement, MouseEvent>, node: EventDataNode) => void;
+    onFocus: React.FocusEventHandler<HTMLDivElement>;
+    onBlur: React.FocusEventHandler<HTMLDivElement>;
+    getTreeNodeRequiredProps: () => {
+        expandedKeys: (string | number)[];
+        selectedKeys: (string | number)[];
+        loadedKeys: (string | number)[];
+        loadingKeys: (string | number)[];
+        checkedKeys: (string | number)[];
+        halfCheckedKeys: (string | number)[];
+        dragOverNodeKey: string | number;
+        dropPosition: number;
+        keyEntities: Record<string | number, DataEntity>;
+    };
+    onActiveChange: (newActiveKey: string | number) => void;
+    getActiveItem: () => FlattenNode;
+    offsetActiveKey: (offset: number) => void;
+    onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    /**
+     * Only update the value which is not in props
+     */
+    setUncontrolledState: (state: Partial<TreeState>, atomic?: boolean, forceState?: Partial<TreeState>) => void;
+    scrollTo: ScrollTo;
+    render(): JSX.Element;
+}
+export default Tree;

web/node_modules/rc-tree/es/TreeNode.d.ts

@@ -0,0 +1,105 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { TreeContextProps } from './contextTypes';
+import { IconType, Key, DataNode } from './interface';
+export interface TreeNodeProps {
+    eventKey?: Key;
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    halfChecked?: boolean;
+    title?: React.ReactNode | ((data: DataNode) => React.ReactNode);
+    dragOver?: boolean;
+    dragOverGapTop?: boolean;
+    dragOverGapBottom?: boolean;
+    pos?: string;
+    domRef?: React.Ref<HTMLDivElement>;
+    /** New added in Tree for easy data access */
+    data?: DataNode;
+    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;
+}
+export interface InternalTreeNodeProps extends TreeNodeProps {
+    context?: TreeContextProps;
+}
+export interface TreeNodeState {
+    dragNodeHighlight: boolean;
+}
+declare class InternalTreeNode extends React.Component<InternalTreeNodeProps, TreeNodeState> {
+    static propTypes: {
+        prefixCls: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        eventKey: PropTypes.Requireable<string | number>;
+        expanded: PropTypes.Requireable<boolean>;
+        selected: PropTypes.Requireable<boolean>;
+        checked: PropTypes.Requireable<boolean>;
+        loaded: PropTypes.Requireable<boolean>;
+        loading: PropTypes.Requireable<boolean>;
+        halfChecked: PropTypes.Requireable<boolean>;
+        title: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        dragOver: PropTypes.Requireable<boolean>;
+        dragOverGapTop: PropTypes.Requireable<boolean>;
+        dragOverGapBottom: PropTypes.Requireable<boolean>;
+        pos: PropTypes.Requireable<string>;
+        isLeaf: PropTypes.Requireable<boolean>;
+        checkable: PropTypes.Requireable<boolean>;
+        selectable: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        disableCheckbox: PropTypes.Requireable<boolean>;
+        icon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        switcherIcon: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    state: {
+        dragNodeHighlight: boolean;
+    };
+    selectHandle: HTMLSpanElement;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    onSelectorClick: (e: any) => void;
+    onSelectorDoubleClick: (e: any) => void;
+    onSelect: (e: any) => void;
+    onCheck: (e: any) => void;
+    onMouseEnter: (e: any) => void;
+    onMouseLeave: (e: any) => void;
+    onContextMenu: (e: any) => void;
+    onDragStart: (e: any) => void;
+    onDragEnter: (e: any) => void;
+    onDragOver: (e: any) => void;
+    onDragLeave: (e: any) => void;
+    onDragEnd: (e: any) => void;
+    onDrop: (e: any) => void;
+    onExpand: React.MouseEventHandler<HTMLDivElement>;
+    setSelectHandle: (node: any) => void;
+    getNodeState: () => "open" | "close";
+    hasChildren: () => boolean;
+    isLeaf: () => boolean;
+    isDisabled: () => boolean;
+    isCheckable: () => {};
+    syncLoadData: (props: any) => void;
+    isSelectable(): boolean;
+    renderSwitcher: () => JSX.Element;
+    renderCheckbox: () => JSX.Element;
+    renderIcon: () => JSX.Element;
+    renderSelector: () => JSX.Element;
+    render(): JSX.Element;
+}
+declare const ContextTreeNode: React.FC<TreeNodeProps>;
+export { InternalTreeNode };
+export default ContextTreeNode;

web/node_modules/rc-tree/es/TreeNode.js

@@ -0,0 +1,479 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+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; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames'; // @ts-ignore
+
+import { polyfill } from 'react-lifecycles-compat';
+import { TreeContext } from './contextTypes';
+import { getDataAndAria } from './util';
+import Indent from './Indent';
+import { convertNodePropsToEventData } from './utils/treeUtil';
+var ICON_OPEN = 'open';
+var ICON_CLOSE = 'close';
+var defaultTitle = '---';
+
+var InternalTreeNode = /*#__PURE__*/function (_React$Component) {
+  _inherits(InternalTreeNode, _React$Component);
+
+  function InternalTreeNode() {
+    var _this;
+
+    _classCallCheck(this, InternalTreeNode);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(InternalTreeNode).apply(this, arguments));
+    _this.state = {
+      dragNodeHighlight: false
+    };
+
+    _this.onSelectorClick = function (e) {
+      // Click trigger before select/check operation
+      var onNodeClick = _this.props.context.onNodeClick;
+      onNodeClick(e, convertNodePropsToEventData(_this.props));
+
+      if (_this.isSelectable()) {
+        _this.onSelect(e);
+      } else {
+        _this.onCheck(e);
+      }
+    };
+
+    _this.onSelectorDoubleClick = function (e) {
+      var onNodeDoubleClick = _this.props.context.onNodeDoubleClick;
+      onNodeDoubleClick(e, convertNodePropsToEventData(_this.props));
+    };
+
+    _this.onSelect = function (e) {
+      if (_this.isDisabled()) return;
+      var onNodeSelect = _this.props.context.onNodeSelect;
+      e.preventDefault();
+      onNodeSelect(e, convertNodePropsToEventData(_this.props));
+    };
+
+    _this.onCheck = function (e) {
+      if (_this.isDisabled()) return;
+      var _this$props = _this.props,
+          disableCheckbox = _this$props.disableCheckbox,
+          checked = _this$props.checked;
+      var onNodeCheck = _this.props.context.onNodeCheck;
+      if (!_this.isCheckable() || disableCheckbox) return;
+      e.preventDefault();
+      var targetChecked = !checked;
+      onNodeCheck(e, convertNodePropsToEventData(_this.props), targetChecked);
+    };
+
+    _this.onMouseEnter = function (e) {
+      var onNodeMouseEnter = _this.props.context.onNodeMouseEnter;
+      onNodeMouseEnter(e, convertNodePropsToEventData(_this.props));
+    };
+
+    _this.onMouseLeave = function (e) {
+      var onNodeMouseLeave = _this.props.context.onNodeMouseLeave;
+      onNodeMouseLeave(e, convertNodePropsToEventData(_this.props));
+    };
+
+    _this.onContextMenu = function (e) {
+      var onNodeContextMenu = _this.props.context.onNodeContextMenu;
+      onNodeContextMenu(e, convertNodePropsToEventData(_this.props));
+    };
+
+    _this.onDragStart = function (e) {
+      var onNodeDragStart = _this.props.context.onNodeDragStart;
+      e.stopPropagation();
+
+      _this.setState({
+        dragNodeHighlight: true
+      });
+
+      onNodeDragStart(e, _assertThisInitialized(_this));
+
+      try {
+        // ie throw error
+        // firefox-need-it
+        e.dataTransfer.setData('text/plain', '');
+      } catch (error) {// empty
+      }
+    };
+
+    _this.onDragEnter = function (e) {
+      var onNodeDragEnter = _this.props.context.onNodeDragEnter;
+      e.preventDefault();
+      e.stopPropagation();
+      onNodeDragEnter(e, _assertThisInitialized(_this));
+    };
+
+    _this.onDragOver = function (e) {
+      var onNodeDragOver = _this.props.context.onNodeDragOver;
+      e.preventDefault();
+      e.stopPropagation();
+      onNodeDragOver(e, _assertThisInitialized(_this));
+    };
+
+    _this.onDragLeave = function (e) {
+      var onNodeDragLeave = _this.props.context.onNodeDragLeave;
+      e.stopPropagation();
+      onNodeDragLeave(e, _assertThisInitialized(_this));
+    };
+
+    _this.onDragEnd = function (e) {
+      var onNodeDragEnd = _this.props.context.onNodeDragEnd;
+      e.stopPropagation();
+
+      _this.setState({
+        dragNodeHighlight: false
+      });
+
+      onNodeDragEnd(e, _assertThisInitialized(_this));
+    };
+
+    _this.onDrop = function (e) {
+      var onNodeDrop = _this.props.context.onNodeDrop;
+      e.preventDefault();
+      e.stopPropagation();
+
+      _this.setState({
+        dragNodeHighlight: false
+      });
+
+      onNodeDrop(e, _assertThisInitialized(_this));
+    }; // Disabled item still can be switch
+
+
+    _this.onExpand = function (e) {
+      var onNodeExpand = _this.props.context.onNodeExpand;
+      onNodeExpand(e, convertNodePropsToEventData(_this.props));
+    }; // Drag usage
+
+
+    _this.setSelectHandle = function (node) {
+      _this.selectHandle = node;
+    };
+
+    _this.getNodeState = function () {
+      var expanded = _this.props.expanded;
+
+      if (_this.isLeaf()) {
+        return null;
+      }
+
+      return expanded ? ICON_OPEN : ICON_CLOSE;
+    };
+
+    _this.hasChildren = function () {
+      var eventKey = _this.props.eventKey;
+      var keyEntities = _this.props.context.keyEntities;
+
+      var _ref = keyEntities[eventKey] || {},
+          children = _ref.children;
+
+      return !!(children || []).length;
+    };
+
+    _this.isLeaf = function () {
+      var _this$props2 = _this.props,
+          isLeaf = _this$props2.isLeaf,
+          loaded = _this$props2.loaded;
+      var loadData = _this.props.context.loadData;
+
+      var hasChildren = _this.hasChildren();
+
+      if (isLeaf === false) {
+        return false;
+      }
+
+      return isLeaf || !loadData && !hasChildren || loadData && loaded && !hasChildren;
+    };
+
+    _this.isDisabled = function () {
+      var disabled = _this.props.disabled;
+      var treeDisabled = _this.props.context.disabled;
+      return !!(treeDisabled || disabled);
+    };
+
+    _this.isCheckable = function () {
+      var checkable = _this.props.checkable;
+      var treeCheckable = _this.props.context.checkable; // Return false if tree or treeNode is not checkable
+
+      if (!treeCheckable || checkable === false) return false;
+      return treeCheckable;
+    }; // Load data to avoid default expanded tree without data
+
+
+    _this.syncLoadData = function (props) {
+      var expanded = props.expanded,
+          loading = props.loading,
+          loaded = props.loaded;
+      var _this$props$context = _this.props.context,
+          loadData = _this$props$context.loadData,
+          onNodeLoad = _this$props$context.onNodeLoad;
+      if (loading) return; // read from state to avoid loadData at same time
+
+      if (loadData && expanded && !_this.isLeaf()) {
+        // We needn't reload data when has children in sync logic
+        // It's only needed in node expanded
+        if (!_this.hasChildren() && !loaded) {
+          onNodeLoad(convertNodePropsToEventData(_this.props));
+        }
+      }
+    }; // Switcher
+
+
+    _this.renderSwitcher = function () {
+      var _this$props3 = _this.props,
+          expanded = _this$props3.expanded,
+          switcherIconFromProps = _this$props3.switcherIcon;
+      var _this$props$context2 = _this.props.context,
+          prefixCls = _this$props$context2.prefixCls,
+          switcherIconFromCtx = _this$props$context2.switcherIcon;
+      var switcherIcon = switcherIconFromProps || switcherIconFromCtx;
+
+      if (_this.isLeaf()) {
+        return React.createElement("span", {
+          className: classNames("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher-noop"))
+        }, typeof switcherIcon === 'function' ? switcherIcon(_objectSpread({}, _this.props, {
+          isLeaf: true
+        })) : switcherIcon);
+      }
+
+      var switcherCls = classNames("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher_").concat(expanded ? ICON_OPEN : ICON_CLOSE));
+      return React.createElement("span", {
+        onClick: _this.onExpand,
+        className: switcherCls
+      }, typeof switcherIcon === 'function' ? switcherIcon(_objectSpread({}, _this.props, {
+        isLeaf: false
+      })) : switcherIcon);
+    }; // Checkbox
+
+
+    _this.renderCheckbox = function () {
+      var _this$props4 = _this.props,
+          checked = _this$props4.checked,
+          halfChecked = _this$props4.halfChecked,
+          disableCheckbox = _this$props4.disableCheckbox;
+      var prefixCls = _this.props.context.prefixCls;
+
+      var disabled = _this.isDisabled();
+
+      var checkable = _this.isCheckable();
+
+      if (!checkable) return null; // [Legacy] Custom element should be separate with `checkable` in future
+
+      var $custom = typeof checkable !== 'boolean' ? checkable : null;
+      return React.createElement("span", {
+        className: classNames("".concat(prefixCls, "-checkbox"), checked && "".concat(prefixCls, "-checkbox-checked"), !checked && halfChecked && "".concat(prefixCls, "-checkbox-indeterminate"), (disabled || disableCheckbox) && "".concat(prefixCls, "-checkbox-disabled")),
+        onClick: _this.onCheck
+      }, $custom);
+    };
+
+    _this.renderIcon = function () {
+      var loading = _this.props.loading;
+      var prefixCls = _this.props.context.prefixCls;
+      return React.createElement("span", {
+        className: classNames("".concat(prefixCls, "-iconEle"), "".concat(prefixCls, "-icon__").concat(_this.getNodeState() || 'docu'), loading && "".concat(prefixCls, "-icon_loading"))
+      });
+    }; // Icon + Title
+
+
+    _this.renderSelector = function () {
+      var dragNodeHighlight = _this.state.dragNodeHighlight;
+      var _this$props5 = _this.props,
+          title = _this$props5.title,
+          selected = _this$props5.selected,
+          icon = _this$props5.icon,
+          loading = _this$props5.loading,
+          data = _this$props5.data;
+      var _this$props$context3 = _this.props.context,
+          prefixCls = _this$props$context3.prefixCls,
+          showIcon = _this$props$context3.showIcon,
+          treeIcon = _this$props$context3.icon,
+          draggable = _this$props$context3.draggable,
+          loadData = _this$props$context3.loadData;
+
+      var disabled = _this.isDisabled();
+
+      var wrapClass = "".concat(prefixCls, "-node-content-wrapper"); // Icon - Still show loading icon when loading without showIcon
+
+      var $icon;
+
+      if (showIcon) {
+        var currentIcon = icon || treeIcon;
+        $icon = currentIcon ? React.createElement("span", {
+          className: classNames("".concat(prefixCls, "-iconEle"), "".concat(prefixCls, "-icon__customize"))
+        }, typeof currentIcon === 'function' ? currentIcon(_this.props) : currentIcon) : _this.renderIcon();
+      } else if (loadData && loading) {
+        $icon = _this.renderIcon();
+      } // Title
+
+
+      var $title = React.createElement("span", {
+        className: "".concat(prefixCls, "-title")
+      }, typeof title === 'function' ? title(data) : title);
+      return React.createElement("span", {
+        ref: _this.setSelectHandle,
+        title: typeof title === 'string' ? title : '',
+        className: classNames("".concat(wrapClass), "".concat(wrapClass, "-").concat(_this.getNodeState() || 'normal'), !disabled && (selected || dragNodeHighlight) && "".concat(prefixCls, "-node-selected"), !disabled && draggable && 'draggable'),
+        draggable: !disabled && draggable || undefined,
+        "aria-grabbed": !disabled && draggable || undefined,
+        onMouseEnter: _this.onMouseEnter,
+        onMouseLeave: _this.onMouseLeave,
+        onContextMenu: _this.onContextMenu,
+        onClick: _this.onSelectorClick,
+        onDoubleClick: _this.onSelectorDoubleClick,
+        onDragStart: draggable ? _this.onDragStart : undefined
+      }, $icon, $title);
+    };
+
+    return _this;
+  } // Isomorphic needn't load data in server side
+
+
+  _createClass(InternalTreeNode, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.syncLoadData(this.props);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this.syncLoadData(this.props);
+    }
+  }, {
+    key: "isSelectable",
+    value: function isSelectable() {
+      var selectable = this.props.selectable;
+      var treeSelectable = this.props.context.selectable; // Ignore when selectable is undefined or null
+
+      if (typeof selectable === 'boolean') {
+        return selectable;
+      }
+
+      return treeSelectable;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames;
+
+      var _this$props6 = this.props,
+          eventKey = _this$props6.eventKey,
+          className = _this$props6.className,
+          style = _this$props6.style,
+          dragOver = _this$props6.dragOver,
+          dragOverGapTop = _this$props6.dragOverGapTop,
+          dragOverGapBottom = _this$props6.dragOverGapBottom,
+          isLeaf = _this$props6.isLeaf,
+          isStart = _this$props6.isStart,
+          isEnd = _this$props6.isEnd,
+          expanded = _this$props6.expanded,
+          selected = _this$props6.selected,
+          checked = _this$props6.checked,
+          halfChecked = _this$props6.halfChecked,
+          loading = _this$props6.loading,
+          domRef = _this$props6.domRef,
+          active = _this$props6.active,
+          onMouseMove = _this$props6.onMouseMove,
+          otherProps = _objectWithoutProperties(_this$props6, ["eventKey", "className", "style", "dragOver", "dragOverGapTop", "dragOverGapBottom", "isLeaf", "isStart", "isEnd", "expanded", "selected", "checked", "halfChecked", "loading", "domRef", "active", "onMouseMove"]);
+
+      var _this$props$context4 = this.props.context,
+          prefixCls = _this$props$context4.prefixCls,
+          filterTreeNode = _this$props$context4.filterTreeNode,
+          draggable = _this$props$context4.draggable,
+          keyEntities = _this$props$context4.keyEntities;
+      var disabled = this.isDisabled();
+      var dataOrAriaAttributeProps = getDataAndAria(otherProps);
+
+      var _ref2 = keyEntities[eventKey] || {},
+          level = _ref2.level;
+
+      return React.createElement("div", Object.assign({
+        ref: domRef,
+        className: classNames(className, "".concat(prefixCls, "-treenode"), (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-treenode-disabled"), disabled), _defineProperty(_classNames, "".concat(prefixCls, "-treenode-switcher-").concat(expanded ? 'open' : 'close'), !isLeaf), _defineProperty(_classNames, "".concat(prefixCls, "-treenode-checkbox-checked"), checked), _defineProperty(_classNames, "".concat(prefixCls, "-treenode-checkbox-indeterminate"), halfChecked), _defineProperty(_classNames, "".concat(prefixCls, "-treenode-selected"), selected), _defineProperty(_classNames, "".concat(prefixCls, "-treenode-loading"), loading), _defineProperty(_classNames, "".concat(prefixCls, "-treenode-active"), active), _defineProperty(_classNames, 'drag-over', !disabled && dragOver), _defineProperty(_classNames, 'drag-over-gap-top', !disabled && dragOverGapTop), _defineProperty(_classNames, 'drag-over-gap-bottom', !disabled && dragOverGapBottom), _defineProperty(_classNames, 'filter-node', filterTreeNode && filterTreeNode(convertNodePropsToEventData(this.props))), _classNames)),
+        style: style,
+        onDragEnter: draggable ? this.onDragEnter : undefined,
+        onDragOver: draggable ? this.onDragOver : undefined,
+        onDragLeave: draggable ? this.onDragLeave : undefined,
+        onDrop: draggable ? this.onDrop : undefined,
+        onDragEnd: draggable ? this.onDragEnd : undefined,
+        onMouseMove: onMouseMove
+      }, dataOrAriaAttributeProps), React.createElement(Indent, {
+        prefixCls: prefixCls,
+        level: level,
+        isStart: isStart,
+        isEnd: isEnd
+      }), this.renderSwitcher(), this.renderCheckbox(), this.renderSelector());
+    }
+  }]);
+
+  return InternalTreeNode;
+}(React.Component);
+
+InternalTreeNode.propTypes = {
+  prefixCls: PropTypes.string,
+  className: PropTypes.string,
+  style: PropTypes.object,
+  onSelect: PropTypes.func,
+  // By parent
+  eventKey: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  expanded: PropTypes.bool,
+  selected: PropTypes.bool,
+  checked: PropTypes.bool,
+  loaded: PropTypes.bool,
+  loading: PropTypes.bool,
+  halfChecked: PropTypes.bool,
+  title: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  dragOver: PropTypes.bool,
+  dragOverGapTop: PropTypes.bool,
+  dragOverGapBottom: PropTypes.bool,
+  pos: PropTypes.string,
+  // By user
+  isLeaf: PropTypes.bool,
+  checkable: PropTypes.bool,
+  selectable: PropTypes.bool,
+  disabled: PropTypes.bool,
+  disableCheckbox: PropTypes.bool,
+  icon: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  switcherIcon: PropTypes.oneOfType([PropTypes.node, PropTypes.func])
+};
+polyfill(InternalTreeNode);
+
+var ContextTreeNode = function ContextTreeNode(props) {
+  return React.createElement(TreeContext.Consumer, null, function (context) {
+    return React.createElement(InternalTreeNode, Object.assign({}, props, {
+      context: context
+    }));
+  });
+};
+
+ContextTreeNode.displayName = 'TreeNode';
+ContextTreeNode.defaultProps = {
+  title: defaultTitle
+};
+ContextTreeNode.isTreeNode = 1;
+export { InternalTreeNode };
+export default ContextTreeNode;

web/node_modules/rc-tree/es/contextTypes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { IconType, Key, DataEntity, EventDataNode, NodeInstance } from './interface';
+declare type NodeMouseEventHandler = (e: React.MouseEvent<HTMLDivElement>, node: EventDataNode) => void;
+declare type NodeDragEventHandler = (e: React.MouseEvent<HTMLDivElement>, node: NodeInstance) => void;
+export interface TreeContextProps {
+    prefixCls: string;
+    selectable: boolean;
+    showIcon: boolean;
+    icon: IconType;
+    switcherIcon: IconType;
+    draggable: boolean;
+    checkable: boolean | React.ReactNode;
+    checkStrictly: boolean;
+    disabled: boolean;
+    keyEntities: Record<Key, DataEntity>;
+    loadData: (treeNode: EventDataNode) => Promise<void>;
+    filterTreeNode: (treeNode: EventDataNode) => boolean;
+    onNodeClick: NodeMouseEventHandler;
+    onNodeDoubleClick: NodeMouseEventHandler;
+    onNodeExpand: NodeMouseEventHandler;
+    onNodeSelect: NodeMouseEventHandler;
+    onNodeCheck: (e: React.MouseEvent<HTMLDivElement>, treeNode: EventDataNode, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode) => void;
+    onNodeMouseEnter: NodeMouseEventHandler;
+    onNodeMouseLeave: NodeMouseEventHandler;
+    onNodeContextMenu: NodeMouseEventHandler;
+    onNodeDragStart: NodeDragEventHandler;
+    onNodeDragEnter: NodeDragEventHandler;
+    onNodeDragOver: NodeDragEventHandler;
+    onNodeDragLeave: NodeDragEventHandler;
+    onNodeDragEnd: NodeDragEventHandler;
+    onNodeDrop: NodeDragEventHandler;
+}
+export declare const TreeContext: React.Context<TreeContextProps | null>;
+export {};

web/node_modules/rc-tree/es/contextTypes.js

@@ -0,0 +1,6 @@
+/**
+ * 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 = React.createContext(null);

web/node_modules/rc-tree/es/index.d.ts

@@ -0,0 +1,4 @@
+import Tree, { TreeProps } from './Tree';
+import TreeNode, { TreeNodeProps } from './TreeNode';
+export { TreeNode, TreeProps, TreeNodeProps };
+export default Tree;

web/node_modules/rc-tree/es/index.js

@@ -0,0 +1,4 @@
+import Tree from './Tree';
+import TreeNode from './TreeNode';
+export { TreeNode };
+export default Tree;

web/node_modules/rc-tree/es/interface.d.ts

@@ -0,0 +1,66 @@
+import * as React from 'react';
+import { TreeNodeProps } from './TreeNode';
+export interface DataNode {
+    checkable?: boolean;
+    children?: DataNode[];
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    isLeaf?: boolean;
+    key: string | number;
+    title?: React.ReactNode;
+    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 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 declare type IconType = React.ReactNode | ((props: TreeNodeProps) => React.ReactNode);
+export declare type Key = string | number;
+export declare type NodeElement = React.ReactElement<TreeNodeProps> & {
+    selectHandle?: HTMLSpanElement;
+    type: {
+        isTreeNode: boolean;
+    };
+};
+export declare type NodeInstance = React.Component<TreeNodeProps> & {
+    selectHandle?: HTMLSpanElement;
+};
+export interface Entity {
+    node: NodeElement;
+    index: number;
+    key: Key;
+    pos: string;
+    parent?: Entity;
+    children?: Entity[];
+}
+export interface DataEntity extends Omit<Entity, 'node' | 'parent' | 'children'> {
+    node: DataNode;
+    parent?: DataEntity;
+    children?: DataEntity[];
+    level: number;
+}
+export interface FlattenNode {
+    parent: FlattenNode | null;
+    children: FlattenNode[];
+    pos: string;
+    data: DataNode;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+export declare type ScrollTo = (scroll: {
+    key: Key;
+}) => void;

web/node_modules/rc-tree/es/util.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Legacy code. Should avoid to use if you are new to import these code.
+ */
+import React from 'react';
+import { TreeNodeProps } from './TreeNode';
+import { NodeElement, Key, DataNode, DataEntity, NodeInstance } from './interface';
+import { TreeProps } from './Tree';
+export declare function arrDel(list: Key[], value: Key): (string | number)[];
+export declare function arrAdd(list: Key[], value: Key): (string | number)[];
+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 getDragNodesKeys(dragNodeKey: Key, keyEntities: Record<Key, DataEntity>): Key[];
+export declare function calcDropPosition(event: React.MouseEvent, treeNode: NodeInstance): 1 | 0 | -1;
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): (string | number)[];
+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[];
+}): any;
+/**
+ * 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>): string[];
+/**
+ * Returns only the data- and aria- key/value pairs
+ */
+export declare function getDataAndAria(props: Partial<TreeProps | TreeNodeProps>): Record<string, string>;

web/node_modules/rc-tree/es/util.js

@@ -0,0 +1,193 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+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; }
+
+/**
+ * Legacy code. Should avoid to use if you are new to import these code.
+ */
+import React from 'react';
+import warning from "rc-util/es/warning";
+import TreeNode from './TreeNode';
+var DRAG_SIDE_RANGE = 0.25;
+var DRAG_MIN_GAP = 2;
+export function arrDel(list, value) {
+  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 getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
+}
+export function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+export function getDragNodesKeys(dragNodeKey, keyEntities) {
+  var dragNodesKeys = [dragNodeKey];
+  var entity = 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;
+      dragNodesKeys.push(key);
+      dig(children);
+    });
+  }
+
+  dig(entity.children);
+  return dragNodesKeys;
+} // Only used when drag, not affect SSR.
+
+export function calcDropPosition(event, treeNode) {
+  var clientY = event.clientY;
+
+  var _treeNode$selectHandl = treeNode.selectHandle.getBoundingClientRect(),
+      top = _treeNode$selectHandl.top,
+      bottom = _treeNode$selectHandl.bottom,
+      height = _treeNode$selectHandl.height;
+
+  var des = Math.max(height * DRAG_SIDE_RANGE, DRAG_MIN_GAP);
+
+  if (clientY <= top + des) {
+    return -1;
+  }
+
+  if (clientY >= bottom - des) {
+    return 1;
+  }
+
+  return 0;
+}
+/**
+ * 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, ["children"]);
+
+    var childrenNodes = convertDataToTree(children, processor);
+    return React.createElement(TreeNode, Object.assign({}, 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 = {};
+
+  function conductUp(key) {
+    if (expandedKeys[key]) return;
+    var entity = keyEntities[key];
+    if (!entity) return;
+    expandedKeys[key] = true;
+    var parent = entity.parent,
+        node = entity.node;
+    if (node.disabled) return;
+
+    if (parent) {
+      conductUp(parent.key);
+    }
+  }
+
+  (keyList || []).forEach(function (key) {
+    conductUp(key);
+  });
+  return Object.keys(expandedKeys);
+}
+/**
+ * Returns only the data- and aria- key/value pairs
+ */
+
+export function getDataAndAria(props) {
+  var omitProps = {};
+  Object.keys(props).forEach(function (key) {
+    if (key.startsWith('data-') || key.startsWith('aria-')) {
+      omitProps[key] = props[key];
+    }
+  });
+  return omitProps;
+}

web/node_modules/rc-tree/es/utils/conductUtil.d.ts

@@ -0,0 +1,17 @@
+import { Key, DataEntity, DataNode } from '../interface';
+interface ConductReturnType {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export declare function isCheckDisabled(node: DataNode): boolean;
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+export declare function conductCheck(keyList: Key[], checked: true | {
+    checked: false;
+    halfCheckedKeys: Key[];
+}, keyEntities: Record<Key, DataEntity>): ConductReturnType;
+export {};

web/node_modules/rc-tree/es/utils/conductUtil.js

@@ -0,0 +1,225 @@
+import warning from "rc-util/es/warning";
+
+function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
+  var filteredKeys = new Set();
+  halfCheckedKeys.forEach(function (key) {
+    if (!checkedKeys.has(key)) {
+      filteredKeys.add(key);
+    }
+  });
+  return filteredKeys;
+}
+
+export function isCheckDisabled(node) {
+  var _ref = node || {},
+      disabled = _ref.disabled,
+      disableCheckbox = _ref.disableCheckbox,
+      checkable = _ref.checkable;
+
+  return !!(disabled || disableCheckbox) || checkable === false;
+} // Fill miss keys
+
+function fillConductCheck(keys, levelEntities, maxLevel) {
+  var checkedKeys = new Set(keys);
+  var halfCheckedKeys = new Set(); // Add checked keys top to bottom
+
+  for (var level = 0; level <= maxLevel; level += 1) {
+    var entities = levelEntities.get(level) || new Set();
+    entities.forEach(function (entity) {
+      var key = entity.key,
+          node = entity.node,
+          _entity$children = entity.children,
+          children = _entity$children === void 0 ? [] : _entity$children;
+
+      if (checkedKeys.has(key) && !isCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !isCheckDisabled(childEntity.node);
+        }).forEach(function (childEntity) {
+          checkedKeys.add(childEntity.key);
+        });
+      }
+    });
+  } // Add checked keys from bottom to top
+
+
+  var visitedKeys = new Set();
+
+  for (var _level = maxLevel; _level >= 0; _level -= 1) {
+    var _entities = levelEntities.get(_level) || new Set();
+
+    _entities.forEach(function (entity) {
+      var parent = entity.parent,
+          node = entity.node; // Skip if no need to check
+
+      if (isCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      } // Skip if parent is disabled
+
+
+      if (isCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !isCheckDisabled(childEntity.node);
+      }).forEach(function (_ref2) {
+        var key = _ref2.key;
+        var checked = checkedKeys.has(key);
+
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+
+      if (allChecked) {
+        checkedKeys.add(parent.key);
+      }
+
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+
+      visitedKeys.add(parent.key);
+    });
+  }
+
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+} // Remove useless key
+
+
+function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel) {
+  var checkedKeys = new Set(keys);
+  var halfCheckedKeys = new Set(halfKeys); // Remove checked keys from top to bottom
+
+  for (var level = 0; level <= maxLevel; level += 1) {
+    var entities = levelEntities.get(level) || new Set();
+    entities.forEach(function (entity) {
+      var key = entity.key,
+          node = entity.node,
+          _entity$children2 = entity.children,
+          children = _entity$children2 === void 0 ? [] : _entity$children2;
+
+      if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !isCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !isCheckDisabled(childEntity.node);
+        }).forEach(function (childEntity) {
+          checkedKeys.delete(childEntity.key);
+        });
+      }
+    });
+  } // Remove checked keys form bottom to top
+
+
+  halfCheckedKeys = new Set();
+  var visitedKeys = new Set();
+
+  for (var _level2 = maxLevel; _level2 >= 0; _level2 -= 1) {
+    var _entities2 = levelEntities.get(_level2) || new Set();
+
+    _entities2.forEach(function (entity) {
+      var parent = entity.parent,
+          node = entity.node; // Skip if no need to check
+
+      if (isCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      } // Skip if parent is disabled
+
+
+      if (isCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !isCheckDisabled(childEntity.node);
+      }).forEach(function (_ref3) {
+        var key = _ref3.key;
+        var checked = checkedKeys.has(key);
+
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+
+      if (!allChecked) {
+        checkedKeys.delete(parent.key);
+      }
+
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+
+      visitedKeys.add(parent.key);
+    });
+  }
+
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+}
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+
+
+export function conductCheck(keyList, checked, keyEntities) {
+  var warningMissKeys = []; // We only handle exist keys
+
+  var keys = new Set(keyList.filter(function (key) {
+    var hasEntity = !!keyEntities[key];
+
+    if (!hasEntity) {
+      warningMissKeys.push(key);
+    }
+
+    return hasEntity;
+  }));
+  var levelEntities = new Map();
+  var maxLevel = 0; // Convert entities by level for calculation
+
+  Object.keys(keyEntities).forEach(function (key) {
+    var entity = keyEntities[key];
+    var level = entity.level;
+    var levelSet = levelEntities.get(level);
+
+    if (!levelSet) {
+      levelSet = new Set();
+      levelEntities.set(level, levelSet);
+    }
+
+    levelSet.add(entity);
+    maxLevel = Math.max(maxLevel, level);
+  });
+  warning(!warningMissKeys.length, "Tree missing follow keys: ".concat(warningMissKeys.slice(0, 100).map(function (key) {
+    return "'".concat(key, "'");
+  }).join(', ')));
+  var result;
+
+  if (checked === true) {
+    result = fillConductCheck(keys, levelEntities, maxLevel);
+  } else {
+    result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel);
+  }
+
+  return result;
+}

web/node_modules/rc-tree/es/utils/diffUtil.d.ts

@@ -0,0 +1,6 @@
+import { Key, FlattenNode } from '../interface';
+export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
+    add: boolean;
+    key: string | number;
+};
+export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode[];

web/node_modules/rc-tree/es/utils/diffUtil.js

@@ -0,0 +1,57 @@
+export function findExpandedKeys() {
+  var prev = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var next = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var prevLen = prev.length;
+  var nextLen = next.length;
+
+  if (Math.abs(prevLen - nextLen) !== 1) {
+    return {
+      add: false,
+      key: null
+    };
+  }
+
+  function find(shorter, longer) {
+    var cache = new Map();
+    shorter.forEach(function (key) {
+      cache.set(key, true);
+    });
+    var keys = longer.filter(function (key) {
+      return !cache.has(key);
+    });
+    return keys.length === 1 ? keys[0] : null;
+  }
+
+  if (prevLen < nextLen) {
+    return {
+      add: true,
+      key: find(prev, next)
+    };
+  }
+
+  return {
+    add: false,
+    key: find(next, prev)
+  };
+}
+export function getExpandRange(shorter, longer, key) {
+  var shorterStartIndex = shorter.findIndex(function (_ref) {
+    var data = _ref.data;
+    return data.key === key;
+  });
+  var shorterEndNode = shorter[shorterStartIndex + 1];
+  var longerStartIndex = longer.findIndex(function (_ref2) {
+    var data = _ref2.data;
+    return data.key === key;
+  });
+
+  if (shorterEndNode) {
+    var longerEndIndex = longer.findIndex(function (_ref3) {
+      var data = _ref3.data;
+      return data.key === shorterEndNode.data.key;
+    });
+    return longer.slice(longerStartIndex + 1, longerEndIndex);
+  }
+
+  return longer.slice(longerStartIndex + 1);
+}

web/node_modules/rc-tree/es/utils/treeUtil.d.ts

@@ -0,0 +1,75 @@
+import * as React from 'react';
+import { DataNode, FlattenNode, DataEntity, Key, EventDataNode } from '../interface';
+import { TreeNodeProps } from '../TreeNode';
+export declare function getKey(key: Key, pos: string): string | number;
+/**
+ * Warning if TreeNode do not provides key
+ */
+export declare function warningWithoutKey(treeData?: DataNode[]): void;
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+export declare function convertTreeToData(rootNodes: React.ReactNode): DataNode[];
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+export declare function flattenTreeData(treeNodeList?: DataNode[], expandedKeys?: Key[] | true): FlattenNode[];
+/**
+ * Traverse all the data by `treeData`.
+ * Please not use it out of the `rc-tree` since we may refactor this code.
+ */
+export declare function traverseDataNodes(dataNodes: DataNode[], callback: (data: {
+    node: DataNode;
+    index: number;
+    pos: string;
+    key: Key;
+    parentPos: string | number;
+    level: number;
+}) => void): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: Record<Key, DataEntity>;
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+}): {
+    posEntities: {};
+    keyEntities: {};
+};
+export interface TreeNodeRequiredProps {
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: Record<Key, DataEntity>;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps): {
+    eventKey: string | number;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData(props: TreeNodeProps): EventDataNode;
+export {};

web/node_modules/rc-tree/es/utils/treeUtil.js

@@ -0,0 +1,295 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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; }
+
+import toArray from "rc-util/es/Children/toArray";
+import warning from "rc-util/es/warning";
+import { getPosition, isTreeNode } from '../util';
+export function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+
+  return pos;
+}
+/**
+ * Warning if TreeNode do not provides key
+ */
+
+export function warningWithoutKey() {
+  var treeData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var keys = new Map();
+
+  function dig(list) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    (list || []).forEach(function (treeNode) {
+      var key = treeNode.key,
+          children = treeNode.children;
+      warning(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
+      var recordKey = String(key);
+      warning(!keys.has(recordKey) || key === null || key === undefined, "Same 'key' exist in the Tree: ".concat(recordKey));
+      keys.set(recordKey, true);
+      dig(children, "".concat(path).concat(recordKey, " > "));
+    });
+  }
+
+  dig(treeData);
+}
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+
+export function convertTreeToData(rootNodes) {
+  function dig(node) {
+    var treeNodes = toArray(node);
+    return treeNodes.map(function (treeNode) {
+      // Filter invalidate node
+      if (!isTreeNode(treeNode)) {
+        warning(!treeNode, 'Tree/TreeNode can only accept TreeNode as children.');
+        return null;
+      }
+
+      var key = treeNode.key;
+
+      var _treeNode$props = treeNode.props,
+          children = _treeNode$props.children,
+          rest = _objectWithoutProperties(_treeNode$props, ["children"]);
+
+      var dataNode = _objectSpread({
+        key: key
+      }, rest);
+
+      var parsedChildren = dig(children);
+
+      if (parsedChildren.length) {
+        dataNode.children = parsedChildren;
+      }
+
+      return dataNode;
+    }).filter(function (dataNode) {
+      return dataNode;
+    });
+  }
+
+  return dig(rootNodes);
+}
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+
+export function flattenTreeData() {
+  var treeNodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var expandedKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
+  var flattenList = [];
+
+  function dig(list) {
+    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    return list.map(function (treeNode, index) {
+      var pos = getPosition(parent ? parent.pos : '0', index);
+      var mergedKey = getKey(treeNode.key, pos); // Add FlattenDataNode into list
+
+      var flattenNode = _objectSpread({}, treeNode, {
+        parent: parent,
+        pos: pos,
+        children: null,
+        data: treeNode,
+        isStart: [].concat(_toConsumableArray(parent ? parent.isStart : []), [index === 0]),
+        isEnd: [].concat(_toConsumableArray(parent ? parent.isEnd : []), [index === list.length - 1])
+      });
+
+      flattenList.push(flattenNode); // Loop treeNode children
+
+      if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
+        flattenNode.children = dig(treeNode.children || [], flattenNode);
+      } else {
+        flattenNode.children = [];
+      }
+
+      return flattenNode;
+    });
+  }
+
+  dig(treeNodeList);
+  return flattenList;
+}
+/**
+ * Traverse all the data by `treeData`.
+ * Please not use it out of the `rc-tree` since we may refactor this code.
+ */
+
+export function traverseDataNodes(dataNodes, callback) {
+  function processNode(node, index, parent) {
+    var children = node ? node.children : dataNodes;
+    var pos = node ? getPosition(parent.pos, index) : '0'; // Process node if is not root
+
+    if (node) {
+      var data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: node.key !== null ? node.key : pos,
+        parentPos: parent.node ? parent.pos : null,
+        level: parent.level + 1
+      };
+      callback(data);
+    } // Process children node
+
+
+    if (children) {
+      children.forEach(function (subNode, subIndex) {
+        processNode(subNode, subIndex, {
+          node: node,
+          pos: pos,
+          level: parent ? parent.level + 1 : -1
+        });
+      });
+    }
+  }
+
+  processNode(null);
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+
+export function convertDataToEntities(dataNodes) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      initWrapper = _ref.initWrapper,
+      processEntity = _ref.processEntity,
+      onProcessFinished = _ref.onProcessFinished;
+
+  var posEntities = {};
+  var keyEntities = {};
+  var wrapper = {
+    posEntities: posEntities,
+    keyEntities: keyEntities
+  };
+
+  if (initWrapper) {
+    wrapper = initWrapper(wrapper) || wrapper;
+  }
+
+  traverseDataNodes(dataNodes, function (item) {
+    var node = item.node,
+        index = item.index,
+        pos = item.pos,
+        key = item.key,
+        parentPos = item.parentPos,
+        level = item.level;
+    var entity = {
+      node: node,
+      index: index,
+      key: key,
+      pos: pos,
+      level: level
+    };
+    var mergedKey = getKey(key, pos);
+    posEntities[pos] = entity;
+    keyEntities[mergedKey] = entity; // Fill children
+
+    entity.parent = posEntities[parentPos];
+
+    if (entity.parent) {
+      entity.parent.children = entity.parent.children || [];
+      entity.parent.children.push(entity);
+    }
+
+    if (processEntity) {
+      processEntity(entity, wrapper);
+    }
+  });
+
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+
+  return wrapper;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+
+export function getTreeNodeProps(key, _ref2) {
+  var expandedKeys = _ref2.expandedKeys,
+      selectedKeys = _ref2.selectedKeys,
+      loadedKeys = _ref2.loadedKeys,
+      loadingKeys = _ref2.loadingKeys,
+      checkedKeys = _ref2.checkedKeys,
+      halfCheckedKeys = _ref2.halfCheckedKeys,
+      dragOverNodeKey = _ref2.dragOverNodeKey,
+      dropPosition = _ref2.dropPosition,
+      keyEntities = _ref2.keyEntities;
+  var entity = keyEntities[key];
+  var treeNodeProps = {
+    eventKey: key,
+    expanded: expandedKeys.indexOf(key) !== -1,
+    selected: selectedKeys.indexOf(key) !== -1,
+    loaded: loadedKeys.indexOf(key) !== -1,
+    loading: loadingKeys.indexOf(key) !== -1,
+    checked: checkedKeys.indexOf(key) !== -1,
+    halfChecked: halfCheckedKeys.indexOf(key) !== -1,
+    pos: String(entity ? entity.pos : ''),
+    // [Legacy] Drag props
+    dragOver: dragOverNodeKey === key && dropPosition === 0,
+    dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
+    dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
+  };
+  return treeNodeProps;
+}
+export function convertNodePropsToEventData(props) {
+  var data = props.data,
+      expanded = props.expanded,
+      selected = props.selected,
+      checked = props.checked,
+      loaded = props.loaded,
+      loading = props.loading,
+      halfChecked = props.halfChecked,
+      dragOver = props.dragOver,
+      dragOverGapTop = props.dragOverGapTop,
+      dragOverGapBottom = props.dragOverGapBottom,
+      pos = props.pos,
+      active = props.active;
+
+  var eventData = _objectSpread({}, data, {
+    expanded: expanded,
+    selected: selected,
+    checked: checked,
+    loaded: loaded,
+    loading: loading,
+    halfChecked: halfChecked,
+    dragOver: dragOver,
+    dragOverGapTop: dragOverGapTop,
+    dragOverGapBottom: dragOverGapBottom,
+    pos: pos,
+    active: active
+  });
+
+  if (!('props' in eventData)) {
+    Object.defineProperty(eventData, 'props', {
+      get: function get() {
+        warning(false, 'Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.');
+        return props;
+      }
+    });
+  }
+
+  return eventData;
+}