ngx-kel-agent 0.4.10 → 0.5.3

package/fesm2020/ngx-kel-agent.mjs

@@ -1,237 +1,162 @@
+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() {
-        // if we haven't heard from Hamlib in 15 seconds, consider it down
-        this.hamlibState$.pipe(debounceTime(15000)).subscribe(() => {
-            this.hamlibState$.next(false);
-        });
-        // When Hamlib goes down, clear its persistent message subjects
-        this.hamlibState$.subscribe((isUp) => {
-            if (!isUp) {
-                this.hamlibRigState$.next(null);
-            }
-        });
-    }
-    /** Connect (or reconnect) the websocket to the kel-agent server. */
-    connect() {
-        if (this.agentWebsocketSubscription) {
-            this.agentWebsocketSubscription.unsubscribe();
-        }
-        this.agentHost = this.getHost();
-        this.agentPort = this.getPort();
-        const protocol = this.agentHost === 'localhost' ? 'ws://' : 'wss://';
-        this.agentWebSocketSubject = webSocket({
-            url: protocol + this.agentHost + ':' + this.agentPort + '/websocket',
-        });
-        this.connectedState$.next(true);
-        this.agentWebsocketSubscription = this.agentWebSocketSubject
-            .pipe(retryWhen((errors) => 
-        // retry the websocket connection after 10 seconds
-        errors.pipe(tap(() => this.connectedState$.next(false)), delay(10000))))
-            .subscribe({
-            next: (msg) => {
-                this.connectedState$.next(true);
-                this.handleMessage(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.wsjtx) {
+            return;
         }
-        if (msg.hamlib !== null) {
-            this.hamlibState$.next(true);
-            switch (msg.hamlib.type) {
-                case 'RigState':
-                    this.hamlibRigState$.next(msg.hamlib.payload);
-                    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;
         }
     }
-    /** Get the currently configured kel-agent host. */
-    getHost() {
-        return localStorage.getItem(this.localStorageHostKey) || this.defaultAgentHost;
-    }
-    /** Get the currently configured kel-agent port. */
-    getPort() {
-        let portStr = localStorage.getItem(this.localStoragePortKey);
-        if (portStr == null) {
-            return this.defaultAgentPort;
-        }
-        let portNum = parseInt(portStr, 10);
-        if (isNaN(portNum)) {
-            return this.defaultAgentPort;
-        }
-        return portNum;
-    }
-    /** Set the kel-agent host. */
-    setHost(host) {
-        localStorage.setItem(this.localStorageHostKey, host);
-        this.connect();
-    }
-    /** Set the kel-agent port. */
-    setPort(port) {
-        localStorage.setItem(this.localStoragePortKey, String(port));
-        this.connect();
-    }
     /** Send a command to WSJT-X to clear the Band Activity window. */
-    sendWsjtxClearBandActivity() {
+    clearBandActivity() {
         const wsMsg = {
             wsjtx: {
                 type: 'ClearMessage',
                 payload: { id: this.wsjtxId, window: 0 },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
     }
     /** Send a command to WSJT-X to clear the Rx Frequency window. */
-    sendWsjtxClearRxFreqWindow() {
+    clearRxFreqWindow() {
         const wsMsg = {
             wsjtx: {
                 type: 'ClearMessage',
                 payload: { id: this.wsjtxId, window: 1 },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
     }
     /** Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows. */
-    sendWsjtxClearAll() {
+    clearAll() {
         const wsMsg = {
             wsjtx: {
                 type: 'ClearMessage',
                 payload: { id: this.wsjtxId, window: 2 },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        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. */
-    sendWsjtxReplay() {
+    replay() {
         const wsMsg = {
             wsjtx: {
                 type: 'ReplayMessage',
                 payload: { id: this.wsjtxId },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
     }
     /** Send a command to WSJT-X to halt any transmissions immediately. */
-    sendWsjtxHaltTxNow() {
+    haltTxNow() {
         const wsMsg = {
             wsjtx: {
                 type: 'HaltTxMessage',
                 payload: { id: this.wsjtxId, autoTxOnly: false },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
     }
     /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round. */
-    sendWsjtxHaltTxAfterCurrent() {
+    haltTxAfterCurrent() {
         const wsMsg = {
             wsjtx: {
                 type: 'HaltTxMessage',
                 payload: { id: this.wsjtxId, autoTxOnly: true },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
     }
     /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */
-    sendWsjtxReply(decode) {
+    reply(decode) {
         const wsMsg = {
             wsjtx: {
                 type: 'ReplyMessage',
@@ -247,10 +172,10 @@ class AgentService {
                 },
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
     }
     /** Send a command to WSJT-X to reply to the given decode. The message must include CQ or QRZ. */
-    sendWsjtxHighlightCallsign(highlightMsg) {
+    highlightCallsign(highlightMsg) {
         highlightMsg.id = this.wsjtxId;
         const wsMsg = {
             wsjtx: {
@@ -258,32 +183,300 @@ class AgentService {
                 payload: highlightMsg,
             },
         };
-        this.agentWebSocketSubject?.next(wsMsg);
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /**
+     * Send a command to WSJT-X to transmit the given free text. If the text is too long to be
+     * encoded in a single message, it may be silently truncated. */
+    sendFreeText(freeText) {
+        freeText.id = this.wsjtxId;
+        const wsMsg = {
+            wsjtx: {
+                type: 'FreeTextMessage',
+                payload: freeText,
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to set the local station's Maidenhead grid. This is temporary,
+     * lasting only as long as WSJT-X is running. */
+    setLocation(grid) {
+        const wsMsg = {
+            wsjtx: {
+                type: 'LocationMessage',
+                payload: {
+                    id: this.wsjtxId,
+                    location: grid,
+                },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to switch to the named configuration. */
+    switchConfiguration(configName) {
+        const wsMsg = {
+            wsjtx: {
+                type: 'SwitchConfigurationMessage',
+                payload: {
+                    id: this.wsjtxId,
+                    configurationName: configName,
+                },
+            },
+        };
+        this.messages.txMessage$.next(wsMsg);
+    }
+    /** Send a command to WSJT-X to set the given configuration parameters. */
+    configure(config) {
+        config.id = this.wsjtxId;
+        const wsMsg = {
+            wsjtx: {
+                type: 'ConfigureMessage',
+                payload: config,
+            },
+        };
+        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 timeStr = this.formatTime(msg.time);
+        return `${timeStr} ${msg.snr.toString().padStart(3)} ${msg.deltaTime
+            .toFixed(1)
+            .padStart(4)} ${msg.deltaFrequency.toString().padStart(4)} ~  ${msg.message}`;
+    }
+    /** Given a time in milliseconds since midnight UTC, format as HHMMSS. */
+    static formatTime(time) {
+        const secondsSinceMidnight = Math.floor(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
+        return `${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}`;
     }
 }
-AgentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AgentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+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.connected$.pipe(debounceTime(15000)).subscribe(() => {
+            this.connected$.next(false);
+        });
+        // When Hamlib goes down, clear its persistent message subjects
+        this.connected$.subscribe((isUp) => {
+            if (!isUp) {
+                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) {
+            this.agentWebsocketSubscription.unsubscribe();
+        }
+        this.agentHost = this.getHost();
+        this.agentPort = this.getPort();
+        const protocol = this.agentHost === 'localhost' ? 'ws://' : 'wss://';
+        this.agentWebSocketSubject = webSocket({
+            url: protocol + this.agentHost + ':' + this.agentPort + '/websocket',
+        });
+        this.connectedState$.next(true);
+        this.agentWebsocketSubscription = this.agentWebSocketSubject
+            .pipe(retryWhen((errors) => 
+        // retry the websocket connection after 10 seconds
+        errors.pipe(tap(() => this.connectedState$.next(false)), delay(10000))))
+            .subscribe({
+            next: (msg) => {
+                this.connectedState$.next(true);
+                this.messages.rxMessage$.next(msg);
+            },
+            error: () => this.connectedState$.next(false),
+            complete: () => this.connectedState$.next(false),
+        });
+    }
+    /** Get the currently configured kel-agent host. */
+    getHost() {
+        return (localStorage.getItem(this.localStorageHostKey) || this.defaultAgentHost);
+    }
+    /** Get the currently configured kel-agent port. */
+    getPort() {
+        let portStr = localStorage.getItem(this.localStoragePortKey);
+        if (portStr == null) {
+            return this.defaultAgentPort;
+        }
+        let portNum = parseInt(portStr, 10);
+        if (isNaN(portNum)) {
+            return this.defaultAgentPort;
+        }
+        return portNum;
+    }
+    /** Set the kel-agent host. */
+    setHost(host) {
+        localStorage.setItem(this.localStorageHostKey, host);
+        this.connect();
+    }
+    /** Set the kel-agent port. */
+    setPort(port) {
+        localStorage.setItem(this.localStoragePortKey, String(port));
+        this.connect();
+    }
+    send(wsMsg) {
+        this.agentWebSocketSubject?.next(wsMsg);
+    }
+    /**
+     * 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() {
+        this.wsjtxService.clearRxFreqWindow();
+    }
+    /**
+     * Send a command to WSJT-X to clear the Band Activity and Rx Frequency windows.
+     *
+     * @deprecated Use {@link WsjtxService.clearAll} instead.
+     */
+    sendWsjtxClearAll() {
+        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.
+     *
+     * @deprecated Use {@link WsjtxService.replay} instead.
+     */
+    sendWsjtxReplay() {
+        this.wsjtxService.replay();
+    }
+    /**
+     * Send a command to WSJT-X to halt any transmissions immediately.
+     *
+     * @deprecated Use {@link WsjtxService.haltTxNow} instead.
+     */
+    sendWsjtxHaltTxNow() {
+        this.wsjtxService.haltTxNow();
+    }
+    /** Send a command to WSJT-X to stop auto-transmitting after finishing the current round.
+     *
+     * @deprecated Use {@link WsjtxService.haltTxAfterCurrent} instead.
+     */
+    sendWsjtxHaltTxAfterCurrent() {
+        this.wsjtxService.haltTxAfterCurrent();
+    }
+    /**
+     * 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) {
+        return WsjtxService.formatDecode(msg);
+    }
+}
+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
@@ -295,5 +488,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AgentService };
+export { AgentMessageService, AgentService, HamlibService, WsjtxService };
 //# sourceMappingURL=ngx-kel-agent.mjs.map