Latest updates from IceHrmPro

web/node_modules/rc-tree/HISTORY.md

@@ -0,0 +1,78 @@
+# History
+---
+
+## 2.1.0 / 2019-04-28
+
+- TreeNode support `checkable`.
+
+## 2.0.0 / 2019-04-26
+
+- Remove old animation api and use `motion` instead.
+
+## 1.11.5 / 2018-04-19
+- add `onClick` & `onDoubleClick` for node click event
+- add related className in treeNode
+- fix drag into another tree will throw exception
+
+## 1.10.0 / 2018-04-17
+- `onCheck` arguments provide nativeEvent
+- `onSelect` arguments provide nativeEvent
+- `onExpand` arguments provide nativeEvent
+
+## 1.9.0 / 2018-04-09
+- adjust `dragable` logic to make drag more smooth
+- fix `loadData` trigger twice when expand node
+- add `icon` prop on `Tree`
+- fix check by prop not work on `disabled` node
+
+
+## 1.8.0 / 2018-03-29
+- code refactor and optimize logic
+- add `disabled` API
+- add `icon` API
+
+## 1.4.0 / 2016-10-24
+- add `onDragEnd` API and fix related issues.
+
+## 1.3.0 / 2016-04-15
+- make `autoExpandParent` also work in controlled mode.(Before just work in uncontrolled mode)
+- change `onExpand` params
+    - old: function(node, expanded, expandedKeys)
+    - new: function(expandedKeys, {expanded: bool, node})
+
+## 1.2.1 / 2016-04-08
+- remove `halfCheckedKeys` api, and change `checkedKeys` to an object on setting `checkStrictly`.
+
+## 1.2.0 / 2016-04-06
+- improve performance.
+- add `checkStrictly`/`halfCheckedKeys` api.
+
+## 1.1.0 / 2016-01-25
+- change `onDrop` params (from `originExpandedKeys` to `rawExpandedKeys`)
+
+## 1.0.x / 2016-01-15
+- change `onSelect`/`onCheck` params
+
+## 0.26.x / 2016-01-13
+- change drag api (from `onTreeXX` to `onXX`)
+
+## 0.23.x / 2015-12-31
+- change `onDataLoaded` api to `loadData`
+
+## 0.22.x / 2015-12-30
+- add `expandedKeys`/`onExpand`/`filterTreeNode` api
+
+## 0.21.x / 2015-12-25
+- add `onMouseEnter`/`onMouseLeave` api
+
+## 0.20.0 / 2015-12-01
+- add draggable feature #5
+
+## 0.18.0 / 2015-10-23
+- add contextmenu feature #5
+
+## 0.17.0 / 2015-10-14
+- add dynamic feature #4
+
+## 0.9.5 / 2015-05-26
+- support checkbox

web/node_modules/rc-tree/LICENSE.md

@@ -0,0 +1,22 @@
+MIT LICENSE
+
+Copyright (c) 2015-present Alipay.com, https://www.alipay.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

web/node_modules/rc-tree/README.md

