@en-solutions/tgm-client-sdk 1.6.21

package/esm2022/lib/services/chat/chat-websocket.service.mjs

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/websocket.service";
+export class ChatWebSocketService {
+    ws;
+    destroy$ = new Subject();
+    connected = false;
+    /** Incoming new messages */
+    messages$;
+    /** Typing indicators */
+    typing$;
+    /** Presence updates */
+    presence$;
+    /** Read receipt broadcasts */
+    readReceipts$;
+    /** Reaction broadcasts */
+    reactions$;
+    /** Error messages */
+    errors$;
+    constructor(ws) {
+        this.ws = ws;
+        this.messages$ = this.ws.subscribe('/user/queue/chat/messages').pipe(takeUntil(this.destroy$));
+        this.typing$ = this.ws.subscribe('/user/queue/chat/typing').pipe(takeUntil(this.destroy$));
+        this.presence$ = this.ws.subscribe('/user/queue/chat/presence').pipe(takeUntil(this.destroy$));
+        this.readReceipts$ = this.ws.subscribe('/user/queue/chat/receipts').pipe(takeUntil(this.destroy$));
+        this.reactions$ = this.ws.subscribe('/user/queue/chat/reactions').pipe(takeUntil(this.destroy$));
+        this.errors$ = this.ws.subscribe('/user/queue/chat/errors').pipe(takeUntil(this.destroy$));
+    }
+    connect() {
+        if (!this.connected) {
+            this.ws.connect('/ws/chat');
+            this.connected = true;
+        }
+    }
+    disconnect() {
+        this.ws.disconnect();
+        this.connected = false;
+    }
+    sendMessage(request) {
+        this.ws.send('/app/chat.send', request);
+    }
+    sendTyping(conversationId, typing) {
+        this.ws.send('/app/chat.typing', { conversationId, typing });
+    }
+    markRead(conversationId, lastMessageId) {
+        this.ws.send('/app/chat.markRead', { conversationId, lastReadMessageId: lastMessageId });
+    }
+    sendReaction(messageId, conversationId, emoji, add) {
+        this.ws.send('/app/chat.reaction', { messageId, conversationId, emoji, add });
+    }
+    updatePresence(online, deviceType) {
+        this.ws.send('/app/chat.presence', { online, deviceType });
+    }
+    heartbeat() {
+        this.ws.send('/app/chat.heartbeat', {});
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.disconnect();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatWebSocketService, deps: [{ token: i1.WebSocketService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatWebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WebSocketService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhdC13ZWJzb2NrZXQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvY2hhdC9jaGF0LXdlYnNvY2tldC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQWEsTUFBTSxlQUFlLENBQUM7QUFDdEQsT0FBTyxFQUFjLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7OztBQVl0RCxNQUFNLE9BQU8sb0JBQW9CO0lBc0JYO0lBckJaLFFBQVEsR0FBRyxJQUFJLE9BQU8sRUFBUSxDQUFDO0lBQy9CLFNBQVMsR0FBRyxLQUFLLENBQUM7SUFFMUIsNEJBQTRCO0lBQ25CLFNBQVMsQ0FBMEI7SUFFNUMsd0JBQXdCO0lBQ2YsT0FBTyxDQUFzQztJQUV0RCx1QkFBdUI7SUFDZCxTQUFTLENBQStCO0lBRWpELDhCQUE4QjtJQUNyQixhQUFhLENBQW1DO0lBRXpELDBCQUEwQjtJQUNqQixVQUFVLENBQWdDO0lBRW5ELHFCQUFxQjtJQUNaLE9BQU8sQ0FBa0I7SUFFbEMsWUFBb0IsRUFBb0I7UUFBcEIsT0FBRSxHQUFGLEVBQUUsQ0FBa0I7UUFDdEMsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBYywyQkFBMkIsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFDNUcsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBMEIseUJBQXlCLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1FBQ3BILElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQW1CLDJCQUEyQixDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUNqSCxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUF1QiwyQkFBMkIsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFDekgsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBb0IsNEJBQTRCLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1FBQ3BILElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQU0seUJBQXlCLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO0lBQ2xHLENBQUM7SUFFRCxPQUFPO1FBQ0wsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUNwQixJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUM1QixJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQztRQUN4QixDQUFDO0lBQ0gsQ0FBQztJQUVELFVBQVU7UUFDUixJQUFJLENBQUMsRUFBRSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxTQUFTLEdBQUcsS0FBSyxDQUFDO0lBQ3pCLENBQUM7SUFFRCxXQUFXLENBQUMsT0FBMkI7UUFDckMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVELFVBQVUsQ0FBQyxjQUFzQixFQUFFLE1BQWU7UUFDaEQsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUMvRCxDQUFDO0lBRUQsUUFBUSxDQUFDLGNBQXNCLEVBQUUsYUFBc0I7UUFDckQsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsb0JBQW9CLEVBQUUsRUFBRSxjQUFjLEVBQUUsaUJBQWlCLEVBQUUsYUFBYSxFQUFFLENBQUMsQ0FBQztJQUMzRixDQUFDO0lBRUQsWUFBWSxDQUFDLFNBQWlCLEVBQUUsY0FBc0IsRUFBRSxLQUFhLEVBQUUsR0FBWTtRQUNqRixJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUM7SUFDaEYsQ0FBQztJQUVELGNBQWMsQ0FBQyxNQUFlLEVBQUUsVUFBbUI7UUFDakQsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsb0JBQW9CLEVBQUUsRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRUQsU0FBUztRQUNQLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLHFCQUFxQixFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRCxXQUFXO1FBQ1QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNyQixJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUNwQixDQUFDO3dHQXZFVSxvQkFBb0I7NEdBQXBCLG9CQUFvQixjQURQLE1BQU07OzRGQUNuQixvQkFBb0I7a0JBRGhDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBTdWJqZWN0LCB0YWtlVW50aWwgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IFdlYlNvY2tldFNlcnZpY2UgfSBmcm9tICcuLi8uLi9jb3JlL3dlYnNvY2tldC5zZXJ2aWNlJztcbmltcG9ydCB7XG4gIENoYXRNZXNzYWdlLFxuICBUeXBpbmdJbmRpY2F0b3JSZXNwb25zZSxcbiAgUHJlc2VuY2VSZXNwb25zZSxcbiAgUmVhZFJlY2VpcHRCcm9hZGNhc3QsXG4gIFJlYWN0aW9uQnJvYWRjYXN0LFxuICBTZW5kTWVzc2FnZVJlcXVlc3QsXG59IGZyb20gJy4uLy4uL21vZGVscy9jaGF0L2NoYXQubW9kZWxzJztcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBDaGF0V2ViU29ja2V0U2VydmljZSBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XG4gIHByaXZhdGUgZGVzdHJveSQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuICBwcml2YXRlIGNvbm5lY3RlZCA9IGZhbHNlO1xuXG4gIC8qKiBJbmNvbWluZyBuZXcgbWVzc2FnZXMgKi9cbiAgcmVhZG9ubHkgbWVzc2FnZXMkOiBPYnNlcnZhYmxlPENoYXRNZXNzYWdlPjtcblxuICAvKiogVHlwaW5nIGluZGljYXRvcnMgKi9cbiAgcmVhZG9ubHkgdHlwaW5nJDogT2JzZXJ2YWJsZTxUeXBpbmdJbmRpY2F0b3JSZXNwb25zZT47XG5cbiAgLyoqIFByZXNlbmNlIHVwZGF0ZXMgKi9cbiAgcmVhZG9ubHkgcHJlc2VuY2UkOiBPYnNlcnZhYmxlPFByZXNlbmNlUmVzcG9uc2U+O1xuXG4gIC8qKiBSZWFkIHJlY2VpcHQgYnJvYWRjYXN0cyAqL1xuICByZWFkb25seSByZWFkUmVjZWlwdHMkOiBPYnNlcnZhYmxlPFJlYWRSZWNlaXB0QnJvYWRjYXN0PjtcblxuICAvKiogUmVhY3Rpb24gYnJvYWRjYXN0cyAqL1xuICByZWFkb25seSByZWFjdGlvbnMkOiBPYnNlcnZhYmxlPFJlYWN0aW9uQnJvYWRjYXN0PjtcblxuICAvKiogRXJyb3IgbWVzc2FnZXMgKi9cbiAgcmVhZG9ubHkgZXJyb3JzJDogT2JzZXJ2YWJsZTxhbnk+O1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgd3M6IFdlYlNvY2tldFNlcnZpY2UpIHtcbiAgICB0aGlzLm1lc3NhZ2VzJCA9IHRoaXMud3Muc3Vic2NyaWJlPENoYXRNZXNzYWdlPignL3VzZXIvcXVldWUvY2hhdC9tZXNzYWdlcycpLnBpcGUodGFrZVVudGlsKHRoaXMuZGVzdHJveSQpKTtcbiAgICB0aGlzLnR5cGluZyQgPSB0aGlzLndzLnN1YnNjcmliZTxUeXBpbmdJbmRpY2F0b3JSZXNwb25zZT4oJy91c2VyL3F1ZXVlL2NoYXQvdHlwaW5nJykucGlwZSh0YWtlVW50aWwodGhpcy5kZXN0cm95JCkpO1xuICAgIHRoaXMucHJlc2VuY2UkID0gdGhpcy53cy5zdWJzY3JpYmU8UHJlc2VuY2VSZXNwb25zZT4oJy91c2VyL3F1ZXVlL2NoYXQvcHJlc2VuY2UnKS5waXBlKHRha2VVbnRpbCh0aGlzLmRlc3Ryb3kkKSk7XG4gICAgdGhpcy5yZWFkUmVjZWlwdHMkID0gdGhpcy53cy5zdWJzY3JpYmU8UmVhZFJlY2VpcHRCcm9hZGNhc3Q+KCcvdXNlci9xdWV1ZS9jaGF0L3JlY2VpcHRzJykucGlwZSh0YWtlVW50aWwodGhpcy5kZXN0cm95JCkpO1xuICAgIHRoaXMucmVhY3Rpb25zJCA9IHRoaXMud3Muc3Vic2NyaWJlPFJlYWN0aW9uQnJvYWRjYXN0PignL3VzZXIvcXVldWUvY2hhdC9yZWFjdGlvbnMnKS5waXBlKHRha2VVbnRpbCh0aGlzLmRlc3Ryb3kkKSk7XG4gICAgdGhpcy5lcnJvcnMkID0gdGhpcy53cy5zdWJzY3JpYmU8YW55PignL3VzZXIvcXVldWUvY2hhdC9lcnJvcnMnKS5waXBlKHRha2VVbnRpbCh0aGlzLmRlc3Ryb3kkKSk7XG4gIH1cblxuICBjb25uZWN0KCk6IHZvaWQge1xuICAgIGlmICghdGhpcy5jb25uZWN0ZWQpIHtcbiAgICAgIHRoaXMud3MuY29ubmVjdCgnL3dzL2NoYXQnKTtcbiAgICAgIHRoaXMuY29ubmVjdGVkID0gdHJ1ZTtcbiAgICB9XG4gIH1cblxuICBkaXNjb25uZWN0KCk6IHZvaWQge1xuICAgIHRoaXMud3MuZGlzY29ubmVjdCgpO1xuICAgIHRoaXMuY29ubmVjdGVkID0gZmFsc2U7XG4gIH1cblxuICBzZW5kTWVzc2FnZShyZXF1ZXN0OiBTZW5kTWVzc2FnZVJlcXVlc3QpOiB2b2lkIHtcbiAgICB0aGlzLndzLnNlbmQoJy9hcHAvY2hhdC5zZW5kJywgcmVxdWVzdCk7XG4gIH1cblxuICBzZW5kVHlwaW5nKGNvbnZlcnNhdGlvbklkOiBudW1iZXIsIHR5cGluZzogYm9vbGVhbik6IHZvaWQge1xuICAgIHRoaXMud3Muc2VuZCgnL2FwcC9jaGF0LnR5cGluZycsIHsgY29udmVyc2F0aW9uSWQsIHR5cGluZyB9KTtcbiAgfVxuXG4gIG1hcmtSZWFkKGNvbnZlcnNhdGlvbklkOiBudW1iZXIsIGxhc3RNZXNzYWdlSWQ/OiBudW1iZXIpOiB2b2lkIHtcbiAgICB0aGlzLndzLnNlbmQoJy9hcHAvY2hhdC5tYXJrUmVhZCcsIHsgY29udmVyc2F0aW9uSWQsIGxhc3RSZWFkTWVzc2FnZUlkOiBsYXN0TWVzc2FnZUlkIH0pO1xuICB9XG5cbiAgc2VuZFJlYWN0aW9uKG1lc3NhZ2VJZDogbnVtYmVyLCBjb252ZXJzYXRpb25JZDogbnVtYmVyLCBlbW9qaTogc3RyaW5nLCBhZGQ6IGJvb2xlYW4pOiB2b2lkIHtcbiAgICB0aGlzLndzLnNlbmQoJy9hcHAvY2hhdC5yZWFjdGlvbicsIHsgbWVzc2FnZUlkLCBjb252ZXJzYXRpb25JZCwgZW1vamksIGFkZCB9KTtcbiAgfVxuXG4gIHVwZGF0ZVByZXNlbmNlKG9ubGluZTogYm9vbGVhbiwgZGV2aWNlVHlwZT86IHN0cmluZyk6IHZvaWQge1xuICAgIHRoaXMud3Muc2VuZCgnL2FwcC9jaGF0LnByZXNlbmNlJywgeyBvbmxpbmUsIGRldmljZVR5cGUgfSk7XG4gIH1cblxuICBoZWFydGJlYXQoKTogdm9pZCB7XG4gICAgdGhpcy53cy5zZW5kKCcvYXBwL2NoYXQuaGVhcnRiZWF0Jywge30pO1xuICB9XG5cbiAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgdGhpcy5kZXN0cm95JC5uZXh0KCk7XG4gICAgdGhpcy5kZXN0cm95JC5jb21wbGV0ZSgpO1xuICAgIHRoaXMuZGlzY29ubmVjdCgpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/services/chat/index.mjs

@@ -0,0 +1,3 @@
+export { ChatRestService } from './chat-rest.service';
+export { ChatWebSocketService } from './chat-websocket.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2NoYXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQ2hhdFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi9jaGF0LXJlc3Quc2VydmljZSc7XG5leHBvcnQgeyBDaGF0V2ViU29ja2V0U2VydmljZSB9IGZyb20gJy4vY2hhdC13ZWJzb2NrZXQuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,8 @@
+export * from './auth';
+export * from './admin';
+export * from './api';
+export * from './chat';
+export * from './realtime';
+export * from './reservoir';
+export * from './video';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsT0FBTyxDQUFDO0FBQ3RCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRoJztcbmV4cG9ydCAqIGZyb20gJy4vYWRtaW4nO1xuZXhwb3J0ICogZnJvbSAnLi9hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9jaGF0JztcbmV4cG9ydCAqIGZyb20gJy4vcmVhbHRpbWUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNlcnZvaXInO1xuZXhwb3J0ICogZnJvbSAnLi92aWRlbyc7XG4iXX0=

package/esm2022/lib/services/realtime/index.mjs

@@ -0,0 +1,2 @@
+export { RealtimeEventService } from './realtime-event.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3JlYWx0aW1lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgUmVhbHRpbWVFdmVudFNlcnZpY2UgfSBmcm9tICcuL3JlYWx0aW1lLWV2ZW50LnNlcnZpY2UnO1xuIl19

package/esm2022/lib/services/realtime/realtime-event.service.mjs

@@ -0,0 +1,187 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/websocket.service";
+/**
+ * Real-time event service for subscribing to entity CRUD changes,
+ * dynamic queue messages, IoT events, notifications, and calendar updates.
+ *
+ * ## Entity Changes
+ *
+ * When any entity is created, updated, or deleted via the API, an event is
+ * broadcast to WebSocket. No RabbitMQ required — this works automatically
+ * for every entity type managed by BaseApiController.
+ *
+ * ```typescript
+ * // All entity changes
+ * this.realtimeEvents.allEntityChanges$.subscribe(event => { ... });
+ *
+ * // Specific resource type
+ * this.realtimeEvents.entityChanges('inspections').subscribe(event => { ... });
+ * ```
+ *
+ * ## Dynamic Queue Messages
+ *
+ * When a RabbitMQ dynamic queue message is processed, it is broadcast to
+ * WebSocket. The queue must exist and have an active listener (create via
+ * QueueAdminService).
+ *
+ * ```typescript
+ * // All queue messages
+ * this.realtimeEvents.allQueueMessages$.subscribe(event => { ... });
+ *
+ * // Specific queue
+ * this.realtimeEvents.queueMessages('tgm_iot').subscribe(event => { ... });
+ * ```
+ *
+ * ## Connection
+ *
+ * Call `connect()` once (e.g. after login). The service uses the shared
+ * `WebSocketService` and auto-reconnects on disconnect.
+ */
+export class RealtimeEventService {
+    ws;
+    destroy$ = new Subject();
+    connected = false;
+    // ─── Entity Change Streams ────────────────────────────────────────
+    /**
+     * All entity CRUD changes (firehose).
+     * Emits for every create, update, and delete across all entity types.
+     *
+     * STOMP destination: `/topic/entities`
+     */
+    allEntityChanges$;
+    // ─── Queue Message Streams ────────────────────────────────────────
+    /**
+     * All dynamic queue messages (firehose).
+     * Emits for every successfully processed message across all queues.
+     *
+     * STOMP destination: `/topic/queues`
+     */
+    allQueueMessages$;
+    // ─── IoT Stream ───────────────────────────────────────────────────
+    /**
+     * IoT sensor events from the static RabbitMQ listener.
+     *
+     * STOMP destination: `/topic/iot-event`
+     */
+    iotEvents$;
+    // ─── User-Specific Streams ────────────────────────────────────────
+    /**
+     * Notifications for the authenticated user.
+     *
+     * STOMP destination: `/user/queue/notifications`
+     */
+    notifications$;
+    /**
+     * Calendar updates for the authenticated user.
+     *
+     * STOMP destination: `/user/queue/calendar`
+     */
+    calendarUpdates$;
+    constructor(ws) {
+        this.ws = ws;
+        this.allEntityChanges$ = this.ws
+            .subscribe('/topic/entities')
+            .pipe(takeUntil(this.destroy$));
+        this.allQueueMessages$ = this.ws
+            .subscribe('/topic/queues')
+            .pipe(takeUntil(this.destroy$));
+        this.iotEvents$ = this.ws
+            .subscribe('/topic/iot-event')
+            .pipe(takeUntil(this.destroy$));
+        this.notifications$ = this.ws
+            .subscribe('/user/queue/notifications')
+            .pipe(takeUntil(this.destroy$));
+        this.calendarUpdates$ = this.ws
+            .subscribe('/user/queue/calendar')
+            .pipe(takeUntil(this.destroy$));
+    }
+    /**
+     * Connect to the WebSocket server.
+     * Call once after authentication (e.g. in AppComponent.ngOnInit or after login).
+     * Subsequent calls are no-ops.
+     */
+    connect() {
+        if (!this.connected) {
+            this.ws.connect('/ws');
+            this.connected = true;
+        }
+    }
+    /**
+     * Disconnect from the WebSocket server.
+     */
+    disconnect() {
+        this.ws.disconnect();
+        this.connected = false;
+    }
+    // ─── Resource-Specific Subscriptions ──────────────────────────────
+    /**
+     * Subscribe to entity changes for a specific resource type.
+     *
+     * @param resourceName The API resource name (plural) — e.g. 'inspections', 'units', 'interventions', 'failures', 'locations'
+     * @returns Observable that emits EntityChangeEvent for that resource
+     *
+     * STOMP destination: `/topic/entities/{resourceName}`
+     *
+     * @example
+     * ```typescript
+     * this.realtimeEvents.entityChanges('inspections').subscribe(event => {
+     *   console.log(event.action, event.entityId, event.data);
+     * });
+     * ```
+     */
+    entityChanges(resourceName) {
+        return this.ws
+            .subscribe(`/topic/entities/${resourceName}`)
+            .pipe(takeUntil(this.destroy$));
+    }
+    /**
+     * Subscribe to messages from a specific dynamic queue.
+     *
+     * The queue must exist in RabbitMQ with an active listener.
+     * Create queues via `QueueAdminService.create()`.
+     *
+     * @param queueName The queue name — e.g. 'tgm_iot', 'tgm_notifications', 'my_custom_queue'
+     * @returns Observable that emits QueueMessageEvent for that queue
+     *
+     * STOMP destination: `/topic/queues/{queueName}`
+     *
+     * @example
+     * ```typescript
+     * this.realtimeEvents.queueMessages('tgm_iot').subscribe(event => {
+     *   console.log(event.handlerType, event.payload);
+     * });
+     * ```
+     */
+    queueMessages(queueName) {
+        return this.ws
+            .subscribe(`/topic/queues/${queueName}`)
+            .pipe(takeUntil(this.destroy$));
+    }
+    /**
+     * Stop listening to a specific entity resource.
+     * Useful when navigating away from a page that was watching a resource.
+     */
+    unsubscribeEntity(resourceName) {
+        this.ws.unsubscribe(`/topic/entities/${resourceName}`);
+    }
+    /**
+     * Stop listening to a specific queue.
+     */
+    unsubscribeQueue(queueName) {
+        this.ws.unsubscribe(`/topic/queues/${queueName}`);
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.disconnect();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RealtimeEventService, deps: [{ token: i1.WebSocketService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RealtimeEventService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RealtimeEventService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WebSocketService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"realtime-event.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/realtime/realtime-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { Observable, Subject, takeUntil } from 'rxjs';\nimport { WebSocketService } from '../../core/websocket.service';\nimport {\n  EntityChangeEvent,\n  QueueMessageEvent,\n  QueueMessageFirehoseEvent,\n  IoTEvent,\n  NotificationEvent,\n  CalendarUpdateEvent,\n} from '../../models/realtime/realtime-event.models';\n\n/**\n * Real-time event service for subscribing to entity CRUD changes,\n * dynamic queue messages, IoT events, notifications, and calendar updates.\n *\n * ## Entity Changes\n *\n * When any entity is created, updated, or deleted via the API, an event is\n * broadcast to WebSocket. No RabbitMQ required — this works automatically\n * for every entity type managed by BaseApiController.\n *\n * ```typescript\n * // All entity changes\n * this.realtimeEvents.allEntityChanges$.subscribe(event => { ... });\n *\n * // Specific resource type\n * this.realtimeEvents.entityChanges('inspections').subscribe(event => { ... });\n * ```\n *\n * ## Dynamic Queue Messages\n *\n * When a RabbitMQ dynamic queue message is processed, it is broadcast to\n * WebSocket. The queue must exist and have an active listener (create via\n * QueueAdminService).\n *\n * ```typescript\n * // All queue messages\n * this.realtimeEvents.allQueueMessages$.subscribe(event => { ... });\n *\n * // Specific queue\n * this.realtimeEvents.queueMessages('tgm_iot').subscribe(event => { ... });\n * ```\n *\n * ## Connection\n *\n * Call `connect()` once (e.g. after login). The service uses the shared\n * `WebSocketService` and auto-reconnects on disconnect.\n */\n@Injectable({ providedIn: 'root' })\nexport class RealtimeEventService implements OnDestroy {\n  private destroy$ = new Subject<void>();\n  private connected = false;\n\n  // ─── Entity Change Streams ────────────────────────────────────────\n\n  /**\n   * All entity CRUD changes (firehose).\n   * Emits for every create, update, and delete across all entity types.\n   *\n   * STOMP destination: `/topic/entities`\n   */\n  readonly allEntityChanges$: Observable<EntityChangeEvent>;\n\n  // ─── Queue Message Streams ────────────────────────────────────────\n\n  /**\n   * All dynamic queue messages (firehose).\n   * Emits for every successfully processed message across all queues.\n   *\n   * STOMP destination: `/topic/queues`\n   */\n  readonly allQueueMessages$: Observable<QueueMessageFirehoseEvent>;\n\n  // ─── IoT Stream ───────────────────────────────────────────────────\n\n  /**\n   * IoT sensor events from the static RabbitMQ listener.\n   *\n   * STOMP destination: `/topic/iot-event`\n   */\n  readonly iotEvents$: Observable<IoTEvent>;\n\n  // ─── User-Specific Streams ────────────────────────────────────────\n\n  /**\n   * Notifications for the authenticated user.\n   *\n   * STOMP destination: `/user/queue/notifications`\n   */\n  readonly notifications$: Observable<NotificationEvent>;\n\n  /**\n   * Calendar updates for the authenticated user.\n   *\n   * STOMP destination: `/user/queue/calendar`\n   */\n  readonly calendarUpdates$: Observable<CalendarUpdateEvent>;\n\n  constructor(private ws: WebSocketService) {\n    this.allEntityChanges$ = this.ws\n      .subscribe<EntityChangeEvent>('/topic/entities')\n      .pipe(takeUntil(this.destroy$));\n\n    this.allQueueMessages$ = this.ws\n      .subscribe<QueueMessageFirehoseEvent>('/topic/queues')\n      .pipe(takeUntil(this.destroy$));\n\n    this.iotEvents$ = this.ws\n      .subscribe<IoTEvent>('/topic/iot-event')\n      .pipe(takeUntil(this.destroy$));\n\n    this.notifications$ = this.ws\n      .subscribe<NotificationEvent>('/user/queue/notifications')\n      .pipe(takeUntil(this.destroy$));\n\n    this.calendarUpdates$ = this.ws\n      .subscribe<CalendarUpdateEvent>('/user/queue/calendar')\n      .pipe(takeUntil(this.destroy$));\n  }\n\n  /**\n   * Connect to the WebSocket server.\n   * Call once after authentication (e.g. in AppComponent.ngOnInit or after login).\n   * Subsequent calls are no-ops.\n   */\n  connect(): void {\n    if (!this.connected) {\n      this.ws.connect('/ws');\n      this.connected = true;\n    }\n  }\n\n  /**\n   * Disconnect from the WebSocket server.\n   */\n  disconnect(): void {\n    this.ws.disconnect();\n    this.connected = false;\n  }\n\n  // ─── Resource-Specific Subscriptions ──────────────────────────────\n\n  /**\n   * Subscribe to entity changes for a specific resource type.\n   *\n   * @param resourceName The API resource name (plural) — e.g. 'inspections', 'units', 'interventions', 'failures', 'locations'\n   * @returns Observable that emits EntityChangeEvent for that resource\n   *\n   * STOMP destination: `/topic/entities/{resourceName}`\n   *\n   * @example\n   * ```typescript\n   * this.realtimeEvents.entityChanges('inspections').subscribe(event => {\n   *   console.log(event.action, event.entityId, event.data);\n   * });\n   * ```\n   */\n  entityChanges<T = any>(resourceName: string): Observable<EntityChangeEvent<T>> {\n    return this.ws\n      .subscribe<EntityChangeEvent<T>>(`/topic/entities/${resourceName}`)\n      .pipe(takeUntil(this.destroy$));\n  }\n\n  /**\n   * Subscribe to messages from a specific dynamic queue.\n   *\n   * The queue must exist in RabbitMQ with an active listener.\n   * Create queues via `QueueAdminService.create()`.\n   *\n   * @param queueName The queue name — e.g. 'tgm_iot', 'tgm_notifications', 'my_custom_queue'\n   * @returns Observable that emits QueueMessageEvent for that queue\n   *\n   * STOMP destination: `/topic/queues/{queueName}`\n   *\n   * @example\n   * ```typescript\n   * this.realtimeEvents.queueMessages('tgm_iot').subscribe(event => {\n   *   console.log(event.handlerType, event.payload);\n   * });\n   * ```\n   */\n  queueMessages<T = any>(queueName: string): Observable<QueueMessageEvent<T>> {\n    return this.ws\n      .subscribe<QueueMessageEvent<T>>(`/topic/queues/${queueName}`)\n      .pipe(takeUntil(this.destroy$));\n  }\n\n  /**\n   * Stop listening to a specific entity resource.\n   * Useful when navigating away from a page that was watching a resource.\n   */\n  unsubscribeEntity(resourceName: string): void {\n    this.ws.unsubscribe(`/topic/entities/${resourceName}`);\n  }\n\n  /**\n   * Stop listening to a specific queue.\n   */\n  unsubscribeQueue(queueName: string): void {\n    this.ws.unsubscribe(`/topic/queues/${queueName}`);\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.disconnect();\n  }\n}\n"]}

package/esm2022/lib/services/reservoir/index.mjs

@@ -0,0 +1,2 @@
+export { ReservoirWebSocketService } from './reservoir-websocket.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3Jlc2Vydm9pci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFJlc2Vydm9pcldlYlNvY2tldFNlcnZpY2UgfSBmcm9tICcuL3Jlc2Vydm9pci13ZWJzb2NrZXQuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/services/reservoir/reservoir-websocket.service.mjs

@@ -0,0 +1,105 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/websocket.service";
+/**
+ * WebSocket service for real-time reservoir data streams.
+ *
+ * Provides 4 strongly-typed observable streams per reservoir:
+ * - `sensors$` — real-time sensor readings (single or bulk)
+ * - `externalData$` — weather, grid market, lab results, fish monitoring, regulatory updates
+ * - `manualData$` — inspections, manual readings, operational observations
+ * - `statusAlerts$` — operating events and alert notifications
+ */
+export class ReservoirWebSocketService {
+    ws;
+    destroy$ = new Subject();
+    connected = false;
+    currentReservoirId = null;
+    sensorsSubject$ = new Subject();
+    externalDataSubject$ = new Subject();
+    manualDataSubject$ = new Subject();
+    statusAlertsSubject$ = new Subject();
+    /** Real-time sensor readings stream (single or bulk messages) */
+    sensors$ = this.sensorsSubject$.asObservable();
+    /** External data stream (weather, grid market, lab results, etc.) */
+    externalData$ = this.externalDataSubject$.asObservable();
+    /** Manual data stream (inspections, manual readings, observations) */
+    manualData$ = this.manualDataSubject$.asObservable();
+    /** Status and alert notifications stream */
+    statusAlerts$ = this.statusAlertsSubject$.asObservable();
+    constructor(ws) {
+        this.ws = ws;
+    }
+    /** Connects to the WebSocket and subscribes to all 4 streams for the given reservoir. */
+    connect(reservoirId) {
+        if (this.connected && this.currentReservoirId === reservoirId)
+            return;
+        // Disconnect from previous reservoir if switching
+        if (this.connected) {
+            this.unsubscribeStreams();
+        }
+        this.ws.connect('/ws');
+        this.connected = true;
+        this.currentReservoirId = reservoirId;
+        this.ws.subscribe(`/topic/reservoir/${reservoirId}/sensors`)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(data => this.sensorsSubject$.next(data));
+        this.ws.subscribe(`/topic/reservoir/${reservoirId}/external`)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(data => this.externalDataSubject$.next(data));
+        this.ws.subscribe(`/topic/reservoir/${reservoirId}/manual`)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(data => this.manualDataSubject$.next(data));
+        this.ws.subscribe(`/topic/reservoir/${reservoirId}/status`)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(data => this.statusAlertsSubject$.next(data));
+    }
+    /** Disconnects from the WebSocket. */
+    disconnect() {
+        this.unsubscribeStreams();
+        this.ws.disconnect();
+        this.connected = false;
+        this.currentReservoirId = null;
+    }
+    /** Sends a subscription request to the backend for a specific data type. */
+    subscribe(reservoirId, dataType) {
+        this.ws.send('/app/reservoir.subscribe', {
+            action: 'subscribe',
+            dataType,
+            reservoir_id: reservoirId,
+        });
+    }
+    /** Sends an unsubscription request for a specific data type. */
+    unsubscribe(reservoirId, dataType) {
+        this.ws.send('/app/reservoir.unsubscribe', {
+            action: 'unsubscribe',
+            dataType,
+            reservoir_id: reservoirId,
+        });
+    }
+    /** The currently subscribed reservoir ID. */
+    getCurrentReservoirId() {
+        return this.currentReservoirId;
+    }
+    unsubscribeStreams() {
+        if (this.currentReservoirId) {
+            this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/sensors`);
+            this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/external`);
+            this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/manual`);
+            this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/status`);
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.disconnect();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReservoirWebSocketService, deps: [{ token: i1.WebSocketService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReservoirWebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReservoirWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WebSocketService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reservoir-websocket.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/reservoir/reservoir-websocket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { Observable, Subject, takeUntil } from 'rxjs';\nimport { WebSocketService } from '../../core/websocket.service';\nimport {\n  ReservoirSensorEvent,\n  ReservoirExternalMessage,\n  ReservoirManualMessage,\n  ReservoirStatusMessage,\n} from '../../models/api/reservoir-websocket.models';\n\n/**\n * WebSocket service for real-time reservoir data streams.\n *\n * Provides 4 strongly-typed observable streams per reservoir:\n * - `sensors$` — real-time sensor readings (single or bulk)\n * - `externalData$` — weather, grid market, lab results, fish monitoring, regulatory updates\n * - `manualData$` — inspections, manual readings, operational observations\n * - `statusAlerts$` — operating events and alert notifications\n */\n@Injectable({ providedIn: 'root' })\nexport class ReservoirWebSocketService implements OnDestroy {\n  private destroy$ = new Subject<void>();\n  private connected = false;\n  private currentReservoirId: string | null = null;\n\n  private sensorsSubject$ = new Subject<ReservoirSensorEvent>();\n  private externalDataSubject$ = new Subject<ReservoirExternalMessage>();\n  private manualDataSubject$ = new Subject<ReservoirManualMessage>();\n  private statusAlertsSubject$ = new Subject<ReservoirStatusMessage>();\n\n  /** Real-time sensor readings stream (single or bulk messages) */\n  readonly sensors$: Observable<ReservoirSensorEvent> = this.sensorsSubject$.asObservable();\n\n  /** External data stream (weather, grid market, lab results, etc.) */\n  readonly externalData$: Observable<ReservoirExternalMessage> = this.externalDataSubject$.asObservable();\n\n  /** Manual data stream (inspections, manual readings, observations) */\n  readonly manualData$: Observable<ReservoirManualMessage> = this.manualDataSubject$.asObservable();\n\n  /** Status and alert notifications stream */\n  readonly statusAlerts$: Observable<ReservoirStatusMessage> = this.statusAlertsSubject$.asObservable();\n\n  constructor(private ws: WebSocketService) {}\n\n  /** Connects to the WebSocket and subscribes to all 4 streams for the given reservoir. */\n  connect(reservoirId: string): void {\n    if (this.connected && this.currentReservoirId === reservoirId) return;\n\n    // Disconnect from previous reservoir if switching\n    if (this.connected) {\n      this.unsubscribeStreams();\n    }\n\n    this.ws.connect('/ws');\n    this.connected = true;\n    this.currentReservoirId = reservoirId;\n\n    this.ws.subscribe<ReservoirSensorEvent>(`/topic/reservoir/${reservoirId}/sensors`)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(data => this.sensorsSubject$.next(data));\n\n    this.ws.subscribe<ReservoirExternalMessage>(`/topic/reservoir/${reservoirId}/external`)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(data => this.externalDataSubject$.next(data));\n\n    this.ws.subscribe<ReservoirManualMessage>(`/topic/reservoir/${reservoirId}/manual`)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(data => this.manualDataSubject$.next(data));\n\n    this.ws.subscribe<ReservoirStatusMessage>(`/topic/reservoir/${reservoirId}/status`)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(data => this.statusAlertsSubject$.next(data));\n  }\n\n  /** Disconnects from the WebSocket. */\n  disconnect(): void {\n    this.unsubscribeStreams();\n    this.ws.disconnect();\n    this.connected = false;\n    this.currentReservoirId = null;\n  }\n\n  /** Sends a subscription request to the backend for a specific data type. */\n  subscribe(reservoirId: string, dataType: string): void {\n    this.ws.send('/app/reservoir.subscribe', {\n      action: 'subscribe',\n      dataType,\n      reservoir_id: reservoirId,\n    });\n  }\n\n  /** Sends an unsubscription request for a specific data type. */\n  unsubscribe(reservoirId: string, dataType: string): void {\n    this.ws.send('/app/reservoir.unsubscribe', {\n      action: 'unsubscribe',\n      dataType,\n      reservoir_id: reservoirId,\n    });\n  }\n\n  /** The currently subscribed reservoir ID. */\n  getCurrentReservoirId(): string | null {\n    return this.currentReservoirId;\n  }\n\n  private unsubscribeStreams(): void {\n    if (this.currentReservoirId) {\n      this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/sensors`);\n      this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/external`);\n      this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/manual`);\n      this.ws.unsubscribe(`/topic/reservoir/${this.currentReservoirId}/status`);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.disconnect();\n  }\n}\n"]}

package/esm2022/lib/services/video/index.mjs

@@ -0,0 +1,3 @@
+export { VideoCallRestService } from './video-call-rest.service';
+export { VideoCallWebSocketService } from './video-call-websocket.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3ZpZGVvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgVmlkZW9DYWxsUmVzdFNlcnZpY2UgfSBmcm9tICcuL3ZpZGVvLWNhbGwtcmVzdC5zZXJ2aWNlJztcbmV4cG9ydCB7IFZpZGVvQ2FsbFdlYlNvY2tldFNlcnZpY2UgfSBmcm9tICcuL3ZpZGVvLWNhbGwtd2Vic29ja2V0LnNlcnZpY2UnO1xuIl19

package/esm2022/lib/services/video/video-call-rest.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class VideoCallRestService {
+    http;
+    basePath = '/api/video-calls';
+    constructor(http) {
+        this.http = http;
+    }
+    initiateCall(request) {
+        return this.http.post(this.basePath, request);
+    }
+    answerCall(callId, accepted) {
+        return this.http.post(`${this.basePath}/${callId}/answer`, { callId, accepted });
+    }
+    joinCall(callId) {
+        return this.http.post(`${this.basePath}/${callId}/join`);
+    }
+    endCall(callId) {
+        return this.http.post(`${this.basePath}/${callId}/end`);
+    }
+    getCall(callId) {
+        return this.http.get(`${this.basePath}/${callId}`);
+    }
+    getCallHistory(companyId, page = 0, size = 20) {
+        return this.http.get(this.basePath, {
+            params: { companyId, page, size },
+        });
+    }
+    getActiveCall(companyId) {
+        return this.http.get(`${this.basePath}/active`, {
+            params: { companyId },
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VideoCallRestService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VideoCallRestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VideoCallRestService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/video/video-call-websocket.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/websocket.service";
+export class VideoCallWebSocketService {
+    ws;
+    destroy$ = new Subject();
+    /** Incoming call notification (for targets) */
+    incomingCall$;
+    /** Call initiated confirmation (for initiator) */
+    callInitiated$;
+    /** Call answered notification */
+    callAnswered$;
+    /** LiveKit token delivery (after accepting call) */
+    callToken$;
+    /** Call ended notification */
+    callEnded$;
+    /** Call rejected notification */
+    callRejected$;
+    /** Error messages */
+    errors$;
+    constructor(ws) {
+        this.ws = ws;
+        this.incomingCall$ = this.ws.subscribe('/user/queue/video/incoming-call').pipe(takeUntil(this.destroy$));
+        this.callInitiated$ = this.ws.subscribe('/user/queue/video/call-initiated').pipe(takeUntil(this.destroy$));
+        this.callAnswered$ = this.ws.subscribe('/user/queue/video/call-answered').pipe(takeUntil(this.destroy$));
+        this.callToken$ = this.ws.subscribe('/user/queue/video/call-token').pipe(takeUntil(this.destroy$));
+        this.callEnded$ = this.ws.subscribe('/user/queue/video/call-ended').pipe(takeUntil(this.destroy$));
+        this.callRejected$ = this.ws.subscribe('/user/queue/video/call-rejected').pipe(takeUntil(this.destroy$));
+        this.errors$ = this.ws.subscribe('/user/queue/video/errors').pipe(takeUntil(this.destroy$));
+    }
+    initiateCall(request) {
+        this.ws.send('/app/video.call-init', request);
+    }
+    answerCall(callId, accepted) {
+        this.ws.send('/app/video.call-answer', { callId, accepted });
+    }
+    endCall(callId) {
+        this.ws.send('/app/video.call-end', { callId });
+    }
+    rejectCall(callId) {
+        this.ws.send('/app/video.call-reject', { callId });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VideoCallWebSocketService, deps: [{ token: i1.WebSocketService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VideoCallWebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: VideoCallWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WebSocketService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tgm-sdk.config.mjs

@@ -0,0 +1,32 @@
+import { InjectionToken } from '@angular/core';
+export const TGM_SDK_CONFIG = new InjectionToken('TGM_SDK_CONFIG', {
+    providedIn: 'root',
+    factory: () => ({
+        baseUrl: '',
+        tokenStorage: new InMemoryTokenStorage(),
+        autoRefresh: false,
+    })
+});
+export class InMemoryTokenStorage {
+    token = null;
+    refreshToken = null;
+    getToken() {
+        return this.token;
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    removeToken() {
+        this.token = null;
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setRefreshToken(token) {
+        this.refreshToken = token;
+    }
+    removeRefreshToken() {
+        this.refreshToken = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGdtLXNkay5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3RnbS1zZGsuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFrQy9DLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxJQUFJLGNBQWMsQ0FBZSxnQkFBZ0IsRUFBRTtJQUMvRSxVQUFVLEVBQUUsTUFBTTtJQUNsQixPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztRQUNkLE9BQU8sRUFBRSxFQUFFO1FBQ1gsWUFBWSxFQUFFLElBQUksb0JBQW9CLEVBQUU7UUFDeEMsV0FBVyxFQUFFLEtBQUs7S0FDbkIsQ0FBQztDQUNILENBQUMsQ0FBQztBQUVILE1BQU0sT0FBTyxvQkFBb0I7SUFDdkIsS0FBSyxHQUFrQixJQUFJLENBQUM7SUFDNUIsWUFBWSxHQUFrQixJQUFJLENBQUM7SUFFM0MsUUFBUTtRQUNOLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwQixDQUFDO0lBRUQsUUFBUSxDQUFDLEtBQWE7UUFDcEIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7SUFDckIsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztJQUNwQixDQUFDO0lBRUQsZUFBZTtRQUNiLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQztJQUMzQixDQUFDO0lBRUQsZUFBZSxDQUFDLEtBQWE7UUFDM0IsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUM7SUFDNUIsQ0FBQztJQUVELGtCQUFrQjtRQUNoQixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQztJQUMzQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRva2VuU3RvcmFnZVN0cmF0ZWd5IHtcbiAgZ2V0VG9rZW4oKTogc3RyaW5nIHwgbnVsbDtcbiAgc2V0VG9rZW4odG9rZW46IHN0cmluZyk6IHZvaWQ7XG4gIHJlbW92ZVRva2VuKCk6IHZvaWQ7XG4gIGdldFJlZnJlc2hUb2tlbigpOiBzdHJpbmcgfCBudWxsO1xuICBzZXRSZWZyZXNoVG9rZW4odG9rZW46IHN0cmluZyk6IHZvaWQ7XG4gIHJlbW92ZVJlZnJlc2hUb2tlbigpOiB2b2lkO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRnbVNka0NvbmZpZyB7XG4gIC8qKiBCYXNlIFVSTCBvZiB0aGUgVEdNIE1hbmFnZXIgYmFja2VuZCAoZS5nLiwgJ2h0dHA6Ly9sb2NhbGhvc3Q6MTMzNycpICovXG4gIGJhc2VVcmw6IHN0cmluZztcblxuICAvKiogU3RhdGljIGNsaWVudCBpZGVudGlmaWVyIGZvciBtdWx0aS10ZW5hbmN5IChYLUNsaWVudC1JRCBoZWFkZXIpICovXG4gIGNsaWVudElkPzogc3RyaW5nO1xuXG4gIC8qKiBXZWJTb2NrZXQgZW5kcG9pbnQgcGF0aCAoZGVmYXVsdHMgdG8gJy93cycpICovXG4gIHdzRW5kcG9pbnQ/OiBzdHJpbmc7XG5cbiAgLyoqIEN1c3RvbSB0b2tlbiBzdG9yYWdlIHN0cmF0ZWd5LiBEZWZhdWx0cyB0byBpbi1tZW1vcnkgc3RvcmFnZS4gKi9cbiAgdG9rZW5TdG9yYWdlPzogVG9rZW5TdG9yYWdlU3RyYXRlZ3k7XG5cbiAgLyoqIFdoZXRoZXIgdG8gYXV0b21hdGljYWxseSByZWZyZXNoIHRva2VucyBvbiA0MDEgKGRlZmF1bHRzIHRvIHRydWUpICovXG4gIGF1dG9SZWZyZXNoPzogYm9vbGVhbjtcblxuICAvKiogVG9rZW4ga2V5IG5hbWUgdXNlZCBpbiBhdXRoIHJlc3BvbnNlcyAoZGVmYXVsdHMgdG8gJ2p3dCcpICovXG4gIHRva2VuS2V5Pzogc3RyaW5nO1xuXG4gIC8qKiBSZWZyZXNoIHRva2VuIGtleSBuYW1lIChkZWZhdWx0cyB0byAncmVmcmVzaFRva2VuJykgKi9cbiAgcmVmcmVzaFRva2VuS2V5Pzogc3RyaW5nO1xufVxuXG5leHBvcnQgY29uc3QgVEdNX1NES19DT05GSUcgPSBuZXcgSW5qZWN0aW9uVG9rZW48VGdtU2RrQ29uZmlnPignVEdNX1NES19DT05GSUcnLCB7XG4gIHByb3ZpZGVkSW46ICdyb290JyxcbiAgZmFjdG9yeTogKCkgPT4gKHtcbiAgICBiYXNlVXJsOiAnJyxcbiAgICB0b2tlblN0b3JhZ2U6IG5ldyBJbk1lbW9yeVRva2VuU3RvcmFnZSgpLFxuICAgIGF1dG9SZWZyZXNoOiBmYWxzZSxcbiAgfSlcbn0pO1xuXG5leHBvcnQgY2xhc3MgSW5NZW1vcnlUb2tlblN0b3JhZ2UgaW1wbGVtZW50cyBUb2tlblN0b3JhZ2VTdHJhdGVneSB7XG4gIHByaXZhdGUgdG9rZW46IHN0cmluZyB8IG51bGwgPSBudWxsO1xuICBwcml2YXRlIHJlZnJlc2hUb2tlbjogc3RyaW5nIHwgbnVsbCA9IG51bGw7XG5cbiAgZ2V0VG9rZW4oKTogc3RyaW5nIHwgbnVsbCB7XG4gICAgcmV0dXJuIHRoaXMudG9rZW47XG4gIH1cblxuICBzZXRUb2tlbih0b2tlbjogc3RyaW5nKTogdm9pZCB7XG4gICAgdGhpcy50b2tlbiA9IHRva2VuO1xuICB9XG5cbiAgcmVtb3ZlVG9rZW4oKTogdm9pZCB7XG4gICAgdGhpcy50b2tlbiA9IG51bGw7XG4gIH1cblxuICBnZXRSZWZyZXNoVG9rZW4oKTogc3RyaW5nIHwgbnVsbCB7XG4gICAgcmV0dXJuIHRoaXMucmVmcmVzaFRva2VuO1xuICB9XG5cbiAgc2V0UmVmcmVzaFRva2VuKHRva2VuOiBzdHJpbmcpOiB2b2lkIHtcbiAgICB0aGlzLnJlZnJlc2hUb2tlbiA9IHRva2VuO1xuICB9XG5cbiAgcmVtb3ZlUmVmcmVzaFRva2VuKCk6IHZvaWQge1xuICAgIHRoaXMucmVmcmVzaFRva2VuID0gbnVsbDtcbiAgfVxufVxuIl19