first commit

frontend/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.

frontend/node_modules/rc-tree/README.md

@@ -0,0 +1,149 @@
+# rc-tree
+
+Tree component.
+
+[![NPM version][npm-image]][npm-url]
+[![npm download][download-image]][download-url]
+[![build status][github-actions-image]][github-actions-url]
+[![Codecov][codecov-image]][codecov-url]
+[![bundle size][bundlephobia-image]][bundlephobia-url]
+[![dumi][dumi-image]][dumi-url]
+
+[npm-image]: http://img.shields.io/npm/v/rc-tree.svg?style=flat-square
+[npm-url]: http://npmjs.org/package/rc-tree
+[github-actions-image]: https://github.com/react-component/tree/actions/workflows/main.yml/badge.svg
+[github-actions-url]: https://github.com/react-component/tree/actions/workflows/main.yml
+[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/
+[david-url]: https://david-dm.org/react-component/tree
+[david-image]: https://david-dm.org/react-component/tree/status.svg?style=flat-square
+[david-dev-url]: https://david-dm.org/react-component/tree?type=dev
+[david-dev-image]: https://david-dm.org/react-component/tree/dev-status.svg?style=flat-square
+[download-image]: https://img.shields.io/npm/dm/rc-tree.svg?style=flat-square
+[download-url]: https://npmjs.org/package/rc-tree
+[bundlephobia-url]: https://bundlephobia.com/result?p=rc-tree
+[bundlephobia-image]: https://badgen.net/bundlephobia/minzip/rc-tree
+[dumi-url]: https://github.com/umijs/dumi
+[dumi-image]: https://img.shields.io/badge/docs%20by-dumi-blue?style=flat-square
+
+## 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: https://tree.react-component.now.sh/
+
+## Install
+
+[![rc-tree](https://nodei.co/npm/rc-tree.png)](https://npmjs.org/package/rc-tree)
+
+## Usage
+> Note: `import "rc-tree/assets/index.css"`
+
+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 \| ({ node }) => boolean | 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 | - |
+| allowDrop | Whether to allow drop on node | ({ dragNode, dropNode, dropPosition }) => boolean | - |
+| dropIndicatorRender | The indicator to render when dragging | ({ dropPosition, dropLevelOffset, indent: number, prefixCls }) => ReactNode| - |
+| direction | Display direction of the tree, it may affect dragging behavior | `ltr` \| `rtl` | - |
+| expandAction | Tree open logic, optional: false \| `click` \| `doubleClick` | string \| boolean | `click` |
+
+### 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 | false |
+| 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 views
+
+- [zTree](http://www.treejs.cn/)
+- [jqTree](https://mbraak.github.io/jqTree/)
+- [jquery.treeselect](https://travistidwell.com/jquery.treeselect.js/)
+- [Angular Multi Select Tree](https://a5hik.github.io/angular-multi-select-tree/)

frontend/node_modules/rc-tree/es/DropIndicator.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface DropIndicatorProps {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+}
+declare const DropIndicator: React.FC<Readonly<DropIndicatorProps>>;
+export default DropIndicator;

frontend/node_modules/rc-tree/es/DropIndicator.js

@@ -0,0 +1,34 @@
+import React from 'react';
+var DropIndicator = function DropIndicator(props) {
+  var dropPosition = props.dropPosition,
+    dropLevelOffset = props.dropLevelOffset,
+    indent = props.indent;
+  var style = {
+    pointerEvents: 'none',
+    position: 'absolute',
+    right: 0,
+    backgroundColor: 'red',
+    height: 2
+  };
+  switch (dropPosition) {
+    case -1:
+      style.top = 0;
+      style.left = -dropLevelOffset * indent;
+      break;
+    case 1:
+      style.bottom = 0;
+      style.left = -dropLevelOffset * indent;
+      break;
+    case 0:
+      style.bottom = 0;
+      style.left = indent;
+      break;
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    style: style
+  });
+};
+if (process.env.NODE_ENV !== 'production') {
+  DropIndicator.displayName = 'DropIndicator';
+}
+export default DropIndicator;

frontend/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 _default: React.NamedExoticComponent<IndentProps>;
+export default _default;

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

@@ -0,0 +1,22 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import classNames from 'classnames';
+import * as React from 'react';
+var Indent = function Indent(_ref) {
+  var prefixCls = _ref.prefixCls,
+    level = _ref.level,
+    isStart = _ref.isStart,
+    isEnd = _ref.isEnd;
+  var baseClassName = "".concat(prefixCls, "-indent-unit");
+  var list = [];
+  for (var i = 0; i < level; i += 1) {
+    list.push( /*#__PURE__*/React.createElement("span", {
+      key: i,
+      className: classNames(baseClassName, _defineProperty(_defineProperty({}, "".concat(baseClassName, "-start"), isStart[i]), "".concat(baseClassName, "-end"), isEnd[i]))
+    }));
+  }
+  return /*#__PURE__*/React.createElement("span", {
+    "aria-hidden": "true",
+    className: "".concat(prefixCls, "-indent")
+  }, list);
+};
+export default /*#__PURE__*/React.memo(Indent);

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

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

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

@@ -0,0 +1,110 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectDestructuringEmpty from "@babel/runtime/helpers/esm/objectDestructuringEmpty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["className", "style", "motion", "motionNodes", "motionType", "onMotionStart", "onMotionEnd", "active", "treeNodeRequiredProps"];
+import classNames from 'classnames';
+import CSSMotion from 'rc-motion';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import * as React from 'react';
+import { TreeContext } from "./contextTypes";
+import TreeNode from "./TreeNode";
+import useUnmount from "./useUnmount";
+import { getTreeNodeProps } from "./utils/treeUtil";
+var MotionTreeNode = /*#__PURE__*/React.forwardRef(function (oriProps, ref) {
+  var className = oriProps.className,
+    style = oriProps.style,
+    motion = oriProps.motion,
+    motionNodes = oriProps.motionNodes,
+    motionType = oriProps.motionType,
+    onOriginMotionStart = oriProps.onMotionStart,
+    onOriginMotionEnd = oriProps.onMotionEnd,
+    active = oriProps.active,
+    treeNodeRequiredProps = oriProps.treeNodeRequiredProps,
+    props = _objectWithoutProperties(oriProps, _excluded);
+  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;
+
+  // Calculate target visible here.
+  // And apply in effect to make `leave` motion work.
+  var targetVisible = motionNodes && motionType !== 'hide';
+  useLayoutEffect(function () {
+    if (motionNodes) {
+      if (targetVisible !== visible) {
+        setVisible(targetVisible);
+      }
+    }
+  }, [motionNodes]);
+  var triggerMotionStart = function triggerMotionStart() {
+    if (motionNodes) {
+      onOriginMotionStart();
+    }
+  };
+
+  // Should only trigger once
+  var triggerMotionEndRef = React.useRef(false);
+  var triggerMotionEnd = function triggerMotionEnd() {
+    if (motionNodes && !triggerMotionEndRef.current) {
+      triggerMotionEndRef.current = true;
+      onOriginMotionEnd();
+    }
+  };
+
+  // Effect if unmount
+  useUnmount(triggerMotionStart, triggerMotionEnd);
+
+  // Motion end event
+  var onVisibleChanged = function onVisibleChanged(nextVisible) {
+    if (targetVisible === nextVisible) {
+      triggerMotionEnd();
+    }
+  };
+  if (motionNodes) {
+    return /*#__PURE__*/React.createElement(CSSMotion, _extends({
+      ref: ref,
+      visible: visible
+    }, motion, {
+      motionAppear: motionType === 'show',
+      onVisibleChanged: onVisibleChanged
+    }), function (_ref, motionRef) {
+      var motionClassName = _ref.className,
+        motionStyle = _ref.style;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: motionRef,
+        className: classNames("".concat(prefixCls, "-treenode-motion"), motionClassName),
+        style: motionStyle
+      }, motionNodes.map(function (treeNode) {
+        var restProps = Object.assign({}, (_objectDestructuringEmpty(treeNode.data), treeNode.data)),
+          title = treeNode.title,
+          key = treeNode.key,
+          isStart = treeNode.isStart,
+          isEnd = treeNode.isEnd;
+        delete restProps.children;
+        var treeNodeProps = getTreeNodeProps(key, treeNodeRequiredProps);
+        return /*#__PURE__*/React.createElement(TreeNode, _extends({}, restProps, treeNodeProps, {
+          title: title,
+          active: active,
+          data: treeNode.data,
+          key: key,
+          isStart: isStart,
+          isEnd: isEnd
+        }));
+      }));
+    });
+  }
+  return /*#__PURE__*/React.createElement(TreeNode, _extends({
+    domRef: ref,
+    className: className,
+    style: style
+  }, props, {
+    active: active
+  }));
+});
+if (process.env.NODE_ENV !== 'production') {
+  MotionTreeNode.displayName = 'MotionTreeNode';
+}
+export default MotionTreeNode;

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

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

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

@@ -0,0 +1,293 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectDestructuringEmpty from "@babel/runtime/helpers/esm/objectDestructuringEmpty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["prefixCls", "data", "selectable", "checkable", "expandedKeys", "selectedKeys", "checkedKeys", "loadedKeys", "loadingKeys", "halfCheckedKeys", "keyEntities", "disabled", "dragging", "dragOverNodeKey", "dropPosition", "motion", "height", "itemHeight", "virtual", "scrollWidth", "focusable", "activeItem", "focused", "tabIndex", "onKeyDown", "onFocus", "onBlur", "onActiveChange", "onListChangeStart", "onListChangeEnd"];
+/**
+ * Handle virtual list of the TreeNodes.
+ */
+
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+import VirtualList from 'rc-virtual-list';
+import * as React from 'react';
+import MotionTreeNode from "./MotionTreeNode";
+import { findExpandedKeys, getExpandRange } from "./utils/diffUtil";
+import { getKey, getTreeNodeProps } 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,
+  nodes: [MotionNode]
+};
+var MotionFlattenData = {
+  parent: null,
+  children: [],
+  pos: MotionEntity.pos,
+  data: MotionNode,
+  title: null,
+  key: MOTION_KEY,
+  /** 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, virtual, height, itemHeight) {
+  if (virtual === false || !height) {
+    return list;
+  }
+  return list.slice(0, Math.ceil(height / itemHeight) + 1);
+}
+function itemKey(item) {
+  var key = item.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 NodeList = /*#__PURE__*/React.forwardRef(function (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,
+    scrollWidth = props.scrollWidth,
+    focusable = props.focusable,
+    activeItem = props.activeItem,
+    focused = props.focused,
+    tabIndex = props.tabIndex,
+    onKeyDown = props.onKeyDown,
+    onFocus = props.onFocus,
+    onBlur = props.onBlur,
+    onActiveChange = props.onActiveChange,
+    onListChangeStart = props.onListChangeStart,
+    onListChangeEnd = props.onListChangeEnd,
+    domProps = _objectWithoutProperties(props, _excluded);
+
+  // =============================== Ref ================================
+  var listRef = React.useRef(null);
+  var indentMeasurerRef = React.useRef(null);
+  React.useImperativeHandle(ref, function () {
+    return {
+      scrollTo: function scrollTo(scroll) {
+        listRef.current.scrollTo(scroll);
+      },
+      getIndentWidth: function getIndentWidth() {
+        return indentMeasurerRef.current.offsetWidth;
+      }
+    };
+  });
+
+  // ============================== Motion ==============================
+  var _React$useState = React.useState(expandedKeys),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    prevExpandedKeys = _React$useState2[0],
+    setPrevExpandedKeys = _React$useState2[1];
+  var _React$useState3 = React.useState(data),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    prevData = _React$useState4[0],
+    setPrevData = _React$useState4[1];
+  var _React$useState5 = React.useState(data),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    transitionData = _React$useState6[0],
+    setTransitionData = _React$useState6[1];
+  var _React$useState7 = React.useState([]),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    transitionRange = _React$useState8[0],
+    setTransitionRange = _React$useState8[1];
+  var _React$useState9 = React.useState(null),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    motionType = _React$useState10[0],
+    setMotionType = _React$useState10[1];
+
+  // When motion end but data change, this will makes data back to previous one
+  var dataRef = React.useRef(data);
+  dataRef.current = data;
+  function onMotionEnd() {
+    var latestData = dataRef.current;
+    setPrevData(latestData);
+    setTransitionData(latestData);
+    setTransitionRange([]);
+    setMotionType(null);
+    onListChangeEnd();
+  }
+
+  // Do animation if expanded keys changed
+  // layoutEffect here to avoid blink of node removing
+  useLayoutEffect(function () {
+    setPrevExpandedKeys(expandedKeys);
+    var diffExpanded = findExpandedKeys(prevExpandedKeys, expandedKeys);
+    if (diffExpanded.key !== null) {
+      if (diffExpanded.add) {
+        var keyIndex = prevData.findIndex(function (_ref) {
+          var key = _ref.key;
+          return key === diffExpanded.key;
+        });
+        var rangeNodes = getMinimumRangeTransitionRange(getExpandRange(prevData, data, diffExpanded.key), virtual, 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.key;
+          return key === diffExpanded.key;
+        });
+        var _rangeNodes = getMinimumRangeTransitionRange(getExpandRange(data, prevData, diffExpanded.key), virtual, 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 /*#__PURE__*/React.createElement(React.Fragment, null, focused && activeItem && /*#__PURE__*/React.createElement("span", {
+    style: HIDDEN_STYLE,
+    "aria-live": "assertive"
+  }, getAccessibilityPath(activeItem)), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("input", {
+    style: HIDDEN_STYLE,
+    disabled: focusable === false || disabled,
+    tabIndex: focusable !== false ? tabIndex : null,
+    onKeyDown: onKeyDown,
+    onFocus: onFocus,
+    onBlur: onBlur,
+    value: "",
+    onChange: noop,
+    "aria-label": "for screen reader"
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-treenode"),
+    "aria-hidden": true,
+    style: {
+      position: 'absolute',
+      pointerEvents: 'none',
+      visibility: 'hidden',
+      height: 0,
+      overflow: 'hidden',
+      border: 0,
+      padding: 0
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-indent")
+  }, /*#__PURE__*/React.createElement("div", {
+    ref: indentMeasurerRef,
+    className: "".concat(prefixCls, "-indent-unit")
+  }))), /*#__PURE__*/React.createElement(VirtualList, _extends({}, domProps, {
+    data: mergedData,
+    itemKey: itemKey,
+    height: height,
+    fullHeight: false,
+    virtual: virtual,
+    itemHeight: itemHeight,
+    scrollWidth: scrollWidth,
+    prefixCls: "".concat(prefixCls, "-list"),
+    ref: listRef,
+    role: "tree",
+    onVisibleChange: function onVisibleChange(originList) {
+      // The best match is using `fullList` - `originList` = `restList`
+      // and check the `restList` to see if has the MOTION_KEY node
+      // but this will cause performance issue for long list compare
+      // we just check `originList` and repeat trigger `onMotionEnd`
+      if (originList.every(function (item) {
+        return itemKey(item) !== MOTION_KEY;
+      })) {
+        onMotionEnd();
+      }
+    }
+  }), function (treeNode) {
+    var pos = treeNode.pos,
+      restProps = Object.assign({}, (_objectDestructuringEmpty(treeNode.data), treeNode.data)),
+      title = treeNode.title,
+      key = treeNode.key,
+      isStart = treeNode.isStart,
+      isEnd = treeNode.isEnd;
+    var mergedKey = getKey(key, pos);
+    delete restProps.key;
+    delete restProps.children;
+    var treeNodeProps = getTreeNodeProps(mergedKey, treeNodeRequiredProps);
+    return /*#__PURE__*/React.createElement(MotionTreeNode, _extends({}, restProps, treeNodeProps, {
+      title: title,
+      active: !!activeItem && key === activeItem.key,
+      pos: pos,
+      data: treeNode.data,
+      isStart: isStart,
+      isEnd: isEnd,
+      motion: motion,
+      motionNodes: key === MOTION_KEY ? transitionRange : null,
+      motionType: motionType,
+      onMotionStart: onListChangeStart,
+      onMotionEnd: onMotionEnd,
+      treeNodeRequiredProps: treeNodeRequiredProps,
+      onMouseMove: function onMouseMove() {
+        onActiveChange(null);
+      }
+    }));
+  }));
+});
+if (process.env.NODE_ENV !== 'production') {
+  NodeList.displayName = 'NodeList';
+}
+export default NodeList;

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

@@ -0,0 +1,245 @@
+import * as React from 'react';
+import type { NodeDragEventHandler, NodeDragEventParams, NodeMouseEventHandler, NodeMouseEventParams } from './contextTypes';
+import type { DropIndicatorProps } from './DropIndicator';
+import type { BasicDataNode, DataNode, Direction, EventDataNode, FieldNames, FlattenNode, IconType, Key, KeyEntities, SafeKey, ScrollTo, TreeNodeProps } from './interface';
+import { type NodeListRef } from './NodeList';
+export interface CheckInfo<TreeDataType extends BasicDataNode = DataNode> {
+    event: 'check';
+    node: EventDataNode<TreeDataType>;
+    checked: boolean;
+    nativeEvent: MouseEvent;
+    checkedNodes: TreeDataType[];
+    checkedNodesPositions?: {
+        node: TreeDataType;
+        pos: string;
+    }[];
+    halfCheckedKeys?: Key[];
+}
+export interface AllowDropOptions<TreeDataType extends BasicDataNode = DataNode> {
+    dragNode: TreeDataType;
+    dropNode: TreeDataType;
+    dropPosition: -1 | 0 | 1;
+}
+export type AllowDrop<TreeDataType extends BasicDataNode = DataNode> = (options: AllowDropOptions<TreeDataType>) => boolean;
+export type DraggableFn = (node: DataNode) => boolean;
+export type DraggableConfig = {
+    icon?: React.ReactNode | false;
+    nodeDraggable?: DraggableFn;
+};
+export type ExpandAction = false | 'click' | 'doubleClick';
+export interface TreeProps<TreeDataType extends BasicDataNode = DataNode> {
+    prefixCls: string;
+    className?: string;
+    style?: React.CSSProperties;
+    focusable?: boolean;
+    activeKey?: Key | null;
+    tabIndex?: number;
+    children?: React.ReactNode;
+    treeData?: TreeDataType[];
+    fieldNames?: FieldNames;
+    showLine?: boolean;
+    showIcon?: boolean;
+    icon?: IconType;
+    selectable?: boolean;
+    expandAction?: ExpandAction;
+    disabled?: boolean;
+    multiple?: boolean;
+    checkable?: boolean | React.ReactNode;
+    checkStrictly?: boolean;
+    draggable?: DraggableFn | boolean | DraggableConfig;
+    defaultExpandParent?: boolean;
+    autoExpandParent?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: Key[];
+    expandedKeys?: Key[];
+    defaultCheckedKeys?: Key[];
+    checkedKeys?: Key[] | {
+        checked: Key[];
+        halfChecked: Key[];
+    };
+    defaultSelectedKeys?: Key[];
+    selectedKeys?: Key[];
+    allowDrop?: AllowDrop<TreeDataType>;
+    titleRender?: (node: TreeDataType) => React.ReactNode;
+    dropIndicatorRender?: (props: DropIndicatorProps) => React.ReactNode;
+    onFocus?: React.FocusEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLDivElement>;
+    onClick?: NodeMouseEventHandler<TreeDataType>;
+    onDoubleClick?: NodeMouseEventHandler<TreeDataType>;
+    onScroll?: React.UIEventHandler<HTMLElement>;
+    onExpand?: (expandedKeys: Key[], info: {
+        node: EventDataNode<TreeDataType>;
+        expanded: boolean;
+        nativeEvent: MouseEvent;
+    }) => void;
+    onCheck?: (checked: {
+        checked: Key[];
+        halfChecked: Key[];
+    } | Key[], info: CheckInfo<TreeDataType>) => void;
+    onSelect?: (selectedKeys: Key[], info: {
+        event: 'select';
+        selected: boolean;
+        node: EventDataNode<TreeDataType>;
+        selectedNodes: TreeDataType[];
+        nativeEvent: MouseEvent;
+    }) => void;
+    onLoad?: (loadedKeys: Key[], info: {
+        event: 'load';
+        node: EventDataNode<TreeDataType>;
+    }) => void;
+    loadData?: (treeNode: EventDataNode<TreeDataType>) => Promise<any>;
+    loadedKeys?: Key[];
+    onMouseEnter?: (info: NodeMouseEventParams<TreeDataType>) => void;
+    onMouseLeave?: (info: NodeMouseEventParams<TreeDataType>) => void;
+    onRightClick?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode<TreeDataType>;
+    }) => void;
+    onDragStart?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDragEnter?: (info: NodeDragEventParams<TreeDataType> & {
+        expandedKeys: Key[];
+    }) => void;
+    onDragOver?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDragLeave?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDragEnd?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDrop?: (info: NodeDragEventParams<TreeDataType> & {
+        dragNode: EventDataNode<TreeDataType>;
+        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<TreeDataType>) => boolean;
+    motion?: any;
+    switcherIcon?: IconType;
+    height?: number;
+    itemHeight?: number;
+    scrollWidth?: number;
+    itemScrollOffset?: number;
+    virtual?: boolean;
+    direction?: Direction;
+    rootClassName?: string;
+    rootStyle?: React.CSSProperties;
+}
+interface TreeState<TreeDataType extends BasicDataNode = DataNode> {
+    keyEntities: KeyEntities<TreeDataType>;
+    indent: number | null;
+    selectedKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    expandedKeys: Key[];
+    draggingNodeKey: Key;
+    dragChildrenKeys: Key[];
+    dropPosition: -1 | 0 | 1 | null;
+    dropLevelOffset: number | null;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropTargetPos: string | null;
+    dropAllowed: boolean;
+    dragOverNodeKey: Key | null;
+    treeData: TreeDataType[];
+    flattenNodes: FlattenNode<TreeDataType>[];
+    focused: boolean;
+    activeKey: Key | null;
+    listChanging: boolean;
+    prevProps: TreeProps;
+    fieldNames: FieldNames;
+}
+declare class Tree<TreeDataType extends DataNode | BasicDataNode = DataNode> extends React.Component<TreeProps<TreeDataType>, TreeState<TreeDataType>> {
+    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[];
+        dropIndicatorRender: React.FC<Readonly<DropIndicatorProps>>;
+        allowDrop: () => boolean;
+        expandAction: boolean;
+    };
+    static TreeNode: React.FC<Readonly<TreeNodeProps<DataNode>>>;
+    destroyed: boolean;
+    delayedDragEnterLogic: Record<SafeKey, number>;
+    loadingRetryTimes: Record<SafeKey, number>;
+    state: TreeState<TreeDataType>;
+    dragStartMousePosition: any;
+    dragNodeProps: TreeNodeProps<TreeDataType>;
+    currentMouseOverDroppableNodeKey: any;
+    listRef: React.RefObject<NodeListRef>;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    onUpdated(): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(props: TreeProps, prevState: TreeState): Partial<TreeState<DataNode>>;
+    onNodeDragStart: NodeDragEventHandler<TreeDataType, HTMLDivElement>;
+    /**
+     * [Legacy] Select handler is smaller 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.DragEvent<HTMLDivElement>, nodeProps: TreeNodeProps<TreeDataType>) => void;
+    onNodeDragOver: (event: React.DragEvent<HTMLDivElement>, nodeProps: TreeNodeProps<TreeDataType>) => void;
+    onNodeDragLeave: NodeDragEventHandler<TreeDataType>;
+    onWindowDragEnd: (event: any) => void;
+    onNodeDragEnd: NodeDragEventHandler<TreeDataType>;
+    onNodeDrop: (event: React.DragEvent<HTMLDivElement>, _: TreeNodeProps<TreeDataType>, outsideTree?: boolean) => void;
+    resetDragState(): void;
+    cleanDragState: () => void;
+    triggerExpandActionExpand: NodeMouseEventHandler;
+    onNodeClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeDoubleClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeSelect: NodeMouseEventHandler<TreeDataType>;
+    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode<TreeDataType>, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode<TreeDataType>) => Promise<void>;
+    onNodeMouseEnter: NodeMouseEventHandler<TreeDataType>;
+    onNodeMouseLeave: NodeMouseEventHandler<TreeDataType>;
+    onNodeContextMenu: NodeMouseEventHandler<TreeDataType>;
+    onFocus: React.FocusEventHandler<HTMLDivElement>;
+    onBlur: React.FocusEventHandler<HTMLDivElement>;
+    getTreeNodeRequiredProps: () => {
+        expandedKeys: React.Key[];
+        selectedKeys: React.Key[];
+        loadedKeys: React.Key[];
+        loadingKeys: React.Key[];
+        checkedKeys: React.Key[];
+        halfCheckedKeys: React.Key[];
+        dragOverNodeKey: React.Key;
+        dropPosition: 0 | 1 | -1;
+        keyEntities: KeyEntities<TreeDataType>;
+    };
+    /** Set uncontrolled `expandedKeys`. This will also auto update `flattenNodes`. */
+    setExpandedKeys: (expandedKeys: Key[]) => void;
+    onNodeExpand: (e: React.MouseEvent<HTMLDivElement>, treeNode: EventDataNode<TreeDataType>) => void;
+    onListChangeStart: () => void;
+    onListChangeEnd: () => void;
+    onActiveChange: (newActiveKey: Key | null) => void;
+    getActiveItem: () => FlattenNode<TreeDataType>;
+    offsetActiveKey: (offset: number) => void;
+    onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    /**
+     * Only update the value which is not in props
+     */
+    setUncontrolledState: (state: Partial<TreeState<TreeDataType>>, atomic?: boolean, forceState?: Partial<TreeState<TreeDataType>> | null) => void;
+    scrollTo: ScrollTo;
+    render(): React.JSX.Element;
+}
+export default Tree;

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { TreeNodeProps } from './interface';
+export type { TreeNodeProps } from './interface';
+declare const TreeNode: React.FC<Readonly<TreeNodeProps>>;
+export default TreeNode;

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

@@ -0,0 +1,354 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["eventKey", "className", "style", "dragOver", "dragOverGapTop", "dragOverGapBottom", "isLeaf", "isStart", "isEnd", "expanded", "selected", "checked", "halfChecked", "loading", "domRef", "active", "data", "onMouseMove", "selectable"];
+import React from 'react';
+import classNames from 'classnames';
+import pickAttrs from "rc-util/es/pickAttrs";
+import { TreeContext, UnstableContext } from "./contextTypes";
+import Indent from "./Indent";
+import getEntity from "./utils/keyUtil";
+import { convertNodePropsToEventData } from "./utils/treeUtil";
+var ICON_OPEN = 'open';
+var ICON_CLOSE = 'close';
+var defaultTitle = '---';
+var TreeNode = function TreeNode(props) {
+  var _unstableContext$node, _context$filterTreeNo, _classNames4;
+  var eventKey = props.eventKey,
+    className = props.className,
+    style = props.style,
+    dragOver = props.dragOver,
+    dragOverGapTop = props.dragOverGapTop,
+    dragOverGapBottom = props.dragOverGapBottom,
+    isLeaf = props.isLeaf,
+    isStart = props.isStart,
+    isEnd = props.isEnd,
+    expanded = props.expanded,
+    selected = props.selected,
+    checked = props.checked,
+    halfChecked = props.halfChecked,
+    loading = props.loading,
+    domRef = props.domRef,
+    active = props.active,
+    data = props.data,
+    onMouseMove = props.onMouseMove,
+    selectable = props.selectable,
+    otherProps = _objectWithoutProperties(props, _excluded);
+  var context = React.useContext(TreeContext);
+  var unstableContext = React.useContext(UnstableContext);
+  var selectHandleRef = React.useRef(null);
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    dragNodeHighlight = _React$useState2[0],
+    setDragNodeHighlight = _React$useState2[1];
+
+  // ======= State: Disabled State =======
+  var isDisabled = !!(context.disabled || props.disabled || (_unstableContext$node = unstableContext.nodeDisabled) !== null && _unstableContext$node !== void 0 && _unstableContext$node.call(unstableContext, data));
+  var isCheckable = React.useMemo(function () {
+    // Return false if tree or treeNode is not checkable
+    if (!context.checkable || props.checkable === false) {
+      return false;
+    }
+    return context.checkable;
+  }, [context.checkable, props.checkable]);
+
+  // ======= Event Handlers: Selection and Check =======
+  var onSelect = function onSelect(e) {
+    if (isDisabled) {
+      return;
+    }
+    context.onNodeSelect(e, convertNodePropsToEventData(props));
+  };
+  var onCheck = function onCheck(e) {
+    if (isDisabled) {
+      return;
+    }
+    if (!isCheckable || props.disableCheckbox) {
+      return;
+    }
+    context.onNodeCheck(e, convertNodePropsToEventData(props), !checked);
+  };
+
+  // ======= State: Selectable Check =======
+  var isSelectable = React.useMemo(function () {
+    // Ignore when selectable is undefined or null
+    if (typeof selectable === 'boolean') {
+      return selectable;
+    }
+    return context.selectable;
+  }, [selectable, context.selectable]);
+  var onSelectorClick = function onSelectorClick(e) {
+    // Click trigger before select/check operation
+    context.onNodeClick(e, convertNodePropsToEventData(props));
+    if (isSelectable) {
+      onSelect(e);
+    } else {
+      onCheck(e);
+    }
+  };
+  var onSelectorDoubleClick = function onSelectorDoubleClick(e) {
+    context.onNodeDoubleClick(e, convertNodePropsToEventData(props));
+  };
+  var onMouseEnter = function onMouseEnter(e) {
+    context.onNodeMouseEnter(e, convertNodePropsToEventData(props));
+  };
+  var onMouseLeave = function onMouseLeave(e) {
+    context.onNodeMouseLeave(e, convertNodePropsToEventData(props));
+  };
+  var onContextMenu = function onContextMenu(e) {
+    context.onNodeContextMenu(e, convertNodePropsToEventData(props));
+  };
+
+  // ======= Drag: Drag Enabled =======
+  var isDraggable = React.useMemo(function () {
+    return !!(context.draggable && (!context.draggable.nodeDraggable || context.draggable.nodeDraggable(data)));
+  }, [context.draggable, data]);
+
+  // ======= Drag: Drag Event Handlers =======
+  var onDragStart = function onDragStart(e) {
+    e.stopPropagation();
+    setDragNodeHighlight(true);
+    context.onNodeDragStart(e, props);
+    try {
+      // ie throw error
+      // firefox-need-it
+      e.dataTransfer.setData('text/plain', '');
+    } catch (_unused) {
+      // empty
+    }
+  };
+  var onDragEnter = function onDragEnter(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    context.onNodeDragEnter(e, props);
+  };
+  var onDragOver = function onDragOver(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    context.onNodeDragOver(e, props);
+  };
+  var onDragLeave = function onDragLeave(e) {
+    e.stopPropagation();
+    context.onNodeDragLeave(e, props);
+  };
+  var onDragEnd = function onDragEnd(e) {
+    e.stopPropagation();
+    setDragNodeHighlight(false);
+    context.onNodeDragEnd(e, props);
+  };
+  var onDrop = function onDrop(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    setDragNodeHighlight(false);
+    context.onNodeDrop(e, props);
+  };
+
+  // ======= Expand: Node Expansion =======
+  var onExpand = function onExpand(e) {
+    if (loading) {
+      return;
+    }
+    context.onNodeExpand(e, convertNodePropsToEventData(props));
+  };
+
+  // ======= State: Has Children =======
+  var hasChildren = React.useMemo(function () {
+    var _ref = getEntity(context.keyEntities, eventKey) || {},
+      children = _ref.children;
+    return Boolean((children || []).length);
+  }, [context.keyEntities, eventKey]);
+
+  // ======= State: Leaf Check =======
+  var memoizedIsLeaf = React.useMemo(function () {
+    if (isLeaf === false) {
+      return false;
+    }
+    return isLeaf || !context.loadData && !hasChildren || context.loadData && props.loaded && !hasChildren;
+  }, [isLeaf, context.loadData, hasChildren, props.loaded]);
+
+  // ============== Effect ==============
+  React.useEffect(function () {
+    // Load data to avoid default expanded tree without data
+    if (loading) {
+      return;
+    }
+    // read from state to avoid loadData at same time
+    if (typeof context.loadData === 'function' && expanded && !memoizedIsLeaf && !props.loaded) {
+      // We needn't reload data when has children in sync logic
+      // It's only needed in node expanded
+      context.onNodeLoad(convertNodePropsToEventData(props));
+    }
+  }, [loading, context.loadData, context.onNodeLoad, expanded, memoizedIsLeaf, props]);
+
+  // ==================== Render: Drag Handler ====================
+  var dragHandlerNode = React.useMemo(function () {
+    var _context$draggable;
+    if (!((_context$draggable = context.draggable) !== null && _context$draggable !== void 0 && _context$draggable.icon)) {
+      return null;
+    }
+    return /*#__PURE__*/React.createElement("span", {
+      className: "".concat(context.prefixCls, "-draggable-icon")
+    }, context.draggable.icon);
+  }, [context.draggable]);
+
+  // ====================== Render: Switcher ======================
+  var renderSwitcherIconDom = function renderSwitcherIconDom(isInternalLeaf) {
+    var switcherIcon = props.switcherIcon || context.switcherIcon;
+    // if switcherIconDom is null, no render switcher span
+    if (typeof switcherIcon === 'function') {
+      return switcherIcon(_objectSpread(_objectSpread({}, props), {}, {
+        isLeaf: isInternalLeaf
+      }));
+    }
+    return switcherIcon;
+  };
+
+  // Switcher
+  var renderSwitcher = function renderSwitcher() {
+    if (memoizedIsLeaf) {
+      // if switcherIconDom is null, no render switcher span
+      var _switcherIconDom = renderSwitcherIconDom(true);
+      return _switcherIconDom !== false ? /*#__PURE__*/React.createElement("span", {
+        className: classNames("".concat(context.prefixCls, "-switcher"), "".concat(context.prefixCls, "-switcher-noop"))
+      }, _switcherIconDom) : null;
+    }
+    var switcherIconDom = renderSwitcherIconDom(false);
+    return switcherIconDom !== false ? /*#__PURE__*/React.createElement("span", {
+      onClick: onExpand,
+      className: classNames("".concat(context.prefixCls, "-switcher"), "".concat(context.prefixCls, "-switcher_").concat(expanded ? ICON_OPEN : ICON_CLOSE))
+    }, switcherIconDom) : null;
+  };
+
+  // ====================== Checkbox ======================
+  var checkboxNode = React.useMemo(function () {
+    if (!isCheckable) {
+      return null;
+    }
+
+    // [Legacy] Custom element should be separate with `checkable` in future
+    var $custom = typeof isCheckable !== 'boolean' ? isCheckable : null;
+    return /*#__PURE__*/React.createElement("span", {
+      className: classNames("".concat(context.prefixCls, "-checkbox"), _defineProperty(_defineProperty(_defineProperty({}, "".concat(context.prefixCls, "-checkbox-checked"), checked), "".concat(context.prefixCls, "-checkbox-indeterminate"), !checked && halfChecked), "".concat(context.prefixCls, "-checkbox-disabled"), isDisabled || props.disableCheckbox)),
+      onClick: onCheck,
+      role: "checkbox",
+      "aria-checked": halfChecked ? 'mixed' : checked,
+      "aria-disabled": isDisabled || props.disableCheckbox,
+      "aria-label": "Select ".concat(typeof props.title === 'string' ? props.title : 'tree node')
+    }, $custom);
+  }, [isCheckable, checked, halfChecked, isDisabled, props.disableCheckbox, props.title]);
+
+  // ============== State: Node State (Open/Close) ==============
+  var nodeState = React.useMemo(function () {
+    if (memoizedIsLeaf) {
+      return null;
+    }
+    return expanded ? ICON_OPEN : ICON_CLOSE;
+  }, [memoizedIsLeaf, expanded]);
+
+  // ==================== Render: Title + Icon ====================
+  var iconNode = React.useMemo(function () {
+    return /*#__PURE__*/React.createElement("span", {
+      className: classNames("".concat(context.prefixCls, "-iconEle"), "".concat(context.prefixCls, "-icon__").concat(nodeState || 'docu'), _defineProperty({}, "".concat(context.prefixCls, "-icon_loading"), loading))
+    });
+  }, [context.prefixCls, nodeState, loading]);
+
+  // =================== Drop Indicator ===================
+  var dropIndicatorNode = React.useMemo(function () {
+    var rootDraggable = Boolean(context.draggable);
+    // allowDrop is calculated in Tree.tsx, there is no need for calc it here
+    var showIndicator = !props.disabled && rootDraggable && context.dragOverNodeKey === eventKey;
+    if (!showIndicator) {
+      return null;
+    }
+    return context.dropIndicatorRender({
+      dropPosition: context.dropPosition,
+      dropLevelOffset: context.dropLevelOffset,
+      indent: context.indent,
+      prefixCls: context.prefixCls,
+      direction: context.direction
+    });
+  }, [context.dropPosition, context.dropLevelOffset, context.indent, context.prefixCls, context.direction, context.draggable, context.dragOverNodeKey, context.dropIndicatorRender]);
+
+  // Icon + Title
+  var selectorNode = React.useMemo(function () {
+    var _props$title = props.title,
+      title = _props$title === void 0 ? defaultTitle : _props$title;
+    var wrapClass = "".concat(context.prefixCls, "-node-content-wrapper");
+
+    // Icon - Still show loading icon when loading without showIcon
+    var $icon;
+    if (context.showIcon) {
+      var currentIcon = props.icon || context.icon;
+      $icon = currentIcon ? /*#__PURE__*/React.createElement("span", {
+        className: classNames("".concat(context.prefixCls, "-iconEle"), "".concat(context.prefixCls, "-icon__customize"))
+      }, typeof currentIcon === 'function' ? currentIcon(props) : currentIcon) : iconNode;
+    } else if (context.loadData && loading) {
+      $icon = iconNode;
+    }
+
+    // Title
+    var titleNode;
+    if (typeof title === 'function') {
+      titleNode = title(data);
+    } else if (context.titleRender) {
+      titleNode = context.titleRender(data);
+    } else {
+      titleNode = title;
+    }
+    return /*#__PURE__*/React.createElement("span", {
+      ref: selectHandleRef,
+      title: typeof title === 'string' ? title : '',
+      className: classNames(wrapClass, "".concat(wrapClass, "-").concat(nodeState || 'normal'), _defineProperty({}, "".concat(context.prefixCls, "-node-selected"), !isDisabled && (selected || dragNodeHighlight))),
+      onMouseEnter: onMouseEnter,
+      onMouseLeave: onMouseLeave,
+      onContextMenu: onContextMenu,
+      onClick: onSelectorClick,
+      onDoubleClick: onSelectorDoubleClick
+    }, $icon, /*#__PURE__*/React.createElement("span", {
+      className: "".concat(context.prefixCls, "-title")
+    }, titleNode), dropIndicatorNode);
+  }, [context.prefixCls, context.showIcon, props, context.icon, iconNode, context.titleRender, data, nodeState, onMouseEnter, onMouseLeave, onContextMenu, onSelectorClick, onSelectorDoubleClick]);
+  var dataOrAriaAttributeProps = pickAttrs(otherProps, {
+    aria: true,
+    data: true
+  });
+  var _ref2 = getEntity(context.keyEntities, eventKey) || {},
+    level = _ref2.level;
+  var isEndNode = isEnd[isEnd.length - 1];
+  var draggableWithoutDisabled = !isDisabled && isDraggable;
+  var dragging = context.draggingNodeKey === eventKey;
+  var ariaSelected = selectable !== undefined ? {
+    'aria-selected': !!selectable
+  } : undefined;
+  return /*#__PURE__*/React.createElement("div", _extends({
+    ref: domRef,
+    role: "treeitem",
+    "aria-expanded": isLeaf ? undefined : expanded,
+    className: classNames(className, "".concat(context.prefixCls, "-treenode"), (_classNames4 = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_classNames4, "".concat(context.prefixCls, "-treenode-disabled"), isDisabled), "".concat(context.prefixCls, "-treenode-switcher-").concat(expanded ? 'open' : 'close'), !isLeaf), "".concat(context.prefixCls, "-treenode-checkbox-checked"), checked), "".concat(context.prefixCls, "-treenode-checkbox-indeterminate"), halfChecked), "".concat(context.prefixCls, "-treenode-selected"), selected), "".concat(context.prefixCls, "-treenode-loading"), loading), "".concat(context.prefixCls, "-treenode-active"), active), "".concat(context.prefixCls, "-treenode-leaf-last"), isEndNode), "".concat(context.prefixCls, "-treenode-draggable"), isDraggable), "dragging", dragging), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_classNames4, 'drop-target', context.dropTargetKey === eventKey), 'drop-container', context.dropContainerKey === eventKey), 'drag-over', !isDisabled && dragOver), 'drag-over-gap-top', !isDisabled && dragOverGapTop), 'drag-over-gap-bottom', !isDisabled && dragOverGapBottom), 'filter-node', (_context$filterTreeNo = context.filterTreeNode) === null || _context$filterTreeNo === void 0 ? void 0 : _context$filterTreeNo.call(context, convertNodePropsToEventData(props))), "".concat(context.prefixCls, "-treenode-leaf"), memoizedIsLeaf))),
+    style: style
+    // Draggable config
+    ,
+    draggable: draggableWithoutDisabled,
+    onDragStart: draggableWithoutDisabled ? onDragStart : undefined
+    // Drop config
+    ,
+    onDragEnter: isDraggable ? onDragEnter : undefined,
+    onDragOver: isDraggable ? onDragOver : undefined,
+    onDragLeave: isDraggable ? onDragLeave : undefined,
+    onDrop: isDraggable ? onDrop : undefined,
+    onDragEnd: isDraggable ? onDragEnd : undefined,
+    onMouseMove: onMouseMove
+  }, ariaSelected, dataOrAriaAttributeProps), /*#__PURE__*/React.createElement(Indent, {
+    prefixCls: context.prefixCls,
+    level: level,
+    isStart: isStart,
+    isEnd: isEnd
+  }), dragHandlerNode, renderSwitcher(), checkboxNode, selectorNode);
+};
+TreeNode.isTreeNode = 1;
+if (process.env.NODE_ENV !== 'production') {
+  TreeNode.displayName = 'TreeNode';
+}
+export default TreeNode;

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

