1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 |
|
7 | var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
8 |
|
9 | var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
10 |
|
11 | var _react = require('react');
|
12 |
|
13 | var _react2 = _interopRequireDefault(_react);
|
14 |
|
15 | var _TreeNode = require('./TreeNode');
|
16 |
|
17 | var _TreeNode2 = _interopRequireDefault(_TreeNode);
|
18 |
|
19 | var _infiniteScroll = require('./infiniteScroll');
|
20 |
|
21 | var _infiniteScroll2 = _interopRequireDefault(_infiniteScroll);
|
22 |
|
23 | var _classnames = require('classnames');
|
24 |
|
25 | var _classnames2 = _interopRequireDefault(_classnames);
|
26 |
|
27 | var _util = require('./util');
|
28 |
|
29 | var _propTypes = require('prop-types');
|
30 |
|
31 | var _propTypes2 = _interopRequireDefault(_propTypes);
|
32 |
|
33 | var _tinperBeeCore = require('tinper-bee-core');
|
34 |
|
35 | var _config = require('./config');
|
36 |
|
37 | var _config2 = _interopRequireDefault(_config);
|
38 |
|
39 | var _createStore = require('./createStore');
|
40 |
|
41 | var _createStore2 = _interopRequireDefault(_createStore);
|
42 |
|
43 | var _omit = require('omit.js');
|
44 |
|
45 | var _omit2 = _interopRequireDefault(_omit);
|
46 |
|
47 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
48 |
|
49 | function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
|
50 |
|
51 | function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
|
52 |
|
53 | function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
54 |
|
55 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
56 |
|
57 | function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
58 |
|
59 | function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); }
|
60 |
|
61 |
|
62 | function noop() {}
|
63 |
|
64 | var Tree = function (_React$Component) {
|
65 | _inherits(Tree, _React$Component);
|
66 |
|
67 | function Tree(props) {
|
68 | _classCallCheck(this, Tree);
|
69 |
|
70 | var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
|
71 |
|
72 | _initialiseProps.call(_this);
|
73 |
|
74 | ['onKeyDown', 'onCheck', "onUlFocus", "_focusDom", "onUlMouseEnter", "onUlMouseLeave"].forEach(function (m) {
|
75 | _this[m] = _this[m].bind(_this);
|
76 | });
|
77 | _this.contextmenuKeys = [];
|
78 | _this.checkedKeysChange = true;
|
79 | _this.selectKeyDomPos = '0-0';
|
80 | _this.state = {
|
81 | expandedKeys: _this.getDefaultExpandedKeys(props),
|
82 | checkedKeys: _this.getDefaultCheckedKeys(props),
|
83 | selectedKeys: _this.getDefaultSelectedKeys(props),
|
84 | dragNodesKeys: '',
|
85 | dragOverNodeKey: '',
|
86 | dropNodeKey: '',
|
87 | focusKey: '',
|
88 | treeData: [],
|
89 | flatTreeData: [],
|
90 | prevProps: null
|
91 | };
|
92 |
|
93 | _this.rowsInView = _config2["default"].defaultRowsInView;
|
94 |
|
95 | _this.loadCount = _config2["default"].loadBuffer ? _this.rowsInView + _config2["default"].loadBuffer * 2 : 16;
|
96 | _this.flatTreeKeysMap = {};
|
97 | _this.startIndex = 0;
|
98 | _this.endIndex = _this.startIndex + _this.loadCount;
|
99 | _this.cacheTreeNodes = [];
|
100 | _this.store = (0, _createStore2["default"])({ rowHeight: 24 });
|
101 | return _this;
|
102 | }
|
103 |
|
104 | Tree.prototype.componentDidMount = function componentDidMount() {
|
105 |
|
106 | if (this.hasTreeNode()) {
|
107 | this.setState({
|
108 | prevProps: this.props
|
109 | });
|
110 | }
|
111 |
|
112 | if (this.props._getTreeObj) {
|
113 | this.props._getTreeObj(this);
|
114 | }
|
115 | this.calculateRowHeight();
|
116 | };
|
117 |
|
118 |
|
119 |
|
120 |
|
121 | Tree.prototype.componentWillMount = function componentWillMount() {
|
122 | var _this2 = this;
|
123 |
|
124 | var _props = this.props,
|
125 | treeData = _props.treeData,
|
126 | lazyLoad = _props.lazyLoad;
|
127 |
|
128 | var sliceTreeList = [];
|
129 |
|
130 | if (lazyLoad) {
|
131 | var flatTreeData = this.deepTraversal(treeData);
|
132 | flatTreeData.forEach(function (element) {
|
133 | if (sliceTreeList.length >= _this2.loadCount) return;
|
134 | sliceTreeList.push(element);
|
135 | });
|
136 | this.handleTreeListChange(sliceTreeList);
|
137 | this.setState({
|
138 | flatTreeData: flatTreeData
|
139 | });
|
140 | } else {
|
141 | this.setState({
|
142 | treeData: treeData
|
143 | });
|
144 | }
|
145 | };
|
146 |
|
147 | Tree.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
|
148 | var flatTreeDataDone = false;
|
149 | var startIndex = this.startIndex,
|
150 | endIndex = this.endIndex,
|
151 | props = this.props,
|
152 | state = this.state;
|
153 | var prevProps = state.prevProps;
|
154 |
|
155 | var expandedKeys = this.getDefaultExpandedKeys(nextProps, true);
|
156 | var checkedKeys = this.getDefaultCheckedKeys(nextProps, true);
|
157 | var selectedKeys = this.getDefaultSelectedKeys(nextProps, true);
|
158 | var st = {
|
159 | prevProps: nextProps
|
160 | };
|
161 |
|
162 | this.dataChange = false;
|
163 | function needSync(name) {
|
164 | return !prevProps && name in nextProps || prevProps && prevProps[name] !== nextProps[name];
|
165 | }
|
166 |
|
167 | if (needSync('expandedKeys') || prevProps && needSync('autoExpandParent') || prevProps && prevProps['expandedKeys'] !== expandedKeys) {
|
168 | st.expandedKeys = expandedKeys;
|
169 | } else if (!prevProps && props.defaultExpandAll || !prevProps && props.defaultExpandedKeys) {
|
170 | st.expandedKeys = this.getDefaultExpandedKeys(nextProps);
|
171 | }
|
172 | if (st.expandedKeys) {
|
173 |
|
174 | this.cacheExpandedKeys = new Set(expandedKeys);
|
175 | if (nextProps.lazyLoad) {
|
176 | var flatTreeData = this.deepTraversal(nextProps.treeData);
|
177 | this.cacheExpandedKeys = null;
|
178 | st.flatTreeData = flatTreeData;
|
179 | var newTreeList = flatTreeData.slice(startIndex, endIndex);
|
180 | this.handleTreeListChange(newTreeList, startIndex, endIndex);
|
181 | flatTreeDataDone = true;
|
182 | }
|
183 | }
|
184 |
|
185 |
|
186 | if (checkedKeys) {
|
187 | if (nextProps.checkedKeys === this.props.checkedKeys) {
|
188 | this.checkedKeysChange = false;
|
189 | } else {
|
190 | this.checkedKeysChange = true;
|
191 | }
|
192 | st.checkedKeys = checkedKeys;
|
193 | }
|
194 |
|
195 |
|
196 | if (selectedKeys) {
|
197 | st.selectedKeys = selectedKeys;
|
198 | }
|
199 |
|
200 |
|
201 | if (nextProps.hasOwnProperty('treeData') && nextProps.treeData !== this.props.treeData) {
|
202 | this.dataChange = true;
|
203 |
|
204 | if (nextProps.lazyLoad) {
|
205 | if (!flatTreeDataDone) {
|
206 | var _flatTreeData = this.deepTraversal(nextProps.treeData);
|
207 | st.flatTreeData = _flatTreeData;
|
208 | var _newTreeList = _flatTreeData.slice(startIndex, endIndex);
|
209 | this.handleTreeListChange(_newTreeList, startIndex, endIndex);
|
210 | }
|
211 | } else {
|
212 | st.treeData = nextProps.treeData;
|
213 | }
|
214 | }
|
215 |
|
216 |
|
217 | if (nextProps.children !== this.props.children) {
|
218 | this.dataChange = true;
|
219 | }
|
220 | this.setState(st);
|
221 | };
|
222 |
|
223 | Tree.prototype.componentDidUpdate = function componentDidUpdate() {
|
224 | if (!this.hasCalculateRowHeight) {
|
225 | this.calculateRowHeight();
|
226 | }
|
227 | };
|
228 |
|
229 | Tree.prototype.onDragStart = function onDragStart(e, treeNode) {
|
230 | this.dragNode = treeNode;
|
231 | this.dragNodesKeys = this.getDragNodes(treeNode);
|
232 | var st = {
|
233 | dragNodesKeys: this.dragNodesKeys
|
234 | };
|
235 | var expandedKeys = this.getExpandedKeys(treeNode, false);
|
236 | if (expandedKeys) {
|
237 |
|
238 | this.getRawExpandedKeys();
|
239 | st.expandedKeys = expandedKeys;
|
240 | }
|
241 | this.setState(st);
|
242 | this.props.onDragStart({
|
243 | event: e,
|
244 | node: treeNode
|
245 | });
|
246 | this._dropTrigger = false;
|
247 | };
|
248 |
|
249 | Tree.prototype.onDragEnterGap = function onDragEnterGap(e, treeNode) {
|
250 | var offsetTop = (0, _util.getOffset)(treeNode.selectHandle).top;
|
251 | var offsetHeight = treeNode.selectHandle.offsetHeight;
|
252 | var pageY = e.pageY;
|
253 | var gapHeight = 2;
|
254 | if (pageY > offsetTop + offsetHeight - gapHeight) {
|
255 | this.dropPosition = 1;
|
256 | return 1;
|
257 | }
|
258 | if (pageY < offsetTop + gapHeight) {
|
259 | this.dropPosition = -1;
|
260 | return -1;
|
261 | }
|
262 | this.dropPosition = 0;
|
263 | return 0;
|
264 | };
|
265 |
|
266 | Tree.prototype.onDragEnter = function onDragEnter(e, treeNode) {
|
267 | var enterGap = this.onDragEnterGap(e, treeNode);
|
268 | if (this.dragNode.props.eventKey === treeNode.props.eventKey && enterGap === 0) {
|
269 | this.setState({
|
270 | dragOverNodeKey: ''
|
271 | });
|
272 | return;
|
273 | }
|
274 | var st = {
|
275 | dragOverNodeKey: treeNode.props.eventKey
|
276 | };
|
277 | var expandedKeys = this.getExpandedKeys(treeNode, true);
|
278 | if (expandedKeys) {
|
279 | this.getRawExpandedKeys();
|
280 | st.expandedKeys = expandedKeys;
|
281 | }
|
282 | this.setState(st);
|
283 | this.props.onDragEnter({
|
284 | event: e,
|
285 | node: treeNode,
|
286 | expandedKeys: expandedKeys && [].concat(_toConsumableArray(expandedKeys)) || [].concat(_toConsumableArray(this.state.expandedKeys))
|
287 | });
|
288 | };
|
289 |
|
290 | Tree.prototype.onDragOver = function onDragOver(e, treeNode) {
|
291 | this.props.onDragOver({
|
292 | event: e,
|
293 | node: treeNode
|
294 | });
|
295 | };
|
296 |
|
297 | Tree.prototype.onDragLeave = function onDragLeave(e, treeNode) {
|
298 | this.props.onDragLeave({
|
299 | event: e,
|
300 | node: treeNode
|
301 | });
|
302 | };
|
303 |
|
304 | Tree.prototype.onDrop = function onDrop(e, treeNode) {
|
305 | var key = treeNode.props.eventKey;
|
306 | this.setState({
|
307 | dragOverNodeKey: '',
|
308 | dropNodeKey: key
|
309 | });
|
310 | if (this.dragNodesKeys.indexOf(key) > -1) {
|
311 | if (console.warn) {
|
312 | console.warn('can not drop to dragNode(include it\'s children node)');
|
313 | }
|
314 | return false;
|
315 | }
|
316 |
|
317 | var posArr = treeNode.props.pos.split('-');
|
318 | var res = {
|
319 | event: e,
|
320 | node: treeNode,
|
321 | dragNode: this.dragNode,
|
322 | dragNodesKeys: [].concat(_toConsumableArray(this.dragNodesKeys)),
|
323 | dropPosition: this.dropPosition + Number(posArr[posArr.length - 1])
|
324 | };
|
325 | if (this.dropPosition !== 0) {
|
326 | res.dropToGap = true;
|
327 | }
|
328 | if ('expandedKeys' in this.props) {
|
329 | res.rawExpandedKeys = [].concat(_toConsumableArray(this._rawExpandedKeys)) || [].concat(_toConsumableArray(this.state.expandedKeys));
|
330 | }
|
331 | this.props.onDrop(res);
|
332 | this._dropTrigger = true;
|
333 | };
|
334 |
|
335 | Tree.prototype.onDragEnd = function onDragEnd(e, treeNode) {
|
336 | this.setState({
|
337 | dragOverNodeKey: ''
|
338 | });
|
339 | this.props.onDragEnd({
|
340 | event: e,
|
341 | node: treeNode
|
342 | });
|
343 | };
|
344 | |
345 |
|
346 |
|
347 |
|
348 |
|
349 |
|
350 |
|
351 |
|
352 |
|
353 |
|
354 | Tree.prototype.onExpand = function onExpand(treeNode, keyType) {
|
355 | var _this3 = this;
|
356 |
|
357 | var _props2 = this.props,
|
358 | treeData = _props2.treeData,
|
359 | lazyLoad = _props2.lazyLoad;
|
360 |
|
361 | var expanded = !treeNode.props.expanded;
|
362 | var controlled = 'expandedKeys' in this.props;
|
363 | var expandedKeys = [].concat(_toConsumableArray(this.state.expandedKeys));
|
364 | var index = expandedKeys.indexOf(treeNode.props.eventKey);
|
365 |
|
366 | if (keyType == 'left') {
|
367 | expanded = false;
|
368 | } else if (keyType == 'right') {
|
369 | expanded = true;
|
370 | }
|
371 |
|
372 | if (expanded && index === -1) {
|
373 | expandedKeys.push(treeNode.props.eventKey);
|
374 | } else if (!expanded && index > -1) {
|
375 | expandedKeys.splice(index, 1);
|
376 | }
|
377 | if (!controlled) {
|
378 | this.setState({
|
379 | expandedKeys: expandedKeys
|
380 | });
|
381 | }
|
382 | this.props.onExpand(expandedKeys, {
|
383 | node: treeNode,
|
384 | expanded: expanded
|
385 | });
|
386 |
|
387 |
|
388 | if (expanded && this.props.loadData) {
|
389 | return this.props.loadData(treeNode).then(function () {
|
390 | if (!controlled) {
|
391 | _this3.setState({
|
392 | expandedKeys: expandedKeys
|
393 | });
|
394 | }
|
395 | });
|
396 | }
|
397 |
|
398 | this.cacheExpandedKeys = new Set(expandedKeys);
|
399 |
|
400 | if (lazyLoad) {
|
401 | var flatTreeData = this.deepTraversal(treeData);
|
402 | this.cacheExpandedKeys = null;
|
403 | this.setState({
|
404 | flatTreeData: flatTreeData
|
405 | });
|
406 | }
|
407 | };
|
408 |
|
409 | Tree.prototype.onCheck = function onCheck(treeNode) {
|
410 | var _this4 = this;
|
411 |
|
412 | var checked = !treeNode.props.checked;
|
413 | if (treeNode.props.halfChecked) {
|
414 | checked = true;
|
415 | }
|
416 | var key = treeNode.props.eventKey;
|
417 | var checkedKeys = [].concat(_toConsumableArray(this.state.checkedKeys));
|
418 | var index = checkedKeys.indexOf(key);
|
419 |
|
420 | var newSt = {
|
421 | event: 'check',
|
422 | node: treeNode,
|
423 | checked: checked
|
424 | };
|
425 |
|
426 | if (this.props.checkStrictly) {
|
427 | var rsCheckedKeys = [];
|
428 | if (checked && index === -1) {
|
429 | checkedKeys.push(key);
|
430 |
|
431 | }
|
432 | if (!checked && index > -1) {
|
433 | checkedKeys.splice(index, 1);
|
434 | }
|
435 | this.treeNodesStates[treeNode.props.pos].checked = checked;
|
436 | newSt.checkedNodes = [];
|
437 | (0, _util.loopAllChildren)(this.props.children, function (item, ind, pos, keyOrPos) {
|
438 | if (checkedKeys.indexOf(keyOrPos) !== -1) {
|
439 | newSt.checkedNodes.push(item);
|
440 | rsCheckedKeys.push(keyOrPos);
|
441 | }
|
442 | });
|
443 | if (!('checkedKeys' in this.props)) {
|
444 | this.setState({
|
445 | checkedKeys: rsCheckedKeys
|
446 | });
|
447 | }
|
448 | var halfChecked = this.props.checkedKeys ? this.props.checkedKeys.halfChecked : [];
|
449 | this.props.onCheck((0, _util.getStrictlyValue)(rsCheckedKeys, halfChecked), newSt);
|
450 | } else {
|
451 | if (checked && index === -1) {
|
452 | this.treeNodesStates[treeNode.props.pos].checked = true;
|
453 | var checkedPositions = [];
|
454 | Object.keys(this.treeNodesStates).forEach(function (i) {
|
455 | if (_this4.treeNodesStates[i].checked) {
|
456 | checkedPositions.push(i);
|
457 | }
|
458 | });
|
459 | (0, _util.handleCheckState)(this.treeNodesStates, (0, _util.filterParentPosition)(checkedPositions), true);
|
460 | }
|
461 | if (!checked) {
|
462 | this.treeNodesStates[treeNode.props.pos].checked = false;
|
463 | this.treeNodesStates[treeNode.props.pos].halfChecked = false;
|
464 | (0, _util.handleCheckState)(this.treeNodesStates, [treeNode.props.pos], false);
|
465 | }
|
466 | var checkKeys = (0, _util.getCheck)(this.treeNodesStates);
|
467 | newSt.checkedNodes = checkKeys.checkedNodes;
|
468 | newSt.checkedNodesPositions = checkKeys.checkedNodesPositions;
|
469 | newSt.halfCheckedKeys = checkKeys.halfCheckedKeys;
|
470 | this.checkKeys = checkKeys;
|
471 |
|
472 | this._checkedKeys = checkedKeys = checkKeys.checkedKeys;
|
473 | if (!('checkedKeys' in this.props)) {
|
474 | this.setState({
|
475 | checkedKeys: checkedKeys
|
476 | });
|
477 | }
|
478 | this.props.onCheck(checkedKeys, newSt);
|
479 | }
|
480 | };
|
481 |
|
482 | Tree.prototype.onSelect = function onSelect(treeNode) {
|
483 | var props = this.props;
|
484 | var selectedKeys = [].concat(_toConsumableArray(this.state.selectedKeys));
|
485 | var eventKey = treeNode.props.eventKey || treeNode.key;
|
486 | var index = selectedKeys.indexOf(eventKey);
|
487 | var selected = void 0;
|
488 |
|
489 | if (props.cancelUnSelect) {
|
490 | if (index == -1) {
|
491 | selected = true;
|
492 | if (!props.multiple) {
|
493 | selectedKeys.length = 0;
|
494 | }
|
495 | selectedKeys.push(eventKey);
|
496 | }
|
497 | } else {
|
498 | if (index !== -1) {
|
499 | selected = false;
|
500 | selectedKeys.splice(index, 1);
|
501 | } else {
|
502 | selected = true;
|
503 | if (!props.multiple) {
|
504 | selectedKeys.length = 0;
|
505 | }
|
506 | selectedKeys.push(eventKey);
|
507 | }
|
508 | }
|
509 |
|
510 | var selectedNodes = [];
|
511 | if (selectedKeys.length) {
|
512 | var treeNodes = this.props.children || treeNode.props.root.cacheTreeNodes;
|
513 | (0, _util.loopAllChildren)(treeNodes, function (item) {
|
514 | if (selectedKeys.indexOf(item.key) !== -1) {
|
515 | selectedNodes.push(item);
|
516 | }
|
517 | });
|
518 | }
|
519 | var newSt = {
|
520 | event: 'select',
|
521 | node: treeNode,
|
522 | selected: selected,
|
523 | selectedNodes: selectedNodes
|
524 | };
|
525 | if (!('selectedKeys' in this.props)) {
|
526 | this.setState({
|
527 | selectedKeys: selectedKeys
|
528 | });
|
529 | }
|
530 | props.onSelect(selectedKeys, newSt);
|
531 | };
|
532 |
|
533 | Tree.prototype.onDoubleClick = function onDoubleClick(treeNode) {
|
534 | var props = this.props;
|
535 | var eventKey = treeNode.props.eventKey;
|
536 | var newSt = {
|
537 | event: 'dblclick',
|
538 | node: treeNode
|
539 | };
|
540 | if (props.expandWhenDoubleClick) {
|
541 | this.onExpand(treeNode);
|
542 | }
|
543 | props.onDoubleClick(eventKey, newSt);
|
544 | };
|
545 |
|
546 | Tree.prototype.onMouseEnter = function onMouseEnter(e, treeNode) {
|
547 | this.props.onMouseEnter({
|
548 | event: e,
|
549 | node: treeNode
|
550 | });
|
551 | };
|
552 |
|
553 | Tree.prototype.onMouseLeave = function onMouseLeave(e, treeNode) {
|
554 | this.props.onMouseLeave({
|
555 | event: e,
|
556 | node: treeNode
|
557 | });
|
558 | };
|
559 |
|
560 | Tree.prototype.onContextMenu = function onContextMenu(e, treeNode) {
|
561 | var selectedKeys = [].concat(_toConsumableArray(this.state.selectedKeys));
|
562 | var eventKey = treeNode.props.eventKey;
|
563 | if (this.contextmenuKeys.indexOf(eventKey) === -1) {
|
564 | this.contextmenuKeys.push(eventKey);
|
565 | }
|
566 | this.contextmenuKeys.forEach(function (key) {
|
567 | var index = selectedKeys.indexOf(key);
|
568 | if (index !== -1) {
|
569 | selectedKeys.splice(index, 1);
|
570 | }
|
571 | });
|
572 | if (selectedKeys.indexOf(eventKey) === -1) {
|
573 | selectedKeys.push(eventKey);
|
574 | }
|
575 | this.setState({
|
576 | selectedKeys: selectedKeys
|
577 | });
|
578 | this.props.onRightClick({
|
579 | event: e,
|
580 | node: treeNode
|
581 | });
|
582 | };
|
583 |
|
584 | Tree.prototype.getTreeNode = function getTreeNode() {
|
585 | var props = this.props;
|
586 | };
|
587 |
|
588 | Tree.prototype.goDown = function goDown(currentPos, currentIndex, e, treeNode) {
|
589 | var props = this.props;
|
590 | var state = this.state;
|
591 | var treeChildren = props.children ? props.children : this.cacheTreeNodes;
|
592 | var nextIndex = parseInt(currentIndex) + 1;
|
593 |
|
594 | var nextPos = void 0,
|
595 | backNextPos = void 0;
|
596 | var nextTreeNode = void 0,
|
597 | backNextTreeNode = void 0;
|
598 | var backNextPosArr = [],
|
599 | backNextTreeNodeArr = [],
|
600 | tempBackNextPosArr = [];
|
601 |
|
602 | if (state.expandedKeys.indexOf(treeNode.props.eventKey) > -1) {
|
603 | nextPos = currentPos + '-0';
|
604 | } else {
|
605 | nextPos = currentPos.substr(0, currentPos.lastIndexOf('-') + 1) + nextIndex;
|
606 | }
|
607 |
|
608 | var tempPosArr = currentPos.split('-');
|
609 | var tempPosArrLength = tempPosArr.length;
|
610 |
|
611 | while (tempPosArrLength > 1) {
|
612 | backNextPos = tempPosArrLength > 1 && tempPosArr.slice(0, tempPosArrLength - 1).join('-') + '-' + (parseInt(tempPosArr[tempPosArrLength - 1]) + 1);
|
613 | tempBackNextPosArr.push(backNextPos);
|
614 | tempPosArr = tempPosArr.slice(0, tempPosArrLength - 1);
|
615 | tempPosArrLength = tempPosArr.length;
|
616 | }
|
617 |
|
618 | (0, _util.loopAllChildren)(treeChildren, function (itemNode, index, pos, newKey) {
|
619 | if (pos == nextPos) {
|
620 | nextTreeNode = itemNode;
|
621 | }
|
622 | tempBackNextPosArr.forEach(function (item) {
|
623 | if (item && item == pos) {
|
624 |
|
625 | backNextTreeNodeArr.push(itemNode);
|
626 | backNextPosArr.push(pos);
|
627 | }
|
628 | });
|
629 | });
|
630 |
|
631 | if (!nextTreeNode) {
|
632 | for (var i = 0; i < backNextTreeNodeArr.length; i++) {
|
633 | if (backNextTreeNodeArr[i]) {
|
634 | nextTreeNode = backNextTreeNodeArr[i];
|
635 | nextPos = backNextPosArr[i];
|
636 | break;
|
637 | }
|
638 | }
|
639 | }
|
640 |
|
641 |
|
642 | if (nextTreeNode) {
|
643 | var queryInfo = 'a[pos="' + nextPos + '"]';
|
644 | var parentEle = (0, _util.closest)(e.target, ".u-tree");
|
645 | var focusEle = parentEle ? parentEle.querySelector(queryInfo) : null;
|
646 | focusEle && focusEle.focus();
|
647 | var eventKey = nextTreeNode.props.eventKey || nextTreeNode.key;
|
648 | this.setState({
|
649 | focusKey: eventKey
|
650 | });
|
651 | if (props.autoSelectWhenFocus) {
|
652 | this.onSelect(nextTreeNode);
|
653 | }
|
654 | }
|
655 | };
|
656 |
|
657 | Tree.prototype.goUp = function goUp(currentPos, currentIndex, e, treeNode) {
|
658 | var props = this.props;
|
659 | var state = this.state;
|
660 | if (currentIndex == 0 && currentPos.length === 3) {
|
661 | return;
|
662 | }
|
663 |
|
664 | var preIndex = parseInt(currentIndex) - 1;
|
665 | var prePos = void 0;
|
666 | if (preIndex >= 0) {
|
667 | prePos = currentPos.substr(0, currentPos.lastIndexOf('-') + 1) + preIndex;
|
668 | } else {
|
669 | prePos = currentPos.substr(0, currentPos.lastIndexOf('-'));
|
670 | }
|
671 |
|
672 | var prevTreeNode = void 0,
|
673 | preElement = void 0;
|
674 |
|
675 | (0, _util.loopAllChildren)(props.children, function (item, index, pos, newKey) {
|
676 | if (pos == prePos) {
|
677 | prevTreeNode = item;
|
678 | }
|
679 | });
|
680 |
|
681 | if (prevTreeNode) {
|
682 | if (preIndex >= 0) {
|
683 |
|
684 | if (state.expandedKeys.indexOf(prevTreeNode.key) > -1) {
|
685 | var preElementArr = e.target.parentElement.previousElementSibling.querySelectorAll('a');
|
686 | preElement = preElementArr[preElementArr.length - 1];
|
687 | prePos = preElement.getAttribute('pos');
|
688 | (0, _util.loopAllChildren)(props.children, function (item, index, pos, newKey) {
|
689 | if (pos == prePos) {
|
690 | prevTreeNode = item;
|
691 | }
|
692 | });
|
693 | } else {
|
694 |
|
695 | preElement = e.target.parentElement.previousElementSibling.querySelector('a');
|
696 | }
|
697 | } else {
|
698 |
|
699 | preElement = e.target.parentElement.parentElement.parentElement.querySelector('a');
|
700 | }
|
701 | }
|
702 | preElement && preElement.focus();
|
703 | var eventKey = prevTreeNode.props.eventKey || prevTreeNode.key;
|
704 | this.setState({
|
705 | focusKey: eventKey
|
706 | });
|
707 | if (props.autoSelectWhenFocus) {
|
708 | this.onSelect(prevTreeNode);
|
709 | }
|
710 | };
|
711 |
|
712 |
|
713 |
|
714 | Tree.prototype.onKeyDown = function onKeyDown(e, treeNode) {
|
715 |
|
716 |
|
717 | var props = this.props;
|
718 | var currentPos = treeNode.props.pos;
|
719 | var selectable = treeNode.props.selectable;
|
720 | var currentIndex = currentPos.substr(currentPos.lastIndexOf('-') + 1);
|
721 |
|
722 | if (e.keyCode == _tinperBeeCore.KeyCode.DOWN) {
|
723 | this.goDown(currentPos, currentIndex, e, treeNode);
|
724 | } else if (e.keyCode == _tinperBeeCore.KeyCode.UP) {
|
725 | this.goUp(currentPos, currentIndex, e, treeNode);
|
726 | } else if (e.keyCode == _tinperBeeCore.KeyCode.LEFT && !treeNode.props.isLeaf) {
|
727 |
|
728 | this.onExpand(treeNode, 'left');
|
729 | } else if (e.keyCode == _tinperBeeCore.KeyCode.RIGHT && !treeNode.props.isLeaf) {
|
730 |
|
731 | this.onExpand(treeNode, 'right');
|
732 | } else if (e.keyCode == _tinperBeeCore.KeyCode.SPACE) {
|
733 | this.onSelect(treeNode);
|
734 |
|
735 | props.checkable && this.onCheck(treeNode);
|
736 | } else if (e.keyCode == _tinperBeeCore.KeyCode.ENTER) {
|
737 | if (props.onDoubleClick) {
|
738 | this.onDoubleClick(treeNode);
|
739 | } else {
|
740 | selectable && this.onSelect(treeNode);
|
741 | props.checkable && this.onCheck(treeNode);
|
742 | }
|
743 | }
|
744 | this.props.keyFun && this.props.keyFun(e, treeNode);
|
745 |
|
746 | };
|
747 |
|
748 | Tree.prototype._focusDom = function _focusDom(selectKeyDomPos, targetDom) {
|
749 | var queryInfo = 'a[pos="' + selectKeyDomPos + '"]';
|
750 | var parentEle = (0, _util.closest)(targetDom, ".u-tree");
|
751 | var focusEle = parentEle ? parentEle.querySelector(queryInfo) : null;
|
752 | if (document.activeElement !== focusEle) {
|
753 | focusEle && focusEle.focus();
|
754 | }
|
755 | };
|
756 |
|
757 | |
758 |
|
759 |
|
760 |
|
761 |
|
762 |
|
763 | Tree.prototype.onUlFocus = function onUlFocus(e) {
|
764 | var _this5 = this;
|
765 |
|
766 | var targetDom = e.target;
|
767 |
|
768 |
|
769 | if (this.tree == targetDom && !this.isIn && !this.tree.contains(e.relatedTarget)) {
|
770 | var _props3 = this.props,
|
771 | onFocus = _props3.onFocus,
|
772 | children = _props3.children;
|
773 | var _state$selectedKeys = this.state.selectedKeys,
|
774 | selectedKeys = _state$selectedKeys === undefined ? [] : _state$selectedKeys;
|
775 |
|
776 | var tabIndexKey = selectedKeys[0];
|
777 | var isExist = false;
|
778 | var treeNode = children && children.length && children[0];
|
779 | var eventKey = treeNode && treeNode.props.eventKey || treeNode.key;
|
780 | if (this.selectKeyDomExist && tabIndexKey || !tabIndexKey) {
|
781 | isExist = true;
|
782 | var queryInfo = 'a[pos="' + this.selectKeyDomPos + '"]';
|
783 | var parentEle = (0, _util.closest)(e.target, ".u-tree");
|
784 | var focusEle = parentEle ? parentEle.querySelector(queryInfo) : null;
|
785 | focusEle && focusEle.focus();
|
786 |
|
787 | this.setState({
|
788 | focusKey: tabIndexKey || eventKey
|
789 | });
|
790 | }
|
791 | var onFocusRes = onFocus && onFocus(isExist);
|
792 | if (onFocusRes instanceof Promise) {
|
793 | onFocusRes.then(function () {
|
794 | _this5._focusDom(_this5.selectKeyDomPos, targetDom);
|
795 | });
|
796 | } else {
|
797 | this._focusDom(this.selectKeyDomPos, targetDom);
|
798 | }
|
799 | }
|
800 | };
|
801 |
|
802 | Tree.prototype.onUlMouseEnter = function onUlMouseEnter(e) {
|
803 | this.isIn = true;
|
804 |
|
805 | };
|
806 |
|
807 | Tree.prototype.onUlMouseLeave = function onUlMouseLeave(e) {
|
808 | this.isIn = false;
|
809 |
|
810 | };
|
811 |
|
812 | Tree.prototype.getFilterExpandedKeys = function getFilterExpandedKeys(props, expandKeyProp, expandAll) {
|
813 | var keys = props[expandKeyProp];
|
814 | if (!expandAll && !props.autoExpandParent) {
|
815 | return keys || [];
|
816 | }
|
817 | var expandedPositionArr = [];
|
818 | if (props.autoExpandParent) {
|
819 | (0, _util.loopAllChildren)(props.children, function (item, index, pos, newKey) {
|
820 | if (keys.indexOf(newKey) > -1) {
|
821 | expandedPositionArr.push(pos);
|
822 | }
|
823 | });
|
824 | }
|
825 | var filterExpandedKeys = [];
|
826 | (0, _util.loopAllChildren)(props.children, function (item, index, pos, newKey) {
|
827 | if (expandAll) {
|
828 | filterExpandedKeys.push(newKey);
|
829 | } else if (props.autoExpandParent) {
|
830 | expandedPositionArr.forEach(function (p) {
|
831 | if ((p.split('-').length > pos.split('-').length && (0, _util.isInclude)(pos.split('-'), p.split('-')) || pos === p) && filterExpandedKeys.indexOf(newKey) === -1) {
|
832 | filterExpandedKeys.push(newKey);
|
833 | }
|
834 | });
|
835 | }
|
836 | });
|
837 | return filterExpandedKeys.length ? filterExpandedKeys : keys;
|
838 | };
|
839 |
|
840 | Tree.prototype.getDefaultExpandedKeys = function getDefaultExpandedKeys(props, willReceiveProps) {
|
841 | var expandedKeys = willReceiveProps ? undefined : this.getFilterExpandedKeys(props, 'defaultExpandedKeys', props.defaultExpandedKeys.length ? false : props.defaultExpandAll);
|
842 | if ('expandedKeys' in props) {
|
843 | expandedKeys = (props.autoExpandParent ? this.getFilterExpandedKeys(props, 'expandedKeys', false) : props.expandedKeys) || [];
|
844 | }
|
845 | return expandedKeys;
|
846 | };
|
847 |
|
848 | Tree.prototype.getDefaultCheckedKeys = function getDefaultCheckedKeys(props, willReceiveProps) {
|
849 | var checkedKeys = willReceiveProps ? undefined : props.defaultCheckedKeys;
|
850 | if ('checkedKeys' in props) {
|
851 | checkedKeys = props.checkedKeys || [];
|
852 | if (props.checkStrictly) {
|
853 | if (props.checkedKeys.checked) {
|
854 | checkedKeys = props.checkedKeys.checked;
|
855 | } else if (!Array.isArray(props.checkedKeys)) {
|
856 | checkedKeys = [];
|
857 | }
|
858 | }
|
859 | }
|
860 | return checkedKeys;
|
861 | };
|
862 |
|
863 | Tree.prototype.getDefaultSelectedKeys = function getDefaultSelectedKeys(props, willReceiveProps) {
|
864 | var getKeys = function getKeys(keys) {
|
865 | if (props.multiple) {
|
866 | return [].concat(_toConsumableArray(keys));
|
867 | }
|
868 | if (keys.length) {
|
869 | return [keys[0]];
|
870 | }
|
871 | return keys;
|
872 | };
|
873 | var selectedKeys = willReceiveProps ? undefined : getKeys(props.defaultSelectedKeys);
|
874 | if ('selectedKeys' in props) {
|
875 | selectedKeys = getKeys(props.selectedKeys);
|
876 | }
|
877 | return selectedKeys;
|
878 | };
|
879 |
|
880 | Tree.prototype.getRawExpandedKeys = function getRawExpandedKeys() {
|
881 | if (!this._rawExpandedKeys && 'expandedKeys' in this.props) {
|
882 | this._rawExpandedKeys = [].concat(_toConsumableArray(this.state.expandedKeys));
|
883 | }
|
884 | };
|
885 |
|
886 | Tree.prototype.getOpenTransitionName = function getOpenTransitionName() {
|
887 | var props = this.props;
|
888 | var transitionName = props.openTransitionName;
|
889 | var animationName = props.openAnimation;
|
890 | if (!transitionName && typeof animationName === 'string') {
|
891 | transitionName = props.prefixCls + '-open-' + animationName;
|
892 | }
|
893 | return transitionName;
|
894 | };
|
895 |
|
896 | Tree.prototype.getDragNodes = function getDragNodes(treeNode) {
|
897 | var dragNodesKeys = [];
|
898 | var tPArr = treeNode.props.pos.split('-');
|
899 | (0, _util.loopAllChildren)(this.props.children, function (item, index, pos, newKey) {
|
900 | var pArr = pos.split('-');
|
901 | if (treeNode.props.pos === pos || tPArr.length < pArr.length && (0, _util.isInclude)(tPArr, pArr)) {
|
902 | dragNodesKeys.push(newKey);
|
903 | }
|
904 | });
|
905 | return dragNodesKeys;
|
906 | };
|
907 |
|
908 | Tree.prototype.getExpandedKeys = function getExpandedKeys(treeNode, expand) {
|
909 | var key = treeNode.props.eventKey;
|
910 | var expandedKeys = this.state.expandedKeys;
|
911 | var expandedIndex = expandedKeys.indexOf(key);
|
912 | var exKeys = void 0;
|
913 | if (expandedIndex > -1 && !expand) {
|
914 | exKeys = [].concat(_toConsumableArray(expandedKeys));
|
915 | exKeys.splice(expandedIndex, 1);
|
916 | return exKeys;
|
917 | }
|
918 | if (expand && expandedKeys.indexOf(key) === -1) {
|
919 | return expandedKeys.concat([key]);
|
920 | }
|
921 | };
|
922 |
|
923 | Tree.prototype.filterTreeNode = function filterTreeNode(treeNode) {
|
924 | var filterTreeNode = this.props.filterTreeNode;
|
925 | if (typeof filterTreeNode !== 'function' || treeNode.props.disabled) {
|
926 | return false;
|
927 | }
|
928 | return filterTreeNode.call(this, treeNode);
|
929 | };
|
930 |
|
931 | |
932 |
|
933 |
|
934 |
|
935 |
|
936 | |
937 |
|
938 |
|
939 |
|
940 |
|
941 |
|
942 |
|
943 |
|
944 | |
945 |
|
946 |
|
947 |
|
948 |
|
949 |
|
950 |
|
951 |
|
952 | |
953 |
|
954 |
|
955 |
|
956 |
|
957 |
|
958 |
|
959 |
|
960 | Tree.prototype.renderTreeNode = function renderTreeNode(child, index) {
|
961 | var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
|
962 |
|
963 |
|
964 | var actualIndex = index + parseInt(this.startIndex);
|
965 | var pos = level + '-' + actualIndex;
|
966 | var key = child.key || pos;
|
967 |
|
968 | var state = this.state;
|
969 | var props = this.props;
|
970 | var _state$selectedKeys2 = this.state.selectedKeys,
|
971 | selectedKeys = _state$selectedKeys2 === undefined ? [] : _state$selectedKeys2;
|
972 |
|
973 | var tabIndexKey = selectedKeys[0];
|
974 | if (tabIndexKey && key == tabIndexKey) {
|
975 | this.selectKeyDomExist = true;
|
976 | this.selectKeyDomPos = pos;
|
977 | }
|
978 |
|
979 | var selectable = props.selectable;
|
980 | if (child.props.hasOwnProperty('selectable')) {
|
981 | selectable = child.props.selectable;
|
982 | }
|
983 | var draggable = props.draggable;
|
984 | if (child.props.hasOwnProperty('draggable')) {
|
985 | draggable = child.props.draggable;
|
986 | }
|
987 | var isLeaf = null;
|
988 | if (child.props.hasOwnProperty('isLeaf')) {
|
989 | isLeaf = child.props.isLeaf;
|
990 | }
|
991 |
|
992 | var cloneProps = {
|
993 | root: this,
|
994 | eventKey: key,
|
995 | pos: pos,
|
996 | selectable: selectable,
|
997 | loadData: props.loadData,
|
998 | onMouseEnter: props.onMouseEnter,
|
999 | onMouseLeave: props.onMouseLeave,
|
1000 | onRightClick: props.onRightClick,
|
1001 | onDoubleClick: props.onDoubleClick,
|
1002 | onKeyDown: props.onKeyDown,
|
1003 | prefixCls: props.prefixCls,
|
1004 | showLine: props.showLine,
|
1005 | showIcon: props.showIcon,
|
1006 | draggable: draggable,
|
1007 | dragOver: state.dragOverNodeKey === key && this.dropPosition === 0,
|
1008 | dragOverGapTop: state.dragOverNodeKey === key && this.dropPosition === -1,
|
1009 | dragOverGapBottom: state.dragOverNodeKey === key && this.dropPosition === 1,
|
1010 | _dropTrigger: this._dropTrigger,
|
1011 | expanded: state.expandedKeys.indexOf(key) !== -1,
|
1012 | selected: state.selectedKeys.indexOf(key) !== -1,
|
1013 | focused: state.focusKey === key,
|
1014 | openTransitionName: this.getOpenTransitionName(),
|
1015 | openAnimation: props.openAnimation,
|
1016 | filterTreeNode: this.filterTreeNode.bind(this),
|
1017 | openIcon: props.openIcon,
|
1018 | closeIcon: props.closeIcon,
|
1019 | focusable: props.focusable,
|
1020 | tabIndexKey: state.selectedKeys[0],
|
1021 | tabIndexValue: props.tabIndexValue,
|
1022 | ext: child.props.ext,
|
1023 | mustExpandable: props.mustExpandable,
|
1024 | isLeaf: isLeaf
|
1025 | };
|
1026 | if (props.checkable) {
|
1027 | cloneProps.checkable = props.checkable;
|
1028 | if (props.checkStrictly) {
|
1029 | if (state.checkedKeys) {
|
1030 | cloneProps.checked = state.checkedKeys.indexOf(key) !== -1 || false;
|
1031 | }
|
1032 | if (props.checkedKeys && props.checkedKeys.halfChecked) {
|
1033 | cloneProps.halfChecked = props.checkedKeys.halfChecked.indexOf(key) !== -1 || false;
|
1034 | } else {
|
1035 | cloneProps.halfChecked = false;
|
1036 | }
|
1037 | } else {
|
1038 | if (this.checkedKeys) {
|
1039 | cloneProps.checked = this.checkedKeys.indexOf(key) !== -1 || false;
|
1040 | }
|
1041 | cloneProps.halfChecked = this.halfCheckedKeys.indexOf(key) !== -1;
|
1042 | }
|
1043 | }
|
1044 | if (this.treeNodesStates && this.treeNodesStates[pos]) {
|
1045 | _extends(cloneProps, this.treeNodesStates[pos].siblingPosition);
|
1046 | }
|
1047 | return _react2["default"].cloneElement(child, cloneProps);
|
1048 | };
|
1049 |
|
1050 | Tree.prototype.render = function render() {
|
1051 | var _this6 = this;
|
1052 |
|
1053 | var props = this.props;
|
1054 |
|
1055 | var _props4 = this.props,
|
1056 | showLine = _props4.showLine,
|
1057 | prefixCls = _props4.prefixCls,
|
1058 | className = _props4.className,
|
1059 | focusable = _props4.focusable,
|
1060 | checkable = _props4.checkable,
|
1061 | loadData = _props4.loadData,
|
1062 | checkStrictly = _props4.checkStrictly,
|
1063 | tabIndexValue = _props4.tabIndexValue,
|
1064 | lazyLoad = _props4.lazyLoad,
|
1065 | getScrollContainer = _props4.getScrollContainer,
|
1066 | defaultExpandedKeys = _props4.defaultExpandedKeys,
|
1067 | defaultSelectedKeys = _props4.defaultSelectedKeys,
|
1068 | defaultCheckedKeys = _props4.defaultCheckedKeys,
|
1069 | openAnimation = _props4.openAnimation,
|
1070 | draggable = _props4.draggable,
|
1071 | others = _objectWithoutProperties(_props4, ['showLine', 'prefixCls', 'className', 'focusable', 'checkable', 'loadData', 'checkStrictly', 'tabIndexValue', 'lazyLoad', 'getScrollContainer', 'defaultExpandedKeys', 'defaultSelectedKeys', 'defaultCheckedKeys', 'openAnimation', 'draggable']);
|
1072 |
|
1073 | var customProps = _extends({}, (0, _omit2["default"])(others, ['showIcon', 'cancelUnSelect', 'onCheck', 'selectable', 'autoExpandParent', 'defaultExpandAll', 'onExpand', 'autoSelectWhenFocus', 'expandWhenDoubleClick', 'expandedKeys', 'keyFun', 'openIcon', 'closeIcon', 'treeData', 'checkedKeys', 'selectedKeys', 'renderTreeNodes', 'mustExpandable', 'onMouseEnter', 'onMouseLeave', 'onDoubleClick']));
|
1074 | var _state = this.state,
|
1075 | treeData = _state.treeData,
|
1076 | flatTreeData = _state.flatTreeData;
|
1077 | var startIndex = this.startIndex,
|
1078 | endIndex = this.endIndex,
|
1079 | preHeight = 0,
|
1080 | sufHeight = 0,
|
1081 | treeNode = [],
|
1082 | treeChildren = props.children;
|
1083 |
|
1084 | if (lazyLoad) {
|
1085 | preHeight = this.getSumHeight(0, startIndex);
|
1086 | sufHeight = this.getSumHeight(endIndex, flatTreeData.length);
|
1087 | }
|
1088 | if (!props.children && treeData) {
|
1089 |
|
1090 | treeNode = this.renderTreefromData(treeData);
|
1091 | this.cacheTreeNodes = treeNode;
|
1092 | treeChildren = treeNode;
|
1093 | }
|
1094 | var showLineCls = "";
|
1095 | if (showLine) {
|
1096 | showLineCls = prefixCls + '-show-line';
|
1097 | }
|
1098 | var domProps = {
|
1099 | className: (0, _classnames2["default"])(className, prefixCls, showLineCls),
|
1100 | role: 'tree-node'
|
1101 | };
|
1102 |
|
1103 | if (focusable) {
|
1104 | domProps.onFocus = this.onUlFocus;
|
1105 | domProps.onMouseEnter = this.onUlMouseEnter;
|
1106 | domProps.onMouseLeave = this.onUlMouseLeave;
|
1107 | }
|
1108 |
|
1109 |
|
1110 |
|
1111 |
|
1112 |
|
1113 | var getTreeNodesStates = function getTreeNodesStates() {
|
1114 | _this6.treeNodesStates = {};
|
1115 | (0, _util.loopAllChildren)(treeChildren, function (item, index, pos, keyOrPos, siblingPosition) {
|
1116 | _this6.treeNodesStates[pos] = {
|
1117 | siblingPosition: siblingPosition
|
1118 | };
|
1119 | }, undefined, startIndex);
|
1120 | };
|
1121 | if (showLine && !checkable) {
|
1122 | getTreeNodesStates();
|
1123 | }
|
1124 | if (checkable && (this.checkedKeysChange || loadData || this.dataChange)) {
|
1125 | if (checkStrictly) {
|
1126 | getTreeNodesStates();
|
1127 | } else if (props._treeNodesStates) {
|
1128 | this.treeNodesStates = props._treeNodesStates.treeNodesStates;
|
1129 | this.halfCheckedKeys = props._treeNodesStates.halfCheckedKeys;
|
1130 | this.checkedKeys = props._treeNodesStates.checkedKeys;
|
1131 | } else {
|
1132 | var checkedKeys = this.state.checkedKeys;
|
1133 | var checkKeys = void 0;
|
1134 | if (!loadData && this.checkKeys && this._checkedKeys && (0, _util.arraysEqual)(this._checkedKeys, checkedKeys) && !this.dataChange) {
|
1135 |
|
1136 | checkKeys = this.checkKeys;
|
1137 | } else {
|
1138 | var checkedPositions = [];
|
1139 | this.treeNodesStates = {};
|
1140 | (0, _util.loopAllChildren)(treeChildren, function (item, index, pos, keyOrPos, siblingPosition) {
|
1141 | _this6.treeNodesStates[pos] = {
|
1142 | node: item,
|
1143 | key: keyOrPos,
|
1144 | checked: false,
|
1145 | halfChecked: false,
|
1146 | siblingPosition: siblingPosition
|
1147 | };
|
1148 | if (checkedKeys.indexOf(keyOrPos) !== -1) {
|
1149 | _this6.treeNodesStates[pos].checked = true;
|
1150 | checkedPositions.push(pos);
|
1151 | }
|
1152 | }, undefined, startIndex);
|
1153 |
|
1154 | (0, _util.handleCheckState)(this.treeNodesStates, (0, _util.filterParentPosition)(checkedPositions), true);
|
1155 | checkKeys = (0, _util.getCheck)(this.treeNodesStates);
|
1156 | }
|
1157 | this.halfCheckedKeys = checkKeys.halfCheckedKeys;
|
1158 | this.checkedKeys = checkKeys.checkedKeys;
|
1159 | }
|
1160 | }
|
1161 | this.selectKeyDomExist = false;
|
1162 | return lazyLoad ? _react2["default"].createElement(
|
1163 | _infiniteScroll2["default"],
|
1164 | {
|
1165 | className: 'u-tree-infinite-scroll',
|
1166 | treeList: flatTreeData,
|
1167 | handleTreeListChange: this.handleTreeListChange,
|
1168 | getScrollParent: getScrollContainer,
|
1169 | store: this.store
|
1170 | },
|
1171 | _react2["default"].createElement(
|
1172 | 'ul',
|
1173 | _extends({}, domProps, { unselectable: 'true', ref: function ref(el) {
|
1174 | _this6.tree = el;
|
1175 | }, tabIndex: focusable && tabIndexValue }, customProps),
|
1176 | _react2["default"].createElement('li', { style: { height: preHeight }, className: 'u-treenode-start', key: 'tree_node_start' }),
|
1177 | _react2["default"].Children.map(treeChildren, this.renderTreeNode, this),
|
1178 | _react2["default"].createElement('li', { style: { height: sufHeight }, className: 'u-treenode-end', key: 'tree_node_end' })
|
1179 | )
|
1180 | ) : _react2["default"].createElement(
|
1181 | 'ul',
|
1182 | _extends({}, domProps, { unselectable: 'true', ref: function ref(el) {
|
1183 | _this6.tree = el;
|
1184 | }, tabIndex: focusable && tabIndexValue }, customProps),
|
1185 | _react2["default"].Children.map(treeChildren, this.renderTreeNode, this)
|
1186 | );
|
1187 | };
|
1188 |
|
1189 | return Tree;
|
1190 | }(_react2["default"].Component);
|
1191 |
|
1192 | var _initialiseProps = function _initialiseProps() {
|
1193 | var _this7 = this;
|
1194 |
|
1195 | this.hasTreeNode = function () {
|
1196 | var _props5 = _this7.props,
|
1197 | children = _props5.children,
|
1198 | treeData = _props5.treeData;
|
1199 |
|
1200 | var noTreeNode = children === null || typeof children === 'undefined' || (typeof children === 'undefined' ? 'undefined' : _typeof(children)) === 'object' && children.length === 0 || (typeof treeData === 'undefined' ? 'undefined' : _typeof(treeData)) === 'object' && treeData.length === 0;
|
1201 | return !noTreeNode;
|
1202 | };
|
1203 |
|
1204 | this.calculateRowHeight = function () {
|
1205 | var lazyLoad = _this7.props.lazyLoad;
|
1206 |
|
1207 |
|
1208 | if (!lazyLoad) return;
|
1209 | var treenodes = _this7.tree.querySelectorAll('.u-tree-treenode-close')[0];
|
1210 | if (!treenodes) return;
|
1211 | _this7.hasCalculateRowHeight = true;
|
1212 | var rowHeight = treenodes.getBoundingClientRect().height;
|
1213 | _this7.store.setState({
|
1214 | rowHeight: rowHeight
|
1215 | });
|
1216 | };
|
1217 |
|
1218 | this.handleTreeListChange = function (treeList, startIndex, endIndex) {
|
1219 |
|
1220 | var attr = {
|
1221 | id: 'key',
|
1222 | parendId: 'parentKey',
|
1223 | name: 'title',
|
1224 | rootId: null,
|
1225 | isLeaf: 'isLeaf'
|
1226 | };
|
1227 | var treeData = (0, _util.convertListToTree)(treeList, attr, _this7.flatTreeKeysMap);
|
1228 |
|
1229 | _this7.startIndex = typeof startIndex !== "undefined" ? startIndex : _this7.startIndex;
|
1230 | _this7.endIndex = typeof endIndex !== "undefined" ? endIndex : _this7.endIndex;
|
1231 | _this7.setState({
|
1232 | treeData: treeData
|
1233 | });
|
1234 | _this7.dataChange = true;
|
1235 | };
|
1236 |
|
1237 | this.deepTraversal = function (treeData) {
|
1238 | var parentKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
1239 | var isShown = arguments[2];
|
1240 | var expandedKeys = _this7.state.expandedKeys,
|
1241 | expandedKeysSet = _this7.cacheExpandedKeys ? _this7.cacheExpandedKeys : new Set(expandedKeys),
|
1242 | flatTreeData = [],
|
1243 | flatTreeKeysMap = _this7.flatTreeKeysMap,
|
1244 | dataCopy = treeData;
|
1245 |
|
1246 | if (Array.isArray(dataCopy)) {
|
1247 | for (var i = 0, l = dataCopy.length; i < l; i++) {
|
1248 | var _dataCopy$i = dataCopy[i],
|
1249 | key = _dataCopy$i.key,
|
1250 | title = _dataCopy$i.title,
|
1251 | children = _dataCopy$i.children,
|
1252 | props = _objectWithoutProperties(_dataCopy$i, ['key', 'title', 'children']),
|
1253 | dataCopyI = new Object(),
|
1254 | isLeaf = children ? false : true;
|
1255 |
|
1256 |
|
1257 |
|
1258 | var isExpanded = parentKey === null || expandedKeysSet.has(parentKey) ? expandedKeysSet.has(key) : false;
|
1259 | dataCopyI = _extends(dataCopyI, {
|
1260 | key: key,
|
1261 | title: title,
|
1262 | isExpanded: isExpanded,
|
1263 | parentKey: parentKey || null,
|
1264 | isShown: isShown,
|
1265 | isLeaf: isLeaf
|
1266 | }, _extends({}, props));
|
1267 |
|
1268 | if (isShown || parentKey === null) {
|
1269 | flatTreeData.push(dataCopyI);
|
1270 | flatTreeKeysMap[key] = dataCopyI;
|
1271 | }
|
1272 | if (Array.isArray(children) && children.length > 0) {
|
1273 |
|
1274 | flatTreeData = flatTreeData.concat(_this7.deepTraversal(children, key, isExpanded));
|
1275 | }
|
1276 | }
|
1277 | }
|
1278 | return flatTreeData;
|
1279 | };
|
1280 |
|
1281 | this.renderTreefromData = function (data) {
|
1282 | var _props6 = _this7.props,
|
1283 | renderTitle = _props6.renderTitle,
|
1284 | renderTreeNodes = _props6.renderTreeNodes;
|
1285 |
|
1286 | if (renderTreeNodes) {
|
1287 | return renderTreeNodes(data);
|
1288 | }
|
1289 | var loop = function loop(data) {
|
1290 | return data.map(function (item) {
|
1291 | var key = item.key,
|
1292 | title = item.title,
|
1293 | children = item.children,
|
1294 | isLeaf = item.isLeaf,
|
1295 | others = _objectWithoutProperties(item, ['key', 'title', 'children', 'isLeaf']);
|
1296 |
|
1297 | if (item.children) {
|
1298 | return _react2["default"].createElement(
|
1299 | _TreeNode2["default"],
|
1300 | _extends({}, others, { key: key, title: renderTitle ? renderTitle(item) : key, isLeaf: isLeaf }),
|
1301 | loop(item.children)
|
1302 | );
|
1303 | }
|
1304 | return _react2["default"].createElement(_TreeNode2["default"], _extends({}, others, { key: key, title: renderTitle ? renderTitle(item) : key, isLeaf: true }));
|
1305 | });
|
1306 | };
|
1307 | return loop(data);
|
1308 | };
|
1309 |
|
1310 | this.getSumHeight = function (start, end) {
|
1311 | var sumHeight = 0;
|
1312 | if (start > end) {
|
1313 | return sumHeight;
|
1314 | }
|
1315 | var span = Math.abs(end - start);
|
1316 | if (span) {
|
1317 | sumHeight = span * _this7.store.getState().rowHeight;
|
1318 | }
|
1319 | return sumHeight;
|
1320 | };
|
1321 | };
|
1322 |
|
1323 | Tree.propTypes = {
|
1324 | prefixCls: _propTypes2["default"].string,
|
1325 | children: _propTypes2["default"].any,
|
1326 | showLine: _propTypes2["default"].bool,
|
1327 | showIcon: _propTypes2["default"].bool,
|
1328 | selectable: _propTypes2["default"].bool,
|
1329 | multiple: _propTypes2["default"].bool,
|
1330 | checkable: _propTypes2["default"].oneOfType([_propTypes2["default"].bool, _propTypes2["default"].node]),
|
1331 | _treeNodesStates: _propTypes2["default"].object,
|
1332 | checkStrictly: _propTypes2["default"].bool,
|
1333 | draggable: _propTypes2["default"].bool,
|
1334 | autoExpandParent: _propTypes2["default"].bool,
|
1335 | defaultExpandAll: _propTypes2["default"].bool,
|
1336 | defaultExpandedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
|
1337 | expandedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
|
1338 | defaultCheckedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
|
1339 | checkedKeys: _propTypes2["default"].oneOfType([_propTypes2["default"].arrayOf(_propTypes2["default"].string), _propTypes2["default"].object]),
|
1340 | defaultSelectedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
|
1341 | selectedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
|
1342 | onExpand: _propTypes2["default"].func,
|
1343 | onCheck: _propTypes2["default"].func,
|
1344 | onSelect: _propTypes2["default"].func,
|
1345 | loadData: _propTypes2["default"].func,
|
1346 | onMouseEnter: _propTypes2["default"].func,
|
1347 | onMouseLeave: _propTypes2["default"].func,
|
1348 | onRightClick: _propTypes2["default"].func,
|
1349 | onDragStart: _propTypes2["default"].func,
|
1350 | onDragEnter: _propTypes2["default"].func,
|
1351 | onDragOver: _propTypes2["default"].func,
|
1352 | onDragLeave: _propTypes2["default"].func,
|
1353 | onDrop: _propTypes2["default"].func,
|
1354 | onDragEnd: _propTypes2["default"].func,
|
1355 | filterTreeNode: _propTypes2["default"].func,
|
1356 | openTransitionName: _propTypes2["default"].string,
|
1357 | focusable: _propTypes2["default"].bool,
|
1358 | openAnimation: _propTypes2["default"].oneOfType([_propTypes2["default"].string, _propTypes2["default"].object]),
|
1359 | lazyLoad: _propTypes2["default"].bool,
|
1360 | treeData: _propTypes2["default"].array,
|
1361 | renderTreeNodes: _propTypes2["default"].func,
|
1362 | autoSelectWhenFocus: _propTypes2["default"].bool,
|
1363 | getScrollContainer: _propTypes2["default"].func,
|
1364 | expandWhenDoubleClick: _propTypes2["default"].bool
|
1365 | };
|
1366 |
|
1367 | Tree.defaultProps = {
|
1368 | prefixCls: 'rc-tree',
|
1369 | showLine: false,
|
1370 | showIcon: true,
|
1371 | selectable: true,
|
1372 | multiple: false,
|
1373 | checkable: false,
|
1374 | checkStrictly: false,
|
1375 | draggable: false,
|
1376 | autoExpandParent: true,
|
1377 | defaultExpandAll: false,
|
1378 | defaultExpandedKeys: [],
|
1379 | defaultCheckedKeys: [],
|
1380 | defaultSelectedKeys: [],
|
1381 | onExpand: noop,
|
1382 | onCheck: noop,
|
1383 | onSelect: noop,
|
1384 | onDragStart: noop,
|
1385 | onDragEnter: noop,
|
1386 | onDragOver: noop,
|
1387 | onDragLeave: noop,
|
1388 | onDrop: noop,
|
1389 | onDragEnd: noop,
|
1390 | tabIndexValue: 0,
|
1391 | lazyLoad: false,
|
1392 | autoSelectWhenFocus: false,
|
1393 | getScrollContainer: noop,
|
1394 | expandWhenDoubleClick: false
|
1395 | };
|
1396 |
|
1397 | exports["default"] = Tree;
|
1398 | module.exports = exports['default']; |
\ | No newline at end of file |