ota-hub-reactjs 0.0.18 → 0.0.19

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

@@ -36,7 +36,7 @@ export declare function MultiDeviceWhisperer<T extends DeviceConnectionState>({
     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.
@@ -45,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()));
@@ -82,6 +81,6 @@ export function MultiDeviceWhisperer({ createInitialConnectionState = createDefa
         appendLog,
         isReady,
         setIsReady,
-        createInitialConnectionState
+        createInitialConnectionState,
     };
 }

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

@@ -16,7 +16,7 @@ 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;

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>;

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

@@ -13,8 +13,9 @@ export type MQTTConnectionState = DeviceConnectionState & {
     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;
@@ -24,13 +25,14 @@ 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[];

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

@@ -1,10 +1,12 @@
 import { useEffect, useRef } from "react";
-import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
+import { MultiDeviceWhisperer, } from "../base/device-whisperer.js";
 import mqtt from "mqtt";
-export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicFromUuid = undefined, pubTopicFromUuid = undefined, serverPort = 8883, clientId = undefined, username = undefined, password = undefined, serverAutoConnect = true, serverConnectOn = false, ...props }) {
+export function MQTTMultiDeviceWhisperer({ serverUrl, serverUrlFnc, uuidFromMessage, subTopicFromUuid = undefined, pubTopicFromUuid = undefined, serverPort = 443, clientId = undefined, username = undefined, password = undefined, serverAutoConnect = true, serverConnectOn = false, enableWatchdog = true, ...props }) {
     const base = MultiDeviceWhisperer(props);
     const clientRef = useRef(null);
     const isUnmountedRef = useRef(false);
+    // ✨ NEW: Manage our own reconnect timer
+    const reconnectTimeoutRef = useRef(null);
     const watchdogTimers = useRef({});
     const addingConnections = useRef(new Set());
     const topicCallbacksRef = useRef(new Map());
@@ -84,47 +86,71 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
             }
         };
     };