@@ -0,0 +1,67 @@
+/**
+ * Webpack has bug for import loop, which is not the same behavior as ES module.
+ * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
+ */
+import * as React from 'react';
+import type { BasicDataNode, DataNode, Direction, EventDataNode, IconType, Key, KeyEntities, TreeNodeProps } from './interface';
+import type { DraggableConfig } from './Tree';
+export type NodeMouseEventParams<TreeDataType extends BasicDataNode = DataNode, T = HTMLSpanElement> = {
+    event: React.MouseEvent<T>;
+    node: EventDataNode<TreeDataType>;
+};
+export type NodeDragEventParams<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = {
+    event: React.DragEvent<T>;
+    node: EventDataNode<TreeDataType>;
+};
+export type NodeMouseEventHandler<TreeDataType extends BasicDataNode = DataNode, T = HTMLSpanElement> = (e: React.MouseEvent<T>, node: EventDataNode<TreeDataType>) => void;
+export type NodeDragEventHandler<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = (e: React.DragEvent<T>, nodeProps: TreeNodeProps<TreeDataType>, outsideTree?: boolean) => void;
+export interface TreeContextProps<TreeDataType extends BasicDataNode = DataNode> {
+    prefixCls: string;
+    selectable: boolean;
+    showIcon: boolean;
+    icon: IconType;
+    switcherIcon: IconType;
+    draggable?: DraggableConfig;
+    draggingNodeKey?: Key;
+    checkable: boolean | React.ReactNode;
+    checkStrictly: boolean;
+    disabled: boolean;
+    keyEntities: KeyEntities;
+    dropLevelOffset?: number;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropPosition: -1 | 0 | 1 | null;
+    indent: number | null;
+    dropIndicatorRender: (props: {
+        dropPosition: -1 | 0 | 1;
+        dropLevelOffset: number;
+        indent: number;
+        prefixCls: string;
+        direction: Direction;
+    }) => React.ReactNode;
+    dragOverNodeKey: Key | null;
+    direction: Direction;
+    loadData: (treeNode: EventDataNode<TreeDataType>) => Promise<void>;
+    filterTreeNode: (treeNode: EventDataNode<TreeDataType>) => boolean;
+    titleRender?: (node: any) => React.ReactNode;
+    onNodeClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeDoubleClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeExpand: NodeMouseEventHandler<TreeDataType>;
+    onNodeSelect: NodeMouseEventHandler<TreeDataType>;
+    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode<TreeDataType>, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode<TreeDataType>) => void;
+    onNodeMouseEnter: NodeMouseEventHandler<TreeDataType>;
+    onNodeMouseLeave: NodeMouseEventHandler<TreeDataType>;
+    onNodeContextMenu: NodeMouseEventHandler<TreeDataType>;
+    onNodeDragStart: NodeDragEventHandler<any, any>;
+    onNodeDragEnter: NodeDragEventHandler<any, any>;
+    onNodeDragOver: NodeDragEventHandler<any, any>;
+    onNodeDragLeave: NodeDragEventHandler<any, any>;
+    onNodeDragEnd: NodeDragEventHandler<any, any>;
+    onNodeDrop: NodeDragEventHandler<any, any>;
+}
+export declare const TreeContext: React.Context<TreeContextProps<any>>;
+/** Internal usage, safe to remove. Do not use in prod */
+export declare const UnstableContext: React.Context<{
+    nodeDisabled?: (n: DataNode) => boolean;
+}>;

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

