tci-client-node 0.1.0 → 0.1.2

package/dist/index.js

@@ -48,28 +48,37 @@ function parseStreamFrame(input) {
   const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   const header = Array.from({ length: 16 }, (_, index) => view.getUint32(index * 4, true));
   const sampleType = normalizeSampleType(header[2]);
+  const streamType = normalizeStreamType(header[6]);
   let channels = header[7];
   const bytesPerSample = sampleTypeBytes(sampleType);
   const sampleCount = header[5];
   const actualPayloadLength = buffer.byteLength - TCI_STREAM_HEADER_BYTES;
   if (channels <= 0) {
-    const inferredChannels = sampleCount > 0 ? actualPayloadLength / sampleCount / bytesPerSample : 1;
-    if (!Number.isInteger(inferredChannels) || inferredChannels <= 0) {
-      throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+    if (streamType === 3 /* TX_CHRONO */ && actualPayloadLength === 0) {
+      channels = 1;
+    } else {
+      const inferredChannels = sampleCount > 0 ? actualPayloadLength / sampleCount / bytesPerSample : 1;
+      if (!Number.isInteger(inferredChannels) || inferredChannels <= 0) {
+        throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+      }
+      channels = inferredChannels;
     }
-    channels = inferredChannels;
-  }
-  const payloadLength = sampleCount * bytesPerSample * channels;
-  const expectedLength = TCI_STREAM_HEADER_BYTES + payloadLength;
-  if (buffer.byteLength !== expectedLength) {
-    throw new TciError(
-      "invalid-frame",
-      `TCI stream frame length mismatch: header says ${sampleCount} samples (${payloadLength} payload bytes), got ${buffer.byteLength - TCI_STREAM_HEADER_BYTES}`
-    );
   }
-  if (payloadLength % (bytesPerSample * channels) !== 0) {
+  const payloadLength = actualPayloadLength;
+  const alignedFrameBytes = bytesPerSample * channels;
+  if (payloadLength % alignedFrameBytes !== 0) {
     throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
   }
+  if (streamType !== 3 /* TX_CHRONO */) {
+    const expectedPerChannelPayloadLength = sampleCount * bytesPerSample * channels;
+    const expectedScalarPayloadLength = sampleCount * bytesPerSample;
+    if (payloadLength !== expectedPerChannelPayloadLength && payloadLength !== expectedScalarPayloadLength) {
+      throw new TciError(
+        "invalid-frame",
+        `TCI stream frame length mismatch: header says ${sampleCount} samples (${expectedPerChannelPayloadLength} payload bytes), got ${payloadLength}`
+      );
+    }
+  }
   return {
     receiver: header[0],
     sampleRate: header[1],
@@ -77,7 +86,7 @@ function parseStreamFrame(input) {
     codec: header[3],
     crc: header[4],
     payloadLength,
-    streamType: normalizeStreamType(header[6]),
+    streamType,
     channels,
     reserved: header.slice(8),
     payload: buffer.subarray(TCI_STREAM_HEADER_BYTES),
@@ -95,7 +104,11 @@ function buildStreamFrame(options) {
   if (payload.byteLength % (bytesPerSample * channels) !== 0) {
     throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
   }
-  const sampleCount = payload.byteLength / bytesPerSample / channels;
+  const derivedSampleCount = payload.byteLength / bytesPerSample / channels;
+  const sampleCount = options.sampleCount ?? derivedSampleCount;
+  if (!Number.isInteger(sampleCount) || sampleCount < 0) {
+    throw new TciError("invalid-frame", `Invalid TCI sample count: ${sampleCount}`);
+  }
   const frame = Buffer.alloc(TCI_STREAM_HEADER_BYTES + payload.byteLength);
   const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
   const reserved = options.reserved ?? [];
@@ -560,7 +573,11 @@ var TciClient = class extends EventEmitter {
       trx: options.trx ?? 0,
       vfo: options.vfo ?? 0,
       connectTimeoutMs: options.connectTimeoutMs ?? 5e3,
-      commandTimeoutMs: options.commandTimeoutMs ?? 1e3
+      commandTimeoutMs: options.commandTimeoutMs ?? 1e3,
+      writeAckMode: options.writeAckMode ?? "state",
+      writeTimeoutMs: options.writeTimeoutMs ?? 3e3,
+      writeSettleMs: options.writeSettleMs ?? 0,
+      frequencyWriteSettleMs: options.frequencyWriteSettleMs ?? 250
     };
     this.WebSocketImpl = options.WebSocketImpl ?? WebSocket;
     this.queue = new TciCommandQueue({
@@ -646,15 +663,55 @@ var TciClient = class extends EventEmitter {
     }
     return reply;
   }
-  async setFrequency(frequencyHz, receiver = this.options.receiver, vfo = this.options.vfo) {
-    await this.sendCommand("VFO", [receiver, vfo, Math.round(frequencyHz)]);
+  async sendStateWrite(name, args, isApplied, description = formatTciCommand(name, args).replace(/;$/, ""), options = {}) {
+    const ackMode = options.ackMode ?? this.options.writeAckMode;
+    if (ackMode === "reply") {
+      await this.sendCommand(name, args, { timeoutMs: options.timeoutMs });
+      return;
+    }
+    if (isApplied(this.getState())) {
+      return;
+    }
+    if (ackMode === "optimistic") {
+      await this.sendCommand(name, args, { waitForReply: false });
+      return;
+    }
+    const timeoutMs = options.timeoutMs ?? this.options.writeTimeoutMs;
+    const settleMs = options.settleMs ?? this.options.writeSettleMs;
+    const waiter = this.waitForState(isApplied, timeoutMs, settleMs, description);
+    try {
+      await this.sendCommand(name, args, { waitForReply: false });
+      await waiter.promise;
+    } catch (error) {
+      waiter.cancel();
+      throw error;
+    }
+  }
+  async setFrequency(frequencyHz, receiver = this.options.receiver, vfo = this.options.vfo, options = {}) {
+    const frequency = Math.round(frequencyHz);
+    const key = rxVfoKey(receiver, vfo);
+    await this.sendStateWrite(
+      "VFO",
+      [receiver, vfo, frequency],
+      (state) => state.frequencies[key] === frequency,
+      `VFO:${receiver},${vfo},${frequency}`,
+      { settleMs: this.options.frequencyWriteSettleMs, ...options }
+    );
   }
   async getFrequency(receiver = this.options.receiver, vfo = this.options.vfo) {
     const reply = await this.request("VFO", [receiver, vfo]);
     return parseNumber(reply.args[2]) ?? this.state.frequencies[rxVfoKey(receiver, vfo)];
   }
-  async setMode(mode, receiver = this.options.receiver) {
-    await this.sendCommand("MODULATION", [receiver, mode.toUpperCase()]);
+  async setMode(mode, receiver = this.options.receiver, options = {}) {
+    const normalizedMode = mode.toUpperCase();
+    const key = rxVfoKey(receiver, this.options.vfo);
+    await this.sendStateWrite(
+      "MODULATION",
+      [receiver, normalizedMode],
+      (state) => state.modes[key]?.toLowerCase() === normalizedMode.toLowerCase(),
+      `MODULATION:${receiver},${normalizedMode}`,
+      options
+    );
   }
   async getMode(receiver = this.options.receiver) {
     const reply = await this.request("MODULATION", [receiver]);
@@ -664,7 +721,13 @@ var TciClient = class extends EventEmitter {
   async setPtt(enabled, options = {}) {
     const trx = options.trx ?? this.options.trx;
     const args = options.source ? [trx, enabled, options.source] : [trx, enabled];
-    await this.sendCommand("TRX", args);
+    await this.sendStateWrite(
+      "TRX",
+      args,
+      (state) => state.ptt[String(trx)] === enabled,
+      `TRX:${trx},${enabled}`,
+      options
+    );
   }
   async getPtt(trx = this.options.trx) {
     const reply = await this.request("TRX", [trx]);
@@ -716,6 +779,20 @@ var TciClient = class extends EventEmitter {
     const frame = buildTxAudioFrame({ receiver: this.options.receiver, ...options });
     this.sendRawBinary(frame);
   }
+  sendTxAudioForChrono(request, samples) {
+    const channels = Math.max(1, Math.floor(request.channels || 1));
+    const targetSampleLength = Math.max(0, Math.floor(request.sampleCount) * channels);
+    const output = new Float32Array(targetSampleLength);
+    const source = samples instanceof Float32Array ? samples : Float32Array.from(samples);
+    output.set(source.subarray(0, output.length));
+    this.sendTxAudio({
+      receiver: request.receiver,
+      sampleRate: request.sampleRate,
+      sampleType: request.sampleType,
+      channels,
+      samples: output
+    });
+  }
   async setRxSensorsEnabled(enabled, intervalMs) {
     const args = intervalMs === void 0 ? [enabled] : [enabled, intervalMs];
     await this.sendCommand("RX_SENSORS_ENABLE", args, { waitForReply: false });
@@ -733,6 +810,75 @@ var TciClient = class extends EventEmitter {
   async stopCw() {
     await this.sendCommand("CW_MACROS_STOP");
   }
+  waitForState(predicate, timeoutMs, settleMs, description) {
+    let timeout;
+    let settleTimeout;
+    let resolved = false;
+    let resolvePromise;
+    let rejectPromise;
+    const cleanup = () => {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+      if (settleTimeout) {
+        clearTimeout(settleTimeout);
+        settleTimeout = void 0;
+      }
+      this.off("state", onState);
+      this.off("disconnected", onDisconnected);
+    };
+    const resolveNow = () => {
+      resolved = true;
+      cleanup();
+      resolvePromise();
+    };
+    const check = () => {
+      if (!predicate(this.getState())) {
+        if (settleTimeout) {
+          clearTimeout(settleTimeout);
+          settleTimeout = void 0;
+        }
+        return;
+      }
+      if (settleMs <= 0) {
+        resolveNow();
+        return;
+      }
+      if (settleTimeout) {
+        return;
+      }
+      settleTimeout = setTimeout(() => {
+        settleTimeout = void 0;
+        if (predicate(this.getState())) {
+          resolveNow();
+        }
+      }, settleMs);
+    };
+    const onState = () => check();
+    const onDisconnected = () => {
+      if (resolved) {
+        return;
+      }
+      cleanup();
+      rejectPromise(new TciError("disconnected", `Disconnected while waiting for TCI state ${description}`));
+    };
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+      timeout = setTimeout(() => {
+        cleanup();
+        reject(new TciError("command-timeout", `Timed out waiting for TCI state ${description}`));
+      }, timeoutMs);
+      this.on("state", onState);
+      this.on("disconnected", onDisconnected);
+      check();
+    });
+    return {
+      promise,
+      cancel: cleanup
+    };
+  }
   waitForOpen(ws) {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
@@ -783,6 +929,7 @@ var TciClient = class extends EventEmitter {
     if (!ws || ws.readyState !== WebSocket.OPEN) {
       throw new TciError("not-connected", "TCI socket is not connected");
     }
+    this.emit("tci:tx", raw);
     await new Promise((resolve, reject) => {
       ws.send(raw, (error) => error ? reject(error) : resolve());
     });
@@ -800,7 +947,9 @@ var TciClient = class extends EventEmitter {
         this.handleBinary(data);
         return;
       }
-      const commands = parseTciText(dataToBuffer(data));
+      const raw = dataToBuffer(data).toString("utf8");
+      const commands = parseTciText(raw);
+      this.emit("tci:rx", raw, commands);
       for (const command of commands) {
         this.queue.handleCommand(command);
         this.applyCommand(command);
@@ -812,6 +961,7 @@ var TciClient = class extends EventEmitter {
   }
   handleBinary(data) {
     const frame = parseStreamFrame(dataToBuffer(data));
+    this.emit("tci:binary", frame);
     this.emit("binary", frame);
     switch (frame.streamType) {
       case 1 /* RX_AUDIO_STREAM */: