first commit

frontend/node_modules/rc-select/lib/Selector/Input.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+type InputRef = HTMLInputElement | HTMLTextAreaElement;
+interface InputProps {
+    prefixCls: string;
+    id: string;
+    inputElement: React.ReactElement;
+    disabled: boolean;
+    autoFocus: boolean;
+    autoComplete: string;
+    editable: boolean;
+    activeDescendantId?: string;
+    value: string;
+    maxLength?: number;
+    open: boolean;
+    tabIndex: number;
+    /** Pass accessibility props to input */
+    attrs: Record<string, unknown>;
+    onKeyDown: React.KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+    onMouseDown: React.MouseEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+    onChange: React.ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+    onPaste: React.ClipboardEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+    onBlur: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+    onCompositionStart: React.CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+    onCompositionEnd: React.CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement | HTMLElement>;
+}
+declare const RefInput: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<InputRef>>;
+export default RefInput;

frontend/node_modules/rc-select/lib/Selector/Input.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _ref = require("rc-util/lib/ref");
+var _warning = require("rc-util/lib/warning");
+var _composeProps = _interopRequireDefault(require("rc-util/lib/composeProps"));
+var _excluded = ["prefixCls", "id", "inputElement", "autoFocus", "autoComplete", "editable", "activeDescendantId", "value", "open", "attrs"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var Input = function Input(props, ref) {
+  var prefixCls = props.prefixCls,
+    id = props.id,
+    inputElement = props.inputElement,
+    autoFocus = props.autoFocus,
+    autoComplete = props.autoComplete,
+    editable = props.editable,
+    activeDescendantId = props.activeDescendantId,
+    value = props.value,
+    open = props.open,
+    attrs = props.attrs,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var inputNode = inputElement || /*#__PURE__*/React.createElement("input", null);
+  var _inputNode = inputNode,
+    originRef = _inputNode.ref,
+    originProps = _inputNode.props;
+  (0, _warning.warning)(!('maxLength' in inputNode.props), "Passing 'maxLength' to input element directly may not work because input in BaseSelect is controlled.");
+  inputNode = /*#__PURE__*/React.cloneElement(inputNode, (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({
+    type: 'search'
+  }, (0, _composeProps.default)(restProps, originProps, true)), {}, {
+    // Override over origin props
+    id: id,
+    ref: (0, _ref.composeRef)(ref, originRef),
+    autoComplete: autoComplete || 'off',
+    autoFocus: autoFocus,
+    className: (0, _classnames.default)("".concat(prefixCls, "-selection-search-input"), originProps === null || originProps === void 0 ? void 0 : originProps.className),
+    role: 'combobox',
+    'aria-expanded': open || false,
+    'aria-haspopup': 'listbox',
+    'aria-owns': "".concat(id, "_list"),
+    'aria-autocomplete': 'list',
+    'aria-controls': "".concat(id, "_list"),
+    'aria-activedescendant': open ? activeDescendantId : undefined
+  }, attrs), {}, {
+    value: editable ? value : '',
+    readOnly: !editable,
+    unselectable: !editable ? 'on' : null,
+    style: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, originProps.style), {}, {
+      opacity: editable ? null : 0
+    })
+  }));
+  return inputNode;
+};
+var RefInput = /*#__PURE__*/React.forwardRef(Input);
+if (process.env.NODE_ENV !== 'production') {
+  RefInput.displayName = 'Input';
+}
+var _default = exports.default = RefInput;

frontend/node_modules/rc-select/lib/Selector/MultipleSelector.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { InnerSelectorProps } from '.';
+import type { DisplayValueType, RenderNode, CustomTagProps } from '../BaseSelect';
+interface SelectorProps extends InnerSelectorProps {
+    removeIcon?: RenderNode;
+    maxTagCount?: number | 'responsive';
+    maxTagTextLength?: number;
+    maxTagPlaceholder?: React.ReactNode | ((omittedValues: DisplayValueType[]) => React.ReactNode);
+    tokenSeparators?: string[];
+    tagRender?: (props: CustomTagProps) => React.ReactElement;
+    onToggleOpen: (open?: boolean) => void;
+    choiceTransitionName?: string;
+    onRemove: (value: DisplayValueType) => void;
+}
+declare const SelectSelector: React.FC<SelectorProps>;
+export default SelectSelector;

