@agilemotion/oui-react-js 1.6.1 → 1.6.2

package/dist/Utils.js

@@ -17,16 +17,38 @@ var _EventType = _interopRequireDefault(require("./event/EventType"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-class Utils {
-  constructor() {
-    _defineProperty(this, "showMessage", (viewRef, message, type) => {
+var Utils = /*#__PURE__*/function () {
+  function Utils() {
+    _classCallCheck(this, Utils);
+
+    _defineProperty(this, "showMessage", function (viewRef, message, type) {
       if (Utils.isNull(message)) {
         message = "";
       }
 
-      let messageType = type === "ERROR" ? "danger" : Utils.isNull(type) ? "message" : type;
+      var messageType = type === "ERROR" ? "danger" : Utils.isNull(type) ? "message" : type;
       viewRef.setState({
         message: message,
         messageStyle: messageType
@@ -34,349 +56,391 @@ class Utils {
     });
   }
 
-  static isNull(value) {
-    return value === null || typeof value === 'undefined';
-  }
-
-  static getInitials(name) {
-    const parts = name.split(' ');
-    let initials = '';
-
-    for (let i = 0; i < parts.length; i++) {
-      if (parts[i].length > 0 && parts[i] !== '') {
-        initials += parts[i][0];
+  _createClass(Utils, [{
+    key: "saveForm",
+    value: function saveForm(viewRef, formRef, url) {
+      this.saveForm(viewRef, formRef, url, null, null, null);
+    }
+  }, {
+    key: "saveForm",
+    value: function saveForm(viewRef, formRef, url, successCallback, errorCallback) {
+      this.saveForm(viewRef, formRef, url, successCallback, errorCallback, null);
+    }
+  }, {
+    key: "autoSetDate",
+    value: function autoSetDate(viewRef, formRef, newDate, yearOffset, monthOffset, dayOffset, autoFillDateName, refDateName) {
+      var stateDate = viewRef.state[refDateName];
+      var tempDate = stateDate;
+
+      if (Utils.isNull(stateDate) || stateDate.getTime() !== newDate.getTime()) {
+        viewRef.setState(_objectSpread(_objectSpread({}, viewRef.state), {}, _defineProperty({}, refDateName, newDate)), function () {
+          if (!Utils.isNull(tempDate) && !Utils.isNull(viewRef.state.id)) {
+            var autoFillDate = Utils.offsetDate(newDate, yearOffset, monthOffset, dayOffset);
+            formRef.current.setValue(autoFillDateName, autoFillDate);
+          } else if (Utils.isNull(viewRef.state.id)) {
+            var _autoFillDate = Utils.offsetDate(newDate, yearOffset, monthOffset, dayOffset);
+
+            formRef.current.setValue(autoFillDateName, _autoFillDate);
+          }
+        });
       }
     }
+  }], [{
+    key: "isNull",
+    value: function isNull(value) {
+      return value === null || typeof value === 'undefined';
+    }
+  }, {
+    key: "getInitials",
+    value: function getInitials(name) {
+      var parts = name.split(' ');
+      var initials = '';
+
+      for (var i = 0; i < parts.length; i++) {
+        if (parts[i].length > 0 && parts[i] !== '') {
+          initials += parts[i][0];
+        }
+      }
 
-    return initials;
-  }
-
-  static updateModel(values, model) {
-    if (!Utils.isNull(values)) {
-      for (let i = 0; i < values.length; i++) {
-        let value = values[i];
-        model[value.name] = value.value;
+      return initials;
+    }
+  }, {
+    key: "updateModel",
+    value: function updateModel(values, model) {
+      if (!Utils.isNull(values)) {
+        for (var i = 0; i < values.length; i++) {
+          var value = values[i];
+          model[value.name] = value.value;
+        }
       }
     }
-  }
+  }, {
+    key: "joinScript",
+    value: function joinScript(lines) {
+      var script = '';
 
-  static joinScript(lines) {
-    let script = '';
+      for (var i = 0; i < lines.length; i++) {
+        var line = lines[i].trim();
 
-    for (let i = 0; i < lines.length; i++) {
-      let line = lines[i].trim();
+        if (!line.endsWith(';') && !line.endsWith(':')) {
+          line += ';';
+        }
 
-      if (!line.endsWith(';') && !line.endsWith(':')) {
-        line += ';';
+        line += '\n';
+        script += line;
       }
 
-      line += '\n';
-      script += line;
+      return script;
     }
+  }, {
+    key: "sleep",
+    value: function sleep(milliseconds) {
+      var date = Date.now();
+      var currentDate = null;
+
+      do {
+        currentDate = Date.now();
+      } while (currentDate - date < milliseconds);
+    }
+  }, {
+    key: "parseConfig",
+    value: function parseConfig(config, currentViewId) {
+      var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
 
-    return script;
-  }
-
-  static sleep(milliseconds) {
-    const date = Date.now();
-    let currentDate = null;
+      if (!this.isNull(config) && !this.isNull(config.id)) {
+        var configJson = JSON.stringify(config);
+        var replace = configJson.replace(/#{this}/g, '#{' + config.id + '}').replace(/#{view}/g, '#{' + currentViewId + '}');
 
-    do {
-      currentDate = Date.now();
-    } while (currentDate - date < milliseconds);
-  }
+        if (index !== null) {
+          replace = replace.replace(/\[#i]/g, "[".concat(index, "]"));
+        }
 
-  static parseConfig(config, currentViewId, index = null) {
-    if (!this.isNull(config) && !this.isNull(config.id)) {
-      let configJson = JSON.stringify(config);
-      let replace = configJson.replace(/#{this}/g, '#{' + config.id + '}').replace(/#{view}/g, '#{' + currentViewId + '}');
+        return JSON.parse(replace);
+      }
 
-      if (index !== null) {
-        replace = replace.replace(/\[#i]/g, "[".concat(index, "]"));
+      return config;
+    }
+  }, {
+    key: "isFieldRequired",
+    value: function isFieldRequired(id, formId) {
+      if (!Utils.isStringEmpty(formId)) {
+        var fields = Utils.getFields(formId, 'validate');
+
+        for (var i = 0; i < fields.length; i++) {
+          if (fields[i].id === id) {
+            return fields[i].required;
+          }
+        }
       }
 
-      return JSON.parse(replace);
+      return false;
+    }
+  }, {
+    key: "isStringEmpty",
+    value: function isStringEmpty(val) {
+      return typeof val === 'undefined' || val === null || val.trim().length === 0;
     }
+  }, {
+    key: "getFields",
+    value: function getFields(formId, className) {
+      var inputFields = [];
+      var form = document.getElementById(formId);
 
-    return config;
-  }
+      if (!Utils.isNull(form)) {
+        var inputDivs = form.getElementsByClassName(className);
 
-  static isFieldRequired(id, formId) {
-    if (!Utils.isStringEmpty(formId)) {
-      let fields = Utils.getFields(formId, 'validate');
+        for (var i = 0; i < inputDivs.length; i++) {
+          var inputs = inputDivs[i].getElementsByTagName("input");
 
-      for (var i = 0; i < fields.length; i++) {
-        if (fields[i].id === id) {
-          return fields[i].required;
+          for (var j = 0; j < inputs.length; j++) {
+            inputFields.push(inputs[j]);
+          }
         }
       }
-    }
 
-    return false;
-  }
+      return inputFields;
+    }
+  }, {
+    key: "validateField",
+    value: function validateField(id, required, values, currentValue, validator) {
+      var message = !this.isNull(validator) ? validator.errorMessage : null;
+      var regex = !this.isNull(validator) ? validator.regex : null;
+      var result = {};
+      result.valid = true;
+      result.message = "";
+      var value;
 
-  static isStringEmpty(val) {
-    return typeof val === 'undefined' || val === null || val.trim().length === 0;
-  }
+      if (!this.isNull(currentValue)) {
+        value = currentValue;
+      } else {
+        value = JSON.parse(JSON.stringify(values))[id];
+      }
 
-  static getFields(formId, className) {
-    let inputFields = [];
-    let form = document.getElementById(formId);
+      var hasErrors = false;
 
-    if (!Utils.isNull(form)) {
-      let inputDivs = form.getElementsByClassName(className);
+      if (required && (Utils.isNull(value) || Utils.isStringEmpty(value.toString()))) {
+        result.message = !Utils.isNull(message) ? message : "This field is required";
+        hasErrors = true;
+      } else {
+        result.message = "";
+      }
 
-      for (let i = 0; i < inputDivs.length; i++) {
-        let inputs = inputDivs[i].getElementsByTagName("input");
+      if (!hasErrors && !Utils.isNull(regex) && !Utils.isNull(value)) {
+        hasErrors = Utils.isNull(value.toString().match(regex));
 
-        for (let j = 0; j < inputs.length; j++) {
-          inputFields.push(inputs[j]);
+        if (hasErrors) {
+          result.message = !Utils.isNull(message) ? message : "This field is invalid";
         }
       }
-    }
-
-    return inputFields;
-  }
 
-  static validateField(id, required, values, currentValue, validator) {
-    let message = !this.isNull(validator) ? validator.errorMessage : null;
-    let regex = !this.isNull(validator) ? validator.regex : null;
-    let result = {};
-    result.valid = true;
-    result.message = "";
-    let value;
-
-    if (!this.isNull(currentValue)) {
-      value = currentValue;
-    } else {
-      value = JSON.parse(JSON.stringify(values))[id];
+      result.valid = !hasErrors;
+      return result;
     }
+  }, {
+    key: "getComponentAttribute",
+    value: function getComponentAttribute(field, attribute, defaultValue) {
+      if (this.isNull(field.attributes)) {
+        return defaultValue;
+      }
 
-    let hasErrors = false;
-
-    if (required && (Utils.isNull(value) || Utils.isStringEmpty(value.toString()))) {
-      result.message = !Utils.isNull(message) ? message : "This field is required";
-      hasErrors = true;
-    } else {
-      result.message = "";
+      return this.isNull(field.attributes[attribute]) ? defaultValue : field.attributes[attribute];
     }
-
-    if (!hasErrors && !Utils.isNull(regex) && !Utils.isNull(value)) {
-      hasErrors = Utils.isNull(value.toString().match(regex));
-
-      if (hasErrors) {
-        result.message = !Utils.isNull(message) ? message : "This field is invalid";
+  }, {
+    key: "getComponentStyleAttribute",
+    value: function getComponentStyleAttribute(field, attribute, defaultValue) {
+      if (this.isNull(field.attributes) || this.isNull(field.attributes.style)) {
+        return defaultValue;
       }
-    }
 
-    result.valid = !hasErrors;
-    return result;
-  }
-
-  static getComponentAttribute(field, attribute, defaultValue) {
-    if (this.isNull(field.attributes)) {
-      return defaultValue;
+      return this.isNull(field.attributes.style[attribute]) ? defaultValue : field.attributes.style[attribute];
     }
-
-    return this.isNull(field.attributes[attribute]) ? defaultValue : field.attributes[attribute];
-  }
-
-  static getComponentStyleAttribute(field, attribute, defaultValue) {
-    if (this.isNull(field.attributes) || this.isNull(field.attributes.style)) {
-      return defaultValue;
+  }, {
+    key: "doGetRequestJson",
+    value: function doGetRequestJson(currentPage, curretRowsPerPage, currentSearchParameters, paged) {
+      var request = {};
+      request.pageSize = curretRowsPerPage;
+      request.currentPage = currentPage;
+      request.searchParameters = currentSearchParameters;
+      request.paged = typeof paged === 'undefined' || paged === null || paged;
+      return JSON.stringify(request);
     }
+  }, {
+    key: "getFieldGrid",
+    value: function getFieldGrid(attributes, fields) {
+      var fieldGrid = {};
+      var maxColspan = !Utils.isNull(attributes) && !Utils.isNull(attributes.layoutColumns) ? attributes.layoutColumns : 1;
+      fieldGrid.maxColPerRow = maxColspan;
+      fieldGrid.rows = [];
+      var currRow = this.createRow();
 
-    return this.isNull(field.attributes.style[attribute]) ? defaultValue : field.attributes.style[attribute];
-  }
-
-  static doGetRequestJson(currentPage, curretRowsPerPage, currentSearchParameters, paged) {
-    var request = {};
-    request.pageSize = curretRowsPerPage;
-    request.currentPage = currentPage;
-    request.searchParameters = currentSearchParameters;
-    request.paged = typeof paged === 'undefined' || paged === null || paged;
-    return JSON.stringify(request);
-  }
+      for (var i = 0; i < fields.length; i++) {
+        var field = fields[i];
+        var colspan = this.getFieldColspan(field);
 
-  static getFieldGrid(attributes, fields) {
-    let fieldGrid = {};
-    let maxColspan = !Utils.isNull(attributes) && !Utils.isNull(attributes.layoutColumns) ? attributes.layoutColumns : 1;
-    fieldGrid.maxColPerRow = maxColspan;
-    fieldGrid.rows = [];
-    let currRow = this.createRow();
+        if (!this.rowHasSpaceForNewField(currRow, colspan, maxColspan)) {
+          this.fillRowWithSpacers(currRow, maxColspan);
+          currRow = this.createRow();
+        }
 
-    for (let i = 0; i < fields.length; i++) {
-      let field = fields[i];
-      let colspan = this.getFieldColspan(field);
+        if (currRow.fields.length === 0) {
+          fieldGrid.rows.push(currRow);
+        }
 
-      if (!this.rowHasSpaceForNewField(currRow, colspan, maxColspan)) {
-        this.fillRowWithSpacers(currRow, maxColspan);
-        currRow = this.createRow();
+        currRow.fields.push(field);
+        currRow.usedSlots += colspan;
       }
 
-      if (currRow.fields.length === 0) {
-        fieldGrid.rows.push(currRow);
+      return fieldGrid;
+    }
+  }, {
+    key: "evaluateBooleanExpression",
+    value: function evaluateBooleanExpression(expression, id, defaultValue) {
+      if (expression === "false" || expression === false) {
+        return false;
+      } else if (expression === "true" || expression === true) {
+        return true;
+      } else if (!Utils.isNull(expression)) {
+        return _DynamicJS.default.executeScript("".concat(id, "UtilsBoolEval"), expression);
       }
 
-      currRow.fields.push(field);
-      currRow.usedSlots += colspan;
+      return !this.isNull(defaultValue) ? defaultValue : false;
     }
+  }, {
+    key: "getEntityViewTitle",
+    value: function getEntityViewTitle(queryParameterState, viewName) {
+      if (Utils.isNull(queryParameterState) || Utils.isNull(queryParameterState.selection)) {
+        return !Utils.isNull(viewName) ? viewName + " > Add" : "Add";
+      }
 
-    return fieldGrid;
-  }
+      var props = "";
 
-  static evaluateBooleanExpression(expression, id, defaultValue) {
-    if (expression === "false" || expression === false) {
-      return false;
-    } else if (expression === "true" || expression === true) {
-      return true;
-    } else if (!Utils.isNull(expression)) {
-      return _DynamicJS.default.executeScript("".concat(id, "UtilsBoolEval"), expression);
-    }
+      for (var _len = arguments.length, fields = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        fields[_key - 2] = arguments[_key];
+      }
 
-    return !this.isNull(defaultValue) ? defaultValue : false;
-  }
+      for (var i = 0; i < fields.length; i++) {
+        if (!Utils.isNull(fields[i])) {
+          props += fields[i].trim();
+          props += " ";
+        }
+      }
 
-  static getEntityViewTitle(queryParameterState, viewName, ...fields) {
-    if (Utils.isNull(queryParameterState) || Utils.isNull(queryParameterState.selection)) {
-      return !Utils.isNull(viewName) ? viewName + " > Add" : "Add";
+      props = props.trim();
+      var prefix = Utils.isNull(viewName) ? "" : " > ";
+      return (Utils.isNull(viewName) ? "" : viewName) + (props.length > 0 ? prefix + props : "");
     }
+  }, {
+    key: "setLegendColor",
+    value: function setLegendColor(color) {
+      var legends = document.getElementsByClassName("legend");
 
-    let props = "";
-
-    for (let i = 0; i < fields.length; i++) {
-      if (!Utils.isNull(fields[i])) {
-        props += fields[i].trim();
-        props += " ";
+      for (var i = 0; i < legends.length; i++) {
+        legends[i].style.color = color;
       }
     }
-
-    props = props.trim();
-    let prefix = Utils.isNull(viewName) ? "" : " > ";
-    return (Utils.isNull(viewName) ? "" : viewName) + (props.length > 0 ? prefix + props : "");
-  }
-
-  static setLegendColor(color) {
-    let legends = document.getElementsByClassName("legend");
-
-    for (let i = 0; i < legends.length; i++) {
-      legends[i].style.color = color;
+  }, {
+    key: "setLegend",
+    value: function setLegend(text) {
+      if (!Utils.isNull(text)) {
+        var legend = document.getElementById("globalLegend");
+        legend.innerHTML = text;
+      }
     }
-  }
-
-  static setLegend(text) {
-    if (!Utils.isNull(text)) {
-      let legend = document.getElementById("globalLegend");
-      legend.innerHTML = text;
+  }, {
+    key: "offsetDate",
+    value: function offsetDate(date, yearOffset, monthOffset, dayOffset) {
+      var year = date.getFullYear() + yearOffset;
+      var day = date.getDate() + dayOffset;
+      var month = date.getMonth() + monthOffset;
+      return new Date(year, month, day);
     }
-  }
-
-  saveForm(viewRef, formRef, url) {
-    this.saveForm(viewRef, formRef, url, null, null, null);
-  }
-
-  saveForm(viewRef, formRef, url, successCallback, errorCallback) {
-    this.saveForm(viewRef, formRef, url, successCallback, errorCallback, null);
-  }
-
-  static offsetDate(date, yearOffset, monthOffset, dayOffset) {
-    let year = date.getFullYear() + yearOffset;
-    let day = date.getDate() + dayOffset;
-    let month = date.getMonth() + monthOffset;
-    return new Date(year, month, day);
-  }
-
-  autoSetDate(viewRef, formRef, newDate, yearOffset, monthOffset, dayOffset, autoFillDateName, refDateName) {
-    let stateDate = viewRef.state[refDateName];
-    let tempDate = stateDate;
-
-    if (Utils.isNull(stateDate) || stateDate.getTime() !== newDate.getTime()) {
-      viewRef.setState({ ...viewRef.state,
-        [refDateName]: newDate
-      }, () => {
-        if (!Utils.isNull(tempDate) && !Utils.isNull(viewRef.state.id)) {
-          let autoFillDate = Utils.offsetDate(newDate, yearOffset, monthOffset, dayOffset);
-          formRef.current.setValue(autoFillDateName, autoFillDate);
-        } else if (Utils.isNull(viewRef.state.id)) {
-          let autoFillDate = Utils.offsetDate(newDate, yearOffset, monthOffset, dayOffset);
-          formRef.current.setValue(autoFillDateName, autoFillDate);
-        }
+  }, {
+    key: "getArgs",
+    value: function getArgs(func) {
+      // First match everything inside the function argument parens.
+      var args = func.toString().match(/function\s.*?\(([^)]*)\)/)[1]; // Split the arguments string into an array comma delimited.
+
+      return args.split(',').map(function (arg) {
+        // Ensure no inline comments are parsed and trim the whitespace.
+        return arg.replace(/\/\*.*\*\//, '').trim();
+      }).filter(function (arg) {
+        // Ensure no undefined values are added.
+        return arg;
       });
     }
-  }
-
-  static getArgs(func) {
-    // First match everything inside the function argument parens.
-    var args = func.toString().match(/function\s.*?\(([^)]*)\)/)[1]; // Split the arguments string into an array comma delimited.
-
-    return args.split(',').map(function (arg) {
-      // Ensure no inline comments are parsed and trim the whitespace.
-      return arg.replace(/\/\*.*\*\//, '').trim();
-    }).filter(function (arg) {
-      // Ensure no undefined values are added.
-      return arg;
-    });
-  }
-
-  static mergeObjects(source, target) {
-    let properties = Object.getOwnPropertyNames(source);
+  }, {
+    key: "mergeObjects",
+    value: function mergeObjects(source, target) {
+      var properties = Object.getOwnPropertyNames(source);
+
+      var _iterator = _createForOfIteratorHelper(properties),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var property = _step.value;
+          target[property] = source[property];
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
 
-    for (const property of properties) {
-      target[property] = source[property];
+      return target;
     }
+  }]);
 
-    return target;
-  }
-
-}
+  return Utils;
+}();
 
 exports.default = Utils;
 
 _defineProperty(Utils, "SYSTEM_ERROR_MESSAGE", "A system error has accured. Please contact your system administrator");
 
-_defineProperty(Utils, "capitalize", s => {
+_defineProperty(Utils, "capitalize", function (s) {
   if (typeof s !== 'string') return '';
   return s.charAt(0).toUpperCase() + s.slice(1);
 });
 
-_defineProperty(Utils, "getFieldColspan", field => {
+_defineProperty(Utils, "getFieldColspan", function (field) {
   return !Utils.isNull(field.attributes) && !Utils.isNull(field.attributes['colspan']) ? parseFloat(field.attributes['colspan']) : 1;
 });
 
-_defineProperty(Utils, "createRow", () => {
-  let row = {};
+_defineProperty(Utils, "createRow", function () {
+  var row = {};
   row.fields = [];
   row.usedSlots = 0;
   return row;
 });
 
-_defineProperty(Utils, "fillRowWithSpacers", (row, max) => {
-  for (let i = row.usedSlots; i < max; i++) {
-    let field = {};
+_defineProperty(Utils, "fillRowWithSpacers", function (row, max) {
+  for (var i = row.usedSlots; i < max; i++) {
+    var field = {};
     field.fieldType = 'LABEL';
     field.id = 'system_col_span_spacer_' + i;
     row.fields.push(field);
   }
 });
 
-_defineProperty(Utils, "rowHasSpaceForNewField", (row, colspan, max) => {
+_defineProperty(Utils, "rowHasSpaceForNewField", function (row, colspan, max) {
   return colspan <= max - row.usedSlots;
 });
 
-_defineProperty(Utils, "getPropertyChainPath", expression => {
-  let path = {};
+_defineProperty(Utils, "getPropertyChainPath", function (expression) {
+  var path = {};
 
   if (!Utils.isNull(expression)) {
-    let tokens = expression.split('.');
+    var tokens = expression.split('.');
     path.property = tokens[tokens.length - 1];
-    let voExpression = expression.substring(0, expression.indexOf('.'));
+    var voExpression = expression.substring(0, expression.indexOf('.'));
     path.valueObject = _DynamicJS.default.executeScript("".concat(Math.random(), "_PropertyChainUtilsEval"), voExpression);
 
-    for (let i = 1; i < tokens.length - 1; i++) {
-      let token = tokens[i];
+    for (var i = 1; i < tokens.length - 1; i++) {
+      var token = tokens[i];
 
       if (!Utils.isNull(path.valueObject)) {
-        let getter = path.valueObject[token];
+        var getter = path.valueObject[token];
 
         if (!Utils.isNull(getter)) {
           if (typeof getter === 'function') {
@@ -394,8 +458,8 @@ _defineProperty(Utils, "getPropertyChainPath", expression => {
   return path;
 });
 
-_defineProperty(Utils, "mergeStyles", (defaultStyle, config) => {
-  let configStyle = Utils.getComponentAttribute(config, 'style', null);
+_defineProperty(Utils, "mergeStyles", function (defaultStyle, config) {
+  var configStyle = Utils.getComponentAttribute(config, 'style', null);
 
   if (configStyle) {
     return Utils.mergeObjects(configStyle, defaultStyle);
@@ -404,31 +468,66 @@ _defineProperty(Utils, "mergeStyles", (defaultStyle, config) => {
   return defaultStyle;
 });
 
-_defineProperty(Utils, "publishErrorMessage", async (e, viewId, component = null) => {
-  let messageText;
-
-  if (e.json) {
-    let data = await e.json();
-    messageText = data.message;
-  } else {
-    messageText = Utils.SYSTEM_ERROR_MESSAGE;
-  }
+_defineProperty(Utils, "publishErrorMessage", /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(e, viewId) {
+    var component,
+        messageText,
+        data,
+        message,
+        event,
+        _args = arguments;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            component = _args.length > 2 && _args[2] !== undefined ? _args[2] : null;
+
+            if (!e.json) {
+              _context.next = 8;
+              break;
+            }
+
+            _context.next = 4;
+            return e.json();
+
+          case 4:
+            data = _context.sent;
+            messageText = data.message;
+            _context.next = 9;
+            break;
+
+          case 8:
+            messageText = Utils.SYSTEM_ERROR_MESSAGE;
+
+          case 9:
+            message = {
+              messageType: 'ERROR',
+              message: messageText
+            };
+            event = new _Event.default(_ApplicationManager.default, viewId, message);
+
+            _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+
+            if (component !== null) {
+              event = new _Event.default(component, viewId, message);
+
+              _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+            }
+
+          case 13:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
 
-  let message = {
-    messageType: 'ERROR',
-    message: messageText
+  return function (_x, _x2) {
+    return _ref.apply(this, arguments);
   };
-  let event = new _Event.default(_ApplicationManager.default, viewId, message);
-
-  _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
-
-  if (component !== null) {
-    event = new _Event.default(component, viewId, message);
-
-    _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
-  }
-});
+}());
 
-_defineProperty(Utils, "publishSystemErrorMessage", (viewId, component = null) => {
+_defineProperty(Utils, "publishSystemErrorMessage", function (viewId) {
+  var component = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   Utils.publishErrorMessage('A system error has accured. Please try again later', viewId, component);
 });