choerodon-ui/pro/lib/data-set/utils.js

An enterprise-class UI design language and React-based implementation

"use strict";

var _interopRequireWildcard3 = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.useNormal = useNormal;
exports.useAll = useAll;
exports.useSelected = useSelected;
exports.useCascade = useCascade;
exports.useDirty = useDirty;
exports.useDirtyField = useDirtyField;
exports.append = append;
exports.getOrderFields = getOrderFields;
exports.processToJSON = processToJSON;
exports.arrayMove = arrayMove;
exports.processValue = processValue;
exports.processExportValue = processExportValue;
exports.getSplitValue = getSplitValue;
exports.childrenInfoForDelete = childrenInfoForDelete;
exports.sortTree = sortTree;
exports.sliceTree = sliceTree;
exports.checkParentByInsert = checkParentByInsert;
exports.getBaseType = getBaseType;
exports.checkFieldType = checkFieldType;
exports.doExport = doExport;
exports.getChainFieldName = getChainFieldName;
exports.findBindTargetFields = findBindTargetFields;
exports.findBindFields = findBindFields;
exports.findBindField = findBindField;
exports.getFieldSorter = getFieldSorter;
exports.generateRecordJSONData = generateRecordJSONData;
exports.prepareSubmitData = prepareSubmitData;
exports.axiosConfigAdapter = axiosConfigAdapter;
exports.findRootParent = findRootParent;
exports.prepareForSubmit = prepareForSubmit;
exports.generateResponseData = generateResponseData;
exports.getRecordValue = getRecordValue;
exports.processIntlField = processIntlField;
exports.findBindFieldBy = findBindFieldBy;
exports.getLimit = getLimit;
exports.adapterDataToJSON = adapterDataToJSON;
exports.generateData = generateData;
exports.generateJSONData = generateJSONData;
exports.getUniqueFieldNames = getUniqueFieldNames;
exports.getUniqueKeysAndPrimaryKey = getUniqueKeysAndPrimaryKey;
exports.isDirtyRecord = isDirtyRecord;
exports.getSpliceRecord = getSpliceRecord;
exports.fixAxiosConfig = fixAxiosConfig;
exports.normalizeGroups = normalizeGroups;
exports.exportExcel = exportExcel;
exports.getSortedFields = getSortedFields;
exports.concurrentPromise = concurrentPromise;
exports.treeSelect = treeSelect;
exports.treeUnSelect = treeUnSelect;
exports.treeSelectParent = treeSelectParent;
exports.treeUnSelectParent = treeUnSelectParent;
exports.getIf = getIf;
exports.defaultValueField = exports.defaultTextField = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _interopRequireWildcard2 = _interopRequireDefault(require("@babel/runtime/helpers/interopRequireWildcard"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _querystringify = _interopRequireDefault(require("querystringify"));

var _moment = _interopRequireWildcard3(require("moment"));

var _mobx = require("mobx");

var _isBoolean = _interopRequireDefault(require("lodash/isBoolean"));

var _isObject = _interopRequireDefault(require("lodash/isObject"));

var _isString = _interopRequireDefault(require("lodash/isString"));

var _isArray = _interopRequireDefault(require("lodash/isArray"));

var _isNumber = _interopRequireDefault(require("lodash/isNumber"));

var _warning = _interopRequireDefault(require("../../../lib/_util/warning"));

var _configure = require("../../../lib/configure");

var _isNil = _interopRequireDefault(require("lodash/isNil"));

var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));

var _enum = require("./enum");

var _isEmpty3 = _interopRequireDefault(require("../_util/isEmpty"));

var ObjectChainValue = _interopRequireWildcard3(require("../_util/ObjectChainValue"));

var _localeContext = _interopRequireWildcard3(require("../locale-context"));

var _formatString = _interopRequireDefault(require("../formatter/formatString"));

var _utils = require("../number-field/utils");

var _treeUtils = require("../_util/treeUtils");

