Latest updates from IceHrmPro

web/node_modules/rc-tree-select/lib/Context.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { IconType } from 'rc-tree/lib/interface';
+import { Key, LegacyDataNode } from './interface';
+interface ContextProps {
+    checkable: boolean | React.ReactNode;
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    treeExpandedKeys: Key[];
+    treeDefaultExpandedKeys: Key[];
+    onTreeExpand: (keys: Key[]) => void;
+    treeDefaultExpandAll: boolean;
+    treeIcon: IconType;
+    showTreeIcon: boolean;
+    switcherIcon: IconType;
+    treeLine: boolean;
+    treeNodeFilterProp: string;
+    treeLoadedKeys: Key[];
+    treeMotion: any;
+    loadData: (treeNode: LegacyDataNode) => Promise<unknown>;
+    onTreeLoad: (loadedKeys: Key[]) => void;
+}
+export declare const SelectContext: React.Context<ContextProps>;
+export {};

web/node_modules/rc-tree-select/lib/Context.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SelectContext = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var SelectContext = _react.default.createContext(null);
+
+exports.SelectContext = SelectContext;

web/node_modules/rc-tree-select/lib/OptionList.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { RefOptionListProps } from 'rc-select/lib/OptionList';
+import { FlattenDataNode, RawValueType, DataNode } from './interface';
+export interface OptionListProps<OptionsType extends object[]> {
+    prefixCls: string;
+    id: string;
+    options: OptionsType;
+    flattenOptions: FlattenDataNode[];
+    height: number;
+    itemHeight: number;
+    virtual?: boolean;
+    values: Set<RawValueType>;
+    multiple: boolean;
+    open: boolean;
+    defaultActiveFirstOption?: boolean;
+    notFoundContent?: React.ReactNode;
+    menuItemSelectedIcon?: any;
+    childrenAsData: boolean;
+    searchValue: string;
+    onSelect: (value: RawValueType, option: {
+        selected: boolean;
+    }) => void;
+    onToggleOpen: (open?: boolean) => void;
+    /** Tell Select that some value is now active to make accessibility work */
+    onActiveValue: (value: RawValueType, index: number) => void;
+    onScroll: React.UIEventHandler<HTMLDivElement>;
+}
+declare const RefOptionList: React.ForwardRefExoticComponent<OptionListProps<DataNode[]> & React.RefAttributes<RefOptionListProps>>;
+export default RefOptionList;

web/node_modules/rc-tree-select/lib/OptionList.js

