1 | "use strict";
|
2 |
|
3 | var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
4 | var _typeof3 = require("@babel/runtime/helpers/typeof");
|
5 | Object.defineProperty(exports, "__esModule", {
|
6 | value: true
|
7 | });
|
8 | exports.default = void 0;
|
9 | var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
|
10 | var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
|
11 | var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
12 | var _objectSpread3 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
13 | var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
14 | var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
|
15 | var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
|
16 | var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
|
17 | var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
|
18 | var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
|
19 | var React = _interopRequireWildcard(require("react"));
|
20 | var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
|
21 | var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
22 | var _pickAttrs = _interopRequireDefault(require("rc-util/lib/pickAttrs"));
|
23 | var _classnames = _interopRequireDefault(require("classnames"));
|
24 | var _contextTypes = require("./contextTypes");
|
25 | var _util = require("./util");
|
26 | var _treeUtil = require("./utils/treeUtil");
|
27 | var _NodeList = _interopRequireWildcard(require("./NodeList"));
|
28 | var _TreeNode = _interopRequireDefault(require("./TreeNode"));
|
29 | var _conductUtil = require("./utils/conductUtil");
|
30 | var _DropIndicator = _interopRequireDefault(require("./DropIndicator"));
|
31 | function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
32 | function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
33 |
|
34 |
|
35 |
|
36 | var MAX_RETRY_TIMES = 10;
|
37 | var Tree = function (_React$Component) {
|
38 | (0, _inherits2.default)(Tree, _React$Component);
|
39 | var _super = (0, _createSuper2.default)(Tree);
|
40 | function Tree() {
|
41 | var _this;
|
42 | (0, _classCallCheck2.default)(this, Tree);
|
43 | for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
|
44 | _args[_key] = arguments[_key];
|
45 | }
|
46 | _this = _super.call.apply(_super, [this].concat(_args));
|
47 | _this.destroyed = false;
|
48 | _this.delayedDragEnterLogic = void 0;
|
49 | _this.loadingRetryTimes = {};
|
50 | _this.state = {
|
51 | keyEntities: {},
|
52 | indent: null,
|
53 | selectedKeys: [],
|
54 | checkedKeys: [],
|
55 | halfCheckedKeys: [],
|
56 | loadedKeys: [],
|
57 | loadingKeys: [],
|
58 | expandedKeys: [],
|
59 | draggingNodeKey: null,
|
60 | dragChildrenKeys: [],
|
61 |
|
62 |
|
63 |
|
64 | dropTargetKey: null,
|
65 | dropPosition: null,
|
66 | dropContainerKey: null,
|
67 | dropLevelOffset: null,
|
68 | dropTargetPos: null,
|
69 | dropAllowed: true,
|
70 |
|
71 |
|
72 |
|
73 | dragOverNodeKey: null,
|
74 | treeData: [],
|
75 | flattenNodes: [],
|
76 | focused: false,
|
77 | activeKey: null,
|
78 | listChanging: false,
|
79 | prevProps: null,
|
80 | fieldNames: (0, _treeUtil.fillFieldNames)()
|
81 | };
|
82 | _this.dragStartMousePosition = null;
|
83 | _this.dragNode = void 0;
|
84 | _this.currentMouseOverDroppableNodeKey = null;
|
85 | _this.listRef = React.createRef();
|
86 | _this.onNodeDragStart = function (event, node) {
|
87 | var _this$state = _this.state,
|
88 | expandedKeys = _this$state.expandedKeys,
|
89 | keyEntities = _this$state.keyEntities;
|
90 | var onDragStart = _this.props.onDragStart;
|
91 | var eventKey = node.props.eventKey;
|
92 | _this.dragNode = node;
|
93 | _this.dragStartMousePosition = {
|
94 | x: event.clientX,
|
95 | y: event.clientY
|
96 | };
|
97 | var newExpandedKeys = (0, _util.arrDel)(expandedKeys, eventKey);
|
98 | _this.setState({
|
99 | draggingNodeKey: eventKey,
|
100 | dragChildrenKeys: (0, _util.getDragChildrenKeys)(eventKey, keyEntities),
|
101 | indent: _this.listRef.current.getIndentWidth()
|
102 | });
|
103 | _this.setExpandedKeys(newExpandedKeys);
|
104 | window.addEventListener('dragend', _this.onWindowDragEnd);
|
105 | onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart({
|
106 | event: event,
|
107 | node: (0, _treeUtil.convertNodePropsToEventData)(node.props)
|
108 | });
|
109 | };
|
110 | |
111 |
|
112 |
|
113 |
|
114 |
|
115 |
|
116 |
|
117 | _this.onNodeDragEnter = function (event, node) {
|
118 | var _this$state2 = _this.state,
|
119 | expandedKeys = _this$state2.expandedKeys,
|
120 | keyEntities = _this$state2.keyEntities,
|
121 | dragChildrenKeys = _this$state2.dragChildrenKeys,
|
122 | flattenNodes = _this$state2.flattenNodes,
|
123 | indent = _this$state2.indent;
|
124 | var _this$props = _this.props,
|
125 | onDragEnter = _this$props.onDragEnter,
|
126 | onExpand = _this$props.onExpand,
|
127 | allowDrop = _this$props.allowDrop,
|
128 | direction = _this$props.direction;
|
129 | var _node$props = node.props,
|
130 | pos = _node$props.pos,
|
131 | eventKey = _node$props.eventKey;
|
132 | var _assertThisInitialize = (0, _assertThisInitialized2.default)(_this),
|
133 | dragNode = _assertThisInitialize.dragNode;
|
134 |
|
135 | if (_this.currentMouseOverDroppableNodeKey !== eventKey) {
|
136 | _this.currentMouseOverDroppableNodeKey = eventKey;
|
137 | }
|
138 | if (!dragNode) {
|
139 | _this.resetDragState();
|
140 | return;
|
141 | }
|
142 | var _calcDropPosition = (0, _util.calcDropPosition)(event, dragNode, node, indent, _this.dragStartMousePosition, allowDrop, flattenNodes, keyEntities, expandedKeys, direction),
|
143 | dropPosition = _calcDropPosition.dropPosition,
|
144 | dropLevelOffset = _calcDropPosition.dropLevelOffset,
|
145 | dropTargetKey = _calcDropPosition.dropTargetKey,
|
146 | dropContainerKey = _calcDropPosition.dropContainerKey,
|
147 | dropTargetPos = _calcDropPosition.dropTargetPos,
|
148 | dropAllowed = _calcDropPosition.dropAllowed,
|
149 | dragOverNodeKey = _calcDropPosition.dragOverNodeKey;
|
150 | if (
|
151 |
|
152 | dragChildrenKeys.indexOf(dropTargetKey) !== -1 ||
|
153 |
|
154 | !dropAllowed) {
|
155 | _this.resetDragState();
|
156 | return;
|
157 | }
|
158 |
|
159 | if (!_this.delayedDragEnterLogic) {
|
160 | _this.delayedDragEnterLogic = {};
|
161 | }
|
162 | Object.keys(_this.delayedDragEnterLogic).forEach(function (key) {
|
163 | clearTimeout(_this.delayedDragEnterLogic[key]);
|
164 | });
|
165 | if (dragNode.props.eventKey !== node.props.eventKey) {
|
166 |
|
167 |
|
168 |
|
169 |
|
170 | event.persist();
|
171 | _this.delayedDragEnterLogic[pos] = window.setTimeout(function () {
|
172 | if (_this.state.draggingNodeKey === null) return;
|
173 | var newExpandedKeys = (0, _toConsumableArray2.default)(expandedKeys);
|
174 | var entity = keyEntities[node.props.eventKey];
|
175 | if (entity && (entity.children || []).length) {
|
176 | newExpandedKeys = (0, _util.arrAdd)(expandedKeys, node.props.eventKey);
|
177 | }
|
178 | if (!('expandedKeys' in _this.props)) {
|
179 | _this.setExpandedKeys(newExpandedKeys);
|
180 | }
|
181 | onExpand === null || onExpand === void 0 ? void 0 : onExpand(newExpandedKeys, {
|
182 | node: (0, _treeUtil.convertNodePropsToEventData)(node.props),
|
183 | expanded: true,
|
184 | nativeEvent: event.nativeEvent
|
185 | });
|
186 | }, 800);
|
187 | }
|
188 |
|
189 | if (dragNode.props.eventKey === dropTargetKey && dropLevelOffset === 0) {
|
190 | _this.resetDragState();
|
191 | return;
|
192 | }
|
193 |
|
194 | _this.setState({
|
195 | dragOverNodeKey: dragOverNodeKey,
|
196 | dropPosition: dropPosition,
|
197 | dropLevelOffset: dropLevelOffset,
|
198 | dropTargetKey: dropTargetKey,
|
199 | dropContainerKey: dropContainerKey,
|
200 | dropTargetPos: dropTargetPos,
|
201 | dropAllowed: dropAllowed
|
202 | });
|
203 | onDragEnter === null || onDragEnter === void 0 ? void 0 : onDragEnter({
|
204 | event: event,
|
205 | node: (0, _treeUtil.convertNodePropsToEventData)(node.props),
|
206 | expandedKeys: expandedKeys
|
207 | });
|
208 | };
|
209 | _this.onNodeDragOver = function (event, node) {
|
210 | var _this$state3 = _this.state,
|
211 | dragChildrenKeys = _this$state3.dragChildrenKeys,
|
212 | flattenNodes = _this$state3.flattenNodes,
|
213 | keyEntities = _this$state3.keyEntities,
|
214 | expandedKeys = _this$state3.expandedKeys,
|
215 | indent = _this$state3.indent;
|
216 | var _this$props2 = _this.props,
|
217 | onDragOver = _this$props2.onDragOver,
|
218 | allowDrop = _this$props2.allowDrop,
|
219 | direction = _this$props2.direction;
|
220 | var _assertThisInitialize2 = (0, _assertThisInitialized2.default)(_this),
|
221 | dragNode = _assertThisInitialize2.dragNode;
|
222 | if (!dragNode) {
|
223 | return;
|
224 | }
|
225 | var _calcDropPosition2 = (0, _util.calcDropPosition)(event, dragNode, node, indent, _this.dragStartMousePosition, allowDrop, flattenNodes, keyEntities, expandedKeys, direction),
|
226 | dropPosition = _calcDropPosition2.dropPosition,
|
227 | dropLevelOffset = _calcDropPosition2.dropLevelOffset,
|
228 | dropTargetKey = _calcDropPosition2.dropTargetKey,
|
229 | dropContainerKey = _calcDropPosition2.dropContainerKey,
|
230 | dropAllowed = _calcDropPosition2.dropAllowed,
|
231 | dropTargetPos = _calcDropPosition2.dropTargetPos,
|
232 | dragOverNodeKey = _calcDropPosition2.dragOverNodeKey;
|
233 | if (dragChildrenKeys.indexOf(dropTargetKey) !== -1 || !dropAllowed) {
|
234 |
|
235 |
|
236 | return;
|
237 | }
|
238 |
|
239 | if (dragNode.props.eventKey === dropTargetKey && dropLevelOffset === 0) {
|
240 | 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)) {
|
241 | _this.resetDragState();
|
242 | }
|
243 | } 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)) {
|
244 | _this.setState({
|
245 | dropPosition: dropPosition,
|
246 | dropLevelOffset: dropLevelOffset,
|
247 | dropTargetKey: dropTargetKey,
|
248 | dropContainerKey: dropContainerKey,
|
249 | dropTargetPos: dropTargetPos,
|
250 | dropAllowed: dropAllowed,
|
251 | dragOverNodeKey: dragOverNodeKey
|
252 | });
|
253 | }
|
254 | onDragOver === null || onDragOver === void 0 ? void 0 : onDragOver({
|
255 | event: event,
|
256 | node: (0, _treeUtil.convertNodePropsToEventData)(node.props)
|
257 | });
|
258 | };
|
259 | _this.onNodeDragLeave = function (event, node) {
|
260 |
|
261 |
|
262 | if (_this.currentMouseOverDroppableNodeKey === node.props.eventKey && !event.currentTarget.contains(event.relatedTarget)) {
|
263 | _this.resetDragState();
|
264 | _this.currentMouseOverDroppableNodeKey = null;
|
265 | }
|
266 | var onDragLeave = _this.props.onDragLeave;
|
267 | onDragLeave === null || onDragLeave === void 0 ? void 0 : onDragLeave({
|
268 | event: event,
|
269 | node: (0, _treeUtil.convertNodePropsToEventData)(node.props)
|
270 | });
|
271 | };
|
272 |
|
273 |
|
274 | _this.onWindowDragEnd = function (event) {
|
275 | _this.onNodeDragEnd(event, null, true);
|
276 | window.removeEventListener('dragend', _this.onWindowDragEnd);
|
277 | };
|
278 |
|
279 | _this.onNodeDragEnd = function (event, node) {
|
280 | var onDragEnd = _this.props.onDragEnd;
|
281 | _this.setState({
|
282 | dragOverNodeKey: null
|
283 | });
|
284 | _this.cleanDragState();
|
285 | onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd({
|
286 | event: event,
|
287 | node: (0, _treeUtil.convertNodePropsToEventData)(node.props)
|
288 | });
|
289 | _this.dragNode = null;
|
290 | window.removeEventListener('dragend', _this.onWindowDragEnd);
|
291 | };
|
292 | _this.onNodeDrop = function (event, node) {
|
293 | var _this$getActiveItem;
|
294 | var outsideTree = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
295 | var _this$state4 = _this.state,
|
296 | dragChildrenKeys = _this$state4.dragChildrenKeys,
|
297 | dropPosition = _this$state4.dropPosition,
|
298 | dropTargetKey = _this$state4.dropTargetKey,
|
299 | dropTargetPos = _this$state4.dropTargetPos,
|
300 | dropAllowed = _this$state4.dropAllowed;
|
301 | if (!dropAllowed) return;
|
302 | var onDrop = _this.props.onDrop;
|
303 | _this.setState({
|
304 | dragOverNodeKey: null
|
305 | });
|
306 | _this.cleanDragState();
|
307 | if (dropTargetKey === null) return;
|
308 | var abstractDropNodeProps = (0, _objectSpread3.default)((0, _objectSpread3.default)({}, (0, _treeUtil.getTreeNodeProps)(dropTargetKey, _this.getTreeNodeRequiredProps())), {}, {
|
309 | active: ((_this$getActiveItem = _this.getActiveItem()) === null || _this$getActiveItem === void 0 ? void 0 : _this$getActiveItem.key) === dropTargetKey,
|
310 | data: _this.state.keyEntities[dropTargetKey].node
|
311 | });
|
312 | var dropToChild = dragChildrenKeys.indexOf(dropTargetKey) !== -1;
|
313 | (0, _warning.default)(!dropToChild, "Can not drop to dragNode's children node. This is a bug of rc-tree. Please report an issue.");
|
314 | var posArr = (0, _util.posToArr)(dropTargetPos);
|
315 | var dropResult = {
|
316 | event: event,
|
317 | node: (0, _treeUtil.convertNodePropsToEventData)(abstractDropNodeProps),
|
318 | dragNode: _this.dragNode ? (0, _treeUtil.convertNodePropsToEventData)(_this.dragNode.props) : null,
|
319 | dragNodesKeys: [_this.dragNode.props.eventKey].concat(dragChildrenKeys),
|
320 | dropToGap: dropPosition !== 0,
|
321 | dropPosition: dropPosition + Number(posArr[posArr.length - 1])
|
322 | };
|
323 | if (!outsideTree) {
|
324 | onDrop === null || onDrop === void 0 ? void 0 : onDrop(dropResult);
|
325 | }
|
326 | _this.dragNode = null;
|
327 | };
|
328 | _this.cleanDragState = function () {
|
329 | var draggingNodeKey = _this.state.draggingNodeKey;
|
330 | if (draggingNodeKey !== null) {
|
331 | _this.setState({
|
332 | draggingNodeKey: null,
|
333 | dropPosition: null,
|
334 | dropContainerKey: null,
|
335 | dropTargetKey: null,
|
336 | dropLevelOffset: null,
|
337 | dropAllowed: true,
|
338 | dragOverNodeKey: null
|
339 | });
|
340 | }
|
341 | _this.dragStartMousePosition = null;
|
342 | _this.currentMouseOverDroppableNodeKey = null;
|
343 | };
|
344 | _this.triggerExpandActionExpand = function (e, treeNode) {
|
345 | var _this$state5 = _this.state,
|
346 | expandedKeys = _this$state5.expandedKeys,
|
347 | flattenNodes = _this$state5.flattenNodes;
|
348 | var expanded = treeNode.expanded,
|
349 | key = treeNode.key,
|
350 | isLeaf = treeNode.isLeaf;
|
351 | if (isLeaf || e.shiftKey || e.metaKey || e.ctrlKey) {
|
352 | return;
|
353 | }
|
354 | var node = flattenNodes.filter(function (nodeItem) {
|
355 | return nodeItem.key === key;
|
356 | })[0];
|
357 | var eventNode = (0, _treeUtil.convertNodePropsToEventData)((0, _objectSpread3.default)((0, _objectSpread3.default)({}, (0, _treeUtil.getTreeNodeProps)(key, _this.getTreeNodeRequiredProps())), {}, {
|
358 | data: node.data
|
359 | }));
|
360 | _this.setExpandedKeys(expanded ? (0, _util.arrDel)(expandedKeys, key) : (0, _util.arrAdd)(expandedKeys, key));
|
361 | _this.onNodeExpand(e, eventNode);
|
362 | };
|
363 | _this.onNodeClick = function (e, treeNode) {
|
364 | var _this$props3 = _this.props,
|
365 | onClick = _this$props3.onClick,
|
366 | expandAction = _this$props3.expandAction;
|
367 | if (expandAction === 'click') {
|
368 | _this.triggerExpandActionExpand(e, treeNode);
|
369 | }
|
370 | onClick === null || onClick === void 0 ? void 0 : onClick(e, treeNode);
|
371 | };
|
372 | _this.onNodeDoubleClick = function (e, treeNode) {
|
373 | var _this$props4 = _this.props,
|
374 | onDoubleClick = _this$props4.onDoubleClick,
|
375 | expandAction = _this$props4.expandAction;
|
376 | if (expandAction === 'doubleClick') {
|
377 | _this.triggerExpandActionExpand(e, treeNode);
|
378 | }
|
379 | onDoubleClick === null || onDoubleClick === void 0 ? void 0 : onDoubleClick(e, treeNode);
|
380 | };
|
381 | _this.onNodeSelect = function (e, treeNode) {
|
382 | var selectedKeys = _this.state.selectedKeys;
|
383 | var _this$state6 = _this.state,
|
384 | keyEntities = _this$state6.keyEntities,
|
385 | fieldNames = _this$state6.fieldNames;
|
386 | var _this$props5 = _this.props,
|
387 | onSelect = _this$props5.onSelect,
|
388 | multiple = _this$props5.multiple;
|
389 | var selected = treeNode.selected;
|
390 | var key = treeNode[fieldNames.key];
|
391 | var targetSelected = !selected;
|
392 |
|
393 | if (!targetSelected) {
|
394 | selectedKeys = (0, _util.arrDel)(selectedKeys, key);
|
395 | } else if (!multiple) {
|
396 | selectedKeys = [key];
|
397 | } else {
|
398 | selectedKeys = (0, _util.arrAdd)(selectedKeys, key);
|
399 | }
|
400 |
|
401 | var selectedNodes = selectedKeys.map(function (selectedKey) {
|
402 | var entity = keyEntities[selectedKey];
|
403 | if (!entity) return null;
|
404 | return entity.node;
|
405 | }).filter(function (node) {
|
406 | return node;
|
407 | });
|
408 | _this.setUncontrolledState({
|
409 | selectedKeys: selectedKeys
|
410 | });
|
411 | onSelect === null || onSelect === void 0 ? void 0 : onSelect(selectedKeys, {
|
412 | event: 'select',
|
413 | selected: targetSelected,
|
414 | node: treeNode,
|
415 | selectedNodes: selectedNodes,
|
416 | nativeEvent: e.nativeEvent
|
417 | });
|
418 | };
|
419 | _this.onNodeCheck = function (e, treeNode, checked) {
|
420 | var _this$state7 = _this.state,
|
421 | keyEntities = _this$state7.keyEntities,
|
422 | oriCheckedKeys = _this$state7.checkedKeys,
|
423 | oriHalfCheckedKeys = _this$state7.halfCheckedKeys;
|
424 | var _this$props6 = _this.props,
|
425 | checkStrictly = _this$props6.checkStrictly,
|
426 | onCheck = _this$props6.onCheck;
|
427 | var key = treeNode.key;
|
428 |
|
429 | var checkedObj;
|
430 | var eventObj = {
|
431 | event: 'check',
|
432 | node: treeNode,
|
433 | checked: checked,
|
434 | nativeEvent: e.nativeEvent
|
435 | };
|
436 | if (checkStrictly) {
|
437 | var checkedKeys = checked ? (0, _util.arrAdd)(oriCheckedKeys, key) : (0, _util.arrDel)(oriCheckedKeys, key);
|
438 | var halfCheckedKeys = (0, _util.arrDel)(oriHalfCheckedKeys, key);
|
439 | checkedObj = {
|
440 | checked: checkedKeys,
|
441 | halfChecked: halfCheckedKeys
|
442 | };
|
443 | eventObj.checkedNodes = checkedKeys.map(function (checkedKey) {
|
444 | return keyEntities[checkedKey];
|
445 | }).filter(function (entity) {
|
446 | return entity;
|
447 | }).map(function (entity) {
|
448 | return entity.node;
|
449 | });
|
450 | _this.setUncontrolledState({
|
451 | checkedKeys: checkedKeys
|
452 | });
|
453 | } else {
|
454 |
|
455 | var _conductCheck = (0, _conductUtil.conductCheck)([].concat((0, _toConsumableArray2.default)(oriCheckedKeys), [key]), true, keyEntities),
|
456 | _checkedKeys = _conductCheck.checkedKeys,
|
457 | _halfCheckedKeys = _conductCheck.halfCheckedKeys;
|
458 |
|
459 | if (!checked) {
|
460 | var keySet = new Set(_checkedKeys);
|
461 | keySet.delete(key);
|
462 | var _conductCheck2 = (0, _conductUtil.conductCheck)(Array.from(keySet), {
|
463 | checked: false,
|
464 | halfCheckedKeys: _halfCheckedKeys
|
465 | }, keyEntities);
|
466 | _checkedKeys = _conductCheck2.checkedKeys;
|
467 | _halfCheckedKeys = _conductCheck2.halfCheckedKeys;
|
468 | }
|
469 | checkedObj = _checkedKeys;
|
470 |
|
471 | eventObj.checkedNodes = [];
|
472 | eventObj.checkedNodesPositions = [];
|
473 | eventObj.halfCheckedKeys = _halfCheckedKeys;
|
474 | _checkedKeys.forEach(function (checkedKey) {
|
475 | var entity = keyEntities[checkedKey];
|
476 | if (!entity) return;
|
477 | var node = entity.node,
|
478 | pos = entity.pos;
|
479 | eventObj.checkedNodes.push(node);
|
480 | eventObj.checkedNodesPositions.push({
|
481 | node: node,
|
482 | pos: pos
|
483 | });
|
484 | });
|
485 | _this.setUncontrolledState({
|
486 | checkedKeys: _checkedKeys
|
487 | }, false, {
|
488 | halfCheckedKeys: _halfCheckedKeys
|
489 | });
|
490 | }
|
491 | onCheck === null || onCheck === void 0 ? void 0 : onCheck(checkedObj, eventObj);
|
492 | };
|
493 | _this.onNodeLoad = function (treeNode) {
|
494 | var key = treeNode.key;
|
495 | var loadPromise = new Promise(function (resolve, reject) {
|
496 |
|
497 | _this.setState(function (_ref) {
|
498 | var _ref$loadedKeys = _ref.loadedKeys,
|
499 | loadedKeys = _ref$loadedKeys === void 0 ? [] : _ref$loadedKeys,
|
500 | _ref$loadingKeys = _ref.loadingKeys,
|
501 | loadingKeys = _ref$loadingKeys === void 0 ? [] : _ref$loadingKeys;
|
502 | var _this$props7 = _this.props,
|
503 | loadData = _this$props7.loadData,
|
504 | onLoad = _this$props7.onLoad;
|
505 | if (!loadData || loadedKeys.indexOf(key) !== -1 || loadingKeys.indexOf(key) !== -1) {
|
506 | return null;
|
507 | }
|
508 |
|
509 | var promise = loadData(treeNode);
|
510 | promise.then(function () {
|
511 | var currentLoadedKeys = _this.state.loadedKeys;
|
512 | var newLoadedKeys = (0, _util.arrAdd)(currentLoadedKeys, key);
|
513 |
|
514 |
|
515 | onLoad === null || onLoad === void 0 ? void 0 : onLoad(newLoadedKeys, {
|
516 | event: 'load',
|
517 | node: treeNode
|
518 | });
|
519 | _this.setUncontrolledState({
|
520 | loadedKeys: newLoadedKeys
|
521 | });
|
522 | _this.setState(function (prevState) {
|
523 | return {
|
524 | loadingKeys: (0, _util.arrDel)(prevState.loadingKeys, key)
|
525 | };
|
526 | });
|
527 | resolve();
|
528 | }).catch(function (e) {
|
529 | _this.setState(function (prevState) {
|
530 | return {
|
531 | loadingKeys: (0, _util.arrDel)(prevState.loadingKeys, key)
|
532 | };
|
533 | });
|
534 |
|
535 | _this.loadingRetryTimes[key] = (_this.loadingRetryTimes[key] || 0) + 1;
|
536 | if (_this.loadingRetryTimes[key] >= MAX_RETRY_TIMES) {
|
537 | var currentLoadedKeys = _this.state.loadedKeys;
|
538 | (0, _warning.default)(false, 'Retry for `loadData` many times but still failed. No more retry.');
|
539 | _this.setUncontrolledState({
|
540 | loadedKeys: (0, _util.arrAdd)(currentLoadedKeys, key)
|
541 | });
|
542 | resolve();
|
543 | }
|
544 | reject(e);
|
545 | });
|
546 | return {
|
547 | loadingKeys: (0, _util.arrAdd)(loadingKeys, key)
|
548 | };
|
549 | });
|
550 | });
|
551 |
|
552 | loadPromise.catch(function () {});
|
553 | return loadPromise;
|
554 | };
|
555 | _this.onNodeMouseEnter = function (event, node) {
|
556 | var onMouseEnter = _this.props.onMouseEnter;
|
557 | onMouseEnter === null || onMouseEnter === void 0 ? void 0 : onMouseEnter({
|
558 | event: event,
|
559 | node: node
|
560 | });
|
561 | };
|
562 | _this.onNodeMouseLeave = function (event, node) {
|
563 | var onMouseLeave = _this.props.onMouseLeave;
|
564 | onMouseLeave === null || onMouseLeave === void 0 ? void 0 : onMouseLeave({
|
565 | event: event,
|
566 | node: node
|
567 | });
|
568 | };
|
569 | _this.onNodeContextMenu = function (event, node) {
|
570 | var onRightClick = _this.props.onRightClick;
|
571 | if (onRightClick) {
|
572 | event.preventDefault();
|
573 | onRightClick({
|
574 | event: event,
|
575 | node: node
|
576 | });
|
577 | }
|
578 | };
|
579 | _this.onFocus = function () {
|
580 | var onFocus = _this.props.onFocus;
|
581 | _this.setState({
|
582 | focused: true
|
583 | });
|
584 | for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
585 | args[_key2] = arguments[_key2];
|
586 | }
|
587 | onFocus === null || onFocus === void 0 ? void 0 : onFocus.apply(void 0, args);
|
588 | };
|
589 | _this.onBlur = function () {
|
590 | var onBlur = _this.props.onBlur;
|
591 | _this.setState({
|
592 | focused: false
|
593 | });
|
594 | _this.onActiveChange(null);
|
595 | for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
|
596 | args[_key3] = arguments[_key3];
|
597 | }
|
598 | onBlur === null || onBlur === void 0 ? void 0 : onBlur.apply(void 0, args);
|
599 | };
|
600 | _this.getTreeNodeRequiredProps = function () {
|
601 | var _this$state8 = _this.state,
|
602 | expandedKeys = _this$state8.expandedKeys,
|
603 | selectedKeys = _this$state8.selectedKeys,
|
604 | loadedKeys = _this$state8.loadedKeys,
|
605 | loadingKeys = _this$state8.loadingKeys,
|
606 | checkedKeys = _this$state8.checkedKeys,
|
607 | halfCheckedKeys = _this$state8.halfCheckedKeys,
|
608 | dragOverNodeKey = _this$state8.dragOverNodeKey,
|
609 | dropPosition = _this$state8.dropPosition,
|
610 | keyEntities = _this$state8.keyEntities;
|
611 | return {
|
612 | expandedKeys: expandedKeys || [],
|
613 | selectedKeys: selectedKeys || [],
|
614 | loadedKeys: loadedKeys || [],
|
615 | loadingKeys: loadingKeys || [],
|
616 | checkedKeys: checkedKeys || [],
|
617 | halfCheckedKeys: halfCheckedKeys || [],
|
618 | dragOverNodeKey: dragOverNodeKey,
|
619 | dropPosition: dropPosition,
|
620 | keyEntities: keyEntities
|
621 | };
|
622 | };
|
623 |
|
624 |
|
625 | _this.setExpandedKeys = function (expandedKeys) {
|
626 | var _this$state9 = _this.state,
|
627 | treeData = _this$state9.treeData,
|
628 | fieldNames = _this$state9.fieldNames;
|
629 | var flattenNodes = (0, _treeUtil.flattenTreeData)(treeData, expandedKeys, fieldNames);
|
630 | _this.setUncontrolledState({
|
631 | expandedKeys: expandedKeys,
|
632 | flattenNodes: flattenNodes
|
633 | }, true);
|
634 | };
|
635 | _this.onNodeExpand = function (e, treeNode) {
|
636 | var expandedKeys = _this.state.expandedKeys;
|
637 | var _this$state10 = _this.state,
|
638 | listChanging = _this$state10.listChanging,
|
639 | fieldNames = _this$state10.fieldNames;
|
640 | var _this$props8 = _this.props,
|
641 | onExpand = _this$props8.onExpand,
|
642 | loadData = _this$props8.loadData;
|
643 | var expanded = treeNode.expanded;
|
644 | var key = treeNode[fieldNames.key];
|
645 |
|
646 | if (listChanging) {
|
647 | return;
|
648 | }
|
649 |
|
650 | var index = expandedKeys.indexOf(key);
|
651 | var targetExpanded = !expanded;
|
652 | (0, _warning.default)(expanded && index !== -1 || !expanded && index === -1, 'Expand state not sync with index check');
|
653 | if (targetExpanded) {
|
654 | expandedKeys = (0, _util.arrAdd)(expandedKeys, key);
|
655 | } else {
|
656 | expandedKeys = (0, _util.arrDel)(expandedKeys, key);
|
657 | }
|
658 | _this.setExpandedKeys(expandedKeys);
|
659 | onExpand === null || onExpand === void 0 ? void 0 : onExpand(expandedKeys, {
|
660 | node: treeNode,
|
661 | expanded: targetExpanded,
|
662 | nativeEvent: e.nativeEvent
|
663 | });
|
664 |
|
665 | if (targetExpanded && loadData) {
|
666 | var loadPromise = _this.onNodeLoad(treeNode);
|
667 | if (loadPromise) {
|
668 | loadPromise.then(function () {
|
669 |
|
670 | var newFlattenTreeData = (0, _treeUtil.flattenTreeData)(_this.state.treeData, expandedKeys, fieldNames);
|
671 | _this.setUncontrolledState({
|
672 | flattenNodes: newFlattenTreeData
|
673 | });
|
674 | }).catch(function () {
|
675 | var currentExpandedKeys = _this.state.expandedKeys;
|
676 | var expandedKeysToRestore = (0, _util.arrDel)(currentExpandedKeys, key);
|
677 | _this.setExpandedKeys(expandedKeysToRestore);
|
678 | });
|
679 | }
|
680 | }
|
681 | };
|
682 | _this.onListChangeStart = function () {
|
683 | _this.setUncontrolledState({
|
684 | listChanging: true
|
685 | });
|
686 | };
|
687 | _this.onListChangeEnd = function () {
|
688 | setTimeout(function () {
|
689 | _this.setUncontrolledState({
|
690 | listChanging: false
|
691 | });
|
692 | });
|
693 | };
|
694 |
|
695 | _this.onActiveChange = function (newActiveKey) {
|
696 | var activeKey = _this.state.activeKey;
|
697 | var onActiveChange = _this.props.onActiveChange;
|
698 | if (activeKey === newActiveKey) {
|
699 | return;
|
700 | }
|
701 | _this.setState({
|
702 | activeKey: newActiveKey
|
703 | });
|
704 | if (newActiveKey !== null) {
|
705 | _this.scrollTo({
|
706 | key: newActiveKey
|
707 | });
|
708 | }
|
709 | onActiveChange === null || onActiveChange === void 0 ? void 0 : onActiveChange(newActiveKey);
|
710 | };
|
711 | _this.getActiveItem = function () {
|
712 | var _this$state11 = _this.state,
|
713 | activeKey = _this$state11.activeKey,
|
714 | flattenNodes = _this$state11.flattenNodes;
|
715 | if (activeKey === null) {
|
716 | return null;
|
717 | }
|
718 | return flattenNodes.find(function (_ref2) {
|
719 | var key = _ref2.key;
|
720 | return key === activeKey;
|
721 | }) || null;
|
722 | };
|
723 | _this.offsetActiveKey = function (offset) {
|
724 | var _this$state12 = _this.state,
|
725 | flattenNodes = _this$state12.flattenNodes,
|
726 | activeKey = _this$state12.activeKey;
|
727 | var index = flattenNodes.findIndex(function (_ref3) {
|
728 | var key = _ref3.key;
|
729 | return key === activeKey;
|
730 | });
|
731 |
|
732 | if (index === -1 && offset < 0) {
|
733 | index = flattenNodes.length;
|
734 | }
|
735 | index = (index + offset + flattenNodes.length) % flattenNodes.length;
|
736 | var item = flattenNodes[index];
|
737 | if (item) {
|
738 | var key = item.key;
|
739 | _this.onActiveChange(key);
|
740 | } else {
|
741 | _this.onActiveChange(null);
|
742 | }
|
743 | };
|
744 | _this.onKeyDown = function (event) {
|
745 | var _this$state13 = _this.state,
|
746 | activeKey = _this$state13.activeKey,
|
747 | expandedKeys = _this$state13.expandedKeys,
|
748 | checkedKeys = _this$state13.checkedKeys,
|
749 | fieldNames = _this$state13.fieldNames;
|
750 | var _this$props9 = _this.props,
|
751 | onKeyDown = _this$props9.onKeyDown,
|
752 | checkable = _this$props9.checkable,
|
753 | selectable = _this$props9.selectable;
|
754 |
|
755 | switch (event.which) {
|
756 | case _KeyCode.default.UP:
|
757 | {
|
758 | _this.offsetActiveKey(-1);
|
759 | event.preventDefault();
|
760 | break;
|
761 | }
|
762 | case _KeyCode.default.DOWN:
|
763 | {
|
764 | _this.offsetActiveKey(1);
|
765 | event.preventDefault();
|
766 | break;
|
767 | }
|
768 | }
|
769 |
|
770 | var activeItem = _this.getActiveItem();
|
771 | if (activeItem && activeItem.data) {
|
772 | var treeNodeRequiredProps = _this.getTreeNodeRequiredProps();
|
773 | var expandable = activeItem.data.isLeaf === false || !!(activeItem.data[fieldNames.children] || []).length;
|
774 | var eventNode = (0, _treeUtil.convertNodePropsToEventData)((0, _objectSpread3.default)((0, _objectSpread3.default)({}, (0, _treeUtil.getTreeNodeProps)(activeKey, treeNodeRequiredProps)), {}, {
|
775 | data: activeItem.data,
|
776 | active: true
|
777 | }));
|
778 | switch (event.which) {
|
779 |
|
780 | case _KeyCode.default.LEFT:
|
781 | {
|
782 |
|
783 | if (expandable && expandedKeys.includes(activeKey)) {
|
784 | _this.onNodeExpand({}, eventNode);
|
785 | } else if (activeItem.parent) {
|
786 | _this.onActiveChange(activeItem.parent.key);
|
787 | }
|
788 | event.preventDefault();
|
789 | break;
|
790 | }
|
791 | case _KeyCode.default.RIGHT:
|
792 | {
|
793 |
|
794 | if (expandable && !expandedKeys.includes(activeKey)) {
|
795 | _this.onNodeExpand({}, eventNode);
|
796 | } else if (activeItem.children && activeItem.children.length) {
|
797 | _this.onActiveChange(activeItem.children[0].key);
|
798 | }
|
799 | event.preventDefault();
|
800 | break;
|
801 | }
|
802 |
|
803 | case _KeyCode.default.ENTER:
|
804 | case _KeyCode.default.SPACE:
|
805 | {
|
806 | if (checkable && !eventNode.disabled && eventNode.checkable !== false && !eventNode.disableCheckbox) {
|
807 | _this.onNodeCheck({}, eventNode, !checkedKeys.includes(activeKey));
|
808 | } else if (!checkable && selectable && !eventNode.disabled && eventNode.selectable !== false) {
|
809 | _this.onNodeSelect({}, eventNode);
|
810 | }
|
811 | break;
|
812 | }
|
813 | }
|
814 | }
|
815 | onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event);
|
816 | };
|
817 | |
818 |
|
819 |
|
820 | _this.setUncontrolledState = function (state) {
|
821 | var atomic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
822 | var forceState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
823 | if (!_this.destroyed) {
|
824 | var needSync = false;
|
825 | var allPassed = true;
|
826 | var newState = {};
|
827 | Object.keys(state).forEach(function (name) {
|
828 | if (name in _this.props) {
|
829 | allPassed = false;
|
830 | return;
|
831 | }
|
832 | needSync = true;
|
833 | newState[name] = state[name];
|
834 | });
|
835 | if (needSync && (!atomic || allPassed)) {
|
836 | _this.setState((0, _objectSpread3.default)((0, _objectSpread3.default)({}, newState), forceState));
|
837 | }
|
838 | }
|
839 | };
|
840 | _this.scrollTo = function (scroll) {
|
841 | _this.listRef.current.scrollTo(scroll);
|
842 | };
|
843 | return _this;
|
844 | }
|
845 | (0, _createClass2.default)(Tree, [{
|
846 | key: "componentDidMount",
|
847 | value: function componentDidMount() {
|
848 | this.destroyed = false;
|
849 | this.onUpdated();
|
850 | }
|
851 | }, {
|
852 | key: "componentDidUpdate",
|
853 | value: function componentDidUpdate() {
|
854 | this.onUpdated();
|
855 | }
|
856 | }, {
|
857 | key: "onUpdated",
|
858 | value: function onUpdated() {
|
859 | var activeKey = this.props.activeKey;
|
860 | if (activeKey !== undefined && activeKey !== this.state.activeKey) {
|
861 | this.setState({
|
862 | activeKey: activeKey
|
863 | });
|
864 | if (activeKey !== null) {
|
865 | this.scrollTo({
|
866 | key: activeKey
|
867 | });
|
868 | }
|
869 | }
|
870 | }
|
871 | }, {
|
872 | key: "componentWillUnmount",
|
873 | value: function componentWillUnmount() {
|
874 | window.removeEventListener('dragend', this.onWindowDragEnd);
|
875 | this.destroyed = true;
|
876 | }
|
877 | }, {
|
878 | key: "resetDragState",
|
879 | value: function resetDragState() {
|
880 | this.setState({
|
881 | dragOverNodeKey: null,
|
882 | dropPosition: null,
|
883 | dropLevelOffset: null,
|
884 | dropTargetKey: null,
|
885 | dropContainerKey: null,
|
886 | dropTargetPos: null,
|
887 | dropAllowed: false
|
888 | });
|
889 | }
|
890 | }, {
|
891 | key: "render",
|
892 | value: function render() {
|
893 | var _classNames;
|
894 | var _this$state14 = this.state,
|
895 | focused = _this$state14.focused,
|
896 | flattenNodes = _this$state14.flattenNodes,
|
897 | keyEntities = _this$state14.keyEntities,
|
898 | draggingNodeKey = _this$state14.draggingNodeKey,
|
899 | activeKey = _this$state14.activeKey,
|
900 | dropLevelOffset = _this$state14.dropLevelOffset,
|
901 | dropContainerKey = _this$state14.dropContainerKey,
|
902 | dropTargetKey = _this$state14.dropTargetKey,
|
903 | dropPosition = _this$state14.dropPosition,
|
904 | dragOverNodeKey = _this$state14.dragOverNodeKey,
|
905 | indent = _this$state14.indent;
|
906 | var _this$props10 = this.props,
|
907 | prefixCls = _this$props10.prefixCls,
|
908 | className = _this$props10.className,
|
909 | style = _this$props10.style,
|
910 | showLine = _this$props10.showLine,
|
911 | focusable = _this$props10.focusable,
|
912 | _this$props10$tabInde = _this$props10.tabIndex,
|
913 | tabIndex = _this$props10$tabInde === void 0 ? 0 : _this$props10$tabInde,
|
914 | selectable = _this$props10.selectable,
|
915 | showIcon = _this$props10.showIcon,
|
916 | icon = _this$props10.icon,
|
917 | switcherIcon = _this$props10.switcherIcon,
|
918 | draggable = _this$props10.draggable,
|
919 | checkable = _this$props10.checkable,
|
920 | checkStrictly = _this$props10.checkStrictly,
|
921 | disabled = _this$props10.disabled,
|
922 | motion = _this$props10.motion,
|
923 | loadData = _this$props10.loadData,
|
924 | filterTreeNode = _this$props10.filterTreeNode,
|
925 | height = _this$props10.height,
|
926 | itemHeight = _this$props10.itemHeight,
|
927 | virtual = _this$props10.virtual,
|
928 | titleRender = _this$props10.titleRender,
|
929 | dropIndicatorRender = _this$props10.dropIndicatorRender,
|
930 | onContextMenu = _this$props10.onContextMenu,
|
931 | onScroll = _this$props10.onScroll,
|
932 | direction = _this$props10.direction,
|
933 | rootClassName = _this$props10.rootClassName,
|
934 | rootStyle = _this$props10.rootStyle;
|
935 | var domProps = (0, _pickAttrs.default)(this.props, {
|
936 | aria: true,
|
937 | data: true
|
938 | });
|
939 |
|
940 | var draggableConfig;
|
941 | if (draggable) {
|
942 | if ((0, _typeof2.default)(draggable) === 'object') {
|
943 | draggableConfig = draggable;
|
944 | } else if (typeof draggable === 'function') {
|
945 | draggableConfig = {
|
946 | nodeDraggable: draggable
|
947 | };
|
948 | } else {
|
949 | draggableConfig = {};
|
950 | }
|
951 | }
|
952 | return React.createElement(_contextTypes.TreeContext.Provider, {
|
953 | value: {
|
954 | prefixCls: prefixCls,
|
955 | selectable: selectable,
|
956 | showIcon: showIcon,
|
957 | icon: icon,
|
958 | switcherIcon: switcherIcon,
|
959 | draggable: draggableConfig,
|
960 | draggingNodeKey: draggingNodeKey,
|
961 | checkable: checkable,
|
962 | checkStrictly: checkStrictly,
|
963 | disabled: disabled,
|
964 | keyEntities: keyEntities,
|
965 | dropLevelOffset: dropLevelOffset,
|
966 | dropContainerKey: dropContainerKey,
|
967 | dropTargetKey: dropTargetKey,
|
968 | dropPosition: dropPosition,
|
969 | dragOverNodeKey: dragOverNodeKey,
|
970 | indent: indent,
|
971 | direction: direction,
|
972 | dropIndicatorRender: dropIndicatorRender,
|
973 | loadData: loadData,
|
974 | filterTreeNode: filterTreeNode,
|
975 | titleRender: titleRender,
|
976 | onNodeClick: this.onNodeClick,
|
977 | onNodeDoubleClick: this.onNodeDoubleClick,
|
978 | onNodeExpand: this.onNodeExpand,
|
979 | onNodeSelect: this.onNodeSelect,
|
980 | onNodeCheck: this.onNodeCheck,
|
981 | onNodeLoad: this.onNodeLoad,
|
982 | onNodeMouseEnter: this.onNodeMouseEnter,
|
983 | onNodeMouseLeave: this.onNodeMouseLeave,
|
984 | onNodeContextMenu: this.onNodeContextMenu,
|
985 | onNodeDragStart: this.onNodeDragStart,
|
986 | onNodeDragEnter: this.onNodeDragEnter,
|
987 | onNodeDragOver: this.onNodeDragOver,
|
988 | onNodeDragLeave: this.onNodeDragLeave,
|
989 | onNodeDragEnd: this.onNodeDragEnd,
|
990 | onNodeDrop: this.onNodeDrop
|
991 | }
|
992 | }, React.createElement("div", {
|
993 | role: "tree",
|
994 | className: (0, _classnames.default)(prefixCls, className, rootClassName, (_classNames = {}, (0, _defineProperty2.default)(_classNames, "".concat(prefixCls, "-show-line"), showLine), (0, _defineProperty2.default)(_classNames, "".concat(prefixCls, "-focused"), focused), (0, _defineProperty2.default)(_classNames, "".concat(prefixCls, "-active-focused"), activeKey !== null), _classNames)),
|
995 | style: rootStyle
|
996 | }, React.createElement(_NodeList.default, (0, _extends2.default)({
|
997 | ref: this.listRef,
|
998 | prefixCls: prefixCls,
|
999 | style: style,
|
1000 | data: flattenNodes,
|
1001 | disabled: disabled,
|
1002 | selectable: selectable,
|
1003 | checkable: !!checkable,
|
1004 | motion: motion,
|
1005 | dragging: draggingNodeKey !== null,
|
1006 | height: height,
|
1007 | itemHeight: itemHeight,
|
1008 | virtual: virtual,
|
1009 | focusable: focusable,
|
1010 | focused: focused,
|
1011 | tabIndex: tabIndex,
|
1012 | activeItem: this.getActiveItem(),
|
1013 | onFocus: this.onFocus,
|
1014 | onBlur: this.onBlur,
|
1015 | onKeyDown: this.onKeyDown,
|
1016 | onActiveChange: this.onActiveChange,
|
1017 | onListChangeStart: this.onListChangeStart,
|
1018 | onListChangeEnd: this.onListChangeEnd,
|
1019 | onContextMenu: onContextMenu,
|
1020 | onScroll: onScroll
|
1021 | }, this.getTreeNodeRequiredProps(), domProps))));
|
1022 | }
|
1023 | }], [{
|
1024 | key: "getDerivedStateFromProps",
|
1025 | value: function getDerivedStateFromProps(props, prevState) {
|
1026 | var prevProps = prevState.prevProps;
|
1027 | var newState = {
|
1028 | prevProps: props
|
1029 | };
|
1030 | function needSync(name) {
|
1031 | return !prevProps && name in props || prevProps && prevProps[name] !== props[name];
|
1032 | }
|
1033 |
|
1034 | var treeData;
|
1035 |
|
1036 | var fieldNames = prevState.fieldNames;
|
1037 | if (needSync('fieldNames')) {
|
1038 | fieldNames = (0, _treeUtil.fillFieldNames)(props.fieldNames);
|
1039 | newState.fieldNames = fieldNames;
|
1040 | }
|
1041 |
|
1042 | if (needSync('treeData')) {
|
1043 | treeData = props.treeData;
|
1044 | } else if (needSync('children')) {
|
1045 | (0, _warning.default)(false, '`children` of Tree is deprecated. Please use `treeData` instead.');
|
1046 | treeData = (0, _treeUtil.convertTreeToData)(props.children);
|
1047 | }
|
1048 |
|
1049 | if (treeData) {
|
1050 | newState.treeData = treeData;
|
1051 | var entitiesMap = (0, _treeUtil.convertDataToEntities)(treeData, {
|
1052 | fieldNames: fieldNames
|
1053 | });
|
1054 | newState.keyEntities = (0, _objectSpread3.default)((0, _defineProperty2.default)({}, _NodeList.MOTION_KEY, _NodeList.MotionEntity), entitiesMap.keyEntities);
|
1055 |
|
1056 | if (process.env.NODE_ENV !== 'production') {
|
1057 | (0, _treeUtil.warningWithoutKey)(treeData, fieldNames);
|
1058 | }
|
1059 | }
|
1060 | var keyEntities = newState.keyEntities || prevState.keyEntities;
|
1061 |
|
1062 | if (needSync('expandedKeys') || prevProps && needSync('autoExpandParent')) {
|
1063 | newState.expandedKeys = props.autoExpandParent || !prevProps && props.defaultExpandParent ? (0, _util.conductExpandParent)(props.expandedKeys, keyEntities) : props.expandedKeys;
|
1064 | } else if (!prevProps && props.defaultExpandAll) {
|
1065 | var cloneKeyEntities = (0, _objectSpread3.default)({}, keyEntities);
|
1066 | delete cloneKeyEntities[_NodeList.MOTION_KEY];
|
1067 | newState.expandedKeys = Object.keys(cloneKeyEntities).map(function (key) {
|
1068 | return cloneKeyEntities[key].key;
|
1069 | });
|
1070 | } else if (!prevProps && props.defaultExpandedKeys) {
|
1071 | newState.expandedKeys = props.autoExpandParent || props.defaultExpandParent ? (0, _util.conductExpandParent)(props.defaultExpandedKeys, keyEntities) : props.defaultExpandedKeys;
|
1072 | }
|
1073 | if (!newState.expandedKeys) {
|
1074 | delete newState.expandedKeys;
|
1075 | }
|
1076 |
|
1077 | if (treeData || newState.expandedKeys) {
|
1078 | var flattenNodes = (0, _treeUtil.flattenTreeData)(treeData || prevState.treeData, newState.expandedKeys || prevState.expandedKeys, fieldNames);
|
1079 | newState.flattenNodes = flattenNodes;
|
1080 | }
|
1081 |
|
1082 | if (props.selectable) {
|
1083 | if (needSync('selectedKeys')) {
|
1084 | newState.selectedKeys = (0, _util.calcSelectedKeys)(props.selectedKeys, props);
|
1085 | } else if (!prevProps && props.defaultSelectedKeys) {
|
1086 | newState.selectedKeys = (0, _util.calcSelectedKeys)(props.defaultSelectedKeys, props);
|
1087 | }
|
1088 | }
|
1089 |
|
1090 | if (props.checkable) {
|
1091 | var checkedKeyEntity;
|
1092 | if (needSync('checkedKeys')) {
|
1093 | checkedKeyEntity = (0, _util.parseCheckedKeys)(props.checkedKeys) || {};
|
1094 | } else if (!prevProps && props.defaultCheckedKeys) {
|
1095 | checkedKeyEntity = (0, _util.parseCheckedKeys)(props.defaultCheckedKeys) || {};
|
1096 | } else if (treeData) {
|
1097 |
|
1098 | checkedKeyEntity = (0, _util.parseCheckedKeys)(props.checkedKeys) || {
|
1099 | checkedKeys: prevState.checkedKeys,
|
1100 | halfCheckedKeys: prevState.halfCheckedKeys
|
1101 | };
|
1102 | }
|
1103 | if (checkedKeyEntity) {
|
1104 | var _checkedKeyEntity = checkedKeyEntity,
|
1105 | _checkedKeyEntity$che = _checkedKeyEntity.checkedKeys,
|
1106 | checkedKeys = _checkedKeyEntity$che === void 0 ? [] : _checkedKeyEntity$che,
|
1107 | _checkedKeyEntity$hal = _checkedKeyEntity.halfCheckedKeys,
|
1108 | halfCheckedKeys = _checkedKeyEntity$hal === void 0 ? [] : _checkedKeyEntity$hal;
|
1109 | if (!props.checkStrictly) {
|
1110 | var conductKeys = (0, _conductUtil.conductCheck)(checkedKeys, true, keyEntities);
|
1111 | checkedKeys = conductKeys.checkedKeys;
|
1112 | halfCheckedKeys = conductKeys.halfCheckedKeys;
|
1113 | }
|
1114 | newState.checkedKeys = checkedKeys;
|
1115 | newState.halfCheckedKeys = halfCheckedKeys;
|
1116 | }
|
1117 | }
|
1118 |
|
1119 | if (needSync('loadedKeys')) {
|
1120 | newState.loadedKeys = props.loadedKeys;
|
1121 | }
|
1122 | return newState;
|
1123 | }
|
1124 | }]);
|
1125 | return Tree;
|
1126 | }(React.Component);
|
1127 | Tree.defaultProps = {
|
1128 | prefixCls: 'rc-tree',
|
1129 | showLine: false,
|
1130 | showIcon: true,
|
1131 | selectable: true,
|
1132 | multiple: false,
|
1133 | checkable: false,
|
1134 | disabled: false,
|
1135 | checkStrictly: false,
|
1136 | draggable: false,
|
1137 | defaultExpandParent: true,
|
1138 | autoExpandParent: false,
|
1139 | defaultExpandAll: false,
|
1140 | defaultExpandedKeys: [],
|
1141 | defaultCheckedKeys: [],
|
1142 | defaultSelectedKeys: [],
|
1143 | dropIndicatorRender: _DropIndicator.default,
|
1144 | allowDrop: function allowDrop() {
|
1145 | return true;
|
1146 | },
|
1147 | expandAction: false
|
1148 | };
|
1149 | Tree.TreeNode = _TreeNode.default;
|
1150 | var _default = Tree;
|
1151 | exports.default = _default; |
\ | No newline at end of file |