Latest updates from IceHrmPro

web/node_modules/rc-cascader/es/Cascader.d.ts

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { BuildInPlacements, TriggerProps } from 'rc-trigger';
+export interface CascaderFieldNames {
+    value?: string;
+    label?: string;
+    children?: string;
+}
+export interface CascaderOption {
+    value?: string;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    loading?: boolean;
+    children?: CascaderOption[];
+    [key: string]: any;
+}
+export interface CascaderProps extends Pick<TriggerProps, 'getPopupContainer'> {
+    value?: string[];
+    defaultValue?: string[];
+    options?: CascaderOption[];
+    onChange?: (value: string[], selectOptions: CascaderOption[]) => void;
+    onPopupVisibleChange?: (popupVisible: boolean) => void;
+    popupVisible?: boolean;
+    disabled?: boolean;
+    transitionName?: string;
+    popupClassName?: string;
+    popupPlacement?: string;
+    prefixCls?: string;
+    dropdownMenuColumnStyle?: React.CSSProperties;
+    builtinPlacements?: BuildInPlacements;
+    loadData?: (selectOptions: CascaderOption[]) => void;
+    changeOnSelect?: boolean;
+    children?: React.ReactElement;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => void;
+    expandTrigger?: string;
+    fieldNames?: CascaderFieldNames;
+    filedNames?: CascaderFieldNames;
+    expandIcon?: React.ReactNode;
+    loadingIcon?: React.ReactNode;
+}
+interface CascaderState {
+    popupVisible?: boolean;
+    activeValue?: string[];
+    value?: string[];
+    prevProps?: CascaderProps;
+}
+declare class Cascader extends React.Component<CascaderProps, CascaderState> {
+    defaultFieldNames: object;
+    trigger: any;
+    constructor(props: CascaderProps);
+    static defaultProps: CascaderProps;
+    static getDerivedStateFromProps(nextProps: CascaderProps, prevState: CascaderState): CascaderState;
+    getPopupDOMNode(): any;
+    getFieldName(name: string): string;
+    getFieldNames(): CascaderFieldNames;
+    getCurrentLevelOptions(): CascaderOption[];
+    getActiveOptions(activeValue: string[]): CascaderOption[];
+    setPopupVisible: (popupVisible: boolean) => void;
+    handleChange: (options: CascaderOption[], { visible }: {
+        visible: any;
+    }, e: React.KeyboardEvent<HTMLElement>) => void;
+    handlePopupVisibleChange: (popupVisible: boolean) => void;
+    handleMenuSelect: (targetOption: CascaderOption, menuIndex: number, e: React.KeyboardEvent<HTMLElement>) => void;
+    handleItemDoubleClick: () => void;
+    handleKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+    saveTrigger: (node: any) => void;
+    render(): JSX.Element;
+}
+export default Cascader;

web/node_modules/rc-cascader/es/Cascader.js

