@beinformed/ui 1.23.3-beta.0 → 1.23.4

package/esm/modularui/ModularUIRequest.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
 import _JSON$stringify from "@babel/runtime-corejs3/core-js-stable/json/stringify";
 import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
 import _Promise from "@babel/runtime-corejs3/core-js-stable/promise";
 import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
 import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
@@ -19,6 +20,7 @@ import ModularUIResponse from "./ModularUIResponse";
 import ModularUIError from "./ModularUIError";
 import { IllegalArgumentException, IllegalStateException } from "../exceptions";
 import { isPlainObject } from "../utils/helpers/objects";
+
 /**
  * Helper for fetching data and contributions from the Be Informed modular ui
  * and merge it into a target or resolvable model.
@@ -27,363 +29,447 @@ class ModularUIRequest {
   /**
    */
   constructor(href) {
+    var _options$locale;
+
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
     _defineProperty(this, "_response", void 0);
+
     _defineProperty(this, "_href", void 0);
+
     _defineProperty(this, "_options", void 0);
+
     _defineProperty(this, "_targetModel", void 0);
+
     _defineProperty(this, "_contributionsHref", void 0);
+
     _defineProperty(this, "_locale", void 0);
+
     _defineProperty(this, "_method", HTTP_METHODS.GET);
+
     _defineProperty(this, "_progressEvent", void 0);
+
     if (!href) {
       throw new IllegalArgumentException("You must pass a href to the resource that is requested");
     }
+
     this.options = options;
     this._response = new ModularUIResponse();
     this.href = typeof href === "string" ? new Href(href) : href;
-    this.locale = options.locale ?? "en";
-
-    // copy request parameters to response, to be able to use them in the models
+    this.locale = (_options$locale = options.locale) !== null && _options$locale !== void 0 ? _options$locale : "en"; // copy request parameters to response, to be able to use them in the models
     // self links are missing the request parameters
+
     this._response.parameters = this.href.parameters;
+
     if (options.targetModel) {
       this.targetModel = options.targetModel;
     }
+
     if (options.method) {
       this.method = options.method;
     } else {
       this.method = this.href.method;
     }
   }
-
   /**
    */
+
+
   get contributionsHref() {
     return this._contributionsHref;
   }
-
   /**
    */
+
+
   set contributionsHref(contributionsHref) {
     this._contributionsHref = contributionsHref;
   }
-
   /**
    */
+
+
   set locale(locale) {
     this._locale = locale;
     this._response.locale = locale;
   }
-
   /**
    */
+
+
   get locale() {
     return this._locale;
   }
-
   /**
    */
+
+
   get response() {
     return this._response;
   }
-
   /**
    */
+
+
   set href(href) {
     this._href = href;
   }
-
   /**
    */
+
+
   get href() {
     return this._href;
   }
-
   /**
    */
+
+
   set method(method) {
     this._method = method;
   }
-
   /**
    */
+
+
   get method() {
     return this._method;
   }
-
   /**
    */
+
+
   get options() {
-    return {
-      ...this._options,
+    return { ...this._options,
       locale: this.locale,
       method: this.method
     };
   }
-
   /**
    */
+
+
   set options(options) {
     this._options = options;
   }
-
   /**
    */
+
+
   get withChildModels() {
     return !("childmodels" in this.options) || this.options.childmodels === true;
   }
-
   /**
    */
+
+
   set targetModel(targetModel) {
     this._targetModel = targetModel;
   }
-
   /**
    */
+
+
   get targetModel() {
     return this._targetModel;
   }
-
   /**
    */
+
+
   createModel() {
-    const Model = this.targetModel || resolveModel(this.response);
+    const Model = this.targetModel || resolveModel(this.response); // check for ResourceModel
 
-    // check for ResourceModel
     if (Model && Model.isApplicableModel) {
       return new Model(this.response);
     }
-    throw new IllegalStateException(`No model available for data: ${_JSON$stringify(this.response)}`);
-  }
 
+    throw new IllegalStateException("No model available for data: ".concat(_JSON$stringify(this.response)));
+  }
   /**
    */
