@agilemotion/oui-react-js 1.2.7 → 1.2.9

package/dist/ApplicationContext.js

@@ -0,0 +1,713 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TEMPLATE_TOKEN_REGEX = exports.SYSTEM_EVENT = exports.AVATAR_LISTENER_TYPE = exports.APP_VARIABLE = void 0;
+
+var _Observable = _interopRequireDefault(require("./event/Observable"));
+
+var _Event = _interopRequireDefault(require("./event/Event"));
+
+var _EventType = _interopRequireDefault(require("./event/EventType"));
+
+var _Graph = _interopRequireDefault(require("./components/Graph"));
+
+var _Utils = _interopRequireDefault(require("./Utils"));
+
+var _DynamicJS = _interopRequireWildcard(require("./DynamicJS"));
+
+var _TypedValue = _interopRequireDefault(require("./TypedValue"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 _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; }
+
+const APP_VARIABLE = '__DOLLAR_APPLICATION_OUI_SYS_VAR__';
+exports.APP_VARIABLE = APP_VARIABLE;
+const AVATAR_LISTENER_TYPE = 'AVATAR_LISTENER';
+exports.AVATAR_LISTENER_TYPE = AVATAR_LISTENER_TYPE;
+const SYSTEM_EVENT = 'SYSTEM_EVENT';
+exports.SYSTEM_EVENT = SYSTEM_EVENT;
+const TEMPLATE_TOKEN_REGEX = new RegExp('(([$]{1}[{]{1})(([a-zA-Z0-9_$.@#{}[\\]]*)+){1}([}]{1}))+', 'g');
+exports.TEMPLATE_TOKEN_REGEX = TEMPLATE_TOKEN_REGEX;
+
+class ApplicationContext {
+  constructor() {
+    _defineProperty(this, "setConfirmDialogHandler", handler => {
+      this.props.dialogHandler = handler;
+    });
+
+    _defineProperty(this, "registerLibrary", (name, lib) => {
+      this.libs[name] = lib;
+    });
+
+    _defineProperty(this, "setApplicationHistory", history => {
+      this.props.applicationHistory = history;
+    });
+
+    _defineProperty(this, "getApplicationHistory", () => {
+      return this.props.applicationHistory;
+    });
+
+    _defineProperty(this, "setViewPortHistory", history => {
+      this.props.viewPortHistory = history;
+    });
+
+    _defineProperty(this, "getAppBarTitle", () => {
+      return this.props.appBarTitle;
+    });
+
+    _defineProperty(this, "updateAppBarTitle", (viewId, title) => {
+      let view = this.getView(viewId);
+
+      if (!view.popUp) {
+        let titleValue = '';
+
+        if (!title.match(_DynamicJS.TEMPLATE_REGEX)) {
+          titleValue = title;
+        } else {
+          titleValue = _DynamicJS.default.executeScript(viewId + 'Title', title, viewId);
+        }
+
+        var _iterator = _createForOfIteratorHelper(this.navHistory),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            const navHistoryElement = _step.value;
+
+            if (navHistoryElement.viewId === viewId) {
+              navHistoryElement.title = titleValue;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        let legendValue = "<span>";
+        let counter = 0;
+
+        var _iterator2 = _createForOfIteratorHelper(this.navHistory),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            const navHistoryElement = _step2.value;
+            legendValue += "".concat(navHistoryElement.title);
+
+            if (counter++ < this.navHistory.length - 1) {
+              legendValue += " <i class=\"fa fa-arrow-right fa-xs\" aria-hidden=\"true\" style='color:".concat(this.props.secondaryColor, "'></i> ");
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        legendValue += "</span>";
+        this.props.appBarTitle = legendValue;
+        let property = {};
+        property.name = 'title';
+        property.value = legendValue;
+        let event = new _Event.default(this, SYSTEM_EVENT, property);
+
+        _Observable.default.fireEvent(_EventType.default.APPLICATION_CONTEXT_CHANGE, event);
+      }
+    });
+
+    _defineProperty(this, "getViewPortHistory", () => {
+      return this.props.viewPortHistory;
+    });
+
+    _defineProperty(this, "clear", () => {
+      _Observable.default.clearAllEventListeners();
+
+      this.views.splice(0, this.views.length);
+      this.fileCache.splice(0, this.fileCache.length);
+    });
+
+    _defineProperty(this, "getPreviousHistoryElement", () => {
+      if (this.navHistory.length > 1) {
+        return this.navHistory[this.navHistory.length - 2];
+      }
+
+      return null;
+    });
+
+    _defineProperty(this, "getFileDomainCache", domain => {
+      var _iterator3 = _createForOfIteratorHelper(this.fileCache),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          const fileCacheElement = _step3.value;
+
+          if (fileCacheElement.domain === domain) {
+            return fileCacheElement;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      return null;
+    });
+
+    _defineProperty(this, "addFile", (domain, file) => {
+      if (_Utils.default.isNull(domain)) {
+        console.error("Please specify file domain");
+        return;
+      }
+
+      let fileDomainCache = this.getFileDomainCache(domain);
+
+      if (fileDomainCache === null) {
+        fileDomainCache = {};
+        fileDomainCache.domain = domain;
+        fileDomainCache.files = [];
+        this.fileCache.push(fileDomainCache);
+      }
+
+      let cachedFile = null;
+
+      var _iterator4 = _createForOfIteratorHelper(fileDomainCache.files),
+          _step4;
+
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          const domainFile = _step4.value;
+
+          if (domainFile.correlationId === file.correlationId) {
+            cachedFile = domainFile;
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+
+      if (cachedFile === null) {
+        fileDomainCache.files.push(file);
+      } else {
+        cachedFile.content = file.content;
+      }
+    });
+
+    _defineProperty(this, "addView", (view, path, forward) => {
+      if (!view.popUp) {
+        this.closeCurrentView(forward);
+
+        if (!forward) {
+          this.navHistory.pop();
+        }
+      } else {
+        this.props.dialogHandler.openPopupView(view);
+      }
+
+      if (view.parent) {
+        this.navHistory.splice(0, this.navHistory.length);
+
+        var _iterator5 = _createForOfIteratorHelper(this.views),
+            _step5;
+
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            const contextView = _step5.value;
+            this.closeView(contextView.handle.api.id, forward);
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+
+      let historyElement = {};
+      historyElement.viewId = view.config.id;
+      historyElement.path = path;
+      this.navHistory.push(historyElement);
+      this.views.push(view);
+    });
+
+    _defineProperty(this, "getCurrentView", () => {
+      return this.views[this.views.length - 1];
+    });
+
+    _defineProperty(this, "closeCurrentView", forward => {
+      let currentView = this.views[this.views.length - 1];
+
+      if (!_Utils.default.isNull(currentView)) {
+        this.closeView(currentView.handle.api.id, forward);
+      }
+    });
+
+    _defineProperty(this, "closeView", (viewId, forward) => {
+      _Observable.default.clearEventListeners(viewId);
+
+      for (let i = 0; i < this.fileCache.length; i++) {
+        let cacheElement = this.fileCache[i];
+
+        if (cacheElement.domain === viewId) {
+          this.fileCache.slice(i, 1);
+          break;
+        }
+      }
+
+      let count = 0;
+
+      var _iterator6 = _createForOfIteratorHelper(this.views),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          const view = _step6.value;
+
+          if (view.handle.api.id === viewId) {
+            this.views.splice(count, 1);
+
+            if (!view.popUp && !view.parent && (_Utils.default.isNull(forward) || forward === false)) {
+              this.navHistory.pop();
+            } else if (view.popUp) {
+              this.props.dialogHandler.closePopupView();
+            }
+          }
+
+          count++;
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    });
+
+    _defineProperty(this, "getView", id => {
+      var _iterator7 = _createForOfIteratorHelper(this.views),
+          _step7;
+
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          const view = _step7.value;
+
+          if (id === view.config.id) {
+            return view;
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+
+      return null;
+    });
+
+    _defineProperty(this, "resolveComponentApi", id => {
+      if (APP_VARIABLE === id) {
+        return this.api;
+      }
+
+      var _iterator8 = _createForOfIteratorHelper(this.graphs),
+          _step8;
+
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          const graph = _step8.value;
+
+          if (graph.id === id) {
+            return graph;
+          }
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+
+      let currentView = this.views[this.views.length - 1];
+
+      if (!_Utils.default.isNull(currentView) && !_Utils.default.isNull(currentView.handle)) {
+        if (id === currentView.handle.api.id) {
+          return currentView.handle.api;
+        }
+
+        let handle = currentView.handle.api.getChild(id);
+
+        if (handle !== null) {
+          return handle.api;
+        }
+
+        if (id === 'view') {
+          return currentView.handle.api;
+        }
+      }
+
+      return null;
+    });
+
+    _defineProperty(this, "populateTemplate", (template, eventData) => {
+      let matches = template.match(TEMPLATE_TOKEN_REGEX);
+
+      if (!_Utils.default.isNull(matches)) {
+        var _iterator9 = _createForOfIteratorHelper(matches),
+            _step9;
+
+        try {
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            const match = _step9.value;
+            let expresionContent = match.substring(match.indexOf('{') + 1, match.lastIndexOf('}'));
+            let expressionValue = "";
+
+            if (expresionContent.startsWith("$event.data") && !_Utils.default.isNull(eventData)) {
+              let props = expresionContent.replace("$event.data.", "").split(".");
+              let vo = eventData;
+
+              var _iterator10 = _createForOfIteratorHelper(props),
+                  _step10;
+
+              try {
+                for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+                  const prop = _step10.value;
+                  vo = vo[prop];
+                }
+              } catch (err) {
+                _iterator10.e(err);
+              } finally {
+                _iterator10.f();
+              }
+
+              expressionValue = vo;
+            } else {
+              expressionValue = this.resolveExpressionValue(expresionContent);
+            }
+
+            template = template.replace(match, expressionValue);
+          }
+        } catch (err) {
+          _iterator9.e(err);
+        } finally {
+          _iterator9.f();
+        }
+      }
+
+      return template;
+    });
+
+    _defineProperty(this, "resolveExpressionValue", expression => {
+      let paramExpression = expression.match(/\(([^)]*)\)/);
+      let baseExpression = !_Utils.default.isNull(paramExpression) && paramExpression.length > 0 ? expression.replace(paramExpression[0], '') : expression;
+      let expresionContent = baseExpression.substring(baseExpression.indexOf('{') + 1, baseExpression.indexOf('}'));
+      let isComponent = baseExpression.startsWith('@#{');
+      let isLib = baseExpression.startsWith('@@{');
+      let tokens = expresionContent.split('.');
+      let idToken = tokens[0];
+
+      if (isComponent) {
+        return this.resolveComponentApi(expresionContent);
+      } else if (isLib) {
+        if (idToken === 'view') {
+          idToken = this.getCurrentView().config.id + '_lib';
+        }
+
+        return this.libs[idToken];
+      }
+
+      return expression;
+    });
+
+    _defineProperty(this, "setExpressionValues", obj => {
+      let isArray = Array.isArray(obj);
+      const updated = isArray ? [] : {};
+      Object.keys(obj).forEach(key => {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+          updated[key] = this.setExpressionValues(obj[key]);
+
+          if (_Utils.default.isNull(updated[key].type)) {
+            updated[key].type = "String";
+          }
+        } else {
+          let objValue = obj[key];
+
+          if (typeof objValue === 'function') {
+            objValue = objValue();
+          }
+
+          if (typeof objValue === 'undefined') {
+            objValue = null;
+          }
+
+          if (this.isExpression(objValue)) {
+            let scriptValue = _DynamicJS.default.executeScript("resolveParam_".concat(Math.random().toString().replace('.', '_')), objValue);
+
+            if (typeof scriptValue === 'undefined') {
+              scriptValue = null;
+            }
+
+            let objKey = key === "valueExpression" ? "value" : key;
+            updated[objKey] = !_Utils.default.isNull(scriptValue) && scriptValue.instanceType === 'TypedValue' ? scriptValue.value : scriptValue;
+
+            if (typeof updated[objKey] === 'undefined') {
+              delete updated.type;
+            }
+          } else {
+            updated[key] = objValue;
+          }
+        }
+      });
+      return updated;
+    });
+
+    _defineProperty(this, "resolveParameterConfigValue", configValue => {
+      let json = JSON.stringify(configValue);
+      let matches = json.match(_DynamicJS.TEMPLATE_REGEX);
+
+      if (!_Utils.default.isNull(matches)) {
+        return this.setExpressionValues(configValue);
+      } else {
+        return configValue;
+      }
+    });
+
+    _defineProperty(this, "resolveParameterValue", parameterConfig => {
+      let val = null;
+
+      if (_Utils.default.isNull(parameterConfig.value)) {
+        console.error("NULL parameter value expression in : " + JSON.stringify(parameterConfig));
+        return null;
+      }
+
+      if (!this.isExpression(parameterConfig.value)) {
+        val = this.resolveParameterConfigValue(parameterConfig.value);
+      } else {
+        let expression = parameterConfig.value;
+        val = _DynamicJS.default.executeScript("resolveParam_".concat(Math.random().toString().replace('.', '_')), expression);
+      }
+
+      if (_Utils.default.isNull(val)) {
+        return null;
+      }
+
+      if (!_Utils.default.isNull(val) && !_Utils.default.isNull(val.instanceType) && val.instanceType === 'TypedValue') {
+        if (!_Utils.default.isNull(parameterConfig.type)) {
+          val.type = parameterConfig.type;
+        }
+
+        return val;
+      }
+
+      let type = null;
+
+      if (!_Utils.default.isNull(parameterConfig.type)) {
+        type = parameterConfig.type;
+      } else if (val !== null) {
+        type = typeof val;
+      }
+
+      return new _TypedValue.default(type, val);
+    });
+
+    _defineProperty(this, "setModelValue", (key, value, viewId) => {
+      this.getView(viewId).handle.api.setModelValue(key, value);
+
+      _Observable.default.processSystemGeneratedSubscriptions(viewId);
+    });
+
+    _defineProperty(this, "getId", () => {
+      return "applicationContext";
+    });
+
+    if (!ApplicationContext.instance) {
+      this.views = [];
+      this.props = {};
+      this.listeners = [];
+      this.libs = {};
+      this.navHistory = [];
+      this.fileCache = [];
+      this.graphs = [];
+      this.api = {
+        get id() {
+          return instance.getId();
+        },
+
+        closeCurrentView() {
+          instance.closeCurrentView();
+        }
+
+      };
+
+      if (!Array.isArray) {
+        Array.isArray = function (arg) {
+          return Object.prototype.toString.call(arg) === '[object Array]';
+        };
+      }
+
+      ApplicationContext.instance = this;
+    }
+
+    return ApplicationContext.instance;
+  }
+
+  setBaseApiUrl(baseApiUrl) {
+    this.props.baseApiUrl = baseApiUrl;
+  }
+
+  getBaseApiUrl() {
+    return this.props.baseApiUrl;
+  }
+
+  setServiceApiPath(serviceApiPath) {
+    this.props.serviceApiPath = serviceApiPath;
+  }
+
+  getServiceApiPath() {
+    return this.props.serviceApiPath;
+  }
+
+  setUIConfigPath(uiConfigPath) {
+    this.props.uiConfigPath = uiConfigPath;
+  }
+
+  getUIConfigPath() {
+    return this.props.uiConfigPath;
+  }
+
+  setFilesApiPath(filesApiPath) {
+    this.props.filesApiPath = filesApiPath;
+  }
+
+  getFilesApiPath() {
+    return this.props.filesApiPath;
+  }
+
+  addApplicationListener(listener) {
+    this.listeners.push(listener);
+  }
+
+  refreshUserAvatar(avatar) {
+    var _iterator11 = _createForOfIteratorHelper(this.listeners),
+        _step11;
+
+    try {
+      for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+        const listener = _step11.value;
+
+        if (listener.type === AVATAR_LISTENER_TYPE) {
+          listener.handler(avatar);
+        }
+      }
+    } catch (err) {
+      _iterator11.e(err);
+    } finally {
+      _iterator11.f();
+    }
+  }
+
+  setApplicationThemeColors(primary, secondary) {
+    this.props.primaryColor = primary;
+    this.props.secondaryColor = secondary;
+  }
+
+  getApplicationPrimaryColor() {
+    return this.props.primaryColor;
+  }
+
+  openConfirmDialog(message, resultCallback) {
+    return this.props.dialogHandler.openDialog(message, resultCallback);
+  }
+
+  isExpression(objValue) {
+    return !_Utils.default.isNull(objValue) && typeof objValue === 'string' && !_Utils.default.isNull(objValue.match(_DynamicJS.TEMPLATE_REGEX));
+  }
+  /**
+   * Returns a view configuration with a particular id
+   *
+   */
+
+
+  removeLoadedGraph() {
+    this.closeCurrentView(false);
+    this.graphs.splice(0, this.graphs.length);
+  }
+
+  loadGraph(isParent, isPopup, config) {
+    if (isParent && !isPopup) {
+      this.navHistory.splice(0, this.navHistory.length);
+
+      var _iterator12 = _createForOfIteratorHelper(this.views),
+          _step12;
+
+      try {
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          const contextView = _step12.value;
+          this.closeView(contextView.handle.api.id, false);
+        }
+      } catch (err) {
+        _iterator12.e(err);
+      } finally {
+        _iterator12.f();
+      }
+
+      this.getViewPortHistory().push("/switch");
+      let graph = new _Graph.default(_Utils.default.parseConfig(config));
+      graph.init();
+      this.graphs.push(graph);
+    }
+  }
+
+  signalGraph(id, event) {
+    if (this.graphs.length > 0) {
+      let graphToSignal = this.graphs[0];
+
+      var _iterator13 = _createForOfIteratorHelper(this.graphs),
+          _step13;
+
+      try {
+        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+          const graph = _step13.value;
+
+          if (id === graph.id) {
+            graphToSignal = graph;
+            break;
+          }
+        }
+      } catch (err) {
+        _iterator13.e(err);
+      } finally {
+        _iterator13.f();
+      }
+
+      graphToSignal.signal(event);
+    }
+  }
+
+  enableFormMarkers(enabled) {
+    this.props.formMarkersEnabled = enabled;
+  }
+
+  isFormMarkersEnabled() {
+    return this.props.formMarkersEnabled;
+  }
+
+}
+
+const instance = new ApplicationContext();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;