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.
1576 lines
60 KiB
1576 lines
60 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[98228],{
|
|
|
|
/***/ 98228:
|
|
/*!****************************************************************************!*\
|
|
!*** ./node_modules/_antd@5.9.0@antd/es/tree-select/index.js + 17 modules ***!
|
|
\****************************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
Z: function() { return /* binding */ tree_select; }
|
|
});
|
|
|
|
// UNUSED EXPORTS: TreeNode
|
|
|
|
// EXTERNAL MODULE: ./node_modules/_classnames@2.5.1@classnames/index.js
|
|
var _classnames_2_5_1_classnames = __webpack_require__(92310);
|
|
var _classnames_2_5_1_classnames_default = /*#__PURE__*/__webpack_require__.n(_classnames_2_5_1_classnames);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(14809);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(95190);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(20439);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(50298);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(62646);
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(93664);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-select@14.8.1@rc-select/es/index.js + 28 modules
|
|
var es = __webpack_require__(77861);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-select@14.8.1@rc-select/es/hooks/useId.js
|
|
var useId = __webpack_require__(17115);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-tree@5.7.12@rc-tree/es/utils/conductUtil.js
|
|
var conductUtil = __webpack_require__(90782);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/hooks/useMergedState.js
|
|
var useMergedState = __webpack_require__(18929);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/warning.js
|
|
var es_warning = __webpack_require__(48736);
|
|
// EXTERNAL MODULE: ./node_modules/_react@17.0.2@react/index.js
|
|
var _react_17_0_2_react = __webpack_require__(59301);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/hooks/useCache.js
|
|
|
|
|
|
/**
|
|
* This function will try to call requestIdleCallback if available to save performance.
|
|
* No need `getLabel` here since already fetch on `rawLabeledValue`.
|
|
*/
|
|
/* harmony default export */ var useCache = (function (values) {
|
|
var cacheRef = _react_17_0_2_react.useRef({
|
|
valueLabels: new Map()
|
|
});
|
|
return _react_17_0_2_react.useMemo(function () {
|
|
var valueLabels = cacheRef.current.valueLabels;
|
|
var valueLabelsCache = new Map();
|
|
var filledValues = values.map(function (item) {
|
|
var _item$label;
|
|
var value = item.value;
|
|
var mergedLabel = (_item$label = item.label) !== null && _item$label !== void 0 ? _item$label : valueLabels.get(value);
|
|
|
|
// Save in cache
|
|
valueLabelsCache.set(value, mergedLabel);
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, item), {}, {
|
|
label: mergedLabel
|
|
});
|
|
});
|
|
cacheRef.current.valueLabels = valueLabelsCache;
|
|
return [filledValues];
|
|
}, [values]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/hooks/useCheckedKeys.js
|
|
|
|
|
|
|
|
/* harmony default export */ var useCheckedKeys = (function (rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities) {
|
|
return _react_17_0_2_react.useMemo(function () {
|
|
var checkedKeys = rawLabeledValues.map(function (_ref) {
|
|
var value = _ref.value;
|
|
return value;
|
|
});
|
|
var halfCheckedKeys = rawHalfCheckedValues.map(function (_ref2) {
|
|
var value = _ref2.value;
|
|
return value;
|
|
});
|
|
var missingValues = checkedKeys.filter(function (key) {
|
|
return !keyEntities[key];
|
|
});
|
|
if (treeConduction) {
|
|
var _conductCheck = (0,conductUtil/* conductCheck */.S)(checkedKeys, true, keyEntities);
|
|
checkedKeys = _conductCheck.checkedKeys;
|
|
halfCheckedKeys = _conductCheck.halfCheckedKeys;
|
|
}
|
|
return [
|
|
// Checked keys should fill with missing keys which should de-duplicated
|
|
Array.from(new Set([].concat((0,toConsumableArray/* default */.Z)(missingValues), (0,toConsumableArray/* default */.Z)(checkedKeys)))),
|
|
// Half checked keys
|
|
halfCheckedKeys];
|
|
}, [rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities]);
|
|
});
|
|
// EXTERNAL MODULE: ./node_modules/_rc-tree@5.7.12@rc-tree/es/utils/treeUtil.js
|
|
var treeUtil = __webpack_require__(71430);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/hooks/useDataEntities.js
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var useDataEntities = (function (treeData, fieldNames) {
|
|
return _react_17_0_2_react.useMemo(function () {
|
|
var collection = (0,treeUtil/* convertDataToEntities */.I8)(treeData, {
|
|
fieldNames: fieldNames,
|
|
initWrapper: function initWrapper(wrapper) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, wrapper), {}, {
|
|
valueEntities: new Map()
|
|
});
|
|
},
|
|
processEntity: function processEntity(entity, wrapper) {
|
|
var val = entity.node[fieldNames.value];
|
|
|
|
// Check if exist same value
|
|
if (false) { var key; }
|
|
wrapper.valueEntities.set(val, entity);
|
|
}
|
|
});
|
|
return collection;
|
|
}, [treeData, fieldNames]);
|
|
});
|
|
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.27.6@@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4635);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/Children/toArray.js
|
|
var Children_toArray = __webpack_require__(11592);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/TreeNode.js
|
|
/* istanbul ignore file */
|
|
|
|
/** This is a placeholder, not real render in dom */
|
|
var TreeNode = function TreeNode() {
|
|
return null;
|
|
};
|
|
/* harmony default export */ var es_TreeNode = (TreeNode);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/utils/legacyUtil.js
|
|
|
|
|
|
var _excluded = ["children", "value"];
|
|
|
|
|
|
|
|
|
|
function convertChildrenToData(nodes) {
|
|
return (0,Children_toArray/* default */.Z)(nodes).map(function (node) {
|
|
if (! /*#__PURE__*/_react_17_0_2_react.isValidElement(node) || !node.type) {
|
|
return null;
|
|
}
|
|
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, _excluded);
|
|
var data = (0,objectSpread2/* default */.Z)({
|
|
key: key,
|
|
value: value
|
|
}, restProps);
|
|
var childData = convertChildrenToData(children);
|
|
if (childData.length) {
|
|
data.children = childData;
|
|
}
|
|
return data;
|
|
}).filter(function (data) {
|
|
return data;
|
|
});
|
|
}
|
|
function fillLegacyProps(dataNode) {
|
|
if (!dataNode) {
|
|
return dataNode;
|
|
}
|
|
var cloneNode = (0,objectSpread2/* default */.Z)({}, dataNode);
|
|
if (!('props' in cloneNode)) {
|
|
Object.defineProperty(cloneNode, 'props', {
|
|
get: function get() {
|
|
(0,es_warning/* default */.ZP)(false, 'New `rc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
|
|
return cloneNode;
|
|
}
|
|
});
|
|
}
|
|
return cloneNode;
|
|
}
|
|
function fillAdditionalInfo(extra, triggerValue, checkedValues, treeData, showPosition, fieldNames) {
|
|
var triggerNode = null;
|
|
var nodeList = null;
|
|
function generateMap() {
|
|
function dig(list) {
|
|
var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0';
|
|
var parentIncluded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
return list.map(function (option, index) {
|
|
var pos = "".concat(level, "-").concat(index);
|
|
var value = option[fieldNames.value];
|
|
var included = checkedValues.includes(value);
|
|
var children = dig(option[fieldNames.children] || [], pos, included);
|
|
var node = /*#__PURE__*/_react_17_0_2_react.createElement(es_TreeNode, option, children.map(function (child) {
|
|
return child.node;
|
|
}));
|
|
|
|
// Link with trigger node
|
|
if (triggerValue === value) {
|
|
triggerNode = node;
|
|
}
|
|
if (included) {
|
|
var checkedNode = {
|
|
pos: pos,
|
|
node: node,
|
|
children: children
|
|
};
|
|
if (!parentIncluded) {
|
|
nodeList.push(checkedNode);
|
|
}
|
|
return checkedNode;
|
|
}
|
|
return null;
|
|
}).filter(function (node) {
|
|
return node;
|
|
});
|
|
}
|
|
if (!nodeList) {
|
|
nodeList = [];
|
|
dig(treeData);
|
|
|
|
// Sort to keep the checked node length
|
|
nodeList.sort(function (_ref2, _ref3) {
|
|
var val1 = _ref2.node.props.value;
|
|
var val2 = _ref3.node.props.value;
|
|
var index1 = checkedValues.indexOf(val1);
|
|
var index2 = checkedValues.indexOf(val2);
|
|
return index1 - index2;
|
|
});
|
|
}
|
|
}
|
|
Object.defineProperty(extra, 'triggerNode', {
|
|
get: function get() {
|
|
(0,es_warning/* default */.ZP)(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
|
|
generateMap();
|
|
return triggerNode;
|
|
}
|
|
});
|
|
Object.defineProperty(extra, 'allCheckedNodes', {
|
|
get: function get() {
|
|
(0,es_warning/* default */.ZP)(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
|
|
generateMap();
|
|
if (showPosition) {
|
|
return nodeList;
|
|
}
|
|
return nodeList.map(function (_ref4) {
|
|
var node = _ref4.node;
|
|
return node;
|
|
});
|
|
}
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/hooks/useFilterTreeData.js
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var useFilterTreeData = (function (treeData, searchValue, _ref) {
|
|
var treeNodeFilterProp = _ref.treeNodeFilterProp,
|
|
filterTreeNode = _ref.filterTreeNode,
|
|
fieldNames = _ref.fieldNames;
|
|
var fieldChildren = fieldNames.children;
|
|
return _react_17_0_2_react.useMemo(function () {
|
|
if (!searchValue || filterTreeNode === false) {
|
|
return treeData;
|
|
}
|
|
var filterOptionFunc;
|
|
if (typeof filterTreeNode === 'function') {
|
|
filterOptionFunc = filterTreeNode;
|
|
} else {
|
|
var upperStr = searchValue.toUpperCase();
|
|
filterOptionFunc = function filterOptionFunc(_, dataNode) {
|
|
var value = dataNode[treeNodeFilterProp];
|
|
return String(value).toUpperCase().includes(upperStr);
|
|
};
|
|
}
|
|
function dig(list) {
|
|
var keepAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
return list.reduce(function (total, dataNode) {
|
|
var children = dataNode[fieldChildren];
|
|
var match = keepAll || filterOptionFunc(searchValue, fillLegacyProps(dataNode));
|
|
var childList = dig(children || [], match);
|
|
if (match || childList.length) {
|
|
total.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, dataNode), {}, (0,defineProperty/* default */.Z)({
|
|
isLeaf: undefined
|
|
}, fieldChildren, childList)));
|
|
}
|
|
return total;
|
|
}, []);
|
|
}
|
|
return dig(treeData);
|
|
}, [treeData, searchValue, fieldChildren, treeNodeFilterProp, filterTreeNode]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-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_17_0_2_react.useRef();
|
|
funcRef.current = callback;
|
|
var cacheFn = _react_17_0_2_react.useCallback(function () {
|
|
return funcRef.current.apply(funcRef, arguments);
|
|
}, []);
|
|
return cacheFn;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/hooks/useTreeData.js
|
|
|
|
|
|
|
|
function parseSimpleTreeData(treeData, _ref) {
|
|
var id = _ref.id,
|
|
pId = _ref.pId,
|
|
rootPId = _ref.rootPId;
|
|
var keyNodes = {};
|
|
var rootNodeList = [];
|
|
|
|
// Fill in the map
|
|
var nodeList = treeData.map(function (node) {
|
|
var clone = (0,objectSpread2/* default */.Z)({}, node);
|
|
var key = clone[id];
|
|
keyNodes[key] = clone;
|
|
clone.key = clone.key || key;
|
|
return clone;
|
|
});
|
|
|
|
// Connect tree
|
|
nodeList.forEach(function (node) {
|
|
var parentKey = node[pId];
|
|
var parent = keyNodes[parentKey];
|
|
|
|
// Fill parent
|
|
if (parent) {
|
|
parent.children = parent.children || [];
|
|
parent.children.push(node);
|
|
}
|
|
|
|
// Fill root tree node
|
|
if (parentKey === rootPId || !parent && rootPId === null) {
|
|
rootNodeList.push(node);
|
|
}
|
|
});
|
|
return rootNodeList;
|
|
}
|
|
|
|
/**
|
|
* Convert `treeData` or `children` into formatted `treeData`.
|
|
* Will not re-calculate if `treeData` or `children` not change.
|
|
*/
|
|
function useTreeData(treeData, children, simpleMode) {
|
|
return _react_17_0_2_react.useMemo(function () {
|
|
if (treeData) {
|
|
return simpleMode ? parseSimpleTreeData(treeData, (0,objectSpread2/* default */.Z)({
|
|
id: 'id',
|
|
pId: 'pId',
|
|
rootPId: null
|
|
}, simpleMode !== true ? simpleMode : {})) : treeData;
|
|
}
|
|
return convertChildrenToData(children);
|
|
}, [children, simpleMode, treeData]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/LegacyContext.js
|
|
|
|
var LegacySelectContext = /*#__PURE__*/_react_17_0_2_react.createContext(null);
|
|
/* harmony default export */ var LegacyContext = (LegacySelectContext);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/KeyCode.js
|
|
var KeyCode = __webpack_require__(10228);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/hooks/useMemo.js
|
|
var useMemo = __webpack_require__(80547);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-tree@5.7.12@rc-tree/es/index.js + 7 modules
|
|
var _rc_tree_5_7_12_rc_tree_es = __webpack_require__(79556);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/TreeSelectContext.js
|
|
|
|
var TreeSelectContext = /*#__PURE__*/_react_17_0_2_react.createContext(null);
|
|
/* harmony default export */ var es_TreeSelectContext = (TreeSelectContext);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/utils/valueUtil.js
|
|
function valueUtil_toArray(value) {
|
|
if (Array.isArray(value)) {
|
|
return value;
|
|
}
|
|
return value !== undefined ? [value] : [];
|
|
}
|
|
function fillFieldNames(fieldNames) {
|
|
var _ref = fieldNames || {},
|
|
label = _ref.label,
|
|
value = _ref.value,
|
|
children = _ref.children;
|
|
var mergedValue = value || 'value';
|
|
return {
|
|
_title: label ? [label] : ['title', 'label'],
|
|
value: mergedValue,
|
|
key: mergedValue,
|
|
children: children || 'children'
|
|
};
|
|
}
|
|
function isCheckDisabled(node) {
|
|
return !node || node.disabled || node.disableCheckbox || node.checkable === false;
|
|
}
|
|
|
|
/** Loop fetch all the keys exist in the tree */
|
|
function getAllKeys(treeData, fieldNames) {
|
|
var keys = [];
|
|
function dig(list) {
|
|
list.forEach(function (item) {
|
|
var children = item[fieldNames.children];
|
|
if (children) {
|
|
keys.push(item[fieldNames.value]);
|
|
dig(children);
|
|
}
|
|
});
|
|
}
|
|
dig(treeData);
|
|
return keys;
|
|
}
|
|
function isNil(val) {
|
|
return val === null || val === undefined;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/OptionList.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var HIDDEN_STYLE = {
|
|
width: 0,
|
|
height: 0,
|
|
display: 'flex',
|
|
overflow: 'hidden',
|
|
opacity: 0,
|
|
border: 0,
|
|
padding: 0,
|
|
margin: 0
|
|
};
|
|
var OptionList = function OptionList(_, ref) {
|
|
var _useBaseProps = (0,es/* useBaseProps */.lk)(),
|
|
prefixCls = _useBaseProps.prefixCls,
|
|
multiple = _useBaseProps.multiple,
|
|
searchValue = _useBaseProps.searchValue,
|
|
toggleOpen = _useBaseProps.toggleOpen,
|
|
open = _useBaseProps.open,
|
|
notFoundContent = _useBaseProps.notFoundContent;
|
|
var _React$useContext = _react_17_0_2_react.useContext(es_TreeSelectContext),
|
|
virtual = _React$useContext.virtual,
|
|
listHeight = _React$useContext.listHeight,
|
|
listItemHeight = _React$useContext.listItemHeight,
|
|
treeData = _React$useContext.treeData,
|
|
fieldNames = _React$useContext.fieldNames,
|
|
onSelect = _React$useContext.onSelect,
|
|
dropdownMatchSelectWidth = _React$useContext.dropdownMatchSelectWidth,
|
|
treeExpandAction = _React$useContext.treeExpandAction;
|
|
var _React$useContext2 = _react_17_0_2_react.useContext(LegacyContext),
|
|
checkable = _React$useContext2.checkable,
|
|
checkedKeys = _React$useContext2.checkedKeys,
|
|
halfCheckedKeys = _React$useContext2.halfCheckedKeys,
|
|
treeExpandedKeys = _React$useContext2.treeExpandedKeys,
|
|
treeDefaultExpandAll = _React$useContext2.treeDefaultExpandAll,
|
|
treeDefaultExpandedKeys = _React$useContext2.treeDefaultExpandedKeys,
|
|
onTreeExpand = _React$useContext2.onTreeExpand,
|
|
treeIcon = _React$useContext2.treeIcon,
|
|
showTreeIcon = _React$useContext2.showTreeIcon,
|
|
switcherIcon = _React$useContext2.switcherIcon,
|
|
treeLine = _React$useContext2.treeLine,
|
|
treeNodeFilterProp = _React$useContext2.treeNodeFilterProp,
|
|
loadData = _React$useContext2.loadData,
|
|
treeLoadedKeys = _React$useContext2.treeLoadedKeys,
|
|
treeMotion = _React$useContext2.treeMotion,
|
|
onTreeLoad = _React$useContext2.onTreeLoad,
|
|
keyEntities = _React$useContext2.keyEntities;
|
|
var treeRef = _react_17_0_2_react.useRef();
|
|
var memoTreeData = (0,useMemo/* default */.Z)(function () {
|
|
return treeData;
|
|
}, [open, treeData], function (prev, next) {
|
|
return next[0] && prev[1] !== next[1];
|
|
});
|
|
|
|
// ========================== Active ==========================
|
|
var _React$useState = _react_17_0_2_react.useState(null),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activeKey = _React$useState2[0],
|
|
setActiveKey = _React$useState2[1];
|
|
var activeEntity = keyEntities[activeKey];
|
|
|
|
// ========================== Values ==========================
|
|
var mergedCheckedKeys = _react_17_0_2_react.useMemo(function () {
|
|
if (!checkable) {
|
|
return null;
|
|
}
|
|
return {
|
|
checked: checkedKeys,
|
|
halfChecked: halfCheckedKeys
|
|
};
|
|
}, [checkable, checkedKeys, halfCheckedKeys]);
|
|
|
|
// ========================== Scroll ==========================
|
|
_react_17_0_2_react.useEffect(function () {
|
|
// Single mode should scroll to current key
|
|
if (open && !multiple && checkedKeys.length) {
|
|
var _treeRef$current;
|
|
(_treeRef$current = treeRef.current) === null || _treeRef$current === void 0 ? void 0 : _treeRef$current.scrollTo({
|
|
key: checkedKeys[0]
|
|
});
|
|
setActiveKey(checkedKeys[0]);
|
|
}
|
|
}, [open]);
|
|
|
|
// ========================== Search ==========================
|
|
var lowerSearchValue = String(searchValue).toLowerCase();
|
|
var filterTreeNode = function filterTreeNode(treeNode) {
|
|
if (!lowerSearchValue) {
|
|
return false;
|
|
}
|
|
return String(treeNode[treeNodeFilterProp]).toLowerCase().includes(lowerSearchValue);
|
|
};
|
|
|
|
// =========================== Keys ===========================
|
|
var _React$useState3 = _react_17_0_2_react.useState(treeDefaultExpandedKeys),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
expandedKeys = _React$useState4[0],
|
|
setExpandedKeys = _React$useState4[1];
|
|
var _React$useState5 = _react_17_0_2_react.useState(null),
|
|
_React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2),
|
|
searchExpandedKeys = _React$useState6[0],
|
|
setSearchExpandedKeys = _React$useState6[1];
|
|
var mergedExpandedKeys = _react_17_0_2_react.useMemo(function () {
|
|
if (treeExpandedKeys) {
|
|
return (0,toConsumableArray/* default */.Z)(treeExpandedKeys);
|
|
}
|
|
return searchValue ? searchExpandedKeys : expandedKeys;
|
|
}, [expandedKeys, searchExpandedKeys, treeExpandedKeys, searchValue]);
|
|
_react_17_0_2_react.useEffect(function () {
|
|
if (searchValue) {
|
|
setSearchExpandedKeys(getAllKeys(treeData, fieldNames));
|
|
}
|
|
}, [searchValue]);
|
|
var onInternalExpand = function onInternalExpand(keys) {
|
|
setExpandedKeys(keys);
|
|
setSearchExpandedKeys(keys);
|
|
if (onTreeExpand) {
|
|
onTreeExpand(keys);
|
|
}
|
|
};
|
|
|
|
// ========================== Events ==========================
|
|
var onListMouseDown = function onListMouseDown(event) {
|
|
event.preventDefault();
|
|
};
|
|
var onInternalSelect = function onInternalSelect(__, info) {
|
|
var node = info.node;
|
|
if (checkable && isCheckDisabled(node)) {
|
|
return;
|
|
}
|
|
onSelect(node.key, {
|
|
selected: !checkedKeys.includes(node.key)
|
|
});
|
|
if (!multiple) {
|
|
toggleOpen(false);
|
|
}
|
|
};
|
|
|
|
// ========================= Keyboard =========================
|
|
_react_17_0_2_react.useImperativeHandle(ref, function () {
|
|
var _treeRef$current2;
|
|
return {
|
|
scrollTo: (_treeRef$current2 = treeRef.current) === null || _treeRef$current2 === void 0 ? void 0 : _treeRef$current2.scrollTo,
|
|
onKeyDown: function onKeyDown(event) {
|
|
var _treeRef$current3;
|
|
var which = event.which;
|
|
switch (which) {
|
|
// >>> Arrow keys
|
|
case KeyCode/* default */.Z.UP:
|
|
case KeyCode/* default */.Z.DOWN:
|
|
case KeyCode/* default */.Z.LEFT:
|
|
case KeyCode/* default */.Z.RIGHT:
|
|
(_treeRef$current3 = treeRef.current) === null || _treeRef$current3 === void 0 ? void 0 : _treeRef$current3.onKeyDown(event);
|
|
break;
|
|
|
|
// >>> Select item
|
|
case KeyCode/* default */.Z.ENTER:
|
|
{
|
|
if (activeEntity) {
|
|
var _ref = (activeEntity === null || activeEntity === void 0 ? void 0 : activeEntity.node) || {},
|
|
selectable = _ref.selectable,
|
|
value = _ref.value;
|
|
if (selectable !== false) {
|
|
onInternalSelect(null, {
|
|
node: {
|
|
key: activeKey
|
|
},
|
|
selected: !checkedKeys.includes(value)
|
|
});
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// >>> Close
|
|
case KeyCode/* default */.Z.ESC:
|
|
{
|
|
toggleOpen(false);
|
|
}
|
|
}
|
|
},
|
|
onKeyUp: function onKeyUp() {}
|
|
};
|
|
});
|
|
|
|
// ========================== Render ==========================
|
|
if (memoTreeData.length === 0) {
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
role: "listbox",
|
|
className: "".concat(prefixCls, "-empty"),
|
|
onMouseDown: onListMouseDown
|
|
}, notFoundContent);
|
|
}
|
|
var treeProps = {
|
|
fieldNames: fieldNames
|
|
};
|
|
if (treeLoadedKeys) {
|
|
treeProps.loadedKeys = treeLoadedKeys;
|
|
}
|
|
if (mergedExpandedKeys) {
|
|
treeProps.expandedKeys = mergedExpandedKeys;
|
|
}
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement("div", {
|
|
onMouseDown: onListMouseDown
|
|
}, activeEntity && open && /*#__PURE__*/_react_17_0_2_react.createElement("span", {
|
|
style: HIDDEN_STYLE,
|
|
"aria-live": "assertive"
|
|
}, activeEntity.node.value), /*#__PURE__*/_react_17_0_2_react.createElement(_rc_tree_5_7_12_rc_tree_es/* default */.Z, (0,esm_extends/* default */.Z)({
|
|
ref: treeRef,
|
|
focusable: false,
|
|
prefixCls: "".concat(prefixCls, "-tree"),
|
|
treeData: memoTreeData,
|
|
height: listHeight,
|
|
itemHeight: listItemHeight,
|
|
virtual: virtual !== false && dropdownMatchSelectWidth !== false,
|
|
multiple: multiple,
|
|
icon: treeIcon,
|
|
showIcon: showTreeIcon,
|
|
switcherIcon: switcherIcon,
|
|
showLine: treeLine,
|
|
loadData: searchValue ? null : loadData,
|
|
motion: treeMotion,
|
|
activeKey: activeKey
|
|
// We handle keys by out instead tree self
|
|
,
|
|
checkable: checkable,
|
|
checkStrictly: true,
|
|
checkedKeys: mergedCheckedKeys,
|
|
selectedKeys: !checkable ? checkedKeys : [],
|
|
defaultExpandAll: treeDefaultExpandAll
|
|
}, treeProps, {
|
|
// Proxy event out
|
|
onActiveChange: setActiveKey,
|
|
onSelect: onInternalSelect,
|
|
onCheck: onInternalSelect,
|
|
onExpand: onInternalExpand,
|
|
onLoad: onTreeLoad,
|
|
filterTreeNode: filterTreeNode,
|
|
expandAction: treeExpandAction
|
|
})));
|
|
};
|
|
var RefOptionList = /*#__PURE__*/_react_17_0_2_react.forwardRef(OptionList);
|
|
RefOptionList.displayName = 'OptionList';
|
|
/* harmony default export */ var es_OptionList = (RefOptionList);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/utils/strategyUtil.js
|
|
|
|
var SHOW_ALL = 'SHOW_ALL';
|
|
var SHOW_PARENT = 'SHOW_PARENT';
|
|
var SHOW_CHILD = 'SHOW_CHILD';
|
|
function formatStrategyValues(values, strategy, keyEntities, fieldNames) {
|
|
var valueSet = new Set(values);
|
|
if (strategy === SHOW_CHILD) {
|
|
return values.filter(function (key) {
|
|
var entity = keyEntities[key];
|
|
if (entity && entity.children && entity.children.some(function (_ref) {
|
|
var node = _ref.node;
|
|
return valueSet.has(node[fieldNames.value]);
|
|
}) && entity.children.every(function (_ref2) {
|
|
var node = _ref2.node;
|
|
return isCheckDisabled(node) || valueSet.has(node[fieldNames.value]);
|
|
})) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
if (strategy === SHOW_PARENT) {
|
|
return values.filter(function (key) {
|
|
var entity = keyEntities[key];
|
|
var parent = entity ? entity.parent : null;
|
|
if (parent && !isCheckDisabled(parent.node) && valueSet.has(parent.key)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
return values;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/utils/warningPropsUtil.js
|
|
|
|
|
|
|
|
function warningProps(props) {
|
|
var searchPlaceholder = props.searchPlaceholder,
|
|
treeCheckStrictly = props.treeCheckStrictly,
|
|
treeCheckable = props.treeCheckable,
|
|
labelInValue = props.labelInValue,
|
|
value = props.value,
|
|
multiple = props.multiple;
|
|
warning(!searchPlaceholder, '`searchPlaceholder` has been removed.');
|
|
if (treeCheckStrictly && labelInValue === false) {
|
|
warning(false, '`treeCheckStrictly` will force set `labelInValue` to `true`.');
|
|
}
|
|
if (labelInValue || treeCheckStrictly) {
|
|
warning(toArray(value).every(function (val) {
|
|
return val && _typeof(val) === 'object' && 'value' in val;
|
|
}), 'Invalid prop `value` supplied to `TreeSelect`. You should use { label: string, value: string | number } or [{ label: string, value: string | number }] instead.');
|
|
}
|
|
if (treeCheckStrictly || multiple || treeCheckable) {
|
|
warning(!value || Array.isArray(value), '`value` should be an array when `TreeSelect` is checkable or multiple.');
|
|
} else {
|
|
warning(!Array.isArray(value), '`value` should not be array when `TreeSelect` is single mode.');
|
|
}
|
|
}
|
|
/* harmony default export */ var warningPropsUtil = ((/* unused pure expression or super */ null && (warningProps)));
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/TreeSelect.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var TreeSelect_excluded = ["id", "prefixCls", "value", "defaultValue", "onChange", "onSelect", "onDeselect", "searchValue", "inputValue", "onSearch", "autoClearSearchValue", "filterTreeNode", "treeNodeFilterProp", "showCheckedStrategy", "treeNodeLabelProp", "multiple", "treeCheckable", "treeCheckStrictly", "labelInValue", "fieldNames", "treeDataSimpleMode", "treeData", "children", "loadData", "treeLoadedKeys", "onTreeLoad", "treeDefaultExpandAll", "treeExpandedKeys", "treeDefaultExpandedKeys", "onTreeExpand", "treeExpandAction", "virtual", "listHeight", "listItemHeight", "onDropdownVisibleChange", "dropdownMatchSelectWidth", "treeLine", "treeIcon", "showTreeIcon", "switcherIcon", "treeMotion"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** @deprecated This is only used for legacy compatible. Not works on new code. */
|
|
|
|
function isRawValue(value) {
|
|
return !value || (0,esm_typeof/* default */.Z)(value) !== 'object';
|
|
}
|
|
var TreeSelect = /*#__PURE__*/_react_17_0_2_react.forwardRef(function (props, ref) {
|
|
var id = props.id,
|
|
_props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-tree-select' : _props$prefixCls,
|
|
value = props.value,
|
|
defaultValue = props.defaultValue,
|
|
onChange = props.onChange,
|
|
onSelect = props.onSelect,
|
|
onDeselect = props.onDeselect,
|
|
searchValue = props.searchValue,
|
|
inputValue = props.inputValue,
|
|
onSearch = props.onSearch,
|
|
_props$autoClearSearc = props.autoClearSearchValue,
|
|
autoClearSearchValue = _props$autoClearSearc === void 0 ? true : _props$autoClearSearc,
|
|
filterTreeNode = props.filterTreeNode,
|
|
_props$treeNodeFilter = props.treeNodeFilterProp,
|
|
treeNodeFilterProp = _props$treeNodeFilter === void 0 ? 'value' : _props$treeNodeFilter,
|
|
showCheckedStrategy = props.showCheckedStrategy,
|
|
treeNodeLabelProp = props.treeNodeLabelProp,
|
|
multiple = props.multiple,
|
|
treeCheckable = props.treeCheckable,
|
|
treeCheckStrictly = props.treeCheckStrictly,
|
|
labelInValue = props.labelInValue,
|
|
fieldNames = props.fieldNames,
|
|
treeDataSimpleMode = props.treeDataSimpleMode,
|
|
treeData = props.treeData,
|
|
children = props.children,
|
|
loadData = props.loadData,
|
|
treeLoadedKeys = props.treeLoadedKeys,
|
|
onTreeLoad = props.onTreeLoad,
|
|
treeDefaultExpandAll = props.treeDefaultExpandAll,
|
|
treeExpandedKeys = props.treeExpandedKeys,
|
|
treeDefaultExpandedKeys = props.treeDefaultExpandedKeys,
|
|
onTreeExpand = props.onTreeExpand,
|
|
treeExpandAction = props.treeExpandAction,
|
|
virtual = props.virtual,
|
|
_props$listHeight = props.listHeight,
|
|
listHeight = _props$listHeight === void 0 ? 200 : _props$listHeight,
|
|
_props$listItemHeight = props.listItemHeight,
|
|
listItemHeight = _props$listItemHeight === void 0 ? 20 : _props$listItemHeight,
|
|
onDropdownVisibleChange = props.onDropdownVisibleChange,
|
|
_props$dropdownMatchS = props.dropdownMatchSelectWidth,
|
|
dropdownMatchSelectWidth = _props$dropdownMatchS === void 0 ? true : _props$dropdownMatchS,
|
|
treeLine = props.treeLine,
|
|
treeIcon = props.treeIcon,
|
|
showTreeIcon = props.showTreeIcon,
|
|
switcherIcon = props.switcherIcon,
|
|
treeMotion = props.treeMotion,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, TreeSelect_excluded);
|
|
var mergedId = (0,useId/* default */.ZP)(id);
|
|
var treeConduction = treeCheckable && !treeCheckStrictly;
|
|
var mergedCheckable = treeCheckable || treeCheckStrictly;
|
|
var mergedLabelInValue = treeCheckStrictly || labelInValue;
|
|
var mergedMultiple = mergedCheckable || multiple;
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(defaultValue, {
|
|
value: value
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
internalValue = _useMergedState2[0],
|
|
setInternalValue = _useMergedState2[1];
|
|
|
|
// `multiple` && `!treeCheckable` should be show all
|
|
var mergedShowCheckedStrategy = _react_17_0_2_react.useMemo(function () {
|
|
if (!treeCheckable) {
|
|
return SHOW_ALL;
|
|
}
|
|
return showCheckedStrategy || SHOW_CHILD;
|
|
}, [showCheckedStrategy, treeCheckable]);
|
|
|
|
// ========================== Warning ===========================
|
|
if (false) {}
|
|
|
|
// ========================= FieldNames =========================
|
|
var mergedFieldNames = _react_17_0_2_react.useMemo(function () {
|
|
return fillFieldNames(fieldNames);
|
|
}, /* eslint-disable react-hooks/exhaustive-deps */
|
|
[JSON.stringify(fieldNames)]
|
|
/* eslint-enable react-hooks/exhaustive-deps */);
|
|
|
|
// =========================== Search ===========================
|
|
var _useMergedState3 = (0,useMergedState/* default */.Z)('', {
|
|
value: searchValue !== undefined ? searchValue : inputValue,
|
|
postState: function postState(search) {
|
|
return search || '';
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
mergedSearchValue = _useMergedState4[0],
|
|
setSearchValue = _useMergedState4[1];
|
|
var onInternalSearch = function onInternalSearch(searchText) {
|
|
setSearchValue(searchText);
|
|
onSearch === null || onSearch === void 0 ? void 0 : onSearch(searchText);
|
|
};
|
|
|
|
// ============================ Data ============================
|
|
// `useTreeData` only do convert of `children` or `simpleMode`.
|
|
// Else will return origin `treeData` for perf consideration.
|
|
// Do not do anything to loop the data.
|
|
var mergedTreeData = useTreeData(treeData, children, treeDataSimpleMode);
|
|
var _useDataEntities = useDataEntities(mergedTreeData, mergedFieldNames),
|
|
keyEntities = _useDataEntities.keyEntities,
|
|
valueEntities = _useDataEntities.valueEntities;
|
|
|
|
/** Get `missingRawValues` which not exist in the tree yet */
|
|
var splitRawValues = _react_17_0_2_react.useCallback(function (newRawValues) {
|
|
var missingRawValues = [];
|
|
var existRawValues = [];
|
|
|
|
// Keep missing value in the cache
|
|
newRawValues.forEach(function (val) {
|
|
if (valueEntities.has(val)) {
|
|
existRawValues.push(val);
|
|
} else {
|
|
missingRawValues.push(val);
|
|
}
|
|
});
|
|
return {
|
|
missingRawValues: missingRawValues,
|
|
existRawValues: existRawValues
|
|
};
|
|
}, [valueEntities]);
|
|
|
|
// Filtered Tree
|
|
var filteredTreeData = useFilterTreeData(mergedTreeData, mergedSearchValue, {
|
|
fieldNames: mergedFieldNames,
|
|
treeNodeFilterProp: treeNodeFilterProp,
|
|
filterTreeNode: filterTreeNode
|
|
});
|
|
|
|
// =========================== Label ============================
|
|
var getLabel = _react_17_0_2_react.useCallback(function (item) {
|
|
if (item) {
|
|
if (treeNodeLabelProp) {
|
|
return item[treeNodeLabelProp];
|
|
}
|
|
|
|
// Loop from fieldNames
|
|
var titleList = mergedFieldNames._title;
|
|
for (var i = 0; i < titleList.length; i += 1) {
|
|
var title = item[titleList[i]];
|
|
if (title !== undefined) {
|
|
return title;
|
|
}
|
|
}
|
|
}
|
|
}, [mergedFieldNames, treeNodeLabelProp]);
|
|
|
|
// ========================= Wrap Value =========================
|
|
var toLabeledValues = _react_17_0_2_react.useCallback(function (draftValues) {
|
|
var values = valueUtil_toArray(draftValues);
|
|
return values.map(function (val) {
|
|
if (isRawValue(val)) {
|
|
return {
|
|
value: val
|
|
};
|
|
}
|
|
return val;
|
|
});
|
|
}, []);
|
|
var convert2LabelValues = _react_17_0_2_react.useCallback(function (draftValues) {
|
|
var values = toLabeledValues(draftValues);
|
|
return values.map(function (item) {
|
|
var rawLabel = item.label;
|
|
var rawValue = item.value,
|
|
rawHalfChecked = item.halfChecked;
|
|
var rawDisabled;
|
|
var entity = valueEntities.get(rawValue);
|
|
|
|
// Fill missing label & status
|
|
if (entity) {
|
|
var _rawLabel;
|
|
rawLabel = (_rawLabel = rawLabel) !== null && _rawLabel !== void 0 ? _rawLabel : getLabel(entity.node);
|
|
rawDisabled = entity.node.disabled;
|
|
} else if (rawLabel === undefined) {
|
|
// We try to find in current `labelInValue` value
|
|
var labelInValueItem = toLabeledValues(internalValue).find(function (labeledItem) {
|
|
return labeledItem.value === rawValue;
|
|
});
|
|
rawLabel = labelInValueItem.label;
|
|
}
|
|
return {
|
|
label: rawLabel,
|
|
value: rawValue,
|
|
halfChecked: rawHalfChecked,
|
|
disabled: rawDisabled
|
|
};
|
|
});
|
|
}, [valueEntities, getLabel, toLabeledValues, internalValue]);
|
|
|
|
// =========================== Values ===========================
|
|
var rawMixedLabeledValues = _react_17_0_2_react.useMemo(function () {
|
|
return toLabeledValues(internalValue);
|
|
}, [toLabeledValues, internalValue]);
|
|
|
|
// Split value into full check and half check
|
|
var _React$useMemo = _react_17_0_2_react.useMemo(function () {
|
|
var fullCheckValues = [];
|
|
var halfCheckValues = [];
|
|
rawMixedLabeledValues.forEach(function (item) {
|
|
if (item.halfChecked) {
|
|
halfCheckValues.push(item);
|
|
} else {
|
|
fullCheckValues.push(item);
|
|
}
|
|
});
|
|
return [fullCheckValues, halfCheckValues];
|
|
}, [rawMixedLabeledValues]),
|
|
_React$useMemo2 = (0,slicedToArray/* default */.Z)(_React$useMemo, 2),
|
|
rawLabeledValues = _React$useMemo2[0],
|
|
rawHalfLabeledValues = _React$useMemo2[1];
|
|
|
|
// const [mergedValues] = useCache(rawLabeledValues);
|
|
var rawValues = _react_17_0_2_react.useMemo(function () {
|
|
return rawLabeledValues.map(function (item) {
|
|
return item.value;
|
|
});
|
|
}, [rawLabeledValues]);
|
|
|
|
// Convert value to key. Will fill missed keys for conduct check.
|
|
var _useCheckedKeys = useCheckedKeys(rawLabeledValues, rawHalfLabeledValues, treeConduction, keyEntities),
|
|
_useCheckedKeys2 = (0,slicedToArray/* default */.Z)(_useCheckedKeys, 2),
|
|
rawCheckedValues = _useCheckedKeys2[0],
|
|
rawHalfCheckedValues = _useCheckedKeys2[1];
|
|
|
|
// Convert rawCheckedKeys to check strategy related values
|
|
var displayValues = _react_17_0_2_react.useMemo(function () {
|
|
// Collect keys which need to show
|
|
var displayKeys = formatStrategyValues(rawCheckedValues, mergedShowCheckedStrategy, keyEntities, mergedFieldNames);
|
|
|
|
// Convert to value and filled with label
|
|
var values = displayKeys.map(function (key) {
|
|
var _keyEntities$key$node, _keyEntities$key, _keyEntities$key$node2;
|
|
return (_keyEntities$key$node = (_keyEntities$key = keyEntities[key]) === null || _keyEntities$key === void 0 ? void 0 : (_keyEntities$key$node2 = _keyEntities$key.node) === null || _keyEntities$key$node2 === void 0 ? void 0 : _keyEntities$key$node2[mergedFieldNames.value]) !== null && _keyEntities$key$node !== void 0 ? _keyEntities$key$node : key;
|
|
});
|
|
|
|
// Back fill with origin label
|
|
var labeledValues = values.map(function (val) {
|
|
var targetItem = rawLabeledValues.find(function (item) {
|
|
return item.value === val;
|
|
});
|
|
return {
|
|
value: val,
|
|
label: targetItem === null || targetItem === void 0 ? void 0 : targetItem.label
|
|
};
|
|
});
|
|
var rawDisplayValues = convert2LabelValues(labeledValues);
|
|
var firstVal = rawDisplayValues[0];
|
|
if (!mergedMultiple && firstVal && isNil(firstVal.value) && isNil(firstVal.label)) {
|
|
return [];
|
|
}
|
|
return rawDisplayValues.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
|
|
});
|
|
});
|
|
}, [mergedFieldNames, mergedMultiple, rawCheckedValues, rawLabeledValues, convert2LabelValues, mergedShowCheckedStrategy, keyEntities]);
|
|
var _useCache = useCache(displayValues),
|
|
_useCache2 = (0,slicedToArray/* default */.Z)(_useCache, 1),
|
|
cachedDisplayValues = _useCache2[0];
|
|
|
|
// =========================== Change ===========================
|
|
var triggerChange = useRefFunc(function (newRawValues, extra, source) {
|
|
var labeledValues = convert2LabelValues(newRawValues);
|
|
setInternalValue(labeledValues);
|
|
|
|
// Clean up if needed
|
|
if (autoClearSearchValue) {
|
|
setSearchValue('');
|
|
}
|
|
|
|
// Generate rest parameters is costly, so only do it when necessary
|
|
if (onChange) {
|
|
var eventValues = newRawValues;
|
|
if (treeConduction) {
|
|
var formattedKeyList = formatStrategyValues(newRawValues, mergedShowCheckedStrategy, keyEntities, mergedFieldNames);
|
|
eventValues = formattedKeyList.map(function (key) {
|
|
var entity = valueEntities.get(key);
|
|
return entity ? entity.node[mergedFieldNames.value] : key;
|
|
});
|
|
}
|
|
var _ref = extra || {
|
|
triggerValue: undefined,
|
|
selected: undefined
|
|
},
|
|
triggerValue = _ref.triggerValue,
|
|
selected = _ref.selected;
|
|
var returnRawValues = eventValues;
|
|
|
|
// We need fill half check back
|
|
if (treeCheckStrictly) {
|
|
var halfValues = rawHalfLabeledValues.filter(function (item) {
|
|
return !eventValues.includes(item.value);
|
|
});
|
|
returnRawValues = [].concat((0,toConsumableArray/* default */.Z)(returnRawValues), (0,toConsumableArray/* default */.Z)(halfValues));
|
|
}
|
|
var returnLabeledValues = convert2LabelValues(returnRawValues);
|
|
var additionalInfo = {
|
|
// [Legacy] Always return as array contains label & value
|
|
preValue: rawLabeledValues,
|
|
triggerValue: triggerValue
|
|
};
|
|
|
|
// [Legacy] Fill legacy data if user query.
|
|
// This is expansive that we only fill when user query
|
|
// https://github.com/react-component/tree-select/blob/fe33eb7c27830c9ac70cd1fdb1ebbe7bc679c16a/src/Select.jsx
|
|
var showPosition = true;
|
|
if (treeCheckStrictly || source === 'selection' && !selected) {
|
|
showPosition = false;
|
|
}
|
|
fillAdditionalInfo(additionalInfo, triggerValue, newRawValues, mergedTreeData, showPosition, mergedFieldNames);
|
|
if (mergedCheckable) {
|
|
additionalInfo.checked = selected;
|
|
} else {
|
|
additionalInfo.selected = selected;
|
|
}
|
|
var returnValues = mergedLabelInValue ? returnLabeledValues : returnLabeledValues.map(function (item) {
|
|
return item.value;
|
|
});
|
|
onChange(mergedMultiple ? returnValues : returnValues[0], mergedLabelInValue ? null : returnLabeledValues.map(function (item) {
|
|
return item.label;
|
|
}), additionalInfo);
|
|
}
|
|
});
|
|
|
|
// ========================== Options ===========================
|
|
/** Trigger by option list */
|
|
var onOptionSelect = _react_17_0_2_react.useCallback(function (selectedKey, _ref2) {
|
|
var _node$mergedFieldName;
|
|
var selected = _ref2.selected,
|
|
source = _ref2.source;
|
|
var entity = keyEntities[selectedKey];
|
|
var node = entity === null || entity === void 0 ? void 0 : entity.node;
|
|
var selectedValue = (_node$mergedFieldName = node === null || node === void 0 ? void 0 : node[mergedFieldNames.value]) !== null && _node$mergedFieldName !== void 0 ? _node$mergedFieldName : selectedKey;
|
|
|
|
// Never be falsy but keep it safe
|
|
if (!mergedMultiple) {
|
|
// Single mode always set value
|
|
triggerChange([selectedValue], {
|
|
selected: true,
|
|
triggerValue: selectedValue
|
|
}, 'option');
|
|
} else {
|
|
var newRawValues = selected ? [].concat((0,toConsumableArray/* default */.Z)(rawValues), [selectedValue]) : rawCheckedValues.filter(function (v) {
|
|
return v !== selectedValue;
|
|
});
|
|
|
|
// Add keys if tree conduction
|
|
if (treeConduction) {
|
|
// Should keep missing values
|
|
var _splitRawValues = splitRawValues(newRawValues),
|
|
missingRawValues = _splitRawValues.missingRawValues,
|
|
existRawValues = _splitRawValues.existRawValues;
|
|
var keyList = existRawValues.map(function (val) {
|
|
return valueEntities.get(val).key;
|
|
});
|
|
|
|
// Conduction by selected or not
|
|
var checkedKeys;
|
|
if (selected) {
|
|
var _conductCheck = (0,conductUtil/* conductCheck */.S)(keyList, true, keyEntities);
|
|
checkedKeys = _conductCheck.checkedKeys;
|
|
} else {
|
|
var _conductCheck2 = (0,conductUtil/* conductCheck */.S)(keyList, {
|
|
checked: false,
|
|
halfCheckedKeys: rawHalfCheckedValues
|
|
}, keyEntities);
|
|
checkedKeys = _conductCheck2.checkedKeys;
|
|
}
|
|
|
|
// Fill back of keys
|
|
newRawValues = [].concat((0,toConsumableArray/* default */.Z)(missingRawValues), (0,toConsumableArray/* default */.Z)(checkedKeys.map(function (key) {
|
|
return keyEntities[key].node[mergedFieldNames.value];
|
|
})));
|
|
}
|
|
triggerChange(newRawValues, {
|
|
selected: selected,
|
|
triggerValue: selectedValue
|
|
}, source || 'option');
|
|
}
|
|
|
|
// Trigger select event
|
|
if (selected || !mergedMultiple) {
|
|
onSelect === null || onSelect === void 0 ? void 0 : onSelect(selectedValue, fillLegacyProps(node));
|
|
} else {
|
|
onDeselect === null || onDeselect === void 0 ? void 0 : onDeselect(selectedValue, fillLegacyProps(node));
|
|
}
|
|
}, [splitRawValues, valueEntities, keyEntities, mergedFieldNames, mergedMultiple, rawValues, triggerChange, treeConduction, onSelect, onDeselect, rawCheckedValues, rawHalfCheckedValues]);
|
|
|
|
// ========================== Dropdown ==========================
|
|
var onInternalDropdownVisibleChange = _react_17_0_2_react.useCallback(function (open) {
|
|
if (onDropdownVisibleChange) {
|
|
var legacyParam = {};
|
|
Object.defineProperty(legacyParam, 'documentClickClose', {
|
|
get: function get() {
|
|
(0,es_warning/* default */.ZP)(false, 'Second param of `onDropdownVisibleChange` has been removed.');
|
|
return false;
|
|
}
|
|
});
|
|
onDropdownVisibleChange(open, legacyParam);
|
|
}
|
|
}, [onDropdownVisibleChange]);
|
|
|
|
// ====================== Display Change ========================
|
|
var onDisplayValuesChange = useRefFunc(function (newValues, info) {
|
|
var newRawValues = newValues.map(function (item) {
|
|
return item.value;
|
|
});
|
|
if (info.type === 'clear') {
|
|
triggerChange(newRawValues, {}, 'selection');
|
|
return;
|
|
}
|
|
|
|
// TreeSelect only have multiple mode which means display change only has remove
|
|
if (info.values.length) {
|
|
onOptionSelect(info.values[0].value, {
|
|
selected: false,
|
|
source: 'selection'
|
|
});
|
|
}
|
|
});
|
|
|
|
// ========================== Context ===========================
|
|
var treeSelectContext = _react_17_0_2_react.useMemo(function () {
|
|
return {
|
|
virtual: virtual,
|
|
dropdownMatchSelectWidth: dropdownMatchSelectWidth,
|
|
listHeight: listHeight,
|
|
listItemHeight: listItemHeight,
|
|
treeData: filteredTreeData,
|
|
fieldNames: mergedFieldNames,
|
|
onSelect: onOptionSelect,
|
|
treeExpandAction: treeExpandAction
|
|
};
|
|
}, [virtual, dropdownMatchSelectWidth, listHeight, listItemHeight, filteredTreeData, mergedFieldNames, onOptionSelect, treeExpandAction]);
|
|
|
|
// ======================= Legacy Context =======================
|
|
var legacyContext = _react_17_0_2_react.useMemo(function () {
|
|
return {
|
|
checkable: mergedCheckable,
|
|
loadData: loadData,
|
|
treeLoadedKeys: treeLoadedKeys,
|
|
onTreeLoad: onTreeLoad,
|
|
checkedKeys: rawCheckedValues,
|
|
halfCheckedKeys: rawHalfCheckedValues,
|
|
treeDefaultExpandAll: treeDefaultExpandAll,
|
|
treeExpandedKeys: treeExpandedKeys,
|
|
treeDefaultExpandedKeys: treeDefaultExpandedKeys,
|
|
onTreeExpand: onTreeExpand,
|
|
treeIcon: treeIcon,
|
|
treeMotion: treeMotion,
|
|
showTreeIcon: showTreeIcon,
|
|
switcherIcon: switcherIcon,
|
|
treeLine: treeLine,
|
|
treeNodeFilterProp: treeNodeFilterProp,
|
|
keyEntities: keyEntities
|
|
};
|
|
}, [mergedCheckable, loadData, treeLoadedKeys, onTreeLoad, rawCheckedValues, rawHalfCheckedValues, treeDefaultExpandAll, treeExpandedKeys, treeDefaultExpandedKeys, onTreeExpand, treeIcon, treeMotion, showTreeIcon, switcherIcon, treeLine, treeNodeFilterProp, keyEntities]);
|
|
|
|
// =========================== Render ===========================
|
|
return /*#__PURE__*/_react_17_0_2_react.createElement(es_TreeSelectContext.Provider, {
|
|
value: treeSelectContext
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement(LegacyContext.Provider, {
|
|
value: legacyContext
|
|
}, /*#__PURE__*/_react_17_0_2_react.createElement(es/* BaseSelect */.Ac, (0,esm_extends/* default */.Z)({
|
|
ref: ref
|
|
}, restProps, {
|
|
// >>> MISC
|
|
id: mergedId,
|
|
prefixCls: prefixCls,
|
|
mode: mergedMultiple ? 'multiple' : undefined
|
|
// >>> Display Value
|
|
,
|
|
displayValues: cachedDisplayValues,
|
|
onDisplayValuesChange: onDisplayValuesChange
|
|
// >>> Search
|
|
,
|
|
searchValue: mergedSearchValue,
|
|
onSearch: onInternalSearch
|
|
// >>> Options
|
|
,
|
|
OptionList: es_OptionList,
|
|
emptyOptions: !mergedTreeData.length,
|
|
onDropdownVisibleChange: onInternalDropdownVisibleChange,
|
|
dropdownMatchSelectWidth: dropdownMatchSelectWidth
|
|
}))));
|
|
});
|
|
|
|
// Assign name for Debug
|
|
if (false) {}
|
|
var GenericTreeSelect = TreeSelect;
|
|
GenericTreeSelect.TreeNode = es_TreeNode;
|
|
GenericTreeSelect.SHOW_ALL = SHOW_ALL;
|
|
GenericTreeSelect.SHOW_PARENT = SHOW_PARENT;
|
|
GenericTreeSelect.SHOW_CHILD = SHOW_CHILD;
|
|
/* harmony default export */ var es_TreeSelect = (GenericTreeSelect);
|
|
;// CONCATENATED MODULE: ./node_modules/_rc-tree-select@5.12.1@rc-tree-select/es/index.js
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var _rc_tree_select_5_12_1_rc_tree_select_es = (es_TreeSelect);
|
|
// EXTERNAL MODULE: ./node_modules/_rc-util@5.44.4@rc-util/es/omit.js
|
|
var omit = __webpack_require__(2738);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/_util/PurePanel.js
|
|
var PurePanel = __webpack_require__(53487);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/_util/motion.js
|
|
var motion = __webpack_require__(62892);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/_util/statusUtils.js
|
|
var statusUtils = __webpack_require__(19080);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/config-provider/context.js
|
|
var context = __webpack_require__(36355);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/config-provider/DisabledContext.js
|
|
var DisabledContext = __webpack_require__(1684);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/config-provider/defaultRenderEmpty.js
|
|
var defaultRenderEmpty = __webpack_require__(93891);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/config-provider/hooks/useSize.js
|
|
var useSize = __webpack_require__(19716);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/form/context.js
|
|
var form_context = __webpack_require__(32441);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/select/style/index.js + 3 modules
|
|
var style = __webpack_require__(14154);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/select/useBuiltinPlacements.js
|
|
var useBuiltinPlacements = __webpack_require__(58582);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/select/useShowArrow.js
|
|
var useShowArrow = __webpack_require__(84443);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/select/utils/iconUtil.js
|
|
var iconUtil = __webpack_require__(66339);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/space/Compact.js
|
|
var Compact = __webpack_require__(33234);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/tree/utils/iconUtil.js + 2 modules
|
|
var utils_iconUtil = __webpack_require__(71997);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/checkbox/style/index.js
|
|
var checkbox_style = __webpack_require__(98447);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/theme/util/statistic.js
|
|
var statistic = __webpack_require__(37613);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/theme/util/genComponentStyleHook.js
|
|
var genComponentStyleHook = __webpack_require__(83116);
|
|
// EXTERNAL MODULE: ./node_modules/_antd@5.9.0@antd/es/tree/style/index.js
|
|
var tree_style = __webpack_require__(20648);
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/tree-select/style/index.js
|
|
|
|
|
|
|
|
// =============================== Base ===============================
|
|
const genBaseStyle = token => {
|
|
const {
|
|
componentCls,
|
|
treePrefixCls,
|
|
colorBgElevated
|
|
} = token;
|
|
const treeCls = `.${treePrefixCls}`;
|
|
return [
|
|
// ======================================================
|
|
// == Dropdown ==
|
|
// ======================================================
|
|
{
|
|
[`${componentCls}-dropdown`]: [{
|
|
padding: `${token.paddingXS}px ${token.paddingXS / 2}px`
|
|
},
|
|
// ====================== Tree ======================
|
|
(0,tree_style/* genTreeStyle */.Yk)(treePrefixCls, (0,statistic/* merge */.TS)(token, {
|
|
colorBgContainer: colorBgElevated
|
|
})), {
|
|
[treeCls]: {
|
|
borderRadius: 0,
|
|
[`${treeCls}-list-holder-inner`]: {
|
|
alignItems: 'stretch',
|
|
[`${treeCls}-treenode`]: {
|
|
[`${treeCls}-node-content-wrapper`]: {
|
|
flex: 'auto'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// ==================== Checkbox ====================
|
|
(0,checkbox_style/* getStyle */.C2)(`${treePrefixCls}-checkbox`, token),
|
|
// ====================== RTL =======================
|
|
{
|
|
'&-rtl': {
|
|
direction: 'rtl',
|
|
[`${treeCls}-switcher${treeCls}-switcher_close`]: {
|
|
[`${treeCls}-switcher-icon svg`]: {
|
|
transform: 'rotate(90deg)'
|
|
}
|
|
}
|
|
}
|
|
}]
|
|
}];
|
|
};
|
|
// ============================== Export ==============================
|
|
function useTreeSelectStyle(prefixCls, treePrefixCls) {
|
|
return (0,genComponentStyleHook/* default */.Z)('TreeSelect', token => {
|
|
const treeSelectToken = (0,statistic/* merge */.TS)(token, {
|
|
treePrefixCls
|
|
});
|
|
return [genBaseStyle(treeSelectToken)];
|
|
}, tree_style/* initComponentToken */.TM)(prefixCls);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/_antd@5.9.0@antd/es/tree-select/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 InternalTreeSelect = (_a, ref) => {
|
|
var _b;
|
|
var {
|
|
prefixCls: customizePrefixCls,
|
|
size: customizeSize,
|
|
disabled: customDisabled,
|
|
bordered = true,
|
|
className,
|
|
rootClassName,
|
|
treeCheckable,
|
|
multiple,
|
|
listHeight = 256,
|
|
listItemHeight = 26,
|
|
placement,
|
|
notFoundContent,
|
|
switcherIcon,
|
|
treeLine,
|
|
getPopupContainer,
|
|
popupClassName,
|
|
dropdownClassName,
|
|
treeIcon = false,
|
|
transitionName,
|
|
choiceTransitionName = '',
|
|
status: customStatus,
|
|
treeExpandAction,
|
|
builtinPlacements,
|
|
dropdownMatchSelectWidth,
|
|
popupMatchSelectWidth,
|
|
allowClear
|
|
} = _a,
|
|
props = __rest(_a, ["prefixCls", "size", "disabled", "bordered", "className", "rootClassName", "treeCheckable", "multiple", "listHeight", "listItemHeight", "placement", "notFoundContent", "switcherIcon", "treeLine", "getPopupContainer", "popupClassName", "dropdownClassName", "treeIcon", "transitionName", "choiceTransitionName", "status", "treeExpandAction", "builtinPlacements", "dropdownMatchSelectWidth", "popupMatchSelectWidth", "allowClear"]);
|
|
const {
|
|
getPopupContainer: getContextPopupContainer,
|
|
getPrefixCls,
|
|
renderEmpty,
|
|
direction,
|
|
virtual,
|
|
popupMatchSelectWidth: contextPopupMatchSelectWidth,
|
|
popupOverflow
|
|
} = _react_17_0_2_react.useContext(context/* ConfigContext */.E_);
|
|
if (false) {}
|
|
const rootPrefixCls = getPrefixCls();
|
|
const prefixCls = getPrefixCls('select', customizePrefixCls);
|
|
const treePrefixCls = getPrefixCls('select-tree', customizePrefixCls);
|
|
const treeSelectPrefixCls = getPrefixCls('tree-select', customizePrefixCls);
|
|
const {
|
|
compactSize,
|
|
compactItemClassnames
|
|
} = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction);
|
|
const [wrapSelectSSR, hashId] = (0,style/* default */.Z)(prefixCls);
|
|
const [wrapTreeSelectSSR] = useTreeSelectStyle(treeSelectPrefixCls, treePrefixCls);
|
|
const mergedDropdownClassName = _classnames_2_5_1_classnames_default()(popupClassName || dropdownClassName, `${treeSelectPrefixCls}-dropdown`, {
|
|
[`${treeSelectPrefixCls}-dropdown-rtl`]: direction === 'rtl'
|
|
}, rootClassName, hashId);
|
|
const isMultiple = !!(treeCheckable || multiple);
|
|
const showSuffixIcon = (0,useShowArrow/* default */.Z)(props.suffixIcon, props.showArrow);
|
|
const mergedPopupMatchSelectWidth = (_b = popupMatchSelectWidth !== null && popupMatchSelectWidth !== void 0 ? popupMatchSelectWidth : dropdownMatchSelectWidth) !== null && _b !== void 0 ? _b : contextPopupMatchSelectWidth;
|
|
// ===================== Form =====================
|
|
const {
|
|
status: contextStatus,
|
|
hasFeedback,
|
|
isFormItemInput,
|
|
feedbackIcon
|
|
} = _react_17_0_2_react.useContext(form_context/* FormItemInputContext */.aM);
|
|
const mergedStatus = (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus);
|
|
// ===================== Icons =====================
|
|
const {
|
|
suffixIcon,
|
|
removeIcon,
|
|
clearIcon
|
|
} = (0,iconUtil/* default */.Z)(Object.assign(Object.assign({}, props), {
|
|
multiple: isMultiple,
|
|
showSuffixIcon,
|
|
hasFeedback,
|
|
feedbackIcon,
|
|
prefixCls,
|
|
componentName: 'TreeSelect'
|
|
}));
|
|
const mergedAllowClear = allowClear === true ? {
|
|
clearIcon
|
|
} : allowClear;
|
|
// ===================== Empty =====================
|
|
let mergedNotFound;
|
|
if (notFoundContent !== undefined) {
|
|
mergedNotFound = notFoundContent;
|
|
} else {
|
|
mergedNotFound = (renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Select')) || /*#__PURE__*/_react_17_0_2_react.createElement(defaultRenderEmpty/* default */.Z, {
|
|
componentName: "Select"
|
|
});
|
|
}
|
|
// ==================== Render =====================
|
|
const selectProps = (0,omit/* default */.Z)(props, ['suffixIcon', 'itemIcon', 'removeIcon', 'clearIcon', 'switcherIcon']);
|
|
// ===================== Placement =====================
|
|
const memoizedPlacement = _react_17_0_2_react.useMemo(() => {
|
|
if (placement !== undefined) {
|
|
return placement;
|
|
}
|
|
return direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
|
|
}, [placement, direction]);
|
|
const mergedBuiltinPlacements = (0,useBuiltinPlacements/* default */.Z)(builtinPlacements, popupOverflow);
|
|
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_17_0_2_react.useContext(DisabledContext/* default */.Z);
|
|
const mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
const mergedClassName = _classnames_2_5_1_classnames_default()(!customizePrefixCls && treeSelectPrefixCls, {
|
|
[`${prefixCls}-lg`]: mergedSize === 'large',
|
|
[`${prefixCls}-sm`]: mergedSize === 'small',
|
|
[`${prefixCls}-rtl`]: direction === 'rtl',
|
|
[`${prefixCls}-borderless`]: !bordered,
|
|
[`${prefixCls}-in-form-item`]: isFormItemInput
|
|
}, (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, mergedStatus, hasFeedback), compactItemClassnames, className, rootClassName, hashId);
|
|
const renderSwitcherIcon = nodeProps => /*#__PURE__*/_react_17_0_2_react.createElement(utils_iconUtil/* default */.Z, {
|
|
prefixCls: treePrefixCls,
|
|
switcherIcon: switcherIcon,
|
|
treeNodeProps: nodeProps,
|
|
showLine: treeLine
|
|
});
|
|
const returnNode = /*#__PURE__*/_react_17_0_2_react.createElement(_rc_tree_select_5_12_1_rc_tree_select_es, Object.assign({
|
|
virtual: virtual,
|
|
disabled: mergedDisabled
|
|
}, selectProps, {
|
|
dropdownMatchSelectWidth: mergedPopupMatchSelectWidth,
|
|
builtinPlacements: mergedBuiltinPlacements,
|
|
ref: ref,
|
|
prefixCls: prefixCls,
|
|
className: mergedClassName,
|
|
listHeight: listHeight,
|
|
listItemHeight: listItemHeight,
|
|
treeCheckable: treeCheckable ? /*#__PURE__*/_react_17_0_2_react.createElement("span", {
|
|
className: `${prefixCls}-tree-checkbox-inner`
|
|
}) : treeCheckable,
|
|
treeLine: !!treeLine,
|
|
suffixIcon: suffixIcon,
|
|
multiple: isMultiple,
|
|
placement: memoizedPlacement,
|
|
removeIcon: removeIcon,
|
|
allowClear: mergedAllowClear,
|
|
switcherIcon: renderSwitcherIcon,
|
|
showTreeIcon: treeIcon,
|
|
notFoundContent: mergedNotFound,
|
|
getPopupContainer: getPopupContainer || getContextPopupContainer,
|
|
treeMotion: null,
|
|
dropdownClassName: mergedDropdownClassName,
|
|
choiceTransitionName: (0,motion/* getTransitionName */.m)(rootPrefixCls, '', choiceTransitionName),
|
|
transitionName: (0,motion/* getTransitionName */.m)(rootPrefixCls, 'slide-up', transitionName),
|
|
treeExpandAction: treeExpandAction
|
|
}));
|
|
return wrapSelectSSR(wrapTreeSelectSSR(returnNode));
|
|
};
|
|
const TreeSelectRef = /*#__PURE__*/_react_17_0_2_react.forwardRef(InternalTreeSelect);
|
|
const tree_select_TreeSelect = TreeSelectRef;
|
|
// We don't care debug panel
|
|
/* istanbul ignore next */
|
|
const tree_select_PurePanel = (0,PurePanel/* default */.Z)(tree_select_TreeSelect);
|
|
tree_select_TreeSelect.TreeNode = es_TreeNode;
|
|
tree_select_TreeSelect.SHOW_ALL = SHOW_ALL;
|
|
tree_select_TreeSelect.SHOW_PARENT = SHOW_PARENT;
|
|
tree_select_TreeSelect.SHOW_CHILD = SHOW_CHILD;
|
|
tree_select_TreeSelect._InternalPanelDoNotUseOrYouWillBeFired = tree_select_PurePanel;
|
|
if (false) {}
|
|
|
|
/* harmony default export */ var tree_select = (tree_select_TreeSelect);
|
|
|
|
/***/ })
|
|
|
|
}]); |