-    const connectToMQTTServer = () => {
+    const connectToMQTTServer = async () => {
+        if (!serverUrl && !serverUrlFnc) {
+            console.error("MQTT MultiDeviceWhisperer requires either serverUrl or serverUrlFnc");
+            return;
+        }
+        if (reconnectTimeoutRef.current)
+            clearTimeout(reconnectTimeoutRef.current);
         isUnmountedRef.current = false;
         if (clientRef.current) {
             if (clientRef.current.connected) {
                 base.setIsReady(true);
                 return;
             }
+            clientRef.current.removeAllListeners();
             clientRef.current.end(true);
         }
         try {
-            const new_client = mqtt.connect(serverUrl, {
+            const finalUrl = serverUrlFnc ? await serverUrlFnc() : serverUrl;
+            if (!finalUrl)
+                throw new Error("Generated MQTT URL was undefined.");
+            const options = {
                 port: serverPort,
                 clientId: clientId,
                 username,
                 password,
                 clean: true,
                 keepalive: 30,
-                reconnectPeriod: 3000,
-            });
+                reconnectPeriod: 0, // We now handle this ourselves
+            };
+            const new_client = mqtt.connect(finalUrl, options);
             new_client.on("connect", () => {
                 console.log("MQTT Whisperer Connected");
                 base.setIsReady(true);
-                // Re-subscribe custom topic callbacks after reconnect.
+                // Re-subscribe topic callbacks
                 topicCallbacksRef.current.forEach((_callbacks, topic) => {
                     new_client.subscribe(topic, { qos: 1 }, (err) => {
                         if (err)
                             console.error("Topic callback subscribe failed:", err);
                     });
                 });
+                // Since we create a brand new client on reconnect, we MUST re-subscribe
+                // to all actively managed device connections.
+                base.connections.forEach((conn) => {
+                    const topic = subTopicFromUuid?.(conn.uuid) ?? conn.uuid;
+                    new_client.subscribe(topic, { qos: 1 });
+                });
             });
-            new_client.on("reconnect", () => {
-                console.log("MQTT Whisperer Reconnecting...");
-                base.setIsReady(false);
-            });
-            new_client.on("close", () => {
-                console.log("MQTT Whisperer Closed");
+            const handleReconnectCycle = () => {
                 base.setIsReady(false);
-            });
+                if (isUnmountedRef.current)
+                    return;
+                console.log("MQTT Whisperer closed. Scheduling async reconnect...");
+                // Ensure we only queue one reconnect attempt
+                if (reconnectTimeoutRef.current)
+                    clearTimeout(reconnectTimeoutRef.current);
+                if (serverAutoConnect || serverConnectOn) {
+                    reconnectTimeoutRef.current = setTimeout(() => {
+                        connectToMQTTServer();
+                    }, 3000); // 3 second backoff
+                }
+            };
+            new_client.on("close", handleReconnectCycle);
             new_client.on("error", (err) => {
-                base.setIsReady(false);
                 console.error("MQTT Whisperer Error:", err);
+                handleReconnectCycle();
             });
             new_client.on("message", (topic, payload) => {
                 if (isUnmountedRef.current)
@@ -155,26 +181,13 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         catch (err) {
             console.error("MQTT init failed:", err);
             base.setIsReady(false);
-        }
-        return () => {
-            isUnmountedRef.current = true;
-            base.setIsReady(false);
-            Object.keys(watchdogTimers.current).forEach((uuid) => {
-                const timers = watchdogTimers.current[uuid];
-                if (timers) {
-                    clearTimeout(timers.ping);
-                    clearTimeout(timers.warn);
-                    clearTimeout(timers.fail);
-                }
-            });
-            watchdogTimers.current = {};
-            topicCallbacksRef.current.clear();
-            if (clientRef.current) {
-                clientRef.current.removeAllListeners();
-                clientRef.current.end(true);
+            // If fetching the URL fails, try again in 3 seconds
+            if (!isUnmountedRef.current && (serverAutoConnect || serverConnectOn)) {
+                reconnectTimeoutRef.current = setTimeout(() => {
+                    connectToMQTTServer();
+                }, 3000);
             }
-            clientRef.current = null;
-        };
+        }
     };
     const connect = async (uuid) => {
         const conn = base.getConnection(uuid);
@@ -200,7 +213,8 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
             return;
         const topic = subTopicFromUuid?.(uuid) ?? uuid;
         // Keep topic subscribed if callbacks or other device-connections still depend on it.
-        if (hasCallbackForTopic(topic) || hasOtherConnectionUsingTopic(topic, uuid)) {
+        if (hasCallbackForTopic(topic) ||
+            hasOtherConnectionUsingTopic(topic, uuid)) {
             return;
         }
         if (clientRef.current.connected && !clientRef.current.disconnecting) {
@@ -213,12 +227,12 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
             });
         }
         else {
-            console.warn("Skipped subscribe - client disconnected or unmounted");
+            console.warn("Skipped unsubscribe - client disconnected or unmounted");
         }
     };
     function touchHeartbeat(uuid) {
-        if (isUnmountedRef.current)
-            return; // Stop if unmounted
+        if (isUnmountedRef.current || !enableWatchdog)
+            return;
         clearTimeout(watchdogTimers.current[uuid]?.ping);
         clearTimeout(watchdogTimers.current[uuid]?.warn);
         clearTimeout(watchdogTimers.current[uuid]?.fail);
@@ -226,7 +240,7 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         base.updateConnection(uuid, (c) => ({
             ...c,
             isConnected: true,
-            isConnecting: false
+            isConnecting: false,
         }));
         const ping = setTimeout(() => {
             if (isUnmountedRef.current)
@@ -236,12 +250,20 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         const warn = setTimeout(() => {
             if (isUnmountedRef.current)
                 return;
-            base.updateConnection(uuid, (c) => ({ ...c, isConnected: false, isConnecting: true }));
+            base.updateConnection(uuid, (c) => ({
+                ...c,
+                isConnected: false,
+                isConnecting: true,
+            }));
         }, 30000);
         const fail = setTimeout(() => {
             if (isUnmountedRef.current)
                 return;
-            base.updateConnection(uuid, (c) => ({ ...c, isConnected: false, isConnecting: false }));
+            base.updateConnection(uuid, (c) => ({
+                ...c,
+                isConnected: false,
+                isConnecting: false,
+            }));
         }, 60000);
         watchdogTimers.current[uuid] = { ping, warn, fail };
     }
@@ -274,15 +296,16 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         const topic = pubTopicFromUuid?.(uuid) ?? subTopicFromUuid?.(uuid) ?? uuid;
         await publish(topic, data, uuid);
     };
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         if (!clientRef.current || isUnmountedRef.current)
-            return;
+            return "";
         if (!uuid) {
             Error("In MQTT you MUST define a UUID otherwise we don't know what device we're connecting to!");
-            return;
+            return "";
         }
-        if (base.connections.some(c => c.uuid === uuid) || addingConnections.current.has(uuid)) {
-            return;
+        if (base.connections.some((c) => c.uuid === uuid) ||
+            addingConnections.current.has(uuid)) {
+            return "";
         }
         await base.addConnection({
             uuid,
@@ -297,12 +320,10 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
                     touchHeartbeat: () => touchHeartbeat(id),
                     // Initial connection state
                     ...base.createInitialConnectionState(id),
-                    // From props
-                    ...props
+                    ...props,
                 };
-            }
+            },
         });
-        // Delete this adding connections item
         addingConnections.current.delete(uuid);
         // Connect immediately
         const conn = base.getConnection(uuid);
@@ -315,7 +336,7 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         base.removeConnection(uuid);
     };
     const reconnectAll = async () => {
-        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)
@@ -328,8 +349,27 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
     useEffect(() => {
         if (!(serverAutoConnect || serverConnectOn))
             return;
-        const cleanup = connectToMQTTServer();
-        return cleanup;
+        connectToMQTTServer();
+        return () => {
+            isUnmountedRef.current = true;
+            if (reconnectTimeoutRef.current)
+                clearTimeout(reconnectTimeoutRef.current);
+            Object.keys(watchdogTimers.current).forEach((uuid) => {
+                const timers = watchdogTimers.current[uuid];
+                if (timers) {
+                    clearTimeout(timers.ping);
+                    clearTimeout(timers.warn);
+                    clearTimeout(timers.fail);
+                }
+            });
+            watchdogTimers.current = {};
+            topicCallbacksRef.current.clear();
+            if (clientRef.current) {
+                clientRef.current.removeAllListeners();
+                clientRef.current.end(true);
+            }
+            clientRef.current = null;
+        };
     }, [serverUrl, serverConnectOn]);
     return {
         ...base,
@@ -338,6 +378,6 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         connect,
         disconnect,
         reconnectAll,
-        connectToMQTTServer
+        connectToMQTTServer,
     };
 }

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

