@machinemetrics/mm-react-tools 2.1.0 → 2.2.0-dev

package/dist/index.js

@@ -547,11 +547,165 @@ function _taggedTemplateLiteralLoose(strings, raw) {
 }
 
 // A type of promise-like that resolves synchronously and supports only one observer
+const _Pact = /*#__PURE__*/(function() {
+	function _Pact() {}
+	_Pact.prototype.then = function(onFulfilled, onRejected) {
+		const result = new _Pact();
+		const state = this.s;
+		if (state) {
+			const callback = state & 1 ? onFulfilled : onRejected;
+			if (callback) {
+				try {
+					_settle(result, 1, callback(this.v));
+				} catch (e) {
+					_settle(result, 2, e);
+				}
+				return result;
+			} else {
+				return this;
+			}
+		}
+		this.o = function(_this) {
+			try {
+				const value = _this.v;
+				if (_this.s & 1) {
+					_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+				} else if (onRejected) {
+					_settle(result, 1, onRejected(value));
+				} else {
+					_settle(result, 2, value);
+				}
+			} catch (e) {
+				_settle(result, 2, e);
+			}
+		};
+		return result;
+	};
+	return _Pact;
+})();
+
+// Settles a pact synchronously
+function _settle(pact, state, value) {
+	if (!pact.s) {
+		if (value instanceof _Pact) {
+			if (value.s) {
+				if (state & 1) {
+					state = value.s;
+				}
+				value = value.v;
+			} else {
+				value.o = _settle.bind(null, pact, state);
+				return;
+			}
+		}
+		if (value && value.then) {
+			value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+			return;
+		}
+		pact.s = state;
+		pact.v = value;
+		const observer = pact.o;
+		if (observer) {
+			observer(pact);
+		}
+	}
+}
+
+function _isSettledPact(thenable) {
+	return thenable instanceof _Pact && thenable.s & 1;
+}
 
 const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
 
 const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
 