frontend/node_modules/rc-select/lib/Selector/MultipleSelector.js

@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _pickAttrs = _interopRequireDefault(require("rc-util/lib/pickAttrs"));
+var _rcOverflow = _interopRequireDefault(require("rc-overflow"));
+var _TransBtn = _interopRequireDefault(require("../TransBtn"));
+var _Input = _interopRequireDefault(require("./Input"));
+var _useLayoutEffect = _interopRequireDefault(require("../hooks/useLayoutEffect"));
+var _commonUtil = require("../utils/commonUtil");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function itemKey(value) {
+  var _value$key;
+  return (_value$key = value.key) !== null && _value$key !== void 0 ? _value$key : value.value;
+}
+var onPreventMouseDown = function onPreventMouseDown(event) {
+  event.preventDefault();
+  event.stopPropagation();
+};
+var SelectSelector = function SelectSelector(props) {
+  var id = props.id,
+    prefixCls = props.prefixCls,
+    values = props.values,
+    open = props.open,
+    searchValue = props.searchValue,
+    autoClearSearchValue = props.autoClearSearchValue,
+    inputRef = props.inputRef,
+    placeholder = props.placeholder,
+    disabled = props.disabled,
+    mode = props.mode,
+    showSearch = props.showSearch,
+    autoFocus = props.autoFocus,
+    autoComplete = props.autoComplete,
+    activeDescendantId = props.activeDescendantId,
+    tabIndex = props.tabIndex,
+    removeIcon = props.removeIcon,
+    maxTagCount = props.maxTagCount,
+    maxTagTextLength = props.maxTagTextLength,
+    _props$maxTagPlacehol = props.maxTagPlaceholder,
+    maxTagPlaceholder = _props$maxTagPlacehol === void 0 ? function (omittedValues) {
+      return "+ ".concat(omittedValues.length, " ...");
+    } : _props$maxTagPlacehol,
+    tagRender = props.tagRender,
+    onToggleOpen = props.onToggleOpen,
+    onRemove = props.onRemove,
+    onInputChange = props.onInputChange,
+    onInputPaste = props.onInputPaste,
+    onInputKeyDown = props.onInputKeyDown,
+    onInputMouseDown = props.onInputMouseDown,
+    onInputCompositionStart = props.onInputCompositionStart,
+    onInputCompositionEnd = props.onInputCompositionEnd,
+    onInputBlur = props.onInputBlur;
+  var measureRef = React.useRef(null);
+  var _useState = (0, _react.useState)(0),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    inputWidth = _useState2[0],
+    setInputWidth = _useState2[1];
+  var _useState3 = (0, _react.useState)(false),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    focused = _useState4[0],
+    setFocused = _useState4[1];
+  var selectionPrefixCls = "".concat(prefixCls, "-selection");
+
+  // ===================== Search ======================
+  var inputValue = open || mode === 'multiple' && autoClearSearchValue === false || mode === 'tags' ? searchValue : '';
+  var inputEditable = mode === 'tags' || mode === 'multiple' && autoClearSearchValue === false || showSearch && (open || focused);
+
+  // We measure width and set to the input immediately
+  (0, _useLayoutEffect.default)(function () {
+    setInputWidth(measureRef.current.scrollWidth);
+  }, [inputValue]);
+
+  // ===================== Render ======================
+  // >>> Render Selector Node. Includes Item & Rest
+  var defaultRenderSelector = function defaultRenderSelector(item, content, itemDisabled, closable, onClose) {
+    return /*#__PURE__*/React.createElement("span", {
+      title: (0, _commonUtil.getTitle)(item),
+      className: (0, _classnames.default)("".concat(selectionPrefixCls, "-item"), (0, _defineProperty2.default)({}, "".concat(selectionPrefixCls, "-item-disabled"), itemDisabled))
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "".concat(selectionPrefixCls, "-item-content")
+    }, content), closable && /*#__PURE__*/React.createElement(_TransBtn.default, {
+      className: "".concat(selectionPrefixCls, "-item-remove"),
+      onMouseDown: onPreventMouseDown,
+      onClick: onClose,
+      customizeIcon: removeIcon
+    }, "\xD7"));
+  };
+  var customizeRenderSelector = function customizeRenderSelector(value, content, itemDisabled, closable, onClose, isMaxTag) {
+    var onMouseDown = function onMouseDown(e) {
+      onPreventMouseDown(e);
+      onToggleOpen(!open);
+    };
+    return /*#__PURE__*/React.createElement("span", {
+      onMouseDown: onMouseDown
+    }, tagRender({
+      label: content,
+      value: value,
+      disabled: itemDisabled,
+      closable: closable,
+      onClose: onClose,
+      isMaxTag: !!isMaxTag
+    }));
+  };
+  var renderItem = function renderItem(valueItem) {
+    var itemDisabled = valueItem.disabled,
+      label = valueItem.label,
+      value = valueItem.value;
+    var closable = !disabled && !itemDisabled;
+    var displayLabel = label;
+    if (typeof maxTagTextLength === 'number') {
+      if (typeof label === 'string' || typeof label === 'number') {
+        var strLabel = String(displayLabel);
+        if (strLabel.length > maxTagTextLength) {
+          displayLabel = "".concat(strLabel.slice(0, maxTagTextLength), "...");
+        }
+      }
+    }
+    var onClose = function onClose(event) {
+      if (event) {
+        event.stopPropagation();
+      }
+      onRemove(valueItem);
+    };
+    return typeof tagRender === 'function' ? customizeRenderSelector(value, displayLabel, itemDisabled, closable, onClose) : defaultRenderSelector(valueItem, displayLabel, itemDisabled, closable, onClose);
+  };
+  var renderRest = function renderRest(omittedValues) {
+    // https://github.com/ant-design/ant-design/issues/48930
+    if (!values.length) {
+      return null;
+    }
+    var content = typeof maxTagPlaceholder === 'function' ? maxTagPlaceholder(omittedValues) : maxTagPlaceholder;
+    return typeof tagRender === 'function' ? customizeRenderSelector(undefined, content, false, false, undefined, true) : defaultRenderSelector({
+      title: content
+    }, content, false);
+  };
+
+  // >>> Input Node
+  var inputNode = /*#__PURE__*/React.createElement("div", {
+    className: "".concat(selectionPrefixCls, "-search"),
+    style: {
+      width: inputWidth
+    },
+    onFocus: function onFocus() {
+      setFocused(true);
+    },
+    onBlur: function onBlur() {
+      setFocused(false);
+    }
+  }, /*#__PURE__*/React.createElement(_Input.default, {
+    ref: inputRef,
+    open: open,
+    prefixCls: prefixCls,
+    id: id,
+    inputElement: null,
+    disabled: disabled,
+    autoFocus: autoFocus,
+    autoComplete: autoComplete,
+    editable: inputEditable,
+    activeDescendantId: activeDescendantId,
+    value: inputValue,
+    onKeyDown: onInputKeyDown,
+    onMouseDown: onInputMouseDown,
+    onChange: onInputChange,
+    onPaste: onInputPaste,
+    onCompositionStart: onInputCompositionStart,
+    onCompositionEnd: onInputCompositionEnd,
+    onBlur: onInputBlur,
+    tabIndex: tabIndex,
+    attrs: (0, _pickAttrs.default)(props, true)
+  }), /*#__PURE__*/React.createElement("span", {
+    ref: measureRef,
+    className: "".concat(selectionPrefixCls, "-search-mirror"),
+    "aria-hidden": true
+  }, inputValue, "\xA0"));
+
+  // >>> Selections
+  var selectionNode = /*#__PURE__*/React.createElement(_rcOverflow.default, {
+    prefixCls: "".concat(selectionPrefixCls, "-overflow"),
+    data: values,
+    renderItem: renderItem,
+    renderRest: renderRest,
+    suffix: inputNode,
+    itemKey: itemKey,
+    maxCount: maxTagCount
+  });
+  return /*#__PURE__*/React.createElement("span", {
+    className: "".concat(selectionPrefixCls, "-wrap")
+  }, selectionNode, !values.length && !inputValue && /*#__PURE__*/React.createElement("span", {
+    className: "".concat(selectionPrefixCls, "-placeholder")
+  }, placeholder));
+};
+var _default = exports.default = SelectSelector;

