datastake-daf 0.6.845 → 0.6.847

package/src/@daf/utils/timeFilterUtils.js

@@ -2,251 +2,268 @@ import dayjs from 'dayjs';
 import { capitalize } from '../../helpers/StringHelper.js';
 import { renderNumber } from './numbers.js';
 
-/**
- * Formats a date based on the time filter
- * @param {dayjs.Dayjs} date - The date to format
- * @param {boolean} breakLine - Whether to add a line break (for tooltips)
- * @param {string} timeFilter - The time filter ('daily', 'weekly', 'monthly', 'yearly')
- * @returns {string} Formatted date string
- */
 export const getFormatDate = (date, breakLine = false, timeFilter = 'monthly') => {
-    switch (timeFilter) {
-        case "daily":
-            return date.format("DD/MM");
-        case "weekly":
-            return `W${renderNumber(date.week())}`;
-        case "yearly":
-            return date.format("YYYY");
-        default:
-            // Monthly format: "Dec 24", "Jan 25", etc.
-            return breakLine
-                ? `${capitalize(date.format("MMM"))}\n${date.format("YY")}`
-                : `${capitalize(date.format("MMM"))} ${date.format("YY")}`;
-    }
+   switch (timeFilter) {
+       case "daily":
+           return date.format("DD/MM");
+       case "weekly":
+           return `W${renderNumber(date.week())}`;
+       case "yearly":
+           return date.format("YYYY");
+       default:
+           // Monthly format: "Dec 24", "Jan 25", etc.
+           return breakLine
+               ? `${capitalize(date.format("MMM"))}\n${date.format("YY")}`
+               : `${capitalize(date.format("MMM"))} ${date.format("YY")}`;
+   }
 };
 
-/**
- * Gets the time quantity string for dayjs operations
- * @param {string} timeFilter - The time filter ('daily', 'weekly', 'monthly', 'yearly')
- * @returns {string} Time quantity string ('days', 'weeks', 'months', 'years')
- */
 export const getTimeQuantity = (timeFilter = 'monthly') => {
-    switch (timeFilter) {
-        case "daily":
-            return "days";
-        case "weekly":
-            return "weeks";
-        case "yearly":
-            return "years";
-        default:
-            return "months";
-    }
+   switch (timeFilter) {
+       case "daily":
+           return "days";
+       case "weekly":
+           return "weeks";
+       case "yearly":
+           return "years";
+       default:
+           return "months";
+   }
 };
 
-/**
- * Gets previous cumulative score from data before start date
- * @param {Array} dates - Array of data objects with date field
- * @param {dayjs.Dayjs} startDate - The start date
- * @param {string} timeFilter - The time filter
- * @param {string} valueField - The field name to extract value from (default: 'total')
- * @returns {Object} Object with hasPreviousData, previousCumulativeScore, previousMaxScore
- */
 export const getPreviousGraphData = (dates, startDate, timeFilter, valueField = 'total') => {
-    let previousCumulativeScore = 0;
-    let previousMaxScore = 0;
-    let hasPreviousData = false;
-
-    dates.forEach((d) => {
-        const date = dayjs(d.date, "YYYY-MM-DD");
-        if (!date.isValid()) return;
-
-        let isBeforeStart = false;
-        switch (timeFilter) {
-            case "daily":
-                isBeforeStart = date.isBefore(startDate, 'day');
-                break;
-            case "weekly":
-                isBeforeStart = date.isBefore(startDate, 'week');
-                break;
-            case "yearly":
-                isBeforeStart = date.isBefore(startDate, 'year');
-                break;
-            default:
-                isBeforeStart = date.isBefore(startDate, 'month');
-                break;
-        }
-
-        if (isBeforeStart) {
-            hasPreviousData = true;
-            const value = Number(d[valueField] || d.count || d.jobs || d.value || 0) || 0;
-            previousCumulativeScore += value;
-            previousMaxScore = Math.max(previousMaxScore, value);
-        }
-    });
-
-    return {
-        hasPreviousData,
-        previousCumulativeScore,
-        previousMaxScore,
-    };
+   let previousCumulativeScore = 0;
+   let previousMaxScore = 0;
+   let hasPreviousData = false;
+
+   dates.forEach((d) => {
+       const date = dayjs(d.date, "YYYY-MM-DD");
+       if (!date.isValid()) return;
+
+       let isBeforeStart = false;
+       switch (timeFilter) {
+           case "daily":
+               isBeforeStart = date.isBefore(startDate, 'day');
+               break;
+           case "weekly":
+               isBeforeStart = date.isBefore(startDate, 'week');
+               break;
+           case "yearly":
+               isBeforeStart = date.isBefore(startDate, 'year');
+               break;
+           default:
+               isBeforeStart = date.isBefore(startDate, 'month');
+               break;
+       }
+
+       if (isBeforeStart) {
+           hasPreviousData = true;
+           const value = Number(d[valueField] || d.count || d.jobs || d.value || 0) || 0;
+           previousCumulativeScore += value;
+           previousMaxScore = Math.max(previousMaxScore, value);
+       }
+   });
+
+   return {
+       hasPreviousData,
+       previousCumulativeScore,
+       previousMaxScore,
+   };
 };
 