@@ -0,0 +1,431 @@
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _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 _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); }
+
+import * as React from 'react';
+import Trigger from 'rc-trigger';
+import warning from 'warning';
+import KeyCode from "rc-util/es/KeyCode";
+import arrayTreeFilter from 'array-tree-filter';
+import { isEqualArrays } from './utils';
+import Menus from './Menus';
+import BUILT_IN_PLACEMENTS from './placements';
+
+var Cascader =
+/*#__PURE__*/
+function (_React$Component) {
+  _inherits(Cascader, _React$Component);
+
+  function Cascader(props) {
+    var _this;
+
+    _classCallCheck(this, Cascader);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(Cascader).call(this, props));
+
+    _this.setPopupVisible = function (popupVisible) {
+      var value = _this.state.value;
+
+      if (!('popupVisible' in _this.props)) {
+        _this.setState({
+          popupVisible: popupVisible
+        });
+      } // sync activeValue with value when panel open
+
+
+      if (popupVisible && !_this.state.popupVisible) {
+        _this.setState({
+          activeValue: value
+        });
+      }
+
+      _this.props.onPopupVisibleChange(popupVisible);
+    };
+
+    _this.handleChange = function (options, _ref, e) {
+      var visible = _ref.visible;
+
+      if (e.type !== 'keydown' || e.keyCode === KeyCode.ENTER) {
+        _this.props.onChange(options.map(function (o) {
+          return o[_this.getFieldName('value')];
+        }), options);
+
+        _this.setPopupVisible(visible);
+      }
+    };
+
+    _this.handlePopupVisibleChange = function (popupVisible) {
+      _this.setPopupVisible(popupVisible);
+    };
+
+    _this.handleMenuSelect = function (targetOption, menuIndex, e) {
+      // Keep focused state for keyboard support
+      var triggerNode = _this.trigger.getRootDomNode();
+
+      if (triggerNode && triggerNode.focus) {
+        triggerNode.focus();
+      }
+
+      var _this$props = _this.props,
+          changeOnSelect = _this$props.changeOnSelect,
+          loadData = _this$props.loadData,
+          expandTrigger = _this$props.expandTrigger;
+
+      if (!targetOption || targetOption.disabled) {
+        return;
+      }
+
+      var activeValue = _this.state.activeValue;
+      activeValue = activeValue.slice(0, menuIndex + 1);
+      activeValue[menuIndex] = targetOption[_this.getFieldName('value')];
+
+      var activeOptions = _this.getActiveOptions(activeValue);
+
+      if (targetOption.isLeaf === false && !targetOption[_this.getFieldName('children')] && loadData) {
+        if (changeOnSelect) {
+          _this.handleChange(activeOptions, {
+            visible: true
+          }, e);
+        }
+
+        _this.setState({
+          activeValue: activeValue
+        });
+
+        loadData(activeOptions);
+        return;
+      }
+
+      var newState = {};
+
+      if (!targetOption[_this.getFieldName('children')] || !targetOption[_this.getFieldName('children')].length) {
+        _this.handleChange(activeOptions, {
+          visible: false
+        }, e); // set value to activeValue when select leaf option
+
+
+        newState.value = activeValue; // add e.type judgement to prevent `onChange` being triggered by mouseEnter
+      } else if (changeOnSelect && (e.type === 'click' || e.type === 'keydown')) {
+        if (expandTrigger === 'hover') {
+          _this.handleChange(activeOptions, {
+            visible: false
+          }, e);
+        } else {
+          _this.handleChange(activeOptions, {
+            visible: true
+          }, e);
+        } // set value to activeValue on every select
+
+
+        newState.value = activeValue;
+      }
+
+      newState.activeValue = activeValue; //  not change the value by keyboard
+
+      if ('value' in _this.props || e.type === 'keydown' && e.keyCode !== KeyCode.ENTER) {
+        delete newState.value;
+      }
+
+      _this.setState(newState);
+    };
+
+    _this.handleItemDoubleClick = function () {
+      var changeOnSelect = _this.props.changeOnSelect;
+
+      if (changeOnSelect) {
+        _this.setPopupVisible(false);
+      }
+    };
+
+    _this.handleKeyDown = function (e) {
+      var children = _this.props.children; // https://github.com/ant-design/ant-design/issues/6717
+      // Don't bind keyboard support when children specify the onKeyDown
+
+      if (children && children.props.onKeyDown) {
+        children.props.onKeyDown(e);
+        return;
+      }
+
+      var activeValue = _toConsumableArray(_this.state.activeValue);
+
+      var currentLevel = activeValue.length - 1 < 0 ? 0 : activeValue.length - 1;
+
+      var currentOptions = _this.getCurrentLevelOptions();
+
+      var currentIndex = currentOptions.map(function (o) {
+        return o[_this.getFieldName('value')];
+      }).indexOf(activeValue[currentLevel]);
+
+      if (e.keyCode !== KeyCode.DOWN && e.keyCode !== KeyCode.UP && e.keyCode !== KeyCode.LEFT && e.keyCode !== KeyCode.RIGHT && e.keyCode !== KeyCode.ENTER && e.keyCode !== KeyCode.SPACE && e.keyCode !== KeyCode.BACKSPACE && e.keyCode !== KeyCode.ESC && e.keyCode !== KeyCode.TAB) {
+        return;
+      } // Press any keys above to reopen menu
+
+
+      if (!_this.state.popupVisible && e.keyCode !== KeyCode.BACKSPACE && e.keyCode !== KeyCode.LEFT && e.keyCode !== KeyCode.RIGHT && e.keyCode !== KeyCode.ESC && e.keyCode !== KeyCode.TAB) {
+        _this.setPopupVisible(true);
+
+        return;
+      }
+
+      if (e.keyCode === KeyCode.DOWN || e.keyCode === KeyCode.UP) {
+        e.preventDefault();
+        var nextIndex = currentIndex;
+
+        if (nextIndex !== -1) {
+          if (e.keyCode === KeyCode.DOWN) {
+            nextIndex += 1;
+            nextIndex = nextIndex >= currentOptions.length ? 0 : nextIndex;
+          } else {
+            nextIndex -= 1;
+            nextIndex = nextIndex < 0 ? currentOptions.length - 1 : nextIndex;
+          }
+        } else {
+          nextIndex = 0;
+        }
+
+        activeValue[currentLevel] = currentOptions[nextIndex][_this.getFieldName('value')];
+      } else if (e.keyCode === KeyCode.LEFT || e.keyCode === KeyCode.BACKSPACE) {
+        e.preventDefault();
+        activeValue.splice(activeValue.length - 1, 1);
+      } else if (e.keyCode === KeyCode.RIGHT) {
+        e.preventDefault();
+
+        if (currentOptions[currentIndex] && currentOptions[currentIndex][_this.getFieldName('children')]) {
+          activeValue.push(currentOptions[currentIndex][_this.getFieldName('children')][0][_this.getFieldName('value')]);
+        }
+      } else if (e.keyCode === KeyCode.ESC || e.keyCode === KeyCode.TAB) {
+        _this.setPopupVisible(false);
+
+        return;
+      }
+
+      if (!activeValue || activeValue.length === 0) {
+        _this.setPopupVisible(false);
+      }
+
+      var activeOptions = _this.getActiveOptions(activeValue);
+
+      var targetOption = activeOptions[activeOptions.length - 1];
+
+      _this.handleMenuSelect(targetOption, activeOptions.length - 1, e);
+
+      if (_this.props.onKeyDown) {
+        _this.props.onKeyDown(e);
+      }
+    };
+
+    _this.saveTrigger = function (node) {
+      _this.trigger = node;
+    };
+
+    var initialValue = [];
+
+    if ('value' in props) {
+      initialValue = props.value || [];
+    } else if ('defaultValue' in props) {
+      initialValue = props.defaultValue || [];
+    }
+
+    warning(!('filedNames' in props), '`filedNames` of Cascader is a typo usage and deprecated, please use `fieldNames` instead.');
+    _this.state = {
+      popupVisible: props.popupVisible,
+      activeValue: initialValue,
+      value: initialValue,
+      prevProps: props
+    };
+    _this.defaultFieldNames = {
+      label: 'label',
+      value: 'value',
+      children: 'children'
+    };
+    return _this;
+  }
+
+  _createClass(Cascader, [{
+    key: "getPopupDOMNode",
+    value: function getPopupDOMNode() {
+      return this.trigger.getPopupDomNode();
+    }
+  }, {
+    key: "getFieldName",
+    value: function getFieldName(name) {
+      var defaultFieldNames = this.defaultFieldNames;
+      var _this$props2 = this.props,
+          fieldNames = _this$props2.fieldNames,
+          filedNames = _this$props2.filedNames;
+
+      if ('filedNames' in this.props) {
+        return filedNames[name] || defaultFieldNames[name]; // For old compatibility
+      }
+
+      return fieldNames[name] || defaultFieldNames[name];
+    }
+  }, {
+    key: "getFieldNames",
+    value: function getFieldNames() {
+      var _this$props3 = this.props,
+          fieldNames = _this$props3.fieldNames,
+          filedNames = _this$props3.filedNames;
+
+      if ('filedNames' in this.props) {
+        return filedNames; // For old compatibility
+      }
+
+      return fieldNames;
+    }
+  }, {
+    key: "getCurrentLevelOptions",
+    value: function getCurrentLevelOptions() {
+      var _this2 = this;
+
+      var _this$props$options = this.props.options,
+          options = _this$props$options === void 0 ? [] : _this$props$options;
+      var _this$state$activeVal = this.state.activeValue,
+          activeValue = _this$state$activeVal === void 0 ? [] : _this$state$activeVal;
+      var result = arrayTreeFilter(options, function (o, level) {
+        return o[_this2.getFieldName('value')] === activeValue[level];
+      }, {
+        childrenKeyName: this.getFieldName('children')
+      });
+
+      if (result[result.length - 2]) {
+        return result[result.length - 2][this.getFieldName('children')];
+      }
+
+      return _toConsumableArray(options).filter(function (o) {
+        return !o.disabled;
+      });
+    }
+  }, {
+    key: "getActiveOptions",
+    value: function getActiveOptions(activeValue) {
+      var _this3 = this;
+
+      return arrayTreeFilter(this.props.options || [], function (o, level) {
+        return o[_this3.getFieldName('value')] === activeValue[level];
+      }, {
+        childrenKeyName: this.getFieldName('children')
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+          prefixCls = _this$props4.prefixCls,
+          transitionName = _this$props4.transitionName,
+          popupClassName = _this$props4.popupClassName,
+          _this$props4$options = _this$props4.options,
+          options = _this$props4$options === void 0 ? [] : _this$props4$options,
+          disabled = _this$props4.disabled,
+          builtinPlacements = _this$props4.builtinPlacements,
+          popupPlacement = _this$props4.popupPlacement,
+          children = _this$props4.children,
+          restProps = _objectWithoutProperties(_this$props4, ["prefixCls", "transitionName", "popupClassName", "options", "disabled", "builtinPlacements", "popupPlacement", "children"]); // Did not show popup when there is no options
+
+
+      var menus = React.createElement("div", null);
+      var emptyMenuClassName = '';
+
+      if (options && options.length > 0) {
+        menus = React.createElement(Menus, Object.assign({}, this.props, {
+          fieldNames: this.getFieldNames(),
+          defaultFieldNames: this.defaultFieldNames,
+          activeValue: this.state.activeValue,
+          onSelect: this.handleMenuSelect,
+          onItemDoubleClick: this.handleItemDoubleClick,
+          visible: this.state.popupVisible
+        }));
+      } else {
+        emptyMenuClassName = " ".concat(prefixCls, "-menus-empty");
+      }
+
+      return React.createElement(Trigger, Object.assign({
+        ref: this.saveTrigger
+      }, restProps, {
+        popupPlacement: popupPlacement,
+        builtinPlacements: builtinPlacements,
+        popupTransitionName: transitionName,
+        action: disabled ? [] : ['click'],
+        popupVisible: disabled ? false : this.state.popupVisible,
+        onPopupVisibleChange: this.handlePopupVisibleChange,
+        prefixCls: "".concat(prefixCls, "-menus"),
+        popupClassName: popupClassName + emptyMenuClassName,
+        popup: menus
+      }), React.cloneElement(children, {
+        onKeyDown: this.handleKeyDown,
+        tabIndex: disabled ? undefined : 0
+      }));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      var _prevState$prevProps = prevState.prevProps,
+          prevProps = _prevState$prevProps === void 0 ? {} : _prevState$prevProps;
+      var newState = {
+        prevProps: nextProps
+      };
+
+      if ('value' in nextProps && !isEqualArrays(prevProps.value, nextProps.value)) {
+        newState.value = nextProps.value || []; // allow activeValue diff from value
+        // https://github.com/ant-design/ant-design/issues/2767
+
+        if (!('loadData' in nextProps)) {
+          newState.activeValue = nextProps.value || [];
+        }
+      }
+
+      if ('popupVisible' in nextProps) {
+        newState.popupVisible = nextProps.popupVisible;
+      }
+
+      return newState;
+    }
+  }]);
+
+  return Cascader;
+}(React.Component);
+
+Cascader.defaultProps = {
+  onChange: function onChange() {},
+  onPopupVisibleChange: function onPopupVisibleChange() {},
+  disabled: false,
+  transitionName: '',
+  prefixCls: 'rc-cascader',
+  popupClassName: '',
+  popupPlacement: 'bottomLeft',
+  builtinPlacements: BUILT_IN_PLACEMENTS,
+  expandTrigger: 'click',
+  fieldNames: {
+    label: 'label',
+    value: 'value',
+    children: 'children'
+  },
+  expandIcon: '>'
+};
+export default Cascader;

web/node_modules/rc-cascader/es/Menus.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { CascaderOption, CascaderFieldNames } from './Cascader';
+interface MenusProps {
+    value?: string[];
+    activeValue?: string[];
+    options?: CascaderOption[];
+    prefixCls?: string;
+    expandTrigger?: string;
+    onSelect?: (targetOption: string[], index: number, e: React.KeyboardEvent<HTMLElement>) => void;
+    visible?: boolean;
+    dropdownMenuColumnStyle?: React.CSSProperties;
+    defaultFieldNames?: CascaderFieldNames;
+    fieldNames?: CascaderFieldNames;
+    expandIcon?: React.ReactNode;
+    loadingIcon?: React.ReactNode;
+    onItemDoubleClick?: (targetOption: string[], index: number, e: React.MouseEvent<HTMLElement>) => void;
+}
+interface MenuItems {
+    [index: number]: HTMLLIElement;
+}
+declare class Menus extends React.Component<MenusProps> {
+    menuItems: MenuItems;
+    delayTimer: number;
+    static defaultProps: MenusProps;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: MenusProps): void;
+    getFieldName(name: any): any;
+    getOption(option: CascaderOption, menuIndex: number): JSX.Element;
+    getActiveOptions(values?: CascaderOption[]): CascaderOption[];
+    getShowOptions(): CascaderOption[][];
+    delayOnSelect(onSelect: any, ...args: any[]): void;
+    scrollActiveItemToView(): void;
+    isActiveOption(option: any, menuIndex: any): boolean;
+    saveMenuItem: (index: any) => (node: any) => void;
+    render(): JSX.Element;
+}
+export default Menus;

