@sailingrotevista/rotevista-dash 5.0.7 → 6.0.1

package/app.js

@@ -616,14 +616,11 @@ function startDisplayLoop() {
         if (store.raw["navigation.speedThroughWater"] !== undefined) {
             ui.stw.innerText = stwKts.toFixed(1);
             ui.stw.style.color = ""; // Neutro
-            manageHistory('stw', stwKts);
         }
         
         // --- LOGICA SOG / VMG ---
         if (store.raw["navigation.speedOverGround"] !== undefined) {
             const vmgVal = Math.abs(stwKts * Math.cos(store.raw["environment.wind.angleTrueWater"] || 0));
-            manageHistory('vmg', vmgVal);
-            manageHistory('sog', sogKts);
             
             const labelSogVmg = document.getElementById('sog-vmg-label');
             if (displayModeSog === 'VMG') {
@@ -652,16 +649,12 @@ function startDisplayLoop() {
         if (store.raw["environment.depth.belowTransducer"] !== undefined) {
             ui.depth.innerText = store.raw["environment.depth.belowTransducer"].toFixed(1);
             checkDepthAlarm(store.raw["environment.depth.belowTransducer"]);
-            manageHistory('depth', store.raw["environment.depth.belowTransducer"]);
         }
 
         // --- GESTIONE VENTO (TWS / AWS SWITCH) ---
         const twsVal = store.raw["environment.wind.speedTrue"] ? msToKts(store.raw["environment.wind.speedTrue"]) : 0;
         const awsVal = store.raw["environment.wind.speedApparent"] ? msToKts(store.raw["environment.wind.speedApparent"]) : 0;
         
-        if (store.raw["environment.wind.speedTrue"] !== undefined) manageHistory('tws', twsVal);
-        if (store.raw["environment.wind.speedApparent"] !== undefined) manageHistory('aws', awsVal);
-
         if (store.raw["environment.wind.speedTrue"] !== undefined || store.raw["environment.wind.speedApparent"] !== undefined) {
             const labelWind = document.getElementById('tws-aws-label');
             const currentWind = (displayModeTws === 'AWS') ? awsVal : twsVal;
@@ -801,7 +794,7 @@ async function fetchServerConfig() {
         applyConfigData(data);
         console.log("✅ Configurazione iniziale applicata con successo.");
     } catch (err) {
-        console.warn("⚠️ Impossibile raggiungere il server per le configurazioni. Utilizzo default locali. Motivo:", err.message);
+        console.warn("⚠️ Impossibile raggiungere le configurazioni dal server. Utilizzo default.");
     }
 }
 
@@ -837,215 +830,26 @@ async function watchConfigChanges() {
 }
 
 /**
- * manageHistory v3.7 - Aggregazione semantica "Pro-Grade"
- * Integrazioni:
- * 1. Strict undefined check per lastUpdates.
- * 2. Anti-dropout dinamico tarato sul 50% del Reef 1.
- * 3. Clamping di sicurezza (no negativi, no Infinity).
+ * Recupera lo storico dei grafici pre-popolato dal server Signal K (Pro v6.0)
  */
-function manageHistory(type, value) {
-    // --- 1. VALIDAZIONE INPUT RIGOROSA ---
-    if (value === undefined || value === null || !isFinite(value)) return;
-
-    const now = Date.now();
-    const historyMinutes = Math.max(1, CONFIG.graphs.historyMinutes || 10);
-    const samples = Math.max(2, CONFIG.graphs.samples || 60);
-    const bucketIntervalMs = (historyMinutes * 60000) / samples;
-
-    // --- 2. INIT SICURO (Strict Check) ---
-    if (!store.graphTempBuf[type]) store.graphTempBuf[type] = [];
-    if (!store.histories[type]) store.histories[type] = [];
-    if (store.lastUpdates[type] === undefined) store.lastUpdates[type] = 0;
-
-    const tempBuf = store.graphTempBuf[type];
-
-    // --- 3. ANTI-DROPOUT DINAMICO (Auto-scaling) ---
-    if ((type === 'tws' || type === 'aws') && value < 0.05 && tempBuf.length > 0) {
-        const lastPoint = tempBuf[tempBuf.length - 1];
-        const glitchThreshold = (CONFIG.graphs.reef1 || 15) * 0.5;
-        if (lastPoint && lastPoint.val > glitchThreshold) return;
-    }
-
-    // --- 4. STORAGE TEMPORANEO ---
-    tempBuf.push({ val: value, time: now });
-
-    // Controllo finestra temporale
-    const bucketReady = (now - store.lastUpdates[type] > bucketIntervalMs) || store.histories[type].length === 0;
-    if (!bucketReady) return;
-
-    // --- 5. AGGREGAZIONE SEMANTICA ---
-    let finalValue = value;
-
-    if (tempBuf.length > 0) {
-        // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware)
-        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
-        else if (type === 'depth') {
-            const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
-            if (vals.length > 0) finalValue = Math.min(...vals);
-        }
-        // C. VELOCITÀ -> 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;
-            }
-        }
-    }
-
-    // --- 6. CLAMPING E VALIDAZIONE FINALE ---
-    if (!isFinite(finalValue)) return;
-    finalValue = Math.max(0, finalValue);
-
-    // --- 7. STORAGE STORICO ---
-    store.histories[type].push({ val: finalValue, time: now });
-
-    // --- 8. PRUNING DINAMICO ---
-    const maxViewportMinutes = historyMinutes * 2;
-    const maxHistoryMs = (maxViewportMinutes * 60000) + 60000;
-
-    while (store.histories[type].length > 0 && (now - store.histories[type][0].time) > maxHistoryMs) {
-        store.histories[type].shift();
-    }
-
-    // Reset per il prossimo bucket
-    store.graphTempBuf[type] = [];
-    store.lastUpdates[type] = now;
-}
-
-/**
- * Gestione dinamica delle scale dei grafici (Involucro Elastico e Safety Zoom)
- * Implementa la logica di sicurezza disaccoppiata a 2 minuti per la profondità.
- */
-function calculateScale(type, data, mode) {
-    const s = CONFIG.scales[type];
-    const currentVal = data[data.length - 1];
-    
-    // Fallback di emergenza se il buffer è momentaneamente vuoto
-    if (currentVal === undefined || currentVal === null) {
-        return { min: 0, max: s ? s.stdMax : 10 };
-    }
-
-    // Inizializzazione della memoria delle scale nello store se non esiste
-    if (!store.herculesScales) store.herculesScales = {};
-    if (!store.herculesScales[type]) {
-        store.herculesScales[type] = { min: 0, max: s ? s.stdMax : 10 };
-    }
-    let currentScale = store.herculesScales[type];
-
-    // ==========================================================================
-    // SEZIONE PROFONDITÀ (REGOLA DI SICUREZZA DISACCOPPIATA A 2 MINUTI)
-    // ==========================================================================
-    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
+async function fetchServerHistory() {
+    try {
+        const response = await fetch('/rotevista-history');
+        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+        const data = await response.json();
         
-        // Estrazione dati reali degli ultimi 2 minuti con timestamp
-        const recentPoints = store.histories.depth.filter(p => (now - p.time) <= depthSafetyWindowMs);
-        const recentVals = recentPoints.map(p => p.val);
-
-        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) ---
-        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]
-            }
-
-            // 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) ---
-        if (mode === 'hercules') {
-            const padding = 1.0; // 1 metro di margine sopra il fondo
-            
-            // Calcoliamo i limiti ideali basati solo sugli ultimi 2 minuti
-            let targetMin = 0;
-            let targetMax = Math.ceil(localMax + padding);
-
-            // Impediamo una scala troppo stretta (minimo 4 metri di range totale per sicurezza)
-            const absoluteMinSpan = 4;
-            if (targetMax < absoluteMinSpan) {
-                targetMax = absoluteMinSpan;
-            }
-
-            // Regola asimmetrica di aggiornamento
-            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;
+        if (data && typeof data === 'object') {
+            for (let key in data) {
+                if (store.histories[key] !== undefined) {
+                    store.histories[key] = data[key];
                 }
             }
-
-            currentScale.min = 0;
-            return { min: currentScale.min, max: currentScale.max };
+            console.log("📈 Storico dei grafici pre-popolato caricato dal server.");
         }
+    } catch (err) {
+        console.warn("⚠️ Impossibile caricare lo storico dal server. Utilizzo dati vuoti/simulati.");
+        throw err; // Rilancia l'errore per far attivare il fallback nella funzione init()
     }
-
-    // ==========================================================================
-    // ALTRI GRAFICI (STW, SOG, TWS): MANTENGONO IL COMPORTAMENTO ORIGINALE
-    // ==========================================================================
-    let aMin = Math.min(...data), aMax = Math.max(...data);
-
-    if (mode === 'hercules') {
-        const padding = (type === 'stw' || type === 'sog') ? 0.5 : 1.0;
-
-        let min = Math.max(0, Math.floor(aMin - padding));
-        let max = Math.ceil(aMax + padding);
-
-        // 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;
-        }
-
-        // 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;
-
-        return { min, 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) {
@@ -1120,7 +924,8 @@ function drawGraph(d, id, min, max, isTws, isHercules) {
     };
 
     let grids = "";
-    [0.25, 0.5, 0.75].forEach(p => grids += `<line x1="0" y1="${h-(p*h)}" x2="${w}" y2="${h-(p*h)}" stroke="rgba(0,0,0,0.12)" stroke-width="0.5" />`);
+    // Una sola linea di griglia centrale al 50%, matematicamente sempre intera e allineata all'etichetta
+    [0.5].forEach(p => grids += `<line x1="0" y1="${h-(p*h)}" x2="${w}" y2="${h-(p*h)}" stroke="rgba(0,0,0,0.12)" stroke-width="0.5" />`);
 
     const gridInterval = (visibleMinutes <= 15) ? 1 : 5;
     for (let m = gridInterval; m < visibleMinutes; m += gridInterval) {
@@ -1317,6 +1122,17 @@ window.addEventListener('contextmenu', e => e.preventDefault(), true);
 
 async function init() {
     loadDashboardState();
+    
+    // Prova a caricare lo storico dal server. Se fallisce (test offline), gestisce il fallback
+    try {
+        await fetchServerHistory();
+    } catch (err) {
+        if (simulationMode) {
+            // Se sei in modalità simulazione locale, puoi generare dati finti qui (opzionale)
+            console.log("🎮 Modalità Simulazione Locale attiva.");
+        }
+    }
+
     await fetchServerConfig();
     startDisplayLoop();
     connect();

package/index.js

@@ -1,9 +1,9 @@
 /**
  * ==========================================================================
- * Rotevista Dash Configuration Plugin
+ * Rotevista Dash Configuration & History Plugin (Pro v6.0)
  * ==========================================================================
  * Definisce l'interfaccia di configurazione in Signal K Admin e crea
- * l'endpoint pubblico per la comunicazione con la Dashboard.
+ * gli endpoint pubblici per la Dashboard, mantenendo lo storico in RAM.
  */
 
 module.exports = function (app) {
@@ -14,40 +14,213 @@ module.exports = function (app) {
 
   let currentConfig = {};
   let routeRegistered = false;
+  let unsubscribes = [];
+
+  // Database dello storico in RAM sul server
+  let histories = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [] };
+  let graphTempBuf = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [] };
+  let lastUpdates = { stw: 0, sog: 0, depth: 0, tws: 0, vmg: 0, aws: 0 };
+  let raw = {};
 
   /**
    * plugin.start: Inizializza il plugin.
    * Viene chiamato all'avvio e OGNI VOLTA che clicchi "Save" nelle impostazioni.
    */
   plugin.start = function (options) {
-    // 1. Aggiorna la configurazione in memoria (per l'endpoint pubblico)
+    // 1. Aggiorna la configurazione in memoria
     currentConfig = options;
-
-    // 2. Log di debug nel server Signal K
     app.debug(`${plugin.name} started/updated with new options`);
 
-    // 3. Registra la rotta API solo la prima volta
+    // Reset dello storico al riavvio del plugin per evitare incoerenze
+    histories = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [] };
+    graphTempBuf = { stw: [], sog: [], depth: [], tws: [], vmg: [], aws: [] };
+    lastUpdates = { stw: 0, sog: 0, depth: 0, tws: 0, vmg: 0, aws: 0 };
+    raw = {};
+
+    // 2. Registra le rotte API solo la prima volta
     if (!routeRegistered) {
       app.get('/rotevista-config', (req, res) => {
         res.json(currentConfig);
       });
+      app.get('/rotevista-history', (req, res) => {
+        res.json(histories);
+      });
       routeRegistered = true;
-      app.debug('Public API endpoint registered at /rotevista-config');
+      app.debug('Public API endpoints registered at /rotevista-config and /rotevista-history');
     }
+
+    // 3. Iscrizione ai dati dei sensori di bordo tramite Signal K
+    const localSubscription = {
+      context: 'vessels.self',
+      subscribe: [
+        { path: 'navigation.speedThroughWater' },
+        { path: 'navigation.speedOverGround' },
+        { path: 'environment.depth.belowTransducer' },
+        { path: 'environment.wind.speedApparent' },
+        { path: 'environment.wind.angleApparent' },
+        { path: 'navigation.headingTrue' },
+        { path: 'navigation.courseOverGroundTrue' }
+      ]
+    };
+
+    app.subscriptionmanager.subscribe(
+      localSubscription,
+      unsubscribes,
+      subscriptionError => {
+        app.error('Subscription error: ' + subscriptionError);
+      },
+      delta => {
+        if (delta.updates) {
+          delta.updates.forEach(update => {
+            if (update.values) {
+              update.values.forEach(v => {
+                processIncomingDelta(v.path, v.value);
+              });
+            }
+          });
+        }
+      }
+    );
   };
 
   /**
-   * plugin.stop: Chiamato quando il plugin viene disattivato o prima di un aggiornamento.
+   * plugin.stop: Chiamato quando il plugin viene disattivato.
    */
   plugin.stop = function () {
+    unsubscribes.forEach(f => f());
+    unsubscribes = [];
     app.debug(`${plugin.name} stopped`);
   };
 
-  // Se desideri avere una funzione plugin.debug personalizzata (opzionale)
   plugin.debug = function(msg) {
     app.debug(msg);
   };
 
+  /**
+   * processIncomingDelta: Decodifica i dati dei sensori in Knots/Meters ed esegue l'aggregazione
+   */
+  function processIncomingDelta(path, val) {
+    if (val === null || val === undefined) return;
+    raw[path] = val;
+
+    // Elaborazione e invio alla macchina a stati temporali dello storico
+    if (path === 'navigation.speedThroughWater') {
+      manageHistory('stw', val * 1.94384);
+    }
+    else if (path === 'navigation.speedOverGround') {
+      manageHistory('sog', val * 1.94384);
+    }
+    else if (path === 'environment.depth.belowTransducer') {
+      manageHistory('depth', val);
+    }
+    else if (path === 'environment.wind.speedApparent') {
+      manageHistory('aws', val * 1.94384);
+    }
+
+    // Calcolo combinato del Vento Reale (TWS) e della VMG a livello Server
+    const aws = raw["environment.wind.speedApparent"];
+    const awa = raw["environment.wind.angleApparent"];
+    const stw = raw["navigation.speedThroughWater"] || 0;
+    const sog = raw["navigation.speedOverGround"] || 0;
+    const hdg = raw["navigation.headingTrue"] || 0;
+    const cog = raw["navigation.courseOverGroundTrue"] || 0;
+
+    if (aws !== undefined && awa !== undefined) {
+      const awsKts = aws * 1.94384;
+      const stwKts = stw * 1.94384;
+      const tw_water_x = awsKts * Math.cos(awa) - stwKts;
+      const tw_water_y = awsKts * Math.sin(awa);
+      const tws = Math.sqrt(tw_water_x * tw_water_x + tw_water_y * tw_water_y);
+
+      manageHistory('tws', tws);
+
+      const twa = Math.atan2(tw_water_y, tw_water_x);
+      const vmg = Math.abs(stwKts * Math.cos(twa));
+      manageHistory('vmg', vmg);
+    }
+  }
+
+  /**
+   * manageHistory: Versione Server-side dell'aggregatore matematico tattico
+   */
+  function manageHistory(type, value) {
+    if (value === undefined || value === null || !isFinite(value)) return;
+
+    const now = Date.now();
+    const historyMinutes = currentConfig.graphs ? currentConfig.graphs.historyMinutes : 5;
+    const samples = 60;
+    const bucketIntervalMs = (historyMinutes * 60000) / samples;
+
+    if (!graphTempBuf[type]) graphTempBuf[type] = [];
+    if (!histories[type]) histories[type] = [];
+    if (lastUpdates[type] === undefined) lastUpdates[type] = 0;
+
+    const tempBuf = graphTempBuf[type];
+
+    // Anti-dropout dinamico sul vento forte
+    if ((type === 'tws' || type === 'aws') && value < 0.05 && tempBuf.length > 0) {
+      const lastPoint = tempBuf[tempBuf.length - 1];
+      const reef1 = currentConfig.graphs ? currentConfig.graphs.reef1 : 15;
+      const glitchThreshold = reef1 * 0.5;
+      if (lastPoint && lastPoint.val > glitchThreshold) return;
+    }
+
+    tempBuf.push({ val: value, time: now });
+
+    // Controllo avanzamento del secchiello temporale (Bucket)
+    const bucketReady = (now - lastUpdates[type] > bucketIntervalMs) || histories[type].length === 0;
+    if (!bucketReady) return;
+
+    let finalValue = value;
+
+    if (tempBuf.length > 0) {
+      // A. VENTO -> SUSTAINED PEAK (EMA Time-Aware)
+      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
+      else if (type === 'depth') {
+        const vals = tempBuf.map(p => p.val).filter(v => isFinite(v));
+        if (vals.length > 0) finalValue = Math.min(...vals);
+      }
+      // C. VELOCITÀ -> 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;
+        }
+      }
+    }
+
+    if (!isFinite(finalValue)) return;
+    finalValue = Math.max(0, finalValue);
+
+    // Salvataggio nel ring buffer dello storico principale
+    histories[type].push({ val: finalValue, time: now });
+
+    // Pruning automatico basato sulle impostazioni di timeline
+    const maxViewportMinutes = historyMinutes * 2;
+    const maxHistoryMs = (maxViewportMinutes * 60000) + 60000;
+
+    while (histories[type].length > 0 && (now - histories[type][0].time) > maxHistoryMs) {
+      histories[type].shift();
+    }
+
+    graphTempBuf[type] = [];
+    lastUpdates[type] = now;
+  }
+
   /**
    * plugin.schema: Definisce l'interfaccia grafica in Signal K Admin.
    */
@@ -127,10 +300,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 +325,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 +340,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 +355,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 +370,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": "6.0.1",
   "description": "Wind Dashboard with navigation and course aids",
   "main": "index.js",
   "publishConfig": {