@quadrel-enterprise-ui/framework 18.23.2 → 18.24.0

package/esm2022/lib/core/services/push-events.service.mjs

@@ -1,4 +1,5 @@
-import { Injectable } from '@angular/core';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { EventSourcePolyfill } from 'event-source-polyfill';
 import { NEVER, Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 /**
@@ -9,12 +10,15 @@ import * as i0 from "@angular/core";
  * - **Real-Time Interaction**: Enables live updates without user actions or polling.
  * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.
  * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.
+ * - **Authorization**: It uses the user's authentication (QdAuth) to secure the connection against the backend out-of-the-box. This requires a proper QdAuth setup. You can disable this feature when starting the connection.
  *
  * ### Usage
  *
  * ```ts
  * // Start the connection to the events
  * pushEventsService.connect('http://service-endpint/events');
+ * // or start without authentication in case you don't need:
+ * pushEventsService.connect('http://service-endpint/events', { disableAuthentication: true });
  *
  * // Subscribe to the event (Side Effect)
  * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));
@@ -27,37 +31,47 @@ import * as i0 from "@angular/core";
  * ```
  */
 export class QdPushEventsService {
+    authenticationService;
     _eventSource;
     _eventSubscriptionSubjects = new Map();
     _listeners = [];
     _heartbeatTimeout;
     _reconnectDelayTime = 10000;
     _heartbeatReconnectDelayTime = 100;
+    _accessTokenSub;
+    _options;
+    constructor(authenticationService) {
+        this.authenticationService = authenticationService;
+    }
     /**
      * Establishes an EventSource connection to the given URL.
      * Automatically reconnects if heartbeat fails or is delayed.
      * Subscribers are retained across reconnections.
      *
      * @param url The backend URL for the event stream.
+     * @param options Options for the connection
      */
-    connect(url) {
+    connect(url, options) {
         if (this.isConnectedOrConnecting())
             return;
-        if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED)
-            this._eventSource = new EventSource(url);
-        this._eventSource.onerror = (err) => {
-            if (this._eventSource.readyState === EventSource.CLOSED)
-                this.reconnect();
-            this.logError('SSE connection error:', err);
-        };
-        this._eventSource.addEventListener('HEARTBEAT', message => {
-            if (this._heartbeatTimeout)
-                clearTimeout(this._heartbeatTimeout);
-            const interval = JSON.parse(message.data).interval;
-            this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);
-        });
-        this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);
-        this.addEventListenersForExistingSubscriptions();
+        if (!options?.disableAuthentication) {
+            if (!this.authenticationService) {
+                this.logError("Can't connect to SSE without QdAuth as the connection has to be secured. Please install QdAuth or disable authentication when connecting.");
+                return;
+            }
+            if (this._accessTokenSub)
+                this._accessTokenSub.unsubscribe();
+            this._accessTokenSub = this.authenticationService.accessToken$.subscribe((token) => {
+                this._options = { url, options };
+                this.connectEventSource(url, {
+                    headers: { Authorization: `Bearer ${token}` }
+                }, true);
+            });
+        }
+        else {
+            this._options = { url, options };
+            this.connectEventSource(url);
+        }
     }
     /**
      * Closes the EventSource connection and clears all listeners.
@@ -106,10 +120,10 @@ export class QdPushEventsService {
             (this._eventSource.readyState === EventSource.OPEN || this._eventSource.readyState === EventSource.CONNECTING));
     }
     reconnect() {
-        if (!this.isConnectedOrConnecting()) {
-            this.disconnect();
-            this.connect(this._eventSource.url);
-        }
+        if (this.isConnectedOrConnecting())
+            return;
+        this.disconnect();
+        this.connect(this._options.url, this._options.options);
     }
     addEventListenerForEventName(eventName) {
         const callback = (messageEvent) => {
@@ -141,7 +155,26 @@ export class QdPushEventsService {
     logError(message, err) {
         console.error(`QD-UI | QdPushEventsService - ${message}`, err);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    connectEventSource(url, options = {}, reconnect) {
+        if (this._eventSource && this._eventSource.readyState !== EventSource.CLOSED)
+            this._eventSource.close();
+        if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED || reconnect)
+            this._eventSource = new EventSourcePolyfill(url, options);
+        this._eventSource.onerror = (err) => {
+            if (this._eventSource.readyState === EventSource.CLOSED)
+                this.reconnect();
+            this.logError('SSE connection error:', err);
+        };
+        this._eventSource.addEventListener('HEARTBEAT', (message) => {
+            if (this._heartbeatTimeout)
+                clearTimeout(this._heartbeatTimeout);
+            const interval = JSON.parse(message.data).interval;
+            this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);
+        });
+        this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);
+        this.addEventListenersForExistingSubscriptions();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, deps: [{ token: 'QdAuthenticationService', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, decorators: [{
@@ -149,5 +182,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"push-events.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/core/services/push-events.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { NEVER, Observable, Subject } from 'rxjs';\n\nexport type EventName = 'RESOURCE_CREATED' | 'RESOURCE_UPDATED' | 'RESOURCE_DELETED';\n\n/**\n * Service for handling real-time server-sent events.\n *\n * ### Benefits\n *\n * - **Real-Time Interaction**: Enables live updates without user actions or polling.\n * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.\n * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.\n *\n * ### Usage\n *\n * ```ts\n * // Start the connection to the events\n * pushEventsService.connect('http://service-endpint/events');\n *\n * // Subscribe to the event (Side Effect)\n * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));\n *\n * // Unsubscribe to prevent memory leaks\n * subscription.unsubscribe();\n *\n * // Disconnect the connection\n * pushEventsService.disconnect();\n * ```\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class QdPushEventsService {\n  private _eventSource!: EventSource;\n  private _eventSubscriptionSubjects = new Map<string, Subject<MessageEvent>>();\n  private _listeners: [string, (message: MessageEvent) => void][] = [];\n  private _heartbeatTimeout!: ReturnType<typeof setTimeout>;\n  private _reconnectDelayTime = 10000;\n  private _heartbeatReconnectDelayTime = 100;\n\n  /**\n   * Establishes an EventSource connection to the given URL.\n   * Automatically reconnects if heartbeat fails or is delayed.\n   * Subscribers are retained across reconnections.\n   *\n   * @param url The backend URL for the event stream.\n   */\n  connect(url: string): void {\n    if (this.isConnectedOrConnecting()) return;\n\n    if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED)\n      this._eventSource = new EventSource(url);\n\n    this._eventSource.onerror = (err: Event): void => {\n      if (this._eventSource.readyState === EventSource.CLOSED) this.reconnect();\n\n      this.logError('SSE connection error:', err);\n    };\n\n    this._eventSource.addEventListener('HEARTBEAT', message => {\n      if (this._heartbeatTimeout) clearTimeout(this._heartbeatTimeout);\n\n      const interval = JSON.parse(message.data).interval;\n\n      this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);\n    });\n\n    this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);\n\n    this.addEventListenersForExistingSubscriptions();\n  }\n\n  /**\n   * Closes the EventSource connection and clears all listeners.\n   * Subscribers are preserved for reconnection.\n   */\n  disconnect(): void {\n    if (!this._eventSource) {\n      this.logWarn('No active connection to disconnect.');\n\n      return;\n    }\n\n    this.removeAllEventListenersFromEventSource();\n\n    this._eventSource.close();\n  }\n\n  /**\n   * Returns an Observable for the specified event name.\n   * If not connected, returns `NEVER` and logs an error.\n   * Automatically adds a listener for the event if needed.\n   *\n   * @param eventName The event type ('RESOURCE_CREATED', 'RESOURCE_UPDATED', 'RESOURCE_DELETED').\n   * @returns Observable<MessageEvent> The event stream.\n   */\n  observe(eventName: EventName): Observable<MessageEvent> {\n    if (!this._eventSource) {\n      this.logError('Cannot observe events without a connection. Call connect() first.');\n\n      return NEVER;\n    }\n\n    if (!this._eventSubscriptionSubjects.has(eventName)) {\n      this._eventSubscriptionSubjects.set(eventName, new Subject<MessageEvent>());\n\n      this.addEventListenerForEventName(eventName);\n    }\n\n    return this._eventSubscriptionSubjects.get(eventName)!.asObservable();\n  }\n\n  /**\n   * Removes all listeners and clears all subscriptions.\n   * The EventSource connection remains open.\n   */\n  unobserveAll(): void {\n    this.removeAllEventListenersFromEventSource();\n    this._eventSubscriptionSubjects.clear();\n  }\n\n  /**\n   * Checks if the EventSource is connected or in the process of connecting.\n   */\n  isConnectedOrConnecting(): boolean {\n    return (\n      this._eventSource &&\n      (this._eventSource.readyState === EventSource.OPEN || this._eventSource.readyState === EventSource.CONNECTING)\n    );\n  }\n\n  private reconnect(): void {\n    if (!this.isConnectedOrConnecting()) {\n      this.disconnect();\n      this.connect(this._eventSource.url);\n    }\n  }\n\n  private addEventListenerForEventName(eventName: EventName): void {\n    const callback = (messageEvent: MessageEvent): void => {\n      const subject = this._eventSubscriptionSubjects.get(eventName);\n\n      if (subject) subject.next(messageEvent);\n    };\n\n    this._eventSource.addEventListener(eventName, callback);\n    this._listeners.push([eventName, callback]);\n  }\n\n  private addEventListenersForExistingSubscriptions(): void {\n    this._eventSubscriptionSubjects.forEach((subject, eventName) =>\n      this.addEventListenerToEventSource(eventName as EventName, (messageEvent: MessageEvent) =>\n        subject.next(messageEvent)\n      )\n    );\n  }\n\n  private addEventListenerToEventSource(eventName: EventName, callback: (messageEvent: MessageEvent) => void): void {\n    this._eventSource.addEventListener(eventName, callback);\n    this._listeners.push([eventName, callback]);\n  }\n\n  private removeAllEventListenersFromEventSource(): void {\n    if (!this._eventSource) {\n      this.logWarn('Cannot remove listeners: No active connection.');\n\n      return;\n    }\n\n    this._listeners.forEach(([eventName, callback]) => this._eventSource.removeEventListener(eventName, callback));\n    this._listeners = [];\n  }\n\n  private logWarn(message: string): void {\n    console.warn(`QD-UI | QdPushEventsService - ${message}`);\n  }\n\n  private logError(message: string, err?: Event): void {\n    console.error(`QD-UI | QdPushEventsService - ${message}`, err);\n  }\n}\n"]}
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['QdAuthenticationService']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"push-events.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/core/services/push-events.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { EventSourcePolyfill } from 'event-source-polyfill';\nimport { NEVER, Observable, Subject, Subscription } from 'rxjs';\n\nexport type EventName = 'RESOURCE_CREATED' | 'RESOURCE_UPDATED' | 'RESOURCE_DELETED';\n\n/**\n * Service for handling real-time server-sent events.\n *\n * ### Benefits\n *\n * - **Real-Time Interaction**: Enables live updates without user actions or polling.\n * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.\n * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.\n * - **Authorization**: It uses the user's authentication (QdAuth) to secure the connection against the backend out-of-the-box. This requires a proper QdAuth setup. You can disable this feature when starting the connection.\n *\n * ### Usage\n *\n * ```ts\n * // Start the connection to the events\n * pushEventsService.connect('http://service-endpint/events');\n * // or start without authentication in case you don't need:\n * pushEventsService.connect('http://service-endpint/events', { disableAuthentication: true });\n *\n * // Subscribe to the event (Side Effect)\n * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));\n *\n * // Unsubscribe to prevent memory leaks\n * subscription.unsubscribe();\n *\n * // Disconnect the connection\n * pushEventsService.disconnect();\n * ```\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class QdPushEventsService {\n  private _eventSource!: EventSource;\n  private _eventSubscriptionSubjects = new Map<string, Subject<MessageEvent>>();\n  private _listeners: [string, (message: MessageEvent) => void][] = [];\n  private _heartbeatTimeout!: ReturnType<typeof setTimeout>;\n  private _reconnectDelayTime = 10000;\n  private _heartbeatReconnectDelayTime = 100;\n  private _accessTokenSub?: Subscription;\n  private _options!: { url: string; options?: { disableAuthentication: boolean } };\n\n  constructor(@Optional() @Inject('QdAuthenticationService') private readonly authenticationService: any) {}\n\n  /**\n   * Establishes an EventSource connection to the given URL.\n   * Automatically reconnects if heartbeat fails or is delayed.\n   * Subscribers are retained across reconnections.\n   *\n   * @param url The backend URL for the event stream.\n   * @param options Options for the connection\n   */\n  connect(url: string, options?: { disableAuthentication: boolean }): void {\n    if (this.isConnectedOrConnecting()) return;\n\n    if (!options?.disableAuthentication) {\n      if (!this.authenticationService) {\n        this.logError(\n          \"Can't connect to SSE without QdAuth as the connection has to be secured. Please install QdAuth or disable authentication when connecting.\"\n        );\n\n        return;\n      }\n\n      if (this._accessTokenSub) this._accessTokenSub.unsubscribe();\n\n      this._accessTokenSub = this.authenticationService.accessToken$.subscribe((token: string) => {\n        this._options = { url, options };\n        this.connectEventSource(\n          url,\n          {\n            headers: { Authorization: `Bearer ${token}` }\n          },\n          true\n        );\n      });\n    } else {\n      this._options = { url, options };\n      this.connectEventSource(url);\n    }\n  }\n\n  /**\n   * Closes the EventSource connection and clears all listeners.\n   * Subscribers are preserved for reconnection.\n   */\n  disconnect(): void {\n    if (!this._eventSource) {\n      this.logWarn('No active connection to disconnect.');\n\n      return;\n    }\n\n    this.removeAllEventListenersFromEventSource();\n\n    this._eventSource.close();\n  }\n\n  /**\n   * Returns an Observable for the specified event name.\n   * If not connected, returns `NEVER` and logs an error.\n   * Automatically adds a listener for the event if needed.\n   *\n   * @param eventName The event type ('RESOURCE_CREATED', 'RESOURCE_UPDATED', 'RESOURCE_DELETED').\n   * @returns Observable<MessageEvent> The event stream.\n   */\n  observe(eventName: EventName): Observable<MessageEvent> {\n    if (!this._eventSource) {\n      this.logError('Cannot observe events without a connection. Call connect() first.');\n\n      return NEVER;\n    }\n\n    if (!this._eventSubscriptionSubjects.has(eventName)) {\n      this._eventSubscriptionSubjects.set(eventName, new Subject<MessageEvent>());\n\n      this.addEventListenerForEventName(eventName);\n    }\n\n    return this._eventSubscriptionSubjects.get(eventName)!.asObservable();\n  }\n\n  /**\n   * Removes all listeners and clears all subscriptions.\n   * The EventSource connection remains open.\n   */\n  unobserveAll(): void {\n    this.removeAllEventListenersFromEventSource();\n    this._eventSubscriptionSubjects.clear();\n  }\n\n  /**\n   * Checks if the EventSource is connected or in the process of connecting.\n   */\n  isConnectedOrConnecting(): boolean {\n    return (\n      this._eventSource &&\n      (this._eventSource.readyState === EventSource.OPEN || this._eventSource.readyState === EventSource.CONNECTING)\n    );\n  }\n\n  private reconnect(): void {\n    if (this.isConnectedOrConnecting()) return;\n\n    this.disconnect();\n    this.connect(this._options.url, this._options.options);\n  }\n\n  private addEventListenerForEventName(eventName: EventName): void {\n    const callback = (messageEvent: MessageEvent): void => {\n      const subject = this._eventSubscriptionSubjects.get(eventName);\n\n      if (subject) subject.next(messageEvent);\n    };\n\n    this._eventSource.addEventListener(eventName, callback);\n    this._listeners.push([eventName, callback]);\n  }\n\n  private addEventListenersForExistingSubscriptions(): void {\n    this._eventSubscriptionSubjects.forEach((subject, eventName) =>\n      this.addEventListenerToEventSource(eventName as EventName, (messageEvent: MessageEvent) =>\n        subject.next(messageEvent)\n      )\n    );\n  }\n\n  private addEventListenerToEventSource(eventName: EventName, callback: (messageEvent: MessageEvent) => void): void {\n    this._eventSource.addEventListener(eventName, callback);\n    this._listeners.push([eventName, callback]);\n  }\n\n  private removeAllEventListenersFromEventSource(): void {\n    if (!this._eventSource) {\n      this.logWarn('Cannot remove listeners: No active connection.');\n\n      return;\n    }\n\n    this._listeners.forEach(([eventName, callback]) => this._eventSource.removeEventListener(eventName, callback));\n    this._listeners = [];\n  }\n\n  private logWarn(message: string): void {\n    console.warn(`QD-UI | QdPushEventsService - ${message}`);\n  }\n\n  private logError(message: string, err?: Event): void {\n    console.error(`QD-UI | QdPushEventsService - ${message}`, err);\n  }\n\n  private connectEventSource(url: string, options: unknown = {}, reconnect?: boolean): void {\n    if (this._eventSource && this._eventSource.readyState !== EventSource.CLOSED) this._eventSource.close();\n\n    if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED || reconnect)\n      this._eventSource = new EventSourcePolyfill(url, options);\n\n    this._eventSource.onerror = (err: Event): void => {\n      if (this._eventSource.readyState === EventSource.CLOSED) this.reconnect();\n\n      this.logError('SSE connection error:', err);\n    };\n\n    this._eventSource.addEventListener('HEARTBEAT', (message: MessageEvent) => {\n      if (this._heartbeatTimeout) clearTimeout(this._heartbeatTimeout);\n\n      const interval = JSON.parse(message.data).interval;\n      this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);\n    });\n\n    this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);\n\n    this.addEventListenersForExistingSubscriptions();\n  }\n}\n"]}

