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

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

"use strict";

var _interopRequireWildcard = 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.append = append;
exports.getOrderFields = getOrderFields;
exports.processToJSON = processToJSON;
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.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.processFieldValue = processFieldValue;
exports.getLimit = getLimit;
exports.adapterDataToJSON = adapterDataToJSON;
exports.generateData = generateData;
exports.generateJSONData = generateJSONData;
exports.isDirtyRecord = isDirtyRecord;
exports.getSpliceRecord = getSpliceRecord;
exports.fixAxiosConfig = fixAxiosConfig;
exports.normalizeGroups = normalizeGroups;
exports.exportExcel = exportExcel;
exports.arrayMove = void 0;

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

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

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

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

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

var _moment = _interopRequireWildcard(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 _xlsx = _interopRequireDefault(require("xlsx"));

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

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

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

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

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

var _formatNumber = _interopRequireDefault(require("../formatter/formatNumber"));

var _formatCurrency = _interopRequireDefault(require("../formatter/formatCurrency"));

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

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.selected, _enum.DataToJSON.all, _enum.DataToJSON.normal].includes(dataToJSON);
}

function useDirty(dataToJSON) {
  return [_enum.DataToJSON.dirty, _enum.DataToJSON['dirty-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 processToJSON(value) {
  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;
  }

  return value;
}

var arrayMove = 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);
};

