1
This commit is contained in:
+17
@@ -0,0 +1,17 @@
|
||||
import type { BasicDataNode, DataNode, GetCheckDisabled, Key, KeyEntities } from '../interface';
|
||||
interface ConductReturnType {
|
||||
checkedKeys: Key[];
|
||||
halfCheckedKeys: Key[];
|
||||
}
|
||||
export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): boolean;
|
||||
/**
|
||||
* Conduct with keys.
|
||||
* @param keyList current key list
|
||||
* @param keyEntities key - dataEntity map
|
||||
* @param mode `fill` to fill missing key, `clean` to remove useless key
|
||||
*/
|
||||
export declare function conductCheck<TreeDataType extends BasicDataNode = DataNode>(keyList: Key[], checked: true | {
|
||||
checked: false;
|
||||
halfCheckedKeys: Key[];
|
||||
}, keyEntities: KeyEntities<TreeDataType>, getCheckDisabled?: GetCheckDisabled<TreeDataType>): ConductReturnType;
|
||||
export {};
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.conductCheck = conductCheck;
|
||||
exports.isCheckDisabled = isCheckDisabled;
|
||||
var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
|
||||
var _keyUtil = _interopRequireDefault(require("./keyUtil"));
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
|
||||
const filteredKeys = new Set();
|
||||
halfCheckedKeys.forEach(key => {
|
||||
if (!checkedKeys.has(key)) {
|
||||
filteredKeys.add(key);
|
||||
}
|
||||
});
|
||||
return filteredKeys;
|
||||
}
|
||||
function isCheckDisabled(node) {
|
||||
const {
|
||||
disabled,
|
||||
disableCheckbox,
|
||||
checkable
|
||||
} = node || {};
|
||||
return !!(disabled || disableCheckbox) || checkable === false;
|
||||
}
|
||||
|
||||
// Fill miss keys
|
||||
function fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
|
||||
const checkedKeys = new Set(keys);
|
||||
const halfCheckedKeys = new Set();
|
||||
|
||||
// Add checked keys top to bottom
|
||||
for (let level = 0; level <= maxLevel; level += 1) {
|
||||
const entities = levelEntities.get(level) || new Set();
|
||||
entities.forEach(entity => {
|
||||
const {
|
||||
key,
|
||||
node,
|
||||
children = []
|
||||
} = entity;
|
||||
if (checkedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
|
||||
children.filter(childEntity => !syntheticGetCheckDisabled(childEntity.node)).forEach(childEntity => {
|
||||
checkedKeys.add(childEntity.key);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Add checked keys from bottom to top
|
||||
const visitedKeys = new Set();
|
||||
for (let level = maxLevel; level >= 0; level -= 1) {
|
||||
const entities = levelEntities.get(level) || new Set();
|
||||
entities.forEach(entity => {
|
||||
const {
|
||||
parent,
|
||||
node
|
||||
} = entity;
|
||||
|
||||
// Skip if no need to check
|
||||
if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Skip if parent is disabled
|
||||
if (syntheticGetCheckDisabled(entity.parent.node)) {
|
||||
visitedKeys.add(parent.key);
|
||||
return;
|
||||
}
|
||||
let allChecked = true;
|
||||
let partialChecked = false;
|
||||
(parent.children || []).filter(childEntity => !syntheticGetCheckDisabled(childEntity.node)).forEach(({
|
||||
key
|
||||
}) => {
|
||||
const checked = checkedKeys.has(key);
|
||||
if (allChecked && !checked) {
|
||||
allChecked = false;
|
||||
}
|
||||
if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
|
||||
partialChecked = true;
|
||||
}
|
||||
});
|
||||
if (allChecked) {
|
||||
checkedKeys.add(parent.key);
|
||||
}
|
||||
if (partialChecked) {
|
||||
halfCheckedKeys.add(parent.key);
|
||||
}
|
||||
visitedKeys.add(parent.key);
|
||||
});
|
||||
}
|
||||
return {
|
||||
checkedKeys: Array.from(checkedKeys),
|
||||
halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
|
||||
};
|
||||
}
|
||||
|
||||
// Remove useless key
|
||||
function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
|
||||
const checkedKeys = new Set(keys);
|
||||
let halfCheckedKeys = new Set(halfKeys);
|
||||
|
||||
// Remove checked keys from top to bottom
|
||||
for (let level = 0; level <= maxLevel; level += 1) {
|
||||
const entities = levelEntities.get(level) || new Set();
|
||||
entities.forEach(entity => {
|
||||
const {
|
||||
key,
|
||||
node,
|
||||
children = []
|
||||
} = entity;
|
||||
if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
|
||||
children.filter(childEntity => !syntheticGetCheckDisabled(childEntity.node)).forEach(childEntity => {
|
||||
checkedKeys.delete(childEntity.key);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Remove checked keys form bottom to top
|
||||
halfCheckedKeys = new Set();
|
||||
const visitedKeys = new Set();
|
||||
for (let level = maxLevel; level >= 0; level -= 1) {
|
||||
const entities = levelEntities.get(level) || new Set();
|
||||
entities.forEach(entity => {
|
||||
const {
|
||||
parent,
|
||||
node
|
||||
} = entity;
|
||||
|
||||
// Skip if no need to check
|
||||
if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Skip if parent is disabled
|
||||
if (syntheticGetCheckDisabled(entity.parent.node)) {
|
||||
visitedKeys.add(parent.key);
|
||||
return;
|
||||
}
|
||||
let allChecked = true;
|
||||
let partialChecked = false;
|
||||
(parent.children || []).filter(childEntity => !syntheticGetCheckDisabled(childEntity.node)).forEach(({
|
||||
key
|
||||
}) => {
|
||||
const checked = checkedKeys.has(key);
|
||||
if (allChecked && !checked) {
|
||||
allChecked = false;
|
||||
}
|
||||
if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
|
||||
partialChecked = true;
|
||||
}
|
||||
});
|
||||
if (!allChecked) {
|
||||
checkedKeys.delete(parent.key);
|
||||
}
|
||||
if (partialChecked) {
|
||||
halfCheckedKeys.add(parent.key);
|
||||
}
|
||||
visitedKeys.add(parent.key);
|
||||
});
|
||||
}
|
||||
return {
|
||||
checkedKeys: Array.from(checkedKeys),
|
||||
halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Conduct with keys.
|
||||
* @param keyList current key list
|
||||
* @param keyEntities key - dataEntity map
|
||||
* @param mode `fill` to fill missing key, `clean` to remove useless key
|
||||
*/
|
||||
function conductCheck(keyList, checked, keyEntities, getCheckDisabled) {
|
||||
const warningMissKeys = [];
|
||||
let syntheticGetCheckDisabled;
|
||||
if (getCheckDisabled) {
|
||||
syntheticGetCheckDisabled = getCheckDisabled;
|
||||
} else {
|
||||
syntheticGetCheckDisabled = isCheckDisabled;
|
||||
}
|
||||
|
||||
// We only handle exist keys
|
||||
const keys = new Set(keyList.filter(key => {
|
||||
const hasEntity = !!(0, _keyUtil.default)(keyEntities, key);
|
||||
if (!hasEntity) {
|
||||
warningMissKeys.push(key);
|
||||
}
|
||||
return hasEntity;
|
||||
}));
|
||||
const levelEntities = new Map();
|
||||
let maxLevel = 0;
|
||||
|
||||
// Convert entities by level for calculation
|
||||
Object.keys(keyEntities).forEach(key => {
|
||||
const entity = keyEntities[key];
|
||||
const {
|
||||
level
|
||||
} = entity;
|
||||
let levelSet = levelEntities.get(level);
|
||||
if (!levelSet) {
|
||||
levelSet = new Set();
|
||||
levelEntities.set(level, levelSet);
|
||||
}
|
||||
levelSet.add(entity);
|
||||
maxLevel = Math.max(maxLevel, level);
|
||||
});
|
||||
(0, _warning.default)(!warningMissKeys.length, `Tree missing follow keys: ${warningMissKeys.slice(0, 100).map(key => `'${key}'`).join(', ')}`);
|
||||
let result;
|
||||
if (checked === true) {
|
||||
result = fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled);
|
||||
} else {
|
||||
result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel, syntheticGetCheckDisabled);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
/// <reference types="react" />
|
||||
import type { Key, FlattenNode } from '../interface';
|
||||
export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
|
||||
add: boolean;
|
||||
key: import("react").Key;
|
||||
};
|
||||
export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode<import("../interface").DataNode>[];
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.findExpandedKeys = findExpandedKeys;
|
||||
exports.getExpandRange = getExpandRange;
|
||||
function findExpandedKeys(prev = [], next = []) {
|
||||
const prevLen = prev.length;
|
||||
const nextLen = next.length;
|
||||
if (Math.abs(prevLen - nextLen) !== 1) {
|
||||
return {
|
||||
add: false,
|
||||
key: null
|
||||
};
|
||||
}
|
||||
function find(shorter, longer) {
|
||||
const cache = new Map();
|
||||
shorter.forEach(key => {
|
||||
cache.set(key, true);
|
||||
});
|
||||
const keys = longer.filter(key => !cache.has(key));
|
||||
return keys.length === 1 ? keys[0] : null;
|
||||
}
|
||||
if (prevLen < nextLen) {
|
||||
return {
|
||||
add: true,
|
||||
key: find(prev, next)
|
||||
};
|
||||
}
|
||||
return {
|
||||
add: false,
|
||||
key: find(next, prev)
|
||||
};
|
||||
}
|
||||
function getExpandRange(shorter, longer, key) {
|
||||
const shorterStartIndex = shorter.findIndex(data => data.key === key);
|
||||
const shorterEndNode = shorter[shorterStartIndex + 1];
|
||||
const longerStartIndex = longer.findIndex(data => data.key === key);
|
||||
if (shorterEndNode) {
|
||||
const longerEndIndex = longer.findIndex(data => data.key === shorterEndNode.key);
|
||||
return longer.slice(longerStartIndex + 1, longerEndIndex);
|
||||
}
|
||||
return longer.slice(longerStartIndex + 1);
|
||||
}
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
import type { Key, KeyEntities } from '../interface';
|
||||
export default function getEntity<T = any>(keyEntities: KeyEntities<T>, key: Key): import("../interface").DataEntity<T>;
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = getEntity;
|
||||
function getEntity(keyEntities, key) {
|
||||
return keyEntities[key];
|
||||
}
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
import * as React from 'react';
|
||||
import type { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key, KeyEntities, NodeElement, TreeNodeProps } from '../interface';
|
||||
export declare function getPosition(level: string | number, index: number): string;
|
||||
export declare function isTreeNode(node: NodeElement): boolean;
|
||||
export declare function getKey(key: Key, pos: string): React.Key;
|
||||
export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
|
||||
/**
|
||||
* Warning if TreeNode do not provides key
|
||||
*/
|
||||
export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): void;
|
||||
/**
|
||||
* Convert `children` of Tree into `treeData` structure.
|
||||
*/
|
||||
export declare function convertTreeToData(rootNodes: React.ReactNode): DataNode[];
|
||||
/**
|
||||
* Flat nest tree data into flatten list. This is used for virtual list render.
|
||||
* @param treeNodeList Origin data node list
|
||||
* @param expandedKeys
|
||||
* need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
|
||||
*/
|
||||
export declare function flattenTreeData<TreeDataType extends BasicDataNode = DataNode>(treeNodeList: TreeDataType[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode<TreeDataType>[];
|
||||
type ExternalGetKey = GetKey<DataNode> | string;
|
||||
interface TraverseDataNodesConfig {
|
||||
childrenPropName?: string;
|
||||
externalGetKey?: ExternalGetKey;
|
||||
fieldNames?: FieldNames;
|
||||
}
|
||||
/**
|
||||
* Traverse all the data by `treeData`.
|
||||
* Please not use it out of the `rc-tree` since we may refactor this code.
|
||||
*/
|
||||
export declare function traverseDataNodes(dataNodes: DataNode[], callback: (data: {
|
||||
node: DataNode;
|
||||
index: number;
|
||||
pos: string;
|
||||
key: Key;
|
||||
parentPos: string | number;
|
||||
level: number;
|
||||
nodes: DataNode[];
|
||||
}) => void, config?: TraverseDataNodesConfig | string): void;
|
||||
interface Wrapper {
|
||||
posEntities: Record<string, DataEntity>;
|
||||
keyEntities: KeyEntities;
|
||||
}
|
||||
/**
|
||||
* Convert `treeData` into entity records.
|
||||
*/
|
||||
export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
|
||||
initWrapper?: (wrapper: Wrapper) => Wrapper;
|
||||
processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
|
||||
onProcessFinished?: (wrapper: Wrapper) => void;
|
||||
externalGetKey?: ExternalGetKey;
|
||||
childrenPropName?: string;
|
||||
fieldNames?: FieldNames;
|
||||
},
|
||||
/** @deprecated Use `config.externalGetKey` instead */
|
||||
legacyExternalGetKey?: ExternalGetKey): Wrapper;
|
||||
export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
|
||||
expandedKeys: Key[];
|
||||
selectedKeys: Key[];
|
||||
loadedKeys: Key[];
|
||||
loadingKeys: Key[];
|
||||
checkedKeys: Key[];
|
||||
halfCheckedKeys: Key[];
|
||||
dragOverNodeKey: Key;
|
||||
dropPosition: number;
|
||||
keyEntities: KeyEntities<TreeDataType>;
|
||||
}
|
||||
export declare function isLeafNode<TreeDataType extends BasicDataNode = DataNode>(isLeaf: boolean | undefined, loadData: ((node: EventDataNode<TreeDataType>) => Promise<any>) | undefined, hasChildren: boolean, loaded: boolean): boolean;
|
||||
/**
|
||||
* Get TreeNode props with Tree props.
|
||||
*/
|
||||
export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps<TreeDataType>): {
|
||||
eventKey: React.Key;
|
||||
expanded: boolean;
|
||||
selected: boolean;
|
||||
loaded: boolean;
|
||||
loading: boolean;
|
||||
checked: boolean;
|
||||
halfChecked: boolean;
|
||||
pos: string;
|
||||
dragOver: boolean;
|
||||
dragOverGapTop: boolean;
|
||||
dragOverGapBottom: boolean;
|
||||
};
|
||||
export declare function convertNodePropsToEventData<TreeDataType extends BasicDataNode = DataNode>(props: TreeNodeProps<TreeDataType>): EventDataNode<TreeDataType>;
|
||||
export {};
|
||||
+377
@@ -0,0 +1,377 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.convertDataToEntities = convertDataToEntities;
|
||||
exports.convertNodePropsToEventData = convertNodePropsToEventData;
|
||||
exports.convertTreeToData = convertTreeToData;
|
||||
exports.fillFieldNames = fillFieldNames;
|
||||
exports.flattenTreeData = flattenTreeData;
|
||||
exports.getKey = getKey;
|
||||
exports.getPosition = getPosition;
|
||||
exports.getTreeNodeProps = getTreeNodeProps;
|
||||
exports.isLeafNode = isLeafNode;
|
||||
exports.isTreeNode = isTreeNode;
|
||||
exports.traverseDataNodes = traverseDataNodes;
|
||||
exports.warningWithoutKey = warningWithoutKey;
|
||||
var _toArray = _interopRequireDefault(require("@rc-component/util/lib/Children/toArray"));
|
||||
var _omit = _interopRequireDefault(require("@rc-component/util/lib/omit"));
|
||||
var _warning = _interopRequireDefault(require("@rc-component/util/lib/warning"));
|
||||
var _keyUtil = _interopRequireDefault(require("./keyUtil"));
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
function getPosition(level, index) {
|
||||
return `${level}-${index}`;
|
||||
}
|
||||
function isTreeNode(node) {
|
||||
return node && node.type && node.type.isTreeNode;
|
||||
}
|
||||
function getKey(key, pos) {
|
||||
if (key !== null && key !== undefined) {
|
||||
return key;
|
||||
}
|
||||
return pos;
|
||||
}
|
||||
function fillFieldNames(fieldNames) {
|
||||
const {
|
||||
title,
|
||||
_title,
|
||||
key,
|
||||
children
|
||||
} = fieldNames || {};
|
||||
const mergedTitle = title || 'title';
|
||||
return {
|
||||
title: mergedTitle,
|
||||
_title: _title || [mergedTitle],
|
||||
key: key || 'key',
|
||||
children: children || 'children'
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Warning if TreeNode do not provides key
|
||||
*/
|
||||
function warningWithoutKey(treeData, fieldNames) {
|
||||
const keys = new Map();
|
||||
function dig(list, path = '') {
|
||||
(list || []).forEach(treeNode => {
|
||||
const key = treeNode[fieldNames.key];
|
||||
const children = treeNode[fieldNames.children];
|
||||
(0, _warning.default)(key !== null && key !== undefined, `Tree node must have a certain key: [${path}${key}]`);
|
||||
const recordKey = String(key);
|
||||
(0, _warning.default)(!keys.has(recordKey) || key === null || key === undefined, `Same 'key' exist in the Tree: ${recordKey}`);
|
||||
keys.set(recordKey, true);
|
||||
dig(children, `${path}${recordKey} > `);
|
||||
});
|
||||
}
|
||||
dig(treeData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert `children` of Tree into `treeData` structure.
|
||||
*/
|
||||
function convertTreeToData(rootNodes) {
|
||||
function dig(node) {
|
||||
const treeNodes = (0, _toArray.default)(node);
|
||||
return treeNodes.map(treeNode => {
|
||||
// Filter invalidate node
|
||||
if (!isTreeNode(treeNode)) {
|
||||
(0, _warning.default)(!treeNode, 'Tree/TreeNode can only accept TreeNode as children.');
|
||||
return null;
|
||||
}
|
||||
const {
|
||||
key
|
||||
} = treeNode;
|
||||
const {
|
||||
children,
|
||||
...rest
|
||||
} = treeNode.props;
|
||||
const dataNode = {
|
||||
key: key,
|
||||
...rest
|
||||
};
|
||||
const parsedChildren = dig(children);
|
||||
if (parsedChildren.length) {
|
||||
dataNode.children = parsedChildren;
|
||||
}
|
||||
return dataNode;
|
||||
}).filter(dataNode => dataNode);
|
||||
}
|
||||
return dig(rootNodes);
|
||||
}
|
||||
|
||||
/**
|
||||
* Flat nest tree data into flatten list. This is used for virtual list render.
|
||||
* @param treeNodeList Origin data node list
|
||||
* @param expandedKeys
|
||||
* need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
|
||||
*/
|
||||
function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
|
||||
const {
|
||||
_title: fieldTitles,
|
||||
key: fieldKey,
|
||||
children: fieldChildren
|
||||
} = fillFieldNames(fieldNames);
|
||||
const expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
|
||||
const flattenList = [];
|
||||
function dig(list, parent = null) {
|
||||
return list.map((treeNode, index) => {
|
||||
const pos = getPosition(parent ? parent.pos : '0', index);
|
||||
const mergedKey = getKey(treeNode[fieldKey], pos);
|
||||
|
||||
// Pick matched title in field title list
|
||||
let mergedTitle;
|
||||
for (let i = 0; i < fieldTitles.length; i += 1) {
|
||||
const fieldTitle = fieldTitles[i];
|
||||
if (treeNode[fieldTitle] !== undefined) {
|
||||
mergedTitle = treeNode[fieldTitle];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Add FlattenDataNode into list
|
||||
// We use `Object.assign` here to save perf since babel's `objectSpread` has perf issue
|
||||
const flattenNode = Object.assign((0, _omit.default)(treeNode, [...fieldTitles, fieldKey, fieldChildren]), {
|
||||
title: mergedTitle,
|
||||
key: mergedKey,
|
||||
parent,
|
||||
pos,
|
||||
children: null,
|
||||
data: treeNode,
|
||||
isStart: [...(parent ? parent.isStart : []), index === 0],
|
||||
isEnd: [...(parent ? parent.isEnd : []), index === list.length - 1]
|
||||
});
|
||||
flattenList.push(flattenNode);
|
||||
|
||||
// Loop treeNode children
|
||||
if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
|
||||
flattenNode.children = dig(treeNode[fieldChildren] || [], flattenNode);
|
||||
} else {
|
||||
flattenNode.children = [];
|
||||
}
|
||||
return flattenNode;
|
||||
});
|
||||
}
|
||||
dig(treeNodeList);
|
||||
return flattenList;
|
||||
}
|
||||
/**
|
||||
* Traverse all the data by `treeData`.
|
||||
* Please not use it out of the `rc-tree` since we may refactor this code.
|
||||
*/
|
||||
function traverseDataNodes(dataNodes, callback,
|
||||
// To avoid too many params, let use config instead of origin param
|
||||
config) {
|
||||
let mergedConfig = {};
|
||||
if (typeof config === 'object') {
|
||||
mergedConfig = config;
|
||||
} else {
|
||||
mergedConfig = {
|
||||
externalGetKey: config
|
||||
};
|
||||
}
|
||||
mergedConfig = mergedConfig || {};
|
||||
|
||||
// Init config
|
||||
const {
|
||||
childrenPropName,
|
||||
externalGetKey,
|
||||
fieldNames
|
||||
} = mergedConfig;
|
||||
const {
|
||||
key: fieldKey,
|
||||
children: fieldChildren
|
||||
} = fillFieldNames(fieldNames);
|
||||
const mergeChildrenPropName = childrenPropName || fieldChildren;
|
||||
|
||||
// Get keys
|
||||
let syntheticGetKey;
|
||||
if (externalGetKey) {
|
||||
if (typeof externalGetKey === 'string') {
|
||||
syntheticGetKey = node => node[externalGetKey];
|
||||
} else if (typeof externalGetKey === 'function') {
|
||||
syntheticGetKey = node => externalGetKey(node);
|
||||
}
|
||||
} else {
|
||||
syntheticGetKey = (node, pos) => getKey(node[fieldKey], pos);
|
||||
}
|
||||
|
||||
// Process
|
||||
function processNode(node, index, parent, pathNodes) {
|
||||
const children = node ? node[mergeChildrenPropName] : dataNodes;
|
||||
const pos = node ? getPosition(parent.pos, index) : '0';
|
||||
const connectNodes = node ? [...pathNodes, node] : [];
|
||||
|
||||
// Process node if is not root
|
||||
if (node) {
|
||||
const key = syntheticGetKey(node, pos);
|
||||
const data = {
|
||||
node,
|
||||
index,
|
||||
pos,
|
||||
key,
|
||||
parentPos: parent.node ? parent.pos : null,
|
||||
level: parent.level + 1,
|
||||
nodes: connectNodes
|
||||
};
|
||||
callback(data);
|
||||
}
|
||||
|
||||
// Process children node
|
||||
if (children) {
|
||||
children.forEach((subNode, subIndex) => {
|
||||
processNode(subNode, subIndex, {
|
||||
node,
|
||||
pos,
|
||||
level: parent ? parent.level + 1 : -1
|
||||
}, connectNodes);
|
||||
});
|
||||
}
|
||||
}
|
||||
processNode(null);
|
||||
}
|
||||
/**
|
||||
* Convert `treeData` into entity records.
|
||||
*/
|
||||
function convertDataToEntities(dataNodes, {
|
||||
initWrapper,
|
||||
processEntity,
|
||||
onProcessFinished,
|
||||
externalGetKey,
|
||||
childrenPropName,
|
||||
fieldNames
|
||||
} = {}, /** @deprecated Use `config.externalGetKey` instead */
|
||||
legacyExternalGetKey) {
|
||||
// Init config
|
||||
const mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
|
||||
const posEntities = {};
|
||||
const keyEntities = {};
|
||||
let wrapper = {
|
||||
posEntities,
|
||||
keyEntities
|
||||
};
|
||||
if (initWrapper) {
|
||||
wrapper = initWrapper(wrapper) || wrapper;
|
||||
}
|
||||
traverseDataNodes(dataNodes, item => {
|
||||
const {
|
||||
node,
|
||||
index,
|
||||
pos,
|
||||
key,
|
||||
parentPos,
|
||||
level,
|
||||
nodes
|
||||
} = item;
|
||||
const entity = {
|
||||
node,
|
||||
nodes,
|
||||
index,
|
||||
key,
|
||||
pos,
|
||||
level
|
||||
};
|
||||
const mergedKey = getKey(key, pos);
|
||||
posEntities[pos] = entity;
|
||||
keyEntities[mergedKey] = entity;
|
||||
|
||||
// Fill children
|
||||
entity.parent = posEntities[parentPos];
|
||||
if (entity.parent) {
|
||||
entity.parent.children = entity.parent.children || [];
|
||||
entity.parent.children.push(entity);
|
||||
}
|
||||
if (processEntity) {
|
||||
processEntity(entity, wrapper);
|
||||
}
|
||||
}, {
|
||||
externalGetKey: mergedExternalGetKey,
|
||||
childrenPropName,
|
||||
fieldNames
|
||||
});
|
||||
if (onProcessFinished) {
|
||||
onProcessFinished(wrapper);
|
||||
}
|
||||
return wrapper;
|
||||
}
|
||||
function isLeafNode(isLeaf, loadData, hasChildren, loaded) {
|
||||
if (isLeaf === false) {
|
||||
return false;
|
||||
}
|
||||
return isLeaf || !loadData && !hasChildren || loadData && loaded && !hasChildren;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get TreeNode props with Tree props.
|
||||
*/
|
||||
function getTreeNodeProps(key, {
|
||||
expandedKeys,
|
||||
selectedKeys,
|
||||
loadedKeys,
|
||||
loadingKeys,
|
||||
checkedKeys,
|
||||
halfCheckedKeys,
|
||||
dragOverNodeKey,
|
||||
dropPosition,
|
||||
keyEntities
|
||||
}) {
|
||||
const entity = (0, _keyUtil.default)(keyEntities, key);
|
||||
const treeNodeProps = {
|
||||
eventKey: key,
|
||||
expanded: expandedKeys.indexOf(key) !== -1,
|
||||
selected: selectedKeys.indexOf(key) !== -1,
|
||||
loaded: loadedKeys.indexOf(key) !== -1,
|
||||
loading: loadingKeys.indexOf(key) !== -1,
|
||||
checked: checkedKeys.indexOf(key) !== -1,
|
||||
halfChecked: halfCheckedKeys.indexOf(key) !== -1,
|
||||
pos: String(entity ? entity.pos : ''),
|
||||
// [Legacy] Drag props
|
||||
// Since the interaction of drag is changed, the semantic of the props are
|
||||
// not accuracy, I think it should be finally removed
|
||||
dragOver: dragOverNodeKey === key && dropPosition === 0,
|
||||
dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
|
||||
dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
|
||||
};
|
||||
return treeNodeProps;
|
||||
}
|
||||
function convertNodePropsToEventData(props) {
|
||||
const {
|
||||
data,
|
||||
expanded,
|
||||
selected,
|
||||
checked,
|
||||
loaded,
|
||||
loading,
|
||||
halfChecked,
|
||||
dragOver,
|
||||
dragOverGapTop,
|
||||
dragOverGapBottom,
|
||||
pos,
|
||||
active,
|
||||
eventKey
|
||||
} = props;
|
||||
const eventData = {
|
||||
...data,
|
||||
expanded,
|
||||
selected,
|
||||
checked,
|
||||
loaded,
|
||||
loading,
|
||||
halfChecked,
|
||||
dragOver,
|
||||
dragOverGapTop,
|
||||
dragOverGapBottom,
|
||||
pos,
|
||||
active,
|
||||
key: eventKey
|
||||
};
|
||||
if (!('props' in eventData)) {
|
||||
Object.defineProperty(eventData, 'props', {
|
||||
get() {
|
||||
(0, _warning.default)(false, 'Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.');
|
||||
return props;
|
||||
}
|
||||
});
|
||||
}
|
||||
return eventData;
|
||||
}
|
||||
Reference in New Issue
Block a user