package/fesm2022/quadrel-enterprise-ui-framework.mjs

@@ -21,6 +21,7 @@ import { ComponentPortal } from '@angular/cdk/portal';
 import * as i1$5 from '@angular/cdk/overlay';
 import { OverlayModule } from '@angular/cdk/overlay';
 import isNumber from 'lodash/isNumber';
+import { EventSourcePolyfill } from 'event-source-polyfill';
 import * as i1$6 from '@angular/platform-browser';
 import * as i4 from 'ngx-editor';
 import { Editor, NgxEditorModule } from 'ngx-editor';
@@ -8109,12 +8110,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
  * - **Real-Time Interaction**: Enables live updates without user actions or polling.
  * - **Scalable and Flexible**: The system is flexible and easily expandable to handle new events.
  * - **Consistency**: Ensures synchronization between server and client states for a consistent user experience.
+ * - **Authorization**: It uses the user's authentication (QdAuth) to secure the connection against the backend out-of-the-box. This requires a proper QdAuth setup. You can disable this feature when starting the connection.
  *
  * ### Usage
  *
  * ```ts
  * // Start the connection to the events
  * pushEventsService.connect('http://service-endpint/events');
+ * // or start without authentication in case you don't need:
+ * pushEventsService.connect('http://service-endpint/events', { disableAuthentication: true });
  *
  * // Subscribe to the event (Side Effect)
  * const subscription = pushEventsService.observe('RESOURCE_UPDATED').subscribe(event => handleEvent(event));
@@ -8127,37 +8131,47 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
  * ```
  */
 class QdPushEventsService {
+    authenticationService;
     _eventSource;
     _eventSubscriptionSubjects = new Map();
     _listeners = [];
     _heartbeatTimeout;
     _reconnectDelayTime = 10000;
     _heartbeatReconnectDelayTime = 100;
+    _accessTokenSub;
+    _options;
+    constructor(authenticationService) {
+        this.authenticationService = authenticationService;
+    }
     /**
      * Establishes an EventSource connection to the given URL.
      * Automatically reconnects if heartbeat fails or is delayed.
      * Subscribers are retained across reconnections.
      *
      * @param url The backend URL for the event stream.
+     * @param options Options for the connection
      */
-    connect(url) {
+    connect(url, options) {
         if (this.isConnectedOrConnecting())
             return;
-        if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED)
-            this._eventSource = new EventSource(url);
-        this._eventSource.onerror = (err) => {
-            if (this._eventSource.readyState === EventSource.CLOSED)
-                this.reconnect();
-            this.logError('SSE connection error:', err);
-        };
-        this._eventSource.addEventListener('HEARTBEAT', message => {
-            if (this._heartbeatTimeout)
-                clearTimeout(this._heartbeatTimeout);
-            const interval = JSON.parse(message.data).interval;
-            this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);
-        });
-        this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);
-        this.addEventListenersForExistingSubscriptions();
+        if (!options?.disableAuthentication) {
+            if (!this.authenticationService) {
+                this.logError("Can't connect to SSE without QdAuth as the connection has to be secured. Please install QdAuth or disable authentication when connecting.");
+                return;
+            }
+            if (this._accessTokenSub)
+                this._accessTokenSub.unsubscribe();
+            this._accessTokenSub = this.authenticationService.accessToken$.subscribe((token) => {
+                this._options = { url, options };
+                this.connectEventSource(url, {
+                    headers: { Authorization: `Bearer ${token}` }
+                }, true);
+            });
+        }
+        else {
+            this._options = { url, options };
+            this.connectEventSource(url);
+        }
     }
     /**
      * Closes the EventSource connection and clears all listeners.
@@ -8206,10 +8220,10 @@ class QdPushEventsService {
             (this._eventSource.readyState === EventSource.OPEN || this._eventSource.readyState === EventSource.CONNECTING));
     }
     reconnect() {
-        if (!this.isConnectedOrConnecting()) {
-            this.disconnect();
-            this.connect(this._eventSource.url);
-        }
+        if (this.isConnectedOrConnecting())
+            return;
+        this.disconnect();
+        this.connect(this._options.url, this._options.options);
     }
     addEventListenerForEventName(eventName) {
         const callback = (messageEvent) => {
@@ -8241,7 +8255,26 @@ class QdPushEventsService {
     logError(message, err) {
         console.error(`QD-UI | QdPushEventsService - ${message}`, err);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    connectEventSource(url, options = {}, reconnect) {
+        if (this._eventSource && this._eventSource.readyState !== EventSource.CLOSED)
+            this._eventSource.close();
+        if (!this._eventSource || this._eventSource.readyState === EventSource.CLOSED || reconnect)
+            this._eventSource = new EventSourcePolyfill(url, options);
+        this._eventSource.onerror = (err) => {
+            if (this._eventSource.readyState === EventSource.CLOSED)
+                this.reconnect();
+            this.logError('SSE connection error:', err);
+        };
+        this._eventSource.addEventListener('HEARTBEAT', (message) => {
+            if (this._heartbeatTimeout)
+                clearTimeout(this._heartbeatTimeout);
+            const interval = JSON.parse(message.data).interval;
+            this._heartbeatTimeout = setTimeout(() => this.reconnect(), interval + this._heartbeatReconnectDelayTime);
+        });
+        this._heartbeatTimeout = setTimeout(() => this.reconnect(), this._reconnectDelayTime);
+        this.addEventListenersForExistingSubscriptions();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, deps: [{ token: 'QdAuthenticationService', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPushEventsService, decorators: [{
@@ -8249,7 +8282,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['QdAuthenticationService']
+                }] }] });
 
 const QD_POPOVER_TOP_FIRST = new InjectionToken('QD_POPOVER_TOP_FIRST');