web/node_modules/rc-cascader/es/Menus.js

@@ -0,0 +1,238 @@
+function _typeof(obj) { 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 _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); }
+
+import * as React from 'react';
+import arrayTreeFilter from 'array-tree-filter';
+
+var Menus =
+/*#__PURE__*/
+function (_React$Component) {
+  _inherits(Menus, _React$Component);
+
+  function Menus() {
+    var _this;
+
+    _classCallCheck(this, Menus);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(Menus).apply(this, arguments));
+    _this.menuItems = {};
+
+    _this.saveMenuItem = function (index) {
+      return function (node) {
+        _this.menuItems[index] = node;
+      };
+    };
+
+    return _this;
+  }
+
+  _createClass(Menus, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.scrollActiveItemToView();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (!prevProps.visible && this.props.visible) {
+        this.scrollActiveItemToView();
+      }
+    }
+  }, {
+    key: "getFieldName",
+    value: function getFieldName(name) {
+      var _this$props = this.props,
+          fieldNames = _this$props.fieldNames,
+          defaultFieldNames = _this$props.defaultFieldNames; // 防止只设置单个属性的名字
+
+      return fieldNames[name] || defaultFieldNames[name];
+    }
+  }, {
+    key: "getOption",
+    value: function getOption(option, menuIndex) {
+      var _this$props2 = this.props,
+          prefixCls = _this$props2.prefixCls,
+          expandTrigger = _this$props2.expandTrigger,
+          expandIcon = _this$props2.expandIcon,
+          loadingIcon = _this$props2.loadingIcon;
+      var onSelect = this.props.onSelect.bind(this, option, menuIndex);
+      var onItemDoubleClick = this.props.onItemDoubleClick.bind(this, option, menuIndex);
+      var expandProps = {
+        onClick: onSelect,
+        onDoubleClick: onItemDoubleClick
+      };
+      var menuItemCls = "".concat(prefixCls, "-menu-item");
+      var expandIconNode = null;
+      var hasChildren = option[this.getFieldName('children')] && option[this.getFieldName('children')].length > 0;
+
+      if (hasChildren || option.isLeaf === false) {
+        menuItemCls += " ".concat(prefixCls, "-menu-item-expand");
+
+        if (!option.loading) {
+          expandIconNode = React.createElement("span", {
+            className: "".concat(prefixCls, "-menu-item-expand-icon")
+          }, expandIcon);
+        }
+      }
+
+      if (expandTrigger === 'hover' && (hasChildren || option.isLeaf === false)) {
+        expandProps = {
+          onMouseEnter: this.delayOnSelect.bind(this, onSelect),
+          onMouseLeave: this.delayOnSelect.bind(this),
+          onClick: onSelect
+        };
+      }
+
+      if (this.isActiveOption(option, menuIndex)) {
+        menuItemCls += " ".concat(prefixCls, "-menu-item-active");
+        expandProps.ref = this.saveMenuItem(menuIndex);
+      }
+
+      if (option.disabled) {
+        menuItemCls += " ".concat(prefixCls, "-menu-item-disabled");
+      }
+
+      var loadingIconNode = null;
+
+      if (option.loading) {
+        menuItemCls += " ".concat(prefixCls, "-menu-item-loading");
+        loadingIconNode = loadingIcon || null;
+      }
+
+      var title = '';
+
+      if ('title' in option) {
+        // eslint-disable-next-line prefer-destructuring
+        title = option.title;
+      } else if (typeof option[this.getFieldName('label')] === 'string') {
+        title = option[this.getFieldName('label')];
+      }
+
+      return React.createElement("li", Object.assign({
+        key: option[this.getFieldName('value')],
+        className: menuItemCls,
+        title: title
+      }, expandProps, {
+        role: "menuitem",
+        onMouseDown: function onMouseDown(e) {
+          return e.preventDefault();
+        }
+      }), option[this.getFieldName('label')], expandIconNode, loadingIconNode);
+    }
+  }, {
+    key: "getActiveOptions",
+    value: function getActiveOptions(values) {
+      var _this2 = this;
+
+      var options = this.props.options;
+      var activeValue = values || this.props.activeValue;
+      return arrayTreeFilter(options, function (o, level) {
+        return o[_this2.getFieldName('value')] === activeValue[level];
+      }, {
+        childrenKeyName: this.getFieldName('children')
+      });
+    }
+  }, {
+    key: "getShowOptions",
+    value: function getShowOptions() {
+      var _this3 = this;
+
+      var options = this.props.options;
+      var result = this.getActiveOptions().map(function (activeOption) {
+        return activeOption[_this3.getFieldName('children')];
+      }).filter(function (activeOption) {
+        return !!activeOption;
+      });
+      result.unshift(options);
+      return result;
+    }
+  }, {
+    key: "delayOnSelect",
+    value: function delayOnSelect(onSelect) {
+      var _this4 = this;
+
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      if (this.delayTimer) {
+        clearTimeout(this.delayTimer);
+        this.delayTimer = null;
+      }
+
+      if (typeof onSelect === 'function') {
+        this.delayTimer = window.setTimeout(function () {
+          onSelect(args);
+          _this4.delayTimer = null;
+        }, 150);
+      }
+    }
+  }, {
+    key: "scrollActiveItemToView",
+    value: function scrollActiveItemToView() {
+      // scroll into view
+      var optionsLength = this.getShowOptions().length; // eslint-disable-next-line no-plusplus
+
+      for (var i = 0; i < optionsLength; i++) {
+        var itemComponent = this.menuItems[i];
+
+        if (itemComponent && itemComponent.parentElement) {
+          itemComponent.parentElement.scrollTop = itemComponent.offsetTop;
+        }
+      }
+    }
+  }, {
+    key: "isActiveOption",
+    value: function isActiveOption(option, menuIndex) {
+      var _this$props$activeVal = this.props.activeValue,
+          activeValue = _this$props$activeVal === void 0 ? [] : _this$props$activeVal;
+      return activeValue[menuIndex] === option[this.getFieldName('value')];
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this5 = this;
+
+      var _this$props3 = this.props,
+          prefixCls = _this$props3.prefixCls,
+          dropdownMenuColumnStyle = _this$props3.dropdownMenuColumnStyle;
+      return React.createElement("div", null, this.getShowOptions().map(function (options, menuIndex) {
+        return React.createElement("ul", {
+          className: "".concat(prefixCls, "-menu"),
+          key: menuIndex,
+          style: dropdownMenuColumnStyle
+        }, options.map(function (option) {
+          return _this5.getOption(option, menuIndex);
+        }));
+      }));
+    }
+  }]);
+
+  return Menus;
+}(React.Component);
+
+Menus.defaultProps = {
+  options: [],
+  value: [],
+  activeValue: [],
+  onSelect: function onSelect() {},
+  prefixCls: 'rc-cascader-menus',
+  visible: false,
+  expandTrigger: 'click'
+};
+export default Menus;