+
+
   processContributionsService(contributionsData) {
     if (!isPlainObject(contributionsData)) {
       throw new IllegalArgumentException("Missing contributions data or contributions is not JSON");
     }
+
     const [contributionsKey] = _Object$keys(contributionsData);
+
     if (contributionsData.error && contributionsKey === "error") {
       this.handleContributionsError(contributionsData.error);
-    }
+    } // The key of the data service is different from the contributions service for forms
+
 
-    // The key of the data service is different from the contributions service for forms
     if (!(this.response.key in contributionsData)) {
       this.response.key = contributionsKey;
     }
+
     this.response.contributions = contributionsData[this.response.key];
   }
-
   /**
    */
+
+
   handleContributionsError(error) {
-    var _error$properties;
-    const errorMessage = ((_error$properties = error.properties) === null || _error$properties === void 0 ? void 0 : _error$properties.message) ?? "Error in contribution";
+    var _error$properties$mes, _error$properties;
+
+    const errorMessage = (_error$properties$mes = (_error$properties = error.properties) === null || _error$properties === void 0 ? void 0 : _error$properties.message) !== null && _error$properties$mes !== void 0 ? _error$properties$mes : "Error in contribution";
     throw new ModularUIError(errorMessage, error, this.contributionsHref);
   }
-
   /**
    */
+
+
   handleDataError(error) {
     if (error.properties) {
-      var _error$properties2;
-      const errorMessage = ((_error$properties2 = error.properties) === null || _error$properties2 === void 0 ? void 0 : _error$properties2.message) ?? "Error in data";
+      var _error$properties$mes2, _error$properties2;
+
+      const errorMessage = (_error$properties$mes2 = (_error$properties2 = error.properties) === null || _error$properties2 === void 0 ? void 0 : _error$properties2.message) !== null && _error$properties$mes2 !== void 0 ? _error$properties$mes2 : "Error in data";
       throw new ModularUIError(errorMessage, error, this.href.path.toString());
     }
+
     throw new IllegalArgumentException(error);
   }
-
   /**
    */
+
+
   handleData(key, data) {
     this.response.key = key;
     this.response.data = data;
     const links = data._links;
+
     if (links && links.contributions) {
       this.contributionsHref = links.contributions.href;
     } else if (Array.isArray(links) && links[0].contributions) {
       this.contributionsHref = links[0].contributions.href;
     } else {
-      throw new IllegalArgumentException(`Contributions link not found for data with key ${key}`);
+      throw new IllegalArgumentException("Contributions link not found for data with key ".concat(key));
     }
   }
-
   /**
    */
+
+
   processDataService(data) {
     if (!isPlainObject(data)) {
       throw new IllegalArgumentException("Missing data or data is not JSON");
     }
+
     if (data.error) {
       this.handleDataError(data.error);
     } else {
       const [key] = _Object$keys(data);
+
       this.handleData(key, data[key]);
     }
   }
-
   /**
    */
+
+
   fetchContributionsService() {
+    var _context;
+
     if (!this.contributionsHref) {
       throw new IllegalStateException("Missing a contributions href");
     }
+
     return universalFetch({
-      url: `${BASE}${this.contributionsHref}`,
+      url: _concatInstanceProperty(_context = "".concat(BASE)).call(_context, this.contributionsHref),
       cache: true,
       locale: this.options.locale
     });
   }
-
   /**
    */
