datastake-daf 0.6.774 → 0.6.775

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

@@ -0,0 +1,226 @@
+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')
+ * @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())}`;
+        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')
+ * @returns {string} Time quantity string ('days', 'weeks', 'months')
+ */
+export const getTimeQuantity = (timeFilter = 'monthly') => {
+    return timeFilter === "monthly"
+        ? "months"
+        : timeFilter === "daily"
+        ? "days"
+        : "weeks";
+};
+
+/**
+ * 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;
+            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')
+ * @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'
+}) => {
+    if (!mainData || !Array.isArray(mainData) || mainData.length === 0) {
+        return [];
+    }
+
+    const timeQuantity = getTimeQuantity(filter);
+    const dates = mainData;
+
+    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 {
+        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;
+    }
+
+    // Loop until we reach the end date
+    let currentDate = start.clone();
+    while (currentDate.isBefore(end) || currentDate.isSame(end, filter === "daily" ? "day" : filter === "weekly" ? "week" : "month")) {
+        // Filter data points that fall within this period
+        const score = 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();
+                    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, or W#)
+    // 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;
+        }
+    }
+    
+    // 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', '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;
+};
+