ota-hub-reactjs 0.0.16 → 0.0.19

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

@@ -1,52 +1,171 @@
 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 connectToMQTTServer = () => {
+    const topicCallbacksRef = useRef(new Map());
+    const hasCallbackForTopic = (topic) => {
+        const callbacks = topicCallbacksRef.current.get(topic);
+        return !!callbacks && callbacks.size > 0;
+    };
+    const hasOtherConnectionUsingTopic = (topic, excludingUuid) => {
+        return base.connections.some((connection) => {
+            if (excludingUuid && connection.uuid === excludingUuid)
+                return false;
+            const connectionTopic = subTopicFromUuid?.(connection.uuid) ?? connection.uuid;
+            return connectionTopic === topic;
+        });
+    };
+    const normalizePayload = (payload) => {
+        if (typeof payload === "string") {
+            return new TextEncoder().encode(payload);
+        }
+        if (payload instanceof ArrayBuffer) {
+            return new Uint8Array(payload);
+        }
+        return payload;
+    };
+    const publish = async (topic, payload, uuidForLogs) => {
+        const client = clientRef.current;
+        if (!client || isUnmountedRef.current)
+            return;
+        const bytes = normalizePayload(payload);
+        if (uuidForLogs) {
+            base.appendLog(uuidForLogs, {
+                level: 5,
+                message: bytes,
+            });
+        }
+        await new Promise((resolve, reject) => {
+            client.publish(topic, bytes, { qos: 1 }, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    };
+    const subscribeCallbackToTopic = (topic, callback) => {
+        if (!topic)
+            return () => { };
+        const topicCallbacks = topicCallbacksRef.current.get(topic) ?? new Set();
+        const topicAlreadyRegistered = topicCallbacksRef.current.has(topic);
+        topicCallbacks.add(callback);
+        topicCallbacksRef.current.set(topic, topicCallbacks);
+        const client = clientRef.current;
+        if (client?.connected && !client.disconnecting && !topicAlreadyRegistered) {
+            client.subscribe(topic, { qos: 1 }, (err) => {
+                if (err)
+                    console.error("Topic callback subscribe failed:", err);
+            });
+        }
+        return () => {
+            const currentCallbacks = topicCallbacksRef.current.get(topic);
+            if (!currentCallbacks)
+                return;
+            currentCallbacks.delete(callback);
+            if (currentCallbacks.size > 0)
+                return;
+            topicCallbacksRef.current.delete(topic);
+            // Keep topic subscribed when at least one managed connection still uses it.
+            if (hasOtherConnectionUsingTopic(topic))
+                return;
+            const latestClient = clientRef.current;
+            if (latestClient?.connected && !latestClient.disconnecting) {
+                latestClient.unsubscribe(topic, (err) => {
+                    if (err)
+                        console.error("Topic callback unsubscribe failed:", err);
+                });
+            }
+        };
+    };
+    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 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...");
+            const handleReconnectCycle = () => {
                 base.setIsReady(false);
-            });
-            new_client.on("close", () => {
-                console.log("MQTT Whisperer Closed");
-                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)
                     return;
                 const uuid = uuidFromMessage(topic, payload);
                 const bytes = payload instanceof Uint8Array ? payload : new Uint8Array(payload);
+                const topicCallbacks = topicCallbacksRef.current.get(topic);
+                topicCallbacks?.forEach((cb) => {
+                    try {
+                        cb(bytes, topic);
+                    }
+                    catch (err) {
+                        console.error("Topic callback failed:", err);
+                    }
+                });
                 if (!uuid)
                     return;
                 const conn = base.getConnection(uuid);
@@ -62,25 +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 = {};
-            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);
@@ -105,6 +212,11 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         if (!clientRef.current || isUnmountedRef.current)
             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)) {
+            return;
+        }
         if (clientRef.current.connected && !clientRef.current.disconnecting) {
             clientRef.current.unsubscribe(topic, async (err) => {
                 if (err)
@@ -115,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);
@@ -128,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)
@@ -138,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 };
     }
@@ -173,24 +293,19 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         const conn = base.getConnection(uuid);
         if (!conn)
             return;
-        const payload = typeof data === 'string'
-            ? new TextEncoder().encode(data)
-            : data;
-        base.appendLog(uuid, {
-            level: 5,
-            message: payload,
-        });
-        clientRef.current?.publish(pubTopicFromUuid?.(uuid) ?? uuid, payload); // TS is wrong here!
+        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,
@@ -199,16 +314,16 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
                 return {
                     // Defaults, may be overridden by props
                     send: (d) => defaultSend(id, d),
+                    publish: (topic, payload) => publish(topic, payload, id),
+                    subscribeCallbackToTopic,
                     onReceive: (d) => defaultOnReceive(id, d),
                     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);
@@ -221,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)
@@ -234,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,
@@ -244,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,13 +39,15 @@ 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>;
     reconnectAll: (...connectionProps: any) => Promise<void>;
     releasePortByDefault: boolean;
     setReleasePortByDefault: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    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/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,12 +13,14 @@ 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>;
     checkForNewDevices: () => Promise<DeviceObjectResponse[]>;
     reconnectAll: (...connectionProps: any) => 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;