web/node_modules/rc-cascader/es/index.d.ts

@@ -0,0 +1,2 @@
+import Cascader from './Cascader';
+export default Cascader;

web/node_modules/rc-cascader/es/index.js

@@ -0,0 +1,2 @@
+import Cascader from './Cascader';
+export default Cascader;

web/node_modules/rc-cascader/es/placements.d.ts

@@ -0,0 +1,3 @@
+import { BuildInPlacements } from 'rc-trigger';
+declare const BUILT_IN_PLACEMENTS: BuildInPlacements;
+export default BUILT_IN_PLACEMENTS;

web/node_modules/rc-cascader/es/placements.js

@@ -0,0 +1,35 @@
+var BUILT_IN_PLACEMENTS = {
+  bottomLeft: {
+    points: ['tl', 'bl'],
+    offset: [0, 4],
+    overflow: {
+      adjustX: 1,
+      adjustY: 1
+    }
+  },
+  topLeft: {
+    points: ['bl', 'tl'],
+    offset: [0, -4],
+    overflow: {
+      adjustX: 1,
+      adjustY: 1
+    }
+  },
+  bottomRight: {
+    points: ['tr', 'br'],
+    offset: [0, 4],
+    overflow: {
+      adjustX: 1,
+      adjustY: 1
+    }
+  },
+  topRight: {
+    points: ['br', 'tr'],
+    offset: [0, -4],
+    overflow: {
+      adjustX: 1,
+      adjustY: 1
+    }
+  }
+};
+export default BUILT_IN_PLACEMENTS;

web/node_modules/rc-cascader/es/utils.d.ts

@@ -0,0 +1 @@
+export declare function isEqualArrays(arrA: any[], arrB: any[]): boolean;

web/node_modules/rc-cascader/es/utils.js

@@ -0,0 +1,24 @@
+export function isEqualArrays(arrA, arrB) {
+  if (arrA === arrB) {
+    return true;
+  }
+
+  if (!arrA || !arrB) {
+    return false;
+  }
+
+  var len = arrA.length;
+
+  if (arrB.length !== len) {
+    return false;
+  } // eslint-disable-next-line no-plusplus
+
+
+  for (var i = 0; i < len; i++) {
+    if (arrA[i] !== arrB[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}