choerodon-ui
Version:
An enterprise-class UI design language and React-based implementation
322 lines (280 loc) • 8.99 kB
JavaScript
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _typeof from "@babel/runtime/helpers/typeof";
import _extends from "@babel/runtime/helpers/extends";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
var _excluded = ["children"];
/* eslint-disable no-lonely-if */
/**
* Legacy code. Should avoid to use if you are new to import these code.
*/
import React from 'react';
import warning from '../../_util/warning';
import TreeNode from './TreeNode';
export function arrDel(list, value) {
var clone = list.slice();
if (value !== undefined && value !== null) {
var index = clone.indexOf(value);
if (index >= 0) {
clone.splice(index, 1);
}
}
return clone;
}
export function arrAdd(list, value) {
var clone = list.slice();
if (value !== undefined && value !== null) {
if (clone.indexOf(value) === -1) {
clone.push(value);
}
}
return clone;
}
export function posToArr(pos) {
return pos.split('-');
}
export function getPosition(level, index) {
return "".concat(level, "-").concat(index);
}
export function isTreeNode(node) {
return node && node.type && node.type.isTreeNode;
}
export function getDragChildrenKeys(dragNodeKey, keyEntities) {
// not contains self
// self for left or right drag
var dragChildrenKeys = [];
var entity = keyEntities[dragNodeKey];
function dig() {
var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
list.forEach(function (_ref) {
var key = _ref.key,
children = _ref.children;
dragChildrenKeys.push(key);
dig(children);
});
}
dig(entity.children);
return dragChildrenKeys;
}
export function isLastChild(treeNodeEntity) {
if (treeNodeEntity.parent) {
var posArr = posToArr(treeNodeEntity.pos);
return Number(posArr[posArr.length - 1]) === treeNodeEntity.parent.children.length - 1;
}
return false;
}
export function isFirstChild(treeNodeEntity) {
var posArr = posToArr(treeNodeEntity.pos);
return Number(posArr[posArr.length - 1]) === 0;
} // Only used when drag, not affect SSR.
export function calcDropPosition(event, targetNode, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, direction) {
var clientX = event.clientX,
clientY = event.clientY;
var _event$target$getBoun = event.target.getBoundingClientRect(),
top = _event$target$getBoun.top,
height = _event$target$getBoun.height; // optional chain for testing
var horizontalMouseOffset = (direction === 'rtl' ? -1 : 1) * ((startMousePosition && startMousePosition.x || 0) - clientX);
var rawDropLevelOffset = (horizontalMouseOffset - 12) / indent; // find abstract drop node by horizontal offset
var abstractDropNodeEntity = keyEntities[targetNode.props.eventKey];
if (clientY < top + height / 2) {
// first half, set abstract drop node to previous node
var nodeIndex = flattenedNodes.findIndex(function (flattenedNode) {
return flattenedNode.data.key === abstractDropNodeEntity.key;
});
var prevNodeIndex = nodeIndex <= 0 ? 0 : nodeIndex - 1;
var prevNodeKey = flattenedNodes[prevNodeIndex].data.key;
abstractDropNodeEntity = keyEntities[prevNodeKey];
}
var abstractDragOverEntity = abstractDropNodeEntity;
var dragOverNodeKey = abstractDropNodeEntity.key;
var dropPosition = 0;
var dropLevelOffset = 0;
for (var i = 0; i < rawDropLevelOffset; i += 1) {
if (isLastChild(abstractDropNodeEntity)) {
abstractDropNodeEntity = abstractDropNodeEntity.parent;
dropLevelOffset += 1;
} else {
break;
}
}
var abstractDropDataNode = abstractDropNodeEntity.node;
var dropAllowed = true;
if (isFirstChild(abstractDropNodeEntity) && abstractDropNodeEntity.level === 0 && clientY < top + height / 2 && allowDrop({
dropNode: abstractDropDataNode,
dropPosition: -1
}) && abstractDropNodeEntity.key === targetNode.props.eventKey) {
// first half of first node in first level
dropPosition = -1;
} else if ((abstractDragOverEntity.children || []).length) {
// drop on expanded node
// only allow drop inside
if (allowDrop({
dropNode: abstractDropDataNode,
dropPosition: 0
})) {
dropPosition = 0;
} else {
dropAllowed = false;
}
} else if (dropLevelOffset === 0) {
var dropOffsetY = Math.abs((startMousePosition && startMousePosition.y || 0) - clientY);
if (dropOffsetY < height || clientY < top + height / 2) {
// | Node | <- abstractDropNode
// | -^-===== | <- mousePosition
// 1. try drop after
// 2. do not allow drop
if (allowDrop({
dropNode: abstractDropDataNode,
dropPosition: 1
})) {
dropPosition = 1;
} else {
dropAllowed = false;
}
} else {
// | Node | <- abstractDropNode
// | ---==^== | <- mousePosition
// whether it has children or doesn't has children
// always
// 1. try drop inside
// 2. try drop after
// 3. do not allow drop
if (allowDrop({
dropNode: abstractDropDataNode,
dropPosition: 0
})) {
dropPosition = 0;
} else if (allowDrop({
dropNode: abstractDropDataNode,
dropPosition: 1
})) {
dropPosition = 1;
} else {
dropAllowed = false;
}
}
} else {
// | Node1 | <- abstractDropNode
// | Node2 |
// --^--|----=====| <- mousePosition
// 1. try insert after Node1
// 2. do not allow drop
if (allowDrop({
dropNode: abstractDropDataNode,
dropPosition: 1
})) {
dropPosition = 1;
} else {
dropAllowed = false;
}
}
var _abstractDropNodeEnti = abstractDropNodeEntity,
dropTargetKey = _abstractDropNodeEnti.key,
dropTargetPos = _abstractDropNodeEnti.pos,
parent = _abstractDropNodeEnti.parent;
return {
dropPosition: dropPosition,
dropLevelOffset: dropLevelOffset,
dropTargetKey: dropTargetKey,
dropTargetPos: dropTargetPos,
dragOverNodeKey: dragOverNodeKey,
dropContainerKey: dropPosition === 0 ? null : parent && parent.key || null,
dropAllowed: dropAllowed
};
}
/**
* Return selectedKeys according with multiple prop
* @param selectedKeys
* @param props
* @returns [string]
*/
export function calcSelectedKeys(selectedKeys, props) {
if (!selectedKeys) return undefined;
var multiple = props.multiple;
if (multiple) {
return selectedKeys.slice();
}
if (selectedKeys.length) {
return [selectedKeys[0]];
}
return selectedKeys;
}
var internalProcessProps = function internalProcessProps(props) {
return props;
};
export function convertDataToTree(treeData, processor) {
if (!treeData) return [];
var _ref2 = processor || {},
_ref2$processProps = _ref2.processProps,
processProps = _ref2$processProps === void 0 ? internalProcessProps : _ref2$processProps;
var list = Array.isArray(treeData) ? treeData : [treeData];
return list.map(function (_ref3) {
var children = _ref3.children,
props = _objectWithoutProperties(_ref3, _excluded);
var childrenNodes = convertDataToTree(children, processor);
return /*#__PURE__*/React.createElement(TreeNode, _extends({
key: props.key
}, processProps(props)), childrenNodes);
});
}
/**
* Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
*/
export function parseCheckedKeys(keys) {
if (!keys) {
return null;
} // Convert keys to object format
var keyProps;
if (Array.isArray(keys)) {
// [Legacy] Follow the api doc
keyProps = {
checkedKeys: keys,
halfCheckedKeys: undefined
};
} else if (_typeof(keys) === 'object') {
keyProps = {
checkedKeys: keys.checked || undefined,
halfCheckedKeys: keys.halfChecked || undefined
};
} else {
warning(false, '`checkedKeys` is not an array or an object');
return null;
}
return keyProps;
}
/**
* If user use `autoExpandParent` we should get the list of parent node
* @param keyList
* @param keyEntities
*/
export function conductExpandParent(keyList, keyEntities) {
var expandedKeys = new Set();
function conductUp(key) {
if (expandedKeys.has(key)) return;
var entity = keyEntities[key];
if (!entity) return;
expandedKeys.add(key);
var parent = entity.parent,
node = entity.node;
if (node.disabled) return;
if (parent) {
conductUp(parent.key);
}
}
(keyList || []).forEach(function (key) {
conductUp(key);
});
return _toConsumableArray(expandedKeys);
}
/**
* Returns only the data- and aria- key/value pairs
*/
export function getDataAndAria(props) {
var omitProps = {};
Object.keys(props).forEach(function (key) {
if (key.startsWith('data-') || key.startsWith('aria-')) {
omitProps[key] = props[key];
}
});
return omitProps;
}
//# sourceMappingURL=util.js.map