@@ -0,0 +1,137 @@
+# rc-tree
+
+---
+
+tree ui component for react
+
+[![NPM version][npm-image]][npm-url] [![build status][travis-image]][travis-url] [![Test coverage][codecov-image]][codecov-url] [![gemnasium deps][gemnasium-image]][gemnasium-url] [![npm download][download-image]][download-url]
+
+[npm-image]: http://img.shields.io/npm/v/rc-tree.svg?style=flat-square
+[npm-url]: http://npmjs.org/package/rc-tree
+[travis-image]: https://img.shields.io/travis/react-component/tree.svg?style=flat-square
+[travis-url]: https://travis-ci.org/react-component/tree
+[codecov-image]: https://img.shields.io/codecov/c/github/react-component/tree/master.svg?style=flat-square
+[codecov-url]: https://codecov.io/gh/react-component/tree/branch/master
+[gemnasium-image]: http://img.shields.io/gemnasium/react-component/tree.svg?style=flat-square
+[gemnasium-url]: https://gemnasium.com/react-component/tree
+[node-image]: https://img.shields.io/badge/node.js-%3E=_0.10-green.svg?style=flat-square
+[node-url]: http://nodejs.org/download/
+[download-image]: https://img.shields.io/npm/dm/rc-tree.svg?style=flat-square
+[download-url]: https://npmjs.org/package/rc-tree
+
+## Screenshots
+
+<img src="https://t.alipayobjects.com/images/T15BpfXn8nXXXXXXXX.png" width="288"/>
+
+## Feature
+
+- Support all popular browsers, including Internet Explorer 9 and above.
+
+## Example
+
+http://localhost:9001/
+
+online example: http://react-component.github.io/tree/
+
+## install
+
+[![rc-tree](https://nodei.co/npm/rc-tree.png)](https://npmjs.org/package/rc-tree)
+
+## Usage
+
+see examples
+
+## API
+
+### Tree props
+
+| name | description | type | default |
+| --- | --- | --- | --- |
+| autoExpandParent | whether auto expand parent treeNodes | bool | false |
+| checkable | whether support checked | bool/React Node | false |
+| checkedKeys | Controlled checked treeNodes(After setting, defaultCheckedKeys will not work). Note: parent and children nodes are associated, if the parent node's key exists, it all children node will be checked, and vice versa. When set checkable and checkStrictly, it should be an object, which contains checked array and halfChecked array. | String[]/{checked:Array<String>,halfChecked:Array<String>} | [] |
+| checkStrictly | check node precisely, parent and children nodes are not associated | bool | false |
+| className | additional css class of root dom node | String | '' |
+| defaultCheckedKeys | default checked treeNodes | String[] | [] |
+| defaultExpandedKeys | expand specific treeNodes | String[] | - |
+| defaultExpandAll | expand all treeNodes | bool | false |
+| defaultExpandParent | auto expand parent treeNodes when init | bool | true |
+| defaultSelectedKeys | default selected treeNodes | String[] | [] |
+| disabled | whether disabled the tree | bool | false |
+| draggable | whether can drag treeNode. (drag events are not supported in Internet Explorer 8 and earlier versions or Safari 5.1 and earlier versions.) | bool | false |
+| expandedKeys | Controlled expand specific treeNodes | String[] | - |
+| filterTreeNode | filter some treeNodes as you need. it should return true | function(node) | - |
+| icon | customize icon. When you pass component, whose render will receive full TreeNode props as component props | element/Function(props) | - |
+| loadedKeys | Mark node is loaded when `loadData` is true | string[] | - |
+| loadData | load data asynchronously and the return value should be a promise | function(node) | - |
+| multiple | whether multiple select | bool | false |
+| prefixCls | prefix class | String | 'rc-tree' |
+| selectable | whether can be selected | bool | true |
+| selectedKeys | Controlled selected treeNodes(After setting, defaultSelectedKeys will not work) | String[] | [] |
+| showIcon | whether show icon | bool | true |
+| showLine | whether show line | bool | false |
+| treeData | treeNodes data Array, if set it then you need not to construct children TreeNode. (value should be unique across the whole array) | array<{key,title,children, [disabled, selectable]}> | - |
+| onCheck | click the treeNode/checkbox to fire | function(checkedKeys, e:{checked: bool, checkedNodes, node, event, nativeEvent}) | - |
+| onExpand | fire on treeNode expand or not | function(expandedKeys, {expanded: bool, node, nativeEvent}) | - |
+| onDragEnd | it execs when fire the tree's dragend event | function({event,node}) | - |
+| onDragEnter | it execs when fire the tree's dragenter event | function({event,node,expandedKeys}) | - |
+| onDragLeave | it execs when fire the tree's dragleave event | function({event,node}) | - |
+| onDragOver | it execs when fire the tree's dragover event | function({event,node}) | - |
+| onDragStart | it execs when fire the tree's dragstart event | function({event,node}) | - |
+| onDrop | it execs when fire the tree's drop event | function({event, node, dragNode, dragNodesKeys}) | - |
+| onLoad | Trigger when a node is loaded. If you set the `loadedKeys`, you must handle `onLoad` to avoid infinity loop | function(loadedKeys, {event, node}) | - |
+| onMouseEnter | call when mouse enter a treeNode | function({event,node}) | - |
+| onMouseLeave | call when mouse leave a treeNode | function({event,node}) | - |
+| onRightClick | select current treeNode and show customized contextmenu | function({event,node}) | - |
+| onSelect | click the treeNode to fire | function(selectedKeys, e:{selected: bool, selectedNodes, node, event, nativeEvent}) | - |
+| switcherIcon | specific the switcher icon. | ReactNode / (props: TreeNodeAttribute) => ReactNode | - |
+| virtual | Disable virtual scroll when `false` | boolean | - |
+
+### TreeNode props
+
+> note: if you have a lot of TreeNode, like more than 1000,  
+> make the parent node is collapsed by default, will obvious effect, very fast.  
+> Because the children hide TreeNode will not insert into dom.
+
+| name | description | type | default |
+| --- | --- | --- | --- |
+| className | additional class to treeNode | String | '' |
+| checkable | control node checkable if Tree is checkable | bool | - |
+| style | set style to treeNode | Object | '' |
+| disabled | whether disabled the treeNode | bool | false |
+| disableCheckbox | whether disable the treeNode' checkbox | bool | false |
+| title | tree/subTree's title | String/element/((data: DataNode) => React.ReactNode) | '---' |
+| key | it's used with tree props's (default)ExpandedKeys / (default)CheckedKeys / (default)SelectedKeys. you'd better to set it, and it must be unique in the tree's all treeNodes | String | treeNode's position |
+| isLeaf | whether it's leaf node | bool | false |
+| icon | customize icon. When you pass component, whose render will receive full TreeNode props as component props | element/Function(props) | - |
+| switcherIcon | specific the switcher icon. | ReactNode / (props: TreeNodeAttribute) => ReactNode | - |
+
+## note
+
+The number of treeNodes can be very large, but when enable `checkable`, it will spend more computing time, so we cached some calculations(e.g. `this.treeNodesStates`), to avoid double computing. But, this bring some restrictions, **when you async load treeNodes, you should render tree like this** `{this.state.treeData.length ? <Tree ...>{this.state.treeData.map(t => <TreeNode ... />)}</Tree> : 'loading tree'}`
+
+## Development
+
+```bash
+npm install
+npm start
+```
+
+## Test Case
+
+http://localhost:8018/tests/runner.html?coverage
+
+## Coverage
+
+http://localhost:8018/node_modules/rc-server/node_modules/node-jscover/lib/front-end/jscoverage.html?w=http://localhost:8018/tests/runner.html?coverage
+
+## License
+
+rc-tree is released under the MIT license.
+
+## other tree view
+
+- [ztree](http://www.ztree.me/)
+- [jqTree](http://mbraak.github.io/jqTree/)
+- [jquery.treeselect](http://travistidwell.com/jquery.treeselect.js/)
+- [angular Select Tree](http://a5hik.github.io/angular-multi-select-tree/)

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;
+}

web/node_modules/rc-tree/lib/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/lib/Indent.js

@@ -0,0 +1,51 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+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 _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; }
+
+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: (0, _classnames.default)(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);
+};
+
+var _default = Indent;
+exports.default = _default;

web/node_modules/rc-tree/lib/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/lib/MotionTreeNode.js

@@ -0,0 +1,112 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _CSSMotion = _interopRequireDefault(require("rc-animate/lib/CSSMotion"));
+
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+
+var _treeUtil = require("./utils/treeUtil");
+
+var _contextTypes = require("./contextTypes");
+
+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 _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; }
+
+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(_contextTypes.TreeContext),
+      prefixCls = _React$useContext.prefixCls;
+
+  React.useEffect(function () {
+    if (motionNodes && motionType === 'hide' && visible) {
+      setVisible(false);
+    }
+  }, [motionNodes]);
+
+  if (motionNodes) {
+    return React.createElement(_CSSMotion.default, 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: (0, _classnames.default)("".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 = (0, _treeUtil.getTreeNodeProps)(key, treeNodeRequiredProps);
+        return React.createElement(_TreeNode.default, Object.assign({}, restProps, treeNodeProps, {
+          active: active,
+          data: treeNode.data,
+          key: key,
+          isStart: isStart,
+          isEnd: isEnd
+        }));
+      }));
+    });
+  }
+
+  return React.createElement(_TreeNode.default, Object.assign({
+    domRef: ref,
+    className: className,
+    style: style
+  }, props, {
+    active: active
+  }));
+};
+
+MotionTreeNode.displayName = 'MotionTreeNode';
+var RefMotionTreeNode = React.forwardRef(MotionTreeNode);
+var _default = RefMotionTreeNode;
+exports.default = _default;