// import XLSX from 'xlsx';
var defaultTextField = 'meaning';
exports.defaultTextField = defaultTextField;
var defaultValueField = 'value';
exports.defaultValueField = defaultValueField;

function useNormal(dataToJSON) {
  return [_enum.DataToJSON.normal, _enum.DataToJSON['normal-self']].includes(dataToJSON);
}

function useAll(dataToJSON) {
  return [_enum.DataToJSON.all, _enum.DataToJSON['all-self']].includes(dataToJSON);
}

function useSelected(dataToJSON) {
  return [_enum.DataToJSON.selected, _enum.DataToJSON['selected-self']].includes(dataToJSON);
}

function useCascade(dataToJSON) {
  return [_enum.DataToJSON.dirty, _enum.DataToJSON['dirty-field'], _enum.DataToJSON.selected, _enum.DataToJSON.all, _enum.DataToJSON.normal].includes(dataToJSON);
}

function useDirty(dataToJSON) {
  return [_enum.DataToJSON.dirty, _enum.DataToJSON['dirty-self']].includes(dataToJSON);
}

function useDirtyField(dataToJSON) {
  return [_enum.DataToJSON['dirty-field'], _enum.DataToJSON['dirty-field-self']].includes(dataToJSON);
}

function append(url, suffix) {
  if (suffix) {
    return url + _querystringify["default"].stringify(suffix, url.indexOf('?') === -1);
  }

  return url;
}

function getOrderFields(fields) {
  return (0, _toConsumableArray2["default"])(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 (!(0, _isEmpty3["default"])(value)) {
    var range = field.get('range');

    if (range && checkRange) {
      if ((0, _mobx.isArrayLike)(range)) {
        if ((0, _isObject["default"])(value)) {
          var _value;

          var _range = (0, _slicedToArray2["default"])(range, 2),
              start = _range[0],
              end = _range[1];

          value = (_value = {}, (0, _defineProperty2["default"])(_value, start, processOneToJSON(value[start], field, false)), (0, _defineProperty2["default"])(_value, end, processOneToJSON(value[end], field, false)), _value);
        }
      } else if ((0, _mobx.isArrayLike)(value)) {
        value = [processOneToJSON(value[0], field, false), processOneToJSON(value[1], field, false)];
      }
    } else {
      if ((0, _moment.isDate)(value)) {
        value = (0, _moment["default"])(value);
      }

      if ((0, _moment.isMoment)(value)) {
        var _getConfig = (0, _configure.getConfig)('formatter'),
            jsonDate = _getConfig.jsonDate;

        value = jsonDate ? value.format(jsonDate) : +value;
      }

      if (field.type === _enum.FieldType.json) {
        value = JSON.stringify(value);
      }
    }
  }

  return value;
}

function processToJSON(value, field) {
  if (!(0, _isEmpty3["default"])(value)) {
    var multiple = field.get('multiple');
    var range = field.get('range');

    if ((0, _mobx.isArrayLike)(value) && (multiple || !range)) {
      value = value.map(function (v) {
        return processOneToJSON(v, field);
      });

      if ((0, _isString["default"])(multiple)) {
        return value.join(multiple);
      }

      return value;
    }

    return processOneToJSON(value, field);
  }

  return value;
}

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 (!(0, _isEmpty3["default"])(value)) {
    var range = field.get('range');

    if (range && checkRange) {
      if ((0, _mobx.isArrayLike)(range)) {
        if ((0, _isObject["default"])(value)) {
          var _range2 = (0, _slicedToArray2["default"])(range, 2),
              start = _range2[0],
              end = _range2[1];

          value[start] = processOne(value[start], field, false);
          value[end] = processOne(value[end], field, false);
        }
      } else if ((0, _mobx.isArrayLike)(value)) {
        value[0] = processOne(value[0], field, false);
        value[1] = processOne(value[1], field, false);
      }
    } else if (value instanceof Date) {
      value = (0, _moment["default"])(value);
    } else if (!(0, _isObject["default"])(value)) {
      value = (0, _formatString["default"])(value, {
        trim: field.get('trim'),
        format: field.get('format')
      });

      switch (field.type) {
        case _enum.FieldType["boolean"]:
          {
            var trueValue = field.get(_enum.BooleanValue.trueValue);
            var falseValue = field.get(_enum.BooleanValue.falseValue);

            if (value !== trueValue) {
              value = falseValue;
            }

            break;
          }

        case _enum.FieldType.number:
        case _enum.FieldType.currency:
          if (!isNaN(value)) {
            value = (0, _utils.parseNumber)(value, field.get('precision'));
          } else {
            value = undefined;
          }

          break;

        case _enum.FieldType.string:
        case _enum.FieldType.intl:
        case _enum.FieldType.email:
        case _enum.FieldType.url:
          value = String(value);
          break;

        case _enum.FieldType.date:
        case _enum.FieldType.dateTime:
        case _enum.FieldType.time:
        case _enum.FieldType.week:
        case _enum.FieldType.month:
        case _enum.FieldType.year:
          {
            var _getConfig2 = (0, _configure.getConfig)('formatter'),
                jsonDate = _getConfig2.jsonDate;

            value = jsonDate ? (0, _moment["default"])(value, jsonDate) : (0, _moment["default"])(value);
            break;
          }

        case _enum.FieldType.json:
          value = JSON.parse(value);
          break;

        default:
      }
    }
  }

  return value;
}