-/**
- * Processes chart data with time filtering support
- * @param {Object} params - Parameters object
- * @param {Array} params.mainData - Array of data objects with date and value fields
- * @param {string} params.timeFilter - Time filter ('daily', 'weekly', 'monthly', 'yearly')
- * @param {Object} params.filters - Optional filters object with timeframe
- * @param {boolean} params.isCumulative - Whether to calculate cumulative values (default: false)
- * @param {string} params.valueField - Field name to extract value from (default: 'total', also checks 'count', 'jobs', 'value')
- * @returns {Array} Processed chart data array
- */
-export const processChartDateData = ({ 
-    mainData, 
-    timeFilter: filter, 
-    filters = {},
-    isCumulative = false,
-    valueField = 'total'
+export const processChartDateData = ({
+   mainData,
+   timeFilter: filter,
+   filters = {},
+   isCumulative = false,
+   valueField = 'total'
 }) => {
-    const timeQuantity = getTimeQuantity(filter);
-    const dates = mainData || [];
-    const isEmpty = !mainData || !Array.isArray(mainData) || mainData.length === 0;
-
-    const _data = [];
-    let end = filters?.timeframe?.endDate || dayjs();
-    let start = filters?.timeframe?.startDate || dayjs().add(-12, timeQuantity);
-
-    // Normalize start and end to period boundaries
-    if (filter === "daily") {
-        start = start.startOf('day');
-        end = end.startOf('day');
-    } else if (filter === "weekly") {
-        start = start.startOf('week');
-        end = end.startOf('week');
-    } else if (filter === "yearly") {
-        start = start.startOf('year');
-        end = end.startOf('year');
-    } else {
-        start = start.startOf('month');
-        end = end.startOf('month');
-    }
-
-    let i = 0;
-    let cumulativeScore = 0;
-
-    // Calculate initial cumulative value if needed
-    if (isCumulative) {
-        const { hasPreviousData, previousCumulativeScore } = getPreviousGraphData(
-            dates,
-            start,
-            filter,
-            valueField
-        );
-        cumulativeScore = hasPreviousData ? previousCumulativeScore : 0;
-    }
-
-    // Get the period unit for comparison
-    const getPeriodUnit = (f) => {
-        switch (f) {
-            case "daily": return "day";
-            case "weekly": return "week";
-            case "yearly": return "year";
-            default: return "month";
-        }
-    };
-    const periodUnit = getPeriodUnit(filter);
-
-    // Loop until we reach the end date
-    let currentDate = start.clone();
-    while (currentDate.isBefore(end) || currentDate.isSame(end, periodUnit)) {
-        // Filter data points that fall within this period
-        const score = isEmpty ? 0 : dates
-            .filter((d) => {
-                if (!d.date) return false;
-                switch (filter) {
-                    case "daily":
-                        return d.date === currentDate.format("YYYY-MM-DD");
-                    case "weekly":
-                        return dayjs(d.date, "YYYY-MM-DD").week() === currentDate.week() &&
-                               dayjs(d.date, "YYYY-MM-DD").year() === currentDate.year();
-                    case "yearly":
-                        return dayjs(d.date, "YYYY-MM-DD").year() === currentDate.year();
-                    default:
-                        return (
-                            dayjs(d.date, "YYYY-MM-DD").format("YYYY-MM") ===
-                            currentDate.format("YYYY-MM")
-                        );
-                }
-            })
-            .reduce((a, b) => {
-                const value = Number(b[valueField] || b.count || b.jobs || b.value || 0) || 0;
-                return a + value;
-            }, 0);
-
-        if (isCumulative) {
-            cumulativeScore += score;
-        }
-
-        _data.push({
-            date: getFormatDate(currentDate, false, filter),
-            value: isCumulative ? cumulativeScore : score,
-            period: score, // Period value for tooltip
-            jobs: score, // For compatibility with jobs field
-            month: currentDate.format('YYYY-MM-DD'), // For compatibility
-            key: i,
-        });
-
-        currentDate = currentDate.add(1, timeQuantity);
-        i++;
-    }
-
-    return _data;
+   const timeQuantity = getTimeQuantity(filter);
+   const dates = mainData || [];
+   const isEmpty = !mainData || !Array.isArray(mainData) || mainData.length === 0;
+
+   const _data = [];
+  
+   // Derive date range from actual data if no filters provided and data exists
+   let end, start;
+  
+   if (filters?.timeframe?.endDate) {
+       end = filters.timeframe.endDate;
+   } else if (!isEmpty) {
+       // Find the latest date in the data
+       const sortedDates = dates
+           .map(d => dayjs(d.date, "YYYY-MM-DD"))
+           .filter(d => d.isValid())
+           .sort((a, b) => b.valueOf() - a.valueOf());
+       end = sortedDates.length > 0 ? sortedDates[0] : dayjs();
+   } else {
+       end = dayjs();
+   }
+  
+   if (filters?.timeframe?.startDate) {
+       start = filters.timeframe.startDate;
+   } else if (!isEmpty) {
+       // Find the earliest date in the data
+       const sortedDates = dates
+           .map(d => dayjs(d.date, "YYYY-MM-DD"))
+           .filter(d => d.isValid())
+           .sort((a, b) => a.valueOf() - b.valueOf());
+       start = sortedDates.length > 0 ? sortedDates[0] : dayjs().add(-12, timeQuantity);
+      
+       // For daily filter, limit to last 14 days to avoid overcrowded x-axis
+       if (filter === "daily" && end) {
+           const maxDailyStart = end.subtract(13, 'days'); // 14 days total including end date
+           if (start.isBefore(maxDailyStart)) {
+               start = maxDailyStart;
+           }
+       }
+   } else {
+       start = dayjs().add(-12, timeQuantity);
+   }
+
+   // Normalize start and end to period boundaries
+   if (filter === "daily") {
+       start = start.startOf('day');
+       end = end.startOf('day');
+   } else if (filter === "weekly") {
+       start = start.startOf('week');
+       end = end.startOf('week');
+   } else if (filter === "yearly") {
+       start = start.startOf('year');
+       end = end.startOf('year');
+   } else {
+       start = start.startOf('month');
+       end = end.startOf('month');
+   }
+
+   // Ensure minimum number of periods to fill the x-axis properly
+   const getMinPeriods = (f) => {
+       switch (f) {
+           case "daily": return 14;    // At least 14 days
+           case "weekly": return 8;    // At least 8 weeks
+           case "yearly": return 5;    // At least 5 years
+           default: return 12;         // At least 12 months
+       }
+   };
+   const minPeriods = getMinPeriods(filter);
+   const periodsDiff = end.diff(start, timeQuantity);
+   
+   if (periodsDiff < minPeriods - 1) {
+       const periodsToAdd = minPeriods - 1 - periodsDiff;
+       start = start.subtract(periodsToAdd, timeQuantity);
+   }
+
+   let i = 0;
+   let cumulativeScore = 0;
+
+   // Calculate initial cumulative value if needed
+   if (isCumulative) {
+       const { hasPreviousData, previousCumulativeScore } = getPreviousGraphData(
+           dates,
+           start,
+           filter,
+           valueField
+       );
+       cumulativeScore = hasPreviousData ? previousCumulativeScore : 0;
+   }
+
+   // Get the period unit for comparison
+   const getPeriodUnit = (f) => {
+       switch (f) {
+           case "daily": return "day";
+           case "weekly": return "week";
+           case "yearly": return "year";
+           default: return "month";
+       }
+   };
+   const periodUnit = getPeriodUnit(filter);
+
+   // Loop until we reach the end date
+   let currentDate = start.clone();
+   while (currentDate.isBefore(end) || currentDate.isSame(end, periodUnit)) {
+       // Filter data points that fall within this period
+       const score = isEmpty ? 0 : dates
+           .filter((d) => {
+               if (!d.date) return false;
+               switch (filter) {
+                   case "daily":
+                       return d.date === currentDate.format("YYYY-MM-DD");
+                   case "weekly":
+                       return dayjs(d.date, "YYYY-MM-DD").week() === currentDate.week() &&
+                              dayjs(d.date, "YYYY-MM-DD").year() === currentDate.year();
+                   case "yearly":
+                       return dayjs(d.date, "YYYY-MM-DD").year() === currentDate.year();
+                   default:
+                       return (
+                           dayjs(d.date, "YYYY-MM-DD").format("YYYY-MM") ===
+                           currentDate.format("YYYY-MM")
+                       );
+               }
+           })
+           .reduce((a, b) => {
+               const value = Number(b[valueField] || b.count || b.jobs || b.value || 0) || 0;
+               return a + value;
+           }, 0);
+
+       if (isCumulative) {
+           cumulativeScore += score;
+       }
+
+       _data.push({
+           date: getFormatDate(currentDate, false, filter),
+           value: isCumulative ? cumulativeScore : score,
+           period: score, // Period value for tooltip
+           jobs: score, // For compatibility with jobs field
+           month: currentDate.format('YYYY-MM-DD'), // For compatibility
+           key: i,
+       });
+
+       currentDate = currentDate.add(1, timeQuantity);
+       i++;
+   }
+
+   return _data;
 };
 
-/**
- * Formats date axis labels, checking if already formatted
- * @param {string} label - The label to format
- * @param {Function} getFormatDateFn - Function to format dates
- * @returns {string} Formatted date string
- */
 export const formatDateAxis = (label, getFormatDateFn) => {
-    if (!label) return label;
-    
-    // Check if label is already in the correct format (MMM YY, DD/MM, W#, or YYYY)
-    // If it matches our format patterns, return as-is
-    if (typeof label === 'string') {
-        // Check for MMM YY format (e.g., "Dec 24", "Jan 25")
-        if (/^[A-Z][a-z]{2} \d{2}$/.test(label)) {
-            return label;
-        }
-        // Check for DD/MM format (e.g., "03/11")
-        if (/^\d{2}\/\d{2}$/.test(label)) {
-            return label;
-        }
-        // Check for W# format (e.g., "W1", "W12")
-        if (/^W\d+$/.test(label)) {
-            return label;
-        }
-        // Check for YYYY format (e.g., "2024", "2025")
-        if (/^\d{4}$/.test(label)) {
-            return label;
-        }
-    }
-    
-    // Otherwise, try to parse and format it
-    let date = dayjs(label);
-    
-    // If first attempt fails, try parsing as ISO date string
-    if (!date.isValid() && typeof label === 'string') {
-        date = dayjs(label, ['YYYY-MM-DD', 'YYYY-MM', 'YYYY', 'MMM YY', 'MMM YYYY', 'DD/MM'], true);
-    }
-    
-    // If it's a valid date, format it using getFormatDate
-    if (date.isValid() && getFormatDateFn) {
-        return getFormatDateFn(date, false);
-    }
-    
-    // Return as-is if we can't parse it
-    return label;
+   if (!label) return label;
+  
+   // Check if label is already in the correct format (MMM YY, DD/MM, W#, or YYYY)
+   // If it matches our format patterns, return as-is
+   if (typeof label === 'string') {
+       // Check for MMM YY format (e.g., "Dec 24", "Jan 25")
+       if (/^[A-Z][a-z]{2} \d{2}$/.test(label)) {
+           return label;
+       }
+       // Check for DD/MM format (e.g., "03/11")
+       if (/^\d{2}\/\d{2}$/.test(label)) {
+           return label;
+       }
+       // Check for W# format (e.g., "W1", "W12")
+       if (/^W\d+$/.test(label)) {
+           return label;
+       }
+       // Check for YYYY format (e.g., "2024", "2025")
+       if (/^\d{4}$/.test(label)) {
+           return label;
+       }
+   }
+  
+   // Otherwise, try to parse and format it
+   let date = dayjs(label);
+  
+   // If first attempt fails, try parsing as ISO date string
+   if (!date.isValid() && typeof label === 'string') {
+       date = dayjs(label, ['YYYY-MM-DD', 'YYYY-MM', 'YYYY', 'MMM YY', 'MMM YYYY', 'DD/MM'], true);
+   }
+  
+   // If it's a valid date, format it using getFormatDate
+   if (date.isValid() && getFormatDateFn) {
+       return getFormatDateFn(date, false);
+   }
+  
+   // Return as-is if we can't parse it
+   return label;
 };
 
+