@agilemotion/oui-react-js 1.2.7 → 1.2.9

package/dist/components/typography/Info.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Info;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _styles = require("@material-ui/core/styles");
+
+var _typographyStyle = _interopRequireDefault(require("../../assets/jss/components/typographyStyle"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// @material-ui/core components
+// core components
+const useStyles = (0, _styles.makeStyles)(_typographyStyle.default);
+
+function Info(props) {
+  const classes = useStyles();
+  const children = props.children;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: classes.defaultFontStyle + " " + classes.infoText
+  }, children);
+}
+
+Info.propTypes = {
+  children: _propTypes.default.node
+};

package/dist/components/typography/Link.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Info;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _typographyStyle = _interopRequireDefault(require("../../assets/jss/components/typographyStyle"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const useStyles = makeStyles(_typographyStyle.default);
+
+function Info(props) {
+  const classes = useStyles();
+  const children = props.children;
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: classes.defaultFontStyle + " " + classes.infoText
+  }, children);
+}
+
+Info.propTypes = {
+  children: _propTypes.default.node
+};

package/dist/event/ActionHandlers.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _ScriptActionHandler = _interopRequireDefault(require("./ScriptActionHandler"));
+
+var _RouteActionHandler = _interopRequireDefault(require("./RouteActionHandler"));
+
+var _ServiceCallActionHandler = _interopRequireDefault(require("./ServiceCallActionHandler"));
+
+var _LoadDataActionHandler = _interopRequireDefault(require("./LoadDataActionHandler"));
+
+var _SignalGraphActionHandler = _interopRequireDefault(require("./SignalGraphActionHandler"));
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+var _ApplicationContext = _interopRequireDefault(require("../ApplicationContext"));
+
+var _DynamicJS = _interopRequireDefault(require("../DynamicJS"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 ActionHandlers {
+  constructor() {
+    _defineProperty(this, "confirmAction", message => {
+      if (!_Utils.default.isNull(message)) {
+        _ApplicationContext.default.openConfirmDialog(message);
+
+        return false;
+      }
+
+      return true;
+    });
+
+    if (!ActionHandlers.instance) {
+      ActionHandlers.instance = this;
+    }
+
+    return ActionHandlers.instance;
+  }
+
+  getActionHandler(id) {
+    if (id === 'script') {
+      return _ScriptActionHandler.default;
+    } else if (id === 'route') {
+      return _RouteActionHandler.default;
+    } else if (id === 'serviceCall') {
+      return _ServiceCallActionHandler.default;
+    } else if (id === 'loadData') {
+      return _LoadDataActionHandler.default;
+    } else if (id === 'signalGraph') {
+      return _SignalGraphActionHandler.default;
+    }
+  }
+
+  invoke(action, be, listener) {
+    // TODO : Check action conditions and also run pre and post scripts
+    let component = listener.getSubscriberRef();
+    let viewId = listener.getViewId();
+    this.invokeHandler(action, be, component, viewId);
+  }
+
+  invokeHandler(action, be, component, viewId) {
+    let actionHandler = this.getActionHandler(action.actionType);
+    let message = action.confirmationMessage;
+    let preCondition = action.preCondition;
+    let shouldRun = true;
+
+    if (!_Utils.default.isNull(preCondition)) {
+      shouldRun = _DynamicJS.default.executeScript(Math.random() + "_action_pre_condition", preCondition);
+    }
+
+    if (shouldRun) {
+      if (!_Utils.default.isNull(message)) {
+        _ApplicationContext.default.openConfirmDialog(message, result => {
+          if (result === true) {
+            actionHandler.execute(action, be, component, viewId);
+          }
+        });
+      } else {
+        actionHandler.execute(action, be, component, viewId);
+      }
+    }
+  }
+
+}
+
+const instance = new ActionHandlers();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;

package/dist/event/Event.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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 Event {
+  constructor(source, viewId, data) {
+    _defineProperty(this, "getSource", () => {
+      return this.source;
+    });
+
+    _defineProperty(this, "getData", () => {
+      return this.data;
+    });
+
+    this.source = source;
+    this.viewId = viewId;
+    this.data = data;
+  }
+
+}
+
+var _default = Event;
+exports.default = _default;

package/dist/event/EventListener.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 EventSubscription {
+  constructor(subscriberRef, viewId, publisher, eventType, actions, callback) {
+    _defineProperty(this, "getSubscriberRef", () => {
+      return this.subscriberRef;
+    });
+
+    _defineProperty(this, "getEventType", () => {
+      return this.eventType;
+    });
+
+    _defineProperty(this, "getViewId", () => {
+      return this.viewId;
+    });
+
+    _defineProperty(this, "getPublisher", () => {
+      return this.publisher;
+    });
+
+    _defineProperty(this, "getActions", () => {
+      return this.actions;
+    });
+
+    _defineProperty(this, "getCallback", () => {
+      return this.callback;
+    });
+
+    this.subscriberRef = subscriberRef;
+    this.subscriber = !_Utils.default.isNull(subscriberRef) && !_Utils.default.isNull(subscriberRef.api.id) ? subscriberRef.api.id : null;
+    this.eventType = eventType;
+    this.viewId = viewId;
+    this.publisher = publisher;
+    this.actions = actions;
+    this.callback = callback;
+  }
+
+}
+
+var _default = EventSubscription;
+exports.default = _default;

package/dist/event/EventType.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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 EventType {}
+
+exports.default = EventType;
+
+_defineProperty(EventType, "CLICK", "CLICK");
+
+_defineProperty(EventType, "SELECTION_CHANGE", "SELECTION_CHANGE");
+
+_defineProperty(EventType, "SERVICE_CALL_SUCCESS", "SERVICE_CALL_SUCCESS");
+
+_defineProperty(EventType, "SERVICE_CALL_FAILURE", "SERVICE_CALL_FAILURE");
+
+_defineProperty(EventType, "COMPONENT_LOAD", "COMPONENT_LOAD");
+
+_defineProperty(EventType, "VALUE_CHANGE", "VALUE_CHANGE");
+
+_defineProperty(EventType, "ROW_DELETED", "ROW_DELETED");
+
+_defineProperty(EventType, "VIEW_CLOSED", "VIEW_CLOSED");
+
+_defineProperty(EventType, "BARCODE_SCANNED", "BARCODE_SCANNED");
+
+_defineProperty(EventType, "APPLICATION_CONTEXT_CHANGE", "APPLICATION_CONTEXT_CHANGE");
+
+_defineProperty(EventType, "MESSAGE_ARRIVED", "MESSAGE_ARRIVED");
+
+_defineProperty(EventType, "DATA_ARRIVED", "DATA_ARRIVED");

package/dist/event/LoadDataActionHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _Utils = _interopRequireDefault(require("./../Utils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class LoadDataActionHandler {
+  constructor() {
+    if (!LoadDataActionHandler.instance) {
+      LoadDataActionHandler.instance = this;
+    }
+
+    return LoadDataActionHandler.instance;
+  }
+
+  execute(actionConfig, event, component, currentViewId) {
+    if (!_Utils.default.isNull(component)) {
+      component.api.loadData(actionConfig);
+    }
+  }
+
+}
+
+const instance = new LoadDataActionHandler();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;

package/dist/event/Observable.js

@@ -0,0 +1,353 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ActionHandlers = _interopRequireDefault(require("./ActionHandlers"));
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+var _EventListener = _interopRequireDefault(require("./EventListener"));
+
+var _ApplicationContext = _interopRequireWildcard(require("../ApplicationContext"));
+
+var _DynamicJS = require("../DynamicJS");
+
+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 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 _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 Observable {
+  constructor() {
+    _defineProperty(this, "addSubscription", subscription => this.subscriptions.push(subscription));
+
+    _defineProperty(this, "addSubscriptions", (eventHandlingConfig, componentHandle, viewId) => {
+      if (!_Utils.default.isNull(eventHandlingConfig)) {
+        let subscriptions = eventHandlingConfig.subscriptions;
+
+        var _iterator = _createForOfIteratorHelper(subscriptions),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            const subscription = _step.value;
+            this.addSubscription(new _EventListener.default(componentHandle, viewId, !_Utils.default.isNull(subscription.publisher) ? subscription.publisher : componentHandle.api.id, subscription.eventType, subscription.actions));
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    });
+
+    _defineProperty(this, "addSystemSubscriptions", config => {
+      if (!_Utils.default.isNull(config.disabled)) {
+        let matches = config.disabled.match(_DynamicJS.TEMPLATE_REGEX);
+
+        if (!_Utils.default.isNull(matches)) {
+          var _iterator2 = _createForOfIteratorHelper(matches),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              const match = _step2.value;
+              let component = match.replace("@#{", "").replace("}", "");
+              this.addSystemGeneratedSubscription(component, config.id);
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      }
+
+      if (!_Utils.default.isNull(config.visible)) {
+        let matches = config.visible.match(_DynamicJS.TEMPLATE_REGEX);
+
+        if (!_Utils.default.isNull(matches)) {
+          var _iterator3 = _createForOfIteratorHelper(matches),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              const match = _step3.value;
+              let component = match.replace("@#{", "").replace("}", "");
+              this.addSystemGeneratedSubscription(component, config.id);
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      }
+
+      if (!_Utils.default.isNull(config.validator) && !_Utils.default.isNull(config.validator.nullable)) {
+        let matches = config.validator.nullable.match(_DynamicJS.TEMPLATE_REGEX);
+
+        if (!_Utils.default.isNull(matches)) {
+          var _iterator4 = _createForOfIteratorHelper(matches),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              const match = _step4.value;
+              let component = match.replace("@#{", "").replace("}", "");
+              this.addSystemGeneratedSubscription(component, config.id);
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      }
+    });
+
+    _defineProperty(this, "processSystemGeneratedSubscriptions", componentId => {
+      let component = _ApplicationContext.default.resolveComponentApi(componentId);
+
+      if (!_Utils.default.isNull(component)) {
+        var _iterator5 = _createForOfIteratorHelper(this.systemGeneratedSubscriptions),
+            _step5;
+
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            const subscription = _step5.value;
+
+            if (subscription.publisher === componentId) {
+              let component = _ApplicationContext.default.resolveComponentApi(subscription.subscriber);
+
+              if (!_Utils.default.isNull(component)) {
+                if (!_Utils.default.isNull(subscription.callback)) {
+                  subscription.callback();
+                } else if (!_Utils.default.isNull(component.refresh)) {
+                  component.refresh();
+                }
+              }
+            }
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+    });
+
+    _defineProperty(this, "addSystemGeneratedSubscription", (publisher, subscriber, callback) => {
+      let found = false;
+
+      let currentViewid = _ApplicationContext.default.getCurrentView().config.id;
+
+      var _iterator6 = _createForOfIteratorHelper(this.systemGeneratedSubscriptions),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          const systemGeneratedSubscription = _step6.value;
+
+          if (publisher === systemGeneratedSubscription.publisher && subscriber === systemGeneratedSubscription.subscriber && currentViewid === systemGeneratedSubscription.viewId) {
+            found = true;
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+
+      if (!found) {
+        let subscription = {};
+        subscription.publisher = publisher;
+        subscription.subscriber = subscriber;
+        subscription.callback = callback;
+        subscription.viewId = currentViewid;
+        this.systemGeneratedSubscriptions.push(subscription);
+      }
+    });
+
+    if (!Observable.instance) {
+      this.subscriptions = [];
+      this.systemGeneratedSubscriptions = [];
+      Observable.instance = this;
+    }
+
+    return Observable.instance;
+  }
+  /**
+   * Adds a subscription bound by the given event type.
+   *
+   * @param subscription the subscription to be added
+   */
+
+
+  /**
+   * Fires an event.
+   *
+   * @param eventType eventType the event type
+   * @param be the base event
+   * @return false if any subscriptions cancel the event.
+   */
+  fireEvent(eventType, be) {
+    var _this = this;
+
+    return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      var sourceId, viewId, _iterator7, _step7, subscription, j, action;
+
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // Components could be unloading on the cases where screens are busy closing,
+            // meaning the "current" object may be nullified, so we need the null check
+            // This happens on async events such as RPC_CALL. If there is no view masking,
+            // the REST call may return while the component has been destroyed, and the source's current could be null
+            // Proper masking when doing REST CALL should prevent this from happening. The null check provides the sort of defence
+            if (!_Utils.default.isNull(be.getSource())) {
+              sourceId = be.getSource().api.id;
+              viewId = be.viewId;
+
+              if (!_Utils.default.isNull(sourceId)) {
+                _iterator7 = _createForOfIteratorHelper(_this.subscriptions);
+
+                try {
+                  for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+                    subscription = _step7.value;
+
+                    /*if (sourceId === 'jobTitlesMenuIem') {
+                        console.log("CHECKING VIEW [" + subscription.getViewId() + " - " + viewId + "], PUB : ["
+                            + subscription.getPublisher() + " - " + sourceId + "], EVENT: [" + subscription.getEventType() + " - " + eventType + "]");
+                    }*/
+                    if ((subscription.getViewId() === viewId || _ApplicationContext.SYSTEM_EVENT === viewId) && subscription.getPublisher() === sourceId && subscription.getEventType() === eventType) {
+                      if (!_Utils.default.isNull(subscription.getActions())) {
+                        for (j = 0; j < subscription.getActions().length; j++) {
+                          action = subscription.getActions()[j];
+
+                          _ActionHandlers.default.invoke(action, be, subscription);
+                        }
+                      } else if (!_Utils.default.isNull(subscription.getCallback())) {
+                        subscription.getCallback()(be);
+                      }
+                    }
+                  }
+                } catch (err) {
+                  _iterator7.e(err);
+                } finally {
+                  _iterator7.f();
+                }
+
+                _this.processSystemGeneratedSubscriptions(sourceId);
+              }
+            }
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }
+
+  getNextIndexToRemove(val, prop, listenerCollection) {
+    let counter = 0;
+
+    var _iterator8 = _createForOfIteratorHelper(listenerCollection),
+        _step8;
+
+    try {
+      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+        const listener = _step8.value;
+
+        if (listener[prop] === val) {
+          return counter;
+        }
+
+        counter++;
+      }
+    } catch (err) {
+      _iterator8.e(err);
+    } finally {
+      _iterator8.f();
+    }
+
+    return -1;
+  }
+  /**
+   * Clears all event subscriptions
+   *
+   */
+
+
+  clearAllEventListeners() {
+    this.subscriptions.splice(0, this.subscriptions.length);
+    this.systemGeneratedSubscriptions.splice(0, this.systemGeneratedSubscriptions.length);
+  }
+
+  /**
+   * Clears all event subscriptions for the specified view
+   *
+   * @param viewId the view
+   */
+  clearEventListeners(viewId) {
+    let indexes = [];
+    let index = -2;
+
+    while ((index = this.getNextIndexToRemove(viewId, 'viewId', this.subscriptions)) !== -1) {
+      this.subscriptions.splice(index, 1);
+    }
+
+    if (!_Utils.default.isNull(this.systemGeneratedSubscriptions)) {
+      index = -2;
+
+      while ((index = this.getNextIndexToRemove(viewId, 'viewId', this.systemGeneratedSubscriptions)) !== -1) {
+        this.systemGeneratedSubscriptions.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Clears all event subscriptions for the specified view
+   *
+   * @param componentId the view
+   */
+  clearComponentEventListeners(componentId) {
+    let indexes = [];
+    let index = -2;
+
+    while ((index = this.getNextIndexToRemove(componentId, 'subscriber', this.subscriptions)) !== -1) {
+      this.subscriptions.splice(index, 1);
+    }
+
+    if (!_Utils.default.isNull(this.systemGeneratedSubscriptions)) {
+      index = -2;
+
+      while ((index = this.getNextIndexToRemove(componentId, 'subscriber', this.systemGeneratedSubscriptions)) !== -1) {
+        this.systemGeneratedSubscriptions.splice(index, 1);
+      }
+    }
+  }
+
+}
+
+const instance = new Observable();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;