choerodon-ui/pro/es/data-set/Record.js

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

import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import { __decorate } from "tslib";
import { action, computed, isArrayLike, isObservableArray, isObservableObject, observable, runInAction, toJS } from 'mobx';
import merge from 'lodash/merge';
import isObject from 'lodash/isObject';
import pick from 'lodash/pick';
import isNil from 'lodash/isNil';
import isString from 'lodash/isString';
import isNumber from 'lodash/isNumber';
import omit from 'lodash/omit';
import isPlainObject from 'lodash/isPlainObject';
import { getConfig } from '../../../es/configure';
import DataSet, { addRecordField } from './DataSet';
import { axiosConfigAdapter, checkFieldType, childrenInfoForDelete, findBindField, findBindFields, findBindTargetFields, generateData, generateJSONData, generateResponseData, getChainFieldName, getIf, getRecordValue, getSortedFields, getUniqueKeysAndPrimaryKey, isDirtyRecord, processToJSON, processValue, useCascade, useDirtyField, useNormal, useSelected } from './utils';
import * as ObjectChainValue from '../_util/ObjectChainValue';
import { BooleanValue, DataSetEvents, DataSetSelection, FieldIgnore, FieldType, RecordStatus } from './enum';
import isSame from '../_util/isSame';
import { treeReduce as _treeReduce } from '../_util/treeUtils';
/**
 * 记录ID生成器
 */

var IDGen =
/*#__PURE__*/
_regeneratorRuntime.mark(function _callee(start) {
  return _regeneratorRuntime.wrap(function _callee$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!true) {
            _context.next = 5;
            break;
          }

          _context.next = 3;
          return ++start;

        case 3:
          _context.next = 0;
          break;

        case 5:
        case "end":
          return _context.stop();
      }
    }
  }, _callee);
})(1000);

var EXPANDED_KEY = '__EXPANDED_KEY__'; // TODO:Symbol

var SELECTABLE_KEY = '__SELECTABLE_KEY__'; // TODO:Symbol

var SELECT_KEY = '__SELECT_KEY__'; // TODO:Symbol

var UNSELECT_KEY = '__UNSELECT_KEY__'; // TODO:Symbol