frontend/node_modules/rc-select/lib/Selector/SingleSelector.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import type { InnerSelectorProps } from '.';
+interface SelectorProps extends InnerSelectorProps {
+    inputElement: React.ReactElement;
+    activeValue: string;
+}
+declare const SingleSelector: React.FC<SelectorProps>;
+export default SingleSelector;

frontend/node_modules/rc-select/lib/Selector/SingleSelector.js

@@ -0,0 +1,116 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _pickAttrs = _interopRequireDefault(require("rc-util/lib/pickAttrs"));
+var _Input = _interopRequireDefault(require("./Input"));
+var _commonUtil = require("../utils/commonUtil");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var SingleSelector = function SingleSelector(props) {
+  var inputElement = props.inputElement,
+    prefixCls = props.prefixCls,
+    id = props.id,
+    inputRef = props.inputRef,
+    disabled = props.disabled,
+    autoFocus = props.autoFocus,
+    autoComplete = props.autoComplete,
+    activeDescendantId = props.activeDescendantId,
+    mode = props.mode,
+    open = props.open,
+    values = props.values,
+    placeholder = props.placeholder,
+    tabIndex = props.tabIndex,
+    showSearch = props.showSearch,
+    searchValue = props.searchValue,
+    activeValue = props.activeValue,
+    maxLength = props.maxLength,
+    onInputKeyDown = props.onInputKeyDown,
+    onInputMouseDown = props.onInputMouseDown,
+    onInputChange = props.onInputChange,
+    onInputPaste = props.onInputPaste,
+    onInputCompositionStart = props.onInputCompositionStart,
+    onInputCompositionEnd = props.onInputCompositionEnd,
+    onInputBlur = props.onInputBlur,
+    title = props.title;
+  var _React$useState = React.useState(false),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    inputChanged = _React$useState2[0],
+    setInputChanged = _React$useState2[1];
+  var combobox = mode === 'combobox';
+  var inputEditable = combobox || showSearch;
+  var item = values[0];
+  var inputValue = searchValue || '';
+  if (combobox && activeValue && !inputChanged) {
+    inputValue = activeValue;
+  }
+  React.useEffect(function () {
+    if (combobox) {
+      setInputChanged(false);
+    }
+  }, [combobox, activeValue]);
+
+  // Not show text when closed expect combobox mode
+  var hasTextInput = mode !== 'combobox' && !open && !showSearch ? false : !!inputValue;
+
+  // Get title of selection item
+  var selectionTitle = title === undefined ? (0, _commonUtil.getTitle)(item) : title;
+  var placeholderNode = React.useMemo(function () {
+    if (item) {
+      return null;
+    }
+    return /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-selection-placeholder"),
+      style: hasTextInput ? {
+        visibility: 'hidden'
+      } : undefined
+    }, placeholder);
+  }, [item, hasTextInput, placeholder, prefixCls]);
+  return /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-selection-wrap")
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-selection-search")
+  }, /*#__PURE__*/React.createElement(_Input.default, {
+    ref: inputRef,
+    prefixCls: prefixCls,
+    id: id,
+    open: open,
+    inputElement: inputElement,
+    disabled: disabled,
+    autoFocus: autoFocus,
+    autoComplete: autoComplete,
+    editable: inputEditable,
+    activeDescendantId: activeDescendantId,
+    value: inputValue,
+    onKeyDown: onInputKeyDown,
+    onMouseDown: onInputMouseDown,
+    onChange: function onChange(e) {
+      setInputChanged(true);
+      onInputChange(e);
+    },
+    onPaste: onInputPaste,
+    onCompositionStart: onInputCompositionStart,
+    onCompositionEnd: onInputCompositionEnd,
+    onBlur: onInputBlur,
+    tabIndex: tabIndex,
+    attrs: (0, _pickAttrs.default)(props, true),
+    maxLength: combobox ? maxLength : undefined
+  })), !combobox && item ? /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-selection-item"),
+    title: selectionTitle
+    // 当 Select 已经选中选项时，还需 selection 隐藏但留在原地占位
+    // https://github.com/ant-design/ant-design/issues/27688
+    // https://github.com/ant-design/ant-design/issues/41530
+    ,
+    style: hasTextInput ? {
+      visibility: 'hidden'
+    } : undefined
+  }, item.label) : null, placeholderNode);
+};
+var _default = exports.default = SingleSelector;

