@sailingrotevista/rotevista-dash 7.0.15 → 7.0.17

package/app.js

@@ -23,7 +23,7 @@ let CONFIG = {
         minSpeed: 0.5,
         stabilityBreakout: 15
     },
-    graphs: { reef1: 10, reef2: 15, historyMinutes: 10, samples: 60 },
+    graphs: { reef1: 10, reef2: 15, historyMinutes: 5, samples: 60 },
     scales: {
         stw: { stdMax: 4, hercSpan: 2, step: 1 },
         sog: { stdMax: 4, hercSpan: 2, step: 1 },
@@ -964,11 +964,11 @@ function manageHistory(type, value) {
     const bucketReady = (now - store.lastUpdates[type] > bucketIntervalMs) || store.histories[type].length === 0;
     if (!bucketReady) return;
 
-    // --- 5. AGGREGAZIONE SEMANTICA ---
+    // --- 5. AGGREGAZIONE SEMANTICA (Ottimizzata a zero-allocazioni di array intermedi) ---
     let finalValue = value;
 
     if (tempBuf.length > 0) {
-        // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware)
+        // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware) (0 allocazioni)
         if (type === 'tws' || type === 'aws') {
             const tauMs = 2500;
             let ema = tempBuf[0].val;
@@ -982,17 +982,32 @@ function manageHistory(type, value) {
             }
             finalValue = maxSustained;
         }
-        // B. PROFONDITÀ -> MINIMO
+        // B. PROFONDITÀ -> MINIMO (In-place loop, 0 allocazioni)
         else if (type === 'depth') {
-            const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-            if (vals.length > 0) finalValue = Math.min(...vals);
+            let minVal = Infinity;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v) && v < minVal) {
+                    minVal = v;
+                }
+            }
+            if (minVal !== Infinity) {
+                finalValue = minVal;
+            }
         }
-        // C. VELOCITÀ -> MEDIA
+        // C. VELOCITÀ -> MEDIA (In-place loop, 0 allocazioni)
         else {
-            const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-            if (vals.length > 0) {
-                const sum = vals.reduce((a, b) => a + b, 0);
-                finalValue = sum / tempBuf.length;
+            let sum = 0;
+            let count = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v)) {
+                    sum += v;
+                    count++;
+                }
+            }
+            if (count > 0) {
+                finalValue = sum / count;
             }
         }
     }
@@ -1201,9 +1216,15 @@ function connect() {
         socket.onclose = () => {
             if (!simulationMode) {
                 ui.status.className = "offline";
-                ui.status.innerText = "RECONNECTING...";
-                setTimeout(connect, reconnectDelay);
-                reconnectDelay = Math.min(reconnectDelay * 1.5, 10000);
+                ui.status.innerText = "OFFLINE";
+                
+                // Tentiamo la riconnessione automatica solo se lo schermo è attivo e visibile,
+                // evitando cicli di loop di rete infiniti in background mentre il tablet dorme
+                if (document.visibilityState === "visible") {
+                    ui.status.innerText = "RECONNECTING...";
+                    setTimeout(connect, reconnectDelay);
+                    reconnectDelay = Math.min(reconnectDelay * 1.5, 10000);
+                }
             }
         };
     } catch (e) {
@@ -1319,24 +1340,17 @@ async function init() {
     }
 }
 
-// Watchdog per il risveglio dallo stato di sospensione / cambio scheda
+// Watchdog attivo per la gestione intelligente dello standby e il massimo risparmio energetico
 document.addEventListener('visibilitychange', () => {
     if (document.visibilityState === 'visible') {
-        console.log("🔌 [Watchdog] Tab ritornato visibile. Verifica connessione...");
-        
-        // Se il socket esiste ma non è attivo o se vogliamo forzare la pulizia delle connessioni fantasma:
+        console.log("🔌 [Watchdog] Schermo sbloccato / Tab visibile. Riconnessione immediata e allineamento storico...");
+        // Al risveglio stabiliamo una nuova connessione pulita che scaricherà lo storico accumulato in background dal server
+        connect();
+    } else if (document.visibilityState === 'hidden') {
+        console.log("🔌 [Watchdog] Schermo bloccato / Tab in background. Chiusura WebSocket preventiva per salvaguardare la batteria.");
+        // Tagliamo attivamente la connessione per congelare all'istante l'attività di rete ed i consumi del browser
         if (socket) {
-            if (socket.readyState !== WebSocket.OPEN) {
-                // Se era già chiuso o in errore, proviamo a riconnettere subito
-                connect();
-            } else {
-                // Se resulta "OPEN" ma potrebbe essere una connessione fantasma,
-                // la chiudiamo forzatamente per scatenare la riconnessione pulita e il download della cronologia
-                console.log("🔌 [Watchdog] Riavvio precauzionale del WebSocket per evitare connessioni fantasma.");
-                socket.close();
-            }
-        } else {
-            connect();
+            socket.close();
         }
     }
 });