function processValue(value, field, isCreated) {
  if (field) {
    var multiple = field.get('multiple');
    var range = field.get('range');

    if (multiple && field.type !== _enum.FieldType.attachment) {
      if ((0, _isEmpty3["default"])(value)) {
        if (isCreated) {
          // for defaultValue
          value = undefined;
        } else {
          value = [];
        }
      } else if (!(0, _isArray["default"])(value)) {
        if ((0, _isString["default"])(multiple) && (0, _isString["default"])(value)) {
          value = value.split(multiple);
        } else {
          value = [value];
        }
      }
    }

    if ((0, _isArray["default"])(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 = (0, _moment.isMoment)(item) ? item.format() : (0, _isObject["default"])(item) ? item[field.get('textField')] : item.toString();
    return valueRange;
  }).join("~");
};

function processExportValue(value, field) {
  if (field) {
    var multiple = field.get('multiple');
    var range = field.get('range');

    if (multiple) {
      if ((0, _isEmpty3["default"])(value)) {
        value = [];
      } else if (!(0, _isArray["default"])(value)) {
        if ((0, _isString["default"])(multiple) && (0, _isString["default"])(value)) {
          value = value.split(multiple);
        } else {
          value = [value];
        }
      }
    }

    if ((0, _isArray["default"])(value) && (multiple || !range)) {
      if (field && !(0, _isEmpty2["default"])(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 && (0, _isObject["default"])(itemValue)) {
          return itemValue[field.get('textField')];
        }

        return itemValue;
      }).join(',');
    }

    if ((0, _isArray["default"])(value) && multiple && range) {
      if (field && !(0, _isEmpty2["default"])(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 && !(0, _isEmpty2["default"])(field.lookup)) {
      return field.getText(processOne(value, field));
    }

    var resultValue = processOne(value, field);

    if ((0, _moment.isMoment)(resultValue)) {
      return resultValue.format();
    }

    if (field && field.get('textField') && resultValue && (0, _isObject["default"])(resultValue)) {
      if (range && (0, _mobx.isArrayLike)(resultValue)) {
        return processRangeToText(resultValue, field);
      }

      return resultValue[field.get('textField')];
    }

    return resultValue;
  }

  return value;
}
/**
 * 实现如果名字是带有属性含义`.`找到能够导出的值
 * @param dataItem 一行数据
 * @param name 对应的fieldname
 * @param isBind 是否是从绑定获取值
 */


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 (!(0, _isObject["default"])(levelValue)) {
        break;
      }

      if (isBind || i !== 0) {
        levelValue = levelValue[nameArray[i]];
      }
    }

    return levelValue;
  }

  if (isBind) {
    return dataItem ? dataItem[name] : undefined;
  }

  return dataItem;
}

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);
}

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 ((0, _isString["default"])(a) || (0, _isString["default"])(b)) {
        return order === _enum.SortOrder.asc ? String(a).localeCompare(String(b)) : String(b).localeCompare(String(a));
      }

      return order === _enum.SortOrder.asc ? a - b : b - a;
    });
  }

  return children;
} // 获取单个页面能够展示的数据


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 (!(0, _isNil["default"])(id)) {
        var node = {
          item: item,
          children: []
        };
        itemMap.set(id, node);
        rootMap.set(id, node);
      }
    });
    (0, _toConsumableArray2["default"])(itemMap.entries()).forEach(function (_ref2) {
      var _ref3 = (0, _slicedToArray2["default"])(_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 (0, _treeUtils.treeReduce)((0, _toConsumableArray2["default"])(rootMap.values()).slice(0, pageSize), function (previousValue, node) {
      return previousValue.concat(node.item);
    }, []);
  }

  return [];
}

function checkParentByInsert(_ref4) {
  var parent = _ref4.parent;

  if (parent && !parent.current) {
    throw new Error((0, _localeContext.$l)('DataSet', 'cannot_add_record_when_head_no_current'));
  }
}

function getValueType(value) {
  return (0, _isBoolean["default"])(value) ? _enum.FieldType["boolean"] : (0, _isNumber["default"])(value) ? _enum.FieldType.number : (0, _isString["default"])(value) ? _enum.FieldType.string : (0, _moment.isMoment)(value) ? _enum.FieldType.date : (0, _isObject["default"])(value) ? _enum.FieldType.object : _enum.FieldType.auto;
}

function getBaseType(type) {
  switch (type) {
    case _enum.FieldType.number:
    case _enum.FieldType.currency:
      return _enum.FieldType.number;

    case _enum.FieldType.dateTime:
    case _enum.FieldType.time:
    case _enum.FieldType.week:
    case _enum.FieldType.month:
    case _enum.FieldType.year:
      return _enum.FieldType.date;

    case _enum.FieldType.intl:
    case _enum.FieldType.url:
    case _enum.FieldType.email:
      return _enum.FieldType.string;

    default:
      return type;
  }
}

function checkFieldType(value, field) {
  if (process.env.NODE_ENV !== 'production' && !(0, _isEmpty3["default"])(value)) {
    var fieldType = getBaseType(field.type);

    if (fieldType !== _enum.FieldType.auto) {
      if ((0, _mobx.isArrayLike)(value)) {
        return value.every(function (item) {
          return checkFieldType(item, field);
        });
      }

      var valueType = field.type === _enum.FieldType["boolean"] && [field.get(_enum.BooleanValue.trueValue), field.get(_enum.BooleanValue.falseValue)].includes(value) ? _enum.FieldType["boolean"] : getValueType(value);

      if (fieldType !== _enum.FieldType.reactNode && fieldType !== valueType) {
        (0, _warning["default"])(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请求
 */

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 = (0, _toConsumableArray2["default"])(map.keys());
  throw new Error("DataSet: Cycle binding fields[".concat((0, _toConsumableArray2["default"])(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;
}

function getChainFieldName(record, fieldName) {
  return getChainFieldNamePrivate(record, fieldName);
}

function findBindTargetFields(myField, fields, deep) {
  var bindFields = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
  var bind = myField.get('bind');

  if (bind) {
    (0, _toConsumableArray2["default"])(fields.entries()).some(function (_ref5) {
      var _ref6 = (0, _slicedToArray2["default"])(_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 (0, _toConsumableArray2["default"])(bindFields.values());
}

function findBindFields(myField, fields, deep) {
  var bindFields = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
  var name = myField.name;
  (0, _toConsumableArray2["default"])(fields.entries()).forEach(function (_ref7) {
    var _ref8 = (0, _slicedToArray2["default"])(_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 (0, _toConsumableArray2["default"])(bindFields.values());
}

function findBindField(myField, chainFieldName, record) {
  return (0, _toConsumableArray2["default"])(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 || ''));
}

function getFieldSorter(field) {
  var name = field.name;

  switch (field.type) {
    case _enum.FieldType.number:
    case _enum.FieldType.currency:
    case _enum.FieldType.date:
    case _enum.FieldType.dateTime:
    case _enum.FieldType.week:
    case _enum.FieldType.month:
    case _enum.FieldType.year:
    case _enum.FieldType.time:
      return field.order === _enum.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 === _enum.SortOrder.asc ? function (a, b) {
        return stringSorter(a.get(name), b.get(name));
      } : function (a, b) {
        return stringSorter(b.get(name), a.get(name));
      };
  }
}

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);
  }
}

function prepareSubmitData(records, dataToJSON) {
  var created = [];
  var updated = [];
  var destroyed = [];

  function storeWith(status) {
    switch (status) {
      case _enum.RecordStatus.add:
        return created;

      case _enum.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 ((0, _isString["default"])(config)) {
    return {
      url: config
    };
  }

  if (typeof config === 'function') {
    return config((0, _objectSpread2["default"])({}, options, {
      data: data,
      dataSet: dataSet,
      params: params
    }));
  }

  return config;
}

function axiosConfigAdapter(type, dataSet, data, params, options) {
  var newConfig = {
    data: data,
    params: params,
    method: 'post'
  };

  var _ref9 = (0, _configure.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) {
    (0, _extends2["default"])(newConfig, generateConfig(globalConfig, dataSet, data, params, options));
  }

  if (config) {
    (0, _extends2["default"])(newConfig, generateConfig(config, dataSet, data, params, options));
  }

  if (newConfig.data && newConfig.method && newConfig.method.toLowerCase() === 'get') {
    newConfig.params = (0, _objectSpread2["default"])({}, newConfig.params, {}, newConfig.data);
  }

  return (adapter || globalAdapter)(newConfig, type) || newConfig;
} // 查询顶层父亲节点


function findRootParent(children) {
  if (children.parent) {
    return findRootParent(children.parent);
  }

  return children;
}

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 [];
}

function generateResponseData(item, dataKey) {
  if (item) {
    if ((0, _isArray["default"])(item)) {
      return item;
    }

    if ((0, _isObject["default"])(item)) {
      if (dataKey) {
        var result = ObjectChainValue.get(item, dataKey);

        if (result === undefined) {
          return [item];
        }

        if ((0, _isArray["default"])(result)) {
          return result;
        }

        if ((0, _isObject["default"])(result)) {
          return [result];
        }
      } else {
        return [item];
      }
    }
  }

  return [];
}

function getRecordValue(record, cb, fieldName) {
  if (fieldName) {
    if ((0, _mobx.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(_enum.BooleanValue.trueValue) : true;
        var falseValue = field ? field.get(_enum.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);
  }
}

function processIntlField(name, fieldProps, callback, dataSet) {
  if (fieldProps.type === _enum.FieldType.intl) {
    var transformRequest = fieldProps.transformRequest;
    var tlsKey = (0, _configure.getConfig)('tlsKey');
    var supports = _localeContext["default"].supports;
    var languages = Object.keys(supports);
    languages.forEach(function (language) {
      return callback("".concat(tlsKey, ".").concat(name, ".").concat(language), {
        type: _enum.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["default"].locale.lang) === language) {
                return name;
              }
            }
          }
        }
      });
    });
  }

  return callback(name, fieldProps);
}

function findBindFieldBy(myField, fields, prop) {
  var value = myField.get(prop);
  var myName = myField.name;
  return (0, _toConsumableArray2["default"])(fields.values()).find(function (field) {
    var bind = field.get('bind');
    return bind && bind === "".concat(myName, ".").concat(value);
  });
}

function getLimit(limit, record) {
  if ((0, _isString["default"])(limit) && record.getField(limit)) {
    return record.get(limit);
  }

  return limit;
}

function adapterDataToJSON(isSelected, noCascade) {
  if (isSelected) {
    if (noCascade) {
      return _enum.DataToJSON['selected-self'];
    }

    return _enum.DataToJSON.selected;
  }

  if (noCascade) {
    return _enum.DataToJSON['dirty-self'];
  }

  return undefined;
}

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
  };
}

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
  };
}

function getUniqueFieldNames(dataSet) {
  var keys = [];
  (0, _toConsumableArray2["default"])(dataSet.fields.entries()).forEach(function (_ref11) {
    var _ref12 = (0, _slicedToArray2["default"])(_ref11, 2),
        key = _ref12[0],
        field = _ref12[1];

    if (field.get('unique')) {
      keys.push(key);
    }
  });
  return keys;
}

function getUniqueKeysAndPrimaryKey(dataSet) {
  if (dataSet) {
    var keys = getUniqueFieldNames(dataSet);
    var primaryKey = dataSet.props.primaryKey;

    if (primaryKey) {
      keys.push(primaryKey);
    }

    return keys;
  }

  return [];
}

function isDirtyRecord(record) {
  return record.status !== _enum.RecordStatus.sync || record.dirty;
}

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


function fixAxiosConfig(config) {
  var method = config.method;

  if (method && method.toLowerCase() === 'get') {
    delete config.data;
  }

  return config;
}

var EMPTY_GROUP_KEY = '__empty_group__';

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 导出表单的名字
 */


function exportExcel(data, excelName) {
  Promise.resolve().then(function () {
    return (0, _interopRequireWildcard2["default"])(require('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文件名称) */
  });
}

function getSortedFields(fields) {
  var normalFields = [];
  var objectBindFields = [];
  var bindFields = [];
  var transformResponseField = [];
  var dynamicFields = [];
  var dynamicObjectBindFields = [];
  var dynamicBindFields = [];
  (0, _toConsumableArray2["default"])(fields.entries()).forEach(function (entry) {
    var _entry = (0, _slicedToArray2["default"])(entry, 2),
        field = _entry[1];

    var dynamicProps = field.get('computedProps') || field.get('dynamicProps');

    if (dynamicProps) {
      if (dynamicProps.bind) {
        if (field.type === _enum.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 === _enum.FieldType.object) {
            dynamicObjectBindFields.push(entry);
          } else {
            dynamicBindFields.push(entry);
          }
        } else if (field.get('transformResponse')) {
          transformResponseField.push(entry);
        } else if (field.type === _enum.FieldType.object) {
          objectBindFields.push(entry);
        } else {
          bindFields.push(entry);
        }
      } else {
        normalFields.push(entry);
      }
    }
  });
  return [].concat(normalFields, objectBindFields, bindFields, transformResponseField, dynamicFields, dynamicObjectBindFields, dynamicBindFields);
}

function concurrentPromise(_x, _x2) {
  return _concurrentPromise.apply(this, arguments);
}

function _concurrentPromise() {
  _concurrentPromise = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee2(promiseLoaders, cancelFnc) {
    var promiseLoadersLength, fail;
    return _regenerator["default"].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 = (0, _asyncToGenerator2["default"])(
                /*#__PURE__*/
                _regenerator["default"].mark(function _callee(getPromise, index) {
                  var res, _promiseLoaders$curre;

                  return _regenerator["default"].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);
}

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);
      });
    }
  }
}

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);
      });
    }
  }
}

function treeSelectParent(dataSet, record, selected) {
  var parent = record.parent;

  if (parent && !parent.isSelected) {
    dataSet.select(parent);
    selected.push(parent);
    treeSelectParent(dataSet, parent, selected);
  }
}

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);
    }
  }
}

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