frontend/node_modules/rc-select/lib/Selector/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Cursor rule:
+ * 1. Only `showSearch` enabled
+ * 2. Only `open` is `true`
+ * 3. When typing, set `open` to `true` which hit rule of 2
+ *
+ * Accessibility:
+ * - https://www.w3.org/TR/wai-aria-practices/examples/combobox/aria1.1pattern/listbox-combo.html
+ */
+import type { ScrollTo } from 'rc-virtual-list/lib/List';
+import * as React from 'react';
+import type { CustomTagProps, DisplayValueType, Mode, RenderNode } from '../BaseSelect';
+export interface InnerSelectorProps {
+    prefixCls: string;
+    id: string;
+    mode: Mode;
+    title?: string;
+    inputRef: React.Ref<HTMLInputElement | HTMLTextAreaElement>;
+    placeholder?: React.ReactNode;
+    disabled?: boolean;
+    autoFocus?: boolean;
+    autoComplete?: string;
+    values: DisplayValueType[];
+    showSearch?: boolean;
+    searchValue: string;
+    autoClearSearchValue?: boolean;
+    activeDescendantId?: string;
+    open: boolean;
+    tabIndex?: number;
+    maxLength?: number;
+    onInputKeyDown: React.KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputMouseDown: React.MouseEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputChange: React.ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputPaste: React.ClipboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputCompositionStart: React.CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputCompositionEnd: React.CompositionEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputBlur: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+}
+export interface RefSelectorProps {
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    scrollTo?: ScrollTo;
+}
+export interface SelectorProps {
+    id: string;
+    prefixCls: string;
+    showSearch?: boolean;
+    open: boolean;
+    /** Display in the Selector value, it's not same as `value` prop */
+    values: DisplayValueType[];
+    mode: Mode;
+    searchValue: string;
+    activeValue: string;
+    autoClearSearchValue: boolean;
+    inputElement: JSX.Element;
+    maxLength?: number;
+    autoFocus?: boolean;
+    activeDescendantId?: string;
+    tabIndex?: number;
+    disabled?: boolean;
+    placeholder?: React.ReactNode;
+    removeIcon?: RenderNode;
+    prefix?: React.ReactNode;
+    maxTagCount?: number | 'responsive';
+    maxTagTextLength?: number;
+    maxTagPlaceholder?: React.ReactNode | ((omittedValues: DisplayValueType[]) => React.ReactNode);
+    tagRender?: (props: CustomTagProps) => React.ReactElement;
+    /** Check if `tokenSeparators` contains `\n` or `\r\n` */
+    tokenWithEnter?: boolean;
+    choiceTransitionName?: string;
+    onToggleOpen: (open?: boolean) => void;
+    /** `onSearch` returns go next step boolean to check if need do toggle open */
+    onSearch: (searchText: string, fromTyping: boolean, isCompositing: boolean) => boolean;
+    onSearchSubmit?: (searchText: string) => void;
+    onRemove: (value: DisplayValueType) => void;
+    onInputKeyDown?: React.KeyboardEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+    onInputBlur?: () => void;
+    /**
+     * @private get real dom for trigger align.
+     * This may be removed after React provides replacement of `findDOMNode`
+     */
+    domRef: React.Ref<HTMLDivElement>;
+}
+declare const ForwardSelector: React.ForwardRefExoticComponent<SelectorProps & React.RefAttributes<RefSelectorProps>>;
+export default ForwardSelector;

