@robdobsn/raftjs 1.3.2 → 1.5.0

package/src/RaftDeviceManager.ts

@@ -11,11 +11,10 @@ import { DeviceAttributeState, DevicesState, DeviceState, getDeviceKey } from ".
 import { DeviceMsgJson } from "./RaftDeviceMsg";
 import { RaftOKFail } from './RaftTypes';
 import { DeviceTypeInfo, DeviceTypeAction, DeviceTypeInfoRecs, RaftDevTypeInfoResponse } from "./RaftDeviceInfo";
-import struct, { DataType } from 'python-struct';
 import AttributeHandler from "./RaftAttributeHandler";
 import RaftSystemUtils from "./RaftSystemUtils";
 import RaftDeviceMgrIF from "./RaftDeviceMgrIF";
-import { Buffer } from 'buffer';
+import { structPack } from "./RaftStruct";
 
 export class DeviceManager implements RaftDeviceMgrIF{
 
@@ -130,7 +129,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
 
     public handleClientMsgJson(jsonMsg: string) {
 
-        let data = JSON.parse(jsonMsg) as DeviceMsgJson;
+        const data = JSON.parse(jsonMsg) as DeviceMsgJson;
         // console.log(`DeviceManager websocket message ${JSON.stringify(data)}`);
 
         // Iterate over the buses
@@ -221,9 +220,6 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     // Convert the hex string to an arraybuffer by converting each pair of hex chars to a byte
                     const msgBytes = this.hexToBytes(msgHexStr);
 
-                    // Convert to a Buffer
-                    const msgBuffer = Buffer.from(msgBytes);
-
                     // Work through the message which may contain multiple data instances
                     let msgBufIdx = 0;
 
@@ -234,7 +230,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
                     while (msgBufIdx < msgBytes.length) {
 
                         const curTimelineLen = deviceState.deviceTimeline.timestampsUs.length;
-                        const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(msgBuffer, msgBufIdx,
+                        const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(msgBytes, msgBufIdx,
                             deviceState.deviceTimeline, pollRespMetadata,
                             deviceState.deviceAttributes,
                             this._maxDatapointsToStore);
@@ -284,7 +280,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             }
 
             // Iterate over the attributes
-            Object.entries(deviceState.deviceAttributes).forEach(([_attrKey, attrState]) => {
+            Object.entries(deviceState.deviceAttributes).forEach(([, attrState]): void => {
                 if (attrState.newAttribute) {
                     if (this._callbackNewDeviceAttribute) {
                         this._callbackNewDeviceAttribute(
@@ -352,14 +348,20 @@ export class DeviceManager implements RaftDeviceMgrIF{
     // Send action to device
     ////////////////////////////////////////////////////////////////////////////
 
-    public async sendAction(deviceKey: string, action: DeviceTypeAction, data: DataType[]): Promise<boolean> {
+    private toHex(data: Uint8Array): string {
+        return Array.from(data)
+            .map(byte => byte.toString(16).padStart(2, "0"))
+            .join("");
+    }
+
+    public async sendAction(deviceKey: string, action: DeviceTypeAction, data: number[]): Promise<boolean> {
         // console.log(`DeviceManager sendAction ${deviceKey} action name ${action.n} value ${value} prefix ${action.w}`);
 
         // Form the write bytes
-        let writeBytes = action.t ? struct.pack(action.t, data) : Buffer.from([]);
+        const writeBytes = action.t ? structPack(action.t, data) : new Uint8Array(0);
 
         // Convert to hex string
-        let writeHexStr = Buffer.from(writeBytes).toString('hex');
+        let writeHexStr = this.toHex(writeBytes);
 
         // Add prefix
         writeHexStr = action.w + writeHexStr;
@@ -393,13 +395,13 @@ export class DeviceManager implements RaftDeviceMgrIF{
     // Send a compound action to the device
     ////////////////////////////////////////////////////////////////////////////
 
-    public async sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: DataType[][]): Promise<boolean> {
+    public async sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: number[][]): Promise<boolean> {
         // console.log(`DeviceManager sendAction ${deviceKey} action name ${action.n} value ${value} prefix ${action.w}`);
 
         // Check if all data to be sent at once
         if (action.concat) {
             // Form a single list by flattening data
-            let dataToWrite: DataType[] = [];
+            let dataToWrite: number[] = [];
             for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
                 dataToWrite = dataToWrite.concat(data[dataIdx]);
             }
@@ -412,7 +414,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
 
                 // Create the data to write by prepending the index to the data for this index
-                let dataToWrite = [dataIdx as DataType].concat(data[dataIdx]);
+                const dataToWrite = [dataIdx as number].concat(data[dataIdx]);
 
                 // Use sendAction to send this
                 allOk = allOk && await this.sendAction(deviceKey, action, dataToWrite);
@@ -432,5 +434,4 @@ export class DeviceManager implements RaftDeviceMgrIF{
         }
         return bytes;
     }
-
 }

package/src/RaftDeviceMgrIF.ts

@@ -7,7 +7,6 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import { DataType } from "python-struct";
 import { DeviceTypeAction } from "./RaftDeviceInfo";
 import { DeviceAttributeState, DevicesState, DeviceState } from "./RaftDeviceStates";
 
@@ -23,6 +22,6 @@ export default interface RaftDeviceMgrIF {
     onNewAttributeData(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
 
     // Send action to device
-    sendAction(deviceKey: string, action: DeviceTypeAction, data: DataType[]): void;
-    sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: DataType[][]): void;
+    sendAction(deviceKey: string, action: DeviceTypeAction, data: number[]): void;
+    sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: number[][]): void;
 }

package/src/RaftDeviceStates.ts

@@ -30,7 +30,7 @@ export function deviceAttrGetLatestFormatted(attrState: DeviceAttributeState): s
             decimalPlaces = parseInt(parts[1], 10);
         }
         const formattedNumber = value.toFixed(decimalPlaces);
-        let fieldWidth = parseInt(parts[0], 10);
+        const fieldWidth = parseInt(parts[0], 10);
         return fieldWidth ? formattedNumber.padStart(fieldWidth, ' ') : formattedNumber;
     } else if (format.endsWith('x')) {
         // Hexadecimal formatting

package/src/RaftMsgHandler.ts

@@ -571,7 +571,6 @@ export default class RaftMsgHandler {
     // if (msgRsltCode === RaftMsgResultCode.MESSAGE_RESULT_OK) {
     const resolve = this._msgTrackInfos[msgNum].resolve;
     if (resolve) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       RaftLog.verbose(`_msgCompleted msgNum ${msgNum} result ${msgRsltCode.toString()} ${JSON.stringify(msgRsltObj)}`);
       (resolve as ((arg: object | null) => void))(msgRsltObj);
     }
@@ -679,7 +678,7 @@ export default class RaftMsgHandler {
     // RICREST protocol
     msgBuf[msgBufPos++] = RICRESTElemCode.RICREST_ELEM_CODE_FILEBLOCK;
 
-    // Buffer header
+    // Header
     msgBuf[msgBufPos++] = streamID & 0xff;
     msgBuf[msgBufPos++] = (blockStart >> 16) & 0xff;
     msgBuf[msgBufPos++] = (blockStart >> 8) & 0xff;

package/src/RaftStruct.ts

@@ -0,0 +1,208 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftStruct
+// Part of RaftJS
+//
+// Rob Dobson 2024
+// (C) 2024 All rights reserved
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+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;
+
+    for (const char of format) {
+        switch (char) {
+            case "<":
+                littleEndian = true;
+                break;
+            case ">":
+                littleEndian = false;
+                break;
+            case "x": // Padding byte
+                offset += 1;
+                break;
+            case "c": // Char
+                results.push(view.getUint8(offset));
+                offset += 1;
+                break;
+            case "b": // Signed 8-bit integer
+                results.push(view.getInt8(offset));
+                offset += 1;
+                break;
+            case "B": // Unsigned 8-bit integer
+                results.push(view.getUint8(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 (big-endian)
+                results.push(view.getUint16(offset, littleEndian));
+                offset += 2;
+                break;
+            case "i": // Signed 32-bit integer (big-endian)
+                results.push(view.getInt32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "I": // Unsigned 32-bit integer (big-endian)
+                results.push(view.getUint32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "l": // Signed 32-bit integer (big-endian)
+                results.push(view.getInt32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "L": // Unsigned 32-bit integer (big-endian)
+                results.push(view.getUint32(offset, littleEndian));
+                offset += 4;
+                break;
+            // case "q": // Signed 64-bit integer (big-endian)
+            //     results.push(view.getBigInt64(offset, littleEndian));
+            //     offset += 8;
+            //     break;
+            // case "Q": // Unsigned 64-bit integer (big-endian)
+            //     results.push(view.getBigUint64(offset, littleEndian));
+            //     offset += 8;
+            //     break;
+            case "f": // 32-bit float (big-endian)
+                results.push(view.getFloat32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "d": // 64-bit float (big-endian)
+                results.push(view.getFloat64(offset, littleEndian));
+                offset += 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${char}`);
+        }
+    }
+
+    return results;
+}
+
+export function structSizeOf(format: string): number {
+    let size = 0;
+    for (const char of format) {
+        switch (char) {
+            case "<":
+            case ">":
+                break;
+            case "x": // Padding byte
+                size += 1;
+                break;
+            case "c": // Char
+            case "b": // Signed 8-bit integer
+            case "B": // Unsigned 8-bit integer
+                size += 1;
+                break;
+            case "h": // Signed 16-bit integer
+            case "H": // Unsigned 16-bit integer
+                size += 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
+                size += 4;
+                break;
+            // case "q": // Signed 64-bit integer
+            // case "Q": // Unsigned 64-bit integer
+            //     size += 8;
+            //     break;
+            case "f": // 32-bit float
+                size += 4;
+                break;
+            case "d": // 64-bit float
+                size += 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${char}`);
+        }
+    }
+    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;
+
+    for (let i = 0; i < format.length; i++) {
+        const char = format[i];
+        const value = values[i];
+        switch (char) {
+            case "<":
+                littleEndian = true;
+                break;
+            case ">":
+                littleEndian = false;
+                break;
+            case "x": // Padding byte
+                offset += 1;
+                break;
+            case "c": // Char
+                view.setInt8(offset, value);
+                offset += 1;
+                break;
+            case "b": // Signed 8-bit integer
+                view.setInt8(offset, value);
+                offset += 1;
+                break;
+            case "B": // Unsigned 8-bit integer
+                view.setUint8(offset, value);
+                offset += 1;
+                break;
+            case "h": // Signed 16-bit integer
+                view.setInt16(offset, value, littleEndian);
+                offset += 2;
+                break;
+            case "H": // Unsigned 16-bit integer
+                view.setUint16(offset, value, littleEndian);
+                offset += 2;
+                break;
+            case "i": // Signed 32-bit integer
+                view.setInt32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "I": // Unsigned 32-bit integer
+                view.setUint32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "l": // Signed 32-bit integer
+                view.setInt32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "L": // Unsigned 32-bit integer
+                view.setUint32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            // case "q": // Signed 64-bit integer
+            //     view.setBigInt64(offset, BigInt(value), littleEndian);
+            //     offset += 8;
+            //     break;
+            // case "Q": // Unsigned 64-bit integer
+            //     view.setBigUint64(offset, BigInt(value), littleEndian);
+            //     offset += 8;
+            //     break;
+            case "f": // 32-bit float
+                view.setFloat32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "d": // 64-bit float
+                view.setFloat64(offset, value, littleEndian);
+                offset += 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${char}`);
+        }
+    }
+
+    return new Uint8Array(buffer);
+}

package/src/RaftSysTypeManager.ts

@@ -0,0 +1,60 @@
+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();
+      sysType.BLEServiceUUIDs.forEach((uuid) => serviceUUIDs.add(uuid));
+    });
+    return Array.from(serviceUUIDs);
+  }
+}

package/src/RaftSystemType.ts

@@ -16,6 +16,9 @@ export interface ConnectorOptions {
 export interface RaftSystemType {
   nameForDialogs: string;
   defaultWiFiHostname: string;
+  BLEServiceUUIDs: string[];
+  BLECmdUUID: string;
+  BLERespUUID: string;
   firmwareDestName: string;
   normalFileDestName: string;
   connectorOptions: ConnectorOptions;

package/src/RaftTypes.ts

@@ -248,7 +248,7 @@ export type PystatusMsgType = {
 };
 
 // Phone BLE 
-export class DiscoveredRIC {
+export class DiscoveredDevice {
   _localName = '';
   _name = '';
   _id = '';
@@ -278,4 +278,4 @@ export class DiscoveredRIC {
   }
 }
 
-export type DiscoveredRICsCB = (discoveredRICs: DiscoveredRIC[]) => void;
+export type DiscoveredDevicesCB = (discoveredDevicess: DiscoveredDevice[]) => void;

package/src/RaftUpdateManager.ts

@@ -8,7 +8,6 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import axios from "axios";
 import RaftChannel from "./RaftChannel";
 import RaftFileHandler from "./RaftFileHandler";
 import RaftLog from "./RaftLog";
@@ -91,8 +90,12 @@ export default class RICUpdateManager {
 
       // debug
       RaftLog.debug(`Update URL: ${updateURL}`);
-      const response = await axios.get(updateURL);
-      this._latestVersionInfo = response.data;
+      const response = await fetch(updateURL, { method: 'GET' });
+      if (!response.ok) {
+        RaftLog.debug(`HTTP error! status: ${response.status}`);
+        return RaftUpdateEvent.UPDATE_CANT_REACH_SERVER;
+      }
+      this._latestVersionInfo = await response.json();
     } catch (error) {
       RaftLog.debug(`Failed to get latest version from internet ${error}`);
     }

package/src/RaftUtils.ts

@@ -9,8 +9,6 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 import RaftLog from "./RaftLog";
-import semverGt from "semver/functions/gt";
-import semverEq from "semver/functions/eq";
 
 export default class RaftUtils {
   static _isEndianSet = false;
@@ -446,9 +444,21 @@ export default class RaftUtils {
     }
   }
 
+  static semverGt(v1: string, v2: string): boolean {
+    const [major1, minor1, patch1] = v1.split('.').map(Number);
+    const [major2, minor2, patch2] = v2.split('.').map(Number);
+    if (major1 !== major2) return major1 > major2;
+    if (minor1 !== minor2) return minor1 > minor2;
+    return patch1 > patch2;
+  }
+
   static isVersionGreater(v1: string, v2: string) {
     try {
-      return semverGt(v1, v2);
+      const [major1, minor1, patch1] = v1.split('.').map(Number);
+      const [major2, minor2, patch2] = v2.split('.').map(Number);
+      if (major1 !== major2) return major1 > major2;
+      if (minor1 !== minor2) return minor1 > minor2;
+      return patch1 > patch2;
     } catch (e) {
       // one of the two versions is invalid, return true
       RaftLog.warn(`isVersionGreater - invalid version ${v1} or ${v2} ${e}`);
@@ -458,7 +468,7 @@ export default class RaftUtils {
 
   static isVersionEqual(v1: string, v2: string) {
     try {
-      return semverEq(v1, v2);
+      return v1 === v2;
     } catch (e) {
       // one of the two versions is invalid, return false
       RaftLog.error(`isVersionEqual - invalid version ${v1} or ${v2} ${e}`);

package/src/main.ts

@@ -23,9 +23,9 @@ export { default as RaftMsgHandler } from './RaftMsgHandler'
 export { default as RaftStreamHandler } from './RaftStreamHandler';
 export { default as RaftSystemUtils } from './RaftSystemUtils';
 export { default as RaftUtils } from './RaftUtils';
+export { default as RaftSysTypeManager } from './RaftSysTypeManager';
 export { DeviceManager as RaftDeviceManager } from './RaftDeviceManager';
 
-
 export * from './RaftTypes';
 export * from './RaftSystemType';
 export * from './RaftWifiTypes';