ota-hub-reactjs 0.0.16 → 0.0.19

package/dist/base/device-whisperer.d.ts

@@ -13,6 +13,10 @@ export type DeviceConnectionState = {
     uuid: string;
     deviceMac?: string;
     name: string;
+    /**
+     * Default device send helper.
+     * This is a utility function which may better be replaced with transport specific send functions (e.g. MQTT has publish, Serial has write etc.)
+     */
     send: (data: string | Uint8Array) => void | Promise<void>;
     onReceive?: (data: string | Uint8Array) => void;
     onConnect?: () => void | Promise<void>;
@@ -29,8 +33,10 @@ export type DeviceWhispererProps<T extends DeviceConnectionState> = {
     createInitialConnectionState?: (uuid: string) => Partial<T>;
 };
 export declare function MultiDeviceWhisperer<T extends DeviceConnectionState>({ createInitialConnectionState, }?: DeviceWhispererProps<T>): {
+    focussedConnection: string | undefined;
+    setFocussedConnection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     connections: T[];
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<T>) => Promise<string>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<T>) => Promise<string>;
     removeConnection: (uuid: string) => void;
     connect: (_uuid: string) => void;
     disconnect: (_uuid: string) => void;

package/dist/base/device-whisperer.js

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { useEffect, useRef, useState } from "react";
-;
 // Initial, generic state for the generic device
 export function createDefaultInitialDeviceState(uuid, props) {
     return {
@@ -11,7 +10,7 @@ export function createDefaultInitialDeviceState(uuid, props) {
         logs: [],
         readBufferLeftover: "",
         readBufferLeftoverAsBytes: new Uint8Array([]),
-        ...props
+        ...props,
     };
 }
 /* One Device Whisperer is used for all like-devices, such as all Serial with Protobuf.
@@ -21,6 +20,7 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
     const [connections, setConnections] = useState([]);
     const connectionsRef = useRef(new Map());
     const [isReady, setIsReady] = useState(false);
+    const [focussedConnection, setFocussedConnection] = useState();
     // ---------- GET ----------
     const getConnection = (uuid) => connectionsRef.current.get(uuid);
     // ---------- UPDATE ----------
@@ -44,13 +44,13 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
         }));
     };
     // ---------- ADD ----------
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         uuid = uuid ?? `unnamed_device_${connectionsRef.current.size}`;
         const props = propCreator?.(uuid);
         const newConnection = {
             ...createDefaultInitialDeviceState(uuid),
             ...createInitialConnectionState(uuid),
-            ...props
+            ...props,
         };
         connectionsRef.current.set(uuid, newConnection);
         setConnections(Array.from(connectionsRef.current.values()));
@@ -67,6 +67,8 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
         setConnections(Array.from(connectionsRef.current.values()));
     }, []);
     return {
+        focussedConnection,
+        setFocussedConnection,
         connections,
         addConnection,
         removeConnection,
@@ -79,6 +81,6 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
         appendLog,
         isReady,
         setIsReady,
-        createInitialConnectionState
+        createInitialConnectionState,
     };
 }

package/dist/message_layers/protobuf-wrapper.d.ts

@@ -16,9 +16,11 @@ export type ProtobufDeviceWhispererProps<AppLayer extends DeviceConnectionState,
     expectLength?: boolean;
 };
 export declare function ProtobufMultiDeviceWhisperer<AppLayer extends DeviceConnectionState, Topic extends string | number, MessageRX = any, MessageTX = any>({ transportLayer, encodeRX, decodeTX, messageTypeField, rxTopicHandlerMap, HEADER, }: ProtobufDeviceWhispererProps<AppLayer, Topic, MessageRX, MessageTX>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppLayer>) => Promise<string>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppLayer>) => Promise<string>;
     sendProtobuf: (uuid: string, message: MessageTX) => void;
     protoBufOnReceiveHandler: (uuid: string, data: string | Uint8Array) => void;
+    focussedConnection: string | undefined;
+    setFocussedConnection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     connections: AppLayer[];
     removeConnection: (uuid: string) => void;
     connect: (_uuid: string) => void;

package/dist/message_layers/protobuf-wrapper.js

@@ -10,7 +10,7 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
         const length = payload.length;
         const header = new Uint8Array([
             (length >> 8) & 0xff, // Most significant byte first
-            length & 0xff // Least significant byte second
+            length & 0xff, // Least significant byte second
         ]);
         return concatUint8Arrays(header, payload);
     };
@@ -55,9 +55,7 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
     // --- Inbound buffering ---
     const buffers = {};
     const protoBufOnReceiveHandler = (uuid, data) => {
-        const bytes = typeof data === "string"
-            ? new TextEncoder().encode(data)
-            : data;
+        const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
         buffers[uuid] = concatUint8Arrays(buffers[uuid] || new Uint8Array(), bytes);
         let buffer = buffers[uuid];
         while (buffer.length > 0) {
@@ -73,14 +71,14 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
                     catch (err) {
                         transportLayer.appendLog(uuid, {
                             level: 0,
-                            message: `[!] Error in handler for topic "${topic}": ${err}`
+                            message: `[!] Error in handler for topic "${topic}": ${err}`,
                         });
                     }
                 }
                 else {
                     transportLayer.appendLog(uuid, {
                         level: 1,
-                        message: `[!] Unknown Protobuf topic: "${topic}"`
+                        message: `[!] Unknown Protobuf topic: "${topic}"`,
                     });
                 }
                 buffer = buffers[uuid];
@@ -97,7 +95,7 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
                 if (text) {
                     transportLayer.appendLog(uuid, {
                         level: 2,
-                        message: text
+                        message: text,
                     });
                 }
                 continue;
@@ -108,11 +106,11 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
                 buffers[uuid] = buffer;
                 const preview = Array.from(garbage)
                     .slice(0, 16)
-                    .map(b => b.toString(16).padStart(2, '0'))
-                    .join(' ');
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join(" ");
                 transportLayer.appendLog(uuid, {
                     level: 1,
-                    message: `[!] Skipped invalid bytes before Protobuf header: ${preview}... (${garbage.length} bytes)`
+                    message: `[!] Skipped invalid bytes before Protobuf header: ${preview}... (${garbage.length} bytes)`,
                 });
                 continue;
             }
@@ -121,22 +119,22 @@ export function ProtobufMultiDeviceWhisperer({ transportLayer, encodeRX, decodeT
         buffers[uuid] = buffer;
     };
     // --- Override addConnection to wrap onReceive ---
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         return await transportLayer.addConnection({
             uuid,
             propCreator: (id) => {
                 const props = propCreator?.(id);
                 return {
                     onReceive: (data) => protoBufOnReceiveHandler(id, data),
-                    ...props
+                    ...props,
                 };
-            }
+            },
         });
     };
     return {
         ...transportLayer,
         addConnection,
         sendProtobuf,
-        protoBufOnReceiveHandler
+        protoBufOnReceiveHandler,
     };
 }

package/dist/transport_layers/esp32-device-whisperer.d.ts

@@ -18,7 +18,7 @@ export type FlashFirmwareProps = {
 export declare function ESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP32ConnectionState>({ releasePortByDefault, ...props }?: {
     releasePortByDefault: boolean;
 } & DeviceWhispererProps<AppOrMessageLayer>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string, baudrate?: number, restart_on_connect?: boolean) => Promise<void>;
     disconnect: (uuid: string, timeout?: number) => Promise<void>;
@@ -27,6 +27,8 @@ export declare function ESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP3
         blob: Blob;
         address: number;
     }[]) => Promise<void>;
+    focussedConnection: string | undefined;
+    setFocussedConnection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     connections: AppOrMessageLayer[];
     updateConnection: (uuid: string, updater: (c: AppOrMessageLayer) => AppOrMessageLayer) => void;
     updateConnectionName: (uuid: string, name: string) => void;

package/dist/transport_layers/esp32-device-whisperer.js

@@ -1,12 +1,10 @@
 import { useEffect } from "react";
 import { ESPLoader, Transport } from "esptool-js";
-import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
+import { MultiDeviceWhisperer, } from "../base/device-whisperer.js";
 export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = { releasePortByDefault: true }) {
     const base = MultiDeviceWhisperer(props);
     const defaultOnReceive = (uuid, data) => {
-        const text = typeof data === "string"
-            ? data
-            : new TextDecoder().decode(data);
+        const text = typeof data === "string" ? data : new TextDecoder().decode(data);
         const trimmed = text.trim();
         if (!trimmed)
             return;
@@ -45,7 +43,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                     console.log("Kack!");
                     return;
                 }
-                ;
                 const { value, done } = await reader.next();
                 if (done || !value)
                     break;
@@ -54,7 +51,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                     const b = bytes[i];
                     if (inSlipFrame) {
                         // SLIP decoding
-                        if (b === 0xC0) {
+                        if (b === 0xc0) {
                             if (slipBuffer.length > 0) {
                                 // complete SLIP frame received
                                 const payload = new Uint8Array(slipBuffer);
@@ -75,10 +72,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                             escapeNext = false;
                         }
                         else if (escapeNext) {
-                            if (b === 0xDC)
-                                slipBuffer.push(0xC0);
-                            else if (b === 0xDD)
-                                slipBuffer.push(0xDB);
+                            if (b === 0xdc)
+                                slipBuffer.push(0xc0);
+                            else if (b === 0xdd)
+                                slipBuffer.push(0xdb);
                             else {
                                 // protocol violation: discard frame
                                 slipBuffer = [];
@@ -86,7 +83,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                             }
                             escapeNext = false;
                         }
-                        else if (b === 0xDB) {
+                        else if (b === 0xdb) {
                             escapeNext = true;
                         }
                         else {
@@ -94,7 +91,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                         }
                         continue;
                     }
-                    if (b === 0xC0 && conn.slipReadWrite) {
+                    if (b === 0xc0 && conn.slipReadWrite) {
                         // start of a SLIP frame
                         inSlipFrame = true;
                         slipBuffer = [];
@@ -102,7 +99,9 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                         continue;
                     }
                     // treat as normal text (correctly)
-                    readBuffer += textDecoder.decode(new Uint8Array([b]), { stream: true });
+                    readBuffer += textDecoder.decode(new Uint8Array([b]), {
+                        stream: true,
+                    });
                     // check for newline
                     let newlineIndex;
                     while ((newlineIndex = readBuffer.indexOf("\n")) >= 0) {
@@ -149,11 +148,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         let port = conn?.port;
         if (!port) {
             port = await navigator.serial.requestPort({
-                filters: [{ usbVendorId: 0x303a }]
+                filters: [{ usbVendorId: 0x303a }],
             });
             base.updateConnection(uuid, (c) => ({ ...c, port }));
         }
-        ;
         base.updateConnection(uuid, (c) => ({ ...c, isConnecting: true }));
         const use_baudrate = baudrate ?? conn.baudrate ?? 115200;
         const transport = new Transport(port, false, false);
@@ -161,7 +159,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             const esploader = new ESPLoader({
                 transport,
                 baudrate: use_baudrate,
-                enableTracing: false
+                enableTracing: false,
             });
             try {
                 await esploader.main();
@@ -170,7 +168,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 console.log("failed to esploader.main()", e);
                 return;
             }
-            ;
             try {
                 const mac = await esploader.chip.readMac(esploader);
                 console.log("Mac from device:", mac);
@@ -182,7 +179,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             if (restart_on_connect) {
                 await restartDevice(uuid, transport);
             }
-            ;
             base.updateConnection(uuid, (c) => ({
                 ...c,
                 transport,
@@ -192,7 +188,7 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             }));
             base.appendLog(uuid, {
                 level: 2,
-                message: "[✓] Serial connected"
+                message: "[✓] Serial connected",
             });
             await conn.onConnect?.();
             await readLoop(uuid, transport);
@@ -201,11 +197,11 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             base.updateConnection(uuid, (c) => ({
                 ...c,
                 isConnected: false,
-                isConnecting: false
+                isConnecting: false,
             }));
             base.appendLog(uuid, {
                 level: 0,
-                message: `[x] Serial connection error: ${err?.message || "Unknown error"}`
+                message: `[x] Serial connection error: ${err?.message || "Unknown error"}`,
             });
             await disconnect(uuid);
         }
@@ -235,24 +231,47 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         }));
         await conn?.onDisconnect?.();
     };
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         const port = await navigator.serial.requestPort({
-            filters: [{ usbVendorId: 0x303a }]
+            filters: [{ usbVendorId: 0x303a }],
         });
+        let deviceId = uuid;
+        // If no UUID provided, try to read the MAC address before registering the connection
+        if (!uuid) {
+            // 1. Interrogate the port for the MAC address BEFORE registering the connection
+            try {
+                const tempTransport = new Transport(port, false, false);
+                const tempLoader = new ESPLoader({
+                    transport: tempTransport,
+                    baudrate: 115200,
+                    enableTracing: false,
+                });
+                await tempLoader.main();
+                const mac = await tempLoader.chip.readMac(tempLoader);
+                if (mac) {
+                    deviceId = mac; // Swap 'unnamed_device_0' for the actual MAC
+                }
+                // Disconnect to release the port so connect() can start fresh
+                await tempTransport.disconnect();
+            }
+            catch (e) {
+                console.warn("Failed to pre-fetch MAC address. Falling back to default UUID.", e);
+            }
+        }
+        // 2. Register the connection using the real MAC address
         const return_uuid = await base.addConnection({
-            uuid,
+            uuid: deviceId,
             propCreator: (id) => {
                 const props = propCreator?.(id);
                 return {
                     send: (d) => defaultSend(id, d),
                     onReceive: (d) => defaultOnReceive(id, d),
                     port,
-                    // Initial connection state
                     ...base.createInitialConnectionState(id),
-                    // From props
-                    ...props
+                    deviceMac: deviceId, // Lock it in immediately
+                    ...props,
                 };
-            }
+            },
         });
         const conn = base.getConnection(return_uuid);
         if (conn?.autoConnect)
@@ -264,11 +283,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             await disconnect(uuid);
         }
         catch (e) { }
-        ;
         base.removeConnection(uuid);
     };
     const reconnectAll = async (...connectionProps) => {
-        const connectionIds = base.connections.map(c => c.uuid);
+        const connectionIds = base.connections.map((c) => c.uuid);
         await Promise.all(connectionIds.map(async (id) => {
             const c = base.getConnection(id);
             if (!c)
@@ -284,14 +302,19 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         if (!conn || !conn.port || assetsToFlash.length === 0)
             return;
         await disconnect(uuid);
-        base.updateConnection(uuid, (c) => ({ ...c, isFlashing: true, flashProgress: 0, flashError: undefined }));
+        base.updateConnection(uuid, (c) => ({
+            ...c,
+            isFlashing: true,
+            flashProgress: 0,
+            flashError: undefined,
+        }));
         try {
             // --- Connect ONCE ---
             const transport = new Transport(conn.port, true);
             const esploader = new ESPLoader({
                 transport,
                 baudrate: 921600,
-                enableTracing: false
+                enableTracing: false,
             });
             try {
                 await esploader.main();
@@ -300,7 +323,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 console.log("failed to esploader.main()", e);
                 return;
             }
-            ;
             // --- Prepare an ARRAY of files for the library ---
             const fileArray = await Promise.all(assetsToFlash.map(async ({ blob, address }) => {
                 const arrayBuffer = await blob.arrayBuffer();
@@ -320,7 +342,10 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                     // You can enhance progress reporting to show which file is being flashed
                     const progress = (written / total) * 100;
                     console.log(`Flashing file ${fileIndex + 1}/${fileArray.length}: ${progress.toFixed(1)}%`);
-                    base.updateConnection(uuid, (c) => ({ ...c, flashProgress: progress }));
+                    base.updateConnection(uuid, (c) => ({
+                        ...c,
+                        flashProgress: progress,
+                    }));
                 },
             };
             // --- Call writeFlash ONCE with all files ---
@@ -331,7 +356,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
             catch (e) {
                 console.log("failed to esploader.writeFlash", e);
             }
-            ;
             // --- Disconnect ---
             await esploader.after();
             try {
@@ -343,7 +367,11 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
                 await conn.port?.writable?.close();
                 await conn.port?.close();
             }
-            base.updateConnection(uuid, (c) => ({ ...c, isFlashing: false, flashProgress: 100 }));
+            base.updateConnection(uuid, (c) => ({
+                ...c,
+                isFlashing: false,
+                flashProgress: 100,
+            }));
         }
         catch (e) {
             console.error(`[${uuid}] Flashing failed:`, e);
@@ -364,6 +392,6 @@ export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = {
         connect,
         disconnect,
         reconnectAll,
-        handleFlashFirmware
+        handleFlashFirmware,
     };
 }

package/dist/transport_layers/mqtt-device-whisperer.d.ts

@@ -1,10 +1,21 @@
 import { DeviceConnectionState, AddConnectionProps, DeviceWhispererProps } from "../base/device-whisperer.js";
+type MQTTPayload = string | Uint8Array | ArrayBuffer;
+type MQTTTopicCallback = (payload: MQTTPayload, topic: string) => void;
 export type MQTTConnectionState = DeviceConnectionState & {
+    /**
+     * Publishes a payload to any explicit MQTT topic.
+     */
+    publish?: (topic: string, payload: MQTTPayload) => void | Promise<void>;
+    /**
+     * Subscribes a callback for a specific topic. Returns an unsubscribe function.
+     */
+    subscribeCallbackToTopic?: (topic: string, callback: MQTTTopicCallback) => () => void;
     pingFunction?: (props?: any) => void;
     touchHeartbeat?: () => void;
 };
