ant-design-vue
Version:
An enterprise-class UI design language and Vue-based implementation
652 lines (593 loc) • 18.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.UNSELECTABLE_ATTRIBUTE = exports.UNSELECTABLE_STYLE = undefined;
var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
var _defineProperty3 = _interopRequireDefault(_defineProperty2);
var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');
var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
var _extends2 = require('babel-runtime/helpers/extends');
var _extends3 = _interopRequireDefault(_extends2);
exports.toTitle = toTitle;
exports.getValuePropValue = getValuePropValue;
exports.getPropValue = getPropValue;
exports.isMultiple = isMultiple;
exports.toArray = toArray;
exports.preventDefaultEvent = preventDefaultEvent;
exports.labelCompatible = labelCompatible;
exports.isInclude = isInclude;
exports.isPositionPrefix = isPositionPrefix;
exports.loopAllChildren = loopAllChildren;
exports.flatToHierarchy = flatToHierarchy;
exports.filterParentPosition = filterParentPosition;
exports.handleCheckState = handleCheckState;
exports.getTreeNodesStates = getTreeNodesStates;
exports.recursiveCloneChildren = recursiveCloneChildren;
exports.filterAllCheckedData = filterAllCheckedData;
exports.processSimpleTreeData = processSimpleTreeData;
exports.saveRef = saveRef;
var _propsUtil = require('../../_util/props-util');
var _vnode = require('../../_util/vnode');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
function toTitle(title) {
if (typeof title === 'string') {
return title;
}
return null;
}
function getValuePropValue(child) {
var props = (0, _propsUtil.getAllProps)(child);
if ('value' in props) {
return props.value;
}
if ((0, _propsUtil.getKey)(child) !== undefined) {
return (0, _propsUtil.getKey)(child);
}
throw new Error('no key or value for ' + child);
}
function getPropValue(child, prop) {
if (prop === 'value') {
return getValuePropValue(child);
}
var slots = (0, _propsUtil.getSlots)(child);
if (prop === 'children') {
var newChild = child.$slots ? (0, _vnode.cloneVNodes)(child.$slots['default'], true) : (0, _vnode.cloneVNodes)(child.componentOptions.children, true);
if (newChild.length === 1 && !newChild[0].tag) {
return newChild[0].text;
}
return newChild;
}
if (slots[prop]) {
return (0, _vnode.cloneVNodes)(slots[prop], true);
}
var data = (0, _propsUtil.getPropsData)(child);
if (prop in data) {
return data[prop];
} else {
return (0, _propsUtil.getAttrs)(child)[prop];
}
}
function isMultiple(props) {
return !!(props.multiple || props.treeCheckable);
}
function toArray(value) {
var ret = value;
if (value === undefined) {
ret = [];
} else if (!Array.isArray(value)) {
ret = [value];
}
return ret;
}
function preventDefaultEvent(e) {
e.preventDefault();
}
var UNSELECTABLE_STYLE = exports.UNSELECTABLE_STYLE = {
userSelect: 'none',
WebkitUserSelect: 'none'
};
var UNSELECTABLE_ATTRIBUTE = exports.UNSELECTABLE_ATTRIBUTE = {
unselectable: 'unselectable'
};
function labelCompatible(prop) {
var newProp = prop;
if (newProp === 'label') {
newProp = 'title';
}
return newProp;
}
function isInclude(smallArray, bigArray) {
// attention: [0,0,1] [0,0,10]
return smallArray.every(function (ii, i) {
return ii === bigArray[i];
});
}
function isPositionPrefix(smallPos, bigPos) {
if (!bigPos || !smallPos) {
// console.log(smallPos, bigPos);
return false;
}
if (bigPos.length < smallPos.length) {
return false;
}
// attention: "0-0-1" "0-0-10"
if (bigPos.length > smallPos.length && bigPos.charAt(smallPos.length) !== '-') {
return false;
}
return bigPos.substr(0, smallPos.length) === smallPos;
}
/*
export function getCheckedKeys(node, checkedKeys, allCheckedNodesKeys) {
const nodeKey = node.props.eventKey;
let newCks = [...checkedKeys];
let nodePos;
const unCheck = allCheckedNodesKeys.some(item => {
if (item.key === nodeKey) {
nodePos = item.pos;
return true;
}
});
if (unCheck) {
newCks = [];
allCheckedNodesKeys.forEach(item => {
if (isPositionPrefix(item.pos, nodePos) || isPositionPrefix(nodePos, item.pos)) {
return;
}
newCks.push(item.key);
});
} else {
newCks.push(nodeKey);
}
return newCks;
}
*/
function getChildrenlength(children) {
var len = 1;
if (Array.isArray(children)) {
len = children.length;
}
return len;
}
function getSiblingPosition(index, len, siblingPosition) {
if (len === 1) {
siblingPosition.first = true;
siblingPosition.last = true;
} else {
siblingPosition.first = index === 0;
siblingPosition.last = index === len - 1;
}
return siblingPosition;
}
function filterChild(childs) {
var newChilds = [];
childs.forEach(function (child) {
var options = (0, _propsUtil.getSlotOptions)(child);
if (options.__ANT_TREE_NODE || options.__ANT_TREE_SELECT_NODE) {
newChilds.push(child);
}
});
return newChilds;
}
function loopAllChildren(childs, callback, parent) {
var loop = function loop(children, level, _parent) {
var len = getChildrenlength(children);
children.forEach(function handler(item, index) {
// eslint-disable-line
var pos = level + '-' + index;
if (item && item.componentOptions && item.componentOptions.children) {
loop(filterChild(item.componentOptions.children), pos, { node: item, pos: pos });
}
if (item) {
callback(item, index, pos, item.key || pos, getSiblingPosition(index, len, {}), _parent);
}
});
};
loop(filterChild(childs), 0, parent);
}
// export function loopAllChildren(childs, callback) {
// const loop = (children, level) => {
// React.Children.forEach(children, (item, index) => {
// const pos = `${level}-${index}`;
// if (item && item.props.children) {
// loop(item.props.children, pos);
// }
// if (item) {
// callback(item, index, pos, getValuePropValue(item));
// }
// });
// };
// loop(childs, 0);
// }
// TODO: Here has the side effect. Update node children data affect.
function flatToHierarchy(arr) {
if (!arr.length) {
return arr;
}
var hierarchyNodes = [];
var levelObj = {};
arr.forEach(function (item) {
if (!item.pos) {
return;
}
var posLen = item.pos.split('-').length;
if (!levelObj[posLen]) {
levelObj[posLen] = [];
}
levelObj[posLen].push(item);
});
var levelArr = Object.keys(levelObj).sort(function (a, b) {
return b - a;
});
// const s = Date.now();
// todo: there are performance issues!
levelArr.reduce(function (pre, cur) {
if (cur && cur !== pre) {
levelObj[pre].forEach(function (item) {
var haveParent = false;
levelObj[cur].forEach(function (ii) {
if (isPositionPrefix(ii.pos, item.pos)) {
haveParent = true;
if (!ii.children) {
ii.children = [];
}
ii.children.push(item);
}
});
if (!haveParent) {
hierarchyNodes.push(item);
}
});
}
return cur;
});
// console.log(Date.now() - s);
return levelObj[levelArr[levelArr.length - 1]].concat(hierarchyNodes);
}
// arr.length === 628, use time: ~20ms
function filterParentPosition(arr) {
var levelObj = {};
arr.forEach(function (item) {
var posLen = item.split('-').length;
if (!levelObj[posLen]) {
levelObj[posLen] = [];
}
levelObj[posLen].push(item);
});
var levelArr = Object.keys(levelObj).sort();
var _loop = function _loop(i) {
if (levelArr[i + 1]) {
levelObj[levelArr[i]].forEach(function (ii) {
var _loop2 = function _loop2(j) {
levelObj[levelArr[j]].forEach(function (_i, index) {
if (isPositionPrefix(ii, _i)) {
levelObj[levelArr[j]][index] = null;
}
});
levelObj[levelArr[j]] = levelObj[levelArr[j]].filter(function (p) {
return p;
});
};
for (var j = i + 1; j < levelArr.length; j++) {
_loop2(j);
}
});
}
};
for (var i = 0; i < levelArr.length; i++) {
_loop(i);
}
var nArr = [];
levelArr.forEach(function (i) {
nArr = nArr.concat(levelObj[i]);
});
return nArr;
}
// console.log(filterParentPosition(
// ['0-2', '0-3-3', '0-10', '0-10-0', '0-0-1', '0-0', '0-1-1', '0-1']
// ));
function stripTail(str) {
var arr = str.match(/(.+)(-[^-]+)$/);
var st = '';
if (arr && arr.length === 3) {
st = arr[1];
}
return st;
}
function splitPosition(pos) {
return pos.split('-');
}
// todo: do optimization.
function handleCheckState(obj, checkedPositionArr, checkIt) {
// console.log(stripTail('0-101-000'));
// let s = Date.now();
var objKeys = Object.keys(obj);
objKeys.forEach(function (i, index) {
var iArr = splitPosition(i);
var saved = false;
checkedPositionArr.forEach(function (_pos) {
var _posArr = splitPosition(_pos);
if (iArr.length > _posArr.length && isInclude(_posArr, iArr)) {
obj[i].halfChecked = false;
obj[i].checked = checkIt;
objKeys[index] = null;
}
if (iArr[0] === _posArr[0] && iArr[1] === _posArr[1]) {
saved = true;
}
});
if (!saved) {
objKeys[index] = null;
}
});
objKeys = objKeys.filter(function (i) {
return i;
}); // filter non null;
var _loop3 = function _loop3(_pIndex) {
// loop to set ancestral nodes's `checked` or `halfChecked`
var loop = function loop(__pos) {
var _posLen = splitPosition(__pos).length;
if (_posLen <= 2) {
// e.g. '0-0', '0-1'
return;
}
var sibling = 0;
var siblingChecked = 0;
var parentPosition = stripTail(__pos);
objKeys.forEach(function (i /* , index*/) {
var iArr = splitPosition(i);
if (iArr.length === _posLen && isInclude(splitPosition(parentPosition), iArr)) {
sibling++;
if (obj[i].checked) {
siblingChecked++;
var _i = checkedPositionArr.indexOf(i);
if (_i > -1) {
checkedPositionArr.splice(_i, 1);
if (_i <= _pIndex) {
_pIndex--;
}
}
} else if (obj[i].halfChecked) {
siblingChecked += 0.5;
}
// objKeys[index] = null;
}
});
// objKeys = objKeys.filter(i => i); // filter non null;
var parent = obj[parentPosition];
// not check, checked, halfChecked
if (siblingChecked === 0) {
parent.checked = false;
parent.halfChecked = false;
} else if (siblingChecked === sibling) {
parent.checked = true;
parent.halfChecked = false;
} else {
parent.halfChecked = true;
parent.checked = false;
}
loop(parentPosition);
};
loop(checkedPositionArr[_pIndex], _pIndex);
pIndex = _pIndex;
};
for (var pIndex = 0; pIndex < checkedPositionArr.length; pIndex++) {
_loop3(pIndex);
}
// console.log(Date.now()-s, objKeys.length, checkIt);
}
function getCheck(treeNodesStates, checkedPositions) {
var halfCheckedKeys = [];
var checkedKeys = [];
var checkedNodes = [];
Object.keys(treeNodesStates).forEach(function (item) {
var itemObj = treeNodesStates[item];
if (itemObj.checked) {
checkedKeys.push(itemObj.key);
// checkedNodes.push(getValuePropValue(itemObj.node));
checkedNodes.push((0, _extends3['default'])({}, itemObj, { pos: item }));
} else if (itemObj.halfChecked) {
halfCheckedKeys.push(itemObj.key);
}
});
return {
halfCheckedKeys: halfCheckedKeys, checkedKeys: checkedKeys, checkedNodes: checkedNodes, treeNodesStates: treeNodesStates, checkedPositions: checkedPositions
};
}
function getTreeNodesStates(children, values) {
var checkedPositions = [];
var treeNodesStates = {};
loopAllChildren(children, function (item, index, pos, keyOrPos, siblingPosition) {
treeNodesStates[pos] = {
node: item,
key: keyOrPos,
checked: false,
halfChecked: false,
siblingPosition: siblingPosition
};
if (values.indexOf(getValuePropValue(item)) !== -1) {
treeNodesStates[pos].checked = true;
checkedPositions.push(pos);
}
});
handleCheckState(treeNodesStates, filterParentPosition(checkedPositions.sort()), true);
return getCheck(treeNodesStates, checkedPositions);
}
// can add extra prop to every node.
function recursiveCloneChildren(children) {
var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (ch) {
return ch;
};
// return React.Children.map(children, child => {
return Array.from(children).map(function (child) {
var newChild = cb(child);
if (newChild && newChild.props && newChild.props.children) {
return (0, _vnode.cloneElement)(newChild, {
children: recursiveCloneChildren(newChild.props.children, cb)
});
}
return newChild;
});
}
// const newChildren = recursiveCloneChildren(children, child => {
// const extraProps = {};
// if (child && child.type && child.type.xxx) {
// extraProps._prop = true;
// return React.cloneElement(child, extraProps);
// }
// return child;
// });
function recursiveGen(children) {
var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
return children.map(function (child, index) {
var pos = level + '-' + index;
var props = (0, _propsUtil.getAllProps)(child);
var title = props.title,
label = props.label,
value = props.value,
rest = (0, _objectWithoutProperties3['default'])(props, ['title', 'label', 'value']);
var subChildren = child.componentOptions.children;
var o = (0, _extends3['default'])({}, rest, {
title: title,
label: label || title,
value: value,
key: child.key,
_pos: pos
});
if (subChildren) {
o.children = recursiveGen(subChildren, pos);
}
return o;
});
}
function recursive(children, cb) {
children.forEach(function (item) {
cb(item);
if (item.children) {
recursive(item.children, cb);
}
});
}
// Get the tree's checkedNodes (todo: can merge to the `handleCheckState` function)
// If one node checked, it's all children nodes checked.
// If sibling nodes all checked, the parent checked.
function filterAllCheckedData(vs, treeNodes) {
var vals = [].concat((0, _toConsumableArray3['default'])(vs));
if (!vals.length) {
return vals;
}
var data = recursiveGen(treeNodes);
var checkedNodesPositions = [];
function checkChildren(children) {
children.forEach(function (item) {
if (item.__checked) {
return;
}
var ci = vals.indexOf(item.value);
var childs = item.children;
if (ci > -1) {
item.__checked = true;
checkedNodesPositions.push({ node: item, pos: item._pos });
vals.splice(ci, 1);
if (childs) {
recursive(childs, function (child) {
child.__checked = true;
checkedNodesPositions.push({ node: child, pos: child._pos });
});
}
} else {
if (childs) {
checkChildren(childs);
}
}
});
}
function checkParent(children) {
var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { root: true };
var siblingChecked = 0;
children.forEach(function (item) {
var childs = item.children;
if (childs && !item.__checked && !item.__halfChecked) {
var p = checkParent(childs, item);
if (p.__checked) {
siblingChecked++;
} else if (p.__halfChecked) {
siblingChecked += 0.5;
}
} else if (item.__checked) {
siblingChecked++;
} else if (item.__halfChecked) {
siblingChecked += 0.5;
}
});
var len = children.length;
if (siblingChecked === len) {
parent.__checked = true;
checkedNodesPositions.push({ node: parent, pos: parent._pos });
} else if (siblingChecked < len && siblingChecked > 0) {
parent.__halfChecked = true;
}
if (parent.root) {
return children;
}
return parent;
}
checkChildren(data);
checkParent(data);
checkedNodesPositions.forEach(function (i, index) {
// clear private metadata
delete checkedNodesPositions[index].node.__checked;
delete checkedNodesPositions[index].node._pos;
// create the same structure of `onCheck`'s return.
checkedNodesPositions[index].node.props = {
title: checkedNodesPositions[index].node.title,
label: checkedNodesPositions[index].node.label || checkedNodesPositions[index].node.title,
value: checkedNodesPositions[index].node.value
};
if (checkedNodesPositions[index].node.children) {
checkedNodesPositions[index].node.props.children = checkedNodesPositions[index].node.children;
}
delete checkedNodesPositions[index].node.title;
delete checkedNodesPositions[index].node.label;
delete checkedNodesPositions[index].node.value;
delete checkedNodesPositions[index].node.children;
});
return checkedNodesPositions;
}
function processSimpleTreeData(treeData, format) {
function unflatten2(array) {
var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (0, _defineProperty3['default'])({}, format.id, format.rootPId);
var children = [];
for (var i = 0; i < array.length; i++) {
array[i] = (0, _extends3['default'])({}, array[i]); // copy, can not corrupts original data
if (array[i][format.pId] === parent[format.id]) {
array[i].key = array[i][format.id];
children.push(array[i]);
array.splice(i--, 1);
}
}
if (children.length) {
parent.children = children;
children.forEach(function (child) {
return unflatten2(array, child);
});
}
if (parent[format.id] === format.rootPId) {
return children;
}
}
return unflatten2(treeData);
}
function saveRef(instance, name) {
if (!instance.saveRefs) {
instance.saveRefs = {};
}
if (!instance.saveRefs[name]) {
instance.saveRefs[name] = function (node) {
instance[name] = node;
};
}
return instance.saveRefs[name];
}