@valtimo/sse 10.8.0 → 11.0.0

package/{esm2020 → esm2022}/lib/models/index.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,4 +15,4 @@
  */
 export * from './sse-bucket.model';
 export * from './sse-events.model';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3NzZS9zcmMvbGliL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIwIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc3NlLWJ1Y2tldC5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS1ldmVudHMubW9kZWwnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3NzZS9zcmMvbGliL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIzIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc3NlLWJ1Y2tldC5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS1ldmVudHMubW9kZWwnO1xuIl19

package/{esm2020 → esm2022}/lib/models/sse-bucket.model.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,4 +45,4 @@ export class SseEventSubscriptionBucket extends SseSubscriptionBucket {
         this.event = event;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/models/sse-events.model.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NlLWV2ZW50cy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vc3NlL3NyYy9saWIvbW9kZWxzL3NzZS1ldmVudHMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG50eXBlIFNzZUV2ZW50VHlwZSA9XG4gIHwgJ0NBU0VfQ1JFQVRFRCdcbiAgfCAnVEFTS19VUERBVEUnXG4gIHwgJ1BST0NFU1NfRU5EJ1xuICB8ICdDQVNFX0FTU0lHTkVEJ1xuICB8ICdDQVNFX1VOQVNTSUdORUQnXG4gIHwgJ0VTVEFCTElTSEVEX0NPTk5FQ1RJT04nO1xuXG50eXBlIFNzZUV2ZW50TGlzdGVuZXI8VD4gPSAoZXZlbnQ6IFQpID0+IHZvaWQ7XG5cbi8vIGJhc2UgZXZlbnQgY29udGFpbmluZyB0aGUgZXZlbnQgdHlwZVxuaW50ZXJmYWNlIEJhc2VTc2VFdmVudCB7XG4gIGV2ZW50VHlwZT86IFNzZUV2ZW50VHlwZTtcbiAgcHJvY2Vzc0luc3RhbmNlSWQ/OiBzdHJpbmc7XG59XG5cbi8vIGV2ZW50IGltcGxlbWVudGF0aW9ucyBmb3IganNvbiBtYXBwaW5nIG9iamVjdHMgaW46XG5pbnRlcmZhY2UgVGFza1VwZGF0ZVNzZUV2ZW50IGV4dGVuZHMgQmFzZVNzZUV2ZW50IHtcbiAgcHJvY2Vzc0luc3RhbmNlSWQ6IHN0cmluZztcbn1cblxuaW50ZXJmYWNlIEVzdGFibGlzaGVkQ29ubmVjdGlvblNzZUV2ZW50IGV4dGVuZHMgQmFzZVNzZUV2ZW50IHtcbiAgc3Vic2NyaXB0aW9uSWQ6IHN0cmluZztcbn1cblxuaW50ZXJmYWNlIFNzZUVycm9yIHtcbiAgc3RhdGU6IG51bWJlcjtcbiAgbWVzc2FnZTogc3RyaW5nO1xuICBkYXRhPzogYW55O1xufVxuXG5leHBvcnQge1xuICBTc2VFcnJvcixcbiAgRXN0YWJsaXNoZWRDb25uZWN0aW9uU3NlRXZlbnQsXG4gIFRhc2tVcGRhdGVTc2VFdmVudCxcbiAgQmFzZVNzZUV2ZW50LFxuICBTc2VFdmVudExpc3RlbmVyLFxuICBTc2VFdmVudFR5cGUsXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/services/index.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 export * from './sse.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3NzZS9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NzZS5zZXJ2aWNlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3NzZS9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3NzZS5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/services/sse.service.mjs

@@ -0,0 +1,238 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { filter, Observable, Subject } from 'rxjs';
+import { SseErrorBucket, SseEventSubscriptionBucket, SseSubscriptionBucket, } from '../models/sse-bucket.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/config";
+import * as i2 from "ngx-logger";
+/**
+ * Server-side events service, for connecting and reconnecting to SSE,
+ * and a translation layer between SSE json string data and TS typed events.
+ *
+ * The service is always present, and so events can be registered with {@link onMessage} and {@link onEvent},
+ * and will not be lost on disconnect or reconnect of the SSE connection itself.
+ * It is expected to also unregister events using the off-method variants of the on-method listeners.
+ *
+ * To ensure messages are received the connection must be explicitly opened with {@link connect},
+ * likewise the connection should also be closed with {@link disconnect} to stop receiving messages.
+ *
+ * This service can reconnect itself with the backend, and might use the {@link subscriptionId} to ask for its
+ * previous connection state. This state currently exists in the backend as the "Subscriber" class, and might
+ * have a state containing queues of items that need to be sent, so you can reconnect and receive the rest.
+ *
+ * At this time no state data is kept, so reconnection without a subscriptionId does not give a different result
+ */
+export class SseService {
+    static { this.CONNECTION_RETRIES_EXCEEDED = -1; }
+    static { this.NOT_CONNECTED = 0; }
+    static { this.CONNECTING = 1; }
+    static { this.RECONNECTING = 2; }
+    static { this.CONNECTED = 10; }
+    get sseMessages$() {
+        return this._sseMessages$.asObservable().pipe(filter(message => !!message));
+    }
+    constructor(configService, logger) {
+        this.configService = configService;
+        this.logger = logger;
+        this.connectionCount = 0; // amount of times we have connected sequentially, no concurrent connections
+        this.establishedDataHandler = null;
+        this.establishedConnection = null;
+        this.establishedConnectionObservable = null;
+        this.subscriptionId = null;
+        this.sequentialConnectionAttemptFailCount = 0;
+        this.errorBucket = new SseErrorBucket();
+        this.anySubscribersBucket = new SseSubscriptionBucket();
+        this.eventSubscribersBuckets = [];
+        this.state = SseService.NOT_CONNECTED;
+        this._sseMessages$ = new Subject();
+        this.VALTIMO_ENDPOINT_URL = configService.config.valtimoApi.endpointUri;
+        this.connect();
+    }
+    getSseMessagesObservableByEventType(eventTypes) {
+        return this._sseMessages$.asObservable().pipe(filter(message => !!message), filter(message => eventTypes.includes(message?.data?.eventType)));
+    }
+    /**
+     * Start receiving SSE events
+     */
+    connect() {
+        this.ensureConnection();
+        return this;
+    }
+    onMessage(listener) {
+        this.ensureConnection(); // ensure connection
+        this.anySubscribersBucket.on(listener);
+        return this;
+    }
+    onEvent(event, listener) {
+        this.ensureConnection(); // ensure connection
+        let found = false;
+        this.eventSubscribersBuckets.forEach(bucket => {
+            if (bucket.event === event) {
+                bucket.on(listener);
+                found = true;
+            }
+        });
+        if (!found) {
+            const bucket = new SseEventSubscriptionBucket(event);
+            bucket.on(listener);
+            this.eventSubscribersBuckets.push(bucket);
+        }
+        return this;
+    }
+    offMessage(listener) {
+        this.anySubscribersBucket.off(listener);
+    }
+    offEvent(event, listener) {
+        this.eventSubscribersBuckets.forEach(bucket => {
+            if (bucket.event === event) {
+                bucket.off(listener);
+            }
+        });
+    }
+    offEvents(type) {
+        this.eventSubscribersBuckets.forEach(bucket => {
+            if (type === null || type === bucket.event) {
+                bucket.offAll();
+            }
+        });
+    }
+    offMessages() {
+        this.anySubscribersBucket.offAll();
+    }
+    offAll() {
+        this.offEvents();
+        this.offMessages();
+    }
+    disconnect(keepSubscriptionId = false) {
+        this.disconnectWith(SseService.NOT_CONNECTED, keepSubscriptionId);
+    }
+    disconnectWith(state, keepSubscriptionId = false) {
+        this.state = state;
+        if (this.establishedConnection?.readyState !== EventSource.CLOSED) {
+            this.establishedConnection?.close();
+        }
+        this.establishedDataHandler.unsubscribe();
+        this.establishedConnection = null;
+        this.establishedConnectionObservable = null;
+        this.establishedDataHandler = null;
+        if (!keepSubscriptionId) {
+            this.subscriptionId = null;
+        }
+    }
+    ensureConnection(retry = false) {
+        if (this.establishedConnection !== null && this.establishedConnectionObservable !== null) {
+            if (this.establishedConnection.readyState !== EventSource.CLOSED) {
+                return; // found
+            }
+        }
+        if (this.state === SseService.CONNECTING || this.state === SseService.RECONNECTING) {
+            return; // already connecting
+        }
+        this.establishedConnection = null;
+        this.establishedConnectionObservable = null;
+        this.constructNewSse(retry); // create new
+    }
+    constructNewSse(retry) {
+        this.logger.debug('subscribing to sse events');
+        if (this.connectionCount > 0) {
+            this.state = SseService.RECONNECTING;
+        }
+        else {
+            this.state = SseService.CONNECTING;
+        }
+        const observable = new Observable(observer => {
+            const eventSource = this.getEventSource();
+            eventSource.onopen = () => {
+                this.establishedConnection = eventSource;
+                this.logger.debug('connected to sse');
+                this.connectionCount++;
+                this.sequentialConnectionAttemptFailCount = 0; // reset retry count
+                this.state = SseService.CONNECTED;
+            };
+            eventSource.onmessage = event => {
+                observer.next({
+                    ...event,
+                    data: JSON.parse(event.data), // parse JSON string to JSON object
+                });
+            };
+            eventSource.onerror = () => {
+                eventSource.close();
+                observer.complete();
+                if (retry) {
+                    this.sequentialConnectionAttemptFailCount++;
+                    this.logger.debug(`retry failed: ${this.sequentialConnectionAttemptFailCount}`);
+                    if (this.sequentialConnectionAttemptFailCount > 3) {
+                        this.disconnectWith(SseService.CONNECTION_RETRIES_EXCEEDED, false);
+                        this.err(`Failed to connect to SSE after ${this.sequentialConnectionAttemptFailCount} retries`);
+                        return;
+                    }
+                }
+                this.disconnect(true);
+                this.ensureConnection(true);
+            };
+            return () => eventSource.close();
+        });
+        this.establishedConnectionObservable = observable;
+        this.registerSseEventHandling(observable);
+        return observable;
+    }
+    getEventSource() {
+        let suffix = '';
+        if (this.subscriptionId != null) {
+            suffix = '/' + this.subscriptionId;
+        }
+        // subscribe to /sse or /sse/<subscriptionId>
+        return new EventSource(this.VALTIMO_ENDPOINT_URL + 'v1/sse' + suffix);
+    }
+    registerSseEventHandling(observable) {
+        this.establishedDataHandler = observable.subscribe(event => {
+            this._sseMessages$.next(event);
+            this.internalListenerEstablishConnection(event);
+            // notify all generic listeners
+            this.anySubscribersBucket.sendEvent(event.data);
+            // notify the specific event listener bucket
+            this.eventSubscribersBuckets.forEach(bucket => {
+                if (bucket.event === event?.data?.eventType) {
+                    bucket.sendEvent(event.data);
+                }
+            });
+        });
+    }
+    internalListenerEstablishConnection(event) {
+        if (event?.data?.eventType !== 'ESTABLISHED_CONNECTION') {
+            return;
+        }
+        this.logger.debug(`established connection: ${event}`);
+        this.subscriptionId = event.data.subscriptionId;
+    }
+    err(message, ...data) {
+        this.errorBucket.sendEvent({
+            state: this.state,
+            message,
+            data,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseService, deps: [{ token: i1.ConfigService }, { token: i2.NGXLogger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.NGXLogger }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/sse/src/lib/services/sse.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAe,MAAM,MAAM,CAAC;AAQ/D,OAAO,EACL,cAAc,EACd,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;;;;AAGpC;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,OAAO,UAAU;aACG,gCAA2B,GAAG,CAAC,CAAC,AAAL,CAAM;aACjC,kBAAa,GAAG,CAAC,AAAJ,CAAK;aAClB,eAAU,GAAG,CAAC,AAAJ,CAAK;aACf,iBAAY,GAAG,CAAC,AAAJ,CAAK;aACjB,cAAS,GAAG,EAAE,AAAL,CAAM;IAkBvC,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED,YACmB,aAA4B,EAC5B,MAAiB;QADjB,kBAAa,GAAb,aAAa,CAAe;QAC5B,WAAM,GAAN,MAAM,CAAW;QArB5B,oBAAe,GAAG,CAAC,CAAC,CAAC,4EAA4E;QACjG,2BAAsB,GAAkB,IAAI,CAAC;QAC7C,0BAAqB,GAAiB,IAAI,CAAC;QAC3C,oCAA+B,GAA2C,IAAI,CAAC;QAC/E,mBAAc,GAAY,IAAI,CAAC;QAC/B,yCAAoC,GAAG,CAAC,CAAC;QAEzC,gBAAW,GAAG,IAAI,cAAc,EAAE,CAAC;QACnC,yBAAoB,GAAG,IAAI,qBAAqB,EAAgB,CAAC;QACjE,4BAAuB,GAA+C,EAAE,CAAC;QAEzE,UAAK,GAAW,UAAU,CAAC,aAAa,CAAC;QAEzC,kBAAa,GAAG,IAAI,OAAO,EAA8B,CAAC;QAUhE,IAAI,CAAC,oBAAoB,GAAG,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC;QACxE,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED,mCAAmC,CACjC,UAA+B;QAE/B,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,IAAI,CAC3C,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAC5B,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CACjE,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,OAAO;QACb,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,SAAS,CAAC,QAAwC;QACxD,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,oBAAoB;QAC7C,IAAI,CAAC,oBAAoB,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,OAAO,CAAyB,KAAa,EAAE,QAA6B;QAClF,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,oBAAoB;QAC7C,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YAC5C,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,EAAE;gBAC1B,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;gBACpB,KAAK,GAAG,IAAI,CAAC;aACd;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,EAAE;YACV,MAAM,MAAM,GAAG,IAAI,0BAA0B,CAAC,KAAK,CAAC,CAAC;YACrD,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;YACpB,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAC3C;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,UAAU,CAAC,QAAwC;QACzD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAEO,QAAQ,CAAC,KAAa,EAAE,QAA+B;QAC7D,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YAC5C,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,EAAE;gBAC1B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;aACtB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,SAAS,CAAC,IAAa;QAC7B,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YAC5C,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,MAAM,CAAC,KAAK,EAAE;gBAC1C,MAAM,CAAC,MAAM,EAAE,CAAC;aACjB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC;IACrC,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAEO,UAAU,CAAC,qBAA8B,KAAK;QACpD,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;IACpE,CAAC;IAEO,cAAc,CAAC,KAAa,EAAE,qBAA8B,KAAK;QACvE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,IAAI,CAAC,qBAAqB,EAAE,UAAU,KAAK,WAAW,CAAC,MAAM,EAAE;YACjE,IAAI,CAAC,qBAAqB,EAAE,KAAK,EAAE,CAAC;SACrC;QACD,IAAI,CAAC,sBAAsB,CAAC,WAAW,EAAE,CAAC;QAC1C,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,+BAA+B,GAAG,IAAI,CAAC;QAC5C,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,kBAAkB,EAAE;YACvB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;SAC5B;IACH,CAAC;IAEO,gBAAgB,CAAC,QAAiB,KAAK;QAC7C,IAAI,IAAI,CAAC,qBAAqB,KAAK,IAAI,IAAI,IAAI,CAAC,+BAA+B,KAAK,IAAI,EAAE;YACxF,IAAI,IAAI,CAAC,qBAAqB,CAAC,UAAU,KAAK,WAAW,CAAC,MAAM,EAAE;gBAChE,OAAO,CAAC,QAAQ;aACjB;SACF;QACD,IAAI,IAAI,CAAC,KAAK,KAAK,UAAU,CAAC,UAAU,IAAI,IAAI,CAAC,KAAK,KAAK,UAAU,CAAC,YAAY,EAAE;YAClF,OAAO,CAAC,qBAAqB;SAC9B;QACD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,+BAA+B,GAAG,IAAI,CAAC;QAE5C,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa;IAC5C,CAAC;IAEO,eAAe,CAAC,KAAc;QACpC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,IAAI,IAAI,CAAC,eAAe,GAAG,CAAC,EAAE;YAC5B,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,YAAY,CAAC;SACtC;aAAM;YACL,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC;SACpC;QACD,MAAM,UAAU,GAAG,IAAI,UAAU,CAA6B,QAAQ,CAAC,EAAE;YACvE,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAC1C,WAAW,CAAC,MAAM,GAAG,GAAG,EAAE;gBACxB,IAAI,CAAC,qBAAqB,GAAG,WAAW,CAAC;gBACzC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;gBACtC,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,IAAI,CAAC,oCAAoC,GAAG,CAAC,CAAC,CAAC,oBAAoB;gBACnE,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC;YACpC,CAAC,CAAC;YACF,WAAW,CAAC,SAAS,GAAG,KAAK,CAAC,EAAE;gBAC9B,QAAQ,CAAC,IAAI,CAAC;oBACZ,GAAG,KAAK;oBACR,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,mCAAmC;iBAClE,CAAC,CAAC;YACL,CAAC,CAAC;YACF,WAAW,CAAC,OAAO,GAAG,GAAG,EAAE;gBACzB,WAAW,CAAC,KAAK,EAAE,CAAC;gBACpB,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBACpB,IAAI,KAAK,EAAE;oBACT,IAAI,CAAC,oCAAoC,EAAE,CAAC;oBAC5C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,IAAI,CAAC,oCAAoC,EAAE,CAAC,CAAC;oBAChF,IAAI,IAAI,CAAC,oCAAoC,GAAG,CAAC,EAAE;wBACjD,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,2BAA2B,EAAE,KAAK,CAAC,CAAC;wBACnE,IAAI,CAAC,GAAG,CACN,kCAAkC,IAAI,CAAC,oCAAoC,UAAU,CACtF,CAAC;wBACF,OAAO;qBACR;iBACF;gBACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBACtB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAC9B,CAAC,CAAC;YACF,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,+BAA+B,GAAG,UAAU,CAAC;QAClD,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,CAAC;QAC1C,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,cAAc;QACpB,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,EAAE;YAC/B,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC;SACpC;QACD,6CAA6C;QAC7C,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,oBAAoB,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC;IACxE,CAAC;IAEO,wBAAwB,CAAC,UAAkD;QACjF,IAAI,CAAC,sBAAsB,GAAG,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YACzD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/B,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YAChD,+BAA+B;YAC/B,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAChD,4CAA4C;YAC5C,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAC5C,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE;oBAC3C,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;iBAC9B;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,mCAAmC,CAAC,KAAiC;QAC3E,IAAI,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,wBAAwB,EAAE;YACvD,OAAO;SACR;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2BAA2B,KAAK,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,cAAc,GAAI,KAAK,CAAC,IAAsC,CAAC,cAAc,CAAC;IACrF,CAAC;IAEO,GAAG,CAAC,OAAe,EAAE,GAAG,IAAS;QACvC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACzB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO;YACP,IAAI;SACL,CAAC,CAAC;IACL,CAAC;+GA7NU,UAAU;mHAAV,UAAU,cAFT,MAAM;;4FAEP,UAAU;kBAHtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable} from '@angular/core';\nimport {filter, Observable, Subject, Subscription} from 'rxjs';\nimport {\n  BaseSseEvent,\n  EstablishedConnectionSseEvent,\n  SseEventListener,\n  SseEventType,\n} from '../models/sse-events.model';\nimport {ConfigService} from '@valtimo/config';\nimport {\n  SseErrorBucket,\n  SseEventSubscriptionBucket,\n  SseSubscriptionBucket,\n} from '../models/sse-bucket.model';\nimport {NGXLogger} from 'ngx-logger';\n\n/**\n * Server-side events service, for connecting and reconnecting to SSE,\n * and a translation layer between SSE json string data and TS typed events.\n *\n * The service is always present, and so events can be registered with {@link onMessage} and {@link onEvent},\n * and will not be lost on disconnect or reconnect of the SSE connection itself.\n * It is expected to also unregister events using the off-method variants of the on-method listeners.\n *\n * To ensure messages are received the connection must be explicitly opened with {@link connect},\n * likewise the connection should also be closed with {@link disconnect} to stop receiving messages.\n *\n * This service can reconnect itself with the backend, and might use the {@link subscriptionId} to ask for its\n * previous connection state. This state currently exists in the backend as the \"Subscriber\" class, and might\n * have a state containing queues of items that need to be sent, so you can reconnect and receive the rest.\n *\n * At this time no state data is kept, so reconnection without a subscriptionId does not give a different result\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class SseService {\n  private static readonly CONNECTION_RETRIES_EXCEEDED = -1;\n  private static readonly NOT_CONNECTED = 0;\n  private static readonly CONNECTING = 1;\n  private static readonly RECONNECTING = 2;\n  private static readonly CONNECTED = 10;\n\n  private readonly VALTIMO_ENDPOINT_URL: string;\n  private connectionCount = 0; // amount of times we have connected sequentially, no concurrent connections\n  private establishedDataHandler?: Subscription = null;\n  private establishedConnection?: EventSource = null;\n  private establishedConnectionObservable: Observable<MessageEvent<BaseSseEvent>> = null;\n  private subscriptionId?: string = null;\n  private sequentialConnectionAttemptFailCount = 0;\n\n  private errorBucket = new SseErrorBucket();\n  private anySubscribersBucket = new SseSubscriptionBucket<BaseSseEvent>();\n  private eventSubscribersBuckets: SseEventSubscriptionBucket<BaseSseEvent>[] = [];\n\n  private state: number = SseService.NOT_CONNECTED;\n\n  private _sseMessages$ = new Subject<MessageEvent<BaseSseEvent>>();\n\n  get sseMessages$(): Observable<MessageEvent<BaseSseEvent>> {\n    return this._sseMessages$.asObservable().pipe(filter(message => !!message));\n  }\n\n  constructor(\n    private readonly configService: ConfigService,\n    private readonly logger: NGXLogger\n  ) {\n    this.VALTIMO_ENDPOINT_URL = configService.config.valtimoApi.endpointUri;\n    this.connect();\n  }\n\n  getSseMessagesObservableByEventType(\n    eventTypes: Array<SseEventType>\n  ): Observable<MessageEvent<BaseSseEvent>> {\n    return this._sseMessages$.asObservable().pipe(\n      filter(message => !!message),\n      filter(message => eventTypes.includes(message?.data?.eventType))\n    );\n  }\n\n  /**\n   * Start receiving SSE events\n   */\n  private connect() {\n    this.ensureConnection();\n    return this;\n  }\n\n  private onMessage(listener: SseEventListener<BaseSseEvent>) {\n    this.ensureConnection(); // ensure connection\n    this.anySubscribersBucket.on(listener);\n    return this;\n  }\n\n  private onEvent<T extends BaseSseEvent>(event: string, listener: SseEventListener<T>) {\n    this.ensureConnection(); // ensure connection\n    let found = false;\n    this.eventSubscribersBuckets.forEach(bucket => {\n      if (bucket.event === event) {\n        bucket.on(listener);\n        found = true;\n      }\n    });\n    if (!found) {\n      const bucket = new SseEventSubscriptionBucket(event);\n      bucket.on(listener);\n      this.eventSubscribersBuckets.push(bucket);\n    }\n    return this;\n  }\n\n  private offMessage(listener: SseEventListener<BaseSseEvent>) {\n    this.anySubscribersBucket.off(listener);\n  }\n\n  private offEvent(event: string, listener: SseEventListener<any>) {\n    this.eventSubscribersBuckets.forEach(bucket => {\n      if (bucket.event === event) {\n        bucket.off(listener);\n      }\n    });\n  }\n\n  private offEvents(type?: string) {\n    this.eventSubscribersBuckets.forEach(bucket => {\n      if (type === null || type === bucket.event) {\n        bucket.offAll();\n      }\n    });\n  }\n\n  private offMessages() {\n    this.anySubscribersBucket.offAll();\n  }\n\n  private offAll() {\n    this.offEvents();\n    this.offMessages();\n  }\n\n  private disconnect(keepSubscriptionId: boolean = false) {\n    this.disconnectWith(SseService.NOT_CONNECTED, keepSubscriptionId);\n  }\n\n  private disconnectWith(state: number, keepSubscriptionId: boolean = false) {\n    this.state = state;\n    if (this.establishedConnection?.readyState !== EventSource.CLOSED) {\n      this.establishedConnection?.close();\n    }\n    this.establishedDataHandler.unsubscribe();\n    this.establishedConnection = null;\n    this.establishedConnectionObservable = null;\n    this.establishedDataHandler = null;\n    if (!keepSubscriptionId) {\n      this.subscriptionId = null;\n    }\n  }\n\n  private ensureConnection(retry: boolean = false) {\n    if (this.establishedConnection !== null && this.establishedConnectionObservable !== null) {\n      if (this.establishedConnection.readyState !== EventSource.CLOSED) {\n        return; // found\n      }\n    }\n    if (this.state === SseService.CONNECTING || this.state === SseService.RECONNECTING) {\n      return; // already connecting\n    }\n    this.establishedConnection = null;\n    this.establishedConnectionObservable = null;\n\n    this.constructNewSse(retry); // create new\n  }\n\n  private constructNewSse(retry: boolean) {\n    this.logger.debug('subscribing to sse events');\n    if (this.connectionCount > 0) {\n      this.state = SseService.RECONNECTING;\n    } else {\n      this.state = SseService.CONNECTING;\n    }\n    const observable = new Observable<MessageEvent<BaseSseEvent>>(observer => {\n      const eventSource = this.getEventSource();\n      eventSource.onopen = () => {\n        this.establishedConnection = eventSource;\n        this.logger.debug('connected to sse');\n        this.connectionCount++;\n        this.sequentialConnectionAttemptFailCount = 0; // reset retry count\n        this.state = SseService.CONNECTED;\n      };\n      eventSource.onmessage = event => {\n        observer.next({\n          ...event, // forward event object but replace data field\n          data: JSON.parse(event.data), // parse JSON string to JSON object\n        });\n      };\n      eventSource.onerror = () => {\n        eventSource.close();\n        observer.complete();\n        if (retry) {\n          this.sequentialConnectionAttemptFailCount++;\n          this.logger.debug(`retry failed: ${this.sequentialConnectionAttemptFailCount}`);\n          if (this.sequentialConnectionAttemptFailCount > 3) {\n            this.disconnectWith(SseService.CONNECTION_RETRIES_EXCEEDED, false);\n            this.err(\n              `Failed to connect to SSE after ${this.sequentialConnectionAttemptFailCount} retries`\n            );\n            return;\n          }\n        }\n        this.disconnect(true);\n        this.ensureConnection(true);\n      };\n      return () => eventSource.close();\n    });\n    this.establishedConnectionObservable = observable;\n    this.registerSseEventHandling(observable);\n    return observable;\n  }\n\n  private getEventSource() {\n    let suffix = '';\n    if (this.subscriptionId != null) {\n      suffix = '/' + this.subscriptionId;\n    }\n    // subscribe to /sse or /sse/<subscriptionId>\n    return new EventSource(this.VALTIMO_ENDPOINT_URL + 'v1/sse' + suffix);\n  }\n\n  private registerSseEventHandling(observable: Observable<MessageEvent<BaseSseEvent>>) {\n    this.establishedDataHandler = observable.subscribe(event => {\n      this._sseMessages$.next(event);\n      this.internalListenerEstablishConnection(event);\n      // notify all generic listeners\n      this.anySubscribersBucket.sendEvent(event.data);\n      // notify the specific event listener bucket\n      this.eventSubscribersBuckets.forEach(bucket => {\n        if (bucket.event === event?.data?.eventType) {\n          bucket.sendEvent(event.data);\n        }\n      });\n    });\n  }\n\n  private internalListenerEstablishConnection(event: MessageEvent<BaseSseEvent>) {\n    if (event?.data?.eventType !== 'ESTABLISHED_CONNECTION') {\n      return;\n    }\n    this.logger.debug(`established connection: ${event}`);\n    this.subscriptionId = (event.data as EstablishedConnectionSseEvent).subscriptionId;\n  }\n\n  private err(message: string, ...data: any) {\n    this.errorBucket.sendEvent({\n      state: this.state,\n      message,\n      data,\n    });\n  }\n}\n"]}

package/{esm2020 → esm2022}/lib/sse.module.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,11 @@
 import { NgModule } from '@angular/core';
 import * as i0 from "@angular/core";
 export class SseModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: SseModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseModule }); }
 }
-SseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: SseModule });
-SseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
@@ -28,4 +28,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                     exports: [],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vc3NlL3NyYy9saWIvc3NlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBT3ZDLE1BQU0sT0FBTyxTQUFTOztzR0FBVCxTQUFTO3VHQUFULFNBQVM7dUdBQVQsU0FBUzsyRkFBVCxTQUFTO2tCQUxyQixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsRUFBRTtvQkFDWCxPQUFPLEVBQUUsRUFBRTtpQkFDWiIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIwIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBpbXBvcnRzOiBbXSxcbiAgZXhwb3J0czogW10sXG59KVxuZXhwb3J0IGNsYXNzIFNzZU1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3NlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vc3NlL3NyYy9saWIvc3NlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBT3ZDLE1BQU0sT0FBTyxTQUFTOytHQUFULFNBQVM7Z0hBQVQsU0FBUztnSEFBVCxTQUFTOzs0RkFBVCxTQUFTO2tCQUxyQixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsRUFBRTtvQkFDWCxPQUFPLEVBQUUsRUFBRTtpQkFDWiIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgMjAxNS0yMDIzIFJpdGVuc2UgQlYsIHRoZSBOZXRoZXJsYW5kcy5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciBFVVBMLCBWZXJzaW9uIDEuMiAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqIGh0dHBzOi8vam9pbnVwLmVjLmV1cm9wYS5ldS9jb2xsZWN0aW9uL2V1cGwvZXVwbC10ZXh0LWV1cGwtMTJcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgYmFzaXMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBpbXBvcnRzOiBbXSxcbiAgZXhwb3J0czogW10sXG59KVxuZXhwb3J0IGNsYXNzIFNzZU1vZHVsZSB7fVxuIl19

