@robdobsn/raftjs 1.10.7 → 1.11.6

package/src/RaftStruct.ts

@@ -33,22 +33,40 @@ function parseFormatInstructions(format: string): FormatInstruction[] {
             continue;
         }
 
+        // Check for prefix digit count (e.g. 3H, 16s)
+        let repeat = 1;
+        if (/\d/.test(char)) {
+            let numStr = char;
+            idx++;
+            while (idx < format.length && /\d/.test(format[idx])) {
+                numStr += format[idx];
+                idx++;
+            }
+            repeat = parseInt(numStr, 10);
+            if (!Number.isFinite(repeat) || repeat <= 0) {
+                throw new Error(`Invalid prefix count "${numStr}" in format string "${format}"`);
+            }
+            if (idx >= format.length || /[\s<>\d]/.test(format[idx])) {
+                throw new Error(`Expected format code after prefix count "${numStr}" in format string "${format}"`);
+            }
+        }
+
         // Attribute code
-        const code = char;
-        idx++;
+        const code = /\d/.test(char) ? format[idx] : char;
+        if (/\d/.test(char)) idx++; else idx++;
 
-        // Check for repeat count using [N] syntax
-        let repeat = 1;
+        // Check for [N] suffix count (e.g. B[3]) — multiplied with any prefix count
         if (idx < format.length && format[idx] === "[") {
             const endIdx = format.indexOf("]", idx + 1);
             if (endIdx === -1) {
                 throw new Error(`Invalid format string: missing closing ] in "${format}"`);
             }
             const repeatStr = format.slice(idx + 1, endIdx);
-            repeat = parseInt(repeatStr, 10);
-            if (!Number.isFinite(repeat) || repeat <= 0) {
+            const bracketRepeat = parseInt(repeatStr, 10);
+            if (!Number.isFinite(bracketRepeat) || bracketRepeat <= 0) {
                 throw new Error(`Invalid repeat count "${repeatStr}" in format string "${format}"`);
             }
+            repeat *= bracketRepeat;
             idx = endIdx + 1;
         }
 
@@ -58,9 +76,9 @@ function parseFormatInstructions(format: string): FormatInstruction[] {
     return instructions;
 }
 
-export function structUnpack(format: string, data: Uint8Array): number[] {
+export function structUnpack(format: string, data: Uint8Array): (number | string)[] {
     const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    const results: number[] = [];
+    const results: (number | string)[] = [];
     let offset = 0;
     let littleEndian = false;
 
@@ -107,14 +125,14 @@ export function structUnpack(format: string, data: Uint8Array): number[] {
                     results.push(view.getUint32(offset, littleEndian));
                     offset += 4;
                     break;
-                // case "q": // Signed 64-bit integer
-                //     results.push(Number(view.getBigInt64(offset, littleEndian)));
-                //     offset += 8;
-                //     break;
-                // case "Q": // Unsigned 64-bit integer
-                //     results.push(Number(view.getBigUint64(offset, littleEndian)));
-                //     offset += 8;
-                //     break;
+                case "q": // Signed 64-bit integer
+                    results.push(Number(view.getBigInt64(offset, littleEndian)));
+                    offset += 8;
+                    break;
+                case "Q": // Unsigned 64-bit integer
+                    results.push(Number(view.getBigUint64(offset, littleEndian)));
+                    offset += 8;
+                    break;
                 case "f": // 32-bit float
                     results.push(view.getFloat32(offset, littleEndian));
                     offset += 4;
@@ -123,9 +141,20 @@ export function structUnpack(format: string, data: Uint8Array): number[] {
                     results.push(view.getFloat64(offset, littleEndian));
                     offset += 8;
                     break;
+                case "s": { // Byte string (repeat = byte length, produces one string value)
+                    const bytes = data.slice(offset, offset + repeat);
+                    // Trim trailing null bytes for C-string compatibility
+                    let end = bytes.length;
+                    while (end > 0 && bytes[end - 1] === 0) end--;
+                    results.push(new TextDecoder().decode(bytes.subarray(0, end)));
+                    offset += repeat;
+                    break;
+                }
                 default:
                     throw new Error(`Unknown format character: ${code}`);
             }
+            // For 's', the repeat is consumed as byte-length in one go
+            if (code === "s") break;
         }
     }
 
@@ -162,16 +191,19 @@ export function structSizeOf(format: string): number {
             case "L": // Unsigned 32-bit integer
                 unitSize = 4;
                 break;
-            // case "q": // Signed 64-bit integer
-            // case "Q": // Unsigned 64-bit integer
-            //     unitSize = 8;
-            //     break;
+            case "q": // Signed 64-bit integer
+            case "Q": // Unsigned 64-bit integer
+                unitSize = 8;
+                break;
             case "f": // 32-bit float
                 unitSize = 4;
                 break;
             case "d": // 64-bit float
                 unitSize = 8;
                 break;
+            case "s": // Byte string (repeat = byte length)
+                size += repeat;
+                continue;
             default:
                 throw new Error(`Unknown format character: ${code}`);
         }
@@ -181,7 +213,7 @@ export function structSizeOf(format: string): number {
     return size;
 }
 
-export function structPack(format: string, values: number[]): Uint8Array {
+export function structPack(format: string, values: (number | string | Uint8Array)[]): Uint8Array {
     const size = structSizeOf(format);
     const buffer = new ArrayBuffer(size);
     const view = new DataView(buffer);
@@ -209,7 +241,7 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setInt8(offset, values[valueIdx++]);
+                    view.setInt8(offset, values[valueIdx++] as number);
                     offset += 1;
                     break;
                 case "B": // Unsigned 8-bit integer
@@ -217,21 +249,21 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setUint8(offset, values[valueIdx++]);
+                    view.setUint8(offset, values[valueIdx++] as number);
                     offset += 1;
                     break;
                 case "h": // Signed 16-bit integer
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setInt16(offset, values[valueIdx++], littleEndian);
+                    view.setInt16(offset, values[valueIdx++] as number, littleEndian);
                     offset += 2;
                     break;
                 case "H": // Unsigned 16-bit integer
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setUint16(offset, values[valueIdx++], littleEndian);
+                    view.setUint16(offset, values[valueIdx++] as number, littleEndian);
                     offset += 2;
                     break;
                 case "i": // Signed 32-bit integer
@@ -239,7 +271,7 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setInt32(offset, values[valueIdx++], littleEndian);
+                    view.setInt32(offset, values[valueIdx++] as number, littleEndian);
                     offset += 4;
                     break;
                 case "I": // Unsigned 32-bit integer
@@ -247,34 +279,66 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setUint32(offset, values[valueIdx++], littleEndian);
+                    view.setUint32(offset, values[valueIdx++] as number, littleEndian);
                     offset += 4;
                     break;
-                // case "q": // Signed 64-bit integer
-                //     view.setBigInt64(offset, BigInt(values[valueIdx++]), littleEndian);
-                //     offset += 8;
-                //     break;
-                // case "Q": // Unsigned 64-bit integer
-                //     view.setBigUint64(offset, BigInt(values[valueIdx++]), littleEndian);
-                //     offset += 8;
-                //     break;
+                case "q": // Signed 64-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setBigInt64(offset, BigInt(values[valueIdx++] as number), littleEndian);
+                    offset += 8;
+                    break;
+                case "Q": // Unsigned 64-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setBigUint64(offset, BigInt(values[valueIdx++] as number), littleEndian);
+                    offset += 8;
+                    break;
                 case "f": // 32-bit float
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setFloat32(offset, values[valueIdx++], littleEndian);
+                    view.setFloat32(offset, values[valueIdx++] as number, littleEndian);
                     offset += 4;
                     break;
                 case "d": // 64-bit float
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setFloat64(offset, values[valueIdx++], littleEndian);
+                    view.setFloat64(offset, values[valueIdx++] as number, littleEndian);
                     offset += 8;
                     break;
+                case "s": { // Byte string (repeat = byte length, consumes one value)
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    const val = values[valueIdx++];
+                    let bytes: Uint8Array;
+                    if (val instanceof Uint8Array) {
+                        bytes = val;
+                    } else if (typeof val === "string") {
+                        bytes = new TextEncoder().encode(val);
+                    } else {
+                        throw new Error(`Expected string or Uint8Array for 's' format, got number`);
+                    }
+                    // Copy bytes, zero-pad if shorter than repeat
+                    const copyLen = Math.min(bytes.length, repeat);
+                    for (let j = 0; j < copyLen; j++) {
+                        view.setUint8(offset + j, bytes[j]);
+                    }
+                    for (let j = copyLen; j < repeat; j++) {
+                        view.setUint8(offset + j, 0);
+                    }
+                    offset += repeat;
+                    break;
+                }
                 default:
                     throw new Error(`Unknown format character: ${code}`);
             }
+            // For 's', the repeat is consumed as byte-length in one go
+            if (code === "s") break;
         }
     }
 

package/src/RaftSystemUtils.ts

@@ -20,6 +20,9 @@ import {
   RaftFileList,
   RaftFriendlyName,
   RaftOKFail,
+  RaftPubTopicRec,
+  RaftPubTopicsResponse,
+  RaftSubscriptionUpdateResponse,
   RaftSysModInfoBLEMan,
   RaftSystemInfo,
   RaftWifiScanResults,
@@ -40,6 +43,10 @@ export default class RaftSystemUtils {
   private _defaultWiFiHostname = "Raft";
   private _maxSecsToWaitForWiFiConn = 20;
 
+  // Publish topic index/name lookup tables (session scoped)
+  private _pubTopicIdxToName: { [idx: number]: string } = {};
+  private _pubTopicNameToIdx: { [name: string]: number } = {};
+
   /**
    * constructor
    * @param raftMsgHandler 
@@ -56,6 +63,58 @@ export default class RaftSystemUtils {
     return this._msgHandler;
   }
 
+  /**
+   * Update publish topic maps from topic records.
+   */
+  updatePublishTopicMap(topicRecs: Array<RaftPubTopicRec> | undefined): void {
+    if (!topicRecs || !Array.isArray(topicRecs)) {
+      return;
+    }
+    for (const topicRec of topicRecs) {
+      if (!topicRec || typeof topicRec.name !== "string" || typeof topicRec.idx !== "number") {
+        continue;
+      }
+      this._pubTopicIdxToName[topicRec.idx] = topicRec.name;
+      this._pubTopicNameToIdx[topicRec.name] = topicRec.idx;
+    }
+  }
+
+  /**
+   * Update publish topic maps from subscription response.
+   */
+  updatePublishTopicMapFromSubscriptionResponse(resp: RaftSubscriptionUpdateResponse | RaftOKFail | null | undefined): void {
+    if (!resp || typeof resp !== "object") {
+      return;
+    }
+    if ("topics" in resp) {
+      this.updatePublishTopicMap((resp as RaftSubscriptionUpdateResponse).topics);
+    }
+  }
+
+  /**
+   * Fetch publish topic map from firmware endpoint.
+   */
+  async refreshPublishTopicMap(): Promise<boolean> {
+    try {
+      const pubTopicsResp = await this._msgHandler.sendRICRESTURL<RaftPubTopicsResponse>("pubtopics");
+      if (pubTopicsResp && pubTopicsResp.rslt === "ok") {
+        this.updatePublishTopicMap(pubTopicsResp.topics);
+        return true;
+      }
+    } catch (error) {
+      RaftLog.debug(`refreshPublishTopicMap failed ${error}`);
+    }
+    return false;
+  }
+
+  getPublishTopicName(topicIndex: number): string | undefined {
+    return this._pubTopicIdxToName[topicIndex];
+  }
+
+  getPublishTopicIndex(topicName: string): number | undefined {
+    return this._pubTopicNameToIdx[topicName];
+  }
+
   /**
    * setDefaultWiFiHostname
    * @param defaultWiFiHostname

package/src/RaftTypes.ts

@@ -72,6 +72,31 @@ export class RaftOKFail {
   rslt = 'failComms';
 }
 
+export type RaftPubTopicRec = {
+  name: string;
+  idx: number;
+};
+
+export type RaftSubscriptionUpdateResponse = RaftOKFail & {
+  topics?: Array<RaftPubTopicRec>;
+};
+
+export type RaftPubTopicsResponse = RaftOKFail & {
+  topics?: Array<RaftPubTopicRec>;
+};
+
+export type RaftPublishFrameType = 'json' | 'binary' | 'unknown';
+
+export type RaftPublishFrameMeta = {
+  frameType: RaftPublishFrameType;
+  topicIndex?: number;
+  topicName?: string;
+  version?: number;
+  binaryHasEnvelope?: boolean;
+  binaryPayloadOffset?: number;
+  jsonString?: string;
+};
+
 export type RaftReportMsg = {
   msgType?: string;
   rslt?: string;
@@ -181,6 +206,8 @@ export class RaftSysModInfoBLEMan {
 
 export type RaftProgressCBType = (received: number, total: number) => void;
 
+export type RaftStreamDataProgressCBType = (sent: number, total: number, progress: number) => void;
+
 export class RaftFileDownloadResult {
   fileData: Uint8Array | null = null;
   downloadedOk = false;

package/src/main.ts

@@ -29,6 +29,7 @@ export { default as RaftDeviceMgrIF } from './RaftDeviceMgrIF';
 export { DeviceManager as RaftDeviceManager } from './RaftDeviceManager';
 export type { DeviceDecodedData } from './RaftDeviceManager';
 
+export * from './RaftPublish';
 export * from './RaftTypes';
 export * from './RaftSystemType';
 export * from './RaftWifiTypes';