ota-hub-reactjs 0.1.2 → 0.1.4

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

@@ -6,7 +6,6 @@ export type ESP32ConnectionState = DeviceConnectionState & {
     transport?: Transport;
     esp?: ESPLoader;
     debugLogging?: false;
-    reader?: AsyncGenerator<Uint8Array>;
     slipReadWrite?: boolean;
     isFlashing: boolean;
     flashProgress: number;

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

@@ -36,7 +36,7 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
         let inSlipFrame = false; // are we inside a SLIP frame?
         let escapeNext = false;
         const reader = transport.rawRead();
-        base.updateConnection(uuid, (c) => ({ ...c, reader }));
+        base.updateConnection(uuid, (c) => ({ ...c }));
         try {
             while (true) {
                 const conn = base.getConnection(uuid);
@@ -44,6 +44,8 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
                     console.log("Kack!");
                     return;
                 }
+                if (conn.isFlashing || !conn.isConnected)
+                    break;
                 const { value, done } = await reader.next();
                 if (done || !value)
                     break;
@@ -114,6 +116,7 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
                     }
                 }
             }
+            await new Promise((resolve) => setTimeout(resolve, 100)); // Little breather before attempt any disconnects
         }
         catch (e) {
             base.appendLog(uuid, {
@@ -122,13 +125,11 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
             });
         }
         finally {
-            // Clear reader state so it's fresh for next connect
-            base.updateConnection(uuid, (c) => ({ ...c, reader: undefined }));
-            base.appendLog(uuid, {
-                level: 0,
-                message: "[!] Serial disconnected",
-            });
-            await disconnect(uuid);
+            base.updateConnection(uuid, (c) => ({ ...c }));
+            const conn = base.getConnection(uuid);
+            if (conn?.isConnected) {
+                await disconnect(uuid);
+            }
         }
     };
     const restartDevice = async (uuid, default_transport) => {
@@ -155,21 +156,6 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
             });
             base.updateConnection(uuid, (c) => ({ ...c, port }));
         }
-        else {
-            try {
-                const oldInfo = port.getInfo();
-                const authorizedPorts = await navigator.serial.getPorts();
-                const freshPort = authorizedPorts.find((p) => p.getInfo().usbVendorId === oldInfo.usbVendorId &&
-                    p.getInfo().usbProductId === oldInfo.usbProductId);
-                if (freshPort) {
-                    port = freshPort; // Swap out the dead pointer
-                    base.updateConnection(uuid, (c) => ({ ...c, port }));
-                }
-            }
-            catch (e) {
-                console.warn(`[${uuid}] Failed to silently heal port reference:`, e);
-            }
-        }
         base.updateConnection(uuid, (c) => ({ ...c, isConnecting: true }));
         const use_baudrate = baudrate ?? conn.baudrate ?? 115200;
         const transport = new Transport(port, false, false);