+
+
   fetchDataService() {
-    return universalFetch({
-      ...this.options,
-      url: `${BASE}${this.href.path}`,
+    var _context2;
+
+    return universalFetch({ ...this.options,
+      url: _concatInstanceProperty(_context2 = "".concat(BASE)).call(_context2, this.href.path),
       params: this.href.getQuerystringForModularUI(),
       locale: this.options.locale,
       onProgress: this.onProgress
     });
   }
-
   /**
    * Check if links contain a 'hide-when-empty' layout hint and remove the link from
    * the component when it exists and no results are available
    */
+
+
   async processAsyncLayoutHints() {
     if (getSetting("ALLOW_HIDE_WHEN_EMPTY_ON_TABS")) {
       await this.processApplicationLinks();
       await this.processTabLinks();
     }
+
     await this.processPanelLinks();
     return _Promise.resolve();
   }
-
   /**
    * hide application links<br>
    * _links on application data contains an extra level of tab links
    */
+
+
   processApplicationLinks() {
     const contributionLinks = this.response.contributions._links;
     const dataLinks = this.response.data._links;
+
     if (!contributionLinks || !dataLinks) {
       return _Promise.resolve();
     }
+
     if ("tab" in contributionLinks && "tab" in dataLinks) {
       for (const contributionTabLink of contributionLinks.tab) {
         if ("components" in contributionTabLink) {
-          var _context;
-          const dataTabLinks = _findInstanceProperty(_context = dataLinks.tab).call(_context, dataLink => dataLink.name === contributionTabLink.name);
+          var _context3;
+
+          const dataTabLinks = _findInstanceProperty(_context3 = dataLinks.tab).call(_context3, dataLink => dataLink.name === contributionTabLink.name);
+
           if (dataTabLinks && "components" in dataTabLinks) {
             return this.processLinks(dataTabLinks.components, contributionTabLink.components).then(newLinks => this.replaceApplicationLinks(contributionTabLink.name, newLinks));
           }
         }
       }
     }
+
     return _Promise.resolve();
   }
-
   /**
    * Replace hidden link in application link tree
    */
+
+
   replaceApplicationLinks(tabName, newLinks) {
-    var _context2;
-    this.response.data._links.tab = _mapInstanceProperty(_context2 = this.response.data._links.tab).call(_context2, tabLink => {
+    var _context4;
+
+    this.response.data._links.tab = _mapInstanceProperty(_context4 = this.response.data._links.tab).call(_context4, tabLink => {
       const key = tabLink.name;
+
       if (tabName === key) {
         tabLink.components = newLinks;
       }
+
       return tabLink;
     });
   }
-
   /**
    */
+
+
   processTabLinks() {
     const contributionLinks = this.response.contributions._links;
+
     if (!contributionLinks) {
       return _Promise.resolve();
     }
+
     if ("component" in contributionLinks) {
       return this.processLinks(this.response.data._links.component, contributionLinks.component).then(newLinks => {
         this.response.data._links.component = newLinks;
       });
     }
+
     return _Promise.resolve();
   }
-
   /**
    */
+
+
   processPanelLinks() {
     const contributionLinks = this.response.contributions._links;
+
     if (!contributionLinks) {
       return _Promise.resolve();
     }
+
     if ("panel" in contributionLinks) {
       return this.processLinks(this.response.data._links, contributionLinks.panel).then(newLinks => {
         this.response.data._links = newLinks;
       });
     }
+
     return _Promise.resolve();
   }
-
   /**
    * Retrieve an object of key: link
    */
+
+
   dataLinksPerName(dataLinks) {
     if (Array.isArray(dataLinks)) {
       const links = {};
+
       for (const dataLink of dataLinks) {
         links[dataLink.name] = dataLink;
       }
+
       return links;
     }
+
     return dataLinks;
   }
-
   /**
    * Check if links are empty and hide them when hide-when-empty hint exists
    */
+
+
   processLinks(dataLinks, contributionLinks) {
     const linksPerName = this.dataLinksPerName(dataLinks);
+
     const hideWhenEmptyLinks = _filterInstanceProperty(contributionLinks).call(contributionLinks, contributionLink => {
       var _contributionLink$lay;
+
       return (_contributionLink$lay = contributionLink.layouthint) === null || _contributionLink$lay === void 0 ? void 0 : _includesInstanceProperty(_contributionLink$lay).call(_contributionLink$lay, HIDE_WHEN_EMPTY);
     });
+
     const isHiddenListChecks = [];
+
     for (const contributionLink of hideWhenEmptyLinks) {
       const dataLink = linksPerName[contributionLink.name];
+
       if (dataLink !== null && dataLink !== void 0 && dataLink.href) {
         isHiddenListChecks.push(this.isHiddenList(contributionLink.name, dataLink.href));
       }
     }
+
     return _Promise.all(isHiddenListChecks).then(hiddenLinks => {
       if (Array.isArray(dataLinks)) {
         return _filterInstanceProperty(dataLinks).call(dataLinks, dataLink => !_includesInstanceProperty(hiddenLinks).call(hiddenLinks, dataLink.name));
       }
+
       const newDataLinks = {};
+
       for (const dataLinkKey in dataLinks) {
         if (!_includesInstanceProperty(hiddenLinks).call(hiddenLinks, dataLinkKey)) {
           newDataLinks[dataLinkKey] = dataLinks[dataLinkKey];
         }
       }
+
       return newDataLinks;
     });
   }
-
   /**
    */
+
+
   isHiddenList(name, href) {
+    var _context5;
+
     const HIDE_WHEN_EMPTY_IGNORE_TASKS = getSetting("HIDE_WHEN_EMPTY_IGNORE_TASKS", false);
-    return universalFetch({
-      ...this.options,
-      url: `${BASE}${href}`
+    return universalFetch({ ...this.options,
+      url: _concatInstanceProperty(_context5 = "".concat(BASE)).call(_context5, href)
     }).then(response => {
       if (isPlainObject(response)) {
         const [key] = _Object$keys(response);
+
         const {
           _embedded,
           actions
@@ -391,52 +477,63 @@ class ModularUIRequest {
         const noListItems = _embedded === null;
         const noActions = actions == null || HIDE_WHEN_EMPTY_IGNORE_TASKS;
         const isHidden = noListItems && noActions;
+
         if (isHidden) {
           return name;
         }
       }
+
       return "";
     }).catch(() => {
       return "";
     });
   }
-
   /**
    */
+
+
   set onProgress(progressEvent) {
     this._progressEvent = progressEvent;
   }
-
   /**
    */
+
+
   get onProgress() {
     return this._progressEvent || null;
   }
-
   /**
    * Combine previous send request data with new validation data to create a complete request object
    * The received model is new FormModel containing ONLY the current question, not the previously entered questions
    * to create a complete request we append the originally send form objects
    */
+
+
   getDynamicValidationData(model) {
+    var _JSON$stringify2;
+
     const prevData = typeof this.options.data === "string" ? JSON.parse(this.options.data) : this.options.data;
+
     if (model instanceof FormModel) {
-      const newData = JSON.parse(model.validationData);
-      // $FlowFixMe incompatible-call
+      const newData = JSON.parse(model.validationData); // $FlowFixMe incompatible-call
+
       return _JSON$stringify(deepmerge(prevData || {}, newData));
     }
-    return _JSON$stringify(prevData) ?? "{}";
-  }
 
+    return (_JSON$stringify2 = _JSON$stringify(prevData)) !== null && _JSON$stringify2 !== void 0 ? _JSON$stringify2 : "{}";
+  }
   /**
    * First load of dynamic values when a form is loaded
    */
+
+
   loadDynamicValidations(model) {
     if (!this.options.isValidationRequest && getSetting("USE_INSTANT_SERVER_VALIDATION") && model instanceof FormModel && model.currentFormObject && model.currentFormObject.hasDynamicValidations) {
+      var _context6;
+
       const validationHref = this.href.setParameter("commit", "false");
-      return universalFetch({
-        ...this.options,
-        url: `${BASE}${this.href.path}`,
+      return universalFetch({ ...this.options,
+        url: _concatInstanceProperty(_context6 = "".concat(BASE)).call(_context6, this.href.path),
         params: validationHref.getQuerystringForModularUI(),
         childmodels: false,
         data: this.getDynamicValidationData(model)
@@ -444,62 +541,75 @@ class ModularUIRequest {
         if (data == null || typeof data !== "object") {
           return model;
         }
+
         const [key] = _Object$keys(data);
+
         return model.updateValidations(data[key]);
       });
     }
+
     return _Promise.resolve(model);
   }
-
   /**
    */
+
+
   fetch() {
     return this.fetchDataService().then(data => {
       if (data == null) {
-        throw new Error(`No data received for ${this.href.toString()}`);
+        throw new Error("No data received for ".concat(this.href.toString()));
       }
+
       this.processDataService(data);
       return this.fetchContributionsService();
     }).then(contributionsData => {
       if (contributionsData == null) {
-        throw new Error(`No contributions data received for ${this.contributionsHref}`);
+        throw new Error("No contributions data received for ".concat(this.contributionsHref));
       }
+
       this.processContributionsService(contributionsData);
       return this.processAsyncLayoutHints();
     }).then(() => _Promise.resolve(this.createModel())).then(model => this.loadDynamicValidations(model)).then(model => {
       if (this.withChildModels) {
         return this.fetchChildModels(model);
       }
+
       return _Promise.resolve(model);
     });
   }
-
   /**
    */
+
+
   fetchFromCache() {
-    this.options = {
-      ...this.options,
+    this.options = { ...this.options,
       cache: true
     };
     return this.fetch();
   }
-
   /**
    */
+
+
   fetchChildModels(model) {
     const childModelLinks = model.getInitialChildModelLinks();
+
     const childModelRequests = _mapInstanceProperty(childModelLinks).call(childModelLinks, childModelLink => {
       const request = new ModularUIRequest(childModelLink.href, {
         locale: this.locale
       });
+
       if (childModelLink.targetModel) {
         request.targetModel = childModelLink.targetModel;
       }
+
       if (childModelLink.isCacheable) {
         return request.fetchFromCache();
       }
+
       return request.fetch();
     });
+
     return _Promise.allSettled(childModelRequests).then(childModels => {
       const resolvedChildModels = [];
       childModels.forEach(childModel => {
@@ -507,6 +617,7 @@ class ModularUIRequest {
           const {
             reason
           } = childModel;
+
           if (reason.name !== "Error.ChangePasswordRequired") {
             console.error("Unexpected error when retrieving child model:", reason);
           }
@@ -518,25 +629,29 @@ class ModularUIRequest {
       return model;
     });
   }
-
   /**
    */
+
+
   fetchContent(withChildSections) {
     return this.fetchFromCache().then(model => {
       if (withChildSections && model instanceof ContentModel && model.childSectionLinks.length > 0) {
         return this.fetchContentChildSections(model);
       }
+
       return _Promise.resolve(model);
     });
   }
-
   /**
    * Recursively return child sections defined on the content model
    */
+
+
   fetchContentChildSections(contentModel) {
-    var _context3;
+    var _context7;
+
     const newContentModel = contentModel.clone();
-    return _Promise.all(_mapInstanceProperty(_context3 = contentModel.childSectionLinks).call(_context3, childSectionLink => {
+    return _Promise.all(_mapInstanceProperty(_context7 = contentModel.childSectionLinks).call(_context7, childSectionLink => {
       const contentHrefWithEntryDate = childSectionLink.selfhref.addParameter(TIMEVERSION_FILTER_NAME, contentModel.entryDate);
       const request = new ModularUIRequest(contentHrefWithEntryDate, {
         locale: this.locale
@@ -547,6 +662,8 @@ class ModularUIRequest {
       return newContentModel;
     });
   }
+
 }
+
 export default ModularUIRequest;
 //# sourceMappingURL=ModularUIRequest.js.map