@sms-frontend/components
Version:
SMS Design React UI Library.
670 lines (669 loc) • 33.7 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
import React, { Component } from 'react';
import isEqualWith from 'lodash/isEqualWith';
import cs from '../_util/classNames';
import Node from './node';
import NodeList from './node-list';
import { isFunction } from '../_util/is';
import { ConfigContext } from '../ConfigProvider';
import { getAllCheckedKeysByCheck, getCheckedKeysByInitKeys, getTreeDataFromTreeChildren, } from './util';
import { TreeContext } from './context';
import mergeProps from '../_util/mergeProps';
var DefaultFieldNames = {
key: 'key',
title: 'title',
children: 'children',
selectable: 'selectable',
disabled: 'disabled',
disableCheckbox: 'disableCheckbox',
checkable: 'checkable',
isLeaf: 'isLeaf',
};
var defaultProps = {
selectable: true,
autoExpandParent: true,
checkedStrategy: 'all',
allowDrop: function () { return true; },
fieldNames: DefaultFieldNames,
};
var needMergeKeys = [
'style',
'className',
'height',
'size',
'blockNode',
'autoExpandParent',
'checkedStrategy',
'fieldNames',
'icons',
'virtualListProps',
'showLine',
'selectable',
'allowDrop',
];
var Tree = /** @class */ (function (_super) {
__extends(Tree, _super);
function Tree(props, context) {
var _this = _super.call(this, props, context) || this;
// 依旧使用NodeInstance 是为了兼容1.x的一些用法，改动较大
_this.cacheNodes = {};
_this.key2nodeProps = {};
_this.indeterminateKeys = [];
_this.getMergedProps = function (baseProps) {
var componentConfig = _this.context.componentConfig;
var props = mergeProps(baseProps || _this.props, defaultProps, componentConfig === null || componentConfig === void 0 ? void 0 : componentConfig.Tree);
return Object.keys(props).reduce(function (total, key) {
if (needMergeKeys.indexOf(key) > -1) {
total[key] = props[key];
}
return total;
}, {});
};
// index: 第几个dom元素, 如果传入的是字符串，会作为 node 的 key去查找。
// nodeProps 参数似乎咩有什么用。。。但是不知道外部有没有调用，就当key用吧。。
_this.scrollIntoView = function (_index, nodeProps) {
var index = _index;
if (typeof _index === 'string' || nodeProps) {
// 作为key
index = _index || nodeProps._key;
}
if (_this.nodeListRef) {
_this.nodeListRef.scrollIntoView(index, nodeProps || _this.key2nodeProps[index]);
}
};
_this.getTreeData = function () {
return 'treeData' in _this.props
? _this.props.treeData
: getTreeDataFromTreeChildren(_this.props.children);
};
// 以下外部传入的属性改变时，需要更新nodeList
_this.needUpdateTreeData = function (prevProps, props) {
var keys = [
'fieldNames',
'selectable',
'draggable',
'checkStrictly',
'showLine',
'blockNode',
'checkable',
'treeData',
'children',
];
return keys.some(function (key) { return isEqualWith(prevProps[key], props[key]); });
};
// 根据 fieldNames 获取节点数据
_this.getFieldInfo = function (data) {
var mergedProps = _this.getMergedProps();
var selectable = mergedProps.selectable;
// fieldsNames 仅在treeData时生效。
var fieldNames = __assign(__assign({}, DefaultFieldNames), ('treeData' in _this.props ? mergedProps.fieldNames : {}));
var result = {
children: data[fieldNames.children],
selectable: fieldNames.selectable in data ? data[fieldNames.selectable] : selectable,
checkable: fieldNames.checkable in data ? data[fieldNames.checkable] : _this.props.checkable,
title: data[fieldNames.title],
disabled: data[fieldNames.disabled],
disableCheckbox: data[fieldNames.disableCheckbox],
isLeaf: data[fieldNames.isLeaf],
key: data[fieldNames.key],
};
if (!(fieldNames.key in data)) {
delete result.key;
}
return result;
};
_this.getNodeList = function (treedata, prefix) {
_this.key2nodeProps = {};
var prefixCls = prefix || _this.context.getPrefixCls('tree');
var nodeList = [];
var currentIndex = 0;
var _a = _this.getMergedProps(), showLine = _a.showLine, blockNode = _a.blockNode;
var loop = function (treeData, father) {
var totalLength = treeData.length;
return treeData.map(function (data, index) {
var _a = _this.getFieldInfo(data), children = _a.children, selectable = _a.selectable, checkable = _a.checkable, _b = _a.key, key = _b === void 0 ? ((father === null || father === void 0 ? void 0 : father._key) || '') + "-" + index : _b, rest = __rest(_a, ["children", "selectable", "checkable", "key"]);
var nodeProps = __assign(__assign(__assign({
// data 中含有dataRef时，优先级较高
dataRef: data, draggable: _this.props.draggable, selectable: selectable, checkable: checkable, showLine: showLine, blockNode: blockNode }, data), rest), { key: key, children: children, _key: key, _index: currentIndex++, parentKey: father ? father._key : undefined, pathParentKeys: (father && father.pathParentKeys) || [], _level: father._level || 0,
// 保存node在sowLine模式下是否显示缩进线。如果父节点是其所在层级的最后一个节点，那么所有的子节点（包括孙子节点等）在父节点所在层级的缩进格都不显示缩进线。
_lineless: father && father._lineless ? __spreadArray(__spreadArray([], __read((father._lineless || [])), false), [father._isTail], false) : [] });
if (totalLength === index + 1) {
nodeProps.className = cs(prefixCls + "-node-is-tail", nodeProps.className);
}
nodeList.push(nodeProps);
_this.key2nodeProps[key] = nodeProps;
if (children && children.length) {
_this.key2nodeProps[key].children = loop(children, {
_key: key,
_level: nodeProps._level + 1,
_lineless: nodeProps._lineless,
_isTail: totalLength === index + 1,
pathParentKeys: __spreadArray(__spreadArray([], __read(((father === null || father === void 0 ? void 0 : father.pathParentKeys) || [])), false), [key], false),
});
}
return nodeProps;
});
};
loop(treedata || [], {});
return nodeList;
};
_this.getInitExpandedKeys = function (keys) {
if (!_this.getMergedProps().autoExpandParent) {
return keys || [];
}
if (!keys) {
return Object.keys(_this.key2nodeProps).filter(function (key) {
var props = _this.key2nodeProps[key];
return props.children && props.children.length;
});
}
var expandedKeys = {};
keys.forEach(function (key) {
var item = _this.key2nodeProps[key];
if (!item) {
return;
}
expandedKeys[key] = 1;
if (item.pathParentKeys) {
item.pathParentKeys.forEach(function (x) {
expandedKeys[x] = 1;
});
}
});
return Object.keys(expandedKeys);
};
_this.getInitCheckedKeys = function (keys) {
if (!_this.props.checkStrictly) {
var _a = getCheckedKeysByInitKeys(keys, _this.key2nodeProps), checkedKeys = _a.checkedKeys, indeterminateKeys = _a.indeterminateKeys;
_this.indeterminateKeys = indeterminateKeys;
return checkedKeys;
}
_this.indeterminateKeys = [];
return keys;
};
_this.handleSelect = function (key, e) {
var onSelect = _this.props.onSelect;
var extra = { e: e, node: _this.cacheNodes[key] };
if (_this.props.multiple) {
var selectedKeys = __spreadArray([], __read(_this.state.selectedKeys), false);
var index = selectedKeys.indexOf(key);
if (index > -1) {
selectedKeys.splice(index, 1);
extra.selected = false;
}
else {
extra.selected = true;
selectedKeys.push(key);
}
extra.selectedNodes = selectedKeys.map(function (x) { return _this.cacheNodes[x]; });
if (!('selectedKeys' in _this.props)) {
_this.setState({ selectedKeys: selectedKeys });
}
onSelect && onSelect(selectedKeys, extra);
}
else {
extra.selected = true;
extra.selectedNodes = [_this.cacheNodes[key]];
if (!('selectedKeys' in _this.props)) {
_this.setState({ selectedKeys: [key] });
}
onSelect && onSelect([key], extra);
}
};
_this.handleCheck = function (checked, key, e) {
var checkedStrategy = _this.getMergedProps().checkedStrategy;
var _a = _this.props, onCheck = _a.onCheck, checkStrictly = _a.checkStrictly;
var extra = { e: e, node: _this.cacheNodes[key] };
var checkedKeys = _this.state.checkedKeys;
if (checkStrictly) {
if (checked) {
checkedKeys = checkedKeys.concat(key);
}
else {
checkedKeys = checkedKeys.filter(function (item) { return item !== key; });
}
if (!('checkedKeys' in _this.props)) {
_this.setState({ checkedKeys: checkedKeys });
}
}
else {
// 找到所有允许勾选的子节点
var _b = getAllCheckedKeysByCheck(key, checked, checkedKeys, _this.key2nodeProps, _this.indeterminateKeys), newCheckedKeys = _b.checkedKeys, indeterminateKeys = _b.indeterminateKeys;
checkedKeys = newCheckedKeys;
_this.indeterminateKeys = indeterminateKeys;
if (!('checkedKeys' in _this.props)) {
_this.setState({ checkedKeys: checkedKeys });
}
if (checkedStrategy === Tree.SHOW_PARENT) {
checkedKeys = checkedKeys.filter(function (x) {
var item = _this.key2nodeProps[x];
if (!item || checkedKeys.indexOf(item.parentKey) === -1) {
return true;
}
});
}
else if (checkedStrategy === Tree.SHOW_CHILD) {
checkedKeys = checkedKeys.filter(function (x) {
var item = _this.key2nodeProps[x];
if (!item || !item.children || !item.children.length) {
return true;
}
});
}
}
onCheck &&
onCheck(checkedKeys, __assign({ checkedNodes: checkedKeys.map(function (x) { return _this.cacheNodes[x]; }).filter(function (x) { return x; }), checked: checked }, extra));
};
_this.handleLoadMore = function (node) {
var loadMore = _this.props.loadMore;
if (isFunction(loadMore)) {
var _a = _this.state, _b = _a.loadingKeys, loadingKeys = _b === void 0 ? [] : _b, loadedKeys = _a.loadedKeys;
_this.setState({
loadingKeys: Array.from(new Set(__spreadArray(__spreadArray([], __read(loadingKeys), false), [node._key], false))),
loadedKeys: loadedKeys.filter(function (x) { return x !== node._key; }),
}, function () { return __awaiter(_this, void 0, void 0, function () {
var e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4 /*yield*/, loadMore(this.cacheNodes[node._key])];
case 1:
_a.sent();
this.setState({
loadedKeys: Array.from(new Set(__spreadArray(__spreadArray([], __read(this.state.loadedKeys), false), [node._key], false))),
loadingKeys: this.state.loadingKeys.filter(function (x) { return x !== node._key; }),
});
this.handleExpand(!node.expanded, node._key);
return [3 /*break*/, 3];
case 2:
e_1 = _a.sent();
console.error('[tree]load data error: ', e_1);
this.setState({
loadingKeys: this.state.loadingKeys.filter(function (x) { return x !== node._key; }),
});
return [3 /*break*/, 3];
case 3: return [2 /*return*/];
}
});
}); });
}
};
_this.handleNodeDragStart = function (e, node) {
_this.dragNode = _this.cacheNodes[node._key];
_this.dropPosition = 0;
var onDragStart = _this.props.onDragStart;
onDragStart && onDragStart(e, _this.cacheNodes[node._key]);
};
_this.handleNodeDragEnd = function (e, node) {
_this.dragNode = null;
_this.dropPosition = 0;
var onDragEnd = _this.props.onDragEnd;
onDragEnd && onDragEnd(e, _this.cacheNodes[node._key]);
};
_this.handleNodeDragOver = function (e, node, dropPosition) {
_this.dropPosition = dropPosition;
var onDragOver = _this.props.onDragOver;
onDragOver && onDragOver(e, _this.cacheNodes[node._key]);
};
_this.handleNodeDragLeave = function (e, node) {
// this.dropNode = null;
_this.dropPosition = 0;
var onDragLeave = _this.props.onDragLeave;
onDragLeave && onDragLeave(e, _this.cacheNodes[node._key]);
};
_this.isChildOfNode = function (node, target) {
var current = _this.key2nodeProps[node.parentKey];
while (current) {
var _key = current._key, parentKey = current.parentKey;
if (_key === target.props._key) {
return true;
}
if (parentKey === _key)
return;
current = _this.key2nodeProps[parentKey];
}
};
_this.isSameNode = function (node1, node2) {
// 对比 node
if (node1 === undefined || node2 === undefined)
return false;
if (node1 === node2)
return true;
// 对比 node.key
var key1 = node1.key;
var key2 = node2.key;
if (key1 !== undefined || key2 !== undefined)
return key1 === key2;
// 对比 node.props._key
var _key1 = node1.props._key;
var _key2 = node2.props._key;
if (_key1 === undefined && _key2 === undefined)
return false;
return _key1 === _key2;
};
_this.handleNodeDrop = function (e, node, dropPosition) {
if (_this.dragNode) {
var allowDrop = _this.getMergedProps().allowDrop;
var onDrop = _this.props.onDrop;
var nodeInstance = _this.cacheNodes[node._key];
if (onDrop &&
!_this.isChildOfNode(node, _this.dragNode) &&
!_this.isSameNode(_this.dragNode, nodeInstance)) {
if (allowDrop && !allowDrop({ dropNode: nodeInstance, dropPosition: dropPosition })) {
return;
}
onDrop({
dragNode: _this.dragNode,
dropNode: nodeInstance,
dropPosition: dropPosition,
e: e,
});
}
}
};
_this.handleAllowDrop = function (node, dropPosition) {
var allowDrop = _this.getMergedProps().allowDrop;
var isAllowDrop = true;
if (typeof allowDrop === 'function') {
isAllowDrop = allowDrop({ dropNode: _this.cacheNodes[node._key], dropPosition: dropPosition });
}
return isAllowDrop;
};
_this.handleExpand = function (expanded, key) {
var _a = _this.state, currentExpandKeys = _a.currentExpandKeys, _b = _a.expandedKeys, expandedKeys = _b === void 0 ? [] : _b;
var onExpand = _this.props.onExpand;
if (currentExpandKeys.indexOf(key) > -1) {
// 如果当前key节点正在展开/收起，不执行操作。
return;
}
var newExpandedKeys = [];
if (expanded) {
newExpandedKeys = Array.from(new Set(__spreadArray(__spreadArray([], __read(expandedKeys), false), [key], false)));
}
else {
newExpandedKeys = expandedKeys.filter(function (k) { return k !== key; });
}
if (!('expandedKeys' in _this.props)) {
_this.setState({
expandedKeys: newExpandedKeys,
currentExpandKeys: __spreadArray(__spreadArray([], __read(currentExpandKeys), false), [key], false),
});
}
onExpand &&
onExpand(newExpandedKeys, {
expanded: expanded,
node: _this.cacheNodes[key],
expandedNodes: newExpandedKeys.map(function (x) { return _this.cacheNodes[x]; }).filter(function (x) { return x; }),
});
};
// 传入构建好的expandedKeysSet
_this.getNodeProps = function (nodeProps, expandedKeysSet) {
var autoExpandParent = _this.getMergedProps().autoExpandParent;
var loadMore = _this.props.loadMore;
var _a = _this.state, selectedKeys = _a.selectedKeys, expandedKeys = _a.expandedKeys, checkedKeys = _a.checkedKeys, _b = _a.loadingKeys, loadingKeys = _b === void 0 ? [] : _b, _c = _a.loadedKeys, loadedKeys = _c === void 0 ? [] : _c;
var hasChildren = nodeProps.children && nodeProps.children.length;
var otherProps = {
isLeaf: !hasChildren,
autoExpandParent: hasChildren ? autoExpandParent : false,
expanded: expandedKeysSet
? expandedKeysSet.has(nodeProps._key)
: expandedKeys.indexOf(nodeProps._key) > -1,
};
if (loadMore) {
var loaded = loadedKeys.indexOf(nodeProps._key) > -1;
otherProps.loaded = loaded;
otherProps.isLeaf = hasChildren ? false : nodeProps.isLeaf;
}
return __assign(__assign(__assign({}, nodeProps), otherProps), { selected: selectedKeys && selectedKeys.indexOf(nodeProps._key) > -1, indeterminated: _this.indeterminateKeys.indexOf(nodeProps._key) > -1, loading: loadingKeys.indexOf(nodeProps._key) > -1, checked: checkedKeys && checkedKeys.indexOf(nodeProps._key) > -1, selectedKeys: selectedKeys, checkedKeys: checkedKeys, loadingKeys: loadingKeys, loadedKeys: loadedKeys, expandedKeys: _this.state.expandedKeys, childrenData: nodeProps.children || [], children: null });
};
_this.handleExpandEnd = function (key) {
var currentExpandKeys = _this.state.currentExpandKeys;
if (currentExpandKeys.indexOf(key) > -1) {
_this.setState({
currentExpandKeys: currentExpandKeys.filter(function (v) { return v !== key; }),
});
}
};
// 获取tree的state数据，在子组件里使用。
_this.getTreeState = function () {
return _this.state;
};
_this.state = {};
var treeData = _this.getTreeData();
var nodeList = _this.getNodeList(treeData, context.getPrefixCls('tree'));
_this.state = {
selectedKeys: props.selectedKeys || props.defaultSelectedKeys || [],
checkedKeys: _this.getInitCheckedKeys(props.checkedKeys || props.defaultCheckedKeys || []),
expandedKeys: _this.getInitExpandedKeys(props.expandedKeys || props.defaultExpandedKeys),
loadedKeys: [],
loadingKeys: [],
currentExpandKeys: [],
nodeList: nodeList,
};
return _this;
}
Tree.getDerivedStateFromProps = function (nextProps, state) {
var newState = {};
if ('selectedKeys' in nextProps && !isEqualWith(nextProps.selectedKeys, state.selectedKeys)) {
newState.selectedKeys = nextProps.selectedKeys || [];
}
if (Object.keys(newState).length) {
return newState;
}
return null;
};
Tree.prototype.componentDidUpdate = function (prevProps) {
// 类似 componentWillReceiveProps 周期
var _this = this;
var prevMergedProps = this.getMergedProps(prevProps);
var mergedProps = this.getMergedProps();
if (prevProps !== this.props || !isEqualWith(prevMergedProps, mergedProps)) {
var newState_1 = {};
if (this.needUpdateTreeData(__assign({ prevMergedProps: prevMergedProps }, prevProps), __assign(__assign({}, mergedProps), this.props))) {
var treeData = this.getTreeData();
var nodeList = this.getNodeList(treeData);
newState_1.treeData = treeData;
newState_1.nodeList = nodeList;
}
// 说明treeData变了，需要比较下内部checkedKeys
if (newState_1.treeData ||
('checkedKeys' in this.props && !isEqualWith(prevProps.checkedKeys, this.props.checkedKeys))) {
var currentCheckedKeys = 'checkedKeys' in this.props ? this.props.checkedKeys : this.state.checkedKeys;
var keys = this.getInitCheckedKeys(currentCheckedKeys || []);
if (!isEqualWith(keys, this.state.checkedKeys)) {
newState_1.checkedKeys = keys;
}
}
if ('expandedKeys' in this.props &&
!isEqualWith(this.props.expandedKeys, prevProps.expandedKeys)) {
newState_1.expandedKeys = this.props.expandedKeys;
// 比较前后expandKeys的改变，去重，得到需要收起/展开的动画
// 例如 [...[1, 2, 3], ...[1, 3, 4]] 。那么 2 会收起，4会展开。
// 如果父节点正在执行收起/展开逻辑，子节点不需要出现在 currentExpandKeys 数组。
newState_1.currentExpandKeys = __spreadArray(__spreadArray([], __read(newState_1.expandedKeys), false), __read(this.state.expandedKeys), false).reduce(function (total, next) {
var index = total.indexOf(next);
if (index === -1) {
total.push(next);
}
else {
total.splice(index, 1);
}
return total;
}, [])
.filter(function (key, _, array) {
var _a;
if (_this.key2nodeProps[key]) {
var pathParentKeys = _this.key2nodeProps[key].pathParentKeys;
if (pathParentKeys.some(function (x) { return array.indexOf(x) > -1; })) {
return false;
}
return (_a = _this.key2nodeProps[key].children) === null || _a === void 0 ? void 0 : _a.length;
}
});
}
var currentExpandKeys = newState_1.currentExpandKeys || this.state.currentExpandKeys;
if (newState_1.treeData && currentExpandKeys) {
newState_1.currentExpandKeys = currentExpandKeys.filter(function (key) {
var item = newState_1.treeData.find(function (node) { return node._key === key; });
return item && item.children && item.children.length;
});
}
if (Object.keys(newState_1).length) {
this.setState(newState_1);
}
}
};
Tree.prototype.render = function () {
var _a;
var _this = this;
// render 之前重置掉，在NodeList里会进行赋值。
this.cacheNodes = {};
var _b = this.getMergedProps(), className = _b.className, showLine = _b.showLine, size = _b.size, _virtualListProps = _b.virtualListProps, height = _b.height, style = _b.style, icons = _b.icons;
var _c = this.props, loadMore = _c.loadMore, checkable = _c.checkable;
// 兼容旧 APi : height
var virtualListProps = _virtualListProps
? __assign({ threshold: 100 }, _virtualListProps) : height
? { height: height, threshold: 100 }
: {
threshold: null,
};
var getPrefixCls = this.context.getPrefixCls;
var prefixCls = getPrefixCls('tree');
return (React.createElement(TreeContext.Provider, { value: {
icons: icons,
key2nodeProps: this.key2nodeProps,
getFieldInfo: this.getFieldInfo,
getTreeState: this.getTreeState,
getNodeProps: this.getNodeProps,
onExpandEnd: this.handleExpandEnd,
onSelect: this.handleSelect,
onCheck: this.handleCheck,
onNodeDragStart: this.handleNodeDragStart,
onNodeDragEnd: this.handleNodeDragEnd,
onNodeDragLeave: this.handleNodeDragLeave,
onNodeDragOver: this.handleNodeDragOver,
onNodeDrop: this.handleNodeDrop,
onExpand: this.handleExpand,
renderExtra: this.props.renderExtra,
renderTitle: this.props.renderTitle,
loadMore: loadMore && this.handleLoadMore,
allowDrop: this.handleAllowDrop,
virtualListProps: virtualListProps,
} },
React.createElement(NodeList, { ref: function (node) {
_this.nodeListRef = node;
}, className: cs(prefixCls, (_a = {},
_a[prefixCls + "-checkable"] = checkable,
_a[prefixCls + "-show-line"] = showLine,
_a[prefixCls + "-size-" + size] = size,
_a), className), style: style, filterNode: this.props.filterNode, virtualListProps: virtualListProps, expandedKeys: this.state.expandedKeys, currentExpandKeys: this.state.currentExpandKeys, getNodeProps: this.getNodeProps, nodeList: this.state.nodeList, saveCacheNode: function (node) {
_this.cacheNodes[node.key] = node;
} })));
};
Tree.displayName = 'Tree';
Tree.SHOW_PARENT = 'parent';
Tree.SHOW_ALL = 'all';
Tree.SHOW_CHILD = 'child';
Tree.Node = Node;
Tree.contextType = ConfigContext;
return Tree;
}(Component));
export default Tree;