Calendar/wwwroot/js/utils/DateCalculator.js

/**
 * DateCalculator - Centralized date calculation logic for calendar
 * Handles all date computations with proper week start handling
 */
export class DateCalculator {
    /**
     * Initialize DateCalculator with configuration
     * @param config - Calendar configuration
     */
    static initialize(config) {
        DateCalculator.config = config;
    }
    /**
     * Validate that a date is valid
     * @param date - Date to validate
     * @param methodName - Name of calling method for error messages
     * @throws Error if date is invalid
     */
    static validateDate(date, methodName) {
        if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
            throw new Error(`${methodName}: Invalid date provided - ${date}`);
        }
    }
    /**
     * Get dates for work week using ISO 8601 day numbering (Monday=1, Sunday=7)
     * @param weekStart - Any date in the week
     * @returns Array of dates for the configured work days
     */
    static getWorkWeekDates(weekStart) {
        DateCalculator.validateDate(weekStart, 'getWorkWeekDates');
        const dates = [];
        const workWeekSettings = DateCalculator.config.getWorkWeekSettings();
        // Always use ISO week start (Monday)
        const mondayOfWeek = DateCalculator.getISOWeekStart(weekStart);
        // Calculate dates for each work day using ISO numbering
        workWeekSettings.workDays.forEach(isoDay => {
            const date = new Date(mondayOfWeek);
            // ISO day 1=Monday is +0 days, ISO day 7=Sunday is +6 days
            const daysFromMonday = isoDay === 7 ? 6 : isoDay - 1;
            date.setDate(mondayOfWeek.getDate() + daysFromMonday);
            dates.push(date);
        });
        return dates;
    }
    /**
     * Get the start of the ISO week (Monday) for a given date
     * @param date - Any date in the week
     * @returns The Monday of the ISO week
     */
    static getISOWeekStart(date) {
        DateCalculator.validateDate(date, 'getISOWeekStart');
        const monday = new Date(date);
        const currentDay = monday.getDay();
        const daysToSubtract = currentDay === 0 ? 6 : currentDay - 1;
        monday.setDate(monday.getDate() - daysToSubtract);
        monday.setHours(0, 0, 0, 0);
        return monday;
    }
    /**
     * Get the end of the ISO week for a given date
     * @param date - Any date in the week
     * @returns The end date of the ISO week (Sunday)
     */
    static getWeekEnd(date) {
        DateCalculator.validateDate(date, 'getWeekEnd');
        const weekStart = DateCalculator.getISOWeekStart(date);
        const weekEnd = new Date(weekStart);
        weekEnd.setDate(weekStart.getDate() + 6);
        weekEnd.setHours(23, 59, 59, 999);
        return weekEnd;
    }
    /**
     * Get week number for a date (ISO 8601)
     * @param date - The date to get week number for
     * @returns Week number (1-53)
     */
    static getWeekNumber(date) {
        const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
        const dayNum = d.getUTCDay() || 7;
        d.setUTCDate(d.getUTCDate() + 4 - dayNum);
        const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
        return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
    }
    /**
     * Format a date range with customizable options
     * @param start - Start date
     * @param end - End date
     * @param options - Formatting options
     * @returns Formatted date range string
     */
    static formatDateRange(start, end, options = {}) {
        const { locale = 'en-US', month = 'short', day = 'numeric' } = options;
        const startYear = start.getFullYear();
        const endYear = end.getFullYear();
        const formatter = new Intl.DateTimeFormat(locale, {
            month,
            day,
            year: startYear !== endYear ? 'numeric' : undefined
        });
        // @ts-ignore
        if (typeof formatter.formatRange === 'function') {
            // @ts-ignore
            return formatter.formatRange(start, end);
        }
        return `${formatter.format(start)} - ${formatter.format(end)}`;
    }
    /**
     * Format a date to ISO date string (YYYY-MM-DD)
     * @param date - Date to format
     * @returns ISO date string
     */
    static formatISODate(date) {
        return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
    }
    /**
     * Check if a date is today
     * @param date - Date to check
     * @returns True if the date is today
     */
    static isToday(date) {
        const today = new Date();
        return date.toDateString() === today.toDateString();
    }
    /**
     * Add days to a date
     * @param date - Base date
     * @param days - Number of days to add (can be negative)
     * @returns New date
     */
    static addDays(date, days) {
        const result = new Date(date);
        result.setDate(result.getDate() + days);
        return result;
    }
    /**
     * Add weeks to a date
     * @param date - Base date
     * @param weeks - Number of weeks to add (can be negative)
     * @returns New date
     */
    static addWeeks(date, weeks) {
        return DateCalculator.addDays(date, weeks * 7);
    }
    /**
     * Get all dates in a week
     * @param weekStart - Start of the week
     * @returns Array of 7 dates for the full week
     */
    static getFullWeekDates(weekStart) {
        const dates = [];
        for (let i = 0; i < 7; i++) {
            dates.push(DateCalculator.addDays(weekStart, i));
        }
        return dates;
    }
    /**
     * Get the day name for a date using Intl.DateTimeFormat
     * @param date - Date to get day name for
     * @param format - 'short' or 'long'
     * @returns Day name
     */
    static getDayName(date, format = 'short') {
        const formatter = new Intl.DateTimeFormat('en-US', {
            weekday: format
        });
        return formatter.format(date);
    }
    /**
     * Format time to HH:MM
     * @param date - Date to format
     * @returns Time string
     */
    static formatTime(date) {
        return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
    }
    /**
     * Format time to 12-hour format
     * @param date - Date to format
     * @returns 12-hour time string
     */
    static formatTime12(date) {
        const hours = date.getHours();
        const minutes = date.getMinutes();
        const period = hours >= 12 ? 'PM' : 'AM';
        const displayHours = hours % 12 || 12;
        return `${displayHours}:${String(minutes).padStart(2, '0')} ${period}`;
    }
    /**
     * Convert minutes since midnight to time string
     * @param minutes - Minutes since midnight
     * @returns Time string
     */
    static minutesToTime(minutes) {
        const hours = Math.floor(minutes / 60);
        const mins = minutes % 60;
        const period = hours >= 12 ? 'PM' : 'AM';
        const displayHours = hours % 12 || 12;
        return `${displayHours}:${String(mins).padStart(2, '0')} ${period}`;
    }
    /**
     * Convert time string to minutes since midnight
     * @param timeStr - Time string
     * @returns Minutes since midnight
     */
    static timeToMinutes(timeStr) {
        const [time] = timeStr.split('T').pop().split('.');
        const [hours, minutes] = time.split(':').map(Number);
        return hours * 60 + minutes;
    }
    /**
     * Get minutes since start of day
     * @param date - Date or ISO string
     * @returns Minutes since midnight
     */
    static getMinutesSinceMidnight(date) {
        const d = typeof date === 'string' ? new Date(date) : date;
        return d.getHours() * 60 + d.getMinutes();
    }
    /**
     * Calculate duration in minutes between two dates
     * @param start - Start date or ISO string
     * @param end - End date or ISO string
     * @returns Duration in minutes
     */
    static getDurationMinutes(start, end) {
        const startDate = typeof start === 'string' ? new Date(start) : start;
        const endDate = typeof end === 'string' ? new Date(end) : end;
        return Math.floor((endDate.getTime() - startDate.getTime()) / 60000);
    }
    /**
     * Check if two dates are on the same day
     * @param date1 - First date
     * @param date2 - Second date
     * @returns True if same day
     */
    static isSameDay(date1, date2) {
        return date1.toDateString() === date2.toDateString();
    }
    /**
     * Check if event spans multiple days
     * @param start - Start date or ISO string
     * @param end - End date or ISO string
     * @returns True if spans multiple days
     */
    static isMultiDay(start, end) {
        const startDate = typeof start === 'string' ? new Date(start) : start;
        const endDate = typeof end === 'string' ? new Date(end) : end;
        return !DateCalculator.isSameDay(startDate, endDate);
    }
    // Legacy constructor for backward compatibility
    constructor() {
        // Empty constructor - all methods are now static
    }
}
// Legacy factory function - deprecated, use static methods instead
export function createDateCalculator(config) {
    DateCalculator.initialize(config);
    return new DateCalculator();
}
//# sourceMappingURL=DateCalculator.js.map