web/node_modules/rc-tree/lib/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/lib/NodeList.js

@@ -0,0 +1,300 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMinimumRangeTransitionRange = getMinimumRangeTransitionRange;
+exports.default = exports.MotionEntity = exports.MOTION_KEY = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _rcVirtualList = _interopRequireDefault(require("rc-virtual-list"));
+
+var _MotionTreeNode = _interopRequireDefault(require("./MotionTreeNode"));
+
+var _diffUtil = require("./utils/diffUtil");
+
+var _treeUtil = require("./utils/treeUtil");
+
+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 _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; }
+
+var HIDDEN_STYLE = {
+  width: 0,
+  height: 0,
+  display: 'flex',
+  overflow: 'hidden',
+  opacity: 0,
+  border: 0,
+  padding: 0,
+  margin: 0
+};
+
+var noop = function noop() {};
+
+var MOTION_KEY = "RC_TREE_MOTION_".concat(Math.random());
+exports.MOTION_KEY = MOTION_KEY;
+var MotionNode = {
+  key: MOTION_KEY
+};
+var MotionEntity = {
+  key: MOTION_KEY,
+  level: 0,
+  index: 0,
+  pos: '0',
+  node: MotionNode
+};
+exports.MotionEntity = MotionEntity;
+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.
+ */
+
+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 (0, _treeUtil.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 = (0, _diffUtil.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((0, _diffUtil.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((0, _diffUtil.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(_rcVirtualList.default, 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 = (0, _treeUtil.getKey)(key, pos);
+    delete restProps.children;
+    var treeNodeProps = (0, _treeUtil.getTreeNodeProps)(mergedKey, treeNodeRequiredProps);
+    return React.createElement(_MotionTreeNode.default, 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';
+var _default = NodeList;
+exports.default = _default;

web/node_modules/rc-tree/lib/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/lib/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/lib/TreeNode.js

@@ -0,0 +1,500 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.InternalTreeNode = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _reactLifecyclesCompat = require("react-lifecycles-compat");
+
+var _contextTypes = require("./contextTypes");
+
+var _util = require("./util");
+
+var _Indent = _interopRequireDefault(require("./Indent"));
+
+var _treeUtil = require("./utils/treeUtil");
+
+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 _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); }
+
+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, (0, _treeUtil.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, (0, _treeUtil.convertNodePropsToEventData)(_this.props));
+    };
+
+    _this.onSelect = function (e) {
+      if (_this.isDisabled()) return;
+      var onNodeSelect = _this.props.context.onNodeSelect;
+      e.preventDefault();
+      onNodeSelect(e, (0, _treeUtil.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, (0, _treeUtil.convertNodePropsToEventData)(_this.props), targetChecked);
+    };
+
+    _this.onMouseEnter = function (e) {
+      var onNodeMouseEnter = _this.props.context.onNodeMouseEnter;
+      onNodeMouseEnter(e, (0, _treeUtil.convertNodePropsToEventData)(_this.props));
+    };
+
+    _this.onMouseLeave = function (e) {
+      var onNodeMouseLeave = _this.props.context.onNodeMouseLeave;
+      onNodeMouseLeave(e, (0, _treeUtil.convertNodePropsToEventData)(_this.props));
+    };
+
+    _this.onContextMenu = function (e) {
+      var onNodeContextMenu = _this.props.context.onNodeContextMenu;
+      onNodeContextMenu(e, (0, _treeUtil.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, (0, _treeUtil.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((0, _treeUtil.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: (0, _classnames.default)("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher-noop"))
+        }, typeof switcherIcon === 'function' ? switcherIcon(_objectSpread({}, _this.props, {
+          isLeaf: true
+        })) : switcherIcon);
+      }
+
+      var switcherCls = (0, _classnames.default)("".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: (0, _classnames.default)("".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: (0, _classnames.default)("".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: (0, _classnames.default)("".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: (0, _classnames.default)("".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 = (0, _util.getDataAndAria)(otherProps);
+
+      var _ref2 = keyEntities[eventKey] || {},
+          level = _ref2.level;
+
+      return React.createElement("div", Object.assign({
+        ref: domRef,
+        className: (0, _classnames.default)(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((0, _treeUtil.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.default, {
+        prefixCls: prefixCls,
+        level: level,
+        isStart: isStart,
+        isEnd: isEnd
+      }), this.renderSwitcher(), this.renderCheckbox(), this.renderSelector());
+    }
+  }]);
+
+  return InternalTreeNode;
+}(React.Component);
+
+exports.InternalTreeNode = InternalTreeNode;
+InternalTreeNode.propTypes = {
+  prefixCls: _propTypes.default.string,
+  className: _propTypes.default.string,
+  style: _propTypes.default.object,
+  onSelect: _propTypes.default.func,
+  // By parent
+  eventKey: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
+  expanded: _propTypes.default.bool,
+  selected: _propTypes.default.bool,
+  checked: _propTypes.default.bool,
+  loaded: _propTypes.default.bool,
+  loading: _propTypes.default.bool,
+  halfChecked: _propTypes.default.bool,
+  title: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func]),
+  dragOver: _propTypes.default.bool,
+  dragOverGapTop: _propTypes.default.bool,
+  dragOverGapBottom: _propTypes.default.bool,
+  pos: _propTypes.default.string,
+  // By user
+  isLeaf: _propTypes.default.bool,
+  checkable: _propTypes.default.bool,
+  selectable: _propTypes.default.bool,
+  disabled: _propTypes.default.bool,
+  disableCheckbox: _propTypes.default.bool,
+  icon: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func]),
+  switcherIcon: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func])
+};
+(0, _reactLifecyclesCompat.polyfill)(InternalTreeNode);
+
+var ContextTreeNode = function ContextTreeNode(props) {
+  return React.createElement(_contextTypes.TreeContext.Consumer, null, function (context) {
+    return React.createElement(InternalTreeNode, Object.assign({}, props, {
+      context: context
+    }));
+  });
+};
+
+ContextTreeNode.displayName = 'TreeNode';
+ContextTreeNode.defaultProps = {
+  title: defaultTitle
+};
+ContextTreeNode.isTreeNode = 1;
+var _default = ContextTreeNode;
+exports.default = _default;

web/node_modules/rc-tree/lib/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/lib/contextTypes.js

@@ -0,0 +1,21 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreeContext = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+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; }
+
+/**
+ * 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.
+ */
+var TreeContext = React.createContext(null);
+exports.TreeContext = TreeContext;

web/node_modules/rc-tree/lib/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/lib/index.js

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

web/node_modules/rc-tree/lib/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/lib/interface.js

@@ -0,0 +1 @@
+"use strict";

web/node_modules/rc-tree/lib/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/lib/util.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrDel = arrDel;
+exports.arrAdd = arrAdd;
+exports.posToArr = posToArr;
+exports.getPosition = getPosition;
+exports.isTreeNode = isTreeNode;
+exports.getDragNodesKeys = getDragNodesKeys;
+exports.calcDropPosition = calcDropPosition;
+exports.calcSelectedKeys = calcSelectedKeys;
+exports.convertDataToTree = convertDataToTree;
+exports.parseCheckedKeys = parseCheckedKeys;
+exports.conductExpandParent = conductExpandParent;
+exports.getDataAndAria = getDataAndAria;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+var DRAG_SIDE_RANGE = 0.25;
+var DRAG_MIN_GAP = 2;
+
+function arrDel(list, value) {
+  var clone = list.slice();
+  var index = clone.indexOf(value);
+
+  if (index >= 0) {
+    clone.splice(index, 1);
+  }
+
+  return clone;
+}
+
+function arrAdd(list, value) {
+  var clone = list.slice();
+
+  if (clone.indexOf(value) === -1) {
+    clone.push(value);
+  }
+
+  return clone;
+}
+
+function posToArr(pos) {
+  return pos.split('-');
+}
+
+function getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
+}
+
+function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+
+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.
+
+
+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]
+ */
+
+
+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;
+};
+
+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.default.createElement(_TreeNode.default, Object.assign({}, processProps(props)), childrenNodes);
+  });
+}
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
+
+
+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 {
+    (0, _warning.default)(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
+ */
+
+
+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
+ */
+
+
+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/lib/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/lib/utils/conductUtil.js

@@ -0,0 +1,236 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCheckDisabled = isCheckDisabled;
+exports.conductCheck = conductCheck;
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
+  var filteredKeys = new Set();
+  halfCheckedKeys.forEach(function (key) {
+    if (!checkedKeys.has(key)) {
+      filteredKeys.add(key);
+    }
+  });
+  return filteredKeys;
+}
+
+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
+ */
+
+
+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);
+  });
+  (0, _warning.default)(!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/lib/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/lib/utils/diffUtil.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findExpandedKeys = findExpandedKeys;
+exports.getExpandRange = getExpandRange;
+
+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)
+  };
+}
+
+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/lib/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/lib/utils/treeUtil.js

