some fixes

src/components/charts.ts

@@ -526,13 +526,24 @@ function createDualAxisChart(
     const allAverage28d = [...data.average28d];
     const allAcwr = [...data.acwr];
 
-    // Add future data if available
-    if (data.futureDates && data.futureValues) {
-        allDates.push(...data.futureDates);
-        allValues.push(...data.futureValues);
-        allAverage7d.push(...(data.futureAverage7d || []));
-        allAverage28d.push(...(data.futureAverage28d || []));
-        allAcwr.push(...(data.futureAcwr || []));
+    // Add ALL future dates to maintain x-axis continuity
+    // Use allFuture* arrays for complete data including ACWR curve
+    if (data.allFutureDates && data.allFutureValues) {
+        const MIN_THRESHOLD = 1;
+        
+        // Use the complete future data that includes all days
+        data.allFutureDates.forEach((date, i) => {
+            allDates.push(date);
+            
+            // Only show activity value if above threshold
+            const value = data.allFutureValues![i];
+            allValues.push(value >= MIN_THRESHOLD ? value : null);
+            
+            // Include all ACWR and average data for curve continuity
+            allAverage7d.push(data.allFutureAverage7d?.[i] ?? null);
+            allAverage28d.push(data.allFutureAverage28d?.[i] ?? null);
+            allAcwr.push(data.allFutureAcwr?.[i] ?? null);
+        });
     }
 
     const historicalCount = data.dates.length;
@@ -553,12 +564,12 @@ function createDualAxisChart(
                     pointHoverRadius: 7,
                     yAxisID: 'y',
                 },
-                // Future daily values (grey, larger points) - exclude zero values
-                ...(data.futureValues ? [{
+                // Future daily values (grey, larger points) - filtered to exclude insignificant values
+                ...(data.futureValues && data.futureValues.some(v => v !== null && v >= 1) ? [{
                     type: 'scatter' as const,
                     label: `Predicted Daily ${metricLabel}`,
                     data: Array(historicalCount).fill(null).concat(
-                        data.futureValues.map(v => (v !== null && v > 0) ? v : null)
+                        allValues.slice(historicalCount)
                     ),
                     backgroundColor: 'rgba(148, 163, 184, 0.6)',
                     borderColor: 'rgba(100, 116, 139, 0.8)',
@@ -610,11 +621,13 @@ function createDualAxisChart(
                     fill: false,
                     yAxisID: 'y1',
                 },
-                // Future ACWR (grey, thicker)
-                ...(data.futureAcwr ? [{
+                // Future ACWR (grey, thicker) - filtered to match future values
+                ...(data.futureAcwr && allAcwr.length > historicalCount ? [{
                     type: 'line' as const,
                     label: 'Predicted ACWR',
-                    data: Array(historicalCount).fill(null).concat(data.futureAcwr),
+                    data: Array(historicalCount).fill(null).concat(
+                        allAcwr.slice(historicalCount)
+                    ),
                     borderColor: 'rgba(148, 163, 184, 0.8)',
                     backgroundColor: 'rgba(148, 163, 184, 0.1)',
                     borderWidth: 5,
@@ -729,7 +742,8 @@ export function createDistanceChart(data: MetricACWRData): void {
         '(km)',
         'rgba(234, 179, 8, 0.8)'
     );
-    updateTargetInfo('distance-target', data.targetTomorrowValue, 'km', data.targetACWR, data.restTomorrowACWR);
+    // Use first predicted value if it's for tomorrow/today, otherwise use targetTomorrowValue
+    updateTargetInfo('distance-target', data, 'km');
 
     // Update ACWR display in title
     const currentACWR = data.acwr.length > 0 ? data.acwr[data.acwr.length - 1] : null;
@@ -747,7 +761,8 @@ export function createDurationChart(data: MetricACWRData): void {
         '(min)',
         'rgba(234, 179, 8, 0.8)'
     );
-    updateTargetInfo('duration-target', data.targetTomorrowValue, 'minutes', data.targetACWR, data.restTomorrowACWR);
+    // Use first predicted value if it's for tomorrow/today, otherwise use targetTomorrowValue
+    updateTargetInfo('duration-target', data, 'minutes');
 
     // Update ACWR display in title
     const currentACWR = data.acwr.length > 0 ? data.acwr[data.acwr.length - 1] : null;
@@ -765,7 +780,10 @@ export function createTSSChart(data: MetricACWRData): void {
         '',
         'rgba(234, 179, 8, 0.8)'
     );
-    updateTargetInfo('tss-target', data.targetTomorrowValue, 'TSS', data.targetACWR, data.restTomorrowACWR);
+    // Use first predicted value if it's for tomorrow/today, otherwise use targetTomorrowValue
+    updateTargetInfo('tss-target', data, 'TSS');
+
+    // Update ACWR display in titleet', nextDistanceValue, 'km', data.targetACWR, data.restTomorrowACWR);
 
     // Update ACWR display in title
     const currentACWR = data.acwr.length > 0 ? data.acwr[data.acwr.length - 1] : null;
@@ -783,33 +801,57 @@ export function createCaloriesChart(data: MetricACWRData): void {
         '',
         'rgba(234, 179, 8, 0.8)'
     );
-    updateTargetInfo('calories-target', data.targetTomorrowValue, 'cal', data.targetACWR, data.restTomorrowACWR);
+    // Use first predicted value if it's for tomorrow/today, otherwise use targetTomorrowValue
+    updateTargetInfo('calories-target', data, 'cal');
 
     // Update ACWR display in title
     const currentACWR = data.acwr.length > 0 ? data.acwr[data.acwr.length - 1] : null;
     updateACWRDisplay('calories-acwr-display', currentACWR);
 }
 
-function updateTargetInfo(elementId: string, targetValue: number | null | undefined, unit: string, targetACWR: number | undefined, restTomorrowACWR: number | null | undefined): void {
+function updateTargetInfo(elementId: string, data: MetricACWRData, unit: string): void {
     const element = document.getElementById(elementId);
     if (!element) return;
 
-    if (targetACWR !== undefined) {
+    if (data.targetACWR !== undefined) {
         let html: string;
+        let targetValue: number | null | undefined;
+        
+        // Check if first prediction is for tomorrow (day after last date in data)
+        if (data.futureDates && data.futureDates.length > 0 && data.futureValues && data.futureValues.length > 0) {
+            const lastHistoricalDate = data.dates[data.dates.length - 1];
+            const firstPredictionDate = data.futureDates[0];
+            
+            // Calculate tomorrow's date from last historical date
+            const lastDate = new Date(lastHistoricalDate);
+            const tomorrowDate = new Date(lastDate);
+            tomorrowDate.setDate(lastDate.getDate() + 1);
+            const tomorrowStr = tomorrowDate.toISOString().split('T')[0];
+            
+            // If first prediction is for tomorrow, use it; otherwise use targetTomorrowValue
+            if (firstPredictionDate === tomorrowStr) {
+                targetValue = data.futureValues[0];
+            } else {
+                // First prediction is not for tomorrow, so tomorrow must be a rest day
+                targetValue = data.targetTomorrowValue;
+            }
+        } else {
+            targetValue = data.targetTomorrowValue;
+        }
 
         if (targetValue === null || targetValue === undefined) {
-            html = `<strong>🎯 Next activity :</strong> <span style="color: var(--secondary-color);">ACWR of ${targetACWR} cannot be reached</span>`;
+            html = `<strong>🎯 Next activity :</strong> <span style="color: var(--secondary-color);">ACWR of ${data.targetACWR} cannot be reached</span>`;
         } else if (targetValue === 0) {
-            html = `<strong>🎯 Next activity :</strong> <span style="color: var(--secondary-color);">Rest recommended to reach ACWR of ${targetACWR}</span>`;
+            html = `<strong>🎯 Next activity :</strong> <span style="color: var(--secondary-color);">Rest recommended to reach ACWR of ${data.targetACWR}</span>`;
         } else {
             const formattedValue = targetValue.toFixed(1);
-            html = `<strong>🎯 Next activity :</strong> <span class="target-value">${formattedValue} ${unit}</span> <span style="color: var(--secondary-color);">to reach ACWR of ${targetACWR}</span>`;
+            html = `<strong>🎯 Next activity :</strong> <span class="target-value">${formattedValue} ${unit}</span> <span style="color: var(--secondary-color);">to reach ACWR of ${data.targetACWR}</span>`;
         }
 
         // Add rest tomorrow information
-        if (restTomorrowACWR !== null && restTomorrowACWR !== undefined) {
-            const color = getACWRColor(restTomorrowACWR);
-            html += `<br><strong>😴 If Rest :</strong> <span style="color: ${color};">ACWR ${restTomorrowACWR.toFixed(2)}</span>`;
+        if (data.restTomorrowACWR !== null && data.restTomorrowACWR !== undefined) {
+            const color = getACWRColor(data.restTomorrowACWR);
+            html += `<br><strong>😴 If Rest :</strong> <span style="color: ${color};">ACWR ${data.restTomorrowACWR.toFixed(2)}</span>`;
         }
 
         element.innerHTML = html;

src/types/index.ts

@@ -30,10 +30,16 @@ export interface MetricACWRData {
     restTomorrowACWR?: number | null; // What ACWR would be with a rest day tomorrow
     todayValue?: number | null; // Today's value for reference
     activitiesByDate?: Map<string, Activity[]>; // Activities grouped by date
-    // Future predictions (next 7 days)
-    futureDates?: string[]; // Dates for future predictions
-    futureValues?: (number | null)[]; // Optimal activity values for future days
-    futureAverage7d?: (number | null)[]; // Predicted 7-day rolling average
-    futureAverage28d?: (number | null)[]; // Predicted 28-day rolling average
-    futureAcwr?: (number | null)[]; // Predicted ACWR values
+    // Future predictions (filtered - only significant activities)
+    futureDates?: string[]; // Dates for future predictions (filtered)
+    futureValues?: (number | null)[]; // Optimal activity values for future days (filtered)
+    futureAverage7d?: (number | null)[]; // Predicted 7-day rolling average (filtered)
+    futureAverage28d?: (number | null)[]; // Predicted 28-day rolling average (filtered)
+    futureAcwr?: (number | null)[]; // Predicted ACWR values (filtered)
+    // Complete future predictions (including rest days for ACWR curve continuity)
+    allFutureDates?: string[]; // All future dates including rest days
+    allFutureValues?: number[]; // All future values including low values
+    allFutureAverage7d?: number[]; // All 7-day averages
+    allFutureAverage28d?: number[]; // All 28-day averages
+    allFutureAcwr?: number[]; // All ACWR values for curve continuity
 }

src/utils/metricAcwr.ts

@@ -31,6 +31,11 @@ function calculateOptimalFutureDays(
     futureAverage7d: number[];
     futureAverage28d: number[];
     futureAcwr: number[];
+    allFutureDates: string[];
+    allFutureValues: number[];
+    allFutureAverage7d: number[];
+    allFutureAverage28d: number[];
+    allFutureAcwr: number[];
 } {
     // Variance weight parameter (0-1): controls trade-off between ACWR accuracy and value consistency
     // Higher weight = more preference for consistent daily values
@@ -184,26 +189,46 @@ function calculateOptimalFutureDays(
     }
 
     // Build final results with optimized values
+    // Filter out insignificant values (< 1) - likely rest days
+    const MIN_THRESHOLD = 1;
+
     const futureDates: string[] = [];
-    const futureValues: number[] = bestValues;
+    const futureValues: number[] = [];
     const futureAverage7d: number[] = [];
     const futureAverage28d: number[] = [];
     const futureAcwr: number[] = [];
 
     const finalSimulatedDailyValues = new Map(dailyValues);
     const finalSimulatedAllDates = [...allDates];
+    
+    // We need to track ALL dates and their ACWR for curve continuity
+    const allFutureDates: string[] = [];
+    const allFutureValues: number[] = [];
+    const allFutureAverage7d: number[] = [];
+    const allFutureAverage28d: number[] = [];
+    const allFutureAcwr: number[] = [];
 
     for (let dayOffset = 0; dayOffset < numFutureDays; dayOffset++) {
         const futureDate = new Date(lastDate);
         futureDate.setDate(lastDate.getDate() + 1 + startOffset + dayOffset);
         const futureDateStr = formatDateLocal(futureDate);
+        
+        // Store ALL dates for ACWR calculation
+        allFutureDates.push(futureDateStr);
+        allFutureValues.push(bestValues[dayOffset]);
+
+        // Only include days with significant values (>= MIN_THRESHOLD) in the filtered arrays
+        if (bestValues[dayOffset] >= MIN_THRESHOLD) {
+            futureDates.push(futureDateStr);
+            futureValues.push(bestValues[dayOffset]);
+        }
 
-        futureDates.push(futureDateStr);
         finalSimulatedDailyValues.set(futureDateStr, bestValues[dayOffset]);
         finalSimulatedAllDates.push(futureDate);
 
         const currentIndex = finalSimulatedAllDates.length - 1;
 
+        // Calculate averages and ACWR for ALL days to maintain curve continuity
         // Calculate 7-day average
         let newAcuteSum = 0;
         for (let i = Math.max(0, currentIndex - 6); i <= currentIndex; i++) {
@@ -211,7 +236,7 @@ function calculateOptimalFutureDays(
             newAcuteSum += finalSimulatedDailyValues.get(checkDateStr) || 0;
         }
         const newAcuteAvg = newAcuteSum / 7;
-        futureAverage7d.push(newAcuteAvg);
+        allFutureAverage7d.push(newAcuteAvg);
 
         // Calculate 28-day average
         let newChronicSum = 0;
@@ -220,11 +245,11 @@ function calculateOptimalFutureDays(
             newChronicSum += finalSimulatedDailyValues.get(checkDateStr) || 0;
         }
         const newChronicAvg = newChronicSum / 28;
-        futureAverage28d.push(newChronicAvg);
+        allFutureAverage28d.push(newChronicAvg);
 
         // Calculate ACWR
         const newACWR = newChronicAvg > 0 ? newAcuteAvg / newChronicAvg : 0;
-        futureAcwr.push(newACWR);
+        allFutureAcwr.push(newACWR);
     }
 
     return {
@@ -233,6 +258,12 @@ function calculateOptimalFutureDays(
         futureAverage7d,
         futureAverage28d,
         futureAcwr,
+        // Include all dates and ACWR for curve continuity
+        allFutureDates,
+        allFutureValues,
+        allFutureAverage7d,
+        allFutureAverage28d,
+        allFutureAcwr,
     };
 }