choerodon-ui/pro/lib/data-set/Record.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["default"] = void 0;

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

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

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

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

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

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

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

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

var _tslib = require("tslib");

var _mobx = require("mobx");

var _merge = _interopRequireDefault(require("lodash/merge"));

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

var _pick = _interopRequireDefault(require("lodash/pick"));

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

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

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

var _omit = _interopRequireDefault(require("lodash/omit"));

var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));

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

var _DataSet = _interopRequireWildcard(require("./DataSet"));

var _utils = require("./utils");

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

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

var _isSame = _interopRequireDefault(require("../_util/isSame"));

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

/**
 * 记录ID生成器
 */
var IDGen =
/*#__PURE__*/
_regenerator["default"].mark(function _callee(start) {
  return _regenerator["default"].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] : _enum.RecordStatus.add;
    (0, _classCallCheck2["default"])(this, Record);
    (0, _mobx.runInAction)(function () {
      var initData = (0, _mobx.isObservableObject)(data) ? (0, _mobx.toJS)(data) : data;
      _this.fields = _mobx.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);
    });
  }

  (0, _createClass2["default"])(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 ? (0, _utils.useCascade)(dataToJSON) : !noCascade;
      var normal = all || dataToJSON && (0, _utils.useNormal)(dataToJSON);
      var dirty = status !== _enum.RecordStatus.sync;
      var childrenKeys = cascade && dataSet ? Object.keys(dataSet.children) : undefined;
      var jsonFieldKeys = childrenKeys && (0, _toConsumableArray2["default"])(fields.entries()).reduce(function (fieldKeys, _ref) {
        var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
            key = _ref2[0],
            field = _ref2[1];

        if (field.type === _enum.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 (0, _objectSpread3["default"])({}, json, {
        __dirty: dirty
      });
    }
    /**
     * 转换成用于提交的数据
     */

  }, {
    key: "toJSONData",
    value: function toJSONData(noCascade, isCascadeSelect) {
      var status = this.status;
      return (0, _objectSpread3["default"])({}, this.toData(true, noCascade, isCascadeSelect, false), (0, _defineProperty2["default"])({
        __id: this.id
      }, (0, _configure.getConfig)('statusKey'), (0, _configure.getConfig)('status')[status === _enum.RecordStatus.sync ? _enum.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 !== _enum.RecordStatus.sync) {
        (0, _toConsumableArray2["default"])(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["default"]().restore(snapshot);

            if (child) {
              promises.push(child.validate());
            } else {
              var dataToJSON = ds.dataToJSON;
              var cascade = noCascade === undefined && dataToJSON ? (0, _utils.useCascade)(dataToJSON) : !noCascade;
              (((0, _utils.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 = (0, _utils.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 (0, _toConsumableArray2["default"])(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 = (0, _utils.getIf)(this, 'cascadeRecordsMap', {});
          var cascadeRecords = cascadeRecordsMap[fieldName];

          if (cascadeRecords) {
            return cascadeRecords;
          }

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

          if (!cascading[fieldName] && (0, _mobx.isObservableArray)(data)) {
            cascading[fieldName] = true;
            var records = childDataSet.processData(data, this.isNew ? _enum.RecordStatus.add : _enum.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 (0, _utils.getRecordValue)(this, function (child, checkField) {
        return child.get(checkField);
      }, fieldName);
    }
  }, {
    key: "set",
    value: function set(item, value) {
      var _this4 = this;

      if ((0, _isString["default"])(item)) {
        var oldName = item;
        var fieldName = (0, _utils.getChainFieldName)(this, oldName);
        var field = this.getField(oldName) || this.getField(fieldName) || (0, _utils.findBindField)(oldName, fieldName, this) || (0, _DataSet.addRecordField)(this, oldName);
        (0, _utils.checkFieldType)(value, field);
        var oldValue = (0, _mobx.toJS)(this.get(fieldName));
        var newValue = (0, _utils.processValue)(value, field);
        var newValueForCompare = (0, _utils.processToJSON)(newValue, field);

        if (!(0, _isSame["default"])((0, _utils.processToJSON)(oldValue, field), newValueForCompare)) {
          var _fields = this.fields;
          ObjectChainValue.set(this.data, fieldName, newValue, _fields);
          var dirtyData = (0, _utils.getIf)(this, 'dirtyData', function () {
            return _mobx.observable.map();
          });

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

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

            if (this.status === _enum.RecordStatus.update && dirtyData.size === 0 && (0, _toConsumableArray2["default"])(_fields.values()).every(function (f) {
              return !f.dirty;
            })) {
              this.status = _enum.RecordStatus.sync;
            }
          }

          var dataSet = this.dataSet;

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

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

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

        var fields = this.fields;
        [field].concat((0, _toConsumableArray2["default"])((0, _utils.findBindFields)(field, fields, true)), (0, _toConsumableArray2["default"])((0, _utils.findBindTargetFields)(field, fields, true))).forEach(function (oneField) {
          return oneField.checkValidity(false);
        });
      } else if ((0, _isPlainObject["default"])(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 = (0, _utils.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 ((0, _isString["default"])(item)) {
        var oldName = item;
        var fieldName = (0, _utils.getChainFieldName)(this, oldName);
        var field = this.getField(oldName) || this.getField(fieldName) || (0, _utils.findBindField)(oldName, fieldName, this) || (0, _DataSet.addRecordField)(this, fieldName);
        var newValue = (0, _utils.processValue)(value, field);

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

        ObjectChainValue.set(data, fieldName, newValue, fields);
        field.commit();
      } else if ((0, _isPlainObject["default"])(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 = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2(name) {
        var _this6 = this;

        var tlsKey, dataSet, tlsData, axios, lang, primaryKey, newConfig, result, dataKey;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                tlsKey = (0, _configure.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 = (0, _utils.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 = (0, _configure.getConfig)('dataKey');
                  this.commitTls((0, _utils.generateResponseData)(result, dataKey)[0], name);
                }

                _context2.next = 16;
                break;

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

                  if (field.type === _enum.FieldType.intl) {
                    data[key] = (0, _defineProperty2["default"])({}, 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;
      (0, _toConsumableArray2["default"])(fields.values()).forEach(function (field) {
        return field.commit();
      });

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

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

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

      return this;
    }
  }, {
    key: "save",
    value: function save() {
      this.memo = (0, _mobx.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((0, _toConsumableArray2["default"])(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["default"]();
            var dataSetSnapshot = (0, _utils.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((0, _omit["default"])(r.toData(), ['__dirty']), ds);
                  });
                }
              }
            });
          }
        }
      }

      this.dirtyData = undefined;
      (0, _toConsumableArray2["default"])(this.fields.values()).forEach(function (field) {
        return field.commit();
      });
      this.status = _enum.RecordStatus.sync;
      return this;
    }
  }, {
    key: "setState",
    value: function setState(item, value) {
      var state = (0, _utils.getIf)(this, 'state', function () {
        return _mobx.observable.map();
      });

      if ((0, _isString["default"])(item)) {
        state.set(item, value);
      } else if ((0, _isPlainObject["default"])(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 (0, _treeUtils.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 = (0, _configure.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 = (0, _objectSpread3["default"])({}, 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;

      (0, _toConsumableArray2["default"])(fields.keys()).forEach(function (key) {
        return (0, _DataSet.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 = (0, _DataSet.addRecordField)(this, name, fieldProps);

      if (!old) {
        var data = (0, _mobx.toJS)(this.data);
        var newData = (0, _objectSpread3["default"])({}, 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 = (0, _utils.getChainFieldName)(this, fieldName);
      var transformResponse = field.get('transformResponse');

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

        if ((0, _isNil["default"])(value) && !(0, _isNil["default"])(bindValue)) {
          value = bindValue;
        }
      }

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

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

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

      if (needMerge && (0, _isObject["default"])(value)) {
        var oldValue = ObjectChainValue.get(this.data, chainFieldName);

        if ((0, _isObject["default"])(oldValue)) {
          value = (0, _merge["default"])(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 = (0, _objectSpread3["default"])({}, data);
      var fields = this.fields;
      (0, _utils.getSortedFields)(fields).forEach(function (_ref5) {
        var _ref6 = (0, _slicedToArray2["default"])(_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 ? (0, _utils.useDirtyField)(dataToJSON) : false;
      var neverKeys = onlyDirtyField ? (0, _utils.getUniqueKeysAndPrimaryKey)(dataSet) : [];
      var json = onlyDirtyField ? (0, _pick["default"])(this.data, neverKeys) : (0, _mobx.toJS)(this.data);
      var fieldIgnore = onlyDirtyField ? _enum.FieldIgnore.clean : undefined;
      var objectFieldsList = [];
      var normalFields = [];
      var ignoreFieldNames = new Set();
      (0, _toConsumableArray2["default"])(fields.entries()).forEach(function (_ref7) {
        var _ref8 = (0, _slicedToArray2["default"])(_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 === _enum.FieldIgnore.always || ignore === _enum.FieldIgnore.clean && !field.dirty)) {
            ignoreFieldNames.add(key);
          } else {
            var type = field.get('type');

            if (type === _enum.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 ? (0, _objectSpread3["default"])({}, _this11.data, {}, json) : json, name);
            var bind = field.get('bind');
            var transformRequest = field.get('transformRequest');

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

            var old = value;
            value = (0, _utils.processToJSON)(value, field);

            if (transformRequest) {
              // compatible old logic
              value = (0, _isString["default"])(field.get('multiple')) && (0, _mobx.isArrayLike)(old) ? transformRequest(value, _this11) : (0, _utils.processToJSON)(transformRequest(old, _this11), field);
            }

            if (value !== undefined) {
              ObjectChainValue.set(json, name, value, fields);
            } else {
              ignoreFieldNames.add(name);
            }
          });
        }
      });
      (0, _toConsumableArray2["default"])(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) {
          (0, _utils.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["default"]().restore(snapshot) || children[name];

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

                var records = _this12.getCascadeRecordsIncludeDelete(name);

                var selected = isSelect || (0, _utils.useSelected)(dataToJSON) ? _this12.getCascadeSelectedRecordsIncludeDelete(name) : records;
                var jsonArray = normal || (0, _utils.useNormal)(dataToJSON) ? records && (0, _utils.generateData)(records) : selected && (0, _utils.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 = (0, _mobx.toJS)(this.data);

      if (dirtyData) {
        (0, _toConsumableArray2["default"])(dirtyData.entries()).forEach(function (_ref9) {
          var _ref10 = (0, _slicedToArray2["default"])(_ref9, 2),
              key = _ref10[0],
              value = _ref10[1];

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

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

      (0, _mobx.runInAction)(function () {
        var dirtyData = _this13.dirtyData;

        if (dirtyData) {
          var dirtyKeys = (0, _toConsumableArray2["default"])(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 ((0, _isSame["default"])(item, newItem)) {
                dirtyData["delete"](key);
              } else {
                dirtyData.set(key, newItem);
              }
            });
          }

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

      (0, _mobx.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 ((0, _isString["default"])(key) || (0, _isNumber["default"])(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 === _enum.RecordStatus["delete"];
    }
  }, {
    key: "isNew",
    get: function get() {
      return this.status === _enum.RecordStatus.add;
    }
  }, {
    key: "isSelectionIndeterminate",
    get: function get() {
      var dataSet = this.dataSet;

      if (dataSet && dataSet.selection === _enum.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(_enum.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(_enum.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(_enum.BooleanValue.trueValue) : field.get(_enum.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 !(0, _isNil["default"])(childParentId) && !(0, _isNil["default"])(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 !(0, _isNil["default"])(parentId) && !(0, _isNil["default"])(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((0, _toConsumableArray2["default"])(parent.parents));
      }

      return [];
    }
  }, {
    key: "path",
    get: function get() {
      return [].concat((0, _toConsumableArray2["default"])(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 === _enum.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(_utils.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;
}();

exports["default"] = Record;
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "fields", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "data", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "dirtyData", void 0);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "pristineData", null);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "status", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "isCurrent", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "isCached", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "editing", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "pending", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "childrenLoaded", void 0);
(0, _tslib.__decorate)([_mobx.observable], Record.prototype, "state", void 0);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "key", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "index", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "indexInParent", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "isSelectionIndeterminate", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "isIndeterminate", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "isExpanded", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "previousRecord", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "nextRecord", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "records", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "children", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "parent", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "parents", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "path", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "dirty", null);
(0, _tslib.__decorate)([_mobx.computed], Record.prototype, "cascadeParent", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "set", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "init", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "tls", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "reset", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "save", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "restore", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "clear", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "commit", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "setState", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "commitTls", null);
(0, _tslib.__decorate)([_mobx.action], Record.prototype, "addField", null);
//# sourceMappingURL=Record.js.map