+// Asynchronously implement a generic for loop
+function _for(test, update, body) {
+	var stage;
+	for (;;) {
+		var shouldContinue = test();
+		if (_isSettledPact(shouldContinue)) {
+			shouldContinue = shouldContinue.v;
+		}
+		if (!shouldContinue) {
+			return result;
+		}
+		if (shouldContinue.then) {
+			stage = 0;
+			break;
+		}
+		var result = body();
+		if (result && result.then) {
+			if (_isSettledPact(result)) {
+				result = result.s;
+			} else {
+				stage = 1;
+				break;
+			}
+		}
+		if (update) {
+			var updateValue = update();
+			if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+				stage = 2;
+				break;
+			}
+		}
+	}
+	var pact = new _Pact();
+	var reject = _settle.bind(null, pact, 2);
+	(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+	return pact;
+	function _resumeAfterBody(value) {
+		result = value;
+		do {
+			if (update) {
+				updateValue = update();
+				if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+					updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+					return;
+				}
+			}
+			shouldContinue = test();
+			if (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {
+				_settle(pact, 1, result);
+				return;
+			}
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+				return;
+			}
+			result = body();
+			if (_isSettledPact(result)) {
+				result = result.v;
+			}
+		} while (!result || !result.then);
+		result.then(_resumeAfterBody).then(void 0, reject);
+	}
+	function _resumeAfterTest(shouldContinue) {
+		if (shouldContinue) {
+			result = body();
+			if (result && result.then) {
+				result.then(_resumeAfterBody).then(void 0, reject);
+			} else {
+				_resumeAfterBody(result);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+	function _resumeAfterUpdate() {
+		if (shouldContinue = test()) {
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+			} else {
+				_resumeAfterTest(shouldContinue);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+}
+
 // Asynchronously call a function and send errors to recovery continuation
 function _catch(body, recover) {
 	try {
@@ -565,6 +719,19 @@ function _catch(body, recover) {
 	return result;
 }
 
+// Asynchronously await a promise and pass the result to a finally continuation
+function _finallyRethrows(body, finalizer) {
+	try {
+		var result = body();
+	} catch (e) {
+		return finalizer(true, e);
+	}
+	if (result && result.then) {
+		return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+	}
+	return finalizer(false, result);
+}
+
 var MMAuthContext = React__default.createContext();
 
 var MMAuthInternalContext = React__default.createContext();
@@ -1192,8 +1359,9 @@ var Authorize = function Authorize(_ref) {
   return !isAuthenticated ? /*#__PURE__*/React__default.createElement(Message, null, "Authorizing...") : /*#__PURE__*/React__default.createElement(Done, null);
 };
 
-var ApolloApp = function ApolloApp(_ref) {
-  var jwt = _ref.jwt,
+var DataWrapper = function DataWrapper(_ref) {
+  var jwtRef = _ref.jwtRef,
+      natsCredsRef = _ref.natsCredsRef,
       graphQLRoleOverride = _ref.graphQLRoleOverride,
       clientId = _ref.clientId,
       accessToken = _ref.accessToken;
@@ -1201,6 +1369,14 @@ var ApolloApp = function ApolloApp(_ref) {
   var _useMMAuth = useMMAuth(),
       urls = _useMMAuth.urls;
 
+  var _useState = React.useState(),
+      client$1 = _useState[0],
+      setClient = _useState[1];
+
+  var _useState2 = React.useState(),
+      link = _useState2[0],
+      setLink = _useState2[1];
+
   var getHierPart = function getHierPart() {
     var url = new URL(urls.graphQLUrl);
     return "//" + url.host + url.pathname;
@@ -1212,85 +1388,94 @@ var ApolloApp = function ApolloApp(_ref) {
     } : {};
   };
 
-  var wsLink = new subscriptions.GraphQLWsLink(graphqlWs.createClient({
-    url: "wss:" + getHierPart(),
-    lazy: true,
-    reconnect: true,
-    connectionParams: function () {
+  React.useEffect(function () {
+    var wsLink = new subscriptions.GraphQLWsLink(graphqlWs.createClient({
+      url: "wss:" + getHierPart(),
+      lazy: true,
+      reconnect: true,
+      connectionParams: function () {
+        try {
+          return Promise.resolve({
+            headers: _extends({
+              Authorization: "Bearer " + jwtRef.current
+            }, getRoleHeaders())
+          });
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+    }));
+    var errorLink = error.onError(function (_ref2) {
+      var operation = _ref2.operation,
+          networkError = _ref2.networkError,
+          forward = _ref2.forward;
+      var definition = utilities.getMainDefinition(operation.query);
+
+      if (definition.operation === 'subscription' && networkError) {
+        wsLink.client.terminate();
+      }
+
+      return forward(operation);
+    });
+    var jwtAuthLink = context.setContext(function (_, _ref3) {
+      var headers = _ref3.headers;
+
       try {
         return Promise.resolve({
-          headers: _extends({
-            Authorization: "Bearer " + jwt
+          headers: _extends({}, headers, {
+            Authorization: "Bearer " + jwtRef.current
           }, getRoleHeaders())
         });
       } catch (e) {
         return Promise.reject(e);
       }
-    }
-  }));
-  var errorLink = error.onError(function (_ref2) {
-    var operation = _ref2.operation,
-        networkError = _ref2.networkError,
-        forward = _ref2.forward;
-    var definition = utilities.getMainDefinition(operation.query);
-
-    if (definition.operation === 'subscription' && networkError) {
-      wsLink.client.terminate();
-    }
-
-    return forward(operation);
-  });
-  var jwtAuthLink = context.setContext(function (_, _ref3) {
-    var headers = _ref3.headers;
+    });
+    var httpLink = jwtAuthLink.concat(client.createHttpLink({
+      uri: "https:" + getHierPart(),
+      fetch: window.fetch
+    }));
+    var graphQlLink = errorLink.split(function (_ref4) {
+      var query = _ref4.query;
+      var definition = utilities.getMainDefinition(query);
+      return definition.kind === 'OperationDefinition' && definition.operation === 'subscription';
+    }, wsLink, httpLink);
+    var accessTokenAuthLink = context.setContext(function (_, _ref5) {
+      var headers = _ref5.headers;
 
-    try {
-      return Promise.resolve({
-        headers: _extends({}, headers, {
-          Authorization: "Bearer " + jwt
-        }, getRoleHeaders())
-      });
-    } catch (e) {
-      return Promise.reject(e);
+      try {
+        return Promise.resolve({
+          headers: _extends({}, headers, {
+            Authorization: "Bearer " + accessToken
+          })
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    var restLink = accessTokenAuthLink.concat(new apolloLinkRest.RestLink({
+      uri: urls.apiUrl
+    }));
+    setLink(client.ApolloLink.from([restLink, graphQlLink]));
+  }, []);
+  React.useEffect(function () {
+    if (!link) {
+      return;
     }
-  });
-  var httpLink = jwtAuthLink.concat(client.createHttpLink({
-    uri: "https:" + getHierPart(),
-    fetch: window.fetch
-  }));
-  var graphQlLink = errorLink.split(function (_ref4) {
-    var query = _ref4.query;
-    var definition = utilities.getMainDefinition(query);
-    return definition.kind === 'OperationDefinition' && definition.operation === 'subscription';
-  }, wsLink, httpLink);
-  var accessTokenAuthLink = context.setContext(function (_, _ref5) {
-    var headers = _ref5.headers;
 
-    try {
-      return Promise.resolve({
-        headers: _extends({}, headers, {
-          Authorization: "Bearer " + accessToken
-        })
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  });
-  var restLink = accessTokenAuthLink.concat(new apolloLinkRest.RestLink({
-    uri: urls.apiUrl
-  }));
-  var link = client.ApolloLink.from([restLink, graphQlLink]);
-  var client$1 = new client.ApolloClient({
-    link: link,
-    cache: new client.InMemoryCache()
-  });
+    setClient(new client.ApolloClient({
+      link: link,
+      cache: new client.InMemoryCache()
+    }));
+  }, [link]);
   return /*#__PURE__*/React__default.createElement(MMAuthInternalContext.Provider, {
     value: {
       link: link,
-      jwt: jwt,
+      natsCredsRef: natsCredsRef,
+      jwtRef: jwtRef,
       clientId: clientId,
       accessToken: accessToken
     }
-  }, /*#__PURE__*/React__default.createElement(client.ApolloProvider, {
+  }, client$1 && /*#__PURE__*/React__default.createElement(client.ApolloProvider, {
     client: client$1
   }, /*#__PURE__*/React__default.createElement(reactRouterDom.Outlet, null)));
 };
@@ -1309,13 +1494,8 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
       isAuthenticated = _useState[0],
       setIsAuthenticated = _useState[1];
 
-  var _useState2 = React.useState(),
-      jwt = _useState2[0],
-      setJwt = _useState2[1];
-
-  var _useState3 = React.useState(),
-      natsCreds = _useState3[0],
-      setNatsCreds = _useState3[1];
+  var jwtRef = React.useRef();
+  var natsCredsRef = React.useRef();
 
   var logout = function logout() {
     try {
@@ -1362,14 +1542,14 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
   useAsyncInterval(function () {
     try {
       if (!accessToken) {
-        setJwt();
+        jwtRef.current = null;
         setIsAuthenticated(false);
         return Promise.resolve();
       }
 
       var _temp3 = _catch(function () {
         return Promise.resolve(request(urls.apiUrl + "/user-token?graphql=1")).then(function (response) {
-          setJwt(response);
+          jwtRef.current = response;
           setIsAuthenticated(true);
         });
       }, function () {});
@@ -1382,13 +1562,13 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
   useAsyncInterval(function () {
     try {
       if (!accessToken) {
-        setNatsCreds();
+        natsCredsRef.current = null;
         return Promise.resolve();
       }
 
       var _temp5 = _catch(function () {
         return Promise.resolve(request(urls.apiUrl + "/nats-token")).then(function (response) {
-          setNatsCreds(response);
+          natsCredsRef.current = response;
         });
       }, function () {});
 
@@ -1403,8 +1583,7 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
       login: login,
       logout: logout,
       request: request,
-      urls: urls,
-      natsCreds: natsCreds
+      urls: urls
     }
   }, /*#__PURE__*/React__default.createElement(reactRouterDom.Routes, null, /*#__PURE__*/React__default.createElement(reactRouterDom.Route, {
     exact: true,
@@ -1414,10 +1593,11 @@ var MMJwtProvider = function MMJwtProvider(_ref) {
     })
   }), /*#__PURE__*/React__default.createElement(reactRouterDom.Route, {
     path: "/",
-    element: /*#__PURE__*/React__default.createElement(ApolloApp, {
+    element: /*#__PURE__*/React__default.createElement(DataWrapper, {
       clientId: clientId,
       graphQLRoleOverride: graphQLRoleOverride,
-      jwt: jwt,
+      jwtRef: jwtRef,
+      natsCredsRef: natsCredsRef,
       accessToken: accessToken
     })
   }, children))));
@@ -1461,21 +1641,26 @@ var MMProvider = function MMProvider(_ref) {
       clientId = _ref.clientId,
       clientSecret = _ref.clientSecret,
       releaseStage = _ref.releaseStage,
-      graphQLRoleOverride = _ref.graphQLRoleOverride;
+      graphQLRoleOverride = _ref.graphQLRoleOverride,
+      customUrls = _ref.urls;
 
   if (releaseStage === 'release') {
     releaseStage = 'production';
     console.warn("releaseStage \"release\" has been deprecated. use \"production\" instead.");
   }
 
-  var urls = URL_MAP[releaseStage];
+  var urls;
 
-  if (!urls) {
+  if (URL_MAP[releaseStage]) {
+    urls = URL_MAP[releaseStage];
+  } else {
     var stages = _.keys(URL_MAP).join(', ');
 
     throw Error("MMProvider releaseStage must be one of the following: " + stages);
   }
 
+  urls = _.merge(urls, customUrls);
+
   var _useState = React.useState(retrieveAccessToken()),
       accessToken = _useState[0],
       setAccessToken = _useState[1];
@@ -1563,17 +1748,14 @@ var MMProvider = function MMProvider(_ref) {
   }));
 };
 
+var ALLOWED_DELIVERY_POLICIES = ['new', 'last', 'last_per_subject'];
+
 var connectToServer = function connectToServer(url, creds) {
   try {
-    var credentialsBytes = new TextEncoder().encode(creds);
-    return Promise.resolve(_catch(function () {
-      return Promise.resolve(nats_ws.connect({
-        servers: [url],
-        authenticator: nats_ws.credsAuthenticator(credentialsBytes)
-      }));
-    }, function (error) {
-      console.error("Error connecting to server: " + error.message);
-      throw error;
+    console.info("Connecting to server " + url);
+    return Promise.resolve(nats_ws.connect({
+      servers: [url],
+      authenticator: nats_ws.credsAuthenticator(new TextEncoder().encode(creds))
     }));
   } catch (e) {
     return Promise.reject(e);
@@ -1620,7 +1802,7 @@ function _decode() {
           case 14:
             _context.prev = 14;
             _context.t0 = _context["catch"](9);
-            console.warn("Skipping event\n" + JSON.stringify(event, null, 2) + "\n" + _context.t0);
+            console.warn("Skipping event: " + _context.t0);
 
           case 17:
             _iteratorAbruptCompletion = false;
@@ -1675,67 +1857,212 @@ function _decode() {
   return _decode.apply(this, arguments);
 }
 
-var useEventStream = function useEventStream(_ref) {
-  var streamName = _ref.streamName,
-      subject = _ref.subject;
+var closeConnection = function closeConnection(eventStreamRef, connectionRef) {
+  if (eventStreamRef.current) {
+    eventStreamRef.current = undefined;
+  }
+
+  if (connectionRef.current) {
+    connectionRef.current.close();
+    connectionRef.current = undefined;
+  }
+};
+
+var streamPatterns = {
+  scada: 'mm.0.[location-ref].[machine-ref].[qualifier].[data-category].[metric-key].[message-type]',
+  'machine-service': 'mm.2.[location-ref].[machine-ref].[service-name].[qualifier].[data-category].[metric-key].[message-type]',
+  'edge-service': 'mm.3.[location-ref].[edge-ref].[service-name].[data-category].[metric-key].[message-type]',
+  'machine-source-service': 'mm.4.[location-ref].[machine-ref].[machine-source-ref].[service-name].[data-category].[metric-key].[message-type]',
+  edge: 'mm.7.[location-ref].[edge-ref].[data-category].[metric-key].[message-type]'
+};
+var dataCategoryMapping = {
+  undefined: 0,
+  event: 1,
+  eventset: 2,
+  quantity: 3,
+  state: 4,
+  count: 5,
+  info: 6,
+  beat: 7
+};
+
+var buildSubject = function buildSubject(streamName, locationRef, filter) {
+  if (!streamPatterns[streamName]) {
+    throw new Error('Unknown stream name');
+  }
+
+  var pattern = streamPatterns[streamName].split('.');
+  var subject = '';
+  pattern.forEach(function (part, index) {
+    switch (part) {
+      case '[location-ref]':
+        subject += '.' + locationRef;
+        break;
+
+      case '[machine-ref]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.machineRef) || '*');
+        break;
+
+      case '[qualifier]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.qualifier) || '0');
+        break;
+
+      case '[data-category]':
+        subject += '.' + (dataCategoryMapping[filter === null || filter === void 0 ? void 0 : filter.dataCategory] || '*');
+        break;
+
+      case '[metric-key]':
+        subject += '.' + (filter !== null && filter !== void 0 && filter.metricKey ? filter === null || filter === void 0 ? void 0 : filter.metricKey.toLowerCase().replace(/[^a-zA-Z0-9_\\-]/gi, '-') : '*');
+        break;
+
+      case '[message-type]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.messageType) || '0');
+        break;
+
+      case '[edge-ref]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.edgeRef) || '*');
+        break;
+
+      case '[service-name]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.serviceName) || '*');
+        break;
+
+      case '[machine-source-ref]':
+        subject += '.' + ((filter === null || filter === void 0 ? void 0 : filter.machineSourceRef) || '*');
+        break;
+
+      default:
+        if (index > 0) {
+          subject += '.';
+        }
+
+        subject += part;
+        break;
+    }
+  });
+  return subject;
+};
+
+var useEventStream = function useEventStream(params) {
+  var streamName = params.streamName,
+      locationRef = params.locationRef,
+      filters = params.filters,
+      _params$deliverPolicy = params.deliverPolicy,
+      deliverPolicy = _params$deliverPolicy === void 0 ? 'new' : _params$deliverPolicy,
+      dispatch = params.dispatch;
+
+  if (!ALLOWED_DELIVERY_POLICIES.includes(deliverPolicy)) {
+    throw new Error("Invalid deliverPolicy \"" + deliverPolicy + "\" specified. Valid options are: " + ALLOWED_DELIVERY_POLICIES.join(', '));
+  }
+
+  if (filters && filters.length > 1) {
+    console.warn("Multiple filters are not supported. Only the first filter will be used.");
+  }
 
   var _useMMAuth = useMMAuth(),
-      natsCreds = _useMMAuth.natsCreds,
       urls = _useMMAuth.urls;
 
-  var _useState = React.useState(),
-      connection = _useState[0],
-      setConnection = _useState[1];
-
-  var _useState2 = React.useState(),
-      eventStream = _useState2[0],
-      setEventStream = _useState2[1];
+  var _useMMAuthInternal2 = _useMMAuthInternal(),
+      natsCredsRef = _useMMAuthInternal2.natsCredsRef;
 
+  var connectionRef = React.useRef();
+  var eventStreamRef = React.useRef();
   React.useEffect(function () {
-    if (eventStream === undefined) {
-      if (natsCreds && subject) {
-        connectToServer(urls.natsUrl, natsCreds).then(function (conn) {
-          try {
-            var _temp2 = function _temp2(stream) {
-              return jc.consumers.get(stream, {
-                filterSubjects: subject,
-                deliver_policy: 'last_per_subject'
-              });
-            };
+    if (!urls.natsUrl || !natsCredsRef.current || !streamName || !locationRef) return;
 
-            setConnection(conn);
-            var jc = conn.jetstream();
-            console.log('Consuming from subject:', subject);
-            return Promise.resolve(streamName ? _temp2(streamName) : Promise.resolve(jc.findStream(subject)).then(_temp2));
-          } catch (e) {
-            return Promise.reject(e);
-          }
-        }).then(function (consumer) {
-          try {
-            return Promise.resolve(consumer.consume({
-              max_messages: 1000
-            })).then(function (messages) {
-              var events = decode(messages);
-              setEventStream(events);
+    var setupStream = function setupStream() {
+      try {
+        return Promise.resolve(_catch(function () {
+          return Promise.resolve(connectToServer(urls.natsUrl, natsCredsRef.current)).then(function (conn) {
+            connectionRef.current = conn;
+            var subject = buildSubject(streamName, locationRef, filters === null || filters === void 0 ? void 0 : filters[0]);
+            console.info("Consuming events from stream " + streamName + " filtering by subject " + subject);
+            return Promise.resolve(conn.jetstream().consumers.get(streamName, {
+              deliver_policy: deliverPolicy,
+              filterSubjects: subject
+            })).then(function (consumer) {
+              return Promise.resolve(consumer.consume({
+                max_messages: 1000
+              })).then(function (messages) {
+                var eventStream = decode(messages);
+                eventStreamRef.current = eventStream;
+                return function () {
+                  if (typeof dispatch === 'function') {
+                    var _iteratorAbruptCompletion2 = false;
+                    var _didIteratorError2 = false;
+
+                    var _iteratorError2;
+
+                    return _finallyRethrows(function () {
+                      return _catch(function () {
+                        var _iterator2 = _asyncIterator(eventStream),
+                            _step2;
+
+                        var _temp = _for(function () {
+                          return Promise.resolve(_iterator2.next()).then(function (_iterator2$next) {
+                            return _iteratorAbruptCompletion2 = !(_step2 = _iterator2$next).done;
+                          });
+                        }, function () {
+                          return !!(_iteratorAbruptCompletion2 = false);
+                        }, function () {
+                          var event = _step2.value;
+                          dispatch(event);
+                        });
+
+                        if (_temp && _temp.then) return _temp.then(function () {});
+                      }, function (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                      });
+                    }, function (_wasThrown, _result2) {
+                      var _exit = false;
+
+                      function _temp4(_result3) {
+                        if (_exit) return _result3;
+                        if (_wasThrown) throw _result2;
+                        return _result2;
+                      }
+
+                      var _temp3 = _finallyRethrows(function () {
+                        var _temp2 = function () {
+                          if (_iteratorAbruptCompletion2 && _iterator2["return"] != null) {
+                            return Promise.resolve(_iterator2["return"]()).then(function () {});
+                          }
+                        }();
+
+                        if (_temp2 && _temp2.then) return _temp2.then(function () {});
+                      }, function (_wasThrown2, _result3) {
+                        if (_didIteratorError2) {
+                          throw _iteratorError2;
+                        }
+
+                        if (_wasThrown2) throw _result3;
+                        return _result3;
+                      });
+
+                      return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
+                    });
+                  }
+                }();
+              });
             });
-          } catch (e) {
-            return Promise.reject(e);
-          }
-        });
+          });
+        }, function (error) {
+          console.error("Error setting up event stream. " + error);
+        }));
+      } catch (e) {
+        return Promise.reject(e);
       }
-    } else {
-      return function () {
-        if (eventStream) {
-          setEventStream(undefined);
-        }
+    };
 
-        if (connection) {
-          connection.close();
-        }
-      };
-    }
-  }, [subject, natsCreds]);
-  return eventStream;
+    setupStream();
+    return function () {
+      return closeConnection(eventStreamRef, connectionRef);
+    };
+  }, [streamName, locationRef, deliverPolicy, urls.natsUrl, natsCredsRef]);
+  return [eventStreamRef.current, function () {
+    return closeConnection(eventStreamRef, connectionRef);
+  }];
 };
 
 exports.MMProvider = MMProvider;