var Record =
/*#__PURE__*/
function () {
  function Record() {
    var _this = this;

    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var dataSet = arguments.length > 1 ? arguments[1] : undefined;
    var status = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : RecordStatus.add;

    _classCallCheck(this, Record);

    runInAction(function () {
      var initData = isObservableObject(data) ? toJS(data) : data;
      _this.fields = observable.map();
      _this.status = status;
      _this.selectable = true;
      _this.isSelected = false;
      _this.id = IDGen.next().value;
      _this.data = initData;

      if (dataSet) {
        _this.dataSet = dataSet;
        var fields = dataSet.fields;

        if (fields) {
          _this.initFields(fields);
        }
      }

      _this.processData(initData);
    });
  }

  _createClass(Record, [{
    key: "toData",

    /**
     * 转换成普通数据
     * 一般用于父级联数据源中的json类型字段
     * 禁止通过此方法获取某一个或几个字段值
     */
    value: function toData(needIgnore, noCascade, isCascadeSelect) {
      var all = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
      var status = this.status,
          dataSet = this.dataSet,
          fields = this.fields;
      var dataToJSON = dataSet && dataSet.dataToJSON;
      var cascade = noCascade === undefined && dataToJSON ? useCascade(dataToJSON) : !noCascade;
      var normal = all || dataToJSON && useNormal(dataToJSON);
      var dirty = status !== RecordStatus.sync;
      var childrenKeys = cascade && dataSet ? Object.keys(dataSet.children) : undefined;

      var jsonFieldKeys = childrenKeys && _toConsumableArray(fields.entries()).reduce(function (fieldKeys, _ref) {
        var _ref2 = _slicedToArray(_ref, 2),
            key = _ref2[0],
            field = _ref2[1];

        if (field.type === FieldType.json && childrenKeys.some(function (childKey) {
          return key === childKey || childKey.startsWith("".concat(key, "."));
        })) {
          fieldKeys.push(key);
        }

        return fieldKeys;
      }, []);

      var json = this.normalizeData(needIgnore, jsonFieldKeys);

      if (cascade && this.normalizeCascadeData(json, normal, isCascadeSelect)) {
        dirty = true;
      }

      if (jsonFieldKeys) {
        jsonFieldKeys.forEach(function (key) {
          return ObjectChainValue.set(json, key, JSON.stringify(ObjectChainValue.get(json, key)), fields);
        });
      }

      return _objectSpread({}, json, {
        __dirty: dirty
      });
    }
    /**
     * 转换成用于提交的数据
     */

  }, {
    key: "toJSONData",
    value: function toJSONData(noCascade, isCascadeSelect) {
      var status = this.status;
      return _objectSpread({}, this.toData(true, noCascade, isCascadeSelect, false), _defineProperty({
        __id: this.id
      }, getConfig('statusKey'), getConfig('status')[status === RecordStatus.sync ? RecordStatus.update : status]));
    }
  }, {
    key: "validate",
    value: function validate(all, noCascade) {
      var _this2 = this;

      var dataSet = this.dataSet;
      this.validating = true;
      var promises = [];

      if (all || this.status !== RecordStatus.sync) {
        _toConsumableArray(this.fields.values()).forEach(function (field) {
          return promises.push(field.checkValidity(false));
        });
      }

      if (!noCascade && dataSet) {
        var childrenKeys = Object.keys(dataSet.children);

        if (childrenKeys.length) {
          var dataSetSnapshot = this.dataSetSnapshot,
              isCurrent = this.isCurrent;
          childrenKeys.forEach(function (key) {
            var children = dataSet.children;
            var snapshot = dataSetSnapshot && dataSetSnapshot[key];
            var ds = children[key];
            var child = isCurrent ? ds : snapshot && new DataSet().restore(snapshot);

            if (child) {
              promises.push(child.validate());
            } else {
              var dataToJSON = ds.dataToJSON;
              var cascade = noCascade === undefined && dataToJSON ? useCascade(dataToJSON) : !noCascade;
              ((useSelected(dataToJSON) ? _this2.getCascadeSelectedRecords(key) : _this2.getCascadeRecords(key)) || []).forEach(function (record) {
                return promises.push(record.validate(false, !cascade));
              });
            }
          });
        }
      }

      return Promise.all(promises).then(function (results) {
        var valid = results.every(function (result) {
          return result;
        });

        _this2.reportValidity(valid);

        delete _this2.validating;
        return valid;
      })["catch"](function (error) {
        delete _this2.validating;
        throw error;
      });
    }
  }, {
    key: "reportValidity",
    value: function reportValidity(result) {
      var _this3 = this;

      var dataSet = this.dataSet;

      if (dataSet && !dataSet.validating) {
        var prepareForReport = getIf(this, 'prepareForReport', {});

        if (!result) {
          prepareForReport.result = result;
        }

        if (prepareForReport.timeout) {
          window.clearTimeout(prepareForReport.timeout);
        }

        prepareForReport.timeout = window.setTimeout(function () {
          dataSet.reportValidity(prepareForReport.result || true);
          delete _this3.prepareForReport;
        }, 200);
      }
    }
  }, {
    key: "getValidationErrors",
    value: function getValidationErrors() {
      return _toConsumableArray(this.fields.values()).reduce(function (results, field) {
        if (!field.valid) {
          results.push({
            field: field,
            errors: field.getValidationErrorValues()
          });
        }

        return results;
      }, []);
    }
  }, {
    key: "getField",
    value: function getField(fieldName) {
      if (fieldName) {
        return this.fields.get(fieldName);
      }
    }
  }, {
    key: "getCascadeRecordsIncludeDelete",
    value: function getCascadeRecordsIncludeDelete(fieldName) {
      var dataSet = this.dataSet;

      if (fieldName && dataSet) {
        var childDataSet = dataSet.children[fieldName];

        if (childDataSet) {
          if (this.isCurrent) {
            return childDataSet.records.slice();
          }

          var dataSetSnapshot = this.dataSetSnapshot;
          var snapshot = dataSetSnapshot && dataSetSnapshot[fieldName];

          if (snapshot) {
            return snapshot.records;
          }

          var cascadeRecordsMap = getIf(this, 'cascadeRecordsMap', {});
          var cascadeRecords = cascadeRecordsMap[fieldName];

          if (cascadeRecords) {
            return cascadeRecords;
          }

          var data = this.get(fieldName);
          var cascading = getIf(this, 'cascading', {});

          if (!cascading[fieldName] && isObservableArray(data)) {
            cascading[fieldName] = true;
            var records = childDataSet.processData(data, this.isNew ? RecordStatus.add : RecordStatus.sync);
            delete cascading[fieldName];
            cascadeRecordsMap[fieldName] = records;
            return records;
          }
        }
      }
    }
  }, {
    key: "getCascadeRecords",
    value: function getCascadeRecords(fieldName) {
      var records = this.getCascadeRecordsIncludeDelete(fieldName);

      if (records) {
        return records.filter(function (r) {
          return !r.isRemoved;
        });
      }
    }
  }, {
    key: "getCascadeSelectedRecordsIncludeDelete",
    value: function getCascadeSelectedRecordsIncludeDelete(fieldName) {
      var records = this.getCascadeRecordsIncludeDelete(fieldName);

      if (records) {
        return records.filter(function (r) {
          return r.isSelected;
        });
      }
    }
  }, {
    key: "getCascadeSelectedRecords",
    value: function getCascadeSelectedRecords(fieldName) {
      var records = this.getCascadeRecordsIncludeDelete(fieldName);

      if (records) {
        return records.filter(function (r) {
          return !r.isRemoved && r.isSelected;
        });
      }
    }
  }, {
    key: "get",
    value: function get(fieldName) {
      return getRecordValue(this, function (child, checkField) {
        return child.get(checkField);
      }, fieldName);
    }
  }, {
    key: "set",
    value: function set(item, value) {
      var _this4 = this;

      if (isString(item)) {
        var oldName = item;
        var fieldName = getChainFieldName(this, oldName);
        var field = this.getField(oldName) || this.getField(fieldName) || findBindField(oldName, fieldName, this) || addRecordField(this, oldName);
        checkFieldType(value, field);
        var oldValue = toJS(this.get(fieldName));
        var newValue = processValue(value, field);
        var newValueForCompare = processToJSON(newValue, field);

        if (!isSame(processToJSON(oldValue, field), newValueForCompare)) {
          var _fields = this.fields;
          ObjectChainValue.set(this.data, fieldName, newValue, _fields);
          var dirtyData = getIf(this, 'dirtyData', function () {
            return observable.map();
          });

          if (!dirtyData.has(fieldName)) {
            dirtyData.set(fieldName, oldValue);

            if (this.status === RecordStatus.sync) {
              this.status = RecordStatus.update;
            }
          } else if (isSame(processToJSON(dirtyData.get(fieldName), field), newValueForCompare)) {
            dirtyData["delete"](fieldName);

            if (this.status === RecordStatus.update && dirtyData.size === 0 && _toConsumableArray(_fields.values()).every(function (f) {
              return !f.dirty;
            })) {
              this.status = RecordStatus.sync;
            }
          }

          var dataSet = this.dataSet;

          if (dataSet) {
            dataSet.fireEvent(DataSetEvents.update, {
              dataSet: dataSet,
              record: this,
              name: oldName,
              value: newValue,
              oldValue: oldValue
            });
            var checkField = dataSet.props.checkField;

            if (checkField && fieldName === getChainFieldName(this, checkField)) {
              var children = this.children;

              if (children) {
                children.forEach(function (record) {
                  return record.set(fieldName, value);
                });
              }
            }
          }
        }

        var fields = this.fields;
        [field].concat(_toConsumableArray(findBindFields(field, fields, true)), _toConsumableArray(findBindTargetFields(field, fields, true))).forEach(function (oneField) {
          return oneField.checkValidity(false);
        });
      } else if (isPlainObject(item)) {
        Object.keys(item).forEach(function (key) {
          return _this4.set(key, item[key]);
        });
      }

      return this;
    }
  }, {
    key: "getPristineValue",
    value: function getPristineValue(fieldName) {
      if (fieldName) {
        var chainFieldName = getChainFieldName(this, fieldName);
        var dirtyData = this.dirtyData;

        if (dirtyData && dirtyData.has(chainFieldName)) {
          return dirtyData.get(chainFieldName);
        }

        return this.get(chainFieldName);
      }
    }
  }, {
    key: "init",
    value: function init(item, value) {
      var _this5 = this;

      var fields = this.fields,
          data = this.data,
          dirtyData = this.dirtyData;

      if (isString(item)) {
        var oldName = item;
        var fieldName = getChainFieldName(this, oldName);
        var field = this.getField(oldName) || this.getField(fieldName) || findBindField(oldName, fieldName, this) || addRecordField(this, fieldName);
        var newValue = processValue(value, field);

        if (dirtyData) {
          dirtyData["delete"](fieldName);
        }

        ObjectChainValue.set(data, fieldName, newValue, fields);
        field.commit();
      } else if (isPlainObject(item)) {
        Object.keys(item).forEach(function (key) {
          return _this5.init(key, item[key]);
        });
      }

      return this;
    }
  }, {
    key: "clone",
    value: function clone() {
      var dataSet = this.dataSet;
      var cloneData = this.toData();

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

        if (primaryKey) {
          delete cloneData[primaryKey];
        }

        return new Record(cloneData, dataSet);
      }

      return new Record(cloneData);
    }
  }, {
    key: "ready",
    value: function ready() {
      return Promise.resolve(true); // return Promise.all([...this.fields.values()].map(field => field.ready()));
    }
  }, {
    key: "tls",
    value: function () {
      var _tls = _asyncToGenerator(
      /*#__PURE__*/
      _regeneratorRuntime.mark(function _callee2(name) {
        var _this6 = this;

        var tlsKey, dataSet, tlsData, axios, lang, primaryKey, newConfig, result, dataKey;
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                tlsKey = getConfig('tlsKey');
                dataSet = this.dataSet;

                if (!(dataSet && name)) {
                  _context2.next = 16;
                  break;
                }

                tlsData = this.get(tlsKey) || {};

                if (name in tlsData) {
                  _context2.next = 16;
                  break;
                }

                axios = dataSet.axios, lang = dataSet.lang;
                primaryKey = dataSet.props.primaryKey;
                newConfig = axiosConfigAdapter('tls', dataSet, {}, primaryKey && {
                  key: this.get(primaryKey)
                }, {
                  name: name,
                  record: this
                });

                if (!(newConfig.url && !this.isNew)) {
                  _context2.next = 15;
                  break;
                }

                _context2.next = 11;
                return axios(newConfig);

              case 11:
                result = _context2.sent;

                if (result) {
                  dataKey = getConfig('dataKey');
                  this.commitTls(generateResponseData(result, dataKey)[0], name);
                }

                _context2.next = 16;
                break;

              case 15:
                this.commitTls(_toConsumableArray(this.fields.entries()).reduce(function (data, _ref3) {
                  var _ref4 = _slicedToArray(_ref3, 2),
                      key = _ref4[0],
                      field = _ref4[1];

                  if (field.type === FieldType.intl) {
                    data[key] = _defineProperty({}, lang, _this6.get(key));
                  }

                  return data;
                }, {}), name);

              case 16:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function tls(_x) {
        return _tls.apply(this, arguments);
      }

      return tls;
    }()
  }, {
    key: "reset",
    value: function reset() {
      var status = this.status,
          fields = this.fields,
          dataSet = this.dataSet,
          dirty = this.dirty,
          isRemoved = this.isRemoved;

      _toConsumableArray(fields.values()).forEach(function (field) {
        return field.commit();
      });

      if (status === RecordStatus.update || isRemoved) {
        this.status = RecordStatus.sync;
      }

      if (isRemoved || dirty) {
        this.data = toJS(this.pristineData);
        this.dirtyData = undefined;
        this.memo = undefined;

        if (dataSet && !dataSet.resetInBatch) {
          dataSet.fireEvent(DataSetEvents.reset, {
            records: [this],
            dataSet: dataSet
          });
        }
      }

      return this;
    }
  }, {
    key: "save",
    value: function save() {
      this.memo = toJS(this.data);
      return this;
    }
  }, {
    key: "restore",
    value: function restore() {
      var memo = this.memo;

      if (memo) {
        this.set(memo);
        this.memo = undefined;
      }

      return this;
    }
  }, {
    key: "clear",
    value: function clear() {
      return this.set(_toConsumableArray(this.fields.keys()).reduce(function (obj, key) {
        obj[key] = null;
        return obj;
      }, {}));
    }
  }, {
    key: "commit",
    value: function commit(data, dataSet) {
      var _this7 = this;

      if (dataSet) {
        var records = this.records;

        if (this.isRemoved) {
          var index = records.indexOf(this);

          if (index !== -1) {
            if (dataSet.records === records) {
              dataSet.totalCount -= 1;
            }

            records.splice(index, 1);
          }

          return this;
        }

        if (this.isNew) {
          var _index = records.indexOf(this);

          if (_index !== -1 && dataSet.records === records) {
            dataSet.totalCount += 1;
          }
        }

        if (data) {
          this.data = data;
          this.processData(data, true);
          var children = dataSet.children;
          var keys = Object.keys(children);

          if (keys.length) {
            var isCurrent = this.isCurrent;
            var tmpDs = new DataSet();
            var dataSetSnapshot = getIf(this, 'dataSetSnapshot', {});
            keys.forEach(function (key) {
              var snapshot = dataSetSnapshot[key];
              var ds = children[key];
              var child = isCurrent ? ds : snapshot && tmpDs.restore(snapshot);

              if (child) {
                dataSetSnapshot[key] = child.commitData(data[key] || []).snapshot();
              } else {
                var cascadeRecords = _this7.getCascadeRecordsIncludeDelete(key);

                if (cascadeRecords) {
                  cascadeRecords.forEach(function (r) {
                    return r.commit(omit(r.toData(), ['__dirty']), ds);
                  });
                }
              }
            });
          }
        }
      }

      this.dirtyData = undefined;

      _toConsumableArray(this.fields.values()).forEach(function (field) {
        return field.commit();
      });

      this.status = RecordStatus.sync;
      return this;
    }
  }, {
    key: "setState",
    value: function setState(item, value) {
      var state = getIf(this, 'state', function () {
        return observable.map();
      });

      if (isString(item)) {
        state.set(item, value);
      } else if (isPlainObject(item)) {
        state.merge(item);
      }

      return this;
    }
  }, {
    key: "getState",
    value: function getState(key) {
      var state = this.state;
      return state && state.get(key);
    }
  }, {
    key: "treeReduce",
    value: function treeReduce(fn, initialValue) {
      return _treeReduce([this], fn, initialValue);
    }
  }, {
    key: "commitTls",
    value: function commitTls() {
      var _this8 = this;

      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var name = arguments.length > 1 ? arguments[1] : undefined;
      var tlsKey = getConfig('tlsKey');

      if (!(name in data)) {
        data[name] = {};
      }

      Object.keys(data).forEach(function (key) {
        var value = data[key];

        var field = _this8.getField(key);

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

          if (transformResponse) {
            var originValue = _objectSpread({}, value);

            Object.keys(value).forEach(function (language) {
              value[language] = transformResponse(value[language], originValue);
            });
          }
        }

        ObjectChainValue.set(_this8.data, "".concat(tlsKey, ".").concat(key), value);
      });
    }
  }, {
    key: "initFields",
    value: function initFields(fields) {
      var _this9 = this;

      _toConsumableArray(fields.keys()).forEach(function (key) {
        return addRecordField(_this9, key);
      });
    }
  }, {
    key: "addField",
    value: function addField(name) {
      var fieldProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var old = this.fields.get(name);
      var field = addRecordField(this, name, fieldProps);

      if (!old) {
        var data = toJS(this.data);

        var newData = _objectSpread({}, data);

        this.processFieldValue(name, field, this.fields, newData, data);
      }

      return field;
    }
  }, {
    key: "processFieldValue",
    value: function processFieldValue(fieldName, field, fields, newData, data, needMerge) {
      var value = ObjectChainValue.get(newData, fieldName);
      var chainFieldName = getChainFieldName(this, fieldName);
      var transformResponse = field.get('transformResponse');

      if (chainFieldName !== fieldName) {
        var bindValue = ObjectChainValue.get(newData, chainFieldName);

        if (isNil(value) && !isNil(bindValue)) {
          value = bindValue;
        }
      }

      if (transformResponse) {
        value = transformResponse(value, data);
      }

      value = processValue(value, field, !needMerge && this.isNew);

      if (value === null) {
        value = undefined;
      }

      if (needMerge && isObject(value)) {
        var oldValue = ObjectChainValue.get(this.data, chainFieldName);

        if (isObject(oldValue)) {
          value = merge(oldValue, value);
        }
      }

      ObjectChainValue.set(newData, chainFieldName, value, fields);
      ObjectChainValue.set(this.data, chainFieldName, value, fields);
    }
  }, {
    key: "processData",
    value: function processData() {
      var _this10 = this;

      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var needMerge = arguments.length > 1 ? arguments[1] : undefined;

      var newData = _objectSpread({}, data);

      var fields = this.fields;
      getSortedFields(fields).forEach(function (_ref5) {
        var _ref6 = _slicedToArray(_ref5, 2),
            fieldName = _ref6[0],
            field = _ref6[1];

        return _this10.processFieldValue(fieldName, field, fields, newData, data, needMerge);
      });
    }
  }, {
    key: "normalizeData",
    value: function normalizeData(needIgnore, jsonFields) {
      var _this11 = this;

      var fields = this.fields,
          dataSet = this.dataSet;
      var dataToJSON = dataSet && dataSet.dataToJSON;
      var onlyDirtyField = needIgnore && dataToJSON ? useDirtyField(dataToJSON) : false;
      var neverKeys = onlyDirtyField ? getUniqueKeysAndPrimaryKey(dataSet) : [];
      var json = onlyDirtyField ? pick(this.data, neverKeys) : toJS(this.data);
      var fieldIgnore = onlyDirtyField ? FieldIgnore.clean : undefined;
      var objectFieldsList = [];
      var normalFields = [];
      var ignoreFieldNames = new Set();

      _toConsumableArray(fields.entries()).forEach(function (_ref7) {
        var _ref8 = _slicedToArray(_ref7, 2),
            key = _ref8[0],
            field = _ref8[1];

        if (field && (!jsonFields || !jsonFields.includes(key))) {
          var ignore = field.get('ignore') || fieldIgnore;

          if (needIgnore && !neverKeys.includes(key) && (ignore === FieldIgnore.always || ignore === FieldIgnore.clean && !field.dirty)) {
            ignoreFieldNames.add(key);
          } else {
            var type = field.get('type');

            if (type === FieldType.object) {
              var level = key.split('.').length - 1;
              objectFieldsList[level] = (objectFieldsList[level] || []).concat(field);
            } else {
              normalFields.push(field);
            }
          }
        }
      });

      [].concat(objectFieldsList, [normalFields]).forEach(function (items) {
        if (items) {
          items.forEach(function (field) {
            var name = field.name;
            var value = ObjectChainValue.get(onlyDirtyField ? _objectSpread({}, _this11.data, {}, json) : json, name);
            var bind = field.get('bind');
            var transformRequest = field.get('transformRequest');

            if (bind) {
              value = _this11.get(getChainFieldName(_this11, name));
            }

            var old = value;
            value = processToJSON(value, field);

            if (transformRequest) {
              // compatible old logic
              value = isString(field.get('multiple')) && isArrayLike(old) ? transformRequest(value, _this11) : processToJSON(transformRequest(old, _this11), field);
            }

            if (value !== undefined) {
              ObjectChainValue.set(json, name, value, fields);
            } else {
              ignoreFieldNames.add(name);
            }
          });
        }
      });

      _toConsumableArray(ignoreFieldNames).forEach(function (key) {
        return ObjectChainValue.remove(json, key);
      });

      return json;
    }
  }, {
    key: "normalizeCascadeData",
    value: function normalizeCascadeData(json, normal, isSelect) {
      var _this12 = this;

      var dataSetSnapshot = this.dataSetSnapshot,
          dataSet = this.dataSet,
          fields = this.fields,
          isRemoved = this.isRemoved;

      if (dataSet) {
        var dirty = false;
        var children = dataSet.children;

        if (isRemoved) {
          childrenInfoForDelete(json, children);
        } else {
          var keys = Object.keys(children);

          if (keys.length) {
            var isCurrent = this.isCurrent;
            keys.forEach(function (name) {
              var snapshot = dataSetSnapshot && dataSetSnapshot[name];
              var child = !isCurrent && snapshot && new DataSet().restore(snapshot) || children[name];

              if (child) {
                var dataToJSON = child.dataToJSON;

                var records = _this12.getCascadeRecordsIncludeDelete(name);

                var selected = isSelect || useSelected(dataToJSON) ? _this12.getCascadeSelectedRecordsIncludeDelete(name) : records;
                var jsonArray = normal || useNormal(dataToJSON) ? records && generateData(records) : selected && generateJSONData(child, selected);

                if (jsonArray) {
                  if (jsonArray.dirty) {
                    dirty = true;
                  }

                  ObjectChainValue.set(json, name, jsonArray.data, fields);
                }
              }
            });
          }
        }

        return dirty;
      }
    }
  }, {
    key: "pristineData",
    get: function get() {
      var dirtyData = this.dirtyData;
      var data = toJS(this.data);

      if (dirtyData) {
        _toConsumableArray(dirtyData.entries()).forEach(function (_ref9) {
          var _ref10 = _slicedToArray(_ref9, 2),
              key = _ref10[0],
              value = _ref10[1];

          return ObjectChainValue.set(data, key, value);
        });
      }

      return data;
    },
    set: function set(data) {
      var _this13 = this;

      runInAction(function () {
        var dirtyData = _this13.dirtyData;

        if (dirtyData) {
          var dirtyKeys = _toConsumableArray(dirtyData.keys());

          var newData = {};

          if (dirtyKeys.length) {
            dirtyKeys.forEach(function (key) {
              var item = ObjectChainValue.get(_this13.data, key);
              ObjectChainValue.set(newData, key, item);
              var newItem = ObjectChainValue.get(data, key);

              if (isSame(item, newItem)) {
                dirtyData["delete"](key);
              } else {
                dirtyData.set(key, newItem);
              }
            });
          }

          _this13.data = merge({}, data, newData);
        } else {
          _this13.data = data;
        }
      });
    }
  }, {
    key: "selectable",
    get: function get() {
      return this.getState(SELECTABLE_KEY);
    },
    set: function set(selectable) {
      var _this14 = this;

      runInAction(function () {
        if (!selectable) {
          _this14.isSelected = false;
        }

        _this14.setState(SELECTABLE_KEY, selectable);
      });
    }
  }, {
    key: "isDataSetInAllPageSelection",
    get: function get() {
      var dataSet = this.dataSet;

      if (dataSet) {
        return dataSet.isAllPageSelection;
      }

      return false;
    }
  }, {
    key: "isSelected",
    get: function get() {
      if (this.isDataSetInAllPageSelection) {
        return !this.getState(UNSELECT_KEY);
      }

      return this.getState(SELECT_KEY);
    },
    set: function set(isSelected) {
      if (this.isDataSetInAllPageSelection) {
        this.setState(UNSELECT_KEY, !isSelected);
      } else {
        this.setState(SELECT_KEY, isSelected);
      }
    }
  }, {
    key: "key",
    get: function get() {
      if (!this.isNew) {
        var dataSet = this.dataSet;

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

          if (primaryKey) {
            var key = this.get(primaryKey);

            if (isString(key) || isNumber(key)) {
              return key;
            }
          }
        }
      }

      return this.id;
    }
  }, {
    key: "index",
    get: function get() {
      var dataSet = this.dataSet;

      if (dataSet) {
        return dataSet.indexOf(this);
      }

      return -1;
    }
  }, {
    key: "indexInParent",
    get: function get() {
      var parent = this.parent,
          dataSet = this.dataSet;

      if (parent && parent.children) {
        return parent.children.indexOf(this);
      }

      if (dataSet) {
        return dataSet.treeRecords.indexOf(this);
      }

      return -1;
    }
  }, {
    key: "isRemoved",
    get: function get() {
      return this.status === RecordStatus["delete"];
    }
  }, {
    key: "isNew",
    get: function get() {
      return this.status === RecordStatus.add;
    }
  }, {
    key: "isSelectionIndeterminate",
    get: function get() {
      var dataSet = this.dataSet;

      if (dataSet && dataSet.selection === DataSetSelection.multiple) {
        var children = this.children;

        if (children) {
          var checkedLength = 0;
          return children.some(function (record) {
            if (record.isSelectionIndeterminate) {
              return true;
            }

            if (record.isSelected) {
              checkedLength += 1;
            }

            return false;
          }) || checkedLength > 0 && checkedLength !== children.length;
        }
      }

      return false;
    }
  }, {
    key: "isIndeterminate",
    get: function get() {
      var dataSet = this.dataSet;

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

        if (checkField) {
          var field = this.getField(checkField);
          var trueValue = field ? field.get(BooleanValue.trueValue) : true;
          var children = this.children;

          if (children) {
            var checkedLength = 0;
            return children.some(function (record) {
              if (record.isIndeterminate) {
                return true;
              }

              if (record.get(checkField) === trueValue) {
                checkedLength += 1;
              }

              return false;
            }) || checkedLength > 0 && checkedLength !== children.length;
          }
        }
      }

      return false;
    }
  }, {
    key: "isExpanded",
    get: function get() {
      var dataSet = this.dataSet;

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

        if (expandField) {
          var expanded = this.get(expandField);
          var field = this.getField(expandField);
          return expanded === (field ? field.get(BooleanValue.trueValue) : true);
        }
      }

      return this.getState(EXPANDED_KEY);
    },
    set: function set(expand) {
      var dataSet = this.dataSet;

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

        if (expandField) {
          var field = this.getField(expandField);
          this.set(expandField, field ? expand ? field.get(BooleanValue.trueValue) : field.get(BooleanValue.falseValue) : expand);
        } else {
          this.setState(EXPANDED_KEY, expand);
        }
      }
    }
  }, {
    key: "previousRecord",
    get: function get() {
      var parent = this.parent,
          dataSet = this.dataSet;
      var children;

      if (parent) {
        children = parent.children;
      } else if (dataSet) {
        children = dataSet.treeData;
      }

      if (children) {
        return children[children.indexOf(this) - 1];
      }

      return undefined;
    }
  }, {
    key: "nextRecord",
    get: function get() {
      var parent = this.parent,
          dataSet = this.dataSet;
      var children;

      if (parent) {
        children = parent.children;
      } else if (dataSet) {
        children = dataSet.treeData;
      }

      if (children) {
        return children[children.indexOf(this) + 1];
      }

      return undefined;
    }
  }, {
    key: "records",
    get: function get() {
      var dataSet = this.dataSet;

      if (dataSet) {
        var cascadeParent = this.cascadeParent;

        if (cascadeParent && !cascadeParent.isCurrent) {
          return cascadeParent.getCascadeRecordsIncludeDelete(dataSet.parentName) || [];
        }

        return dataSet.records;
      }

      return [];
    }
  }, {
    key: "children",
    get: function get() {
      var _this15 = this;

      var dataSet = this.dataSet;

      if (dataSet) {
        var _dataSet$props = dataSet.props,
            parentField = _dataSet$props.parentField,
            idField = _dataSet$props.idField,
            childrenField = _dataSet$props.childrenField;

        if (childrenField) {
          return this.$children;
        }

        if (parentField && idField) {
          var children = this.records.filter(function (record) {
            var childParentId = record.get(parentField);

            var id = _this15.get(idField);

            return !isNil(childParentId) && !isNil(id) && childParentId === id;
          });
          return children.length > 0 ? children : undefined;
        }
      }

      return undefined;
    },
    set: function set(children) {
      var dataSet = this.dataSet;

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

        if (childrenField) {
          this.$children = children;
        } else {
          throw new Error('Setter of record.children only support in `childrenField` mode.');
        }
      }
    }
  }, {
    key: "parent",
    get: function get() {
      var _this16 = this;

      var dataSet = this.dataSet;

      if (dataSet) {
        var _dataSet$props2 = dataSet.props,
            parentField = _dataSet$props2.parentField,
            idField = _dataSet$props2.idField,
            childrenField = _dataSet$props2.childrenField;

        if (childrenField) {
          return this.$parent;
        }

        if (parentField && idField) {
          return this.records.find(function (record) {
            var parentId = _this16.get(parentField);

            var id = record.get(idField);
            return !isNil(parentId) && !isNil(id) && parentId === id;
          });
        }
      }

      return undefined;
    },
    set: function set(parent) {
      var dataSet = this.dataSet;

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

        if (childrenField) {
          this.$parent = parent;
        } else {
          throw new Error('Setter of record.parent only support in `childrenField` mode.');
        }
      }
    }
  }, {
    key: "parents",
    get: function get() {
      var parent = this.parent;

      if (parent) {
        return [parent].concat(_toConsumableArray(parent.parents));
      }

      return [];
    }
  }, {
    key: "path",
    get: function get() {
      return [].concat(_toConsumableArray(this.parents), [this]);
    }
  }, {
    key: "level",
    get: function get() {
      var parent = this.parent;

      if (parent) {
        return parent.level + 1;
      }

      return 0;
    }
  }, {
    key: "dirty",
    get: function get() {
      var _this17 = this;

      var status = this.status;

      if (status === RecordStatus.update) {
        return true;
      }

      var dirtyData = this.dirtyData;

      if (dirtyData && dirtyData.size > 0) {
        return true;
      }

      var dataSet = this.dataSet;

      if (dataSet) {
        var children = dataSet.children;
        return Object.keys(children).some(function (key) {
          return (_this17.getCascadeRecordsIncludeDelete(key) || []).some(isDirtyRecord);
        });
      }

      return false;
    }
  }, {
    key: "cascadeParent",
    get: function get() {
      var _this18 = this;

      var dataSet = this.dataSet;

      if (dataSet) {
        var parent = dataSet.parent,
            parentName = dataSet.parentName;

        if (parent && parentName) {
          return parent.cascadeRecords.find(function (record) {
            return (record.getCascadeRecordsIncludeDelete(parentName) || []).indexOf(_this18) !== -1;
          });
        }
      }

      return undefined;
    }
  }]);

  return Record;
}();