package/{esm2020 → esm2022}/public-api.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,4 +19,4 @@
 export * from './lib/models';
 export * from './lib/services';
 export * from './lib/sse.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vc3NlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUg7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHNzZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zc2UubW9kdWxlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vc3NlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUg7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHNzZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zc2UubW9kdWxlJztcbiJdfQ==

package/{fesm2020 → fesm2022}/valtimo-sse.mjs

@@ -1,11 +1,11 @@
 import * as i0 from '@angular/core';
 import { Injectable, NgModule } from '@angular/core';
-import { Subject, filter, Observable } from 'rxjs';
+import { filter, Subject, Observable } from 'rxjs';
 import * as i1 from '@valtimo/config';
 import * as i2 from 'ngx-logger';
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -53,7 +53,7 @@ class SseEventSubscriptionBucket extends SseSubscriptionBucket {
 }
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -69,7 +69,7 @@ class SseEventSubscriptionBucket extends SseSubscriptionBucket {
  */
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -85,7 +85,7 @@ class SseEventSubscriptionBucket extends SseSubscriptionBucket {
  */
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -117,6 +117,14 @@ class SseEventSubscriptionBucket extends SseSubscriptionBucket {
  * At this time no state data is kept, so reconnection without a subscriptionId does not give a different result
  */
 class SseService {
+    static { this.CONNECTION_RETRIES_EXCEEDED = -1; }
+    static { this.NOT_CONNECTED = 0; }
+    static { this.CONNECTING = 1; }
+    static { this.RECONNECTING = 2; }
+    static { this.CONNECTED = 10; }
+    get sseMessages$() {
+        return this._sseMessages$.asObservable().pipe(filter(message => !!message));
+    }
     constructor(configService, logger) {
         this.configService = configService;
         this.logger = logger;
@@ -134,9 +142,6 @@ class SseService {
         this.VALTIMO_ENDPOINT_URL = configService.config.valtimoApi.endpointUri;
         this.connect();
     }
-    get sseMessages$() {
-        return this._sseMessages$.asObservable().pipe(filter(message => !!message));
-    }
     getSseMessagesObservableByEventType(eventTypes) {
         return this._sseMessages$.asObservable().pipe(filter(message => !!message), filter(message => eventTypes.includes(message?.data?.eventType)));
     }
@@ -301,15 +306,10 @@ class SseService {
             data,
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseService, deps: [{ token: i1.ConfigService }, { token: i2.NGXLogger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseService, providedIn: 'root' }); }
 }
-SseService.CONNECTION_RETRIES_EXCEEDED = -1;
-SseService.NOT_CONNECTED = 0;
-SseService.CONNECTING = 1;
-SseService.RECONNECTING = 2;
-SseService.CONNECTED = 10;
-SseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseService, deps: [{ token: i1.ConfigService }, { token: i2.NGXLogger }], target: i0.ɵɵFactoryTarget.Injectable });
-SseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -317,7 +317,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
         }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.NGXLogger }]; } });
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -333,7 +333,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
  */
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -348,11 +348,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
  * limitations under the License.
  */
 class SseModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: SseModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseModule }); }
 }
-SseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: SseModule });
-SseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SseModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SseModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
@@ -362,7 +362,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
         }] });
 
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -376,6 +376,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/*
+ * Public API Surface of sse
+ */
 
 /**
  * Generated bundle index. Do not edit.

package/fesm2022/valtimo-sse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valtimo-sse.mjs","sources":["../../../../projects/valtimo/sse/src/lib/models/sse-bucket.model.ts","../../../../projects/valtimo/sse/src/lib/models/sse-events.model.ts","../../../../projects/valtimo/sse/src/lib/models/index.ts","../../../../projects/valtimo/sse/src/lib/services/sse.service.ts","../../../../projects/valtimo/sse/src/lib/services/index.ts","../../../../projects/valtimo/sse/src/lib/sse.module.ts","../../../../projects/valtimo/sse/src/public-api.ts","../../../../projects/valtimo/sse/src/valtimo-sse.ts"],"sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// generic bucket for listeners of any type\nimport {BaseSseEvent, SseError, SseEventListener} from './sse-events.model';\n\nexport class SseSubscriptionBucket<T> {\n  readonly listeners: SseEventListener<T>[] = [];\n\n  on(listener: SseEventListener<T>) {\n    this.listeners.push(listener);\n  }\n\n  off(listener: SseEventListener<T>) {\n    const index = this.listeners.indexOf(listener);\n    if (index > -1) {\n      this.listeners.splice(index, 1);\n    }\n  }\n\n  offAll() {\n    this.listeners.length = 0;\n  }\n\n  sendEvent(event: T) {\n    this.listeners.forEach(listener => {\n      listener(event);\n    });\n  }\n}\n\n// error bucket for error listeners\nexport class SseErrorBucket extends SseSubscriptionBucket<SseError> {}\n\n// implicit type bucket with event for filtering\nexport class SseEventSubscriptionBucket<T extends BaseSseEvent> extends SseSubscriptionBucket<T> {\n  readonly event: string;\n\n  constructor(event: string) {\n    super();\n    this.event = event;\n  }\n}\n","/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\ntype SseEventType =\n  | 'CASE_CREATED'\n  | 'TASK_UPDATE'\n  | 'PROCESS_END'\n  | 'CASE_ASSIGNED'\n  | 'CASE_UNASSIGNED'\n  | 'ESTABLISHED_CONNECTION';\n\ntype SseEventListener<T> = (event: T) => void;\n\n// base event containing the event type\ninterface BaseSseEvent {\n  eventType?: SseEventType;\n  processInstanceId?: string;\n}\n\n// event implementations for json mapping objects in:\ninterface TaskUpdateSseEvent extends BaseSseEvent {\n  processInstanceId: string;\n}\n\ninterface EstablishedConnectionSseEvent extends BaseSseEvent {\n  subscriptionId: string;\n}\n\ninterface SseError {\n  state: number;\n  message: string;\n  data?: any;\n}\n\nexport {\n  SseError,\n  EstablishedConnectionSseEvent,\n  TaskUpdateSseEvent,\n  BaseSseEvent,\n  SseEventListener,\n  SseEventType,\n};\n","/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport * from './sse-bucket.model';\nexport * from './sse-events.model';\n","/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable} from '@angular/core';\nimport {filter, Observable, Subject, Subscription} from 'rxjs';\nimport {\n  BaseSseEvent,\n  EstablishedConnectionSseEvent,\n  SseEventListener,\n  SseEventType,\n} from '../models/sse-events.model';\nimport {ConfigService} from '@valtimo/config';\nimport {\n  SseErrorBucket,\n  SseEventSubscriptionBucket,\n  SseSubscriptionBucket,\n} from '../models/sse-bucket.model';\nimport {NGXLogger} from 'ngx-logger';\n\n/**\n * Server-side events service, for connecting and reconnecting to SSE,\n * and a translation layer between SSE json string data and TS typed events.\n *\n * The service is always present, and so events can be registered with {@link onMessage} and {@link onEvent},\n * and will not be lost on disconnect or reconnect of the SSE connection itself.\n * It is expected to also unregister events using the off-method variants of the on-method listeners.\n *\n * To ensure messages are received the connection must be explicitly opened with {@link connect},\n * likewise the connection should also be closed with {@link disconnect} to stop receiving messages.\n *\n * This service can reconnect itself with the backend, and might use the {@link subscriptionId} to ask for its\n * previous connection state. This state currently exists in the backend as the \"Subscriber\" class, and might\n * have a state containing queues of items that need to be sent, so you can reconnect and receive the rest.\n *\n * At this time no state data is kept, so reconnection without a subscriptionId does not give a different result\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class SseService {\n  private static readonly CONNECTION_RETRIES_EXCEEDED = -1;\n  private static readonly NOT_CONNECTED = 0;\n  private static readonly CONNECTING = 1;\n  private static readonly RECONNECTING = 2;\n  private static readonly CONNECTED = 10;\n\n  private readonly VALTIMO_ENDPOINT_URL: string;\n  private connectionCount = 0; // amount of times we have connected sequentially, no concurrent connections\n  private establishedDataHandler?: Subscription = null;\n  private establishedConnection?: EventSource = null;\n  private establishedConnectionObservable: Observable<MessageEvent<BaseSseEvent>> = null;\n  private subscriptionId?: string = null;\n  private sequentialConnectionAttemptFailCount = 0;\n\n  private errorBucket = new SseErrorBucket();\n  private anySubscribersBucket = new SseSubscriptionBucket<BaseSseEvent>();\n  private eventSubscribersBuckets: SseEventSubscriptionBucket<BaseSseEvent>[] = [];\n\n  private state: number = SseService.NOT_CONNECTED;\n\n  private _sseMessages$ = new Subject<MessageEvent<BaseSseEvent>>();\n\n  get sseMessages$(): Observable<MessageEvent<BaseSseEvent>> {\n    return this._sseMessages$.asObservable().pipe(filter(message => !!message));\n  }\n\n  constructor(\n    private readonly configService: ConfigService,\n    private readonly logger: NGXLogger\n  ) {\n    this.VALTIMO_ENDPOINT_URL = configService.config.valtimoApi.endpointUri;\n    this.connect();\n  }\n\n  getSseMessagesObservableByEventType(\n    eventTypes: Array<SseEventType>\n  ): Observable<MessageEvent<BaseSseEvent>> {\n    return this._sseMessages$.asObservable().pipe(\n      filter(message => !!message),\n      filter(message => eventTypes.includes(message?.data?.eventType))\n    );\n  }\n\n  /**\n   * Start receiving SSE events\n   */\n  private connect() {\n    this.ensureConnection();\n    return this;\n  }\n\n  private onMessage(listener: SseEventListener<BaseSseEvent>) {\n    this.ensureConnection(); // ensure connection\n    this.anySubscribersBucket.on(listener);\n    return this;\n  }\n\n  private onEvent<T extends BaseSseEvent>(event: string, listener: SseEventListener<T>) {\n    this.ensureConnection(); // ensure connection\n    let found = false;\n    this.eventSubscribersBuckets.forEach(bucket => {\n      if (bucket.event === event) {\n        bucket.on(listener);\n        found = true;\n      }\n    });\n    if (!found) {\n      const bucket = new SseEventSubscriptionBucket(event);\n      bucket.on(listener);\n      this.eventSubscribersBuckets.push(bucket);\n    }\n    return this;\n  }\n\n  private offMessage(listener: SseEventListener<BaseSseEvent>) {\n    this.anySubscribersBucket.off(listener);\n  }\n\n  private offEvent(event: string, listener: SseEventListener<any>) {\n    this.eventSubscribersBuckets.forEach(bucket => {\n      if (bucket.event === event) {\n        bucket.off(listener);\n      }\n    });\n  }\n\n  private offEvents(type?: string) {\n    this.eventSubscribersBuckets.forEach(bucket => {\n      if (type === null || type === bucket.event) {\n        bucket.offAll();\n      }\n    });\n  }\n\n  private offMessages() {\n    this.anySubscribersBucket.offAll();\n  }\n\n  private offAll() {\n    this.offEvents();\n    this.offMessages();\n  }\n\n  private disconnect(keepSubscriptionId: boolean = false) {\n    this.disconnectWith(SseService.NOT_CONNECTED, keepSubscriptionId);\n  }\n\n  private disconnectWith(state: number, keepSubscriptionId: boolean = false) {\n    this.state = state;\n    if (this.establishedConnection?.readyState !== EventSource.CLOSED) {\n      this.establishedConnection?.close();\n    }\n    this.establishedDataHandler.unsubscribe();\n    this.establishedConnection = null;\n    this.establishedConnectionObservable = null;\n    this.establishedDataHandler = null;\n    if (!keepSubscriptionId) {\n      this.subscriptionId = null;\n    }\n  }\n\n  private ensureConnection(retry: boolean = false) {\n    if (this.establishedConnection !== null && this.establishedConnectionObservable !== null) {\n      if (this.establishedConnection.readyState !== EventSource.CLOSED) {\n        return; // found\n      }\n    }\n    if (this.state === SseService.CONNECTING || this.state === SseService.RECONNECTING) {\n      return; // already connecting\n    }\n    this.establishedConnection = null;\n    this.establishedConnectionObservable = null;\n\n    this.constructNewSse(retry); // create new\n  }\n\n  private constructNewSse(retry: boolean) {\n    this.logger.debug('subscribing to sse events');\n    if (this.connectionCount > 0) {\n      this.state = SseService.RECONNECTING;\n    } else {\n      this.state = SseService.CONNECTING;\n    }\n    const observable = new Observable<MessageEvent<BaseSseEvent>>(observer => {\n      const eventSource = this.getEventSource();\n      eventSource.onopen = () => {\n        this.establishedConnection = eventSource;\n        this.logger.debug('connected to sse');\n        this.connectionCount++;\n        this.sequentialConnectionAttemptFailCount = 0; // reset retry count\n        this.state = SseService.CONNECTED;\n      };\n      eventSource.onmessage = event => {\n        observer.next({\n          ...event, // forward event object but replace data field\n          data: JSON.parse(event.data), // parse JSON string to JSON object\n        });\n      };\n      eventSource.onerror = () => {\n        eventSource.close();\n        observer.complete();\n        if (retry) {\n          this.sequentialConnectionAttemptFailCount++;\n          this.logger.debug(`retry failed: ${this.sequentialConnectionAttemptFailCount}`);\n          if (this.sequentialConnectionAttemptFailCount > 3) {\n            this.disconnectWith(SseService.CONNECTION_RETRIES_EXCEEDED, false);\n            this.err(\n              `Failed to connect to SSE after ${this.sequentialConnectionAttemptFailCount} retries`\n            );\n            return;\n          }\n        }\n        this.disconnect(true);\n        this.ensureConnection(true);\n      };\n      return () => eventSource.close();\n    });\n    this.establishedConnectionObservable = observable;\n    this.registerSseEventHandling(observable);\n    return observable;\n  }\n\n  private getEventSource() {\n    let suffix = '';\n    if (this.subscriptionId != null) {\n      suffix = '/' + this.subscriptionId;\n    }\n    // subscribe to /sse or /sse/<subscriptionId>\n    return new EventSource(this.VALTIMO_ENDPOINT_URL + 'v1/sse' + suffix);\n  }\n\n  private registerSseEventHandling(observable: Observable<MessageEvent<BaseSseEvent>>) {\n    this.establishedDataHandler = observable.subscribe(event => {\n      this._sseMessages$.next(event);\n      this.internalListenerEstablishConnection(event);\n      // notify all generic listeners\n      this.anySubscribersBucket.sendEvent(event.data);\n      // notify the specific event listener bucket\n      this.eventSubscribersBuckets.forEach(bucket => {\n        if (bucket.event === event?.data?.eventType) {\n          bucket.sendEvent(event.data);\n        }\n      });\n    });\n  }\n\n  private internalListenerEstablishConnection(event: MessageEvent<BaseSseEvent>) {\n    if (event?.data?.eventType !== 'ESTABLISHED_CONNECTION') {\n      return;\n    }\n    this.logger.debug(`established connection: ${event}`);\n    this.subscriptionId = (event.data as EstablishedConnectionSseEvent).subscriptionId;\n  }\n\n  private err(message: string, ...data: any) {\n    this.errorBucket.sendEvent({\n      state: this.state,\n      message,\n      data,\n    });\n  }\n}\n","/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport * from './sse.service';\n","/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {NgModule} from '@angular/core';\n\n@NgModule({\n  declarations: [],\n  imports: [],\n  exports: [],\n})\nexport class SseModule {}\n","/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*\n * Public API Surface of sse\n */\n\nexport * from './lib/models';\nexport * from './lib/services';\nexport * from './lib/sse.module';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/lib/models/sse-events.model.d.ts

@@ -1,5 +1,5 @@
-declare type SseEventType = 'CASE_CREATED' | 'TASK_UPDATE' | 'PROCESS_END' | 'CASE_ASSIGNED' | 'CASE_UNASSIGNED' | 'ESTABLISHED_CONNECTION';
-declare type SseEventListener<T> = (event: T) => void;
+type SseEventType = 'CASE_CREATED' | 'TASK_UPDATE' | 'PROCESS_END' | 'CASE_ASSIGNED' | 'CASE_UNASSIGNED' | 'ESTABLISHED_CONNECTION';
+type SseEventListener<T> = (event: T) => void;
 interface BaseSseEvent {
     eventType?: SseEventType;
     processInstanceId?: string;