@burnsred/entity 0.6.4-dev.0 → 0.6.5

package/dist/development.js

@@ -0,0 +1,1377 @@
+import 'core-js/modules/es6.regexp.replace';
+import _isString from 'lodash/isString';
+import _isFunction from 'lodash/isFunction';
+import { List, Map, fromJS, isImmutable } from 'immutable';
+import 'core-js/modules/es6.regexp.flags';
+import 'core-js/modules/es6.regexp.to-string';
+import 'core-js/modules/es6.object.assign';
+import 'core-js/modules/es6.function.name';
+import moment from 'moment';
+import 'core-js/modules/es6.array.find';
+import 'core-js/modules/web.dom.iterable';
+import 'core-js/modules/es6.array.iterator';
+import 'core-js/modules/es7.object.values';
+import _range from 'lodash/range';
+import _keyBy from 'lodash/keyBy';
+import _get from 'lodash/get';
+import _sample from 'lodash/sample';
+import _sampleSize from 'lodash/sampleSize';
+import _mapValues from 'lodash/mapValues';
+import _flowRight from 'lodash/flowRight';
+import 'core-js/modules/es6.number.constructor';
+import 'core-js/modules/es6.number.is-nan';
+import queryString from 'query-string';
+
+var removeMultiSpace = (function (value) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!_isString(value)) throw new Error('cleaners.removeMultiSpace: value must be of type string');
+  }
+
+  return value.replace(/\s\s+/g, ' ');
+});
+
+var sliceToMaxLength = (function (value, _ref) {
+  var field = _ref.field;
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (!_isString(value)) throw new Error('cleaners.removeMultiSpace: value must be of type string');
+  }
+
+  return field.maxLength ? value.slice(0, field.maxLength) : value;
+});
+
+
+
+var index = /*#__PURE__*/Object.freeze({
+  removeMultiSpace: removeMultiSpace,
+  sliceToMaxLength: sliceToMaxLength
+});
+
+var allowBlank = (function () {
+  return false;
+});
+
+var entityValid = (function (value) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var errors = options.field.entity.validate(value, options);
+  return !!errors && errors.size > 0 && errors;
+});
+
+var isRequired = (function (value) {
+  var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (!configs.field) throw new Error('validators.isRequired: "field" option is required');
+  }
+
+  return configs.field.isBlank(value, configs) && 'May not be blank';
+});
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+
+    ownKeys.forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+
+  return target;
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+    return arr2;
+  }
+}
+
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+var isRequiredIf = (function (predicate) {
+  return function (value, configs) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!_isFunction(predicate)) throw new Error('validators.isRequiredIf: predicate argument must be of type function');
+    }
+
+    return predicate(_objectSpread({
+      value: value
+    }, configs)) && isRequired(value, configs);
+  };
+});
+
+var list = (function (validators) {
+  return function (values, configs) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!List.isList(values)) throw new Error('validators.list: "values" must be a list');
+    }
+
+    var errors = values.map(function (value) {
+      return List(validators).map(function (validator) {
+        return validator(value, configs);
+      }).filter(function (error) {
+        return error;
+      });
+    });
+    return errors.some(function (error) {
+      return error.size > 0;
+    }) && Map({
+      errors: errors,
+      list: true,
+      message: 'Invalid list'
+    });
+  };
+});
+
+var mayNotBeBlank = (function (value) {
+  var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (!configs.field) throw new Error('validator.mayNotBeBlank: "field" option is required');
+  }
+
+  var validator = configs.flag && configs.field.flags[configs.flag];
+  var defaultError = !configs.field.blank && isRequired(value, configs);
+  if (!validator) return defaultError;
+  var flagError = validator(value, configs);
+  return defaultError ? flagError && defaultError : flagError && 'May not be blank';
+});
+
+
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  allowBlank: allowBlank,
+  entityValid: entityValid,
+  isRequired: isRequired,
+  isRequiredIf: isRequiredIf,
+  list: list,
+  mayNotBeBlank: mayNotBeBlank
+});
+
+var Field =
+/*#__PURE__*/
+function () {
+  function Field() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, Field);
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (options.options && !List.isList(options.options)) throw new Error("Field.constructor (".concat(this.constructor.name, "): options.options must be a an immutable List"));
+      if (options.options && options.options.size !== options.options.toSet().size) throw new Error("Field.constructor (".concat(this.constructor.name, "): options.options must have unique items."));
+    }
+
+    var defaults = {
+      blank: false,
+      cleaners: [],
+      many: false,
+      validators: options.blank ? [] : [isRequired]
+    };
+    Object.assign(this, defaults, options, {
+      validators: _isFunction(options.validators) ? options.validators(defaults.validators) : options.validators || defaults.validators
+    });
+  }
+
+  _createClass(Field, [{
+    key: "clean",
+    value: function clean(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var newOptions = _objectSpread({}, configs, {
+        field: this
+      });
+
+      return this.cleaners.reduce(function (prev, cleaner) {
+        return cleaner(prev, newOptions);
+      }, record);
+    }
+  }, {
+    key: "dataToValue",
+    value: function dataToValue(data) {
+      return fromJS(data);
+    }
+  }, {
+    key: "default",
+    value: function _default() {
+      return this.many ? List() : null;
+    }
+  }, {
+    key: "getErrors",
+    value: function getErrors(errors) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (configs.name) throw new Error("Field.getErrors (".concat(this.constructor.name, "): option \"name\" is not supported."));
+      }
+
+      return errors;
+    }
+  }, {
+    key: "getErrorsArray",
+    value: function getErrorsArray(errors) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (options.index === undefined) throw new Error("Field.getErrorsArray (".concat(this.constructor.name, "): option \"index\" is required."));
+      }
+
+      return errors.filter(function (error) {
+        return Map.isMap(error) && error.get('list');
+      }).flatMap(function (error) {
+        return error.getIn(['errors', options.index]);
+      });
+    }
+  }, {
+    key: "getField",
+    value: function getField() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (options.name) throw new Error("Field.getField (".concat(this.constructor.name, "): method with option name is not supported."));
+      }
+
+      return options.name ? null : this;
+    }
+  }, {
+    key: "getId",
+    value: function getId() {
+      if (process.env.NODE_ENV !== 'production') {
+        throw new Error("Field.getId (".concat(this.constructor.name, "): method is not supported."));
+      }
+    }
+  }, {
+    key: "getKey",
+    value: function getKey(value) {
+      return this.toString(value);
+    }
+  }, {
+    key: "getOptions",
+    value: function getOptions() {
+      return this.options || List();
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(value) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (options.name) throw new Error("Field.getValue (".concat(this.constructor.name, "): option \"name\" is not supported."));
+      }
+
+      return options.name ? null : value;
+    }
+  }, {
+    key: "isBlank",
+    value: function isBlank() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (options.name) throw new Error("Field.isBlank (".concat(this.constructor.name, "): method with option name is not supported."));
+      }
+
+      return value === null || (this.many ? value.size === 0 : value === '');
+    }
+  }, {
+    key: "toData",
+    value: function toData(value) {
+      return isImmutable(value) ? value.toJS() : value;
+    }
+  }, {
+    key: "toParams",
+    value: function toParams(value) {
+      return value && value.toString() || '';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return value === null ? '' : value.toString();
+    }
+  }, {
+    key: "validate",
+    value: function validate(value) {
+      var _this = this;
+
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (this.many && !List.isList(value)) throw new Error("Field.validate (".concat(this.constructor.name, "-").concat(options.fieldName, "): \"value\" must be an \"Immutable List\" with field option \"many\""));
+      }
+
+      var validators = _isFunction(options.validators) ? options.validators(this.validators) : options.validators || this.validators;
+      return List(validators).map(function (validator) {
+        return validator(value, _objectSpread({}, options, {
+          field: _this
+        }));
+      }).filter(function (error) {
+        return error;
+      });
+    }
+  }]);
+
+  return Field;
+}();
+
+var AnyField =
+/*#__PURE__*/
+function (_Field) {
+  _inherits(AnyField, _Field);
+
+  function AnyField() {
+    _classCallCheck(this, AnyField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(AnyField).apply(this, arguments));
+  }
+
+  return AnyField;
+}(Field);
+
+var BooleanField =
+/*#__PURE__*/
+function (_AnyField) {
+  _inherits(BooleanField, _AnyField);
+
+  function BooleanField() {
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, BooleanField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(BooleanField).call(this, _objectSpread({
+      type: 'boolean'
+    }, configs)));
+  }
+
+  return BooleanField;
+}(AnyField);
+
+var CharField =
+/*#__PURE__*/
+function (_AnyField) {
+  _inherits(CharField, _AnyField);
+
+  function CharField() {
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, CharField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(CharField).call(this, _objectSpread({
+      type: 'char'
+    }, configs)));
+  }
+
+  _createClass(CharField, [{
+    key: "default",
+    value: function _default() {
+      return this.many ? List() : '';
+    }
+  }]);
+
+  return CharField;
+}(AnyField);
+
+var DateField =
+/*#__PURE__*/
+function (_AnyField) {
+  _inherits(DateField, _AnyField);
+
+  function DateField() {
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, DateField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(DateField).call(this, _objectSpread({
+      allowTime: false,
+      dateFormat: 'YYYY-MM-DD',
+      type: 'date'
+    }, configs)));
+  }
+
+  _createClass(DateField, [{
+    key: "dataToValue",
+    value: function dataToValue(data) {
+      return data && moment(data);
+    }
+  }, {
+    key: "toData",
+    value: function toData(value) {
+      return value && value.format(this.dateFormat);
+    }
+  }, {
+    key: "toParams",
+    value: function toParams(value) {
+      return value && value.format(this.dateFormat) || '';
+    }
+  }, {
+    key: "toString",
+    value: function toString(value) {
+      return value && value.format(this.dateFormat) || '';
+    }
+  }]);
+
+  return DateField;
+}(AnyField);
+
+var DateTimeField =
+/*#__PURE__*/
+function (_DateField) {
+  _inherits(DateTimeField, _DateField);
+
+  function DateTimeField() {
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, DateTimeField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(DateTimeField).call(this, _objectSpread({
+      dateFormat: 'YYYY-MM-DD HH:mm',
+      allowTime: true
+    }, configs)));
+  }
+
+  return DateTimeField;
+}(DateField);
+
+var EntityField =
+/*#__PURE__*/
+function (_AnyField) {
+  _inherits(EntityField, _AnyField);
+
+  function EntityField() {
+    var _this;
+
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, EntityField);
+
+    var defaults = {
+      nested: true,
+      type: 'entity'
+    };
+    var entityValidators = configs.many ? [list([entityValid])] : [entityValid];
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(EntityField).call(this, Object.assign(defaults, configs, {
+      validators: function validators(defaultValidators) {
+        return _isFunction(configs.validators) ? configs.validators(defaultValidators.concat(entityValidators)) : configs.validators || defaultValidators.concat(entityValidators);
+      }
+    })));
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (!configs.entity) throw new Error("".concat(_this.constructor.name, ".constructor: \"entity\" option is required"));
+    }
+
+    return _this;
+  }
+
+  _createClass(EntityField, [{
+    key: "dataToValue",
+    value: function dataToValue(data) {
+      return this.entity.dataToRecord(data);
+    }
+  }, {
+    key: "default",
+    value: function _default() {
+      if (this.many) return List();
+      return this.blank ? null : this.entity.dataToRecord({});
+    }
+  }, {
+    key: "getErrors",
+    value: function getErrors(errors) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (configs.name && !_isString(configs.name)) throw new Error("EntityField.getErrors (".concat(this.entity.name, "): \"name\" option must be either a string or undefined"));
+        if (configs.name && !this.entity.fields[configs.name]) throw new Error("EntityField.getErrors (".concat(this.entity.name, "): field \"").concat(configs.name, "\" not found"));
+      }
+
+      return configs.name ? errors.filter(function (error) {
+        return Map.isMap(error) && error.get('detail');
+      }).flatMap(function (error) {
+        return Map.isMap(error.getIn(['errors', configs.name])) ? List([error.getIn(['errors', configs.name])]) : error.getIn(['errors', configs.name]);
+      }).filter(function (error) {
+        return error;
+      }) : errors;
+    }
+  }, {
+    key: "getField",
+    value: function getField() {
+      var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (configs.name && !_isString(configs.name)) throw new Error("EntityField.getField (".concat(this.entity.name, "): \"name\" option must be either a string or undefined"));
+        if (configs.name && !this.entity.fields[configs.name]) throw new Error("EntityField.getField (".concat(this.entity.name, "): field \"").concat(configs.name, "\" not found"));
+      }
+
+      return configs.name ? this.entity.fields[configs.name] : this;
+    }
+  }, {
+    key: "getId",
+    value: function getId(value) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (configs.name && !_isString(configs.name)) throw new Error("EntityField.getId (".concat(this.entity.name, "): \"name\" option must be either a string or undefined"));
+        if (configs.name && !this.entity.fields[configs.name]) throw new Error("EntityField.getId (".concat(this.entity.name, "): field \"").concat(configs.name, "\" not found"));
+      }
+
+      return this.getField(_objectSpread({
+        value: value
+      }, configs)).entity.getId(this.getValue(value, configs));
+    }
+  }, {
+    key: "getKey",
+    value: function getKey(value) {
+      return this.getId(value);
+    }
+  }, {
+    key: "getOptions",
+    value: function getOptions() {
+      return this.options || this.entity.options || List();
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(value) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (configs.name && !_isString(configs.name)) throw new Error("EntityField.getValue (".concat(this.entity.name, "): \"name\" option must be either a string or undefined"));
+        if (configs.name && !this.entity.fields[configs.name]) throw new Error("EntityField.getValue (".concat(this.entity.name, "): field \"").concat(configs.name, "\" not found"));
+      }
+
+      return configs.name && value ? value.get(configs.name) : value;
+    }
+  }, {
+    key: "isBlank",
+    value: function isBlank() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (configs.name && !_isString(configs.name)) throw new Error("EntityField.isBlank (".concat(this.entity.name, "): \"name\" option must be either a string or undefined"));
+        if (configs.name && !this.entity.fields[configs.name]) throw new Error("EntityField.isBlank (".concat(this.entity.name, "): field \"").concat(configs.name, "\" not found"));
+      }
+
+      return value === null || (this.many ? value.size === 0 : value === '');
+    }
+  }, {
+    key: "toData",
+    value: function toData(value) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return this.entity.toData(value, configs);
+    }
+  }, {
+    key: "valueToParam",
+    value: function valueToParam() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return value === null ? undefined : value.get(this.entity.idField);
+    }
+  }, {
+    key: "toParams",
+    value: function toParams(value, configs) {
+      return this.getId(value, configs);
+    }
+  }, {
+    key: "toString",
+    value: function toString(value) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return this.entity.toString(value, configs);
+    }
+  }]);
+
+  return EntityField;
+}(AnyField);
+
+var IdField =
+/*#__PURE__*/
+function (_AnyField) {
+  _inherits(IdField, _AnyField);
+
+  function IdField() {
+    var _this;
+
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, IdField);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(IdField).call(this, configs));
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (configs.many) throw new Error("".concat(_this.constructor.name, ".constructor: \"many\" option is not supported."));
+    }
+
+    return _this;
+  }
+
+  _createClass(IdField, [{
+    key: "dataToValue",
+    value: function dataToValue(data) {
+      var _ref;
+
+      return _isFunction((_ref = data) != null ? _ref.toString : _ref) ? data.toString() : data;
+    }
+  }, {
+    key: "default",
+    value: function _default() {
+      return undefined;
+    }
+  }]);
+
+  return IdField;
+}(AnyField);
+
+var Entity =
+/*#__PURE__*/
+function () {
+  function Entity() {
+    _classCallCheck(this, Entity);
+  }
+
+  _createClass(Entity, null, [{
+    key: "actionArrayDeleteAtIndex",
+    value: function actionArrayDeleteAtIndex(records) {
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          _ref$index = _ref.index,
+          index = _ref$index === void 0 ? null : _ref$index;
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (!List.isList(records)) throw new Error("Entity.actionArrayDeleteAt (".concat(this.name, "): \"records\" must be an immutable List."));
+        if (index === null) throw new Error("Entity.actionArrayDeleteAt (".concat(this.name, "): \"index\" option must be set."));
+      }
+
+      return records.delete(index);
+    }
+  }, {
+    key: "actionArrayMoveAtIndex",
+    value: function actionArrayMoveAtIndex(records) {
+      var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          _ref2$index = _ref2.index,
+          index = _ref2$index === void 0 ? null : _ref2$index,
+          _ref2$indexTo = _ref2.indexTo,
+          indexTo = _ref2$indexTo === void 0 ? null : _ref2$indexTo;
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (!List.isList(records)) throw new Error("Entity.actionArrayMoveAtIndex (".concat(this.name, "): \"records\" must be an immutable List."));
+        if (index === null) throw new Error("Entity.actionArrayMoveAtIndex (".concat(this.name, "): \"index\" option must be set."));
+        if (indexTo === null) throw new Error("Entity.actionArrayMoveAtIndex (".concat(this.name, "): \"indexTo\" option must be set."));
+      }
+
+      return records.delete(index).insert(indexTo, records.get(index));
+    }
+  }, {
+    key: "actionReset",
+    value: function actionReset(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return configs.valueInitial || this.dataToRecord(_defineProperty({}, this.idField, record.get(this.idField)));
+    }
+  }, {
+    key: "clean",
+    value: function clean(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var newOptions = _objectSpread({}, configs, {
+        entity: this
+      });
+
+      return this.cleaners.reduce(function (prev, cleaner) {
+        return cleaner(prev, newOptions);
+      }, record);
+    }
+  }, {
+    key: "dataToRecord",
+    value: function dataToRecord() {
+      var _this = this;
+
+      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+      var fieldDataToValue = function fieldDataToValue(value, key) {
+        return List.isList(value) || Array.isArray(value) ? List(value).map(function (val) {
+          return _this.fields[key].dataToValue(val, {
+            data: data
+          });
+        }) : _this.fields[key].dataToValue(value, {
+          data: data
+        });
+      };
+
+      var getDefaultFromField = function getDefaultFromField(field) {
+        return _isFunction(field.default) ? field.default({
+          data: data
+        }) : field.default;
+      };
+
+      var values = Map(data).filter(function (value, key) {
+        return key in _this.fields;
+      }).filterNot(function (value) {
+        return value === undefined;
+      }).map(fieldDataToValue);
+      return data && Map(this.fields).filter(function (value, key) {
+        return data[key] === undefined;
+      }).map(getDefaultFromField).merge(values);
+    }
+  }, {
+    key: "getEntityField",
+    value: function getEntityField() {
+      var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return new EntityField(_objectSpread({
+        entity: this
+      }, configs));
+    }
+  }, {
+    key: "getId",
+    value: function getId() {
+      var record = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return record === null ? undefined : record.get(this.idField);
+    }
+  }, {
+    key: "getPaths",
+    value: function getPaths() {
+      return this.paths;
+    }
+  }, {
+    key: "getSize",
+    value: function getSize() {
+      return 0;
+    }
+  }, {
+    key: "isEntity",
+    value: function isEntity(maybeEntity) {
+      return !!maybeEntity && maybeEntity.prototype instanceof Entity;
+    }
+  }, {
+    key: "isEntityDescendant",
+    value: function isEntityDescendant(maybeDescendant) {
+      return !!maybeDescendant && maybeDescendant.prototype instanceof this;
+    }
+  }, {
+    key: "isValid",
+    value: function isValid(record, configs) {
+      return this.validate(record, configs).size === 0;
+    }
+  }, {
+    key: "isValidFromErrors",
+    value: function isValidFromErrors(errors) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return configs.name ? configs.name.some(function (n) {
+        return errors.filter(function (error) {
+          return Map.isMap(error) && error.get('detail');
+        }).flatMap(function (error) {
+          return error.getIn(['errors', n]);
+        }).filter(function (error) {
+          return error;
+        }).size > 0;
+      }) : !errors || errors.size === 0;
+    }
+  }, {
+    key: "mock",
+    value: function mock(faker, index, mockData) {
+      var _this2 = this;
+
+      return _flowRight([function (record) {
+        return _this2.toData(record);
+      }, function (data) {
+        return _this2.dataToRecord(data);
+      }, function (fields) {
+        return _objectSpread({}, _mapValues(fields, function (field) {
+          if (field instanceof EntityField && !field.blank && field.entity.store) {
+            return field.many ? _sampleSize(Object.values(field.entity.store)) : _sample(Object.values(field.entity.store));
+          }
+
+          return field.mock && (field.mock === 'index' ? index : _get(faker, field.mock).apply(void 0, _toConsumableArray(field.mockConfigs || [])));
+        }), mockData);
+      }])(this.fields);
+    }
+  }, {
+    key: "mockMany",
+    value: function mockMany(faker) {
+      var _this3 = this;
+
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return _keyBy(_range(configs.size).map(function (index) {
+        return _this3.mock(faker, index);
+      }), this.idField);
+    }
+  }, {
+    key: "toData",
+    value: function toData(record) {
+      var _this4 = this;
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (record && !Map.isMap(record)) throw new Error("Entity.toData (".concat(this.name, "): record must be either a Map or null or undefined"));
+      }
+
+      var fieldValueToData = function fieldValueToData(value, key) {
+        return List.isList(value) ? value.map(function (val) {
+          return _this4.fields[key].toData(val, {
+            record: record
+          });
+        }).toArray() : _this4.fields[key].toData(value, {
+          record: record
+        });
+      };
+
+      return record && record.filter(function (value, key) {
+        return key in _this4.fields;
+      }).filterNot(function (value, key) {
+        return _this4.fields[key].local;
+      }).map(fieldValueToData).toObject();
+    }
+  }, {
+    key: "toString",
+    value: function toString(record) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (record && !Map.isMap(record)) throw new Error("Entity.toString (".concat(this.name, "): record must be either a Map or null or undefined"));
+      }
+
+      return record && record.get(this.idField) || '';
+    }
+  }, {
+    key: "validate",
+    value: function validate(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!record) return record;
+      var detailErrors = Map(this.fields).filter(function (field, key) {
+        return !configs.fields || configs.fields[key];
+      }).map(function (field, key) {
+        return field.validate(record.get(key), _objectSpread({}, configs, {
+          fieldName: key,
+          record: record,
+          validators: configs.fields && configs.fields[key]
+        }));
+      }).filterNot(function (errors) {
+        return errors.size === 0;
+      });
+      return detailErrors.size === 0 ? null : Map({
+        detail: true,
+        message: 'Invalid Entity',
+        errors: detailErrors
+      });
+    }
+  }]);
+
+  return Entity;
+}();
+
+_defineProperty(Entity, "cleaners", []);
+
+_defineProperty(Entity, "idField", 'uuid');
+
+_defineProperty(Entity, "fields", {
+  uuid: new IdField({
+    blank: true,
+    mock: 'random.uuid'
+  })
+});
+
+_defineProperty(Entity, "paths", {});
+
+var Locale =
+/*#__PURE__*/
+function (_Entity) {
+  _inherits(Locale, _Entity);
+
+  function Locale() {
+    _classCallCheck(this, Locale);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Locale).apply(this, arguments));
+  }
+
+  return Locale;
+}(Entity);
+
+_defineProperty(Locale, "fields", {
+  messages: new AnyField(),
+  defaultMessage: new CharField(),
+  description: new CharField(),
+  id: new CharField(),
+  uuid: new IdField({
+    mock: 'random.uuid'
+  })
+});
+
+var Enum =
+/*#__PURE__*/
+function (_Entity) {
+  _inherits(Enum, _Entity);
+
+  function Enum() {
+    _classCallCheck(this, Enum);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Enum).apply(this, arguments));
+  }
+
+  _createClass(Enum, null, [{
+    key: "toString",
+    value: function toString(record) {
+      return record && record.get('label') || '';
+    }
+  }]);
+
+  return Enum;
+}(Entity);
+
+_defineProperty(Enum, "idField", 'value');
+
+_defineProperty(Enum, "fields", {
+  disabled: new BooleanField({
+    default: false
+  }),
+  hidden: new BooleanField({
+    default: false
+  }),
+  label: new CharField(),
+  locale: new EntityField({
+    blank: true,
+    entity: Locale
+  }),
+  value: new CharField()
+});
+
+var EnumField =
+/*#__PURE__*/
+function (_EntityField) {
+  _inherits(EnumField, _EntityField);
+
+  function EnumField() {
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, EnumField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(EnumField).call(this, _objectSpread({
+      entity: Enum,
+      type: 'enum'
+    }, configs)));
+  }
+
+  _createClass(EnumField, [{
+    key: "dataToValue",
+    value: function dataToValue() {
+      var _this = this;
+
+      var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return data && this.getOptions().find(function (option) {
+        return _this.entity.getId(option) === data;
+      });
+    }
+  }, {
+    key: "default",
+    value: function _default() {
+      return this.many ? List() : null;
+    }
+  }, {
+    key: "isEnumActive",
+    value: function isEnumActive(value, _ref) {
+      var name = _ref.name;
+      return this.many ? value.some(function (v) {
+        return v.get('value') === name;
+      }) : !!value && value.get('value') === name;
+    }
+  }, {
+    key: "valueToData",
+    value: function valueToData() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return value && this.entity.getId(value);
+    }
+  }, {
+    key: "valueToParam",
+    value: function valueToParam() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      return value === null ? undefined : this.entity.getId(value);
+    }
+  }]);
+
+  return EnumField;
+}(EntityField);
+
+var NumberField =
+/*#__PURE__*/
+function (_AnyField) {
+  _inherits(NumberField, _AnyField);
+
+  function NumberField() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, NumberField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(NumberField).call(this, _objectSpread({
+      type: 'number'
+    }, options)));
+  }
+
+  return NumberField;
+}(AnyField);
+
+var IntegerField =
+/*#__PURE__*/
+function (_NumberField) {
+  _inherits(IntegerField, _NumberField);
+
+  function IntegerField() {
+    _classCallCheck(this, IntegerField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(IntegerField).apply(this, arguments));
+  }
+
+  _createClass(IntegerField, [{
+    key: "dataToValue",
+    value: function dataToValue(data) {
+      var value = parseInt(data, 10);
+      return Number.isNaN(value) ? null : value;
+    }
+  }]);
+
+  return IntegerField;
+}(NumberField);
+
+var TextField =
+/*#__PURE__*/
+function (_CharField) {
+  _inherits(TextField, _CharField);
+
+  function TextField() {
+    var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, TextField);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(TextField).call(this, _objectSpread({
+      type: 'text'
+    }, configs)));
+  }
+
+  return TextField;
+}(CharField);
+
+
+
+var index$2 = /*#__PURE__*/Object.freeze({
+  Field: Field,
+  AnyField: AnyField,
+  BooleanField: BooleanField,
+  CharField: CharField,
+  DateField: DateField,
+  DateTimeField: DateTimeField,
+  EntityField: EntityField,
+  EnumField: EnumField,
+  IdField: IdField,
+  IntegerField: IntegerField,
+  NumberField: NumberField,
+  TextField: TextField
+});
+
+var Filter =
+/*#__PURE__*/
+function (_Entity) {
+  _inherits(Filter, _Entity);
+
+  function Filter() {
+    _classCallCheck(this, Filter);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Filter).apply(this, arguments));
+  }
+
+  _createClass(Filter, null, [{
+    key: "toParams",
+    // NOTE(thierry): returning a map from field.toParams will flatten the output
+    value: function toParams(record) {
+      var _this = this;
+
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var fieldValueToParams = function fieldValueToParams(value, key) {
+        return List.isList(value) ? value.map(function (val) {
+          return _this.fields[key].toParams(val, _objectSpread({
+            record: record
+          }, options));
+        }).reduce(function (prev, param) {
+          return prev.mergeWith(function (prevParam, nextParam) {
+            return prevParam ? "".concat(prevParam, ",").concat(nextParam) : nextParam;
+          }, Map.isMap(param) ? param : Map(_defineProperty({}, key, param)));
+        }, Map()) : _this.fields[key].toParams(value, _objectSpread({
+          record: record
+        }, options));
+      };
+
+      return record ? record.filter(function (_, key) {
+        return key in _this.fields;
+      }).filterNot(function (_, key) {
+        return _this.fields[key].local;
+      }).filterNot(function (value) {
+        return value === undefined;
+      }).map(fieldValueToParams).flatten() : Map();
+    }
+  }]);
+
+  return Filter;
+}(Entity);
+
+_defineProperty(Filter, "fields", {
+  page: new IntegerField({
+    default: 1
+  }),
+  page_size: new IntegerField({
+    default: 20
+  }),
+  uuid: new IdField({
+    blank: true,
+    mock: 'random.uuid'
+  })
+});
+
+var Title =
+/*#__PURE__*/
+function (_Entity) {
+  _inherits(Title, _Entity);
+
+  function Title() {
+    _classCallCheck(this, Title);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(Title).apply(this, arguments));
+  }
+
+  _createClass(Title, null, [{
+    key: "actionArchive",
+    value: function actionArchive(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        var _ref2;
+
+        if (!((_ref2 = this) != null ? (_ref2 = _ref2.duck) != null ? (_ref2 = _ref2.actions) != null ? _ref2.save : _ref2 : _ref2 : _ref2)) throw new Error("EntityTitle.actionArchive (".concat(this.name, "): \"save\" action is required in duck"));
+      }
+
+      return this.duck.actions.save(record, _objectSpread({
+        action: 'archive',
+        method: 'post'
+      }, configs));
+    }
+  }, {
+    key: "actionArrayDeleteAtIndexOrdered",
+    value: function actionArrayDeleteAtIndexOrdered(records, configs) {
+      return this.actionArrayDeleteAtIndex(records, configs).map(function (record, i) {
+        return record.set('order', i);
+      });
+    }
+  }, {
+    key: "actionArrayMoveAtIndexOrdered",
+    value: function actionArrayMoveAtIndexOrdered(records, configs) {
+      return this.actionArrayMoveAtIndex(records, configs).map(function (record, i) {
+        return record.set('order', i);
+      });
+    }
+  }, {
+    key: "actionSave",
+    value: function actionSave(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      if (process.env.NODE_ENV !== 'production') {
+        var _ref;
+
+        if (!((_ref = this) != null ? (_ref = _ref.duck) != null ? (_ref = _ref.actions) != null ? _ref.save : _ref : _ref : _ref)) throw new Error("EntityTitle.actionSave (".concat(this.name, "): \"save\" action is required in duck"));
+      }
+
+      return this.duck.actions.save(record, _objectSpread({
+        invalidateList: true
+      }, configs));
+    }
+  }, {
+    key: "toLink",
+    value: function toLink(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var computedParams = (configs.params || Map()).filterNot(function (param) {
+        return param === undefined;
+      });
+      var path = this.getPaths(configs).urlBase;
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (!/^\/.*\/$/.test(path)) throw new Error("EntityTitle.toLink (".concat(this.name, "): \"urlBase\" property must start with a \"/\" and end with a \"/\""));
+        if (computedParams.some(function (value) {
+          return !_isString(value);
+        })) throw new Error("EntityTitle.toLink (".concat(this.name, "): every params must be a string or undefined"));
+      }
+
+      return "".concat(path).concat(this.getId(record, configs), "/?").concat(queryString.stringify(computedParams.toJS()));
+    }
+  }, {
+    key: "toString",
+    value: function toString(record) {
+      return record && record.get('title') || '';
+    }
+  }, {
+    key: "toStringOrdered",
+    value: function toStringOrdered(record) {
+      return record ? "".concat(record.get('order') + 1, ". ").concat(this.toString(record)) : '';
+    }
+  }, {
+    key: "toUrl",
+    value: function toUrl(record) {
+      var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var computedParams = (configs.params || Map()).remove('page').remove('page_size').filterNot(function (param) {
+        return param === undefined;
+      });
+      var path = this.getPaths(configs).urlBase;
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (!/^\/.*\/$/.test(path)) throw new Error("EntityTitle.toUrl (".concat(this.name, "): \"urlBase\" property must start with a \"/\" and end with a \"/\""));
+        if (computedParams.some(function (param) {
+          return !_isString(param);
+        })) throw new Error("EntityTitle.toUrl (".concat(this.name, "): every params must be a string or undefined"));
+        if (!(configs.settings && configs.settings.BASE_URL)) throw new Error("EntityTitle.toUrl (".concat(this.name, "): \"settings.BASE_URL\" must be set."));
+      }
+
+      return "".concat(configs.settings.BASE_URL).concat(path).concat(this.getId(record, configs), "/?").concat(queryString.stringify(computedParams.toJS()));
+    }
+  }, {
+    key: "toUrlExport",
+    value: function toUrlExport() {
+      var configs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var computedParams = configs.params ? configs.params.remove('page').remove('page_size').filterNot(function (param) {
+        return param === undefined;
+      }) : Map();
+      var path = this.getPaths(configs).apiBase;
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (!/^\/.*\/$/.test(path)) throw new Error("EntityTitle.toUrlExport (".concat(this.name, "): \"apiBase\" property must start with a \"/\" and end with a \"/\""));
+        if (computedParams.some(function (param) {
+          return !_isString(param);
+        })) throw new Error("EntityTitle.toUrlExport (".concat(this.name, "): every params must be a string or undefined"));
+        if (!(configs.settings && configs.settings.BASE_API_URL)) throw new Error("EntityTitle.toUrlExport (".concat(this.name, "): \"settings.BASE_API_URL\" must be set."));
+      }
+
+      return "".concat(configs.settings.BASE_API_URL).concat(path, "?").concat(queryString.stringify(computedParams.toJS()), "&format=xlsx");
+    }
+  }]);
+
+  return Title;
+}(Entity);
+
+_defineProperty(Title, "fields", {
+  description: new TextField({
+    blank: true
+  }),
+  is_archived: new BooleanField({
+    default: false
+  }),
+  locale: new EntityField({
+    blank: true,
+    entity: Locale
+  }),
+  order: new IntegerField({
+    mock: 'index'
+  }),
+  title: new CharField({
+    mock: 'lorem.sentence'
+  }),
+  title_short: new CharField({
+    blank: true
+  }),
+  uuid: new IdField({
+    blank: true,
+    mock: 'random.uuid'
+  })
+});
+
+_defineProperty(Title, "paths", {
+  urlBase: ''
+});
+
+export { index as cleaners, index$1 as validators, index$2 as Fields, Entity, Enum as EntityEnum, Filter as EntityFilter, Locale as EntityLocale, Title as EntityTitle };
+//# sourceMappingURL=development.js.map