@@ -0,0 +1,309 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
+
+var _useMemo = _interopRequireDefault(require("rc-util/lib/hooks/useMemo"));
+
+var _rcTree = _interopRequireDefault(require("rc-tree"));
+
+var _Context = require("./Context");
+
+var _useKeyValueMapping3 = _interopRequireDefault(require("./hooks/useKeyValueMapping"));
+
+var _useKeyValueMap3 = _interopRequireDefault(require("./hooks/useKeyValueMap"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var HIDDEN_STYLE = {
+  width: 0,
+  height: 0,
+  display: 'flex',
+  overflow: 'hidden',
+  opacity: 0,
+  border: 0,
+  padding: 0,
+  margin: 0
+};
+
+var OptionList = function OptionList(props, ref) {
+  var prefixCls = props.prefixCls,
+      height = props.height,
+      itemHeight = props.itemHeight,
+      virtual = props.virtual,
+      options = props.options,
+      flattenOptions = props.flattenOptions,
+      multiple = props.multiple,
+      searchValue = props.searchValue,
+      onSelect = props.onSelect,
+      onToggleOpen = props.onToggleOpen,
+      open = props.open,
+      notFoundContent = props.notFoundContent;
+
+  var _React$useContext = _react.default.useContext(_Context.SelectContext),
+      checkable = _React$useContext.checkable,
+      checkedKeys = _React$useContext.checkedKeys,
+      halfCheckedKeys = _React$useContext.halfCheckedKeys,
+      treeExpandedKeys = _React$useContext.treeExpandedKeys,
+      treeDefaultExpandAll = _React$useContext.treeDefaultExpandAll,
+      treeDefaultExpandedKeys = _React$useContext.treeDefaultExpandedKeys,
+      onTreeExpand = _React$useContext.onTreeExpand,
+      treeIcon = _React$useContext.treeIcon,
+      showTreeIcon = _React$useContext.showTreeIcon,
+      switcherIcon = _React$useContext.switcherIcon,
+      treeLine = _React$useContext.treeLine,
+      treeNodeFilterProp = _React$useContext.treeNodeFilterProp,
+      loadData = _React$useContext.loadData,
+      treeLoadedKeys = _React$useContext.treeLoadedKeys,
+      treeMotion = _React$useContext.treeMotion,
+      onTreeLoad = _React$useContext.onTreeLoad;
+
+  var treeRef = _react.default.useRef();
+
+  var memoOptions = (0, _useMemo.default)(function () {
+    return options;
+  }, [open, options], function (prev, next) {
+    return next[0] && prev[1] !== next[1];
+  });
+
+  var _useKeyValueMap = (0, _useKeyValueMap3.default)(flattenOptions),
+      _useKeyValueMap2 = _slicedToArray(_useKeyValueMap, 2),
+      cacheKeyMap = _useKeyValueMap2[0],
+      cacheValueMap = _useKeyValueMap2[1];
+
+  var _useKeyValueMapping = (0, _useKeyValueMapping3.default)(cacheKeyMap, cacheValueMap),
+      _useKeyValueMapping2 = _slicedToArray(_useKeyValueMapping, 2),
+      getEntityByKey = _useKeyValueMapping2[0],
+      getEntityByValue = _useKeyValueMapping2[1]; // ========================== Values ==========================
+
+
+  var valueKeys = _react.default.useMemo(function () {
+    return checkedKeys.map(function (val) {
+      var entity = getEntityByValue(val);
+      return entity ? entity.key : null;
+    });
+  }, [checkedKeys]);
+
+  var mergedCheckedKeys = _react.default.useMemo(function () {
+    if (!checkable) {
+      return null;
+    }
+
+    return {
+      checked: valueKeys,
+      halfChecked: halfCheckedKeys
+    };
+  }, [valueKeys, halfCheckedKeys, checkable]); // ========================== Scroll ==========================
+
+
+  _react.default.useEffect(function () {
+    // Single mode should scroll to current key
+    if (open && !multiple && valueKeys.length) {
+      var _treeRef$current;
+
+      (_treeRef$current = treeRef.current) === null || _treeRef$current === void 0 ? void 0 : _treeRef$current.scrollTo({
+        key: valueKeys[0]
+      });
+    }
+  }, [open]); // ========================== Search ==========================
+
+
+  var lowerSearchValue = String(searchValue).toLowerCase();
+
+  var filterTreeNode = function filterTreeNode(treeNode) {
+    if (!lowerSearchValue) {
+      return false;
+    }
+
+    return String(treeNode[treeNodeFilterProp]).toLowerCase().includes(lowerSearchValue);
+  }; // =========================== Keys ===========================
+
+
+  var _React$useState = _react.default.useState(treeDefaultExpandedKeys),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      expandedKeys = _React$useState2[0],
+      setExpandedKeys = _React$useState2[1];
+
+  var _React$useState3 = _react.default.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      searchExpandedKeys = _React$useState4[0],
+      setSearchExpandedKeys = _React$useState4[1];
+
+  var mergedExpandedKeys = _react.default.useMemo(function () {
+    if (treeExpandedKeys) {
+      return _toConsumableArray(treeExpandedKeys);
+    }
+
+    return searchValue ? searchExpandedKeys : expandedKeys;
+  }, [expandedKeys, searchExpandedKeys, lowerSearchValue, treeExpandedKeys]);
+
+  _react.default.useEffect(function () {
+    if (searchValue) {
+      setSearchExpandedKeys(flattenOptions.map(function (o) {
+        return o.key;
+      }));
+    }
+  }, [searchValue]);
+
+  var onInternalExpand = function onInternalExpand(keys) {
+    setExpandedKeys(keys);
+    setSearchExpandedKeys(keys);
+
+    if (onTreeExpand) {
+      onTreeExpand(keys);
+    }
+  }; // ========================== Events ==========================
+
+
+  var onListMouseDown = function onListMouseDown(event) {
+    event.preventDefault();
+  };
+
+  var onInternalSelect = function onInternalSelect(_, _ref) {
+    var key = _ref.node.key;
+    var entity = getEntityByKey(key, checkable ? 'checkbox' : 'select');
+
+    if (entity !== null) {
+      onSelect(entity.data.value, {
+        selected: !checkedKeys.includes(entity.data.value)
+      });
+    }
+
+    if (!multiple) {
+      onToggleOpen(false);
+    }
+  }; // ========================= Keyboard =========================
+
+
+  var _React$useState5 = _react.default.useState(null),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      activeKey = _React$useState6[0],
+      setActiveKey = _React$useState6[1];
+
+  var activeEntity = getEntityByKey(activeKey);
+
+  _react.default.useImperativeHandle(ref, function () {
+    return {
+      onKeyDown: function onKeyDown(event) {
+        var _treeRef$current2;
+
+        var which = event.which;
+
+        switch (which) {
+          // >>> Arrow keys
+          case _KeyCode.default.UP:
+          case _KeyCode.default.DOWN:
+          case _KeyCode.default.LEFT:
+          case _KeyCode.default.RIGHT:
+            (_treeRef$current2 = treeRef.current) === null || _treeRef$current2 === void 0 ? void 0 : _treeRef$current2.onKeyDown(event);
+            break;
+          // >>> Select item
+
+          case _KeyCode.default.ENTER:
+            {
+              if (activeEntity !== null) {
+                onInternalSelect(null, {
+                  node: {
+                    key: activeKey
+                  },
+                  selected: !checkedKeys.includes(activeEntity.data.value)
+                });
+              }
+
+              break;
+            }
+          // >>> Close
+
+          case _KeyCode.default.ESC:
+            {
+              onToggleOpen(false);
+            }
+        }
+      },
+      onKeyUp: function onKeyUp() {}
+    };
+  }); // ========================== Render ==========================
+
+
+  if (memoOptions.length === 0) {
+    return _react.default.createElement("div", {
+      role: "listbox",
+      className: "".concat(prefixCls, "-empty"),
+      onMouseDown: onListMouseDown
+    }, notFoundContent);
+  }
+
+  var treeProps = {};
+
+  if (treeLoadedKeys) {
+    treeProps.loadedKeys = treeLoadedKeys;
+  }
+
+  if (mergedExpandedKeys) {
+    treeProps.expandedKeys = mergedExpandedKeys;
+  }
+
+  return _react.default.createElement("div", {
+    onMouseDown: onListMouseDown
+  }, activeEntity && open && _react.default.createElement("span", {
+    style: HIDDEN_STYLE,
+    "aria-live": "assertive"
+  }, activeEntity.data.value), _react.default.createElement(_rcTree.default, Object.assign({
+    ref: treeRef,
+    focusable: false,
+    prefixCls: "".concat(prefixCls, "-tree"),
+    treeData: memoOptions,
+    height: height,
+    itemHeight: itemHeight,
+    virtual: virtual,
+    multiple: multiple,
+    icon: treeIcon,
+    showIcon: showTreeIcon,
+    switcherIcon: switcherIcon,
+    showLine: treeLine,
+    loadData: searchValue ? null : loadData,
+    motion: treeMotion,
+    // We handle keys by out instead tree self
+    checkable: checkable,
+    checkStrictly: true,
+    checkedKeys: mergedCheckedKeys,
+    selectedKeys: !checkable ? valueKeys : [],
+    defaultExpandAll: treeDefaultExpandAll
+  }, treeProps, {
+    // Proxy event out
+    onActiveChange: setActiveKey,
+    onSelect: onInternalSelect,
+    onCheck: onInternalSelect,
+    onExpand: onInternalExpand,
+    onLoad: onTreeLoad,
+    filterTreeNode: filterTreeNode
+  })));
+};
+
+var RefOptionList = _react.default.forwardRef(OptionList);
+
+RefOptionList.displayName = 'OptionList';
+var _default = RefOptionList;
+exports.default = _default;

web/node_modules/rc-tree-select/lib/TreeNode.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { DataNode, Key } from './interface';
+export interface TreeNodeProps extends Omit<DataNode, 'children'> {
+    value: Key;
+    children?: React.ReactNode;
+}
+/** This is a placeholder, not real render in dom */
+declare const TreeNode: React.FC<TreeNodeProps>;
+export default TreeNode;

web/node_modules/rc-tree-select/lib/TreeNode.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** This is a placeholder, not real render in dom */
+var TreeNode = function TreeNode() {
+  return null;
+};
+
+var _default = TreeNode;
+exports.default = _default;

web/node_modules/rc-tree-select/lib/TreeSelect.d.ts

@@ -0,0 +1,61 @@
+import React from 'react';
+import { SelectProps, RefSelectProps } from 'rc-select/lib/generate';
+import { IconType } from 'rc-tree/lib/interface';
+import { FilterFunc } from 'rc-select/lib/interface/generator';
+import { Key, DefaultValueType, DataNode, LabelValueType, SimpleModeConfig, ChangeEventExtra, LegacyDataNode } from './interface';
+import { CheckedStrategy, SHOW_ALL, SHOW_PARENT, SHOW_CHILD } from './utils/strategyUtil';
+export interface TreeSelectProps<ValueType = DefaultValueType> extends Omit<SelectProps<DataNode[], ValueType>, 'onChange' | 'mode' | 'menuItemSelectedIcon' | 'dropdownRender' | 'dropdownAlign' | 'backfill' | 'getInputElement' | 'optionLabelProp' | 'tokenSeparators' | 'filterOption'> {
+    multiple?: boolean;
+    showArrow?: boolean;
+    showSearch?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    value?: ValueType;
+    defaultValue?: ValueType;
+    disabled?: boolean;
+    placeholder?: React.ReactNode;
+    /** @deprecated Use `searchValue` instead */
+    inputValue?: string;
+    searchValue?: string;
+    autoClearSearchValue?: boolean;
+    maxTagTextLength?: number;
+    maxTagCount?: number;
+    maxTagPlaceholder?: (omittedValues: LabelValueType[]) => React.ReactNode;
+    loadData?: (dataNode: LegacyDataNode) => Promise<unknown>;
+    treeNodeFilterProp?: string;
+    treeNodeLabelProp?: string;
+    treeDataSimpleMode?: boolean | SimpleModeConfig;
+    treeExpandedKeys?: Key[];
+    treeDefaultExpandedKeys?: Key[];
+    treeLoadedKeys?: Key[];
+    treeCheckable?: boolean | React.ReactNode;
+    treeCheckStrictly?: boolean;
+    showCheckedStrategy?: CheckedStrategy;
+    treeDefaultExpandAll?: boolean;
+    treeData?: DataNode[];
+    treeLine?: boolean;
+    treeIcon?: IconType;
+    showTreeIcon?: boolean;
+    switcherIcon?: IconType;
+    treeMotion?: any;
+    children?: React.ReactNode;
+    filterTreeNode?: boolean | FilterFunc<LegacyDataNode>;
+    dropdownPopupAlign?: any;
+    onSearch?: (value: string) => void;
+    onChange?: (value: ValueType, labelList: React.ReactNode[], extra: ChangeEventExtra) => void;
+    onTreeExpand?: (expandedKeys: Key[]) => void;
+    onTreeLoad?: (loadedKeys: Key[]) => void;
+    /** `searchPlaceholder` has been removed since search box has been merged into input box */
+    searchPlaceholder?: React.ReactNode;
+}
+declare class TreeSelect<ValueType = DefaultValueType> extends React.Component<TreeSelectProps<ValueType>, {}> {
+    static TreeNode: React.FC<import("./TreeNode").TreeNodeProps>;
+    static SHOW_ALL: typeof SHOW_ALL;
+    static SHOW_PARENT: typeof SHOW_PARENT;
+    static SHOW_CHILD: typeof SHOW_CHILD;
+    selectRef: React.RefObject<RefSelectProps>;
+    focus: () => void;
+    blur: () => void;
+    render(): JSX.Element;
+}
+export default TreeSelect;

web/node_modules/rc-tree-select/lib/TreeSelect.js

@@ -0,0 +1,539 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _generate = _interopRequireDefault(require("rc-select/lib/generate"));
+
+var _valueUtil = require("rc-select/lib/utils/valueUtil");
+
+var _treeUtil = require("rc-tree/lib/utils/treeUtil");
+
+var _conductUtil = require("rc-tree/lib/utils/conductUtil");
+
+var _generator = require("rc-select/lib/interface/generator");
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _OptionList = _interopRequireDefault(require("./OptionList"));
+
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+
+var _valueUtil2 = require("./utils/valueUtil");
+
+var _warningPropsUtil = _interopRequireDefault(require("./utils/warningPropsUtil"));
+
+var _Context = require("./Context");
+
+var _useTreeData = _interopRequireDefault(require("./hooks/useTreeData"));
+
+var _useKeyValueMap3 = _interopRequireDefault(require("./hooks/useKeyValueMap"));
+
+var _useKeyValueMapping3 = _interopRequireDefault(require("./hooks/useKeyValueMapping"));
+
+var _strategyUtil = require("./utils/strategyUtil");
+
+var _legacyUtil = require("./utils/legacyUtil");
+
+var _useSelectValues = _interopRequireDefault(require("./hooks/useSelectValues"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var OMIT_PROPS = ['expandedKeys', 'treeData', 'treeCheckable', 'showCheckedStrategy', 'searchPlaceholder', 'treeLine', 'treeIcon', 'showTreeIcon', 'switcherIcon', 'treeNodeFilterProp', 'filterTreeNode', 'dropdownPopupAlign', 'treeDefaultExpandAll', 'treeCheckStrictly', 'treeExpandedKeys', 'treeLoadedKeys', 'treeMotion', 'onTreeExpand', 'onTreeLoad', 'loadData', 'treeDataSimpleMode', 'treeNodeLabelProp', 'treeDefaultExpandedKeys'];
+var RefSelect = (0, _generate.default)({
+  prefixCls: 'rc-tree-select',
+  components: {
+    optionList: _OptionList.default
+  },
+  // Not use generate since we will handle ourself
+  convertChildrenToData: function convertChildrenToData() {
+    return null;
+  },
+  flattenOptions: _valueUtil2.flattenOptions,
+  // Handle `optionLabelProp` in TreeSelect component
+  getLabeledValue: _valueUtil.getLabeledValue,
+  filterOptions: _valueUtil2.filterOptions,
+  isValueDisabled: _valueUtil2.isValueDisabled,
+  findValueOption: _valueUtil2.findValueOption,
+  omitDOMProps: function omitDOMProps(props) {
+    var cloneProps = _objectSpread({}, props);
+
+    OMIT_PROPS.forEach(function (prop) {
+      delete cloneProps[prop];
+    });
+    return cloneProps;
+  }
+});
+RefSelect.displayName = 'Select';
+
+var RefTreeSelect = _react.default.forwardRef(function (props, ref) {
+  var multiple = props.multiple,
+      treeCheckable = props.treeCheckable,
+      treeCheckStrictly = props.treeCheckStrictly,
+      _props$showCheckedStr = props.showCheckedStrategy,
+      showCheckedStrategy = _props$showCheckedStr === void 0 ? 'SHOW_CHILD' : _props$showCheckedStr,
+      labelInValue = props.labelInValue,
+      loadData = props.loadData,
+      treeLoadedKeys = props.treeLoadedKeys,
+      _props$treeNodeFilter = props.treeNodeFilterProp,
+      treeNodeFilterProp = _props$treeNodeFilter === void 0 ? 'value' : _props$treeNodeFilter,
+      treeNodeLabelProp = props.treeNodeLabelProp,
+      treeDataSimpleMode = props.treeDataSimpleMode,
+      treeData = props.treeData,
+      treeExpandedKeys = props.treeExpandedKeys,
+      treeDefaultExpandedKeys = props.treeDefaultExpandedKeys,
+      treeDefaultExpandAll = props.treeDefaultExpandAll,
+      children = props.children,
+      treeIcon = props.treeIcon,
+      showTreeIcon = props.showTreeIcon,
+      switcherIcon = props.switcherIcon,
+      treeLine = props.treeLine,
+      treeMotion = props.treeMotion,
+      filterTreeNode = props.filterTreeNode,
+      dropdownPopupAlign = props.dropdownPopupAlign,
+      onChange = props.onChange,
+      onTreeExpand = props.onTreeExpand,
+      onTreeLoad = props.onTreeLoad,
+      onDropdownVisibleChange = props.onDropdownVisibleChange,
+      onSelect = props.onSelect,
+      onDeselect = props.onDeselect;
+  var mergedCheckable = treeCheckable || treeCheckStrictly;
+  var mergedMultiple = multiple || mergedCheckable;
+  var treeConduction = treeCheckable && !treeCheckStrictly;
+  var mergedLabelInValue = treeCheckStrictly || labelInValue; // ========================== Ref ==========================
+
+  var selectRef = _react.default.useRef(null);
+
+  _react.default.useImperativeHandle(ref, function () {
+    return {
+      focus: selectRef.current.focus,
+      blur: selectRef.current.blur
+    };
+  }); // ======================= Tree Data =======================
+  // Legacy both support `label` or `title` if not set.
+  // We have to fallback to function to handle this
+
+
+  var getTreeNodeLabelProp = function getTreeNodeLabelProp(node) {
+    if (treeNodeLabelProp) {
+      return node[treeNodeLabelProp];
+    }
+
+    if (!treeData) {
+      return node.title;
+    }
+
+    return node.label || node.title;
+  };
+
+  var mergedTreeData = (0, _useTreeData.default)(treeData, children, {
+    getLabelProp: getTreeNodeLabelProp,
+    simpleMode: treeDataSimpleMode
+  });
+
+  var flattedOptions = _react.default.useMemo(function () {
+    return (0, _valueUtil2.flattenOptions)(mergedTreeData);
+  }, [mergedTreeData]);
+
+  var _useKeyValueMap = (0, _useKeyValueMap3.default)(flattedOptions),
+      _useKeyValueMap2 = _slicedToArray(_useKeyValueMap, 2),
+      cacheKeyMap = _useKeyValueMap2[0],
+      cacheValueMap = _useKeyValueMap2[1];
+
+  var _useKeyValueMapping = (0, _useKeyValueMapping3.default)(cacheKeyMap, cacheValueMap),
+      _useKeyValueMapping2 = _slicedToArray(_useKeyValueMapping, 2),
+      getEntityByKey = _useKeyValueMapping2[0],
+      getEntityByValue = _useKeyValueMapping2[1]; // Only generate keyEntities for check conduction when is `treeCheckable`
+
+
+  var _React$useMemo = _react.default.useMemo(function () {
+    if (treeConduction) {
+      return (0, _treeUtil.convertDataToEntities)(mergedTreeData);
+    }
+
+    return {
+      keyEntities: null
+    };
+  }, [mergedTreeData, treeCheckable, treeCheckStrictly]),
+      conductKeyEntities = _React$useMemo.keyEntities; // ========================= Value =========================
+
+
+  var _React$useState = _react.default.useState(props.defaultValue),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      value = _React$useState2[0],
+      setValue = _React$useState2[1];
+
+  var mergedValue = 'value' in props ? props.value : value;
+  /** Get `missingRawValues` which not exist in the tree yet */
+
+  var splitRawValues = function splitRawValues(newRawValues) {
+    var missingRawValues = [];
+    var existRawValues = []; // Keep missing value in the cache
+
+    newRawValues.forEach(function (val) {
+      if (getEntityByValue(val)) {
+        existRawValues.push(val);
+      } else {
+        missingRawValues.push(val);
+      }
+    });
+    return {
+      missingRawValues: missingRawValues,
+      existRawValues: existRawValues
+    };
+  };
+
+  var _React$useMemo2 = _react.default.useMemo(function () {
+    var valueHalfCheckedKeys = [];
+    var newRawValues = [];
+    (0, _valueUtil2.toArray)(mergedValue).forEach(function (item) {
+      if (item && _typeof(item) === 'object' && 'value' in item) {
+        if (item.halfChecked && treeCheckStrictly) {
+          var entity = getEntityByValue(item.value);
+          valueHalfCheckedKeys.push(entity ? entity.key : item.value);
+        } else {
+          newRawValues.push(item.value);
+        }
+      } else {
+        newRawValues.push(item);
+      }
+    }); // We need do conduction of values
+
+    if (treeConduction) {
+      var _splitRawValues = splitRawValues(newRawValues),
+          missingRawValues = _splitRawValues.missingRawValues,
+          existRawValues = _splitRawValues.existRawValues;
+
+      var keyList = existRawValues.map(function (val) {
+        return getEntityByValue(val).key;
+      });
+
+      var _conductCheck = (0, _conductUtil.conductCheck)(keyList, true, conductKeyEntities),
+          checkedKeys = _conductCheck.checkedKeys,
+          halfCheckedKeys = _conductCheck.halfCheckedKeys;
+
+      return [[].concat(_toConsumableArray(missingRawValues), _toConsumableArray(checkedKeys.map(function (key) {
+        return getEntityByKey(key).data.value;
+      }))), halfCheckedKeys];
+    }
+
+    return [newRawValues, valueHalfCheckedKeys];
+  }, [mergedValue, mergedMultiple, mergedLabelInValue, treeCheckable, treeCheckStrictly]),
+      _React$useMemo3 = _slicedToArray(_React$useMemo2, 2),
+      rawValues = _React$useMemo3[0],
+      rawHalfCheckedKeys = _React$useMemo3[1];
+
+  var selectValues = (0, _useSelectValues.default)(rawValues, {
+    treeConduction: treeConduction,
+    value: mergedValue,
+    showCheckedStrategy: showCheckedStrategy,
+    conductKeyEntities: conductKeyEntities,
+    getEntityByValue: getEntityByValue,
+    getEntityByKey: getEntityByKey,
+    getLabelProp: getTreeNodeLabelProp
+  });
+
+  var triggerChange = function triggerChange(newRawValues, extra, source) {
+    setValue(mergedMultiple ? newRawValues : newRawValues[0]);
+
+    if (onChange) {
+      var eventValues = newRawValues;
+
+      if (treeConduction && showCheckedStrategy !== 'SHOW_ALL') {
+        var keyList = newRawValues.map(function (val) {
+          var entity = getEntityByValue(val);
+          return entity ? entity.key : val;
+        });
+        var formattedKeyList = (0, _strategyUtil.formatStrategyKeys)(keyList, showCheckedStrategy, conductKeyEntities);
+        eventValues = formattedKeyList.map(function (key) {
+          var entity = getEntityByKey(key);
+          return entity ? entity.data.value : key;
+        });
+      }
+
+      var _ref = extra || {
+        triggerValue: undefined,
+        selected: undefined
+      },
+          triggerValue = _ref.triggerValue,
+          selected = _ref.selected;
+
+      var returnValues = mergedLabelInValue ? (0, _valueUtil2.getRawValueLabeled)(eventValues, mergedValue, getEntityByValue, getTreeNodeLabelProp) : eventValues; // We need fill half check back
+
+      if (treeCheckStrictly) {
+        var halfValues = rawHalfCheckedKeys.map(function (key) {
+          var entity = getEntityByKey(key);
+          return entity ? entity.data.value : key;
+        }).filter(function (val) {
+          return !eventValues.includes(val);
+        });
+        returnValues = [].concat(_toConsumableArray(returnValues), _toConsumableArray((0, _valueUtil2.getRawValueLabeled)(halfValues, mergedValue, getEntityByValue, getTreeNodeLabelProp)));
+      }
+
+      var additionalInfo = {
+        // [Legacy] Always return as array contains label & value
+        preValue: selectValues,
+        triggerValue: triggerValue
+      }; // [Legacy] Fill legacy data if user query.
+      // This is expansive that we only fill when user query
+      // https://github.com/react-component/tree-select/blob/fe33eb7c27830c9ac70cd1fdb1ebbe7bc679c16a/src/Select.jsx
+
+      var showPosition = true;
+
+      if (treeCheckStrictly || source === 'selection' && !selected) {
+        showPosition = false;
+      }
+
+      (0, _legacyUtil.fillAdditionalInfo)(additionalInfo, triggerValue, newRawValues, mergedTreeData, showPosition);
+
+      if (mergedCheckable) {
+        additionalInfo.checked = selected;
+      } else {
+        additionalInfo.selected = selected;
+      }
+
+      onChange(mergedMultiple ? returnValues : returnValues[0], mergedLabelInValue ? null : eventValues.map(function (val) {
+        var entity = getEntityByValue(val);
+        return entity ? getTreeNodeLabelProp(entity.data) : null;
+      }), additionalInfo);
+    }
+  };
+
+  var onInternalSelect = function onInternalSelect(selectValue, option, source) {
+    var eventValue = mergedLabelInValue ? selectValue : selectValue;
+
+    if (!mergedMultiple) {
+      // Single mode always set value
+      triggerChange([selectValue], {
+        selected: true,
+        triggerValue: selectValue
+      }, source);
+    } else {
+      var newRawValues = (0, _valueUtil2.addValue)(rawValues, selectValue); // Add keys if tree conduction
+
+      if (treeConduction) {
+        // Should keep missing values
+        var _splitRawValues2 = splitRawValues(newRawValues),
+            missingRawValues = _splitRawValues2.missingRawValues,
+            existRawValues = _splitRawValues2.existRawValues;
+
+        var keyList = existRawValues.map(function (val) {
+          return getEntityByValue(val).key;
+        });
+
+        var _conductCheck2 = (0, _conductUtil.conductCheck)(keyList, true, conductKeyEntities),
+            checkedKeys = _conductCheck2.checkedKeys;
+
+        newRawValues = [].concat(_toConsumableArray(missingRawValues), _toConsumableArray(checkedKeys.map(function (key) {
+          return getEntityByKey(key).data.value;
+        })));
+      }
+
+      triggerChange(newRawValues, {
+        selected: true,
+        triggerValue: selectValue
+      }, source);
+    }
+
+    if (onSelect) {
+      onSelect(eventValue, option);
+    }
+  };
+
+  var onInternalDeselect = function onInternalDeselect(selectValue, option, source) {
+    var eventValue = mergedLabelInValue ? selectValue : selectValue;
+    var newRawValues = (0, _valueUtil2.removeValue)(rawValues, selectValue); // Remove keys if tree conduction
+
+    if (treeConduction) {
+      var _splitRawValues3 = splitRawValues(newRawValues),
+          missingRawValues = _splitRawValues3.missingRawValues,
+          existRawValues = _splitRawValues3.existRawValues;
+
+      var keyList = existRawValues.map(function (val) {
+        return getEntityByValue(val).key;
+      });
+
+      var _conductCheck3 = (0, _conductUtil.conductCheck)(keyList, {
+        checked: false,
+        halfCheckedKeys: rawHalfCheckedKeys
+      }, conductKeyEntities),
+          checkedKeys = _conductCheck3.checkedKeys;
+
+      newRawValues = [].concat(_toConsumableArray(missingRawValues), _toConsumableArray(checkedKeys.map(function (key) {
+        return getEntityByKey(key).data.value;
+      })));
+    }
+
+    triggerChange(newRawValues, {
+      selected: false,
+      triggerValue: selectValue
+    }, source);
+
+    if (onDeselect) {
+      onDeselect(eventValue, option);
+    }
+  };
+
+  var onInternalClear = function onInternalClear() {
+    triggerChange([], null, 'clear');
+  }; // ========================= Open ==========================
+
+
+  var onInternalDropdownVisibleChange = _react.default.useCallback(function (open) {
+    if (onDropdownVisibleChange) {
+      var legacyParam = {};
+      Object.defineProperty(legacyParam, 'documentClickClose', {
+        get: function get() {
+          (0, _warning.default)(false, 'Second param of `onDropdownVisibleChange` has been removed.');
+          return false;
+        }
+      });
+      onDropdownVisibleChange(open, legacyParam);
+    }
+  }, [onDropdownVisibleChange]); // ======================== Warning ========================
+
+
+  if (process.env.NODE_ENV !== 'production') {
+    (0, _warningPropsUtil.default)(props);
+  } // ======================== Render =========================
+  // We pass some props into select props style
+
+
+  var selectProps = {
+    optionLabelProp: null,
+    optionFilterProp: treeNodeFilterProp,
+    dropdownAlign: dropdownPopupAlign,
+    internalProps: {
+      mark: _generator.INTERNAL_PROPS_MARK,
+      onClear: onInternalClear,
+      skipTriggerChange: true,
+      skipTriggerSelect: true,
+      onRawSelect: onInternalSelect,
+      onRawDeselect: onInternalDeselect
+    }
+  };
+
+  if ('filterTreeNode' in props) {
+    selectProps.filterOption = filterTreeNode;
+  }
+
+  return _react.default.createElement(_Context.SelectContext.Provider, {
+    value: {
+      checkable: mergedCheckable,
+      loadData: loadData,
+      treeLoadedKeys: treeLoadedKeys,
+      onTreeLoad: onTreeLoad,
+      checkedKeys: rawValues,
+      halfCheckedKeys: rawHalfCheckedKeys,
+      treeDefaultExpandAll: treeDefaultExpandAll,
+      treeExpandedKeys: treeExpandedKeys,
+      treeDefaultExpandedKeys: treeDefaultExpandedKeys,
+      onTreeExpand: onTreeExpand,
+      treeIcon: treeIcon,
+      treeMotion: treeMotion,
+      showTreeIcon: showTreeIcon,
+      switcherIcon: switcherIcon,
+      treeLine: treeLine,
+      treeNodeFilterProp: treeNodeFilterProp
+    }
+  }, _react.default.createElement(RefSelect, Object.assign({
+    ref: selectRef,
+    mode: mergedMultiple ? 'multiple' : null
+  }, props, selectProps, {
+    value: selectValues,
+    // We will handle this ourself since we need calculate conduction
+    labelInValue: true,
+    options: mergedTreeData,
+    onChange: null,
+    onSelect: null,
+    onDeselect: null,
+    onDropdownVisibleChange: onInternalDropdownVisibleChange
+  })));
+}); // Use class component since typescript not support generic
+// by `forwardRef` with function component yet.
+
+
+var TreeSelect = /*#__PURE__*/function (_React$Component) {
+  _inherits(TreeSelect, _React$Component);
+
+  function TreeSelect() {
+    var _this;
+
+    _classCallCheck(this, TreeSelect);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(TreeSelect).apply(this, arguments));
+    _this.selectRef = _react.default.createRef();
+
+    _this.focus = function () {
+      _this.selectRef.current.focus();
+    };
+
+    _this.blur = function () {
+      _this.selectRef.current.blur();
+    };
+
+    return _this;
+  }
+
+  _createClass(TreeSelect, [{
+    key: "render",
+    value: function render() {
+      return _react.default.createElement(RefTreeSelect, Object.assign({
+        ref: this.selectRef
+      }, this.props));
+    }
+  }]);
+
+  return TreeSelect;
+}(_react.default.Component);
+
+TreeSelect.TreeNode = _TreeNode.default;
+TreeSelect.SHOW_ALL = _strategyUtil.SHOW_ALL;
+TreeSelect.SHOW_PARENT = _strategyUtil.SHOW_PARENT;
+TreeSelect.SHOW_CHILD = _strategyUtil.SHOW_CHILD;
+var _default = TreeSelect;
+exports.default = _default;

web/node_modules/rc-tree-select/lib/hooks/useKeyValueMap.d.ts

@@ -0,0 +1,6 @@
+import { FlattenDataNode } from '../interface';
+/**
+ * Return cached Key Value map with DataNode.
+ * Only re-calculate when `flattenOptions` changed.
+ */
+export default function useKeyValueMap(flattenOptions: FlattenDataNode[]): Map<string | number, FlattenDataNode>[];

web/node_modules/rc-tree-select/lib/hooks/useKeyValueMap.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useKeyValueMap;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Return cached Key Value map with DataNode.
+ * Only re-calculate when `flattenOptions` changed.
+ */
+function useKeyValueMap(flattenOptions) {
+  return _react.default.useMemo(function () {
+    var cacheKeyMap = new Map();
+    var cacheValueMap = new Map(); // Cache options by key
+
+    flattenOptions.forEach(function (dataNode) {
+      cacheKeyMap.set(dataNode.key, dataNode);
+      cacheValueMap.set(dataNode.data.value, dataNode);
+    });
+    return [cacheKeyMap, cacheValueMap];
+  }, [flattenOptions]);
+}

web/node_modules/rc-tree-select/lib/hooks/useKeyValueMapping.d.ts

@@ -0,0 +1,4 @@
+import { FlattenDataNode, Key, RawValueType } from '../interface';
+export declare type SkipType = null | 'select' | 'checkbox';
+export declare function isDisabled(dataNode: FlattenDataNode, skipType: SkipType): boolean;
+export default function useKeyValueMapping(cacheKeyMap: Map<Key, FlattenDataNode>, cacheValueMap: Map<RawValueType, FlattenDataNode>): [(key: Key, skipType?: SkipType) => FlattenDataNode, (value: RawValueType, skipType?: SkipType) => FlattenDataNode];

web/node_modules/rc-tree-select/lib/hooks/useKeyValueMapping.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDisabled = isDisabled;
+exports.default = useKeyValueMapping;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isDisabled(dataNode, skipType) {
+  if (!dataNode) {
+    return true;
+  }
+
+  var _dataNode$data = dataNode.data,
+      disabled = _dataNode$data.disabled,
+      disableCheckbox = _dataNode$data.disableCheckbox;
+
+  switch (skipType) {
+    case 'select':
+      return disabled;
+
+    case 'checkbox':
+      return disabled || disableCheckbox;
+  }
+
+  return false;
+}
+
+function useKeyValueMapping(cacheKeyMap, cacheValueMap) {
+  var getEntityByKey = _react.default.useCallback(function (key) {
+    var skipType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'select';
+    var dataNode = cacheKeyMap.get(key);
+
+    if (isDisabled(dataNode, skipType)) {
+      return null;
+    }
+
+    return dataNode;
+  }, [cacheKeyMap]);
+
+  var getEntityByValue = _react.default.useCallback(function (value) {
+    var skipType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'select';
+    var dataNode = cacheValueMap.get(value);
+
+    if (isDisabled(dataNode, skipType)) {
+      return null;
+    }
+
+    return dataNode;
+  }, [cacheValueMap]);
+
+  return [getEntityByKey, getEntityByValue];
+}

web/node_modules/rc-tree-select/lib/hooks/useSelectValues.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { DefaultValueType } from 'rc-select/lib/interface/generator';
+import { DataEntity } from 'rc-tree/lib/interface';
+import { RawValueType, FlattenDataNode, Key, LabelValueType, DataNode } from '../interface';
+import { SkipType } from './useKeyValueMapping';
+import { CheckedStrategy } from '../utils/strategyUtil';
+interface Config {
+    treeConduction: boolean;
+    /** Current `value` of TreeSelect */
+    value: DefaultValueType;
+    showCheckedStrategy: CheckedStrategy;
+    conductKeyEntities: Record<Key, DataEntity>;
+    getEntityByKey: (key: Key, skipType?: SkipType) => FlattenDataNode;
+    getEntityByValue: (value: RawValueType, skipType?: SkipType) => FlattenDataNode;
+    getLabelProp: (node: DataNode) => React.ReactNode;
+}
+/** Return  */
+export default function useSelectValues(rawValues: RawValueType[], { value, getEntityByValue, getEntityByKey, treeConduction, showCheckedStrategy, conductKeyEntities, getLabelProp, }: Config): LabelValueType[];
+export {};

web/node_modules/rc-tree-select/lib/hooks/useSelectValues.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSelectValues;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _valueUtil = require("../utils/valueUtil");
+
+var _strategyUtil = require("../utils/strategyUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** Return  */
+function useSelectValues(rawValues, _ref) {
+  var value = _ref.value,
+      getEntityByValue = _ref.getEntityByValue,
+      getEntityByKey = _ref.getEntityByKey,
+      treeConduction = _ref.treeConduction,
+      showCheckedStrategy = _ref.showCheckedStrategy,
+      conductKeyEntities = _ref.conductKeyEntities,
+      getLabelProp = _ref.getLabelProp;
+  return _react.default.useMemo(function () {
+    var mergedRawValues = rawValues;
+
+    if (treeConduction) {
+      var rawKeys = (0, _strategyUtil.formatStrategyKeys)(rawValues.map(function (val) {
+        var entity = getEntityByValue(val);
+        return entity ? entity.key : val;
+      }), showCheckedStrategy, conductKeyEntities);
+      mergedRawValues = rawKeys.map(function (key) {
+        var entity = getEntityByKey(key);
+        return entity ? entity.data.value : key;
+      });
+    }
+
+    return (0, _valueUtil.getRawValueLabeled)(mergedRawValues, value, getEntityByValue, getLabelProp);
+  }, [rawValues, value, treeConduction, showCheckedStrategy, getEntityByValue]);
+}

web/node_modules/rc-tree-select/lib/hooks/useTreeData.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { DataNode, InnerDataNode, SimpleModeConfig } from '../interface';
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+export default function useTreeData(treeData: DataNode[], children: React.ReactNode, { getLabelProp, simpleMode, }: {
+    getLabelProp: (node: DataNode) => React.ReactNode;
+    simpleMode: boolean | SimpleModeConfig;
+}): InnerDataNode[];

web/node_modules/rc-tree-select/lib/hooks/useTreeData.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useTreeData;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _legacyUtil = require("../utils/legacyUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var MAX_WARNING_TIMES = 10;
+
+function parseSimpleTreeData(treeData, _ref) {
+  var id = _ref.id,
+      pId = _ref.pId,
+      rootPId = _ref.rootPId;
+  var keyNodes = {};
+  var rootNodeList = []; // Fill in the map
+
+  var nodeList = treeData.map(function (node) {
+    var clone = _objectSpread({}, node);
+
+    var key = clone[id];
+    keyNodes[key] = clone;
+    clone.key = clone.key || key;
+    return clone;
+  }); // Connect tree
+
+  nodeList.forEach(function (node) {
+    var parentKey = node[pId];
+    var parent = keyNodes[parentKey]; // Fill parent
+
+    if (parent) {
+      parent.children = parent.children || [];
+      parent.children.push(node);
+    } // Fill root tree node
+
+
+    if (parentKey === rootPId || !parent && rootPId === null) {
+      rootNodeList.push(node);
+    }
+  });
+  return rootNodeList;
+}
+/**
+ * Format `treeData` with `value` & `key` which is used for calculation
+ */
+
+
+function formatTreeData(treeData, getLabelProp) {
+  var warningTimes = 0;
+  var valueSet = new Set();
+
+  function dig(dataNodes) {
+    return (dataNodes || []).map(function (node) {
+      var key = node.key,
+          value = node.value,
+          children = node.children,
+          rest = _objectWithoutProperties(node, ["key", "value", "children"]);
+
+      var mergedValue = 'value' in node ? value : key;
+
+      var dataNode = _objectSpread({}, rest, {
+        key: key !== null && key !== undefined ? key : mergedValue,
+        value: mergedValue,
+        title: getLabelProp(node)
+      }); // Check `key` & `value` and warning user
+
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (key !== null && key !== undefined && value !== undefined && String(key) !== String(value) && warningTimes < MAX_WARNING_TIMES) {
+          warningTimes += 1;
+          (0, _warning.default)(false, "`key` or `value` with TreeNode must be the same or you can remove one of them. key: ".concat(key, ", value: ").concat(value, "."));
+        }
+
+        (0, _warning.default)(!valueSet.has(value), "Same `value` exist in the tree: ".concat(value));
+        valueSet.add(value);
+      }
+
+      if ('children' in node) {
+        dataNode.children = dig(children);
+      }
+
+      return dataNode;
+    });
+  }
+
+  return dig(treeData);
+}
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+
+
+function useTreeData(treeData, children, _ref2) {
+  var getLabelProp = _ref2.getLabelProp,
+      simpleMode = _ref2.simpleMode;
+
+  var cacheRef = _react.default.useRef({});
+
+  if (treeData) {
+    cacheRef.current.formatTreeData = cacheRef.current.treeData === treeData ? cacheRef.current.formatTreeData : formatTreeData(simpleMode ? parseSimpleTreeData(treeData, _objectSpread({
+      id: 'id',
+      pId: 'pId',
+      rootPId: null
+    }, simpleMode !== true ? simpleMode : {})) : treeData, getLabelProp);
+    cacheRef.current.treeData = treeData;
+  } else {
+    cacheRef.current.formatTreeData = cacheRef.current.children === children ? cacheRef.current.formatTreeData : formatTreeData((0, _legacyUtil.convertChildrenToData)(children), getLabelProp);
+  }
+
+  return cacheRef.current.formatTreeData;
+}

web/node_modules/rc-tree-select/lib/index.d.ts

@@ -0,0 +1,5 @@
+import TreeSelect, { TreeSelectProps } from './TreeSelect';
+import TreeNode from './TreeNode';
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil';
+export { TreeNode, SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeSelectProps };
+export default TreeSelect;

web/node_modules/rc-tree-select/lib/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TreeNode", {
+  enumerable: true,
+  get: function get() {
+    return _TreeNode.default;
+  }
+});
+Object.defineProperty(exports, "SHOW_ALL", {
+  enumerable: true,
+  get: function get() {
+    return _strategyUtil.SHOW_ALL;
+  }
+});
+Object.defineProperty(exports, "SHOW_CHILD", {
+  enumerable: true,
+  get: function get() {
+    return _strategyUtil.SHOW_CHILD;
+  }
+});
+Object.defineProperty(exports, "SHOW_PARENT", {
+  enumerable: true,
+  get: function get() {
+    return _strategyUtil.SHOW_PARENT;
+  }
+});
+exports.default = void 0;
+
+var _TreeSelect = _interopRequireDefault(require("./TreeSelect"));
+
+var _TreeNode = _interopRequireDefault(require("./TreeNode"));
+
+var _strategyUtil = require("./utils/strategyUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _TreeSelect.default;
+exports.default = _default;

web/node_modules/rc-tree-select/lib/interface.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+export declare type SelectSource = 'option' | 'selection' | 'input' | 'clear';
+export declare type Key = string | number;
+export declare type RawValueType = string | number;
+export interface LabelValueType {
+    key?: Key;
+    value?: RawValueType;
+    label?: React.ReactNode;
+    /** Only works on `treeCheckStrictly` */
+    halfChecked?: boolean;
+}
+export declare type DefaultValueType = RawValueType | RawValueType[] | LabelValueType | LabelValueType[];
+export interface DataNode {
+    value?: RawValueType;
+    title?: React.ReactNode;
+    label?: React.ReactNode;
+    key?: Key;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    checkable?: boolean;
+    children?: DataNode[];
+    /** Customize data info */
+    [prop: string]: any;
+}
+export interface InnerDataNode extends DataNode {
+    key: Key;
+    value: RawValueType;
+    label?: React.ReactNode;
+    children?: InnerDataNode[];
+}
+export interface LegacyDataNode extends DataNode {
+    props: any;
+}
+export interface TreeDataNode extends DataNode {
+    key: Key;
+    children?: TreeDataNode[];
+}
+export interface FlattenDataNode {
+    data: DataNode;
+    key: Key;
+    level: number;
+}
+export interface SimpleModeConfig {
+    id?: Key;
+    pId?: Key;
+    rootPId?: Key;
+}
+/** @deprecated This is only used for legacy compatible. Not works on new code. */
+export interface LegacyCheckedNode {
+    pos: string;
+    node: React.ReactElement;
+    children?: LegacyCheckedNode[];
+}
+export interface ChangeEventExtra {
+    /** @deprecated Please save prev value by control logic instead */
+    preValue: LabelValueType[];
+    triggerValue: RawValueType;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    selected?: boolean;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    checked?: boolean;
+    /** @deprecated This prop not work as react node anymore. */
+    triggerNode: React.ReactElement;
+    /** @deprecated This prop not work as react node anymore. */
+    allCheckedNodes: LegacyCheckedNode[];
+}

web/node_modules/rc-tree-select/lib/interface.js

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

web/node_modules/rc-tree-select/lib/utils/legacyUtil.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { DataNode, LegacyDataNode, ChangeEventExtra, InnerDataNode, RawValueType } from '../interface';
+export declare function convertChildrenToData(nodes: React.ReactNode): DataNode[];
+export declare function fillLegacyProps(dataNode: DataNode): LegacyDataNode;
+export declare function fillAdditionalInfo(extra: ChangeEventExtra, triggerValue: RawValueType, checkedValues: RawValueType[], treeData: InnerDataNode[], showPosition: boolean): void;

web/node_modules/rc-tree-select/lib/utils/legacyUtil.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertChildrenToData = convertChildrenToData;
+exports.fillLegacyProps = fillLegacyProps;
+exports.fillAdditionalInfo = fillAdditionalInfo;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _TreeNode = _interopRequireDefault(require("../TreeNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function convertChildrenToData(nodes) {
+  return (0, _toArray.default)(nodes).map(function (node) {
+    if (!_react.default.isValidElement(node) || !node.type) {
+      return null;
+    }
+
+    var key = node.key,
+        _node$props = node.props,
+        children = _node$props.children,
+        value = _node$props.value,
+        restProps = _objectWithoutProperties(_node$props, ["children", "value"]);
+
+    var data = _objectSpread({
+      key: key,
+      value: value
+    }, restProps);
+
+    var childData = convertChildrenToData(children);
+
+    if (childData.length) {
+      data.children = childData;
+    }
+
+    return data;
+  }).filter(function (data) {
+    return data;
+  });
+}
+
+function fillLegacyProps(dataNode) {
+  // Skip if not dataNode exist
+  if (!dataNode) {
+    return dataNode;
+  }
+
+  var cloneNode = _objectSpread({}, dataNode);
+
+  if (!('props' in cloneNode)) {
+    Object.defineProperty(cloneNode, 'props', {
+      get: function get() {
+        (0, _warning.default)(false, 'New `rc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
+        return cloneNode;
+      }
+    });
+  }
+
+  return cloneNode;
+}
+
+function fillAdditionalInfo(extra, triggerValue, checkedValues, treeData, showPosition) {
+  var triggerNode = null;
+  var nodeList = null;
+
+  function generateMap() {
+    function dig(list) {
+      var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0';
+      var parentIncluded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return list.map(function (dataNode, index) {
+        var pos = "".concat(level, "-").concat(index);
+        var included = checkedValues.includes(dataNode.value);
+        var children = dig(dataNode.children || [], pos, included);
+
+        var node = _react.default.createElement(_TreeNode.default, Object.assign({}, dataNode), children.map(function (child) {
+          return child.node;
+        })); // Link with trigger node
+
+
+        if (triggerValue === dataNode.value) {
+          triggerNode = node;
+        }
+
+        if (included) {
+          var checkedNode = {
+            pos: pos,
+            node: node,
+            children: children
+          };
+
+          if (!parentIncluded) {
+            nodeList.push(checkedNode);
+          }
+
+          return checkedNode;
+        }
+
+        return null;
+      }).filter(function (node) {
+        return node;
+      });
+    }
+
+    if (!nodeList) {
+      nodeList = [];
+      dig(treeData); // Sort to keep the checked node length
+
+      nodeList.sort(function (_ref, _ref2) {
+        var val1 = _ref.node.props.value;
+        var val2 = _ref2.node.props.value;
+        var index1 = checkedValues.indexOf(val1);
+        var index2 = checkedValues.indexOf(val2);
+        return index1 - index2;
+      });
+    }
+  }
+
+  Object.defineProperty(extra, 'triggerNode', {
+    get: function get() {
+      (0, _warning.default)(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      return triggerNode;
+    }
+  });
+  Object.defineProperty(extra, 'allCheckedNodes', {
+    get: function get() {
+      (0, _warning.default)(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+
+      if (showPosition) {
+        return nodeList;
+      }
+
+      return nodeList.map(function (_ref3) {
+        var node = _ref3.node;
+        return node;
+      });
+    }
+  });
+}

web/node_modules/rc-tree-select/lib/utils/strategyUtil.d.ts

@@ -0,0 +1,7 @@
+import { DataEntity } from 'rc-tree/lib/interface';
+import { RawValueType, Key } from '../interface';
+export declare const SHOW_ALL = "SHOW_ALL";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+export declare type CheckedStrategy = typeof SHOW_ALL | typeof SHOW_PARENT | typeof SHOW_CHILD;
+export declare function formatStrategyKeys(keys: Key[], strategy: CheckedStrategy, keyEntities: Record<Key, DataEntity>): RawValueType[];

web/node_modules/rc-tree-select/lib/utils/strategyUtil.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatStrategyKeys = formatStrategyKeys;
+exports.SHOW_CHILD = exports.SHOW_PARENT = exports.SHOW_ALL = void 0;
+
+var _valueUtil = require("./valueUtil");
+
+var SHOW_ALL = 'SHOW_ALL';
+exports.SHOW_ALL = SHOW_ALL;
+var SHOW_PARENT = 'SHOW_PARENT';
+exports.SHOW_PARENT = SHOW_PARENT;
+var SHOW_CHILD = 'SHOW_CHILD';
+exports.SHOW_CHILD = SHOW_CHILD;
+
+function formatStrategyKeys(keys, strategy, keyEntities) {
+  var keySet = new Set(keys);
+
+  if (strategy === SHOW_CHILD) {
+    return keys.filter(function (key) {
+      var entity = keyEntities[key];
+
+      if (entity && entity.children && entity.children.every(function (_ref) {
+        var node = _ref.node;
+        return (0, _valueUtil.isCheckDisabled)(node) || keySet.has(node.key);
+      })) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  if (strategy === SHOW_PARENT) {
+    return keys.filter(function (key) {
+      var entity = keyEntities[key];
+      var parent = entity ? entity.parent : null;
+
+      if (parent && !(0, _valueUtil.isCheckDisabled)(parent.node) && keySet.has(parent.node.key)) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  return keys;
+}

web/node_modules/rc-tree-select/lib/utils/valueUtil.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { FilterFunc } from 'rc-select/lib/interface/generator';
+import { FlattenDataNode, RawValueType, DataNode, DefaultValueType, LabelValueType, LegacyDataNode } from '../interface';
+import { SkipType } from '../hooks/useKeyValueMapping';
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function findValueOption(values: RawValueType[], options: FlattenDataNode[]): DataNode[];
+export declare function isValueDisabled(value: RawValueType, options: FlattenDataNode[]): boolean;
+export declare function isCheckDisabled(node: DataNode): boolean;
+/**
+ * Before reuse `rc-tree` logic, we need to add key since TreeSelect use `value` instead of `key`.
+ */
+export declare function flattenOptions(options: DataNode[]): FlattenDataNode[];
+/** Filter options and return a new options by the search text */
+export declare function filterOptions(searchValue: string, options: DataNode[], { optionFilterProp, filterOption, }: {
+    optionFilterProp: string;
+    filterOption: boolean | FilterFunc<LegacyDataNode>;
+}): DataNode[];
+export declare function getRawValueLabeled(values: RawValueType[], prevValue: DefaultValueType, getEntityByValue: (value: RawValueType, skipType?: SkipType) => FlattenDataNode, getLabelProp: (node: DataNode) => React.ReactNode): LabelValueType[];
+export declare function addValue(rawValues: RawValueType[], value: RawValueType): (string | number)[];
+export declare function removeValue(rawValues: RawValueType[], value: RawValueType): (string | number)[];

web/node_modules/rc-tree-select/lib/utils/valueUtil.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toArray = toArray;
+exports.findValueOption = findValueOption;
+exports.isValueDisabled = isValueDisabled;
+exports.isCheckDisabled = isCheckDisabled;
+exports.flattenOptions = flattenOptions;
+exports.filterOptions = filterOptions;
+exports.getRawValueLabeled = getRawValueLabeled;
+exports.addValue = addValue;
+exports.removeValue = removeValue;
+
+var _treeUtil = require("rc-tree/lib/utils/treeUtil");
+
+var _legacyUtil = require("./legacyUtil");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  return value !== undefined ? [value] : [];
+}
+
+function findValueOption(values, options) {
+  var optionMap = new Map();
+  options.forEach(function (flattenItem) {
+    var data = flattenItem.data;
+    optionMap.set(data.value, data);
+  });
+  return values.map(function (val) {
+    return (0, _legacyUtil.fillLegacyProps)(optionMap.get(val));
+  });
+}
+
+function isValueDisabled(value, options) {
+  var option = findValueOption([value], options)[0];
+
+  if (option) {
+    return option.disabled;
+  }
+
+  return false;
+}
+
+function isCheckDisabled(node) {
+  return node.disabled || node.disableCheckbox || node.checkable === false;
+}
+
+function getLevel(_ref) {
+  var parent = _ref.parent;
+  var level = 0;
+  var current = parent;
+
+  while (current) {
+    current = current.parent;
+    level += 1;
+  }
+
+  return level;
+}
+/**
+ * Before reuse `rc-tree` logic, we need to add key since TreeSelect use `value` instead of `key`.
+ */
+
+
+function flattenOptions(options) {
+  // Add missing key
+  function fillKey(list) {
+    return (list || []).map(function (node) {
+      var value = node.value,
+          key = node.key,
+          children = node.children;
+
+      var clone = _objectSpread({}, node, {
+        key: 'key' in node ? key : value
+      });
+
+      if (children) {
+        clone.children = fillKey(children);
+      }
+
+      return clone;
+    });
+  }
+
+  var flattenList = (0, _treeUtil.flattenTreeData)(fillKey(options), true);
+  return flattenList.map(function (node) {
+    return {
+      key: node.data.key,
+      data: node.data,
+      level: getLevel(node)
+    };
+  });
+}
+
+function getDefaultFilterOption(optionFilterProp) {
+  return function (searchValue, dataNode) {
+    var value = dataNode[optionFilterProp];
+    return String(value).toLowerCase().includes(String(searchValue).toLowerCase());
+  };
+}
+/** Filter options and return a new options by the search text */
+
+
+function filterOptions(searchValue, options, _ref2) {
+  var optionFilterProp = _ref2.optionFilterProp,
+      filterOption = _ref2.filterOption;
+
+  if (filterOption === false) {
+    return options;
+  }
+
+  var filterOptionFunc;
+
+  if (typeof filterOption === 'function') {
+    filterOptionFunc = filterOption;
+  } else {
+    filterOptionFunc = getDefaultFilterOption(optionFilterProp);
+  }
+
+  function dig(list) {
+    var keepAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return list.map(function (dataNode) {
+      var children = dataNode.children;
+      var match = keepAll || filterOptionFunc(searchValue, (0, _legacyUtil.fillLegacyProps)(dataNode));
+      var childList = dig(children || [], match);
+
+      if (match || childList.length) {
+        return _objectSpread({}, dataNode, {
+          children: childList
+        });
+      }
+
+      return null;
+    }).filter(function (node) {
+      return node;
+    });
+  }
+
+  return dig(options);
+}
+
+function getRawValueLabeled(values, prevValue, getEntityByValue, getLabelProp) {
+  var valueMap = new Map();
+  toArray(prevValue).forEach(function (item) {
+    if (item && _typeof(item) === 'object' && 'value' in item) {
+      valueMap.set(item.value, item);
+    }
+  });
+  return values.map(function (val) {
+    var item = {
+      value: val
+    };
+    var entity = getEntityByValue(val);
+    var label = entity ? getLabelProp(entity.data) : val;
+
+    if (valueMap.has(val)) {
+      var labeledValue = valueMap.get(val);
+      item.label = 'label' in labeledValue ? labeledValue.label : label;
+
+      if ('halfChecked' in labeledValue) {
+        item.halfChecked = labeledValue.halfChecked;
+      }
+    } else {
+      item.label = label;
+    }
+
+    return item;
+  });
+}
+
+function addValue(rawValues, value) {
+  var values = new Set(rawValues);
+  values.add(value);
+  return Array.from(values);
+}
+
+function removeValue(rawValues, value) {
+  var values = new Set(rawValues);
+  values.delete(value);
+  return Array.from(values);
+}

web/node_modules/rc-tree-select/lib/utils/warningPropsUtil.d.ts

@@ -0,0 +1,3 @@
+import { TreeSelectProps } from '../TreeSelect';
+declare function warningProps(props: TreeSelectProps): void;
+export default warningProps;

web/node_modules/rc-tree-select/lib/utils/warningPropsUtil.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _valueUtil = require("./valueUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function warningProps(props) {
+  var searchPlaceholder = props.searchPlaceholder,
+      treeCheckStrictly = props.treeCheckStrictly,
+      treeCheckable = props.treeCheckable,
+      labelInValue = props.labelInValue,
+      value = props.value,
+      multiple = props.multiple;
+  (0, _warning.default)(!searchPlaceholder, '`searchPlaceholder` has been removed.');
+
+  if (treeCheckStrictly && labelInValue === false) {
+    (0, _warning.default)(false, '`treeCheckStrictly` will force set `labelInValue` to `true`.');
+  }
+
+  if (labelInValue || treeCheckStrictly) {
+    (0, _warning.default)((0, _valueUtil.toArray)(value).every(function (val) {
+      return val && _typeof(val) === 'object' && 'value' in val;
+    }), 'Invalid prop `value` supplied to `TreeSelect`. You should use { label: string, value: string | number } or [{ label: string, value: string | number }] instead.');
+  }
+
+  if (treeCheckStrictly || multiple || treeCheckable) {
+    (0, _warning.default)(!value || Array.isArray(value), '`value` should be an array when `TreeSelect` is checkable or multiple.');
+  } else {
+    (0, _warning.default)(!Array.isArray(value), '`value` should not be array when `TreeSelect` is single mode.');
+  }
+}
+
+var _default = warningProps;
+exports.default = _default;