@robdobsn/raftjs 1.8.5 → 1.11.5

package/src/RaftStruct.ts

@@ -0,0 +1,282 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftStruct
+// Part of RaftJS
+//
+// Rob Dobson 2024
+// (C) 2024 All rights reserved
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type FormatInstruction = 
+    | { kind: "endian"; littleEndian: boolean }
+    | { kind: "spec"; code: string; repeat: number };
+
+function parseFormatInstructions(format: string): FormatInstruction[] {
+    const instructions: FormatInstruction[] = [];
+    let idx = 0;
+
+    while (idx < format.length) {
+
+        const char = format[idx];
+
+        // Endianness specifiers
+        if (char === "<" || char === ">") {
+            instructions.push({ kind: "endian", littleEndian: char === "<" });
+            idx++;
+            continue;
+        }
+
+        // Ignore whitespace
+        if (/\s/.test(char)) {
+            idx++;
+            continue;
+        }
+
+        // Attribute code
+        const code = char;
+        idx++;
+
+        // Check for repeat count using [N] syntax
+        let repeat = 1;
+        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) {
+                throw new Error(`Invalid repeat count "${repeatStr}" in format string "${format}"`);
+            }
+            idx = endIdx + 1;
+        }
+
+        instructions.push({ kind: "spec", code, repeat });
+    }
+
+    return instructions;
+}
+
+export function structUnpack(format: string, data: Uint8Array): number[] {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const results: number[] = [];
+    let offset = 0;
+    let littleEndian = false;
+
+    const instructions = parseFormatInstructions(format);
+
+    for (const instruction of instructions) {
+        if (instruction.kind === "endian") {
+            littleEndian = instruction.littleEndian;
+            continue;
+        }
+
+        const { code, repeat } = instruction;
+
+        for (let count = 0; count < repeat; count++) {
+            switch (code) {
+                case "x": // Padding byte
+                    offset += 1;
+                    break;
+                case "c": // Char
+                case "B": // Unsigned 8-bit integer
+                case "?": // Boolean (stored as uint8)
+                    results.push(view.getUint8(offset));
+                    offset += 1;
+                    break;
+                case "b": // Signed 8-bit integer
+                    results.push(view.getInt8(offset));
+                    offset += 1;
+                    break;
+                case "h": // Signed 16-bit integer
+                    results.push(view.getInt16(offset, littleEndian));
+                    offset += 2;
+                    break;
+                case "H": // Unsigned 16-bit integer
+                    results.push(view.getUint16(offset, littleEndian));
+                    offset += 2;
+                    break;
+                case "i": // Signed 32-bit integer
+                case "l": // Signed 32-bit integer
+                    results.push(view.getInt32(offset, littleEndian));
+                    offset += 4;
+                    break;
+                case "I": // Unsigned 32-bit integer
+                case "L": // Unsigned 32-bit integer
+                    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 "f": // 32-bit float
+                    results.push(view.getFloat32(offset, littleEndian));
+                    offset += 4;
+                    break;
+                case "d": // 64-bit float
+                    results.push(view.getFloat64(offset, littleEndian));
+                    offset += 8;
+                    break;
+                default:
+                    throw new Error(`Unknown format character: ${code}`);
+            }
+        }
+    }
+
+    return results;
+}
+
+export function structSizeOf(format: string): number {
+    let size = 0;
+    const instructions = parseFormatInstructions(format);
+
+    for (const instruction of instructions) {
+        if (instruction.kind === "endian") {
+            continue;
+        }
+
+        const { code, repeat } = instruction;
+        let unitSize: number;
+
+        switch (code) {
+            case "x": // Padding byte
+            case "c": // Char
+            case "b": // Signed 8-bit integer
+            case "B": // Unsigned 8-bit integer
+            case "?": // Boolean (uint8)
+                unitSize = 1;
+                break;
+            case "h": // Signed 16-bit integer
+            case "H": // Unsigned 16-bit integer
+                unitSize = 2;
+                break;
+            case "i": // Signed 32-bit integer
+            case "I": // Unsigned 32-bit integer
+            case "l": // Signed 32-bit integer
+            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 "f": // 32-bit float
+                unitSize = 4;
+                break;
+            case "d": // 64-bit float
+                unitSize = 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${code}`);
+        }
+
+        size += unitSize * repeat;
+    }
+    return size;
+}
+
+export function structPack(format: string, values: number[]): Uint8Array {
+    const size = structSizeOf(format);
+    const buffer = new ArrayBuffer(size);
+    const view = new DataView(buffer);
+    let offset = 0;
+    let littleEndian = false;
+
+    const instructions = parseFormatInstructions(format);
+    let valueIdx = 0;
+
+    for (const instruction of instructions) {
+        if (instruction.kind === "endian") {
+            littleEndian = instruction.littleEndian;
+            continue;
+        }
+
+        const { code, repeat } = instruction;
+
+        for (let count = 0; count < repeat; count++) {
+            switch (code) {
+                case "x": // Padding byte
+                    offset += 1;
+                    break;
+                case "c": // Char
+                case "b": // Signed 8-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setInt8(offset, values[valueIdx++]);
+                    offset += 1;
+                    break;
+                case "B": // Unsigned 8-bit integer
+                case "?": // Boolean (uint8)
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setUint8(offset, values[valueIdx++]);
+                    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);
+                    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);
+                    offset += 2;
+                    break;
+                case "i": // Signed 32-bit integer
+                case "l": // Signed 32-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setInt32(offset, values[valueIdx++], littleEndian);
+                    offset += 4;
+                    break;
+                case "I": // Unsigned 32-bit integer
+                case "L": // Unsigned 32-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setUint32(offset, values[valueIdx++], 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 "f": // 32-bit float
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setFloat32(offset, values[valueIdx++], 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);
+                    offset += 8;
+                    break;
+                default:
+                    throw new Error(`Unknown format character: ${code}`);
+            }
+        }
+    }
+
+    return new Uint8Array(buffer);
+}

package/src/RaftSysTypeManager.ts

@@ -0,0 +1,87 @@
+import { RaftSystemType } from "./RaftSystemType";
+
+type RaftSystemTypeCreator = () => RaftSystemType;
+
+export default class RaftSysTypeManager {
+  // Singleton instance
+  private static _instance: RaftSysTypeManager;
+
+  // System type map
+  private _sysTypes: Map<string, RaftSystemTypeCreator> = new Map();
+  private _defaultSysTypeFactory: RaftSystemTypeCreator | null = null;
+
+  // Get instance (Singleton)
+  public static getInstance(): RaftSysTypeManager {
+    if (!RaftSysTypeManager._instance) {
+      RaftSysTypeManager._instance = new RaftSysTypeManager();
+    }
+    return RaftSysTypeManager._instance;
+  }
+
+  // Add a system type by name with its factory
+  public addSystemType(sysType: string, factory: RaftSystemTypeCreator): void {
+    if (this._sysTypes.has(sysType)) {
+      throw new Error(`System type '${sysType}' is already registered.`);
+    }
+    this._sysTypes.set(sysType, factory);
+  }
+
+  // Set the default system type factory
+  public addDefaultSystemType(factory: RaftSystemTypeCreator): void {
+    this._defaultSysTypeFactory = factory;
+  }
+
+  // Create a system type by name
+  public createSystemType(sysType: string): RaftSystemType | null {
+    const factory = this._sysTypes.get(sysType);
+    if (!factory) {
+      return null;
+    }
+    return factory();
+  }
+
+  // Create the default system type
+  public createDefaultSystemType(): RaftSystemType | null {
+    if (!this._defaultSysTypeFactory) {
+      return null;
+    }
+    return this._defaultSysTypeFactory();
+  }
+
+  // Get a list of all unique BLE service UUIDs
+  getAllServiceUUIDs(): string[] {
+    const serviceUUIDs = new Set<string>();
+    this._sysTypes.forEach((factory) => {
+      const sysType = factory();
+      if (!sysType.BLEServiceUUIDs) {
+        return;
+      }
+      sysType.BLEServiceUUIDs.forEach((uuid) => serviceUUIDs.add(uuid));
+    });
+    return Array.from(serviceUUIDs);
+  }
+
+  // Get a list of all device name prefixes to filter on
+  getAllNamePrefixes(): string[] {
+    const deviceNames = new Set<string>();
+    this._sysTypes.forEach((factory) => {
+      const sysType = factory();
+      if (!sysType.BLEDeviceNames) {
+        return;
+      }
+      sysType.BLEDeviceNames.forEach((name) => deviceNames.add(name));
+    });
+    return Array.from(deviceNames);
+  }
+
+  // Find the system type for a given BLE device name prefix
+  getSystemTypeByBLENamePrefix(name: string): RaftSystemType | null {
+    for (const factory of this._sysTypes.values()) {
+      const sysType = factory();
+      if (sysType.BLEDeviceNames && sysType.BLEDeviceNames.some((prefix) => name.startsWith(prefix))) {
+        return sysType;
+      }
+    }
+    return null;
+  }
+}

package/src/RaftSystemType.ts

@@ -0,0 +1,34 @@
+import RaftDeviceMgrIF from "./RaftDeviceMgrIF";
+import RaftSystemUtils from "./RaftSystemUtils";
+import { RaftEventFn } from "./RaftTypes";
+
+export type RaftSubscribeForUpdatesCBType = (systemUtils: RaftSystemUtils, enable: boolean) => Promise<void>;
+export type RaftStateIsInvalidCBType = () => void;
+export type RaftRxOtherMsgType = (payload: Uint8Array, _frameTimeMs: number) => void;
+
+export interface ConnectorOptions {
+  wsSuffix?: string;
+  connTimeoutMs?: number;
+  bleConnItvlMs?: number;
+  bleUuid?: string;
+}
+
+export interface RaftSystemType {
+  nameForDialogs: string;
+  defaultWiFiHostname?: string;
+  BLEServiceUUIDs?: string[];
+  BLECmdUUID?: string;
+  BLERespUUID?: string;
+  BLEDeviceNames?: string[];
+  firmwareDestName?: string;
+  normalFileDestName?: string;
+  connectorOptions: ConnectorOptions;
+  setup: (systemUtils: RaftSystemUtils, onEvent: RaftEventFn | null) => void;
+  subscribeForUpdates: RaftSubscribeForUpdatesCBType | null;
+  stateIsInvalid: RaftStateIsInvalidCBType | null;
+  rxOtherMsgType: RaftRxOtherMsgType | null;
+  deviceMgrIF?: RaftDeviceMgrIF;
+  nonRaftTypeCode?: string;
+}
+
+export type RaftGetSystemTypeCBType = (systemUtils: RaftSystemUtils) => Promise<RaftSystemType | null>;