package/index.js

@@ -351,81 +351,111 @@ module.exports = function (app) {
         let isTwdType = (type === 'twd');
 
         if (tempBuf.length > 0) {
-            // ==========================================================================
-            // CASO PARTICOLARE: DIREZIONE VENTO (TWD) -> MEDIA PESATA E LIMITI MIN/MAX
-            // ==========================================================================
-            if (isTwdType) {
-                // 1. Identifica il vento massimo del minuto (in m/s)
-                const twsVals = tempBuf.map(p => p.tws || 0);
-                const maxTwsInMinute = Math.max(...twsVals, 0);
-
-                // 2. Calcola la soglia dinamica di pressione: max tra 40% del picco e soglia di calma piatta (in m/s)
-                const calmThresholdMs = CALM_THRESHOLD_KTS / 1.94384;
-                const pressureThreshold = Math.max(maxTwsInMinute * PRESSURE_FILTER_RATIO, calmThresholdMs);
-
-                // 3. Esclude le direzioni registrate quando il vento era debole (sotto la soglia di pressione)
-                const activePoints = tempBuf.filter(p => (p.tws || 0) >= pressureThreshold);
-                const pointsToUse = activePoints.length > 0 ? activePoints : tempBuf; // Fallback se tutto è calma piatta
-
-                // 4. Media Vettoriale Pesata (TWS * sin, TWS * cos)
-                let sumSin = 0;
-                let sumCos = 0;
-                let totalWeight = 0;
-                pointsToUse.forEach(p => {
-                    const weight = Math.max(p.tws || 0.1, 0.05); // Evita pesi a zero
-                    sumSin += weight * Math.sin(p.val);
-                    sumCos += weight * Math.cos(p.val);
-                    totalWeight += weight;
-                });
-                const avgAngle = Math.atan2(sumSin, sumCos);
-                const finalAvg = (avgAngle + Math.PI * 2) % (Math.PI * 2);
-
-                // 5. Calcolo di Min e Max angolare del minuto (rispetto alla media per gestire l'oltrepasso di 0/360°)
-                let diffs = pointsToUse.map(p => {
-                    let diff = p.val - finalAvg;
-                    return Math.atan2(Math.sin(diff), Math.cos(diff)); // Srotolamento tra -PI e +PI
-                });
-
-                const minDiff = Math.min(...diffs);
-                const maxDiff = Math.max(...diffs);
-
-                const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
-                const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
-
-                finalValue = {
-                    val: finalAvg,
-                    min: finalMin,
-                    max: finalMax
-                };
+        // ==========================================================================
+        // CASO PARTICOLARE: DIREZIONE VENTO (TWD) -> MEDIA PESATA E LIMITI MIN/MAX
+        // ==========================================================================
+        if (isTwdType) {
+            // 1. Identifica il vento massimo del minuto (in m/s) - Loop in-place (0 allocazioni)
+            let maxTwsInMinute = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const tws = tempBuf[i].tws || 0;
+                if (tws > maxTwsInMinute) maxTwsInMinute = tws;
             }
-            // A. VENTO VELOCITÀ -> SUSTAINED PEAK (EMA Time-Aware)
-            else if (type === 'tws' || type === 'aws') {
-                const tauMs = 2500;
-                let ema = tempBuf[0].val;
-                let maxSustained = ema;
-
-                for (let i = 1; i < tempBuf.length; i++) {
-                    const dt = Math.max(1, tempBuf[i].time - tempBuf[i-1].time);
-                    const alpha = 1 - Math.exp(-dt / tauMs);
-                    ema = (tempBuf[i].val * alpha) + (ema * (1 - alpha));
-                    if (isFinite(ema) && ema > maxSustained) maxSustained = ema;
+
+            // 2. Calcola la soglia dinamica di pressione
+            const calmThresholdMs = CALM_THRESHOLD_KTS / 1.94384;
+            const pressureThreshold = Math.max(maxTwsInMinute * PRESSURE_FILTER_RATIO, calmThresholdMs);
+
+            // 3. Determina in un unico passaggio se ci sono punti attivi sopra la soglia (0 allocazioni)
+            let hasActivePoints = false;
+            for (let i = 0; i < tempBuf.length; i++) {
+                if ((tempBuf[i].tws || 0) >= pressureThreshold) {
+                    hasActivePoints = true;
+                    break;
                 }
-                finalValue = maxSustained;
             }
-            // B. PROFONDITÀ -> MINIMO
-            else if (type === 'depth') {
-                const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-                if (vals.length > 0) finalValue = Math.min(...vals);
+
+            // 4. Media Vettoriale Pesata (0 allocazioni di array)
+            let sumSin = 0;
+            let sumCos = 0;
+            let totalWeight = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const p = tempBuf[i];
+                if (hasActivePoints && (p.tws || 0) < pressureThreshold) continue;
+
+                const weight = Math.max(p.tws || 0.1, 0.05);
+                sumSin += weight * Math.sin(p.val);
+                sumCos += weight * Math.cos(p.val);
+                totalWeight += weight;
             }
-            // C. VELOCITÀ BARCA / ALTRO -> MEDIA
-            else {
-                const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-                if (vals.length > 0) {
-                    const sum = vals.reduce((a, b) => a + b, 0);
-                    finalValue = sum / tempBuf.length;
+            const avgAngle = Math.atan2(sumSin, sumCos);
+            const finalAvg = (avgAngle + Math.PI * 2) % (Math.PI * 2);
+
+            // 5. Calcolo di Min e Max angolare del minuto (0 allocazioni di array)
+            let minDiff = 0;
+            let maxDiff = 0;
+            let firstDiff = true;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const p = tempBuf[i];
+                if (hasActivePoints && (p.tws || 0) < pressureThreshold) continue;
+
+                const diff = Math.atan2(Math.sin(p.val - finalAvg), Math.cos(p.val - finalAvg));
+                if (firstDiff) {
+                    minDiff = diff;
+                    maxDiff = diff;
+                    firstDiff = false;
+                } else {
+                    if (diff < minDiff) minDiff = diff;
+                    if (diff > maxDiff) maxDiff = diff;
                 }
             }
+
+            const finalMin = (finalAvg + minDiff + Math.PI * 2) % (Math.PI * 2);
+            const finalMax = (finalAvg + maxDiff + Math.PI * 2) % (Math.PI * 2);
+
+            finalValue = {
+                val: finalAvg,
+                min: finalMin,
+                max: finalMax
+            };
         }
+        // A. VENTO VELOCITÀ -> SUSTAINED PEAK (EMA Time-Aware) (Inalterato per minimizzare le modifiche)
+        else if (type === 'tws' || type === 'aws') {
+            const tauMs = 2500;
+            let ema = tempBuf[0].val;
+            let maxSustained = ema;
+
+            for (let i = 1; i < tempBuf.length; i++) {
+                const dt = Math.max(1, tempBuf[i].time - tempBuf[i-1].time);
+                const alpha = 1 - Math.exp(-dt / tauMs);
+                ema = (tempBuf[i].val * alpha) + (ema * (1 - alpha));
+                if (isFinite(ema) && ema > maxSustained) maxSustained = ema;
+            }
+            finalValue = maxSustained;
+        }
+        // B. PROFONDITÀ -> MINIMO (Ottimizzato a 0 allocazioni)
+        else if (type === 'depth') {
+            let minVal = Infinity;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v) && v < minVal) minVal = v;
+            }
+            if (minVal !== Infinity) finalValue = minVal;
+        }
+        // C. VELOCITÀ BARCA / ALTRO -> MEDIA (Ottimizzato a 0 allocazioni)
+        else {
+            let sum = 0;
+            let count = 0;
+            for (let i = 0; i < tempBuf.length; i++) {
+                const v = tempBuf[i].val;
+                if (isFinite(v)) {
+                    sum += v;
+                    count++;
+                }
+            }
+            if (count > 0) finalValue = sum / count;
+        }
+    }
 
         // Validazione e clamping di sicurezza (non si applica all'oggetto TWD)
         if (!isTwdType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailingrotevista/rotevista-dash",
-  "version": "7.0.15",
+  "version": "7.0.17",
   "description": "Wind Dashboard with navigation and course aids",
   "main": "index.js",
   "publishConfig": {