@@ -0,0 +1,9 @@
+/**
+ * Webpack has bug for import loop, which is not the same behavior as ES module.
+ * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
+ */
+import * as React from 'react';
+export var TreeContext = /*#__PURE__*/React.createContext(null);
+
+/** Internal usage, safe to remove. Do not use in prod */
+export var UnstableContext = /*#__PURE__*/React.createContext({});

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

@@ -0,0 +1,8 @@
+import Tree from './Tree';
+import TreeNode from './TreeNode';
+import type { TreeProps } from './Tree';
+import type { TreeNodeProps, BasicDataNode, FieldDataNode } from './interface';
+import { UnstableContext } from './contextTypes';
+export { TreeNode, UnstableContext };
+export type { TreeProps, TreeNodeProps, BasicDataNode, FieldDataNode };
+export default Tree;

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

@@ -0,0 +1,5 @@
+import Tree from "./Tree";
+import TreeNode from "./TreeNode";
+import { UnstableContext } from "./contextTypes";
+export { TreeNode, UnstableContext };
+export default Tree;

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

@@ -0,0 +1,122 @@
+import * as React from 'react';
+export type { ScrollTo } from 'rc-virtual-list/lib/List';
+export interface TreeNodeProps<TreeDataType extends BasicDataNode = DataNode> {
+    eventKey?: Key;
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    id?: string;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    halfChecked?: boolean;
+    title?: React.ReactNode | ((data: TreeDataType) => React.ReactNode);
+    dragOver?: boolean;
+    dragOverGapTop?: boolean;
+    dragOverGapBottom?: boolean;
+    pos?: string;
+    domRef?: React.Ref<HTMLDivElement>;
+    /** New added in Tree for easy data access */
+    data?: TreeDataType;
+    isStart?: boolean[];
+    isEnd?: boolean[];
+    active?: boolean;
+    onMouseMove?: React.MouseEventHandler<HTMLDivElement>;
+    isLeaf?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    switcherIcon?: IconType;
+    children?: React.ReactNode;
+}
+/** For fieldNames, we provides a abstract interface */
+export interface BasicDataNode {
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    isLeaf?: boolean;
+    selectable?: boolean;
+    switcherIcon?: IconType;
+    /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
+    className?: string;
+    style?: React.CSSProperties;
+}
+/** Provide a wrap type define for developer to wrap with customize fieldNames data type */
+export type FieldDataNode<T, ChildFieldName extends string = 'children'> = BasicDataNode & T & Partial<Record<ChildFieldName, FieldDataNode<T, ChildFieldName>[]>>;
+export type Key = React.Key;
+/**
+ * Typescript not support `bigint` as index type yet.
+ * We use this to mark the `bigint` type is for `Key` usage.
+ * It's safe to remove this when typescript fix:
+ * https://github.com/microsoft/TypeScript/issues/50217
+ */
+export type SafeKey = Exclude<Key, bigint>;
+export type KeyEntities<DateType extends BasicDataNode = any> = Record<SafeKey, DataEntity<DateType>>;
+export type DataNode = FieldDataNode<{
+    key: Key;
+    title?: React.ReactNode | ((data: DataNode) => React.ReactNode);
+}>;
+export type EventDataNode<TreeDataType> = {
+    key: Key;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    loaded: boolean;
+    loading: boolean;
+    halfChecked: boolean;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    pos: string;
+    active: boolean;
+} & TreeDataType & BasicDataNode;
+export type IconType = React.ReactNode | ((props: TreeNodeProps) => React.ReactNode);
+export type NodeElement = React.ReactElement<TreeNodeProps> & {
+    selectHandle?: HTMLSpanElement;
+    type: {
+        isTreeNode: boolean;
+    };
+};
+export type NodeInstance<TreeDataType extends BasicDataNode = DataNode> = React.Component<TreeNodeProps<TreeDataType>> & {
+    selectHandle?: HTMLSpanElement;
+};
+export interface Entity {
+    node: NodeElement;
+    index: number;
+    key: Key;
+    pos: string;
+    parent?: Entity;
+    children?: Entity[];
+}
+export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> extends Omit<Entity, 'node' | 'parent' | 'children'> {
+    node: TreeDataType;
+    nodes: TreeDataType[];
+    parent?: DataEntity<TreeDataType>;
+    children?: DataEntity<TreeDataType>[];
+    level: number;
+}
+export interface FlattenNode<TreeDataType extends BasicDataNode = DataNode> {
+    parent: FlattenNode<TreeDataType> | null;
+    children: FlattenNode<TreeDataType>[];
+    pos: string;
+    data: TreeDataType;
+    title: React.ReactNode;
+    key: Key;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+export type GetKey<RecordType> = (record: RecordType, index?: number) => Key;
+export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+export type Direction = 'ltr' | 'rtl' | undefined;
+export interface FieldNames {
+    title?: string;
+    /** @private Internal usage for `rc-tree-select`, safe to remove if no need */
+    _title?: string[];
+    key?: string;
+    children?: string;
+}

frontend/node_modules/rc-tree/es/interface.js

@@ -0,0 +1 @@
+export {};

frontend/node_modules/rc-tree/es/useUnmount.d.ts

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

frontend/node_modules/rc-tree/es/useUnmount.js

@@ -0,0 +1,28 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+
+/**
+ * Trigger only when component unmount
+ */
+function useUnmount(triggerStart, triggerEnd) {
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    firstMount = _React$useState2[0],
+    setFirstMount = _React$useState2[1];
+  useLayoutEffect(function () {
+    if (firstMount) {
+      triggerStart();
+      return function () {
+        triggerEnd();
+      };
+    }
+  }, [firstMount]);
+  useLayoutEffect(function () {
+    setFirstMount(true);
+    return function () {
+      setFirstMount(false);
+    };
+  }, []);
+}
+export default useUnmount;

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

@@ -0,0 +1,51 @@
+/**
+ * Legacy code. Should avoid to use if you are new to import these code.
+ */
+import React from 'react';
+import type { BasicDataNode, DataEntity, DataNode, Direction, FlattenNode, Key, KeyEntities, NodeElement, TreeNodeProps } from './interface';
+import type { AllowDrop, TreeProps } from './Tree';
+export { getPosition, isTreeNode } from './utils/treeUtil';
+export declare function arrDel(list: Key[], value: Key): React.Key[];
+export declare function arrAdd(list: Key[], value: Key): React.Key[];
+export declare function posToArr(pos: string): string[];
+export declare function getDragChildrenKeys<TreeDataType extends BasicDataNode = DataNode>(dragNodeKey: Key, keyEntities: KeyEntities<TreeDataType>): Key[];
+export declare function isLastChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function isFirstChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function calcDropPosition<TreeDataType extends BasicDataNode = DataNode>(event: React.MouseEvent, dragNodeProps: TreeNodeProps<TreeDataType>, targetNodeProps: TreeNodeProps<TreeDataType>, indent: number, startMousePosition: {
+    x: number;
+    y: number;
+}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode<TreeDataType>[], keyEntities: KeyEntities<TreeDataType>, expandKeys: Key[], direction: Direction): {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    dropTargetKey: Key;
+    dropTargetPos: string;
+    dropContainerKey: Key;
+    dragOverNodeKey: Key;
+    dropAllowed: boolean;
+};
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): React.Key[];
+export declare function convertDataToTree(treeData: DataNode[], processor?: {
+    processProps: (prop: DataNode) => any;
+}): NodeElement[];
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
+export declare function parseCheckedKeys(keys: Key[] | {
+    checked: Key[];
+    halfChecked: Key[];
+}): {
+    checkedKeys?: Key[];
+    halfCheckedKeys?: Key[];
+};
+/**
+ * If user use `autoExpandParent` we should get the list of parent node
+ * @param keyList
+ * @param keyEntities
+ */
+export declare function conductExpandParent(keyList: Key[], keyEntities: KeyEntities): Key[];

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

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

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

