Latest updates from IceHrmPro

web/node_modules/antd/lib/tree/DirectoryTree.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { EventDataNode, DataNode, Key } from 'rc-tree/lib/interface';
+import { ConfigConsumerProps } from '../config-provider';
+import Tree, { TreeProps } from './Tree';
+export declare type ExpandAction = false | 'click' | 'doubleClick';
+export interface DirectoryTreeProps extends TreeProps {
+    expandAction?: ExpandAction;
+}
+export interface DirectoryTreeState {
+    expandedKeys?: Key[];
+    selectedKeys?: Key[];
+}
+declare class DirectoryTree extends React.Component<DirectoryTreeProps, DirectoryTreeState> {
+    static defaultProps: {
+        showIcon: boolean;
+        expandAction: false | "click" | "doubleClick" | undefined;
+    };
+    static getDerivedStateFromProps(nextProps: DirectoryTreeProps): DirectoryTreeState;
+    state: DirectoryTreeState;
+    tree: Tree;
+    onDebounceExpand: (event: React.MouseEvent<HTMLElement>, node: EventDataNode) => void;
+    lastSelectedKey?: Key;
+    cachedSelectedKeys?: Key[];
+    constructor(props: DirectoryTreeProps);
+    onExpand: (expandedKeys: React.ReactText[], info: {
+        node: EventDataNode;
+        expanded: boolean;
+        nativeEvent: MouseEvent;
+    }) => void;
+    onClick: (event: React.MouseEvent<HTMLElement, MouseEvent>, node: EventDataNode) => void;
+    onDoubleClick: (event: React.MouseEvent<HTMLElement, MouseEvent>, node: EventDataNode) => void;
+    onSelect: (keys: React.ReactText[], event: {
+        event: "select";
+        selected: boolean;
+        node: any;
+        selectedNodes: DataNode[];
+        nativeEvent: MouseEvent;
+    }) => void;
+    setTreeRef: (node: Tree) => void;
+    expandFolderNode: (event: React.MouseEvent<HTMLElement, MouseEvent>, node: any) => void;
+    setUncontrolledState: (state: DirectoryTreeState) => void;
+    renderDirectoryTree: ({ getPrefixCls, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}
+export default DirectoryTree;

web/node_modules/antd/lib/tree/DirectoryTree.js

@@ -0,0 +1,324 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _omit = _interopRequireDefault(require("omit.js"));
+
+var _debounce = _interopRequireDefault(require("lodash/debounce"));
+
+var _util = require("rc-tree/lib/util");
+
+var _treeUtil = require("rc-tree/lib/utils/treeUtil");
+
+var _FileOutlined = _interopRequireDefault(require("@ant-design/icons/FileOutlined"));
+
+var _FolderOpenOutlined = _interopRequireDefault(require("@ant-design/icons/FolderOpenOutlined"));
+
+var _FolderOutlined = _interopRequireDefault(require("@ant-design/icons/FolderOutlined"));
+
+var _configProvider = require("../config-provider");
+
+var _Tree = _interopRequireDefault(require("./Tree"));
+
+var _dictUtil = require("./utils/dictUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 _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 _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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) 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 _extends() { _extends = Object.assign || 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 _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 _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); }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+function getIcon(props) {
+  var isLeaf = props.isLeaf,
+      expanded = props.expanded;
+
+  if (isLeaf) {
+    return /*#__PURE__*/React.createElement(_FileOutlined["default"], null);
+  }
+
+  return expanded ? /*#__PURE__*/React.createElement(_FolderOpenOutlined["default"], null) : /*#__PURE__*/React.createElement(_FolderOutlined["default"], null);
+}
+
+function getTreeData(_ref) {
+  var treeData = _ref.treeData,
+      children = _ref.children;
+  return treeData || (0, _treeUtil.convertTreeToData)(children);
+}
+
+var DirectoryTree = /*#__PURE__*/function (_React$Component) {
+  _inherits(DirectoryTree, _React$Component);
+
+  var _super = _createSuper(DirectoryTree);
+
+  function DirectoryTree(props) {
+    var _this;
+
+    _classCallCheck(this, DirectoryTree);
+
+    _this = _super.call(this, props);
+
+    _this.onExpand = function (expandedKeys, info) {
+      var onExpand = _this.props.onExpand;
+
+      _this.setUncontrolledState({
+        expandedKeys: expandedKeys
+      }); // Call origin function
+
+
+      if (onExpand) {
+        return onExpand(expandedKeys, info);
+      }
+
+      return undefined;
+    };
+
+    _this.onClick = function (event, node) {
+      var _this$props = _this.props,
+          onClick = _this$props.onClick,
+          expandAction = _this$props.expandAction; // Expand the tree
+
+      if (expandAction === 'click') {
+        _this.onDebounceExpand(event, node);
+      }
+
+      if (onClick) {
+        onClick(event, node);
+      }
+    };
+
+    _this.onDoubleClick = function (event, node) {
+      var _this$props2 = _this.props,
+          onDoubleClick = _this$props2.onDoubleClick,
+          expandAction = _this$props2.expandAction; // Expand the tree
+
+      if (expandAction === 'doubleClick') {
+        _this.onDebounceExpand(event, node);
+      }
+
+      if (onDoubleClick) {
+        onDoubleClick(event, node);
+      }
+    };
+
+    _this.onSelect = function (keys, event) {
+      var _this$props3 = _this.props,
+          onSelect = _this$props3.onSelect,
+          multiple = _this$props3.multiple;
+      var _this$state$expandedK = _this.state.expandedKeys,
+          expandedKeys = _this$state$expandedK === void 0 ? [] : _this$state$expandedK;
+      var node = event.node,
+          nativeEvent = event.nativeEvent;
+      var _node$key = node.key,
+          key = _node$key === void 0 ? '' : _node$key;
+      var treeData = getTreeData(_this.props);
+      var newState = {}; // We need wrap this event since some value is not same
+
+      var newEvent = _extends(_extends({}, event), {
+        selected: true
+      }); // Windows / Mac single pick
+
+
+      var ctrlPick = nativeEvent.ctrlKey || nativeEvent.metaKey;
+      var shiftPick = nativeEvent.shiftKey; // Generate new selected keys
+
+      var newSelectedKeys;
+
+      if (multiple && ctrlPick) {
+        // Control click
+        newSelectedKeys = keys;
+        _this.lastSelectedKey = key;
+        _this.cachedSelectedKeys = newSelectedKeys;
+        newEvent.selectedNodes = (0, _dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+      } else if (multiple && shiftPick) {
+        // Shift click
+        newSelectedKeys = Array.from(new Set([].concat(_toConsumableArray(_this.cachedSelectedKeys || []), _toConsumableArray((0, _dictUtil.calcRangeKeys)(treeData, expandedKeys, key, _this.lastSelectedKey)))));
+        newEvent.selectedNodes = (0, _dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+      } else {
+        // Single click
+        newSelectedKeys = [key];
+        _this.lastSelectedKey = key;
+        _this.cachedSelectedKeys = newSelectedKeys;
+        newEvent.selectedNodes = (0, _dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+      }
+
+      newState.selectedKeys = newSelectedKeys;
+
+      if (onSelect) {
+        onSelect(newSelectedKeys, newEvent);
+      }
+
+      _this.setUncontrolledState(newState);
+    };
+
+    _this.setTreeRef = function (node) {
+      _this.tree = node;
+    };
+
+    _this.expandFolderNode = function (event, node) {
+      var isLeaf = node.isLeaf;
+
+      if (isLeaf || event.shiftKey || event.metaKey || event.ctrlKey) {
+        return;
+      } // Get internal rc-tree
+
+
+      var internalTree = _this.tree.tree; // Call internal rc-tree expand function
+      // https://github.com/ant-design/ant-design/issues/12567
+
+      internalTree.onNodeExpand(event, node);
+    };
+
+    _this.setUncontrolledState = function (state) {
+      var newState = (0, _omit["default"])(state, Object.keys(_this.props));
+
+      if (Object.keys(newState).length) {
+        _this.setState(newState);
+      }
+    };
+
+    _this.renderDirectoryTree = function (_ref2) {
+      var getPrefixCls = _ref2.getPrefixCls,
+          direction = _ref2.direction;
+
+      var _a = _this.props,
+          customizePrefixCls = _a.prefixCls,
+          className = _a.className,
+          props = __rest(_a, ["prefixCls", "className"]);
+
+      var _this$state = _this.state,
+          expandedKeys = _this$state.expandedKeys,
+          selectedKeys = _this$state.selectedKeys;
+      var prefixCls = getPrefixCls('tree', customizePrefixCls);
+      var connectClassName = (0, _classnames["default"])("".concat(prefixCls, "-directory"), className, _defineProperty({}, "".concat(prefixCls, "-directory-rtl"), direction === 'rtl'));
+      return /*#__PURE__*/React.createElement(_Tree["default"], _extends({
+        icon: getIcon,
+        ref: _this.setTreeRef,
+        blockNode: true
+      }, props, {
+        prefixCls: prefixCls,
+        className: connectClassName,
+        expandedKeys: expandedKeys,
+        selectedKeys: selectedKeys,
+        onSelect: _this.onSelect,
+        onClick: _this.onClick,
+        onDoubleClick: _this.onDoubleClick,
+        onExpand: _this.onExpand
+      }));
+    };
+
+    var defaultExpandAll = props.defaultExpandAll,
+        defaultExpandParent = props.defaultExpandParent,
+        expandedKeys = props.expandedKeys,
+        defaultExpandedKeys = props.defaultExpandedKeys;
+
+    var _convertDataToEntitie = (0, _treeUtil.convertDataToEntities)(getTreeData(props)),
+        keyEntities = _convertDataToEntitie.keyEntities; // Selected keys
+
+
+    _this.state = {
+      selectedKeys: props.selectedKeys || props.defaultSelectedKeys || []
+    }; // Expanded keys
+
+    if (defaultExpandAll) {
+      _this.state.expandedKeys = Object.keys(keyEntities);
+    } else if (defaultExpandParent) {
+      _this.state.expandedKeys = (0, _util.conductExpandParent)(expandedKeys || defaultExpandedKeys, keyEntities);
+    } else {
+      _this.state.expandedKeys = expandedKeys || defaultExpandedKeys;
+    }
+
+    _this.onDebounceExpand = (0, _debounce["default"])(_this.expandFolderNode, 200, {
+      leading: true
+    });
+    return _this;
+  }
+
+  _createClass(DirectoryTree, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(_configProvider.ConfigConsumer, null, this.renderDirectoryTree);
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps) {
+      var newState = {};
+
+      if ('expandedKeys' in nextProps) {
+        newState.expandedKeys = nextProps.expandedKeys;
+      }
+
+      if ('selectedKeys' in nextProps) {
+        newState.selectedKeys = nextProps.selectedKeys;
+      }
+
+      return newState;
+    }
+  }]);
+
+  return DirectoryTree;
+}(React.Component);
+
+DirectoryTree.defaultProps = {
+  showIcon: true,
+  expandAction: 'click'
+};
+var _default = DirectoryTree;
+exports["default"] = _default;

web/node_modules/antd/lib/tree/Tree.d.ts

@@ -0,0 +1,155 @@
+import * as React from 'react';
+import { TreeProps as RcTreeProps } from 'rc-tree';
+import { DataNode, Key } from 'rc-tree/lib/interface';
+import DirectoryTree from './DirectoryTree';
+import { ConfigConsumerProps } from '../config-provider';
+export interface AntdTreeNodeAttribute {
+    eventKey: string;
+    prefixCls: string;
+    className: string;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    children: React.ReactNode;
+    title: React.ReactNode;
+    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.ReactNode;
+    key?: Key;
+    eventKey?: string;
+    isLeaf?: boolean;
+    checked?: boolean;
+    expanded?: boolean;
+    loading?: boolean;
+    selected?: boolean;
+    selectable?: boolean;
+    icon?: ((treeNode: AntdTreeNodeAttribute) => React.ReactNode) | React.ReactNode;
+    children?: React.ReactNode;
+    [customProp: string]: any;
+}
+export interface AntTreeNode extends React.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: React.DragEvent<HTMLElement>;
+}
+export interface AntTreeNodeDragEnterEvent extends AntTreeNodeMouseEvent {
+    expandedKeys: Key[];
+}
+export interface AntTreeNodeDropEvent {
+    node: AntTreeNode;
+    dragNode: AntTreeNode;
+    dragNodesKeys: Key[];
+    dropPosition: number;
+    dropToGap?: boolean;
+    event: React.MouseEvent<HTMLElement>;
+}
+export declare type TreeNodeNormal = DataNode;
+export interface TreeProps extends Omit<RcTreeProps, 'prefixCls'> {
+    showLine?: 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?: boolean;
+    style?: React.CSSProperties;
+    showIcon?: boolean;
+    icon?: ((nodeProps: AntdTreeNodeAttribute) => React.ReactNode) | React.ReactNode;
+    switcherIcon?: React.ReactElement<any>;
+    prefixCls?: string;
+    children?: React.ReactNode;
+    blockNode?: boolean;
+}
+export default class Tree extends React.Component<TreeProps, any> {
+    static TreeNode: React.FC<import("rc-tree").TreeNodeProps>;
+    static DirectoryTree: typeof DirectoryTree;
+    static defaultProps: {
+        checkable: boolean;
+        showIcon: boolean;
+        motion: {
+            motionAppear: boolean;
+            visible?: boolean | undefined;
+            motionName?: string | undefined;
+            motionEnter?: boolean | undefined;
+            motionLeave?: boolean | undefined;
+            motionLeaveImmediately?: boolean | undefined;
+            removeOnLeave?: boolean | undefined;
+            leavedClassName?: string | undefined;
+            onAppearStart?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onAppearActive?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onAppearEnd?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onEnterStart?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onEnterActive?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onEnterEnd?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onLeaveStart?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onLeaveActive?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+            onLeaveEnd?: ((element: HTMLElement) => React.CSSProperties) | undefined;
+        };
+        blockNode: boolean;
+    };
+    tree: any;
+    setTreeRef: (node: any) => void;
+    renderTree: ({ getPrefixCls, direction }: ConfigConsumerProps) => JSX.Element;
+    render(): JSX.Element;
+}

web/node_modules/antd/lib/tree/Tree.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _rcTree = _interopRequireWildcard(require("rc-tree"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _DirectoryTree = _interopRequireDefault(require("./DirectoryTree"));
+
+var _configProvider = require("../config-provider");
+
+var _motion = _interopRequireDefault(require("../_util/motion"));
+
+var _iconUtil = _interopRequireDefault(require("./utils/iconUtil"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 _extends() { _extends = Object.assign || 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 _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 _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); }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var Tree = /*#__PURE__*/function (_React$Component) {
+  _inherits(Tree, _React$Component);
+
+  var _super = _createSuper(Tree);
+
+  function Tree() {
+    var _this;
+
+    _classCallCheck(this, Tree);
+
+    _this = _super.apply(this, arguments);
+
+    _this.setTreeRef = function (node) {
+      _this.tree = node;
+    };
+
+    _this.renderTree = function (_ref) {
+      var _classNames;
+
+      var getPrefixCls = _ref.getPrefixCls,
+          direction = _ref.direction;
+
+      var _assertThisInitialize = _assertThisInitialized(_this),
+          props = _assertThisInitialize.props;
+
+      var customizePrefixCls = props.prefixCls,
+          className = props.className,
+          showIcon = props.showIcon,
+          showLine = props.showLine,
+          _switcherIcon = props.switcherIcon,
+          blockNode = props.blockNode,
+          children = props.children;
+      var checkable = props.checkable;
+      var prefixCls = getPrefixCls('tree', customizePrefixCls);
+      return /*#__PURE__*/React.createElement(_rcTree["default"], _extends({
+        itemHeight: 20,
+        ref: _this.setTreeRef
+      }, props, {
+        prefixCls: prefixCls,
+        className: (0, _classnames["default"])(className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-icon-hide"), !showIcon), _defineProperty(_classNames, "".concat(prefixCls, "-block-node"), blockNode), _defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames)),
+        checkable: checkable ? /*#__PURE__*/React.createElement("span", {
+          className: "".concat(prefixCls, "-checkbox-inner")
+        }) : checkable,
+        switcherIcon: function switcherIcon(nodeProps) {
+          return (0, _iconUtil["default"])(prefixCls, _switcherIcon, showLine, nodeProps);
+        }
+      }), children);
+    };
+
+    return _this;
+  }
+
+  _createClass(Tree, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(_configProvider.ConfigConsumer, null, this.renderTree);
+    }
+  }]);
+
+  return Tree;
+}(React.Component);
+
+exports["default"] = Tree;
+Tree.TreeNode = _rcTree.TreeNode;
+Tree.DirectoryTree = _DirectoryTree["default"];
+Tree.defaultProps = {
+  checkable: false,
+  showIcon: false,
+  motion: _extends(_extends({}, _motion["default"]), {
+    motionAppear: false
+  }),
+  blockNode: false
+};

web/node_modules/antd/lib/tree/index.d.ts

@@ -0,0 +1,4 @@
+import Tree from './Tree';
+export { TreeProps, AntTreeNode, AntTreeNodeMouseEvent, AntTreeNodeExpandedEvent, AntTreeNodeCheckedEvent, AntTreeNodeSelectedEvent, AntdTreeNodeAttribute, AntTreeNodeProps, } from './Tree';
+export { ExpandAction as DirectoryTreeExpandAction, DirectoryTreeProps } from './DirectoryTree';
+export default Tree;

web/node_modules/antd/lib/tree/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _Tree = _interopRequireDefault(require("./Tree"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var _default = _Tree["default"];
+exports["default"] = _default;

web/node_modules/antd/lib/tree/style/css.js

@@ -0,0 +1,5 @@
+"use strict";
+
+require("../../style/index.css");
+
+require("./index.css");

web/node_modules/antd/lib/tree/style/directory.less

@@ -0,0 +1,74 @@
+@import '../../style/themes/index';
+
+@tree-prefix-cls: ~'@{ant-prefix}-tree';
+
+.@{tree-prefix-cls} {
+  &.@{tree-prefix-cls}-directory {
+    // ================== TreeNode ==================
+    .@{tree-prefix-cls}-treenode {
+      position: relative;
+
+      // Hover color
+      &::before {
+        position: absolute;
+        top: 0;
+        right: 0;
+        bottom: 4px;
+        left: 0;
+        transition: background-color 0.3s;
+        content: '';
+        pointer-events: none;
+      }
+
+      &:hover {
+        &::before {
+          background: @item-hover-bg;
+        }
+      }
+
+      // Elements
+      > * {
+        z-index: 1;
+      }
+
+      // >>> Switcher
+      .@{tree-prefix-cls}-switcher {
+        transition: color 0.3s;
+      }
+
+      // >>> Title
+      .@{tree-prefix-cls}-node-content-wrapper {
+        border-radius: 0;
+        user-select: none;
+
+        &:hover {
+          background: transparent;
+        }
+
+        &.@{tree-prefix-cls}-node-selected {
+          color: @tree-directory-selected-color;
+          background: transparent;
+        }
+      }
+
+      // ============= Selected =============
+      &-selected {
+        &:hover::before,
+        &::before {
+          background: @primary-color;
+        }
+
+        // >>> Switcher
+        .@{tree-prefix-cls}-switcher {
+          color: @tree-directory-selected-color;
+        }
+
+        // >>> Title
+        .@{tree-prefix-cls}-node-content-wrapper {
+          color: @tree-directory-selected-color;
+          background: transparent;
+        }
+      }
+    }
+  }
+}

web/node_modules/antd/lib/tree/style/index.css

@@ -0,0 +1,478 @@
+/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */
+/* stylelint-disable no-duplicate-selectors */
+/* stylelint-disable */
+/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */
+@-webkit-keyframes antCheckboxEffect {
+  0% {
+    -webkit-transform: scale(1);
+            transform: scale(1);
+    opacity: 0.5;
+  }
+  100% {
+    -webkit-transform: scale(1.6);
+            transform: scale(1.6);
+    opacity: 0;
+  }
+}
+@keyframes antCheckboxEffect {
+  0% {
+    -webkit-transform: scale(1);
+            transform: scale(1);
+    opacity: 0.5;
+  }
+  100% {
+    -webkit-transform: scale(1.6);
+            transform: scale(1.6);
+    opacity: 0;
+  }
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode {
+  position: relative;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode::before {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 4px;
+  left: 0;
+  -webkit-transition: background-color 0.3s;
+  transition: background-color 0.3s;
+  content: '';
+  pointer-events: none;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode:hover::before {
+  background: #f5f5f5;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode > * {
+  z-index: 1;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode .ant-tree-switcher {
+  -webkit-transition: color 0.3s;
+  transition: color 0.3s;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode .ant-tree-node-content-wrapper {
+  border-radius: 0;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode .ant-tree-node-content-wrapper:hover {
+  background: transparent;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode .ant-tree-node-content-wrapper.ant-tree-node-selected {
+  color: #fff;
+  background: transparent;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode-selected:hover::before,
+.ant-tree.ant-tree-directory .ant-tree-treenode-selected::before {
+  background: #1890ff;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode-selected .ant-tree-switcher {
+  color: #fff;
+}
+.ant-tree.ant-tree-directory .ant-tree-treenode-selected .ant-tree-node-content-wrapper {
+  color: #fff;
+  background: transparent;
+}
+.ant-tree-checkbox {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  position: relative;
+  top: -0.09em;
+  display: inline-block;
+  line-height: 1;
+  white-space: nowrap;
+  vertical-align: middle;
+  outline: none;
+  cursor: pointer;
+}
+.ant-tree-checkbox-wrapper:hover .ant-tree-checkbox-inner,
+.ant-tree-checkbox:hover .ant-tree-checkbox-inner,
+.ant-tree-checkbox-input:focus + .ant-tree-checkbox-inner {
+  border-color: #1890ff;
+}
+.ant-tree-checkbox-checked::after {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border: 1px solid #1890ff;
+  border-radius: 2px;
+  visibility: hidden;
+  -webkit-animation: antCheckboxEffect 0.36s ease-in-out;
+          animation: antCheckboxEffect 0.36s ease-in-out;
+  -webkit-animation-fill-mode: backwards;
+          animation-fill-mode: backwards;
+  content: '';
+}
+.ant-tree-checkbox:hover::after,
+.ant-tree-checkbox-wrapper:hover .ant-tree-checkbox::after {
+  visibility: visible;
+}
+.ant-tree-checkbox-inner {
+  position: relative;
+  top: 0;
+  left: 0;
+  display: block;
+  width: 16px;
+  height: 16px;
+  direction: ltr;
+  background-color: #fff;
+  border: 1px solid #d9d9d9;
+  border-radius: 2px;
+  border-collapse: separate;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.ant-tree-checkbox-inner::after {
+  position: absolute;
+  top: 50%;
+  left: 22%;
+  display: table;
+  width: 5.71428571px;
+  height: 9.14285714px;
+  border: 2px solid #fff;
+  border-top: 0;
+  border-left: 0;
+  -webkit-transform: rotate(45deg) scale(0) translate(-50%, -50%);
+          transform: rotate(45deg) scale(0) translate(-50%, -50%);
+  opacity: 0;
+  -webkit-transition: all 0.1s cubic-bezier(0.71, -0.46, 0.88, 0.6), opacity 0.1s;
+  transition: all 0.1s cubic-bezier(0.71, -0.46, 0.88, 0.6), opacity 0.1s;
+  content: ' ';
+}
+.ant-tree-checkbox-input {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1;
+  width: 100%;
+  height: 100%;
+  cursor: pointer;
+  opacity: 0;
+}
+.ant-tree-checkbox-checked .ant-tree-checkbox-inner::after {
+  position: absolute;
+  display: table;
+  border: 2px solid #fff;
+  border-top: 0;
+  border-left: 0;
+  -webkit-transform: rotate(45deg) scale(1) translate(-50%, -50%);
+          transform: rotate(45deg) scale(1) translate(-50%, -50%);
+  opacity: 1;
+  -webkit-transition: all 0.2s cubic-bezier(0.12, 0.4, 0.29, 1.46) 0.1s;
+  transition: all 0.2s cubic-bezier(0.12, 0.4, 0.29, 1.46) 0.1s;
+  content: ' ';
+}
+.ant-tree-checkbox-checked .ant-tree-checkbox-inner {
+  background-color: #1890ff;
+  border-color: #1890ff;
+}
+.ant-tree-checkbox-disabled {
+  cursor: not-allowed;
+}
+.ant-tree-checkbox-disabled.ant-tree-checkbox-checked .ant-tree-checkbox-inner::after {
+  border-color: rgba(0, 0, 0, 0.25);
+  -webkit-animation-name: none;
+          animation-name: none;
+}
+.ant-tree-checkbox-disabled .ant-tree-checkbox-input {
+  cursor: not-allowed;
+}
+.ant-tree-checkbox-disabled .ant-tree-checkbox-inner {
+  background-color: #f5f5f5;
+  border-color: #d9d9d9 !important;
+}
+.ant-tree-checkbox-disabled .ant-tree-checkbox-inner::after {
+  border-color: #f5f5f5;
+  border-collapse: separate;
+  -webkit-animation-name: none;
+          animation-name: none;
+}
+.ant-tree-checkbox-disabled + span {
+  color: rgba(0, 0, 0, 0.25);
+  cursor: not-allowed;
+}
+.ant-tree-checkbox-disabled:hover::after,
+.ant-tree-checkbox-wrapper:hover .ant-tree-checkbox-disabled::after {
+  visibility: hidden;
+}
+.ant-tree-checkbox-wrapper {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  display: inline-block;
+  line-height: unset;
+  cursor: pointer;
+}
+.ant-tree-checkbox-wrapper.ant-tree-checkbox-wrapper-disabled {
+  cursor: not-allowed;
+}
+.ant-tree-checkbox-wrapper + .ant-tree-checkbox-wrapper {
+  margin-left: 8px;
+}
+.ant-tree-checkbox + span {
+  padding-right: 8px;
+  padding-left: 8px;
+}
+.ant-tree-checkbox-group {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  display: inline-block;
+}
+.ant-tree-checkbox-group-item {
+  display: inline-block;
+  margin-right: 8px;
+}
+.ant-tree-checkbox-group-item:last-child {
+  margin-right: 0;
+}
+.ant-tree-checkbox-group-item + .ant-tree-checkbox-group-item {
+  margin-left: 0;
+}
+.ant-tree-checkbox-indeterminate .ant-tree-checkbox-inner {
+  background-color: #fff;
+  border-color: #d9d9d9;
+}
+.ant-tree-checkbox-indeterminate .ant-tree-checkbox-inner::after {
+  top: 50%;
+  left: 50%;
+  width: 8px;
+  height: 8px;
+  background-color: #1890ff;
+  border: 0;
+  -webkit-transform: translate(-50%, -50%) scale(1);
+          transform: translate(-50%, -50%) scale(1);
+  opacity: 1;
+  content: ' ';
+}
+.ant-tree-checkbox-indeterminate.ant-tree-checkbox-disabled .ant-tree-checkbox-inner::after {
+  background-color: rgba(0, 0, 0, 0.25);
+  border-color: rgba(0, 0, 0, 0.25);
+}
+.ant-tree {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  color: rgba(0, 0, 0, 0.65);
+  font-size: 14px;
+  font-variant: tabular-nums;
+  line-height: 1.5715;
+  list-style: none;
+  -webkit-font-feature-settings: 'tnum';
+          font-feature-settings: 'tnum';
+  background: #fff;
+  border-radius: 2px;
+  -webkit-transition: background-color 0.3s;
+  transition: background-color 0.3s;
+}
+.ant-tree-focused:not(:hover):not(.ant-tree-active-focused) {
+  background: #e6f7ff;
+}
+.ant-tree-list-holder-inner {
+  -webkit-box-align: start;
+      -ms-flex-align: start;
+          align-items: flex-start;
+}
+.ant-tree.ant-tree-block-node .ant-tree-list-holder-inner {
+  -webkit-box-align: stretch;
+      -ms-flex-align: stretch;
+          align-items: stretch;
+}
+.ant-tree.ant-tree-block-node .ant-tree-list-holder-inner .ant-tree-node-content-wrapper {
+  -webkit-box-flex: 1;
+      -ms-flex: auto;
+          flex: auto;
+}
+.ant-tree .ant-tree-treenode {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-align: start;
+      -ms-flex-align: start;
+          align-items: flex-start;
+  padding: 0 0 4px 0;
+  outline: none;
+}
+.ant-tree .ant-tree-treenode-disabled .ant-tree-node-content-wrapper {
+  color: rgba(0, 0, 0, 0.25);
+  cursor: not-allowed;
+}
+.ant-tree .ant-tree-treenode-disabled .ant-tree-node-content-wrapper:hover {
+  background: transparent;
+}
+.ant-tree .ant-tree-treenode-active .ant-tree-node-content-wrapper {
+  background: #f5f5f5;
+}
+.ant-tree-indent {
+  -ms-flex-item-align: stretch;
+      align-self: stretch;
+  white-space: nowrap;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+}
+.ant-tree-indent-unit {
+  display: inline-block;
+  width: 24px;
+}
+.ant-tree .ant-tree-switcher {
+  -webkit-box-flex: 0;
+      -ms-flex: none;
+          flex: none;
+  width: 24px;
+  height: 24px;
+  margin: 0;
+  line-height: 24px;
+  text-align: center;
+  cursor: pointer;
+}
+.ant-tree .ant-tree-switcher .ant-tree-switcher-icon,
+.ant-tree .ant-tree-switcher .ant-select-tree-switcher-icon {
+  font-size: 10px;
+  display: inline-block;
+  font-weight: bold;
+}
+.ant-tree .ant-tree-switcher .ant-tree-switcher-icon svg,
+.ant-tree .ant-tree-switcher .ant-select-tree-switcher-icon svg {
+  -webkit-transition: -webkit-transform 0.3s;
+  transition: -webkit-transform 0.3s;
+  transition: transform 0.3s;
+  transition: transform 0.3s, -webkit-transform 0.3s;
+}
+.ant-tree .ant-tree-switcher-noop {
+  cursor: default;
+}
+.ant-tree .ant-tree-switcher_close .ant-tree-switcher-icon svg {
+  -webkit-transform: rotate(-90deg);
+          transform: rotate(-90deg);
+}
+.ant-tree .ant-tree-checkbox {
+  top: initial;
+  margin: 4px 8px 0 0;
+}
+.ant-tree .ant-tree-node-content-wrapper {
+  min-height: 24px;
+  margin: 0;
+  padding: 0 4px;
+  color: inherit;
+  line-height: 24px;
+  background: transparent;
+  border-radius: 2px;
+  cursor: pointer;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.ant-tree .ant-tree-node-content-wrapper:hover {
+  background-color: #f5f5f5;
+}
+.ant-tree .ant-tree-node-content-wrapper.ant-tree-node-selected {
+  background-color: #bae7ff;
+}
+.ant-tree .ant-tree-node-content-wrapper .ant-tree-iconEle {
+  display: inline-block;
+  width: 24px;
+  height: 24px;
+  line-height: 24px;
+  text-align: center;
+  vertical-align: top;
+}
+.ant-tree .ant-tree-node-content-wrapper .ant-tree-iconEle:empty {
+  display: none;
+}
+.ant-tree .ant-tree-treenode-loading .ant-tree-iconEle {
+  display: none;
+}
+.ant-tree-node-content-wrapper[draggable='true'] {
+  line-height: 20px;
+  border-top: 2px transparent solid;
+  border-bottom: 2px transparent solid;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+}
+.ant-tree .ant-tree-treenode.drag-over > [draggable] {
+  color: white;
+  background-color: #1890ff;
+  opacity: 0.8;
+}
+.ant-tree .ant-tree-treenode.drag-over-gap-top > [draggable] {
+  border-top-color: #1890ff;
+}
+.ant-tree .ant-tree-treenode.drag-over-gap-bottom > [draggable] {
+  border-bottom-color: #1890ff;
+}
+.ant-tree-show-line {
+  /* Motion should hide line of measure */
+}
+.ant-tree-show-line .ant-tree-indent-unit {
+  position: relative;
+  height: 100%;
+}
+.ant-tree-show-line .ant-tree-indent-unit::before {
+  position: absolute;
+  top: calc(100% - 4px);
+  right: -12px;
+  bottom: -28px;
+  border-right: 1px solid #d9d9d9;
+  content: '';
+}
+.ant-tree-show-line .ant-tree-indent-unit-end::before {
+  display: none;
+}
+.ant-tree-show-line .ant-tree-treenode-motion:not(.ant-motion-collapse-leave):not(.ant-motion-collapse-appear-active) .ant-tree-indent-unit::before {
+  display: none;
+}
+.ant-tree-show-line .ant-tree-switcher {
+  z-index: 1;
+  background: #fff;
+}
+.ant-tree-rtl {
+  direction: rtl;
+}
+.ant-tree .ant-tree-treenode-rtl {
+  direction: rtl;
+}
+.ant-tree-rtl.ant-tree .ant-tree-switcher_close .ant-tree-switcher-icon svg {
+  -webkit-transform: rotate(90deg);
+          transform: rotate(90deg);
+}
+.ant-tree-rtl.ant-tree-show-line .ant-tree-indent-unit::before {
+  right: auto;
+  left: -12px;
+  border-right: none;
+  border-left: 1px solid #d9d9d9;
+}

web/node_modules/antd/lib/tree/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

web/node_modules/antd/lib/tree/style/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+require("../../style/index.less");
+
+require("./index.less");

web/node_modules/antd/lib/tree/style/index.less

@@ -0,0 +1,219 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import '../../checkbox/style/mixin';
+@import './mixin';
+@import './directory';
+
+@tree-prefix-cls: ~'@{ant-prefix}-tree';
+@tree-node-prefix-cls: ~'@{tree-prefix-cls}-treenode';
+@tree-motion: ~'@{ant-prefix}-motion-collapse';
+
+.antCheckboxFn(@checkbox-prefix-cls: ~'@{ant-prefix}-tree-checkbox');
+
+.antTreeFn(@tree-prefix-cls) {
+  .@{tree-prefix-cls} {
+    .reset-component;
+    background: @tree-bg;
+    border-radius: @border-radius-base;
+    transition: background-color 0.3s;
+
+    &-focused:not(:hover):not(&-active-focused) {
+      background: @primary-1;
+    }
+
+    // =================== Virtual List ===================
+    &-list-holder-inner {
+      align-items: flex-start;
+    }
+
+    &.@{tree-prefix-cls}-block-node {
+      .@{tree-prefix-cls}-list-holder-inner {
+        align-items: stretch;
+
+        // >>> Title
+        .@{tree-prefix-cls}-node-content-wrapper {
+          flex: auto;
+        }
+      }
+    }
+
+    // ===================== TreeNode =====================
+    .@{tree-node-prefix-cls} {
+      display: flex;
+      align-items: flex-start;
+      padding: 0 0 (@padding-xs / 2) 0;
+      outline: none;
+      // Disabled
+      &-disabled {
+        // >>> Title
+        .@{tree-prefix-cls}-node-content-wrapper {
+          color: @disabled-color;
+          cursor: not-allowed;
+
+          &:hover {
+            background: transparent;
+          }
+        }
+      }
+
+      &-active .@{tree-prefix-cls}-node-content-wrapper {
+        background: @tree-node-hover-bg;
+      }
+    }
+
+    // >>> Indent
+    &-indent {
+      align-self: stretch;
+      white-space: nowrap;
+      user-select: none;
+
+      &-unit {
+        display: inline-block;
+        width: @tree-title-height;
+      }
+    }
+
+    // >>> Switcher
+    & &-switcher {
+      .antTreeSwitcherIcon();
+      flex: none;
+
+      width: @tree-title-height;
+      height: @tree-title-height;
+      margin: 0;
+      line-height: @tree-title-height;
+      text-align: center;
+      cursor: pointer;
+
+      &-noop {
+        cursor: default;
+      }
+
+      &_close {
+        .@{tree-prefix-cls}-switcher-icon {
+          svg {
+            transform: rotate(-90deg);
+          }
+        }
+      }
+    }
+
+    // >>> Checkbox
+    & &-checkbox {
+      top: initial;
+      margin: ((@tree-title-height - @checkbox-size) / 2) 8px 0 0;
+    }
+
+    // >>> Title
+    & &-node-content-wrapper {
+      min-height: @tree-title-height;
+      margin: 0;
+      padding: 0 4px;
+      color: inherit;
+      line-height: @tree-title-height;
+      background: transparent;
+      border-radius: @border-radius-base;
+      cursor: pointer;
+      transition: all 0.3s;
+
+      &:hover {
+        background-color: @tree-node-hover-bg;
+      }
+      &.@{tree-prefix-cls}-node-selected {
+        background-color: @tree-node-selected-bg;
+      }
+
+      // Icon
+      .@{tree-prefix-cls}-iconEle {
+        display: inline-block;
+        width: @tree-title-height;
+        height: @tree-title-height;
+        line-height: @tree-title-height;
+        text-align: center;
+        vertical-align: top;
+        &:empty {
+          display: none;
+        }
+      }
+    }
+
+    // ===================== Loading ======================
+    .@{tree-node-prefix-cls}-loading {
+      // Icon
+      .@{tree-prefix-cls}-iconEle {
+        display: none;
+      }
+    }
+
+    // ==================== Draggable =====================
+    &-node-content-wrapper[draggable='true'] {
+      line-height: @tree-title-height - 4px;
+      border-top: 2px transparent solid;
+      border-bottom: 2px transparent solid;
+      user-select: none;
+    }
+
+    .@{tree-node-prefix-cls}.drag-over {
+      > [draggable] {
+        color: white;
+        background-color: @primary-color;
+        opacity: 0.8;
+      }
+    }
+    .@{tree-node-prefix-cls}.drag-over-gap-top {
+      > [draggable] {
+        border-top-color: @primary-color;
+      }
+    }
+    .@{tree-node-prefix-cls}.drag-over-gap-bottom {
+      > [draggable] {
+        border-bottom-color: @primary-color;
+      }
+    }
+
+    // ==================== Show Line =====================
+    &-show-line {
+      // ================ Indent lines ================
+      .@{tree-prefix-cls}-indent {
+        &-unit {
+          position: relative;
+          height: 100%;
+
+          &::before {
+            position: absolute;
+            top: calc(100% - 4px);
+            right: -@tree-title-height / 2;
+            bottom: -@tree-title-height - 4px;
+            border-right: 1px solid @border-color-base;
+            content: '';
+          }
+
+          &-end {
+            &::before {
+              display: none;
+            }
+          }
+        }
+      }
+
+      /* Motion should hide line of measure */
+      .@{tree-node-prefix-cls}-motion:not(.@{tree-motion}-leave):not(.@{tree-motion}-appear-active) {
+        .@{tree-prefix-cls}-indent-unit {
+          &::before {
+            display: none;
+          }
+        }
+      }
+
+      // ============== Cover Background ==============
+      .@{tree-prefix-cls}-switcher {
+        z-index: 1;
+        background: @component-background;
+      }
+    }
+  }
+}
+
+.antTreeFn(@tree-prefix-cls);
+
+@import './rtl';

web/node_modules/antd/lib/tree/style/mixin.less

@@ -0,0 +1,29 @@
+@import '../../style/mixins/index';
+
+@tree-prefix-cls: ~'@{ant-prefix}-tree';
+@select-tree-prefix-cls: ~'@{ant-prefix}-select-tree';
+
+.antTreeSwitcherIcon(@type: 'tree-default-open-icon') {
+  .@{tree-prefix-cls}-switcher-icon,
+  .@{select-tree-prefix-cls}-switcher-icon {
+    .iconfont-size-under-12px(10px);
+
+    display: inline-block;
+    font-weight: bold;
+    svg {
+      transition: transform 0.3s;
+    }
+  }
+}
+
+.antTreeShowLineIcon(@type) {
+  .@{tree-prefix-cls}-switcher-icon,
+  .@{tree-select-prefix-cls}-switcher-icon {
+    display: inline-block;
+    font-weight: normal;
+    font-size: 12px;
+    svg {
+      transition: transform 0.3s;
+    }
+  }
+}

web/node_modules/antd/lib/tree/style/rtl.less

@@ -0,0 +1,50 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import '../../checkbox/style/mixin';
+
+@tree-prefix-cls: ~'@{ant-prefix}-tree';
+@tree-node-prefix-cls: ~'@{tree-prefix-cls}-treenode';
+
+.antTreeFn(@tree-prefix-cls) {
+  .@{tree-prefix-cls} {
+    &-rtl {
+      direction: rtl;
+    }
+
+    // ===================== TreeNode =====================
+    .@{tree-node-prefix-cls} {
+      &-rtl {
+        direction: rtl;
+      }
+    }
+
+    // >>> Switcher
+    & &-switcher {
+      &_close {
+        .@{tree-prefix-cls}-switcher-icon {
+          svg {
+            .@{tree-prefix-cls}-rtl& {
+              transform: rotate(90deg);
+            }
+          }
+        }
+      }
+    }
+    // ==================== Show Line =====================
+    &-show-line {
+      // ================ Indent lines ================
+      .@{tree-prefix-cls}-indent {
+        &-unit {
+          &::before {
+            .@{tree-prefix-cls}-rtl& {
+              right: auto;
+              left: -@tree-title-height / 2;
+              border-right: none;
+              border-left: 1px solid @border-color-base;
+            }
+          }
+        }
+      }
+    }
+  }
+}

web/node_modules/antd/lib/tree/utils/dictUtil.d.ts

@@ -0,0 +1,4 @@
+import { DataNode, Key } from 'rc-tree/lib/interface';
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+export declare function calcRangeKeys(treeData: DataNode[], expandedKeys: Key[], startKey?: Key, endKey?: Key): Key[];
+export declare function convertDirectoryKeysToNodes(treeData: DataNode[], keys: Key[]): DataNode[];

web/node_modules/antd/lib/tree/utils/dictUtil.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcRangeKeys = calcRangeKeys;
+exports.convertDirectoryKeysToNodes = convertDirectoryKeysToNodes;
+
+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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) 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; }
+
+var Record;
+
+(function (Record) {
+  Record[Record["None"] = 0] = "None";
+  Record[Record["Start"] = 1] = "Start";
+  Record[Record["End"] = 2] = "End";
+})(Record || (Record = {}));
+
+function traverseNodesKey(treeData, callback) {
+  function processNode(dataNode) {
+    var key = dataNode.key,
+        children = dataNode.children;
+
+    if (callback(key, dataNode) !== false) {
+      traverseNodesKey(children || [], callback);
+    }
+  }
+
+  treeData.forEach(processNode);
+}
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+
+
+function calcRangeKeys(treeData, expandedKeys, startKey, endKey) {
+  var keys = [];
+  var record = Record.None;
+
+  if (startKey && startKey === endKey) {
+    return [startKey];
+  }
+
+  if (!startKey || !endKey) {
+    return [];
+  }
+
+  function matchKey(key) {
+    return key === startKey || key === endKey;
+  }
+
+  traverseNodesKey(treeData, function (key) {
+    if (record === Record.End) {
+      return false;
+    }
+
+    if (matchKey(key)) {
+      // Match test
+      keys.push(key);
+
+      if (record === Record.None) {
+        record = Record.Start;
+      } else if (record === Record.Start) {
+        record = Record.End;
+        return false;
+      }
+    } else if (record === Record.Start) {
+      // Append selection
+      keys.push(key);
+    }
+
+    if (expandedKeys.indexOf(key) === -1) {
+      return false;
+    }
+
+    return true;
+  });
+  return keys;
+}
+
+function convertDirectoryKeysToNodes(treeData, keys) {
+  var restKeys = _toConsumableArray(keys);
+
+  var nodes = [];
+  traverseNodesKey(treeData, function (key, node) {
+    var index = restKeys.indexOf(key);
+
+    if (index !== -1) {
+      nodes.push(node);
+      restKeys.splice(index, 1);
+    }
+
+    return !!restKeys.length;
+  });
+  return nodes;
+}

web/node_modules/antd/lib/tree/utils/iconUtil.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { AntTreeNodeProps } from '../Tree';
+export default function renderSwitcherIcon(prefixCls: string, switcherIcon: React.ReactNode | null | undefined, showLine: boolean | undefined, { isLeaf, expanded, loading }: AntTreeNodeProps): {} | null;

web/node_modules/antd/lib/tree/utils/iconUtil.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = renderSwitcherIcon;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _LoadingOutlined = _interopRequireDefault(require("@ant-design/icons/LoadingOutlined"));
+
+var _FileOutlined = _interopRequireDefault(require("@ant-design/icons/FileOutlined"));
+
+var _MinusSquareOutlined = _interopRequireDefault(require("@ant-design/icons/MinusSquareOutlined"));
+
+var _PlusSquareOutlined = _interopRequireDefault(require("@ant-design/icons/PlusSquareOutlined"));
+
+var _CaretDownFilled = _interopRequireDefault(require("@ant-design/icons/CaretDownFilled"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function renderSwitcherIcon(prefixCls, switcherIcon, showLine, _ref) {
+  var isLeaf = _ref.isLeaf,
+      expanded = _ref.expanded,
+      loading = _ref.loading;
+
+  if (loading) {
+    return /*#__PURE__*/_react["default"].createElement(_LoadingOutlined["default"], {
+      className: "".concat(prefixCls, "-switcher-loading-icon")
+    });
+  }
+
+  if (isLeaf) {
+    return showLine ? /*#__PURE__*/_react["default"].createElement(_FileOutlined["default"], {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    }) : null;
+  }
+
+  var switcherCls = "".concat(prefixCls, "-switcher-icon");
+
+  if (_react["default"].isValidElement(switcherIcon)) {
+    return _react["default"].cloneElement(switcherIcon, {
+      className: (0, _classnames["default"])(switcherIcon.props.className || '', switcherCls)
+    });
+  }
+
+  if (switcherIcon) {
+    return switcherIcon;
+  }
+
+  if (showLine) {
+    return expanded ? /*#__PURE__*/_react["default"].createElement(_MinusSquareOutlined["default"], {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    }) : /*#__PURE__*/_react["default"].createElement(_PlusSquareOutlined["default"], {
+      className: "".concat(prefixCls, "-switcher-line-icon")
+    });
+  }
+
+  return /*#__PURE__*/_react["default"].createElement(_CaretDownFilled["default"], {
+    className: switcherCls
+  });
+}