@sailingrotevista/rotevista-dash 5.0.7 → 5.0.8

package/app.js

@@ -927,8 +927,8 @@ function manageHistory(type, value) {
 }
 
 /**
- * Gestione dinamica delle scale dei grafici (Involucro Elastico e Safety Zoom)
- * Implementa la logica di sicurezza disaccoppiata a 2 minuti per la profondità.
+ * Gestione dinamica delle scale dei grafici (Involucro Elastico Snapped e Safety Zoom)
+ * Implementa lo "Snap a Griglia" basato sull'hercSpan senza padding per tutti i sensori.
  */
 function calculateScale(type, data, mode) {
     const s = CONFIG.scales[type];
@@ -947,14 +947,14 @@ function calculateScale(type, data, mode) {
     let currentScale = store.herculesScales[type];
 
     // ==========================================================================
-    // SEZIONE PROFONDITÀ (REGOLA DI SICUREZZA DISACCOPPIATA A 2 MINUTI)
+    // 1. SEZIONE PROFONDITÀ (DEDICATA A 2 MINUTI DI SICUREZZA, MINIMO FISSO A 0)
     // ==========================================================================
     if (type === 'depth') {
         const shallowThreshold = Math.max(s.stdMax, 10); // Es. 20m
         if (store.depthProtectedActive === undefined) store.depthProtectedActive = false;
 
         const now = Date.now();
-        const depthSafetyWindowMs = 120000; // 2 minuti di stabilizzazione fissi per la sicurezza
+        const depthSafetyWindowMs = 120000; // 2 minuti fissi per la sicurezza
         
         // Estrazione dati reali degli ultimi 2 minuti con timestamp
         const recentPoints = store.histories.depth.filter(p => (now - p.time) <= depthSafetyWindowMs);
@@ -963,49 +963,40 @@ function calculateScale(type, data, mode) {
         const localMax = recentVals.length > 0 ? Math.max(...recentVals) : currentVal;
         const localMin = recentVals.length > 0 ? Math.min(...recentVals) : currentVal;
 
-        // --- NORMALE PROFONDITÀ (CON SOGLIA STANDARD E FILTRO 2 MINUTI) ---
+        // --- 1.1 NORMALE PROFONDITÀ (CON SOGLIA STANDARD E FILTRO 2 MINUTI) ---
         if (mode !== 'hercules') {
-            // Entrata istantanea sotto lo Standard Max (sicurezza immediata)
             if (!store.depthProtectedActive && currentVal <= shallowThreshold) {
                 store.depthProtectedActive = true;
             }
-
-            // Uscita ritardata: usciamo solo se il minimo degli ultimi 2 minuti è sopra soglia
             if (store.depthProtectedActive) {
                 if (localMin > shallowThreshold) {
                     store.depthProtectedActive = false;
                 }
             }
-
             if (store.depthProtectedActive) {
-                return { min: 0, max: shallowThreshold }; // Blocco a [0 - 20m]
+                return { min: 0, max: shallowThreshold };
             }
-
-            // Se siamo fuori, scala dinamica normale basata sull'intero buffer passato
             const maxHistorico = Math.max(...data);
             return { min: 0, max: Math.max(s.stdMax, Math.ceil(maxHistorico / s.step) * s.step) };
         }
 
-        // --- HERCULES PROFONDITÀ (0 IN BASSO, ZOOM SUL MASSIMO DEI 2 MINUTI) ---
+        // --- 1.2 HERCULES PROFONDITÀ (0 IN BASSO, SNAP SUL MAX SENZA PADDING) ---
         if (mode === 'hercules') {
-            const padding = 1.0; // 1 metro di margine sopra il fondo
+            const roundStep = s.hercSpan; // Passo di griglia selezionato dall'utente
             
-            // Calcoliamo i limiti ideali basati solo sugli ultimi 2 minuti
             let targetMin = 0;
-            let targetMax = Math.ceil(localMax + padding);
+            let targetMax = Math.ceil(localMax / roundStep) * roundStep;
 
-            // Impediamo una scala troppo stretta (minimo 4 metri di range totale per sicurezza)
+            // Impediamo una scala inferiore a 4 metri per sicurezza visiva
             const absoluteMinSpan = 4;
             if (targetMax < absoluteMinSpan) {
                 targetMax = absoluteMinSpan;
             }
 
-            // Regola asimmetrica di aggiornamento
+            // Regola asimmetrica per il MAX (Espansione istantanea, contrazione a 2 minuti)
             if (currentVal > currentScale.max) {
-                // Se andiamo verso il fondo profondo, allarghiamo istantaneamente
                 currentScale.max = targetMax;
             } else {
-                // Stringiamo lo zoom solo se tutti i dati degli ultimi 2 minuti sono inferiori al target
                 const allStableInTarget = recentVals.every(val => val <= targetMax);
                 if (allStableInTarget) {
                     currentScale.max = targetMax;
@@ -1018,34 +1009,51 @@ function calculateScale(type, data, mode) {
     }
 
     // ==========================================================================
-    // ALTRI GRAFICI (STW, SOG, TWS): MANTENGONO IL COMPORTAMENTO ORIGINALE
+    // 2. ALTRI GRAFICI (STW, SOG, TWS): COMPORTAMENTO ADATTIVO SU TERZO DEL GRAFICO
     // ==========================================================================
-    let aMin = Math.min(...data), aMax = Math.max(...data);
+    
+    // --- 2.1 MODALITÀ NORMALE ---
+    if (mode !== 'hercules') {
+        const maxHistorico = Math.max(...data);
+        return { min: 0, max: Math.max(s.stdMax, Math.ceil(maxHistorico / s.step) * s.step) };
+    }
 
+    // --- 2.2 MODALITÀ HERCULES AD ALTO CONTRASTO (SNAP SENZA PADDING) ---
     if (mode === 'hercules') {
-        const padding = (type === 'stw' || type === 'sog') ? 0.5 : 1.0;
+        const roundStep = s.hercSpan; // Passo di griglia (ex hercSpan)
+
+        const oneThirdCount = Math.max(1, Math.floor(data.length / 3));
+        const recentThirdData = data.slice(-oneThirdCount);
+
+        const localMin = Math.min(...recentThirdData);
+        const localMax = Math.max(...recentThirdData);
 
-        let min = Math.max(0, Math.floor(aMin - padding));
-        let max = Math.ceil(aMax + padding);
+        // Applichiamo lo snap diretto ai multipli della griglia
+        let targetMin = Math.max(0, Math.floor(localMin / roundStep) * roundStep);
+        let targetMax = Math.ceil(localMax / roundStep) * roundStep;
 
-        // Garantisce lo span minimo
-        const currentSpan = max - min;
-        if (currentSpan < s.hercSpan) {
-            const diff = s.hercSpan - currentSpan;
-            min = Math.max(0, min - Math.floor(diff / 2));
-            max = min + s.hercSpan;
+        // Se lo span calcolato è nullo (es. velocità costante), forziamo lo span minimo
+        if (targetMax - targetMin === 0) {
+            targetMax = targetMin + roundStep;
         }
 
-        // Arrotonda la griglia numerica a step prefissati
-        const roundStep = (type === 'stw' || type === 'sog') ? 0.5 : 1.0;
-        min = Math.floor(min / roundStep) * roundStep;
-        max = Math.ceil(max / roundStep) * roundStep;
+        // APPLICAZIONE REGOLE ASIMMETRICHE ANTI-CLIPPING
+        // A. Espansione ISTANTANEA in alto o in basso (sicurezza)
+        if (currentVal < currentScale.min || currentVal > currentScale.max) {
+            currentScale.min = Math.min(currentScale.min, targetMin);
+            currentScale.max = Math.max(currentScale.max, targetMax);
+        }
+        // B. Contrazione RITARDATA (solo se tutto il terzo recente si è assestato nel target)
+        else {
+            const allStableInTarget = recentThirdData.every(val => val >= targetMin && val <= targetMax);
+            if (allStableInTarget) {
+                currentScale.min = targetMin;
+                currentScale.max = targetMax;
+            }
+        }
 
-        return { min, max };
+        return { min: currentScale.min, max: currentScale.max };
     }
-    
-    // Scala Standard (Autocompressione a scatti)
-    return { min: 0, max: Math.max(s.stdMax, Math.ceil(aMax / s.step) * s.step) };
 }
 
 function updateScaleLabels(t, min, max) {

package/index.js

@@ -127,10 +127,10 @@ module.exports = function (app) {
             default: 0.5
           },
           stabilityThreshold: {
-              type: 'number',
-              title: 'Steering Precision (Sensitivity)',
-              description: "How strictly the system judges data coherence (0.0 to 1.0). Due to internal smoothing, 0.97-0.98 requires racing precision; 0.93-0.95 is ideal for cruising in waves. Below this, the display rarely alerts for instability.",
-                default: 0.95 
+            type: 'number',
+            title: 'Steering Precision (Sensitivity)',
+            description: "How strictly the system judges data coherence (0.0 to 1.0). Due to internal smoothing, 0.97-0.98 requires racing precision; 0.93-0.95 is ideal for cruising in waves. Below this, the display rarely alerts for instability.",
+            default: 0.95
           },
           stabilityBreakout: {
             type: 'number',
@@ -152,7 +152,13 @@ module.exports = function (app) {
             properties: {
               stdMax: { type: 'number', title: 'Standard Max', description: "Default top limit of the graph.", default: 12 },
               step: { type: 'number', title: 'Scale Jump', description: "Amount the scale increases when you exceed the limit.", default: 2 },
-              hercSpan: { type: 'number', title: 'Hercules Zoom Span', description: "Width of the zoom window around your current speed.", default: 4 }
+              hercSpan: {
+                type: 'number',
+                title: 'Hercules Grid Step (Resolution)',
+                description: "Select the multiplier step for the Hercules zoom. The scale boundaries will always snap to multiples of this value.",
+                enum: [0.5, 1.0, 2.0, 3.0],
+                default: 1.0
+              }
             }
           },
           sog: {
@@ -161,7 +167,13 @@ module.exports = function (app) {
             properties: {
               stdMax: { type: 'number', title: 'Standard Max', default: 12 },
               step: { type: 'number', title: 'Scale Jump', default: 2 },
-              hercSpan: { type: 'number', title: 'Hercules Zoom Span', default: 4 }
+              hercSpan: {
+                type: 'number',
+                title: 'Hercules Grid Step (Resolution)',
+                description: "Select the multiplier step for the Hercules zoom. The scale boundaries will always snap to multiples of this value.",
+                enum: [0.5, 1.0, 2.0, 3.0],
+                default: 1.0
+              }
             }
           },
           tws: {
@@ -170,7 +182,13 @@ module.exports = function (app) {
             properties: {
               stdMax: { type: 'number', title: 'Standard Max', default: 25 },
               step: { type: 'number', title: 'Scale Jump', default: 5 },
-              hercSpan: { type: 'number', title: 'Hercules Zoom Span', default: 10 }
+              hercSpan: {
+                type: 'number',
+                title: 'Hercules Grid Step (Resolution)',
+                description: "Select the multiplier step for the Hercules zoom. The scale boundaries will always snap to multiples of this value.",
+                enum: [1, 2, 3, 5, 10],
+                default: 2
+              }
             }
           },
           depth: {
@@ -179,7 +197,13 @@ module.exports = function (app) {
             properties: {
               stdMax: { type: 'number', title: 'Standard Max', default: 20 },
               step: { type: 'number', title: 'Scale Jump', default: 10 },
-              hercSpan: { type: 'number', title: 'Hercules Zoom Span', default: 10 }
+              hercSpan: {
+                type: 'number',
+                title: 'Hercules Grid Step (Resolution)',
+                description: "Select the multiplier step for the Hercules zoom. The scale boundaries will always snap to multiples of this value.",
+                enum: [1, 2, 3, 5, 10],
+                default: 2
+              }
             }
           }
         }

package/package.json

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