nice

index.html

@@ -34,27 +34,24 @@
             </section>
 
             <section id="filter-section" class="hidden">
-                <div class="filter-container">
-                    <label class="filter-checkbox">
-                        <input type="checkbox" id="running-only-filter" />
-                        <span>🏃 Running only</span>
-                    </label>
+                <div class="filter-container" id="filter-container">
+                    <!-- Activity type filters will be dynamically generated here -->
                 </div>
             </section>
 
             <section id="charts-section" class="hidden">
                 <div class="chart-container">
-                    <h2>Distance-based ACWR</h2>
+                    <h2>🗺️ Distance-based ACWR</h2>
                     <canvas id="distance-chart"></canvas>
                 </div>
 
                 <div class="chart-container">
-                    <h2>Duration-based ACWR</h2>
+                    <h2>⏱️ Duration-based ACWR</h2>
                     <canvas id="duration-chart"></canvas>
                 </div>
 
                 <div class="chart-container">
-                    <h2>TSS-based ACWR</h2>
+                    <h2>🔋 TSS-based ACWR</h2>
                     <canvas id="tss-chart"></canvas>
                 </div>
 
@@ -67,6 +64,10 @@
                         <span class="legend-color optimal"></span>
                         <span>ACWR 0.8 - 1.3 - Optimal</span>
                     </div>
+                    <div class="legend-item">
+                        <span class="legend-color warning"></span>
+                        <span>ACWR 1.3 - 1.5 - Warning</span>
+                    </div>
                     <div class="legend-item">
                         <span class="legend-color high"></span>
                         <span>ACWR &gt; 1.5 - Injury risk</span>

src/components/charts.ts

@@ -8,6 +8,97 @@ let distanceChart: Chart | null = null;
 let durationChart: Chart | null = null;
 let tssChart: Chart | null = null;
 
