first commit

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