@@ -0,0 +1,321 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKey = getKey;
+exports.warningWithoutKey = warningWithoutKey;
+exports.convertTreeToData = convertTreeToData;
+exports.flattenTreeData = flattenTreeData;
+exports.traverseDataNodes = traverseDataNodes;
+exports.convertDataToEntities = convertDataToEntities;
+exports.getTreeNodeProps = getTreeNodeProps;
+exports.convertNodePropsToEventData = convertNodePropsToEventData;
+
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _util = require("../util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+
+  return pos;
+}
+/**
+ * Warning if TreeNode do not provides key
+ */
+
+
+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;
+      (0, _warning.default)(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
+      var recordKey = String(key);
+      (0, _warning.default)(!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.
+ */
+
+
+function convertTreeToData(rootNodes) {
+  function dig(node) {
+    var treeNodes = (0, _toArray.default)(node);
+    return treeNodes.map(function (treeNode) {
+      // Filter invalidate node
+      if (!(0, _util.isTreeNode)(treeNode)) {
+        (0, _warning.default)(!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`).
+ */
+
+
+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 = (0, _util.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.
+ */
+
+
+function traverseDataNodes(dataNodes, callback) {
+  function processNode(node, index, parent) {
+    var children = node ? node.children : dataNodes;
+    var pos = node ? (0, _util.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.
+ */
+
+
+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.
+ */
+
+
+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;
+}
+
+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() {
+        (0, _warning.default)(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;
+}

web/node_modules/rc-tree/package.json

@@ -0,0 +1,104 @@
+{
+  "_from": "rc-tree@~3.1.0",
+  "_id": "rc-tree@3.1.5",
+  "_inBundle": false,
+  "_integrity": "sha512-LOUfsJg5XxtA4FKgGkuVwnbBlnh3VVtySF7LMp4ko0n8oIUBYnn2vs6WG41kuH0V4tLTlQhvCFup/6JEKL01sg==",
+  "_location": "/rc-tree",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "rc-tree@~3.1.0",
+    "name": "rc-tree",
+    "escapedName": "rc-tree",
+    "rawSpec": "~3.1.0",
+    "saveSpec": null,
+    "fetchSpec": "~3.1.0"
+  },
+  "_requiredBy": [
+    "/antd",
+    "/rc-tree-select"
+  ],
+  "_resolved": "https://registry.npmjs.org/rc-tree/-/rc-tree-3.1.5.tgz",
+  "_shasum": "eb1c0d40f34ae2ad1ab8c951174c06e6a64957a6",
+  "_spec": "rc-tree@~3.1.0",
+  "_where": "/Users/thilina/TestProjects/icehrm-pro/web/node_modules/antd",
+  "author": {
+    "name": "smith3816@gmail.com"
+  },
+  "bugs": {
+    "url": "http://github.com/react-component/tree/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "classnames": "2.x",
+    "prop-types": "^15.5.8",
+    "rc-animate": "^2.9.2",
+    "rc-util": "^4.11.0",
+    "rc-virtual-list": "^1.1.0",
+    "react-lifecycles-compat": "^3.0.4"
+  },
+  "deprecated": false,
+  "description": "tree ui component for react",
+  "devDependencies": {
+    "@types/react": "^16.8.19",
+    "@types/react-dom": "^16.8.4",
+    "@types/warning": "^3.0.0",
+    "css-animation": "^1.2.0",
+    "enzyme": "^3.3.0",
+    "enzyme-adapter-react-16": "^1.1.1",
+    "enzyme-to-json": "^3.0.0",
+    "father": "^2.25.0-alpha.1",
+    "less": "^3.11.1",
+    "np": "^6.0.0",
+    "rc-dialog": "^7.3.1",
+    "rc-tooltip": "4.x",
+    "rc-trigger": "^4.0.0",
+    "react": "^16.8.0",
+    "react-dom": "^16.8.0",
+    "typescript": "^3.5.2"
+  },
+  "engines": {
+    "node": ">=8.x"
+  },
+  "files": [
+    "assets/*.css",
+    "assets/*.png",
+    "assets/*.gif",
+    "assets/*.less",
+    "dist",
+    "es",
+    "lib"
+  ],
+  "homepage": "http://github.com/react-component/tree",
+  "keywords": [
+    "react",
+    "react-component",
+    "react-tree",
+    "tree"
+  ],
+  "license": "MIT",
+  "main": "./lib/index",
+  "module": "./es/index",
+  "name": "rc-tree",
+  "peerDependencies": {
+    "react": "*",
+    "react-dom": "*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/react-component/tree.git"
+  },
+  "scripts": {
+    "build": "father doc build --storybook",
+    "compile": "father build && lessc assets/index.less assets/index.css",
+    "gh-pages": "npm run build && father doc deploy",
+    "lint": "eslint src/ examples/ --ext .tsx,.ts,.jsx,.js",
+    "now-build": "npm run build",
+    "postpublish": "npm run gh-pages",
+    "prepublishOnly": "npm run compile && np --no-cleanup --yolo --no-publish",
+    "start": "father doc dev --storybook",
+    "test": "father test"
+  },
+  "version": "3.1.5"
+}