+// ACWR color zones
+function getACWRColor(value: number | null): string {
+    if (value === null || value === undefined) return 'rgba(148, 163, 184, 0.3)';
+    if (value < 0.8) return 'rgba(59, 130, 246, 0.9)'; // Blue - Detraining risk
+    if (value <= 1.3) return 'rgba(16, 185, 129, 0.9)'; // Green - Optimal
+    if (value <= 1.5) return 'rgba(249, 115, 22, 0.9)'; // Orange - Warning
+    return 'rgba(239, 68, 68, 0.9)'; // Red - Injury risk
+}
+
+// Plugin to draw gradient-colored ACWR line
+const acwrGradientPlugin = {
+    id: 'acwrGradient',
+    afterDatasetsDraw(chart: Chart) {
+        const meta = chart.getDatasetMeta(3); // ACWR is the 4th dataset (index 3)
+        if (!meta || meta.hidden) return;
+
+        const ctx = chart.ctx;
+        const data = chart.data.datasets[3].data as (number | null)[];
+        const chartArea = chart.chartArea;
+
+        ctx.save();
+
+        // First, fill the area under the curve with gradient colors
+        for (let i = 0; i < meta.data.length - 1; i++) {
+            const point1 = meta.data[i];
+            const point2 = meta.data[i + 1];
+
+            if (!point1 || !point2) continue;
+
+            const value1 = data[i];
+            const value2 = data[i + 1];
+
+            // Skip if both values are null
+            if (value1 === null && value2 === null) continue;
+
+            // Use the average color of the two points
+            const avgValue = value1 !== null && value2 !== null
+                ? (value1 + value2) / 2
+                : (value1 ?? value2);
+
+            const color = getACWRColor(avgValue);
+            // Make the fill more transparent
+            const fillColor = color.replace(/[\d.]+\)$/, '0.15)');
+
+            ctx.fillStyle = fillColor;
+            ctx.beginPath();
+            ctx.moveTo(point1.x, point1.y);
+            ctx.lineTo(point2.x, point2.y);
+            ctx.lineTo(point2.x, chartArea.bottom);
+            ctx.lineTo(point1.x, chartArea.bottom);
+            ctx.closePath();
+            ctx.fill();
+        }
+
+        // Then draw the line on top
+        ctx.lineWidth = 4;
+        ctx.lineCap = 'round';
+        ctx.lineJoin = 'round';
+
+        // Draw line segments with colors based on values
+        for (let i = 0; i < meta.data.length - 1; i++) {
+            const point1 = meta.data[i];
+            const point2 = meta.data[i + 1];
+
+            if (!point1 || !point2) continue;
+
+            const value1 = data[i];
+            const value2 = data[i + 1];
+
+            // Skip if both values are null
+            if (value1 === null && value2 === null) continue;
+
+            // Use the average color of the two points
+            const avgValue = value1 !== null && value2 !== null
+                ? (value1 + value2) / 2
+                : (value1 ?? value2);
+
+            ctx.strokeStyle = getACWRColor(avgValue);
+            ctx.beginPath();
+            ctx.moveTo(point1.x, point1.y);
+            ctx.lineTo(point2.x, point2.y);
+            ctx.stroke();
+        }
+
+        ctx.restore();
+    },
+};
+
+// Register the custom plugin
+Chart.register(acwrGradientPlugin);
+
 // Common chart styling inspired by Garmin
 const commonOptions = {
     responsive: true,
@@ -39,7 +130,9 @@ const commonOptions = {
     scales: {
         x: {
             grid: {
-                display: false,
+                display: true,
+                color: 'rgba(148, 163, 184, 0.15)',
+                lineWidth: 1,
                 drawBorder: false,
             },
             ticks: {
@@ -62,33 +155,34 @@ function createDualAxisChart(
     data: MetricACWRData,
     metricLabel: string,
     metricUnit: string,
-    barColor: string
+    dotColor: string
 ): Chart {
     const canvas = document.getElementById(canvasId) as HTMLCanvasElement;
     if (!canvas) throw new Error(`Canvas ${canvasId} not found`);
 
     const config: ChartConfiguration = {
-        type: 'bar',
+        type: 'line',
         data: {
             labels: data.dates,
             datasets: [
                 {
-                    type: 'bar',
+                    type: 'scatter',
                     label: `Daily ${metricLabel}`,
                     data: data.values,
-                    backgroundColor: barColor,
-                    borderWidth: 0,
-                    borderRadius: 2,
-                    barPercentage: 0.8,
+                    backgroundColor: dotColor,
+                    borderColor: dotColor.replace('0.8)', '1)'),
+                    borderWidth: 1,
+                    pointRadius: 5,
+                    pointHoverRadius: 7,
                     yAxisID: 'y',
                 },
                 {
                     type: 'line',
                     label: '7-Day Average',
                     data: data.average7d,
-                    borderColor: 'rgba(239, 68, 68, 0.9)',
-                    backgroundColor: 'rgba(239, 68, 68, 0.1)',
-                    borderWidth: 2,
+                    borderColor: 'rgba(168, 85, 247, 0.5)',
+                    backgroundColor: 'rgba(168, 85, 247, 0.05)',
+                    borderWidth: 1.5,
                     pointRadius: 0,
                     pointHoverRadius: 4,
                     tension: 0.4,
@@ -99,9 +193,9 @@ function createDualAxisChart(
                     type: 'line',
                     label: '28-Day Average',
                     data: data.average28d,
-                    borderColor: 'rgba(249, 115, 22, 0.9)',
-                    backgroundColor: 'rgba(249, 115, 22, 0.1)',
-                    borderWidth: 2,
+                    borderColor: 'rgba(236, 72, 153, 0.5)',
+                    backgroundColor: 'rgba(236, 72, 153, 0.05)',
+                    borderWidth: 1.5,
                     pointRadius: 0,
                     pointHoverRadius: 4,
                     tension: 0.4,
@@ -112,11 +206,15 @@ function createDualAxisChart(
                     type: 'line',
                     label: 'ACWR',
                     data: data.acwr,
-                    borderColor: 'rgba(139, 92, 246, 1)',
-                    backgroundColor: 'rgba(139, 92, 246, 0.1)',
-                    borderWidth: 3,
+                    borderColor: 'rgba(139, 92, 246, 0)', // Transparent - we draw it in the plugin
+                    backgroundColor: 'rgba(139, 92, 246, 0)',
+                    borderWidth: 4,
                     pointRadius: 0,
                     pointHoverRadius: 5,
+                    pointHoverBackgroundColor: (context: any) => {
+                        const value = context.raw;
+                        return getACWRColor(value);
+                    },
                     tension: 0.4,
                     fill: false,
                     yAxisID: 'y1',
@@ -200,7 +298,7 @@ export function createDistanceChart(data: MetricACWRData): void {
         data,
         'Distance',
         '(km)',
-        'rgba(59, 130, 246, 0.6)'
+        'rgba(234, 179, 8, 0.8)'
     );
 }
 
@@ -213,7 +311,7 @@ export function createDurationChart(data: MetricACWRData): void {
         data,
         'Duration',
         '(min)',
-        'rgba(16, 185, 129, 0.6)'
+        'rgba(234, 179, 8, 0.8)'
     );
 }
 
@@ -226,7 +324,7 @@ export function createTSSChart(data: MetricACWRData): void {
         data,
         'TSS',
         '',
-        'rgba(245, 158, 11, 0.6)'
+        'rgba(234, 179, 8, 0.8)'
     );
 }
 

src/main.ts

@@ -15,14 +15,93 @@ const ftpInput = document.getElementById('ftp-input') as HTMLInputElement;
 const uploadStatus = document.getElementById('upload-status') as HTMLDivElement;
 const chartsSection = document.getElementById('charts-section') as HTMLElement;
 const filterSection = document.getElementById('filter-section') as HTMLElement;
-const runningOnlyFilter = document.getElementById('running-only-filter') as HTMLInputElement;
+const filterContainer = document.getElementById('filter-container') as HTMLElement;
 
 // Store all activities globally
 let allActivities: Activity[] = [];
+let selectedActivityTypes: Set<string> = new Set(['Running']);
 
 // Event listeners
 csvUpload?.addEventListener('change', handleFileUpload);
-runningOnlyFilter?.addEventListener('change', handleFilterChange);
+
+function createActivityTypeFilters(activities: Activity[]): void {
+    // Get unique activity types
+    const activityTypes = new Set<string>();
+    activities.forEach(activity => {
+        if (activity.activityType) {
+            activityTypes.add(activity.activityType);
+        }
+    });
+
+    // Define priority order
+    const priorityOrder = ['Running', 'Cycling', 'Strength Training'];
+    const sortedTypes: string[] = [];
+
+    // Add priority types first (if they exist)
+    priorityOrder.forEach(type => {
+        if (activityTypes.has(type)) {
+            sortedTypes.push(type);
+            activityTypes.delete(type);
+        }
+    });
+
+    // Add remaining types alphabetically
+    sortedTypes.push(...Array.from(activityTypes).sort());
+
+    // Clear existing filters
+    filterContainer.innerHTML = '';
+
+    // Create checkbox for each activity type
+    sortedTypes.forEach(type => {
+        const label = document.createElement('label');
+        label.className = 'filter-checkbox';
+
+        const checkbox = document.createElement('input');
+        checkbox.type = 'checkbox';
+        checkbox.id = `filter-${type.replace(/\s+/g, '-').toLowerCase()}`;
+        checkbox.value = type;
+        checkbox.checked = selectedActivityTypes.has(type);
+        checkbox.addEventListener('change', handleFilterChange);
+
+        const icon = getActivityIcon(type);
+        const span = document.createElement('span');
+        span.textContent = `${icon} ${type}`;
+
+        label.appendChild(checkbox);
+        label.appendChild(span);
+        filterContainer.appendChild(label);
+    });
+}
+
+function getActivityIcon(activityType: string): string {
+    const icons: { [key: string]: string } = {
+        'Running': '🏃',
+        'Cycling': '🚴',
+        'Strength Training': '🏋️',
+        'HIIT': '💪',
+        'Cardio': '❤️',
+    };
+    return icons[activityType] || '🏃';
+}
+
+function handleFilterChange(): void {
+    // Update selected activity types based on checkboxes
+    const checkboxes = filterContainer.querySelectorAll('input[type="checkbox"]') as NodeListOf<HTMLInputElement>;
+    selectedActivityTypes.clear();
+
+    checkboxes.forEach(checkbox => {
+        if (checkbox.checked) {
+            selectedActivityTypes.add(checkbox.value);
+        }
+    });
+
+    // Filter and render
+    const filteredActivities = selectedActivityTypes.size > 0
+        ? allActivities.filter(activity => selectedActivityTypes.has(activity.activityType || ''))
+        : allActivities;
+
+    renderCharts(filteredActivities);
+}
 
 async function handleFileUpload(event: Event): Promise<void> {
     const input = event.target as HTMLInputElement;
@@ -46,13 +125,14 @@ async function handleFileUpload(event: Event): Promise<void> {
             throw new Error('No valid activities found in the CSV file');
         }
 
-        // Reset filter
-        if (runningOnlyFilter) {
-            runningOnlyFilter.checked = false;
-        }
+        // Create dynamic activity type filters
+        createActivityTypeFilters(allActivities);
 
-        // Render charts with all activities
-        renderCharts(allActivities);
+        // Initial render with selected activity types
+        const filteredActivities = selectedActivityTypes.size > 0
+            ? allActivities.filter(activity => selectedActivityTypes.has(activity.activityType || ''))
+            : allActivities;
+        renderCharts(filteredActivities);
 
         // Show filter and charts sections
         filterSection.classList.remove('hidden');
@@ -70,16 +150,6 @@ async function handleFileUpload(event: Event): Promise<void> {
     }
 }
 
-function handleFilterChange(): void {
-    if (allActivities.length === 0) return;
-
-    const filteredActivities = runningOnlyFilter.checked
-        ? allActivities.filter(activity => activity.activityType === 'Running')
-        : allActivities;
-
-    renderCharts(filteredActivities);
-}
-
 function renderCharts(activities: Activity[]): void {
     // Calculate date range from all activities for consistency
     let dateRange: { start: Date; end: Date } | undefined;

src/style.css

@@ -143,6 +143,9 @@ h2 {
     font-size: 0.875rem;
     color: var(--secondary-color);
     min-height: 1.5rem;
+    max-width: 800px;
+    white-space: pre-wrap;
+    text-align: left;
 }
 
 #upload-status.success {
@@ -153,6 +156,11 @@ h2 {
 #upload-status.error {
     color: var(--danger-color);
     font-weight: 500;
+    background-color: #fef2f2;
+    border: 1px solid #fecaca;
+    border-radius: 6px;
+    padding: 1rem;
+    line-height: 1.6;
 }
 
 /* Filter Section */
@@ -164,10 +172,11 @@ h2 {
     margin-bottom: 2rem;
 }
 
-.filter-container {
+#filter-container {
     display: flex;
     align-items: center;
-    gap: 1rem;
+    flex-wrap: wrap;
+    gap: 1.5rem;
 }
 
 .filter-checkbox {
@@ -177,6 +186,13 @@ h2 {
     cursor: pointer;
     font-size: 1rem;
     user-select: none;
+    padding: 0.5rem 0.75rem;
+    border-radius: 6px;
+    transition: background-color 0.2s;
+}
+
+.filter-checkbox:hover {
+    background-color: var(--bg-color);
 }
 
 .filter-checkbox input[type="checkbox"] {
@@ -231,18 +247,23 @@ h2 {
 }
 
 .legend-color.low {
-    background-color: rgba(191, 219, 254, 0.5);
-    border: 2px solid rgba(59, 130, 246, 0.7);
+    background-color: rgba(59, 130, 246, 0.3);
+    border: 2px solid rgba(59, 130, 246, 0.9);
 }
 
 .legend-color.optimal {
-    background-color: rgba(187, 247, 208, 0.5);
-    border: 2px solid rgba(34, 197, 94, 0.7);
+    background-color: rgba(16, 185, 129, 0.3);
+    border: 2px solid rgba(16, 185, 129, 0.9);
+}
+
+.legend-color.warning {
+    background-color: rgba(249, 115, 22, 0.3);
+    border: 2px solid rgba(249, 115, 22, 0.9);
 }
 
 .legend-color.high {
-    background-color: rgba(254, 202, 202, 0.5);
-    border: 2px solid rgba(239, 68, 68, 0.7);
+    background-color: rgba(239, 68, 68, 0.3);
+    border: 2px solid rgba(239, 68, 68, 0.9);
 }
 
 /* Responsive Design */

src/utils/csvParser.ts

@@ -1,6 +1,7 @@
 import Papa from 'papaparse';
 import type { Activity } from '@/types';
 import { calculateTSS } from './tssCalculator';
+import { validateCSV } from './csvValidator';
 
 export function parseCSV(file: File, userFTP: number = 343): Promise<Activity[]> {
     return new Promise((resolve, reject) => {
@@ -9,6 +10,25 @@ export function parseCSV(file: File, userFTP: number = 343): Promise<Activity[]>
             skipEmptyLines: true,
             complete: (results) => {
                 try {
+                    // Validate CSV structure first
+                    const validation = validateCSV(results.data);
+
+                    if (!validation.isValid) {
+                        const errorMessage = [
+                            'CSV Validation Failed:',
+                            '',
+                            ...validation.errors.map(err => `❌ ${err}`),
+                            ...(validation.warnings.length > 0 ? ['', 'Warnings:', ...validation.warnings.map(warn => `⚠️ ${warn}`)] : []),
+                        ].join('\n');
+                        reject(new Error(errorMessage));
+                        return;
+                    }
+
+                    // Log warnings to console if any
+                    if (validation.warnings.length > 0) {
+                        console.warn('CSV Validation Warnings:', validation.warnings);
+                    }
+
                     const activities = results.data.map((row: any) => {
                         // Parse date - Garmin format: "2025-12-02 09:19:49"
                         const dateStr = row['Date'] || row['Activity Date'] || row['date'];
@@ -65,15 +85,24 @@ export function parseCSV(file: File, userFTP: number = 343): Promise<Activity[]>
 
                         // If no TSS provided, try to calculate from power data
                         if (!trainingStressScore && durationSeconds) {
-                            // Parse Normalized Power (NP)
-                            const npStr = row['Normalized Power (NP)'] || row['Normalized Power'] || row['NP'];
-                            const normalizedPower = npStr && npStr !== '--' ? parseFloat(npStr) : undefined;
+                            // Parse Normalized Power (NP) - find column that starts with "Normalized Power"
+                            let normalizedPower: number | undefined;
+                            const npKey = Object.keys(row).find(key => key.startsWith('Normalized Power'));
+                            if (npKey) {
+                                const npStr = row[npKey];
+                                if (npStr && npStr !== '--' && npStr !== '0.0' && npStr !== '0') {
+                                    normalizedPower = parseFloat(npStr);
+                                    if (isNaN(normalizedPower) || normalizedPower <= 0) {
+                                        normalizedPower = undefined;
+                                    }
+                                }
+                            }
 
                             // Use FTP from CSV if available, otherwise use user-provided FTP
                             const ftpStr = row['FTP'] || row['Functional Threshold Power'];
                             const ftp = ftpStr && ftpStr !== '--' ? parseFloat(ftpStr) : userFTP;
 
-                            if (normalizedPower && ftp) {
+                            if (normalizedPower && normalizedPower > 0 && ftp && ftp > 0) {
                                 const calculatedTSS = calculateTSS({
                                     durationSeconds,
                                     normalizedPower,

src/utils/csvValidator.ts

@@ -0,0 +1,179 @@
+/**
+ * CSV Validation utilities
+ * Checks for required fields and data quality
+ */
+
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+export interface FieldValidation {
+    found: boolean;
+    fieldName?: string;
+    nonNullCount: number;
+    nonZeroCount: number;
+    totalRows: number;
+}
+
+/**
+ * Validate CSV structure and required fields
+ * @param data - Parsed CSV data array
+ * @returns Validation result with errors and warnings
+ */
+export function validateCSV(data: any[]): ValidationResult {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    if (!data || data.length === 0) {
+        errors.push('CSV file is empty or contains no valid data rows.');
+        return { isValid: false, errors, warnings };
+    }
+
+    const totalRows = data.length;
+
+    // Required fields validation
+    const dateField = validateField(data, ['Date', 'Activity Date', 'date']);
+    const timeField = validateField(data, ['Time', 'Duration', 'Moving Time', 'Elapsed Time']);
+    const activityTypeField = validateField(data, ['Activity Type', 'Type', 'Sport']);
+
+    // Check required fields
+    if (!dateField.found) {
+        errors.push('Missing required field: "Date". Expected column names: Date, Activity Date, or date.');
+    } else if (dateField.nonNullCount === 0) {
+        errors.push(`Field "${dateField.fieldName}" has no valid values (all rows are empty or "--").`);
+    } else if (dateField.nonNullCount < totalRows) {
+        warnings.push(`Field "${dateField.fieldName}": ${totalRows - dateField.nonNullCount} out of ${totalRows} rows have missing dates.`);
+    }
+
+    if (!timeField.found) {
+        errors.push('Missing required field: "Time" or "Duration". Expected column names: Time, Duration, Moving Time, or Elapsed Time.');
+    } else if (timeField.nonNullCount === 0) {
+        errors.push(`Field "${timeField.fieldName}" has no valid values (all rows are empty or "--").`);
+    } else if (timeField.nonNullCount < totalRows) {
+        warnings.push(`Field "${timeField.fieldName}": ${totalRows - timeField.nonNullCount} out of ${totalRows} rows have missing duration.`);
+    }
+
+    if (!activityTypeField.found) {
+        errors.push('Missing required field: "Activity Type". Expected column names: Activity Type, Type, or Sport.');
+    } else if (activityTypeField.nonNullCount === 0) {
+        errors.push(`Field "${activityTypeField.fieldName}" has no valid values (all rows are empty or "--").`);
+    }
+
+    // Optional but important fields validation
+    const distanceField = validateField(data, ['Distance', 'distance']);
+    const normalizedPowerField = validateFieldByPrefix(data, 'Normalized Power');
+
+    // Distance warnings
+    if (!distanceField.found) {
+        warnings.push('Optional field "Distance" is missing. Distance-based ACWR chart will be empty.');
+    } else if (distanceField.nonZeroCount === 0) {
+        warnings.push('Field "Distance" exists but all values are 0 or empty. Distance-based ACWR chart will be empty.');
+    } else if (distanceField.nonZeroCount < totalRows * 0.5) {
+        warnings.push(`Field "Distance": Only ${distanceField.nonZeroCount} out of ${totalRows} activities have distance values.`);
+    }
+
+    // Power/TSS warnings
+    const tssField = validateFieldByPrefix(data, 'Training Stress Score');
+
+    if (!normalizedPowerField.found && !tssField.found) {
+        warnings.push('Neither "Normalized Power" nor "Training Stress Score" fields found. TSS will be calculated using default FTP (343W). Ensure activities have Normalized Power data for accurate TSS calculation.');
+    } else if (normalizedPowerField.found && normalizedPowerField.nonZeroCount === 0) {
+        warnings.push('Field "Normalized Power" exists but all values are 0 or empty. TSS calculation may be limited.');
+    } else if (normalizedPowerField.found && normalizedPowerField.nonZeroCount < totalRows * 0.3) {
+        warnings.push(`Field "Normalized Power": Only ${normalizedPowerField.nonZeroCount} out of ${totalRows} activities have power data. TSS-based ACWR will have limited data.`);
+    }
+
+    // Summary
+    if (errors.length === 0 && warnings.length === 0) {
+        warnings.push(`✓ CSV validation passed. Successfully found ${totalRows} activities with all required fields.`);
+    }
+
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+
+/**
+ * Validate a field by checking multiple possible column names
+ */
+function validateField(data: any[], possibleNames: string[]): FieldValidation {
+    for (const name of possibleNames) {
+        if (data[0] && name in data[0]) {
+            const nonNullCount = data.filter(row => {
+                const value = row[name];
+                return value && value !== '--' && value !== '';
+            }).length;
+
+            const nonZeroCount = data.filter(row => {
+                const value = row[name];
+                if (!value || value === '--' || value === '') return false;
+                const parsed = parseFloat(value);
+                return !isNaN(parsed) && parsed !== 0;
+            }).length;
+
+            return {
+                found: true,
+                fieldName: name,
+                nonNullCount,
+                nonZeroCount,
+                totalRows: data.length,
+            };
+        }
+    }
+
+    return {
+        found: false,
+        nonNullCount: 0,
+        nonZeroCount: 0,
+        totalRows: data.length,
+    };
+}
+
+/**
+ * Validate a field by checking if any column name starts with a prefix
+ */
+function validateFieldByPrefix(data: any[], prefix: string): FieldValidation {
+    if (!data[0]) {
+        return {
+            found: false,
+            nonNullCount: 0,
+            nonZeroCount: 0,
+            totalRows: data.length,
+        };
+    }
+
+    const fieldName = Object.keys(data[0]).find(key => key.startsWith(prefix));
+
+    if (!fieldName) {
+        return {
+            found: false,
+            nonNullCount: 0,
+            nonZeroCount: 0,
+            totalRows: data.length,
+        };
+    }
+
+    const nonNullCount = data.filter(row => {
+        const value = row[fieldName];
+        return value && value !== '--' && value !== '';
+    }).length;
+
+    const nonZeroCount = data.filter(row => {
+        const value = row[fieldName];
+        if (!value || value === '--' || value === '') return false;
+        const parsed = parseFloat(value);
+        return !isNaN(parsed) && parsed !== 0;
+    }).length;
+
+    return {
+        found: true,
+        fieldName,
+        nonNullCount,
+        nonZeroCount,
+        totalRows: data.length,
+    };
+}