156 lines
3.9 KiB
Java
156 lines
3.9 KiB
Java
import _typeof from 'babel-runtime/helpers/typeof';
|
|
import _extends from 'babel-runtime/helpers/extends';
|
|
import warning from 'warning';
|
|
|
|
function getDisplayName(WrappedComponent) {
|
|
return WrappedComponent.name || 'WrappedComponent';
|
|
}
|
|
|
|
export function argumentContainer(Container, WrappedComponent) {
|
|
/* eslint no-param-reassign:0 */
|
|
Container.name = 'Form_' + getDisplayName(WrappedComponent);
|
|
Container.WrappedComponent = WrappedComponent;
|
|
Container.props = _extends({}, Container.props, WrappedComponent.props);
|
|
return Container;
|
|
}
|
|
|
|
export function identity(obj) {
|
|
return obj;
|
|
}
|
|
|
|
export function flattenArray(arr) {
|
|
return Array.prototype.concat.apply([], arr);
|
|
}
|
|
|
|
export function treeTraverse() {
|
|
var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
|
var tree = arguments[1];
|
|
var isLeafNode = arguments[2];
|
|
var errorMessage = arguments[3];
|
|
var callback = arguments[4];
|
|
|
|
if (isLeafNode(path, tree)) {
|
|
callback(path, tree);
|
|
} else if (tree === undefined || tree === null) {
|
|
// Do nothing
|
|
} else if (Array.isArray(tree)) {
|
|
tree.forEach(function (subTree, index) {
|
|
return treeTraverse(path + '[' + index + ']', subTree, isLeafNode, errorMessage, callback);
|
|
});
|
|
} else {
|
|
// It's object and not a leaf node
|
|
if ((typeof tree === 'undefined' ? 'undefined' : _typeof(tree)) !== 'object') {
|
|
warning(false, errorMessage);
|
|
return;
|
|
}
|
|
Object.keys(tree).forEach(function (subTreeKey) {
|
|
var subTree = tree[subTreeKey];
|
|
treeTraverse('' + path + (path ? '.' : '') + subTreeKey, subTree, isLeafNode, errorMessage, callback);
|
|
});
|
|
}
|
|
}
|
|
|
|
export function flattenFields(maybeNestedFields, isLeafNode, errorMessage) {
|
|
var fields = {};
|
|
treeTraverse(undefined, maybeNestedFields, isLeafNode, errorMessage, function (path, node) {
|
|
fields[path] = node;
|
|
});
|
|
return fields;
|
|
}
|
|
|
|
export function normalizeValidateRules(validate, rules, validateTrigger) {
|
|
var validateRules = validate.map(function (item) {
|
|
var newItem = _extends({}, item, {
|
|
trigger: item.trigger || []
|
|
});
|
|
if (typeof newItem.trigger === 'string') {
|
|
newItem.trigger = [newItem.trigger];
|
|
}
|
|
return newItem;
|
|
});
|
|
if (rules) {
|
|
validateRules.push({
|
|
trigger: validateTrigger ? [].concat(validateTrigger) : [],
|
|
rules: rules
|
|
});
|
|
}
|
|
return validateRules;
|
|
}
|
|
|
|
export function getValidateTriggers(validateRules) {
|
|
return validateRules.filter(function (item) {
|
|
return !!item.rules && item.rules.length;
|
|
}).map(function (item) {
|
|
return item.trigger;
|
|
}).reduce(function (pre, curr) {
|
|
return pre.concat(curr);
|
|
}, []);
|
|
}
|
|
|
|
export function getValueFromEvent(e) {
|
|
// To support custom element
|
|
if (!e || !e.target) {
|
|
return e;
|
|
}
|
|
var target = e.target;
|
|
|
|
return target.type === 'checkbox' ? target.checked : target.value;
|
|
}
|
|
|
|
export function getErrorStrs(errors) {
|
|
if (errors) {
|
|
return errors.map(function (e) {
|
|
if (e && e.message) {
|
|
return e.message;
|
|
}
|
|
return e;
|
|
});
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
export function getParams(ns, opt, cb) {
|
|
var names = ns;
|
|
var options = opt;
|
|
var callback = cb;
|
|
if (cb === undefined) {
|
|
if (typeof names === 'function') {
|
|
callback = names;
|
|
options = {};
|
|
names = undefined;
|
|
} else if (Array.isArray(names)) {
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = {};
|
|
} else {
|
|
options = options || {};
|
|
}
|
|
} else {
|
|
callback = options;
|
|
options = names || {};
|
|
names = undefined;
|
|
}
|
|
}
|
|
return {
|
|
names: names,
|
|
options: options,
|
|
callback: callback
|
|
};
|
|
}
|
|
|
|
export function isEmptyObject(obj) {
|
|
return Object.keys(obj).length === 0;
|
|
}
|
|
|
|
export function hasRules(validate) {
|
|
if (validate) {
|
|
return validate.some(function (item) {
|
|
return item.rules && item.rules.length;
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export function startsWith(str, prefix) {
|
|
return str.lastIndexOf(prefix, 0) === 0;
|
|
} |