export { Record as default };

__decorate([observable], Record.prototype, "fields", void 0);

__decorate([observable], Record.prototype, "data", void 0);

__decorate([observable], Record.prototype, "dirtyData", void 0);

__decorate([computed], Record.prototype, "pristineData", null);

__decorate([observable], Record.prototype, "status", void 0);

__decorate([observable], Record.prototype, "isCurrent", void 0);

__decorate([observable], Record.prototype, "isCached", void 0);

__decorate([observable], Record.prototype, "editing", void 0);

__decorate([observable], Record.prototype, "pending", void 0);

__decorate([observable], Record.prototype, "childrenLoaded", void 0);

__decorate([observable], Record.prototype, "state", void 0);

__decorate([computed], Record.prototype, "key", null);

__decorate([computed], Record.prototype, "index", null);

__decorate([computed], Record.prototype, "indexInParent", null);

__decorate([computed], Record.prototype, "isSelectionIndeterminate", null);

__decorate([computed], Record.prototype, "isIndeterminate", null);

__decorate([computed], Record.prototype, "isExpanded", null);

__decorate([computed], Record.prototype, "previousRecord", null);

__decorate([computed], Record.prototype, "nextRecord", null);

__decorate([computed], Record.prototype, "records", null);

__decorate([computed], Record.prototype, "children", null);

__decorate([computed], Record.prototype, "parent", null);

__decorate([computed], Record.prototype, "parents", null);

__decorate([computed], Record.prototype, "path", null);

__decorate([computed], Record.prototype, "dirty", null);

__decorate([computed], Record.prototype, "cascadeParent", null);

__decorate([action], Record.prototype, "set", null);

__decorate([action], Record.prototype, "init", null);

__decorate([action], Record.prototype, "tls", null);

__decorate([action], Record.prototype, "reset", null);

__decorate([action], Record.prototype, "save", null);

__decorate([action], Record.prototype, "restore", null);

__decorate([action], Record.prototype, "clear", null);

__decorate([action], Record.prototype, "commit", null);

__decorate([action], Record.prototype, "setState", null);

__decorate([action], Record.prototype, "commitTls", null);

__decorate([action], Record.prototype, "addField", null);
//# sourceMappingURL=Record.js.map