@beinformed/ui 1.20.8 → 1.20.9

package/esm/models/attributes/ChoiceAttributeModel.js

@@ -1,30 +1,7 @@
-import _Reflect$construct from "@babel/runtime-corejs3/core-js-stable/reflect/construct";
-import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
-import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
-import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
-import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
-import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
-import _toConsumableArray from "@babel/runtime-corejs3/helpers/esm/toConsumableArray";
-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";
-
-function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? Object.defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
 import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
 import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
-
-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 } from "../../utils/datetime/DateTimeUtil";
 import AttributeModel from "./AttributeModel";
@@ -37,475 +14,411 @@ import { ATTRIBUTE_WIDTH } from "../../constants";
 /**
  * Model for a choice attribute
  */
-var ChoiceAttributeModel = /*#__PURE__*/function (_AttributeModel) {
-  _inherits(ChoiceAttributeModel, _AttributeModel);
-
-  var _super = _createSuper(ChoiceAttributeModel);
-
+export default class ChoiceAttributeModel extends AttributeModel {
   /**
    * Constructs a choice attribute
    */
-  function ChoiceAttributeModel(attribute, attributeContributions) {
-    var _this;
+  constructor(attribute, attributeContributions) {
+    super(attribute, attributeContributions);
+
+    _defineProperty(this, "_referenceDate", void 0);
+
+    _defineProperty(this, "_options", void 0);
 
-    _classCallCheck(this, ChoiceAttributeModel);
+    _defineProperty(this, "_hasContentConfiguration", void 0);
 
-    _this = _super.call(this, attribute, attributeContributions);
+    this._referenceDate = this.getData("referenceDate", DateUtil.now());
+    this._options = ChoiceAttributeOptionCollection.create(attribute, attributeContributions, this.referenceDate);
+
+    if (this.layouthint.has(SORT_OPTIONS)) {
+      this._options.sortOptions = true;
+    }
+  }
+  /**
+   */
 
-    _defineProperty(_assertThisInitialized(_this), "_referenceDate", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_options", void 0);
+  static isApplicableModel(contributions) {
+    return contributions.type !== "composite" && contributions.type !== "boolean" && (contributions.type === "choice" || contributions.type === "array" || has(contributions, "enumerated") || has(contributions, "options"));
+  }
+  /**
+   */
 
-    _defineProperty(_assertThisInitialized(_this), "_hasContentConfiguration", void 0);
 
-    _this._referenceDate = _this.getData("referenceDate", DateUtil.now());
-    _this._options = ChoiceAttributeOptionCollection.create(attribute, attributeContributions, _this.referenceDate);
+  get type() {
+    const optionMode = this.getContribution("optionMode", "");
+    const hasLookupLink = this.lookupLink || this.lookupListLink;
 
-    if (_this.layouthint.has(SORT_OPTIONS)) {
-      _this._options.sortOptions = true;
+    if (optionMode === "lookup" || optionMode === "dynamicWithThreshold" && hasLookupLink) {
+      return "lookup";
     }
 
-    return _this;
+    return "choice";
   }
   /**
    */
 
 
-  _createClass(ChoiceAttributeModel, [{
-    key: "type",
-    get:
-    /**
-     */
-    function get() {
-      var optionMode = this.getContribution("optionMode", "");
-      var hasLookupLink = this.lookupLink || this.lookupListLink;
+  getInitialChildModelLinks() {
+    const links = [];
 
-      if (optionMode === "lookup" || optionMode === "dynamicWithThreshold" && hasLookupLink) {
-        return "lookup";
+    if (this.hasContentConfiguration) {
+      if (!this.hasContentFromData && this.conceptLink) {
+        links.push(this.conceptLink);
       }
 
-      return "choice";
+      links.push(...this.options.getInitialChildModelLinks());
     }
-    /**
-     */
 
-  }, {
-    key: "getInitialChildModelLinks",
-    value: function getInitialChildModelLinks() {
-      var links = [];
+    return links;
+  }
+  /**
+   */
 
-      if (this.hasContentConfiguration) {
-        if (!this.hasContentFromData && this.conceptLink) {
-          links.push(this.conceptLink);
-        }
 
-        links.push.apply(links, _toConsumableArray(this.options.getInitialChildModelLinks()));
-      }
+  setChildModels(models) {
+    var _this$conceptLink;
 
-      return links;
+    const conceptLinkHref = (_this$conceptLink = this.conceptLink) === null || _this$conceptLink === void 0 ? void 0 : _this$conceptLink.href;
+
+    if (conceptLinkHref) {
+      this.concept = _findInstanceProperty(models).call(models, model => model.type === "ConceptDetail" && model.selfhref.equalsWithParameters(conceptLinkHref));
     }
-    /**
-     */
 
-  }, {
-    key: "setChildModels",
-    value: function setChildModels(models) {
-      var _this$conceptLink;
+    this.options.setChildModels(models);
+  }
+  /**
+   * Retrieve lookup service link
+   */
 
-      var conceptLinkHref = (_this$conceptLink = this.conceptLink) === null || _this$conceptLink === void 0 ? void 0 : _this$conceptLink.href;
 
-      if (conceptLinkHref) {
-        this.concept = _findInstanceProperty(models).call(models, function (model) {
-          return model.type === "ConceptDetail" && model.selfhref.equalsWithParameters(conceptLinkHref);
-        });
-      }
+  get lookupLink() {
+    return this.links.getLinkByKey("lookupOptions");
+  }
+  /**
+   * Retrieve lookup service as list link
+   */
 
-      this.options.setChildModels(models);
-    }
-    /**
-     * Retrieve lookup service link
-     */
-
-  }, {
-    key: "lookupLink",
-    get: function get() {
-      return this.links.getLinkByKey("lookupOptions");
-    }
-    /**
-     * Retrieve lookup service as list link
-     */
-
-  }, {
-    key: "lookupListLink",
-    get: function get() {
-      return this.links.getLinkByKey("lookupList");
-    }
-    /**
-     */
 
-  }, {
-    key: "lookupListLabel",
-    get: function get() {
-      var _this$contributions$l, _this$contributions$l2;
+  get lookupListLink() {
+    return this.links.getLinkByKey("lookupList");
+  }
+  /**
+   */
 
-      return (_this$contributions$l = (_this$contributions$l2 = this.contributions.lookupList) === null || _this$contributions$l2 === void 0 ? void 0 : _this$contributions$l2.label) !== null && _this$contributions$l !== void 0 ? _this$contributions$l : "";
-    }
-    /**
-     * Retrieve reference date of attribute which can be used as entryDate for content
-     */
-
-  }, {
-    key: "referenceDate",
-    get: function get() {
-      return this._referenceDate;
-    }
-    /**
-     * Set reference date for concepts and content
-     */
-    ,
-    set: function set(date) {
-      this._referenceDate = date;
-      this.options.referenceDate = date;
-    }
-    /**
-     * Retrieve available choice options
-     */
-
-  }, {
-    key: "options",
-    get: function get() {
-      return this._options;
-    }
-    /**
-     * Getting all enabled options
-     */
-
-  }, {
-    key: "selected",
-    get: function get() {
-      var _context;
-
-      // $FlowFixMe[incompatible-call]
-      return _mapInstanceProperty(_context = this.options.selected).call(_context, function (option) {
-        return option.code;
-      });
-    }
-    /**
-     * Flatten options and filter out the options that are not selected
-     */
-
-  }, {
-    key: "readonlyvalue",
-    get: function get() {
-      var _context2;
-
-      return _mapInstanceProperty(_context2 = this.options.selected).call(_context2, function (option) {
-        return option.label;
-      }).join(", ");
-    }
-    /**
-     */
-
-  }, {
-    key: "initvalue",
-    get: function get() {
-      if (Array.isArray(this._initvalue) && this._initvalue.length === 0) {
-        return null;
-      }
 
-      return this._initvalue;
-    }
-    /**
-     * Retrieve list of selected options, joined with comma
-     */
-
-  }, {
-    key: "getValue",
-    value: function getValue() {
-      var _context3;
-
-      return this.options.selected.length > 0 ? _mapInstanceProperty(_context3 = this.options.selected).call(_context3, function (option) {
-        return option.code;
-      }).join(",") : null;
-    }
-    /**
-     */
+  get lookupListLabel() {
+    var _this$contributions$l, _this$contributions$l2;
 
-  }, {
-    key: "hasValue",
-    value: function hasValue() {
-      return this.options.selected.length > 0;
-    }
-    /**
-     * Get input value of attribute
-     */
-
-  }, {
-    key: "getInputValue",
-    value: function getInputValue() {
-      return this.selected.join(",");
-    }
-    /**
-     * Setting an option selected or unselected based on the current state
-     */
-
-  }, {
-    key: "toggleOption",
-    value: function toggleOption(code) {
-      var _context4;
-
-      if (_includesInstanceProperty(_context4 = this.selected).call(_context4, code)) {
-        this.disableOption(code);
-      } else {
-        this.enableOption(code);
-      }
-    }
-    /**
-     * Enable a option
-     */
-
-  }, {
-    key: "enableOption",
-    value: function enableOption(code) {
-      if (!this.isMultiple) {
-        this.options.deselectAll();
-      }
+    return (_this$contributions$l = (_this$contributions$l2 = this.contributions.lookupList) === null || _this$contributions$l2 === void 0 ? void 0 : _this$contributions$l2.label) !== null && _this$contributions$l !== void 0 ? _this$contributions$l : "";
+  }
+  /**
+   * Retrieve reference date of attribute which can be used as entryDate for content
+   */
 
-      this.options.select(code);
-      this.inputvalue = this.getInputValue();
-    }
-    /**
-     * Disable a option
-     */
-
-  }, {
-    key: "disableOption",
-    value: function disableOption(code) {
-      this.options.deselect(code);
-      this.inputvalue = this.getInputValue();
-    }
-    /**
-     * Add a new option to the collection of lookup options
-     */
 
-  }, {
-    key: "addOption",
-    value: function addOption(option) {
-      var _context5;
+  get referenceDate() {
+    return this._referenceDate;
+  }
+  /**
+   * Set reference date for concepts and content
+   */
 
-      if (!this.isMultiple) {
-        this.options.deselectAll();
-      }
 
-      if (_findInstanceProperty(_context5 = this.options).call(_context5, function (opt) {
-        return opt.code === option.code;
-      }) === null) {
-        this.options.addOption(option.code, option);
-      }
-    }
-    /**
-     * Getting the type of choice filter. For instance checkbox, radiobutton, combobox.
-     */
-
-  }, {
-    key: "choicetype",
-    get: function get() {
-      var _context6,
-          _this2 = this;
-
-      return _findInstanceProperty(_context6 = ["checkbox", "radiobutton", "combobox", "list", "listview", "table", "longlist", "toggle"]).call(_context6, function (hint) {
-        return _this2.layouthint.has(hint);
-      }) || "checkbox";
+  set referenceDate(date) {
+    this._referenceDate = date;
+    this.options.referenceDate = date;
+  }
+  /**
+   * Retrieve available choice options
+   */
+
+
+  get options() {
+    return this._options;
+  }
+  /**
+   * Getting all enabled options
+   */
+
+
+  get selected() {
+    var _context;
+
+    // $FlowFixMe[incompatible-call]
+    return _mapInstanceProperty(_context = this.options.selected).call(_context, option => option.code);
+  }
+  /**
+   * Flatten options and filter out the options that are not selected
+   */
+
+
+  get readonlyvalue() {
+    var _context2;
+
+    return _mapInstanceProperty(_context2 = this.options.selected).call(_context2, option => option.label).join(", ");
+  }
+  /**
+   */
+
+
+  get initvalue() {
+    if (Array.isArray(this._initvalue) && this._initvalue.length === 0) {
+      return null;
     }
-    /**
-     * Can multiple options be selected
-     */
-
-  }, {
-    key: "isMultiple",
-    get: function get() {
-      return this.contributions.multiplechoice || this.choicetype === "checkbox";
+
+    return this._initvalue;
+  }
+  /**
+   * Retrieve list of selected options, joined with comma
+   */
+
+
+  getValue() {
+    var _context3;
+
+    return this.options.selected.length > 0 ? _mapInstanceProperty(_context3 = this.options.selected).call(_context3, option => option.code).join(",") : null;
+  }
+  /**
+   */
+
+
+  hasValue() {
+    return this.options.selected.length > 0;
+  }
+  /**
+   * Get input value of attribute
+   */
+
+
+  getInputValue() {
+    return this.selected.join(",");
+  }
+  /**
+   * Setting an option selected or unselected based on the current state
+   */
+
+
+  toggleOption(code) {
+    var _context4;
+
+    if (_includesInstanceProperty(_context4 = this.selected).call(_context4, code)) {
+      this.disableOption(code);
+    } else {
+      this.enableOption(code);
     }
-    /**
-     * Check if options need to be rendered as tree
-     */
-
-  }, {
-    key: "isTree",
-    get: function get() {
-      return has(this.contributions, "options") && this.contributions.options.some(function (option) {
-        return has(option, "children");
-      });
+  }
+  /**
+   * Enable a option
+   */
+
+
+  enableOption(code) {
+    if (!this.isMultiple) {
+      this.options.deselectAll();
     }
-    /**
-     * Reset choice attribute to unselected list
-     */
 
-  }, {
-    key: "reset",
-    value: function reset() {
+    this.options.select(code);
+    this.inputvalue = this.getInputValue();
+  }
+  /**
+   * Disable a option
+   */
+
+
+  disableOption(code) {
+    this.options.deselect(code);
+    this.inputvalue = this.getInputValue();
+  }
+  /**
+   * Add a new option to the collection of lookup options
+   */
+
+
+  addOption(option) {
+    var _context5;
+
+    if (!this.isMultiple) {
       this.options.deselectAll();
     }
-    /**
-     */
-
-  }, {
-    key: "mergeAttribute",
-    value: function mergeAttribute(oldAttribute) {
-      // when attribute is readonly, don't merge the options no modifications necessary
-      if (!this.readonly && oldAttribute instanceof ChoiceAttributeModel) {
-        this.concept = oldAttribute.concept;
-        this.options.mergeOptions(oldAttribute.options, this.type === "lookup");
-        this.options.deselectAll();
-
-        if (oldAttribute.isValid && oldAttribute.inputvalue !== null) {
-          this.update(oldAttribute.inputvalue);
-        }
-      }
+
+    if (_findInstanceProperty(_context5 = this.options).call(_context5, opt => opt.code === option.code) === null) {
+      this.options.addOption(option.code, option);
     }
-    /**
-     * Update attribute by name and value
-     */
+  }
+  /**
+   * Getting the type of choice filter. For instance checkbox, radiobutton, combobox.
+   */
 
-  }, {
-    key: "update",
-    value: function update(value) {
-      var _this3 = this;
 
-      if (this.readonly) {
-        return this;
-      }
+  get choicetype() {
+    var _context6;
+
+    return _findInstanceProperty(_context6 = ["checkbox", "radiobutton", "combobox", "list", "listview", "table", "longlist", "toggle"]).call(_context6, hint => this.layouthint.has(hint)) || "checkbox";
+  }
+  /**
+   * Can multiple options be selected
+   */
 
-      this.updateLastModification();
-      var values;
 
-      if (Array.isArray(value)) {
-        values = value;
-      } else if (typeof value === "string" && this.isMultiple) {
-        values = value.split(",");
-      } else {
-        values = [value];
+  get isMultiple() {
+    return this.contributions.multiplechoice || this.choicetype === "checkbox";
+  }
+  /**
+   * Check if options need to be rendered as tree
+   */
+
+
+  get isTree() {
+    return has(this.contributions, "options") && this.contributions.options.some(option => has(option, "children"));
+  }
+  /**
+   * Reset choice attribute to unselected list
+   */
+
+
+  reset() {
+    this.options.deselectAll();
+  }
+  /**
+   */
+
+
+  mergeAttribute(oldAttribute) {
+    // when attribute is readonly, don't merge the options no modifications necessary
+    if (!this.readonly && oldAttribute instanceof ChoiceAttributeModel) {
+      this.concept = oldAttribute.concept;
+      this.options.mergeOptions(oldAttribute.options, this.type === "lookup");
+      this.options.deselectAll();
+
+      if (oldAttribute.isValid && oldAttribute.inputvalue !== null) {
+        this.update(oldAttribute.inputvalue);
       }
+    }
+  }
+  /**
+   * Update attribute by name and value
+   */
 
-      values.forEach(function (val) {
-        if (val instanceof ChoiceAttributeOptionModel) {
-          if (!_this3.options.some(function (option) {
-            return option.equals(val);
-          })) {
-            _this3.options.add(val);
-          }
 
-          _this3.toggleOption(val.code);
-        } else if (typeof val === "string" && _this3.options.some(function (option) {
-          return option.code.toString() === val;
-        })) {
-          _this3.toggleOption(val);
-        }
-      });
+  update(value) {
+    if (this.readonly) {
       return this;
     }
-    /**
-     */
-
-  }, {
-    key: "hasContentConfiguration",
-    get:
-    /**
-     */
-    function get() {
-      return this._hasContentConfiguration;
-    }
-    /**
-     * Get content configuration configured on the attribute.
-     * Only applicable for taxonomy element and knowledge codemaps,
-     * content configuration for instrument questions is available on the form object
-     */
-    ,
-    set: function set(hasContentConfiguration) {
-      this._hasContentConfiguration = this.contentConfiguration !== null || hasContentConfiguration;
+
+    this.updateLastModification();
+    let values;
+
+    if (Array.isArray(value)) {
+      values = value;
+    } else if (typeof value === "string" && this.isMultiple) {
+      values = value.split(",");
+    } else {
+      values = [value];
     }
-  }, {
-    key: "contentConfiguration",
-    get: function get() {
-      var _context7;
-
-      if (!this.contributions.content || !this.contributions.content.optionElements) {
-        return null;
-      } // Add RENDER_SECTION_LABEL to all content configuration to make sure the label of a section is always rendered on taxonomy and knowlege codemaps
-
-
-      var optionElementConfig = _mapInstanceProperty(_context7 = this.contributions.content.optionElements).call(_context7, function (optionElement) {
-        if ("contentElement" in optionElement) {
-          return {
-            contentElement: _objectSpread(_objectSpread({}, optionElement.contentElement), {}, {
-              layouthint: [RENDER_SECTION_LABEL]
-            })
-          };
+
+    values.forEach(val => {
+      if (val instanceof ChoiceAttributeOptionModel) {
+        if (!this.options.some(option => option.equals(val))) {
+          this.options.add(val);
         }
 
-        return optionElement;
-      });
+        this.toggleOption(val.code);
+      } else if (typeof val === "string" && this.options.some(option => option.code.toString() === val)) {
+        this.toggleOption(val);
+      }
+    });
+    return this;
+  }
+  /**
+   */
 
-      return new ContentConfigurationElements(optionElementConfig);
-    }
-    /**
-     * Get placeholder text
-     */
-
-  }, {
-    key: "placeholder",
-    get: function get() {
-      return this.getContribution("placeholder", "");
-    }
-    /**
-     * 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;
-      var ANSWER_OPTION_KEY = "answer-option-key";
+  set hasContentConfiguration(hasContentConfiguration) {
+    this._hasContentConfiguration = this.contentConfiguration !== null || hasContentConfiguration;
+  }
+  /**
+   */
+
 
-      if (properties && has(properties, ANSWER_OPTION_KEY)) {
-        var _context8;
+  get hasContentConfiguration() {
+    return this._hasContentConfiguration;
+  }
+  /**
+   * Get content configuration configured on the attribute.
+   * Only applicable for taxonomy element and knowledge codemaps,
+   * content configuration for instrument questions is available on the form object
+   */
 
-        var optionKey = properties[ANSWER_OPTION_KEY];
 
-        var foundOption = _findInstanceProperty(_context8 = this.options).call(_context8, function (option) {
-          return option.code === optionKey;
-        });
+  get contentConfiguration() {
+    var _context7;
 
-        if (foundOption) {
-          properties[ANSWER_OPTION_KEY] = foundOption.getContentConfiguredLabel(this.contentConfiguration);
-        }
-      }
+    if (!this.contributions.content || !this.contributions.content.optionElements) {
+      return null;
+    } // Add RENDER_SECTION_LABEL to all content configuration to make sure the label of a section is always rendered on taxonomy and knowlege codemaps
 
-      this._errorCollection.addServerError(id, message, properties);
-    }
-    /**
-     */
-
-  }, {
-    key: "readonlyWidth",
-    get: function get() {
-      if (this.type === "lookup") {
-        return ATTRIBUTE_WIDTH.SMALL;
+
+    const optionElementConfig = _mapInstanceProperty(_context7 = this.contributions.content.optionElements).call(_context7, optionElement => {
+      if ("contentElement" in optionElement) {
+        return {
+          contentElement: { ...optionElement.contentElement,
+            layouthint: [RENDER_SECTION_LABEL]
+          }
+        };
       }
 
-      return ATTRIBUTE_WIDTH.MEDIUM;
+      return optionElement;
+    });
+
+    return new ContentConfigurationElements(optionElementConfig);
+  }
+  /**
+   * Get placeholder text
+   */
+
+
+  get placeholder() {
+    return this.getContribution("placeholder", "");
+  }
+  /**
+   * Registers an error that was received from a server response
+   */
+
+
+  addServerError(error) {
+    const {
+      id,
+      message,
+      properties
+    } = error;
+    const ANSWER_OPTION_KEY = "answer-option-key";
+
+    if (properties && has(properties, ANSWER_OPTION_KEY)) {
+      var _context8;
+
+      const optionKey = properties[ANSWER_OPTION_KEY];
+
+      const foundOption = _findInstanceProperty(_context8 = this.options).call(_context8, option => option.code === optionKey);
+
+      if (foundOption) {
+        properties[ANSWER_OPTION_KEY] = foundOption.getContentConfiguredLabel(this.contentConfiguration);
+      }
     }
-  }], [{
-    key: "isApplicableModel",
-    value: function isApplicableModel(contributions) {
-      return contributions.type !== "composite" && contributions.type !== "boolean" && (contributions.type === "choice" || contributions.type === "array" || has(contributions, "enumerated") || has(contributions, "options"));
+
+    this._errorCollection.addServerError(id, message, properties);
+  }
+  /**
+   */
+
+
+  get readonlyWidth() {
+    if (this.type === "lookup") {
+      return ATTRIBUTE_WIDTH.SMALL;
     }
-  }]);
 
-  return ChoiceAttributeModel;
-}(AttributeModel);
+    return ATTRIBUTE_WIDTH.MEDIUM;
+  }
 
-export { ChoiceAttributeModel as default };
+}
 //# sourceMappingURL=ChoiceAttributeModel.js.map