@@ -0,0 +1,17 @@
+import type { BasicDataNode, DataNode, GetCheckDisabled, Key, KeyEntities } from '../interface';
+interface ConductReturnType {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): 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<TreeDataType extends BasicDataNode = DataNode>(keyList: Key[], checked: true | {
+    checked: false;
+    halfCheckedKeys: Key[];
+}, keyEntities: KeyEntities<TreeDataType>, getCheckDisabled?: GetCheckDisabled<TreeDataType>): ConductReturnType;
+export {};

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

@@ -0,0 +1,209 @@
+import warning from "rc-util/es/warning";
+import getEntity from "./keyUtil";
+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, syntheticGetCheckDisabled) {
+  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) && !syntheticGetCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !syntheticGetCheckDisabled(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 (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+
+      // Skip if parent is disabled
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !syntheticGetCheckDisabled(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, syntheticGetCheckDisabled) {
+  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) && !syntheticGetCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !syntheticGetCheckDisabled(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 (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+
+      // Skip if parent is disabled
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !syntheticGetCheckDisabled(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, getCheckDisabled) {
+  var warningMissKeys = [];
+  var syntheticGetCheckDisabled;
+  if (getCheckDisabled) {
+    syntheticGetCheckDisabled = getCheckDisabled;
+  } else {
+    syntheticGetCheckDisabled = isCheckDisabled;
+  }
+
+  // We only handle exist keys
+  var keys = new Set(keyList.filter(function (key) {
+    var hasEntity = !!getEntity(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, syntheticGetCheckDisabled);
+  } else {
+    result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel, syntheticGetCheckDisabled);
+  }
+  return result;
+}

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { Key, FlattenNode } from '../interface';
+export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
+    add: boolean;
+    key: import("react").Key;
+};
+export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode<import("../interface").DataNode>[];

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

@@ -0,0 +1,48 @@
+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 (data) {
+    return data.key === key;
+  });
+  var shorterEndNode = shorter[shorterStartIndex + 1];
+  var longerStartIndex = longer.findIndex(function (data) {
+    return data.key === key;
+  });
+  if (shorterEndNode) {
+    var longerEndIndex = longer.findIndex(function (data) {
+      return data.key === shorterEndNode.key;
+    });
+    return longer.slice(longerStartIndex + 1, longerEndIndex);
+  }
+  return longer.slice(longerStartIndex + 1);
+}

frontend/node_modules/rc-tree/es/utils/keyUtil.d.ts

@@ -0,0 +1,2 @@
+import type { Key, KeyEntities } from '../interface';
+export default function getEntity<T = any>(keyEntities: KeyEntities<T>, key: Key): import("../interface").DataEntity<T>;

frontend/node_modules/rc-tree/es/utils/keyUtil.js

@@ -0,0 +1,3 @@
+export default function getEntity(keyEntities, key) {
+  return keyEntities[key];
+}

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

@@ -0,0 +1,86 @@
+import * as React from 'react';
+import type { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key, KeyEntities, NodeElement, TreeNodeProps } from '../interface';
+export declare function getPosition(level: string | number, index: number): string;
+export declare function isTreeNode(node: NodeElement): boolean;
+export declare function getKey(key: Key, pos: string): React.Key;
+export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
+/**
+ * Warning if TreeNode do not provides key
+ */
+export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): 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<TreeDataType extends BasicDataNode = DataNode>(treeNodeList: TreeDataType[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode<TreeDataType>[];
+type ExternalGetKey = GetKey<DataNode> | string;
+interface TraverseDataNodesConfig {
+    childrenPropName?: string;
+    externalGetKey?: ExternalGetKey;
+    fieldNames?: FieldNames;
+}
+/**
+ * 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;
+    nodes: DataNode[];
+}) => void, config?: TraverseDataNodesConfig | string): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: KeyEntities;
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+    externalGetKey?: ExternalGetKey;
+    childrenPropName?: string;
+    fieldNames?: FieldNames;
+}, 
+/** @deprecated Use `config.externalGetKey` instead */
+legacyExternalGetKey?: ExternalGetKey): Wrapper;
+export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: KeyEntities<TreeDataType>;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps<TreeDataType>): {
+    eventKey: React.Key;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData<TreeDataType extends BasicDataNode = DataNode>(props: TreeNodeProps<TreeDataType>): EventDataNode<TreeDataType>;
+export {};

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

@@ -0,0 +1,354 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children"];
+import toArray from "rc-util/es/Children/toArray";
+import omit from "rc-util/es/omit";
+import warning from "rc-util/es/warning";
+import getEntity from "./keyUtil";
+export function getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
+}
+export function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+export function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+  return pos;
+}
+export function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+    title = _ref.title,
+    _title = _ref._title,
+    key = _ref.key,
+    children = _ref.children;
+  var mergedTitle = title || 'title';
+  return {
+    title: mergedTitle,
+    _title: _title || [mergedTitle],
+    key: key || 'key',
+    children: children || 'children'
+  };
+}
+
+/**
+ * Warning if TreeNode do not provides key
+ */
+export function warningWithoutKey(treeData, fieldNames) {
+  var keys = new Map();
+  function dig(list) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    (list || []).forEach(function (treeNode) {
+      var key = treeNode[fieldNames.key];
+      var children = treeNode[fieldNames.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, _excluded);
+      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(treeNodeList, expandedKeys, fieldNames) {
+  var _fillFieldNames = fillFieldNames(fieldNames),
+    fieldTitles = _fillFieldNames._title,
+    fieldKey = _fillFieldNames.key,
+    fieldChildren = _fillFieldNames.children;
+  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[fieldKey], pos);
+
+      // Pick matched title in field title list
+      var mergedTitle;
+      for (var i = 0; i < fieldTitles.length; i += 1) {
+        var fieldTitle = fieldTitles[i];
+        if (treeNode[fieldTitle] !== undefined) {
+          mergedTitle = treeNode[fieldTitle];
+          break;
+        }
+      }
+
+      // Add FlattenDataNode into list
+      // We use `Object.assign` here to save perf since babel's `objectSpread` has perf issue
+      var flattenNode = Object.assign(omit(treeNode, [].concat(_toConsumableArray(fieldTitles), [fieldKey, fieldChildren])), {
+        title: mergedTitle,
+        key: mergedKey,
+        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[fieldChildren] || [], 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,
+// To avoid too many params, let use config instead of origin param
+config) {
+  var mergedConfig = {};
+  if (_typeof(config) === 'object') {
+    mergedConfig = config;
+  } else {
+    mergedConfig = {
+      externalGetKey: config
+    };
+  }
+  mergedConfig = mergedConfig || {};
+
+  // Init config
+  var _mergedConfig = mergedConfig,
+    childrenPropName = _mergedConfig.childrenPropName,
+    externalGetKey = _mergedConfig.externalGetKey,
+    fieldNames = _mergedConfig.fieldNames;
+  var _fillFieldNames2 = fillFieldNames(fieldNames),
+    fieldKey = _fillFieldNames2.key,
+    fieldChildren = _fillFieldNames2.children;
+  var mergeChildrenPropName = childrenPropName || fieldChildren;
+
+  // Get keys
+  var syntheticGetKey;
+  if (externalGetKey) {
+    if (typeof externalGetKey === 'string') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return node[externalGetKey];
+      };
+    } else if (typeof externalGetKey === 'function') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return externalGetKey(node);
+      };
+    }
+  } else {
+    syntheticGetKey = function syntheticGetKey(node, pos) {
+      return getKey(node[fieldKey], pos);
+    };
+  }
+
+  // Process
+  function processNode(node, index, parent, pathNodes) {
+    var children = node ? node[mergeChildrenPropName] : dataNodes;
+    var pos = node ? getPosition(parent.pos, index) : '0';
+    var connectNodes = node ? [].concat(_toConsumableArray(pathNodes), [node]) : [];
+
+    // Process node if is not root
+    if (node) {
+      var key = syntheticGetKey(node, pos);
+      var _data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: key,
+        parentPos: parent.node ? parent.pos : null,
+        level: parent.level + 1,
+        nodes: connectNodes
+      };
+      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
+        }, connectNodes);
+      });
+    }
+  }
+  processNode(null);
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export function convertDataToEntities(dataNodes) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    initWrapper = _ref2.initWrapper,
+    processEntity = _ref2.processEntity,
+    onProcessFinished = _ref2.onProcessFinished,
+    externalGetKey = _ref2.externalGetKey,
+    childrenPropName = _ref2.childrenPropName,
+    fieldNames = _ref2.fieldNames;
+  var /** @deprecated Use `config.externalGetKey` instead */
+  legacyExternalGetKey = arguments.length > 2 ? arguments[2] : undefined;
+  // Init config
+  var mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
+  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,
+      nodes = item.nodes;
+    var entity = {
+      node: node,
+      nodes: nodes,
+      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);
+    }
+  }, {
+    externalGetKey: mergedExternalGetKey,
+    childrenPropName: childrenPropName,
+    fieldNames: fieldNames
+  });
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+  return wrapper;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export function getTreeNodeProps(key, _ref3) {
+  var expandedKeys = _ref3.expandedKeys,
+    selectedKeys = _ref3.selectedKeys,
+    loadedKeys = _ref3.loadedKeys,
+    loadingKeys = _ref3.loadingKeys,
+    checkedKeys = _ref3.checkedKeys,
+    halfCheckedKeys = _ref3.halfCheckedKeys,
+    dragOverNodeKey = _ref3.dragOverNodeKey,
+    dropPosition = _ref3.dropPosition,
+    keyEntities = _ref3.keyEntities;
+  var entity = getEntity(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
+    // Since the interaction of drag is changed, the semantic of the props are
+    // not accuracy, I think it should be finally removed
+    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,
+    eventKey = props.eventKey;
+  var eventData = _objectSpread(_objectSpread({}, data), {}, {
+    expanded: expanded,
+    selected: selected,
+    checked: checked,
+    loaded: loaded,
+    loading: loading,
+    halfChecked: halfChecked,
+    dragOver: dragOver,
+    dragOverGapTop: dragOverGapTop,
+    dragOverGapBottom: dragOverGapBottom,
+    pos: pos,
+    active: active,
+    key: eventKey
+  });
+  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;
+}

frontend/node_modules/rc-tree/lib/DropIndicator.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface DropIndicatorProps {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+}
+declare const DropIndicator: React.FC<Readonly<DropIndicatorProps>>;
+export default DropIndicator;

frontend/node_modules/rc-tree/lib/DropIndicator.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var DropIndicator = function DropIndicator(props) {
+  var dropPosition = props.dropPosition,
+    dropLevelOffset = props.dropLevelOffset,
+    indent = props.indent;
+  var style = {
+    pointerEvents: 'none',
+    position: 'absolute',
+    right: 0,
+    backgroundColor: 'red',
+    height: 2
+  };
+  switch (dropPosition) {
+    case -1:
+      style.top = 0;
+      style.left = -dropLevelOffset * indent;
+      break;
+    case 1:
+      style.bottom = 0;
+      style.left = -dropLevelOffset * indent;
+      break;
+    case 0:
+      style.bottom = 0;
+      style.left = indent;
+      break;
+  }
+  return /*#__PURE__*/_react.default.createElement("div", {
+    style: style
+  });
+};
+if (process.env.NODE_ENV !== 'production') {
+  DropIndicator.displayName = 'DropIndicator';
+}
+var _default = exports.default = DropIndicator;

frontend/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 _default: React.NamedExoticComponent<IndentProps>;
+export default _default;

frontend/node_modules/rc-tree/lib/Indent.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var Indent = function Indent(_ref) {
+  var prefixCls = _ref.prefixCls,
+    level = _ref.level,
+    isStart = _ref.isStart,
+    isEnd = _ref.isEnd;
+  var baseClassName = "".concat(prefixCls, "-indent-unit");
+  var list = [];
+  for (var i = 0; i < level; i += 1) {
+    list.push( /*#__PURE__*/React.createElement("span", {
+      key: i,
+      className: (0, _classnames.default)(baseClassName, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, "".concat(baseClassName, "-start"), isStart[i]), "".concat(baseClassName, "-end"), isEnd[i]))
+    }));
+  }
+  return /*#__PURE__*/React.createElement("span", {
+    "aria-hidden": "true",
+    className: "".concat(prefixCls, "-indent")
+  }, list);
+};
+var _default = exports.default = /*#__PURE__*/React.memo(Indent);

frontend/node_modules/rc-tree/lib/MotionTreeNode.d.ts

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

