@beinformed/ui 1.23.3-beta.0 → 1.23.5

package/esm/models/attributes/AttributeModel.js

@@ -18,650 +18,785 @@ import { ATTRIBUTE_WIDTH, TIMEVERSION_FILTER_NAME } from "../../constants/Consta
 import { getSetting, hasAllContentInData } from "../../constants/Settings";
 import { IllegalArgumentException, UnsupportedOperationException } from "../../exceptions";
 import AttributeContent from "./AttributeContent";
-
 /**
  * Attribute model, base model for all kind of attributes
  */
+
 export default class AttributeModel extends BaseModel {
   /**
    */
   constructor(attribute, attributeContributions) {
     super(attribute, attributeContributions);
+
     _defineProperty(this, "_label", void 0);
+
     _defineProperty(this, "_lastModification", 0);
+
     _defineProperty(this, "_initvalue", void 0);
+
     _defineProperty(this, "_inputvalue", void 0);
+
     _defineProperty(this, "_value", void 0);
+
     _defineProperty(this, "_errorCollection", void 0);
+
     _defineProperty(this, "_serverConstraints", new ConstraintCollection());
+
     _defineProperty(this, "_useClientsideValidation", getSetting("USE_CLIENTSIDE_VALIDATION"));
+
     _defineProperty(this, "_isValid", true);
+
     _defineProperty(this, "_validatedValue", void 0);
+
     _defineProperty(this, "_isEditable", false);
+
     _defineProperty(this, "_concept", null);
+
     _defineProperty(this, "_referenceDate", void 0);
+
     _defineProperty(this, "_isResult", void 0);
+
     _defineProperty(this, "_isHidden", false);
+
     _defineProperty(this, "_readonly", void 0);
+
     _defineProperty(this, "_disabled", false);
+
     _defineProperty(this, "_mandatory", void 0);
+
     _defineProperty(this, "_links", void 0);
+
     _defineProperty(this, "_parentKey", void 0);
+
     _defineProperty(this, "_hasContentConfiguration", void 0);
+
     _defineProperty(this, "_layoutHintRules", void 0);
+
     if (this.hasContentFromData && this.content.label) {
       this._label = this.content.label;
     } else {
       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");
+
     if (attribute && attribute.message) {
       this._errorCollection.addServerError(attribute.message.id, attribute.message.message, attribute.message.parameters, attribute.message.layouthint);
     }
+
     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);
   }
-
   /**
    */
+
+
   static isApplicableModel(contributions) {
     if (!isPlainObject(contributions)) {
       throw new IllegalArgumentException("Given argument for isApplicableModel is not a contributions object");
     }
+
     return false;
   }
-
   /**
    * Retrieve initial input value
    */
+
+
   getInitialInputValue(value) {
     return value;
   }
-
   /**
    */
+
+
   getInitialChildModelLinks() {
     if (!this.hasContentFromData && this.hasContentConfiguration && this.conceptLink) {
       return [this.conceptLink];
     }
+
     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));
     }
   }
-
   /**
    * 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;
     }
   }
-
   /**
    * 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) {
-      return this.content.label ?? this.label;
+      var _this$content$label;
+
+      return (_this$content$label = this.content.label) !== null && _this$content$label !== void 0 ? _this$content$label : this.label;
     }
+
     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;
   }
-
   /**
    */
+
+
   get defaultAlignment() {
     return "left";
   }
-
   /**
    * Handles layout hint align-left, align-center and align-right
    */
+
+
   get alignment() {
-    const alignmentHints = this.layouthint.getByLayoutHint("align-");
+    const alignmentHints = this.layouthint.getByLayoutHint("align-"); // return alignment based on layouthint or the default alignment for the attribute
 
-    // return alignment based on layouthint or the default alignment for the attribute
     const alignment = alignmentHints ? alignmentHints.substring("align-".length) : this.defaultAlignment;
+
     if (alignment === "left" || alignment === "center" || alignment === "right") {
       return alignment;
     }
+
     return this.defaultAlignment;
   }
-
   /**
    * Retrieve links of attribute
    */
+
+
   get links() {
     if (!this._links) {
       this._links = new LinkCollection(this.data._links, this.contributions._links);
     }
+
     return this._links;
   }
-
   /**
    * Retrieve link of attribute when available
    */
+
+
   get downloadLink() {
     const downloadLink = this.links.getLinksByGroup("download").first;
+
     if (downloadLink && downloadLink.key === this.key) {
       return downloadLink;
     }
+
     return null;
   }
-
   /**
    * Retrieve concept link of attribute when available
    */
+
+
   get conceptLink() {
     const 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
    */
+
+
   get concept() {
-    return this._concept ?? null;
-  }
+    var _this$_concept;
 
+    return (_this$_concept = this._concept) !== null && _this$_concept !== void 0 ? _this$_concept : null;
+  }
   /**
    * Set the concept
    */
+
+
   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
    */
+
+
   get referenceDate() {
     return this._referenceDate;
   }
-
   /**
    * Set reference date for concepts and content
    */
+
+
   set referenceDate(date) {
     this._referenceDate = date;
   }
-
   /**
    * Initial value received from the modular ui service
    */
+
+
   get initvalue() {
     return this._initvalue;
   }
-
   /**
    * Retrieve input value
    */
+
+
   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
    */
+
+
   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
    */
+
+
   get validateValue() {
     return this.inputvalue;
   }
-
   /**
    * Sets the input value to the value entered by the user
    */
+
+
   set inputvalue(value) {
     this._inputvalue = value;
     this.value = value;
     this.validate(value);
   }
-
   /**
    */
+
+
   hasValue() {
     return this._value != null && this._value !== "";
   }
-
   /**
    * Getting the value of the attribute
    */
+
+
   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
    */
+
+
   getFormData() {
     if (this.inError()) {
       return null;
     }
+
     return {
       [this.name]: this.value
     };
   }
-
   /**
    */
+
+
   get formdata() {
     return this.getFormData();
   }
-
   /**
    */
+
+
   getEmptyFormData() {
     return {
       [this.name]: null
     };
   }
-
   /**
    * Getting the value of the attribute
    */
+
+
   get value() {
     return this.getValue();
   }
-
   /**
    * Setting a value in the element
    */
+
+
   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);
+    constraints.add(this._serverConstraints); // Mandatory constraint
 
-    // 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() {
-    return this._useClientsideValidation ?? true;
-  }
+    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, error.layouthint);
   }
-
   /**
    */
+
+
   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), error.layouthint);
@@ -670,140 +805,161 @@ export default class AttributeModel extends BaseModel {
       }
     });
   }
-
   /**
    * 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 ${this.type}`);
+    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 ${this.type}`);
+    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);
   }
+
 }
 //# sourceMappingURL=AttributeModel.js.map