ota-hub-reactjs 0.1.1 → 0.1.3

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

@@ -5,7 +5,7 @@ export type ESP32ConnectionState = DeviceConnectionState & {
     baudrate?: number;
     transport?: Transport;
     esp?: ESPLoader;
-    reader?: AsyncGenerator<Uint8Array>;
+    debugLogging?: false;
     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) => {
@@ -177,7 +178,8 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
             const esploader = new ESPLoader({
                 transport,
                 baudrate: use_baudrate,
-                enableTracing: false,
+                enableTracing: !!conn.debugLogging,
+                debugLogging: !!conn.debugLogging,
             });
             try {
                 await esploader.main();
@@ -229,18 +231,6 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
     };
     const disconnect = async (uuid, timeout = 2000) => {
         const conn = base.getConnection(uuid);
-        // 1. POLITELY KILL THE READER
-        // If we have an active reader generator in state, call return() to
-        // gracefully resolve the pending reader.next() in the background loop
-        if (conn?.reader && typeof conn.reader.return === "function") {
-            try {
-                // @ts-ignore - The underlying AsyncGenerator handles return gracefully
-                await conn.reader.return();
-            }
-            catch (e) {
-                console.warn(`[${uuid}] Error returning generator lock:`, e);
-            }
-        }
         if (conn?.transport) {
             try {
                 // Attempt disconnect, but don’t hang if the port is crashed
@@ -256,13 +246,17 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
         // 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, }) => {
@@ -332,37 +326,34 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
     };
     // This function now handles an entire device flashing session
     const handleFlashFirmware = async (uuid, assetsToFlash) => {
+        // Capture the original connection and port reference before disconnect
         const conn = base.getConnection(uuid);
         // 1. Bail if we don't have the required state
-        if (!conn ||
-            !conn.transport ||
-            !conn.port ||
-            !conn.esp ||
-            assetsToFlash.length === 0)
+        if (!conn || !conn.port || assetsToFlash.length === 0)
             return;
-        // Gracefully cancel reader and completely drop the transport natively
-        await disconnect(uuid);
+        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,
         }));
+        if (conn.isConnected)
+            await disconnect(uuid);
+        await new Promise((resolve) => setTimeout(resolve, 400));
         try {
             // --- Connect ONCE ---
             const transport = new Transport(conn.port, true);
             const esploader = new ESPLoader({
                 transport,
                 baudrate: 921600,
-                enableTracing: false,
+                enableTracing: !!conn.debugLogging,
+                debugLogging: !!conn.debugLogging,
             });
-            try {
-                await esploader.main();
-            }
-            catch (e) {
-                console.log("failed to esploader.main()", e);
-                return;
-            }
+            // This may fail, that'll bubble the failure up to the upper try/catch
+            await esploader.main();
             // --- Prepare an ARRAY of files for the library ---
             const fileArray = await Promise.all(assetsToFlash.map(async ({ blob, address }) => {
                 const arrayBuffer = await blob.arrayBuffer();
@@ -371,32 +362,34 @@ export function useESP32MultiDeviceWhisperer({ releasePortByDefault, ...props }
                     .join("");
                 return { data: binaryString, address };
             }));
+            let lastRenderTime = 0;
             const flashOptions = {
-                fileArray, // Pass the whole array here
+                fileArray,
                 flashSize: "keep",
                 flashMode: "qio",
                 flashFreq: "80m",
                 eraseAll: fileArray.length > 1, // Writing more than 1 thing, so likely writing partitions.
                 compress: true,
                 reportProgress: (fileIndex, written, total) => {
-                    // 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,
-                    }));
+                    const now = performance.now();
+                    // Throttle UI updates to at most once every 100ms (~10 FPS),
+                    // but ALWAYS ensure the final 100% tick renders.
+                    if (now - lastRenderTime > 100 || written === total) {
+                        lastRenderTime = now;
+                        // Optional: Only log every 100ms as well to prevent console spam
+                        console.log(`Flashing file ${fileIndex + 1}/${fileArray.length}: ${progress.toFixed(1)}%`);
+                        base.updateConnection(uuid, (c) => ({
+                            ...c,
+                            flashProgress: progress,
+                        }));
+                    }
                 },
             };
             // --- Call writeFlash ONCE with all files ---
-            try {
-                base.updateConnection(uuid, (c) => ({ ...c, flashProgress: -1 }));
-                await esploader.writeFlash(flashOptions);
-            }
-            catch (e) {
-                console.log("failed to esploader.writeFlash", e);
-            }
-            // --- Disconnect ---
+            base.updateConnection(uuid, (c) => ({ ...c, flashProgress: -1 }));
+            await esploader.writeFlash(flashOptions);
+            // --- Disconnect cleanly ---
             await esploader.after();
             try {
                 await transport.disconnect();
@@ -411,9 +404,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);
@@ -423,6 +415,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.1",
+  "version": "0.1.3",
   "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",