frontend/node_modules/rc-tree/lib/MotionTreeNode.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectDestructuringEmpty2 = _interopRequireDefault(require("@babel/runtime/helpers/objectDestructuringEmpty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcMotion = _interopRequireDefault(require("rc-motion"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var React = _interopRequireWildcard(require("react"));
+var _contextTypes = require("./contextTypes");
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+var _useUnmount = _interopRequireDefault(require("./useUnmount"));
+var _treeUtil = require("./utils/treeUtil");
+var _excluded = ["className", "style", "motion", "motionNodes", "motionType", "onMotionStart", "onMotionEnd", "active", "treeNodeRequiredProps"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var MotionTreeNode = /*#__PURE__*/React.forwardRef(function (oriProps, ref) {
+  var className = oriProps.className,
+    style = oriProps.style,
+    motion = oriProps.motion,
+    motionNodes = oriProps.motionNodes,
+    motionType = oriProps.motionType,
+    onOriginMotionStart = oriProps.onMotionStart,
+    onOriginMotionEnd = oriProps.onMotionEnd,
+    active = oriProps.active,
+    treeNodeRequiredProps = oriProps.treeNodeRequiredProps,
+    props = (0, _objectWithoutProperties2.default)(oriProps, _excluded);
+  var _React$useState = React.useState(true),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    visible = _React$useState2[0],
+    setVisible = _React$useState2[1];
+  var _React$useContext = React.useContext(_contextTypes.TreeContext),
+    prefixCls = _React$useContext.prefixCls;
+
+  // Calculate target visible here.
+  // And apply in effect to make `leave` motion work.
+  var targetVisible = motionNodes && motionType !== 'hide';
+  (0, _useLayoutEffect.default)(function () {
+    if (motionNodes) {
+      if (targetVisible !== visible) {
+        setVisible(targetVisible);
+      }
+    }
+  }, [motionNodes]);
+  var triggerMotionStart = function triggerMotionStart() {
+    if (motionNodes) {
+      onOriginMotionStart();
+    }
+  };
+
+  // Should only trigger once
+  var triggerMotionEndRef = React.useRef(false);
+  var triggerMotionEnd = function triggerMotionEnd() {
+    if (motionNodes && !triggerMotionEndRef.current) {
+      triggerMotionEndRef.current = true;
+      onOriginMotionEnd();
+    }
+  };
+
+  // Effect if unmount
+  (0, _useUnmount.default)(triggerMotionStart, triggerMotionEnd);
+
+  // Motion end event
+  var onVisibleChanged = function onVisibleChanged(nextVisible) {
+    if (targetVisible === nextVisible) {
+      triggerMotionEnd();
+    }
+  };
+  if (motionNodes) {
+    return /*#__PURE__*/React.createElement(_rcMotion.default, (0, _extends2.default)({
+      ref: ref,
+      visible: visible
+    }, motion, {
+      motionAppear: motionType === 'show',
+      onVisibleChanged: onVisibleChanged
+    }), function (_ref, motionRef) {
+      var motionClassName = _ref.className,
+        motionStyle = _ref.style;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: motionRef,
+        className: (0, _classnames.default)("".concat(prefixCls, "-treenode-motion"), motionClassName),
+        style: motionStyle
+      }, motionNodes.map(function (treeNode) {
+        var restProps = Object.assign({}, ((0, _objectDestructuringEmpty2.default)(treeNode.data), treeNode.data)),
+          title = treeNode.title,
+          key = treeNode.key,
+          isStart = treeNode.isStart,
+          isEnd = treeNode.isEnd;
+        delete restProps.children;
+        var treeNodeProps = (0, _treeUtil.getTreeNodeProps)(key, treeNodeRequiredProps);
+        return /*#__PURE__*/React.createElement(_TreeNode.default, (0, _extends2.default)({}, restProps, treeNodeProps, {
+          title: title,
+          active: active,
+          data: treeNode.data,
+          key: key,
+          isStart: isStart,
+          isEnd: isEnd
+        }));
+      }));
+    });
+  }
+  return /*#__PURE__*/React.createElement(_TreeNode.default, (0, _extends2.default)({
+    domRef: ref,
+    className: className,
+    style: style
+  }, props, {
+    active: active
+  }));
+});
+if (process.env.NODE_ENV !== 'production') {
+  MotionTreeNode.displayName = 'MotionTreeNode';
+}
+var _default = exports.default = MotionTreeNode;

frontend/node_modules/rc-tree/lib/NodeList.d.ts

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

frontend/node_modules/rc-tree/lib/NodeList.js

@@ -0,0 +1,303 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.MotionEntity = exports.MOTION_KEY = void 0;
+exports.getMinimumRangeTransitionRange = getMinimumRangeTransitionRange;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectDestructuringEmpty2 = _interopRequireDefault(require("@babel/runtime/helpers/objectDestructuringEmpty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var _rcVirtualList = _interopRequireDefault(require("rc-virtual-list"));
+var React = _interopRequireWildcard(require("react"));
+var _MotionTreeNode = _interopRequireDefault(require("./MotionTreeNode"));
+var _diffUtil = require("./utils/diffUtil");
+var _treeUtil = require("./utils/treeUtil");
+var _excluded = ["prefixCls", "data", "selectable", "checkable", "expandedKeys", "selectedKeys", "checkedKeys", "loadedKeys", "loadingKeys", "halfCheckedKeys", "keyEntities", "disabled", "dragging", "dragOverNodeKey", "dropPosition", "motion", "height", "itemHeight", "virtual", "scrollWidth", "focusable", "activeItem", "focused", "tabIndex", "onKeyDown", "onFocus", "onBlur", "onActiveChange", "onListChangeStart", "onListChangeEnd"];
+/**
+ * Handle virtual list of the TreeNodes.
+ */
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 = exports.MOTION_KEY = "RC_TREE_MOTION_".concat(Math.random());
+var MotionNode = {
+  key: MOTION_KEY
+};
+var MotionEntity = exports.MotionEntity = {
+  key: MOTION_KEY,
+  level: 0,
+  index: 0,
+  pos: '0',
+  node: MotionNode,
+  nodes: [MotionNode]
+};
+var MotionFlattenData = {
+  parent: null,
+  children: [],
+  pos: MotionEntity.pos,
+  data: MotionNode,
+  title: null,
+  key: MOTION_KEY,
+  /** 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, virtual, height, itemHeight) {
+  if (virtual === false || !height) {
+    return list;
+  }
+  return list.slice(0, Math.ceil(height / itemHeight) + 1);
+}
+function itemKey(item) {
+  var key = item.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 NodeList = /*#__PURE__*/React.forwardRef(function (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,
+    scrollWidth = props.scrollWidth,
+    focusable = props.focusable,
+    activeItem = props.activeItem,
+    focused = props.focused,
+    tabIndex = props.tabIndex,
+    onKeyDown = props.onKeyDown,
+    onFocus = props.onFocus,
+    onBlur = props.onBlur,
+    onActiveChange = props.onActiveChange,
+    onListChangeStart = props.onListChangeStart,
+    onListChangeEnd = props.onListChangeEnd,
+    domProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+
+  // =============================== Ref ================================
+  var listRef = React.useRef(null);
+  var indentMeasurerRef = React.useRef(null);
+  React.useImperativeHandle(ref, function () {
+    return {
+      scrollTo: function scrollTo(scroll) {
+        listRef.current.scrollTo(scroll);
+      },
+      getIndentWidth: function getIndentWidth() {
+        return indentMeasurerRef.current.offsetWidth;
+      }
+    };
+  });
+
+  // ============================== Motion ==============================
+  var _React$useState = React.useState(expandedKeys),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    prevExpandedKeys = _React$useState2[0],
+    setPrevExpandedKeys = _React$useState2[1];
+  var _React$useState3 = React.useState(data),
+    _React$useState4 = (0, _slicedToArray2.default)(_React$useState3, 2),
+    prevData = _React$useState4[0],
+    setPrevData = _React$useState4[1];
+  var _React$useState5 = React.useState(data),
+    _React$useState6 = (0, _slicedToArray2.default)(_React$useState5, 2),
+    transitionData = _React$useState6[0],
+    setTransitionData = _React$useState6[1];
+  var _React$useState7 = React.useState([]),
+    _React$useState8 = (0, _slicedToArray2.default)(_React$useState7, 2),
+    transitionRange = _React$useState8[0],
+    setTransitionRange = _React$useState8[1];
+  var _React$useState9 = React.useState(null),
+    _React$useState10 = (0, _slicedToArray2.default)(_React$useState9, 2),
+    motionType = _React$useState10[0],
+    setMotionType = _React$useState10[1];
+
+  // When motion end but data change, this will makes data back to previous one
+  var dataRef = React.useRef(data);
+  dataRef.current = data;
+  function onMotionEnd() {
+    var latestData = dataRef.current;
+    setPrevData(latestData);
+    setTransitionData(latestData);
+    setTransitionRange([]);
+    setMotionType(null);
+    onListChangeEnd();
+  }
+
+  // Do animation if expanded keys changed
+  // layoutEffect here to avoid blink of node removing
+  (0, _useLayoutEffect.default)(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.key;
+          return key === diffExpanded.key;
+        });
+        var rangeNodes = getMinimumRangeTransitionRange((0, _diffUtil.getExpandRange)(prevData, data, diffExpanded.key), virtual, 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.key;
+          return key === diffExpanded.key;
+        });
+        var _rangeNodes = getMinimumRangeTransitionRange((0, _diffUtil.getExpandRange)(data, prevData, diffExpanded.key), virtual, 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 /*#__PURE__*/React.createElement(React.Fragment, null, focused && activeItem && /*#__PURE__*/React.createElement("span", {
+    style: HIDDEN_STYLE,
+    "aria-live": "assertive"
+  }, getAccessibilityPath(activeItem)), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("input", {
+    style: HIDDEN_STYLE,
+    disabled: focusable === false || disabled,
+    tabIndex: focusable !== false ? tabIndex : null,
+    onKeyDown: onKeyDown,
+    onFocus: onFocus,
+    onBlur: onBlur,
+    value: "",
+    onChange: noop,
+    "aria-label": "for screen reader"
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-treenode"),
+    "aria-hidden": true,
+    style: {
+      position: 'absolute',
+      pointerEvents: 'none',
+      visibility: 'hidden',
+      height: 0,
+      overflow: 'hidden',
+      border: 0,
+      padding: 0
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-indent")
+  }, /*#__PURE__*/React.createElement("div", {
+    ref: indentMeasurerRef,
+    className: "".concat(prefixCls, "-indent-unit")
+  }))), /*#__PURE__*/React.createElement(_rcVirtualList.default, (0, _extends2.default)({}, domProps, {
+    data: mergedData,
+    itemKey: itemKey,
+    height: height,
+    fullHeight: false,
+    virtual: virtual,
+    itemHeight: itemHeight,
+    scrollWidth: scrollWidth,
+    prefixCls: "".concat(prefixCls, "-list"),
+    ref: listRef,
+    role: "tree",
+    onVisibleChange: function onVisibleChange(originList) {
+      // The best match is using `fullList` - `originList` = `restList`
+      // and check the `restList` to see if has the MOTION_KEY node
+      // but this will cause performance issue for long list compare
+      // we just check `originList` and repeat trigger `onMotionEnd`
+      if (originList.every(function (item) {
+        return itemKey(item) !== MOTION_KEY;
+      })) {
+        onMotionEnd();
+      }
+    }
+  }), function (treeNode) {
+    var pos = treeNode.pos,
+      restProps = Object.assign({}, ((0, _objectDestructuringEmpty2.default)(treeNode.data), treeNode.data)),
+      title = treeNode.title,
+      key = treeNode.key,
+      isStart = treeNode.isStart,
+      isEnd = treeNode.isEnd;
+    var mergedKey = (0, _treeUtil.getKey)(key, pos);
+    delete restProps.key;
+    delete restProps.children;
+    var treeNodeProps = (0, _treeUtil.getTreeNodeProps)(mergedKey, treeNodeRequiredProps);
+    return /*#__PURE__*/React.createElement(_MotionTreeNode.default, (0, _extends2.default)({}, restProps, treeNodeProps, {
+      title: title,
+      active: !!activeItem && key === activeItem.key,
+      pos: pos,
+      data: treeNode.data,
+      isStart: isStart,
+      isEnd: isEnd,
+      motion: motion,
+      motionNodes: key === MOTION_KEY ? transitionRange : null,
+      motionType: motionType,
+      onMotionStart: onListChangeStart,
+      onMotionEnd: onMotionEnd,
+      treeNodeRequiredProps: treeNodeRequiredProps,
+      onMouseMove: function onMouseMove() {
+        onActiveChange(null);
+      }
+    }));
+  }));
+});
+if (process.env.NODE_ENV !== 'production') {
+  NodeList.displayName = 'NodeList';
+}
+var _default = exports.default = NodeList;

frontend/node_modules/rc-tree/lib/Tree.d.ts

@@ -0,0 +1,245 @@
+import * as React from 'react';
+import type { NodeDragEventHandler, NodeDragEventParams, NodeMouseEventHandler, NodeMouseEventParams } from './contextTypes';
+import type { DropIndicatorProps } from './DropIndicator';
+import type { BasicDataNode, DataNode, Direction, EventDataNode, FieldNames, FlattenNode, IconType, Key, KeyEntities, SafeKey, ScrollTo, TreeNodeProps } from './interface';
+import { type NodeListRef } from './NodeList';
+export interface CheckInfo<TreeDataType extends BasicDataNode = DataNode> {
+    event: 'check';
+    node: EventDataNode<TreeDataType>;
+    checked: boolean;
+    nativeEvent: MouseEvent;
+    checkedNodes: TreeDataType[];
+    checkedNodesPositions?: {
+        node: TreeDataType;
+        pos: string;
+    }[];
+    halfCheckedKeys?: Key[];
+}
+export interface AllowDropOptions<TreeDataType extends BasicDataNode = DataNode> {
+    dragNode: TreeDataType;
+    dropNode: TreeDataType;
+    dropPosition: -1 | 0 | 1;
+}
+export type AllowDrop<TreeDataType extends BasicDataNode = DataNode> = (options: AllowDropOptions<TreeDataType>) => boolean;
+export type DraggableFn = (node: DataNode) => boolean;
+export type DraggableConfig = {
+    icon?: React.ReactNode | false;
+    nodeDraggable?: DraggableFn;
+};
+export type ExpandAction = false | 'click' | 'doubleClick';
+export interface TreeProps<TreeDataType extends BasicDataNode = DataNode> {
+    prefixCls: string;
+    className?: string;
+    style?: React.CSSProperties;
+    focusable?: boolean;
+    activeKey?: Key | null;
+    tabIndex?: number;
+    children?: React.ReactNode;
+    treeData?: TreeDataType[];
+    fieldNames?: FieldNames;
+    showLine?: boolean;
+    showIcon?: boolean;
+    icon?: IconType;
+    selectable?: boolean;
+    expandAction?: ExpandAction;
+    disabled?: boolean;
+    multiple?: boolean;
+    checkable?: boolean | React.ReactNode;
+    checkStrictly?: boolean;
+    draggable?: DraggableFn | boolean | DraggableConfig;
+    defaultExpandParent?: boolean;
+    autoExpandParent?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: Key[];
+    expandedKeys?: Key[];
+    defaultCheckedKeys?: Key[];
+    checkedKeys?: Key[] | {
+        checked: Key[];
+        halfChecked: Key[];
+    };
+    defaultSelectedKeys?: Key[];
+    selectedKeys?: Key[];
+    allowDrop?: AllowDrop<TreeDataType>;
+    titleRender?: (node: TreeDataType) => React.ReactNode;
+    dropIndicatorRender?: (props: DropIndicatorProps) => React.ReactNode;
+    onFocus?: React.FocusEventHandler<HTMLDivElement>;
+    onBlur?: React.FocusEventHandler<HTMLDivElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLDivElement>;
+    onClick?: NodeMouseEventHandler<TreeDataType>;
+    onDoubleClick?: NodeMouseEventHandler<TreeDataType>;
+    onScroll?: React.UIEventHandler<HTMLElement>;
+    onExpand?: (expandedKeys: Key[], info: {
+        node: EventDataNode<TreeDataType>;
+        expanded: boolean;
+        nativeEvent: MouseEvent;
+    }) => void;
+    onCheck?: (checked: {
+        checked: Key[];
+        halfChecked: Key[];
+    } | Key[], info: CheckInfo<TreeDataType>) => void;
+    onSelect?: (selectedKeys: Key[], info: {
+        event: 'select';
+        selected: boolean;
+        node: EventDataNode<TreeDataType>;
+        selectedNodes: TreeDataType[];
+        nativeEvent: MouseEvent;
+    }) => void;
+    onLoad?: (loadedKeys: Key[], info: {
+        event: 'load';
+        node: EventDataNode<TreeDataType>;
+    }) => void;
+    loadData?: (treeNode: EventDataNode<TreeDataType>) => Promise<any>;
+    loadedKeys?: Key[];
+    onMouseEnter?: (info: NodeMouseEventParams<TreeDataType>) => void;
+    onMouseLeave?: (info: NodeMouseEventParams<TreeDataType>) => void;
+    onRightClick?: (info: {
+        event: React.MouseEvent;
+        node: EventDataNode<TreeDataType>;
+    }) => void;
+    onDragStart?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDragEnter?: (info: NodeDragEventParams<TreeDataType> & {
+        expandedKeys: Key[];
+    }) => void;
+    onDragOver?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDragLeave?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDragEnd?: (info: NodeDragEventParams<TreeDataType>) => void;
+    onDrop?: (info: NodeDragEventParams<TreeDataType> & {
+        dragNode: EventDataNode<TreeDataType>;
+        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<TreeDataType>) => boolean;
+    motion?: any;
+    switcherIcon?: IconType;
+    height?: number;
+    itemHeight?: number;
+    scrollWidth?: number;
+    itemScrollOffset?: number;
+    virtual?: boolean;
+    direction?: Direction;
+    rootClassName?: string;
+    rootStyle?: React.CSSProperties;
+}
+interface TreeState<TreeDataType extends BasicDataNode = DataNode> {
+    keyEntities: KeyEntities<TreeDataType>;
+    indent: number | null;
+    selectedKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    expandedKeys: Key[];
+    draggingNodeKey: Key;
+    dragChildrenKeys: Key[];
+    dropPosition: -1 | 0 | 1 | null;
+    dropLevelOffset: number | null;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropTargetPos: string | null;
+    dropAllowed: boolean;
+    dragOverNodeKey: Key | null;
+    treeData: TreeDataType[];
+    flattenNodes: FlattenNode<TreeDataType>[];
+    focused: boolean;
+    activeKey: Key | null;
+    listChanging: boolean;
+    prevProps: TreeProps;
+    fieldNames: FieldNames;
+}
+declare class Tree<TreeDataType extends DataNode | BasicDataNode = DataNode> extends React.Component<TreeProps<TreeDataType>, TreeState<TreeDataType>> {
+    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[];
+        dropIndicatorRender: React.FC<Readonly<DropIndicatorProps>>;
+        allowDrop: () => boolean;
+        expandAction: boolean;
+    };
+    static TreeNode: React.FC<Readonly<TreeNodeProps<DataNode>>>;
+    destroyed: boolean;
+    delayedDragEnterLogic: Record<SafeKey, number>;
+    loadingRetryTimes: Record<SafeKey, number>;
+    state: TreeState<TreeDataType>;
+    dragStartMousePosition: any;
+    dragNodeProps: TreeNodeProps<TreeDataType>;
+    currentMouseOverDroppableNodeKey: any;
+    listRef: React.RefObject<NodeListRef>;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    onUpdated(): void;
+    componentWillUnmount(): void;
+    static getDerivedStateFromProps(props: TreeProps, prevState: TreeState): Partial<TreeState<DataNode>>;
+    onNodeDragStart: NodeDragEventHandler<TreeDataType, HTMLDivElement>;
+    /**
+     * [Legacy] Select handler is smaller 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.DragEvent<HTMLDivElement>, nodeProps: TreeNodeProps<TreeDataType>) => void;
+    onNodeDragOver: (event: React.DragEvent<HTMLDivElement>, nodeProps: TreeNodeProps<TreeDataType>) => void;
+    onNodeDragLeave: NodeDragEventHandler<TreeDataType>;
+    onWindowDragEnd: (event: any) => void;
+    onNodeDragEnd: NodeDragEventHandler<TreeDataType>;
+    onNodeDrop: (event: React.DragEvent<HTMLDivElement>, _: TreeNodeProps<TreeDataType>, outsideTree?: boolean) => void;
+    resetDragState(): void;
+    cleanDragState: () => void;
+    triggerExpandActionExpand: NodeMouseEventHandler;
+    onNodeClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeDoubleClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeSelect: NodeMouseEventHandler<TreeDataType>;
+    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode<TreeDataType>, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode<TreeDataType>) => Promise<void>;
+    onNodeMouseEnter: NodeMouseEventHandler<TreeDataType>;
+    onNodeMouseLeave: NodeMouseEventHandler<TreeDataType>;
+    onNodeContextMenu: NodeMouseEventHandler<TreeDataType>;
+    onFocus: React.FocusEventHandler<HTMLDivElement>;
+    onBlur: React.FocusEventHandler<HTMLDivElement>;
+    getTreeNodeRequiredProps: () => {
+        expandedKeys: React.Key[];
+        selectedKeys: React.Key[];
+        loadedKeys: React.Key[];
+        loadingKeys: React.Key[];
+        checkedKeys: React.Key[];
+        halfCheckedKeys: React.Key[];
+        dragOverNodeKey: React.Key;
+        dropPosition: 0 | 1 | -1;
+        keyEntities: KeyEntities<TreeDataType>;
+    };
+    /** Set uncontrolled `expandedKeys`. This will also auto update `flattenNodes`. */
+    setExpandedKeys: (expandedKeys: Key[]) => void;
+    onNodeExpand: (e: React.MouseEvent<HTMLDivElement>, treeNode: EventDataNode<TreeDataType>) => void;
+    onListChangeStart: () => void;
+    onListChangeEnd: () => void;
+    onActiveChange: (newActiveKey: Key | null) => void;
+    getActiveItem: () => FlattenNode<TreeDataType>;
+    offsetActiveKey: (offset: number) => void;
+    onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    /**
+     * Only update the value which is not in props
+     */
+    setUncontrolledState: (state: Partial<TreeState<TreeDataType>>, atomic?: boolean, forceState?: Partial<TreeState<TreeDataType>> | null) => void;
+    scrollTo: ScrollTo;
+    render(): React.JSX.Element;
+}
+export default Tree;

frontend/node_modules/rc-tree/lib/TreeNode.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { TreeNodeProps } from './interface';
+export type { TreeNodeProps } from './interface';
+declare const TreeNode: React.FC<Readonly<TreeNodeProps>>;
+export default TreeNode;

frontend/node_modules/rc-tree/lib/TreeNode.js

@@ -0,0 +1,361 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireDefault(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _pickAttrs = _interopRequireDefault(require("rc-util/lib/pickAttrs"));
+var _contextTypes = require("./contextTypes");
+var _Indent = _interopRequireDefault(require("./Indent"));
+var _keyUtil = _interopRequireDefault(require("./utils/keyUtil"));
+var _treeUtil = require("./utils/treeUtil");
+var _excluded = ["eventKey", "className", "style", "dragOver", "dragOverGapTop", "dragOverGapBottom", "isLeaf", "isStart", "isEnd", "expanded", "selected", "checked", "halfChecked", "loading", "domRef", "active", "data", "onMouseMove", "selectable"];
+var ICON_OPEN = 'open';
+var ICON_CLOSE = 'close';
+var defaultTitle = '---';
+var TreeNode = function TreeNode(props) {
+  var _unstableContext$node, _context$filterTreeNo, _classNames4;
+  var eventKey = props.eventKey,
+    className = props.className,
+    style = props.style,
+    dragOver = props.dragOver,
+    dragOverGapTop = props.dragOverGapTop,
+    dragOverGapBottom = props.dragOverGapBottom,
+    isLeaf = props.isLeaf,
+    isStart = props.isStart,
+    isEnd = props.isEnd,
+    expanded = props.expanded,
+    selected = props.selected,
+    checked = props.checked,
+    halfChecked = props.halfChecked,
+    loading = props.loading,
+    domRef = props.domRef,
+    active = props.active,
+    data = props.data,
+    onMouseMove = props.onMouseMove,
+    selectable = props.selectable,
+    otherProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var context = _react.default.useContext(_contextTypes.TreeContext);
+  var unstableContext = _react.default.useContext(_contextTypes.UnstableContext);
+  var selectHandleRef = _react.default.useRef(null);
+  var _React$useState = _react.default.useState(false),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    dragNodeHighlight = _React$useState2[0],
+    setDragNodeHighlight = _React$useState2[1];
+
+  // ======= State: Disabled State =======
+  var isDisabled = !!(context.disabled || props.disabled || (_unstableContext$node = unstableContext.nodeDisabled) !== null && _unstableContext$node !== void 0 && _unstableContext$node.call(unstableContext, data));
+  var isCheckable = _react.default.useMemo(function () {
+    // Return false if tree or treeNode is not checkable
+    if (!context.checkable || props.checkable === false) {
+      return false;
+    }
+    return context.checkable;
+  }, [context.checkable, props.checkable]);
+
+  // ======= Event Handlers: Selection and Check =======
+  var onSelect = function onSelect(e) {
+    if (isDisabled) {
+      return;
+    }
+    context.onNodeSelect(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+  };
+  var onCheck = function onCheck(e) {
+    if (isDisabled) {
+      return;
+    }
+    if (!isCheckable || props.disableCheckbox) {
+      return;
+    }
+    context.onNodeCheck(e, (0, _treeUtil.convertNodePropsToEventData)(props), !checked);
+  };
+
+  // ======= State: Selectable Check =======
+  var isSelectable = _react.default.useMemo(function () {
+    // Ignore when selectable is undefined or null
+    if (typeof selectable === 'boolean') {
+      return selectable;
+    }
+    return context.selectable;
+  }, [selectable, context.selectable]);
+  var onSelectorClick = function onSelectorClick(e) {
+    // Click trigger before select/check operation
+    context.onNodeClick(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+    if (isSelectable) {
+      onSelect(e);
+    } else {
+      onCheck(e);
+    }
+  };
+  var onSelectorDoubleClick = function onSelectorDoubleClick(e) {
+    context.onNodeDoubleClick(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+  };
+  var onMouseEnter = function onMouseEnter(e) {
+    context.onNodeMouseEnter(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+  };
+  var onMouseLeave = function onMouseLeave(e) {
+    context.onNodeMouseLeave(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+  };
+  var onContextMenu = function onContextMenu(e) {
+    context.onNodeContextMenu(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+  };
+
+  // ======= Drag: Drag Enabled =======
+  var isDraggable = _react.default.useMemo(function () {
+    return !!(context.draggable && (!context.draggable.nodeDraggable || context.draggable.nodeDraggable(data)));
+  }, [context.draggable, data]);
+
+  // ======= Drag: Drag Event Handlers =======
+  var onDragStart = function onDragStart(e) {
+    e.stopPropagation();
+    setDragNodeHighlight(true);
+    context.onNodeDragStart(e, props);
+    try {
+      // ie throw error
+      // firefox-need-it
+      e.dataTransfer.setData('text/plain', '');
+    } catch (_unused) {
+      // empty
+    }
+  };
+  var onDragEnter = function onDragEnter(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    context.onNodeDragEnter(e, props);
+  };
+  var onDragOver = function onDragOver(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    context.onNodeDragOver(e, props);
+  };
+  var onDragLeave = function onDragLeave(e) {
+    e.stopPropagation();
+    context.onNodeDragLeave(e, props);
+  };
+  var onDragEnd = function onDragEnd(e) {
+    e.stopPropagation();
+    setDragNodeHighlight(false);
+    context.onNodeDragEnd(e, props);
+  };
+  var onDrop = function onDrop(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    setDragNodeHighlight(false);
+    context.onNodeDrop(e, props);
+  };
+
+  // ======= Expand: Node Expansion =======
+  var onExpand = function onExpand(e) {
+    if (loading) {
+      return;
+    }
+    context.onNodeExpand(e, (0, _treeUtil.convertNodePropsToEventData)(props));
+  };
+
+  // ======= State: Has Children =======
+  var hasChildren = _react.default.useMemo(function () {
+    var _ref = (0, _keyUtil.default)(context.keyEntities, eventKey) || {},
+      children = _ref.children;
+    return Boolean((children || []).length);
+  }, [context.keyEntities, eventKey]);
+
+  // ======= State: Leaf Check =======
+  var memoizedIsLeaf = _react.default.useMemo(function () {
+    if (isLeaf === false) {
+      return false;
+    }
+    return isLeaf || !context.loadData && !hasChildren || context.loadData && props.loaded && !hasChildren;
+  }, [isLeaf, context.loadData, hasChildren, props.loaded]);
+
+  // ============== Effect ==============
+  _react.default.useEffect(function () {
+    // Load data to avoid default expanded tree without data
+    if (loading) {
+      return;
+    }
+    // read from state to avoid loadData at same time
+    if (typeof context.loadData === 'function' && expanded && !memoizedIsLeaf && !props.loaded) {
+      // We needn't reload data when has children in sync logic
+      // It's only needed in node expanded
+      context.onNodeLoad((0, _treeUtil.convertNodePropsToEventData)(props));
+    }
+  }, [loading, context.loadData, context.onNodeLoad, expanded, memoizedIsLeaf, props]);
+
+  // ==================== Render: Drag Handler ====================
+  var dragHandlerNode = _react.default.useMemo(function () {
+    var _context$draggable;
+    if (!((_context$draggable = context.draggable) !== null && _context$draggable !== void 0 && _context$draggable.icon)) {
+      return null;
+    }
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: "".concat(context.prefixCls, "-draggable-icon")
+    }, context.draggable.icon);
+  }, [context.draggable]);
+
+  // ====================== Render: Switcher ======================
+  var renderSwitcherIconDom = function renderSwitcherIconDom(isInternalLeaf) {
+    var switcherIcon = props.switcherIcon || context.switcherIcon;
+    // if switcherIconDom is null, no render switcher span
+    if (typeof switcherIcon === 'function') {
+      return switcherIcon((0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+        isLeaf: isInternalLeaf
+      }));
+    }
+    return switcherIcon;
+  };
+
+  // Switcher
+  var renderSwitcher = function renderSwitcher() {
+    if (memoizedIsLeaf) {
+      // if switcherIconDom is null, no render switcher span
+      var _switcherIconDom = renderSwitcherIconDom(true);
+      return _switcherIconDom !== false ? /*#__PURE__*/_react.default.createElement("span", {
+        className: (0, _classnames.default)("".concat(context.prefixCls, "-switcher"), "".concat(context.prefixCls, "-switcher-noop"))
+      }, _switcherIconDom) : null;
+    }
+    var switcherIconDom = renderSwitcherIconDom(false);
+    return switcherIconDom !== false ? /*#__PURE__*/_react.default.createElement("span", {
+      onClick: onExpand,
+      className: (0, _classnames.default)("".concat(context.prefixCls, "-switcher"), "".concat(context.prefixCls, "-switcher_").concat(expanded ? ICON_OPEN : ICON_CLOSE))
+    }, switcherIconDom) : null;
+  };
+
+  // ====================== Checkbox ======================
+  var checkboxNode = _react.default.useMemo(function () {
+    if (!isCheckable) {
+      return null;
+    }
+
+    // [Legacy] Custom element should be separate with `checkable` in future
+    var $custom = typeof isCheckable !== 'boolean' ? isCheckable : null;
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: (0, _classnames.default)("".concat(context.prefixCls, "-checkbox"), (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, "".concat(context.prefixCls, "-checkbox-checked"), checked), "".concat(context.prefixCls, "-checkbox-indeterminate"), !checked && halfChecked), "".concat(context.prefixCls, "-checkbox-disabled"), isDisabled || props.disableCheckbox)),
+      onClick: onCheck,
+      role: "checkbox",
+      "aria-checked": halfChecked ? 'mixed' : checked,
+      "aria-disabled": isDisabled || props.disableCheckbox,
+      "aria-label": "Select ".concat(typeof props.title === 'string' ? props.title : 'tree node')
+    }, $custom);
+  }, [isCheckable, checked, halfChecked, isDisabled, props.disableCheckbox, props.title]);
+
+  // ============== State: Node State (Open/Close) ==============
+  var nodeState = _react.default.useMemo(function () {
+    if (memoizedIsLeaf) {
+      return null;
+    }
+    return expanded ? ICON_OPEN : ICON_CLOSE;
+  }, [memoizedIsLeaf, expanded]);
+
+  // ==================== Render: Title + Icon ====================
+  var iconNode = _react.default.useMemo(function () {
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: (0, _classnames.default)("".concat(context.prefixCls, "-iconEle"), "".concat(context.prefixCls, "-icon__").concat(nodeState || 'docu'), (0, _defineProperty2.default)({}, "".concat(context.prefixCls, "-icon_loading"), loading))
+    });
+  }, [context.prefixCls, nodeState, loading]);
+
+  // =================== Drop Indicator ===================
+  var dropIndicatorNode = _react.default.useMemo(function () {
+    var rootDraggable = Boolean(context.draggable);
+    // allowDrop is calculated in Tree.tsx, there is no need for calc it here
+    var showIndicator = !props.disabled && rootDraggable && context.dragOverNodeKey === eventKey;
+    if (!showIndicator) {
+      return null;
+    }
+    return context.dropIndicatorRender({
+      dropPosition: context.dropPosition,
+      dropLevelOffset: context.dropLevelOffset,
+      indent: context.indent,
+      prefixCls: context.prefixCls,
+      direction: context.direction
+    });
+  }, [context.dropPosition, context.dropLevelOffset, context.indent, context.prefixCls, context.direction, context.draggable, context.dragOverNodeKey, context.dropIndicatorRender]);
+
+  // Icon + Title
+  var selectorNode = _react.default.useMemo(function () {
+    var _props$title = props.title,
+      title = _props$title === void 0 ? defaultTitle : _props$title;
+    var wrapClass = "".concat(context.prefixCls, "-node-content-wrapper");
+
+    // Icon - Still show loading icon when loading without showIcon
+    var $icon;
+    if (context.showIcon) {
+      var currentIcon = props.icon || context.icon;
+      $icon = currentIcon ? /*#__PURE__*/_react.default.createElement("span", {
+        className: (0, _classnames.default)("".concat(context.prefixCls, "-iconEle"), "".concat(context.prefixCls, "-icon__customize"))
+      }, typeof currentIcon === 'function' ? currentIcon(props) : currentIcon) : iconNode;
+    } else if (context.loadData && loading) {
+      $icon = iconNode;
+    }
+
+    // Title
+    var titleNode;
+    if (typeof title === 'function') {
+      titleNode = title(data);
+    } else if (context.titleRender) {
+      titleNode = context.titleRender(data);
+    } else {
+      titleNode = title;
+    }
+    return /*#__PURE__*/_react.default.createElement("span", {
+      ref: selectHandleRef,
+      title: typeof title === 'string' ? title : '',
+      className: (0, _classnames.default)(wrapClass, "".concat(wrapClass, "-").concat(nodeState || 'normal'), (0, _defineProperty2.default)({}, "".concat(context.prefixCls, "-node-selected"), !isDisabled && (selected || dragNodeHighlight))),
+      onMouseEnter: onMouseEnter,
+      onMouseLeave: onMouseLeave,
+      onContextMenu: onContextMenu,
+      onClick: onSelectorClick,
+      onDoubleClick: onSelectorDoubleClick
+    }, $icon, /*#__PURE__*/_react.default.createElement("span", {
+      className: "".concat(context.prefixCls, "-title")
+    }, titleNode), dropIndicatorNode);
+  }, [context.prefixCls, context.showIcon, props, context.icon, iconNode, context.titleRender, data, nodeState, onMouseEnter, onMouseLeave, onContextMenu, onSelectorClick, onSelectorDoubleClick]);
+  var dataOrAriaAttributeProps = (0, _pickAttrs.default)(otherProps, {
+    aria: true,
+    data: true
+  });
+  var _ref2 = (0, _keyUtil.default)(context.keyEntities, eventKey) || {},
+    level = _ref2.level;
+  var isEndNode = isEnd[isEnd.length - 1];
+  var draggableWithoutDisabled = !isDisabled && isDraggable;
+  var dragging = context.draggingNodeKey === eventKey;
+  var ariaSelected = selectable !== undefined ? {
+    'aria-selected': !!selectable
+  } : undefined;
+  return /*#__PURE__*/_react.default.createElement("div", (0, _extends2.default)({
+    ref: domRef,
+    role: "treeitem",
+    "aria-expanded": isLeaf ? undefined : expanded,
+    className: (0, _classnames.default)(className, "".concat(context.prefixCls, "-treenode"), (_classNames4 = {}, (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)(_classNames4, "".concat(context.prefixCls, "-treenode-disabled"), isDisabled), "".concat(context.prefixCls, "-treenode-switcher-").concat(expanded ? 'open' : 'close'), !isLeaf), "".concat(context.prefixCls, "-treenode-checkbox-checked"), checked), "".concat(context.prefixCls, "-treenode-checkbox-indeterminate"), halfChecked), "".concat(context.prefixCls, "-treenode-selected"), selected), "".concat(context.prefixCls, "-treenode-loading"), loading), "".concat(context.prefixCls, "-treenode-active"), active), "".concat(context.prefixCls, "-treenode-leaf-last"), isEndNode), "".concat(context.prefixCls, "-treenode-draggable"), isDraggable), "dragging", dragging), (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)(_classNames4, 'drop-target', context.dropTargetKey === eventKey), 'drop-container', context.dropContainerKey === eventKey), 'drag-over', !isDisabled && dragOver), 'drag-over-gap-top', !isDisabled && dragOverGapTop), 'drag-over-gap-bottom', !isDisabled && dragOverGapBottom), 'filter-node', (_context$filterTreeNo = context.filterTreeNode) === null || _context$filterTreeNo === void 0 ? void 0 : _context$filterTreeNo.call(context, (0, _treeUtil.convertNodePropsToEventData)(props))), "".concat(context.prefixCls, "-treenode-leaf"), memoizedIsLeaf))),
+    style: style
+    // Draggable config
+    ,
+    draggable: draggableWithoutDisabled,
+    onDragStart: draggableWithoutDisabled ? onDragStart : undefined
+    // Drop config
+    ,
+    onDragEnter: isDraggable ? onDragEnter : undefined,
+    onDragOver: isDraggable ? onDragOver : undefined,
+    onDragLeave: isDraggable ? onDragLeave : undefined,
+    onDrop: isDraggable ? onDrop : undefined,
+    onDragEnd: isDraggable ? onDragEnd : undefined,
+    onMouseMove: onMouseMove
+  }, ariaSelected, dataOrAriaAttributeProps), /*#__PURE__*/_react.default.createElement(_Indent.default, {
+    prefixCls: context.prefixCls,
+    level: level,
+    isStart: isStart,
+    isEnd: isEnd
+  }), dragHandlerNode, renderSwitcher(), checkboxNode, selectorNode);
+};
+TreeNode.isTreeNode = 1;
+if (process.env.NODE_ENV !== 'production') {
+  TreeNode.displayName = 'TreeNode';
+}
+var _default = exports.default = TreeNode;