frontend/node_modules/rc-select/lib/Selector/index.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _useLock3 = _interopRequireDefault(require("../hooks/useLock"));
+var _keyUtil = require("../utils/keyUtil");
+var _MultipleSelector = _interopRequireDefault(require("./MultipleSelector"));
+var _SingleSelector = _interopRequireDefault(require("./SingleSelector"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Cursor rule:
+ * 1. Only `showSearch` enabled
+ * 2. Only `open` is `true`
+ * 3. When typing, set `open` to `true` which hit rule of 2
+ *
+ * Accessibility:
+ * - https://www.w3.org/TR/wai-aria-practices/examples/combobox/aria1.1pattern/listbox-combo.html
+ */
+
+var Selector = function Selector(props, ref) {
+  var inputRef = (0, _react.useRef)(null);
+  var compositionStatusRef = (0, _react.useRef)(false);
+  var prefixCls = props.prefixCls,
+    open = props.open,
+    mode = props.mode,
+    showSearch = props.showSearch,
+    tokenWithEnter = props.tokenWithEnter,
+    disabled = props.disabled,
+    prefix = props.prefix,
+    autoClearSearchValue = props.autoClearSearchValue,
+    onSearch = props.onSearch,
+    onSearchSubmit = props.onSearchSubmit,
+    onToggleOpen = props.onToggleOpen,
+    onInputKeyDown = props.onInputKeyDown,
+    onInputBlur = props.onInputBlur,
+    domRef = props.domRef;
+
+  // ======================= Ref =======================
+  React.useImperativeHandle(ref, function () {
+    return {
+      focus: function focus(options) {
+        inputRef.current.focus(options);
+      },
+      blur: function blur() {
+        inputRef.current.blur();
+      }
+    };
+  });
+
+  // ====================== Input ======================
+  var _useLock = (0, _useLock3.default)(0),
+    _useLock2 = (0, _slicedToArray2.default)(_useLock, 2),
+    getInputMouseDown = _useLock2[0],
+    setInputMouseDown = _useLock2[1];
+  var onInternalInputKeyDown = function onInternalInputKeyDown(event) {
+    var which = event.which;
+
+    // Compatible with multiple lines in TextArea
+    var isTextAreaElement = inputRef.current instanceof HTMLTextAreaElement;
+    if (!isTextAreaElement && open && (which === _KeyCode.default.UP || which === _KeyCode.default.DOWN)) {
+      event.preventDefault();
+    }
+    if (onInputKeyDown) {
+      onInputKeyDown(event);
+    }
+    if (which === _KeyCode.default.ENTER && mode === 'tags' && !compositionStatusRef.current && !open) {
+      // When menu isn't open, OptionList won't trigger a value change
+      // So when enter is pressed, the tag's input value should be emitted here to let selector know
+      onSearchSubmit === null || onSearchSubmit === void 0 || onSearchSubmit(event.target.value);
+    }
+    // Move within the text box
+    if (isTextAreaElement && !open && ~[_KeyCode.default.UP, _KeyCode.default.DOWN, _KeyCode.default.LEFT, _KeyCode.default.RIGHT].indexOf(which)) {
+      return;
+    }
+    if ((0, _keyUtil.isValidateOpenKey)(which)) {
+      onToggleOpen(true);
+    }
+  };
+
+  /**
+   * We can not use `findDOMNode` sine it will get warning,
+   * have to use timer to check if is input element.
+   */
+  var onInternalInputMouseDown = function onInternalInputMouseDown() {
+    setInputMouseDown(true);
+  };
+
+  // When paste come, ignore next onChange
+  var pastedTextRef = (0, _react.useRef)(null);
+  var triggerOnSearch = function triggerOnSearch(value) {
+    if (onSearch(value, true, compositionStatusRef.current) !== false) {
+      onToggleOpen(true);
+    }
+  };
+  var onInputCompositionStart = function onInputCompositionStart() {
+    compositionStatusRef.current = true;
+  };
+  var onInputCompositionEnd = function onInputCompositionEnd(e) {
+    compositionStatusRef.current = false;
+
+    // Trigger search again to support `tokenSeparators` with typewriting
+    if (mode !== 'combobox') {
+      triggerOnSearch(e.target.value);
+    }
+  };
+  var onInputChange = function onInputChange(event) {
+    var value = event.target.value;
+
+    // Pasted text should replace back to origin content
+    if (tokenWithEnter && pastedTextRef.current && /[\r\n]/.test(pastedTextRef.current)) {
+      // CRLF will be treated as a single space for input element
+      var replacedText = pastedTextRef.current.replace(/[\r\n]+$/, '').replace(/\r\n/g, ' ').replace(/[\r\n]/g, ' ');
+      value = value.replace(replacedText, pastedTextRef.current);
+    }
+    pastedTextRef.current = null;
+    triggerOnSearch(value);
+  };
+  var onInputPaste = function onInputPaste(e) {
+    var clipboardData = e.clipboardData;
+    var value = clipboardData === null || clipboardData === void 0 ? void 0 : clipboardData.getData('text');
+    pastedTextRef.current = value || '';
+  };
+  var onClick = function onClick(_ref) {
+    var target = _ref.target;
+    if (target !== inputRef.current) {
+      // Should focus input if click the selector
+      var isIE = document.body.style.msTouchAction !== undefined;
+      if (isIE) {
+        setTimeout(function () {
+          inputRef.current.focus();
+        });
+      } else {
+        inputRef.current.focus();
+      }
+    }
+  };
+  var onMouseDown = function onMouseDown(event) {
+    var inputMouseDown = getInputMouseDown();
+
+    // when mode is combobox and it is disabled, don't prevent default behavior
+    // https://github.com/ant-design/ant-design/issues/37320
+    // https://github.com/ant-design/ant-design/issues/48281
+    if (event.target !== inputRef.current && !inputMouseDown && !(mode === 'combobox' && disabled)) {
+      event.preventDefault();
+    }
+    if (mode !== 'combobox' && (!showSearch || !inputMouseDown) || !open) {
+      if (open && autoClearSearchValue !== false) {
+        onSearch('', true, false);
+      }
+      onToggleOpen();
+    }
+  };
+
+  // ================= Inner Selector ==================
+  var sharedProps = {
+    inputRef: inputRef,
+    onInputKeyDown: onInternalInputKeyDown,
+    onInputMouseDown: onInternalInputMouseDown,
+    onInputChange: onInputChange,
+    onInputPaste: onInputPaste,
+    onInputCompositionStart: onInputCompositionStart,
+    onInputCompositionEnd: onInputCompositionEnd,
+    onInputBlur: onInputBlur
+  };
+  var selectNode = mode === 'multiple' || mode === 'tags' ? /*#__PURE__*/React.createElement(_MultipleSelector.default, (0, _extends2.default)({}, props, sharedProps)) : /*#__PURE__*/React.createElement(_SingleSelector.default, (0, _extends2.default)({}, props, sharedProps));
+  return /*#__PURE__*/React.createElement("div", {
+    ref: domRef,
+    className: "".concat(prefixCls, "-selector"),
+    onClick: onClick,
+    onMouseDown: onMouseDown
+  }, prefix && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-prefix")
+  }, prefix), selectNode);
+};
+var ForwardSelector = /*#__PURE__*/React.forwardRef(Selector);
+if (process.env.NODE_ENV !== 'production') {
+  ForwardSelector.displayName = 'Selector';
+}
+var _default = exports.default = ForwardSelector;