exports.arrayMove = arrayMove;

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 _range = (0, _slicedToArray2["default"])(range, 2),
              start = _range[0],
              end = _range[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 = Number(value);
          } 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;
          }

        default:
      }
    }
  }

  return value;
}

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

    if (multiple) {
      if ((0, _isEmpty3["default"])(value)) {
        if (init) {
          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[name];
  }

  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 availableTree(idField, parentField, parentId, allData) {
  var result = [];
  allData.forEach(function (element) {
    if (element[parentField] === parentId) {
      var childresult = availableTree(idField, parentField, element[idField], allData);
      result = result.concat(element).concat(childresult);
    }
  });
  return result;
} // 获取单个页面能够展示的数据


function sliceTree(idField, parentField, allData, pageSize) {
  var availableTreeData = [];

  if (allData.length) {
    var parentLength = 0;
    allData.forEach(function (item) {
      if (item) {
        if ((0, _isNil["default"])(item[parentField]) && !(0, _isNil["default"])(idField) && parentLength < pageSize) {
          parentLength++;
          var childresult = availableTree(idField, parentField, item[idField], allData);
          availableTreeData = availableTreeData.concat(item).concat(childresult);
        }
      }
    });
  }

  return availableTreeData;
}

function checkParentByInsert(_ref2) {
  var parent = _ref2.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') {
    if (!(0, _isEmpty3["default"])(value)) {
      if ((0, _mobx.isArrayLike)(value)) {
        return value.every(function (item) {
          return checkFieldType(item, field);
        });
      }

      var fieldType = getBaseType(field.type);
      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.auto && 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 findBindFields(myField, fields, excludeSelf) {
  var name = myField.name;
  return (0, _toConsumableArray2["default"])(fields.values()).filter(function (field) {
    if (field !== myField) {
      var bind = field.get('bind'); // 处理 addField 后校验问题
      // return isString(bind) ? bind.startsWith(`${name}.`) : !excludeSelf;

      return (0, _isString["default"])(bind) && bind.startsWith("".concat(name, "."));
    }

    return !excludeSelf;
  });
}

function findBindField(myField, fields, callback) {
  var name = (0, _isString["default"])(myField) ? myField : myField.name;
  return (0, _toConsumableArray2["default"])(fields.values()).find(function (field) {
    if (field.name !== name) {
      var bind = field.get('bind');
      return (0, _isString["default"])(bind) && bind.startsWith("".concat(name, ".")) && (!callback || callback(field));
    }

    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) || 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 _ref3 = (0, _configure.getConfig)('transport') || {},
      globalConfig = _ref3[type],
      _ref3$adapter = _ref3.adapter,
      globalAdapter = _ref3$adapter === void 0 ? defaultAxiosConfigAdapter : _ref3$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(data, cb, fieldName) {
  if (fieldName) {
    var field = this.getField(fieldName);

    if (field) {
      var bind = field.get('bind');

      if (bind) {
        fieldName = bind;
      }
    }

    var dataSet = this.dataSet;

    if (dataSet) {
      var checkField = dataSet.props.checkField;

      if (checkField && checkField === fieldName) {
        var trueValue = field ? field.get(_enum.BooleanValue.trueValue) : true;
        var falseValue = field ? field.get(_enum.BooleanValue.falseValue) : false;
        var children = this.children;

        if (children) {
          return children.every(function (child) {
            return cb(child, checkField) === trueValue;
          }) ? trueValue : falseValue;
        }
      }
    }

    return ObjectChainValue.get(data, fieldName);
  }
}

function tlsBind(props, name, lang, tlsKey) {
  var tls = props.record.get(tlsKey) || {};

  if (name in tls) {
    return "".concat(tlsKey, ".").concat(name, ".").concat(lang);
  }
}

function processIntlField(name, fieldProps, callback, dataSet) {
  if (fieldProps.type === _enum.FieldType.intl) {
    var dynamicProps = fieldProps.dynamicProps;
    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])
      });
    });

    var _ref4 = dataSet || {},
        _ref4$lang = _ref4.lang,
        lang = _ref4$lang === void 0 ? _localeContext["default"].locale.lang : _ref4$lang;

    var newDynamicProps = typeof dynamicProps === 'function' ? function (props) {
      return (0, _objectSpread2["default"])({}, dynamicProps(props), {
        bind: tlsBind(props, name, lang, tlsKey)
      });
    } : (0, _objectSpread2["default"])({}, dynamicProps, {
      bind: function bind(props) {
        return tlsBind(props, name, lang, tlsKey);
      }
    });
    return callback(name, (0, _objectSpread2["default"])({}, fieldProps, {
      dynamicProps: newDynamicProps
    }));
  }

  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 processNumberOptions(field, options) {
  var precision = field.get('precision');
  var numberGrouping = field.get('numberGrouping');

  if ((0, _isNumber["default"])(precision)) {
    options.minimumFractionDigits = precision;
    options.maximumFractionDigits = precision;
  }

  if (numberGrouping === false) {
    options.useGrouping = false;
  }

  return options;
}

function processFieldValue(value, field, defaultLang, showValueIfNotFound) {
  var type = field.type;
  var formatterOptions = field.get('formatterOptions') || {};
  var numberFieldFormatterOptions = (0, _configure.getConfig)('numberFieldFormatterOptions') || {};

  if (type === _enum.FieldType.number) {
    var precisionInValue = (0, _utils.getPrecision)(value || 0);
    return (0, _formatNumber["default"])(value, formatterOptions.lang || numberFieldFormatterOptions.lang || defaultLang, processNumberOptions(field, (0, _objectSpread2["default"])({
      minimumFractionDigits: precisionInValue,
      maximumFractionDigits: precisionInValue
    }, numberFieldFormatterOptions.options, {}, formatterOptions.options)));
  }

  if (type === _enum.FieldType.currency) {
    return (0, _formatCurrency["default"])(value, formatterOptions.lang || defaultLang, processNumberOptions(field, (0, _objectSpread2["default"])({
      currency: field.get('currency')
    }, formatterOptions.options)));
  }

  return field.getText(value, showValueIfNotFound);
}

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 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) {
  var ws = _xlsx["default"].utils.json_to_sheet(data, {
    skipHeader: true
  });
  /* 新建空workbook，然后加入worksheet */


  var wb = _xlsx["default"].utils.book_new();
  /* 新建book */


  _xlsx["default"].utils.book_append_sheet(wb, ws);
  /* 生成xlsx文件(book,sheet数据,sheet命名) */


  _xlsx["default"].writeFile(wb, "".concat(excelName, ".xlsx"));
  /* 写文件(book,xlsx文件名称) */

}
//# sourceMappingURL=utils.js.map