frontend/node_modules/rc-tree/lib/contextTypes.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Webpack has bug for import loop, which is not the same behavior as ES module.
+ * When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
+ */
+import * as React from 'react';
+import type { BasicDataNode, DataNode, Direction, EventDataNode, IconType, Key, KeyEntities, TreeNodeProps } from './interface';
+import type { DraggableConfig } from './Tree';
+export type NodeMouseEventParams<TreeDataType extends BasicDataNode = DataNode, T = HTMLSpanElement> = {
+    event: React.MouseEvent<T>;
+    node: EventDataNode<TreeDataType>;
+};
+export type NodeDragEventParams<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = {
+    event: React.DragEvent<T>;
+    node: EventDataNode<TreeDataType>;
+};
+export type NodeMouseEventHandler<TreeDataType extends BasicDataNode = DataNode, T = HTMLSpanElement> = (e: React.MouseEvent<T>, node: EventDataNode<TreeDataType>) => void;
+export type NodeDragEventHandler<TreeDataType extends BasicDataNode = DataNode, T = HTMLDivElement> = (e: React.DragEvent<T>, nodeProps: TreeNodeProps<TreeDataType>, outsideTree?: boolean) => void;
+export interface TreeContextProps<TreeDataType extends BasicDataNode = DataNode> {
+    prefixCls: string;
+    selectable: boolean;
+    showIcon: boolean;
+    icon: IconType;
+    switcherIcon: IconType;
+    draggable?: DraggableConfig;
+    draggingNodeKey?: Key;
+    checkable: boolean | React.ReactNode;
+    checkStrictly: boolean;
+    disabled: boolean;
+    keyEntities: KeyEntities;
+    dropLevelOffset?: number;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropPosition: -1 | 0 | 1 | null;
+    indent: number | null;
+    dropIndicatorRender: (props: {
+        dropPosition: -1 | 0 | 1;
+        dropLevelOffset: number;
+        indent: number;
+        prefixCls: string;
+        direction: Direction;
+    }) => React.ReactNode;
+    dragOverNodeKey: Key | null;
+    direction: Direction;
+    loadData: (treeNode: EventDataNode<TreeDataType>) => Promise<void>;
+    filterTreeNode: (treeNode: EventDataNode<TreeDataType>) => boolean;
+    titleRender?: (node: any) => React.ReactNode;
+    onNodeClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeDoubleClick: NodeMouseEventHandler<TreeDataType>;
+    onNodeExpand: NodeMouseEventHandler<TreeDataType>;
+    onNodeSelect: NodeMouseEventHandler<TreeDataType>;
+    onNodeCheck: (e: React.MouseEvent<HTMLSpanElement>, treeNode: EventDataNode<TreeDataType>, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode<TreeDataType>) => void;
+    onNodeMouseEnter: NodeMouseEventHandler<TreeDataType>;
+    onNodeMouseLeave: NodeMouseEventHandler<TreeDataType>;
+    onNodeContextMenu: NodeMouseEventHandler<TreeDataType>;
+    onNodeDragStart: NodeDragEventHandler<any, any>;
+    onNodeDragEnter: NodeDragEventHandler<any, any>;
+    onNodeDragOver: NodeDragEventHandler<any, any>;
+    onNodeDragLeave: NodeDragEventHandler<any, any>;
+    onNodeDragEnd: NodeDragEventHandler<any, any>;
+    onNodeDrop: NodeDragEventHandler<any, any>;
+}
+export declare const TreeContext: React.Context<TreeContextProps<any>>;
+/** Internal usage, safe to remove. Do not use in prod */
+export declare const UnstableContext: React.Context<{
+    nodeDisabled?: (n: DataNode) => boolean;
+}>;

