You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5727 lines
211 KiB
5727 lines
211 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[80316],{
|
|
|
|
/***/ 80316:
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/antd/es/cascader/index.js + 63 modules ***!
|
|
\*************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ cascader; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(74902);
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons/es/icons/LeftOutlined.js + 1 modules
|
|
var LeftOutlined = __webpack_require__(6171);
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons/es/icons/LoadingOutlined.js + 1 modules
|
|
var LoadingOutlined = __webpack_require__(50888);
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons/es/icons/RightOutlined.js + 1 modules
|
|
var RightOutlined = __webpack_require__(18073);
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMergedState.js
|
|
var useMergedState = __webpack_require__(21770);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/warning.js
|
|
var es_warning = __webpack_require__(80334);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
var useLayoutEffect = __webpack_require__(8410);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/isMobile.js
|
|
var isMobile = __webpack_require__(31131);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/KeyCode.js
|
|
var KeyCode = __webpack_require__(15105);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/ref.js
|
|
var es_ref = __webpack_require__(42550);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useBaseProps.js
|
|
/**
|
|
* BaseSelect provide some parsed data into context.
|
|
* You can use this hooks to get them.
|
|
*/
|
|
|
|
|
|
var BaseSelectContext = /*#__PURE__*/react.createContext(null);
|
|
function useBaseProps() {
|
|
return react.useContext(BaseSelectContext);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useDelayReset.js
|
|
|
|
|
|
|
|
/**
|
|
* Similar with `useLock`, but this hook will always execute last value.
|
|
* When set to `true`, it will keep `true` for a short time even if `false` is set.
|
|
*/
|
|
function useDelayReset() {
|
|
var timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
bool = _React$useState2[0],
|
|
setBool = _React$useState2[1];
|
|
var delayRef = react.useRef(null);
|
|
var cancelLatest = function cancelLatest() {
|
|
window.clearTimeout(delayRef.current);
|
|
};
|
|
react.useEffect(function () {
|
|
return cancelLatest;
|
|
}, []);
|
|
var delaySetBool = function delaySetBool(value, callback) {
|
|
cancelLatest();
|
|
delayRef.current = window.setTimeout(function () {
|
|
setBool(value);
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
}, timeout);
|
|
};
|
|
return [bool, delaySetBool, cancelLatest];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useLock.js
|
|
|
|
|
|
/**
|
|
* Locker return cached mark.
|
|
* If set to `true`, will return `true` in a short time even if set `false`.
|
|
* If set to `false` and then set to `true`, will change to `true`.
|
|
* And after time duration, it will back to `null` automatically.
|
|
*/
|
|
function useLock() {
|
|
var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 250;
|
|
var lockRef = react.useRef(null);
|
|
var timeoutRef = react.useRef(null);
|
|
|
|
// Clean up
|
|
react.useEffect(function () {
|
|
return function () {
|
|
window.clearTimeout(timeoutRef.current);
|
|
};
|
|
}, []);
|
|
function doLock(locked) {
|
|
if (locked || lockRef.current === null) {
|
|
lockRef.current = locked;
|
|
}
|
|
window.clearTimeout(timeoutRef.current);
|
|
timeoutRef.current = window.setTimeout(function () {
|
|
lockRef.current = null;
|
|
}, duration);
|
|
}
|
|
return [function () {
|
|
return lockRef.current;
|
|
}, doLock];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useSelectTriggerControl.js
|
|
|
|
function useSelectTriggerControl(elements, open, triggerOpen, customizedTrigger) {
|
|
var propsRef = react.useRef(null);
|
|
propsRef.current = {
|
|
open: open,
|
|
triggerOpen: triggerOpen,
|
|
customizedTrigger: customizedTrigger
|
|
};
|
|
react.useEffect(function () {
|
|
function onGlobalMouseDown(event) {
|
|
var _propsRef$current;
|
|
// If trigger is customized, Trigger will take control of popupVisible
|
|
if ((_propsRef$current = propsRef.current) !== null && _propsRef$current !== void 0 && _propsRef$current.customizedTrigger) {
|
|
return;
|
|
}
|
|
var target = event.target;
|
|
if (target.shadowRoot && event.composed) {
|
|
target = event.composedPath()[0] || target;
|
|
}
|
|
if (propsRef.current.open && elements().filter(function (element) {
|
|
return element;
|
|
}).every(function (element) {
|
|
return !element.contains(target) && element !== target;
|
|
})) {
|
|
// Should trigger close
|
|
propsRef.current.triggerOpen(false);
|
|
}
|
|
}
|
|
window.addEventListener('mousedown', onGlobalMouseDown);
|
|
return function () {
|
|
return window.removeEventListener('mousedown', onGlobalMouseDown);
|
|
};
|
|
}, []);
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/pickAttrs.js
|
|
var pickAttrs = __webpack_require__(64217);
|
|
// EXTERNAL MODULE: ./node_modules/rc-overflow/es/index.js + 4 modules
|
|
var es = __webpack_require__(34243);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/TransBtn.js
|
|
|
|
|
|
var TransBtn = function TransBtn(_ref) {
|
|
var className = _ref.className,
|
|
customizeIcon = _ref.customizeIcon,
|
|
customizeIconProps = _ref.customizeIconProps,
|
|
_onMouseDown = _ref.onMouseDown,
|
|
onClick = _ref.onClick,
|
|
children = _ref.children;
|
|
var icon;
|
|
if (typeof customizeIcon === 'function') {
|
|
icon = customizeIcon(customizeIconProps);
|
|
} else {
|
|
icon = customizeIcon;
|
|
}
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
className: className,
|
|
onMouseDown: function onMouseDown(event) {
|
|
event.preventDefault();
|
|
if (_onMouseDown) {
|
|
_onMouseDown(event);
|
|
}
|
|
},
|
|
style: {
|
|
userSelect: 'none',
|
|
WebkitUserSelect: 'none'
|
|
},
|
|
unselectable: "on",
|
|
onClick: onClick,
|
|
"aria-hidden": true
|
|
}, icon !== undefined ? icon : /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()(className.split(/\s+/).map(function (cls) {
|
|
return "".concat(cls, "-icon");
|
|
}))
|
|
}, children));
|
|
};
|
|
/* harmony default export */ var es_TransBtn = (TransBtn);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/Selector/Input.js
|
|
|
|
|
|
|
|
|
|
|
|
var Input = function Input(_ref, ref) {
|
|
var _inputNode2, _inputNode2$props;
|
|
var prefixCls = _ref.prefixCls,
|
|
id = _ref.id,
|
|
inputElement = _ref.inputElement,
|
|
disabled = _ref.disabled,
|
|
tabIndex = _ref.tabIndex,
|
|
autoFocus = _ref.autoFocus,
|
|
autoComplete = _ref.autoComplete,
|
|
editable = _ref.editable,
|
|
activeDescendantId = _ref.activeDescendantId,
|
|
value = _ref.value,
|
|
maxLength = _ref.maxLength,
|
|
_onKeyDown = _ref.onKeyDown,
|
|
_onMouseDown = _ref.onMouseDown,
|
|
_onChange = _ref.onChange,
|
|
onPaste = _ref.onPaste,
|
|
_onCompositionStart = _ref.onCompositionStart,
|
|
_onCompositionEnd = _ref.onCompositionEnd,
|
|
open = _ref.open,
|
|
attrs = _ref.attrs;
|
|
var inputNode = inputElement || /*#__PURE__*/react.createElement("input", null);
|
|
var _inputNode = inputNode,
|
|
originRef = _inputNode.ref,
|
|
originProps = _inputNode.props;
|
|
var onOriginKeyDown = originProps.onKeyDown,
|
|
onOriginChange = originProps.onChange,
|
|
onOriginMouseDown = originProps.onMouseDown,
|
|
onOriginCompositionStart = originProps.onCompositionStart,
|
|
onOriginCompositionEnd = originProps.onCompositionEnd,
|
|
style = originProps.style;
|
|
(0,es_warning/* warning */.Kp)(!('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 */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
type: 'search'
|
|
}, originProps), {}, {
|
|
// Override over origin props
|
|
id: id,
|
|
ref: (0,es_ref/* composeRef */.sQ)(ref, originRef),
|
|
disabled: disabled,
|
|
tabIndex: tabIndex,
|
|
autoComplete: autoComplete || 'off',
|
|
autoFocus: autoFocus,
|
|
className: classnames_default()("".concat(prefixCls, "-selection-search-input"), (_inputNode2 = inputNode) === null || _inputNode2 === void 0 ? void 0 : (_inputNode2$props = _inputNode2.props) === null || _inputNode2$props === void 0 ? void 0 : _inputNode2$props.className),
|
|
role: 'combobox',
|
|
'aria-expanded': open,
|
|
'aria-haspopup': 'listbox',
|
|
'aria-owns': "".concat(id, "_list"),
|
|
'aria-autocomplete': 'list',
|
|
'aria-controls': "".concat(id, "_list"),
|
|
'aria-activedescendant': activeDescendantId
|
|
}, attrs), {}, {
|
|
value: editable ? value : '',
|
|
maxLength: maxLength,
|
|
readOnly: !editable,
|
|
unselectable: !editable ? 'on' : null,
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, style), {}, {
|
|
opacity: editable ? null : 0
|
|
}),
|
|
onKeyDown: function onKeyDown(event) {
|
|
_onKeyDown(event);
|
|
if (onOriginKeyDown) {
|
|
onOriginKeyDown(event);
|
|
}
|
|
},
|
|
onMouseDown: function onMouseDown(event) {
|
|
_onMouseDown(event);
|
|
if (onOriginMouseDown) {
|
|
onOriginMouseDown(event);
|
|
}
|
|
},
|
|
onChange: function onChange(event) {
|
|
_onChange(event);
|
|
if (onOriginChange) {
|
|
onOriginChange(event);
|
|
}
|
|
},
|
|
onCompositionStart: function onCompositionStart(event) {
|
|
_onCompositionStart(event);
|
|
if (onOriginCompositionStart) {
|
|
onOriginCompositionStart(event);
|
|
}
|
|
},
|
|
onCompositionEnd: function onCompositionEnd(event) {
|
|
_onCompositionEnd(event);
|
|
if (onOriginCompositionEnd) {
|
|
onOriginCompositionEnd(event);
|
|
}
|
|
},
|
|
onPaste: onPaste
|
|
}));
|
|
return inputNode;
|
|
};
|
|
var RefInput = /*#__PURE__*/react.forwardRef(Input);
|
|
RefInput.displayName = 'Input';
|
|
/* harmony default export */ var Selector_Input = (RefInput);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/utils/commonUtil.js
|
|
|
|
function commonUtil_toArray(value) {
|
|
if (Array.isArray(value)) {
|
|
return value;
|
|
}
|
|
return value !== undefined ? [value] : [];
|
|
}
|
|
var isClient = typeof window !== 'undefined' && window.document && window.document.documentElement;
|
|
|
|
/** Is client side and not jsdom */
|
|
var isBrowserClient = true && isClient;
|
|
function hasValue(value) {
|
|
return value !== undefined && value !== null;
|
|
}
|
|
function isTitleType(title) {
|
|
return ['string', 'number'].includes((0,esm_typeof/* default */.Z)(title));
|
|
}
|
|
function getTitle(item) {
|
|
var title = undefined;
|
|
if (item) {
|
|
if (isTitleType(item.title)) {
|
|
title = item.title.toString();
|
|
} else if (isTitleType(item.label)) {
|
|
title = item.label.toString();
|
|
}
|
|
}
|
|
return title;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useLayoutEffect.js
|
|
/* eslint-disable react-hooks/rules-of-hooks */
|
|
|
|
|
|
|
|
/**
|
|
* Wrap `React.useLayoutEffect` which will not throw warning message in test env
|
|
*/
|
|
function useLayoutEffect_useLayoutEffect(effect, deps) {
|
|
// Never happen in test env
|
|
if (isBrowserClient) {
|
|
/* istanbul ignore next */
|
|
react.useLayoutEffect(effect, deps);
|
|
} else {
|
|
react.useEffect(effect, deps);
|
|
}
|
|
}
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/Selector/MultipleSelector.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
var measureRef = react.useRef(null);
|
|
var _useState = (0,react.useState)(0),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
inputWidth = _useState2[0],
|
|
setInputWidth = _useState2[1];
|
|
var _useState3 = (0,react.useState)(false),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_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
|
|
useLayoutEffect_useLayoutEffect(function () {
|
|
setInputWidth(measureRef.current.scrollWidth);
|
|
}, [inputValue]);
|
|
|
|
// ===================== Render ======================
|
|
// >>> Render Selector Node. Includes Item & Rest
|
|
function defaultRenderSelector(item, content, itemDisabled, closable, onClose) {
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()("".concat(selectionPrefixCls, "-item"), (0,defineProperty/* default */.Z)({}, "".concat(selectionPrefixCls, "-item-disabled"), itemDisabled)),
|
|
title: getTitle(item)
|
|
}, /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(selectionPrefixCls, "-item-content")
|
|
}, content), closable && /*#__PURE__*/react.createElement(es_TransBtn, {
|
|
className: "".concat(selectionPrefixCls, "-item-remove"),
|
|
onMouseDown: onPreventMouseDown,
|
|
onClick: onClose,
|
|
customizeIcon: removeIcon
|
|
}, "\xD7"));
|
|
}
|
|
function customizeRenderSelector(value, content, itemDisabled, closable, onClose) {
|
|
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
|
|
}));
|
|
}
|
|
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);
|
|
}
|
|
function renderRest(omittedValues) {
|
|
var content = typeof maxTagPlaceholder === 'function' ? maxTagPlaceholder(omittedValues) : maxTagPlaceholder;
|
|
return 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(Selector_Input, {
|
|
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,
|
|
tabIndex: tabIndex,
|
|
attrs: (0,pickAttrs/* default */.Z)(props, true)
|
|
}), /*#__PURE__*/react.createElement("span", {
|
|
ref: measureRef,
|
|
className: "".concat(selectionPrefixCls, "-search-mirror"),
|
|
"aria-hidden": true
|
|
}, inputValue, "\xA0"));
|
|
|
|
// >>> Selections
|
|
var selectionNode = /*#__PURE__*/react.createElement(es/* default */.Z, {
|
|
prefixCls: "".concat(selectionPrefixCls, "-overflow"),
|
|
data: values,
|
|
renderItem: renderItem,
|
|
renderRest: renderRest,
|
|
suffix: inputNode,
|
|
itemKey: itemKey,
|
|
maxCount: maxTagCount
|
|
});
|
|
return /*#__PURE__*/react.createElement(react.Fragment, null, selectionNode, !values.length && !inputValue && /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(selectionPrefixCls, "-placeholder")
|
|
}, placeholder));
|
|
};
|
|
/* harmony default export */ var MultipleSelector = (SelectSelector);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/Selector/SingleSelector.js
|
|
|
|
|
|
|
|
|
|
|
|
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,
|
|
title = props.title;
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_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 ? getTitle(item) : title;
|
|
var renderPlaceholder = function renderPlaceholder() {
|
|
if (item) {
|
|
return null;
|
|
}
|
|
var hiddenStyle = hasTextInput ? {
|
|
visibility: 'hidden'
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-selection-placeholder"),
|
|
style: hiddenStyle
|
|
}, placeholder);
|
|
};
|
|
return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-selection-search")
|
|
}, /*#__PURE__*/react.createElement(Selector_Input, {
|
|
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,
|
|
tabIndex: tabIndex,
|
|
attrs: (0,pickAttrs/* default */.Z)(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, renderPlaceholder());
|
|
};
|
|
/* harmony default export */ var Selector_SingleSelector = (SingleSelector);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/utils/keyUtil.js
|
|
|
|
|
|
/** keyCode Judgment function */
|
|
function isValidateOpenKey(currentKeyCode) {
|
|
return ![
|
|
// System function button
|
|
KeyCode/* default.ESC */.Z.ESC, KeyCode/* default.SHIFT */.Z.SHIFT, KeyCode/* default.BACKSPACE */.Z.BACKSPACE, KeyCode/* default.TAB */.Z.TAB, KeyCode/* default.WIN_KEY */.Z.WIN_KEY, KeyCode/* default.ALT */.Z.ALT, KeyCode/* default.META */.Z.META, KeyCode/* default.WIN_KEY_RIGHT */.Z.WIN_KEY_RIGHT, KeyCode/* default.CTRL */.Z.CTRL, KeyCode/* default.SEMICOLON */.Z.SEMICOLON, KeyCode/* default.EQUALS */.Z.EQUALS, KeyCode/* default.CAPS_LOCK */.Z.CAPS_LOCK, KeyCode/* default.CONTEXT_MENU */.Z.CONTEXT_MENU,
|
|
// F1-F12
|
|
KeyCode/* default.F1 */.Z.F1, KeyCode/* default.F2 */.Z.F2, KeyCode/* default.F3 */.Z.F3, KeyCode/* default.F4 */.Z.F4, KeyCode/* default.F5 */.Z.F5, KeyCode/* default.F6 */.Z.F6, KeyCode/* default.F7 */.Z.F7, KeyCode/* default.F8 */.Z.F8, KeyCode/* default.F9 */.Z.F9, KeyCode/* default.F10 */.Z.F10, KeyCode/* default.F11 */.Z.F11, KeyCode/* default.F12 */.Z.F12].includes(currentKeyCode);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/Selector/index.js
|
|
|
|
|
|
/**
|
|
* 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,
|
|
autoClearSearchValue = props.autoClearSearchValue,
|
|
onSearch = props.onSearch,
|
|
onSearchSubmit = props.onSearchSubmit,
|
|
onToggleOpen = props.onToggleOpen,
|
|
onInputKeyDown = props.onInputKeyDown,
|
|
domRef = props.domRef;
|
|
|
|
// ======================= Ref =======================
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
focus: function focus() {
|
|
inputRef.current.focus();
|
|
},
|
|
blur: function blur() {
|
|
inputRef.current.blur();
|
|
}
|
|
};
|
|
});
|
|
|
|
// ====================== Input ======================
|
|
var _useLock = useLock(0),
|
|
_useLock2 = (0,slicedToArray/* default */.Z)(_useLock, 2),
|
|
getInputMouseDown = _useLock2[0],
|
|
setInputMouseDown = _useLock2[1];
|
|
var onInternalInputKeyDown = function onInternalInputKeyDown(event) {
|
|
var which = event.which;
|
|
if (which === KeyCode/* default.UP */.Z.UP || which === KeyCode/* default.DOWN */.Z.DOWN) {
|
|
event.preventDefault();
|
|
}
|
|
if (onInputKeyDown) {
|
|
onInputKeyDown(event);
|
|
}
|
|
if (which === KeyCode/* default.ENTER */.Z.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 ? void 0 : onSearchSubmit(event.target.value);
|
|
}
|
|
if (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.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, don't prevent default behavior
|
|
// https://github.com/ant-design/ant-design/issues/37320
|
|
if (event.target !== inputRef.current && !inputMouseDown && mode !== 'combobox') {
|
|
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
|
|
};
|
|
var selectNode = mode === 'multiple' || mode === 'tags' ? /*#__PURE__*/react.createElement(MultipleSelector, (0,esm_extends/* default */.Z)({}, props, sharedProps)) : /*#__PURE__*/react.createElement(Selector_SingleSelector, (0,esm_extends/* default */.Z)({}, props, sharedProps));
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: domRef,
|
|
className: "".concat(prefixCls, "-selector"),
|
|
onClick: onClick,
|
|
onMouseDown: onMouseDown
|
|
}, selectNode);
|
|
};
|
|
var ForwardSelector = /*#__PURE__*/react.forwardRef(Selector);
|
|
ForwardSelector.displayName = 'Selector';
|
|
/* harmony default export */ var es_Selector = (ForwardSelector);
|
|
// EXTERNAL MODULE: ./node_modules/@rc-component/trigger/es/index.js + 42 modules
|
|
var trigger_es = __webpack_require__(62709);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/SelectTrigger.js
|
|
|
|
|
|
|
|
|
|
var _excluded = ["prefixCls", "disabled", "visible", "children", "popupElement", "containerWidth", "animation", "transitionName", "dropdownStyle", "dropdownClassName", "direction", "placement", "builtinPlacements", "dropdownMatchSelectWidth", "dropdownRender", "dropdownAlign", "getPopupContainer", "empty", "getTriggerDOMNode", "onPopupVisibleChange", "onPopupMouseEnter"];
|
|
|
|
|
|
|
|
var getBuiltInPlacements = function getBuiltInPlacements(dropdownMatchSelectWidth) {
|
|
// Enable horizontal overflow auto-adjustment when a custom dropdown width is provided
|
|
var adjustX = dropdownMatchSelectWidth === true ? 0 : 1;
|
|
return {
|
|
bottomLeft: {
|
|
points: ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow: {
|
|
adjustX: adjustX,
|
|
adjustY: 1
|
|
},
|
|
htmlRegion: 'scroll'
|
|
},
|
|
bottomRight: {
|
|
points: ['tr', 'br'],
|
|
offset: [0, 4],
|
|
overflow: {
|
|
adjustX: adjustX,
|
|
adjustY: 1
|
|
},
|
|
htmlRegion: 'scroll'
|
|
},
|
|
topLeft: {
|
|
points: ['bl', 'tl'],
|
|
offset: [0, -4],
|
|
overflow: {
|
|
adjustX: adjustX,
|
|
adjustY: 1
|
|
},
|
|
htmlRegion: 'scroll'
|
|
},
|
|
topRight: {
|
|
points: ['br', 'tr'],
|
|
offset: [0, -4],
|
|
overflow: {
|
|
adjustX: adjustX,
|
|
adjustY: 1
|
|
},
|
|
htmlRegion: 'scroll'
|
|
}
|
|
};
|
|
};
|
|
var SelectTrigger = function SelectTrigger(props, ref) {
|
|
var prefixCls = props.prefixCls,
|
|
disabled = props.disabled,
|
|
visible = props.visible,
|
|
children = props.children,
|
|
popupElement = props.popupElement,
|
|
containerWidth = props.containerWidth,
|
|
animation = props.animation,
|
|
transitionName = props.transitionName,
|
|
dropdownStyle = props.dropdownStyle,
|
|
dropdownClassName = props.dropdownClassName,
|
|
_props$direction = props.direction,
|
|
direction = _props$direction === void 0 ? 'ltr' : _props$direction,
|
|
placement = props.placement,
|
|
builtinPlacements = props.builtinPlacements,
|
|
dropdownMatchSelectWidth = props.dropdownMatchSelectWidth,
|
|
dropdownRender = props.dropdownRender,
|
|
dropdownAlign = props.dropdownAlign,
|
|
getPopupContainer = props.getPopupContainer,
|
|
empty = props.empty,
|
|
getTriggerDOMNode = props.getTriggerDOMNode,
|
|
onPopupVisibleChange = props.onPopupVisibleChange,
|
|
onPopupMouseEnter = props.onPopupMouseEnter,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, _excluded);
|
|
var dropdownPrefixCls = "".concat(prefixCls, "-dropdown");
|
|
var popupNode = popupElement;
|
|
if (dropdownRender) {
|
|
popupNode = dropdownRender(popupElement);
|
|
}
|
|
var mergedBuiltinPlacements = react.useMemo(function () {
|
|
return builtinPlacements || getBuiltInPlacements(dropdownMatchSelectWidth);
|
|
}, [builtinPlacements, dropdownMatchSelectWidth]);
|
|
|
|
// ===================== Motion ======================
|
|
var mergedTransitionName = animation ? "".concat(dropdownPrefixCls, "-").concat(animation) : transitionName;
|
|
|
|
// ======================= Ref =======================
|
|
var popupRef = react.useRef(null);
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
getPopupElement: function getPopupElement() {
|
|
return popupRef.current;
|
|
}
|
|
};
|
|
});
|
|
var popupStyle = (0,objectSpread2/* default */.Z)({
|
|
minWidth: containerWidth
|
|
}, dropdownStyle);
|
|
if (typeof dropdownMatchSelectWidth === 'number') {
|
|
popupStyle.width = dropdownMatchSelectWidth;
|
|
} else if (dropdownMatchSelectWidth) {
|
|
popupStyle.width = containerWidth;
|
|
}
|
|
return /*#__PURE__*/react.createElement(trigger_es/* default */.Z, (0,esm_extends/* default */.Z)({}, restProps, {
|
|
showAction: onPopupVisibleChange ? ['click'] : [],
|
|
hideAction: onPopupVisibleChange ? ['click'] : [],
|
|
popupPlacement: placement || (direction === 'rtl' ? 'bottomRight' : 'bottomLeft'),
|
|
builtinPlacements: mergedBuiltinPlacements,
|
|
prefixCls: dropdownPrefixCls,
|
|
popupTransitionName: mergedTransitionName,
|
|
popup: /*#__PURE__*/react.createElement("div", {
|
|
ref: popupRef,
|
|
onMouseEnter: onPopupMouseEnter
|
|
}, popupNode),
|
|
popupAlign: dropdownAlign,
|
|
popupVisible: visible,
|
|
getPopupContainer: getPopupContainer,
|
|
popupClassName: classnames_default()(dropdownClassName, (0,defineProperty/* default */.Z)({}, "".concat(dropdownPrefixCls, "-empty"), empty)),
|
|
popupStyle: popupStyle,
|
|
getTriggerDOMNode: getTriggerDOMNode,
|
|
onPopupVisibleChange: onPopupVisibleChange
|
|
}), children);
|
|
};
|
|
var RefSelectTrigger = /*#__PURE__*/react.forwardRef(SelectTrigger);
|
|
RefSelectTrigger.displayName = 'SelectTrigger';
|
|
/* harmony default export */ var es_SelectTrigger = (RefSelectTrigger);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toArray.js
|
|
var esm_toArray = __webpack_require__(84506);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/utils/valueUtil.js
|
|
|
|
|
|
|
|
|
|
function getKey(data, index) {
|
|
var key = data.key;
|
|
var value;
|
|
if ('value' in data) {
|
|
value = data.value;
|
|
}
|
|
if (key !== null && key !== undefined) {
|
|
return key;
|
|
}
|
|
if (value !== undefined) {
|
|
return value;
|
|
}
|
|
return "rc-index-key-".concat(index);
|
|
}
|
|
function fillFieldNames(fieldNames, childrenAsData) {
|
|
var _ref = fieldNames || {},
|
|
label = _ref.label,
|
|
value = _ref.value,
|
|
options = _ref.options,
|
|
groupLabel = _ref.groupLabel;
|
|
var mergedLabel = label || (childrenAsData ? 'children' : 'label');
|
|
return {
|
|
label: mergedLabel,
|
|
value: value || 'value',
|
|
options: options || 'options',
|
|
groupLabel: groupLabel || mergedLabel
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Flat options into flatten list.
|
|
* We use `optionOnly` here is aim to avoid user use nested option group.
|
|
* Here is simply set `key` to the index if not provided.
|
|
*/
|
|
function flattenOptions(options) {
|
|
var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
|
fieldNames = _ref2.fieldNames,
|
|
childrenAsData = _ref2.childrenAsData;
|
|
var flattenList = [];
|
|
var _fillFieldNames = fillFieldNames(fieldNames, false),
|
|
fieldLabel = _fillFieldNames.label,
|
|
fieldValue = _fillFieldNames.value,
|
|
fieldOptions = _fillFieldNames.options,
|
|
groupLabel = _fillFieldNames.groupLabel;
|
|
function dig(list, isGroupOption) {
|
|
list.forEach(function (data) {
|
|
if (isGroupOption || !(fieldOptions in data)) {
|
|
var value = data[fieldValue];
|
|
|
|
// Option
|
|
flattenList.push({
|
|
key: getKey(data, flattenList.length),
|
|
groupOption: isGroupOption,
|
|
data: data,
|
|
label: data[fieldLabel],
|
|
value: value
|
|
});
|
|
} else {
|
|
var grpLabel = data[groupLabel];
|
|
if (grpLabel === undefined && childrenAsData) {
|
|
grpLabel = data.label;
|
|
}
|
|
|
|
// Option Group
|
|
flattenList.push({
|
|
key: getKey(data, flattenList.length),
|
|
group: true,
|
|
data: data,
|
|
label: grpLabel
|
|
});
|
|
dig(data[fieldOptions], true);
|
|
}
|
|
});
|
|
}
|
|
dig(options, false);
|
|
return flattenList;
|
|
}
|
|
|
|
/**
|
|
* Inject `props` into `option` for legacy usage
|
|
*/
|
|
function injectPropsWithOption(option) {
|
|
var newOption = (0,objectSpread2/* default */.Z)({}, option);
|
|
if (!('props' in newOption)) {
|
|
Object.defineProperty(newOption, 'props', {
|
|
get: function get() {
|
|
(0,es_warning/* default */.ZP)(false, 'Return type is option instead of Option instance. Please read value directly instead of reading from `props`.');
|
|
return newOption;
|
|
}
|
|
});
|
|
}
|
|
return newOption;
|
|
}
|
|
function getSeparatedContent(text, tokens) {
|
|
if (!tokens || !tokens.length) {
|
|
return null;
|
|
}
|
|
var match = false;
|
|
function separate(str, _ref3) {
|
|
var _ref4 = (0,esm_toArray/* default */.Z)(_ref3),
|
|
token = _ref4[0],
|
|
restTokens = _ref4.slice(1);
|
|
if (!token) {
|
|
return [str];
|
|
}
|
|
var list = str.split(token);
|
|
match = match || list.length > 1;
|
|
return list.reduce(function (prevList, unitStr) {
|
|
return [].concat((0,toConsumableArray/* default */.Z)(prevList), (0,toConsumableArray/* default */.Z)(separate(unitStr, restTokens)));
|
|
}, []).filter(function (unit) {
|
|
return unit;
|
|
});
|
|
}
|
|
var list = separate(text, tokens);
|
|
return match ? list : null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/BaseSelect.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var BaseSelect_excluded = ["id", "prefixCls", "className", "showSearch", "tagRender", "direction", "omitDomProps", "displayValues", "onDisplayValuesChange", "emptyOptions", "notFoundContent", "onClear", "mode", "disabled", "loading", "getInputElement", "getRawInputElement", "open", "defaultOpen", "onDropdownVisibleChange", "activeValue", "onActiveValueChange", "activeDescendantId", "searchValue", "autoClearSearchValue", "onSearch", "onSearchSplit", "tokenSeparators", "allowClear", "showArrow", "inputIcon", "clearIcon", "OptionList", "animation", "transitionName", "dropdownStyle", "dropdownClassName", "dropdownMatchSelectWidth", "dropdownRender", "dropdownAlign", "placement", "builtinPlacements", "getPopupContainer", "showAction", "onFocus", "onBlur", "onKeyUp", "onKeyDown", "onMouseDown"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var DEFAULT_OMIT_PROPS = ['value', 'onChange', 'removeIcon', 'placeholder', 'autoFocus', 'maxTagCount', 'maxTagTextLength', 'maxTagPlaceholder', 'choiceTransitionName', 'onInputKeyDown', 'onPopupScroll', 'tabIndex'];
|
|
function BaseSelect_isMultiple(mode) {
|
|
return mode === 'tags' || mode === 'multiple';
|
|
}
|
|
var BaseSelect = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _customizeRawInputEle, _classNames2;
|
|
var id = props.id,
|
|
prefixCls = props.prefixCls,
|
|
className = props.className,
|
|
showSearch = props.showSearch,
|
|
tagRender = props.tagRender,
|
|
direction = props.direction,
|
|
omitDomProps = props.omitDomProps,
|
|
displayValues = props.displayValues,
|
|
onDisplayValuesChange = props.onDisplayValuesChange,
|
|
emptyOptions = props.emptyOptions,
|
|
_props$notFoundConten = props.notFoundContent,
|
|
notFoundContent = _props$notFoundConten === void 0 ? 'Not Found' : _props$notFoundConten,
|
|
onClear = props.onClear,
|
|
mode = props.mode,
|
|
disabled = props.disabled,
|
|
loading = props.loading,
|
|
getInputElement = props.getInputElement,
|
|
getRawInputElement = props.getRawInputElement,
|
|
open = props.open,
|
|
defaultOpen = props.defaultOpen,
|
|
onDropdownVisibleChange = props.onDropdownVisibleChange,
|
|
activeValue = props.activeValue,
|
|
onActiveValueChange = props.onActiveValueChange,
|
|
activeDescendantId = props.activeDescendantId,
|
|
searchValue = props.searchValue,
|
|
autoClearSearchValue = props.autoClearSearchValue,
|
|
onSearch = props.onSearch,
|
|
onSearchSplit = props.onSearchSplit,
|
|
tokenSeparators = props.tokenSeparators,
|
|
allowClear = props.allowClear,
|
|
showArrow = props.showArrow,
|
|
inputIcon = props.inputIcon,
|
|
clearIcon = props.clearIcon,
|
|
OptionList = props.OptionList,
|
|
animation = props.animation,
|
|
transitionName = props.transitionName,
|
|
dropdownStyle = props.dropdownStyle,
|
|
dropdownClassName = props.dropdownClassName,
|
|
dropdownMatchSelectWidth = props.dropdownMatchSelectWidth,
|
|
dropdownRender = props.dropdownRender,
|
|
dropdownAlign = props.dropdownAlign,
|
|
placement = props.placement,
|
|
builtinPlacements = props.builtinPlacements,
|
|
getPopupContainer = props.getPopupContainer,
|
|
_props$showAction = props.showAction,
|
|
showAction = _props$showAction === void 0 ? [] : _props$showAction,
|
|
onFocus = props.onFocus,
|
|
onBlur = props.onBlur,
|
|
onKeyUp = props.onKeyUp,
|
|
onKeyDown = props.onKeyDown,
|
|
onMouseDown = props.onMouseDown,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, BaseSelect_excluded);
|
|
|
|
// ============================== MISC ==============================
|
|
var multiple = BaseSelect_isMultiple(mode);
|
|
var mergedShowSearch = (showSearch !== undefined ? showSearch : multiple) || mode === 'combobox';
|
|
var domProps = (0,objectSpread2/* default */.Z)({}, restProps);
|
|
DEFAULT_OMIT_PROPS.forEach(function (propName) {
|
|
delete domProps[propName];
|
|
});
|
|
omitDomProps === null || omitDomProps === void 0 ? void 0 : omitDomProps.forEach(function (propName) {
|
|
delete domProps[propName];
|
|
});
|
|
|
|
// ============================= Mobile =============================
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
mobile = _React$useState2[0],
|
|
setMobile = _React$useState2[1];
|
|
react.useEffect(function () {
|
|
// Only update on the client side
|
|
setMobile((0,isMobile/* default */.Z)());
|
|
}, []);
|
|
|
|
// ============================== Refs ==============================
|
|
var containerRef = react.useRef(null);
|
|
var selectorDomRef = react.useRef(null);
|
|
var triggerRef = react.useRef(null);
|
|
var selectorRef = react.useRef(null);
|
|
var listRef = react.useRef(null);
|
|
|
|
/** Used for component focused management */
|
|
var _useDelayReset = useDelayReset(),
|
|
_useDelayReset2 = (0,slicedToArray/* default */.Z)(_useDelayReset, 3),
|
|
mockFocused = _useDelayReset2[0],
|
|
setMockFocused = _useDelayReset2[1],
|
|
cancelSetMockFocused = _useDelayReset2[2];
|
|
|
|
// =========================== Imperative ===========================
|
|
react.useImperativeHandle(ref, function () {
|
|
var _selectorRef$current, _selectorRef$current2;
|
|
return {
|
|
focus: (_selectorRef$current = selectorRef.current) === null || _selectorRef$current === void 0 ? void 0 : _selectorRef$current.focus,
|
|
blur: (_selectorRef$current2 = selectorRef.current) === null || _selectorRef$current2 === void 0 ? void 0 : _selectorRef$current2.blur,
|
|
scrollTo: function scrollTo(arg) {
|
|
var _listRef$current;
|
|
return (_listRef$current = listRef.current) === null || _listRef$current === void 0 ? void 0 : _listRef$current.scrollTo(arg);
|
|
}
|
|
};
|
|
});
|
|
|
|
// ========================== Search Value ==========================
|
|
var mergedSearchValue = react.useMemo(function () {
|
|
var _displayValues$;
|
|
if (mode !== 'combobox') {
|
|
return searchValue;
|
|
}
|
|
var val = (_displayValues$ = displayValues[0]) === null || _displayValues$ === void 0 ? void 0 : _displayValues$.value;
|
|
return typeof val === 'string' || typeof val === 'number' ? String(val) : '';
|
|
}, [searchValue, mode, displayValues]);
|
|
|
|
// ========================== Custom Input ==========================
|
|
// Only works in `combobox`
|
|
var customizeInputElement = mode === 'combobox' && typeof getInputElement === 'function' && getInputElement() || null;
|
|
|
|
// Used for customize replacement for `rc-cascader`
|
|
var customizeRawInputElement = typeof getRawInputElement === 'function' && getRawInputElement();
|
|
var customizeRawInputRef = (0,es_ref/* useComposeRef */.x1)(selectorDomRef, customizeRawInputElement === null || customizeRawInputElement === void 0 ? void 0 : (_customizeRawInputEle = customizeRawInputElement.props) === null || _customizeRawInputEle === void 0 ? void 0 : _customizeRawInputEle.ref);
|
|
|
|
// ============================== Open ==============================
|
|
// SSR not support Portal which means we need delay `open` for the first time render
|
|
var _React$useState3 = react.useState(false),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
rendered = _React$useState4[0],
|
|
setRendered = _React$useState4[1];
|
|
(0,useLayoutEffect/* default */.Z)(function () {
|
|
setRendered(true);
|
|
}, []);
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(false, {
|
|
defaultValue: defaultOpen,
|
|
value: open
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
innerOpen = _useMergedState2[0],
|
|
setInnerOpen = _useMergedState2[1];
|
|
var mergedOpen = rendered ? innerOpen : false;
|
|
|
|
// Not trigger `open` in `combobox` when `notFoundContent` is empty
|
|
var emptyListContent = !notFoundContent && emptyOptions;
|
|
if (disabled || emptyListContent && mergedOpen && mode === 'combobox') {
|
|
mergedOpen = false;
|
|
}
|
|
var triggerOpen = emptyListContent ? false : mergedOpen;
|
|
var onToggleOpen = react.useCallback(function (newOpen) {
|
|
var nextOpen = newOpen !== undefined ? newOpen : !mergedOpen;
|
|
if (!disabled) {
|
|
setInnerOpen(nextOpen);
|
|
if (mergedOpen !== nextOpen) {
|
|
onDropdownVisibleChange === null || onDropdownVisibleChange === void 0 ? void 0 : onDropdownVisibleChange(nextOpen);
|
|
}
|
|
}
|
|
}, [disabled, mergedOpen, setInnerOpen, onDropdownVisibleChange]);
|
|
|
|
// ============================= Search =============================
|
|
var tokenWithEnter = react.useMemo(function () {
|
|
return (tokenSeparators || []).some(function (tokenSeparator) {
|
|
return ['\n', '\r\n'].includes(tokenSeparator);
|
|
});
|
|
}, [tokenSeparators]);
|
|
var onInternalSearch = function onInternalSearch(searchText, fromTyping, isCompositing) {
|
|
var ret = true;
|
|
var newSearchText = searchText;
|
|
onActiveValueChange === null || onActiveValueChange === void 0 ? void 0 : onActiveValueChange(null);
|
|
|
|
// Check if match the `tokenSeparators`
|
|
var patchLabels = isCompositing ? null : getSeparatedContent(searchText, tokenSeparators);
|
|
|
|
// Ignore combobox since it's not split-able
|
|
if (mode !== 'combobox' && patchLabels) {
|
|
newSearchText = '';
|
|
onSearchSplit === null || onSearchSplit === void 0 ? void 0 : onSearchSplit(patchLabels);
|
|
|
|
// Should close when paste finish
|
|
onToggleOpen(false);
|
|
|
|
// Tell Selector that break next actions
|
|
ret = false;
|
|
}
|
|
if (onSearch && mergedSearchValue !== newSearchText) {
|
|
onSearch(newSearchText, {
|
|
source: fromTyping ? 'typing' : 'effect'
|
|
});
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
// Only triggered when menu is closed & mode is tags
|
|
// If menu is open, OptionList will take charge
|
|
// If mode isn't tags, press enter is not meaningful when you can't see any option
|
|
var onInternalSearchSubmit = function onInternalSearchSubmit(searchText) {
|
|
// prevent empty tags from appearing when you click the Enter button
|
|
if (!searchText || !searchText.trim()) {
|
|
return;
|
|
}
|
|
onSearch(searchText, {
|
|
source: 'submit'
|
|
});
|
|
};
|
|
|
|
// Close will clean up single mode search text
|
|
react.useEffect(function () {
|
|
if (!mergedOpen && !multiple && mode !== 'combobox') {
|
|
onInternalSearch('', false, false);
|
|
}
|
|
}, [mergedOpen]);
|
|
|
|
// ============================ Disabled ============================
|
|
// Close dropdown & remove focus state when disabled change
|
|
react.useEffect(function () {
|
|
if (innerOpen && disabled) {
|
|
setInnerOpen(false);
|
|
}
|
|
if (disabled) {
|
|
setMockFocused(false);
|
|
}
|
|
}, [disabled]);
|
|
|
|
// ============================ Keyboard ============================
|
|
/**
|
|
* We record input value here to check if can press to clean up by backspace
|
|
* - null: Key is not down, this is reset by key up
|
|
* - true: Search text is empty when first time backspace down
|
|
* - false: Search text is not empty when first time backspace down
|
|
*/
|
|
var _useLock = useLock(),
|
|
_useLock2 = (0,slicedToArray/* default */.Z)(_useLock, 2),
|
|
getClearLock = _useLock2[0],
|
|
setClearLock = _useLock2[1];
|
|
|
|
// KeyDown
|
|
var onInternalKeyDown = function onInternalKeyDown(event) {
|
|
var clearLock = getClearLock();
|
|
var which = event.which;
|
|
if (which === KeyCode/* default.ENTER */.Z.ENTER) {
|
|
// Do not submit form when type in the input
|
|
if (mode !== 'combobox') {
|
|
event.preventDefault();
|
|
}
|
|
|
|
// We only manage open state here, close logic should handle by list component
|
|
if (!mergedOpen) {
|
|
onToggleOpen(true);
|
|
}
|
|
}
|
|
setClearLock(!!mergedSearchValue);
|
|
|
|
// Remove value by `backspace`
|
|
if (which === KeyCode/* default.BACKSPACE */.Z.BACKSPACE && !clearLock && multiple && !mergedSearchValue && displayValues.length) {
|
|
var cloneDisplayValues = (0,toConsumableArray/* default */.Z)(displayValues);
|
|
var removedDisplayValue = null;
|
|
for (var i = cloneDisplayValues.length - 1; i >= 0; i -= 1) {
|
|
var current = cloneDisplayValues[i];
|
|
if (!current.disabled) {
|
|
cloneDisplayValues.splice(i, 1);
|
|
removedDisplayValue = current;
|
|
break;
|
|
}
|
|
}
|
|
if (removedDisplayValue) {
|
|
onDisplayValuesChange(cloneDisplayValues, {
|
|
type: 'remove',
|
|
values: [removedDisplayValue]
|
|
});
|
|
}
|
|
}
|
|
for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
rest[_key - 1] = arguments[_key];
|
|
}
|
|
if (mergedOpen && listRef.current) {
|
|
var _listRef$current2;
|
|
(_listRef$current2 = listRef.current).onKeyDown.apply(_listRef$current2, [event].concat(rest));
|
|
}
|
|
onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown.apply(void 0, [event].concat(rest));
|
|
};
|
|
|
|
// KeyUp
|
|
var onInternalKeyUp = function onInternalKeyUp(event) {
|
|
for (var _len2 = arguments.length, rest = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
rest[_key2 - 1] = arguments[_key2];
|
|
}
|
|
if (mergedOpen && listRef.current) {
|
|
var _listRef$current3;
|
|
(_listRef$current3 = listRef.current).onKeyUp.apply(_listRef$current3, [event].concat(rest));
|
|
}
|
|
onKeyUp === null || onKeyUp === void 0 ? void 0 : onKeyUp.apply(void 0, [event].concat(rest));
|
|
};
|
|
|
|
// ============================ Selector ============================
|
|
var onSelectorRemove = function onSelectorRemove(val) {
|
|
var newValues = displayValues.filter(function (i) {
|
|
return i !== val;
|
|
});
|
|
onDisplayValuesChange(newValues, {
|
|
type: 'remove',
|
|
values: [val]
|
|
});
|
|
};
|
|
|
|
// ========================== Focus / Blur ==========================
|
|
/** Record real focus status */
|
|
var focusRef = react.useRef(false);
|
|
var onContainerFocus = function onContainerFocus() {
|
|
setMockFocused(true);
|
|
if (!disabled) {
|
|
if (onFocus && !focusRef.current) {
|
|
onFocus.apply(void 0, arguments);
|
|
}
|
|
|
|
// `showAction` should handle `focus` if set
|
|
if (showAction.includes('focus')) {
|
|
onToggleOpen(true);
|
|
}
|
|
}
|
|
focusRef.current = true;
|
|
};
|
|
var onContainerBlur = function onContainerBlur() {
|
|
setMockFocused(false, function () {
|
|
focusRef.current = false;
|
|
onToggleOpen(false);
|
|
});
|
|
if (disabled) {
|
|
return;
|
|
}
|
|
if (mergedSearchValue) {
|
|
// `tags` mode should move `searchValue` into values
|
|
if (mode === 'tags') {
|
|
onSearch(mergedSearchValue, {
|
|
source: 'submit'
|
|
});
|
|
} else if (mode === 'multiple') {
|
|
// `multiple` mode only clean the search value but not trigger event
|
|
onSearch('', {
|
|
source: 'blur'
|
|
});
|
|
}
|
|
}
|
|
if (onBlur) {
|
|
onBlur.apply(void 0, arguments);
|
|
}
|
|
};
|
|
|
|
// Give focus back of Select
|
|
var activeTimeoutIds = [];
|
|
react.useEffect(function () {
|
|
return function () {
|
|
activeTimeoutIds.forEach(function (timeoutId) {
|
|
return clearTimeout(timeoutId);
|
|
});
|
|
activeTimeoutIds.splice(0, activeTimeoutIds.length);
|
|
};
|
|
}, []);
|
|
var onInternalMouseDown = function onInternalMouseDown(event) {
|
|
var _triggerRef$current;
|
|
var target = event.target;
|
|
var popupElement = (_triggerRef$current = triggerRef.current) === null || _triggerRef$current === void 0 ? void 0 : _triggerRef$current.getPopupElement();
|
|
|
|
// We should give focus back to selector if clicked item is not focusable
|
|
if (popupElement && popupElement.contains(target)) {
|
|
var timeoutId = setTimeout(function () {
|
|
var index = activeTimeoutIds.indexOf(timeoutId);
|
|
if (index !== -1) {
|
|
activeTimeoutIds.splice(index, 1);
|
|
}
|
|
cancelSetMockFocused();
|
|
if (!mobile && !popupElement.contains(document.activeElement)) {
|
|
var _selectorRef$current3;
|
|
(_selectorRef$current3 = selectorRef.current) === null || _selectorRef$current3 === void 0 ? void 0 : _selectorRef$current3.focus();
|
|
}
|
|
});
|
|
activeTimeoutIds.push(timeoutId);
|
|
}
|
|
for (var _len3 = arguments.length, restArgs = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
|
restArgs[_key3 - 1] = arguments[_key3];
|
|
}
|
|
onMouseDown === null || onMouseDown === void 0 ? void 0 : onMouseDown.apply(void 0, [event].concat(restArgs));
|
|
};
|
|
|
|
// ============================ Dropdown ============================
|
|
var _React$useState5 = react.useState(null),
|
|
_React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2),
|
|
containerWidth = _React$useState6[0],
|
|
setContainerWidth = _React$useState6[1];
|
|
var _React$useState7 = react.useState({}),
|
|
_React$useState8 = (0,slicedToArray/* default */.Z)(_React$useState7, 2),
|
|
forceUpdate = _React$useState8[1];
|
|
// We need force update here since popup dom is render async
|
|
function onPopupMouseEnter() {
|
|
forceUpdate({});
|
|
}
|
|
(0,useLayoutEffect/* default */.Z)(function () {
|
|
if (triggerOpen) {
|
|
var _containerRef$current;
|
|
var newWidth = Math.ceil((_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : _containerRef$current.offsetWidth);
|
|
if (containerWidth !== newWidth && !Number.isNaN(newWidth)) {
|
|
setContainerWidth(newWidth);
|
|
}
|
|
}
|
|
}, [triggerOpen]);
|
|
|
|
// Used for raw custom input trigger
|
|
var onTriggerVisibleChange;
|
|
if (customizeRawInputElement) {
|
|
onTriggerVisibleChange = function onTriggerVisibleChange(newOpen) {
|
|
onToggleOpen(newOpen);
|
|
};
|
|
}
|
|
|
|
// Close when click on non-select element
|
|
useSelectTriggerControl(function () {
|
|
var _triggerRef$current2;
|
|
return [containerRef.current, (_triggerRef$current2 = triggerRef.current) === null || _triggerRef$current2 === void 0 ? void 0 : _triggerRef$current2.getPopupElement()];
|
|
}, triggerOpen, onToggleOpen, !!customizeRawInputElement);
|
|
|
|
// ============================ Context =============================
|
|
var baseSelectContext = react.useMemo(function () {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
notFoundContent: notFoundContent,
|
|
open: mergedOpen,
|
|
triggerOpen: triggerOpen,
|
|
id: id,
|
|
showSearch: mergedShowSearch,
|
|
multiple: multiple,
|
|
toggleOpen: onToggleOpen
|
|
});
|
|
}, [props, notFoundContent, triggerOpen, mergedOpen, id, mergedShowSearch, multiple, onToggleOpen]);
|
|
|
|
// ==================================================================
|
|
// == Render ==
|
|
// ==================================================================
|
|
|
|
// ============================= Arrow ==============================
|
|
var mergedShowArrow = showArrow !== undefined ? showArrow : loading || !multiple && mode !== 'combobox';
|
|
var arrowNode;
|
|
if (mergedShowArrow) {
|
|
arrowNode = /*#__PURE__*/react.createElement(es_TransBtn, {
|
|
className: classnames_default()("".concat(prefixCls, "-arrow"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-arrow-loading"), loading)),
|
|
customizeIcon: inputIcon,
|
|
customizeIconProps: {
|
|
loading: loading,
|
|
searchValue: mergedSearchValue,
|
|
open: mergedOpen,
|
|
focused: mockFocused,
|
|
showSearch: mergedShowSearch
|
|
}
|
|
});
|
|
}
|
|
|
|
// ============================= Clear ==============================
|
|
var clearNode;
|
|
var onClearMouseDown = function onClearMouseDown() {
|
|
var _selectorRef$current4;
|
|
onClear === null || onClear === void 0 ? void 0 : onClear();
|
|
(_selectorRef$current4 = selectorRef.current) === null || _selectorRef$current4 === void 0 ? void 0 : _selectorRef$current4.focus();
|
|
onDisplayValuesChange([], {
|
|
type: 'clear',
|
|
values: displayValues
|
|
});
|
|
onInternalSearch('', false, false);
|
|
};
|
|
if (!disabled && allowClear && (displayValues.length || mergedSearchValue) && !(mode === 'combobox' && mergedSearchValue === '')) {
|
|
clearNode = /*#__PURE__*/react.createElement(es_TransBtn, {
|
|
className: "".concat(prefixCls, "-clear"),
|
|
onMouseDown: onClearMouseDown,
|
|
customizeIcon: clearIcon
|
|
}, "\xD7");
|
|
}
|
|
|
|
// =========================== OptionList ===========================
|
|
var optionList = /*#__PURE__*/react.createElement(OptionList, {
|
|
ref: listRef
|
|
});
|
|
|
|
// ============================= Select =============================
|
|
var mergedClassName = classnames_default()(prefixCls, className, (_classNames2 = {}, (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-focused"), mockFocused), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-multiple"), multiple), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-single"), !multiple), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-allow-clear"), allowClear), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-show-arrow"), mergedShowArrow), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-disabled"), disabled), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-loading"), loading), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-open"), mergedOpen), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-customize-input"), customizeInputElement), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-show-search"), mergedShowSearch), _classNames2));
|
|
|
|
// >>> Selector
|
|
var selectorNode = /*#__PURE__*/react.createElement(es_SelectTrigger, {
|
|
ref: triggerRef,
|
|
disabled: disabled,
|
|
prefixCls: prefixCls,
|
|
visible: triggerOpen,
|
|
popupElement: optionList,
|
|
containerWidth: containerWidth,
|
|
animation: animation,
|
|
transitionName: transitionName,
|
|
dropdownStyle: dropdownStyle,
|
|
dropdownClassName: dropdownClassName,
|
|
direction: direction,
|
|
dropdownMatchSelectWidth: dropdownMatchSelectWidth,
|
|
dropdownRender: dropdownRender,
|
|
dropdownAlign: dropdownAlign,
|
|
placement: placement,
|
|
builtinPlacements: builtinPlacements,
|
|
getPopupContainer: getPopupContainer,
|
|
empty: emptyOptions,
|
|
getTriggerDOMNode: function getTriggerDOMNode() {
|
|
return selectorDomRef.current;
|
|
},
|
|
onPopupVisibleChange: onTriggerVisibleChange,
|
|
onPopupMouseEnter: onPopupMouseEnter
|
|
}, customizeRawInputElement ? /*#__PURE__*/react.cloneElement(customizeRawInputElement, {
|
|
ref: customizeRawInputRef
|
|
}) : /*#__PURE__*/react.createElement(es_Selector, (0,esm_extends/* default */.Z)({}, props, {
|
|
domRef: selectorDomRef,
|
|
prefixCls: prefixCls,
|
|
inputElement: customizeInputElement,
|
|
ref: selectorRef,
|
|
id: id,
|
|
showSearch: mergedShowSearch,
|
|
autoClearSearchValue: autoClearSearchValue,
|
|
mode: mode,
|
|
activeDescendantId: activeDescendantId,
|
|
tagRender: tagRender,
|
|
values: displayValues,
|
|
open: mergedOpen,
|
|
onToggleOpen: onToggleOpen,
|
|
activeValue: activeValue,
|
|
searchValue: mergedSearchValue,
|
|
onSearch: onInternalSearch,
|
|
onSearchSubmit: onInternalSearchSubmit,
|
|
onRemove: onSelectorRemove,
|
|
tokenWithEnter: tokenWithEnter
|
|
})));
|
|
|
|
// >>> Render
|
|
var renderNode;
|
|
|
|
// Render raw
|
|
if (customizeRawInputElement) {
|
|
renderNode = selectorNode;
|
|
} else {
|
|
renderNode = /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
className: mergedClassName
|
|
}, domProps, {
|
|
ref: containerRef,
|
|
onMouseDown: onInternalMouseDown,
|
|
onKeyDown: onInternalKeyDown,
|
|
onKeyUp: onInternalKeyUp,
|
|
onFocus: onContainerFocus,
|
|
onBlur: onContainerBlur
|
|
}), mockFocused && !mergedOpen && /*#__PURE__*/react.createElement("span", {
|
|
style: {
|
|
width: 0,
|
|
height: 0,
|
|
position: 'absolute',
|
|
overflow: 'hidden',
|
|
opacity: 0
|
|
},
|
|
"aria-live": "polite"
|
|
}, "".concat(displayValues.map(function (_ref) {
|
|
var label = _ref.label,
|
|
value = _ref.value;
|
|
return ['number', 'string'].includes((0,esm_typeof/* default */.Z)(label)) ? label : value;
|
|
}).join(', '))), selectorNode, arrowNode, clearNode);
|
|
}
|
|
return /*#__PURE__*/react.createElement(BaseSelectContext.Provider, {
|
|
value: baseSelectContext
|
|
}, renderNode);
|
|
});
|
|
|
|
// Set display name for dev
|
|
if (false) {}
|
|
/* harmony default export */ var es_BaseSelect = (BaseSelect);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useCache.js
|
|
|
|
|
|
/**
|
|
* Cache `value` related LabeledValue & options.
|
|
*/
|
|
/* harmony default export */ var useCache = (function (labeledValues, valueOptions) {
|
|
var cacheRef = react.useRef({
|
|
values: new Map(),
|
|
options: new Map()
|
|
});
|
|
var filledLabeledValues = react.useMemo(function () {
|
|
var _cacheRef$current = cacheRef.current,
|
|
prevValueCache = _cacheRef$current.values,
|
|
prevOptionCache = _cacheRef$current.options;
|
|
|
|
// Fill label by cache
|
|
var patchedValues = labeledValues.map(function (item) {
|
|
if (item.label === undefined) {
|
|
var _prevValueCache$get;
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, item), {}, {
|
|
label: (_prevValueCache$get = prevValueCache.get(item.value)) === null || _prevValueCache$get === void 0 ? void 0 : _prevValueCache$get.label
|
|
});
|
|
}
|
|
return item;
|
|
});
|
|
|
|
// Refresh cache
|
|
var valueCache = new Map();
|
|
var optionCache = new Map();
|
|
patchedValues.forEach(function (item) {
|
|
valueCache.set(item.value, item);
|
|
optionCache.set(item.value, valueOptions.get(item.value) || prevOptionCache.get(item.value));
|
|
});
|
|
cacheRef.current.values = valueCache;
|
|
cacheRef.current.options = optionCache;
|
|
return patchedValues;
|
|
}, [labeledValues, valueOptions]);
|
|
var getOption = react.useCallback(function (val) {
|
|
return valueOptions.get(val) || cacheRef.current.options.get(val);
|
|
}, [valueOptions]);
|
|
return [filledLabeledValues, getOption];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useFilterOptions.js
|
|
|
|
|
|
|
|
|
|
|
|
function includes(test, search) {
|
|
return commonUtil_toArray(test).join('').toUpperCase().includes(search);
|
|
}
|
|
/* harmony default export */ var useFilterOptions = (function (options, fieldNames, searchValue, filterOption, optionFilterProp) {
|
|
return react.useMemo(function () {
|
|
if (!searchValue || filterOption === false) {
|
|
return options;
|
|
}
|
|
var fieldOptions = fieldNames.options,
|
|
fieldLabel = fieldNames.label,
|
|
fieldValue = fieldNames.value;
|
|
var filteredOptions = [];
|
|
var customizeFilter = typeof filterOption === 'function';
|
|
var upperSearch = searchValue.toUpperCase();
|
|
var filterFunc = customizeFilter ? filterOption : function (_, option) {
|
|
// Use provided `optionFilterProp`
|
|
if (optionFilterProp) {
|
|
return includes(option[optionFilterProp], upperSearch);
|
|
}
|
|
|
|
// Auto select `label` or `value` by option type
|
|
if (option[fieldOptions]) {
|
|
// hack `fieldLabel` since `OptionGroup` children is not `label`
|
|
return includes(option[fieldLabel !== 'children' ? fieldLabel : 'label'], upperSearch);
|
|
}
|
|
return includes(option[fieldValue], upperSearch);
|
|
};
|
|
var wrapOption = customizeFilter ? function (opt) {
|
|
return injectPropsWithOption(opt);
|
|
} : function (opt) {
|
|
return opt;
|
|
};
|
|
options.forEach(function (item) {
|
|
// Group should check child options
|
|
if (item[fieldOptions]) {
|
|
// Check group first
|
|
var matchGroup = filterFunc(searchValue, wrapOption(item));
|
|
if (matchGroup) {
|
|
filteredOptions.push(item);
|
|
} else {
|
|
// Check option
|
|
var subOptions = item[fieldOptions].filter(function (subItem) {
|
|
return filterFunc(searchValue, wrapOption(subItem));
|
|
});
|
|
if (subOptions.length) {
|
|
filteredOptions.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, item), {}, (0,defineProperty/* default */.Z)({}, fieldOptions, subOptions)));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (filterFunc(searchValue, wrapOption(item))) {
|
|
filteredOptions.push(item);
|
|
}
|
|
});
|
|
return filteredOptions;
|
|
}, [options, filterOption, optionFilterProp, searchValue, fieldNames]);
|
|
});
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Dom/canUseDom.js
|
|
var canUseDom = __webpack_require__(98924);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useId.js
|
|
|
|
|
|
|
|
var uuid = 0;
|
|
|
|
/** Is client side and not jsdom */
|
|
var useId_isBrowserClient = true && (0,canUseDom/* default */.Z)();
|
|
|
|
/** Get unique id for accessibility usage */
|
|
function getUUID() {
|
|
var retId;
|
|
|
|
// Test never reach
|
|
/* istanbul ignore if */
|
|
if (useId_isBrowserClient) {
|
|
retId = uuid;
|
|
uuid += 1;
|
|
} else {
|
|
retId = 'TEST_OR_SSR';
|
|
}
|
|
return retId;
|
|
}
|
|
function useId(id) {
|
|
// Inner id for accessibility usage. Only work in client side
|
|
var _React$useState = react.useState(),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
innerId = _React$useState2[0],
|
|
setInnerId = _React$useState2[1];
|
|
react.useEffect(function () {
|
|
setInnerId("rc_select_".concat(getUUID()));
|
|
}, []);
|
|
return id || innerId;
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Children/toArray.js
|
|
var Children_toArray = __webpack_require__(50344);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/utils/legacyUtil.js
|
|
|
|
|
|
var legacyUtil_excluded = ["children", "value"],
|
|
_excluded2 = ["children"];
|
|
|
|
|
|
function convertNodeToOption(node) {
|
|
var _ref = node,
|
|
key = _ref.key,
|
|
_ref$props = _ref.props,
|
|
children = _ref$props.children,
|
|
value = _ref$props.value,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(_ref$props, legacyUtil_excluded);
|
|
return (0,objectSpread2/* default */.Z)({
|
|
key: key,
|
|
value: value !== undefined ? value : key,
|
|
children: children
|
|
}, restProps);
|
|
}
|
|
function legacyUtil_convertChildrenToData(nodes) {
|
|
var optionOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
return (0,Children_toArray/* default */.Z)(nodes).map(function (node, index) {
|
|
if (! /*#__PURE__*/react.isValidElement(node) || !node.type) {
|
|
return null;
|
|
}
|
|
var _ref2 = node,
|
|
isSelectOptGroup = _ref2.type.isSelectOptGroup,
|
|
key = _ref2.key,
|
|
_ref2$props = _ref2.props,
|
|
children = _ref2$props.children,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(_ref2$props, _excluded2);
|
|
if (optionOnly || !isSelectOptGroup) {
|
|
return convertNodeToOption(node);
|
|
}
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
key: "__RC_SELECT_GRP__".concat(key === null ? index : key, "__"),
|
|
label: key
|
|
}, restProps), {}, {
|
|
options: legacyUtil_convertChildrenToData(children)
|
|
});
|
|
}).filter(function (data) {
|
|
return data;
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useOptions.js
|
|
|
|
|
|
|
|
/**
|
|
* Parse `children` to `options` if `options` is not provided.
|
|
* Then flatten the `options`.
|
|
*/
|
|
function useOptions(options, children, fieldNames, optionFilterProp, optionLabelProp) {
|
|
return react.useMemo(function () {
|
|
var mergedOptions = options;
|
|
var childrenAsData = !options;
|
|
if (childrenAsData) {
|
|
mergedOptions = legacyUtil_convertChildrenToData(children);
|
|
}
|
|
var valueOptions = new Map();
|
|
var labelOptions = new Map();
|
|
var setLabelOptions = function setLabelOptions(labelOptionsMap, option, key) {
|
|
if (key && typeof key === 'string') {
|
|
labelOptionsMap.set(option[key], option);
|
|
}
|
|
};
|
|
function dig(optionList) {
|
|
var isChildren = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
// for loop to speed up collection speed
|
|
for (var i = 0; i < optionList.length; i += 1) {
|
|
var option = optionList[i];
|
|
if (!option[fieldNames.options] || isChildren) {
|
|
valueOptions.set(option[fieldNames.value], option);
|
|
setLabelOptions(labelOptions, option, fieldNames.label);
|
|
// https://github.com/ant-design/ant-design/issues/35304
|
|
setLabelOptions(labelOptions, option, optionFilterProp);
|
|
setLabelOptions(labelOptions, option, optionLabelProp);
|
|
} else {
|
|
dig(option[fieldNames.options], true);
|
|
}
|
|
}
|
|
}
|
|
dig(mergedOptions);
|
|
return {
|
|
options: mergedOptions,
|
|
valueOptions: valueOptions,
|
|
labelOptions: labelOptions
|
|
};
|
|
}, [options, children, fieldNames, optionFilterProp, optionLabelProp]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/hooks/useRefFunc.js
|
|
|
|
|
|
/**
|
|
* Same as `React.useCallback` but always return a memoized function
|
|
* but redirect to real function.
|
|
*/
|
|
function useRefFunc(callback) {
|
|
var funcRef = react.useRef();
|
|
funcRef.current = callback;
|
|
var cacheFn = react.useCallback(function () {
|
|
return funcRef.current.apply(funcRef, arguments);
|
|
}, []);
|
|
return cacheFn;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/OptGroup.js
|
|
/* istanbul ignore file */
|
|
|
|
/** This is a placeholder, not real render in dom */
|
|
var OptGroup = function OptGroup() {
|
|
return null;
|
|
};
|
|
OptGroup.isSelectOptGroup = true;
|
|
/* harmony default export */ var es_OptGroup = (OptGroup);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/Option.js
|
|
/* istanbul ignore file */
|
|
|
|
/** This is a placeholder, not real render in dom */
|
|
var Option = function Option() {
|
|
return null;
|
|
};
|
|
Option.isSelectOption = true;
|
|
/* harmony default export */ var es_Option = (Option);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMemo.js
|
|
var useMemo = __webpack_require__(56982);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/omit.js
|
|
var omit = __webpack_require__(98423);
|
|
// EXTERNAL MODULE: ./node_modules/rc-resize-observer/es/index.js + 4 modules
|
|
var rc_resize_observer_es = __webpack_require__(48555);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/Filler.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Fill component to provided the scroll content real height.
|
|
*/
|
|
var Filler = /*#__PURE__*/react.forwardRef(function (_ref, ref) {
|
|
var height = _ref.height,
|
|
offset = _ref.offset,
|
|
children = _ref.children,
|
|
prefixCls = _ref.prefixCls,
|
|
onInnerResize = _ref.onInnerResize,
|
|
innerProps = _ref.innerProps;
|
|
var outerStyle = {};
|
|
var innerStyle = {
|
|
display: 'flex',
|
|
flexDirection: 'column'
|
|
};
|
|
if (offset !== undefined) {
|
|
outerStyle = {
|
|
height: height,
|
|
position: 'relative',
|
|
overflow: 'hidden'
|
|
};
|
|
innerStyle = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, innerStyle), {}, {
|
|
transform: "translateY(".concat(offset, "px)"),
|
|
position: 'absolute',
|
|
left: 0,
|
|
right: 0,
|
|
top: 0
|
|
});
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
style: outerStyle
|
|
}, /*#__PURE__*/react.createElement(rc_resize_observer_es/* default */.Z, {
|
|
onResize: function onResize(_ref2) {
|
|
var offsetHeight = _ref2.offsetHeight;
|
|
if (offsetHeight && onInnerResize) {
|
|
onInnerResize();
|
|
}
|
|
}
|
|
}, /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
style: innerStyle,
|
|
className: classnames_default()((0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-holder-inner"), prefixCls)),
|
|
ref: ref
|
|
}, innerProps), children)));
|
|
});
|
|
Filler.displayName = 'Filler';
|
|
/* harmony default export */ var es_Filler = (Filler);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
|
|
var classCallCheck = __webpack_require__(15671);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
var createClass = __webpack_require__(43144);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
|
|
var inherits = __webpack_require__(60136);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js + 1 modules
|
|
var createSuper = __webpack_require__(51630);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/raf.js
|
|
var raf = __webpack_require__(75164);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/ScrollBar.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var MIN_SIZE = 20;
|
|
function getPageY(e) {
|
|
return 'touches' in e ? e.touches[0].pageY : e.pageY;
|
|
}
|
|
var ScrollBar = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(ScrollBar, _React$Component);
|
|
var _super = (0,createSuper/* default */.Z)(ScrollBar);
|
|
function ScrollBar() {
|
|
var _this;
|
|
(0,classCallCheck/* default */.Z)(this, ScrollBar);
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
_this = _super.call.apply(_super, [this].concat(args));
|
|
_this.moveRaf = null;
|
|
_this.scrollbarRef = /*#__PURE__*/react.createRef();
|
|
_this.thumbRef = /*#__PURE__*/react.createRef();
|
|
_this.visibleTimeout = null;
|
|
_this.state = {
|
|
dragging: false,
|
|
pageY: null,
|
|
startTop: null,
|
|
visible: false
|
|
};
|
|
_this.delayHidden = function () {
|
|
clearTimeout(_this.visibleTimeout);
|
|
_this.setState({
|
|
visible: true
|
|
});
|
|
_this.visibleTimeout = setTimeout(function () {
|
|
_this.setState({
|
|
visible: false
|
|
});
|
|
}, 2000);
|
|
};
|
|
_this.onScrollbarTouchStart = function (e) {
|
|
e.preventDefault();
|
|
};
|
|
_this.onContainerMouseDown = function (e) {
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
};
|
|
// ======================= Clean =======================
|
|
_this.patchEvents = function () {
|
|
window.addEventListener('mousemove', _this.onMouseMove);
|
|
window.addEventListener('mouseup', _this.onMouseUp);
|
|
_this.thumbRef.current.addEventListener('touchmove', _this.onMouseMove);
|
|
_this.thumbRef.current.addEventListener('touchend', _this.onMouseUp);
|
|
};
|
|
_this.removeEvents = function () {
|
|
window.removeEventListener('mousemove', _this.onMouseMove);
|
|
window.removeEventListener('mouseup', _this.onMouseUp);
|
|
if (_this.thumbRef.current) {
|
|
_this.thumbRef.current.removeEventListener('touchmove', _this.onMouseMove);
|
|
_this.thumbRef.current.removeEventListener('touchend', _this.onMouseUp);
|
|
}
|
|
raf/* default.cancel */.Z.cancel(_this.moveRaf);
|
|
};
|
|
// ======================= Thumb =======================
|
|
_this.onMouseDown = function (e) {
|
|
var onStartMove = _this.props.onStartMove;
|
|
_this.setState({
|
|
dragging: true,
|
|
pageY: getPageY(e),
|
|
startTop: _this.getTop()
|
|
});
|
|
onStartMove();
|
|
_this.patchEvents();
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
};
|
|
_this.onMouseMove = function (e) {
|
|
var _this$state = _this.state,
|
|
dragging = _this$state.dragging,
|
|
pageY = _this$state.pageY,
|
|
startTop = _this$state.startTop;
|
|
var onScroll = _this.props.onScroll;
|
|
raf/* default.cancel */.Z.cancel(_this.moveRaf);
|
|
if (dragging) {
|
|
var offsetY = getPageY(e) - pageY;
|
|
var newTop = startTop + offsetY;
|
|
var enableScrollRange = _this.getEnableScrollRange();
|
|
var enableHeightRange = _this.getEnableHeightRange();
|
|
var ptg = enableHeightRange ? newTop / enableHeightRange : 0;
|
|
var newScrollTop = Math.ceil(ptg * enableScrollRange);
|
|
_this.moveRaf = (0,raf/* default */.Z)(function () {
|
|
onScroll(newScrollTop);
|
|
});
|
|
}
|
|
};
|
|
_this.onMouseUp = function () {
|
|
var onStopMove = _this.props.onStopMove;
|
|
_this.setState({
|
|
dragging: false
|
|
});
|
|
onStopMove();
|
|
_this.removeEvents();
|
|
};
|
|
// ===================== Calculate =====================
|
|
_this.getSpinHeight = function () {
|
|
var _this$props = _this.props,
|
|
height = _this$props.height,
|
|
count = _this$props.count;
|
|
var baseHeight = height / count * 10;
|
|
baseHeight = Math.max(baseHeight, MIN_SIZE);
|
|
baseHeight = Math.min(baseHeight, height / 2);
|
|
return Math.floor(baseHeight);
|
|
};
|
|
_this.getEnableScrollRange = function () {
|
|
var _this$props2 = _this.props,
|
|
scrollHeight = _this$props2.scrollHeight,
|
|
height = _this$props2.height;
|
|
return scrollHeight - height || 0;
|
|
};
|
|
_this.getEnableHeightRange = function () {
|
|
var height = _this.props.height;
|
|
var spinHeight = _this.getSpinHeight();
|
|
return height - spinHeight || 0;
|
|
};
|
|
_this.getTop = function () {
|
|
var scrollTop = _this.props.scrollTop;
|
|
var enableScrollRange = _this.getEnableScrollRange();
|
|
var enableHeightRange = _this.getEnableHeightRange();
|
|
if (scrollTop === 0 || enableScrollRange === 0) {
|
|
return 0;
|
|
}
|
|
var ptg = scrollTop / enableScrollRange;
|
|
return ptg * enableHeightRange;
|
|
};
|
|
// Not show scrollbar when height is large than scrollHeight
|
|
_this.showScroll = function () {
|
|
var _this$props3 = _this.props,
|
|
height = _this$props3.height,
|
|
scrollHeight = _this$props3.scrollHeight;
|
|
return scrollHeight > height;
|
|
};
|
|
return _this;
|
|
}
|
|
(0,createClass/* default */.Z)(ScrollBar, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
this.scrollbarRef.current.addEventListener('touchstart', this.onScrollbarTouchStart);
|
|
this.thumbRef.current.addEventListener('touchstart', this.onMouseDown);
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(prevProps) {
|
|
if (prevProps.scrollTop !== this.props.scrollTop) {
|
|
this.delayHidden();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
var _this$scrollbarRef$cu, _this$thumbRef$curren;
|
|
this.removeEvents();
|
|
(_this$scrollbarRef$cu = this.scrollbarRef.current) === null || _this$scrollbarRef$cu === void 0 ? void 0 : _this$scrollbarRef$cu.removeEventListener('touchstart', this.onScrollbarTouchStart);
|
|
(_this$thumbRef$curren = this.thumbRef.current) === null || _this$thumbRef$curren === void 0 ? void 0 : _this$thumbRef$curren.removeEventListener('touchstart', this.onMouseDown);
|
|
clearTimeout(this.visibleTimeout);
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value:
|
|
// ====================== Render =======================
|
|
function render() {
|
|
var _this$state2 = this.state,
|
|
dragging = _this$state2.dragging,
|
|
visible = _this$state2.visible;
|
|
var _this$props4 = this.props,
|
|
prefixCls = _this$props4.prefixCls,
|
|
direction = _this$props4.direction;
|
|
var spinHeight = this.getSpinHeight();
|
|
var top = this.getTop();
|
|
var canScroll = this.showScroll();
|
|
var mergedVisible = canScroll && visible;
|
|
var scrollBarDirection = direction === 'rtl' ? {
|
|
left: 0
|
|
} : {
|
|
right: 0
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: this.scrollbarRef,
|
|
className: classnames_default()("".concat(prefixCls, "-scrollbar"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-scrollbar-show"), canScroll)),
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
width: 8,
|
|
top: 0,
|
|
bottom: 0
|
|
}, scrollBarDirection), {}, {
|
|
position: 'absolute',
|
|
display: mergedVisible ? null : 'none'
|
|
}),
|
|
onMouseDown: this.onContainerMouseDown,
|
|
onMouseMove: this.delayHidden
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
ref: this.thumbRef,
|
|
className: classnames_default()("".concat(prefixCls, "-scrollbar-thumb"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-scrollbar-thumb-moving"), dragging)),
|
|
style: {
|
|
width: '100%',
|
|
height: spinHeight,
|
|
top: top,
|
|
left: 0,
|
|
position: 'absolute',
|
|
background: 'rgba(0, 0, 0, 0.5)',
|
|
borderRadius: 99,
|
|
cursor: 'pointer',
|
|
userSelect: 'none'
|
|
},
|
|
onMouseDown: this.onMouseDown
|
|
}));
|
|
}
|
|
}]);
|
|
return ScrollBar;
|
|
}(react.Component);
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/Item.js
|
|
|
|
function Item(_ref) {
|
|
var children = _ref.children,
|
|
setRef = _ref.setRef;
|
|
var refFunc = react.useCallback(function (node) {
|
|
setRef(node);
|
|
}, []);
|
|
return /*#__PURE__*/react.cloneElement(children, {
|
|
ref: refFunc
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useChildren.js
|
|
|
|
|
|
function useChildren(list, startIndex, endIndex, setNodeRef, renderFunc, _ref) {
|
|
var getKey = _ref.getKey;
|
|
return list.slice(startIndex, endIndex + 1).map(function (item, index) {
|
|
var eleIndex = startIndex + index;
|
|
var node = renderFunc(item, eleIndex, {
|
|
// style: status === 'MEASURE_START' ? { visibility: 'hidden' } : {},
|
|
});
|
|
var key = getKey(item);
|
|
return /*#__PURE__*/react.createElement(Item, {
|
|
key: key,
|
|
setRef: function setRef(ele) {
|
|
return setNodeRef(item, ele);
|
|
}
|
|
}, node);
|
|
});
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Dom/findDOMNode.js
|
|
var findDOMNode = __webpack_require__(34203);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/utils/CacheMap.js
|
|
|
|
|
|
// Firefox has low performance of map.
|
|
var CacheMap = /*#__PURE__*/function () {
|
|
function CacheMap() {
|
|
(0,classCallCheck/* default */.Z)(this, CacheMap);
|
|
this.maps = void 0;
|
|
this.maps = Object.create(null);
|
|
}
|
|
(0,createClass/* default */.Z)(CacheMap, [{
|
|
key: "set",
|
|
value: function set(key, value) {
|
|
this.maps[key] = value;
|
|
}
|
|
}, {
|
|
key: "get",
|
|
value: function get(key) {
|
|
return this.maps[key];
|
|
}
|
|
}]);
|
|
return CacheMap;
|
|
}();
|
|
/* harmony default export */ var utils_CacheMap = (CacheMap);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useHeights.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useHeights(getKey, onItemAdd, onItemRemove) {
|
|
var _React$useState = react.useState(0),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
updatedMark = _React$useState2[0],
|
|
setUpdatedMark = _React$useState2[1];
|
|
var instanceRef = (0,react.useRef)(new Map());
|
|
var heightsRef = (0,react.useRef)(new utils_CacheMap());
|
|
var collectRafRef = (0,react.useRef)();
|
|
function cancelRaf() {
|
|
raf/* default.cancel */.Z.cancel(collectRafRef.current);
|
|
}
|
|
function collectHeight() {
|
|
cancelRaf();
|
|
collectRafRef.current = (0,raf/* default */.Z)(function () {
|
|
instanceRef.current.forEach(function (element, key) {
|
|
if (element && element.offsetParent) {
|
|
var htmlElement = (0,findDOMNode/* default */.Z)(element);
|
|
var offsetHeight = htmlElement.offsetHeight;
|
|
if (heightsRef.current.get(key) !== offsetHeight) {
|
|
heightsRef.current.set(key, htmlElement.offsetHeight);
|
|
}
|
|
}
|
|
});
|
|
// Always trigger update mark to tell parent that should re-calculate heights when resized
|
|
setUpdatedMark(function (c) {
|
|
return c + 1;
|
|
});
|
|
});
|
|
}
|
|
function setInstanceRef(item, instance) {
|
|
var key = getKey(item);
|
|
var origin = instanceRef.current.get(key);
|
|
if (instance) {
|
|
instanceRef.current.set(key, instance);
|
|
collectHeight();
|
|
} else {
|
|
instanceRef.current.delete(key);
|
|
}
|
|
// Instance changed
|
|
if (!origin !== !instance) {
|
|
if (instance) {
|
|
onItemAdd === null || onItemAdd === void 0 ? void 0 : onItemAdd(item);
|
|
} else {
|
|
onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove(item);
|
|
}
|
|
}
|
|
}
|
|
(0,react.useEffect)(function () {
|
|
return cancelRaf;
|
|
}, []);
|
|
return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useScrollTo.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHeight, syncScrollTop, triggerFlash) {
|
|
var scrollRef = react.useRef();
|
|
return function (arg) {
|
|
// When not argument provided, we think dev may want to show the scrollbar
|
|
if (arg === null || arg === undefined) {
|
|
triggerFlash();
|
|
return;
|
|
}
|
|
// Normal scroll logic
|
|
raf/* default.cancel */.Z.cancel(scrollRef.current);
|
|
if (typeof arg === 'number') {
|
|
syncScrollTop(arg);
|
|
} else if (arg && (0,esm_typeof/* default */.Z)(arg) === 'object') {
|
|
var index;
|
|
var align = arg.align;
|
|
if ('index' in arg) {
|
|
index = arg.index;
|
|
} else {
|
|
index = data.findIndex(function (item) {
|
|
return getKey(item) === arg.key;
|
|
});
|
|
}
|
|
var _arg$offset = arg.offset,
|
|
offset = _arg$offset === void 0 ? 0 : _arg$offset;
|
|
// We will retry 3 times in case dynamic height shaking
|
|
var syncScroll = function syncScroll(times, targetAlign) {
|
|
if (times < 0 || !containerRef.current) return;
|
|
var height = containerRef.current.clientHeight;
|
|
var needCollectHeight = false;
|
|
var newTargetAlign = targetAlign;
|
|
// Go to next frame if height not exist
|
|
if (height) {
|
|
var mergedAlign = targetAlign || align;
|
|
// Get top & bottom
|
|
var stackTop = 0;
|
|
var itemTop = 0;
|
|
var itemBottom = 0;
|
|
var maxLen = Math.min(data.length, index);
|
|
for (var i = 0; i <= maxLen; i += 1) {
|
|
var key = getKey(data[i]);
|
|
itemTop = stackTop;
|
|
var cacheHeight = heights.get(key);
|
|
itemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
|
|
stackTop = itemBottom;
|
|
if (i === index && cacheHeight === undefined) {
|
|
needCollectHeight = true;
|
|
}
|
|
}
|
|
// Scroll to
|
|
var targetTop = null;
|
|
switch (mergedAlign) {
|
|
case 'top':
|
|
targetTop = itemTop - offset;
|
|
break;
|
|
case 'bottom':
|
|
targetTop = itemBottom - height + offset;
|
|
break;
|
|
default:
|
|
{
|
|
var scrollTop = containerRef.current.scrollTop;
|
|
var scrollBottom = scrollTop + height;
|
|
if (itemTop < scrollTop) {
|
|
newTargetAlign = 'top';
|
|
} else if (itemBottom > scrollBottom) {
|
|
newTargetAlign = 'bottom';
|
|
}
|
|
}
|
|
}
|
|
if (targetTop !== null && targetTop !== containerRef.current.scrollTop) {
|
|
syncScrollTop(targetTop);
|
|
}
|
|
}
|
|
// We will retry since element may not sync height as it described
|
|
scrollRef.current = (0,raf/* default */.Z)(function () {
|
|
if (needCollectHeight) {
|
|
collectHeight();
|
|
}
|
|
syncScroll(times - 1, newTargetAlign);
|
|
}, 2); // Delay 2 to wait for List collect heights
|
|
};
|
|
|
|
syncScroll(3);
|
|
}
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/utils/algorithmUtil.js
|
|
/**
|
|
* Get index with specific start index one by one. e.g.
|
|
* min: 3, max: 9, start: 6
|
|
*
|
|
* Return index is:
|
|
* [0]: 6
|
|
* [1]: 7
|
|
* [2]: 5
|
|
* [3]: 8
|
|
* [4]: 4
|
|
* [5]: 9
|
|
* [6]: 3
|
|
*/
|
|
function getIndexByStartLoc(min, max, start, index) {
|
|
var beforeCount = start - min;
|
|
var afterCount = max - start;
|
|
var balanceCount = Math.min(beforeCount, afterCount) * 2;
|
|
// Balance
|
|
if (index <= balanceCount) {
|
|
var stepIndex = Math.floor(index / 2);
|
|
if (index % 2) {
|
|
return start + stepIndex + 1;
|
|
}
|
|
return start - stepIndex;
|
|
}
|
|
// One is out of range
|
|
if (beforeCount > afterCount) {
|
|
return start - (index - afterCount);
|
|
}
|
|
return start + (index - beforeCount);
|
|
}
|
|
/**
|
|
* We assume that 2 list has only 1 item diff and others keeping the order.
|
|
* So we can use dichotomy algorithm to find changed one.
|
|
*/
|
|
function findListDiffIndex(originList, targetList, getKey) {
|
|
var originLen = originList.length;
|
|
var targetLen = targetList.length;
|
|
var shortList;
|
|
var longList;
|
|
if (originLen === 0 && targetLen === 0) {
|
|
return null;
|
|
}
|
|
if (originLen < targetLen) {
|
|
shortList = originList;
|
|
longList = targetList;
|
|
} else {
|
|
shortList = targetList;
|
|
longList = originList;
|
|
}
|
|
var notExistKey = {
|
|
__EMPTY_ITEM__: true
|
|
};
|
|
function getItemKey(item) {
|
|
if (item !== undefined) {
|
|
return getKey(item);
|
|
}
|
|
return notExistKey;
|
|
}
|
|
// Loop to find diff one
|
|
var diffIndex = null;
|
|
var multiple = Math.abs(originLen - targetLen) !== 1;
|
|
for (var i = 0; i < longList.length; i += 1) {
|
|
var shortKey = getItemKey(shortList[i]);
|
|
var longKey = getItemKey(longList[i]);
|
|
if (shortKey !== longKey) {
|
|
diffIndex = i;
|
|
multiple = multiple || shortKey !== getItemKey(longList[i + 1]);
|
|
break;
|
|
}
|
|
}
|
|
return diffIndex === null ? null : {
|
|
index: diffIndex,
|
|
multiple: multiple
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useDiffItem.js
|
|
|
|
|
|
|
|
function useDiffItem(data, getKey, onDiff) {
|
|
var _React$useState = react.useState(data),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
prevData = _React$useState2[0],
|
|
setPrevData = _React$useState2[1];
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
diffItem = _React$useState4[0],
|
|
setDiffItem = _React$useState4[1];
|
|
react.useEffect(function () {
|
|
var diff = findListDiffIndex(prevData || [], data || [], getKey);
|
|
if ((diff === null || diff === void 0 ? void 0 : diff.index) !== undefined) {
|
|
onDiff === null || onDiff === void 0 ? void 0 : onDiff(diff.index);
|
|
setDiffItem(data[diff.index]);
|
|
}
|
|
setPrevData(data);
|
|
}, [data]);
|
|
return [diffItem];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/utils/isFirefox.js
|
|
|
|
var isFF = (typeof navigator === "undefined" ? "undefined" : (0,esm_typeof/* default */.Z)(navigator)) === 'object' && /Firefox/i.test(navigator.userAgent);
|
|
/* harmony default export */ var isFirefox = (isFF);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useOriginScroll.js
|
|
|
|
/* harmony default export */ var useOriginScroll = (function (isScrollAtTop, isScrollAtBottom) {
|
|
// Do lock for a wheel when scrolling
|
|
var lockRef = (0,react.useRef)(false);
|
|
var lockTimeoutRef = (0,react.useRef)(null);
|
|
function lockScroll() {
|
|
clearTimeout(lockTimeoutRef.current);
|
|
lockRef.current = true;
|
|
lockTimeoutRef.current = setTimeout(function () {
|
|
lockRef.current = false;
|
|
}, 50);
|
|
}
|
|
// Pass to ref since global add is in closure
|
|
var scrollPingRef = (0,react.useRef)({
|
|
top: isScrollAtTop,
|
|
bottom: isScrollAtBottom
|
|
});
|
|
scrollPingRef.current.top = isScrollAtTop;
|
|
scrollPingRef.current.bottom = isScrollAtBottom;
|
|
return function (deltaY) {
|
|
var smoothOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
var originScroll =
|
|
// Pass origin wheel when on the top
|
|
deltaY < 0 && scrollPingRef.current.top ||
|
|
// Pass origin wheel when on the bottom
|
|
deltaY > 0 && scrollPingRef.current.bottom;
|
|
if (smoothOffset && originScroll) {
|
|
// No need lock anymore when it's smooth offset from touchMove interval
|
|
clearTimeout(lockTimeoutRef.current);
|
|
lockRef.current = false;
|
|
} else if (!originScroll || lockRef.current) {
|
|
lockScroll();
|
|
}
|
|
return !lockRef.current && originScroll;
|
|
};
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useFrameWheel.js
|
|
|
|
|
|
|
|
|
|
function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, onWheelDelta) {
|
|
var offsetRef = (0,react.useRef)(0);
|
|
var nextFrameRef = (0,react.useRef)(null);
|
|
// Firefox patch
|
|
var wheelValueRef = (0,react.useRef)(null);
|
|
var isMouseScrollRef = (0,react.useRef)(false);
|
|
// Scroll status sync
|
|
var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
|
|
function onWheel(event) {
|
|
if (!inVirtual) return;
|
|
raf/* default.cancel */.Z.cancel(nextFrameRef.current);
|
|
var deltaY = event.deltaY;
|
|
offsetRef.current += deltaY;
|
|
wheelValueRef.current = deltaY;
|
|
// Do nothing when scroll at the edge, Skip check when is in scroll
|
|
if (originScroll(deltaY)) return;
|
|
// Proxy of scroll events
|
|
if (!isFirefox) {
|
|
event.preventDefault();
|
|
}
|
|
nextFrameRef.current = (0,raf/* default */.Z)(function () {
|
|
// Patch a multiple for Firefox to fix wheel number too small
|
|
// ref: https://github.com/ant-design/ant-design/issues/26372#issuecomment-679460266
|
|
var patchMultiple = isMouseScrollRef.current ? 10 : 1;
|
|
onWheelDelta(offsetRef.current * patchMultiple);
|
|
offsetRef.current = 0;
|
|
});
|
|
}
|
|
// A patch for firefox
|
|
function onFireFoxScroll(event) {
|
|
if (!inVirtual) return;
|
|
isMouseScrollRef.current = event.detail === wheelValueRef.current;
|
|
}
|
|
return [onWheel, onFireFoxScroll];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/hooks/useMobileTouchMove.js
|
|
|
|
|
|
var SMOOTH_PTG = 14 / 15;
|
|
function useMobileTouchMove(inVirtual, listRef, callback) {
|
|
var touchedRef = (0,react.useRef)(false);
|
|
var touchYRef = (0,react.useRef)(0);
|
|
var elementRef = (0,react.useRef)(null);
|
|
// Smooth scroll
|
|
var intervalRef = (0,react.useRef)(null);
|
|
/* eslint-disable prefer-const */
|
|
var cleanUpEvents;
|
|
var onTouchMove = function onTouchMove(e) {
|
|
if (touchedRef.current) {
|
|
var currentY = Math.ceil(e.touches[0].pageY);
|
|
var offsetY = touchYRef.current - currentY;
|
|
touchYRef.current = currentY;
|
|
if (callback(offsetY)) {
|
|
e.preventDefault();
|
|
}
|
|
// Smooth interval
|
|
clearInterval(intervalRef.current);
|
|
intervalRef.current = setInterval(function () {
|
|
offsetY *= SMOOTH_PTG;
|
|
if (!callback(offsetY, true) || Math.abs(offsetY) <= 0.1) {
|
|
clearInterval(intervalRef.current);
|
|
}
|
|
}, 16);
|
|
}
|
|
};
|
|
var onTouchEnd = function onTouchEnd() {
|
|
touchedRef.current = false;
|
|
cleanUpEvents();
|
|
};
|
|
var onTouchStart = function onTouchStart(e) {
|
|
cleanUpEvents();
|
|
if (e.touches.length === 1 && !touchedRef.current) {
|
|
touchedRef.current = true;
|
|
touchYRef.current = Math.ceil(e.touches[0].pageY);
|
|
elementRef.current = e.target;
|
|
elementRef.current.addEventListener('touchmove', onTouchMove);
|
|
elementRef.current.addEventListener('touchend', onTouchEnd);
|
|
}
|
|
};
|
|
cleanUpEvents = function cleanUpEvents() {
|
|
if (elementRef.current) {
|
|
elementRef.current.removeEventListener('touchmove', onTouchMove);
|
|
elementRef.current.removeEventListener('touchend', onTouchEnd);
|
|
}
|
|
};
|
|
(0,useLayoutEffect/* default */.Z)(function () {
|
|
if (inVirtual) {
|
|
listRef.current.addEventListener('touchstart', onTouchStart);
|
|
}
|
|
return function () {
|
|
var _listRef$current;
|
|
(_listRef$current = listRef.current) === null || _listRef$current === void 0 ? void 0 : _listRef$current.removeEventListener('touchstart', onTouchStart);
|
|
cleanUpEvents();
|
|
clearInterval(intervalRef.current);
|
|
};
|
|
}, [inVirtual]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/List.js
|
|
|
|
|
|
|
|
|
|
|
|
var List_excluded = ["prefixCls", "className", "height", "itemHeight", "fullHeight", "style", "data", "children", "itemKey", "virtual", "direction", "component", "onScroll", "onVisibleChange", "innerProps"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var EMPTY_DATA = [];
|
|
var ScrollStyle = {
|
|
overflowY: 'auto',
|
|
overflowAnchor: 'none'
|
|
};
|
|
function RawList(props, ref) {
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-virtual-list' : _props$prefixCls,
|
|
className = props.className,
|
|
height = props.height,
|
|
itemHeight = props.itemHeight,
|
|
_props$fullHeight = props.fullHeight,
|
|
fullHeight = _props$fullHeight === void 0 ? true : _props$fullHeight,
|
|
style = props.style,
|
|
data = props.data,
|
|
children = props.children,
|
|
itemKey = props.itemKey,
|
|
virtual = props.virtual,
|
|
direction = props.direction,
|
|
_props$component = props.component,
|
|
Component = _props$component === void 0 ? 'div' : _props$component,
|
|
onScroll = props.onScroll,
|
|
onVisibleChange = props.onVisibleChange,
|
|
innerProps = props.innerProps,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, List_excluded);
|
|
// ================================= MISC =================================
|
|
var useVirtual = !!(virtual !== false && height && itemHeight);
|
|
var inVirtual = useVirtual && data && itemHeight * data.length > height;
|
|
var _useState = (0,react.useState)(0),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
scrollTop = _useState2[0],
|
|
setScrollTop = _useState2[1];
|
|
var _useState3 = (0,react.useState)(false),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
scrollMoving = _useState4[0],
|
|
setScrollMoving = _useState4[1];
|
|
var mergedClassName = classnames_default()(prefixCls, (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'), className);
|
|
var mergedData = data || EMPTY_DATA;
|
|
var componentRef = (0,react.useRef)();
|
|
var fillerInnerRef = (0,react.useRef)();
|
|
var scrollBarRef = (0,react.useRef)(); // Hack on scrollbar to enable flash call
|
|
// =============================== Item Key ===============================
|
|
var getKey = react.useCallback(function (item) {
|
|
if (typeof itemKey === 'function') {
|
|
return itemKey(item);
|
|
}
|
|
return item === null || item === void 0 ? void 0 : item[itemKey];
|
|
}, [itemKey]);
|
|
var sharedConfig = {
|
|
getKey: getKey
|
|
};
|
|
// ================================ Scroll ================================
|
|
function syncScrollTop(newTop) {
|
|
setScrollTop(function (origin) {
|
|
var value;
|
|
if (typeof newTop === 'function') {
|
|
value = newTop(origin);
|
|
} else {
|
|
value = newTop;
|
|
}
|
|
var alignedTop = keepInRange(value);
|
|
componentRef.current.scrollTop = alignedTop;
|
|
return alignedTop;
|
|
});
|
|
}
|
|
// ================================ Legacy ================================
|
|
// Put ref here since the range is generate by follow
|
|
var rangeRef = (0,react.useRef)({
|
|
start: 0,
|
|
end: mergedData.length
|
|
});
|
|
var diffItemRef = (0,react.useRef)();
|
|
var _useDiffItem = useDiffItem(mergedData, getKey),
|
|
_useDiffItem2 = (0,slicedToArray/* default */.Z)(_useDiffItem, 1),
|
|
diffItem = _useDiffItem2[0];
|
|
diffItemRef.current = diffItem;
|
|
// ================================ Height ================================
|
|
var _useHeights = useHeights(getKey, null, null),
|
|
_useHeights2 = (0,slicedToArray/* default */.Z)(_useHeights, 4),
|
|
setInstanceRef = _useHeights2[0],
|
|
collectHeight = _useHeights2[1],
|
|
heights = _useHeights2[2],
|
|
heightUpdatedMark = _useHeights2[3];
|
|
// ========================== Visible Calculation =========================
|
|
var _React$useMemo = react.useMemo(function () {
|
|
if (!useVirtual) {
|
|
return {
|
|
scrollHeight: undefined,
|
|
start: 0,
|
|
end: mergedData.length - 1,
|
|
offset: undefined
|
|
};
|
|
}
|
|
// Always use virtual scroll bar in avoid shaking
|
|
if (!inVirtual) {
|
|
var _fillerInnerRef$curre;
|
|
return {
|
|
scrollHeight: ((_fillerInnerRef$curre = fillerInnerRef.current) === null || _fillerInnerRef$curre === void 0 ? void 0 : _fillerInnerRef$curre.offsetHeight) || 0,
|
|
start: 0,
|
|
end: mergedData.length - 1,
|
|
offset: undefined
|
|
};
|
|
}
|
|
var itemTop = 0;
|
|
var startIndex;
|
|
var startOffset;
|
|
var endIndex;
|
|
var dataLen = mergedData.length;
|
|
for (var i = 0; i < dataLen; i += 1) {
|
|
var item = mergedData[i];
|
|
var key = getKey(item);
|
|
var cacheHeight = heights.get(key);
|
|
var currentItemBottom = itemTop + (cacheHeight === undefined ? itemHeight : cacheHeight);
|
|
// Check item top in the range
|
|
if (currentItemBottom >= scrollTop && startIndex === undefined) {
|
|
startIndex = i;
|
|
startOffset = itemTop;
|
|
}
|
|
// Check item bottom in the range. We will render additional one item for motion usage
|
|
if (currentItemBottom > scrollTop + height && endIndex === undefined) {
|
|
endIndex = i;
|
|
}
|
|
itemTop = currentItemBottom;
|
|
}
|
|
// When scrollTop at the end but data cut to small count will reach this
|
|
if (startIndex === undefined) {
|
|
startIndex = 0;
|
|
startOffset = 0;
|
|
endIndex = Math.ceil(height / itemHeight);
|
|
}
|
|
if (endIndex === undefined) {
|
|
endIndex = mergedData.length - 1;
|
|
}
|
|
// Give cache to improve scroll experience
|
|
endIndex = Math.min(endIndex + 1, mergedData.length);
|
|
return {
|
|
scrollHeight: itemTop,
|
|
start: startIndex,
|
|
end: endIndex,
|
|
offset: startOffset
|
|
};
|
|
}, [inVirtual, useVirtual, scrollTop, mergedData, heightUpdatedMark, height]),
|
|
scrollHeight = _React$useMemo.scrollHeight,
|
|
start = _React$useMemo.start,
|
|
end = _React$useMemo.end,
|
|
offset = _React$useMemo.offset;
|
|
rangeRef.current.start = start;
|
|
rangeRef.current.end = end;
|
|
// =============================== In Range ===============================
|
|
var maxScrollHeight = scrollHeight - height;
|
|
var maxScrollHeightRef = (0,react.useRef)(maxScrollHeight);
|
|
maxScrollHeightRef.current = maxScrollHeight;
|
|
function keepInRange(newScrollTop) {
|
|
var newTop = newScrollTop;
|
|
if (!Number.isNaN(maxScrollHeightRef.current)) {
|
|
newTop = Math.min(newTop, maxScrollHeightRef.current);
|
|
}
|
|
newTop = Math.max(newTop, 0);
|
|
return newTop;
|
|
}
|
|
var isScrollAtTop = scrollTop <= 0;
|
|
var isScrollAtBottom = scrollTop >= maxScrollHeight;
|
|
var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom);
|
|
// ================================ Scroll ================================
|
|
function onScrollBar(newScrollTop) {
|
|
var newTop = newScrollTop;
|
|
syncScrollTop(newTop);
|
|
}
|
|
// When data size reduce. It may trigger native scroll event back to fit scroll position
|
|
function onFallbackScroll(e) {
|
|
var newScrollTop = e.currentTarget.scrollTop;
|
|
if (newScrollTop !== scrollTop) {
|
|
syncScrollTop(newScrollTop);
|
|
}
|
|
// Trigger origin onScroll
|
|
onScroll === null || onScroll === void 0 ? void 0 : onScroll(e);
|
|
}
|
|
// Since this added in global,should use ref to keep update
|
|
var _useFrameWheel = useFrameWheel(useVirtual, isScrollAtTop, isScrollAtBottom, function (offsetY) {
|
|
syncScrollTop(function (top) {
|
|
var newTop = top + offsetY;
|
|
return newTop;
|
|
});
|
|
}),
|
|
_useFrameWheel2 = (0,slicedToArray/* default */.Z)(_useFrameWheel, 2),
|
|
onRawWheel = _useFrameWheel2[0],
|
|
onFireFoxScroll = _useFrameWheel2[1];
|
|
// Mobile touch move
|
|
useMobileTouchMove(useVirtual, componentRef, function (deltaY, smoothOffset) {
|
|
if (originScroll(deltaY, smoothOffset)) {
|
|
return false;
|
|
}
|
|
onRawWheel({
|
|
preventDefault: function preventDefault() {},
|
|
deltaY: deltaY
|
|
});
|
|
return true;
|
|
});
|
|
(0,useLayoutEffect/* default */.Z)(function () {
|
|
// Firefox only
|
|
function onMozMousePixelScroll(e) {
|
|
if (useVirtual) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
componentRef.current.addEventListener('wheel', onRawWheel);
|
|
componentRef.current.addEventListener('DOMMouseScroll', onFireFoxScroll);
|
|
componentRef.current.addEventListener('MozMousePixelScroll', onMozMousePixelScroll);
|
|
return function () {
|
|
if (componentRef.current) {
|
|
componentRef.current.removeEventListener('wheel', onRawWheel);
|
|
componentRef.current.removeEventListener('DOMMouseScroll', onFireFoxScroll);
|
|
componentRef.current.removeEventListener('MozMousePixelScroll', onMozMousePixelScroll);
|
|
}
|
|
};
|
|
}, [useVirtual]);
|
|
// ================================= Ref ==================================
|
|
var scrollTo = useScrollTo(componentRef, mergedData, heights, itemHeight, getKey, collectHeight, syncScrollTop, function () {
|
|
var _scrollBarRef$current;
|
|
(_scrollBarRef$current = scrollBarRef.current) === null || _scrollBarRef$current === void 0 ? void 0 : _scrollBarRef$current.delayHidden();
|
|
});
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
scrollTo: scrollTo
|
|
};
|
|
});
|
|
// ================================ Effect ================================
|
|
/** We need told outside that some list not rendered */
|
|
(0,useLayoutEffect/* default */.Z)(function () {
|
|
if (onVisibleChange) {
|
|
var renderList = mergedData.slice(start, end + 1);
|
|
onVisibleChange(renderList, mergedData);
|
|
}
|
|
}, [start, end, mergedData]);
|
|
// ================================ Render ================================
|
|
var listChildren = useChildren(mergedData, start, end, setInstanceRef, children, sharedConfig);
|
|
var componentStyle = null;
|
|
if (height) {
|
|
componentStyle = (0,objectSpread2/* default */.Z)((0,defineProperty/* default */.Z)({}, fullHeight ? 'height' : 'maxHeight', height), ScrollStyle);
|
|
if (useVirtual) {
|
|
componentStyle.overflowY = 'hidden';
|
|
if (scrollMoving) {
|
|
componentStyle.pointerEvents = 'none';
|
|
}
|
|
}
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, style), {}, {
|
|
position: 'relative'
|
|
}),
|
|
className: mergedClassName
|
|
}, restProps), /*#__PURE__*/react.createElement(Component, {
|
|
className: "".concat(prefixCls, "-holder"),
|
|
style: componentStyle,
|
|
ref: componentRef,
|
|
onScroll: onFallbackScroll
|
|
}, /*#__PURE__*/react.createElement(es_Filler, {
|
|
prefixCls: prefixCls,
|
|
height: scrollHeight,
|
|
offset: offset,
|
|
onInnerResize: collectHeight,
|
|
ref: fillerInnerRef,
|
|
innerProps: innerProps
|
|
}, listChildren)), useVirtual && /*#__PURE__*/react.createElement(ScrollBar, {
|
|
ref: scrollBarRef,
|
|
prefixCls: prefixCls,
|
|
scrollTop: scrollTop,
|
|
height: height,
|
|
scrollHeight: scrollHeight,
|
|
count: mergedData.length,
|
|
direction: direction,
|
|
onScroll: onScrollBar,
|
|
onStartMove: function onStartMove() {
|
|
setScrollMoving(true);
|
|
},
|
|
onStopMove: function onStopMove() {
|
|
setScrollMoving(false);
|
|
}
|
|
}));
|
|
}
|
|
var List = /*#__PURE__*/react.forwardRef(RawList);
|
|
List.displayName = 'List';
|
|
/* harmony default export */ var es_List = (List);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-virtual-list/es/index.js
|
|
|
|
/* harmony default export */ var rc_virtual_list_es = (es_List);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/SelectContext.js
|
|
|
|
var SelectContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var es_SelectContext = (SelectContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/utils/platformUtil.js
|
|
/* istanbul ignore file */
|
|
function isPlatformMac() {
|
|
return /(mac\sos|macintosh)/i.test(navigator.appVersion);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/OptionList.js
|
|
|
|
|
|
|
|
|
|
|
|
var OptionList_excluded = ["disabled", "title", "children", "style", "className"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// export interface OptionListProps<OptionsType extends object[]> {
|
|
|
|
function OptionList_isTitleType(content) {
|
|
return typeof content === 'string' || typeof content === 'number';
|
|
}
|
|
|
|
/**
|
|
* Using virtual list of option display.
|
|
* Will fallback to dom if use customize render.
|
|
*/
|
|
var OptionList = function OptionList(_, ref) {
|
|
var _useBaseProps = useBaseProps(),
|
|
prefixCls = _useBaseProps.prefixCls,
|
|
id = _useBaseProps.id,
|
|
open = _useBaseProps.open,
|
|
multiple = _useBaseProps.multiple,
|
|
mode = _useBaseProps.mode,
|
|
searchValue = _useBaseProps.searchValue,
|
|
toggleOpen = _useBaseProps.toggleOpen,
|
|
notFoundContent = _useBaseProps.notFoundContent,
|
|
onPopupScroll = _useBaseProps.onPopupScroll;
|
|
var _React$useContext = react.useContext(es_SelectContext),
|
|
flattenOptions = _React$useContext.flattenOptions,
|
|
onActiveValue = _React$useContext.onActiveValue,
|
|
defaultActiveFirstOption = _React$useContext.defaultActiveFirstOption,
|
|
onSelect = _React$useContext.onSelect,
|
|
menuItemSelectedIcon = _React$useContext.menuItemSelectedIcon,
|
|
rawValues = _React$useContext.rawValues,
|
|
fieldNames = _React$useContext.fieldNames,
|
|
virtual = _React$useContext.virtual,
|
|
direction = _React$useContext.direction,
|
|
listHeight = _React$useContext.listHeight,
|
|
listItemHeight = _React$useContext.listItemHeight;
|
|
var itemPrefixCls = "".concat(prefixCls, "-item");
|
|
var memoFlattenOptions = (0,useMemo/* default */.Z)(function () {
|
|
return flattenOptions;
|
|
}, [open, flattenOptions], function (prev, next) {
|
|
return next[0] && prev[1] !== next[1];
|
|
});
|
|
|
|
// =========================== List ===========================
|
|
var listRef = react.useRef(null);
|
|
var onListMouseDown = function onListMouseDown(event) {
|
|
event.preventDefault();
|
|
};
|
|
var scrollIntoView = function scrollIntoView(args) {
|
|
if (listRef.current) {
|
|
listRef.current.scrollTo(typeof args === 'number' ? {
|
|
index: args
|
|
} : args);
|
|
}
|
|
};
|
|
|
|
// ========================== Active ==========================
|
|
var getEnabledActiveIndex = function getEnabledActiveIndex(index) {
|
|
var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
var len = memoFlattenOptions.length;
|
|
for (var i = 0; i < len; i += 1) {
|
|
var current = (index + i * offset + len) % len;
|
|
var _memoFlattenOptions$c = memoFlattenOptions[current],
|
|
group = _memoFlattenOptions$c.group,
|
|
data = _memoFlattenOptions$c.data;
|
|
if (!group && !data.disabled) {
|
|
return current;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
var _React$useState = react.useState(function () {
|
|
return getEnabledActiveIndex(0);
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activeIndex = _React$useState2[0],
|
|
setActiveIndex = _React$useState2[1];
|
|
var setActive = function setActive(index) {
|
|
var fromKeyboard = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
setActiveIndex(index);
|
|
var info = {
|
|
source: fromKeyboard ? 'keyboard' : 'mouse'
|
|
};
|
|
|
|
// Trigger active event
|
|
var flattenItem = memoFlattenOptions[index];
|
|
if (!flattenItem) {
|
|
onActiveValue(null, -1, info);
|
|
return;
|
|
}
|
|
onActiveValue(flattenItem.value, index, info);
|
|
};
|
|
|
|
// Auto active first item when list length or searchValue changed
|
|
(0,react.useEffect)(function () {
|
|
setActive(defaultActiveFirstOption !== false ? getEnabledActiveIndex(0) : -1);
|
|
}, [memoFlattenOptions.length, searchValue]);
|
|
|
|
// https://github.com/ant-design/ant-design/issues/34975
|
|
var isSelected = react.useCallback(function (value) {
|
|
return rawValues.has(value) && mode !== 'combobox';
|
|
}, [mode, (0,toConsumableArray/* default */.Z)(rawValues).toString(), rawValues.size]);
|
|
|
|
// Auto scroll to item position in single mode
|
|
(0,react.useEffect)(function () {
|
|
/**
|
|
* React will skip `onChange` when component update.
|
|
* `setActive` function will call root accessibility state update which makes re-render.
|
|
* So we need to delay to let Input component trigger onChange first.
|
|
*/
|
|
var timeoutId = setTimeout(function () {
|
|
if (!multiple && open && rawValues.size === 1) {
|
|
var value = Array.from(rawValues)[0];
|
|
var index = memoFlattenOptions.findIndex(function (_ref) {
|
|
var data = _ref.data;
|
|
return data.value === value;
|
|
});
|
|
if (index !== -1) {
|
|
setActive(index);
|
|
scrollIntoView(index);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Force trigger scrollbar visible when open
|
|
if (open) {
|
|
var _listRef$current;
|
|
(_listRef$current = listRef.current) === null || _listRef$current === void 0 ? void 0 : _listRef$current.scrollTo(undefined);
|
|
}
|
|
return function () {
|
|
return clearTimeout(timeoutId);
|
|
};
|
|
}, [open, searchValue, flattenOptions.length]);
|
|
|
|
// ========================== Values ==========================
|
|
var onSelectValue = function onSelectValue(value) {
|
|
if (value !== undefined) {
|
|
onSelect(value, {
|
|
selected: !rawValues.has(value)
|
|
});
|
|
}
|
|
|
|
// Single mode should always close by select
|
|
if (!multiple) {
|
|
toggleOpen(false);
|
|
}
|
|
};
|
|
|
|
// ========================= Keyboard =========================
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
onKeyDown: function onKeyDown(event) {
|
|
var which = event.which,
|
|
ctrlKey = event.ctrlKey;
|
|
switch (which) {
|
|
// >>> Arrow keys & ctrl + n/p on Mac
|
|
case KeyCode/* default.N */.Z.N:
|
|
case KeyCode/* default.P */.Z.P:
|
|
case KeyCode/* default.UP */.Z.UP:
|
|
case KeyCode/* default.DOWN */.Z.DOWN:
|
|
{
|
|
var offset = 0;
|
|
if (which === KeyCode/* default.UP */.Z.UP) {
|
|
offset = -1;
|
|
} else if (which === KeyCode/* default.DOWN */.Z.DOWN) {
|
|
offset = 1;
|
|
} else if (isPlatformMac() && ctrlKey) {
|
|
if (which === KeyCode/* default.N */.Z.N) {
|
|
offset = 1;
|
|
} else if (which === KeyCode/* default.P */.Z.P) {
|
|
offset = -1;
|
|
}
|
|
}
|
|
if (offset !== 0) {
|
|
var nextActiveIndex = getEnabledActiveIndex(activeIndex + offset, offset);
|
|
scrollIntoView(nextActiveIndex);
|
|
setActive(nextActiveIndex, true);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// >>> Select
|
|
case KeyCode/* default.ENTER */.Z.ENTER:
|
|
{
|
|
// value
|
|
var item = memoFlattenOptions[activeIndex];
|
|
if (item && !item.data.disabled) {
|
|
onSelectValue(item.value);
|
|
} else {
|
|
onSelectValue(undefined);
|
|
}
|
|
if (open) {
|
|
event.preventDefault();
|
|
}
|
|
break;
|
|
}
|
|
|
|
// >>> Close
|
|
case KeyCode/* default.ESC */.Z.ESC:
|
|
{
|
|
toggleOpen(false);
|
|
if (open) {
|
|
event.stopPropagation();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
onKeyUp: function onKeyUp() {},
|
|
scrollTo: function scrollTo(index) {
|
|
scrollIntoView(index);
|
|
}
|
|
};
|
|
});
|
|
|
|
// ========================== Render ==========================
|
|
if (memoFlattenOptions.length === 0) {
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
role: "listbox",
|
|
id: "".concat(id, "_list"),
|
|
className: "".concat(itemPrefixCls, "-empty"),
|
|
onMouseDown: onListMouseDown
|
|
}, notFoundContent);
|
|
}
|
|
var omitFieldNameList = Object.keys(fieldNames).map(function (key) {
|
|
return fieldNames[key];
|
|
});
|
|
var getLabel = function getLabel(item) {
|
|
return item.label;
|
|
};
|
|
function getItemAriaProps(item, index) {
|
|
var group = item.group;
|
|
return {
|
|
role: group ? 'presentation' : 'option',
|
|
id: "".concat(id, "_list_").concat(index)
|
|
};
|
|
}
|
|
var renderItem = function renderItem(index) {
|
|
var item = memoFlattenOptions[index];
|
|
if (!item) return null;
|
|
var itemData = item.data || {};
|
|
var value = itemData.value;
|
|
var group = item.group;
|
|
var attrs = (0,pickAttrs/* default */.Z)(itemData, true);
|
|
var mergedLabel = getLabel(item);
|
|
return item ? /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
"aria-label": typeof mergedLabel === 'string' && !group ? mergedLabel : null
|
|
}, attrs, {
|
|
key: index
|
|
}, getItemAriaProps(item, index), {
|
|
"aria-selected": isSelected(value)
|
|
}), value) : null;
|
|
};
|
|
var a11yProps = {
|
|
role: 'listbox',
|
|
id: "".concat(id, "_list")
|
|
};
|
|
return /*#__PURE__*/react.createElement(react.Fragment, null, virtual && /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({}, a11yProps, {
|
|
style: {
|
|
height: 0,
|
|
width: 0,
|
|
overflow: 'hidden'
|
|
}
|
|
}), renderItem(activeIndex - 1), renderItem(activeIndex), renderItem(activeIndex + 1)), /*#__PURE__*/react.createElement(rc_virtual_list_es, {
|
|
itemKey: "key",
|
|
ref: listRef,
|
|
data: memoFlattenOptions,
|
|
height: listHeight,
|
|
itemHeight: listItemHeight,
|
|
fullHeight: false,
|
|
onMouseDown: onListMouseDown,
|
|
onScroll: onPopupScroll,
|
|
virtual: virtual,
|
|
direction: direction,
|
|
innerProps: virtual ? null : a11yProps
|
|
}, function (item, itemIndex) {
|
|
var _classNames;
|
|
var group = item.group,
|
|
groupOption = item.groupOption,
|
|
data = item.data,
|
|
label = item.label,
|
|
value = item.value;
|
|
var key = data.key;
|
|
|
|
// Group
|
|
if (group) {
|
|
var _data$title;
|
|
var groupTitle = (_data$title = data.title) !== null && _data$title !== void 0 ? _data$title : OptionList_isTitleType(label) ? label.toString() : undefined;
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(itemPrefixCls, "".concat(itemPrefixCls, "-group")),
|
|
title: groupTitle
|
|
}, label !== undefined ? label : key);
|
|
}
|
|
var disabled = data.disabled,
|
|
title = data.title,
|
|
children = data.children,
|
|
style = data.style,
|
|
className = data.className,
|
|
otherProps = (0,objectWithoutProperties/* default */.Z)(data, OptionList_excluded);
|
|
var passedProps = (0,omit/* default */.Z)(otherProps, omitFieldNameList);
|
|
|
|
// Option
|
|
var selected = isSelected(value);
|
|
var optionPrefixCls = "".concat(itemPrefixCls, "-option");
|
|
var optionClassName = classnames_default()(itemPrefixCls, optionPrefixCls, className, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(optionPrefixCls, "-grouped"), groupOption), (0,defineProperty/* default */.Z)(_classNames, "".concat(optionPrefixCls, "-active"), activeIndex === itemIndex && !disabled), (0,defineProperty/* default */.Z)(_classNames, "".concat(optionPrefixCls, "-disabled"), disabled), (0,defineProperty/* default */.Z)(_classNames, "".concat(optionPrefixCls, "-selected"), selected), _classNames));
|
|
var mergedLabel = getLabel(item);
|
|
var iconVisible = !menuItemSelectedIcon || typeof menuItemSelectedIcon === 'function' || selected;
|
|
|
|
// https://github.com/ant-design/ant-design/issues/34145
|
|
var content = typeof mergedLabel === 'number' ? mergedLabel : mergedLabel || value;
|
|
// https://github.com/ant-design/ant-design/issues/26717
|
|
var optionTitle = OptionList_isTitleType(content) ? content.toString() : undefined;
|
|
if (title !== undefined) {
|
|
optionTitle = title;
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({}, (0,pickAttrs/* default */.Z)(passedProps), !virtual ? getItemAriaProps(item, itemIndex) : {}, {
|
|
"aria-selected": selected,
|
|
className: optionClassName,
|
|
title: optionTitle,
|
|
onMouseMove: function onMouseMove() {
|
|
if (activeIndex === itemIndex || disabled) {
|
|
return;
|
|
}
|
|
setActive(itemIndex);
|
|
},
|
|
onClick: function onClick() {
|
|
if (!disabled) {
|
|
onSelectValue(value);
|
|
}
|
|
},
|
|
style: style
|
|
}), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(optionPrefixCls, "-content")
|
|
}, content), /*#__PURE__*/react.isValidElement(menuItemSelectedIcon) || selected, iconVisible && /*#__PURE__*/react.createElement(es_TransBtn, {
|
|
className: "".concat(itemPrefixCls, "-option-state"),
|
|
customizeIcon: menuItemSelectedIcon,
|
|
customizeIconProps: {
|
|
isSelected: selected
|
|
}
|
|
}, selected ? '✓' : null));
|
|
}));
|
|
};
|
|
var RefOptionList = /*#__PURE__*/react.forwardRef(OptionList);
|
|
RefOptionList.displayName = 'OptionList';
|
|
/* harmony default export */ var es_OptionList = (RefOptionList);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/utils/warningPropsUtil.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function warningProps(props) {
|
|
var mode = props.mode,
|
|
options = props.options,
|
|
children = props.children,
|
|
backfill = props.backfill,
|
|
allowClear = props.allowClear,
|
|
placeholder = props.placeholder,
|
|
getInputElement = props.getInputElement,
|
|
showSearch = props.showSearch,
|
|
onSearch = props.onSearch,
|
|
defaultOpen = props.defaultOpen,
|
|
autoFocus = props.autoFocus,
|
|
labelInValue = props.labelInValue,
|
|
value = props.value,
|
|
inputValue = props.inputValue,
|
|
optionLabelProp = props.optionLabelProp;
|
|
var multiple = isMultiple(mode);
|
|
var mergedShowSearch = showSearch !== undefined ? showSearch : multiple || mode === 'combobox';
|
|
var mergedOptions = options || convertChildrenToData(children);
|
|
|
|
// `tags` should not set option as disabled
|
|
warning(mode !== 'tags' || mergedOptions.every(function (opt) {
|
|
return !opt.disabled;
|
|
}), 'Please avoid setting option to disabled in tags mode since user can always type text as tag.');
|
|
|
|
// `combobox` & `tags` should option be `string` type
|
|
if (mode === 'tags' || mode === 'combobox') {
|
|
var hasNumberValue = mergedOptions.some(function (item) {
|
|
if (item.options) {
|
|
return item.options.some(function (opt) {
|
|
return typeof ('value' in opt ? opt.value : opt.key) === 'number';
|
|
});
|
|
}
|
|
return typeof ('value' in item ? item.value : item.key) === 'number';
|
|
});
|
|
warning(!hasNumberValue, '`value` of Option should not use number type when `mode` is `tags` or `combobox`.');
|
|
}
|
|
|
|
// `combobox` should not use `optionLabelProp`
|
|
warning(mode !== 'combobox' || !optionLabelProp, '`combobox` mode not support `optionLabelProp`. Please set `value` on Option directly.');
|
|
|
|
// Only `combobox` support `backfill`
|
|
warning(mode === 'combobox' || !backfill, '`backfill` only works with `combobox` mode.');
|
|
|
|
// Only `combobox` support `getInputElement`
|
|
warning(mode === 'combobox' || !getInputElement, '`getInputElement` only work with `combobox` mode.');
|
|
|
|
// Customize `getInputElement` should not use `allowClear` & `placeholder`
|
|
noteOnce(mode !== 'combobox' || !getInputElement || !allowClear || !placeholder, 'Customize `getInputElement` should customize clear and placeholder logic instead of configuring `allowClear` and `placeholder`.');
|
|
|
|
// `onSearch` should use in `combobox` or `showSearch`
|
|
if (onSearch && !mergedShowSearch && mode !== 'combobox' && mode !== 'tags') {
|
|
warning(false, '`onSearch` should work with `showSearch` instead of use alone.');
|
|
}
|
|
noteOnce(!defaultOpen || autoFocus, '`defaultOpen` makes Select open without focus which means it will not close by click outside. You can set `autoFocus` if needed.');
|
|
if (value !== undefined && value !== null) {
|
|
var values = toArray(value);
|
|
warning(!labelInValue || values.every(function (val) {
|
|
return _typeof(val) === 'object' && ('key' in val || 'value' in val);
|
|
}), '`value` should in shape of `{ value: string | number, label?: ReactNode }` when you set `labelInValue` to `true`');
|
|
warning(!multiple || Array.isArray(value), '`value` should be array when `mode` is `multiple` or `tags`');
|
|
}
|
|
|
|
// Syntactic sugar should use correct children type
|
|
if (children) {
|
|
var invalidateChildType = null;
|
|
toNodeArray(children).some(function (node) {
|
|
if (! /*#__PURE__*/React.isValidElement(node) || !node.type) {
|
|
return false;
|
|
}
|
|
var _ref = node,
|
|
type = _ref.type;
|
|
if (type.isSelectOption) {
|
|
return false;
|
|
}
|
|
if (type.isSelectOptGroup) {
|
|
var allChildrenValid = toNodeArray(node.props.children).every(function (subNode) {
|
|
if (! /*#__PURE__*/React.isValidElement(subNode) || !node.type || subNode.type.isSelectOption) {
|
|
return true;
|
|
}
|
|
invalidateChildType = subNode.type;
|
|
return false;
|
|
});
|
|
if (allChildrenValid) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
invalidateChildType = type;
|
|
return true;
|
|
});
|
|
if (invalidateChildType) {
|
|
warning(false, "`children` should be `Select.Option` or `Select.OptGroup` instead of `".concat(invalidateChildType.displayName || invalidateChildType.name || invalidateChildType, "`."));
|
|
}
|
|
warning(inputValue === undefined, '`inputValue` is deprecated, please use `searchValue` instead.');
|
|
}
|
|
}
|
|
|
|
// value in Select option should not be null
|
|
// note: OptGroup has options too
|
|
function warningNullOptions(options, fieldNames) {
|
|
if (options) {
|
|
var recursiveOptions = function recursiveOptions(optionsList) {
|
|
var inGroup = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
for (var i = 0; i < optionsList.length; i++) {
|
|
var option = optionsList[i];
|
|
if (option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.value] === null) {
|
|
warning(false, '`value` in Select options should not be `null`.');
|
|
return true;
|
|
}
|
|
if (!inGroup && Array.isArray(option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.options]) && recursiveOptions(option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.options], true)) {
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
recursiveOptions(options);
|
|
}
|
|
}
|
|
/* harmony default export */ var warningPropsUtil = ((/* unused pure expression or super */ null && (warningProps)));
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/Select.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var Select_excluded = ["id", "mode", "prefixCls", "backfill", "fieldNames", "inputValue", "searchValue", "onSearch", "autoClearSearchValue", "onSelect", "onDeselect", "dropdownMatchSelectWidth", "filterOption", "filterSort", "optionFilterProp", "optionLabelProp", "options", "children", "defaultActiveFirstOption", "menuItemSelectedIcon", "virtual", "direction", "listHeight", "listItemHeight", "value", "defaultValue", "labelInValue", "onChange"];
|
|
/**
|
|
* To match accessibility requirement, we always provide an input in the component.
|
|
* Other element will not set `tabIndex` to avoid `onBlur` sequence problem.
|
|
* For focused select, we set `aria-live="polite"` to update the accessibility content.
|
|
*
|
|
* ref:
|
|
* - keyboard: https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/listbox_role#Keyboard_interactions
|
|
*
|
|
* New api:
|
|
* - listHeight
|
|
* - listItemHeight
|
|
* - component
|
|
*
|
|
* Remove deprecated api:
|
|
* - multiple
|
|
* - tags
|
|
* - combobox
|
|
* - firstActiveValue
|
|
* - dropdownMenuStyle
|
|
* - openClassName (Not list in api)
|
|
*
|
|
* Update:
|
|
* - `backfill` only support `combobox` mode
|
|
* - `combobox` mode not support `labelInValue` since it's meaningless
|
|
* - `getInputElement` only support `combobox` mode
|
|
* - `onChange` return OptionData instead of ReactNode
|
|
* - `filterOption` `onChange` `onSelect` accept OptionData instead of ReactNode
|
|
* - `combobox` mode trigger `onChange` will get `undefined` if no `value` match in Option
|
|
* - `combobox` mode not support `optionLabelProp`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var OMIT_DOM_PROPS = ['inputValue'];
|
|
function isRawValue(value) {
|
|
return !value || (0,esm_typeof/* default */.Z)(value) !== 'object';
|
|
}
|
|
var Select_Select = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var id = props.id,
|
|
mode = props.mode,
|
|
_props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-select' : _props$prefixCls,
|
|
backfill = props.backfill,
|
|
fieldNames = props.fieldNames,
|
|
inputValue = props.inputValue,
|
|
searchValue = props.searchValue,
|
|
onSearch = props.onSearch,
|
|
_props$autoClearSearc = props.autoClearSearchValue,
|
|
autoClearSearchValue = _props$autoClearSearc === void 0 ? true : _props$autoClearSearc,
|
|
onSelect = props.onSelect,
|
|
onDeselect = props.onDeselect,
|
|
_props$dropdownMatchS = props.dropdownMatchSelectWidth,
|
|
dropdownMatchSelectWidth = _props$dropdownMatchS === void 0 ? true : _props$dropdownMatchS,
|
|
filterOption = props.filterOption,
|
|
filterSort = props.filterSort,
|
|
optionFilterProp = props.optionFilterProp,
|
|
optionLabelProp = props.optionLabelProp,
|
|
options = props.options,
|
|
children = props.children,
|
|
defaultActiveFirstOption = props.defaultActiveFirstOption,
|
|
menuItemSelectedIcon = props.menuItemSelectedIcon,
|
|
virtual = props.virtual,
|
|
direction = props.direction,
|
|
_props$listHeight = props.listHeight,
|
|
listHeight = _props$listHeight === void 0 ? 200 : _props$listHeight,
|
|
_props$listItemHeight = props.listItemHeight,
|
|
listItemHeight = _props$listItemHeight === void 0 ? 20 : _props$listItemHeight,
|
|
value = props.value,
|
|
defaultValue = props.defaultValue,
|
|
labelInValue = props.labelInValue,
|
|
onChange = props.onChange,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, Select_excluded);
|
|
var mergedId = useId(id);
|
|
var multiple = BaseSelect_isMultiple(mode);
|
|
var childrenAsData = !!(!options && children);
|
|
var mergedFilterOption = react.useMemo(function () {
|
|
if (filterOption === undefined && mode === 'combobox') {
|
|
return false;
|
|
}
|
|
return filterOption;
|
|
}, [filterOption, mode]);
|
|
|
|
// ========================= FieldNames =========================
|
|
var mergedFieldNames = react.useMemo(function () {
|
|
return fillFieldNames(fieldNames, childrenAsData);
|
|
}, /* eslint-disable react-hooks/exhaustive-deps */
|
|
[
|
|
// We stringify fieldNames to avoid unnecessary re-renders.
|
|
JSON.stringify(fieldNames), childrenAsData]
|
|
/* eslint-enable react-hooks/exhaustive-deps */);
|
|
|
|
// =========================== Search ===========================
|
|
var _useMergedState = (0,useMergedState/* default */.Z)('', {
|
|
value: searchValue !== undefined ? searchValue : inputValue,
|
|
postState: function postState(search) {
|
|
return search || '';
|
|
}
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
mergedSearchValue = _useMergedState2[0],
|
|
setSearchValue = _useMergedState2[1];
|
|
|
|
// =========================== Option ===========================
|
|
var parsedOptions = useOptions(options, children, mergedFieldNames, optionFilterProp, optionLabelProp);
|
|
var valueOptions = parsedOptions.valueOptions,
|
|
labelOptions = parsedOptions.labelOptions,
|
|
mergedOptions = parsedOptions.options;
|
|
|
|
// ========================= Wrap Value =========================
|
|
var convert2LabelValues = react.useCallback(function (draftValues) {
|
|
// Convert to array
|
|
var valueList = commonUtil_toArray(draftValues);
|
|
|
|
// Convert to labelInValue type
|
|
return valueList.map(function (val) {
|
|
var rawValue;
|
|
var rawLabel;
|
|
var rawKey;
|
|
var rawDisabled;
|
|
var rawTitle;
|
|
|
|
// Fill label & value
|
|
if (isRawValue(val)) {
|
|
rawValue = val;
|
|
} else {
|
|
var _val$value;
|
|
rawKey = val.key;
|
|
rawLabel = val.label;
|
|
rawValue = (_val$value = val.value) !== null && _val$value !== void 0 ? _val$value : rawKey;
|
|
}
|
|
var option = valueOptions.get(rawValue);
|
|
if (option) {
|
|
var _option$key;
|
|
// Fill missing props
|
|
if (rawLabel === undefined) rawLabel = option === null || option === void 0 ? void 0 : option[optionLabelProp || mergedFieldNames.label];
|
|
if (rawKey === undefined) rawKey = (_option$key = option === null || option === void 0 ? void 0 : option.key) !== null && _option$key !== void 0 ? _option$key : rawValue;
|
|
rawDisabled = option === null || option === void 0 ? void 0 : option.disabled;
|
|
rawTitle = option === null || option === void 0 ? void 0 : option.title;
|
|
|
|
// Warning if label not same as provided
|
|
if (false) { var optionLabel; }
|
|
}
|
|
return {
|
|
label: rawLabel,
|
|
value: rawValue,
|
|
key: rawKey,
|
|
disabled: rawDisabled,
|
|
title: rawTitle
|
|
};
|
|
});
|
|
}, [mergedFieldNames, optionLabelProp, valueOptions]);
|
|
|
|
// =========================== Values ===========================
|
|
var _useMergedState3 = (0,useMergedState/* default */.Z)(defaultValue, {
|
|
value: value
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
internalValue = _useMergedState4[0],
|
|
setInternalValue = _useMergedState4[1];
|
|
|
|
// Merged value with LabelValueType
|
|
var rawLabeledValues = react.useMemo(function () {
|
|
var _values$;
|
|
var values = convert2LabelValues(internalValue);
|
|
|
|
// combobox no need save value when it's no value
|
|
if (mode === 'combobox' && !((_values$ = values[0]) !== null && _values$ !== void 0 && _values$.value)) {
|
|
return [];
|
|
}
|
|
return values;
|
|
}, [internalValue, convert2LabelValues, mode]);
|
|
|
|
// Fill label with cache to avoid option remove
|
|
var _useCache = useCache(rawLabeledValues, valueOptions),
|
|
_useCache2 = (0,slicedToArray/* default */.Z)(_useCache, 2),
|
|
mergedValues = _useCache2[0],
|
|
getMixedOption = _useCache2[1];
|
|
var displayValues = react.useMemo(function () {
|
|
// `null` need show as placeholder instead
|
|
// https://github.com/ant-design/ant-design/issues/25057
|
|
if (!mode && mergedValues.length === 1) {
|
|
var firstValue = mergedValues[0];
|
|
if (firstValue.value === null && (firstValue.label === null || firstValue.label === undefined)) {
|
|
return [];
|
|
}
|
|
}
|
|
return mergedValues.map(function (item) {
|
|
var _item$label;
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, item), {}, {
|
|
label: (_item$label = item.label) !== null && _item$label !== void 0 ? _item$label : item.value
|
|
});
|
|
});
|
|
}, [mode, mergedValues]);
|
|
|
|
/** Convert `displayValues` to raw value type set */
|
|
var rawValues = react.useMemo(function () {
|
|
return new Set(mergedValues.map(function (val) {
|
|
return val.value;
|
|
}));
|
|
}, [mergedValues]);
|
|
react.useEffect(function () {
|
|
if (mode === 'combobox') {
|
|
var _mergedValues$;
|
|
var strValue = (_mergedValues$ = mergedValues[0]) === null || _mergedValues$ === void 0 ? void 0 : _mergedValues$.value;
|
|
setSearchValue(hasValue(strValue) ? String(strValue) : '');
|
|
}
|
|
}, [mergedValues]);
|
|
|
|
// ======================= Display Option =======================
|
|
// Create a placeholder item if not exist in `options`
|
|
var createTagOption = useRefFunc(function (val, label) {
|
|
var _ref;
|
|
var mergedLabel = label !== null && label !== void 0 ? label : val;
|
|
return _ref = {}, (0,defineProperty/* default */.Z)(_ref, mergedFieldNames.value, val), (0,defineProperty/* default */.Z)(_ref, mergedFieldNames.label, mergedLabel), _ref;
|
|
});
|
|
|
|
// Fill tag as option if mode is `tags`
|
|
var filledTagOptions = react.useMemo(function () {
|
|
if (mode !== 'tags') {
|
|
return mergedOptions;
|
|
}
|
|
|
|
// >>> Tag mode
|
|
var cloneOptions = (0,toConsumableArray/* default */.Z)(mergedOptions);
|
|
|
|
// Check if value exist in options (include new patch item)
|
|
var existOptions = function existOptions(val) {
|
|
return valueOptions.has(val);
|
|
};
|
|
|
|
// Fill current value as option
|
|
(0,toConsumableArray/* default */.Z)(mergedValues).sort(function (a, b) {
|
|
return a.value < b.value ? -1 : 1;
|
|
}).forEach(function (item) {
|
|
var val = item.value;
|
|
if (!existOptions(val)) {
|
|
cloneOptions.push(createTagOption(val, item.label));
|
|
}
|
|
});
|
|
return cloneOptions;
|
|
}, [createTagOption, mergedOptions, valueOptions, mergedValues, mode]);
|
|
var filteredOptions = useFilterOptions(filledTagOptions, mergedFieldNames, mergedSearchValue, mergedFilterOption, optionFilterProp);
|
|
|
|
// Fill options with search value if needed
|
|
var filledSearchOptions = react.useMemo(function () {
|
|
if (mode !== 'tags' || !mergedSearchValue || filteredOptions.some(function (item) {
|
|
return item[optionFilterProp || 'value'] === mergedSearchValue;
|
|
})) {
|
|
return filteredOptions;
|
|
}
|
|
|
|
// Fill search value as option
|
|
return [createTagOption(mergedSearchValue)].concat((0,toConsumableArray/* default */.Z)(filteredOptions));
|
|
}, [createTagOption, optionFilterProp, mode, filteredOptions, mergedSearchValue]);
|
|
var orderedFilteredOptions = react.useMemo(function () {
|
|
if (!filterSort) {
|
|
return filledSearchOptions;
|
|
}
|
|
return (0,toConsumableArray/* default */.Z)(filledSearchOptions).sort(function (a, b) {
|
|
return filterSort(a, b);
|
|
});
|
|
}, [filledSearchOptions, filterSort]);
|
|
var displayOptions = react.useMemo(function () {
|
|
return flattenOptions(orderedFilteredOptions, {
|
|
fieldNames: mergedFieldNames,
|
|
childrenAsData: childrenAsData
|
|
});
|
|
}, [orderedFilteredOptions, mergedFieldNames, childrenAsData]);
|
|
|
|
// =========================== Change ===========================
|
|
var triggerChange = function triggerChange(values) {
|
|
var labeledValues = convert2LabelValues(values);
|
|
setInternalValue(labeledValues);
|
|
if (onChange && (
|
|
// Trigger event only when value changed
|
|
labeledValues.length !== mergedValues.length || labeledValues.some(function (newVal, index) {
|
|
var _mergedValues$index;
|
|
return ((_mergedValues$index = mergedValues[index]) === null || _mergedValues$index === void 0 ? void 0 : _mergedValues$index.value) !== (newVal === null || newVal === void 0 ? void 0 : newVal.value);
|
|
}))) {
|
|
var returnValues = labelInValue ? labeledValues : labeledValues.map(function (v) {
|
|
return v.value;
|
|
});
|
|
var returnOptions = labeledValues.map(function (v) {
|
|
return injectPropsWithOption(getMixedOption(v.value));
|
|
});
|
|
onChange(
|
|
// Value
|
|
multiple ? returnValues : returnValues[0],
|
|
// Option
|
|
multiple ? returnOptions : returnOptions[0]);
|
|
}
|
|
};
|
|
|
|
// ======================= Accessibility ========================
|
|
var _React$useState = react.useState(null),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activeValue = _React$useState2[0],
|
|
setActiveValue = _React$useState2[1];
|
|
var _React$useState3 = react.useState(0),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
accessibilityIndex = _React$useState4[0],
|
|
setAccessibilityIndex = _React$useState4[1];
|
|
var mergedDefaultActiveFirstOption = defaultActiveFirstOption !== undefined ? defaultActiveFirstOption : mode !== 'combobox';
|
|
var onActiveValue = react.useCallback(function (active, index) {
|
|
var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
|
|
_ref2$source = _ref2.source,
|
|
source = _ref2$source === void 0 ? 'keyboard' : _ref2$source;
|
|
setAccessibilityIndex(index);
|
|
if (backfill && mode === 'combobox' && active !== null && source === 'keyboard') {
|
|
setActiveValue(String(active));
|
|
}
|
|
}, [backfill, mode]);
|
|
|
|
// ========================= OptionList =========================
|
|
var triggerSelect = function triggerSelect(val, selected, type) {
|
|
var getSelectEnt = function getSelectEnt() {
|
|
var _option$key2;
|
|
var option = getMixedOption(val);
|
|
return [labelInValue ? {
|
|
label: option === null || option === void 0 ? void 0 : option[mergedFieldNames.label],
|
|
value: val,
|
|
key: (_option$key2 = option === null || option === void 0 ? void 0 : option.key) !== null && _option$key2 !== void 0 ? _option$key2 : val
|
|
} : val, injectPropsWithOption(option)];
|
|
};
|
|
if (selected && onSelect) {
|
|
var _getSelectEnt = getSelectEnt(),
|
|
_getSelectEnt2 = (0,slicedToArray/* default */.Z)(_getSelectEnt, 2),
|
|
wrappedValue = _getSelectEnt2[0],
|
|
_option = _getSelectEnt2[1];
|
|
onSelect(wrappedValue, _option);
|
|
} else if (!selected && onDeselect && type !== 'clear') {
|
|
var _getSelectEnt3 = getSelectEnt(),
|
|
_getSelectEnt4 = (0,slicedToArray/* default */.Z)(_getSelectEnt3, 2),
|
|
_wrappedValue = _getSelectEnt4[0],
|
|
_option2 = _getSelectEnt4[1];
|
|
onDeselect(_wrappedValue, _option2);
|
|
}
|
|
};
|
|
|
|
// Used for OptionList selection
|
|
var onInternalSelect = useRefFunc(function (val, info) {
|
|
var cloneValues;
|
|
|
|
// Single mode always trigger select only with option list
|
|
var mergedSelect = multiple ? info.selected : true;
|
|
if (mergedSelect) {
|
|
cloneValues = multiple ? [].concat((0,toConsumableArray/* default */.Z)(mergedValues), [val]) : [val];
|
|
} else {
|
|
cloneValues = mergedValues.filter(function (v) {
|
|
return v.value !== val;
|
|
});
|
|
}
|
|
triggerChange(cloneValues);
|
|
triggerSelect(val, mergedSelect);
|
|
|
|
// Clean search value if single or configured
|
|
if (mode === 'combobox') {
|
|
// setSearchValue(String(val));
|
|
setActiveValue('');
|
|
} else if (!BaseSelect_isMultiple || autoClearSearchValue) {
|
|
setSearchValue('');
|
|
setActiveValue('');
|
|
}
|
|
});
|
|
|
|
// ======================= Display Change =======================
|
|
// BaseSelect display values change
|
|
var onDisplayValuesChange = function onDisplayValuesChange(nextValues, info) {
|
|
triggerChange(nextValues);
|
|
var type = info.type,
|
|
values = info.values;
|
|
if (type === 'remove' || type === 'clear') {
|
|
values.forEach(function (item) {
|
|
triggerSelect(item.value, false, type);
|
|
});
|
|
}
|
|
};
|
|
|
|
// =========================== Search ===========================
|
|
var onInternalSearch = function onInternalSearch(searchText, info) {
|
|
setSearchValue(searchText);
|
|
setActiveValue(null);
|
|
|
|
// [Submit] Tag mode should flush input
|
|
if (info.source === 'submit') {
|
|
var formatted = (searchText || '').trim();
|
|
// prevent empty tags from appearing when you click the Enter button
|
|
if (formatted) {
|
|
var newRawValues = Array.from(new Set([].concat((0,toConsumableArray/* default */.Z)(rawValues), [formatted])));
|
|
triggerChange(newRawValues);
|
|
triggerSelect(formatted, true);
|
|
setSearchValue('');
|
|
}
|
|
return;
|
|
}
|
|
if (info.source !== 'blur') {
|
|
if (mode === 'combobox') {
|
|
triggerChange(searchText);
|
|
}
|
|
onSearch === null || onSearch === void 0 ? void 0 : onSearch(searchText);
|
|
}
|
|
};
|
|
var onInternalSearchSplit = function onInternalSearchSplit(words) {
|
|
var patchValues = words;
|
|
if (mode !== 'tags') {
|
|
patchValues = words.map(function (word) {
|
|
var opt = labelOptions.get(word);
|
|
return opt === null || opt === void 0 ? void 0 : opt.value;
|
|
}).filter(function (val) {
|
|
return val !== undefined;
|
|
});
|
|
}
|
|
var newRawValues = Array.from(new Set([].concat((0,toConsumableArray/* default */.Z)(rawValues), (0,toConsumableArray/* default */.Z)(patchValues))));
|
|
triggerChange(newRawValues);
|
|
newRawValues.forEach(function (newRawValue) {
|
|
triggerSelect(newRawValue, true);
|
|
});
|
|
};
|
|
|
|
// ========================== Context ===========================
|
|
var selectContext = react.useMemo(function () {
|
|
var realVirtual = virtual !== false && dropdownMatchSelectWidth !== false;
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, parsedOptions), {}, {
|
|
flattenOptions: displayOptions,
|
|
onActiveValue: onActiveValue,
|
|
defaultActiveFirstOption: mergedDefaultActiveFirstOption,
|
|
onSelect: onInternalSelect,
|
|
menuItemSelectedIcon: menuItemSelectedIcon,
|
|
rawValues: rawValues,
|
|
fieldNames: mergedFieldNames,
|
|
virtual: realVirtual,
|
|
direction: direction,
|
|
listHeight: listHeight,
|
|
listItemHeight: listItemHeight,
|
|
childrenAsData: childrenAsData
|
|
});
|
|
}, [parsedOptions, displayOptions, onActiveValue, mergedDefaultActiveFirstOption, onInternalSelect, menuItemSelectedIcon, rawValues, mergedFieldNames, virtual, dropdownMatchSelectWidth, listHeight, listItemHeight, childrenAsData]);
|
|
|
|
// ========================== Warning ===========================
|
|
if (false) {}
|
|
|
|
// ==============================================================
|
|
// == Render ==
|
|
// ==============================================================
|
|
return /*#__PURE__*/react.createElement(es_SelectContext.Provider, {
|
|
value: selectContext
|
|
}, /*#__PURE__*/react.createElement(es_BaseSelect, (0,esm_extends/* default */.Z)({}, restProps, {
|
|
// >>> MISC
|
|
id: mergedId,
|
|
prefixCls: prefixCls,
|
|
ref: ref,
|
|
omitDomProps: OMIT_DOM_PROPS,
|
|
mode: mode
|
|
// >>> Values
|
|
,
|
|
displayValues: displayValues,
|
|
onDisplayValuesChange: onDisplayValuesChange
|
|
// >>> Trigger
|
|
,
|
|
direction: direction
|
|
// >>> Search
|
|
,
|
|
searchValue: mergedSearchValue,
|
|
onSearch: onInternalSearch,
|
|
autoClearSearchValue: autoClearSearchValue,
|
|
onSearchSplit: onInternalSearchSplit,
|
|
dropdownMatchSelectWidth: dropdownMatchSelectWidth
|
|
// >>> OptionList
|
|
,
|
|
OptionList: es_OptionList,
|
|
emptyOptions: !displayOptions.length
|
|
// >>> Accessibility
|
|
,
|
|
activeValue: activeValue,
|
|
activeDescendantId: "".concat(mergedId, "_list_").concat(accessibilityIndex)
|
|
})));
|
|
});
|
|
if (false) {}
|
|
var TypedSelect = Select_Select;
|
|
TypedSelect.Option = es_Option;
|
|
TypedSelect.OptGroup = es_OptGroup;
|
|
/* harmony default export */ var es_Select = ((/* unused pure expression or super */ null && (TypedSelect)));
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/node_modules/rc-select/es/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var rc_select_es = ((/* unused pure expression or super */ null && (Select)));
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/conductUtil.js
|
|
var conductUtil = __webpack_require__(17341);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/context.js
|
|
|
|
var CascaderContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var context = (CascaderContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/hooks/useSearchOptions.js
|
|
|
|
|
|
|
|
|
|
var SEARCH_MARK = '__rc_cascader_search_mark__';
|
|
var defaultFilter = function defaultFilter(search, options, _ref) {
|
|
var label = _ref.label;
|
|
return options.some(function (opt) {
|
|
return String(opt[label]).toLowerCase().includes(search.toLowerCase());
|
|
});
|
|
};
|
|
var defaultRender = function defaultRender(inputValue, path, prefixCls, fieldNames) {
|
|
return path.map(function (opt) {
|
|
return opt[fieldNames.label];
|
|
}).join(' / ');
|
|
};
|
|
/* harmony default export */ var useSearchOptions = (function (search, options, fieldNames, prefixCls, config, changeOnSelect) {
|
|
var _config$filter = config.filter,
|
|
filter = _config$filter === void 0 ? defaultFilter : _config$filter,
|
|
_config$render = config.render,
|
|
render = _config$render === void 0 ? defaultRender : _config$render,
|
|
_config$limit = config.limit,
|
|
limit = _config$limit === void 0 ? 50 : _config$limit,
|
|
sort = config.sort;
|
|
return react.useMemo(function () {
|
|
var filteredOptions = [];
|
|
if (!search) {
|
|
return [];
|
|
}
|
|
function dig(list, pathOptions) {
|
|
list.forEach(function (option) {
|
|
// Perf saving when `sort` is disabled and `limit` is provided
|
|
if (!sort && limit > 0 && filteredOptions.length >= limit) {
|
|
return;
|
|
}
|
|
var connectedPathOptions = [].concat((0,toConsumableArray/* default */.Z)(pathOptions), [option]);
|
|
var children = option[fieldNames.children];
|
|
|
|
// If current option is filterable
|
|
if (
|
|
// If is leaf option
|
|
!children || children.length === 0 ||
|
|
// If is changeOnSelect
|
|
changeOnSelect) {
|
|
if (filter(search, connectedPathOptions, {
|
|
label: fieldNames.label
|
|
})) {
|
|
var _objectSpread2;
|
|
filteredOptions.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, option), {}, (_objectSpread2 = {}, (0,defineProperty/* default */.Z)(_objectSpread2, fieldNames.label, render(search, connectedPathOptions, prefixCls, fieldNames)), (0,defineProperty/* default */.Z)(_objectSpread2, SEARCH_MARK, connectedPathOptions), (0,defineProperty/* default */.Z)(_objectSpread2, fieldNames.children, undefined), _objectSpread2)));
|
|
}
|
|
}
|
|
if (children) {
|
|
dig(option[fieldNames.children], connectedPathOptions);
|
|
}
|
|
});
|
|
}
|
|
dig(options, []);
|
|
|
|
// Do sort
|
|
if (sort) {
|
|
filteredOptions.sort(function (a, b) {
|
|
return sort(a[SEARCH_MARK], b[SEARCH_MARK], search, fieldNames);
|
|
});
|
|
}
|
|
return limit > 0 ? filteredOptions.slice(0, limit) : filteredOptions;
|
|
}, [search, options, fieldNames, prefixCls, render, changeOnSelect, filter, sort, limit]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/utils/commonUtil.js
|
|
|
|
var VALUE_SPLIT = '__RC_CASCADER_SPLIT__';
|
|
var SHOW_PARENT = 'SHOW_PARENT';
|
|
var SHOW_CHILD = 'SHOW_CHILD';
|
|
function toPathKey(value) {
|
|
return value.join(VALUE_SPLIT);
|
|
}
|
|
function toPathKeys(value) {
|
|
return value.map(toPathKey);
|
|
}
|
|
function toPathValueStr(pathKey) {
|
|
return pathKey.split(VALUE_SPLIT);
|
|
}
|
|
function commonUtil_fillFieldNames(fieldNames) {
|
|
var _ref = fieldNames || {},
|
|
label = _ref.label,
|
|
value = _ref.value,
|
|
children = _ref.children;
|
|
var val = value || 'value';
|
|
return {
|
|
label: label || 'label',
|
|
value: val,
|
|
key: val,
|
|
children: children || 'children'
|
|
};
|
|
}
|
|
function isLeaf(option, fieldNames) {
|
|
var _option$isLeaf, _option$fieldNames$ch;
|
|
return (_option$isLeaf = option.isLeaf) !== null && _option$isLeaf !== void 0 ? _option$isLeaf : !((_option$fieldNames$ch = option[fieldNames.children]) !== null && _option$fieldNames$ch !== void 0 && _option$fieldNames$ch.length);
|
|
}
|
|
function scrollIntoParentView(element) {
|
|
var parent = element.parentElement;
|
|
if (!parent) {
|
|
return;
|
|
}
|
|
var elementToParent = element.offsetTop - parent.offsetTop; // offsetParent may not be parent.
|
|
if (elementToParent - parent.scrollTop < 0) {
|
|
parent.scrollTo({
|
|
top: elementToParent
|
|
});
|
|
} else if (elementToParent + element.offsetHeight - parent.scrollTop > parent.offsetHeight) {
|
|
parent.scrollTo({
|
|
top: elementToParent + element.offsetHeight - parent.offsetHeight
|
|
});
|
|
}
|
|
}
|
|
function getFullPathKeys(options, fieldNames) {
|
|
return options.map(function (item) {
|
|
var _item$SEARCH_MARK;
|
|
return (_item$SEARCH_MARK = item[SEARCH_MARK]) === null || _item$SEARCH_MARK === void 0 ? void 0 : _item$SEARCH_MARK.map(function (opt) {
|
|
return opt[fieldNames.value];
|
|
});
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/utils/treeUtil.js
|
|
|
|
function formatStrategyValues(pathKeys, getKeyPathEntities, showCheckedStrategy) {
|
|
var valueSet = new Set(pathKeys);
|
|
var keyPathEntities = getKeyPathEntities();
|
|
return pathKeys.filter(function (key) {
|
|
var entity = keyPathEntities[key];
|
|
var parent = entity ? entity.parent : null;
|
|
var children = entity ? entity.children : null;
|
|
return showCheckedStrategy === SHOW_CHILD ? !(children && children.some(function (child) {
|
|
return child.key && valueSet.has(child.key);
|
|
})) : !(parent && !parent.node.disabled && valueSet.has(parent.key));
|
|
});
|
|
}
|
|
function toPathOptions(valueCells, options, fieldNames) {
|
|
var stringMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
var currentList = options;
|
|
var valueOptions = [];
|
|
var _loop = function _loop() {
|
|
var _currentList, _currentList2, _foundOption$fieldNam;
|
|
var valueCell = valueCells[i];
|
|
var foundIndex = (_currentList = currentList) === null || _currentList === void 0 ? void 0 : _currentList.findIndex(function (option) {
|
|
var val = option[fieldNames.value];
|
|
return stringMode ? String(val) === String(valueCell) : val === valueCell;
|
|
});
|
|
var foundOption = foundIndex !== -1 ? (_currentList2 = currentList) === null || _currentList2 === void 0 ? void 0 : _currentList2[foundIndex] : null;
|
|
valueOptions.push({
|
|
value: (_foundOption$fieldNam = foundOption === null || foundOption === void 0 ? void 0 : foundOption[fieldNames.value]) !== null && _foundOption$fieldNam !== void 0 ? _foundOption$fieldNam : valueCell,
|
|
index: foundIndex,
|
|
option: foundOption
|
|
});
|
|
currentList = foundOption === null || foundOption === void 0 ? void 0 : foundOption[fieldNames.children];
|
|
};
|
|
for (var i = 0; i < valueCells.length; i += 1) {
|
|
_loop();
|
|
}
|
|
return valueOptions;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/hooks/useDisplayValues.js
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var useDisplayValues = (function (rawValues, options, fieldNames, multiple, displayRender) {
|
|
return react.useMemo(function () {
|
|
var mergedDisplayRender = displayRender ||
|
|
// Default displayRender
|
|
function (labels) {
|
|
var mergedLabels = multiple ? labels.slice(-1) : labels;
|
|
var SPLIT = ' / ';
|
|
if (mergedLabels.every(function (label) {
|
|
return ['string', 'number'].includes((0,esm_typeof/* default */.Z)(label));
|
|
})) {
|
|
return mergedLabels.join(SPLIT);
|
|
}
|
|
|
|
// If exist non-string value, use ReactNode instead
|
|
return mergedLabels.reduce(function (list, label, index) {
|
|
var keyedLabel = /*#__PURE__*/react.isValidElement(label) ? /*#__PURE__*/react.cloneElement(label, {
|
|
key: index
|
|
}) : label;
|
|
if (index === 0) {
|
|
return [keyedLabel];
|
|
}
|
|
return [].concat((0,toConsumableArray/* default */.Z)(list), [SPLIT, keyedLabel]);
|
|
}, []);
|
|
};
|
|
return rawValues.map(function (valueCells) {
|
|
var _valueOptions, _valueOptions$option;
|
|
var valueOptions = toPathOptions(valueCells, options, fieldNames);
|
|
var label = mergedDisplayRender(valueOptions.map(function (_ref) {
|
|
var _option$fieldNames$la;
|
|
var option = _ref.option,
|
|
value = _ref.value;
|
|
return (_option$fieldNames$la = option === null || option === void 0 ? void 0 : option[fieldNames.label]) !== null && _option$fieldNames$la !== void 0 ? _option$fieldNames$la : value;
|
|
}), valueOptions.map(function (_ref2) {
|
|
var option = _ref2.option;
|
|
return option;
|
|
}));
|
|
var value = toPathKey(valueCells);
|
|
return {
|
|
label: label,
|
|
value: value,
|
|
key: value,
|
|
valueCells: valueCells,
|
|
disabled: (_valueOptions = valueOptions[valueOptions.length - 1]) === null || _valueOptions === void 0 ? void 0 : (_valueOptions$option = _valueOptions.option) === null || _valueOptions$option === void 0 ? void 0 : _valueOptions$option.disabled
|
|
};
|
|
});
|
|
}, [rawValues, options, fieldNames, displayRender, multiple]);
|
|
});
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/treeUtil.js
|
|
var treeUtil = __webpack_require__(1089);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/hooks/useEntities.js
|
|
|
|
|
|
|
|
|
|
/** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
|
|
/* harmony default export */ var useEntities = (function (options, fieldNames) {
|
|
var cacheRef = react.useRef({
|
|
options: null,
|
|
info: null
|
|
});
|
|
var getEntities = react.useCallback(function () {
|
|
if (cacheRef.current.options !== options) {
|
|
cacheRef.current.options = options;
|
|
cacheRef.current.info = (0,treeUtil/* convertDataToEntities */.I8)(options, {
|
|
fieldNames: fieldNames,
|
|
initWrapper: function initWrapper(wrapper) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, wrapper), {}, {
|
|
pathKeyEntities: {}
|
|
});
|
|
},
|
|
processEntity: function processEntity(entity, wrapper) {
|
|
var pathKey = entity.nodes.map(function (node) {
|
|
return node[fieldNames.value];
|
|
}).join(VALUE_SPLIT);
|
|
wrapper.pathKeyEntities[pathKey] = entity;
|
|
|
|
// Overwrite origin key.
|
|
// this is very hack but we need let conduct logic work with connect path
|
|
entity.key = pathKey;
|
|
}
|
|
});
|
|
}
|
|
return cacheRef.current.info.pathKeyEntities;
|
|
}, [fieldNames, options]);
|
|
return getEntities;
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/hooks/useMissingValues.js
|
|
|
|
|
|
/* harmony default export */ var useMissingValues = (function (options, fieldNames) {
|
|
return react.useCallback(function (rawValues) {
|
|
var missingValues = [];
|
|
var existsValues = [];
|
|
rawValues.forEach(function (valueCell) {
|
|
var pathOptions = toPathOptions(valueCell, options, fieldNames);
|
|
if (pathOptions.every(function (opt) {
|
|
return opt.option;
|
|
})) {
|
|
existsValues.push(valueCell);
|
|
} else {
|
|
missingValues.push(valueCell);
|
|
}
|
|
});
|
|
return [existsValues, missingValues];
|
|
}, [options, fieldNames]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/hooks/useRefFunc.js
|
|
|
|
|
|
/**
|
|
* Same as `React.useCallback` but always return a memoized function
|
|
* but redirect to real function.
|
|
*/
|
|
function useRefFunc_useRefFunc(callback) {
|
|
var funcRef = react.useRef();
|
|
funcRef.current = callback;
|
|
var cacheFn = react.useCallback(function () {
|
|
return funcRef.current.apply(funcRef, arguments);
|
|
}, []);
|
|
return cacheFn;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/hooks/useSearchConfig.js
|
|
|
|
|
|
|
|
|
|
// Convert `showSearch` to unique config
|
|
function useSearchConfig(showSearch) {
|
|
return react.useMemo(function () {
|
|
if (!showSearch) {
|
|
return [false, {}];
|
|
}
|
|
var searchConfig = {
|
|
matchInputWidth: true,
|
|
limit: 50
|
|
};
|
|
if (showSearch && (0,esm_typeof/* default */.Z)(showSearch) === 'object') {
|
|
searchConfig = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, searchConfig), showSearch);
|
|
}
|
|
if (searchConfig.limit <= 0) {
|
|
delete searchConfig.limit;
|
|
if (false) {}
|
|
}
|
|
return [true, searchConfig];
|
|
}, [showSearch]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/OptionList/CacheContent.js
|
|
|
|
var CacheContent = /*#__PURE__*/react.memo(function (_ref) {
|
|
var children = _ref.children;
|
|
return children;
|
|
}, function (_, next) {
|
|
return !next.open;
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var OptionList_CacheContent = (CacheContent);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/OptionList/Checkbox.js
|
|
|
|
|
|
|
|
|
|
function Checkbox(_ref) {
|
|
var _classNames;
|
|
var prefixCls = _ref.prefixCls,
|
|
checked = _ref.checked,
|
|
halfChecked = _ref.halfChecked,
|
|
disabled = _ref.disabled,
|
|
onClick = _ref.onClick,
|
|
disableCheckbox = _ref.disableCheckbox;
|
|
var _React$useContext = react.useContext(context),
|
|
checkable = _React$useContext.checkable;
|
|
var customCheckbox = typeof checkable !== 'boolean' ? checkable : null;
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()("".concat(prefixCls), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-checked"), checked), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-indeterminate"), !checked && halfChecked), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-disabled"), disabled || disableCheckbox), _classNames)),
|
|
onClick: onClick
|
|
}, customCheckbox);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/OptionList/Column.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var FIX_LABEL = '__cascader_fix_label__';
|
|
function Column(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
multiple = _ref.multiple,
|
|
options = _ref.options,
|
|
activeValue = _ref.activeValue,
|
|
prevValuePath = _ref.prevValuePath,
|
|
onToggleOpen = _ref.onToggleOpen,
|
|
onSelect = _ref.onSelect,
|
|
onActive = _ref.onActive,
|
|
checkedSet = _ref.checkedSet,
|
|
halfCheckedSet = _ref.halfCheckedSet,
|
|
loadingKeys = _ref.loadingKeys,
|
|
isSelectable = _ref.isSelectable,
|
|
searchValue = _ref.searchValue;
|
|
var menuPrefixCls = "".concat(prefixCls, "-menu");
|
|
var menuItemPrefixCls = "".concat(prefixCls, "-menu-item");
|
|
var _React$useContext = react.useContext(context),
|
|
fieldNames = _React$useContext.fieldNames,
|
|
changeOnSelect = _React$useContext.changeOnSelect,
|
|
expandTrigger = _React$useContext.expandTrigger,
|
|
expandIcon = _React$useContext.expandIcon,
|
|
loadingIcon = _React$useContext.loadingIcon,
|
|
dropdownMenuColumnStyle = _React$useContext.dropdownMenuColumnStyle;
|
|
var hoverOpen = expandTrigger === 'hover';
|
|
|
|
// ============================ Option ============================
|
|
var optionInfoList = react.useMemo(function () {
|
|
return options.map(function (option) {
|
|
var _option$FIX_LABEL;
|
|
var disabled = option.disabled,
|
|
disableCheckbox = option.disableCheckbox;
|
|
var searchOptions = option[SEARCH_MARK];
|
|
var label = (_option$FIX_LABEL = option[FIX_LABEL]) !== null && _option$FIX_LABEL !== void 0 ? _option$FIX_LABEL : option[fieldNames.label];
|
|
var value = option[fieldNames.value];
|
|
var isMergedLeaf = isLeaf(option, fieldNames);
|
|
|
|
// Get real value of option. Search option is different way.
|
|
var fullPath = searchOptions ? searchOptions.map(function (opt) {
|
|
return opt[fieldNames.value];
|
|
}) : [].concat((0,toConsumableArray/* default */.Z)(prevValuePath), [value]);
|
|
var fullPathKey = toPathKey(fullPath);
|
|
var isLoading = loadingKeys.includes(fullPathKey);
|
|
|
|
// >>>>> checked
|
|
var checked = checkedSet.has(fullPathKey);
|
|
|
|
// >>>>> halfChecked
|
|
var halfChecked = halfCheckedSet.has(fullPathKey);
|
|
return {
|
|
disabled: disabled,
|
|
label: label,
|
|
value: value,
|
|
isLeaf: isMergedLeaf,
|
|
isLoading: isLoading,
|
|
checked: checked,
|
|
halfChecked: halfChecked,
|
|
option: option,
|
|
disableCheckbox: disableCheckbox,
|
|
fullPath: fullPath,
|
|
fullPathKey: fullPathKey
|
|
};
|
|
});
|
|
}, [options, checkedSet, fieldNames, halfCheckedSet, loadingKeys, prevValuePath]);
|
|
|
|
// ============================ Render ============================
|
|
return /*#__PURE__*/react.createElement("ul", {
|
|
className: menuPrefixCls,
|
|
role: "menu"
|
|
}, optionInfoList.map(function (_ref2) {
|
|
var _classNames;
|
|
var disabled = _ref2.disabled,
|
|
label = _ref2.label,
|
|
value = _ref2.value,
|
|
isMergedLeaf = _ref2.isLeaf,
|
|
isLoading = _ref2.isLoading,
|
|
checked = _ref2.checked,
|
|
halfChecked = _ref2.halfChecked,
|
|
option = _ref2.option,
|
|
fullPath = _ref2.fullPath,
|
|
fullPathKey = _ref2.fullPathKey,
|
|
disableCheckbox = _ref2.disableCheckbox;
|
|
// >>>>> Open
|
|
var triggerOpenPath = function triggerOpenPath() {
|
|
if (disabled || searchValue) {
|
|
return;
|
|
}
|
|
var nextValueCells = (0,toConsumableArray/* default */.Z)(fullPath);
|
|
if (hoverOpen && isMergedLeaf) {
|
|
nextValueCells.pop();
|
|
}
|
|
onActive(nextValueCells);
|
|
};
|
|
|
|
// >>>>> Selection
|
|
var triggerSelect = function triggerSelect() {
|
|
if (isSelectable(option)) {
|
|
onSelect(fullPath, isMergedLeaf);
|
|
}
|
|
};
|
|
|
|
// >>>>> Title
|
|
var title;
|
|
if (typeof option.title === 'string') {
|
|
title = option.title;
|
|
} else if (typeof label === 'string') {
|
|
title = label;
|
|
}
|
|
|
|
// >>>>> Render
|
|
return /*#__PURE__*/react.createElement("li", {
|
|
key: fullPathKey,
|
|
className: classnames_default()(menuItemPrefixCls, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(menuItemPrefixCls, "-expand"), !isMergedLeaf), (0,defineProperty/* default */.Z)(_classNames, "".concat(menuItemPrefixCls, "-active"), activeValue === value || activeValue === fullPathKey), (0,defineProperty/* default */.Z)(_classNames, "".concat(menuItemPrefixCls, "-disabled"), disabled), (0,defineProperty/* default */.Z)(_classNames, "".concat(menuItemPrefixCls, "-loading"), isLoading), _classNames)),
|
|
style: dropdownMenuColumnStyle,
|
|
role: "menuitemcheckbox",
|
|
title: title,
|
|
"aria-checked": checked,
|
|
"data-path-key": fullPathKey,
|
|
onClick: function onClick() {
|
|
triggerOpenPath();
|
|
if (disableCheckbox) {
|
|
return;
|
|
}
|
|
if (!multiple || isMergedLeaf) {
|
|
triggerSelect();
|
|
}
|
|
},
|
|
onDoubleClick: function onDoubleClick() {
|
|
if (changeOnSelect) {
|
|
onToggleOpen(false);
|
|
}
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
if (hoverOpen) {
|
|
triggerOpenPath();
|
|
}
|
|
},
|
|
onMouseDown: function onMouseDown(e) {
|
|
// Prevent selector from blurring
|
|
e.preventDefault();
|
|
}
|
|
}, multiple && /*#__PURE__*/react.createElement(Checkbox, {
|
|
prefixCls: "".concat(prefixCls, "-checkbox"),
|
|
checked: checked,
|
|
halfChecked: halfChecked,
|
|
disabled: disabled || disableCheckbox,
|
|
disableCheckbox: disableCheckbox,
|
|
onClick: function onClick(e) {
|
|
if (disableCheckbox) {
|
|
return;
|
|
}
|
|
e.stopPropagation();
|
|
triggerSelect();
|
|
}
|
|
}), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(menuItemPrefixCls, "-content")
|
|
}, label), !isLoading && expandIcon && !isMergedLeaf && /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(menuItemPrefixCls, "-expand-icon")
|
|
}, expandIcon), isLoading && loadingIcon && /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(menuItemPrefixCls, "-loading-icon")
|
|
}, loadingIcon));
|
|
}));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/OptionList/useActive.js
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Control the active open options path.
|
|
*/
|
|
/* harmony default export */ var useActive = (function () {
|
|
var _useBaseProps = useBaseProps(),
|
|
multiple = _useBaseProps.multiple,
|
|
open = _useBaseProps.open;
|
|
var _React$useContext = react.useContext(context),
|
|
values = _React$useContext.values;
|
|
|
|
// Record current dropdown active options
|
|
// This also control the open status
|
|
var _React$useState = react.useState([]),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activeValueCells = _React$useState2[0],
|
|
setActiveValueCells = _React$useState2[1];
|
|
react.useEffect(function () {
|
|
if (open && !multiple) {
|
|
var firstValueCells = values[0];
|
|
setActiveValueCells(firstValueCells || []);
|
|
}
|
|
}, /* eslint-disable react-hooks/exhaustive-deps */
|
|
[open]
|
|
/* eslint-enable react-hooks/exhaustive-deps */);
|
|
|
|
return [activeValueCells, setActiveValueCells];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/OptionList/useKeyboard.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var useKeyboard = (function (ref, options, fieldNames, activeValueCells, setActiveValueCells, onKeyBoardSelect) {
|
|
var _useBaseProps = useBaseProps(),
|
|
direction = _useBaseProps.direction,
|
|
searchValue = _useBaseProps.searchValue,
|
|
toggleOpen = _useBaseProps.toggleOpen,
|
|
open = _useBaseProps.open;
|
|
var rtl = direction === 'rtl';
|
|
var _React$useMemo = react.useMemo(function () {
|
|
var activeIndex = -1;
|
|
var currentOptions = options;
|
|
var mergedActiveIndexes = [];
|
|
var mergedActiveValueCells = [];
|
|
var len = activeValueCells.length;
|
|
var pathKeys = getFullPathKeys(options, fieldNames);
|
|
|
|
// Fill validate active value cells and index
|
|
var _loop = function _loop(i) {
|
|
// Mark the active index for current options
|
|
var nextActiveIndex = currentOptions.findIndex(function (option, index) {
|
|
return (pathKeys[index] ? toPathKey(pathKeys[index]) : option[fieldNames.value]) === activeValueCells[i];
|
|
});
|
|
if (nextActiveIndex === -1) {
|
|
return "break";
|
|
}
|
|
activeIndex = nextActiveIndex;
|
|
mergedActiveIndexes.push(activeIndex);
|
|
mergedActiveValueCells.push(activeValueCells[i]);
|
|
currentOptions = currentOptions[activeIndex][fieldNames.children];
|
|
};
|
|
for (var i = 0; i < len && currentOptions; i += 1) {
|
|
var _ret = _loop(i);
|
|
if (_ret === "break") break;
|
|
}
|
|
|
|
// Fill last active options
|
|
var activeOptions = options;
|
|
for (var _i = 0; _i < mergedActiveIndexes.length - 1; _i += 1) {
|
|
activeOptions = activeOptions[mergedActiveIndexes[_i]][fieldNames.children];
|
|
}
|
|
return [mergedActiveValueCells, activeIndex, activeOptions, pathKeys];
|
|
}, [activeValueCells, fieldNames, options]),
|
|
_React$useMemo2 = (0,slicedToArray/* default */.Z)(_React$useMemo, 4),
|
|
validActiveValueCells = _React$useMemo2[0],
|
|
lastActiveIndex = _React$useMemo2[1],
|
|
lastActiveOptions = _React$useMemo2[2],
|
|
fullPathKeys = _React$useMemo2[3];
|
|
|
|
// Update active value cells and scroll to target element
|
|
var internalSetActiveValueCells = function internalSetActiveValueCells(next) {
|
|
setActiveValueCells(next);
|
|
};
|
|
|
|
// Same options offset
|
|
var offsetActiveOption = function offsetActiveOption(offset) {
|
|
var len = lastActiveOptions.length;
|
|
var currentIndex = lastActiveIndex;
|
|
if (currentIndex === -1 && offset < 0) {
|
|
currentIndex = len;
|
|
}
|
|
for (var i = 0; i < len; i += 1) {
|
|
currentIndex = (currentIndex + offset + len) % len;
|
|
var _option = lastActiveOptions[currentIndex];
|
|
if (_option && !_option.disabled) {
|
|
var nextActiveCells = validActiveValueCells.slice(0, -1).concat(fullPathKeys[currentIndex] ? toPathKey(fullPathKeys[currentIndex]) : _option[fieldNames.value]);
|
|
internalSetActiveValueCells(nextActiveCells);
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Different options offset
|
|
var prevColumn = function prevColumn() {
|
|
if (validActiveValueCells.length > 1) {
|
|
var nextActiveCells = validActiveValueCells.slice(0, -1);
|
|
internalSetActiveValueCells(nextActiveCells);
|
|
} else {
|
|
toggleOpen(false);
|
|
}
|
|
};
|
|
var nextColumn = function nextColumn() {
|
|
var _lastActiveOptions$la;
|
|
var nextOptions = ((_lastActiveOptions$la = lastActiveOptions[lastActiveIndex]) === null || _lastActiveOptions$la === void 0 ? void 0 : _lastActiveOptions$la[fieldNames.children]) || [];
|
|
var nextOption = nextOptions.find(function (option) {
|
|
return !option.disabled;
|
|
});
|
|
if (nextOption) {
|
|
var nextActiveCells = [].concat((0,toConsumableArray/* default */.Z)(validActiveValueCells), [nextOption[fieldNames.value]]);
|
|
internalSetActiveValueCells(nextActiveCells);
|
|
}
|
|
};
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
// scrollTo: treeRef.current?.scrollTo,
|
|
onKeyDown: function onKeyDown(event) {
|
|
var which = event.which;
|
|
switch (which) {
|
|
// >>> Arrow keys
|
|
case KeyCode/* default.UP */.Z.UP:
|
|
case KeyCode/* default.DOWN */.Z.DOWN:
|
|
{
|
|
var offset = 0;
|
|
if (which === KeyCode/* default.UP */.Z.UP) {
|
|
offset = -1;
|
|
} else if (which === KeyCode/* default.DOWN */.Z.DOWN) {
|
|
offset = 1;
|
|
}
|
|
if (offset !== 0) {
|
|
offsetActiveOption(offset);
|
|
}
|
|
break;
|
|
}
|
|
case KeyCode/* default.LEFT */.Z.LEFT:
|
|
{
|
|
if (searchValue) {
|
|
break;
|
|
}
|
|
if (rtl) {
|
|
nextColumn();
|
|
} else {
|
|
prevColumn();
|
|
}
|
|
break;
|
|
}
|
|
case KeyCode/* default.RIGHT */.Z.RIGHT:
|
|
{
|
|
if (searchValue) {
|
|
break;
|
|
}
|
|
if (rtl) {
|
|
prevColumn();
|
|
} else {
|
|
nextColumn();
|
|
}
|
|
break;
|
|
}
|
|
case KeyCode/* default.BACKSPACE */.Z.BACKSPACE:
|
|
{
|
|
if (!searchValue) {
|
|
prevColumn();
|
|
}
|
|
break;
|
|
}
|
|
|
|
// >>> Select
|
|
case KeyCode/* default.ENTER */.Z.ENTER:
|
|
{
|
|
if (validActiveValueCells.length) {
|
|
var _option2 = lastActiveOptions[lastActiveIndex];
|
|
|
|
// Search option should revert back of origin options
|
|
var originOptions = (_option2 === null || _option2 === void 0 ? void 0 : _option2[SEARCH_MARK]) || [];
|
|
if (originOptions.length) {
|
|
onKeyBoardSelect(originOptions.map(function (opt) {
|
|
return opt[fieldNames.value];
|
|
}), originOptions[originOptions.length - 1]);
|
|
} else {
|
|
onKeyBoardSelect(validActiveValueCells, lastActiveOptions[lastActiveIndex]);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// >>> Close
|
|
case KeyCode/* default.ESC */.Z.ESC:
|
|
{
|
|
toggleOpen(false);
|
|
if (open) {
|
|
event.stopPropagation();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
onKeyUp: function onKeyUp() {}
|
|
};
|
|
});
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/OptionList/index.js
|
|
|
|
|
|
|
|
|
|
|
|
/* eslint-disable default-case */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var OptionList_RefOptionList = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _optionColumns$, _optionColumns$$optio, _ref3, _classNames;
|
|
var _useBaseProps = useBaseProps(),
|
|
prefixCls = _useBaseProps.prefixCls,
|
|
multiple = _useBaseProps.multiple,
|
|
searchValue = _useBaseProps.searchValue,
|
|
toggleOpen = _useBaseProps.toggleOpen,
|
|
notFoundContent = _useBaseProps.notFoundContent,
|
|
direction = _useBaseProps.direction,
|
|
open = _useBaseProps.open;
|
|
var containerRef = react.useRef();
|
|
var rtl = direction === 'rtl';
|
|
var _React$useContext = react.useContext(context),
|
|
options = _React$useContext.options,
|
|
values = _React$useContext.values,
|
|
halfValues = _React$useContext.halfValues,
|
|
fieldNames = _React$useContext.fieldNames,
|
|
changeOnSelect = _React$useContext.changeOnSelect,
|
|
onSelect = _React$useContext.onSelect,
|
|
searchOptions = _React$useContext.searchOptions,
|
|
dropdownPrefixCls = _React$useContext.dropdownPrefixCls,
|
|
loadData = _React$useContext.loadData,
|
|
expandTrigger = _React$useContext.expandTrigger;
|
|
var mergedPrefixCls = dropdownPrefixCls || prefixCls;
|
|
|
|
// ========================= loadData =========================
|
|
var _React$useState = react.useState([]),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
loadingKeys = _React$useState2[0],
|
|
setLoadingKeys = _React$useState2[1];
|
|
var internalLoadData = function internalLoadData(valueCells) {
|
|
// Do not load when search
|
|
if (!loadData || searchValue) {
|
|
return;
|
|
}
|
|
var optionList = toPathOptions(valueCells, options, fieldNames);
|
|
var rawOptions = optionList.map(function (_ref) {
|
|
var option = _ref.option;
|
|
return option;
|
|
});
|
|
var lastOption = rawOptions[rawOptions.length - 1];
|
|
if (lastOption && !isLeaf(lastOption, fieldNames)) {
|
|
var pathKey = toPathKey(valueCells);
|
|
setLoadingKeys(function (keys) {
|
|
return [].concat((0,toConsumableArray/* default */.Z)(keys), [pathKey]);
|
|
});
|
|
loadData(rawOptions);
|
|
}
|
|
};
|
|
|
|
// zombieJ: This is bad. We should make this same as `rc-tree` to use Promise instead.
|
|
react.useEffect(function () {
|
|
if (loadingKeys.length) {
|
|
loadingKeys.forEach(function (loadingKey) {
|
|
var valueStrCells = toPathValueStr(loadingKey);
|
|
var optionList = toPathOptions(valueStrCells, options, fieldNames, true).map(function (_ref2) {
|
|
var option = _ref2.option;
|
|
return option;
|
|
});
|
|
var lastOption = optionList[optionList.length - 1];
|
|
if (!lastOption || lastOption[fieldNames.children] || isLeaf(lastOption, fieldNames)) {
|
|
setLoadingKeys(function (keys) {
|
|
return keys.filter(function (key) {
|
|
return key !== loadingKey;
|
|
});
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, [options, loadingKeys, fieldNames]);
|
|
|
|
// ========================== Values ==========================
|
|
var checkedSet = react.useMemo(function () {
|
|
return new Set(toPathKeys(values));
|
|
}, [values]);
|
|
var halfCheckedSet = react.useMemo(function () {
|
|
return new Set(toPathKeys(halfValues));
|
|
}, [halfValues]);
|
|
|
|
// ====================== Accessibility =======================
|
|
var _useActive = useActive(),
|
|
_useActive2 = (0,slicedToArray/* default */.Z)(_useActive, 2),
|
|
activeValueCells = _useActive2[0],
|
|
setActiveValueCells = _useActive2[1];
|
|
|
|
// =========================== Path ===========================
|
|
var onPathOpen = function onPathOpen(nextValueCells) {
|
|
setActiveValueCells(nextValueCells);
|
|
|
|
// Trigger loadData
|
|
internalLoadData(nextValueCells);
|
|
};
|
|
var isSelectable = function isSelectable(option) {
|
|
var disabled = option.disabled;
|
|
var isMergedLeaf = isLeaf(option, fieldNames);
|
|
return !disabled && (isMergedLeaf || changeOnSelect || multiple);
|
|
};
|
|
var onPathSelect = function onPathSelect(valuePath, leaf) {
|
|
var fromKeyboard = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
onSelect(valuePath);
|
|
if (!multiple && (leaf || changeOnSelect && (expandTrigger === 'hover' || fromKeyboard))) {
|
|
toggleOpen(false);
|
|
}
|
|
};
|
|
|
|
// ========================== Option ==========================
|
|
var mergedOptions = react.useMemo(function () {
|
|
if (searchValue) {
|
|
return searchOptions;
|
|
}
|
|
return options;
|
|
}, [searchValue, searchOptions, options]);
|
|
|
|
// ========================== Column ==========================
|
|
var optionColumns = react.useMemo(function () {
|
|
var optionList = [{
|
|
options: mergedOptions
|
|
}];
|
|
var currentList = mergedOptions;
|
|
var fullPathKeys = getFullPathKeys(currentList, fieldNames);
|
|
var _loop = function _loop() {
|
|
var activeValueCell = activeValueCells[i];
|
|
var currentOption = currentList.find(function (option, index) {
|
|
return (fullPathKeys[index] ? toPathKey(fullPathKeys[index]) : option[fieldNames.value]) === activeValueCell;
|
|
});
|
|
var subOptions = currentOption === null || currentOption === void 0 ? void 0 : currentOption[fieldNames.children];
|
|
if (!(subOptions !== null && subOptions !== void 0 && subOptions.length)) {
|
|
return "break";
|
|
}
|
|
currentList = subOptions;
|
|
optionList.push({
|
|
options: subOptions
|
|
});
|
|
};
|
|
for (var i = 0; i < activeValueCells.length; i += 1) {
|
|
var _ret = _loop();
|
|
if (_ret === "break") break;
|
|
}
|
|
return optionList;
|
|
}, [mergedOptions, activeValueCells, fieldNames]);
|
|
|
|
// ========================= Keyboard =========================
|
|
var onKeyboardSelect = function onKeyboardSelect(selectValueCells, option) {
|
|
if (isSelectable(option)) {
|
|
onPathSelect(selectValueCells, isLeaf(option, fieldNames), true);
|
|
}
|
|
};
|
|
useKeyboard(ref, mergedOptions, fieldNames, activeValueCells, onPathOpen, onKeyboardSelect);
|
|
|
|
// >>>>> Active Scroll
|
|
react.useEffect(function () {
|
|
for (var i = 0; i < activeValueCells.length; i += 1) {
|
|
var _containerRef$current;
|
|
var cellPath = activeValueCells.slice(0, i + 1);
|
|
var cellKeyPath = toPathKey(cellPath);
|
|
var ele = (_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : _containerRef$current.querySelector("li[data-path-key=\"".concat(cellKeyPath.replace(/\\{0,2}"/g, '\\"'), "\"]") // matches unescaped double quotes
|
|
);
|
|
if (ele) {
|
|
scrollIntoParentView(ele);
|
|
}
|
|
}
|
|
}, [activeValueCells]);
|
|
|
|
// ========================== Render ==========================
|
|
// >>>>> Empty
|
|
var isEmpty = !((_optionColumns$ = optionColumns[0]) !== null && _optionColumns$ !== void 0 && (_optionColumns$$optio = _optionColumns$.options) !== null && _optionColumns$$optio !== void 0 && _optionColumns$$optio.length);
|
|
var emptyList = [(_ref3 = {}, (0,defineProperty/* default */.Z)(_ref3, fieldNames.value, '__EMPTY__'), (0,defineProperty/* default */.Z)(_ref3, FIX_LABEL, notFoundContent), (0,defineProperty/* default */.Z)(_ref3, "disabled", true), _ref3)];
|
|
var columnProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
multiple: !isEmpty && multiple,
|
|
onSelect: onPathSelect,
|
|
onActive: onPathOpen,
|
|
onToggleOpen: toggleOpen,
|
|
checkedSet: checkedSet,
|
|
halfCheckedSet: halfCheckedSet,
|
|
loadingKeys: loadingKeys,
|
|
isSelectable: isSelectable
|
|
});
|
|
|
|
// >>>>> Columns
|
|
var mergedOptionColumns = isEmpty ? [{
|
|
options: emptyList
|
|
}] : optionColumns;
|
|
var columnNodes = mergedOptionColumns.map(function (col, index) {
|
|
var prevValuePath = activeValueCells.slice(0, index);
|
|
var activeValue = activeValueCells[index];
|
|
return /*#__PURE__*/react.createElement(Column, (0,esm_extends/* default */.Z)({
|
|
key: index
|
|
}, columnProps, {
|
|
searchValue: searchValue,
|
|
prefixCls: mergedPrefixCls,
|
|
options: col.options,
|
|
prevValuePath: prevValuePath,
|
|
activeValue: activeValue
|
|
}));
|
|
});
|
|
|
|
// >>>>> Render
|
|
return /*#__PURE__*/react.createElement(OptionList_CacheContent, {
|
|
open: open
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()("".concat(mergedPrefixCls, "-menus"), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(mergedPrefixCls, "-menu-empty"), isEmpty), (0,defineProperty/* default */.Z)(_classNames, "".concat(mergedPrefixCls, "-rtl"), rtl), _classNames)),
|
|
ref: containerRef
|
|
}, columnNodes));
|
|
});
|
|
/* harmony default export */ var rc_cascader_es_OptionList = (OptionList_RefOptionList);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/utils/warningPropsUtil.js
|
|
|
|
function warningPropsUtil_warningProps(props) {
|
|
var onPopupVisibleChange = props.onPopupVisibleChange,
|
|
popupVisible = props.popupVisible,
|
|
popupClassName = props.popupClassName,
|
|
popupPlacement = props.popupPlacement;
|
|
warning(!onPopupVisibleChange, '`onPopupVisibleChange` is deprecated. Please use `onDropdownVisibleChange` instead.');
|
|
warning(popupVisible === undefined, '`popupVisible` is deprecated. Please use `open` instead.');
|
|
warning(popupClassName === undefined, '`popupClassName` is deprecated. Please use `dropdownClassName` instead.');
|
|
warning(popupPlacement === undefined, '`popupPlacement` is deprecated. Please use `placement` instead.');
|
|
}
|
|
|
|
// value in Cascader options should not be null
|
|
function warningPropsUtil_warningNullOptions(options, fieldNames) {
|
|
if (options) {
|
|
var recursiveOptions = function recursiveOptions(optionsList) {
|
|
for (var i = 0; i < optionsList.length; i++) {
|
|
var option = optionsList[i];
|
|
if (option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.value] === null) {
|
|
warning(false, '`value` in Cascader options should not be `null`.');
|
|
return true;
|
|
}
|
|
if (Array.isArray(option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.children]) && recursiveOptions(option[fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.children])) {
|
|
return true;
|
|
}
|
|
}
|
|
};
|
|
recursiveOptions(options);
|
|
}
|
|
}
|
|
/* harmony default export */ var utils_warningPropsUtil = ((/* unused pure expression or super */ null && (warningPropsUtil_warningProps)));
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/Cascader.js
|
|
|
|
|
|
|
|
|
|
var Cascader_excluded = ["id", "prefixCls", "fieldNames", "defaultValue", "value", "changeOnSelect", "onChange", "displayRender", "checkable", "searchValue", "onSearch", "showSearch", "expandTrigger", "options", "dropdownPrefixCls", "loadData", "popupVisible", "open", "popupClassName", "dropdownClassName", "dropdownMenuColumnStyle", "popupPlacement", "placement", "onDropdownVisibleChange", "onPopupVisibleChange", "expandIcon", "loadingIcon", "children", "dropdownMatchSelectWidth", "showCheckedStrategy"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function isMultipleValue(value) {
|
|
return Array.isArray(value) && Array.isArray(value[0]);
|
|
}
|
|
function toRawValues(value) {
|
|
if (!value) {
|
|
return [];
|
|
}
|
|
if (isMultipleValue(value)) {
|
|
return value;
|
|
}
|
|
return (value.length === 0 ? [] : [value]).map(function (val) {
|
|
return Array.isArray(val) ? val : [val];
|
|
});
|
|
}
|
|
var Cascader = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var id = props.id,
|
|
_props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-cascader' : _props$prefixCls,
|
|
fieldNames = props.fieldNames,
|
|
defaultValue = props.defaultValue,
|
|
value = props.value,
|
|
changeOnSelect = props.changeOnSelect,
|
|
onChange = props.onChange,
|
|
displayRender = props.displayRender,
|
|
checkable = props.checkable,
|
|
searchValue = props.searchValue,
|
|
onSearch = props.onSearch,
|
|
showSearch = props.showSearch,
|
|
expandTrigger = props.expandTrigger,
|
|
options = props.options,
|
|
dropdownPrefixCls = props.dropdownPrefixCls,
|
|
loadData = props.loadData,
|
|
popupVisible = props.popupVisible,
|
|
open = props.open,
|
|
popupClassName = props.popupClassName,
|
|
dropdownClassName = props.dropdownClassName,
|
|
dropdownMenuColumnStyle = props.dropdownMenuColumnStyle,
|
|
popupPlacement = props.popupPlacement,
|
|
placement = props.placement,
|
|
onDropdownVisibleChange = props.onDropdownVisibleChange,
|
|
onPopupVisibleChange = props.onPopupVisibleChange,
|
|
_props$expandIcon = props.expandIcon,
|
|
expandIcon = _props$expandIcon === void 0 ? '>' : _props$expandIcon,
|
|
loadingIcon = props.loadingIcon,
|
|
children = props.children,
|
|
_props$dropdownMatchS = props.dropdownMatchSelectWidth,
|
|
dropdownMatchSelectWidth = _props$dropdownMatchS === void 0 ? false : _props$dropdownMatchS,
|
|
_props$showCheckedStr = props.showCheckedStrategy,
|
|
showCheckedStrategy = _props$showCheckedStr === void 0 ? SHOW_PARENT : _props$showCheckedStr,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, Cascader_excluded);
|
|
var mergedId = useId(id);
|
|
var multiple = !!checkable;
|
|
|
|
// =========================== Values ===========================
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(defaultValue, {
|
|
value: value,
|
|
postState: toRawValues
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
rawValues = _useMergedState2[0],
|
|
setRawValues = _useMergedState2[1];
|
|
|
|
// ========================= FieldNames =========================
|
|
var mergedFieldNames = react.useMemo(function () {
|
|
return commonUtil_fillFieldNames(fieldNames);
|
|
}, /* eslint-disable react-hooks/exhaustive-deps */
|
|
[JSON.stringify(fieldNames)]
|
|
/* eslint-enable react-hooks/exhaustive-deps */);
|
|
|
|
// =========================== Option ===========================
|
|
var mergedOptions = react.useMemo(function () {
|
|
return options || [];
|
|
}, [options]);
|
|
|
|
// Only used in multiple mode, this fn will not call in single mode
|
|
var getPathKeyEntities = useEntities(mergedOptions, mergedFieldNames);
|
|
|
|
/** Convert path key back to value format */
|
|
var getValueByKeyPath = react.useCallback(function (pathKeys) {
|
|
var keyPathEntities = getPathKeyEntities();
|
|
return pathKeys.map(function (pathKey) {
|
|
var nodes = keyPathEntities[pathKey].nodes;
|
|
return nodes.map(function (node) {
|
|
return node[mergedFieldNames.value];
|
|
});
|
|
});
|
|
}, [getPathKeyEntities, mergedFieldNames]);
|
|
|
|
// =========================== Search ===========================
|
|
var _useMergedState3 = (0,useMergedState/* default */.Z)('', {
|
|
value: searchValue,
|
|
postState: function postState(search) {
|
|
return search || '';
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
mergedSearchValue = _useMergedState4[0],
|
|
setSearchValue = _useMergedState4[1];
|
|
var onInternalSearch = function onInternalSearch(searchText, info) {
|
|
setSearchValue(searchText);
|
|
if (info.source !== 'blur' && onSearch) {
|
|
onSearch(searchText);
|
|
}
|
|
};
|
|
var _useSearchConfig = useSearchConfig(showSearch),
|
|
_useSearchConfig2 = (0,slicedToArray/* default */.Z)(_useSearchConfig, 2),
|
|
mergedShowSearch = _useSearchConfig2[0],
|
|
searchConfig = _useSearchConfig2[1];
|
|
var searchOptions = useSearchOptions(mergedSearchValue, mergedOptions, mergedFieldNames, dropdownPrefixCls || prefixCls, searchConfig, changeOnSelect);
|
|
|
|
// =========================== Values ===========================
|
|
var getMissingValues = useMissingValues(mergedOptions, mergedFieldNames);
|
|
|
|
// Fill `rawValues` with checked conduction values
|
|
var _React$useMemo = react.useMemo(function () {
|
|
var _getMissingValues = getMissingValues(rawValues),
|
|
_getMissingValues2 = (0,slicedToArray/* default */.Z)(_getMissingValues, 2),
|
|
existValues = _getMissingValues2[0],
|
|
missingValues = _getMissingValues2[1];
|
|
if (!multiple || !rawValues.length) {
|
|
return [existValues, [], missingValues];
|
|
}
|
|
var keyPathValues = toPathKeys(existValues);
|
|
var keyPathEntities = getPathKeyEntities();
|
|
var _conductCheck = (0,conductUtil/* conductCheck */.S)(keyPathValues, true, keyPathEntities),
|
|
checkedKeys = _conductCheck.checkedKeys,
|
|
halfCheckedKeys = _conductCheck.halfCheckedKeys;
|
|
|
|
// Convert key back to value cells
|
|
return [getValueByKeyPath(checkedKeys), getValueByKeyPath(halfCheckedKeys), missingValues];
|
|
}, [multiple, rawValues, getPathKeyEntities, getValueByKeyPath, getMissingValues]),
|
|
_React$useMemo2 = (0,slicedToArray/* default */.Z)(_React$useMemo, 3),
|
|
checkedValues = _React$useMemo2[0],
|
|
halfCheckedValues = _React$useMemo2[1],
|
|
missingCheckedValues = _React$useMemo2[2];
|
|
var deDuplicatedValues = react.useMemo(function () {
|
|
var checkedKeys = toPathKeys(checkedValues);
|
|
var deduplicateKeys = formatStrategyValues(checkedKeys, getPathKeyEntities, showCheckedStrategy);
|
|
return [].concat((0,toConsumableArray/* default */.Z)(missingCheckedValues), (0,toConsumableArray/* default */.Z)(getValueByKeyPath(deduplicateKeys)));
|
|
}, [checkedValues, getPathKeyEntities, getValueByKeyPath, missingCheckedValues, showCheckedStrategy]);
|
|
var displayValues = useDisplayValues(deDuplicatedValues, mergedOptions, mergedFieldNames, multiple, displayRender);
|
|
|
|
// =========================== Change ===========================
|
|
var triggerChange = useRefFunc_useRefFunc(function (nextValues) {
|
|
setRawValues(nextValues);
|
|
|
|
// Save perf if no need trigger event
|
|
if (onChange) {
|
|
var nextRawValues = toRawValues(nextValues);
|
|
var valueOptions = nextRawValues.map(function (valueCells) {
|
|
return toPathOptions(valueCells, mergedOptions, mergedFieldNames).map(function (valueOpt) {
|
|
return valueOpt.option;
|
|
});
|
|
});
|
|
var triggerValues = multiple ? nextRawValues : nextRawValues[0];
|
|
var triggerOptions = multiple ? valueOptions : valueOptions[0];
|
|
onChange(triggerValues, triggerOptions);
|
|
}
|
|
});
|
|
|
|
// =========================== Select ===========================
|
|
var onInternalSelect = useRefFunc_useRefFunc(function (valuePath) {
|
|
setSearchValue('');
|
|
if (!multiple) {
|
|
triggerChange(valuePath);
|
|
} else {
|
|
// Prepare conduct required info
|
|
var pathKey = toPathKey(valuePath);
|
|
var checkedPathKeys = toPathKeys(checkedValues);
|
|
var halfCheckedPathKeys = toPathKeys(halfCheckedValues);
|
|
var existInChecked = checkedPathKeys.includes(pathKey);
|
|
var existInMissing = missingCheckedValues.some(function (valueCells) {
|
|
return toPathKey(valueCells) === pathKey;
|
|
});
|
|
|
|
// Do update
|
|
var nextCheckedValues = checkedValues;
|
|
var nextMissingValues = missingCheckedValues;
|
|
if (existInMissing && !existInChecked) {
|
|
// Missing value only do filter
|
|
nextMissingValues = missingCheckedValues.filter(function (valueCells) {
|
|
return toPathKey(valueCells) !== pathKey;
|
|
});
|
|
} else {
|
|
// Update checked key first
|
|
var nextRawCheckedKeys = existInChecked ? checkedPathKeys.filter(function (key) {
|
|
return key !== pathKey;
|
|
}) : [].concat((0,toConsumableArray/* default */.Z)(checkedPathKeys), [pathKey]);
|
|
var pathKeyEntities = getPathKeyEntities();
|
|
|
|
// Conduction by selected or not
|
|
var checkedKeys;
|
|
if (existInChecked) {
|
|
var _conductCheck2 = (0,conductUtil/* conductCheck */.S)(nextRawCheckedKeys, {
|
|
checked: false,
|
|
halfCheckedKeys: halfCheckedPathKeys
|
|
}, pathKeyEntities);
|
|
checkedKeys = _conductCheck2.checkedKeys;
|
|
} else {
|
|
var _conductCheck3 = (0,conductUtil/* conductCheck */.S)(nextRawCheckedKeys, true, pathKeyEntities);
|
|
checkedKeys = _conductCheck3.checkedKeys;
|
|
}
|
|
|
|
// Roll up to parent level keys
|
|
var deDuplicatedKeys = formatStrategyValues(checkedKeys, getPathKeyEntities, showCheckedStrategy);
|
|
nextCheckedValues = getValueByKeyPath(deDuplicatedKeys);
|
|
}
|
|
triggerChange([].concat((0,toConsumableArray/* default */.Z)(nextMissingValues), (0,toConsumableArray/* default */.Z)(nextCheckedValues)));
|
|
}
|
|
});
|
|
|
|
// Display Value change logic
|
|
var onDisplayValuesChange = function onDisplayValuesChange(_, info) {
|
|
if (info.type === 'clear') {
|
|
triggerChange([]);
|
|
return;
|
|
}
|
|
|
|
// Cascader do not support `add` type. Only support `remove`
|
|
var _ref = info.values[0],
|
|
valueCells = _ref.valueCells;
|
|
onInternalSelect(valueCells);
|
|
};
|
|
|
|
// ============================ Open ============================
|
|
var mergedOpen = open !== undefined ? open : popupVisible;
|
|
var mergedDropdownClassName = dropdownClassName || popupClassName;
|
|
var mergedPlacement = placement || popupPlacement;
|
|
var onInternalDropdownVisibleChange = function onInternalDropdownVisibleChange(nextVisible) {
|
|
onDropdownVisibleChange === null || onDropdownVisibleChange === void 0 ? void 0 : onDropdownVisibleChange(nextVisible);
|
|
onPopupVisibleChange === null || onPopupVisibleChange === void 0 ? void 0 : onPopupVisibleChange(nextVisible);
|
|
};
|
|
|
|
// ========================== Warning ===========================
|
|
if (false) {}
|
|
|
|
// ========================== Context ===========================
|
|
var cascaderContext = react.useMemo(function () {
|
|
return {
|
|
options: mergedOptions,
|
|
fieldNames: mergedFieldNames,
|
|
values: checkedValues,
|
|
halfValues: halfCheckedValues,
|
|
changeOnSelect: changeOnSelect,
|
|
onSelect: onInternalSelect,
|
|
checkable: checkable,
|
|
searchOptions: searchOptions,
|
|
dropdownPrefixCls: dropdownPrefixCls,
|
|
loadData: loadData,
|
|
expandTrigger: expandTrigger,
|
|
expandIcon: expandIcon,
|
|
loadingIcon: loadingIcon,
|
|
dropdownMenuColumnStyle: dropdownMenuColumnStyle
|
|
};
|
|
}, [mergedOptions, mergedFieldNames, checkedValues, halfCheckedValues, changeOnSelect, onInternalSelect, checkable, searchOptions, dropdownPrefixCls, loadData, expandTrigger, expandIcon, loadingIcon, dropdownMenuColumnStyle]);
|
|
|
|
// ==============================================================
|
|
// == Render ==
|
|
// ==============================================================
|
|
var emptyOptions = !(mergedSearchValue ? searchOptions : mergedOptions).length;
|
|
var dropdownStyle =
|
|
// Search to match width
|
|
mergedSearchValue && searchConfig.matchInputWidth ||
|
|
// Empty keep the width
|
|
emptyOptions ? {} : {
|
|
minWidth: 'auto'
|
|
};
|
|
return /*#__PURE__*/react.createElement(context.Provider, {
|
|
value: cascaderContext
|
|
}, /*#__PURE__*/react.createElement(es_BaseSelect, (0,esm_extends/* default */.Z)({}, restProps, {
|
|
// MISC
|
|
ref: ref,
|
|
id: mergedId,
|
|
prefixCls: prefixCls,
|
|
dropdownMatchSelectWidth: dropdownMatchSelectWidth,
|
|
dropdownStyle: dropdownStyle
|
|
// Value
|
|
,
|
|
displayValues: displayValues,
|
|
onDisplayValuesChange: onDisplayValuesChange,
|
|
mode: multiple ? 'multiple' : undefined
|
|
// Search
|
|
,
|
|
searchValue: mergedSearchValue,
|
|
onSearch: onInternalSearch,
|
|
showSearch: mergedShowSearch
|
|
// Options
|
|
,
|
|
OptionList: rc_cascader_es_OptionList,
|
|
emptyOptions: emptyOptions
|
|
// Open
|
|
,
|
|
open: mergedOpen,
|
|
dropdownClassName: mergedDropdownClassName,
|
|
placement: mergedPlacement,
|
|
onDropdownVisibleChange: onInternalDropdownVisibleChange
|
|
// Children
|
|
,
|
|
getRawInputElement: function getRawInputElement() {
|
|
return children;
|
|
}
|
|
})));
|
|
});
|
|
if (false) {}
|
|
Cascader.SHOW_PARENT = SHOW_PARENT;
|
|
Cascader.SHOW_CHILD = SHOW_CHILD;
|
|
/* harmony default export */ var es_Cascader = (Cascader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-cascader/es/index.js
|
|
|
|
/* harmony default export */ var rc_cascader_es = (es_Cascader);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/rc-util/es/omit.js
|
|
var es_omit = __webpack_require__(10366);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/PurePanel.js
|
|
var PurePanel = __webpack_require__(8745);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/motion.js
|
|
var motion = __webpack_require__(33603);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/statusUtils.js
|
|
var statusUtils = __webpack_require__(9708);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/context.js
|
|
var config_provider_context = __webpack_require__(53124);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/DisabledContext.js
|
|
var DisabledContext = __webpack_require__(98866);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/defaultRenderEmpty.js
|
|
var defaultRenderEmpty = __webpack_require__(88258);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/hooks/useSize.js
|
|
var useSize = __webpack_require__(98675);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/form/context.js
|
|
var form_context = __webpack_require__(65223);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/select/style/index.js + 3 modules
|
|
var select_style = __webpack_require__(87244);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/select/useBuiltinPlacements.js
|
|
var useBuiltinPlacements = __webpack_require__(13458);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/select/useShowArrow.js
|
|
var useShowArrow = __webpack_require__(78642);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/select/utils/iconUtil.js
|
|
var iconUtil = __webpack_require__(46163);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/space/Compact.js
|
|
var Compact = __webpack_require__(4173);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/checkbox/style/index.js
|
|
var style = __webpack_require__(63185);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/index.js
|
|
var es_style = __webpack_require__(14747);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/compact-item.js
|
|
var compact_item = __webpack_require__(80110);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/theme/util/genComponentStyleHook.js
|
|
var genComponentStyleHook = __webpack_require__(67968);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/cascader/style/index.js
|
|
|
|
|
|
|
|
|
|
// =============================== Base ===============================
|
|
const genBaseStyle = token => {
|
|
const {
|
|
prefixCls,
|
|
componentCls,
|
|
antCls
|
|
} = token;
|
|
const cascaderMenuItemCls = `${componentCls}-menu-item`;
|
|
const iconCls = `
|
|
&${cascaderMenuItemCls}-expand ${cascaderMenuItemCls}-expand-icon,
|
|
${cascaderMenuItemCls}-loading-icon
|
|
`;
|
|
const itemPaddingVertical = Math.round((token.controlHeight - token.fontSize * token.lineHeight) / 2);
|
|
return [
|
|
// =====================================================
|
|
// == Control ==
|
|
// =====================================================
|
|
{
|
|
[componentCls]: {
|
|
width: token.controlWidth
|
|
}
|
|
},
|
|
// =====================================================
|
|
// == Popup ==
|
|
// =====================================================
|
|
{
|
|
[`${componentCls}-dropdown`]: [
|
|
// ==================== Checkbox ====================
|
|
(0,style/* getStyle */.C2)(`${prefixCls}-checkbox`, token), {
|
|
[`&${antCls}-select-dropdown`]: {
|
|
padding: 0
|
|
}
|
|
}, {
|
|
[componentCls]: {
|
|
// ================== Checkbox ==================
|
|
'&-checkbox': {
|
|
top: 0,
|
|
marginInlineEnd: token.paddingXS
|
|
},
|
|
// ==================== Menu ====================
|
|
// >>> Menus
|
|
'&-menus': {
|
|
display: 'flex',
|
|
flexWrap: 'nowrap',
|
|
alignItems: 'flex-start',
|
|
[`&${componentCls}-menu-empty`]: {
|
|
[`${componentCls}-menu`]: {
|
|
width: '100%',
|
|
height: 'auto',
|
|
[cascaderMenuItemCls]: {
|
|
color: token.colorTextDisabled
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// >>> Menu
|
|
'&-menu': {
|
|
flexGrow: 1,
|
|
minWidth: token.controlItemWidth,
|
|
height: token.dropdownHeight,
|
|
margin: 0,
|
|
padding: token.paddingXXS,
|
|
overflow: 'auto',
|
|
verticalAlign: 'top',
|
|
listStyle: 'none',
|
|
'-ms-overflow-style': '-ms-autohiding-scrollbar',
|
|
'&:not(:last-child)': {
|
|
borderInlineEnd: `${token.lineWidth}px ${token.lineType} ${token.colorSplit}`
|
|
},
|
|
'&-item': Object.assign(Object.assign({}, es_style/* textEllipsis */.vS), {
|
|
display: 'flex',
|
|
flexWrap: 'nowrap',
|
|
alignItems: 'center',
|
|
padding: `${itemPaddingVertical}px ${token.paddingSM}px`,
|
|
lineHeight: token.lineHeight,
|
|
cursor: 'pointer',
|
|
transition: `all ${token.motionDurationMid}`,
|
|
borderRadius: token.borderRadiusSM,
|
|
'&:hover': {
|
|
background: token.controlItemBgHover
|
|
},
|
|
'&-disabled': {
|
|
color: token.colorTextDisabled,
|
|
cursor: 'not-allowed',
|
|
'&:hover': {
|
|
background: 'transparent'
|
|
},
|
|
[iconCls]: {
|
|
color: token.colorTextDisabled
|
|
}
|
|
},
|
|
[`&-active:not(${cascaderMenuItemCls}-disabled)`]: {
|
|
[`&, &:hover`]: {
|
|
fontWeight: token.fontWeightStrong,
|
|
backgroundColor: token.controlItemBgActive
|
|
}
|
|
},
|
|
'&-content': {
|
|
flex: 'auto'
|
|
},
|
|
[iconCls]: {
|
|
marginInlineStart: token.paddingXXS,
|
|
color: token.colorTextDescription,
|
|
fontSize: token.fontSizeIcon
|
|
},
|
|
'&-keyword': {
|
|
color: token.colorHighlight
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}]
|
|
},
|
|
// =====================================================
|
|
// == RTL ==
|
|
// =====================================================
|
|
{
|
|
[`${componentCls}-dropdown-rtl`]: {
|
|
direction: 'rtl'
|
|
}
|
|
},
|
|
// =====================================================
|
|
// == Space Compact ==
|
|
// =====================================================
|
|
(0,compact_item/* genCompactItemStyle */.c)(token)];
|
|
};
|
|
// ============================== Export ==============================
|
|
/* harmony default export */ var cascader_style = ((0,genComponentStyleHook/* default */.Z)('Cascader', token => [genBaseStyle(token)], {
|
|
controlWidth: 184,
|
|
controlItemWidth: 111,
|
|
dropdownHeight: 180
|
|
}));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/cascader/index.js
|
|
'use client';
|
|
|
|
|
|
var __rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const {
|
|
SHOW_CHILD: cascader_SHOW_CHILD,
|
|
SHOW_PARENT: cascader_SHOW_PARENT
|
|
} = rc_cascader_es;
|
|
function highlightKeyword(str, lowerKeyword, prefixCls) {
|
|
const cells = str.toLowerCase().split(lowerKeyword).reduce((list, cur, index) => index === 0 ? [cur] : [].concat((0,toConsumableArray/* default */.Z)(list), [lowerKeyword, cur]), []);
|
|
const fillCells = [];
|
|
let start = 0;
|
|
cells.forEach((cell, index) => {
|
|
const end = start + cell.length;
|
|
let originWorld = str.slice(start, end);
|
|
start = end;
|
|
if (index % 2 === 1) {
|
|
originWorld =
|
|
/*#__PURE__*/
|
|
// eslint-disable-next-line react/no-array-index-key
|
|
react.createElement("span", {
|
|
className: `${prefixCls}-menu-item-keyword`,
|
|
key: `separator-${index}`
|
|
}, originWorld);
|
|
}
|
|
fillCells.push(originWorld);
|
|
});
|
|
return fillCells;
|
|
}
|
|
const defaultSearchRender = (inputValue, path, prefixCls, fieldNames) => {
|
|
const optionList = [];
|
|
// We do lower here to save perf
|
|
const lower = inputValue.toLowerCase();
|
|
path.forEach((node, index) => {
|
|
if (index !== 0) {
|
|
optionList.push(' / ');
|
|
}
|
|
let label = node[fieldNames.label];
|
|
const type = typeof label;
|
|
if (type === 'string' || type === 'number') {
|
|
label = highlightKeyword(String(label), lower, prefixCls);
|
|
}
|
|
optionList.push(label);
|
|
});
|
|
return optionList;
|
|
};
|
|
const cascader_Cascader = /*#__PURE__*/react.forwardRef((props, ref) => {
|
|
const {
|
|
prefixCls: customizePrefixCls,
|
|
size: customizeSize,
|
|
disabled: customDisabled,
|
|
className,
|
|
rootClassName,
|
|
multiple,
|
|
bordered = true,
|
|
transitionName,
|
|
choiceTransitionName = '',
|
|
popupClassName,
|
|
dropdownClassName,
|
|
expandIcon,
|
|
placement,
|
|
showSearch,
|
|
allowClear = true,
|
|
notFoundContent,
|
|
direction,
|
|
getPopupContainer,
|
|
status: customStatus,
|
|
showArrow,
|
|
builtinPlacements,
|
|
style
|
|
} = props,
|
|
rest = __rest(props, ["prefixCls", "size", "disabled", "className", "rootClassName", "multiple", "bordered", "transitionName", "choiceTransitionName", "popupClassName", "dropdownClassName", "expandIcon", "placement", "showSearch", "allowClear", "notFoundContent", "direction", "getPopupContainer", "status", "showArrow", "builtinPlacements", "style"]);
|
|
const restProps = (0,es_omit/* default */.Z)(rest, ['suffixIcon']);
|
|
const {
|
|
getPopupContainer: getContextPopupContainer,
|
|
getPrefixCls,
|
|
renderEmpty,
|
|
direction: rootDirection,
|
|
popupOverflow,
|
|
cascader
|
|
} = react.useContext(config_provider_context/* ConfigContext */.E_);
|
|
const mergedDirection = direction || rootDirection;
|
|
const isRtl = mergedDirection === 'rtl';
|
|
// =================== Form =====================
|
|
const {
|
|
status: contextStatus,
|
|
hasFeedback,
|
|
isFormItemInput,
|
|
feedbackIcon
|
|
} = react.useContext(form_context/* FormItemInputContext */.aM);
|
|
const mergedStatus = (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus);
|
|
// =================== Warning =====================
|
|
if (false) {}
|
|
// =================== No Found ====================
|
|
const mergedNotFoundContent = notFoundContent || (renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Cascader')) || /*#__PURE__*/react.createElement(defaultRenderEmpty/* default */.Z, {
|
|
componentName: "Cascader"
|
|
});
|
|
// ==================== Prefix =====================
|
|
const rootPrefixCls = getPrefixCls();
|
|
const prefixCls = getPrefixCls('select', customizePrefixCls);
|
|
const cascaderPrefixCls = getPrefixCls('cascader', customizePrefixCls);
|
|
const [wrapSelectSSR, hashId] = (0,select_style/* default */.Z)(prefixCls);
|
|
const [wrapCascaderSSR] = cascader_style(cascaderPrefixCls);
|
|
const {
|
|
compactSize,
|
|
compactItemClassnames
|
|
} = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction);
|
|
// =================== Dropdown ====================
|
|
const mergedDropdownClassName = classnames_default()(popupClassName || dropdownClassName, `${cascaderPrefixCls}-dropdown`, {
|
|
[`${cascaderPrefixCls}-dropdown-rtl`]: mergedDirection === 'rtl'
|
|
}, rootClassName, hashId);
|
|
// ==================== Search =====================
|
|
const mergedShowSearch = react.useMemo(() => {
|
|
if (!showSearch) {
|
|
return showSearch;
|
|
}
|
|
let searchConfig = {
|
|
render: defaultSearchRender
|
|
};
|
|
if (typeof showSearch === 'object') {
|
|
searchConfig = Object.assign(Object.assign({}, searchConfig), showSearch);
|
|
}
|
|
return searchConfig;
|
|
}, [showSearch]);
|
|
// ===================== Size ======================
|
|
const mergedSize = (0,useSize/* default */.Z)(ctx => {
|
|
var _a;
|
|
return (_a = customizeSize !== null && customizeSize !== void 0 ? customizeSize : compactSize) !== null && _a !== void 0 ? _a : ctx;
|
|
});
|
|
// ===================== Disabled =====================
|
|
const disabled = react.useContext(DisabledContext/* default */.Z);
|
|
const mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
// ===================== Icon ======================
|
|
let mergedExpandIcon = expandIcon;
|
|
if (!expandIcon) {
|
|
mergedExpandIcon = isRtl ? /*#__PURE__*/react.createElement(LeftOutlined/* default */.Z, null) : /*#__PURE__*/react.createElement(RightOutlined/* default */.Z, null);
|
|
}
|
|
const loadingIcon = /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-menu-item-loading-icon`
|
|
}, /*#__PURE__*/react.createElement(LoadingOutlined/* default */.Z, {
|
|
spin: true
|
|
}));
|
|
// =================== Multiple ====================
|
|
const checkable = react.useMemo(() => multiple ? /*#__PURE__*/react.createElement("span", {
|
|
className: `${cascaderPrefixCls}-checkbox-inner`
|
|
}) : false, [multiple]);
|
|
// ===================== Icons =====================
|
|
const mergedShowArrow = (0,useShowArrow/* default */.Z)(showArrow);
|
|
const {
|
|
suffixIcon,
|
|
removeIcon,
|
|
clearIcon
|
|
} = (0,iconUtil/* default */.Z)(Object.assign(Object.assign({}, props), {
|
|
hasFeedback,
|
|
feedbackIcon,
|
|
showArrow: mergedShowArrow,
|
|
multiple,
|
|
prefixCls
|
|
}));
|
|
// ===================== Placement =====================
|
|
const memoPlacement = react.useMemo(() => {
|
|
if (placement !== undefined) {
|
|
return placement;
|
|
}
|
|
return isRtl ? 'bottomRight' : 'bottomLeft';
|
|
}, [placement, isRtl]);
|
|
const mergedBuiltinPlacements = (0,useBuiltinPlacements/* default */.Z)(builtinPlacements, popupOverflow);
|
|
// ==================== Render =====================
|
|
const renderNode = /*#__PURE__*/react.createElement(rc_cascader_es, Object.assign({
|
|
prefixCls: prefixCls,
|
|
className: classnames_default()(!customizePrefixCls && cascaderPrefixCls, {
|
|
[`${prefixCls}-lg`]: mergedSize === 'large',
|
|
[`${prefixCls}-sm`]: mergedSize === 'small',
|
|
[`${prefixCls}-rtl`]: isRtl,
|
|
[`${prefixCls}-borderless`]: !bordered,
|
|
[`${prefixCls}-in-form-item`]: isFormItemInput
|
|
}, (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, mergedStatus, hasFeedback), compactItemClassnames, cascader === null || cascader === void 0 ? void 0 : cascader.className, className, rootClassName, hashId),
|
|
disabled: mergedDisabled,
|
|
style: Object.assign(Object.assign({}, cascader === null || cascader === void 0 ? void 0 : cascader.style), style)
|
|
}, restProps, {
|
|
builtinPlacements: mergedBuiltinPlacements,
|
|
direction: mergedDirection,
|
|
placement: memoPlacement,
|
|
notFoundContent: mergedNotFoundContent,
|
|
allowClear: allowClear,
|
|
showSearch: mergedShowSearch,
|
|
expandIcon: mergedExpandIcon,
|
|
inputIcon: suffixIcon,
|
|
removeIcon: removeIcon,
|
|
clearIcon: clearIcon,
|
|
loadingIcon: loadingIcon,
|
|
checkable: checkable,
|
|
dropdownClassName: mergedDropdownClassName,
|
|
dropdownPrefixCls: customizePrefixCls || cascaderPrefixCls,
|
|
choiceTransitionName: (0,motion/* getTransitionName */.mL)(rootPrefixCls, '', choiceTransitionName),
|
|
transitionName: (0,motion/* getTransitionName */.mL)(rootPrefixCls, (0,motion/* getTransitionDirection */.q0)(placement), transitionName),
|
|
getPopupContainer: getPopupContainer || getContextPopupContainer,
|
|
ref: ref,
|
|
showArrow: hasFeedback || mergedShowArrow
|
|
}));
|
|
return wrapCascaderSSR(wrapSelectSSR(renderNode));
|
|
});
|
|
if (false) {}
|
|
// We don't care debug panel
|
|
/* istanbul ignore next */
|
|
const cascader_PurePanel = (0,PurePanel/* default */.Z)(cascader_Cascader);
|
|
cascader_Cascader.SHOW_PARENT = cascader_SHOW_PARENT;
|
|
cascader_Cascader.SHOW_CHILD = cascader_SHOW_CHILD;
|
|
cascader_Cascader._InternalPanelDoNotUseOrYouWillBeFired = cascader_PurePanel;
|
|
/* harmony default export */ var cascader = (cascader_Cascader);
|
|
|
|
/***/ })
|
|
|
|
}]); |