@beinformed/ui 1.20.8 → 1.20.9

package/esm/models/attributes/AttributeModel.js

@@ -1,22 +1,9 @@
-import _Reflect$construct from "@babel/runtime-corejs3/core-js-stable/reflect/construct";
-import _slicedToArray from "@babel/runtime-corejs3/helpers/esm/slicedToArray";
-import _classCallCheck from "@babel/runtime-corejs3/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime-corejs3/helpers/esm/createClass";
-import _assertThisInitialized from "@babel/runtime-corejs3/helpers/esm/assertThisInitialized";
-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 _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
 import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
 import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
 import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
 import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
 import _endsWithInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/ends-with";
-
-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 { DateUtil } from "../../utils/datetime/DateTimeUtil";
 import { isPlainObject } from "../../utils/helpers/objects";
 import BaseModel from "../base/BaseModel";
@@ -35,1040 +22,944 @@ import AttributeContent from "./AttributeContent";
  * Attribute model, base model for all kind of attributes
  */
 
-var AttributeModel = /*#__PURE__*/function (_BaseModel) {
-  _inherits(AttributeModel, _BaseModel);
-
-  var _super = _createSuper(AttributeModel);
-
+export default class AttributeModel extends BaseModel {
   /**
    */
-  function AttributeModel(attribute, attributeContributions) {
-    var _this;
-
-    _classCallCheck(this, AttributeModel);
+  constructor(attribute, attributeContributions) {
+    super(attribute, attributeContributions);
 
-    _this = _super.call(this, attribute, attributeContributions);
+    _defineProperty(this, "_label", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_label", void 0);
+    _defineProperty(this, "_lastModification", 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_lastModification", 0);
+    _defineProperty(this, "_initvalue", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_initvalue", void 0);
+    _defineProperty(this, "_inputvalue", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_inputvalue", void 0);
+    _defineProperty(this, "_value", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_value", void 0);
+    _defineProperty(this, "_errorCollection", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_errorCollection", void 0);
+    _defineProperty(this, "_serverConstraints", new ConstraintCollection());
 
-    _defineProperty(_assertThisInitialized(_this), "_serverConstraints", new ConstraintCollection());
+    _defineProperty(this, "_useClientsideValidation", getSetting("USE_CLIENTSIDE_VALIDATION"));
 
-    _defineProperty(_assertThisInitialized(_this), "_useClientsideValidation", getSetting("USE_CLIENTSIDE_VALIDATION"));
+    _defineProperty(this, "_isValid", true);
 
-    _defineProperty(_assertThisInitialized(_this), "_isValid", true);
+    _defineProperty(this, "_validatedValue", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_validatedValue", void 0);
+    _defineProperty(this, "_isEditable", false);
 
-    _defineProperty(_assertThisInitialized(_this), "_isEditable", false);
+    _defineProperty(this, "_concept", null);
 
-    _defineProperty(_assertThisInitialized(_this), "_concept", null);
+    _defineProperty(this, "_referenceDate", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_referenceDate", void 0);
+    _defineProperty(this, "_isResult", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_isResult", void 0);
+    _defineProperty(this, "_isHidden", false);
 
-    _defineProperty(_assertThisInitialized(_this), "_isHidden", false);
+    _defineProperty(this, "_readonly", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_readonly", void 0);
+    _defineProperty(this, "_disabled", false);
 
-    _defineProperty(_assertThisInitialized(_this), "_disabled", false);
+    _defineProperty(this, "_mandatory", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_mandatory", void 0);
+    _defineProperty(this, "_links", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_links", void 0);
+    _defineProperty(this, "_parentKey", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_parentKey", void 0);
+    _defineProperty(this, "_hasContentConfiguration", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_hasContentConfiguration", void 0);
+    _defineProperty(this, "_layoutHintRules", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_layoutHintRules", void 0);
-
-    if (_this.hasContentFromData && _this.content.label) {
-      _this._label = _this.content.label;
+    if (this.hasContentFromData && this.content.label) {
+      this._label = this.content.label;
     } else {
-      _this._label = _this.contributions.label;
+      this._label = this.contributions.label;
     }
 
-    _this._initvalue = _this.data.value;
-    _this._inputvalue = _this.getInitialInputValue(_this.data.value);
-    _this._value = _this.data.value;
-    _this._disabled = _this.layouthint.has(DISABLED);
-    _this._errorCollection = new ErrorCollection("attribute");
+    this._initvalue = this.data.value;
+    this._inputvalue = this.getInitialInputValue(this.data.value);
+    this._value = this.data.value;
+    this._disabled = this.layouthint.has(DISABLED);
+    this._errorCollection = new ErrorCollection("attribute");
 
     if (attribute && attribute.message) {
-      _this._errorCollection.addServerError(attribute.message.id, attribute.message.message, attribute.message.parameters);
+      this._errorCollection.addServerError(attribute.message.id, attribute.message.message, attribute.message.parameters);
     }
 
-    _this._referenceDate = _this.getData("referenceDate", DateUtil.now());
-    _this._isResult = _this.getData("isResult", false);
-    _this._mandatory = _this.layouthint.has(MANDATORY) || _this.contributions.mandatory;
-    _this._links = new LinkCollection(_this.data._links, _this.contributions._links);
-    return _this;
+    this._referenceDate = this.getData("referenceDate", DateUtil.now());
+    this._isResult = this.getData("isResult", false);
+    this._mandatory = this.layouthint.has(MANDATORY) || this.contributions.mandatory;
+    this._links = new LinkCollection(this.data._links, this.contributions._links);
   }
   /**
    */
 
 
-  _createClass(AttributeModel, [{
-    key: "getInitialInputValue",
-    value:
-    /**
-     * Retrieve initial input value
-     */
-    function getInitialInputValue(value) {
-      return value;
+  static isApplicableModel(contributions) {
+    if (!isPlainObject(contributions)) {
+      throw new IllegalArgumentException("Given argument for isApplicableModel is not a contributions object");
     }
-    /**
-     */
-
-  }, {
-    key: "getInitialChildModelLinks",
-    value: function getInitialChildModelLinks() {
-      if (!this.hasContentFromData && this.hasContentConfiguration && this.conceptLink) {
-        return [this.conceptLink];
-      }
 
-      return [];
-    }
-    /**
-     */
+    return false;
+  }
+  /**
+   * Retrieve initial input value
+   */
 
-  }, {
-    key: "setChildModels",
-    value: function setChildModels(models) {
-      var _this$conceptLink;
 
-      var conceptHref = (_this$conceptLink = this.conceptLink) === null || _this$conceptLink === void 0 ? void 0 : _this$conceptLink.href;
+  getInitialInputValue(value) {
+    return value;
+  }
+  /**
+   */
 
-      if (conceptHref) {
-        this.concept = _findInstanceProperty(models).call(models, function (model) {
-          return model.selfhref.equalsWithParameters(conceptHref);
-        });
-      }
-    }
-    /**
-     * Getting the attribute key
-     */
-
-  }, {
-    key: "key",
-    get: function get() {
-      return this.data.key;
-    }
-    /**
-     */
 
-  }, {
-    key: "parentKey",
-    get: function get() {
-      return this._parentKey || "";
-    }
-    /**
-     */
-    ,
-    set: function set(parentKey) {
-      this._parentKey = parentKey;
-    }
-    /**
-     * Getting the attribute name
-     */
-
-  }, {
-    key: "name",
-    get: function get() {
-      return this.key;
+  getInitialChildModelLinks() {
+    if (!this.hasContentFromData && this.hasContentConfiguration && this.conceptLink) {
+      return [this.conceptLink];
     }
-    /**
-     * Getting the type of the attribute
-     */
-
-  }, {
-    key: "type",
-    get: function get() {
-      return this.contributions.type;
-    }
-    /**
-     * Getting the label of the attribute
-     */
-
-  }, {
-    key: "label",
-    get: function get() {
-      return this._label || "";
-    }
-    /**
-     * Set the label of this attribute
-     */
-    ,
-    set: function set(label) {
-      this._label = label;
-    }
-    /**
-     */
-
-  }, {
-    key: "hasContentConfiguration",
-    get:
-    /**
-     */
-    function get() {
-      return this._hasContentConfiguration || false;
+
+    return [];
+  }
+  /**
+   */
+
+
+  setChildModels(models) {
+    var _this$conceptLink;
+
+    const conceptHref = (_this$conceptLink = this.conceptLink) === null || _this$conceptLink === void 0 ? void 0 : _this$conceptLink.href;
+
+    if (conceptHref) {
+      this.concept = _findInstanceProperty(models).call(models, model => model.selfhref.equalsWithParameters(conceptHref));
     }
-    /**
-     */
-    ,
-    set: function set(hasContentConfiguration) {
-      this._hasContentConfiguration = hasContentConfiguration;
+  }
+  /**
+   * Getting the attribute key
+   */
+
+
+  get key() {
+    return this.data.key;
+  }
+  /**
+   */
+
+
+  get parentKey() {
+    return this._parentKey || "";
+  }
+  /**
+   */
+
+
+  set parentKey(parentKey) {
+    this._parentKey = parentKey;
+  }
+  /**
+   * Getting the attribute name
+   */
+
+
+  get name() {
+    return this.key;
+  }
+  /**
+   * Getting the type of the attribute
+   */
+
+
+  get type() {
+    return this.contributions.type;
+  }
+  /**
+   * Getting the label of the attribute
+   */
+
+
+  get label() {
+    return this._label || "";
+  }
+  /**
+   * Set the label of this attribute
+   */
+
+
+  set label(label) {
+    this._label = label;
+  }
+  /**
+   */
+
+
+  set hasContentConfiguration(hasContentConfiguration) {
+    this._hasContentConfiguration = hasContentConfiguration;
+  }
+  /**
+   */
+
+
+  get hasContentConfiguration() {
+    return this._hasContentConfiguration || false;
+  }
+  /**
+   */
+
+
+  indicateContentConfiguration(contentConfiguration) {
+    if (contentConfiguration) {
+      var _contentConfiguration;
+
+      const hasQuestionConfig = (_contentConfiguration = contentConfiguration.questions) === null || _contentConfiguration === void 0 ? void 0 : _contentConfiguration.hasConfig();
+      const hasEndResultConfig = contentConfiguration.isConfiguredEndResultAttribute(this.key);
+      const hasIntermediateResultConfig = contentConfiguration.isConfiguredIntermediateResultAttribute(this.key);
+      this.hasContentConfiguration = hasQuestionConfig || hasEndResultConfig || hasIntermediateResultConfig;
     }
-  }, {
-    key: "indicateContentConfiguration",
-    value: function indicateContentConfiguration(contentConfiguration) {
-      if (contentConfiguration) {
-        var _contentConfiguration;
-
-        var hasQuestionConfig = (_contentConfiguration = contentConfiguration.questions) === null || _contentConfiguration === void 0 ? void 0 : _contentConfiguration.hasConfig();
-        var hasEndResultConfig = contentConfiguration.isConfiguredEndResultAttribute(this.key);
-        var hasIntermediateResultConfig = contentConfiguration.isConfiguredIntermediateResultAttribute(this.key);
-        this.hasContentConfiguration = hasQuestionConfig || hasEndResultConfig || hasIntermediateResultConfig;
-      }
+  }
+  /**
+   * Retrieve the first permitted label to render when a concept and contentConfiguration is available
+   * Be aware that permission could be in place for labels from a concept.
+   */
+
+
+  getContentConfiguredLabel(contentConfiguration) {
+    if (this.hasContentFromData) {
+      var _this$content$label;
+
+      return (_this$content$label = this.content.label) !== null && _this$content$label !== void 0 ? _this$content$label : this.label;
     }
-    /**
-     * Retrieve the first permitted label to render when a concept and contentConfiguration is available
-     * Be aware that permission could be in place for labels from a concept.
-     */
-
-  }, {
-    key: "getContentConfiguredLabel",
-    value: function getContentConfiguredLabel(contentConfiguration) {
-      if (this.hasContentFromData) {
-        var _this$content$label;
-
-        return (_this$content$label = this.content.label) !== null && _this$content$label !== void 0 ? _this$content$label : this.label;
-      }
 
-      var configuredLabelProperties = contentConfiguration && contentConfiguration.labelConfig.length > 0 ? contentConfiguration.labelConfig[0].types : [];
-
-      if (this.concept && configuredLabelProperties.length > 0) {
-        var _context;
-
-        var configuredLabels = _filterInstanceProperty(_context = this.concept.getLabelElementByIds(configuredLabelProperties)).call(_context, function (configuredLabel) {
-          return configuredLabel.value && configuredLabel.value !== "";
-        });
-
-        if (configuredLabels.length > 0) {
-          var _context2;
-
-          var _configuredLabelPrope = _mapInstanceProperty(_context2 = _filterInstanceProperty(configuredLabelProperties).call(configuredLabelProperties, function (configuredLabelProperty) {
-            return configuredLabels.some(function (configuredLabel) {
-              return configuredLabel._id === configuredLabelProperty;
-            });
-          })).call(_context2, function (configuredLabelProperty) {
-            return _findInstanceProperty(configuredLabels).call(configuredLabels, function (configuredLabel) {
-              return configuredLabel._id === configuredLabelProperty;
-            });
-          }),
-              _configuredLabelPrope2 = _slicedToArray(_configuredLabelPrope, 1),
-              firstConfiguredLabel = _configuredLabelPrope2[0];
-
-          if (firstConfiguredLabel) {
-            return firstConfiguredLabel.value;
-          }
+    const configuredLabelProperties = contentConfiguration && contentConfiguration.labelConfig.length > 0 ? contentConfiguration.labelConfig[0].types : [];
+
+    if (this.concept && configuredLabelProperties.length > 0) {
+      var _context;
+
+      const configuredLabels = _filterInstanceProperty(_context = this.concept.getLabelElementByIds(configuredLabelProperties)).call(_context, configuredLabel => configuredLabel.value && configuredLabel.value !== "");
+
+      if (configuredLabels.length > 0) {
+        var _context2;
+
+        const [firstConfiguredLabel] = _mapInstanceProperty(_context2 = _filterInstanceProperty(configuredLabelProperties).call(configuredLabelProperties, configuredLabelProperty => configuredLabels.some(configuredLabel => configuredLabel._id === configuredLabelProperty))).call(_context2, configuredLabelProperty => _findInstanceProperty(configuredLabels).call(configuredLabels, configuredLabel => configuredLabel._id === configuredLabelProperty));
+
+        if (firstConfiguredLabel) {
+          return firstConfiguredLabel.value;
         }
       }
-
-      return this.label;
     }
-    /**
-     */
 
-  }, {
-    key: "defaultAlignment",
-    get: function get() {
-      return "left";
-    }
-    /**
-     * Handles layout hint align-left, align-center and align-right
-     */
+    return this.label;
+  }
+  /**
+   */
 
-  }, {
-    key: "alignment",
-    get: function get() {
-      var alignmentHints = this.layouthint.getByLayoutHint("align-"); // return alignment based on layouthint or the default alignment for the attribute
 
-      var alignment = alignmentHints ? alignmentHints.substring("align-".length) : this.defaultAlignment;
+  get defaultAlignment() {
+    return "left";
+  }
+  /**
+   * Handles layout hint align-left, align-center and align-right
+   */
 
-      if (alignment === "left" || alignment === "center" || alignment === "right") {
-        return alignment;
-      }
 
-      return this.defaultAlignment;
-    }
-    /**
-     * Retrieve links of attribute
-     */
-
-  }, {
-    key: "links",
-    get: function get() {
-      if (!this._links) {
-        this._links = new LinkCollection(this.data._links, this.contributions._links);
-      }
+  get alignment() {
+    const alignmentHints = this.layouthint.getByLayoutHint("align-"); // return alignment based on layouthint or the default alignment for the attribute
 
-      return this._links;
+    const alignment = alignmentHints ? alignmentHints.substring("align-".length) : this.defaultAlignment;
+
+    if (alignment === "left" || alignment === "center" || alignment === "right") {
+      return alignment;
     }
-    /**
-     * Retrieve link of attribute when available
-     */
 
-  }, {
-    key: "downloadLink",
-    get: function get() {
-      var downloadLink = this.links.getLinksByGroup("download").first;
+    return this.defaultAlignment;
+  }
+  /**
+   * Retrieve links of attribute
+   */
 
-      if (downloadLink && downloadLink.key === this.key) {
-        return downloadLink;
-      }
 
-      return null;
+  get links() {
+    if (!this._links) {
+      this._links = new LinkCollection(this.data._links, this.contributions._links);
     }
-    /**
-     * Retrieve concept link of attribute when available
-     */
-
-  }, {
-    key: "conceptLink",
-    get: function get() {
-      var conceptLink = this.links.getLinkByKey("concept");
-
-      if (conceptLink !== null) {
-        conceptLink.href = conceptLink.href.addParameter(TIMEVERSION_FILTER_NAME, this.referenceDate);
-        conceptLink.isCacheable = true;
-      }
 
-      return conceptLink;
-    }
-    /**
-     * Get concept information
-     */
+    return this._links;
+  }
+  /**
+   * Retrieve link of attribute when available
+   */
 
-  }, {
-    key: "concept",
-    get: function get() {
-      var _this$_concept;
 
-      return (_this$_concept = this._concept) !== null && _this$_concept !== void 0 ? _this$_concept : null;
-    }
-    /**
-     * Set the concept
-     */
-    ,
-    set: function set(concept) {
-      this._concept = concept instanceof ConceptDetailModel ? concept : null;
-    }
-    /**
-     * Retrieve reference date of attribute which can be used as entryDate for content
-     * to get information in correct time version
-     */
-
-  }, {
-    key: "referenceDate",
-    get: function get() {
-      return this._referenceDate;
-    }
-    /**
-     * Set reference date for concepts and content
-     */
-    ,
-    set: function set(date) {
-      this._referenceDate = date;
-    }
-    /**
-     * Initial value received from the modular ui service
-     */
-
-  }, {
-    key: "initvalue",
-    get: function get() {
-      return this._initvalue;
-    }
-    /**
-     * Retrieve input value
-     */
-
-  }, {
-    key: "getInputValue",
-    value: function getInputValue() {
-      var inputvalue = this._inputvalue;
-      return inputvalue ? inputvalue.toString() : "";
-    }
-    /**
-     * Returns the value as entered by the user. This can differ from the internal iso value that is stored
-     */
-
-  }, {
-    key: "inputvalue",
-    get: function get() {
-      return this.getInputValue();
-    }
-    /**
-     * Value that is used when retrieving an error collection of this attribute
-     * Mostly this is the input value, but sometimes a different value is needed,
-     * for example iban and postcode need to validate length without spaces
-     */
-    ,
-    set:
-    /**
-     * Sets the input value to the value entered by the user
-     */
-    function set(value) {
-      this._inputvalue = value;
-      this.value = value;
-      this.validate(value);
-    }
-    /**
-     */
+  get downloadLink() {
+    const downloadLink = this.links.getLinksByGroup("download").first;
 
-  }, {
-    key: "validateValue",
-    get: function get() {
-      return this.inputvalue;
-    }
-  }, {
-    key: "hasValue",
-    value: function hasValue() {
-      return this._value != null && this._value !== "";
+    if (downloadLink && downloadLink.key === this.key) {
+      return downloadLink;
     }
-    /**
-     * Getting the value of the attribute
-     */
-
-  }, {
-    key: "getValue",
-    value: function getValue() {
-      return this.hasValue() ? this._value : null;
-    }
-    /**
-     * Getting data ready to be send to the modular ui
-     * Returns null when the attribute should not be send to the server
-     */
-
-  }, {
-    key: "getFormData",
-    value: function getFormData() {
-      if (this.inError()) {
-        return null;
-      }
 
-      return _defineProperty({}, this.name, this.value);
-    }
-    /**
-     */
+    return null;
+  }
+  /**
+   * Retrieve concept link of attribute when available
+   */
 
-  }, {
-    key: "formdata",
-    get: function get() {
-      return this.getFormData();
-    }
-    /**
-     */
 
-  }, {
-    key: "getEmptyFormData",
-    value: function getEmptyFormData() {
-      return _defineProperty({}, this.name, null);
-    }
-    /**
-     * Getting the value of the attribute
-     */
-
-  }, {
-    key: "value",
-    get: function get() {
-      return this.getValue();
-    }
-    /**
-     * Setting a value in the element
-     */
-    ,
-    set: function set(value) {
-      this.updateLastModification();
-      this._value = value;
-    }
-    /**
-     */
+  get conceptLink() {
+    const conceptLink = this.links.getLinkByKey("concept");
 
-  }, {
-    key: "formatValue",
-    value: function formatValue(value) {
-      return value;
+    if (conceptLink !== null) {
+      conceptLink.href = conceptLink.href.addParameter(TIMEVERSION_FILTER_NAME, this.referenceDate);
+      conceptLink.isCacheable = true;
     }
-    /**
-     * Getting the readonly value, iso value converted for human reading
-     */
-
-  }, {
-    key: "readonlyvalue",
-    get: function get() {
-      return this.value ? this.value.toString() : "";
-    }
-    /**
-     * Getting mandatory status of attribute
-     */
-
-  }, {
-    key: "mandatory",
-    get: function get() {
-      return this._mandatory || false;
-    }
-    /**
-     */
-    ,
-    set:
-    /**
-     * Set mandatory status of attribute
-     */
-    function set(mandatory) {
-      if (mandatory !== this._mandatory) {
-        this._validatedValue = null;
-      }
 
-      this._mandatory = mandatory;
-    }
-    /**
-     */
+    return conceptLink;
+  }
+  /**
+   * Get concept information
+   */
 
-  }, {
-    key: "configuredMandatory",
-    get: function get() {
-      return this.layouthint.has(MANDATORY) || this.contributions.mandatory;
-    }
-  }, {
-    key: "readonly",
-    get: function get() {
-      return this._readonly || this.contributions.readonly === true || this.data.static === true || this.isResult === true;
-    }
-    /**
-     */
-    ,
-    set: function set(readonly) {
-      this._readonly = readonly;
-    }
-    /**
-     */
 
-  }, {
-    key: "disabled",
-    get: function get() {
-      return this._disabled;
-    }
-    /**
-     */
-    ,
-    set: function set(disabled) {
-      this._disabled = disabled;
-    }
-    /**
-     */
+  get concept() {
+    var _this$_concept;
 
-  }, {
-    key: "isResult",
-    get: function get() {
-      return this._isResult;
-    }
-    /**
-     */
-    ,
-    set: function set(isResult) {
-      this._isResult = isResult;
-    }
-    /**
-     * Getting the display and input format of a attribute
-     */
-
-  }, {
-    key: "format",
-    get: function get() {
-      return this.getContribution("format");
-    }
-    /**
-     */
+    return (_this$_concept = this._concept) !== null && _this$_concept !== void 0 ? _this$_concept : null;
+  }
+  /**
+   * Set the concept
+   */
 
-  }, {
-    key: "formatLabel",
-    get: function get() {
-      return this.format || "";
-    }
-    /**
-     * Get minimum string length
-     */
-
-  }, {
-    key: "minLength",
-    get: function get() {
-      return this.getContribution("minLength");
-    }
-    /**
-     * Get maximum string length
-     */
-
-  }, {
-    key: "maxLength",
-    get: function get() {
-      return this.getContribution("maxLength");
-    }
-    /**
-     */
 
-  }, {
-    key: "operator",
-    get: function get() {
-      return "";
-    }
-    /**
-     * Get assistant message
-     */
-
-  }, {
-    key: "assistantMessage",
-    get: function get() {
-      return this.getContribution("assistant");
-    }
-    /**
-     * Get valid status
-     */
-
-  }, {
-    key: "isValid",
-    get: function get() {
-      return this.validate(this.validateValue);
-    }
-    /**
-     * Retrieve applicable constraint for this attribute
-     */
-
-  }, {
-    key: "constraintCollection",
-    get: function get() {
-      var constraints = new ConstraintCollection();
-      constraints.add(this._serverConstraints); // Mandatory constraint
-
-      if (this.mandatory) {
-        constraints.add(new MandatoryConstraint());
-      }
+  set concept(concept) {
+    this._concept = concept instanceof ConceptDetailModel ? concept : null;
+  }
+  /**
+   * Retrieve reference date of attribute which can be used as entryDate for content
+   * to get information in correct time version
+   */
 
-      if (this.minLength || this.maxLength) {
-        constraints.add(new StringLengthConstraint(this.minLength, this.maxLength));
-      }
 
-      constraints.add(this.addConstraints());
-      return constraints;
-    }
-    /**
-     * Template method for class extending this model to add extra constraints
-     * @abstract
-     */
-
-  }, {
-    key: "addConstraints",
-    value: function addConstraints() {
-      return new ConstraintCollection();
-    }
-    /**
-     * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
-     */
-
-  }, {
-    key: "setUseClientsideValidation",
-    value: function setUseClientsideValidation(enabled) {
-      this._useClientsideValidation = enabled;
-    }
-    /**
-     * Indicates if client side validation is enabled
-     * @returns {boolean}
-     */
+  get referenceDate() {
+    return this._referenceDate;
+  }
+  /**
+   * Set reference date for concepts and content
+   */
 
-  }, {
-    key: "useClientsideValidation",
-    value: function useClientsideValidation() {
-      var _this$_useClientsideV;
 
-      return (_this$_useClientsideV = this._useClientsideValidation) !== null && _this$_useClientsideV !== void 0 ? _this$_useClientsideV : true;
-    }
-    /**
-     * Validate input on client side constraint
-     */
-
-  }, {
-    key: "validate",
-    value: function validate(value) {
-      // when client side validation is disabled, this attribute is always valid
-      if (!this.useClientsideValidation()) {
-        return true;
-      }
+  set referenceDate(date) {
+    this._referenceDate = date;
+  }
+  /**
+   * Initial value received from the modular ui service
+   */
 
-      if (this.isOptionalAndEmpty(value)) {
-        this._isValid = true;
-      } else if (this._validatedValue !== value) {
-        this._isValid = this.constraintCollection.validate(value);
-      }
 
-      this._validatedValue = value;
-      return this._isValid;
-    }
-    /**
-     * Indicates if attribute is optional and empty
-     */
-
-  }, {
-    key: "isOptionalAndEmpty",
-    value: function isOptionalAndEmpty(value) {
-      if (value === undefined) {
-        throw new IllegalArgumentException("isOptionalAndEmpty method needs value argument");
-      }
+  get initvalue() {
+    return this._initvalue;
+  }
+  /**
+   * Retrieve input value
+   */
 
-      return !this.mandatory && value === "";
-    }
-    /**
-     * Retrieve error messages of this attribute
-     */
-
-  }, {
-    key: "errorCollection",
-    get: function get() {
-      var collection = new ErrorCollection("attribute", this._errorCollection);
-      collection.addConstraints(this.constraintCollection.invalidConstraints(this.validateValue));
-      return collection;
-    }
-    /**
-     * Check if attribute is in error
-     */
-
-  }, {
-    key: "inError",
-    value: function inError() {
-      return !this._isValid && this.isChangedSince(0);
-    }
-    /**
-     * Reset static error messages on attribute
-     */
-
-  }, {
-    key: "resetErrors",
-    value: function resetErrors() {
-      this._errorCollection = new ErrorCollection("attribute");
-    }
-    /**
-     * Registers an error that was received from a server response
-     */
-
-  }, {
-    key: "addServerError",
-    value: function addServerError(error) {
-      this._errorCollection.addServerError(error.id, error.message, error.properties);
-    }
-    /**
-     */
 
-  }, {
-    key: "removeServerError",
-    value: function removeServerError(id) {
-      this._errorCollection.removeServerError(id);
-    }
-    /**
-     */
+  getInputValue() {
+    const inputvalue = this._inputvalue;
+    return inputvalue ? inputvalue.toString() : "";
+  }
+  /**
+   * Returns the value as entered by the user. This can differ from the internal iso value that is stored
+   */
 
-  }, {
-    key: "hasServerErrors",
-    value: function hasServerErrors() {
-      return this.errorCollection.serverErrors.length > 0;
-    }
-    /**
-     */
 
-  }, {
-    key: "hasErrors",
-    value: function hasErrors() {
-      return this.errorCollection.hasItems;
-    }
-    /**
-     * Registers a missing error that was received from the server
-     */
-
-  }, {
-    key: "addMissingError",
-    value: function addMissingError() {
-      this._errorCollection.addServerError("Constraint.Missing");
-    }
-    /**
-     */
+  get inputvalue() {
+    return this.getInputValue();
+  }
+  /**
+   * Value that is used when retrieving an error collection of this attribute
+   * Mostly this is the input value, but sometimes a different value is needed,
+   * for example iban and postcode need to validate length without spaces
+   */
 
-  }, {
-    key: "removeMissingError",
-    value: function removeMissingError() {
-      this.removeServerError("Constraint.Missing");
-    }
-    /**
-     */
 
-  }, {
-    key: "addServerConstraint",
-    value: function addServerConstraint(id, defaultMessage, parameters) {
-      this._serverConstraints.addConstraint(id, null, defaultMessage, parameters, this.useClientsideValidation());
-    }
-    /**
-     */
+  get validateValue() {
+    return this.inputvalue;
+  }
+  /**
+   * Sets the input value to the value entered by the user
+   */
 
-  }, {
-    key: "formatParameters",
-    value: function formatParameters(parameters) {
-      var _this2 = this;
 
-      if (parameters == null) {
-        return {};
-      }
+  set inputvalue(value) {
+    this._inputvalue = value;
+    this.value = value;
+    this.validate(value);
+  }
+  /**
+   */
 
-      var params = {};
 
-      _Object$keys(parameters).forEach(function (paramKey) {
-        var paramValue = parameters[paramKey];
+  hasValue() {
+    return this._value != null && this._value !== "";
+  }
+  /**
+   * Getting the value of the attribute
+   */
+
 
-        if (_endsWithInstanceProperty(paramKey).call(paramKey, "-number") || _endsWithInstanceProperty(paramKey).call(paramKey, "-date")) {
-          params[paramKey] = _this2.formatValue(paramValue);
-        } else {
-          params[paramKey] = paramValue;
-        }
-      });
+  getValue() {
+    return this.hasValue() ? this._value : null;
+  }
+  /**
+   * Getting data ready to be send to the modular ui
+   * Returns null when the attribute should not be send to the server
+   */
 
-      return params;
-    }
-    /**
-     */
 
-  }, {
-    key: "hasDynamicValidationData",
-    get: function get() {
-      return true;
+  getFormData() {
+    if (this.inError()) {
+      return null;
     }
-    /**
-     */
-
-  }, {
-    key: "updateValidations",
-    value: function updateValidations(errors) {
-      var _this3 = this;
-
-      if (errors.some(function (error) {
-        return error.id === "Constraint.Mandatory";
-      }) || this.layouthint.has(MANDATORY)) {
-        this.mandatory = true;
-      } else if (!this.hasValue()) {
-        this.mandatory = false;
-      }
 
-      this._serverConstraints = new ConstraintCollection();
-      this.resetErrors();
+    return {
+      [this.name]: this.value
+    };
+  }
+  /**
+   */
 
-      _filterInstanceProperty(errors).call(errors, function (error) {
-        return error.id !== "Constraint.Mandatory" || !_this3.hasValue();
-      }).forEach(function (error) {
-        if (_this3.hasValue()) {
-          _this3._errorCollection.addServerError(error.id, error.message, _this3.formatParameters(error.properties));
-        } else {
-          _this3.addServerConstraint(error.id, error.message, _this3.formatParameters(error.properties));
-        }
-      });
-    }
-    /**
-     * Set last modification to current timestamp
-     */
-
-  }, {
-    key: "updateLastModification",
-    value: function updateLastModification() {
-      this._lastModification = Date.now();
-    }
-    /**
-     * Inidicates if attribute is changed since a given timestamp (Date.now)
-     */
-
-  }, {
-    key: "isChangedSince",
-    value: function isChangedSince(timestamp) {
-      return this._lastModification > timestamp;
-    }
-    /**
-     * Abstract reset method which should be implemented on each attribute that has this attribute as a base class.
-     *
-     * @abstract
-     */
-
-  }, {
-    key: "reset",
-    value: function reset() {
-      throw new UnsupportedOperationException("Reset method not implemented for ".concat(this.type));
-    }
-    /**
-     * Merge old attribute with the attribute from the server.
-     * Readonly attributes always need to show the value from the server
-     */
-
-  }, {
-    key: "mergeAttribute",
-    value: function mergeAttribute(oldAttribute) {
-      this.concept = oldAttribute.concept;
-
-      if (!oldAttribute.readonly && oldAttribute.isValid && oldAttribute.inputvalue !== null) {
-        this.update(oldAttribute.inputvalue);
-      }
-    }
-    /**
-     * Abstract update method which should be implemented on each attribute that has this attribute as a base class.
-     * @abstract
-     */
-    // eslint-disable-next-line no-unused-vars
-
-  }, {
-    key: "update",
-    value: function update(value, changedAttribute) {
-      throw new UnsupportedOperationException("Update method not implemented for ".concat(this.type));
-    }
-    /**
-     * Indicate if attribute is editable
-     */
-
-  }, {
-    key: "isEditable",
-    get:
-    /**
-     * Retrieve if attribute is editable
-     */
-    function get() {
-      return this._isEditable;
-    }
-    /**
-     * Indicates if the attribute is visible
-     */
-    ,
-    set: function set(isEditable) {
-      this._isEditable = isEditable;
-    }
-  }, {
-    key: "isVisible",
-    get: function get() {
-      return !this._isHidden;
-    }
-    /**
-     */
 
-  }, {
-    key: "isHidden",
-    get: function get() {
-      return this._isHidden;
-    }
-    /**
-     */
-    ,
-    set: function set(isHidden) {
-      this._isHidden = isHidden;
-    }
-    /**
-     * Explicitly toggle visibility of this attribute
-     */
-
-  }, {
-    key: "show",
-    value: function show() {
-      this.isHidden = false;
-    }
-    /**
-     */
+  get formdata() {
+    return this.getFormData();
+  }
+  /**
+   */
 
-  }, {
-    key: "hide",
-    value: function hide() {
-      this.isHidden = true;
-    }
-    /**
-     */
 
-  }, {
-    key: "equals",
-    value: function equals(otherAttribute) {
-      return this.key === otherAttribute.key && this.parentKey === otherAttribute.parentKey;
-    }
-    /**
-     * Readonly attribute width indicates the proposed width of this attribute
-     */
-
-  }, {
-    key: "readonlyWidth",
-    get: function get() {
-      return ATTRIBUTE_WIDTH.MEDIUM;
-    }
-    /**
-     */
+  getEmptyFormData() {
+    return {
+      [this.name]: null
+    };
+  }
+  /**
+   * Getting the value of the attribute
+   */
 
-  }, {
-    key: "layoutHintRules",
-    get: function get() {
-      return this._layoutHintRules;
-    }
-    /**
-     */
-    ,
-    set: function set(rules) {
-      this._layoutHintRules = rules;
-    }
-    /**
-     */
-
-  }, {
-    key: "processLayoutHintRules",
-    value: function processLayoutHintRules(attributes) {
-      if (this._layoutHintRules) {
-        this.layoutHintRules.process(this, attributes);
-      }
-    }
-    /**
-     * Indicates if content comes from the data service
-     */
-
-  }, {
-    key: "hasContentFromData",
-    get: function get() {
-      return hasAllContentInData();
-    }
-    /**
-     */
 
-  }, {
-    key: "content",
-    get: function get() {
-      return new AttributeContent(this.data.content);
-    }
-  }], [{
-    key: "isApplicableModel",
-    value: function isApplicableModel(contributions) {
-      if (!isPlainObject(contributions)) {
-        throw new IllegalArgumentException("Given argument for isApplicableModel is not a contributions object");
-      }
+  get value() {
+    return this.getValue();
+  }
+  /**
+   * Setting a value in the element
+   */
 
-      return false;
-    }
-  }]);
 
-  return AttributeModel;
-}(BaseModel);
+  set value(value) {
+    this.updateLastModification();
+    this._value = value;
+  }
+  /**
+   */
+
+
+  formatValue(value) {
+    return value;
+  }
+  /**
+   * Getting the readonly value, iso value converted for human reading
+   */
+
+
+  get readonlyvalue() {
+    return this.value ? this.value.toString() : "";
+  }
+  /**
+   * Getting mandatory status of attribute
+   */
+
+
+  get mandatory() {
+    return this._mandatory || false;
+  }
+  /**
+   */
+
+
+  get configuredMandatory() {
+    return this.layouthint.has(MANDATORY) || this.contributions.mandatory;
+  }
+  /**
+   * Set mandatory status of attribute
+   */
+
+
+  set mandatory(mandatory) {
+    if (mandatory !== this._mandatory) {
+      this._validatedValue = null;
+    }
+
+    this._mandatory = mandatory;
+  }
+  /**
+   */
+
+
+  get readonly() {
+    return this._readonly || this.contributions.readonly === true || this.data.static === true || this.isResult === true;
+  }
+  /**
+   */
+
+
+  set readonly(readonly) {
+    this._readonly = readonly;
+  }
+  /**
+   */
+
+
+  get disabled() {
+    return this._disabled;
+  }
+  /**
+   */
+
+
+  set disabled(disabled) {
+    this._disabled = disabled;
+  }
+  /**
+   */
+
+
+  get isResult() {
+    return this._isResult;
+  }
+  /**
+   */
+
+
+  set isResult(isResult) {
+    this._isResult = isResult;
+  }
+  /**
+   * Getting the display and input format of a attribute
+   */
+
+
+  get format() {
+    return this.getContribution("format");
+  }
+  /**
+   */
+
+
+  get formatLabel() {
+    return this.format || "";
+  }
+  /**
+   * Get minimum string length
+   */
+
+
+  get minLength() {
+    return this.getContribution("minLength");
+  }
+  /**
+   * Get maximum string length
+   */
+
+
+  get maxLength() {
+    return this.getContribution("maxLength");
+  }
+  /**
+   */
+
+
+  get operator() {
+    return "";
+  }
+  /**
+   * Get assistant message
+   */
+
+
+  get assistantMessage() {
+    return this.getContribution("assistant");
+  }
+  /**
+   * Get valid status
+   */
+
+
+  get isValid() {
+    return this.validate(this.validateValue);
+  }
+  /**
+   * Retrieve applicable constraint for this attribute
+   */
+
+
+  get constraintCollection() {
+    const constraints = new ConstraintCollection();
+    constraints.add(this._serverConstraints); // Mandatory constraint
+
+    if (this.mandatory) {
+      constraints.add(new MandatoryConstraint());
+    }
+
+    if (this.minLength || this.maxLength) {
+      constraints.add(new StringLengthConstraint(this.minLength, this.maxLength));
+    }
+
+    constraints.add(this.addConstraints());
+    return constraints;
+  }
+  /**
+   * Template method for class extending this model to add extra constraints
+   * @abstract
+   */
+
+
+  addConstraints() {
+    return new ConstraintCollection();
+  }
+  /**
+   * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
+   */
+
+
+  setUseClientsideValidation(enabled) {
+    this._useClientsideValidation = enabled;
+  }
+  /**
+   * Indicates if client side validation is enabled
+   * @returns {boolean}
+   */
+
+
+  useClientsideValidation() {
+    var _this$_useClientsideV;
+
+    return (_this$_useClientsideV = this._useClientsideValidation) !== null && _this$_useClientsideV !== void 0 ? _this$_useClientsideV : true;
+  }
+  /**
+   * Validate input on client side constraint
+   */
+
+
+  validate(value) {
+    // when client side validation is disabled, this attribute is always valid
+    if (!this.useClientsideValidation()) {
+      return true;
+    }
+
+    if (this.isOptionalAndEmpty(value)) {
+      this._isValid = true;
+    } else if (this._validatedValue !== value) {
+      this._isValid = this.constraintCollection.validate(value);
+    }
+
+    this._validatedValue = value;
+    return this._isValid;
+  }
+  /**
+   * Indicates if attribute is optional and empty
+   */
+
+
+  isOptionalAndEmpty(value) {
+    if (value === undefined) {
+      throw new IllegalArgumentException("isOptionalAndEmpty method needs value argument");
+    }
+
+    return !this.mandatory && value === "";
+  }
+  /**
+   * Retrieve error messages of this attribute
+   */
+
+
+  get errorCollection() {
+    const collection = new ErrorCollection("attribute", this._errorCollection);
+    collection.addConstraints(this.constraintCollection.invalidConstraints(this.validateValue));
+    return collection;
+  }
+  /**
+   * Check if attribute is in error
+   */
+
+
+  inError() {
+    return !this._isValid && this.isChangedSince(0);
+  }
+  /**
+   * Reset static error messages on attribute
+   */
+
+
+  resetErrors() {
+    this._errorCollection = new ErrorCollection("attribute");
+  }
+  /**
+   * Registers an error that was received from a server response
+   */
+
+
+  addServerError(error) {
+    this._errorCollection.addServerError(error.id, error.message, error.properties);
+  }
+  /**
+   */
+
+
+  removeServerError(id) {
+    this._errorCollection.removeServerError(id);
+  }
+  /**
+   */
+
+
+  hasServerErrors() {
+    return this.errorCollection.serverErrors.length > 0;
+  }
+  /**
+   */
+
+
+  hasErrors() {
+    return this.errorCollection.hasItems;
+  }
+  /**
+   * Registers a missing error that was received from the server
+   */
+
+
+  addMissingError() {
+    this._errorCollection.addServerError("Constraint.Missing");
+  }
+  /**
+   */
+
+
+  removeMissingError() {
+    this.removeServerError("Constraint.Missing");
+  }
+  /**
+   */
+
+
+  addServerConstraint(id, defaultMessage, parameters) {
+    this._serverConstraints.addConstraint(id, null, defaultMessage, parameters, this.useClientsideValidation());
+  }
+  /**
+   */
+
+
+  formatParameters(parameters) {
+    if (parameters == null) {
+      return {};
+    }
+
+    const params = {};
+
+    _Object$keys(parameters).forEach(paramKey => {
+      const paramValue = parameters[paramKey];
+
+      if (_endsWithInstanceProperty(paramKey).call(paramKey, "-number") || _endsWithInstanceProperty(paramKey).call(paramKey, "-date")) {
+        params[paramKey] = this.formatValue(paramValue);
+      } else {
+        params[paramKey] = paramValue;
+      }
+    });
+
+    return params;
+  }
+  /**
+   */
+
+
+  get hasDynamicValidationData() {
+    return true;
+  }
+  /**
+   */
+
+
+  updateValidations(errors) {
+    if (errors.some(error => error.id === "Constraint.Mandatory") || this.layouthint.has(MANDATORY)) {
+      this.mandatory = true;
+    } else if (!this.hasValue()) {
+      this.mandatory = false;
+    }
+
+    this._serverConstraints = new ConstraintCollection();
+    this.resetErrors();
+
+    _filterInstanceProperty(errors).call(errors, error => error.id !== "Constraint.Mandatory" || !this.hasValue()).forEach(error => {
+      if (this.hasValue()) {
+        this._errorCollection.addServerError(error.id, error.message, this.formatParameters(error.properties));
+      } else {
+        this.addServerConstraint(error.id, error.message, this.formatParameters(error.properties));
+      }
+    });
+  }
+  /**
+   * Set last modification to current timestamp
+   */
+
+
+  updateLastModification() {
+    this._lastModification = Date.now();
+  }
+  /**
+   * Inidicates if attribute is changed since a given timestamp (Date.now)
+   */
+
+
+  isChangedSince(timestamp) {
+    return this._lastModification > timestamp;
+  }
+  /**
+   * Abstract reset method which should be implemented on each attribute that has this attribute as a base class.
+   *
+   * @abstract
+   */
+
+
+  reset() {
+    throw new UnsupportedOperationException("Reset method not implemented for ".concat(this.type));
+  }
+  /**
+   * Merge old attribute with the attribute from the server.
+   * Readonly attributes always need to show the value from the server
+   */
+
+
+  mergeAttribute(oldAttribute) {
+    this.concept = oldAttribute.concept;
+
+    if (!oldAttribute.readonly && oldAttribute.isValid && oldAttribute.inputvalue !== null) {
+      this.update(oldAttribute.inputvalue);
+    }
+  }
+  /**
+   * Abstract update method which should be implemented on each attribute that has this attribute as a base class.
+   * @abstract
+   */
+  // eslint-disable-next-line no-unused-vars
+
+
+  update(value, changedAttribute) {
+    throw new UnsupportedOperationException("Update method not implemented for ".concat(this.type));
+  }
+  /**
+   * Indicate if attribute is editable
+   */
+
+
+  set isEditable(isEditable) {
+    this._isEditable = isEditable;
+  }
+  /**
+   * Retrieve if attribute is editable
+   */
+
+
+  get isEditable() {
+    return this._isEditable;
+  }
+  /**
+   * Indicates if the attribute is visible
+   */
+
+
+  get isVisible() {
+    return !this._isHidden;
+  }
+  /**
+   */
+
+
+  get isHidden() {
+    return this._isHidden;
+  }
+  /**
+   */
+
+
+  set isHidden(isHidden) {
+    this._isHidden = isHidden;
+  }
+  /**
+   * Explicitly toggle visibility of this attribute
+   */
+
+
+  show() {
+    this.isHidden = false;
+  }
+  /**
+   */
+
+
+  hide() {
+    this.isHidden = true;
+  }
+  /**
+   */
+
+
+  equals(otherAttribute) {
+    return this.key === otherAttribute.key && this.parentKey === otherAttribute.parentKey;
+  }
+  /**
+   * Readonly attribute width indicates the proposed width of this attribute
+   */
+
+
+  get readonlyWidth() {
+    return ATTRIBUTE_WIDTH.MEDIUM;
+  }
+  /**
+   */
+
+
+  get layoutHintRules() {
+    return this._layoutHintRules;
+  }
+  /**
+   */
+
+
+  set layoutHintRules(rules) {
+    this._layoutHintRules = rules;
+  }
+  /**
+   */
+
+
+  processLayoutHintRules(attributes) {
+    if (this._layoutHintRules) {
+      this.layoutHintRules.process(this, attributes);
+    }
+  }
+  /**
+   * Indicates if content comes from the data service
+   */
+
+
+  get hasContentFromData() {
+    return hasAllContentInData();
+  }
+  /**
+   */
+
+
+  get content() {
+    return new AttributeContent(this.data.content);
+  }
 
-export { AttributeModel as default };
+}
 //# sourceMappingURL=AttributeModel.js.map