@beinformed/ui 1.20.8 → 1.20.9

package/esm/models/attributes/CompositeAttributeModel.js

@@ -1,20 +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 _assertThisInitialized from "@babel/runtime-corejs3/helpers/esm/assertThisInitialized";
-import _get from "@babel/runtime-corejs3/helpers/esm/get";
-import _set from "@babel/runtime-corejs3/helpers/esm/set";
-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 _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
 import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
-
-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 AttributeModel from "./AttributeModel";
 import CompositeAttributeChildCollection from "./CompositeAttributeChildCollection";
 import ConstraintCollection from "./input-constraints/ConstraintCollection";
@@ -27,454 +13,393 @@ import DatetimeAttributeModel from "./DatetimeAttributeModel";
 
 /**
  */
-var CompositeAttributeModel = /*#__PURE__*/function (_AttributeModel) {
-  _inherits(CompositeAttributeModel, _AttributeModel);
+class CompositeAttributeModel extends AttributeModel {
+  /**
+   */
+  constructor(data, contributions) {
+    super(data, contributions);
 
-  var _super = _createSuper(CompositeAttributeModel);
+    _defineProperty(this, "_children", void 0);
 
+    this._children = CompositeAttributeChildCollection.create(data, contributions);
+    this.setChildrenOptionality();
+  }
   /**
    */
-  function CompositeAttributeModel(data, contributions) {
-    var _this;
 
-    _classCallCheck(this, CompositeAttributeModel);
 
-    _this = _super.call(this, data, contributions);
+  static isApplicableModel(contributions) {
+    const type = contributions === null || contributions === void 0 ? void 0 : contributions.type;
+    return type && (type === "composite" || _includesInstanceProperty(type).call(type, "range"));
+  }
+  /**
+   */
 
-    _defineProperty(_assertThisInitialized(_this), "_children", void 0);
 
-    _this._children = CompositeAttributeChildCollection.create(data, contributions);
+  getInitialChildModelLinks() {
+    return this.children.getInitialChildModelLinks();
+  }
+  /**
+   */
 
-    _this.setChildrenOptionality();
 
-    return _this;
+  setChildModels(models) {
+    this.children.setChildModels(models);
   }
   /**
    */
 
 
-  _createClass(CompositeAttributeModel, [{
-    key: "getInitialChildModelLinks",
-    value:
-    /**
-     */
-    function getInitialChildModelLinks() {
-      return this.children.getInitialChildModelLinks();
+  get type() {
+    // temp fix for results and given answers on list result detail panel
+    if (this.key === "results" || this.key === "givenAnswers") {
+      return "composite";
     }
-    /**
-     */
 
-  }, {
-    key: "setChildModels",
-    value: function setChildModels(models) {
-      this.children.setChildModels(models);
-    }
-    /**
-     */
-
-  }, {
-    key: "type",
-    get: function get() {
-      // temp fix for results and given answers on list result detail panel
-      if (this.key === "results" || this.key === "givenAnswers") {
-        return "composite";
-      }
+    return this.isRange ? "range" : "composite";
+  }
+  /**
+   */
 
-      return this.isRange ? "range" : "composite";
-    }
-    /**
-     */
 
-  }, {
-    key: "isRange",
-    get: function get() {
-      var _this$contributions, _this$contributions$t;
+  get isRange() {
+    var _this$contributions, _this$contributions$t;
 
-      return (_this$contributions = this.contributions) === null || _this$contributions === void 0 ? void 0 : (_this$contributions$t = _this$contributions.type) === null || _this$contributions$t === void 0 ? void 0 : _includesInstanceProperty(_this$contributions$t).call(_this$contributions$t, "range");
-    }
-    /**
-     */
+    return (_this$contributions = this.contributions) === null || _this$contributions === void 0 ? void 0 : (_this$contributions$t = _this$contributions.type) === null || _this$contributions$t === void 0 ? void 0 : _includesInstanceProperty(_this$contributions$t).call(_this$contributions$t, "range");
+  }
+  /**
+   */
 
-  }, {
-    key: "children",
-    get: function get() {
-      return this._children;
-    }
-    /**
-     */
-    ,
-    set: function set(children) {
-      this._children = children;
-    }
-    /**
-     */
 
-  }, {
-    key: "isRangeAttribute",
-    value: function isRangeAttribute(attribute) {
-      return attribute instanceof NumberAttributeModel || attribute instanceof DatetimeAttributeModel;
-    }
-    /**
-     */
+  get children() {
+    return this._children;
+  }
+  /**
+   */
 
-  }, {
-    key: "start",
-    get: function get() {
-      return this.children.all[0];
-    }
-    /**
-     */
 
-  }, {
-    key: "end",
-    get: function get() {
-      return this.children.all[this.children.size - 1];
-    }
-    /**
-     * Get input value of attribute
-     */
-
-  }, {
-    key: "getInputValue",
-    value: function getInputValue() {
-      return this.children.getInputValue();
+  set children(children) {
+    this._children = children;
+  }
+  /**
+   */
+
+
+  isRangeAttribute(attribute) {
+    return attribute instanceof NumberAttributeModel || attribute instanceof DatetimeAttributeModel;
+  }
+  /**
+   */
+
+
+  get start() {
+    return this.children.all[0];
+  }
+  /**
+   */
+
+
+  get end() {
+    return this.children.all[this.children.size - 1];
+  }
+  /**
+   * Get input value of attribute
+   */
+
+
+  getInputValue() {
+    return this.children.getInputValue();
+  }
+  /**
+   * Check if at least one child has value
+   */
+
+
+  hasValue() {
+    return this.children.some(child => child.hasValue());
+  }
+  /**
+   */
+
+
+  get constraintCollection() {
+    const constraints = new ConstraintCollection();
+    constraints.add(this._serverConstraints);
+    constraints.add(this.addConstraints());
+    return constraints;
+  }
+  /**
+   * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
+   */
+
+
+  setUseClientsideValidation(enabled) {
+    super._useClientsideValidation = enabled;
+    this.children.all.forEach(child => child.setUseClientsideValidation(enabled));
+  }
+  /**
+   * Validate input
+   */
+
+
+  validate() {
+    // when client side validation is disabled, this attribute is always valid
+    if (!this.useClientsideValidation()) {
+      return true;
     }
-    /**
-     * Check if at least one child has value
-     */
-
-  }, {
-    key: "hasValue",
-    value: function hasValue() {
-      return this.children.some(function (child) {
-        return child.hasValue();
-      });
+
+    this._isValid = this.children.validate();
+
+    if (this._isValid) {
+      this._isValid = this.constraintCollection.validate();
     }
-    /**
-     */
-
-  }, {
-    key: "constraintCollection",
-    get: function get() {
-      var constraints = new ConstraintCollection();
-      constraints.add(this._serverConstraints);
-      constraints.add(this.addConstraints());
-      return constraints;
+
+    return this._isValid;
+  }
+  /**
+   * Add Date constraints for attribute
+   */
+
+
+  addConstraints() {
+    const constraints = new ConstraintCollection();
+    const startAttribute = this.start;
+    const endAttribute = this.end;
+
+    if (this.isRange && startAttribute != null && endAttribute != null) {
+      const allChildsEntered = this.children.every(child => child.hasValue());
+
+      if (allChildsEntered) {
+        constraints.add(new RangeConstraint(startAttribute, endAttribute));
+      }
     }
-    /**
-     * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
-     */
 
-  }, {
-    key: "setUseClientsideValidation",
-    value: function setUseClientsideValidation(enabled) {
-      _set(_getPrototypeOf(CompositeAttributeModel.prototype), "_useClientsideValidation", enabled, this, true);
+    if (this.isRange && this.mandatory && startAttribute !== null) {
+      const allChildsOptional = this.children.every(child => !child.mandatory);
 
-      this.children.all.forEach(function (child) {
-        return child.setUseClientsideValidation(enabled);
-      });
+      if (allChildsOptional) {
+        constraints.add(new MandatoryRangeConstraint(startAttribute.type, this.children));
+      }
     }
-    /**
-     * Validate input
-     */
-
-  }, {
-    key: "validate",
-    value: function validate() {
-      // when client side validation is disabled, this attribute is always valid
-      if (!this.useClientsideValidation()) {
+
+    return constraints;
+  }
+  /**
+   * Indicates if attribute input is valid
+   */
+
+
+  get isValid() {
+    return this.validate();
+  }
+  /**
+   */
+
+
+  hasServerErrors() {
+    return this.errorCollection.serverErrors.length > 0 || this.children.some(child => child.hasServerErrors());
+  }
+  /**
+   */
+
+
+  hasErrors() {
+    return this.errorCollection.hasItems || this.children.some(child => child.hasErrors());
+  }
+  /**
+   * Reset attribute to empty string
+   */
+
+
+  reset() {
+    this.children.reset();
+  }
+  /**
+   */
+
+
+  getChildByAttribute(attribute) {
+    var _context;
+
+    return _findInstanceProperty(_context = this.children).call(_context, child => {
+      if (child.equals(attribute)) {
         return true;
+      } else if (child instanceof CompositeAttributeModel) {
+        return child.getChildByAttribute(attribute);
       }
 
-      this._isValid = this.children.validate();
+      return false;
+    });
+  }
+  /**
+   */
 
-      if (this._isValid) {
-        this._isValid = this.constraintCollection.validate();
-      }
 
-      return this._isValid;
-    }
-    /**
-     * Add Date constraints for attribute
-     */
-
-  }, {
-    key: "addConstraints",
-    value: function addConstraints() {
-      var constraints = new ConstraintCollection();
-      var startAttribute = this.start;
-      var endAttribute = this.end;
-
-      if (this.isRange && startAttribute != null && endAttribute != null) {
-        var allChildsEntered = this.children.every(function (child) {
-          return child.hasValue();
-        });
-
-        if (allChildsEntered) {
-          constraints.add(new RangeConstraint(startAttribute, endAttribute));
-        }
+  getChildByKey(key) {
+    var _context2;
+
+    return _findInstanceProperty(_context2 = this.children).call(_context2, child => {
+      if (child.key === key) {
+        return true;
+      } else if (child instanceof CompositeAttributeModel) {
+        return child.getChildByKey(key);
       }
 
-      if (this.isRange && this.mandatory && startAttribute !== null) {
-        var allChildsOptional = this.children.every(function (child) {
-          return !child.mandatory;
-        });
+      return false;
+    }) || null;
+  }
+  /**
+   */
+
 
-        if (allChildsOptional) {
-          constraints.add(new MandatoryRangeConstraint(startAttribute.type, this.children));
+  mergeAttribute(oldAttribute) {
+    this.concept = oldAttribute.concept;
+    this.children.forEach(child => {
+      if (oldAttribute instanceof CompositeAttributeModel) {
+        const withChildAttribute = oldAttribute.getChildByKey(child.key);
+
+        if (withChildAttribute) {
+          child.mergeAttribute(withChildAttribute);
         }
       }
+    });
+  }
+  /**
+   */
 
-      return constraints;
-    }
-    /**
-     * Indicates if attribute input is valid
-     */
-
-  }, {
-    key: "isValid",
-    get: function get() {
-      return this.validate();
-    }
-    /**
-     */
-
-  }, {
-    key: "hasServerErrors",
-    value: function hasServerErrors() {
-      return this.errorCollection.serverErrors.length > 0 || this.children.some(function (child) {
-        return child.hasServerErrors();
-      });
-    }
-    /**
-     */
-
-  }, {
-    key: "hasErrors",
-    value: function hasErrors() {
-      return this.errorCollection.hasItems || this.children.some(function (child) {
-        return child.hasErrors();
-      });
-    }
-    /**
-     * Reset attribute to empty string
-     */
-
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.children.reset();
-    }
-    /**
-     */
-
-  }, {
-    key: "getChildByAttribute",
-    value: function getChildByAttribute(attribute) {
-      var _context;
-
-      return _findInstanceProperty(_context = this.children).call(_context, function (child) {
-        if (child.equals(attribute)) {
-          return true;
-        } else if (child instanceof CompositeAttributeModel) {
-          return child.getChildByAttribute(attribute);
-        }
 
-        return false;
-      });
+  update(value, changedAttribute) {
+    if (!changedAttribute) {
+      throw new IllegalArgumentException("Composite attribute needs changed attribute on update call");
     }
-    /**
-     */
-
-  }, {
-    key: "getChildByKey",
-    value: function getChildByKey(key) {
-      var _context2;
-
-      return _findInstanceProperty(_context2 = this.children).call(_context2, function (child) {
-        if (child.key === key) {
-          return true;
-        } else if (child instanceof CompositeAttributeModel) {
-          return child.getChildByKey(key);
-        }
 
-        return false;
-      }) || null;
-    }
-    /**
-     */
-
-  }, {
-    key: "mergeAttribute",
-    value: function mergeAttribute(oldAttribute) {
-      this.concept = oldAttribute.concept;
-      this.children.forEach(function (child) {
-        if (oldAttribute instanceof CompositeAttributeModel) {
-          var withChildAttribute = oldAttribute.getChildByKey(child.key);
-
-          if (withChildAttribute) {
-            child.mergeAttribute(withChildAttribute);
-          }
-        }
-      });
-    }
-    /**
-     */
-
-  }, {
-    key: "update",
-    value: function update(value, changedAttribute) {
-      if (!changedAttribute) {
-        throw new IllegalArgumentException("Composite attribute needs changed attribute on update call");
+    this.updateLastModification();
+    this.children.forEach(child => {
+      if (child instanceof CompositeAttributeModel) {
+        child.update(value, changedAttribute);
+      } else if (child.equals(changedAttribute)) {
+        child.update(value);
       }
+    });
+    this.setChildrenOptionality();
+    this.validate();
+    return this;
+  }
+  /**
+   */
 
-      this.updateLastModification();
-      this.children.forEach(function (child) {
-        if (child instanceof CompositeAttributeModel) {
-          child.update(value, changedAttribute);
-        } else if (child.equals(changedAttribute)) {
-          child.update(value);
-        }
-      });
-      this.setChildrenOptionality();
-      this.validate();
-      return this;
-    }
-    /**
-     */
-
-  }, {
-    key: "setChildrenOptionality",
-    value: function setChildrenOptionality() {
-      var childrenAreOptional = !this.mandatory && this.children.every(function (child) {
-        return child.value === null;
-      });
-      this.children.forEach(function (child) {
-        child.mandatory = childrenAreOptional || !child.configuredMandatory ? false : child.configuredMandatory;
-      });
-    }
-    /**
-     */
-
-  }, {
-    key: "readonly",
-    get: function get() {
-      return _get(_getPrototypeOf(CompositeAttributeModel.prototype), "readonly", this) || this.children.every(function (child) {
-        return child.readonly;
-      });
-    }
-    /**
-     */
-    ,
-    set: function set(readonly) {
-      _set(_getPrototypeOf(CompositeAttributeModel.prototype), "readonly", readonly, this, true);
-    }
-    /**
-     */
 
-  }, {
-    key: "readonlyvalue",
-    get: function get() {
-      return this.children.readonlyvalue;
-    }
-    /**
-     */
+  setChildrenOptionality() {
+    const childrenAreOptional = !this.mandatory && this.children.every(child => child.value === null);
+    this.children.forEach(child => {
+      child.mandatory = childrenAreOptional || !child.configuredMandatory ? false : child.configuredMandatory;
+    });
+  }
+  /**
+   */
 
-  }, {
-    key: "initvalue",
-    get: function get() {
-      return this.children.initvalue;
-    }
-    /**
-     */
 
-  }, {
-    key: "getFormData",
-    value: function getFormData() {
-      return _defineProperty({}, this.name, this.value);
-    }
-    /**
-     */
+  get readonly() {
+    return super.readonly || this.children.every(child => child.readonly);
+  }
+  /**
+   */
 
-  }, {
-    key: "getValue",
-    value: function getValue() {
-      return this.children.value;
-    }
-    /**
-     */
 
-  }, {
-    key: "isResult",
-    get: function get() {
-      return this._isResult;
-    }
-    /**
-     */
-    ,
-    set: function set(isResult) {
-      this._isResult = isResult;
-      this.children.forEach(function (child) {
-        child.isResult = isResult;
-      });
-    }
-    /**
-     */
-
-  }, {
-    key: "indicateContentConfiguration",
-    value: function indicateContentConfiguration(contentConfiguration) {
-      if (contentConfiguration) {
-        this.children.forEach(function (child) {
-          child.indicateContentConfiguration(contentConfiguration);
-        });
-      }
-    }
-    /**
-     */
-
-  }, {
-    key: "equals",
-    value: function equals(otherAttribute) {
-      return this.key === otherAttribute.key && this.parentKey === otherAttribute.parentKey || this.children.some( //$FlowFixMe[method-unbinding]
-      function (child) {
-        return child.equals && child.equals(otherAttribute);
+  set readonly(readonly) {
+    super.readonly = readonly;
+  }
+  /**
+   */
+
+
+  get readonlyvalue() {
+    return this.children.readonlyvalue;
+  }
+  /**
+   */
+
+
+  get initvalue() {
+    return this.children.initvalue;
+  }
+  /**
+   */
+
+
+  getFormData() {
+    return {
+      [this.name]: this.value
+    };
+  }
+  /**
+   */
+
+
+  getValue() {
+    return this.children.value;
+  }
+  /**
+   */
+
+
+  get isResult() {
+    return this._isResult;
+  }
+  /**
+   */
+
+
+  set isResult(isResult) {
+    this._isResult = isResult;
+    this.children.forEach(child => {
+      child.isResult = isResult;
+    });
+  }
+  /**
+   */
+
+
+  indicateContentConfiguration(contentConfiguration) {
+    if (contentConfiguration) {
+      this.children.forEach(child => {
+        child.indicateContentConfiguration(contentConfiguration);
       });
     }
-    /**
-     */
+  }
+  /**
+   */
 
-  }, {
-    key: "readonlyWidth",
-    get: function get() {
-      var _this$start;
 
-      if (this.type === "composite") {
-        return ATTRIBUTE_WIDTH.LARGE;
-      } // range
+  equals(otherAttribute) {
+    return this.key === otherAttribute.key && this.parentKey === otherAttribute.parentKey || this.children.some( //$FlowFixMe[method-unbinding]
+    child => child.equals && child.equals(otherAttribute));
+  }
+  /**
+   */
 
 
-      switch ((_this$start = this.start) === null || _this$start === void 0 ? void 0 : _this$start.type) {
-        case "datetime":
-          return ATTRIBUTE_WIDTH.LARGE;
+  get readonlyWidth() {
+    var _this$start;
 
-        case "timestamp":
-          return ATTRIBUTE_WIDTH.EXTRA_LARGE;
+    if (this.type === "composite") {
+      return ATTRIBUTE_WIDTH.LARGE;
+    } // range
 
-        default:
-          return ATTRIBUTE_WIDTH.MEDIUM;
-      }
-    }
-  }], [{
-    key: "isApplicableModel",
-    value: function isApplicableModel(contributions) {
-      var type = contributions === null || contributions === void 0 ? void 0 : contributions.type;
-      return type && (type === "composite" || _includesInstanceProperty(type).call(type, "range"));
+
+    switch ((_this$start = this.start) === null || _this$start === void 0 ? void 0 : _this$start.type) {
+      case "datetime":
+        return ATTRIBUTE_WIDTH.LARGE;
+
+      case "timestamp":
+        return ATTRIBUTE_WIDTH.EXTRA_LARGE;
+
+      default:
+        return ATTRIBUTE_WIDTH.MEDIUM;
     }
-  }]);
+  }
 
-  return CompositeAttributeModel;
-}(AttributeModel);
+}
 
 export default CompositeAttributeModel;
 //# sourceMappingURL=CompositeAttributeModel.js.map