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.
838 lines
30 KiB
838 lines
30 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[78782],{
|
|
|
|
/***/ 98447:
|
|
/*!******************************************************************!*\
|
|
!*** ./node_modules/_antd@5.9.0@antd/es/checkbox/style/index.js ***!
|
|
\******************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ C2: function() { return /* binding */ getStyle; }
|
|
/* harmony export */ });
|
|
/* unused harmony export genCheckboxStyle */
|
|
/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../style */ 17313);
|
|
/* harmony import */ var _theme_internal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../theme/internal */ 37613);
|
|
/* harmony import */ var _theme_internal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../theme/internal */ 83116);
|
|
|
|
|
|
// ============================== Styles ==============================
|
|
const genCheckboxStyle = token => {
|
|
const {
|
|
checkboxCls
|
|
} = token;
|
|
const wrapperCls = `${checkboxCls}-wrapper`;
|
|
return [
|
|
// ===================== Basic =====================
|
|
{
|
|
// Group
|
|
[`${checkboxCls}-group`]: Object.assign(Object.assign({}, (0,_style__WEBPACK_IMPORTED_MODULE_0__/* .resetComponent */ .Wf)(token)), {
|
|
display: 'inline-flex',
|
|
flexWrap: 'wrap',
|
|
columnGap: token.marginXS,
|
|
// Group > Grid
|
|
[`> ${token.antCls}-row`]: {
|
|
flex: 1
|
|
}
|
|
}),
|
|
// Wrapper
|
|
[wrapperCls]: Object.assign(Object.assign({}, (0,_style__WEBPACK_IMPORTED_MODULE_0__/* .resetComponent */ .Wf)(token)), {
|
|
display: 'inline-flex',
|
|
alignItems: 'baseline',
|
|
cursor: 'pointer',
|
|
// Fix checkbox & radio in flex align #30260
|
|
'&:after': {
|
|
display: 'inline-block',
|
|
width: 0,
|
|
overflow: 'hidden',
|
|
content: "'\\a0'"
|
|
},
|
|
// Checkbox near checkbox
|
|
[`& + ${wrapperCls}`]: {
|
|
marginInlineStart: 0
|
|
},
|
|
[`&${wrapperCls}-in-form-item`]: {
|
|
'input[type="checkbox"]': {
|
|
width: 14,
|
|
height: 14 // FIXME: magic
|
|
}
|
|
}
|
|
}),
|
|
|
|
// Wrapper > Checkbox
|
|
[checkboxCls]: Object.assign(Object.assign({}, (0,_style__WEBPACK_IMPORTED_MODULE_0__/* .resetComponent */ .Wf)(token)), {
|
|
position: 'relative',
|
|
whiteSpace: 'nowrap',
|
|
lineHeight: 1,
|
|
cursor: 'pointer',
|
|
borderRadius: token.borderRadiusSM,
|
|
// To make alignment right when `controlHeight` is changed
|
|
// Ref: https://github.com/ant-design/ant-design/issues/41564
|
|
alignSelf: 'center',
|
|
// Wrapper > Checkbox > input
|
|
[`${checkboxCls}-input`]: {
|
|
position: 'absolute',
|
|
// Since baseline align will get additional space offset,
|
|
// we need to move input to top to make it align with text.
|
|
// Ref: https://github.com/ant-design/ant-design/issues/38926#issuecomment-1486137799
|
|
inset: 0,
|
|
zIndex: 1,
|
|
cursor: 'pointer',
|
|
opacity: 0,
|
|
margin: 0,
|
|
[`&:focus-visible + ${checkboxCls}-inner`]: Object.assign({}, (0,_style__WEBPACK_IMPORTED_MODULE_0__/* .genFocusOutline */ .oN)(token))
|
|
},
|
|
// Wrapper > Checkbox > inner
|
|
[`${checkboxCls}-inner`]: {
|
|
boxSizing: 'border-box',
|
|
position: 'relative',
|
|
top: 0,
|
|
insetInlineStart: 0,
|
|
display: 'block',
|
|
width: token.checkboxSize,
|
|
height: token.checkboxSize,
|
|
direction: 'ltr',
|
|
backgroundColor: token.colorBgContainer,
|
|
border: `${token.lineWidth}px ${token.lineType} ${token.colorBorder}`,
|
|
borderRadius: token.borderRadiusSM,
|
|
borderCollapse: 'separate',
|
|
transition: `all ${token.motionDurationSlow}`,
|
|
'&:after': {
|
|
boxSizing: 'border-box',
|
|
position: 'absolute',
|
|
top: '50%',
|
|
insetInlineStart: '21.5%',
|
|
display: 'table',
|
|
width: token.checkboxSize / 14 * 5,
|
|
height: token.checkboxSize / 14 * 8,
|
|
border: `${token.lineWidthBold}px solid ${token.colorWhite}`,
|
|
borderTop: 0,
|
|
borderInlineStart: 0,
|
|
transform: 'rotate(45deg) scale(0) translate(-50%,-50%)',
|
|
opacity: 0,
|
|
content: '""',
|
|
transition: `all ${token.motionDurationFast} ${token.motionEaseInBack}, opacity ${token.motionDurationFast}`
|
|
}
|
|
},
|
|
// Wrapper > Checkbox + Text
|
|
'& + span': {
|
|
paddingInlineStart: token.paddingXS,
|
|
paddingInlineEnd: token.paddingXS
|
|
}
|
|
})
|
|
},
|
|
// ===================== Hover =====================
|
|
{
|
|
// Wrapper & Wrapper > Checkbox
|
|
[`
|
|
${wrapperCls}:not(${wrapperCls}-disabled),
|
|
${checkboxCls}:not(${checkboxCls}-disabled)
|
|
`]: {
|
|
[`&:hover ${checkboxCls}-inner`]: {
|
|
borderColor: token.colorPrimary
|
|
}
|
|
},
|
|
[`${wrapperCls}:not(${wrapperCls}-disabled)`]: {
|
|
[`&:hover ${checkboxCls}-checked:not(${checkboxCls}-disabled) ${checkboxCls}-inner`]: {
|
|
backgroundColor: token.colorPrimaryHover,
|
|
borderColor: 'transparent'
|
|
},
|
|
[`&:hover ${checkboxCls}-checked:not(${checkboxCls}-disabled):after`]: {
|
|
borderColor: token.colorPrimaryHover
|
|
}
|
|
}
|
|
},
|
|
// ==================== Checked ====================
|
|
{
|
|
// Wrapper > Checkbox
|
|
[`${checkboxCls}-checked`]: {
|
|
[`${checkboxCls}-inner`]: {
|
|
backgroundColor: token.colorPrimary,
|
|
borderColor: token.colorPrimary,
|
|
'&:after': {
|
|
opacity: 1,
|
|
transform: 'rotate(45deg) scale(1) translate(-50%,-50%)',
|
|
transition: `all ${token.motionDurationMid} ${token.motionEaseOutBack} ${token.motionDurationFast}`
|
|
}
|
|
}
|
|
},
|
|
[`
|
|
${wrapperCls}-checked:not(${wrapperCls}-disabled),
|
|
${checkboxCls}-checked:not(${checkboxCls}-disabled)
|
|
`]: {
|
|
[`&:hover ${checkboxCls}-inner`]: {
|
|
backgroundColor: token.colorPrimaryHover,
|
|
borderColor: 'transparent'
|
|
}
|
|
}
|
|
},
|
|
// ================= Indeterminate =================
|
|
{
|
|
[checkboxCls]: {
|
|
'&-indeterminate': {
|
|
// Wrapper > Checkbox > inner
|
|
[`${checkboxCls}-inner`]: {
|
|
backgroundColor: token.colorBgContainer,
|
|
borderColor: token.colorBorder,
|
|
'&:after': {
|
|
top: '50%',
|
|
insetInlineStart: '50%',
|
|
width: token.fontSizeLG / 2,
|
|
height: token.fontSizeLG / 2,
|
|
backgroundColor: token.colorPrimary,
|
|
border: 0,
|
|
transform: 'translate(-50%, -50%) scale(1)',
|
|
opacity: 1,
|
|
content: '""'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// ==================== Disable ====================
|
|
{
|
|
// Wrapper
|
|
[`${wrapperCls}-disabled`]: {
|
|
cursor: 'not-allowed'
|
|
},
|
|
// Wrapper > Checkbox
|
|
[`${checkboxCls}-disabled`]: {
|
|
// Wrapper > Checkbox > input
|
|
[`&, ${checkboxCls}-input`]: {
|
|
cursor: 'not-allowed',
|
|
// Disabled for native input to enable Tooltip event handler
|
|
// ref: https://github.com/ant-design/ant-design/issues/39822#issuecomment-1365075901
|
|
pointerEvents: 'none'
|
|
},
|
|
// Wrapper > Checkbox > inner
|
|
[`${checkboxCls}-inner`]: {
|
|
background: token.colorBgContainerDisabled,
|
|
borderColor: token.colorBorder,
|
|
'&:after': {
|
|
borderColor: token.colorTextDisabled
|
|
}
|
|
},
|
|
'&:after': {
|
|
display: 'none'
|
|
},
|
|
'& + span': {
|
|
color: token.colorTextDisabled
|
|
},
|
|
[`&${checkboxCls}-indeterminate ${checkboxCls}-inner::after`]: {
|
|
background: token.colorTextDisabled
|
|
}
|
|
}
|
|
}];
|
|
};
|
|
// ============================== Export ==============================
|
|
function getStyle(prefixCls, token) {
|
|
const checkboxToken = (0,_theme_internal__WEBPACK_IMPORTED_MODULE_1__/* .merge */ .TS)(token, {
|
|
checkboxCls: `.${prefixCls}`,
|
|
checkboxSize: token.controlInteractiveSize
|
|
});
|
|
return [genCheckboxStyle(checkboxToken)];
|
|
}
|
|
/* harmony default export */ __webpack_exports__.ZP = ((0,_theme_internal__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)('Checkbox', (token, _ref) => {
|
|
let {
|
|
prefixCls
|
|
} = _ref;
|
|
return [getStyle(prefixCls, token)];
|
|
}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 90782:
|
|
/*!**********************************************************************!*\
|
|
!*** ./node_modules/_rc-tree@5.7.12@rc-tree/es/utils/conductUtil.js ***!
|
|
\**********************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ S: function() { return /* binding */ conductCheck; }
|
|
/* harmony export */ });
|
|
/* unused harmony export isCheckDisabled */
|
|
/* harmony import */ var rc_util_es_warning__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! rc-util/es/warning */ 48736);
|
|
/* harmony import */ var _keyUtil__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./keyUtil */ 67841);
|
|
|
|
|
|
function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
|
|
var filteredKeys = new Set();
|
|
halfCheckedKeys.forEach(function (key) {
|
|
if (!checkedKeys.has(key)) {
|
|
filteredKeys.add(key);
|
|
}
|
|
});
|
|
return filteredKeys;
|
|
}
|
|
function isCheckDisabled(node) {
|
|
var _ref = node || {},
|
|
disabled = _ref.disabled,
|
|
disableCheckbox = _ref.disableCheckbox,
|
|
checkable = _ref.checkable;
|
|
return !!(disabled || disableCheckbox) || checkable === false;
|
|
}
|
|
// Fill miss keys
|
|
function fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
|
|
var checkedKeys = new Set(keys);
|
|
var halfCheckedKeys = new Set();
|
|
// Add checked keys top to bottom
|
|
for (var level = 0; level <= maxLevel; level += 1) {
|
|
var entities = levelEntities.get(level) || new Set();
|
|
entities.forEach(function (entity) {
|
|
var key = entity.key,
|
|
node = entity.node,
|
|
_entity$children = entity.children,
|
|
children = _entity$children === void 0 ? [] : _entity$children;
|
|
if (checkedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
|
|
children.filter(function (childEntity) {
|
|
return !syntheticGetCheckDisabled(childEntity.node);
|
|
}).forEach(function (childEntity) {
|
|
checkedKeys.add(childEntity.key);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
// Add checked keys from bottom to top
|
|
var visitedKeys = new Set();
|
|
for (var _level = maxLevel; _level >= 0; _level -= 1) {
|
|
var _entities = levelEntities.get(_level) || new Set();
|
|
_entities.forEach(function (entity) {
|
|
var parent = entity.parent,
|
|
node = entity.node;
|
|
// Skip if no need to check
|
|
if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
|
|
return;
|
|
}
|
|
// Skip if parent is disabled
|
|
if (syntheticGetCheckDisabled(entity.parent.node)) {
|
|
visitedKeys.add(parent.key);
|
|
return;
|
|
}
|
|
var allChecked = true;
|
|
var partialChecked = false;
|
|
(parent.children || []).filter(function (childEntity) {
|
|
return !syntheticGetCheckDisabled(childEntity.node);
|
|
}).forEach(function (_ref2) {
|
|
var key = _ref2.key;
|
|
var checked = checkedKeys.has(key);
|
|
if (allChecked && !checked) {
|
|
allChecked = false;
|
|
}
|
|
if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
|
|
partialChecked = true;
|
|
}
|
|
});
|
|
if (allChecked) {
|
|
checkedKeys.add(parent.key);
|
|
}
|
|
if (partialChecked) {
|
|
halfCheckedKeys.add(parent.key);
|
|
}
|
|
visitedKeys.add(parent.key);
|
|
});
|
|
}
|
|
return {
|
|
checkedKeys: Array.from(checkedKeys),
|
|
halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
|
|
};
|
|
}
|
|
// Remove useless key
|
|
function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
|
|
var checkedKeys = new Set(keys);
|
|
var halfCheckedKeys = new Set(halfKeys);
|
|
// Remove checked keys from top to bottom
|
|
for (var level = 0; level <= maxLevel; level += 1) {
|
|
var entities = levelEntities.get(level) || new Set();
|
|
entities.forEach(function (entity) {
|
|
var key = entity.key,
|
|
node = entity.node,
|
|
_entity$children2 = entity.children,
|
|
children = _entity$children2 === void 0 ? [] : _entity$children2;
|
|
if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
|
|
children.filter(function (childEntity) {
|
|
return !syntheticGetCheckDisabled(childEntity.node);
|
|
}).forEach(function (childEntity) {
|
|
checkedKeys.delete(childEntity.key);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
// Remove checked keys form bottom to top
|
|
halfCheckedKeys = new Set();
|
|
var visitedKeys = new Set();
|
|
for (var _level2 = maxLevel; _level2 >= 0; _level2 -= 1) {
|
|
var _entities2 = levelEntities.get(_level2) || new Set();
|
|
_entities2.forEach(function (entity) {
|
|
var parent = entity.parent,
|
|
node = entity.node;
|
|
// Skip if no need to check
|
|
if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
|
|
return;
|
|
}
|
|
// Skip if parent is disabled
|
|
if (syntheticGetCheckDisabled(entity.parent.node)) {
|
|
visitedKeys.add(parent.key);
|
|
return;
|
|
}
|
|
var allChecked = true;
|
|
var partialChecked = false;
|
|
(parent.children || []).filter(function (childEntity) {
|
|
return !syntheticGetCheckDisabled(childEntity.node);
|
|
}).forEach(function (_ref3) {
|
|
var key = _ref3.key;
|
|
var checked = checkedKeys.has(key);
|
|
if (allChecked && !checked) {
|
|
allChecked = false;
|
|
}
|
|
if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
|
|
partialChecked = true;
|
|
}
|
|
});
|
|
if (!allChecked) {
|
|
checkedKeys.delete(parent.key);
|
|
}
|
|
if (partialChecked) {
|
|
halfCheckedKeys.add(parent.key);
|
|
}
|
|
visitedKeys.add(parent.key);
|
|
});
|
|
}
|
|
return {
|
|
checkedKeys: Array.from(checkedKeys),
|
|
halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
|
|
};
|
|
}
|
|
/**
|
|
* Conduct with keys.
|
|
* @param keyList current key list
|
|
* @param keyEntities key - dataEntity map
|
|
* @param mode `fill` to fill missing key, `clean` to remove useless key
|
|
*/
|
|
function conductCheck(keyList, checked, keyEntities, getCheckDisabled) {
|
|
var warningMissKeys = [];
|
|
var syntheticGetCheckDisabled;
|
|
if (getCheckDisabled) {
|
|
syntheticGetCheckDisabled = getCheckDisabled;
|
|
} else {
|
|
syntheticGetCheckDisabled = isCheckDisabled;
|
|
}
|
|
// We only handle exist keys
|
|
var keys = new Set(keyList.filter(function (key) {
|
|
var hasEntity = !!(0,_keyUtil__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(keyEntities, key);
|
|
if (!hasEntity) {
|
|
warningMissKeys.push(key);
|
|
}
|
|
return hasEntity;
|
|
}));
|
|
var levelEntities = new Map();
|
|
var maxLevel = 0;
|
|
// Convert entities by level for calculation
|
|
Object.keys(keyEntities).forEach(function (key) {
|
|
var entity = keyEntities[key];
|
|
var level = entity.level;
|
|
var levelSet = levelEntities.get(level);
|
|
if (!levelSet) {
|
|
levelSet = new Set();
|
|
levelEntities.set(level, levelSet);
|
|
}
|
|
levelSet.add(entity);
|
|
maxLevel = Math.max(maxLevel, level);
|
|
});
|
|
(0,rc_util_es_warning__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(!warningMissKeys.length, "Tree missing follow keys: ".concat(warningMissKeys.slice(0, 100).map(function (key) {
|
|
return "'".concat(key, "'");
|
|
}).join(', ')));
|
|
var result;
|
|
if (checked === true) {
|
|
result = fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled);
|
|
} else {
|
|
result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel, syntheticGetCheckDisabled);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 67841:
|
|
/*!******************************************************************!*\
|
|
!*** ./node_modules/_rc-tree@5.7.12@rc-tree/es/utils/keyUtil.js ***!
|
|
\******************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ Z: function() { return /* binding */ getEntity; }
|
|
/* harmony export */ });
|
|
function getEntity(keyEntities, key) {
|
|
return keyEntities[key];
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 71430:
|
|
/*!*******************************************************************!*\
|
|
!*** ./node_modules/_rc-tree@5.7.12@rc-tree/es/utils/treeUtil.js ***!
|
|
\*******************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ F: function() { return /* binding */ convertNodePropsToEventData; },
|
|
/* harmony export */ H8: function() { return /* binding */ getTreeNodeProps; },
|
|
/* harmony export */ I8: function() { return /* binding */ convertDataToEntities; },
|
|
/* harmony export */ km: function() { return /* binding */ getKey; },
|
|
/* harmony export */ oH: function() { return /* binding */ flattenTreeData; },
|
|
/* harmony export */ w$: function() { return /* binding */ fillFieldNames; },
|
|
/* harmony export */ zn: function() { return /* binding */ convertTreeToData; }
|
|
/* harmony export */ });
|
|
/* unused harmony exports getPosition, isTreeNode, warningWithoutKey, traverseDataNodes */
|
|
/* harmony import */ var _babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/esm/typeof */ 93664);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/esm/toConsumableArray */ 95190);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/esm/objectSpread2 */ 20439);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/esm/objectWithoutProperties */ 62646);
|
|
/* harmony import */ var rc_util_es_Children_toArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! rc-util/es/Children/toArray */ 11592);
|
|
/* harmony import */ var rc_util_es_omit__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! rc-util/es/omit */ 2738);
|
|
/* harmony import */ var rc_util_es_warning__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! rc-util/es/warning */ 48736);
|
|
/* harmony import */ var _keyUtil__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./keyUtil */ 67841);
|
|
|
|
|
|
|
|
|
|
var _excluded = ["children"];
|
|
|
|
|
|
|
|
|
|
function getPosition(level, index) {
|
|
return "".concat(level, "-").concat(index);
|
|
}
|
|
function isTreeNode(node) {
|
|
return node && node.type && node.type.isTreeNode;
|
|
}
|
|
function getKey(key, pos) {
|
|
if (key !== null && key !== undefined) {
|
|
return key;
|
|
}
|
|
return pos;
|
|
}
|
|
function fillFieldNames(fieldNames) {
|
|
var _ref = fieldNames || {},
|
|
title = _ref.title,
|
|
_title = _ref._title,
|
|
key = _ref.key,
|
|
children = _ref.children;
|
|
var mergedTitle = title || 'title';
|
|
return {
|
|
title: mergedTitle,
|
|
_title: _title || [mergedTitle],
|
|
key: key || 'key',
|
|
children: children || 'children'
|
|
};
|
|
}
|
|
/**
|
|
* Warning if TreeNode do not provides key
|
|
*/
|
|
function warningWithoutKey(treeData, fieldNames) {
|
|
var keys = new Map();
|
|
function dig(list) {
|
|
var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
|
|
(list || []).forEach(function (treeNode) {
|
|
var key = treeNode[fieldNames.key];
|
|
var children = treeNode[fieldNames.children];
|
|
warning(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
|
|
var recordKey = String(key);
|
|
warning(!keys.has(recordKey) || key === null || key === undefined, "Same 'key' exist in the Tree: ".concat(recordKey));
|
|
keys.set(recordKey, true);
|
|
dig(children, "".concat(path).concat(recordKey, " > "));
|
|
});
|
|
}
|
|
dig(treeData);
|
|
}
|
|
/**
|
|
* Convert `children` of Tree into `treeData` structure.
|
|
*/
|
|
function convertTreeToData(rootNodes) {
|
|
function dig(node) {
|
|
var treeNodes = (0,rc_util_es_Children_toArray__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(node);
|
|
return treeNodes.map(function (treeNode) {
|
|
// Filter invalidate node
|
|
if (!isTreeNode(treeNode)) {
|
|
(0,rc_util_es_warning__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP)(!treeNode, 'Tree/TreeNode can only accept TreeNode as children.');
|
|
return null;
|
|
}
|
|
var key = treeNode.key;
|
|
var _treeNode$props = treeNode.props,
|
|
children = _treeNode$props.children,
|
|
rest = (0,_babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(_treeNode$props, _excluded);
|
|
var dataNode = (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)({
|
|
key: key
|
|
}, rest);
|
|
var parsedChildren = dig(children);
|
|
if (parsedChildren.length) {
|
|
dataNode.children = parsedChildren;
|
|
}
|
|
return dataNode;
|
|
}).filter(function (dataNode) {
|
|
return dataNode;
|
|
});
|
|
}
|
|
return dig(rootNodes);
|
|
}
|
|
/**
|
|
* Flat nest tree data into flatten list. This is used for virtual list render.
|
|
* @param treeNodeList Origin data node list
|
|
* @param expandedKeys
|
|
* need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
|
|
*/
|
|
function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
|
|
var _fillFieldNames = fillFieldNames(fieldNames),
|
|
fieldTitles = _fillFieldNames._title,
|
|
fieldKey = _fillFieldNames.key,
|
|
fieldChildren = _fillFieldNames.children;
|
|
var expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
|
|
var flattenList = [];
|
|
function dig(list) {
|
|
var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
return list.map(function (treeNode, index) {
|
|
var pos = getPosition(parent ? parent.pos : '0', index);
|
|
var mergedKey = getKey(treeNode[fieldKey], pos);
|
|
// Pick matched title in field title list
|
|
var mergedTitle;
|
|
for (var i = 0; i < fieldTitles.length; i += 1) {
|
|
var fieldTitle = fieldTitles[i];
|
|
if (treeNode[fieldTitle] !== undefined) {
|
|
mergedTitle = treeNode[fieldTitle];
|
|
break;
|
|
}
|
|
}
|
|
// Add FlattenDataNode into list
|
|
var flattenNode = (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)({}, (0,rc_util_es_omit__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(treeNode, [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(fieldTitles), [fieldKey, fieldChildren]))), {}, {
|
|
title: mergedTitle,
|
|
key: mergedKey,
|
|
parent: parent,
|
|
pos: pos,
|
|
children: null,
|
|
data: treeNode,
|
|
isStart: [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(parent ? parent.isStart : []), [index === 0]),
|
|
isEnd: [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(parent ? parent.isEnd : []), [index === list.length - 1])
|
|
});
|
|
flattenList.push(flattenNode);
|
|
// Loop treeNode children
|
|
if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
|
|
flattenNode.children = dig(treeNode[fieldChildren] || [], flattenNode);
|
|
} else {
|
|
flattenNode.children = [];
|
|
}
|
|
return flattenNode;
|
|
});
|
|
}
|
|
dig(treeNodeList);
|
|
return flattenList;
|
|
}
|
|
/**
|
|
* Traverse all the data by `treeData`.
|
|
* Please not use it out of the `rc-tree` since we may refactor this code.
|
|
*/
|
|
function traverseDataNodes(dataNodes, callback,
|
|
// To avoid too many params, let use config instead of origin param
|
|
config) {
|
|
var mergedConfig = {};
|
|
if ((0,_babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)(config) === 'object') {
|
|
mergedConfig = config;
|
|
} else {
|
|
mergedConfig = {
|
|
externalGetKey: config
|
|
};
|
|
}
|
|
mergedConfig = mergedConfig || {};
|
|
// Init config
|
|
var _mergedConfig = mergedConfig,
|
|
childrenPropName = _mergedConfig.childrenPropName,
|
|
externalGetKey = _mergedConfig.externalGetKey,
|
|
fieldNames = _mergedConfig.fieldNames;
|
|
var _fillFieldNames2 = fillFieldNames(fieldNames),
|
|
fieldKey = _fillFieldNames2.key,
|
|
fieldChildren = _fillFieldNames2.children;
|
|
var mergeChildrenPropName = childrenPropName || fieldChildren;
|
|
// Get keys
|
|
var syntheticGetKey;
|
|
if (externalGetKey) {
|
|
if (typeof externalGetKey === 'string') {
|
|
syntheticGetKey = function syntheticGetKey(node) {
|
|
return node[externalGetKey];
|
|
};
|
|
} else if (typeof externalGetKey === 'function') {
|
|
syntheticGetKey = function syntheticGetKey(node) {
|
|
return externalGetKey(node);
|
|
};
|
|
}
|
|
} else {
|
|
syntheticGetKey = function syntheticGetKey(node, pos) {
|
|
return getKey(node[fieldKey], pos);
|
|
};
|
|
}
|
|
// Process
|
|
function processNode(node, index, parent, pathNodes) {
|
|
var children = node ? node[mergeChildrenPropName] : dataNodes;
|
|
var pos = node ? getPosition(parent.pos, index) : '0';
|
|
var connectNodes = node ? [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(pathNodes), [node]) : [];
|
|
// Process node if is not root
|
|
if (node) {
|
|
var key = syntheticGetKey(node, pos);
|
|
var data = {
|
|
node: node,
|
|
index: index,
|
|
pos: pos,
|
|
key: key,
|
|
parentPos: parent.node ? parent.pos : null,
|
|
level: parent.level + 1,
|
|
nodes: connectNodes
|
|
};
|
|
callback(data);
|
|
}
|
|
// Process children node
|
|
if (children) {
|
|
children.forEach(function (subNode, subIndex) {
|
|
processNode(subNode, subIndex, {
|
|
node: node,
|
|
pos: pos,
|
|
level: parent ? parent.level + 1 : -1
|
|
}, connectNodes);
|
|
});
|
|
}
|
|
}
|
|
processNode(null);
|
|
}
|
|
/**
|
|
* Convert `treeData` into entity records.
|
|
*/
|
|
function convertDataToEntities(dataNodes) {
|
|
var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
|
initWrapper = _ref2.initWrapper,
|
|
processEntity = _ref2.processEntity,
|
|
onProcessFinished = _ref2.onProcessFinished,
|
|
externalGetKey = _ref2.externalGetKey,
|
|
childrenPropName = _ref2.childrenPropName,
|
|
fieldNames = _ref2.fieldNames;
|
|
var /** @deprecated Use `config.externalGetKey` instead */
|
|
legacyExternalGetKey = arguments.length > 2 ? arguments[2] : undefined;
|
|
// Init config
|
|
var mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
|
|
var posEntities = {};
|
|
var keyEntities = {};
|
|
var wrapper = {
|
|
posEntities: posEntities,
|
|
keyEntities: keyEntities
|
|
};
|
|
if (initWrapper) {
|
|
wrapper = initWrapper(wrapper) || wrapper;
|
|
}
|
|
traverseDataNodes(dataNodes, function (item) {
|
|
var node = item.node,
|
|
index = item.index,
|
|
pos = item.pos,
|
|
key = item.key,
|
|
parentPos = item.parentPos,
|
|
level = item.level,
|
|
nodes = item.nodes;
|
|
var entity = {
|
|
node: node,
|
|
nodes: nodes,
|
|
index: index,
|
|
key: key,
|
|
pos: pos,
|
|
level: level
|
|
};
|
|
var mergedKey = getKey(key, pos);
|
|
posEntities[pos] = entity;
|
|
keyEntities[mergedKey] = entity;
|
|
// Fill children
|
|
entity.parent = posEntities[parentPos];
|
|
if (entity.parent) {
|
|
entity.parent.children = entity.parent.children || [];
|
|
entity.parent.children.push(entity);
|
|
}
|
|
if (processEntity) {
|
|
processEntity(entity, wrapper);
|
|
}
|
|
}, {
|
|
externalGetKey: mergedExternalGetKey,
|
|
childrenPropName: childrenPropName,
|
|
fieldNames: fieldNames
|
|
});
|
|
if (onProcessFinished) {
|
|
onProcessFinished(wrapper);
|
|
}
|
|
return wrapper;
|
|
}
|
|
/**
|
|
* Get TreeNode props with Tree props.
|
|
*/
|
|
function getTreeNodeProps(key, _ref3) {
|
|
var expandedKeys = _ref3.expandedKeys,
|
|
selectedKeys = _ref3.selectedKeys,
|
|
loadedKeys = _ref3.loadedKeys,
|
|
loadingKeys = _ref3.loadingKeys,
|
|
checkedKeys = _ref3.checkedKeys,
|
|
halfCheckedKeys = _ref3.halfCheckedKeys,
|
|
dragOverNodeKey = _ref3.dragOverNodeKey,
|
|
dropPosition = _ref3.dropPosition,
|
|
keyEntities = _ref3.keyEntities;
|
|
var entity = (0,_keyUtil__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z)(keyEntities, key);
|
|
var treeNodeProps = {
|
|
eventKey: key,
|
|
expanded: expandedKeys.indexOf(key) !== -1,
|
|
selected: selectedKeys.indexOf(key) !== -1,
|
|
loaded: loadedKeys.indexOf(key) !== -1,
|
|
loading: loadingKeys.indexOf(key) !== -1,
|
|
checked: checkedKeys.indexOf(key) !== -1,
|
|
halfChecked: halfCheckedKeys.indexOf(key) !== -1,
|
|
pos: String(entity ? entity.pos : ''),
|
|
// [Legacy] Drag props
|
|
// Since the interaction of drag is changed, the semantic of the props are
|
|
// not accuracy, I think it should be finally removed
|
|
dragOver: dragOverNodeKey === key && dropPosition === 0,
|
|
dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
|
|
dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
|
|
};
|
|
return treeNodeProps;
|
|
}
|
|
function convertNodePropsToEventData(props) {
|
|
var data = props.data,
|
|
expanded = props.expanded,
|
|
selected = props.selected,
|
|
checked = props.checked,
|
|
loaded = props.loaded,
|
|
loading = props.loading,
|
|
halfChecked = props.halfChecked,
|
|
dragOver = props.dragOver,
|
|
dragOverGapTop = props.dragOverGapTop,
|
|
dragOverGapBottom = props.dragOverGapBottom,
|
|
pos = props.pos,
|
|
active = props.active,
|
|
eventKey = props.eventKey;
|
|
var eventData = (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)({}, data), {}, {
|
|
expanded: expanded,
|
|
selected: selected,
|
|
checked: checked,
|
|
loaded: loaded,
|
|
loading: loading,
|
|
halfChecked: halfChecked,
|
|
dragOver: dragOver,
|
|
dragOverGapTop: dragOverGapTop,
|
|
dragOverGapBottom: dragOverGapBottom,
|
|
pos: pos,
|
|
active: active,
|
|
key: eventKey
|
|
});
|
|
if (!('props' in eventData)) {
|
|
Object.defineProperty(eventData, 'props', {
|
|
get: function get() {
|
|
(0,rc_util_es_warning__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP)(false, 'Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.');
|
|
return props;
|
|
}
|
|
});
|
|
}
|
|
return eventData;
|
|
}
|
|
|
|
/***/ })
|
|
|
|
}]); |