@beinformed/ui 1.20.8 → 1.20.9

package/esm/models/attributes/DatetimeAttributeModel.js

@@ -1,17 +1,6 @@
-import _Reflect$construct from "@babel/runtime-corejs3/core-js-stable/reflect/construct";
-import _classCallCheck from "@babel/runtime-corejs3/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime-corejs3/helpers/esm/createClass";
-import _inherits from "@babel/runtime-corejs3/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime-corejs3/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime-corejs3/helpers/esm/getPrototypeOf";
 import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
 import _trimInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/trim";
 import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 import { has } from "../../utils/helpers/objects";
 import { DateUtil, DateTimeUtil, TimeUtil, TimestampUtil } from "../../utils/datetime/DateTimeUtil";
 import StringAttributeModel from "./StringAttributeModel";
@@ -24,531 +13,491 @@ import { ATTRIBUTE_WIDTH, ISO_DATE_FORMAT } from "../../constants";
 import { getSetting } from "../../constants/Settings";
 import { IGNORE_FORMAT_SETTING } from "../../constants/LayoutHints";
 // date format of default
-var PRODUCT_DEFAULT_DATE_FORMAT = "dd-MM-yyyy";
+const PRODUCT_DEFAULT_DATE_FORMAT = "dd-MM-yyyy";
 /**
  */
 
