@agilemotion/oui-react-js 1.6.1 → 1.6.2

package/dist/components/Graph.js

@@ -15,82 +15,122 @@ var _Utils = _interopRequireDefault(require("../Utils"));
 
 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 _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 Graph {
-  constructor(config) {
-    _defineProperty(this, "getCurrentNodeIndex", () => {
-      let index = 0;
-      let collection = this.config.stepperMode === null || this.config.stepperMode === "DYNAMIC" ? this.path : this.config.nodes;
+var Graph = /*#__PURE__*/function () {
+  function Graph(config) {
+    var _this = this;
 
-      for (const element of collection) {
-        if (this.current.config.name === element.name) {
-          return index;
-        }
+    _classCallCheck(this, Graph);
+
+    _defineProperty(this, "getCurrentNodeIndex", function () {
+      var index = 0;
+      var collection = _this.config.stepperMode === null || _this.config.stepperMode === "DYNAMIC" ? _this.path : _this.config.nodes;
+
+      var _iterator = _createForOfIteratorHelper(collection),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var element = _step.value;
+
+          if (_this.current.config.name === element.name) {
+            return index;
+          }
 
-        index++;
+          index++;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
 
       return null;
     });
 
-    _defineProperty(this, "init", () => {
-      let root = this.config.nodes[0];
-      this.current = new _GraphNode.default(this.config.nodes[0]);
-      this.addNodeToPath(this.current);
+    _defineProperty(this, "init", function () {
+      var root = _this.config.nodes[0];
+      _this.current = new _GraphNode.default(_this.config.nodes[0]);
+
+      _this.addNodeToPath(_this.current);
 
       if (root.action.actionType === 'route') {
-        root.action.window = this.config.isWindow;
+        root.action.window = _this.config.isWindow;
       }
 
-      _ActionHandlers.default.invokeHandler(root.action, null, null, this.config.id);
+      _ActionHandlers.default.invokeHandler(root.action, null, null, _this.config.id);
     });
 
-    _defineProperty(this, "signal", event => {
-      let nextNodeName = this.current.getNextNode(event);
+    _defineProperty(this, "signal", function (event) {
+      var nextNodeName = _this.current.getNextNode(event);
 
-      if (this.current.config.last && nextNodeName === null) {
+      if (_this.current.config.last && nextNodeName === null) {
         _ApplicationManager.default.removeLoadedGraph(true);
       } else {
         if (!_Utils.default.isNull(nextNodeName)) {
-          for (const node of this.config.nodes) {
-            if (node.name === nextNodeName) {
-              this.current = new _GraphNode.default(node);
-              this.addNodeToPath(this.current);
+          var _iterator2 = _createForOfIteratorHelper(_this.config.nodes),
+              _step2;
 
-              if (node.action.actionType === 'route') {
-                node.action.window = this.config.isWindow;
-              }
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var node = _step2.value;
+
+              if (node.name === nextNodeName) {
+                _this.current = new _GraphNode.default(node);
+
+                _this.addNodeToPath(_this.current);
 
-              _ActionHandlers.default.invokeHandler(node.action, null, null, this.config.id);
+                if (node.action.actionType === 'route') {
+                  node.action.window = _this.config.isWindow;
+                }
 
-              break;
+                _ActionHandlers.default.invokeHandler(node.action, null, null, _this.config.id);
+
+                break;
+              }
             }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
           }
         }
 
-        if (this.current === null) {
+        if (_this.current === null) {
           console.error("Node name could not be found : " + nextNodeName);
         }
       }
     });
 
-    _defineProperty(this, "setCurrentNodeTitle", title => {
-      if (this.current !== null) {
-        this.current.title = title;
+    _defineProperty(this, "setCurrentNodeTitle", function (title) {
+      if (_this.current !== null) {
+        _this.current.title = title;
       }
     });
 
-    _defineProperty(this, "addNodeToPath", node => {
-      if (this.path.length === 0) {
-        this.path.push(node);
+    _defineProperty(this, "addNodeToPath", function (node) {
+      if (_this.path.length === 0) {
+        _this.path.push(node);
       } else {
-        let lastNode = this.path[this.path.length - 1];
+        var lastNode = _this.path[_this.path.length - 1];
 
         if (lastNode.config.name === node.config.name) {
-          this.path.pop();
+          _this.path.pop();
         } else {
-          this.path.push(node);
+          _this.path.push(node);
         }
       }
     });
@@ -101,59 +141,87 @@ class Graph {
     this.path = [];
   }
 
-  getTitleStack() {
-    let titleStack = [];
-    let index = 0;
-
-    if (this.config.stepperMode === null || this.config.stepperMode === "DYNAMIC") {
-      for (const pathElement of this.path) {
-        let stackItem = {};
-        stackItem.title = pathElement.title;
-        stackItem.index = index++;
-        titleStack.push(stackItem);
-      }
-    } else {
-      for (const node of this.config.nodes) {
-        let stackItem = {};
-        stackItem.title = node.title;
-        stackItem.index = index++;
-        titleStack.push(stackItem);
+  _createClass(Graph, [{
+    key: "getTitleStack",
+    value: function getTitleStack() {
+      var titleStack = [];
+      var index = 0;
+
+      if (this.config.stepperMode === null || this.config.stepperMode === "DYNAMIC") {
+        var _iterator3 = _createForOfIteratorHelper(this.path),
+            _step3;
+
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var pathElement = _step3.value;
+            var stackItem = {};
+            stackItem.title = pathElement.title;
+            stackItem.index = index++;
+            titleStack.push(stackItem);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      } else {
+        var _iterator4 = _createForOfIteratorHelper(this.config.nodes),
+            _step4;
+
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var node = _step4.value;
+            var _stackItem = {};
+            _stackItem.title = node.title;
+            _stackItem.index = index++;
+            titleStack.push(_stackItem);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
       }
-    }
 
-    return titleStack;
-  }
-
-  get title() {
-    return this.config.title;
-  }
-
-  get value() {
-    if (_Utils.default.isNull(this.config.valueObjectType)) {
-      let value = {};
+      return titleStack;
+    }
+  }, {
+    key: "title",
+    get: function get() {
+      return this.config.title;
+    }
+  }, {
+    key: "value",
+    get: function get() {
+      if (_Utils.default.isNull(this.config.valueObjectType)) {
+        var value = {};
+
+        for (var _i = 0, _Object$keys = Object.keys(this.modelData); _i < _Object$keys.length; _i++) {
+          var key = _Object$keys[_i];
+          value[key] = this.modelData[key];
+        }
 
-      for (const key of Object.keys(this.modelData)) {
-        value[key] = this.modelData[key];
+        return value;
       }
 
-      return value;
+      return this.modelData;
     }
+  }, {
+    key: "model",
+    get: function get() {
+      return this.modelData;
+    },
+    set: function set(model) {
+      this.modelData = model;
+    }
+  }, {
+    key: "id",
+    get: function get() {
+      return this.config.id;
+    }
+  }]);
 
-    return this.modelData;
-  }
-
-  get model() {
-    return this.modelData;
-  }
-
-  set model(model) {
-    this.modelData = model;
-  }
-
-  get id() {
-    return this.config.id;
-  }
-
-}
+  return Graph;
+}();
 
 exports.default = Graph;

package/dist/components/GraphNode.js

@@ -15,63 +15,83 @@ var _Utils = _interopRequireDefault(require("./../Utils"));
 
 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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
 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 GraphNode {
-  constructor(config) {
-    _defineProperty(this, "evaluateEdge", (edge, event) => {
-      let totalEdgeCount = this.config.edges.length;
+var GraphNode = function GraphNode(config) {
+  var _this = this;
 
-      if (_Utils.default.isNull(edge.condition) && totalEdgeCount === 0) {
-        return true;
-      }
+  _classCallCheck(this, GraphNode);
+
+  _defineProperty(this, "evaluateEdge", function (edge, event) {
+    var totalEdgeCount = _this.config.edges.length;
+
+    if (_Utils.default.isNull(edge.condition) && totalEdgeCount === 0) {
+      return true;
+    }
+
+    if (_Utils.default.isNull(edge.condition) && totalEdgeCount > 0) {
+      console.error("Missing required condition for link : " + JSON.stringify(edge));
+      return false;
+    }
 
-      if (_Utils.default.isNull(edge.condition) && totalEdgeCount > 0) {
-        console.error("Missing required condition for link : " + JSON.stringify(edge));
+    if (!_Utils.default.isNull(edge.condition)) {
+      var eventSource = edge.condition.eventSource;
+      var expression = edge.condition.expression;
+
+      if (_Utils.default.isNull(eventSource) && _Utils.default.isNull(expression)) {
+        console.error("Empty condition for link : " + JSON.stringify(edge));
         return false;
       }
 
-      if (!_Utils.default.isNull(edge.condition)) {
-        let eventSource = edge.condition.eventSource;
-        let expression = edge.condition.expression;
+      var sourceId = event.source.api.id;
 
-        if (_Utils.default.isNull(eventSource) && _Utils.default.isNull(expression)) {
-          console.error("Empty condition for link : " + JSON.stringify(edge));
-          return false;
-        }
+      if (totalEdgeCount === 0) {
+        return (_Utils.default.isNull(eventSource) || sourceId === eventSource) && (_Utils.default.isNull(expression) || _DynamicJS.default.executeScript('graphEdge_' + Math.random(), expression));
+      } else {
+        return sourceId === eventSource && (_Utils.default.isNull(expression) || _DynamicJS.default.executeScript('graphEdge_' + Math.random(), expression));
+      }
+    }
+  });
 
-        let sourceId = event.source.api.id;
+  _defineProperty(this, "getNextNode", function (event) {
+    var activeEdge = null;
 
-        if (totalEdgeCount === 0) {
-          return (_Utils.default.isNull(eventSource) || sourceId === eventSource) && (_Utils.default.isNull(expression) || _DynamicJS.default.executeScript('graphEdge_' + Math.random(), expression));
-        } else {
-          return sourceId === eventSource && (_Utils.default.isNull(expression) || _DynamicJS.default.executeScript('graphEdge_' + Math.random(), expression));
-        }
-      }
-    });
+    if (!_Utils.default.isNull(_this.config.edges)) {
+      var _iterator = _createForOfIteratorHelper(_this.config.edges),
+          _step;
 
-    _defineProperty(this, "getNextNode", event => {
-      let activeEdge = null;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var edge = _step.value;
 
-      if (!_Utils.default.isNull(this.config.edges)) {
-        for (const edge of this.config.edges) {
-          if (this.evaluateEdge(edge, event)) {
+          if (_this.evaluateEdge(edge, event)) {
             activeEdge = edge;
             break;
           }
         }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
+    }
 
-      if (activeEdge !== null) {
-        return activeEdge.targetNodeName;
-      }
-
-      return null;
-    });
+    if (activeEdge !== null) {
+      return activeEdge.targetNodeName;
+    }
 
-    this.config = config;
-  }
+    return null;
+  });
 
-}
+  this.config = config;
+};
 
 exports.default = GraphNode;

package/dist/components/HtmlPanel.js

@@ -23,59 +23,80 @@ var _EventType = _interopRequireDefault(require("../event/EventType"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const Handlebars = require('handlebars');
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-const status = response => {
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+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 _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var Handlebars = require('handlebars');
+
+var status = function status(response) {
   if (response.ok) {
     return Promise.resolve(response);
   } else {
-    let error = new Error(response.statusText);
+    var error = new Error(response.statusText);
     error.code = response.status;
     return Promise.reject(error);
   }
 };
 
-const json = response => {
+var json = function json(response) {
   return response.text();
 };
 
-const location = window.location.protocol + '//' + window.location.hostname + ':' + window.location.port;
+var location = window.location.protocol + '//' + window.location.hostname + ':' + window.location.port;
 
-const HtmlPanel = /*#__PURE__*/_react.default.memo( /*#__PURE__*/_react.default.forwardRef((props, ref) => {
-  const [template, setTemplate] = _react.default.useState(null);
+var HtmlPanel = /*#__PURE__*/_react.default.memo( /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
+  var _React$useState = _react.default.useState(null),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      template = _React$useState2[0],
+      setTemplate = _React$useState2[1];
 
-  const [content, setContent] = _react.default.useState(null);
+  var _React$useState3 = _react.default.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      content = _React$useState4[0],
+      setContent = _React$useState4[1];
 
-  const [visible, setVisible] = _react.default.useState(false);
+  var _React$useState5 = _react.default.useState(false),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      visible = _React$useState6[0],
+      setVisible = _React$useState6[1];
 
-  _react.default.useEffect(() => {
+  _react.default.useEffect(function () {
     props.handle.api = api();
   });
 
-  _react.default.useEffect(() => {
+  _react.default.useEffect(function () {
     if (template) {
-      let event = new _Event.default(props.handle, props.viewId, null);
+      var event = new _Event.default(props.handle, props.viewId, null);
 
       _Observable.default.fireEvent(_EventType.default.COMPONENT_LOAD, event);
     }
   }, [template]);
 
-  _react.default.useEffect(() => {
-    let parsedConfig = _Utils.default.parseConfig(props.config, props.viewId);
+  _react.default.useEffect(function () {
+    var parsedConfig = _Utils.default.parseConfig(props.config, props.viewId);
 
     _Observable.default.addSubscriptions(parsedConfig.eventHandlingConfig, props.handle, props.viewId);
 
     _Observable.default.addSystemSubscriptions(props.viewId, parsedConfig);
 
-    let configTemplate = props.config.template;
+    var configTemplate = props.config.template;
 
     if (configTemplate && configTemplate.endsWith('.html')) {
-      let fetchConfig = {
+      var fetchConfig = {
         method: 'GET'
       };
-      (0, _reactPromiseTracker.trackPromise)(fetch(encodeURI(location + configTemplate), fetchConfig).then(status).then(json).then(data => {
+      (0, _reactPromiseTracker.trackPromise)(fetch(encodeURI(location + configTemplate), fetchConfig).then(status).then(json).then(function (data) {
         setTemplate(data);
-      }).catch(e => {
+      }).catch(function (e) {
         console.error(e);
       }));
     } else {
@@ -85,45 +106,53 @@ const HtmlPanel = /*#__PURE__*/_react.default.memo( /*#__PURE__*/_react.default.
     }
 
     Handlebars.registerHelper({
-      eq: (v1, v2) => v1 === v2,
-      ne: (v1, v2) => v1 !== v2,
-      lt: (v1, v2) => v1 < v2,
-      gt: (v1, v2) => v1 > v2,
-      lte: (v1, v2) => v1 <= v2,
-      gte: (v1, v2) => v1 >= v2,
-
-      and() {
+      eq: function eq(v1, v2) {
+        return v1 === v2;
+      },
+      ne: function ne(v1, v2) {
+        return v1 !== v2;
+      },
+      lt: function lt(v1, v2) {
+        return v1 < v2;
+      },
+      gt: function gt(v1, v2) {
+        return v1 > v2;
+      },
+      lte: function lte(v1, v2) {
+        return v1 <= v2;
+      },
+      gte: function gte(v1, v2) {
+        return v1 >= v2;
+      },
+      and: function and() {
         return Array.prototype.every.call(arguments, Boolean);
       },
-
-      or() {
+      or: function or() {
         return Array.prototype.slice.call(arguments, 0, -1).some(Boolean);
       }
-
     });
     props.handle.api.refresh();
-    return () => {
+    return function () {
       _Observable.default.clearComponentEventListeners(props.handle);
     };
   }, []);
 
-  const api = () => {
+  var api = function api() {
     return {
       get id() {
         return props.config.id;
       },
 
-      loadData: actionConfig => {
+      loadData: function loadData(actionConfig) {
         if (actionConfig && actionConfig.value) {
-          let data = _ApplicationManager.default.resolveExpressionValue(actionConfig.value);
+          var data = _ApplicationManager.default.resolveExpressionValue(actionConfig.value);
 
-          let templateScript = Handlebars.compile(template);
+          var templateScript = Handlebars.compile(template);
           setContent(templateScript(data));
         }
       },
-
-      refresh() {
-        let parsedConfig = _Utils.default.parseConfig(props.config, props.viewId);
+      refresh: function refresh() {
+        var parsedConfig = _Utils.default.parseConfig(props.config, props.viewId);
 
         if (!_Utils.default.isNull(props.config) && !_Utils.default.isNull(parsedConfig.visible)) {
           setVisible(_Utils.default.evaluateBooleanExpression(parsedConfig.visible, parsedConfig.id));
@@ -131,8 +160,7 @@ const HtmlPanel = /*#__PURE__*/_react.default.memo( /*#__PURE__*/_react.default.
           setVisible(true);
         }
       },
-
-      getChildren: () => {
+      getChildren: function getChildren() {
         return [];
       },