ota-hub-reactjs 0.0.14 → 0.0.16

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

@@ -2,7 +2,7 @@ export type LogMessage = string | number | boolean | Record<string, any> | any[]
 export type LogLine = {
     level: number;
     message: LogMessage;
-    timestamp?: string | Date;
+    timestamp?: Date;
 };
 type PropCreatorProps<T> = (uuid: string) => Partial<T> | undefined;
 export interface AddConnectionProps<T> {
@@ -30,7 +30,6 @@ export type DeviceWhispererProps<T extends DeviceConnectionState> = {
 };
 export declare function MultiDeviceWhisperer<T extends DeviceConnectionState>({ createInitialConnectionState, }?: DeviceWhispererProps<T>): {
     connections: T[];
-    connectionsRef: import("react").RefObject<T[]>;
     addConnection: ({ uuid, propCreator }: AddConnectionProps<T>) => Promise<string>;
     removeConnection: (uuid: string) => void;
     connect: (_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";
-import { uniqueNamesGenerator, animals } from "unique-names-generator";
 ;
 // Initial, generic state for the generic device
 export function createDefaultInitialDeviceState(uuid, props) {
@@ -20,53 +19,55 @@ export function createDefaultInitialDeviceState(uuid, props) {
 */
 export function MultiDeviceWhisperer({ createInitialConnectionState = createDefaultInitialDeviceState, } = {}) {
     const [connections, setConnections] = useState([]);
-    const connectionsRef = useRef(connections);
+    const connectionsRef = useRef(new Map());
     const [isReady, setIsReady] = useState(false);
-    const getConnection = (uuid) => connectionsRef.current.find(c => c.uuid === uuid);
+    // ---------- GET ----------
+    const getConnection = (uuid) => connectionsRef.current.get(uuid);
+    // ---------- UPDATE ----------
     const updateConnection = (uuid, updater) => {
-        setConnections(prev => {
-            const updated = prev.map((c) => c.uuid === uuid ? updater(c) : c);
-            connectionsRef.current = updated;
-            return updated;
-        });
+        const current = connectionsRef.current.get(uuid);
+        if (!current)
+            return;
+        const next = updater(current);
+        connectionsRef.current.set(uuid, next);
+        setConnections(Array.from(connectionsRef.current.values()));
     };
     const updateConnectionName = (uuid, name) => {
-        setConnections((prev) => prev.map((c) => (c.uuid === uuid ? { ...c, name } : c)));
+        updateConnection(uuid, (c) => ({ ...c, name }));
     };
     const appendLog = (uuid, log) => {
-        if (!log.timestamp) {
+        if (!log.timestamp)
             log.timestamp = new Date();
-        }
         updateConnection(uuid, (c) => ({
             ...c,
             logs: [...c.logs.slice(-199), log],
         }));
     };
+    // ---------- ADD ----------
     const addConnection = async ({ uuid, propCreator }) => {
-        uuid = uuid ?? uniqueNamesGenerator({ dictionaries: [animals] });
+        uuid = uuid ?? `unnamed_device_${connectionsRef.current.size}`;
         const props = propCreator?.(uuid);
         const newConnection = {
             ...createDefaultInitialDeviceState(uuid),
             ...createInitialConnectionState(uuid),
             ...props
         };
-        connectionsRef.current = [...connectionsRef.current, newConnection];
-        setConnections(prev => [...prev, newConnection]);
-        const anyUpdatedConnection = getConnection(uuid);
-        if (!anyUpdatedConnection) {
-            return "";
-        }
+        connectionsRef.current.set(uuid, newConnection);
+        setConnections(Array.from(connectionsRef.current.values()));
         return uuid;
     };
+    // ---------- REMOVE ----------
     const removeConnection = (uuid) => {
-        setConnections((prev) => prev.filter((c) => c.uuid !== uuid));
+        connectionsRef.current.delete(uuid);
+        setConnections(Array.from(connectionsRef.current.values()));
     };
+    // ---------- EFFECT ----------
     useEffect(() => {
-        connectionsRef.current = connections;
-    }, [connections]);
+        // initial snapshot
+        setConnections(Array.from(connectionsRef.current.values()));
+    }, []);
     return {
         connections,
-        connectionsRef,
         addConnection,
         removeConnection,
         connect: (_uuid) => { },

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

@@ -20,7 +20,6 @@ export declare function ProtobufMultiDeviceWhisperer<AppLayer extends DeviceConn
     sendProtobuf: (uuid: string, message: MessageTX) => void;
     protoBufOnReceiveHandler: (uuid: string, data: string | Uint8Array) => void;
     connections: AppLayer[];
-    connectionsRef: import("react").RefObject<AppLayer[]>;
     removeConnection: (uuid: string) => void;
     connect: (_uuid: string) => void;
     disconnect: (_uuid: string) => void;

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

@@ -1,5 +1,5 @@
 import { ESPLoader, FlashOptions, Transport } from "esptool-js";
-import { AddConnectionProps, DeviceConnectionState } from "../base/device-whisperer.js";
+import { AddConnectionProps, DeviceConnectionState, DeviceWhispererProps } from "../base/device-whisperer.js";
 export type ESP32ConnectionState = DeviceConnectionState & {
     port?: SerialPort;
     baudrate?: number;
@@ -15,7 +15,9 @@ export type FlashFirmwareProps = {
     firmwareBlob?: Blob;
     fileArray?: FlashOptions["fileArray"];
 };
-export declare function ESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP32ConnectionState>({ ...props }?: {}): {
+export declare function ESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP32ConnectionState>({ releasePortByDefault, ...props }?: {
+    releasePortByDefault: boolean;
+} & DeviceWhispererProps<AppOrMessageLayer>): {
     addConnection: ({ uuid, propCreator }: AddConnectionProps<AppOrMessageLayer>) => Promise<string>;
     removeConnection: (uuid: string) => Promise<void>;
     connect: (uuid: string, baudrate?: number, restart_on_connect?: boolean) => Promise<void>;
@@ -26,7 +28,6 @@ export declare function ESP32MultiDeviceWhisperer<AppOrMessageLayer extends ESP3
         address: number;
     }[]) => Promise<void>;
     connections: AppOrMessageLayer[];
-    connectionsRef: import("react").RefObject<AppOrMessageLayer[]>;
     updateConnection: (uuid: string, updater: (c: AppOrMessageLayer) => AppOrMessageLayer) => void;
     updateConnectionName: (uuid: string, name: string) => void;
     getConnection: (uuid: string) => AppOrMessageLayer | undefined;

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

@@ -1,39 +1,19 @@
 import { useEffect } from "react";
 import { ESPLoader, Transport } from "esptool-js";
 import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
-export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
+export function ESP32MultiDeviceWhisperer({ releasePortByDefault, ...props } = { releasePortByDefault: true }) {
     const base = MultiDeviceWhisperer(props);
     const defaultOnReceive = (uuid, data) => {
-        const conn = base.getConnection(uuid);
-        if (!conn)
+        const text = typeof data === "string"
+            ? data
+            : new TextDecoder().decode(data);
+        const trimmed = text.trim();
+        if (!trimmed)
             return;
-        const decoder = new TextDecoder();
-        let bytes;
-        if (typeof data === "string") {
-            bytes = new TextEncoder().encode(data);
-        }
-        else if (data instanceof ArrayBuffer) {
-            bytes = new Uint8Array(data);
-        }
-        else {
-            bytes = data;
-        }
-        const asText = decoder.decode(bytes);
-        const combined = conn.readBufferLeftover + asText;
-        const lines = combined.split("\r\n");
-        base.updateConnection(uuid, (c) => ({
-            ...c,
-            readBufferLeftover: lines.pop() || ""
-        }));
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed) {
-                base.appendLog(uuid, {
-                    level: 2,
-                    message: trimmed,
-                });
-            }
-        }
+        base.appendLog(uuid, {
+            level: 2,
+            message: trimmed,
+        });
     };
     const defaultSend = async (uuid, data) => {
         const conn = base.getConnection(uuid);
@@ -52,9 +32,7 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
         return;
     };
     const readLoop = async (uuid, transport) => {
-        const conn = base.getConnection(uuid);
-        if (!conn)
-            return;
+        const textDecoder = new TextDecoder();
         let readBuffer = ""; // accumulate ASCII/lines
         let slipBuffer = []; // accumulate SLIP frames
         let inSlipFrame = false; // are we inside a SLIP frame?
@@ -62,6 +40,12 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
         try {
             const reader = transport.rawRead();
             while (true) {
+                const conn = base.getConnection(uuid);
+                if (!conn) {
+                    console.log("Kack!");
+                    return;
+                }
+                ;
                 const { value, done } = await reader.next();
                 if (done || !value)
                     break;
@@ -117,9 +101,8 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
                         escapeNext = false;
                         continue;
                     }
-                    // treat as normal ASCII text
-                    const char = String.fromCharCode(b);
-                    readBuffer += char;
+                    // treat as normal text (correctly)
+                    readBuffer += textDecoder.decode(new Uint8Array([b]), { stream: true });
                     // check for newline
                     let newlineIndex;
                     while ((newlineIndex = readBuffer.indexOf("\n")) >= 0) {
@@ -244,8 +227,8 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
         // Always clear the transport and reset connection state
         base.updateConnection(uuid, (c) => ({
             ...c,
-            port: null,
-            transport: null,
+            port: releasePortByDefault ? null : c.port,
+            transport: releasePortByDefault ? null : c.transport,
             isConnected: false,
             isConnecting: false,
             autoConnect: false,
@@ -285,8 +268,11 @@ export function ESP32MultiDeviceWhisperer({ ...props } = {}) {
         base.removeConnection(uuid);
     };
     const reconnectAll = async (...connectionProps) => {
-        const connections = [...base.connectionsRef.current]; // snapshot first
-        await Promise.all(connections.map(async (c) => {
+        const connectionIds = base.connections.map(c => c.uuid);
+        await Promise.all(connectionIds.map(async (id) => {
+            const c = base.getConnection(id);
+            if (!c)
+                return;
             await disconnect(c.uuid);
             await new Promise((res) => setTimeout(res, 250));
             return connect(c.uuid, ...connectionProps);

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

@@ -22,7 +22,6 @@ export declare function MQTTMultiDeviceWhisperer<AppOrMessageLayer extends MQTTC
     reconnectAll: () => Promise<void>;
     connectToMQTTServer: () => (() => void) | undefined;
     connections: AppOrMessageLayer[];
-    connectionsRef: import("react").RefObject<AppOrMessageLayer[]>;
     updateConnection: (uuid: string, updater: (c: AppOrMessageLayer) => AppOrMessageLayer) => void;
     updateConnectionName: (uuid: string, name: string) => void;
     getConnection: (uuid: string) => AppOrMessageLayer | undefined;

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

@@ -189,7 +189,7 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
             Error("In MQTT you MUST define a UUID otherwise we don't know what device we're connecting to!");
             return;
         }
-        if (base.connectionsRef.current.some(c => c.uuid === uuid) || addingConnections.current.has(uuid)) {
+        if (base.connections.some(c => c.uuid === uuid) || addingConnections.current.has(uuid)) {
             return;
         }
         await base.addConnection({
@@ -221,13 +221,15 @@ export function MQTTMultiDeviceWhisperer({ serverUrl, uuidFromMessage, subTopicF
         base.removeConnection(uuid);
     };
     const reconnectAll = async () => {
-        for (const c of base.connectionsRef.current) {
+        const connectionIds = base.connections.map(c => c.uuid);
+        await Promise.all(connectionIds.map(async (id) => {
+            const c = base.getConnection(id);
+            if (!c)
+                return;
             await disconnect(c.uuid);
             await new Promise((res) => setTimeout(res, 250));
-        }
-        for (const c of base.connectionsRef.current) {
-            await connect(c.uuid);
-        }
+            return connect(c.uuid);
+        }));
     };
     useEffect(() => {
         if (!(serverAutoConnect || serverConnectOn))

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

@@ -1,7 +1,8 @@
-import { DeviceConnectionState, AddConnectionProps } from "../base/device-whisperer.js";
+import { DeviceConnectionState, AddConnectionProps, DeviceWhispererProps } from "../base/device-whisperer.js";
 export declare class UsbTransport {
     device: USBDevice;
-    interfaceNumber: number;
+    controlInterface: number;
+    dataInterface: number;
     endpointIn: number;
     endpointOut: number;
     private static readonly SET_LINE_CODING;
@@ -37,14 +38,15 @@ export type SerialConnectionState = DeviceConnectionState & {
     baudrate?: number;
     slipReadWrite?: boolean;
 };
-export declare function SerialMultiDeviceWhisperer<AppOrMessageLayer extends SerialConnectionState>({ ...props }?: {}): {
+export declare function SerialMultiDeviceWhisperer<AppOrMessageLayer extends SerialConnectionState>({ ...props }?: DeviceWhispererProps<AppOrMessageLayer>): {
     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: () => Promise<void>;
+    reconnectAll: (...connectionProps: any) => Promise<void>;
+    releasePortByDefault: boolean;
+    setReleasePortByDefault: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     connections: AppOrMessageLayer[];
-    connectionsRef: import("react").RefObject<AppOrMessageLayer[]>;
     updateConnection: (uuid: string, updater: (c: AppOrMessageLayer) => AppOrMessageLayer) => void;
     updateConnectionName: (uuid: string, name: string) => void;
     getConnection: (uuid: string) => AppOrMessageLayer | undefined;

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

@@ -1,5 +1,5 @@
 import { MultiDeviceWhisperer } from "../base/device-whisperer.js";
-import { useEffect } from "react";
+import { useEffect, useRef, useState } from "react";
 /*
 ┌────────────────────────────────┐
 │   Device Whisperer (Generic)   │ (connect/disconnect, state mgmt) - "Abstraction Layer"
@@ -14,7 +14,8 @@ import { useEffect } from "react";
 // usb-transport.ts
 export class UsbTransport {
     constructor(device) {
-        this.interfaceNumber = 0;
+        this.controlInterface = 0;
+        this.dataInterface = 1;
         this.endpointIn = 0;
         this.endpointOut = 0;
         this.device = device;
@@ -27,25 +28,40 @@ export class UsbTransport {
         if (this.device.configuration === null) {
             await this.device.selectConfiguration(1);
         }
-        // Find the CDC Data interface (usually class 10) or just the first one with Bulk endpoints
         const interfaces = this.device.configuration?.interfaces || [];
-        let targetInterface;
-        for (const iface of interfaces) {
+        let ctrlIface;
+        let dataIface;
+        dataIface = interfaces.find(iface => {
             const endpoints = iface.alternate.endpoints;
-            const hasIn = endpoints.some(e => e.direction === 'in' && e.type === 'bulk');
-            const hasOut = endpoints.some(e => e.direction === 'out' && e.type === 'bulk');
-            if (hasIn && hasOut) {
-                targetInterface = iface;
-                break;
+            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;
+        }
+        if (!dataIface) {
+            throw new Error("No serial-compatible Bulk interface found.");
+        }
+        // Note: On Android, if the OS has claimed Interface 0, this first call will fail.
+        try {
+            if (this.controlInterface !== this.dataInterface) {
+                await this.device.claimInterface(this.controlInterface);
             }
         }
-        if (!targetInterface) {
-            throw new Error("No serial-compatible interface found on device.");
+        catch (e) {
+            console.warn("Could not claim Control Interface (OS locked?). Proceeding to Data...", e);
+            // We continue, but setSignals might fail later.
+        }
+        try {
+            await this.device.claimInterface(this.dataInterface);
+        }
+        catch (e) {
+            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.`);
         }
-        this.interfaceNumber = targetInterface.interfaceNumber;
-        await this.device.claimInterface(this.interfaceNumber);
-        // Map endpoints
-        const endpoints = targetInterface.alternate.endpoints;
+        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;
         await this.setBaudRate(baudRate);
@@ -57,7 +73,6 @@ export class UsbTransport {
     async write(data) {
         if (!this.device.opened)
             return;
-        // Cast to 'unknown' then 'BufferSource' to satisfy the strict type definition
         await this.device.transferOut(this.endpointOut, data);
     }
     /**
@@ -85,14 +100,13 @@ export class UsbTransport {
     async setSignals({ dtr, rts }) {
         if (!this.device.opened)
             return;
-        // CDC-ACM: DTR is bit 0, RTS is bit 1
         const value = (Number(dtr) | (Number(rts) << 1));
         await this.device.controlTransferOut({
             requestType: 'class',
             recipient: 'interface',
             request: UsbTransport.SET_CONTROL_LINE_STATE,
             value: value,
-            index: this.interfaceNumber
+            index: this.controlInterface
         });
     }
     async setBaudRate(baud) {
@@ -102,20 +116,31 @@ export class UsbTransport {
         // 4 bytes: baud (LE), 1 byte: stop bits, 1 byte: parity, 1 byte: data bits
         const buffer = new ArrayBuffer(7);
         const view = new DataView(buffer);
-        view.setUint32(0, baud, true); // Little Endian
-        view.setUint8(4, 0); // 1 stop bit
-        view.setUint8(5, 0); // No parity
-        view.setUint8(6, 8); // 8 data bits
+        view.setUint32(0, baud, true);
+        view.setUint8(4, 0);
+        view.setUint8(5, 0);
+        view.setUint8(6, 8);
         await this.device.controlTransferOut({
             requestType: 'class',
             recipient: 'interface',
             request: UsbTransport.SET_LINE_CODING,
             value: 0,
-            index: this.interfaceNumber
+            index: this.controlInterface
         }, buffer);
     }
     async disconnect() {
         if (this.device.opened) {
+            // Release both
+            try {
+                await this.device.releaseInterface(this.dataInterface);
+            }
+            catch (e) { }
+            if (this.controlInterface !== this.dataInterface) {
+                try {
+                    await this.device.releaseInterface(this.controlInterface);
+                }
+                catch (e) { }
+            }
             await this.device.close();
         }
     }
@@ -125,6 +150,11 @@ UsbTransport.SET_LINE_CODING = 0x20;
 UsbTransport.SET_CONTROL_LINE_STATE = 0x22;
 export function SerialMultiDeviceWhisperer({ ...props } = {}) {
     const base = MultiDeviceWhisperer(props);
+    const releasePortByDefaultRef = useRef(false);
+    const [releasePortByDefaultState, setReleasePortByDefaultState] = useState(false);
+    useEffect(() => {
+        releasePortByDefaultRef.current = releasePortByDefaultState;
+    }, [releasePortByDefaultState]);
     // --- Message Processing (Identical logic, just copied over) ---
     const defaultOnReceive = (uuid, data) => {
         const conn = base.getConnection(uuid);
@@ -140,7 +170,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
             bytes = data;
         const asText = decoder.decode(bytes);
         const combined = conn.readBufferLeftover + asText;
-        const lines = combined.split("\r\n");
+        const lines = combined.split("\n");
         base.updateConnection(uuid, (c) => ({ ...c, readBufferLeftover: lines.pop() || "" }));
         for (const line of lines) {
             if (line.trim()) {
@@ -281,7 +311,7 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         }
         base.updateConnection(uuid, c => ({
             ...c,
-            transport: null,
+            transport: releasePortByDefaultRef.current ? null : c.transport,
             isConnected: false,
             isConnecting: false
         }));
@@ -321,7 +351,17 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         await disconnect(uuid);
         base.removeConnection(uuid);
     };
-    const reconnectAll = async () => { };
+    const reconnectAll = async (...connectionProps) => {
+        const connectionIds = base.connections.map(c => c.uuid);
+        await Promise.all(connectionIds.map(async (id) => {
+            const c = base.getConnection(id);
+            if (!c)
+                return;
+            await disconnect(c.uuid);
+            await new Promise((res) => setTimeout(res, 250));
+            return connect(c.uuid, ...connectionProps);
+        }));
+    };
     useEffect(() => { base.setIsReady(true); }, []);
     return {
         ...base,
@@ -329,6 +369,8 @@ export function SerialMultiDeviceWhisperer({ ...props } = {}) {
         removeConnection,
         connect,
         disconnect,
-        reconnectAll
+        reconnectAll,
+        releasePortByDefault: releasePortByDefaultState,
+        setReleasePortByDefault: setReleasePortByDefaultState
     };
 }

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

@@ -18,9 +18,8 @@ export declare function WebsocketMultiDeviceWhisperer<AppOrMessageLayer extends
     connect: (uuid: string, attempt?: number) => Promise<void>;
     disconnect: (uuid: string) => Promise<void>;
     checkForNewDevices: () => Promise<DeviceObjectResponse[]>;
-    reconnectAll: () => Promise<void>;
+    reconnectAll: (...connectionProps: any) => Promise<void>;
     connections: AppOrMessageLayer[];
-    connectionsRef: import("react").RefObject<AppOrMessageLayer[]>;
     updateConnection: (uuid: string, updater: (c: AppOrMessageLayer) => AppOrMessageLayer) => void;
     updateConnectionName: (uuid: string, name: string) => void;
     getConnection: (uuid: string) => AppOrMessageLayer | undefined;

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

@@ -19,7 +19,7 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
         }
         const asText = decoder.decode(bytes);
         const combined = conn.readBufferLeftover + asText;
-        const lines = combined.split("\n");
+        const lines = combined.split(/\r?\n/);
         base.updateConnection(uuid, (c) => ({
             ...c,
             readBufferLeftover: lines.pop() || ""
@@ -173,14 +173,16 @@ export function WebsocketMultiDeviceWhisperer({ server_url, server_port, ...prop
             return [];
         }
     };
-    const reconnectAll = async () => {
-        for (const c of base.connectionsRef.current) {
+    const reconnectAll = async (...connectionProps) => {
+        const connectionIds = base.connections.map(c => c.uuid);
+        await Promise.all(connectionIds.map(async (id) => {
+            const c = base.getConnection(id);
+            if (!c)
+                return;
             await disconnect(c.uuid);
             await new Promise((res) => setTimeout(res, 250));
-        }
-        for (const c of base.connectionsRef.current) {
-            await connect(c.uuid);
-        }
+            return connect(c.uuid, ...connectionProps);
+        }));
     };
     useEffect(() => {
         base.setIsReady(true); // Ready on page load by default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ota-hub-reactjs",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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",
@@ -33,7 +33,6 @@
   "dependencies": {
     "esptool-js": "^0.5.5",
     "mqtt": "^5.14.1",
-    "unique-names-generator": "^4.7.1",
     "uuid": "^11.1.0"
   },
   "peerDependencies": {