@@ -177,7 +163,7 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
             const esploader = new ESPLoader({
                 transport,
                 baudrate: use_baudrate,
-                enableTracing: false,
+                enableTracing: !!conn.debugLogging,
                 debugLogging: !!conn.debugLogging,
             });
             try {
@@ -230,29 +216,9 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
     };
     const disconnect = async (uuid, timeout = 2000) => {
         const conn = base.getConnection(uuid);
-        // 1. Politely kill our high-level generator
-        if (conn?.reader && typeof conn.reader.return === "function") {
-            try {
-                // @ts-ignore
-                await conn.reader.return();
-            }
-            catch (e) {
-                console.warn(`[${uuid}] Error returning generator lock:`, e);
-            }
-        }
         if (conn?.transport) {
             try {
-                // 2. AGGRESSIVE LOCK REMOVAL (The Fix)
-                // Dig into esptool-js's internal state and force the native reader to release.
-                // If we don't do this, transport.disconnect() will hang and fail to close the port.
-                const internalReader = conn.transport.reader;
-                if (internalReader) {
-                    await internalReader.cancel().catch(() => { });
-                    if (typeof internalReader.releaseLock === "function") {
-                        internalReader.releaseLock();
-                    }
-                }
-                // 3. Now that locks are cleared, attempt standard disconnect
+                // Attempt disconnect, but don’t hang if the port is crashed
                 await Promise.race([
                     conn.transport.disconnect(),
                     new Promise((resolve) => setTimeout(resolve, timeout)),
@@ -262,32 +228,20 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
                 console.warn(`[${uuid}] Serial Disconnect error:`, e);
             }
         }
-        // 4. NATIVE SAFETY NET
-        // Guarantee the port is closed natively just in case the transport failed
-        if (conn?.port) {
-            try {
-                if (conn.port.readable?.locked) {
-                    await conn.port.readable.cancel().catch(() => { });
-                }
-                if (conn.port.writable?.locked) {
-                    await conn.port.writable.abort().catch(() => { });
-                }
-                await conn.port.close().catch(() => { });
-            }
-            catch (e) {
-                // It will throw if already closed, which is perfectly fine.
-            }
-        }
-        // 5. Always clear the transport and reset connection state
+        // Always clear the transport and reset connection state
         base.updateConnection(uuid, (c) => ({
             ...c,
-            port: releasePortByDefault ? undefined : c.port,
-            transport: releasePortByDefault ? undefined : c.transport,
-            reader: undefined, // Guarantee reader is cleared out
+            port: releasePortByDefault ? null : c.port,
+            transport: releasePortByDefault ? null : c.transport,
+            esp: releasePortByDefault ? null : c.transport,
             isConnected: false,
             isConnecting: false,
             autoConnect: false,
         }));
+        base.appendLog(uuid, {
+            level: 0,
+            message: "[!] Serial disconnected",
+        });
         await conn?.onDisconnect?.();
     };
     const addConnection = async ({ uuid, propCreator, }) => {
@@ -362,27 +316,25 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
         // 1. Bail if we don't have the required state
         if (!conn || !conn.port || assetsToFlash.length === 0)
             return;
-        // Gracefully cancel reader and completely drop the transport natively
-        await disconnect(uuid);
-        await new Promise((resolve) => setTimeout(resolve, 400));
+        const prevAutoConnect = conn.autoConnect;
         base.updateConnection(uuid, (c) => ({
             ...c,
-            port: conn.port, // Restore the port into state in case disconnect wiped it
             isFlashing: true,
             flashProgress: 0,
             flashError: undefined,
+            autoConnect: false,
         }));
-        // Declare outside the try block (Fixes variable shadowing)
-        let transport;
-        let esploader;
+        if (conn.isConnected)
+            await disconnect(uuid);
+        await new Promise((resolve) => setTimeout(resolve, 400));
         try {
             // --- Connect ONCE ---
-            transport = new Transport(conn.port, true);
-            esploader = new ESPLoader({
+            const transport = new Transport(conn.port, true);
+            const esploader = new ESPLoader({
                 transport,
                 baudrate: 921600,
-                enableTracing: false,
-                // debugLogging: !!conn.debugLogging,
+                enableTracing: !!conn.debugLogging,
+                debugLogging: !!conn.debugLogging,
             });
             // This may fail, that'll bubble the failure up to the upper try/catch
             await esploader.main();
@@ -436,9 +388,8 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
                 ...c,
                 isFlashing: false,
                 flashProgress: 100,
+                autoConnect: prevAutoConnect,
             }));
-            // --- Reconnect the standard monitor ---
-            await connect(uuid);
         }
         catch (e) {
             console.error(`[${uuid}] Flashing failed:`, e);
@@ -448,6 +399,8 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
                 flashError: e?.message ?? "Unknown error",
             }));
             // Attempt recovery
+        }
+        finally {
             await connect(uuid);
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ota-hub-reactjs",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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",