@@ -13,8 +13,8 @@ export declare class UsbTransport {
      */
     connect(baudRate?: number): Promise<void>;
     /**
-       * Writes bytes to the device
-       */
+     * Writes bytes to the device
+     */
     write(data: Uint8Array): Promise<void>;
     /**
      * Reads bytes from the device.
@@ -39,7 +39,7 @@ export type SerialConnectionState = DeviceConnectionState & {
     slipReadWrite?: boolean;
 };
 export declare function SerialMultiDeviceWhisperer<AppOrMessageLayer extends SerialConnectionState>({ ...props }?: DeviceWhispererProps<AppOrMessageLayer>): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string | undefined>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppOrMessageLayer>) => Promise<string | undefined>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string, baudrate?: number) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;

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

@@ -1,4 +1,4 @@
-import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
+import { MultiDeviceWhisperer, } from "../base/device-whisperer.js";
 import { useEffect, useRef, useState } from "react";
 /*
 ┌────────────────────────────────┐
@@ -31,16 +31,19 @@ export class UsbTransport {
         const interfaces = this.device.configuration?.interfaces || [];
         let ctrlIface;
         let dataIface;
-        dataIface = interfaces.find(iface => {
+        dataIface = interfaces.find((iface) => {
             const endpoints = iface.alternate.endpoints;
-            return endpoints.some(e => e.direction === 'in' && e.type === 'bulk') &&
-                endpoints.some(e => e.direction === 'out' && e.type === 'bulk');
+            return (endpoints.some((e) => e.direction === "in" && e.type === "bulk") &&
+                endpoints.some((e) => e.direction === "out" && e.type === "bulk"));
         });
         if (dataIface) {
             this.dataInterface = dataIface.interfaceNumber;
-            ctrlIface = interfaces.find(i => i.interfaceNumber === this.dataInterface - 1)
-                || interfaces.find(i => i.alternate.interfaceClass === 2);
-            this.controlInterface = ctrlIface ? ctrlIface.interfaceNumber : this.dataInterface;
+            ctrlIface =
+                interfaces.find((i) => i.interfaceNumber === this.dataInterface - 1) ||
+                    interfaces.find((i) => i.alternate.interfaceClass === 2);
+            this.controlInterface = ctrlIface
+                ? ctrlIface.interfaceNumber
+                : this.dataInterface;
         }
         if (!dataIface) {
             throw new Error("No serial-compatible Bulk interface found.");
@@ -62,14 +65,14 @@ export class UsbTransport {
             throw new Error(`Failed to claim Data Interface. Android OS has locked the device driver. Try using a 'Vendor Specific' USB Class device or a native Serial App workaround.`);
         }
         const endpoints = dataIface.alternate.endpoints;
-        this.endpointIn = endpoints.find(e => e.direction === 'in' && e.type === 'bulk').endpointNumber;
-        this.endpointOut = endpoints.find(e => e.direction === 'out' && e.type === 'bulk').endpointNumber;
+        this.endpointIn = endpoints.find((e) => e.direction === "in" && e.type === "bulk").endpointNumber;
+        this.endpointOut = endpoints.find((e) => e.direction === "out" && e.type === "bulk").endpointNumber;
         await this.setBaudRate(baudRate);
         await this.setSignals({ dtr: false, rts: false });
     }
     /**
-       * Writes bytes to the device
-       */
+     * Writes bytes to the device
+     */
     async write(data) {
         if (!this.device.opened)
             return;
@@ -84,7 +87,7 @@ export class UsbTransport {
             return null;
         try {
             const result = await this.device.transferIn(this.endpointIn, length);
-            if (result.status === 'ok' && result.data) {
+            if (result.status === "ok" && result.data) {
                 return new Uint8Array(result.data.buffer);
             }
         }
@@ -100,13 +103,13 @@ export class UsbTransport {
     async setSignals({ dtr, rts }) {
         if (!this.device.opened)
             return;
-        const value = (Number(dtr) | (Number(rts) << 1));
+        const value = Number(dtr) | (Number(rts) << 1);
         await this.device.controlTransferOut({
-            requestType: 'class',
-            recipient: 'interface',
+            requestType: "class",
+            recipient: "interface",
             request: UsbTransport.SET_CONTROL_LINE_STATE,
             value: value,
-            index: this.controlInterface
+            index: this.controlInterface,
         });
     }
     async setBaudRate(baud) {
@@ -121,11 +124,11 @@ export class UsbTransport {
         view.setUint8(5, 0);
         view.setUint8(6, 8);
         await this.device.controlTransferOut({
-            requestType: 'class',
-            recipient: 'interface',
+            requestType: "class",
+            recipient: "interface",
             request: UsbTransport.SET_LINE_CODING,
             value: 0,
-            index: this.controlInterface
+            index: this.controlInterface,
         }, buffer);
     }
     async disconnect() {
@@ -171,7 +174,10 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         const asText = decoder.decode(bytes);
         const combined = conn.readBufferLeftover + asText;
         const lines = combined.split("\n");
-        base.updateConnection(uuid, (c) => ({ ...c, readBufferLeftover: lines.pop() || "" }));
+        base.updateConnection(uuid, (c) => ({
+            ...c,
+            readBufferLeftover: lines.pop() || "",
+        }));
         for (const line of lines) {
             if (line.trim()) {
                 base.appendLog(uuid, { level: 2, message: line.trim() });
@@ -204,7 +210,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
                 const bytes = await transport.read(64);
                 if (!bytes || bytes.length === 0) {
                     // Small delay to prevent CPU spinning if device sends nothing
-                    await new Promise(r => setTimeout(r, 10));
+                    await new Promise((r) => setTimeout(r, 10));
                     continue;
                 }
                 // --- Same Decoding Logic as before ---
@@ -212,7 +218,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
                     const b = bytes[i];
                     const currentConn = base.getConnection(uuid); // Refresh ref
                     if (inSlipFrame) {
-                        if (b === 0xC0) {
+                        if (b === 0xc0) {
                             if (slipBuffer.length > 0) {
                                 const payload = new Uint8Array(slipBuffer);
                                 currentConn?.onReceive?.(payload);
@@ -222,14 +228,14 @@ export function SerialMultiDeviceWhisperer({ ...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);
                             slipBuffer = []; // reset on error?
                             escapeNext = false;
                         }
-                        else if (b === 0xDB) {
+                        else if (b === 0xdb) {
                             escapeNext = true;
                         }
                         else {
@@ -237,7 +243,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
                         }
                         continue;
                     }
-                    if (b === 0xC0 && currentConn?.slipReadWrite) {
+                    if (b === 0xc0 && currentConn?.slipReadWrite) {
                         inSlipFrame = true;
                         slipBuffer = [];
                         continue;
@@ -281,18 +287,18 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         // Close existing if open
         if (conn.transport)
             await disconnect(uuid);
-        base.updateConnection(uuid, c => ({ ...c, isConnecting: true }));
+        base.updateConnection(uuid, (c) => ({ ...c, isConnecting: true }));
         const transport = new UsbTransport(conn.device);
         try {
             await transport.connect(baudrate);
             // Optional: Auto-restart on connect
             await restartDevice(uuid, transport);
-            base.updateConnection(uuid, c => ({
+            base.updateConnection(uuid, (c) => ({
                 ...c,
                 transport,
                 baudrate,
                 isConnected: true,
-                isConnecting: false
+                isConnecting: false,
             }));
             await conn.onConnect?.();
             // Start polling loop
@@ -300,7 +306,11 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         }
         catch (err) {
             console.error(err);
-            base.updateConnection(uuid, c => ({ ...c, isConnected: false, isConnecting: false }));
+            base.updateConnection(uuid, (c) => ({
+                ...c,
+                isConnected: false,
+                isConnecting: false,
+            }));
             await disconnect(uuid);
         }
     };
@@ -309,18 +319,18 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         if (conn?.transport) {
             await conn.transport.disconnect();
         }
-        base.updateConnection(uuid, c => ({
+        base.updateConnection(uuid, (c) => ({
             ...c,
             transport: releasePortByDefaultRef.current ? null : c.transport,
             isConnected: false,
-            isConnecting: false
+            isConnecting: false,
         }));
         await conn?.onDisconnect?.();
     };
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         try {
             const device = await navigator.usb.requestDevice({
-                filters: []
+                filters: [],
             });
             const return_uuid = await base.addConnection({
                 uuid,
@@ -334,9 +344,9 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
                         // Initial connection state
                         ...base.createInitialConnectionState(id),
                         // From props
-                        ...props
+                        ...props,
                     };
-                }
+                },
             });
             const conn = base.getConnection(return_uuid);
             if (conn?.autoConnect)
@@ -352,7 +362,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         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)
@@ -362,7 +372,9 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
             return connect(c.uuid, ...connectionProps);
         }));
     };
-    useEffect(() => { base.setIsReady(true); }, []);
+    useEffect(() => {
+        base.setIsReady(true);
+    }, []);
     return {
         ...base,
         addConnection,
@@ -371,6 +383,6 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         disconnect,
         reconnectAll,
         releasePortByDefault: releasePortByDefaultState,
-        setReleasePortByDefault: setReleasePortByDefaultState
+        setReleasePortByDefault: setReleasePortByDefaultState,
     };
 }

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

@@ -13,7 +13,7 @@ export declare function WebsocketMultiDeviceWhisperer<AppOrMessageLayer extends
     server_url: string;
     server_port: number;
 }): {
-    addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
+    addConnection: ({ uuid, propCreator, }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string, attempt?: number) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;

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

@@ -1,5 +1,5 @@
 import { useEffect } from "react";
-import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
+import { MultiDeviceWhisperer, } from "../base/device-whisperer.js";
 export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...props }) {
     const base = MultiDeviceWhisperer(props);
     const defaultOnReceive = (uuid, data) => {
@@ -22,7 +22,7 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
         const lines = combined.split(/\r?\n/);
         base.updateConnection(uuid, (c) => ({
             ...c,
-            readBufferLeftover: lines.pop() || ""
+            readBufferLeftover: lines.pop() || "",
         }));
         for (const line of lines) {
             const trimmed = line.trim();
@@ -38,9 +38,7 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
         const conn = base.getConnection(uuid);
         if (!conn || !conn.ws)
             return;
-        const asString = typeof data === "string"
-            ? data
-            : btoa(String.fromCharCode(...data));
+        const asString = typeof data === "string" ? data : btoa(String.fromCharCode(...data));
         base.appendLog(uuid, {
             level: 3,
             message: asString,
@@ -57,7 +55,11 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
             console.log(`[client] Closing existing WS before reconnect for ${uuid}`);
             conn.ws.close();
         }
-        base.updateConnection(uuid, (c) => ({ ...c, isConnecting: true, autoConnect: true }));
+        base.updateConnection(uuid, (c) => ({
+            ...c,
+            isConnecting: true,
+            autoConnect: true,
+        }));
         try {
             const pre = server_port !== 443 ? "ws" : "wss";
             const ws = new WebSocket(`${pre}://${server_url}:${server_port}/ui/${uuid}`);
@@ -68,11 +70,11 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
                     ws,
                     isConnected: true,
                     isConnecting: false,
-                    lastAttempt: attempt
+                    lastAttempt: attempt,
                 }));
                 base.appendLog(uuid, {
                     level: 2,
-                    message: "[✓] WebSocket connected"
+                    message: "[✓] WebSocket connected",
                 });
                 conn?.onConnect?.();
             };
@@ -89,7 +91,7 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
             ws.onerror = (err) => {
                 base.appendLog(uuid, {
                     level: 0,
-                    message: `[x] WS error: ${err}`
+                    message: `[x] WS error: ${err}`,
                 });
             };
             ws.onclose = async () => {
@@ -97,7 +99,7 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
                     ...c,
                     isConnected: false,
                     isConnecting: false,
-                    ws: undefined
+                    ws: undefined,
                 }));
                 base.appendLog(uuid, { level: 0, message: "[!] WS disconnected" });
                 const updated_conn = base.getConnection(uuid);
@@ -107,7 +109,10 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
                 }
                 // Auto reconnect if enabled
                 if (updated_conn.autoConnect && attempt < MAX_RETRIES) {
-                    base.appendLog(uuid, { level: 2, message: `[~] Reconnecting in ${RETRY_DELAY_MS}ms... (attempt ${attempt + 1})` });
+                    base.appendLog(uuid, {
+                        level: 2,
+                        message: `[~] Reconnecting in ${RETRY_DELAY_MS}ms... (attempt ${attempt + 1})`,
+                    });
                     setTimeout(() => connect(uuid, attempt + 1), RETRY_DELAY_MS);
                 }
             };
@@ -119,8 +124,11 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
                 isConnecting: false,
                 logs: [
                     ...c.logs,
-                    { level: 0, message: `[x] WS connection error: ${err?.message || "Unknown error"}` }
-                ]
+                    {
+                        level: 0,
+                        message: `[x] WS connection error: ${err?.message || "Unknown error"}`,
+                    },
+                ],
             }));
             await disconnect(uuid);
         }
@@ -135,12 +143,12 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
             isConnecting: false,
             autoConnect: false,
             ws: undefined,
-            readBufferLeftover: ""
+            readBufferLeftover: "",
         }));
         conn.ws.close();
         await conn?.onDisconnect?.();
     };
-    const addConnection = async ({ uuid, propCreator }) => {
+    const addConnection = async ({ uuid, propCreator, }) => {
         return await base.addConnection({
             uuid,
             propCreator: (id) => {
@@ -148,9 +156,9 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
                 return {
                     send: props?.send || ((d) => defaultSend(id, d)),
                     onReceive: props?.onReceive || ((d) => defaultOnReceive(id, d)),
-                    ...props
+                    ...props,
                 };
-            }
+            },
         });
     };
     const removeConnection = async (uuid) => {
@@ -174,7 +182,7 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
         }
     };
     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)
@@ -194,6 +202,6 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
         connect,
         disconnect,
         checkForNewDevices,
-        reconnectAll
+        reconnectAll,
     };
 }

package/dist/types/builds.js

@@ -1,3 +1 @@
-;
-;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ota-hub-reactjs",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "ReactJS tools for building web apps to flash MCU devices such as esp32, brought to you by OTA Hub.",
   "type": "module",
   "main": "dist/index.js",