-var DatetimeAttributeModel = /*#__PURE__*/function (_StringAttributeModel) {
-  _inherits(DatetimeAttributeModel, _StringAttributeModel);
+class DatetimeAttributeModel extends StringAttributeModel {
+  /**
+   */
+  constructor(attribute, attributeContributions) {
+    super(attribute, attributeContributions);
+    this.updateInitValue();
+  }
+  /**
+   */
+
 
-  var _super = _createSuper(DatetimeAttributeModel);
+  static isApplicableModel(contributions) {
+    var _context;
 
+    return _includesInstanceProperty(_context = ["date", "time", "datetime", "timestamp"]).call(_context, contributions.type);
+  }
   /**
    */
-  function DatetimeAttributeModel(attribute, attributeContributions) {
-    var _this;
 
-    _classCallCheck(this, DatetimeAttributeModel);
 
-    _this = _super.call(this, attribute, attributeContributions);
+  get formatUtil() {
+    switch (this.type) {
+      case "time":
+        return TimeUtil;
 
-    _this.updateInitValue();
+      case "timestamp":
+        return TimestampUtil;
 
-    return _this;
+      case "datetime":
+        return DateTimeUtil;
+
+      default:
+        return DateUtil;
+    }
   }
   /**
    */
 
 
-  _createClass(DatetimeAttributeModel, [{
-    key: "formatUtil",
-    get:
-    /**
-     */
-    function get() {
-      switch (this.type) {
-        case "time":
-          return TimeUtil;
+  getInitValue() {
+    let value = this.data.value;
+
+    if (value != null) {
+      if (this.type === "time" && value.length === 5) {
+        value = "".concat(value, ":00");
+      } // handle old datetime values, which contained ms
 
-        case "timestamp":
-          return TimestampUtil;
 
-        case "datetime":
-          return DateTimeUtil;
+      if (this.type === "datetime" && _includesInstanceProperty(value).call(value, ".")) {
+        value = value.split(".")[0];
+      }
 
-        default:
-          return DateUtil;
+      if (this.hasTime) {
+        value = this.getTimeValue(value);
       }
     }
-    /**
-     */
 
-  }, {
-    key: "getInitValue",
-    value: function getInitValue() {
-      var value = this.data.value;
+    return value;
+  }
+  /**
+   */
 
-      if (value != null) {
-        if (this.type === "time" && value.length === 5) {
-          value = "".concat(value, ":00");
-        } // handle old datetime values, which contained ms
 
+  getTimeValue(value) {
+    var _context2, _context3, _context4, _context5;
 
-        if (this.type === "datetime" && _includesInstanceProperty(value).call(value, ".")) {
-          value = value.split(".")[0];
-        }
+    let timeValue = value;
 
-        if (this.hasTime) {
-          value = this.getTimeValue(value);
-        }
-      }
+    if (!_includesInstanceProperty(_context2 = this.timeInputFormat.toLowerCase()).call(_context2, "h")) {
+      timeValue = this.formatUtil.setHour(value, 0);
+    }
 
-      return value;
+    if (!_includesInstanceProperty(_context3 = this.timeInputFormat).call(_context3, "m")) {
+      timeValue = this.formatUtil.setMinute(value, 0);
     }
-    /**
-     */
 
-  }, {
-    key: "getTimeValue",
-    value: function getTimeValue(value) {
-      var _context, _context2, _context3, _context4;
+    if (!_includesInstanceProperty(_context4 = this.timeInputFormat).call(_context4, "s")) {
+      timeValue = this.formatUtil.setSecond(value, 0);
+    }
 
-      var timeValue = value;
+    if (this.type === "timestamp" && !_includesInstanceProperty(_context5 = this.timeInputFormat).call(_context5, "S")) {
+      timeValue = this.formatUtil.setMilliseconds(value, 0);
+    }
 
-      if (!_includesInstanceProperty(_context = this.timeInputFormat.toLowerCase()).call(_context, "h")) {
-        timeValue = this.formatUtil.setHour(value, 0);
-      }
+    return timeValue;
+  }
+  /**
+   * Set time in the correct value based on available elements in the time format
+   */
 
-      if (!_includesInstanceProperty(_context2 = this.timeInputFormat).call(_context2, "m")) {
-        timeValue = this.formatUtil.setMinute(value, 0);
-      }
 
-      if (!_includesInstanceProperty(_context3 = this.timeInputFormat).call(_context3, "s")) {
-        timeValue = this.formatUtil.setSecond(value, 0);
-      }
+  updateInitValue() {
+    const value = this.getInitValue();
+
+    if (value != null) {
+      this._initvalue = value;
+      this._inputvalue = this.getInitialInputValue(value);
+      this._value = value;
+    }
+  }
+  /**
+   * Get initial user input value
+   */
 
-      if (this.type === "timestamp" && !_includesInstanceProperty(_context4 = this.timeInputFormat).call(_context4, "S")) {
-        timeValue = this.formatUtil.setMilliseconds(value, 0);
-      }
 
-      return timeValue;
+  getInitialInputValue(value) {
+    if (!value) {
+      return "";
     }
-    /**
-     * Set time in the correct value based on available elements in the time format
-     */
 
-  }, {
-    key: "updateInitValue",
-    value: function updateInitValue() {
-      var value = this.getInitValue();
+    let initValue = value;
 
-      if (value != null) {
-        this._initvalue = value;
-        this._inputvalue = this.getInitialInputValue(value);
-        this._value = value;
-      }
+    if (this.type === "time" && value.length === 5) {
+      initValue = "".concat(value, ":00");
     }
-    /**
-     * Get initial user input value
-     */
 
-  }, {
-    key: "getInitialInputValue",
-    value: function getInitialInputValue(value) {
-      if (!value) {
-        return "";
-      }
+    return this.formatUtil.toFormat(initValue, this.inputFormat);
+  }
+  /**
+   * Set type to date
+   */
 
-      var initValue = value;
 
-      if (this.type === "time" && value.length === 5) {
-        initValue = "".concat(value, ":00");
-      }
+  get type() {
+    return this.getContribution("type", "date");
+  }
+  /**
+   * Returns the value as entered by the user. This can differ from the internal iso value that is stored
+   */
 
-      return this.formatUtil.toFormat(initValue, this.inputFormat);
-    }
-    /**
-     * Set type to date
-     */
-
-  }, {
-    key: "type",
-    get: function get() {
-      return this.getContribution("type", "date");
-    }
-    /**
-     * Returns the value as entered by the user. This can differ from the internal iso value that is stored
-     */
-
-  }, {
-    key: "getInputValue",
-    value: function getInputValue() {
-      return this._inputvalue ? this._inputvalue.toString() : "";
-    }
-    /**
-     * Get input value
-     */
-
-  }, {
-    key: "inputvalue",
-    get: function get() {
-      return this.getInputValue();
-    }
-    /**
-     * Sets the input value to the value entered by the user
-     */
-    ,
-    set: function set(value) {
-      this.validate(value);
-      this._inputvalue = value;
-      this.value = value !== null && value !== "" ? this.formatUtil.toISO(value, this.inputFormat) : null;
-    }
-    /**
-     * Get date format
-     */
-
-  }, {
-    key: "format",
-    get: function get() {
-      var format = this.getContribution("format", "");
-      return this.formatUtil.convertFormat(format);
-    }
-    /**
-     */
-
-  }, {
-    key: "operator",
-    get: function get() {
-      return this.getContribution("operator", "");
-    }
-    /**
-     */
-
-  }, {
-    key: "hasDate",
-    get: function get() {
-      return this.type === "date" || this.type === "datetime" || this.type === "timestamp";
-    }
-    /**
-     */
-
-  }, {
-    key: "hasTime",
-    get: function get() {
-      return this.type === "time" || this.type === "datetime" || this.type === "timestamp";
-    }
-    /**
-     */
-
-  }, {
-    key: "formatLabel",
-    get: function get() {
-      switch (this.type) {
-        case "date":
-          return this.dateInputFormat.toLowerCase();
-
-        case "time":
-          return this.timeInputFormat.toLowerCase();
-
-        default:
-          return this.format.toLowerCase();
-      }
-    }
-    /**
-     */
 
-  }, {
-    key: "inputFormat",
-    get: function get() {
-      if (this.hasDate && this.hasTime) {
-        var _context5, _context6;
+  getInputValue() {
+    return this._inputvalue ? this._inputvalue.toString() : "";
+  }
+  /**
+   * Get input value
+   */
 
-        return _trimInstanceProperty(_context5 = _concatInstanceProperty(_context6 = "".concat(this.dateInputFormat, " ")).call(_context6, this.timeInputFormat)).call(_context5);
-      }
 
-      if (this.hasDate) {
-        return this.dateInputFormat;
-      }
+  get inputvalue() {
+    return this.getInputValue();
+  }
+  /**
+   * Sets the input value to the value entered by the user
+   */
 
-      if (this.hasTime) {
-        return this.timeInputFormat;
-      }
 
-      return "";
-    }
-    /**
-     */
+  set inputvalue(value) {
+    this.validate(value);
+    this._inputvalue = value;
+    this.value = value !== null && value !== "" ? this.formatUtil.toISO(value, this.inputFormat) : null;
+  }
+  /**
+   * Get date format
+   */
+
+
+  get format() {
+    const format = this.getContribution("format", "");
+    return this.formatUtil.convertFormat(format);
+  }
+  /**
+   */
 
-  }, {
-    key: "dateInputFormat",
-    get: function get() {
-      var _context7;
 
-      if (!this.hasDate) {
-        return "";
-      } // setting for date input
+  get operator() {
+    return this.getContribution("operator", "");
+  }
+  /**
+   */
 
 
-      var ignoreFormatSetting = this.layouthint.has(IGNORE_FORMAT_SETTING);
+  get hasDate() {
+    return this.type === "date" || this.type === "datetime" || this.type === "timestamp";
+  }
+  /**
+   */
 
-      if (!ignoreFormatSetting) {
-        var dateInputFormatSetting = getSetting("DATE_INPUT_FORMAT", "");
 
-        if (dateInputFormatSetting) {
-          return dateInputFormatSetting;
-        }
-      }
+  get hasTime() {
+    return this.type === "time" || this.type === "datetime" || this.type === "timestamp";
+  }
+  /**
+   */
 
-      var format = this.format;
-      var dateFormat = this.hasTime ? _trimInstanceProperty(_context7 = format.replace(this.timeInputFormat, "")).call(_context7) : format;
-      return dateFormat;
+
+  get formatLabel() {
+    switch (this.type) {
+      case "date":
+        return this.dateInputFormat.toLowerCase();
+
+      case "time":
+        return this.timeInputFormat.toLowerCase();
+
+      default:
+        return this.format.toLowerCase();
     }
-    /**
-     */
+  }
+  /**
+   */
 
-  }, {
-    key: "dateReadonlyFormat",
-    get: function get() {
-      var _context8;
 
-      if (!this.hasDate) {
-        return "";
-      }
+  get inputFormat() {
+    if (this.hasDate && this.hasTime) {
+      var _context6, _context7;
 
-      var format = this.format;
-      var dateFormat = this.hasTime ? _trimInstanceProperty(_context8 = format.replace(this.timeInputFormat, "")).call(_context8) : format;
-      var readonlyFormatSetting = getSetting("DATE_READONLY_FORMAT", "");
+      return _trimInstanceProperty(_context6 = _concatInstanceProperty(_context7 = "".concat(this.dateInputFormat, " ")).call(_context7, this.timeInputFormat)).call(_context6);
+    }
 
-      if (dateFormat === PRODUCT_DEFAULT_DATE_FORMAT && readonlyFormatSetting) {
-        dateFormat = readonlyFormatSetting;
-      }
+    if (this.hasDate) {
+      return this.dateInputFormat;
+    }
 
-      return dateFormat;
+    if (this.hasTime) {
+      return this.timeInputFormat;
     }
-    /**
-     * return attribute placeholder or, if DATE_INPUT_FORMAT setting is used, lowercased setting, otherwise return formatlabel without time input format from contributions
-     */
 
-  }, {
-    key: "placeholder",
-    get: function get() {
-      if (this._placeholder !== "") {
-        return this._placeholder;
-      }
+    return "";
+  }
+  /**
+   */
+
+
+  get dateInputFormat() {
+    var _context8;
+
+    if (!this.hasDate) {
+      return "";
+    } // setting for date input
 
-      var dateInputFormatSetting = getSetting("DATE_INPUT_FORMAT", "");
+
+    const ignoreFormatSetting = this.layouthint.has(IGNORE_FORMAT_SETTING);
+
+    if (!ignoreFormatSetting) {
+      const dateInputFormatSetting = getSetting("DATE_INPUT_FORMAT", "");
 
       if (dateInputFormatSetting) {
-        return dateInputFormatSetting.toLowerCase();
+        return dateInputFormatSetting;
       }
+    }
 
-      var formatLabel = this.getContribution("formatlabel", "");
+    let format = this.format;
+    let dateFormat = this.hasTime ? _trimInstanceProperty(_context8 = format.replace(this.timeInputFormat, "")).call(_context8) : format;
+    return dateFormat;
+  }
+  /**
+   */
 
-      if (this.hasDate && this.hasTime && _includesInstanceProperty(formatLabel).call(formatLabel, " ")) {
-        // return first part of formatlabel to keep placeholder matching date input
-        return formatLabel.split(" ")[0];
-      }
 
-      return formatLabel;
+  get dateReadonlyFormat() {
+    var _context9;
+
+    if (!this.hasDate) {
+      return "";
     }
-    /**
-     * Set placeholder text
-     */
-    ,
-    set: function set(placeholder) {
-      this._placeholder = placeholder;
+
+    let format = this.format;
+    let dateFormat = this.hasTime ? _trimInstanceProperty(_context9 = format.replace(this.timeInputFormat, "")).call(_context9) : format;
+    const readonlyFormatSetting = getSetting("DATE_READONLY_FORMAT", "");
+
+    if (dateFormat === PRODUCT_DEFAULT_DATE_FORMAT && readonlyFormatSetting) {
+      dateFormat = readonlyFormatSetting;
     }
-    /**
-     */
 
-  }, {
-    key: "timeInputFormat",
-    get: function get() {
-      if (!this.hasTime) {
-        return "";
-      }
+    return dateFormat;
+  }
+  /**
+   * return attribute placeholder or, if DATE_INPUT_FORMAT setting is used, lowercased setting, otherwise return formatlabel without time input format from contributions
+   */
 
-      var format = this.format;
-      var timeFormatParts = [];
 
-      if (_includesInstanceProperty(format).call(format, "H")) {
-        timeFormatParts.push("HH");
-      } else if (_includesInstanceProperty(format).call(format, "h")) {
-        timeFormatParts.push("hh");
-      }
+  get placeholder() {
+    if (this._placeholder !== "") {
+      return this._placeholder;
+    }
 
-      if (_includesInstanceProperty(format).call(format, "m")) {
-        timeFormatParts.push("mm");
-      }
+    const dateInputFormatSetting = getSetting("DATE_INPUT_FORMAT", "");
 
-      if (_includesInstanceProperty(format).call(format, "s")) {
-        timeFormatParts.push("ss");
-      }
+    if (dateInputFormatSetting) {
+      return dateInputFormatSetting.toLowerCase();
+    }
 
-      var timeFormat = timeFormatParts.join(":");
+    const formatLabel = this.getContribution("formatlabel", "");
 
-      if (_includesInstanceProperty(format).call(format, "S")) {
-        timeFormat = "".concat(timeFormat, ".SSS");
-      }
+    if (this.hasDate && this.hasTime && _includesInstanceProperty(formatLabel).call(formatLabel, " ")) {
+      // return first part of formatlabel to keep placeholder matching date input
+      return formatLabel.split(" ")[0];
+    }
+
+    return formatLabel;
+  }
+  /**
+   * Set placeholder text
+   */
+
+
+  set placeholder(placeholder) {
+    this._placeholder = placeholder;
+  }
+  /**
+   */
 
-      if (_includesInstanceProperty(format).call(format, "a")) {
-        return "".concat(timeFormat, " a");
-      }
 
-      return timeFormat;
+  get timeInputFormat() {
+    if (!this.hasTime) {
+      return "";
     }
-    /**
-     */
 
-  }, {
-    key: "timeReadonlyFormat",
-    get: function get() {
-      if (!this.hasTime) {
-        return "";
-      }
+    const format = this.format;
+    let timeFormatParts = [];
 
-      return this.timeInputFormat;
+    if (_includesInstanceProperty(format).call(format, "H")) {
+      timeFormatParts.push("HH");
+    } else if (_includesInstanceProperty(format).call(format, "h")) {
+      timeFormatParts.push("hh");
     }
-    /**
-     */
 
-  }, {
-    key: "dateInputValue",
-    get: function get() {
-      return typeof this.value === "string" && this.dateInputFormat !== "" ? this.formatUtil.toFormat(this.value, this.dateInputFormat) : "";
+    if (_includesInstanceProperty(format).call(format, "m")) {
+      timeFormatParts.push("mm");
     }
-    /**
-     */
 
-  }, {
-    key: "timeInputValue",
-    get: function get() {
-      return typeof this.value === "string" && this.timeInputFormat !== "" ? this.formatUtil.toFormat(this.value, this.timeInputFormat) : "";
-    } // format value in readonly rendering
+    if (_includesInstanceProperty(format).call(format, "s")) {
+      timeFormatParts.push("ss");
+    }
 
-    /**
-     */
+    let timeFormat = timeFormatParts.join(":");
 
-  }, {
-    key: "formatValue",
-    value: function formatValue(value) {
-      if (value == null || value.toString() === "") {
-        return "";
-      } // when the value is exactly an iso date, render as date
+    if (_includesInstanceProperty(format).call(format, "S")) {
+      timeFormat = "".concat(timeFormat, ".SSS");
+    }
 
+    if (_includesInstanceProperty(format).call(format, "a")) {
+      return "".concat(timeFormat, " a");
+    }
 
-      if ((this.type === "datetime" || this.type === "timestamp") && DateUtil.hasFormat(value, ISO_DATE_FORMAT)) {
-        return DateUtil.toFormat(value, this.dateReadonlyFormat);
-      }
+    return timeFormat;
+  }
+  /**
+   */
 
-      if (this.hasDate && this.hasTime) {
-        var _context9;
 
-        var dateTimeReadonlyFormat = _concatInstanceProperty(_context9 = "".concat(this.dateReadonlyFormat, " ")).call(_context9, this.timeReadonlyFormat);
+  get timeReadonlyFormat() {
+    if (!this.hasTime) {
+      return "";
+    }
 
-        return this.formatUtil.toFormat(value, dateTimeReadonlyFormat);
-      }
+    return this.timeInputFormat;
+  }
+  /**
+   */
 
-      if (this.type === "date") {
-        return this.formatUtil.toFormat(value, this.dateReadonlyFormat);
-      }
 
-      return this.formatUtil.toFormat(value, this.format);
-    }
-    /**
-     * Retrieve readonly value, the date in the configurated format
-     */
+  get dateInputValue() {
+    return typeof this.value === "string" && this.dateInputFormat !== "" ? this.formatUtil.toFormat(this.value, this.dateInputFormat) : "";
+  }
+  /**
+   */
+
+
+  get timeInputValue() {
+    return typeof this.value === "string" && this.timeInputFormat !== "" ? this.formatUtil.toFormat(this.value, this.timeInputFormat) : "";
+  } // format value in readonly rendering
+
+  /**
+   */
 
-  }, {
-    key: "readonlyvalue",
-    get: function get() {
-      if (typeof this.value === "string") {
-        return this.formatValue(this.value.toString());
-      }
 
+  formatValue(value) {
+    if (value == null || value.toString() === "") {
       return "";
+    } // when the value is exactly an iso date, render as date
+
+
+    if ((this.type === "datetime" || this.type === "timestamp") && DateUtil.hasFormat(value, ISO_DATE_FORMAT)) {
+      return DateUtil.toFormat(value, this.dateReadonlyFormat);
     }
-    /**
-     * Get minimum date
-     */
-
-  }, {
-    key: "mindate",
-    get: function get() {
-      return this.getContribution("mindate");
-    }
-    /**
-     * Get maximum date
-     */
-
-  }, {
-    key: "maxdate",
-    get: function get() {
-      return this.getContribution("maxdate");
-    }
-    /**
-     * Registers an error that was received from a server response
-     */
-
-  }, {
-    key: "addServerError",
-    value: function addServerError(error) {
-      var id = error.id,
-          message = error.message,
-          properties = error.properties;
-
-      if (properties && has(properties, "format") && this.formatLabel) {
-        properties.format = this.formatLabel;
-      }
 
-      this._errorCollection.addServerError(id, message, properties);
+    if (this.hasDate && this.hasTime) {
+      var _context10;
+
+      const dateTimeReadonlyFormat = _concatInstanceProperty(_context10 = "".concat(this.dateReadonlyFormat, " ")).call(_context10, this.timeReadonlyFormat);
+
+      return this.formatUtil.toFormat(value, dateTimeReadonlyFormat);
     }
-    /**
-     */
 
-  }, {
-    key: "getFormatConstraint",
-    value: function getFormatConstraint() {
-      switch (this.type) {
-        case "date":
-          return new DateTimeDateFormatConstraint(this.dateInputFormat, this.formatLabel);
+    if (this.type === "date") {
+      return this.formatUtil.toFormat(value, this.dateReadonlyFormat);
+    }
 
-        case "time":
-          return new DateTimeTimeFormatConstraint(this.timeInputFormat, this.formatLabel);
+    return this.formatUtil.toFormat(value, this.format);
+  }
+  /**
+   * Retrieve readonly value, the date in the configurated format
+   */
 
-        default:
-          return new DatetimeFormatConstraint(this.type, this.inputFormat, this.formatLabel);
-      }
+
+  get readonlyvalue() {
+    if (typeof this.value === "string") {
+      return this.formatValue(this.value.toString());
     }
-    /**
-     * Add Date constraints for attribute
-     */
 
-  }, {
-    key: "addConstraints",
-    value: function addConstraints() {
-      var constraints = new ConstraintCollection();
-      constraints.add(this.getFormatConstraint());
+    return "";
+  }
+  /**
+   * Get minimum date
+   */
 
-      if (this.mindate || this.maxdate) {
-        constraints.add(new DateBoundaryConstraint(this.type, this.mindate, this.maxdate, this.inputFormat));
-      }
 
-      return constraints;
+  get mindate() {
+    return this.getContribution("mindate");
+  }
+  /**
+   * Get maximum date
+   */
+
+
+  get maxdate() {
+    return this.getContribution("maxdate");
+  }
+  /**
+   * Registers an error that was received from a server response
+   */
+
+
+  addServerError(error) {
+    const {
+      id,
+      message,
+      properties
+    } = error;
+
+    if (properties && has(properties, "format") && this.formatLabel) {
+      properties.format = this.formatLabel;
     }
-    /**
-     */
 
-  }, {
-    key: "readonlyWidth",
-    get: function get() {
-      if (this.type === "date" || this.type === "time") {
-        return ATTRIBUTE_WIDTH.SMALL;
-      }
+    this._errorCollection.addServerError(id, message, properties);
+  }
+  /**
+   */
 
-      return ATTRIBUTE_WIDTH.MEDIUM;
+
+  getFormatConstraint() {
+    switch (this.type) {
+      case "date":
+        return new DateTimeDateFormatConstraint(this.dateInputFormat, this.formatLabel);
+
+      case "time":
+        return new DateTimeTimeFormatConstraint(this.timeInputFormat, this.formatLabel);
+
+      default:
+        return new DatetimeFormatConstraint(this.type, this.inputFormat, this.formatLabel);
     }
-  }], [{
-    key: "isApplicableModel",
-    value: function isApplicableModel(contributions) {
-      var _context10;
+  }
+  /**
+   * Add Date constraints for attribute
+   */
+
+
+  addConstraints() {
+    const constraints = new ConstraintCollection();
+    constraints.add(this.getFormatConstraint());
+
+    if (this.mindate || this.maxdate) {
+      constraints.add(new DateBoundaryConstraint(this.type, this.mindate, this.maxdate, this.inputFormat));
+    }
+
+    return constraints;
+  }
+  /**
+   */
 
-      return _includesInstanceProperty(_context10 = ["date", "time", "datetime", "timestamp"]).call(_context10, contributions.type);
+
+  get readonlyWidth() {
+    if (this.type === "date" || this.type === "time") {
+      return ATTRIBUTE_WIDTH.SMALL;
     }
-  }]);
 
-  return DatetimeAttributeModel;
-}(StringAttributeModel);
+    return ATTRIBUTE_WIDTH.MEDIUM;
+  }
+
+}
 
 export default DatetimeAttributeModel;
 //# sourceMappingURL=DatetimeAttributeModel.js.map