@beinformed/ui 1.59.22 → 1.60.0

package/lib/models/form/FormModel.js

@@ -0,0 +1,1038 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+var _find = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/find"));
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+var _findIndex = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/find-index"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
+var _slice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/slice"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+var _flattenDeep = _interopRequireDefault(require("lodash/flattenDeep"));
+var _deepmerge = _interopRequireDefault(require("deepmerge"));
+var _objects = require("../../utils/helpers/objects");
+var _exceptions = require("../../exceptions");
+var _ResourceModel = _interopRequireDefault(require("../base/ResourceModel"));
+var _ErrorCollection = _interopRequireDefault(require("../error/ErrorCollection"));
+var _Href = _interopRequireDefault(require("../href/Href"));
+var _Parameter = _interopRequireDefault(require("../parameter/Parameter"));
+var _FormObjectModel = _interopRequireDefault(require("./FormObjectModel"));
+var _Constants = require("../../constants/Constants");
+var _Settings = require("../../constants/Settings");
+var _LayoutHints = require("../../constants/LayoutHints");
+var _LayoutHintCollection = _interopRequireDefault(require("../layouthint/LayoutHintCollection"));
+var _AttributeSetModel = _interopRequireDefault(require("../attributes/AttributeSetModel"));
+/**
+ */
+class FormModel extends _ResourceModel.default {
+  /**
+   */
+  constructor(modularuiResponse) {
+    super(modularuiResponse);
+    (0, _defineProperty2.default)(this, "_lastUpdate", void 0);
+    (0, _defineProperty2.default)(this, "_completedFormObjects", []);
+    (0, _defineProperty2.default)(this, "_currentFormObject", null);
+    (0, _defineProperty2.default)(this, "_previouslyEnteredFormObjects", []);
+    (0, _defineProperty2.default)(this, "_mergePreviouslyEnteredObjects", true);
+    (0, _defineProperty2.default)(this, "_endResultFormObjects", []);
+    (0, _defineProperty2.default)(this, "_previousEndResultKeys", []);
+    (0, _defineProperty2.default)(this, "_useClientsideValidation", (0, _Settings.getSetting)("USE_CLIENTSIDE_VALIDATION"));
+    (0, _defineProperty2.default)(this, "_errorCollection", new _ErrorCollection.default("form"));
+    (0, _defineProperty2.default)(this, "_redirectLocation", void 0);
+    (0, _defineProperty2.default)(this, "_commit", void 0);
+    (0, _defineProperty2.default)(this, "_isFinished", void 0);
+    (0, _defineProperty2.default)(this, "_isComplete", void 0);
+    (0, _defineProperty2.default)(this, "_success", void 0);
+    (0, _defineProperty2.default)(this, "_parameters", void 0);
+    (0, _defineProperty2.default)(this, "_tokens", void 0);
+    this.lastUpdate = 0;
+    this.currentFormObject = this.createFormObject();
+    this.endResultFormObjects = this.setEndResultFormObjects();
+    this.parameters = this.setParameters(modularuiResponse);
+    this.isComplete = this.getData("complete", false);
+    if (this.data.errors) {
+      this.handleRootErrors(this.data.errors);
+    }
+    this.createSuccess();
+  }
+
+  /**
+   */
+  get type() {
+    return "Form";
+  }
+
+  /**
+   */
+  get actiontype() {
+    if (this.layouthint.has(_LayoutHints.CREATE_ACTION)) {
+      return "create";
+    }
+    if (this.layouthint.has(_LayoutHints.UPDATE_ACTION)) {
+      return "update";
+    }
+    if (this.layouthint.has(_LayoutHints.DELETE_ACTION)) {
+      return "delete";
+    }
+    return this.getContribution("actiontype", "form");
+  }
+
+  /**
+   */
+  static get modelName() {
+    return "FormModel";
+  }
+
+  /**
+   */
+  static isApplicableModel(data) {
+    return data.contributions.resourcetype && data.contributions.resourcetype === "Form";
+  }
+
+  /**
+   */
+  getInitialChildModelLinks() {
+    var _context;
+    const endResultChildLinks = (0, _flattenDeep.default)((0, _map.default)(_context = this.endResultFormObjects).call(_context, endResultFormObject => endResultFormObject.getInitialChildModelLinks()));
+    if (this.currentFormObject === null) {
+      return endResultChildLinks;
+    }
+    return [...this.currentFormObject.getInitialChildModelLinks(), ...endResultChildLinks];
+  }
+
+  /**
+   */
+  setChildModels(models, errors) {
+    if (this.currentFormObject) {
+      this.currentFormObject.setChildModels(models, errors);
+    }
+    this.endResultFormObjects.forEach(endResultFormObject => {
+      endResultFormObject.setChildModels(models, errors);
+    });
+  }
+
+  /**
+   */
+  get label() {
+    return this.getContribution("label", "");
+  }
+
+  /**
+   * Get form level button labels
+   */
+  get buttonLabels() {
+    return this.getContribution("buttonLabels", {});
+  }
+
+  /**
+   * @returns button label from contributions;
+   */
+  getButtonLabel(buttonType) {
+    // cancel button labels are defined on the form
+    if (buttonType === "cancel") {
+      return this.buttonLabels?.cancel ?? null;
+    }
+
+    // all other form related button labels are defined on the object
+    return this.currentFormObject?.buttonLabels?.[buttonType] ?? null;
+  }
+
+  /**
+   * Get all applicable objects
+   */
+  get allObjects() {
+    if (this.currentFormObject === null) {
+      return this.completedFormObjects;
+    }
+    return [...this.completedFormObjects, this.currentFormObject];
+  }
+
+  /**
+   */
+  get objectKeys() {
+    if ((0, _objects.has)(this.contributions, "objects")) {
+      return (0, _keys.default)(this.contributions.objects);
+    }
+    return [];
+  }
+
+  /**
+   */
+  get numberOfExpectedQuestions() {
+    return this.objectKeys.length;
+  }
+
+  /**
+   * Has questions configured on form
+   */
+  get hasNoQuestionsConfigured() {
+    return this.isComplete && (this.objectKeys.length === 0 || !("missing" in this.data) && !("results" in this.data) && !("errors" in this.data));
+  }
+
+  /**
+   */
+  addGlobalDynamicSchema(anchor, dynamicschema) {
+    var _context2;
+    if (!dynamicschema) {
+      return anchor;
+    }
+    return {
+      ...anchor,
+      elements: (0, _map.default)(_context2 = anchor.elements).call(_context2, element => {
+        var _context3;
+        return {
+          ...element,
+          dynamicschema: element.dynamicschema ? (0, _map.default)(_context3 = element.dynamicschema).call(_context3, item => ({
+            ...item,
+            elements: {
+              ...item.elements,
+              dynamicschema
+            }
+          })) : null
+        };
+      })
+    };
+  }
+
+  /**
+   */
+  getMissingAnchors() {
+    const missingAnchors = this.data.missing?.anchors ?? [];
+
+    // Add intermediate result data to anchor
+    return (0, _map.default)(missingAnchors).call(missingAnchors, anchor => {
+      if (this.data.results) {
+        var _context4;
+        const resultObject = (0, _find.default)(_context4 = this.data.results).call(_context4, result => result.objectid === anchor.objectid && "elements" in result);
+        if (resultObject) {
+          anchor.results = resultObject.elements;
+        }
+      }
+      return this.addGlobalDynamicSchema(anchor, this.data.dynamicschema);
+    });
+  }
+
+  /**
+   * Create form object based on the data and contributions available in this form
+   */
+  createFormObject() {
+    if (this.data && this.contributions) {
+      const missingAnchors = this.getMissingAnchors();
+
+      // Get object id from first anchor
+      const objectId = missingAnchors?.[0]?.objectid ?? "";
+      const contributions = this.contributions.objects?.[objectId];
+      if (contributions) {
+        return new _FormObjectModel.default(missingAnchors[0], contributions, this.modelOptions);
+      }
+    }
+    return null;
+  }
+
+  /**
+   */
+  addEmptyFormObject() {
+    let formObjectModel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.currentFormObject;
+    if (formObjectModel) {
+      const emptyFormObject = _FormObjectModel.default.createEmpty(formObjectModel);
+      emptyFormObject.repeatIndex = this.getHighestRepeatIndex(formObjectModel) + 1;
+      this.addFormObject(emptyFormObject);
+    }
+  }
+
+  /**
+   */
+  getHighestRepeatIndex(formObjectModel) {
+    var _context5, _context6;
+    return Math.max(...(0, _map.default)(_context5 = (0, _filter.default)(_context6 = this.allObjects).call(_context6, formObject => formObject.equals(formObjectModel, false))).call(_context5, formObject => formObject.repeatIndex));
+  }
+
+  /**
+   */
+  addFormObject(formObjectModel) {
+    if (!formObjectModel) {
+      throw new _exceptions.IllegalArgumentException("Missing form object to add");
+    }
+    this.completedFormObjects = [...this.allObjects];
+    this.currentFormObject = formObjectModel;
+  }
+
+  /**
+   * Retrieve a form object by the key
+   */
+  getFormObjectByKey(key) {
+    var _context7;
+    return (0, _find.default)(_context7 = this.allObjects).call(_context7, formObject => formObject.key === key);
+  }
+
+  /**
+   * Retrieve a form object by a layouthint
+   */
+  getFormObjectByLayoutHint(hint) {
+    var _context8;
+    return (0, _find.default)(_context8 = this.allObjects).call(_context8, formObject => formObject.layouthint.has(hint));
+  }
+
+  /**
+   */
+  removeFormObject(formObjectModel) {
+    var _context9;
+    if (!formObjectModel) {
+      throw new _exceptions.IllegalArgumentException("Missing form object to remove");
+    }
+    if (formObjectModel.equals(this.currentFormObject)) {
+      throw new _exceptions.IllegalArgumentException("Can not remove the current form object");
+    }
+    this.completedFormObjects = (0, _filter.default)(_context9 = this.completedFormObjects).call(_context9, formObject => !formObject.equals(formObjectModel));
+  }
+
+  /**
+   */
+  get currentFormObject() {
+    return this._currentFormObject;
+  }
+
+  /**
+   */
+  set currentFormObject(formObject) {
+    this._currentFormObject = formObject;
+  }
+
+  /**
+   * Completed objects are previously entered questions
+   */
+  get completedFormObjects() {
+    return this._completedFormObjects;
+  }
+
+  /**
+   */
+  set completedFormObjects(formObjects) {
+    this._completedFormObjects = formObjects;
+  }
+
+  /**
+   * Previously entered objects are questions that have been entered before,
+   * but are currently not applicable for the form.
+   * For example because of previous navigation
+   */
+  get previouslyEnteredFormObjects() {
+    return this._previouslyEnteredFormObjects;
+  }
+
+  /**
+   */
+  set previouslyEnteredFormObjects(formObjects) {
+    this._previouslyEnteredFormObjects = formObjects;
+  }
+
+  /**
+   * Handle end results
+   */
+  setEndResultFormObjects() {
+    if (this.data && this.data.results) {
+      var _context10, _context11;
+      const missingObjects = this.data.missing?.anchors ?? [];
+      const missingObjectIds = (0, _map.default)(missingObjects).call(missingObjects, anchor => anchor.objectid);
+
+      // Filter out intermediate results and rename elements property to result property
+      const endResultAnchors = (0, _map.default)(_context10 = (0, _filter.default)(_context11 = this.data.results).call(_context11, result => !(0, _includes.default)(missingObjectIds).call(missingObjectIds, result.objectid))).call(_context10, result => {
+        const {
+          elements,
+          ...otherProps
+        } = result;
+        return {
+          ...otherProps,
+          results: elements
+        };
+      });
+      if (endResultAnchors.length > 0) {
+        return (0, _map.default)(endResultAnchors).call(endResultAnchors, endResult => new _FormObjectModel.default(endResult, this.contributions.objects[endResult.objectid], this.modelOptions));
+      }
+    }
+    return [];
+  }
+
+  /**
+   */
+  get expectsEndResultFormObjects() {
+    var _context12;
+    const endResultKeys = (0, _map.default)(_context12 = this.endResultFormObjects).call(_context12, endResult => endResult.key);
+    return this.objectKeys.some(objectKey => this.contributions.objects?.[objectKey]?.content?.results && !(0, _includes.default)(endResultKeys).call(endResultKeys, objectKey));
+  }
+
+  /**
+   */
+  get endResultFormObjects() {
+    return this._endResultFormObjects;
+  }
+
+  /**
+   */
+  getEndResultFormObjects() {
+    var _context13;
+    return (0, _filter.default)(_context13 = this.endResultFormObjects).call(_context13, endResult => {
+      var _context14;
+      return !(0, _includes.default)(_context14 = this.previousEndResultKeys).call(_context14, endResult.key);
+    });
+  }
+
+  /**
+   */
+  set endResultFormObjects(endResultFormObjects) {
+    var _context15;
+    this.previousEndResultKeys = (0, _map.default)(_context15 = this.endResultFormObjects).call(_context15, endResult => endResult.key);
+    this._endResultFormObjects = endResultFormObjects;
+  }
+
+  /**
+   */
+  get previousEndResultKeys() {
+    return this._previousEndResultKeys;
+  }
+
+  /**
+   */
+  set previousEndResultKeys(endResultFormObjectKeys) {
+    this._previousEndResultKeys = endResultFormObjectKeys;
+  }
+
+  /**
+   * Error handling
+   */
+  get isValid() {
+    if (this.currentFormObject) {
+      if (this.currentFormObject.isRepeatable) {
+        var _context16, _context17;
+        // repeating objects need at least one valid form object
+        const hasOneValidQuestion = (0, _find.default)(_context16 = (0, _filter.default)(_context17 = this.allObjects).call(_context17, object => object.equals(this.currentFormObject, false))).call(_context16, object => object.isValid);
+        if (hasOneValidQuestion) {
+          return true;
+        }
+      }
+      return this.currentFormObject?.isValid ?? true;
+    }
+    return true;
+  }
+
+  /**
+   */
+  hasServerErrors() {
+    if (this.errorCollection.hasItems) {
+      return true;
+    }
+    if (this.currentFormObject) {
+      return this.currentFormObject.hasServerErrors();
+    }
+    return false;
+  }
+
+  /**
+   */
+  hasErrors() {
+    if (this.errorCollection.hasItems) {
+      return true;
+    }
+    if (this.currentFormObject) {
+      return this.currentFormObject.hasErrors();
+    }
+    return false;
+  }
+
+  /**
+   * Add an error to the error collection of this form
+   */
+  addServerError(error) {
+    if (error.parameters) {
+      this.errorCollection.addServerError(error.id, error.message, error.parameters, error.layouthint);
+    } else {
+      this.errorCollection.addServerError(error.id, error.message, undefined, error.layouthint);
+    }
+  }
+
+  /**
+   * Reset error messages
+   */
+  resetErrors() {
+    this._errorCollection = new _ErrorCollection.default("form");
+    if (this.currentFormObject) {
+      this.currentFormObject.resetErrors();
+    }
+  }
+
+  /**
+   */
+  get errorCollection() {
+    return this._errorCollection;
+  }
+
+  /**
+   */
+  set errorCollection(errorCollection) {
+    this._errorCollection = errorCollection;
+  }
+
+  /**
+   * Indicates if the form needs to be committed
+   */
+  get commit() {
+    return this._commit || false;
+  }
+
+  /**
+   */
+  set commit(commit) {
+    this._commit = commit;
+  }
+
+  /**
+   * Inidicates if form is finished: Form is completely entered and committed
+   */
+  get isFinished() {
+    return this._isFinished || this.success != undefined;
+  }
+
+  /**
+   */
+  set isFinished(isFinished) {
+    this._isFinished = isFinished;
+  }
+
+  /**
+   * Indicates if form is completely entered
+   */
+  get isComplete() {
+    return this._isComplete;
+  }
+
+  /**
+   */
+  set isComplete(isComplete) {
+    this._isComplete = isComplete;
+  }
+
+  /**
+   * Handle success redirects
+   */
+  get successRedirect() {
+    return this.isFinished && this.success ? new _Href.default(this.success.redirect, "", this.modelOptions) : null;
+  }
+
+  /**
+   */
+  get redirectLocation() {
+    return this._redirectLocation || this.successRedirect;
+  }
+
+  /**
+   * Get the result data as plain json object
+   */
+  getSuccessData() {
+    return this.success?.data;
+  }
+
+  /**
+   * Retrieve an object where each property is a result data attribute set
+   */
+  getResultData() {
+    const resultDataKeys = (0, _keys.default)(this.contributions.resultdata) ?? [];
+    const successData = this.getSuccessData() ?? {};
+    const resultdata = {};
+    for (const resultDataKey of resultDataKeys) {
+      resultdata[resultDataKey] = new _AttributeSetModel.default(resultDataKey, successData[resultDataKey], this.contributions.resultdata[resultDataKey], this.modelOptions);
+    }
+    return resultdata;
+  }
+
+  /**
+   */
+  get resultData() {
+    return this.getSuccessData();
+  }
+
+  /**
+   * Href handling
+   */
+  setParameters(modularuiResponse) {
+    const parameters = modularuiResponse?.parameters ?? [];
+    return (0, _map.default)(parameters).call(parameters, par => new _Parameter.default(par._prefix, par._name, par._value));
+  }
+
+  /**
+   */
+  get parameters() {
+    return this._parameters;
+  }
+
+  /**
+   */
+  set parameters(parameters) {
+    this._parameters = parameters;
+  }
+
+  /**
+   */
+  selfhrefNoCommitParam() {
+    var _context18;
+    const selfhref = this.selflink.href;
+    selfhref.method = _Constants.HTTP_METHODS.POST;
+    selfhref.parameters = (0, _filter.default)(_context18 = this.parameters).call(_context18, parameter => parameter.name !== "commit");
+    return selfhref;
+  }
+
+  /**
+   */
+  selfhrefWithCommitParam() {
+    const selfhref = this.selfhrefNoCommitParam();
+    if (this.expectsEndResultFormObjects && !this.isComplete && !this.commit) {
+      selfhref.addParameter("commit", "false");
+    }
+    return selfhref;
+  }
+
+  /**
+   * Create a selfhref including the parameters that are used to start this form
+   */
+  get selfhref() {
+    if (!this.selflink) {
+      throw new Error("No self link found for form");
+    }
+    if ((0, _Settings.getSetting)("ALWAYS_COMMIT_FORM")) {
+      return this.selfhrefNoCommitParam();
+    }
+    return this.selfhrefWithCommitParam();
+  }
+
+  /**
+   * Handle form tokens to indicate concurrent form use
+   */
+  get tokens() {
+    if (!this._tokens) {
+      this._tokens = this.data.tokens ?? [];
+    }
+    return this._tokens;
+  }
+
+  /**
+   * Replaces all tokens with the given collection of tokens
+   */
+  set tokens(tokens) {
+    this._tokens = tokens;
+  }
+
+  /**
+   * Removes all tokens from the form
+   */
+  removeTokens() {
+    this._tokens = [];
+  }
+
+  /**
+   * Keep track of changed form
+   */
+  isChanged() {
+    return this.currentFormObject !== null && this.currentFormObject.isChangedSince(this.lastUpdate);
+  }
+
+  /**
+   */
+  get lastUpdate() {
+    return this._lastUpdate;
+  }
+
+  /**
+   */
+  set lastUpdate(lastUpdate) {
+    this._lastUpdate = lastUpdate;
+  }
+
+  /**
+   */
+  getFormDataObjects() {
+    var _context19;
+    let validOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    let validationData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const formdata = [];
+    const formObjects = (0, _filter.default)(_context19 = this.allObjects).call(_context19, (formObject, index) => {
+      // repeatabe object without fixed nr of repeats, remove last form object from formdata,
+      // because this is the formobject that is used as a placeholder for the create object
+      // of the collection of repeats
+      if (formObject.isRepeatable && !formObject.hasFixedNrOfRepeats) {
+        const isLastRepeat = index === this.allObjects.length - 1 || this.allObjects[index + 1].key !== formObject.key;
+        if (isLastRepeat) {
+          return false;
+        }
+      }
+      return formObject.isValid || !validOnly;
+    });
+    formObjects.forEach(formObject => {
+      const objectFormData = formObject.getFormData(validationData);
+      const existingObjectIndex = (0, _findIndex.default)(formdata).call(formdata, obj => obj.key === formObject.key && obj.repeatIndex === formObject.repeatIndex);
+
+      /*
+       * when the object already exists in the formdata with the same key and index,
+       * merge the attributes of both objects together
+       */
+      if (existingObjectIndex > -1) {
+        formdata[existingObjectIndex].formdata = (0, _deepmerge.default)(formdata[existingObjectIndex].formdata, objectFormData);
+      } else {
+        formdata.push({
+          key: formObject.key,
+          repeatIndex: formObject.repeatIndex,
+          formdata: objectFormData
+        });
+      }
+    });
+    return (0, _map.default)(formdata).call(formdata, obj => ({
+      [obj.key]: obj.formdata
+    }));
+  }
+
+  /**
+   */
+  getFormData() {
+    let validOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    let withConcurrencyToken = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let validationData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (withConcurrencyToken && this.tokens.length > 0) {
+      return (0, _stringify.default)({
+        objects: this.getFormDataObjects(validOnly, validationData),
+        tokens: this.tokens
+      });
+    }
+    return (0, _stringify.default)({
+      objects: this.getFormDataObjects(validOnly, validationData)
+    });
+  }
+
+  /**
+   * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
+   */
+  setUseClientsideValidation(enabled) {
+    this._useClientsideValidation = enabled;
+    this.allObjects.forEach(formObject => {
+      formObject.attributeCollection.all.forEach(item => item.setUseClientsideValidation(enabled));
+    });
+  }
+
+  /**
+   * Indicates if client side validation is enabled
+   * @returns {boolean}
+   */
+  useClientsideValidation() {
+    return this._useClientsideValidation ?? true;
+  }
+
+  /**
+   * Get form data for submitting
+   */
+  get formdata() {
+    return this.getFormData(this.useClientsideValidation());
+  }
+
+  /**
+   */
+  get validationData() {
+    return this.getFormData(false, false, true);
+  }
+
+  /**
+   * Form navigation: Go one object back (previous button)
+   */
+  get hasPreviousStep() {
+    var _context20;
+    const currentFormObjectKey = this.currentFormObject != null ? this.currentFormObject.key : "";
+    return (0, _filter.default)(_context20 = this.completedFormObjects).call(_context20, formObject => !formObject.isRepeatWithUnknownTotal || formObject.key !== currentFormObjectKey).length > 0;
+  }
+
+  /**
+   * Go one form-object back,
+   * for repeating object this means go back
+   * until we get at a form object that had
+   * a different key than the current form object
+   */
+  setPreviousObject() {
+    var _context21, _context22, _context23, _context24, _context25;
+    this.isComplete = false;
+    this.isFinished = false;
+    this.success = null;
+    const oldCurrentFormObject = this.currentFormObject;
+    if (this.currentFormObject !== null) {
+      this.previouslyEnteredFormObjects = [this.currentFormObject, ...this.previouslyEnteredFormObjects];
+    }
+    this.currentFormObject = this.completedFormObjects[this.completedFormObjects.length - 1];
+    this.completedFormObjects = (0, _slice.default)(_context21 = this.completedFormObjects).call(_context21, 0, -1);
+    const completedFormObjectKeys = (0, _filter.default)(_context22 = (0, _map.default)(_context23 = this.completedFormObjects).call(_context23, formObject => formObject.key)).call(_context22, formObjectKey => formObjectKey !== this.currentFormObject?.key);
+    this.endResultFormObjects = (0, _filter.default)(_context24 = this._endResultFormObjects).call(_context24, endResult => (0, _includes.default)(completedFormObjectKeys).call(completedFormObjectKeys, endResult.key));
+    this.previousEndResultKeys = (0, _map.default)(_context25 = this.endResultFormObjects).call(_context25, endResult => endResult.key);
+
+    // while we are at the same repeating form object, go a step back
+    if (this.currentFormObject && this.currentFormObject.equals(oldCurrentFormObject, this.currentFormObject.hasFixedNrOfRepeats)) {
+      this.setPreviousObject();
+    }
+  }
+
+  /**
+   * Form navigation: has next step or is last
+   */
+  get hasNextStep() {
+    var _context26;
+    if (this.isComplete || this.isFinished || this.hasNoQuestionsConfigured || !this.contributions.objects) {
+      return false;
+    }
+
+    // current object is a dynamic object
+    if (this.currentFormObject && this.currentFormObject.isDynamic) {
+      return true;
+    }
+    if (this.expectsEndResultFormObjects) {
+      return true;
+    }
+    const currentObjectIndex = (0, _findIndex.default)(_context26 = this.objectKeys).call(_context26, objectKey => objectKey === this.currentFormObject?.key);
+    const isLastObject = this.objectKeys.length - 1 === currentObjectIndex;
+
+    // current object is a repeating question but it is not the last one
+    if (isLastObject && this.currentFormObject && this.currentFormObject.isRepeatable && !this.currentFormObject.isLastRepeat) {
+      return true;
+    }
+
+    // current object is not repeatable and the last object
+    if (isLastObject) {
+      return false;
+    }
+
+    // can't determine if this is te last, render a next button
+    return true;
+  }
+
+  /**
+   * Merge existing form with new form
+   */
+  update(receivedForm) {
+    if (receivedForm instanceof FormModel) {
+      this.resetErrors();
+      this.lastUpdate = Date.now();
+      this.lastServerUpdate = receivedForm.lastServerUpdate;
+      this.tokens = receivedForm.tokens;
+      this.isComplete = receivedForm.isComplete;
+      this.isFinished = receivedForm.isFinished;
+      this.success = receivedForm.success;
+      const receivedFormData = receivedForm.data ?? {};
+      const hasMissing = (0, _objects.has)(receivedFormData, "missing");
+      const hasErrors = (0, _objects.has)(receivedFormData, "errors");
+      if (!hasMissing && !hasErrors) {
+        this.handleFinished(receivedForm);
+      }
+      if (hasErrors) {
+        this.handleErrors(receivedForm);
+      }
+      if (hasMissing) {
+        this.handleMissing(receivedForm);
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Updates the current form object with new information about the object,
+   * like for example a new dynamicschema. Used for autoupdate functionality that makes it possible
+   * to update the options of a next missing attribute in a form-tree iq question
+   */
+  updateCurrentFormObject(receivedForm) {
+    if (receivedForm instanceof FormModel) {
+      const receivedFormData = receivedForm.data ?? {};
+      const hasMissing = (0, _objects.has)(receivedFormData, "missing");
+      const hasErrors = (0, _objects.has)(receivedFormData, "errors");
+      if (hasErrors) {
+        this.handleErrors(receivedForm);
+      }
+      if (hasMissing) {
+        this.handleMissing(receivedForm);
+      }
+    }
+  }
+
+  /**
+   */
+  updateValidations(data) {
+    if (this.currentFormObject) {
+      this.currentFormObject.updateValidations(data);
+    }
+    return this;
+  }
+
+  /**
+   * Retrieve success information from response
+   * @returns {{redirect: string, data: object}}
+   */
+  get success() {
+    return this._success;
+  }
+
+  /**
+   * Set success information, contains redirect and event data
+   * @param success
+   */
+  set success(success) {
+    this._success = success;
+  }
+
+  /**
+   */
+  createSuccess() {
+    this._success = this.data.success;
+  }
+
+  /**
+   * Process finished form
+   */
+  handleFinished(receivedForm) {
+    if (this.currentFormObject) {
+      this.completedFormObjects = [...this.completedFormObjects, this.currentFormObject];
+    }
+    this.currentFormObject = receivedForm.currentFormObject;
+    this.endResultFormObjects = receivedForm.endResultFormObjects;
+    this._data = receivedForm._data;
+  }
+
+  /**
+   */
+  handleRootErrors(errors) {
+    (0, _filter.default)(errors).call(errors, error => !error.anchor).forEach(error => {
+      this.errorCollection.addServerError(error.id, error.message, error.properties, error.layouthint);
+    });
+  }
+
+  /**
+   * Process errors from received form
+   */
+  handleErrors(receivedForm) {
+    const errorAnchors = receivedForm.data.errors;
+    if (errorAnchors) {
+      errorAnchors.forEach(error => {
+        if (error.anchor && this.currentFormObject && this.currentFormObject.key === error.anchor.objectid) {
+          this.currentFormObject.addServerError(error);
+        } else {
+          this.errorCollection.addServerError(error.id, error.message, error.properties, new _LayoutHintCollection.default(error.layouthint));
+        }
+      });
+    }
+  }
+
+  /**
+   * Process missing from received form
+   */
+  handleMissing(receivedForm) {
+    if (this.currentFormObject && this.currentFormObject.equals(receivedForm.currentFormObject)) {
+      this.handleMissingErrors(receivedForm);
+    } else {
+      this.handleNewFormObject(receivedForm);
+    }
+  }
+
+  /**
+   * Received missing anchors in the response with an object id that is the current form object
+   */
+  processMissingErrors(receivedForm) {
+    var _context27;
+    if (this.currentFormObject === null) {
+      return null;
+    }
+    (0, _map.default)(_context27 = this.currentFormObject.attributeCollection).call(_context27, attribute => {
+      const receivedAttribute = receivedForm.currentFormObject?.getAttributeByKey(attribute.key);
+      if (receivedAttribute) {
+        attribute.addMissingError(receivedAttribute);
+      } else {
+        attribute.removeMissingError();
+      }
+      return attribute;
+    });
+    return this.currentFormObject;
+  }
+
+  /**
+   */
+  handleMissingErrors(receivedForm) {
+    this.currentFormObject = this.processMissingErrors(receivedForm);
+  }
+
+  /**
+   */
+  handleNewFormObject(receivedForm) {
+    this.endResultFormObjects = receivedForm.endResultFormObjects;
+    const receivedCurrentFormObject = receivedForm.currentFormObject;
+    if (receivedCurrentFormObject === null) {
+      this.completedFormObjects = [...this.allObjects];
+      this.currentFormObject = null;
+    } else {
+      var _context28;
+      // check if received form exists in the previously entered form objects
+      const previouslyEnteredFormObjects = (0, _filter.default)(_context28 = this.previouslyEnteredFormObjects).call(_context28, formObject => formObject.equals(receivedCurrentFormObject, formObject.hasFixedNrOfRepeats));
+      if (previouslyEnteredFormObjects.length > 0) {
+        this.handlePreviouslyEnteredFormObjects(receivedCurrentFormObject, previouslyEnteredFormObjects);
+      } else {
+        this.completedFormObjects = [...this.allObjects];
+        this.currentFormObject = receivedCurrentFormObject;
+      }
+    }
+  }
+
+  /**
+   * Indicate if a new form object model should be merged with a previousled entered form object model
+   * Set this property to false on the form that receives the new form to skip the merge behavior
+   */
+  get mergePreviouslyEnteredObjects() {
+    return this._mergePreviouslyEnteredObjects;
+  }
+
+  /**
+   */
+  set mergePreviouslyEnteredObjects(mergePreviouslyEnteredObjects) {
+    this._mergePreviouslyEnteredObjects = mergePreviouslyEnteredObjects;
+  }
+
+  /**
+   */
+  handlePreviouslyEnteredFormObjects(receivedCurrentFormObject, previouslyEnteredFormObjects) {
+    var _context29;
+    previouslyEnteredFormObjects.forEach(previouslyEnteredFormObject => {
+      const mergedObject = this.mergePreviouslyEnteredObjects ? this.mergeObjects(receivedCurrentFormObject, previouslyEnteredFormObject) : receivedCurrentFormObject;
+      this.addFormObject(mergedObject);
+    });
+
+    // remove the previously entered form object
+    this.previouslyEnteredFormObjects = (0, _filter.default)(_context29 = this.previouslyEnteredFormObjects).call(_context29, formObject => {
+      const hasPreviouslyEnteredObject = (0, _find.default)(previouslyEnteredFormObjects).call(previouslyEnteredFormObjects, previouslyEnteredFormObject => formObject.equals(previouslyEnteredFormObject));
+      return !hasPreviouslyEnteredObject;
+    });
+  }
+
+  /**
+   */
+  mergeObjects(newObject, oldObject) {
+    const mergedFormObject = _FormObjectModel.default.createEmpty(newObject);
+    mergedFormObject.mergeObject(oldObject);
+    return mergedFormObject;
+  }
+
+  /**
+   */
+  findAttribute(findMethod) {
+    let foundAttribute = null;
+    this.allObjects.forEach(formObject => {
+      if (foundAttribute === null) {
+        var _context30;
+        foundAttribute = (0, _find.default)(_context30 = formObject.attributeCollection.all).call(_context30, item => findMethod(item)) || null;
+      }
+    });
+    return foundAttribute;
+  }
+}
+var _default = exports.default = FormModel;
+//# sourceMappingURL=FormModel.js.map