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.
1421 lines
56 KiB
1421 lines
56 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[67390],{
|
|
|
|
/***/ 86128:
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/rc-tree/es/TreeNode.js + 1 modules ***!
|
|
\*********************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ TreeNode; }
|
|
});
|
|
|
|
// UNUSED EXPORTS: InternalTreeNode
|
|
|
|
// 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/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
|
|
var classCallCheck = __webpack_require__(15671);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
var createClass = __webpack_require__(43144);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
|
|
var assertThisInitialized = __webpack_require__(97326);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
|
|
var inherits = __webpack_require__(60136);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js + 1 modules
|
|
var createSuper = __webpack_require__(51630);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/pickAttrs.js
|
|
var pickAttrs = __webpack_require__(64217);
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/contextTypes.js
|
|
var contextTypes = __webpack_require__(27822);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-tree/es/Indent.js
|
|
|
|
|
|
|
|
var Indent = function Indent(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
level = _ref.level,
|
|
isStart = _ref.isStart,
|
|
isEnd = _ref.isEnd;
|
|
var baseClassName = "".concat(prefixCls, "-indent-unit");
|
|
var list = [];
|
|
for (var i = 0; i < level; i += 1) {
|
|
var _classNames;
|
|
list.push( /*#__PURE__*/react.createElement("span", {
|
|
key: i,
|
|
className: classnames_default()(baseClassName, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(baseClassName, "-start"), isStart[i]), (0,defineProperty/* default */.Z)(_classNames, "".concat(baseClassName, "-end"), isEnd[i]), _classNames))
|
|
}));
|
|
}
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
"aria-hidden": "true",
|
|
className: "".concat(prefixCls, "-indent")
|
|
}, list);
|
|
};
|
|
/* harmony default export */ var es_Indent = (/*#__PURE__*/react.memo(Indent));
|
|
// EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/treeUtil.js
|
|
var treeUtil = __webpack_require__(1089);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-tree/es/TreeNode.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["eventKey", "className", "style", "dragOver", "dragOverGapTop", "dragOverGapBottom", "isLeaf", "isStart", "isEnd", "expanded", "selected", "checked", "halfChecked", "loading", "domRef", "active", "data", "onMouseMove", "selectable"];
|
|
|
|
|
|
|
|
// @ts-ignore
|
|
|
|
|
|
|
|
var ICON_OPEN = 'open';
|
|
var ICON_CLOSE = 'close';
|
|
var defaultTitle = '---';
|
|
var InternalTreeNode = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(InternalTreeNode, _React$Component);
|
|
var _super = (0,createSuper/* default */.Z)(InternalTreeNode);
|
|
function InternalTreeNode() {
|
|
var _this;
|
|
(0,classCallCheck/* default */.Z)(this, InternalTreeNode);
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
_this = _super.call.apply(_super, [this].concat(args));
|
|
_this.state = {
|
|
dragNodeHighlight: false
|
|
};
|
|
_this.selectHandle = void 0;
|
|
_this.onSelectorClick = function (e) {
|
|
// Click trigger before select/check operation
|
|
var onNodeClick = _this.props.context.onNodeClick;
|
|
onNodeClick(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
if (_this.isSelectable()) {
|
|
_this.onSelect(e);
|
|
} else {
|
|
_this.onCheck(e);
|
|
}
|
|
};
|
|
_this.onSelectorDoubleClick = function (e) {
|
|
var onNodeDoubleClick = _this.props.context.onNodeDoubleClick;
|
|
onNodeDoubleClick(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
};
|
|
_this.onSelect = function (e) {
|
|
if (_this.isDisabled()) return;
|
|
var onNodeSelect = _this.props.context.onNodeSelect;
|
|
e.preventDefault();
|
|
onNodeSelect(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
};
|
|
_this.onCheck = function (e) {
|
|
if (_this.isDisabled()) return;
|
|
var _this$props = _this.props,
|
|
disableCheckbox = _this$props.disableCheckbox,
|
|
checked = _this$props.checked;
|
|
var onNodeCheck = _this.props.context.onNodeCheck;
|
|
if (!_this.isCheckable() || disableCheckbox) return;
|
|
e.preventDefault();
|
|
var targetChecked = !checked;
|
|
onNodeCheck(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props), targetChecked);
|
|
};
|
|
_this.onMouseEnter = function (e) {
|
|
var onNodeMouseEnter = _this.props.context.onNodeMouseEnter;
|
|
onNodeMouseEnter(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
};
|
|
_this.onMouseLeave = function (e) {
|
|
var onNodeMouseLeave = _this.props.context.onNodeMouseLeave;
|
|
onNodeMouseLeave(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
};
|
|
_this.onContextMenu = function (e) {
|
|
var onNodeContextMenu = _this.props.context.onNodeContextMenu;
|
|
onNodeContextMenu(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
};
|
|
_this.onDragStart = function (e) {
|
|
var onNodeDragStart = _this.props.context.onNodeDragStart;
|
|
e.stopPropagation();
|
|
_this.setState({
|
|
dragNodeHighlight: true
|
|
});
|
|
onNodeDragStart(e, (0,assertThisInitialized/* default */.Z)(_this));
|
|
try {
|
|
// ie throw error
|
|
// firefox-need-it
|
|
e.dataTransfer.setData('text/plain', '');
|
|
} catch (error) {
|
|
// empty
|
|
}
|
|
};
|
|
_this.onDragEnter = function (e) {
|
|
var onNodeDragEnter = _this.props.context.onNodeDragEnter;
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
onNodeDragEnter(e, (0,assertThisInitialized/* default */.Z)(_this));
|
|
};
|
|
_this.onDragOver = function (e) {
|
|
var onNodeDragOver = _this.props.context.onNodeDragOver;
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
onNodeDragOver(e, (0,assertThisInitialized/* default */.Z)(_this));
|
|
};
|
|
_this.onDragLeave = function (e) {
|
|
var onNodeDragLeave = _this.props.context.onNodeDragLeave;
|
|
e.stopPropagation();
|
|
onNodeDragLeave(e, (0,assertThisInitialized/* default */.Z)(_this));
|
|
};
|
|
_this.onDragEnd = function (e) {
|
|
var onNodeDragEnd = _this.props.context.onNodeDragEnd;
|
|
e.stopPropagation();
|
|
_this.setState({
|
|
dragNodeHighlight: false
|
|
});
|
|
onNodeDragEnd(e, (0,assertThisInitialized/* default */.Z)(_this));
|
|
};
|
|
_this.onDrop = function (e) {
|
|
var onNodeDrop = _this.props.context.onNodeDrop;
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
_this.setState({
|
|
dragNodeHighlight: false
|
|
});
|
|
onNodeDrop(e, (0,assertThisInitialized/* default */.Z)(_this));
|
|
};
|
|
// Disabled item still can be switch
|
|
_this.onExpand = function (e) {
|
|
var _this$props2 = _this.props,
|
|
loading = _this$props2.loading,
|
|
onNodeExpand = _this$props2.context.onNodeExpand;
|
|
if (loading) return;
|
|
onNodeExpand(e, (0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
};
|
|
// Drag usage
|
|
_this.setSelectHandle = function (node) {
|
|
_this.selectHandle = node;
|
|
};
|
|
_this.getNodeState = function () {
|
|
var expanded = _this.props.expanded;
|
|
if (_this.isLeaf()) {
|
|
return null;
|
|
}
|
|
return expanded ? ICON_OPEN : ICON_CLOSE;
|
|
};
|
|
_this.hasChildren = function () {
|
|
var eventKey = _this.props.eventKey;
|
|
var keyEntities = _this.props.context.keyEntities;
|
|
var _ref = keyEntities[eventKey] || {},
|
|
children = _ref.children;
|
|
return !!(children || []).length;
|
|
};
|
|
_this.isLeaf = function () {
|
|
var _this$props3 = _this.props,
|
|
isLeaf = _this$props3.isLeaf,
|
|
loaded = _this$props3.loaded;
|
|
var loadData = _this.props.context.loadData;
|
|
var hasChildren = _this.hasChildren();
|
|
if (isLeaf === false) {
|
|
return false;
|
|
}
|
|
return isLeaf || !loadData && !hasChildren || loadData && loaded && !hasChildren;
|
|
};
|
|
_this.isDisabled = function () {
|
|
var disabled = _this.props.disabled;
|
|
var treeDisabled = _this.props.context.disabled;
|
|
return !!(treeDisabled || disabled);
|
|
};
|
|
_this.isCheckable = function () {
|
|
var checkable = _this.props.checkable;
|
|
var treeCheckable = _this.props.context.checkable;
|
|
// Return false if tree or treeNode is not checkable
|
|
if (!treeCheckable || checkable === false) return false;
|
|
return treeCheckable;
|
|
};
|
|
// Load data to avoid default expanded tree without data
|
|
_this.syncLoadData = function (props) {
|
|
var expanded = props.expanded,
|
|
loading = props.loading,
|
|
loaded = props.loaded;
|
|
var _this$props$context = _this.props.context,
|
|
loadData = _this$props$context.loadData,
|
|
onNodeLoad = _this$props$context.onNodeLoad;
|
|
if (loading) {
|
|
return;
|
|
}
|
|
// read from state to avoid loadData at same time
|
|
if (loadData && expanded && !_this.isLeaf()) {
|
|
// We needn't reload data when has children in sync logic
|
|
// It's only needed in node expanded
|
|
if (!_this.hasChildren() && !loaded) {
|
|
onNodeLoad((0,treeUtil/* convertNodePropsToEventData */.F)(_this.props));
|
|
}
|
|
}
|
|
};
|
|
_this.isDraggable = function () {
|
|
var _this$props4 = _this.props,
|
|
data = _this$props4.data,
|
|
draggable = _this$props4.context.draggable;
|
|
return !!(draggable && (!draggable.nodeDraggable || draggable.nodeDraggable(data)));
|
|
};
|
|
// ==================== Render: Drag Handler ====================
|
|
_this.renderDragHandler = function () {
|
|
var _this$props$context2 = _this.props.context,
|
|
draggable = _this$props$context2.draggable,
|
|
prefixCls = _this$props$context2.prefixCls;
|
|
return (draggable === null || draggable === void 0 ? void 0 : draggable.icon) ? /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-draggable-icon")
|
|
}, draggable.icon) : null;
|
|
};
|
|
// ====================== Render: Switcher ======================
|
|
_this.renderSwitcherIconDom = function (isLeaf) {
|
|
var switcherIconFromProps = _this.props.switcherIcon;
|
|
var switcherIconFromCtx = _this.props.context.switcherIcon;
|
|
var switcherIcon = switcherIconFromProps || switcherIconFromCtx;
|
|
// if switcherIconDom is null, no render switcher span
|
|
if (typeof switcherIcon === 'function') {
|
|
return switcherIcon((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, _this.props), {}, {
|
|
isLeaf: isLeaf
|
|
}));
|
|
}
|
|
return switcherIcon;
|
|
};
|
|
// Switcher
|
|
_this.renderSwitcher = function () {
|
|
var expanded = _this.props.expanded;
|
|
var prefixCls = _this.props.context.prefixCls;
|
|
if (_this.isLeaf()) {
|
|
// if switcherIconDom is null, no render switcher span
|
|
var _switcherIconDom = _this.renderSwitcherIconDom(true);
|
|
return _switcherIconDom !== false ? /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher-noop"))
|
|
}, _switcherIconDom) : null;
|
|
}
|
|
var switcherCls = classnames_default()("".concat(prefixCls, "-switcher"), "".concat(prefixCls, "-switcher_").concat(expanded ? ICON_OPEN : ICON_CLOSE));
|
|
var switcherIconDom = _this.renderSwitcherIconDom(false);
|
|
return switcherIconDom !== false ? /*#__PURE__*/react.createElement("span", {
|
|
onClick: _this.onExpand,
|
|
className: switcherCls
|
|
}, switcherIconDom) : null;
|
|
};
|
|
// ====================== Render: Checkbox ======================
|
|
// Checkbox
|
|
_this.renderCheckbox = function () {
|
|
var _this$props5 = _this.props,
|
|
checked = _this$props5.checked,
|
|
halfChecked = _this$props5.halfChecked,
|
|
disableCheckbox = _this$props5.disableCheckbox;
|
|
var prefixCls = _this.props.context.prefixCls;
|
|
var disabled = _this.isDisabled();
|
|
var checkable = _this.isCheckable();
|
|
if (!checkable) return null;
|
|
// [Legacy] Custom element should be separate with `checkable` in future
|
|
var $custom = typeof checkable !== 'boolean' ? checkable : null;
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()("".concat(prefixCls, "-checkbox"), checked && "".concat(prefixCls, "-checkbox-checked"), !checked && halfChecked && "".concat(prefixCls, "-checkbox-indeterminate"), (disabled || disableCheckbox) && "".concat(prefixCls, "-checkbox-disabled")),
|
|
onClick: _this.onCheck
|
|
}, $custom);
|
|
};
|
|
// ==================== Render: Title + Icon ====================
|
|
_this.renderIcon = function () {
|
|
var loading = _this.props.loading;
|
|
var prefixCls = _this.props.context.prefixCls;
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()("".concat(prefixCls, "-iconEle"), "".concat(prefixCls, "-icon__").concat(_this.getNodeState() || 'docu'), loading && "".concat(prefixCls, "-icon_loading"))
|
|
});
|
|
};
|
|
// Icon + Title
|
|
_this.renderSelector = function () {
|
|
var dragNodeHighlight = _this.state.dragNodeHighlight;
|
|
var _this$props6 = _this.props,
|
|
_this$props6$title = _this$props6.title,
|
|
title = _this$props6$title === void 0 ? defaultTitle : _this$props6$title,
|
|
selected = _this$props6.selected,
|
|
icon = _this$props6.icon,
|
|
loading = _this$props6.loading,
|
|
data = _this$props6.data;
|
|
var _this$props$context3 = _this.props.context,
|
|
prefixCls = _this$props$context3.prefixCls,
|
|
showIcon = _this$props$context3.showIcon,
|
|
treeIcon = _this$props$context3.icon,
|
|
loadData = _this$props$context3.loadData,
|
|
titleRender = _this$props$context3.titleRender;
|
|
var disabled = _this.isDisabled();
|
|
var wrapClass = "".concat(prefixCls, "-node-content-wrapper");
|
|
// Icon - Still show loading icon when loading without showIcon
|
|
var $icon;
|
|
if (showIcon) {
|
|
var currentIcon = icon || treeIcon;
|
|
$icon = currentIcon ? /*#__PURE__*/react.createElement("span", {
|
|
className: classnames_default()("".concat(prefixCls, "-iconEle"), "".concat(prefixCls, "-icon__customize"))
|
|
}, typeof currentIcon === 'function' ? currentIcon(_this.props) : currentIcon) : _this.renderIcon();
|
|
} else if (loadData && loading) {
|
|
$icon = _this.renderIcon();
|
|
}
|
|
// Title
|
|
var titleNode;
|
|
if (typeof title === 'function') {
|
|
titleNode = title(data);
|
|
} else if (titleRender) {
|
|
titleNode = titleRender(data);
|
|
} else {
|
|
titleNode = title;
|
|
}
|
|
var $title = /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-title")
|
|
}, titleNode);
|
|
return /*#__PURE__*/react.createElement("span", {
|
|
ref: _this.setSelectHandle,
|
|
title: typeof title === 'string' ? title : '',
|
|
className: classnames_default()("".concat(wrapClass), "".concat(wrapClass, "-").concat(_this.getNodeState() || 'normal'), !disabled && (selected || dragNodeHighlight) && "".concat(prefixCls, "-node-selected")),
|
|
onMouseEnter: _this.onMouseEnter,
|
|
onMouseLeave: _this.onMouseLeave,
|
|
onContextMenu: _this.onContextMenu,
|
|
onClick: _this.onSelectorClick,
|
|
onDoubleClick: _this.onSelectorDoubleClick
|
|
}, $icon, $title, _this.renderDropIndicator());
|
|
};
|
|
// =================== Render: Drop Indicator ===================
|
|
_this.renderDropIndicator = function () {
|
|
var _this$props7 = _this.props,
|
|
disabled = _this$props7.disabled,
|
|
eventKey = _this$props7.eventKey;
|
|
var _this$props$context4 = _this.props.context,
|
|
draggable = _this$props$context4.draggable,
|
|
dropLevelOffset = _this$props$context4.dropLevelOffset,
|
|
dropPosition = _this$props$context4.dropPosition,
|
|
prefixCls = _this$props$context4.prefixCls,
|
|
indent = _this$props$context4.indent,
|
|
dropIndicatorRender = _this$props$context4.dropIndicatorRender,
|
|
dragOverNodeKey = _this$props$context4.dragOverNodeKey,
|
|
direction = _this$props$context4.direction;
|
|
var rootDraggable = !!draggable;
|
|
// allowDrop is calculated in Tree.tsx, there is no need for calc it here
|
|
var showIndicator = !disabled && rootDraggable && dragOverNodeKey === eventKey;
|
|
return showIndicator ? dropIndicatorRender({
|
|
dropPosition: dropPosition,
|
|
dropLevelOffset: dropLevelOffset,
|
|
indent: indent,
|
|
prefixCls: prefixCls,
|
|
direction: direction
|
|
}) : null;
|
|
};
|
|
return _this;
|
|
}
|
|
(0,createClass/* default */.Z)(InternalTreeNode, [{
|
|
key: "componentDidMount",
|
|
value:
|
|
// Isomorphic needn't load data in server side
|
|
function componentDidMount() {
|
|
this.syncLoadData(this.props);
|
|
}
|
|
}, {
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate() {
|
|
this.syncLoadData(this.props);
|
|
}
|
|
}, {
|
|
key: "isSelectable",
|
|
value: function isSelectable() {
|
|
var selectable = this.props.selectable;
|
|
var treeSelectable = this.props.context.selectable;
|
|
// Ignore when selectable is undefined or null
|
|
if (typeof selectable === 'boolean') {
|
|
return selectable;
|
|
}
|
|
return treeSelectable;
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value:
|
|
// =========================== Render ===========================
|
|
function render() {
|
|
var _classNames;
|
|
var _this$props8 = this.props,
|
|
eventKey = _this$props8.eventKey,
|
|
className = _this$props8.className,
|
|
style = _this$props8.style,
|
|
dragOver = _this$props8.dragOver,
|
|
dragOverGapTop = _this$props8.dragOverGapTop,
|
|
dragOverGapBottom = _this$props8.dragOverGapBottom,
|
|
isLeaf = _this$props8.isLeaf,
|
|
isStart = _this$props8.isStart,
|
|
isEnd = _this$props8.isEnd,
|
|
expanded = _this$props8.expanded,
|
|
selected = _this$props8.selected,
|
|
checked = _this$props8.checked,
|
|
halfChecked = _this$props8.halfChecked,
|
|
loading = _this$props8.loading,
|
|
domRef = _this$props8.domRef,
|
|
active = _this$props8.active,
|
|
data = _this$props8.data,
|
|
onMouseMove = _this$props8.onMouseMove,
|
|
selectable = _this$props8.selectable,
|
|
otherProps = (0,objectWithoutProperties/* default */.Z)(_this$props8, _excluded);
|
|
var _this$props$context5 = this.props.context,
|
|
prefixCls = _this$props$context5.prefixCls,
|
|
filterTreeNode = _this$props$context5.filterTreeNode,
|
|
keyEntities = _this$props$context5.keyEntities,
|
|
dropContainerKey = _this$props$context5.dropContainerKey,
|
|
dropTargetKey = _this$props$context5.dropTargetKey,
|
|
draggingNodeKey = _this$props$context5.draggingNodeKey;
|
|
var disabled = this.isDisabled();
|
|
var dataOrAriaAttributeProps = (0,pickAttrs/* default */.Z)(otherProps, {
|
|
aria: true,
|
|
data: true
|
|
});
|
|
var _ref2 = keyEntities[eventKey] || {},
|
|
level = _ref2.level;
|
|
var isEndNode = isEnd[isEnd.length - 1];
|
|
var mergedDraggable = this.isDraggable();
|
|
var draggableWithoutDisabled = !disabled && mergedDraggable;
|
|
var dragging = draggingNodeKey === eventKey;
|
|
var ariaSelected = selectable !== undefined ? {
|
|
'aria-selected': !!selectable
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
ref: domRef,
|
|
className: classnames_default()(className, "".concat(prefixCls, "-treenode"), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-disabled"), disabled), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-switcher-").concat(expanded ? 'open' : 'close'), !isLeaf), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-checkbox-checked"), checked), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-checkbox-indeterminate"), halfChecked), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-selected"), selected), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-loading"), loading), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-active"), active), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-leaf-last"), isEndNode), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-treenode-draggable"), mergedDraggable), (0,defineProperty/* default */.Z)(_classNames, "dragging", dragging), (0,defineProperty/* default */.Z)(_classNames, 'drop-target', dropTargetKey === eventKey), (0,defineProperty/* default */.Z)(_classNames, 'drop-container', dropContainerKey === eventKey), (0,defineProperty/* default */.Z)(_classNames, 'drag-over', !disabled && dragOver), (0,defineProperty/* default */.Z)(_classNames, 'drag-over-gap-top', !disabled && dragOverGapTop), (0,defineProperty/* default */.Z)(_classNames, 'drag-over-gap-bottom', !disabled && dragOverGapBottom), (0,defineProperty/* default */.Z)(_classNames, 'filter-node', filterTreeNode && filterTreeNode((0,treeUtil/* convertNodePropsToEventData */.F)(this.props))), _classNames)),
|
|
style: style
|
|
// Draggable config
|
|
,
|
|
draggable: draggableWithoutDisabled,
|
|
"aria-grabbed": dragging,
|
|
onDragStart: draggableWithoutDisabled ? this.onDragStart : undefined
|
|
// Drop config
|
|
,
|
|
onDragEnter: mergedDraggable ? this.onDragEnter : undefined,
|
|
onDragOver: mergedDraggable ? this.onDragOver : undefined,
|
|
onDragLeave: mergedDraggable ? this.onDragLeave : undefined,
|
|
onDrop: mergedDraggable ? this.onDrop : undefined,
|
|
onDragEnd: mergedDraggable ? this.onDragEnd : undefined,
|
|
onMouseMove: onMouseMove
|
|
}, ariaSelected, dataOrAriaAttributeProps), /*#__PURE__*/react.createElement(es_Indent, {
|
|
prefixCls: prefixCls,
|
|
level: level,
|
|
isStart: isStart,
|
|
isEnd: isEnd
|
|
}), this.renderDragHandler(), this.renderSwitcher(), this.renderCheckbox(), this.renderSelector());
|
|
}
|
|
}]);
|
|
return InternalTreeNode;
|
|
}(react.Component);
|
|
var ContextTreeNode = function ContextTreeNode(props) {
|
|
return /*#__PURE__*/react.createElement(contextTypes/* TreeContext.Consumer */.k.Consumer, null, function (context) {
|
|
return /*#__PURE__*/react.createElement(InternalTreeNode, (0,esm_extends/* default */.Z)({}, props, {
|
|
context: context
|
|
}));
|
|
});
|
|
};
|
|
ContextTreeNode.displayName = 'TreeNode';
|
|
ContextTreeNode.isTreeNode = 1;
|
|
|
|
/* harmony default export */ var TreeNode = (ContextTreeNode);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27822:
|
|
/*!*************************************************!*\
|
|
!*** ./node_modules/rc-tree/es/contextTypes.js ***!
|
|
\*************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "k": function() { return /* binding */ TreeContext; }
|
|
/* harmony export */ });
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ 67294);
|
|
/**
|
|
* Webpack has bug for import loop, which is not the same behavior as ES module.
|
|
* When util.js imports the TreeNode for tree generate will cause treeContextTypes be empty.
|
|
*/
|
|
|
|
var TreeContext = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createContext(null);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10225:
|
|
/*!*****************************************!*\
|
|
!*** ./node_modules/rc-tree/es/util.js ***!
|
|
\*****************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "BT": function() { return /* binding */ calcSelectedKeys; },
|
|
/* harmony export */ "Ds": function() { return /* binding */ isTreeNode; },
|
|
/* harmony export */ "E6": function() { return /* binding */ parseCheckedKeys; },
|
|
/* harmony export */ "L0": function() { return /* binding */ arrAdd; },
|
|
/* harmony export */ "OM": function() { return /* binding */ calcDropPosition; },
|
|
/* harmony export */ "_5": function() { return /* binding */ arrDel; },
|
|
/* harmony export */ "bt": function() { return /* binding */ getPosition; },
|
|
/* harmony export */ "r7": function() { return /* binding */ conductExpandParent; },
|
|
/* harmony export */ "wA": function() { return /* binding */ getDragChildrenKeys; },
|
|
/* harmony export */ "yx": function() { return /* binding */ posToArr; }
|
|
/* harmony export */ });
|
|
/* unused harmony exports isLastChild, isFirstChild, convertDataToTree */
|
|
/* harmony import */ var _babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/esm/toConsumableArray */ 74902);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/esm/typeof */ 71002);
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ 67294);
|
|
/* harmony import */ var rc_util_es_warning__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! rc-util/es/warning */ 80334);
|
|
/* harmony import */ var _TreeNode__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./TreeNode */ 86128);
|
|
|
|
|
|
|
|
|
|
var _excluded = (/* unused pure expression or super */ null && (["children"]));
|
|
/* eslint-disable no-lonely-if */
|
|
/**
|
|
* Legacy code. Should avoid to use if you are new to import these code.
|
|
*/
|
|
|
|
|
|
|
|
function arrDel(list, value) {
|
|
if (!list) return [];
|
|
var clone = list.slice();
|
|
var index = clone.indexOf(value);
|
|
if (index >= 0) {
|
|
clone.splice(index, 1);
|
|
}
|
|
return clone;
|
|
}
|
|
function arrAdd(list, value) {
|
|
var clone = (list || []).slice();
|
|
if (clone.indexOf(value) === -1) {
|
|
clone.push(value);
|
|
}
|
|
return clone;
|
|
}
|
|
function posToArr(pos) {
|
|
return pos.split('-');
|
|
}
|
|
function getPosition(level, index) {
|
|
return "".concat(level, "-").concat(index);
|
|
}
|
|
function isTreeNode(node) {
|
|
return node && node.type && node.type.isTreeNode;
|
|
}
|
|
function getDragChildrenKeys(dragNodeKey, keyEntities) {
|
|
// not contains self
|
|
// self for left or right drag
|
|
var dragChildrenKeys = [];
|
|
var entity = keyEntities[dragNodeKey];
|
|
function dig() {
|
|
var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
list.forEach(function (_ref) {
|
|
var key = _ref.key,
|
|
children = _ref.children;
|
|
dragChildrenKeys.push(key);
|
|
dig(children);
|
|
});
|
|
}
|
|
dig(entity.children);
|
|
return dragChildrenKeys;
|
|
}
|
|
function isLastChild(treeNodeEntity) {
|
|
if (treeNodeEntity.parent) {
|
|
var posArr = posToArr(treeNodeEntity.pos);
|
|
return Number(posArr[posArr.length - 1]) === treeNodeEntity.parent.children.length - 1;
|
|
}
|
|
return false;
|
|
}
|
|
function isFirstChild(treeNodeEntity) {
|
|
var posArr = posToArr(treeNodeEntity.pos);
|
|
return Number(posArr[posArr.length - 1]) === 0;
|
|
}
|
|
// Only used when drag, not affect SSR.
|
|
function calcDropPosition(event, dragNode, targetNode, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, expandKeys, direction) {
|
|
var _abstractDropNodeEnti;
|
|
var clientX = event.clientX,
|
|
clientY = event.clientY;
|
|
var _event$target$getBoun = event.target.getBoundingClientRect(),
|
|
top = _event$target$getBoun.top,
|
|
height = _event$target$getBoun.height;
|
|
// optional chain for testing
|
|
var horizontalMouseOffset = (direction === 'rtl' ? -1 : 1) * (((startMousePosition === null || startMousePosition === void 0 ? void 0 : startMousePosition.x) || 0) - clientX);
|
|
var rawDropLevelOffset = (horizontalMouseOffset - 12) / indent;
|
|
// find abstract drop node by horizontal offset
|
|
var abstractDropNodeEntity = keyEntities[targetNode.props.eventKey];
|
|
if (clientY < top + height / 2) {
|
|
// first half, set abstract drop node to previous node
|
|
var nodeIndex = flattenedNodes.findIndex(function (flattenedNode) {
|
|
return flattenedNode.key === abstractDropNodeEntity.key;
|
|
});
|
|
var prevNodeIndex = nodeIndex <= 0 ? 0 : nodeIndex - 1;
|
|
var prevNodeKey = flattenedNodes[prevNodeIndex].key;
|
|
abstractDropNodeEntity = keyEntities[prevNodeKey];
|
|
}
|
|
var initialAbstractDropNodeKey = abstractDropNodeEntity.key;
|
|
var abstractDragOverEntity = abstractDropNodeEntity;
|
|
var dragOverNodeKey = abstractDropNodeEntity.key;
|
|
var dropPosition = 0;
|
|
var dropLevelOffset = 0;
|
|
// Only allow cross level drop when dragging on a non-expanded node
|
|
if (!expandKeys.includes(initialAbstractDropNodeKey)) {
|
|
for (var i = 0; i < rawDropLevelOffset; i += 1) {
|
|
if (isLastChild(abstractDropNodeEntity)) {
|
|
abstractDropNodeEntity = abstractDropNodeEntity.parent;
|
|
dropLevelOffset += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
var abstractDragDataNode = dragNode.props.data;
|
|
var abstractDropDataNode = abstractDropNodeEntity.node;
|
|
var dropAllowed = true;
|
|
if (isFirstChild(abstractDropNodeEntity) && abstractDropNodeEntity.level === 0 && clientY < top + height / 2 && allowDrop({
|
|
dragNode: abstractDragDataNode,
|
|
dropNode: abstractDropDataNode,
|
|
dropPosition: -1
|
|
}) && abstractDropNodeEntity.key === targetNode.props.eventKey) {
|
|
// first half of first node in first level
|
|
dropPosition = -1;
|
|
} else if ((abstractDragOverEntity.children || []).length && expandKeys.includes(dragOverNodeKey)) {
|
|
// drop on expanded node
|
|
// only allow drop inside
|
|
if (allowDrop({
|
|
dragNode: abstractDragDataNode,
|
|
dropNode: abstractDropDataNode,
|
|
dropPosition: 0
|
|
})) {
|
|
dropPosition = 0;
|
|
} else {
|
|
dropAllowed = false;
|
|
}
|
|
} else if (dropLevelOffset === 0) {
|
|
if (rawDropLevelOffset > -1.5) {
|
|
// | Node | <- abstractDropNode
|
|
// | -^-===== | <- mousePosition
|
|
// 1. try drop after
|
|
// 2. do not allow drop
|
|
if (allowDrop({
|
|
dragNode: abstractDragDataNode,
|
|
dropNode: abstractDropDataNode,
|
|
dropPosition: 1
|
|
})) {
|
|
dropPosition = 1;
|
|
} else {
|
|
dropAllowed = false;
|
|
}
|
|
} else {
|
|
// | Node | <- abstractDropNode
|
|
// | ---==^== | <- mousePosition
|
|
// whether it has children or doesn't has children
|
|
// always
|
|
// 1. try drop inside
|
|
// 2. try drop after
|
|
// 3. do not allow drop
|
|
if (allowDrop({
|
|
dragNode: abstractDragDataNode,
|
|
dropNode: abstractDropDataNode,
|
|
dropPosition: 0
|
|
})) {
|
|
dropPosition = 0;
|
|
} else if (allowDrop({
|
|
dragNode: abstractDragDataNode,
|
|
dropNode: abstractDropDataNode,
|
|
dropPosition: 1
|
|
})) {
|
|
dropPosition = 1;
|
|
} else {
|
|
dropAllowed = false;
|
|
}
|
|
}
|
|
} else {
|
|
// | Node1 | <- abstractDropNode
|
|
// | Node2 |
|
|
// --^--|----=====| <- mousePosition
|
|
// 1. try insert after Node1
|
|
// 2. do not allow drop
|
|
if (allowDrop({
|
|
dragNode: abstractDragDataNode,
|
|
dropNode: abstractDropDataNode,
|
|
dropPosition: 1
|
|
})) {
|
|
dropPosition = 1;
|
|
} else {
|
|
dropAllowed = false;
|
|
}
|
|
}
|
|
return {
|
|
dropPosition: dropPosition,
|
|
dropLevelOffset: dropLevelOffset,
|
|
dropTargetKey: abstractDropNodeEntity.key,
|
|
dropTargetPos: abstractDropNodeEntity.pos,
|
|
dragOverNodeKey: dragOverNodeKey,
|
|
dropContainerKey: dropPosition === 0 ? null : ((_abstractDropNodeEnti = abstractDropNodeEntity.parent) === null || _abstractDropNodeEnti === void 0 ? void 0 : _abstractDropNodeEnti.key) || null,
|
|
dropAllowed: dropAllowed
|
|
};
|
|
}
|
|
/**
|
|
* Return selectedKeys according with multiple prop
|
|
* @param selectedKeys
|
|
* @param props
|
|
* @returns [string]
|
|
*/
|
|
function calcSelectedKeys(selectedKeys, props) {
|
|
if (!selectedKeys) return undefined;
|
|
var multiple = props.multiple;
|
|
if (multiple) {
|
|
return selectedKeys.slice();
|
|
}
|
|
if (selectedKeys.length) {
|
|
return [selectedKeys[0]];
|
|
}
|
|
return selectedKeys;
|
|
}
|
|
var internalProcessProps = function internalProcessProps(props) {
|
|
return props;
|
|
};
|
|
function convertDataToTree(treeData, processor) {
|
|
if (!treeData) return [];
|
|
var _ref2 = processor || {},
|
|
_ref2$processProps = _ref2.processProps,
|
|
processProps = _ref2$processProps === void 0 ? internalProcessProps : _ref2$processProps;
|
|
var list = Array.isArray(treeData) ? treeData : [treeData];
|
|
return list.map(function (_ref3) {
|
|
var children = _ref3.children,
|
|
props = _objectWithoutProperties(_ref3, _excluded);
|
|
var childrenNodes = convertDataToTree(children, processor);
|
|
return /*#__PURE__*/React.createElement(TreeNode, _extends({
|
|
key: props.key
|
|
}, processProps(props)), childrenNodes);
|
|
});
|
|
}
|
|
/**
|
|
* Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
|
|
*/
|
|
function parseCheckedKeys(keys) {
|
|
if (!keys) {
|
|
return null;
|
|
}
|
|
// Convert keys to object format
|
|
var keyProps;
|
|
if (Array.isArray(keys)) {
|
|
// [Legacy] Follow the api doc
|
|
keyProps = {
|
|
checkedKeys: keys,
|
|
halfCheckedKeys: undefined
|
|
};
|
|
} else if ((0,_babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(keys) === 'object') {
|
|
keyProps = {
|
|
checkedKeys: keys.checked || undefined,
|
|
halfCheckedKeys: keys.halfChecked || undefined
|
|
};
|
|
} else {
|
|
(0,rc_util_es_warning__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP)(false, '`checkedKeys` is not an array or an object');
|
|
return null;
|
|
}
|
|
return keyProps;
|
|
}
|
|
/**
|
|
* If user use `autoExpandParent` we should get the list of parent node
|
|
* @param keyList
|
|
* @param keyEntities
|
|
*/
|
|
function conductExpandParent(keyList, keyEntities) {
|
|
var expandedKeys = new Set();
|
|
function conductUp(key) {
|
|
if (expandedKeys.has(key)) return;
|
|
var entity = keyEntities[key];
|
|
if (!entity) return;
|
|
expandedKeys.add(key);
|
|
var parent = entity.parent,
|
|
node = entity.node;
|
|
if (node.disabled) return;
|
|
if (parent) {
|
|
conductUp(parent.key);
|
|
}
|
|
}
|
|
(keyList || []).forEach(function (key) {
|
|
conductUp(key);
|
|
});
|
|
return (0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(expandedKeys);
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 17341:
|
|
/*!******************************************************!*\
|
|
!*** ./node_modules/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 */ 80334);
|
|
|
|
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 = !!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;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1089:
|
|
/*!***************************************************!*\
|
|
!*** ./node_modules/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 warningWithoutKey, traverseDataNodes */
|
|
/* harmony import */ var _babel_runtime_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @babel/runtime/helpers/esm/typeof */ 71002);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/esm/toConsumableArray */ 74902);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/esm/objectSpread2 */ 1413);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/esm/objectWithoutProperties */ 45987);
|
|
/* harmony import */ var rc_util_es_omit__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! rc-util/es/omit */ 98423);
|
|
/* harmony import */ var rc_util_es_Children_toArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! rc-util/es/Children/toArray */ 50344);
|
|
/* harmony import */ var rc_util_es_warning__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! rc-util/es/warning */ 80334);
|
|
/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../util */ 10225);
|
|
|
|
|
|
|
|
|
|
var _excluded = ["children"];
|
|
|
|
|
|
|
|
|
|
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 (!(0,_util__WEBPACK_IMPORTED_MODULE_2__/* .isTreeNode */ .Ds)(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_3__/* ["default"] */ .Z)(_treeNode$props, _excluded);
|
|
var dataNode = (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_4__/* ["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 = (0,_util__WEBPACK_IMPORTED_MODULE_2__/* .getPosition */ .bt)(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_4__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)({}, (0,rc_util_es_omit__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(treeNode, [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_6__/* ["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_6__/* ["default"] */ .Z)(parent ? parent.isStart : []), [index === 0]),
|
|
isEnd: [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_6__/* ["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_7__/* ["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 ? (0,_util__WEBPACK_IMPORTED_MODULE_2__/* .getPosition */ .bt)(parent.pos, index) : '0';
|
|
var connectNodes = node ? [].concat((0,_babel_runtime_helpers_esm_toConsumableArray__WEBPACK_IMPORTED_MODULE_6__/* ["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 = 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_4__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_4__/* ["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;
|
|
}
|
|
|
|
/***/ })
|
|
|
|
}]); |