ngx-kel-agent 0.4.5 → 0.5.0

package/fesm2020/ngx-kel-agent.mjs

@@ -1,83 +1,291 @@
+import { Subject, BehaviorSubject, ReplaySubject } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Injectable } from '@angular/core';
-import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
 import { debounceTime, retryWhen, tap, delay } from 'rxjs/operators';
 import { webSocket } from 'rxjs/webSocket';
 
-class AgentService {
+class AgentMessageService {
     constructor() {
-        /** Whether we're connected to the agent. */
-        this.connectedState$ = new BehaviorSubject(false);
-        /*  WSJT-X  */
+        this.rxMessage$ = new Subject();
+        this.txMessage$ = new Subject();
+    }
+}
+AgentMessageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentMessageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AgentMessageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentMessageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentMessageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class WsjtxService {
+    constructor(messages) {
+        this.messages = messages;
         /** Whether we're getting any messages from WSJT-X. */
-        this.wsjtxState$ = new BehaviorSubject(false);
+        this.connected$ = new BehaviorSubject(false);
         /** Subject for listening to WSJT-X "Heartbeat" messages. */
-        this.wsjtxHeartbeat$ = new ReplaySubject(1);
+        this.heartbeat$ = new ReplaySubject(1);
         /** Subject for listening to WSJT-X "Status" messages. */
-        this.wsjtxStatus$ = new ReplaySubject(1);
+        this.status$ = new ReplaySubject(1);
         /** Subject for listening to WSJT-X "Decode" messages. */
-        this.wsjtxDecode$ = new Subject();
+        this.decode$ = new Subject();
         /** Subject for listening to WSJT-X "Clear" messages. */
-        this.wsjtxClear$ = new Subject();
+        this.clear$ = new Subject();
         /** Subject for listening to WSJT-X "QsoLogged" messages. */
-        this.wsjtxQsoLogged$ = new Subject();
+        this.qsoLogged$ = new Subject();
         /** Subject for listening to WSJT-X "Close" messages. */
-        this.wsjtxClose$ = new Subject();
+        this.close$ = new Subject();
         /** Subject for listening to WSJT-X "WsprDecode" messages. */
-        this.wsjtxWsprDecode$ = new Subject();
+        this.wsprDecode$ = new Subject();
         /** Subject for listening to WSJT-X "LoggedAdif" messages. */
-        this.wsjtxLoggedAdif$ = new Subject();
-        /*  Hamlib  */
-        /** Whether we're getting any messages from Hamlib. */
-        this.hamlibState$ = new BehaviorSubject(false);
-        /** Subject for listening to Hamlib "RigState" messages. */
-        this.hamlibRigState$ = new BehaviorSubject(null);
-        this.defaultAgentHost = 'localhost';
-        this.defaultAgentPort = 8081;
-        this.localStorageHostKey = 'agent-host';
-        this.localStoragePortKey = 'agent-port';
-        this.agentHost = this.defaultAgentHost;
-        this.agentPort = this.defaultAgentPort;
-        this.agentWebSocketSubject = null;
-        this.agentWebsocketSubscription = null;
+        this.loggedAdif$ = new Subject();
         this.wsjtxId = 'WSJT-X';
+        this.setupBehaviors();
     }
-    init() {
-        this.agentHost = this.getHost();
-        this.agentPort = this.getPort();
-        this.setupWsjtxBehaviors();
-        this.setupHamlibBehaviors();
-        this.connect();
-    }
-    setupWsjtxBehaviors() {
+    setupBehaviors() {
+        this.messages.rxMessage$.subscribe((msg) => this.handleMessage(msg));
         // if we haven't heard from WSJT-X in 15 seconds, consider it "down"
-        this.wsjtxState$
+        this.connected$
             .pipe(debounceTime(15000))
-            .subscribe(() => this.wsjtxState$.next(false));
+            .subscribe(() => this.connected$.next(false));
         // When WSJT-X announces it's closing, set it to "down" immediately
-        this.wsjtxClose$.subscribe(() => {
-            this.wsjtxState$.next(false);
+        this.close$.subscribe(() => {
+            this.connected$.next(false);
         });
         // When WSJT-X goes down, clear its persistent message subjects
-        this.wsjtxState$.subscribe((isUp) => {
+        this.connected$.subscribe((isUp) => {
             if (!isUp) {
-                this.wsjtxHeartbeat$.next(null);
-                this.wsjtxStatus$.next(null);
+                this.heartbeat$.next(null);
+                this.status$.next(null);
             }
         });
     }
-    setupHamlibBehaviors() {
+    handleMessage(msg) {
+        if (!msg.wsjtx) {
+            return;
+        }
+        this.connected$.next(true);
+        this.wsjtxId = msg.wsjtx.payload.id;
+        switch (msg.wsjtx.type) {
+            case 'HeartbeatMessage':
+                this.heartbeat$.next(msg.wsjtx.payload);
+                return;
+            case 'StatusMessage':
+                this.status$.next(msg.wsjtx.payload);
+                return;
+            case 'DecodeMessage':
+                this.decode$.next(msg.wsjtx.payload);
+                return;
+            case 'ClearMessage':
+                this.clear$.next(msg.wsjtx.payload);
+                return;
+            case 'QsoLoggedMessage':
+                this.qsoLogged$.next(msg.wsjtx.payload);
+                return;
+            case 'CloseMessage':
+                this.close$.next(msg.wsjtx.payload);
+                return;
+            case 'WSPRDecodeMessage':
+                this.wsprDecode$.next(msg.wsjtx.payload);
+                return;
+            case 'LoggedAdifMessage':
+                this.loggedAdif$.next(msg.wsjtx.payload);
+                return;
+        }
+    }
+    /** Send a command to WSJT-X to clear the Band Activity window. */
+    clearBandActivity() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ClearMessage',
+                payload: { id: this.wsjtxId, window: 0 },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to clear the Rx Frequency window. */
+    clearRxFreqWindow() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ClearMessage',
+                payload: { id: this.wsjtxId, window: 1 },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows. */
+    clearAll() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ClearMessage',
+                payload: { id: this.wsjtxId, window: 2 },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to replay messages. Useful for a fresh client that wants to hear
+     * previous WSJT-X decodes. */
+    replay() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ReplayMessage',
+                payload: { id: this.wsjtxId },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to halt any transmissions immediately. */
+    haltTxNow() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'HaltTxMessage',
+                payload: { id: this.wsjtxId, autoTxOnly: false },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round. */
+    haltTxAfterCurrent() {
+        const wsMsg = {
+            wsjtx: {
+                type: 'HaltTxMessage',
+                payload: { id: this.wsjtxId, autoTxOnly: true },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */
+    reply(decode) {
+        const wsMsg = {
+            wsjtx: {
+                type: 'ReplyMessage',
+                payload: {
+                    id: decode.id,
+                    time: decode.time,
+                    snr: decode.snr,
+                    deltaTime: decode.deltaTime,
+                    deltaFrequency: decode.deltaFrequency,
+                    mode: decode.mode,
+                    message: decode.message,
+                    lowConfidence: decode.lowConfidence,
+                },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */
+    highlightCallsign(highlightMsg) {
+        highlightMsg.id = this.wsjtxId;
+        const wsMsg = {
+            wsjtx: {
+                type: 'HighlightCallsignMessage',
+                payload: highlightMsg,
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Given a decode message, format a string the same way as displayed in the WSJT-X Band
+     * Activity/Rx Frequency windows. */
+    static formatDecode(msg) {
+        const secondsSinceMidnight = Math.floor(msg.time / 1000);
+        const hours = Math.floor(secondsSinceMidnight / 3600);
+        const secondsSinceHour = secondsSinceMidnight - hours * 3600;
+        const minutes = Math.floor(secondsSinceHour / 60);
+        const seconds = secondsSinceHour - minutes * 60;
+        const timeStr = `${hours.toString().padStart(2, '0')}${minutes
+            .toString()
+            .padStart(2, '0')}${seconds.toString().padStart(2, '0')}`;
+        return `${timeStr} ${msg.snr.toString().padStart(3)} ${msg.deltaTime
+            .toFixed(1)
+            .padStart(4)} ${msg.deltaFrequency.toString().padStart(4)} ~  ${msg.message}`;
+    }
+}
+WsjtxService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: WsjtxService, deps: [{ token: AgentMessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+WsjtxService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: WsjtxService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: WsjtxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: AgentMessageService }]; } });
+
+class HamlibService {
+    constructor(messages) {
+        this.messages = messages;
+        /** Whether we're getting any messages from Hamlib. */
+        this.connected$ = new BehaviorSubject(false);
+        /** Subject for listening to Hamlib "RigState" messages. */
+        this.rigState$ = new BehaviorSubject(null);
+        this.setupBehaviors();
+    }
+    setupBehaviors() {
+        this.messages.rxMessage$.subscribe((msg) => this.handleMessage(msg));
         // if we haven't heard from Hamlib in 15 seconds, consider it down
-        this.hamlibState$.pipe(debounceTime(15000)).subscribe(() => {
-            this.hamlibState$.next(false);
+        this.connected$.pipe(debounceTime(15000)).subscribe(() => {
+            this.connected$.next(false);
         });
         // When Hamlib goes down, clear its persistent message subjects
-        this.hamlibState$.subscribe((isUp) => {
+        this.connected$.subscribe((isUp) => {
             if (!isUp) {
-                this.hamlibRigState$.next(null);
+                this.rigState$.next(null);
             }
         });
     }
+    handleMessage(msg) {
+        if (!msg.hamlib) {
+            return;
+        }
+        this.connected$.next(true);
+        switch (msg.hamlib.type) {
+            case 'RigState':
+                this.rigState$.next(msg.hamlib.payload);
+                return;
+        }
+    }
+}
+HamlibService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: HamlibService, deps: [{ token: AgentMessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+HamlibService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: HamlibService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: HamlibService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: AgentMessageService }]; } });
+
+class AgentService {
+    constructor(messages, hamlibService, wsjtxService) {
+        this.messages = messages;
+        this.hamlibService = hamlibService;
+        this.wsjtxService = wsjtxService;
+        /** Whether we're connected to the agent. */
+        this.connectedState$ = new BehaviorSubject(false);
+        this.defaultAgentHost = 'localhost';
+        this.defaultAgentPort = 8081;
+        this.localStorageHostKey = 'agent-host';
+        this.localStoragePortKey = 'agent-port';
+        this.agentHost = this.defaultAgentHost;
+        this.agentPort = this.defaultAgentPort;
+        this.agentWebSocketSubject = null;
+        this.agentWebsocketSubscription = null;
+        this.hamlibState$ = this.hamlibService.connected$;
+        this.hamlibRigState$ = this.hamlibService.rigState$;
+        this.wsjtxState$ = this.wsjtxService.connected$;
+        this.wsjtxHeartbeat$ = this.wsjtxService.heartbeat$;
+        this.wsjtxStatus$ = this.wsjtxService.status$;
+        this.wsjtxDecode$ = this.wsjtxService.decode$;
+        this.wsjtxClear$ = this.wsjtxService.clear$;
+        this.wsjtxQsoLogged$ = this.wsjtxService.qsoLogged$;
+        this.wsjtxClose$ = this.wsjtxService.close$;
+        this.wsjtxWsprDecode$ = this.wsjtxService.wsprDecode$;
+        this.wsjtxLoggedAdif$ = this.wsjtxService.loggedAdif$;
+    }
+    init() {
+        this.messages.txMessage$.subscribe((msg) => this.send(msg));
+        this.agentHost = this.getHost();
+        this.agentPort = this.getPort();
+        this.connect();
+    }
     /** Connect (or reconnect) the websocket to the kel-agent server. */
     connect() {
         if (this.agentWebsocketSubscription) {
@@ -97,55 +305,15 @@ class AgentService {
             .subscribe({
             next: (msg) => {
                 this.connectedState$.next(true);
-                this.handleMessage(msg);
+                this.messages.rxMessage$.next(msg);
             },
             error: () => this.connectedState$.next(false),
             complete: () => this.connectedState$.next(false),
         });
     }
-    handleMessage(msg) {
-        if (msg.wsjtx != null && msg.wsjtx.type != null) {
-            this.wsjtxState$.next(true);
-            this.wsjtxId = msg.wsjtx.payload.id;
-            switch (msg.wsjtx.type) {
-                case 'HeartbeatMessage':
-                    this.wsjtxHeartbeat$.next(msg.wsjtx.payload);
-                    return;
-                case 'StatusMessage':
-                    this.wsjtxStatus$.next(msg.wsjtx.payload);
-                    return;
-                case 'DecodeMessage':
-                    this.wsjtxDecode$.next(msg.wsjtx.payload);
-                    return;
-                case 'ClearMessage':
-                    this.wsjtxClear$.next(msg.wsjtx.payload);
-                    return;
-                case 'QsoLoggedMessage':
-                    this.wsjtxQsoLogged$.next(msg.wsjtx.payload);
-                    return;
-                case 'CloseMessage':
-                    this.wsjtxClose$.next(msg.wsjtx.payload);
-                    return;
-                case 'WSPRDecodeMessage':
-                    this.wsjtxWsprDecode$.next(msg.wsjtx.payload);
-                    return;
-                case 'LoggedAdifMessage':
-                    this.wsjtxLoggedAdif$.next(msg.wsjtx.payload);
-                    return;
-            }
-        }
-        if (msg.hamlib !== null) {
-            this.hamlibState$.next(true);
-            switch (msg.hamlib.type) {
-                case 'RigState':
-                    this.hamlibRigState$.next(msg.hamlib.payload);
-                    return;
-            }
-        }
-    }
     /** Get the currently configured kel-agent host. */
     getHost() {
-        return localStorage.getItem(this.localStorageHostKey) || this.defaultAgentHost;
+        return (localStorage.getItem(this.localStorageHostKey) || this.defaultAgentHost);
     }
     /** Get the currently configured kel-agent port. */
     getPort() {
@@ -169,98 +337,101 @@ class AgentService {
         localStorage.setItem(this.localStoragePortKey, String(port));
         this.connect();
     }
-    /** Send a command to WSJT-X to clear the Band Activity window. */
-    sendWsjtxClearBandActivity() {
-        const wsMsg = {
-            wsjtx: {
-                type: 'ClearMessage',
-                payload: { id: this.wsjtxId, window: 0 },
-            },
-        };
+    send(wsMsg) {
         this.agentWebSocketSubject?.next(wsMsg);
     }
-    /** Send a command to WSJT-X to clear the Rx Frequency window. */
+    /**
+     * Send a command to WSJT-X to clear the Band Activity window.
+     *
+     * @deprecated Use {@link WsjtxService.clearBandActivity} instead.
+     */
+    sendWsjtxClearBandActivity() {
+        this.wsjtxService.clearBandActivity();
+    }
+    /**
+     * Send a command to WSJT-X to clear the Rx Frequency window.
+     *
+     * @deprecated Use {@link WsjtxService.clearRxFreqWindow} instead.
+     */
     sendWsjtxClearRxFreqWindow() {
-        const wsMsg = {
-            wsjtx: {
-                type: 'ClearMessage',
-                payload: { id: this.wsjtxId, window: 1 },
-            },
-        };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.wsjtxService.clearRxFreqWindow();
     }
-    /** Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows. */
+    /**
+     * Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows.
+     *
+     * @deprecated Use {@link WsjtxService.clearAll} instead.
+     */
     sendWsjtxClearAll() {
-        const wsMsg = {
-            wsjtx: {
-                type: 'ClearMessage',
-                payload: { id: this.wsjtxId, window: 2 },
-            },
-        };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.wsjtxService.clearAll();
     }
-    /** Send a command to WSJT-X to replay messages. Useful for a fresh client that wants to hear
-     * previous WSJT-X decodes. */
+    /**
+     * Send a command to WSJT-X to replay messages. Useful for a fresh client that wants to hear
+     * previous WSJT-X decodes.
+     *
+     * @deprecated Use {@link WsjtxService.replay} instead.
+     */
     sendWsjtxReplay() {
-        const wsMsg = {
-            wsjtx: {
-                type: 'ReplayMessage',
-                payload: { id: this.wsjtxId },
-            },
-        };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.wsjtxService.replay();
     }
-    /** Send a command to WSJT-X to halt any transmissions immediately. */
+    /**
+     * Send a command to WSJT-X to halt any transmissions immediately.
+     *
+     * @deprecated Use {@link WsjtxService.haltTxNow} instead.
+     */
     sendWsjtxHaltTxNow() {
-        const wsMsg = {
-            wsjtx: {
-                type: 'HaltTxMessage',
-                payload: { id: this.wsjtxId, autoTxOnly: false },
-            },
-        };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.wsjtxService.haltTxNow();
     }
-    /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round. */
+    /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round.
+     *
+     * @deprecated Use {@link WsjtxService.haltTxAfterCurrent} instead.
+     */
     sendWsjtxHaltTxAfterCurrent() {
-        const wsMsg = {
-            wsjtx: {
-                type: 'HaltTxMessage',
-                payload: { id: this.wsjtxId, autoTxOnly: true },
-            },
-        };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.wsjtxService.haltTxAfterCurrent();
     }
-    /** Given a decode message, format a string the same way as displayed in the WSJT-X Band
-     * Activity/Rx Frequency windows. */
+    /**
+     * Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ.
+     *
+     * @deprecated Use {@link WsjtxService.reply} instead.
+     */
+    sendWsjtxReply(decode) {
+        this.wsjtxService.reply(decode);
+    }
+    /**
+     * Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ.
+     *
+     * @deprecated Use {@link WsjtxService.highlightCallsign} instead.
+     */
+    sendWsjtxHighlightCallsign(highlightMsg) {
+        this.wsjtxService.highlightCallsign(highlightMsg);
+    }
+    /**
+     * Given a decode message, format a string the same way as displayed in the WSJT-X Band
+     * Activity/Rx Frequency windows.
+     *
+     * @deprecated Use {@link WsjtxService.formatDecode} instead.
+     */
     static formatDecode(msg) {
-        const secondsSinceMidnight = Math.floor(msg.time / 1000);
-        const hours = Math.floor(secondsSinceMidnight / 3600);
-        const secondsSinceHour = secondsSinceMidnight - hours * 3600;
-        const minutes = Math.floor(secondsSinceHour / 60);
-        const seconds = secondsSinceHour - minutes * 60;
-        const timeStr = `${hours.toString().padStart(2, '0')}${minutes
-            .toString()
-            .padStart(2, '0')}${seconds.toString().padStart(2, '0')}`;
-        return `${timeStr} ${msg.snr.toString().padStart(3)} ${msg.deltaTime
-            .toFixed(1)
-            .padStart(4)} ${msg.deltaFrequency.toString().padStart(4)} ~  ${msg.message}`;
+        return WsjtxService.formatDecode(msg);
     }
 }
-AgentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AgentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentService, deps: [{ token: AgentMessageService }, { token: HamlibService }, { token: WsjtxService }], target: i0.ɵɵFactoryTarget.Injectable });
 AgentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return []; } });
+        }], ctorParameters: function () { return [{ type: AgentMessageService }, { type: HamlibService }, { type: WsjtxService }]; } });
 
 /*
  * Public API Surface of ngx-kel-agent
  */
+// export * from './lib/ngx-kel-agent.component';
+// export * from './lib/ngx-kel-agent.module';
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AgentService };
+export { AgentMessageService, AgentService, HamlibService, WsjtxService };
+//# sourceMappingURL=ngx-kel-agent.mjs.map