"use strict"; (self["webpackChunk"] = self["webpackChunk"] || []).push([[33479],{ /***/ 70478: /*!**************************************************************************!*\ !*** ./node_modules/@ant-design/icons-svg/es/asn/MinusSquareOutlined.js ***! \**************************************************************************/ /***/ (function(__unused_webpack_module, __webpack_exports__) { // This icon file is generated automatically. var MinusSquareOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M328 544h368c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H328c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8z" } }, { "tag": "path", "attrs": { "d": "M880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32zm-40 728H184V184h656v656z" } }] }, "name": "minus-square", "theme": "outlined" }; /* harmony default export */ __webpack_exports__["Z"] = (MinusSquareOutlined); /***/ }), /***/ 43114: /*!*************************************************************************!*\ !*** ./node_modules/@ant-design/icons-svg/es/asn/PlusSquareOutlined.js ***! \*************************************************************************/ /***/ (function(__unused_webpack_module, __webpack_exports__) { // This icon file is generated automatically. var PlusSquareOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M328 544h152v152c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V544h152c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H544V328c0-4.4-3.6-8-8-8h-48c-4.4 0-8 3.6-8 8v152H328c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8z" } }, { "tag": "path", "attrs": { "d": "M880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32zm-40 728H184V184h656v656z" } }] }, "name": "plus-square", "theme": "outlined" }; /* harmony default export */ __webpack_exports__["Z"] = (PlusSquareOutlined); /***/ }), /***/ 84050: /*!*****************************************************************!*\ !*** ./node_modules/antd/es/tree/utils/iconUtil.js + 4 modules ***! \*****************************************************************/ /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { // EXPORTS __webpack_require__.d(__webpack_exports__, { "Z": function() { return /* binding */ renderSwitcherIcon; } }); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js var esm_typeof = __webpack_require__(71002); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js var objectSpread2 = __webpack_require__(1413); // EXTERNAL MODULE: ./node_modules/react/index.js var react = __webpack_require__(67294); ;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/CaretDownFilled.js // This icon file is generated automatically. var CaretDownFilled = { "icon": { "tag": "svg", "attrs": { "viewBox": "0 0 1024 1024", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M840.4 300H183.6c-19.7 0-30.7 20.8-18.5 35l328.4 380.8c9.4 10.9 27.5 10.9 37 0L858.9 335c12.2-14.2 1.2-35-18.5-35z" } }] }, "name": "caret-down", "theme": "filled" }; /* harmony default export */ var asn_CaretDownFilled = (CaretDownFilled); // EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/components/AntdIcon.js + 3 modules var AntdIcon = __webpack_require__(93771); ;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/CaretDownFilled.js // GENERATE BY ./scripts/generate.ts // DON NOT EDIT IT MANUALLY var CaretDownFilled_CaretDownFilled = function CaretDownFilled(props, ref) { return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, { ref: ref, icon: asn_CaretDownFilled })); }; CaretDownFilled_CaretDownFilled.displayName = 'CaretDownFilled'; /* harmony default export */ var icons_CaretDownFilled = (/*#__PURE__*/react.forwardRef(CaretDownFilled_CaretDownFilled)); // EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/FileOutlined.js + 1 modules var FileOutlined = __webpack_require__(5309); // EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/LoadingOutlined.js var LoadingOutlined = __webpack_require__(19267); // EXTERNAL MODULE: ./node_modules/@ant-design/icons-svg/es/asn/MinusSquareOutlined.js var asn_MinusSquareOutlined = __webpack_require__(70478); ;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/MinusSquareOutlined.js // GENERATE BY ./scripts/generate.ts // DON NOT EDIT IT MANUALLY var MinusSquareOutlined = function MinusSquareOutlined(props, ref) { return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, { ref: ref, icon: asn_MinusSquareOutlined/* default */.Z })); }; MinusSquareOutlined.displayName = 'MinusSquareOutlined'; /* harmony default export */ var icons_MinusSquareOutlined = (/*#__PURE__*/react.forwardRef(MinusSquareOutlined)); // EXTERNAL MODULE: ./node_modules/@ant-design/icons-svg/es/asn/PlusSquareOutlined.js var asn_PlusSquareOutlined = __webpack_require__(43114); ;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/PlusSquareOutlined.js // GENERATE BY ./scripts/generate.ts // DON NOT EDIT IT MANUALLY var PlusSquareOutlined = function PlusSquareOutlined(props, ref) { return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, { ref: ref, icon: asn_PlusSquareOutlined/* default */.Z })); }; PlusSquareOutlined.displayName = 'PlusSquareOutlined'; /* harmony default export */ var icons_PlusSquareOutlined = (/*#__PURE__*/react.forwardRef(PlusSquareOutlined)); // EXTERNAL MODULE: ./node_modules/classnames/index.js var classnames = __webpack_require__(94184); var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames); // EXTERNAL MODULE: ./node_modules/antd/es/_util/reactNode.js var reactNode = __webpack_require__(96159); ;// CONCATENATED MODULE: ./node_modules/antd/es/tree/utils/iconUtil.js function renderSwitcherIcon(prefixCls, switcherIcon, showLine, treeNodeProps) { var isLeaf = treeNodeProps.isLeaf, expanded = treeNodeProps.expanded, loading = treeNodeProps.loading; if (loading) { return /*#__PURE__*/react.createElement(LoadingOutlined/* default */.Z, { className: "".concat(prefixCls, "-switcher-loading-icon") }); } var showLeafIcon; if (showLine && (0,esm_typeof/* default */.Z)(showLine) === 'object') { showLeafIcon = showLine.showLeafIcon; } if (isLeaf) { if (!showLine) { return null; } if (typeof showLeafIcon !== 'boolean' && !!showLeafIcon) { var leafIcon = typeof showLeafIcon === 'function' ? showLeafIcon(treeNodeProps) : showLeafIcon; var leafCls = "".concat(prefixCls, "-switcher-line-custom-icon"); if ((0,reactNode/* isValidElement */.l$)(leafIcon)) { return (0,reactNode/* cloneElement */.Tm)(leafIcon, { className: classnames_default()(leafIcon.props.className || '', leafCls) }); } return leafIcon; } return showLeafIcon ? /*#__PURE__*/react.createElement(FileOutlined/* default */.Z, { className: "".concat(prefixCls, "-switcher-line-icon") }) : /*#__PURE__*/react.createElement("span", { className: "".concat(prefixCls, "-switcher-leaf-line") }); } var switcherCls = "".concat(prefixCls, "-switcher-icon"); var switcher = typeof switcherIcon === 'function' ? switcherIcon(treeNodeProps) : switcherIcon; if ((0,reactNode/* isValidElement */.l$)(switcher)) { return (0,reactNode/* cloneElement */.Tm)(switcher, { className: classnames_default()(switcher.props.className || '', switcherCls) }); } if (switcher) { return switcher; } if (showLine) { return expanded ? /*#__PURE__*/react.createElement(icons_MinusSquareOutlined, { className: "".concat(prefixCls, "-switcher-line-icon") }) : /*#__PURE__*/react.createElement(icons_PlusSquareOutlined, { className: "".concat(prefixCls, "-switcher-line-icon") }); } return /*#__PURE__*/react.createElement(icons_CaretDownFilled, { className: switcherCls }); } /***/ }), /***/ 5309: /*!***********************************************************************************************!*\ !*** ./node_modules/antd/node_modules/@ant-design/icons/es/icons/FileOutlined.js + 1 modules ***! \***********************************************************************************************/ /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { // EXPORTS __webpack_require__.d(__webpack_exports__, { "Z": function() { return /* binding */ icons_FileOutlined; } }); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js var objectSpread2 = __webpack_require__(1413); // EXTERNAL MODULE: ./node_modules/react/index.js var react = __webpack_require__(67294); ;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/FileOutlined.js // This icon file is generated automatically. var FileOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326zm1.8 562H232V136h302v216a42 42 0 0042 42h216v494z" } }] }, "name": "file", "theme": "outlined" }; /* harmony default export */ var asn_FileOutlined = (FileOutlined); // EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/components/AntdIcon.js + 3 modules var AntdIcon = __webpack_require__(93771); ;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/FileOutlined.js // GENERATE BY ./scripts/generate.ts // DON NOT EDIT IT MANUALLY var FileOutlined_FileOutlined = function FileOutlined(props, ref) { return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, { ref: ref, icon: asn_FileOutlined })); }; FileOutlined_FileOutlined.displayName = 'FileOutlined'; /* harmony default export */ var icons_FileOutlined = (/*#__PURE__*/react.forwardRef(FileOutlined_FileOutlined)); /***/ }), /***/ 31343: /*!******************************************************!*\ !*** ./node_modules/rc-tree/es/index.js + 6 modules ***! \******************************************************/ /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { // EXPORTS __webpack_require__.d(__webpack_exports__, { "O": function() { return /* reexport */ TreeNode/* default */.Z; }, "Z": function() { return /* binding */ rc_tree_es; } }); // 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/typeof.js var esm_typeof = __webpack_require__(71002); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js var objectSpread2 = __webpack_require__(1413); // 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/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/rc-util/es/KeyCode.js var KeyCode = __webpack_require__(15105); // EXTERNAL MODULE: ./node_modules/rc-util/es/warning.js var warning = __webpack_require__(80334); // EXTERNAL MODULE: ./node_modules/rc-util/es/pickAttrs.js var pickAttrs = __webpack_require__(64217); // 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-tree/es/contextTypes.js var contextTypes = __webpack_require__(27822); // EXTERNAL MODULE: ./node_modules/rc-tree/es/util.js var util = __webpack_require__(10225); // EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/treeUtil.js var treeUtil = __webpack_require__(1089); ;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js function _objectDestructuringEmpty(obj) { if (obj == null) throw new TypeError("Cannot destructure " + obj); } // 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/rc-virtual-list/es/index.js + 14 modules var es = __webpack_require__(73453); // EXTERNAL MODULE: ./node_modules/rc-motion/es/index.js + 11 modules var rc_motion_es = __webpack_require__(62874); // EXTERNAL MODULE: ./node_modules/rc-tree/es/TreeNode.js + 1 modules var TreeNode = __webpack_require__(86128); ;// CONCATENATED MODULE: ./node_modules/rc-tree/es/MotionTreeNode.js var _excluded = ["className", "style", "motion", "motionNodes", "motionType", "onMotionStart", "onMotionEnd", "active", "treeNodeRequiredProps"]; var MotionTreeNode = function MotionTreeNode(_ref, ref) { var className = _ref.className, style = _ref.style, motion = _ref.motion, motionNodes = _ref.motionNodes, motionType = _ref.motionType, onOriginMotionStart = _ref.onMotionStart, onOriginMotionEnd = _ref.onMotionEnd, active = _ref.active, treeNodeRequiredProps = _ref.treeNodeRequiredProps, props = (0,objectWithoutProperties/* default */.Z)(_ref, _excluded); var _React$useState = react.useState(true), _React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2), visible = _React$useState2[0], setVisible = _React$useState2[1]; var _React$useContext = react.useContext(contextTypes/* TreeContext */.k), prefixCls = _React$useContext.prefixCls; var motionedRef = react.useRef(false); var onMotionEnd = function onMotionEnd() { if (!motionedRef.current) { onOriginMotionEnd(); } motionedRef.current = true; }; (0,react.useEffect)(function () { if (motionNodes && motionType === 'hide' && visible) { setVisible(false); } }, [motionNodes]); (0,react.useEffect)(function () { // Trigger motion only when patched if (motionNodes) { onOriginMotionStart(); } return function () { if (motionNodes) { onMotionEnd(); } }; }, []); if (motionNodes) { return /*#__PURE__*/react.createElement(rc_motion_es["default"], (0,esm_extends/* default */.Z)({ ref: ref, visible: visible }, motion, { motionAppear: motionType === 'show', onAppearEnd: onMotionEnd, onLeaveEnd: onMotionEnd }), function (_ref2, motionRef) { var motionClassName = _ref2.className, motionStyle = _ref2.style; return /*#__PURE__*/react.createElement("div", { ref: motionRef, className: classnames_default()("".concat(prefixCls, "-treenode-motion"), motionClassName), style: motionStyle }, motionNodes.map(function (treeNode) { var restProps = (0,esm_extends/* default */.Z)({}, (_objectDestructuringEmpty(treeNode.data), treeNode.data)), title = treeNode.title, key = treeNode.key, isStart = treeNode.isStart, isEnd = treeNode.isEnd; delete restProps.children; var treeNodeProps = (0,treeUtil/* getTreeNodeProps */.H8)(key, treeNodeRequiredProps); return /*#__PURE__*/react.createElement(TreeNode/* default */.Z, (0,esm_extends/* default */.Z)({}, restProps, treeNodeProps, { title: title, active: active, data: treeNode.data, key: key, isStart: isStart, isEnd: isEnd })); })); }); } return /*#__PURE__*/react.createElement(TreeNode/* default */.Z, (0,esm_extends/* default */.Z)({ domRef: ref, className: className, style: style }, props, { active: active })); }; MotionTreeNode.displayName = 'MotionTreeNode'; var RefMotionTreeNode = /*#__PURE__*/react.forwardRef(MotionTreeNode); /* harmony default export */ var es_MotionTreeNode = (RefMotionTreeNode); ;// CONCATENATED MODULE: ./node_modules/rc-tree/es/utils/diffUtil.js function findExpandedKeys() { var prev = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; var next = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; var prevLen = prev.length; var nextLen = next.length; if (Math.abs(prevLen - nextLen) !== 1) { return { add: false, key: null }; } function find(shorter, longer) { var cache = new Map(); shorter.forEach(function (key) { cache.set(key, true); }); var keys = longer.filter(function (key) { return !cache.has(key); }); return keys.length === 1 ? keys[0] : null; } if (prevLen < nextLen) { return { add: true, key: find(prev, next) }; } return { add: false, key: find(next, prev) }; } function getExpandRange(shorter, longer, key) { var shorterStartIndex = shorter.findIndex(function (data) { return data.key === key; }); var shorterEndNode = shorter[shorterStartIndex + 1]; var longerStartIndex = longer.findIndex(function (data) { return data.key === key; }); if (shorterEndNode) { var longerEndIndex = longer.findIndex(function (data) { return data.key === shorterEndNode.key; }); return longer.slice(longerStartIndex + 1, longerEndIndex); } return longer.slice(longerStartIndex + 1); } ;// CONCATENATED MODULE: ./node_modules/rc-tree/es/NodeList.js var NodeList_excluded = ["prefixCls", "data", "selectable", "checkable", "expandedKeys", "selectedKeys", "checkedKeys", "loadedKeys", "loadingKeys", "halfCheckedKeys", "keyEntities", "disabled", "dragging", "dragOverNodeKey", "dropPosition", "motion", "height", "itemHeight", "virtual", "focusable", "activeItem", "focused", "tabIndex", "onKeyDown", "onFocus", "onBlur", "onActiveChange", "onListChangeStart", "onListChangeEnd"]; /** * Handle virtual list of the TreeNodes. */ var HIDDEN_STYLE = { width: 0, height: 0, display: 'flex', overflow: 'hidden', opacity: 0, border: 0, padding: 0, margin: 0 }; var noop = function noop() {}; var MOTION_KEY = "RC_TREE_MOTION_".concat(Math.random()); var MotionNode = { key: MOTION_KEY }; var MotionEntity = { key: MOTION_KEY, level: 0, index: 0, pos: '0', node: MotionNode, nodes: [MotionNode] }; var MotionFlattenData = { parent: null, children: [], pos: MotionEntity.pos, data: MotionNode, title: null, key: MOTION_KEY, /** Hold empty list here since we do not use it */ isStart: [], isEnd: [] }; /** * We only need get visible content items to play the animation. */ function getMinimumRangeTransitionRange(list, virtual, height, itemHeight) { if (virtual === false || !height) { return list; } return list.slice(0, Math.ceil(height / itemHeight) + 1); } function itemKey(item) { var key = item.key, pos = item.pos; return (0,treeUtil/* getKey */.km)(key, pos); } function getAccessibilityPath(item) { var path = String(item.data.key); var current = item; while (current.parent) { current = current.parent; path = "".concat(current.data.key, " > ").concat(path); } return path; } var NodeList = /*#__PURE__*/react.forwardRef(function (props, ref) { var prefixCls = props.prefixCls, data = props.data, selectable = props.selectable, checkable = props.checkable, expandedKeys = props.expandedKeys, selectedKeys = props.selectedKeys, checkedKeys = props.checkedKeys, loadedKeys = props.loadedKeys, loadingKeys = props.loadingKeys, halfCheckedKeys = props.halfCheckedKeys, keyEntities = props.keyEntities, disabled = props.disabled, dragging = props.dragging, dragOverNodeKey = props.dragOverNodeKey, dropPosition = props.dropPosition, motion = props.motion, height = props.height, itemHeight = props.itemHeight, virtual = props.virtual, focusable = props.focusable, activeItem = props.activeItem, focused = props.focused, tabIndex = props.tabIndex, onKeyDown = props.onKeyDown, onFocus = props.onFocus, onBlur = props.onBlur, onActiveChange = props.onActiveChange, onListChangeStart = props.onListChangeStart, onListChangeEnd = props.onListChangeEnd, domProps = (0,objectWithoutProperties/* default */.Z)(props, NodeList_excluded); // =============================== Ref ================================ var listRef = react.useRef(null); var indentMeasurerRef = react.useRef(null); react.useImperativeHandle(ref, function () { return { scrollTo: function scrollTo(scroll) { listRef.current.scrollTo(scroll); }, getIndentWidth: function getIndentWidth() { return indentMeasurerRef.current.offsetWidth; } }; }); // ============================== Motion ============================== var _React$useState = react.useState(expandedKeys), _React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2), prevExpandedKeys = _React$useState2[0], setPrevExpandedKeys = _React$useState2[1]; var _React$useState3 = react.useState(data), _React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2), prevData = _React$useState4[0], setPrevData = _React$useState4[1]; var _React$useState5 = react.useState(data), _React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2), transitionData = _React$useState6[0], setTransitionData = _React$useState6[1]; var _React$useState7 = react.useState([]), _React$useState8 = (0,slicedToArray/* default */.Z)(_React$useState7, 2), transitionRange = _React$useState8[0], setTransitionRange = _React$useState8[1]; var _React$useState9 = react.useState(null), _React$useState10 = (0,slicedToArray/* default */.Z)(_React$useState9, 2), motionType = _React$useState10[0], setMotionType = _React$useState10[1]; // When motion end but data change, this will makes data back to previous one var dataRef = react.useRef(data); dataRef.current = data; function onMotionEnd() { var latestData = dataRef.current; setPrevData(latestData); setTransitionData(latestData); setTransitionRange([]); setMotionType(null); onListChangeEnd(); } // Do animation if expanded keys changed react.useEffect(function () { setPrevExpandedKeys(expandedKeys); var diffExpanded = findExpandedKeys(prevExpandedKeys, expandedKeys); if (diffExpanded.key !== null) { if (diffExpanded.add) { var keyIndex = prevData.findIndex(function (_ref) { var key = _ref.key; return key === diffExpanded.key; }); var rangeNodes = getMinimumRangeTransitionRange(getExpandRange(prevData, data, diffExpanded.key), virtual, height, itemHeight); var newTransitionData = prevData.slice(); newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData); setTransitionData(newTransitionData); setTransitionRange(rangeNodes); setMotionType('show'); } else { var _keyIndex = data.findIndex(function (_ref2) { var key = _ref2.key; return key === diffExpanded.key; }); var _rangeNodes = getMinimumRangeTransitionRange(getExpandRange(data, prevData, diffExpanded.key), virtual, height, itemHeight); var _newTransitionData = data.slice(); _newTransitionData.splice(_keyIndex + 1, 0, MotionFlattenData); setTransitionData(_newTransitionData); setTransitionRange(_rangeNodes); setMotionType('hide'); } } else if (prevData !== data) { // If whole data changed, we just refresh the list setPrevData(data); setTransitionData(data); } }, [expandedKeys, data]); // We should clean up motion if is changed by dragging react.useEffect(function () { if (!dragging) { onMotionEnd(); } }, [dragging]); var mergedData = motion ? transitionData : data; var treeNodeRequiredProps = { expandedKeys: expandedKeys, selectedKeys: selectedKeys, loadedKeys: loadedKeys, loadingKeys: loadingKeys, checkedKeys: checkedKeys, halfCheckedKeys: halfCheckedKeys, dragOverNodeKey: dragOverNodeKey, dropPosition: dropPosition, keyEntities: keyEntities }; return /*#__PURE__*/react.createElement(react.Fragment, null, focused && activeItem && /*#__PURE__*/react.createElement("span", { style: HIDDEN_STYLE, "aria-live": "assertive" }, getAccessibilityPath(activeItem)), /*#__PURE__*/react.createElement("div", null, /*#__PURE__*/react.createElement("input", { style: HIDDEN_STYLE, disabled: focusable === false || disabled, tabIndex: focusable !== false ? tabIndex : null, onKeyDown: onKeyDown, onFocus: onFocus, onBlur: onBlur, value: "", onChange: noop, "aria-label": "for screen reader" })), /*#__PURE__*/react.createElement("div", { className: "".concat(prefixCls, "-treenode"), "aria-hidden": true, style: { position: 'absolute', pointerEvents: 'none', visibility: 'hidden', height: 0, overflow: 'hidden', border: 0, padding: 0 } }, /*#__PURE__*/react.createElement("div", { className: "".concat(prefixCls, "-indent") }, /*#__PURE__*/react.createElement("div", { ref: indentMeasurerRef, className: "".concat(prefixCls, "-indent-unit") }))), /*#__PURE__*/react.createElement(es/* default */.Z, (0,esm_extends/* default */.Z)({}, domProps, { data: mergedData, itemKey: itemKey, height: height, fullHeight: false, virtual: virtual, itemHeight: itemHeight, prefixCls: "".concat(prefixCls, "-list"), ref: listRef, onVisibleChange: function onVisibleChange(originList, fullList) { var originSet = new Set(originList); var restList = fullList.filter(function (item) { return !originSet.has(item); }); // Motion node is not render. Skip motion if (restList.some(function (item) { return itemKey(item) === MOTION_KEY; })) { onMotionEnd(); } } }), function (treeNode) { var pos = treeNode.pos, restProps = (0,esm_extends/* default */.Z)({}, (_objectDestructuringEmpty(treeNode.data), treeNode.data)), title = treeNode.title, key = treeNode.key, isStart = treeNode.isStart, isEnd = treeNode.isEnd; var mergedKey = (0,treeUtil/* getKey */.km)(key, pos); delete restProps.key; delete restProps.children; var treeNodeProps = (0,treeUtil/* getTreeNodeProps */.H8)(mergedKey, treeNodeRequiredProps); return /*#__PURE__*/react.createElement(es_MotionTreeNode, (0,esm_extends/* default */.Z)({}, restProps, treeNodeProps, { title: title, active: !!activeItem && key === activeItem.key, pos: pos, data: treeNode.data, isStart: isStart, isEnd: isEnd, motion: motion, motionNodes: key === MOTION_KEY ? transitionRange : null, motionType: motionType, onMotionStart: onListChangeStart, onMotionEnd: onMotionEnd, treeNodeRequiredProps: treeNodeRequiredProps, onMouseMove: function onMouseMove() { onActiveChange(null); } })); })); }); NodeList.displayName = 'NodeList'; /* harmony default export */ var es_NodeList = (NodeList); // EXTERNAL MODULE: ./node_modules/rc-tree/es/utils/conductUtil.js var conductUtil = __webpack_require__(17341); ;// CONCATENATED MODULE: ./node_modules/rc-tree/es/DropIndicator.js function DropIndicator(_ref) { var dropPosition = _ref.dropPosition, dropLevelOffset = _ref.dropLevelOffset, indent = _ref.indent; var style = { pointerEvents: 'none', position: 'absolute', right: 0, backgroundColor: 'red', height: 2 }; switch (dropPosition) { case -1: style.top = 0; style.left = -dropLevelOffset * indent; break; case 1: style.bottom = 0; style.left = -dropLevelOffset * indent; break; case 0: style.bottom = 0; style.left = indent; break; } return /*#__PURE__*/react.createElement("div", { style: style }); } ;// CONCATENATED MODULE: ./node_modules/rc-tree/es/Tree.js // TODO: https://www.w3.org/TR/2017/NOTE-wai-aria-practices-1.1-20171214/examples/treeview/treeview-2/treeview-2a.html // Fully accessibility support var MAX_RETRY_TIMES = 10; var Tree = /*#__PURE__*/function (_React$Component) { (0,inherits/* default */.Z)(Tree, _React$Component); var _super = (0,createSuper/* default */.Z)(Tree); function Tree() { var _this; (0,classCallCheck/* default */.Z)(this, Tree); 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.destroyed = false; _this.delayedDragEnterLogic = void 0; _this.loadingRetryTimes = {}; _this.state = { keyEntities: {}, indent: null, selectedKeys: [], checkedKeys: [], halfCheckedKeys: [], loadedKeys: [], loadingKeys: [], expandedKeys: [], draggingNodeKey: null, dragChildrenKeys: [], // dropTargetKey is the key of abstract-drop-node // the abstract-drop-node is the real drop node when drag and drop // not the DOM drag over node dropTargetKey: null, dropPosition: null, dropContainerKey: null, dropLevelOffset: null, dropTargetPos: null, dropAllowed: true, // the abstract-drag-over-node // if mouse is on the bottom of top dom node or no the top of the bottom dom node // abstract-drag-over-node is the top node dragOverNodeKey: null, treeData: [], flattenNodes: [], focused: false, activeKey: null, listChanging: false, prevProps: null, fieldNames: (0,treeUtil/* fillFieldNames */.w$)() }; _this.dragStartMousePosition = null; _this.dragNode = void 0; _this.currentMouseOverDroppableNodeKey = null; _this.listRef = /*#__PURE__*/react.createRef(); _this.onNodeDragStart = function (event, node) { var _this$state = _this.state, expandedKeys = _this$state.expandedKeys, keyEntities = _this$state.keyEntities; var onDragStart = _this.props.onDragStart; var eventKey = node.props.eventKey; _this.dragNode = node; _this.dragStartMousePosition = { x: event.clientX, y: event.clientY }; var newExpandedKeys = (0,util/* arrDel */._5)(expandedKeys, eventKey); _this.setState({ draggingNodeKey: eventKey, dragChildrenKeys: (0,util/* getDragChildrenKeys */.wA)(eventKey, keyEntities), indent: _this.listRef.current.getIndentWidth() }); _this.setExpandedKeys(newExpandedKeys); window.addEventListener('dragend', _this.onWindowDragEnd); onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart({ event: event, node: (0,treeUtil/* convertNodePropsToEventData */.F)(node.props) }); }; /** * [Legacy] Select handler is smaller than node, * so that this will trigger when drag enter node or select handler. * This is a little tricky if customize css without padding. * Better for use mouse move event to refresh drag state. * But let's just keep it to avoid event trigger logic change. */ _this.onNodeDragEnter = function (event, node) { var _this$state2 = _this.state, expandedKeys = _this$state2.expandedKeys, keyEntities = _this$state2.keyEntities, dragChildrenKeys = _this$state2.dragChildrenKeys, flattenNodes = _this$state2.flattenNodes, indent = _this$state2.indent; var _this$props = _this.props, onDragEnter = _this$props.onDragEnter, onExpand = _this$props.onExpand, allowDrop = _this$props.allowDrop, direction = _this$props.direction; var _node$props = node.props, pos = _node$props.pos, eventKey = _node$props.eventKey; var _assertThisInitialize = (0,assertThisInitialized/* default */.Z)(_this), dragNode = _assertThisInitialize.dragNode; // record the key of node which is latest entered, used in dragleave event. if (_this.currentMouseOverDroppableNodeKey !== eventKey) { _this.currentMouseOverDroppableNodeKey = eventKey; } if (!dragNode) { _this.resetDragState(); return; } var _calcDropPosition = (0,util/* calcDropPosition */.OM)(event, dragNode, node, indent, _this.dragStartMousePosition, allowDrop, flattenNodes, keyEntities, expandedKeys, direction), dropPosition = _calcDropPosition.dropPosition, dropLevelOffset = _calcDropPosition.dropLevelOffset, dropTargetKey = _calcDropPosition.dropTargetKey, dropContainerKey = _calcDropPosition.dropContainerKey, dropTargetPos = _calcDropPosition.dropTargetPos, dropAllowed = _calcDropPosition.dropAllowed, dragOverNodeKey = _calcDropPosition.dragOverNodeKey; if ( // don't allow drop inside its children dragChildrenKeys.indexOf(dropTargetKey) !== -1 || // don't allow drop when drop is not allowed caculated by calcDropPosition !dropAllowed) { _this.resetDragState(); return; } // Side effect for delay drag if (!_this.delayedDragEnterLogic) { _this.delayedDragEnterLogic = {}; } Object.keys(_this.delayedDragEnterLogic).forEach(function (key) { clearTimeout(_this.delayedDragEnterLogic[key]); }); if (dragNode.props.eventKey !== node.props.eventKey) { // hoist expand logic here // since if logic is on the bottom // it will be blocked by abstract dragover node check // => if you dragenter from top, you mouse will still be consider as in the top node event.persist(); _this.delayedDragEnterLogic[pos] = window.setTimeout(function () { if (_this.state.draggingNodeKey === null) return; var newExpandedKeys = (0,toConsumableArray/* default */.Z)(expandedKeys); var entity = keyEntities[node.props.eventKey]; if (entity && (entity.children || []).length) { newExpandedKeys = (0,util/* arrAdd */.L0)(expandedKeys, node.props.eventKey); } if (!('expandedKeys' in _this.props)) { _this.setExpandedKeys(newExpandedKeys); } onExpand === null || onExpand === void 0 ? void 0 : onExpand(newExpandedKeys, { node: (0,treeUtil/* convertNodePropsToEventData */.F)(node.props), expanded: true, nativeEvent: event.nativeEvent }); }, 800); } // Skip if drag node is self if (dragNode.props.eventKey === dropTargetKey && dropLevelOffset === 0) { _this.resetDragState(); return; } // Update drag over node and drag state _this.setState({ dragOverNodeKey: dragOverNodeKey, dropPosition: dropPosition, dropLevelOffset: dropLevelOffset, dropTargetKey: dropTargetKey, dropContainerKey: dropContainerKey, dropTargetPos: dropTargetPos, dropAllowed: dropAllowed }); onDragEnter === null || onDragEnter === void 0 ? void 0 : onDragEnter({ event: event, node: (0,treeUtil/* convertNodePropsToEventData */.F)(node.props), expandedKeys: expandedKeys }); }; _this.onNodeDragOver = function (event, node) { var _this$state3 = _this.state, dragChildrenKeys = _this$state3.dragChildrenKeys, flattenNodes = _this$state3.flattenNodes, keyEntities = _this$state3.keyEntities, expandedKeys = _this$state3.expandedKeys, indent = _this$state3.indent; var _this$props2 = _this.props, onDragOver = _this$props2.onDragOver, allowDrop = _this$props2.allowDrop, direction = _this$props2.direction; var _assertThisInitialize2 = (0,assertThisInitialized/* default */.Z)(_this), dragNode = _assertThisInitialize2.dragNode; if (!dragNode) { return; } var _calcDropPosition2 = (0,util/* calcDropPosition */.OM)(event, dragNode, node, indent, _this.dragStartMousePosition, allowDrop, flattenNodes, keyEntities, expandedKeys, direction), dropPosition = _calcDropPosition2.dropPosition, dropLevelOffset = _calcDropPosition2.dropLevelOffset, dropTargetKey = _calcDropPosition2.dropTargetKey, dropContainerKey = _calcDropPosition2.dropContainerKey, dropAllowed = _calcDropPosition2.dropAllowed, dropTargetPos = _calcDropPosition2.dropTargetPos, dragOverNodeKey = _calcDropPosition2.dragOverNodeKey; if (dragChildrenKeys.indexOf(dropTargetKey) !== -1 || !dropAllowed) { // don't allow drop inside its children // don't allow drop when drop is not allowed caculated by calcDropPosition return; } // Update drag position if (dragNode.props.eventKey === dropTargetKey && dropLevelOffset === 0) { if (!(_this.state.dropPosition === null && _this.state.dropLevelOffset === null && _this.state.dropTargetKey === null && _this.state.dropContainerKey === null && _this.state.dropTargetPos === null && _this.state.dropAllowed === false && _this.state.dragOverNodeKey === null)) { _this.resetDragState(); } } else if (!(dropPosition === _this.state.dropPosition && dropLevelOffset === _this.state.dropLevelOffset && dropTargetKey === _this.state.dropTargetKey && dropContainerKey === _this.state.dropContainerKey && dropTargetPos === _this.state.dropTargetPos && dropAllowed === _this.state.dropAllowed && dragOverNodeKey === _this.state.dragOverNodeKey)) { _this.setState({ dropPosition: dropPosition, dropLevelOffset: dropLevelOffset, dropTargetKey: dropTargetKey, dropContainerKey: dropContainerKey, dropTargetPos: dropTargetPos, dropAllowed: dropAllowed, dragOverNodeKey: dragOverNodeKey }); } onDragOver === null || onDragOver === void 0 ? void 0 : onDragOver({ event: event, node: (0,treeUtil/* convertNodePropsToEventData */.F)(node.props) }); }; _this.onNodeDragLeave = function (event, node) { // if it is outside the droppable area // currentMouseOverDroppableNodeKey will be updated in dragenter event when into another droppable receiver. if (_this.currentMouseOverDroppableNodeKey === node.props.eventKey && !event.currentTarget.contains(event.relatedTarget)) { _this.resetDragState(); _this.currentMouseOverDroppableNodeKey = null; } var onDragLeave = _this.props.onDragLeave; onDragLeave === null || onDragLeave === void 0 ? void 0 : onDragLeave({ event: event, node: (0,treeUtil/* convertNodePropsToEventData */.F)(node.props) }); }; // since stopPropagation() is called in treeNode // if onWindowDrag is called, whice means state is keeped, drag state should be cleared _this.onWindowDragEnd = function (event) { _this.onNodeDragEnd(event, null, true); window.removeEventListener('dragend', _this.onWindowDragEnd); }; // if onNodeDragEnd is called, onWindowDragEnd won't be called since stopPropagation() is called _this.onNodeDragEnd = function (event, node) { var onDragEnd = _this.props.onDragEnd; _this.setState({ dragOverNodeKey: null }); _this.cleanDragState(); onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd({ event: event, node: (0,treeUtil/* convertNodePropsToEventData */.F)(node.props) }); _this.dragNode = null; window.removeEventListener('dragend', _this.onWindowDragEnd); }; _this.onNodeDrop = function (event, node) { var _this$getActiveItem; var outsideTree = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; var _this$state4 = _this.state, dragChildrenKeys = _this$state4.dragChildrenKeys, dropPosition = _this$state4.dropPosition, dropTargetKey = _this$state4.dropTargetKey, dropTargetPos = _this$state4.dropTargetPos, dropAllowed = _this$state4.dropAllowed; if (!dropAllowed) return; var onDrop = _this.props.onDrop; _this.setState({ dragOverNodeKey: null }); _this.cleanDragState(); if (dropTargetKey === null) return; var abstractDropNodeProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, (0,treeUtil/* getTreeNodeProps */.H8)(dropTargetKey, _this.getTreeNodeRequiredProps())), {}, { active: ((_this$getActiveItem = _this.getActiveItem()) === null || _this$getActiveItem === void 0 ? void 0 : _this$getActiveItem.key) === dropTargetKey, data: _this.state.keyEntities[dropTargetKey].node }); var dropToChild = dragChildrenKeys.indexOf(dropTargetKey) !== -1; (0,warning/* default */.ZP)(!dropToChild, "Can not drop to dragNode's children node. This is a bug of rc-tree. Please report an issue."); var posArr = (0,util/* posToArr */.yx)(dropTargetPos); var dropResult = { event: event, node: (0,treeUtil/* convertNodePropsToEventData */.F)(abstractDropNodeProps), dragNode: _this.dragNode ? (0,treeUtil/* convertNodePropsToEventData */.F)(_this.dragNode.props) : null, dragNodesKeys: [_this.dragNode.props.eventKey].concat(dragChildrenKeys), dropToGap: dropPosition !== 0, dropPosition: dropPosition + Number(posArr[posArr.length - 1]) }; if (!outsideTree) { onDrop === null || onDrop === void 0 ? void 0 : onDrop(dropResult); } _this.dragNode = null; }; _this.cleanDragState = function () { var draggingNodeKey = _this.state.draggingNodeKey; if (draggingNodeKey !== null) { _this.setState({ draggingNodeKey: null, dropPosition: null, dropContainerKey: null, dropTargetKey: null, dropLevelOffset: null, dropAllowed: true, dragOverNodeKey: null }); } _this.dragStartMousePosition = null; _this.currentMouseOverDroppableNodeKey = null; }; _this.triggerExpandActionExpand = function (e, treeNode) { var _this$state5 = _this.state, expandedKeys = _this$state5.expandedKeys, flattenNodes = _this$state5.flattenNodes; var expanded = treeNode.expanded, key = treeNode.key, isLeaf = treeNode.isLeaf; if (isLeaf || e.shiftKey || e.metaKey || e.ctrlKey) { return; } var node = flattenNodes.filter(function (nodeItem) { return nodeItem.key === key; })[0]; var eventNode = (0,treeUtil/* convertNodePropsToEventData */.F)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, (0,treeUtil/* getTreeNodeProps */.H8)(key, _this.getTreeNodeRequiredProps())), {}, { data: node.data })); _this.setExpandedKeys(expanded ? (0,util/* arrDel */._5)(expandedKeys, key) : (0,util/* arrAdd */.L0)(expandedKeys, key)); _this.onNodeExpand(e, eventNode); }; _this.onNodeClick = function (e, treeNode) { var _this$props3 = _this.props, onClick = _this$props3.onClick, expandAction = _this$props3.expandAction; if (expandAction === 'click') { _this.triggerExpandActionExpand(e, treeNode); } onClick === null || onClick === void 0 ? void 0 : onClick(e, treeNode); }; _this.onNodeDoubleClick = function (e, treeNode) { var _this$props4 = _this.props, onDoubleClick = _this$props4.onDoubleClick, expandAction = _this$props4.expandAction; if (expandAction === 'doubleClick') { _this.triggerExpandActionExpand(e, treeNode); } onDoubleClick === null || onDoubleClick === void 0 ? void 0 : onDoubleClick(e, treeNode); }; _this.onNodeSelect = function (e, treeNode) { var selectedKeys = _this.state.selectedKeys; var _this$state6 = _this.state, keyEntities = _this$state6.keyEntities, fieldNames = _this$state6.fieldNames; var _this$props5 = _this.props, onSelect = _this$props5.onSelect, multiple = _this$props5.multiple; var selected = treeNode.selected; var key = treeNode[fieldNames.key]; var targetSelected = !selected; // Update selected keys if (!targetSelected) { selectedKeys = (0,util/* arrDel */._5)(selectedKeys, key); } else if (!multiple) { selectedKeys = [key]; } else { selectedKeys = (0,util/* arrAdd */.L0)(selectedKeys, key); } // [Legacy] Not found related usage in doc or upper libs var selectedNodes = selectedKeys.map(function (selectedKey) { var entity = keyEntities[selectedKey]; if (!entity) return null; return entity.node; }).filter(function (node) { return node; }); _this.setUncontrolledState({ selectedKeys: selectedKeys }); onSelect === null || onSelect === void 0 ? void 0 : onSelect(selectedKeys, { event: 'select', selected: targetSelected, node: treeNode, selectedNodes: selectedNodes, nativeEvent: e.nativeEvent }); }; _this.onNodeCheck = function (e, treeNode, checked) { var _this$state7 = _this.state, keyEntities = _this$state7.keyEntities, oriCheckedKeys = _this$state7.checkedKeys, oriHalfCheckedKeys = _this$state7.halfCheckedKeys; var _this$props6 = _this.props, checkStrictly = _this$props6.checkStrictly, onCheck = _this$props6.onCheck; var key = treeNode.key; // Prepare trigger arguments var checkedObj; var eventObj = { event: 'check', node: treeNode, checked: checked, nativeEvent: e.nativeEvent }; if (checkStrictly) { var checkedKeys = checked ? (0,util/* arrAdd */.L0)(oriCheckedKeys, key) : (0,util/* arrDel */._5)(oriCheckedKeys, key); var halfCheckedKeys = (0,util/* arrDel */._5)(oriHalfCheckedKeys, key); checkedObj = { checked: checkedKeys, halfChecked: halfCheckedKeys }; eventObj.checkedNodes = checkedKeys.map(function (checkedKey) { return keyEntities[checkedKey]; }).filter(function (entity) { return entity; }).map(function (entity) { return entity.node; }); _this.setUncontrolledState({ checkedKeys: checkedKeys }); } else { // Always fill first var _conductCheck = (0,conductUtil/* conductCheck */.S)([].concat((0,toConsumableArray/* default */.Z)(oriCheckedKeys), [key]), true, keyEntities), _checkedKeys = _conductCheck.checkedKeys, _halfCheckedKeys = _conductCheck.halfCheckedKeys; // If remove, we do it again to correction if (!checked) { var keySet = new Set(_checkedKeys); keySet.delete(key); var _conductCheck2 = (0,conductUtil/* conductCheck */.S)(Array.from(keySet), { checked: false, halfCheckedKeys: _halfCheckedKeys }, keyEntities); _checkedKeys = _conductCheck2.checkedKeys; _halfCheckedKeys = _conductCheck2.halfCheckedKeys; } checkedObj = _checkedKeys; // [Legacy] This is used for `rc-tree-select` eventObj.checkedNodes = []; eventObj.checkedNodesPositions = []; eventObj.halfCheckedKeys = _halfCheckedKeys; _checkedKeys.forEach(function (checkedKey) { var entity = keyEntities[checkedKey]; if (!entity) return; var node = entity.node, pos = entity.pos; eventObj.checkedNodes.push(node); eventObj.checkedNodesPositions.push({ node: node, pos: pos }); }); _this.setUncontrolledState({ checkedKeys: _checkedKeys }, false, { halfCheckedKeys: _halfCheckedKeys }); } onCheck === null || onCheck === void 0 ? void 0 : onCheck(checkedObj, eventObj); }; _this.onNodeLoad = function (treeNode) { var key = treeNode.key; var loadPromise = new Promise(function (resolve, reject) { // We need to get the latest state of loading/loaded keys _this.setState(function (_ref) { var _ref$loadedKeys = _ref.loadedKeys, loadedKeys = _ref$loadedKeys === void 0 ? [] : _ref$loadedKeys, _ref$loadingKeys = _ref.loadingKeys, loadingKeys = _ref$loadingKeys === void 0 ? [] : _ref$loadingKeys; var _this$props7 = _this.props, loadData = _this$props7.loadData, onLoad = _this$props7.onLoad; if (!loadData || loadedKeys.indexOf(key) !== -1 || loadingKeys.indexOf(key) !== -1) { return null; } // Process load data var promise = loadData(treeNode); promise.then(function () { var currentLoadedKeys = _this.state.loadedKeys; var newLoadedKeys = (0,util/* arrAdd */.L0)(currentLoadedKeys, key); // onLoad should trigger before internal setState to avoid `loadData` trigger twice. // https://github.com/ant-design/ant-design/issues/12464 onLoad === null || onLoad === void 0 ? void 0 : onLoad(newLoadedKeys, { event: 'load', node: treeNode }); _this.setUncontrolledState({ loadedKeys: newLoadedKeys }); _this.setState(function (prevState) { return { loadingKeys: (0,util/* arrDel */._5)(prevState.loadingKeys, key) }; }); resolve(); }).catch(function (e) { _this.setState(function (prevState) { return { loadingKeys: (0,util/* arrDel */._5)(prevState.loadingKeys, key) }; }); // If exceed max retry times, we give up retry _this.loadingRetryTimes[key] = (_this.loadingRetryTimes[key] || 0) + 1; if (_this.loadingRetryTimes[key] >= MAX_RETRY_TIMES) { var currentLoadedKeys = _this.state.loadedKeys; (0,warning/* default */.ZP)(false, 'Retry for `loadData` many times but still failed. No more retry.'); _this.setUncontrolledState({ loadedKeys: (0,util/* arrAdd */.L0)(currentLoadedKeys, key) }); resolve(); } reject(e); }); return { loadingKeys: (0,util/* arrAdd */.L0)(loadingKeys, key) }; }); }); // Not care warning if we ignore this loadPromise.catch(function () {}); return loadPromise; }; _this.onNodeMouseEnter = function (event, node) { var onMouseEnter = _this.props.onMouseEnter; onMouseEnter === null || onMouseEnter === void 0 ? void 0 : onMouseEnter({ event: event, node: node }); }; _this.onNodeMouseLeave = function (event, node) { var onMouseLeave = _this.props.onMouseLeave; onMouseLeave === null || onMouseLeave === void 0 ? void 0 : onMouseLeave({ event: event, node: node }); }; _this.onNodeContextMenu = function (event, node) { var onRightClick = _this.props.onRightClick; if (onRightClick) { event.preventDefault(); onRightClick({ event: event, node: node }); } }; _this.onFocus = function () { var onFocus = _this.props.onFocus; _this.setState({ focused: true }); for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { args[_key2] = arguments[_key2]; } onFocus === null || onFocus === void 0 ? void 0 : onFocus.apply(void 0, args); }; _this.onBlur = function () { var onBlur = _this.props.onBlur; _this.setState({ focused: false }); _this.onActiveChange(null); for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { args[_key3] = arguments[_key3]; } onBlur === null || onBlur === void 0 ? void 0 : onBlur.apply(void 0, args); }; _this.getTreeNodeRequiredProps = function () { var _this$state8 = _this.state, expandedKeys = _this$state8.expandedKeys, selectedKeys = _this$state8.selectedKeys, loadedKeys = _this$state8.loadedKeys, loadingKeys = _this$state8.loadingKeys, checkedKeys = _this$state8.checkedKeys, halfCheckedKeys = _this$state8.halfCheckedKeys, dragOverNodeKey = _this$state8.dragOverNodeKey, dropPosition = _this$state8.dropPosition, keyEntities = _this$state8.keyEntities; return { expandedKeys: expandedKeys || [], selectedKeys: selectedKeys || [], loadedKeys: loadedKeys || [], loadingKeys: loadingKeys || [], checkedKeys: checkedKeys || [], halfCheckedKeys: halfCheckedKeys || [], dragOverNodeKey: dragOverNodeKey, dropPosition: dropPosition, keyEntities: keyEntities }; }; // =========================== Expanded =========================== /** Set uncontrolled `expandedKeys`. This will also auto update `flattenNodes`. */ _this.setExpandedKeys = function (expandedKeys) { var _this$state9 = _this.state, treeData = _this$state9.treeData, fieldNames = _this$state9.fieldNames; var flattenNodes = (0,treeUtil/* flattenTreeData */.oH)(treeData, expandedKeys, fieldNames); _this.setUncontrolledState({ expandedKeys: expandedKeys, flattenNodes: flattenNodes }, true); }; _this.onNodeExpand = function (e, treeNode) { var expandedKeys = _this.state.expandedKeys; var _this$state10 = _this.state, listChanging = _this$state10.listChanging, fieldNames = _this$state10.fieldNames; var _this$props8 = _this.props, onExpand = _this$props8.onExpand, loadData = _this$props8.loadData; var expanded = treeNode.expanded; var key = treeNode[fieldNames.key]; // Do nothing when motion is in progress if (listChanging) { return; } // Update selected keys var index = expandedKeys.indexOf(key); var targetExpanded = !expanded; (0,warning/* default */.ZP)(expanded && index !== -1 || !expanded && index === -1, 'Expand state not sync with index check'); if (targetExpanded) { expandedKeys = (0,util/* arrAdd */.L0)(expandedKeys, key); } else { expandedKeys = (0,util/* arrDel */._5)(expandedKeys, key); } _this.setExpandedKeys(expandedKeys); onExpand === null || onExpand === void 0 ? void 0 : onExpand(expandedKeys, { node: treeNode, expanded: targetExpanded, nativeEvent: e.nativeEvent }); // Async Load data if (targetExpanded && loadData) { var loadPromise = _this.onNodeLoad(treeNode); if (loadPromise) { loadPromise.then(function () { // [Legacy] Refresh logic var newFlattenTreeData = (0,treeUtil/* flattenTreeData */.oH)(_this.state.treeData, expandedKeys, fieldNames); _this.setUncontrolledState({ flattenNodes: newFlattenTreeData }); }).catch(function () { var currentExpandedKeys = _this.state.expandedKeys; var expandedKeysToRestore = (0,util/* arrDel */._5)(currentExpandedKeys, key); _this.setExpandedKeys(expandedKeysToRestore); }); } } }; _this.onListChangeStart = function () { _this.setUncontrolledState({ listChanging: true }); }; _this.onListChangeEnd = function () { setTimeout(function () { _this.setUncontrolledState({ listChanging: false }); }); }; // =========================== Keyboard =========================== _this.onActiveChange = function (newActiveKey) { var activeKey = _this.state.activeKey; var onActiveChange = _this.props.onActiveChange; if (activeKey === newActiveKey) { return; } _this.setState({ activeKey: newActiveKey }); if (newActiveKey !== null) { _this.scrollTo({ key: newActiveKey }); } onActiveChange === null || onActiveChange === void 0 ? void 0 : onActiveChange(newActiveKey); }; _this.getActiveItem = function () { var _this$state11 = _this.state, activeKey = _this$state11.activeKey, flattenNodes = _this$state11.flattenNodes; if (activeKey === null) { return null; } return flattenNodes.find(function (_ref2) { var key = _ref2.key; return key === activeKey; }) || null; }; _this.offsetActiveKey = function (offset) { var _this$state12 = _this.state, flattenNodes = _this$state12.flattenNodes, activeKey = _this$state12.activeKey; var index = flattenNodes.findIndex(function (_ref3) { var key = _ref3.key; return key === activeKey; }); // Align with index if (index === -1 && offset < 0) { index = flattenNodes.length; } index = (index + offset + flattenNodes.length) % flattenNodes.length; var item = flattenNodes[index]; if (item) { var key = item.key; _this.onActiveChange(key); } else { _this.onActiveChange(null); } }; _this.onKeyDown = function (event) { var _this$state13 = _this.state, activeKey = _this$state13.activeKey, expandedKeys = _this$state13.expandedKeys, checkedKeys = _this$state13.checkedKeys, fieldNames = _this$state13.fieldNames; var _this$props9 = _this.props, onKeyDown = _this$props9.onKeyDown, checkable = _this$props9.checkable, selectable = _this$props9.selectable; // >>>>>>>>>> Direction switch (event.which) { case KeyCode/* default.UP */.Z.UP: { _this.offsetActiveKey(-1); event.preventDefault(); break; } case KeyCode/* default.DOWN */.Z.DOWN: { _this.offsetActiveKey(1); event.preventDefault(); break; } } // >>>>>>>>>> Expand & Selection var activeItem = _this.getActiveItem(); if (activeItem && activeItem.data) { var treeNodeRequiredProps = _this.getTreeNodeRequiredProps(); var expandable = activeItem.data.isLeaf === false || !!(activeItem.data[fieldNames.children] || []).length; var eventNode = (0,treeUtil/* convertNodePropsToEventData */.F)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, (0,treeUtil/* getTreeNodeProps */.H8)(activeKey, treeNodeRequiredProps)), {}, { data: activeItem.data, active: true })); switch (event.which) { // >>> Expand case KeyCode/* default.LEFT */.Z.LEFT: { // Collapse if possible if (expandable && expandedKeys.includes(activeKey)) { _this.onNodeExpand({}, eventNode); } else if (activeItem.parent) { _this.onActiveChange(activeItem.parent.key); } event.preventDefault(); break; } case KeyCode/* default.RIGHT */.Z.RIGHT: { // Expand if possible if (expandable && !expandedKeys.includes(activeKey)) { _this.onNodeExpand({}, eventNode); } else if (activeItem.children && activeItem.children.length) { _this.onActiveChange(activeItem.children[0].key); } event.preventDefault(); break; } // Selection case KeyCode/* default.ENTER */.Z.ENTER: case KeyCode/* default.SPACE */.Z.SPACE: { if (checkable && !eventNode.disabled && eventNode.checkable !== false && !eventNode.disableCheckbox) { _this.onNodeCheck({}, eventNode, !checkedKeys.includes(activeKey)); } else if (!checkable && selectable && !eventNode.disabled && eventNode.selectable !== false) { _this.onNodeSelect({}, eventNode); } break; } } } onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event); }; /** * Only update the value which is not in props */ _this.setUncontrolledState = function (state) { var atomic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; var forceState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; if (!_this.destroyed) { var needSync = false; var allPassed = true; var newState = {}; Object.keys(state).forEach(function (name) { if (name in _this.props) { allPassed = false; return; } needSync = true; newState[name] = state[name]; }); if (needSync && (!atomic || allPassed)) { _this.setState((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, newState), forceState)); } } }; _this.scrollTo = function (scroll) { _this.listRef.current.scrollTo(scroll); }; return _this; } (0,createClass/* default */.Z)(Tree, [{ key: "componentDidMount", value: function componentDidMount() { this.destroyed = false; this.onUpdated(); } }, { key: "componentDidUpdate", value: function componentDidUpdate() { this.onUpdated(); } }, { key: "onUpdated", value: function onUpdated() { var activeKey = this.props.activeKey; if (activeKey !== undefined && activeKey !== this.state.activeKey) { this.setState({ activeKey: activeKey }); if (activeKey !== null) { this.scrollTo({ key: activeKey }); } } } }, { key: "componentWillUnmount", value: function componentWillUnmount() { window.removeEventListener('dragend', this.onWindowDragEnd); this.destroyed = true; } }, { key: "resetDragState", value: function resetDragState() { this.setState({ dragOverNodeKey: null, dropPosition: null, dropLevelOffset: null, dropTargetKey: null, dropContainerKey: null, dropTargetPos: null, dropAllowed: false }); } }, { key: "render", value: function render() { var _classNames; var _this$state14 = this.state, focused = _this$state14.focused, flattenNodes = _this$state14.flattenNodes, keyEntities = _this$state14.keyEntities, draggingNodeKey = _this$state14.draggingNodeKey, activeKey = _this$state14.activeKey, dropLevelOffset = _this$state14.dropLevelOffset, dropContainerKey = _this$state14.dropContainerKey, dropTargetKey = _this$state14.dropTargetKey, dropPosition = _this$state14.dropPosition, dragOverNodeKey = _this$state14.dragOverNodeKey, indent = _this$state14.indent; var _this$props10 = this.props, prefixCls = _this$props10.prefixCls, className = _this$props10.className, style = _this$props10.style, showLine = _this$props10.showLine, focusable = _this$props10.focusable, _this$props10$tabInde = _this$props10.tabIndex, tabIndex = _this$props10$tabInde === void 0 ? 0 : _this$props10$tabInde, selectable = _this$props10.selectable, showIcon = _this$props10.showIcon, icon = _this$props10.icon, switcherIcon = _this$props10.switcherIcon, draggable = _this$props10.draggable, checkable = _this$props10.checkable, checkStrictly = _this$props10.checkStrictly, disabled = _this$props10.disabled, motion = _this$props10.motion, loadData = _this$props10.loadData, filterTreeNode = _this$props10.filterTreeNode, height = _this$props10.height, itemHeight = _this$props10.itemHeight, virtual = _this$props10.virtual, titleRender = _this$props10.titleRender, dropIndicatorRender = _this$props10.dropIndicatorRender, onContextMenu = _this$props10.onContextMenu, onScroll = _this$props10.onScroll, direction = _this$props10.direction, rootClassName = _this$props10.rootClassName, rootStyle = _this$props10.rootStyle; var domProps = (0,pickAttrs/* default */.Z)(this.props, { aria: true, data: true }); // It's better move to hooks but we just simply keep here var draggableConfig; if (draggable) { if ((0,esm_typeof/* default */.Z)(draggable) === 'object') { draggableConfig = draggable; } else if (typeof draggable === 'function') { draggableConfig = { nodeDraggable: draggable }; } else { draggableConfig = {}; } } return /*#__PURE__*/react.createElement(contextTypes/* TreeContext.Provider */.k.Provider, { value: { prefixCls: prefixCls, selectable: selectable, showIcon: showIcon, icon: icon, switcherIcon: switcherIcon, draggable: draggableConfig, draggingNodeKey: draggingNodeKey, checkable: checkable, checkStrictly: checkStrictly, disabled: disabled, keyEntities: keyEntities, dropLevelOffset: dropLevelOffset, dropContainerKey: dropContainerKey, dropTargetKey: dropTargetKey, dropPosition: dropPosition, dragOverNodeKey: dragOverNodeKey, indent: indent, direction: direction, dropIndicatorRender: dropIndicatorRender, loadData: loadData, filterTreeNode: filterTreeNode, titleRender: titleRender, onNodeClick: this.onNodeClick, onNodeDoubleClick: this.onNodeDoubleClick, onNodeExpand: this.onNodeExpand, onNodeSelect: this.onNodeSelect, onNodeCheck: this.onNodeCheck, onNodeLoad: this.onNodeLoad, onNodeMouseEnter: this.onNodeMouseEnter, onNodeMouseLeave: this.onNodeMouseLeave, onNodeContextMenu: this.onNodeContextMenu, onNodeDragStart: this.onNodeDragStart, onNodeDragEnter: this.onNodeDragEnter, onNodeDragOver: this.onNodeDragOver, onNodeDragLeave: this.onNodeDragLeave, onNodeDragEnd: this.onNodeDragEnd, onNodeDrop: this.onNodeDrop } }, /*#__PURE__*/react.createElement("div", { role: "tree", className: classnames_default()(prefixCls, className, rootClassName, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-show-line"), showLine), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-focused"), focused), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-active-focused"), activeKey !== null), _classNames)), style: rootStyle }, /*#__PURE__*/react.createElement(es_NodeList, (0,esm_extends/* default */.Z)({ ref: this.listRef, prefixCls: prefixCls, style: style, data: flattenNodes, disabled: disabled, selectable: selectable, checkable: !!checkable, motion: motion, dragging: draggingNodeKey !== null, height: height, itemHeight: itemHeight, virtual: virtual, focusable: focusable, focused: focused, tabIndex: tabIndex, activeItem: this.getActiveItem(), onFocus: this.onFocus, onBlur: this.onBlur, onKeyDown: this.onKeyDown, onActiveChange: this.onActiveChange, onListChangeStart: this.onListChangeStart, onListChangeEnd: this.onListChangeEnd, onContextMenu: onContextMenu, onScroll: onScroll }, this.getTreeNodeRequiredProps(), domProps)))); } }], [{ key: "getDerivedStateFromProps", value: function getDerivedStateFromProps(props, prevState) { var prevProps = prevState.prevProps; var newState = { prevProps: props }; function needSync(name) { return !prevProps && name in props || prevProps && prevProps[name] !== props[name]; } // ================== Tree Node ================== var treeData; // fieldNames var fieldNames = prevState.fieldNames; if (needSync('fieldNames')) { fieldNames = (0,treeUtil/* fillFieldNames */.w$)(props.fieldNames); newState.fieldNames = fieldNames; } // Check if `treeData` or `children` changed and save into the state. if (needSync('treeData')) { treeData = props.treeData; } else if (needSync('children')) { (0,warning/* default */.ZP)(false, '`children` of Tree is deprecated. Please use `treeData` instead.'); treeData = (0,treeUtil/* convertTreeToData */.zn)(props.children); } // Save flatten nodes info and convert `treeData` into keyEntities if (treeData) { newState.treeData = treeData; var entitiesMap = (0,treeUtil/* convertDataToEntities */.I8)(treeData, { fieldNames: fieldNames }); newState.keyEntities = (0,objectSpread2/* default */.Z)((0,defineProperty/* default */.Z)({}, MOTION_KEY, MotionEntity), entitiesMap.keyEntities); // Warning if treeNode not provide key if (false) {} } var keyEntities = newState.keyEntities || prevState.keyEntities; // ================ expandedKeys ================= if (needSync('expandedKeys') || prevProps && needSync('autoExpandParent')) { newState.expandedKeys = props.autoExpandParent || !prevProps && props.defaultExpandParent ? (0,util/* conductExpandParent */.r7)(props.expandedKeys, keyEntities) : props.expandedKeys; } else if (!prevProps && props.defaultExpandAll) { var cloneKeyEntities = (0,objectSpread2/* default */.Z)({}, keyEntities); delete cloneKeyEntities[MOTION_KEY]; newState.expandedKeys = Object.keys(cloneKeyEntities).map(function (key) { return cloneKeyEntities[key].key; }); } else if (!prevProps && props.defaultExpandedKeys) { newState.expandedKeys = props.autoExpandParent || props.defaultExpandParent ? (0,util/* conductExpandParent */.r7)(props.defaultExpandedKeys, keyEntities) : props.defaultExpandedKeys; } if (!newState.expandedKeys) { delete newState.expandedKeys; } // ================ flattenNodes ================= if (treeData || newState.expandedKeys) { var flattenNodes = (0,treeUtil/* flattenTreeData */.oH)(treeData || prevState.treeData, newState.expandedKeys || prevState.expandedKeys, fieldNames); newState.flattenNodes = flattenNodes; } // ================ selectedKeys ================= if (props.selectable) { if (needSync('selectedKeys')) { newState.selectedKeys = (0,util/* calcSelectedKeys */.BT)(props.selectedKeys, props); } else if (!prevProps && props.defaultSelectedKeys) { newState.selectedKeys = (0,util/* calcSelectedKeys */.BT)(props.defaultSelectedKeys, props); } } // ================= checkedKeys ================= if (props.checkable) { var checkedKeyEntity; if (needSync('checkedKeys')) { checkedKeyEntity = (0,util/* parseCheckedKeys */.E6)(props.checkedKeys) || {}; } else if (!prevProps && props.defaultCheckedKeys) { checkedKeyEntity = (0,util/* parseCheckedKeys */.E6)(props.defaultCheckedKeys) || {}; } else if (treeData) { // If `treeData` changed, we also need check it checkedKeyEntity = (0,util/* parseCheckedKeys */.E6)(props.checkedKeys) || { checkedKeys: prevState.checkedKeys, halfCheckedKeys: prevState.halfCheckedKeys }; } if (checkedKeyEntity) { var _checkedKeyEntity = checkedKeyEntity, _checkedKeyEntity$che = _checkedKeyEntity.checkedKeys, checkedKeys = _checkedKeyEntity$che === void 0 ? [] : _checkedKeyEntity$che, _checkedKeyEntity$hal = _checkedKeyEntity.halfCheckedKeys, halfCheckedKeys = _checkedKeyEntity$hal === void 0 ? [] : _checkedKeyEntity$hal; if (!props.checkStrictly) { var conductKeys = (0,conductUtil/* conductCheck */.S)(checkedKeys, true, keyEntities); checkedKeys = conductKeys.checkedKeys; halfCheckedKeys = conductKeys.halfCheckedKeys; } newState.checkedKeys = checkedKeys; newState.halfCheckedKeys = halfCheckedKeys; } } // ================= loadedKeys ================== if (needSync('loadedKeys')) { newState.loadedKeys = props.loadedKeys; } return newState; } }]); return Tree; }(react.Component); Tree.defaultProps = { prefixCls: 'rc-tree', showLine: false, showIcon: true, selectable: true, multiple: false, checkable: false, disabled: false, checkStrictly: false, draggable: false, defaultExpandParent: true, autoExpandParent: false, defaultExpandAll: false, defaultExpandedKeys: [], defaultCheckedKeys: [], defaultSelectedKeys: [], dropIndicatorRender: DropIndicator, allowDrop: function allowDrop() { return true; }, expandAction: false }; Tree.TreeNode = TreeNode/* default */.Z; /* harmony default export */ var es_Tree = (Tree); ;// CONCATENATED MODULE: ./node_modules/rc-tree/es/index.js /* harmony default export */ var rc_tree_es = (es_Tree); /***/ }) }]);