-export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTConnectionState>({ serverUrl, uuidFromMessage, subTopicFromUuid, pubTopicFromUuid, serverPort, clientId, username, password, serverAutoConnect, serverConnectOn, ...props }: {
-    serverUrl: string;
+export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTConnectionState>({ serverUrl, serverUrlFnc, uuidFromMessage, subTopicFromUuid, pubTopicFromUuid, serverPort, clientId, username, password, serverAutoConnect, serverConnectOn, enableWatchdog, ...props }: {
+    serverUrl?: string;
+    serverUrlFnc?: () => Promise<string> | string;
     uuidFromMessage: (topic: string, payload: Buffer<ArrayBufferLike>) => string;
     subTopicFromUuid?: (uuid: string) => string;
     pubTopicFromUuid?: (uuid: string) => string;
@@ -14,13 +25,16 @@ export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTC
     password?: string;
     serverAutoConnect?: boolean;
     serverConnectOn?: boolean;
+    enableWatchdog?: boolean;
 } & DeviceWhispererProps<AppOrMessageLayer>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string | undefined>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;
     reconnectAll: () => Promise<void>;
-    connectToMQTTServer: () => (() => void) | undefined;
+    connectToMQTTServer: () => Promise<void>;
+    focussedConnection: string | undefined;
+    setFocussedConnection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     connections: AppOrMessageLayer[];
     updateConnection: (uuid: string, updater: (c: AppOrMessageLayer) => AppOrMessageLayer) => void;
     updateConnectionName: (uuid: string, name: string) => void;
@@ -30,3 +44,4 @@ export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTC
     setIsReady: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     createInitialConnectionState: (uuid: string) => Partial<AppOrMessageLayer>;
 };
+export {};