choerodon-ui
Version:
An enterprise-class UI design language and React-based implementation
1,314 lines (1,097 loc) • 36.7 kB
JavaScript
import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _extends from "@babel/runtime/helpers/extends";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import queryString from 'querystringify';
import moment, { isDate, isMoment } from 'moment';
import { isArrayLike } from 'mobx';
import isBoolean from 'lodash/isBoolean';
import isObject from 'lodash/isObject';
import isString from 'lodash/isString';
import isArray from 'lodash/isArray';
import isNumber from 'lodash/isNumber';
import warning from '../../../es/_util/warning';
import { getConfig } from '../../../es/configure';
import isNil from 'lodash/isNil';
import _isEmpty from 'lodash/isEmpty'; // import XLSX from 'xlsx';
import { BooleanValue, DataToJSON, FieldType, RecordStatus, SortOrder } from './enum';
import isEmpty from '../_util/isEmpty';
import * as ObjectChainValue from '../_util/ObjectChainValue';
import localeContext, { $l } from '../locale-context';
import formatString from '../formatter/formatString';
import { parseNumber } from '../number-field/utils';
import { treeReduce } from '../_util/treeUtils';
export var defaultTextField = 'meaning';
export var defaultValueField = 'value';
export function useNormal(dataToJSON) {
return [DataToJSON.normal, DataToJSON['normal-self']].includes(dataToJSON);
}
export function useAll(dataToJSON) {
return [DataToJSON.all, DataToJSON['all-self']].includes(dataToJSON);
}
export function useSelected(dataToJSON) {
return [DataToJSON.selected, DataToJSON['selected-self']].includes(dataToJSON);
}
export function useCascade(dataToJSON) {
return [DataToJSON.dirty, DataToJSON['dirty-field'], DataToJSON.selected, DataToJSON.all, DataToJSON.normal].includes(dataToJSON);
}
export function useDirty(dataToJSON) {
return [DataToJSON.dirty, DataToJSON['dirty-self']].includes(dataToJSON);
}
export function useDirtyField(dataToJSON) {
return [DataToJSON['dirty-field'], DataToJSON['dirty-field-self']].includes(dataToJSON);
}
export function append(url, suffix) {
if (suffix) {
return url + queryString.stringify(suffix, url.indexOf('?') === -1);
}
return url;
}
export function getOrderFields(fields) {
return _toConsumableArray(fields.values()).filter(function (_ref) {
var order = _ref.order;
return order;
});
}
function processOneToJSON(value, field) {
var checkRange = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
if (!isEmpty(value)) {
var range = field.get('range');
if (range && checkRange) {
if (isArrayLike(range)) {
if (isObject(value)) {
var _value;
var _range = _slicedToArray(range, 2),
start = _range[0],
end = _range[1];
value = (_value = {}, _defineProperty(_value, start, processOneToJSON(value[start], field, false)), _defineProperty(_value, end, processOneToJSON(value[end], field, false)), _value);
}
} else if (isArrayLike(value)) {
value = [processOneToJSON(value[0], field, false), processOneToJSON(value[1], field, false)];
}
} else {
if (isDate(value)) {
value = moment(value);
}
if (isMoment(value)) {
var _getConfig = getConfig('formatter'),
jsonDate = _getConfig.jsonDate;
value = jsonDate ? value.format(jsonDate) : +value;
}
if (field.type === FieldType.json) {
value = JSON.stringify(value);
}
}
}
return value;
}
export function processToJSON(value, field) {
if (!isEmpty(value)) {
var multiple = field.get('multiple');
var range = field.get('range');
if (isArrayLike(value) && (multiple || !range)) {
value = value.map(function (v) {
return processOneToJSON(v, field);
});
if (isString(multiple)) {
return value.join(multiple);
}
return value;
}
return processOneToJSON(value, field);
}
return value;
}
export function arrayMove(array, from, to) {
var startIndex = to < 0 ? array.length + to : to;
var item = array.splice(from, 1)[0];
array.splice(startIndex, 0, item);
}
function processOne(value, field) {
var checkRange = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
if (!isEmpty(value)) {
var range = field.get('range');
if (range && checkRange) {
if (isArrayLike(range)) {
if (isObject(value)) {
var _range2 = _slicedToArray(range, 2),
start = _range2[0],
end = _range2[1];
value[start] = processOne(value[start], field, false);
value[end] = processOne(value[end], field, false);
}
} else if (isArrayLike(value)) {
value[0] = processOne(value[0], field, false);
value[1] = processOne(value[1], field, false);
}
} else if (value instanceof Date) {
value = moment(value);
} else if (!isObject(value)) {
value = formatString(value, {
trim: field.get('trim'),
format: field.get('format')
});
switch (field.type) {
case FieldType["boolean"]:
{
var trueValue = field.get(BooleanValue.trueValue);
var falseValue = field.get(BooleanValue.falseValue);
if (value !== trueValue) {
value = falseValue;
}
break;
}
case FieldType.number:
case FieldType.currency:
if (!isNaN(value)) {
value = parseNumber(value, field.get('precision'));
} else {
value = undefined;
}
break;
case FieldType.string:
case FieldType.intl:
case FieldType.email:
case FieldType.url:
value = String(value);
break;
case FieldType.date:
case FieldType.dateTime:
case FieldType.time:
case FieldType.week:
case FieldType.month:
case FieldType.year:
{
var _getConfig2 = getConfig('formatter'),
jsonDate = _getConfig2.jsonDate;
value = jsonDate ? moment(value, jsonDate) : moment(value);
break;
}
case FieldType.json:
value = JSON.parse(value);
break;
default:
}
}
}
return value;
}
export function processValue(value, field, isCreated) {
if (field) {
var multiple = field.get('multiple');
var range = field.get('range');
if (multiple && field.type !== FieldType.attachment) {
if (isEmpty(value)) {
if (isCreated) {
// for defaultValue
value = undefined;
} else {
value = [];
}
} else if (!isArray(value)) {
if (isString(multiple) && isString(value)) {
value = value.split(multiple);
} else {
value = [value];
}
}
}
if (isArray(value) && (multiple || !range)) {
return value.map(function (item) {
return processOne(item, field);
});
}
return processOne(value, field);
}
return value;
} // 处理单个range
var processRangeToText = function processRangeToText(resultValue, field) {
return resultValue.map(function (item) {
var valueRange = isMoment(item) ? item.format() : isObject(item) ? item[field.get('textField')] : item.toString();
return valueRange;
}).join("~");
};
export function processExportValue(value, field) {
if (field) {
var multiple = field.get('multiple');
var range = field.get('range');
if (multiple) {
if (isEmpty(value)) {
value = [];
} else if (!isArray(value)) {
if (isString(multiple) && isString(value)) {
value = value.split(multiple);
} else {
value = [value];
}
}
}
if (isArray(value) && (multiple || !range)) {
if (field && !_isEmpty(field.lookup)) {
return value.map(function (item) {
return field.getText(processOne(item, field));
}).join(',');
}
return value.map(function (item) {
var itemValue = processOne(item, field);
if (field && field.get('textField') && itemValue && isObject(itemValue)) {
return itemValue[field.get('textField')];
}
return itemValue;
}).join(',');
}
if (isArray(value) && multiple && range) {
if (field && !_isEmpty(field.lookup)) {
return value.map(function (item) {
return field.getText(processRangeToText(processOne(item, field), field));
}).join(',');
}
return value.map(function (item) {
return processRangeToText(processOne(item, field), field);
}).join(',');
}
if (field && !_isEmpty(field.lookup)) {
return field.getText(processOne(value, field));
}
var resultValue = processOne(value, field);
if (isMoment(resultValue)) {
return resultValue.format();
}
if (field && field.get('textField') && resultValue && isObject(resultValue)) {
if (range && isArrayLike(resultValue)) {
return processRangeToText(resultValue, field);
}
return resultValue[field.get('textField')];
}
return resultValue;
}
return value;
}
/**
* 实现如果名字是带有属性含义`.`找到能够导出的值
* @param dataItem 一行数据
* @param name 对应的fieldname
* @param isBind 是否是从绑定获取值
*/
export function getSplitValue(dataItem, name) {
var isBind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
var nameArray = name.split('.');
if (nameArray.length > 1) {
var levelValue = dataItem;
for (var i = 0; i < nameArray.length; i++) {
if (!isObject(levelValue)) {
break;
}
if (isBind || i !== 0) {
levelValue = levelValue[nameArray[i]];
}
}
return levelValue;
}
if (isBind) {
return dataItem ? dataItem[name] : undefined;
}
return dataItem;
}
export function childrenInfoForDelete(json, children) {
return Object.keys(children).reduce(function (data, name) {
var child = children[name];
if (child) {
data[name] = [childrenInfoForDelete({}, child.children)];
}
return data;
}, json);
}
export function sortTree(children, orderField) {
if (orderField && children.length > 0) {
var name = orderField.name,
order = orderField.order;
var m = Number.MIN_SAFE_INTEGER;
children.sort(function (record1, record2) {
var a = record1.get(name) || m;
var b = record2.get(name) || m;
if (isString(a) || isString(b)) {
return order === SortOrder.asc ? String(a).localeCompare(String(b)) : String(b).localeCompare(String(a));
}
return order === SortOrder.asc ? a - b : b - a;
});
}
return children;
} // 获取单个页面能够展示的数据
export function sliceTree(idField, parentField, allData, pageSize) {
if (allData.length) {
var rootMap = new Map();
var itemMap = new Map();
allData.forEach(function (item) {
var id = item[idField];
if (!isNil(id)) {
var node = {
item: item,
children: []
};
itemMap.set(id, node);
rootMap.set(id, node);
}
});
_toConsumableArray(itemMap.entries()).forEach(function (_ref2) {
var _ref3 = _slicedToArray(_ref2, 2),
key = _ref3[0],
node = _ref3[1];
var parent = itemMap.get(node.item[parentField]);
if (parent) {
parent.children.push(node);
rootMap["delete"](key);
}
});
return treeReduce(_toConsumableArray(rootMap.values()).slice(0, pageSize), function (previousValue, node) {
return previousValue.concat(node.item);
}, []);
}
return [];
}
export function checkParentByInsert(_ref4) {
var parent = _ref4.parent;
if (parent && !parent.current) {
throw new Error($l('DataSet', 'cannot_add_record_when_head_no_current'));
}
}
function getValueType(value) {
return isBoolean(value) ? FieldType["boolean"] : isNumber(value) ? FieldType.number : isString(value) ? FieldType.string : isMoment(value) ? FieldType.date : isObject(value) ? FieldType.object : FieldType.auto;
}
export function getBaseType(type) {
switch (type) {
case FieldType.number:
case FieldType.currency:
return FieldType.number;
case FieldType.dateTime:
case FieldType.time:
case FieldType.week:
case FieldType.month:
case FieldType.year:
return FieldType.date;
case FieldType.intl:
case FieldType.url:
case FieldType.email:
return FieldType.string;
default:
return type;
}
}
export function checkFieldType(value, field) {
if (process.env.NODE_ENV !== 'production' && !isEmpty(value)) {
var fieldType = getBaseType(field.type);
if (fieldType !== FieldType.auto) {
if (isArrayLike(value)) {
return value.every(function (item) {
return checkFieldType(item, field);
});
}
var valueType = field.type === FieldType["boolean"] && [field.get(BooleanValue.trueValue), field.get(BooleanValue.falseValue)].includes(value) ? FieldType["boolean"] : getValueType(value);
if (fieldType !== FieldType.reactNode && fieldType !== valueType) {
warning(false, "Value type error: The value<".concat(value, ">'s type is ").concat(valueType, ", but the field<").concat(field.name, ">'s type is ").concat(fieldType, "."));
return false;
}
}
}
return true;
}
var iframe;
/**
* 目前定义为服务端请求的方法
* @param url 导出地址
* @param data 导出传递参数
* @param method 默认post请求
*/
export function doExport(url, data) {
var method = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'post';
if (!iframe) {
iframe = document.createElement('iframe');
iframe.id = '_export_window';
iframe.name = '_export_window';
iframe.style.cssText = 'position:absolute;left:-10000px;top:-10000px;width:1px;height:1px;display:none';
document.body.appendChild(iframe);
}
var form = document.createElement('form');
form.target = '_export_window';
form.method = method;
form.action = url;
var s = document.createElement('input');
s.id = '_request_data';
s.type = 'hidden';
s.name = '_request_data';
s.value = JSON.stringify(data);
form.appendChild(s);
document.body.appendChild(form);
form.submit();
document.body.removeChild(form);
}
function throwCycleBindingFields() {
var map = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
var keys = _toConsumableArray(map.keys());
throw new Error("DataSet: Cycle binding fields[".concat(_toConsumableArray(keys).join(' -> '), " -> ").concat(keys[0], "]."));
}
function getChainFieldNamePrivate(record, fieldName) {
var linkedMap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Map();
var init = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
var field = record.getField(fieldName);
if (field) {
var bind = field.get('bind');
if (bind) {
if (linkedMap.has(fieldName)) {
throwCycleBindingFields(linkedMap);
}
linkedMap.set(fieldName, field);
var names = bind.split('.');
if (names.length > 0) {
if (names.length === 1) {
return getChainFieldNamePrivate(record, bind, linkedMap);
}
return names.reduce(function (chainFieldName, name) {
return [getChainFieldNamePrivate(record, chainFieldName, linkedMap, false), name].join('.');
});
}
}
} else if (init && fieldName.indexOf('.') > -1) {
return fieldName.split('.').reduce(function (chainFieldName, name) {
return [getChainFieldNamePrivate(record, chainFieldName, linkedMap, false), name].join('.');
});
}
return fieldName;
}
export function getChainFieldName(record, fieldName) {
return getChainFieldNamePrivate(record, fieldName);
}
export function findBindTargetFields(myField, fields, deep) {
var bindFields = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
var bind = myField.get('bind');
if (bind) {
_toConsumableArray(fields.entries()).some(function (_ref5) {
var _ref6 = _slicedToArray(_ref5, 2),
fieldName = _ref6[0],
field = _ref6[1];
if (field !== myField) {
if (bind === fieldName || bind.startsWith("".concat(fieldName, "."))) {
if (bindFields.has(fieldName)) {
throwCycleBindingFields(bindFields);
}
bindFields.set(fieldName, field);
if (deep) {
findBindTargetFields(field, fields, deep, bindFields);
}
return true;
}
}
return false;
});
}
return _toConsumableArray(bindFields.values());
}
export function findBindFields(myField, fields, deep) {
var bindFields = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
var name = myField.name;
_toConsumableArray(fields.entries()).forEach(function (_ref7) {
var _ref8 = _slicedToArray(_ref7, 2),
fieldName = _ref8[0],
field = _ref8[1];
if (field !== myField) {
var bind = field.get('bind');
if (bind && (bind === name || bind.startsWith("".concat(name, ".")))) {
if (bindFields.has(fieldName)) {
throwCycleBindingFields(bindFields);
}
bindFields.set(fieldName, field);
if (deep) {
findBindFields(field, fields, deep, bindFields);
}
}
}
});
return _toConsumableArray(bindFields.values());
}
export function findBindField(myField, chainFieldName, record) {
return _toConsumableArray(record.fields.values()).find(function (field) {
var fieldName = field.name;
if (fieldName !== myField) {
var bind = field.get('bind');
if (bind) {
return chainFieldName === getChainFieldName(record, fieldName);
}
}
return false;
});
}
function numberSorter(a, b) {
return a - b;
}
function stringSorter(a, b) {
return String(a || '').localeCompare(String(b || ''));
}
export function getFieldSorter(field) {
var name = field.name;
switch (field.type) {
case FieldType.number:
case FieldType.currency:
case FieldType.date:
case FieldType.dateTime:
case FieldType.week:
case FieldType.month:
case FieldType.year:
case FieldType.time:
return field.order === SortOrder.asc ? function (a, b) {
return numberSorter(a.get(name), b.get(name));
} : function (a, b) {
return numberSorter(b.get(name), a.get(name));
};
default:
return field.order === SortOrder.asc ? function (a, b) {
return stringSorter(a.get(name), b.get(name));
} : function (a, b) {
return stringSorter(b.get(name), a.get(name));
};
}
}
export function generateRecordJSONData(array, record, dataToJSON) {
var normal = useNormal(dataToJSON);
var json = normal ? !record.isRemoved && record.toData() : record.toJSONData();
if (json && (normal || useAll(dataToJSON) || !useDirty(dataToJSON) && !useDirtyField(dataToJSON) || json.__dirty)) {
delete json.__dirty;
array.push(json);
}
}
export function prepareSubmitData(records, dataToJSON) {
var created = [];
var updated = [];
var destroyed = [];
function storeWith(status) {
switch (status) {
case RecordStatus.add:
return created;
case RecordStatus["delete"]:
return destroyed;
default:
return updated;
}
}
records.forEach(function (record) {
return generateRecordJSONData(storeWith(record.status), record, dataToJSON);
});
return [created, updated, destroyed];
}
function defaultAxiosConfigAdapter(config) {
return config;
}
function generateConfig(config, dataSet, data, params, options) {
if (isString(config)) {
return {
url: config
};
}
if (typeof config === 'function') {
return config(_objectSpread({}, options, {
data: data,
dataSet: dataSet,
params: params
}));
}
return config;
}
export function axiosConfigAdapter(type, dataSet, data, params, options) {
var newConfig = {
data: data,
params: params,
method: 'post'
};
var _ref9 = getConfig('transport') || {},
globalConfig = _ref9[type],
_ref9$adapter = _ref9.adapter,
globalAdapter = _ref9$adapter === void 0 ? defaultAxiosConfigAdapter : _ref9$adapter;
var _dataSet$transport = dataSet.transport,
config = _dataSet$transport[type],
adapter = _dataSet$transport.adapter;
if (globalConfig) {
_extends(newConfig, generateConfig(globalConfig, dataSet, data, params, options));
}
if (config) {
_extends(newConfig, generateConfig(config, dataSet, data, params, options));
}
if (newConfig.data && newConfig.method && newConfig.method.toLowerCase() === 'get') {
newConfig.params = _objectSpread({}, newConfig.params, {}, newConfig.data);
}
return (adapter || globalAdapter)(newConfig, type) || newConfig;
} // 查询顶层父亲节点
export function findRootParent(children) {
if (children.parent) {
return findRootParent(children.parent);
}
return children;
}
export function prepareForSubmit(type, data, configs, dataSet) {
if (data.length) {
var newConfig = axiosConfigAdapter(type, dataSet, data);
if (newConfig.url) {
configs.push(newConfig);
} else {
return data;
}
}
return [];
}
export function generateResponseData(item, dataKey) {
if (item) {
if (isArray(item)) {
return item;
}
if (isObject(item)) {
if (dataKey) {
var result = ObjectChainValue.get(item, dataKey);
if (result === undefined) {
return [item];
}
if (isArray(result)) {
return result;
}
if (isObject(result)) {
return [result];
}
} else {
return [item];
}
}
}
return [];
}
export function getRecordValue(record, cb, fieldName) {
if (fieldName) {
if (isArrayLike(fieldName)) {
return fieldName.reduce(function (value, key) {
value[key] = getRecordValue(record, cb, key);
return value;
}, {});
}
var chainFieldName = getChainFieldName(record, fieldName);
var dataSet = record.dataSet;
if (dataSet) {
var checkField = dataSet.props.checkField;
if (checkField && chainFieldName === getChainFieldName(record, checkField)) {
var field = record.getField(checkField);
var trueValue = field ? field.get(BooleanValue.trueValue) : true;
var falseValue = field ? field.get(BooleanValue.falseValue) : false;
var children = record.children;
if (children) {
return children.every(function (child) {
return cb(child, checkField) === trueValue;
}) ? trueValue : falseValue;
}
}
}
return ObjectChainValue.get(record.data, chainFieldName);
}
}
export function processIntlField(name, fieldProps, callback, dataSet) {
if (fieldProps.type === FieldType.intl) {
var transformRequest = fieldProps.transformRequest;
var tlsKey = getConfig('tlsKey');
var supports = localeContext.supports;
var languages = Object.keys(supports);
languages.forEach(function (language) {
return callback("".concat(tlsKey, ".").concat(name, ".").concat(language), {
type: FieldType.string,
label: "".concat(supports[language]),
transformRequest: transformRequest,
computedProps: {
bind: function bind(_ref10) {
var record = _ref10.record;
if (record) {
var tls = record.get(tlsKey) || {};
if (name in tls && (dataSet ? dataSet.lang : localeContext.locale.lang) === language) {
return name;
}
}
}
}
});
});
}
return callback(name, fieldProps);
}
export function findBindFieldBy(myField, fields, prop) {
var value = myField.get(prop);
var myName = myField.name;
return _toConsumableArray(fields.values()).find(function (field) {
var bind = field.get('bind');
return bind && bind === "".concat(myName, ".").concat(value);
});
}
export function getLimit(limit, record) {
if (isString(limit) && record.getField(limit)) {
return record.get(limit);
}
return limit;
}
export function adapterDataToJSON(isSelected, noCascade) {
if (isSelected) {
if (noCascade) {
return DataToJSON['selected-self'];
}
return DataToJSON.selected;
}
if (noCascade) {
return DataToJSON['dirty-self'];
}
return undefined;
}
export function generateData(records) {
var dirty = false;
var data = records.reduce(function (list, record) {
if (record.isRemoved) {
dirty = true;
} else {
var d = record.toData();
if (d.__dirty) {
dirty = true;
}
delete d.__dirty;
list.push(d);
}
return list;
}, []);
return {
dirty: dirty,
data: data
};
}
export function generateJSONData(ds, records) {
var dataToJSON = ds.dataToJSON;
var data = [];
records.forEach(function (record) {
return generateRecordJSONData(data, record, dataToJSON);
});
return {
dirty: data.length > 0,
data: data
};
}
export function getUniqueFieldNames(dataSet) {
var keys = [];
_toConsumableArray(dataSet.fields.entries()).forEach(function (_ref11) {
var _ref12 = _slicedToArray(_ref11, 2),
key = _ref12[0],
field = _ref12[1];
if (field.get('unique')) {
keys.push(key);
}
});
return keys;
}
export function getUniqueKeysAndPrimaryKey(dataSet) {
if (dataSet) {
var keys = getUniqueFieldNames(dataSet);
var primaryKey = dataSet.props.primaryKey;
if (primaryKey) {
keys.push(primaryKey);
}
return keys;
}
return [];
}
export function isDirtyRecord(record) {
return record.status !== RecordStatus.sync || record.dirty;
}
export function getSpliceRecord(records, inserts, fromRecord) {
if (fromRecord) {
if (inserts.includes(fromRecord)) {
return getSpliceRecord(records, inserts, records[records.indexOf(fromRecord) + 1]);
}
return fromRecord;
}
} // bugs in react native
export function fixAxiosConfig(config) {
var method = config.method;
if (method && method.toLowerCase() === 'get') {
delete config.data;
}
return config;
}
var EMPTY_GROUP_KEY = '__empty_group__';
export function normalizeGroups(groups, records) {
var optGroups = [];
var restRecords = [];
records.forEach(function (record) {
var previousGroup;
groups.every(function (key) {
var label = record.get(key);
if (label !== undefined) {
if (!previousGroup) {
previousGroup = optGroups.find(function (item) {
return item.value === label;
});
if (!previousGroup) {
previousGroup = {
name: key,
value: label,
records: [],
subGroups: []
};
optGroups.push(previousGroup);
}
} else {
var _previousGroup = previousGroup,
subGroups = _previousGroup.subGroups;
previousGroup = subGroups.find(function (item) {
return item.value === label;
});
if (!previousGroup) {
previousGroup = {
name: key,
value: label,
records: [],
subGroups: []
};
subGroups.push(previousGroup);
}
}
return true;
}
return false;
});
if (previousGroup) {
var _previousGroup2 = previousGroup,
groupRecords = _previousGroup2.records;
groupRecords.push(record);
} else {
restRecords.push(record);
}
});
if (restRecords.length) {
optGroups.push({
name: EMPTY_GROUP_KEY,
value: undefined,
records: restRecords,
subGroups: []
});
}
return optGroups;
}
/**
*
* @param data 导出需要导出的数据
* @param excelname 导出表单的名字
*/
export function exportExcel(data, excelName) {
import('xlsx').then(function (XLSX) {
var ws = XLSX.utils.json_to_sheet(data, {
skipHeader: true
});
/* 新建空workbook，然后加入worksheet */
var wb = XLSX.utils.book_new();
/* 新建book */
XLSX.utils.book_append_sheet(wb, ws);
/* 生成xlsx文件(book,sheet数据,sheet命名) */
XLSX.writeFile(wb, "".concat(excelName, ".xlsx"));
/* 写文件(book,xlsx文件名称) */
});
}
export function getSortedFields(fields) {
var normalFields = [];
var objectBindFields = [];
var bindFields = [];
var transformResponseField = [];
var dynamicFields = [];
var dynamicObjectBindFields = [];
var dynamicBindFields = [];
_toConsumableArray(fields.entries()).forEach(function (entry) {
var _entry = _slicedToArray(entry, 2),
field = _entry[1];
var dynamicProps = field.get('computedProps') || field.get('dynamicProps');
if (dynamicProps) {
if (dynamicProps.bind) {
if (field.type === FieldType.object) {
dynamicObjectBindFields.push(entry);
} else {
dynamicBindFields.push(entry);
}
} else {
dynamicFields.push(entry);
}
} else {
var bind = field.get('bind');
if (bind) {
var targetNames = bind.split('.');
targetNames.pop();
if (targetNames.some(function (targetName) {
var target = fields.get(targetName);
return target && (target.get('computedProps') || target.get('dynamicProps'));
})) {
if (field.type === FieldType.object) {
dynamicObjectBindFields.push(entry);
} else {
dynamicBindFields.push(entry);
}
} else if (field.get('transformResponse')) {
transformResponseField.push(entry);
} else if (field.type === FieldType.object) {
objectBindFields.push(entry);
} else {
bindFields.push(entry);
}
} else {
normalFields.push(entry);
}
}
});
return [].concat(normalFields, objectBindFields, bindFields, transformResponseField, dynamicFields, dynamicObjectBindFields, dynamicBindFields);
}
export function concurrentPromise(_x, _x2) {
return _concurrentPromise.apply(this, arguments);
}
function _concurrentPromise() {
_concurrentPromise = _asyncToGenerator(
/*#__PURE__*/
_regeneratorRuntime.mark(function _callee2(promiseLoaders, cancelFnc) {
var promiseLoadersLength, fail;
return _regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
promiseLoadersLength = promiseLoaders.length;
fail = false;
return _context2.abrupt("return", new Promise(function (resolve, reject) {
var resulet = Array(promiseLoadersLength).fill(null); // 依次执行promise
// 最大并发数
var maxConcurrent = Math.min(5, promiseLoadersLength);
var currentPromiseIndex = 0;
var execPromise =
/*#__PURE__*/
function () {
var _ref13 = _asyncToGenerator(
/*#__PURE__*/
_regeneratorRuntime.mark(function _callee(getPromise, index) {
var res, _promiseLoaders$curre;
return _regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (!fail) {
_context.next = 2;
break;
}
return _context.abrupt("return");
case 2:
if (!cancelFnc(resulet.filter(Boolean).length)) {
_context.next = 6;
break;
}
fail = true;
reject();
return _context.abrupt("return");
case 6:
_context.prev = 6;
_context.next = 9;
return getPromise();
case 9:
res = _context.sent;
_context.next = 17;
break;
case 12:
_context.prev = 12;
_context.t0 = _context["catch"](6);
fail = true;
reject(_context.t0);
return _context.abrupt("return");
case 17:
resulet[index] = res; // 判断是否完结
if (!(currentPromiseIndex === promiseLoadersLength - 1 && resulet.every(Boolean))) {
_context.next = 21;
break;
}
resolve(resulet);
return _context.abrupt("return");
case 21:
// 执行下一个promise
if (currentPromiseIndex < promiseLoadersLength - 1) {
++currentPromiseIndex;
execPromise((_promiseLoaders$curre = promiseLoaders[currentPromiseIndex]) === null || _promiseLoaders$curre === void 0 ? void 0 : _promiseLoaders$curre.getPromise, currentPromiseIndex);
}
case 22:
case "end":
return _context.stop();
}
}
}, _callee, null, [[6, 12]]);
}));
return function execPromise(_x3, _x4) {
return _ref13.apply(this, arguments);
};
}(); // 初始化执行
for (var i = 0; i < maxConcurrent; i++) {
var _promiseLoaders$i;
execPromise((_promiseLoaders$i = promiseLoaders[i]) === null || _promiseLoaders$i === void 0 ? void 0 : _promiseLoaders$i.getPromise, i);
}
currentPromiseIndex = maxConcurrent - 1;
}));
case 3:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
return _concurrentPromise.apply(this, arguments);
}
export function treeSelect(dataSet, record, selected) {
dataSet.select(record);
if (record.isSelected) {
selected.push(record);
var children = record.children;
if (children) {
children.forEach(function (child) {
return treeSelect(dataSet, child, selected);
});
}
}
}
export function treeUnSelect(dataSet, record, unSelected) {
dataSet.unSelect(record);
if (!record.isSelected) {
unSelected.push(record);
var children = record.children;
if (children) {
children.forEach(function (child) {
return treeUnSelect(dataSet, child, unSelected);
});
}
}
}
export function treeSelectParent(dataSet, record, selected) {
var parent = record.parent;
if (parent && !parent.isSelected) {
dataSet.select(parent);
selected.push(parent);
treeSelectParent(dataSet, parent, selected);
}
}
export function treeUnSelectParent(dataSet, record, unSelected) {
var parent = record.parent;
if (parent && parent.isSelected) {
var children = parent.children;
if (children && children.every(function (child) {
return !child.isSelected;
})) {
dataSet.unSelect(parent);
unSelected.push(parent);
treeUnSelectParent(dataSet, parent, unSelected);
}
}
}
export function getIf(target, propName, defaultValue) {
var value = target[propName];
if (value === undefined) {
target[propName] = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
return target[propName];
}
return value;
}
//# sourceMappingURL=utils.js.map