frontend/node_modules/rc-tree/lib/contextTypes.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnstableContext = exports.TreeContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * 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 = exports.TreeContext = /*#__PURE__*/React.createContext(null);
+
+/** Internal usage, safe to remove. Do not use in prod */
+var UnstableContext = exports.UnstableContext = /*#__PURE__*/React.createContext({});

frontend/node_modules/rc-tree/lib/index.d.ts

@@ -0,0 +1,8 @@
+import Tree from './Tree';
+import TreeNode from './TreeNode';
+import type { TreeProps } from './Tree';
+import type { TreeNodeProps, BasicDataNode, FieldDataNode } from './interface';
+import { UnstableContext } from './contextTypes';
+export { TreeNode, UnstableContext };
+export type { TreeProps, TreeNodeProps, BasicDataNode, FieldDataNode };
+export default Tree;

frontend/node_modules/rc-tree/lib/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TreeNode", {
+  enumerable: true,
+  get: function get() {
+    return _TreeNode.default;
+  }
+});
+Object.defineProperty(exports, "UnstableContext", {
+  enumerable: true,
+  get: function get() {
+    return _contextTypes.UnstableContext;
+  }
+});
+exports.default = void 0;
+var _Tree = _interopRequireDefault(require("./Tree"));
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+var _contextTypes = require("./contextTypes");
+var _default = exports.default = _Tree.default;

frontend/node_modules/rc-tree/lib/interface.d.ts

@@ -0,0 +1,122 @@
+import * as React from 'react';
+export type { ScrollTo } from 'rc-virtual-list/lib/List';
+export interface TreeNodeProps<TreeDataType extends BasicDataNode = DataNode> {
+    eventKey?: Key;
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    id?: string;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    halfChecked?: boolean;
+    title?: React.ReactNode | ((data: TreeDataType) => React.ReactNode);
+    dragOver?: boolean;
+    dragOverGapTop?: boolean;
+    dragOverGapBottom?: boolean;
+    pos?: string;
+    domRef?: React.Ref<HTMLDivElement>;
+    /** New added in Tree for easy data access */
+    data?: TreeDataType;
+    isStart?: boolean[];
+    isEnd?: boolean[];
+    active?: boolean;
+    onMouseMove?: React.MouseEventHandler<HTMLDivElement>;
+    isLeaf?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    switcherIcon?: IconType;
+    children?: React.ReactNode;
+}
+/** For fieldNames, we provides a abstract interface */
+export interface BasicDataNode {
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    isLeaf?: boolean;
+    selectable?: boolean;
+    switcherIcon?: IconType;
+    /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
+    className?: string;
+    style?: React.CSSProperties;
+}
+/** Provide a wrap type define for developer to wrap with customize fieldNames data type */
+export type FieldDataNode<T, ChildFieldName extends string = 'children'> = BasicDataNode & T & Partial<Record<ChildFieldName, FieldDataNode<T, ChildFieldName>[]>>;
+export type Key = React.Key;
+/**
+ * Typescript not support `bigint` as index type yet.
+ * We use this to mark the `bigint` type is for `Key` usage.
+ * It's safe to remove this when typescript fix:
+ * https://github.com/microsoft/TypeScript/issues/50217
+ */
+export type SafeKey = Exclude<Key, bigint>;
+export type KeyEntities<DateType extends BasicDataNode = any> = Record<SafeKey, DataEntity<DateType>>;
+export type DataNode = FieldDataNode<{
+    key: Key;
+    title?: React.ReactNode | ((data: DataNode) => React.ReactNode);
+}>;
+export type EventDataNode<TreeDataType> = {
+    key: Key;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    loaded: boolean;
+    loading: boolean;
+    halfChecked: boolean;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    pos: string;
+    active: boolean;
+} & TreeDataType & BasicDataNode;
+export type IconType = React.ReactNode | ((props: TreeNodeProps) => React.ReactNode);
+export type NodeElement = React.ReactElement<TreeNodeProps> & {
+    selectHandle?: HTMLSpanElement;
+    type: {
+        isTreeNode: boolean;
+    };
+};
+export type NodeInstance<TreeDataType extends BasicDataNode = DataNode> = React.Component<TreeNodeProps<TreeDataType>> & {
+    selectHandle?: HTMLSpanElement;
+};
+export interface Entity {
+    node: NodeElement;
+    index: number;
+    key: Key;
+    pos: string;
+    parent?: Entity;
+    children?: Entity[];
+}
+export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> extends Omit<Entity, 'node' | 'parent' | 'children'> {
+    node: TreeDataType;
+    nodes: TreeDataType[];
+    parent?: DataEntity<TreeDataType>;
+    children?: DataEntity<TreeDataType>[];
+    level: number;
+}
+export interface FlattenNode<TreeDataType extends BasicDataNode = DataNode> {
+    parent: FlattenNode<TreeDataType> | null;
+    children: FlattenNode<TreeDataType>[];
+    pos: string;
+    data: TreeDataType;
+    title: React.ReactNode;
+    key: Key;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+export type GetKey<RecordType> = (record: RecordType, index?: number) => Key;
+export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+export type Direction = 'ltr' | 'rtl' | undefined;
+export interface FieldNames {
+    title?: string;
+    /** @private Internal usage for `rc-tree-select`, safe to remove if no need */
+    _title?: string[];
+    key?: string;
+    children?: string;
+}

frontend/node_modules/rc-tree/lib/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

frontend/node_modules/rc-tree/lib/useUnmount.d.ts

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

frontend/node_modules/rc-tree/lib/useUnmount.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Trigger only when component unmount
+ */
+function useUnmount(triggerStart, triggerEnd) {
+  var _React$useState = React.useState(false),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    firstMount = _React$useState2[0],
+    setFirstMount = _React$useState2[1];
+  (0, _useLayoutEffect.default)(function () {
+    if (firstMount) {
+      triggerStart();
+      return function () {
+        triggerEnd();
+      };
+    }
+  }, [firstMount]);
+  (0, _useLayoutEffect.default)(function () {
+    setFirstMount(true);
+    return function () {
+      setFirstMount(false);
+    };
+  }, []);
+}
+var _default = exports.default = useUnmount;

frontend/node_modules/rc-tree/lib/util.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Legacy code. Should avoid to use if you are new to import these code.
+ */
+import React from 'react';
+import type { BasicDataNode, DataEntity, DataNode, Direction, FlattenNode, Key, KeyEntities, NodeElement, TreeNodeProps } from './interface';
+import type { AllowDrop, TreeProps } from './Tree';
+export { getPosition, isTreeNode } from './utils/treeUtil';
+export declare function arrDel(list: Key[], value: Key): React.Key[];
+export declare function arrAdd(list: Key[], value: Key): React.Key[];
+export declare function posToArr(pos: string): string[];
+export declare function getDragChildrenKeys<TreeDataType extends BasicDataNode = DataNode>(dragNodeKey: Key, keyEntities: KeyEntities<TreeDataType>): Key[];
+export declare function isLastChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function isFirstChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function calcDropPosition<TreeDataType extends BasicDataNode = DataNode>(event: React.MouseEvent, dragNodeProps: TreeNodeProps<TreeDataType>, targetNodeProps: TreeNodeProps<TreeDataType>, indent: number, startMousePosition: {
+    x: number;
+    y: number;
+}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode<TreeDataType>[], keyEntities: KeyEntities<TreeDataType>, expandKeys: Key[], direction: Direction): {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    dropTargetKey: Key;
+    dropTargetPos: string;
+    dropContainerKey: Key;
+    dragOverNodeKey: Key;
+    dropAllowed: boolean;
+};
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): React.Key[];
+export declare function convertDataToTree(treeData: DataNode[], processor?: {
+    processProps: (prop: DataNode) => any;
+}): NodeElement[];
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
+export declare function parseCheckedKeys(keys: Key[] | {
+    checked: Key[];
+    halfChecked: Key[];
+}): {
+    checkedKeys?: Key[];
+    halfCheckedKeys?: Key[];
+};
+/**
+ * If user use `autoExpandParent` we should get the list of parent node
+ * @param keyList
+ * @param keyEntities
+ */
+export declare function conductExpandParent(keyList: Key[], keyEntities: KeyEntities): Key[];

frontend/node_modules/rc-tree/lib/util.js

