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.
1551 lines
56 KiB
1551 lines
56 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[93562],{
|
|
|
|
/***/ 45278:
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/antd/es/tree-select/index.js + 16 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/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// 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/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(74902);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// 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/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/rc-select/es/index.js + 27 modules
|
|
var es = __webpack_require__(7752);
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/conductUtil.js
|
|
var conductUtil = __webpack_require__(17341);
|
|
// EXTERNAL MODULE: ./node_modules/rc-select/es/hooks/useId.js
|
|
var useId = __webpack_require__(88708);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMergedState.js
|
|
var useMergedState = __webpack_require__(21770);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/KeyCode.js
|
|
var KeyCode = __webpack_require__(15105);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMemo.js
|
|
var useMemo = __webpack_require__(56982);
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/index.js + 6 modules
|
|
var rc_tree_es = __webpack_require__(31343);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-tree-select/es/LegacyContext.js
|
|
|
|
var LegacySelectContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var LegacyContext = (LegacySelectContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-tree-select/es/TreeSelectContext.js
|
|
|
|
var TreeSelectContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var es_TreeSelectContext = (TreeSelectContext);
|
|
;// CONCATENATED MODULE: ./node_modules/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/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.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.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.useRef();
|
|
var memoTreeData = (0,useMemo/* default */.Z)(function () {
|
|
return treeData;
|
|
}, [open, treeData], function (prev, next) {
|
|
return next[0] && prev[1] !== next[1];
|
|
}); // ========================== Values ==========================
|
|
|
|
var mergedCheckedKeys = react.useMemo(function () {
|
|
if (!checkable) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
checked: checkedKeys,
|
|
halfChecked: halfCheckedKeys
|
|
};
|
|
}, [checkable, checkedKeys, halfCheckedKeys]); // ========================== Scroll ==========================
|
|
|
|
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]
|
|
});
|
|
}
|
|
}, [open]); // ========================== Search ==========================
|
|
|
|
var lowerSearchValue = String(searchValue).toLowerCase();
|
|
|
|
var filterTreeNode = function filterTreeNode(treeNode) {
|
|
if (!lowerSearchValue) {
|
|
return false;
|
|
}
|
|
|
|
return String(treeNode[treeNodeFilterProp]).toLowerCase().includes(lowerSearchValue);
|
|
}; // =========================== Keys ===========================
|
|
|
|
|
|
var _React$useState = react.useState(treeDefaultExpandedKeys),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
expandedKeys = _React$useState2[0],
|
|
setExpandedKeys = _React$useState2[1];
|
|
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
searchExpandedKeys = _React$useState4[0],
|
|
setSearchExpandedKeys = _React$useState4[1];
|
|
|
|
var mergedExpandedKeys = react.useMemo(function () {
|
|
if (treeExpandedKeys) {
|
|
return (0,toConsumableArray/* default */.Z)(treeExpandedKeys);
|
|
}
|
|
|
|
return searchValue ? searchExpandedKeys : expandedKeys;
|
|
}, [expandedKeys, searchExpandedKeys, treeExpandedKeys, searchValue]);
|
|
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 =========================
|
|
|
|
|
|
var _React$useState5 = react.useState(null),
|
|
_React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2),
|
|
activeKey = _React$useState6[0],
|
|
setActiveKey = _React$useState6[1];
|
|
|
|
var activeEntity = keyEntities[activeKey];
|
|
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.UP */.Z.UP:
|
|
case KeyCode/* default.DOWN */.Z.DOWN:
|
|
case KeyCode/* default.LEFT */.Z.LEFT:
|
|
case KeyCode/* default.RIGHT */.Z.RIGHT:
|
|
(_treeRef$current3 = treeRef.current) === null || _treeRef$current3 === void 0 ? void 0 : _treeRef$current3.onKeyDown(event);
|
|
break;
|
|
// >>> Select item
|
|
|
|
case KeyCode/* default.ENTER */.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.ESC */.Z.ESC:
|
|
{
|
|
toggleOpen(false);
|
|
}
|
|
}
|
|
},
|
|
onKeyUp: function onKeyUp() {}
|
|
};
|
|
}); // ========================== Render ==========================
|
|
|
|
if (memoTreeData.length === 0) {
|
|
return /*#__PURE__*/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.createElement("div", {
|
|
onMouseDown: onListMouseDown
|
|
}, activeEntity && open && /*#__PURE__*/react.createElement("span", {
|
|
style: HIDDEN_STYLE,
|
|
"aria-live": "assertive"
|
|
}, activeEntity.node.value), /*#__PURE__*/react.createElement(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.forwardRef(OptionList);
|
|
RefOptionList.displayName = 'OptionList';
|
|
/* harmony default export */ var es_OptionList = (RefOptionList);
|
|
;// CONCATENATED MODULE: ./node_modules/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/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;
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Children/toArray.js
|
|
var Children_toArray = __webpack_require__(50344);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/warning.js
|
|
var es_warning = __webpack_require__(80334);
|
|
;// CONCATENATED MODULE: ./node_modules/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.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.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/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.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/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.useRef({
|
|
valueLabels: new Map()
|
|
});
|
|
return 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/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;
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/treeUtil.js
|
|
var treeUtil = __webpack_require__(1089);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-tree-select/es/hooks/useDataEntities.js
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var useDataEntities = (function (treeData, fieldNames) {
|
|
return 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]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-tree-select/es/hooks/useCheckedKeys.js
|
|
|
|
|
|
|
|
/* harmony default export */ var useCheckedKeys = (function (rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities) {
|
|
return 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]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/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.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.map(function (dataNode) {
|
|
var children = dataNode[fieldChildren];
|
|
var match = keepAll || filterOptionFunc(searchValue, fillLegacyProps(dataNode));
|
|
var childList = dig(children || [], match);
|
|
|
|
if (match || childList.length) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, dataNode), {}, (0,defineProperty/* default */.Z)({
|
|
isLeaf: undefined
|
|
}, fieldChildren, childList));
|
|
}
|
|
|
|
return null;
|
|
}).filter(function (node) {
|
|
return node;
|
|
});
|
|
}
|
|
|
|
return dig(treeData);
|
|
}, [treeData, searchValue, fieldChildren, treeNodeFilterProp, filterTreeNode]);
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/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/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"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function isRawValue(value) {
|
|
return !value || (0,esm_typeof/* default */.Z)(value) !== 'object';
|
|
}
|
|
|
|
var TreeSelect = /*#__PURE__*/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,
|
|
_props$showCheckedStr = props.showCheckedStrategy,
|
|
showCheckedStrategy = _props$showCheckedStr === void 0 ? SHOW_CHILD : _props$showCheckedStr,
|
|
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]; // ========================== Warning ===========================
|
|
|
|
|
|
if (false) {} // ========================= FieldNames =========================
|
|
|
|
|
|
var mergedFieldNames = 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.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.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.useCallback(function (draftValues) {
|
|
var values = valueUtil_toArray(draftValues);
|
|
return values.map(function (val) {
|
|
if (isRawValue(val)) {
|
|
return {
|
|
value: val
|
|
};
|
|
}
|
|
|
|
return val;
|
|
});
|
|
}, []);
|
|
var convert2LabelValues = 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.useMemo(function () {
|
|
return toLabeledValues(internalValue);
|
|
}, [toLabeledValues, internalValue]); // Split value into full check and half check
|
|
|
|
var _React$useMemo = 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.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.useMemo(function () {
|
|
// Collect keys which need to show
|
|
var displayKeys = formatStrategyValues(rawCheckedValues, showCheckedStrategy, 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, showCheckedStrategy, 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, showCheckedStrategy, 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.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.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.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.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.createElement(es_TreeSelectContext.Provider, {
|
|
value: treeSelectContext
|
|
}, /*#__PURE__*/react.createElement(LegacyContext.Provider, {
|
|
value: legacyContext
|
|
}, /*#__PURE__*/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/es/index.js
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var rc_tree_select_es = (es_TreeSelect);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/omit.js
|
|
var omit = __webpack_require__(98423);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/context.js
|
|
var context = __webpack_require__(53124);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/defaultRenderEmpty.js
|
|
var defaultRenderEmpty = __webpack_require__(88258);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/DisabledContext.js
|
|
var DisabledContext = __webpack_require__(98866);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/SizeContext.js
|
|
var SizeContext = __webpack_require__(97647);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/form/context.js
|
|
var form_context = __webpack_require__(65223);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/select/utils/iconUtil.js
|
|
var iconUtil = __webpack_require__(46163);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/tree/utils/iconUtil.js + 4 modules
|
|
var utils_iconUtil = __webpack_require__(84050);
|
|
// 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/space/Compact.js
|
|
var Compact = __webpack_require__(4173);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/tree-select/index.js
|
|
|
|
|
|
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;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var InternalTreeSelect = function InternalTreeSelect(_a, ref) {
|
|
var _classNames2;
|
|
var customizePrefixCls = _a.prefixCls,
|
|
customizeSize = _a.size,
|
|
customDisabled = _a.disabled,
|
|
_a$bordered = _a.bordered,
|
|
bordered = _a$bordered === void 0 ? true : _a$bordered,
|
|
className = _a.className,
|
|
treeCheckable = _a.treeCheckable,
|
|
multiple = _a.multiple,
|
|
_a$listHeight = _a.listHeight,
|
|
listHeight = _a$listHeight === void 0 ? 256 : _a$listHeight,
|
|
_a$listItemHeight = _a.listItemHeight,
|
|
listItemHeight = _a$listItemHeight === void 0 ? 26 : _a$listItemHeight,
|
|
placement = _a.placement,
|
|
notFoundContent = _a.notFoundContent,
|
|
_switcherIcon = _a.switcherIcon,
|
|
treeLine = _a.treeLine,
|
|
getPopupContainer = _a.getPopupContainer,
|
|
dropdownClassName = _a.dropdownClassName,
|
|
popupClassName = _a.popupClassName,
|
|
_a$treeIcon = _a.treeIcon,
|
|
treeIcon = _a$treeIcon === void 0 ? false : _a$treeIcon,
|
|
transitionName = _a.transitionName,
|
|
_a$choiceTransitionNa = _a.choiceTransitionName,
|
|
choiceTransitionName = _a$choiceTransitionNa === void 0 ? '' : _a$choiceTransitionNa,
|
|
customStatus = _a.status,
|
|
showArrow = _a.showArrow,
|
|
treeExpandAction = _a.treeExpandAction,
|
|
props = __rest(_a, ["prefixCls", "size", "disabled", "bordered", "className", "treeCheckable", "multiple", "listHeight", "listItemHeight", "placement", "notFoundContent", "switcherIcon", "treeLine", "getPopupContainer", "dropdownClassName", "popupClassName", "treeIcon", "transitionName", "choiceTransitionName", "status", "showArrow", "treeExpandAction"]);
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getContextPopupContainer = _React$useContext.getPopupContainer,
|
|
getPrefixCls = _React$useContext.getPrefixCls,
|
|
renderEmpty = _React$useContext.renderEmpty,
|
|
direction = _React$useContext.direction,
|
|
virtual = _React$useContext.virtual,
|
|
dropdownMatchSelectWidth = _React$useContext.dropdownMatchSelectWidth;
|
|
var size = react.useContext(SizeContext/* default */.Z);
|
|
false ? 0 : void 0;
|
|
false ? 0 : void 0;
|
|
var prefixCls = getPrefixCls('select', customizePrefixCls);
|
|
var treePrefixCls = getPrefixCls('select-tree', customizePrefixCls);
|
|
var treeSelectPrefixCls = getPrefixCls('tree-select', customizePrefixCls);
|
|
var _useCompactItemContex = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction),
|
|
compactSize = _useCompactItemContex.compactSize,
|
|
compactItemClassnames = _useCompactItemContex.compactItemClassnames;
|
|
var mergedDropdownClassName = classnames_default()(popupClassName || dropdownClassName, "".concat(treeSelectPrefixCls, "-dropdown"), (0,defineProperty/* default */.Z)({}, "".concat(treeSelectPrefixCls, "-dropdown-rtl"), direction === 'rtl'));
|
|
var isMultiple = !!(treeCheckable || multiple);
|
|
var mergedShowArrow = showArrow !== undefined ? showArrow : props.loading || !isMultiple;
|
|
// ===================== Form =====================
|
|
var _useContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM),
|
|
contextStatus = _useContext.status,
|
|
hasFeedback = _useContext.hasFeedback,
|
|
isFormItemInput = _useContext.isFormItemInput,
|
|
feedbackIcon = _useContext.feedbackIcon;
|
|
var mergedStatus = (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus);
|
|
// ===================== Icons =====================
|
|
var _getIcons = (0,iconUtil/* default */.Z)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, props), {
|
|
multiple: isMultiple,
|
|
showArrow: mergedShowArrow,
|
|
hasFeedback: hasFeedback,
|
|
feedbackIcon: feedbackIcon,
|
|
prefixCls: prefixCls
|
|
})),
|
|
suffixIcon = _getIcons.suffixIcon,
|
|
removeIcon = _getIcons.removeIcon,
|
|
clearIcon = _getIcons.clearIcon;
|
|
// ===================== Empty =====================
|
|
var mergedNotFound;
|
|
if (notFoundContent !== undefined) {
|
|
mergedNotFound = notFoundContent;
|
|
} else {
|
|
mergedNotFound = (renderEmpty || defaultRenderEmpty/* default */.Z)('Select');
|
|
}
|
|
// ==================== Render =====================
|
|
var selectProps = (0,omit/* default */.Z)(props, ['suffixIcon', 'itemIcon', 'removeIcon', 'clearIcon', 'switcherIcon']);
|
|
// ===================== Placement =====================
|
|
var getPlacement = function getPlacement() {
|
|
if (placement !== undefined) {
|
|
return placement;
|
|
}
|
|
return direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
|
|
};
|
|
var mergedSize = compactSize || customizeSize || size;
|
|
// ===================== Disabled =====================
|
|
var disabled = react.useContext(DisabledContext/* default */.Z);
|
|
var mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
var mergedClassName = classnames_default()(!customizePrefixCls && treeSelectPrefixCls, (_classNames2 = {}, (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-lg"), mergedSize === 'large'), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-sm"), mergedSize === 'small'), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-borderless"), !bordered), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-in-form-item"), isFormItemInput), _classNames2), (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, mergedStatus, hasFeedback), compactItemClassnames, className);
|
|
var rootPrefixCls = getPrefixCls();
|
|
return /*#__PURE__*/react.createElement(rc_tree_select_es, (0,esm_extends/* default */.Z)({
|
|
virtual: virtual,
|
|
dropdownMatchSelectWidth: dropdownMatchSelectWidth,
|
|
disabled: mergedDisabled
|
|
}, selectProps, {
|
|
ref: ref,
|
|
prefixCls: prefixCls,
|
|
className: mergedClassName,
|
|
listHeight: listHeight,
|
|
listItemHeight: listItemHeight,
|
|
treeCheckable: treeCheckable ? /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-tree-checkbox-inner")
|
|
}) : treeCheckable,
|
|
treeLine: !!treeLine,
|
|
inputIcon: suffixIcon,
|
|
multiple: multiple,
|
|
placement: getPlacement(),
|
|
removeIcon: removeIcon,
|
|
clearIcon: clearIcon,
|
|
switcherIcon: function switcherIcon(nodeProps) {
|
|
return (0,utils_iconUtil/* default */.Z)(treePrefixCls, _switcherIcon, treeLine, nodeProps);
|
|
},
|
|
showTreeIcon: treeIcon,
|
|
notFoundContent: mergedNotFound,
|
|
getPopupContainer: getPopupContainer || getContextPopupContainer,
|
|
treeMotion: null,
|
|
dropdownClassName: mergedDropdownClassName,
|
|
choiceTransitionName: (0,motion/* getTransitionName */.mL)(rootPrefixCls, '', choiceTransitionName),
|
|
transitionName: (0,motion/* getTransitionName */.mL)(rootPrefixCls, (0,motion/* getTransitionDirection */.q0)(placement), transitionName),
|
|
showArrow: hasFeedback || showArrow,
|
|
treeExpandAction: treeExpandAction
|
|
}));
|
|
};
|
|
var TreeSelectRef = /*#__PURE__*/react.forwardRef(InternalTreeSelect);
|
|
var tree_select_TreeSelect = TreeSelectRef;
|
|
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;
|
|
|
|
/* harmony default export */ var tree_select = (tree_select_TreeSelect);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5830:
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/antd/es/tree-select/style/index.js + 1 modules ***!
|
|
\*********************************************************************/
|
|
/***/ (function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/default.less
|
|
var style_default = __webpack_require__(43146);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/tree-select/style/index.less
|
|
// extracted by mini-css-extract-plugin
|
|
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/empty/style/index.js + 1 modules
|
|
var style = __webpack_require__(81151);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/select/style/index.js + 1 modules
|
|
var select_style = __webpack_require__(95985);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/tree-select/style/index.js
|
|
|
|
|
|
// style dependencies
|
|
// deps-lint-skip: tree, form, space
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
}]); |