@@ -0,0 +1,313 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrAdd = arrAdd;
+exports.arrDel = arrDel;
+exports.calcDropPosition = calcDropPosition;
+exports.calcSelectedKeys = calcSelectedKeys;
+exports.conductExpandParent = conductExpandParent;
+exports.convertDataToTree = convertDataToTree;
+exports.getDragChildrenKeys = getDragChildrenKeys;
+Object.defineProperty(exports, "getPosition", {
+  enumerable: true,
+  get: function get() {
+    return _treeUtil.getPosition;
+  }
+});
+exports.isFirstChild = isFirstChild;
+exports.isLastChild = isLastChild;
+Object.defineProperty(exports, "isTreeNode", {
+  enumerable: true,
+  get: function get() {
+    return _treeUtil.isTreeNode;
+  }
+});
+exports.parseCheckedKeys = parseCheckedKeys;
+exports.posToArr = posToArr;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+var _react = _interopRequireDefault(require("react"));
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+var _keyUtil = _interopRequireDefault(require("./utils/keyUtil"));
+var _treeUtil = require("./utils/treeUtil");
+var _excluded = ["children"];
+/* eslint-disable no-lonely-if */
+/**
+ * Legacy code. Should avoid to use if you are new to import these code.
+ */
+function arrDel(list, value) {
+  if (!list) return [];
+  var clone = list.slice();
+  var index = clone.indexOf(value);
+  if (index >= 0) {
+    clone.splice(index, 1);
+  }
+  return clone;
+}
+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 getDragChildrenKeys(dragNodeKey, keyEntities) {
+  // not contains self
+  // self for left or right drag
+  var dragChildrenKeys = [];
+  var entity = (0, _keyUtil.default)(keyEntities, dragNodeKey);
+  function dig() {
+    var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    list.forEach(function (_ref) {
+      var key = _ref.key,
+        children = _ref.children;
+      dragChildrenKeys.push(key);
+      dig(children);
+    });
+  }
+  dig(entity.children);
+  return dragChildrenKeys;
+}
+function isLastChild(treeNodeEntity) {
+  if (treeNodeEntity.parent) {
+    var posArr = posToArr(treeNodeEntity.pos);
+    return Number(posArr[posArr.length - 1]) === treeNodeEntity.parent.children.length - 1;
+  }
+  return false;
+}
+function isFirstChild(treeNodeEntity) {
+  var posArr = posToArr(treeNodeEntity.pos);
+  return Number(posArr[posArr.length - 1]) === 0;
+}
+
+// Only used when drag, not affect SSR.
+function calcDropPosition(event, dragNodeProps, targetNodeProps, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, expandKeys, direction) {
+  var _abstractDropNodeEnti;
+  var clientX = event.clientX,
+    clientY = event.clientY;
+  var _getBoundingClientRec = event.target.getBoundingClientRect(),
+    top = _getBoundingClientRec.top,
+    height = _getBoundingClientRec.height;
+  // optional chain for testing
+  var horizontalMouseOffset = (direction === 'rtl' ? -1 : 1) * (((startMousePosition === null || startMousePosition === void 0 ? void 0 : startMousePosition.x) || 0) - clientX);
+  var rawDropLevelOffset = (horizontalMouseOffset - 12) / indent;
+
+  // Filter the expanded keys to exclude the node that not has children currently (like async nodes).
+  var filteredExpandKeys = expandKeys.filter(function (key) {
+    var _keyEntities$key;
+    return (_keyEntities$key = keyEntities[key]) === null || _keyEntities$key === void 0 || (_keyEntities$key = _keyEntities$key.children) === null || _keyEntities$key === void 0 ? void 0 : _keyEntities$key.length;
+  });
+
+  // find abstract drop node by horizontal offset
+  var abstractDropNodeEntity = (0, _keyUtil.default)(keyEntities, targetNodeProps.eventKey);
+  if (clientY < top + height / 2) {
+    // first half, set abstract drop node to previous node
+    var nodeIndex = flattenedNodes.findIndex(function (flattenedNode) {
+      return flattenedNode.key === abstractDropNodeEntity.key;
+    });
+    var prevNodeIndex = nodeIndex <= 0 ? 0 : nodeIndex - 1;
+    var prevNodeKey = flattenedNodes[prevNodeIndex].key;
+    abstractDropNodeEntity = (0, _keyUtil.default)(keyEntities, prevNodeKey);
+  }
+  var initialAbstractDropNodeKey = abstractDropNodeEntity.key;
+  var abstractDragOverEntity = abstractDropNodeEntity;
+  var dragOverNodeKey = abstractDropNodeEntity.key;
+  var dropPosition = 0;
+  var dropLevelOffset = 0;
+
+  // Only allow cross level drop when dragging on a non-expanded node
+  if (!filteredExpandKeys.includes(initialAbstractDropNodeKey)) {
+    for (var i = 0; i < rawDropLevelOffset; i += 1) {
+      if (isLastChild(abstractDropNodeEntity)) {
+        abstractDropNodeEntity = abstractDropNodeEntity.parent;
+        dropLevelOffset += 1;
+      } else {
+        break;
+      }
+    }
+  }
+  var abstractDragDataNode = dragNodeProps.data;
+  var abstractDropDataNode = abstractDropNodeEntity.node;
+  var dropAllowed = true;
+  if (isFirstChild(abstractDropNodeEntity) && abstractDropNodeEntity.level === 0 && clientY < top + height / 2 && allowDrop({
+    dragNode: abstractDragDataNode,
+    dropNode: abstractDropDataNode,
+    dropPosition: -1
+  }) && abstractDropNodeEntity.key === targetNodeProps.eventKey) {
+    // first half of first node in first level
+    dropPosition = -1;
+  } else if ((abstractDragOverEntity.children || []).length && filteredExpandKeys.includes(dragOverNodeKey)) {
+    // drop on expanded node
+    // only allow drop inside
+    if (allowDrop({
+      dragNode: abstractDragDataNode,
+      dropNode: abstractDropDataNode,
+      dropPosition: 0
+    })) {
+      dropPosition = 0;
+    } else {
+      dropAllowed = false;
+    }
+  } else if (dropLevelOffset === 0) {
+    if (rawDropLevelOffset > -1.5) {
+      // | Node     | <- abstractDropNode
+      // | -^-===== | <- mousePosition
+      // 1. try drop after
+      // 2. do not allow drop
+      if (allowDrop({
+        dragNode: abstractDragDataNode,
+        dropNode: abstractDropDataNode,
+        dropPosition: 1
+      })) {
+        dropPosition = 1;
+      } else {
+        dropAllowed = false;
+      }
+    } else {
+      // | Node     | <- abstractDropNode
+      // | ---==^== | <- mousePosition
+      // whether it has children or doesn't has children
+      // always
+      // 1. try drop inside
+      // 2. try drop after
+      // 3. do not allow drop
+      if (allowDrop({
+        dragNode: abstractDragDataNode,
+        dropNode: abstractDropDataNode,
+        dropPosition: 0
+      })) {
+        dropPosition = 0;
+      } else if (allowDrop({
+        dragNode: abstractDragDataNode,
+        dropNode: abstractDropDataNode,
+        dropPosition: 1
+      })) {
+        dropPosition = 1;
+      } else {
+        dropAllowed = false;
+      }
+    }
+  } else {
+    // | Node1 | <- abstractDropNode
+    //      |  Node2  |
+    // --^--|----=====| <- mousePosition
+    // 1. try insert after Node1
+    // 2. do not allow drop
+    if (allowDrop({
+      dragNode: abstractDragDataNode,
+      dropNode: abstractDropDataNode,
+      dropPosition: 1
+    })) {
+      dropPosition = 1;
+    } else {
+      dropAllowed = false;
+    }
+  }
+  return {
+    dropPosition: dropPosition,
+    dropLevelOffset: dropLevelOffset,
+    dropTargetKey: abstractDropNodeEntity.key,
+    dropTargetPos: abstractDropNodeEntity.pos,
+    dragOverNodeKey: dragOverNodeKey,
+    dropContainerKey: dropPosition === 0 ? null : ((_abstractDropNodeEnti = abstractDropNodeEntity.parent) === null || _abstractDropNodeEnti === void 0 ? void 0 : _abstractDropNodeEnti.key) || null,
+    dropAllowed: dropAllowed
+  };
+}
+
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+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 = (0, _objectWithoutProperties2.default)(_ref3, _excluded);
+    var childrenNodes = convertDataToTree(children, processor);
+    return /*#__PURE__*/_react.default.createElement(_TreeNode.default, (0, _extends2.default)({
+      key: props.key
+    }, 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 ((0, _typeof2.default)(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 = new Set();
+  function conductUp(key) {
+    if (expandedKeys.has(key)) return;
+    var entity = (0, _keyUtil.default)(keyEntities, key);
+    if (!entity) return;
+    expandedKeys.add(key);
+    var parent = entity.parent,
+      node = entity.node;
+    if (node.disabled) return;
+    if (parent) {
+      conductUp(parent.key);
+    }
+  }
+  (keyList || []).forEach(function (key) {
+    conductUp(key);
+  });
+  return (0, _toConsumableArray2.default)(expandedKeys);
+}

frontend/node_modules/rc-tree/lib/utils/conductUtil.d.ts

@@ -0,0 +1,17 @@
+import type { BasicDataNode, DataNode, GetCheckDisabled, Key, KeyEntities } from '../interface';
+interface ConductReturnType {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): 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<TreeDataType extends BasicDataNode = DataNode>(keyList: Key[], checked: true | {
+    checked: false;
+    halfCheckedKeys: Key[];
+}, keyEntities: KeyEntities<TreeDataType>, getCheckDisabled?: GetCheckDisabled<TreeDataType>): ConductReturnType;
+export {};

frontend/node_modules/rc-tree/lib/utils/conductUtil.js

@@ -0,0 +1,217 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conductCheck = conductCheck;
+exports.isCheckDisabled = isCheckDisabled;
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+var _keyUtil = _interopRequireDefault(require("./keyUtil"));
+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, syntheticGetCheckDisabled) {
+  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) && !syntheticGetCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !syntheticGetCheckDisabled(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 (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+
+      // Skip if parent is disabled
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !syntheticGetCheckDisabled(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, syntheticGetCheckDisabled) {
+  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) && !syntheticGetCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !syntheticGetCheckDisabled(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 (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+
+      // Skip if parent is disabled
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !syntheticGetCheckDisabled(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, getCheckDisabled) {
+  var warningMissKeys = [];
+  var syntheticGetCheckDisabled;
+  if (getCheckDisabled) {
+    syntheticGetCheckDisabled = getCheckDisabled;
+  } else {
+    syntheticGetCheckDisabled = isCheckDisabled;
+  }
+
+  // We only handle exist keys
+  var keys = new Set(keyList.filter(function (key) {
+    var hasEntity = !!(0, _keyUtil.default)(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, syntheticGetCheckDisabled);
+  } else {
+    result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel, syntheticGetCheckDisabled);
+  }
+  return result;
+}

frontend/node_modules/rc-tree/lib/utils/diffUtil.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { Key, FlattenNode } from '../interface';
+export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
+    add: boolean;
+    key: import("react").Key;
+};
+export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode<import("../interface").DataNode>[];

frontend/node_modules/rc-tree/lib/utils/diffUtil.js

@@ -0,0 +1,55 @@
+"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 (data) {
+    return data.key === key;
+  });
+  var shorterEndNode = shorter[shorterStartIndex + 1];
+  var longerStartIndex = longer.findIndex(function (data) {
+    return data.key === key;
+  });
+  if (shorterEndNode) {
+    var longerEndIndex = longer.findIndex(function (data) {
+      return data.key === shorterEndNode.key;
+    });
+    return longer.slice(longerStartIndex + 1, longerEndIndex);
+  }
+  return longer.slice(longerStartIndex + 1);
+}

frontend/node_modules/rc-tree/lib/utils/keyUtil.d.ts

@@ -0,0 +1,2 @@
+import type { Key, KeyEntities } from '../interface';
+export default function getEntity<T = any>(keyEntities: KeyEntities<T>, key: Key): import("../interface").DataEntity<T>;

frontend/node_modules/rc-tree/lib/utils/keyUtil.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getEntity;
+function getEntity(keyEntities, key) {
+  return keyEntities[key];
+}

frontend/node_modules/rc-tree/lib/utils/treeUtil.d.ts

@@ -0,0 +1,86 @@
+import * as React from 'react';
+import type { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key, KeyEntities, NodeElement, TreeNodeProps } from '../interface';
+export declare function getPosition(level: string | number, index: number): string;
+export declare function isTreeNode(node: NodeElement): boolean;
+export declare function getKey(key: Key, pos: string): React.Key;
+export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
+/**
+ * Warning if TreeNode do not provides key
+ */
+export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): 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<TreeDataType extends BasicDataNode = DataNode>(treeNodeList: TreeDataType[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode<TreeDataType>[];
+type ExternalGetKey = GetKey<DataNode> | string;
+interface TraverseDataNodesConfig {
+    childrenPropName?: string;
+    externalGetKey?: ExternalGetKey;
+    fieldNames?: FieldNames;
+}
+/**
+ * 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;
+    nodes: DataNode[];
+}) => void, config?: TraverseDataNodesConfig | string): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: KeyEntities;
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+    externalGetKey?: ExternalGetKey;
+    childrenPropName?: string;
+    fieldNames?: FieldNames;
+}, 
+/** @deprecated Use `config.externalGetKey` instead */
+legacyExternalGetKey?: ExternalGetKey): Wrapper;
+export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: KeyEntities<TreeDataType>;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps<TreeDataType>): {
+    eventKey: React.Key;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData<TreeDataType extends BasicDataNode = DataNode>(props: TreeNodeProps<TreeDataType>): EventDataNode<TreeDataType>;
+export {};

frontend/node_modules/rc-tree/lib/utils/treeUtil.js

@@ -0,0 +1,371 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertDataToEntities = convertDataToEntities;
+exports.convertNodePropsToEventData = convertNodePropsToEventData;
+exports.convertTreeToData = convertTreeToData;
+exports.fillFieldNames = fillFieldNames;
+exports.flattenTreeData = flattenTreeData;
+exports.getKey = getKey;
+exports.getPosition = getPosition;
+exports.getTreeNodeProps = getTreeNodeProps;
+exports.isTreeNode = isTreeNode;
+exports.traverseDataNodes = traverseDataNodes;
+exports.warningWithoutKey = warningWithoutKey;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+var _omit = _interopRequireDefault(require("rc-util/lib/omit"));
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+var _keyUtil = _interopRequireDefault(require("./keyUtil"));
+var _excluded = ["children"];
+function getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
+}
+function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+  return pos;
+}
+function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+    title = _ref.title,
+    _title = _ref._title,
+    key = _ref.key,
+    children = _ref.children;
+  var mergedTitle = title || 'title';
+  return {
+    title: mergedTitle,
+    _title: _title || [mergedTitle],
+    key: key || 'key',
+    children: children || 'children'
+  };
+}
+
+/**
+ * Warning if TreeNode do not provides key
+ */
+function warningWithoutKey(treeData, fieldNames) {
+  var keys = new Map();
+  function dig(list) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    (list || []).forEach(function (treeNode) {
+      var key = treeNode[fieldNames.key];
+      var children = treeNode[fieldNames.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 (!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 = (0, _objectWithoutProperties2.default)(_treeNode$props, _excluded);
+      var dataNode = (0, _objectSpread2.default)({
+        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(treeNodeList, expandedKeys, fieldNames) {
+  var _fillFieldNames = fillFieldNames(fieldNames),
+    fieldTitles = _fillFieldNames._title,
+    fieldKey = _fillFieldNames.key,
+    fieldChildren = _fillFieldNames.children;
+  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[fieldKey], pos);
+
+      // Pick matched title in field title list
+      var mergedTitle;
+      for (var i = 0; i < fieldTitles.length; i += 1) {
+        var fieldTitle = fieldTitles[i];
+        if (treeNode[fieldTitle] !== undefined) {
+          mergedTitle = treeNode[fieldTitle];
+          break;
+        }
+      }
+
+      // Add FlattenDataNode into list
+      // We use `Object.assign` here to save perf since babel's `objectSpread` has perf issue
+      var flattenNode = Object.assign((0, _omit.default)(treeNode, [].concat((0, _toConsumableArray2.default)(fieldTitles), [fieldKey, fieldChildren])), {
+        title: mergedTitle,
+        key: mergedKey,
+        parent: parent,
+        pos: pos,
+        children: null,
+        data: treeNode,
+        isStart: [].concat((0, _toConsumableArray2.default)(parent ? parent.isStart : []), [index === 0]),
+        isEnd: [].concat((0, _toConsumableArray2.default)(parent ? parent.isEnd : []), [index === list.length - 1])
+      });
+      flattenList.push(flattenNode);
+
+      // Loop treeNode children
+      if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
+        flattenNode.children = dig(treeNode[fieldChildren] || [], 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,
+// To avoid too many params, let use config instead of origin param
+config) {
+  var mergedConfig = {};
+  if ((0, _typeof2.default)(config) === 'object') {
+    mergedConfig = config;
+  } else {
+    mergedConfig = {
+      externalGetKey: config
+    };
+  }
+  mergedConfig = mergedConfig || {};
+
+  // Init config
+  var _mergedConfig = mergedConfig,
+    childrenPropName = _mergedConfig.childrenPropName,
+    externalGetKey = _mergedConfig.externalGetKey,
+    fieldNames = _mergedConfig.fieldNames;
+  var _fillFieldNames2 = fillFieldNames(fieldNames),
+    fieldKey = _fillFieldNames2.key,
+    fieldChildren = _fillFieldNames2.children;
+  var mergeChildrenPropName = childrenPropName || fieldChildren;
+
+  // Get keys
+  var syntheticGetKey;
+  if (externalGetKey) {
+    if (typeof externalGetKey === 'string') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return node[externalGetKey];
+      };
+    } else if (typeof externalGetKey === 'function') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return externalGetKey(node);
+      };
+    }
+  } else {
+    syntheticGetKey = function syntheticGetKey(node, pos) {
+      return getKey(node[fieldKey], pos);
+    };
+  }
+
+  // Process
+  function processNode(node, index, parent, pathNodes) {
+    var children = node ? node[mergeChildrenPropName] : dataNodes;
+    var pos = node ? getPosition(parent.pos, index) : '0';
+    var connectNodes = node ? [].concat((0, _toConsumableArray2.default)(pathNodes), [node]) : [];
+
+    // Process node if is not root
+    if (node) {
+      var key = syntheticGetKey(node, pos);
+      var _data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: key,
+        parentPos: parent.node ? parent.pos : null,
+        level: parent.level + 1,
+        nodes: connectNodes
+      };
+      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
+        }, connectNodes);
+      });
+    }
+  }
+  processNode(null);
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+function convertDataToEntities(dataNodes) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    initWrapper = _ref2.initWrapper,
+    processEntity = _ref2.processEntity,
+    onProcessFinished = _ref2.onProcessFinished,
+    externalGetKey = _ref2.externalGetKey,
+    childrenPropName = _ref2.childrenPropName,
+    fieldNames = _ref2.fieldNames;
+  var /** @deprecated Use `config.externalGetKey` instead */
+  legacyExternalGetKey = arguments.length > 2 ? arguments[2] : undefined;
+  // Init config
+  var mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
+  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,
+      nodes = item.nodes;
+    var entity = {
+      node: node,
+      nodes: nodes,
+      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);
+    }
+  }, {
+    externalGetKey: mergedExternalGetKey,
+    childrenPropName: childrenPropName,
+    fieldNames: fieldNames
+  });
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+  return wrapper;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+function getTreeNodeProps(key, _ref3) {
+  var expandedKeys = _ref3.expandedKeys,
+    selectedKeys = _ref3.selectedKeys,
+    loadedKeys = _ref3.loadedKeys,
+    loadingKeys = _ref3.loadingKeys,
+    checkedKeys = _ref3.checkedKeys,
+    halfCheckedKeys = _ref3.halfCheckedKeys,
+    dragOverNodeKey = _ref3.dragOverNodeKey,
+    dropPosition = _ref3.dropPosition,
+    keyEntities = _ref3.keyEntities;
+  var entity = (0, _keyUtil.default)(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
+    // Since the interaction of drag is changed, the semantic of the props are
+    // not accuracy, I think it should be finally removed
+    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,
+    eventKey = props.eventKey;
+  var eventData = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, data), {}, {
+    expanded: expanded,
+    selected: selected,
+    checked: checked,
+    loaded: loaded,
+    loading: loading,
+    halfChecked: halfChecked,
+    dragOver: dragOver,
+    dragOverGapTop: dragOverGapTop,
+    dragOverGapBottom: dragOverGapBottom,
+    pos: pos,
+    active: active,
+    key: eventKey
+  });
+  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;
+}

frontend/node_modules/rc-tree/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "rc-tree",
+  "version": "5.13.1",
+  "description": "tree ui component for react",
+  "engines": {
+    "node": ">=10.x"
+  },
+  "keywords": [
+    "react",
+    "react-component",
+    "react-tree",
+    "tree"
+  ],
+  "files": [
+    "assets",
+    "es",
+    "lib"
+  ],
+  "homepage": "http://github.com/react-component/tree",
+  "author": "smith3816@gmail.com",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:react-component/tree.git"
+  },
+  "bugs": {
+    "url": "http://github.com/react-component/tree/issues"
+  },
+  "license": "MIT",
+  "main": "./lib/index",
+  "module": "./es/index",
+  "scripts": {
+    "start": "dumi dev",
+    "docs:build": "dumi build",
+    "docs:deploy": "gh-pages -d dist",
+    "compile": "father build && lessc assets/index.less assets/index.css",
+    "prepare": "husky",
+    "prepublishOnly": "npm run compile && np --yolo --no-publish",
+    "postpublish": "npm run gh-pages",
+    "lint": "eslint src/ --ext .tsx,.ts,.jsx,.js",
+    "test": "rc-test",
+    "coverage": "rc-test --coverage",
+    "gh-pages": "npm run docs:build && npm run docs:deploy",
+    "now-build": "npm run docs:build"
+  },
+  "lint-staged": {
+    "*": "prettier --write --ignore-unknown"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-dom": "*"
+  },
+  "devDependencies": {
+    "@rc-component/father-plugin": "^1.0.2",
+    "@testing-library/jest-dom": "^6.1.5",
+    "@testing-library/react": "^16.1.0",
+    "@types/jest": "^29.5.10",
+    "@types/node": "^22.7.3",
+    "@types/react": "^19.0.1",
+    "@types/react-dom": "^19.0.1",
+    "@types/warning": "^3.0.0",
+    "@umijs/fabric": "^4.0.1",
+    "dumi": "^2.1.0",
+    "eslint": "^8.55.0",
+    "eslint-plugin-jest": "^28.8.3",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "father": "^4.4.0",
+    "gh-pages": "^6.1.1",
+    "glob": "^11.0.0",
+    "husky": "^9.1.6",
+    "less": "^4.2.1",
+    "lint-staged": "^15.2.10",
+    "np": "^10.0.5",
+    "prettier": "^3.3.3",
+    "rc-dialog": "^9.0.0",
+    "rc-test": "^7.0.15",
+    "rc-tooltip": "^6.3.2",
+    "rc-trigger": "^5.0.7",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.10.1",
+    "classnames": "2.x",
+    "rc-motion": "^2.0.1",
+    "rc-util": "^5.16.1",
+    "rc-virtual-list": "^3.5.1"
+  }
+}