ts-time-utils 0.0.1

package/dist/esm/validate.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Check if a date is valid
+ * @param date - date to validate
+ */
+export declare function isValidDate(date: Date | string | number): boolean;
+/**
+ * Check if a year is a leap year
+ * @param year - year to check
+ */
+export declare function isLeapYear(year: number): boolean;
+/**
+ * Check if a date is in the past
+ * @param date - date to check
+ */
+export declare function isPast(date: Date): boolean;
+/**
+ * Check if a date is in the future
+ * @param date - date to check
+ */
+export declare function isFuture(date: Date): boolean;
+/**
+ * Check if a date is today
+ * @param date - date to check
+ */
+export declare function isToday(date: Date): boolean;
+/**
+ * Check if a date is yesterday
+ * @param date - date to check
+ */
+export declare function isYesterday(date: Date): boolean;
+/**
+ * Check if a date is tomorrow
+ * @param date - date to check
+ */
+export declare function isTomorrow(date: Date): boolean;
+/**
+ * Check if two dates are the same day
+ * @param date1 - first date
+ * @param date2 - second date
+ */
+export declare function isSameDay(date1: Date, date2: Date): boolean;
+/**
+ * Check if a date is a weekend (Saturday or Sunday)
+ * @param date - date to check
+ */
+export declare function isWeekend(date: Date): boolean;
+/**
+ * Check if a date is a weekday (Monday through Friday)
+ * @param date - date to check
+ */
+export declare function isWeekday(date: Date): boolean;
+/**
+ * Check if a time string is valid (HH:MM or HH:MM:SS format)
+ * @param time - time string to validate
+ */
+export declare function isValidTimeString(time: string): boolean;
+/**
+ * Check if a date string is valid ISO 8601 format
+ * @param dateString - date string to validate
+ */
+export declare function isValidISOString(dateString: string): boolean;
+//# sourceMappingURL=validate.d.ts.map

package/dist/esm/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAWjE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE1C;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE5C;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAO3C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAQ/C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAQ9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAM3D;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAG7C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE7C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG5D"}

package/dist/esm/validate.js

@@ -0,0 +1,108 @@
+/**
+ * Check if a date is valid
+ * @param date - date to validate
+ */
+export function isValidDate(date) {
+    if (date instanceof Date) {
+        return !isNaN(date.getTime());
+    }
+    if (typeof date === 'string' || typeof date === 'number') {
+        const parsed = new Date(date);
+        return !isNaN(parsed.getTime());
+    }
+    return false;
+}
+/**
+ * Check if a year is a leap year
+ * @param year - year to check
+ */
+export function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
+}
+/**
+ * Check if a date is in the past
+ * @param date - date to check
+ */
+export function isPast(date) {
+    return date.getTime() < new Date().getTime();
+}
+/**
+ * Check if a date is in the future
+ * @param date - date to check
+ */
+export function isFuture(date) {
+    return date.getTime() > new Date().getTime();
+}
+/**
+ * Check if a date is today
+ * @param date - date to check
+ */
+export function isToday(date) {
+    const today = new Date();
+    return (date.getDate() === today.getDate() &&
+        date.getMonth() === today.getMonth() &&
+        date.getFullYear() === today.getFullYear());
+}
+/**
+ * Check if a date is yesterday
+ * @param date - date to check
+ */
+export function isYesterday(date) {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    return (date.getDate() === yesterday.getDate() &&
+        date.getMonth() === yesterday.getMonth() &&
+        date.getFullYear() === yesterday.getFullYear());
+}
+/**
+ * Check if a date is tomorrow
+ * @param date - date to check
+ */
+export function isTomorrow(date) {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    return (date.getDate() === tomorrow.getDate() &&
+        date.getMonth() === tomorrow.getMonth() &&
+        date.getFullYear() === tomorrow.getFullYear());
+}
+/**
+ * Check if two dates are the same day
+ * @param date1 - first date
+ * @param date2 - second date
+ */
+export function isSameDay(date1, date2) {
+    return (date1.getDate() === date2.getDate() &&
+        date1.getMonth() === date2.getMonth() &&
+        date1.getFullYear() === date2.getFullYear());
+}
+/**
+ * Check if a date is a weekend (Saturday or Sunday)
+ * @param date - date to check
+ */
+export function isWeekend(date) {
+    const dayOfWeek = date.getDay();
+    return dayOfWeek === 0 || dayOfWeek === 6; // Sunday or Saturday
+}
+/**
+ * Check if a date is a weekday (Monday through Friday)
+ * @param date - date to check
+ */
+export function isWeekday(date) {
+    return !isWeekend(date);
+}
+/**
+ * Check if a time string is valid (HH:MM or HH:MM:SS format)
+ * @param time - time string to validate
+ */
+export function isValidTimeString(time) {
+    const timeRegex = /^([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$/;
+    return timeRegex.test(time);
+}
+/**
+ * Check if a date string is valid ISO 8601 format
+ * @param dateString - date string to validate
+ */
+export function isValidISOString(dateString) {
+    const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+    return isoRegex.test(dateString) && isValidDate(dateString);
+}

package/dist/esm/workingHours.d.ts

@@ -0,0 +1,25 @@
+/** Working hours utilities */
+export interface WorkingHoursConfig {
+    workingDays: number[];
+    hours: {
+        start: number;
+        end: number;
+    };
+    breaks?: {
+        start: number;
+        end: number;
+    }[];
+    timezone?: string;
+}
+export declare const DEFAULT_WORKING_HOURS: WorkingHoursConfig;
+/** Check if a date is a configured working day */
+export declare function isWorkingDay(date: Date, config?: WorkingHoursConfig): boolean;
+/** Check if inside working hours (excluding breaks) */
+export declare function isWorkingTime(date: Date, config?: WorkingHoursConfig): boolean;
+/** Move date forward to next working minute */
+export declare function nextWorkingTime(date: Date, config?: WorkingHoursConfig): Date;
+/** Compute working time (ms) between two dates */
+export declare function workingTimeBetween(start: Date, end: Date, config?: WorkingHoursConfig): number;
+/** Advance by working hours amount (simple iterative approach) */
+export declare function addWorkingHours(start: Date, hours: number, config?: WorkingHoursConfig): Date;
+//# sourceMappingURL=workingHours.d.ts.map

package/dist/esm/workingHours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workingHours.d.ts","sourceRoot":"","sources":["../../src/workingHours.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAE9B,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,qBAAqB,EAAE,kBAInC,CAAC;AAEF,kDAAkD;AAClD,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,kBAA0C,GAAG,OAAO,CAEpG;AAOD,uDAAuD;AACvD,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,kBAA0C,GAAG,OAAO,CAUrG;AAED,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,kBAA0C,GAAG,IAAI,CAMpG;AAYD,kDAAkD;AAClD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAE,kBAA0C,GAAG,MAAM,CA+BrH;AAED,kEAAkE;AAClE,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,kBAA0C,GAAG,IAAI,CAcpH"}

package/dist/esm/workingHours.js

@@ -0,0 +1,107 @@
+/** Working hours utilities */
+export const DEFAULT_WORKING_HOURS = {
+    workingDays: [1, 2, 3, 4, 5],
+    hours: { start: 9, end: 17 },
+    breaks: [{ start: 12, end: 13 }]
+};
+/** Check if a date is a configured working day */
+export function isWorkingDay(date, config = DEFAULT_WORKING_HOURS) {
+    return config.workingDays.includes(date.getDay());
+}
+/** Convert date to fractional hour */
+function toHourFraction(date) {
+    return date.getHours() + date.getMinutes() / 60 + date.getSeconds() / 3600;
+}
+/** Check if inside working hours (excluding breaks) */
+export function isWorkingTime(date, config = DEFAULT_WORKING_HOURS) {
+    if (!isWorkingDay(date, config))
+        return false;
+    const h = toHourFraction(date);
+    if (h < config.hours.start || h >= config.hours.end)
+        return false;
+    if (config.breaks) {
+        for (const b of config.breaks) {
+            if (h >= b.start && h < b.end)
+                return false;
+        }
+    }
+    return true;
+}
+/** Move date forward to next working minute */
+export function nextWorkingTime(date, config = DEFAULT_WORKING_HOURS) {
+    const d = new Date(date);
+    while (!isWorkingTime(d, config)) {
+        d.setMinutes(d.getMinutes() + 1);
+    }
+    return d;
+}
+/** Clamp a date into working window of its day */
+function clampToWorkingWindow(date, config) {
+    if (!isWorkingDay(date, config))
+        return null;
+    const start = new Date(date);
+    start.setHours(config.hours.start, 0, 0, 0);
+    const end = new Date(date);
+    end.setHours(config.hours.end, 0, 0, 0);
+    if (date < start)
+        return start;
+    if (date > end)
+        return null;
+    return date;
+}
+/** Compute working time (ms) between two dates */
+export function workingTimeBetween(start, end, config = DEFAULT_WORKING_HOURS) {
+    if (end <= start)
+        return 0;
+    let total = 0;
+    const cursor = new Date(start);
+    while (cursor < end) {
+        if (isWorkingDay(cursor, config)) {
+            const windowStart = new Date(cursor);
+            windowStart.setHours(config.hours.start, 0, 0, 0);
+            const windowEnd = new Date(cursor);
+            windowEnd.setHours(config.hours.end, 0, 0, 0);
+            const rangeStart = cursor > windowStart ? cursor : windowStart;
+            const rangeEnd = end < windowEnd ? end : windowEnd;
+            if (rangeStart < rangeEnd) {
+                let segment = (rangeEnd.getTime() - rangeStart.getTime()) / 1000 / 60 / 60; // hours
+                // subtract breaks
+                if (config.breaks) {
+                    for (const b of config.breaks) {
+                        const bStart = new Date(rangeStart);
+                        bStart.setHours(Math.floor(b.start), (b.start % 1) * 60, 0, 0);
+                        const bEnd = new Date(rangeStart);
+                        bEnd.setHours(Math.floor(b.end), (b.end % 1) * 60, 0, 0);
+                        const overlapStart = bStart > rangeStart ? bStart : rangeStart;
+                        const overlapEnd = bEnd < rangeEnd ? bEnd : rangeEnd;
+                        if (overlapStart < overlapEnd) {
+                            segment -= (overlapEnd.getTime() - overlapStart.getTime()) / 1000 / 60 / 60;
+                        }
+                    }
+                }
+                total += segment;
+            }
+        }
+        // advance to next day start
+        cursor.setHours(24, 0, 0, 0);
+    }
+    return total * 60 * 60 * 1000; // ms
+}
+/** Advance by working hours amount (simple iterative approach) */
+export function addWorkingHours(start, hours, config = DEFAULT_WORKING_HOURS) {
+    if (hours <= 0)
+        return new Date(start);
+    let remaining = hours * 60; // minutes
+    let cursor = new Date(start);
+    cursor = nextWorkingTime(cursor, config);
+    while (remaining > 0) {
+        if (isWorkingTime(cursor, config)) {
+            cursor.setMinutes(cursor.getMinutes() + 1);
+            remaining -= 1;
+        }
+        else {
+            cursor = nextWorkingTime(cursor, config);
+        }
+    }
+    return cursor;
+}

package/dist/format.d.ts

@@ -0,0 +1,25 @@
+import { FormatOptions } from './constants.js';
+/**
+ * Convert milliseconds to a human-readable duration.
+ * @param ms - milliseconds
+ * @param options - formatting options
+ */
+export declare function formatDuration(ms: number, options?: FormatOptions): string;
+/**
+ * Return a human-readable "time ago" string.
+ * @param date - past or future date
+ * @param options - formatting options
+ */
+export declare function timeAgo(date: Date, options?: FormatOptions): string;
+/**
+ * Format a date to a human-readable time string
+ * @param date - date to format
+ * @param format - format type
+ */
+export declare function formatTime(date: Date, format?: '12h' | '24h' | 'iso'): string;
+/**
+ * Parse a duration string like "1h 30m" into milliseconds
+ * @param duration - duration string (e.g., "1h 30m", "2d", "45s")
+ */
+export declare function parseDuration(duration: string): number;
+//# sourceMappingURL=format.d.ts.map

package/dist/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,aAAa,EACd,MAAM,gBAAgB,CAAC;AAExB;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CA2E9E;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CA+CvE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,KAAK,GAAG,KAAK,GAAG,KAAa,GAAG,MAAM,CAcpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAyDtD"}

package/dist/format.js

@@ -0,0 +1,189 @@
+import { MILLISECONDS_PER_SECOND, MILLISECONDS_PER_MINUTE, MILLISECONDS_PER_HOUR, MILLISECONDS_PER_DAY, MILLISECONDS_PER_WEEK, MILLISECONDS_PER_MONTH, MILLISECONDS_PER_YEAR } from './constants.js';
+/**
+ * Convert milliseconds to a human-readable duration.
+ * @param ms - milliseconds
+ * @param options - formatting options
+ */
+export function formatDuration(ms, options = {}) {
+    const { includeMs = false, short = false, maxUnits = 2, round = false } = options;
+    if (ms < 0)
+        return '0' + (short ? 's' : ' seconds');
+    const mathFn = round ? Math.round : Math.floor;
+    const parts = [];
+    let remaining = ms;
+    // Years
+    if (remaining >= MILLISECONDS_PER_YEAR) {
+        const years = mathFn(remaining / MILLISECONDS_PER_YEAR);
+        parts.push(years + (short ? 'y' : ` year${years !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_YEAR;
+    }
+    // Months
+    if (remaining >= MILLISECONDS_PER_MONTH && parts.length < maxUnits) {
+        const months = mathFn(remaining / MILLISECONDS_PER_MONTH);
+        parts.push(months + (short ? 'mo' : ` month${months !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_MONTH;
+    }
+    // Weeks
+    if (remaining >= MILLISECONDS_PER_WEEK && parts.length < maxUnits) {
+        const weeks = mathFn(remaining / MILLISECONDS_PER_WEEK);
+        parts.push(weeks + (short ? 'w' : ` week${weeks !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_WEEK;
+    }
+    // Days
+    if (remaining >= MILLISECONDS_PER_DAY && parts.length < maxUnits) {
+        const days = mathFn(remaining / MILLISECONDS_PER_DAY);
+        parts.push(days + (short ? 'd' : ` day${days !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_DAY;
+    }
+    // Hours
+    if (remaining >= MILLISECONDS_PER_HOUR && parts.length < maxUnits) {
+        const hours = mathFn(remaining / MILLISECONDS_PER_HOUR);
+        parts.push(hours + (short ? 'h' : ` hour${hours !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_HOUR;
+    }
+    // Minutes
+    if (remaining >= MILLISECONDS_PER_MINUTE && parts.length < maxUnits) {
+        const minutes = mathFn(remaining / MILLISECONDS_PER_MINUTE);
+        parts.push(minutes + (short ? 'm' : ` minute${minutes !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_MINUTE;
+    }
+    // Seconds
+    if (remaining >= MILLISECONDS_PER_SECOND && parts.length < maxUnits) {
+        const seconds = mathFn(remaining / MILLISECONDS_PER_SECOND);
+        parts.push(seconds + (short ? 's' : ` second${seconds !== 1 ? 's' : ''}`));
+        remaining %= MILLISECONDS_PER_SECOND;
+    }
+    // Milliseconds
+    if ((remaining > 0 || parts.length === 0) && includeMs && parts.length < maxUnits) {
+        const milliseconds = mathFn(remaining);
+        parts.push(milliseconds + (short ? 'ms' : ` millisecond${milliseconds !== 1 ? 's' : ''}`));
+    }
+    if (parts.length === 0) {
+        return '0' + (short ? 's' : ' seconds');
+    }
+    return short ? parts.join(' ') : parts.join(', ');
+}
+/**
+ * Return a human-readable "time ago" string.
+ * @param date - past or future date
+ * @param options - formatting options
+ */
+export function timeAgo(date, options = {}) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const { short = false } = options;
+    const isFuture = diffMs < 0;
+    const absDiffMs = Math.abs(diffMs);
+    if (absDiffMs < MILLISECONDS_PER_MINUTE) {
+        const seconds = Math.floor(absDiffMs / MILLISECONDS_PER_SECOND);
+        const unit = short ? 's' : ` second${seconds !== 1 ? 's' : ''}`;
+        return isFuture ? `in ${seconds}${unit}` : `${seconds}${unit} ago`;
+    }
+    if (absDiffMs < MILLISECONDS_PER_HOUR) {
+        const minutes = Math.floor(absDiffMs / MILLISECONDS_PER_MINUTE);
+        const unit = short ? 'm' : ` minute${minutes !== 1 ? 's' : ''}`;
+        return isFuture ? `in ${minutes}${unit}` : `${minutes}${unit} ago`;
+    }
+    if (absDiffMs < MILLISECONDS_PER_DAY) {
+        const hours = Math.floor(absDiffMs / MILLISECONDS_PER_HOUR);
+        const unit = short ? 'h' : ` hour${hours !== 1 ? 's' : ''}`;
+        return isFuture ? `in ${hours}${unit}` : `${hours}${unit} ago`;
+    }
+    if (absDiffMs < MILLISECONDS_PER_WEEK) {
+        const days = Math.floor(absDiffMs / MILLISECONDS_PER_DAY);
+        const unit = short ? 'd' : ` day${days !== 1 ? 's' : ''}`;
+        return isFuture ? `in ${days}${unit}` : `${days}${unit} ago`;
+    }
+    if (absDiffMs < MILLISECONDS_PER_MONTH) {
+        const weeks = Math.floor(absDiffMs / MILLISECONDS_PER_WEEK);
+        const unit = short ? 'w' : ` week${weeks !== 1 ? 's' : ''}`;
+        return isFuture ? `in ${weeks}${unit}` : `${weeks}${unit} ago`;
+    }
+    if (absDiffMs < MILLISECONDS_PER_YEAR) {
+        const months = Math.floor(absDiffMs / MILLISECONDS_PER_MONTH);
+        const unit = short ? 'mo' : ` month${months !== 1 ? 's' : ''}`;
+        return isFuture ? `in ${months}${unit}` : `${months}${unit} ago`;
+    }
+    const years = Math.floor(absDiffMs / MILLISECONDS_PER_YEAR);
+    const unit = short ? 'y' : ` year${years !== 1 ? 's' : ''}`;
+    return isFuture ? `in ${years}${unit}` : `${years}${unit} ago`;
+}
+/**
+ * Format a date to a human-readable time string
+ * @param date - date to format
+ * @param format - format type
+ */
+export function formatTime(date, format = '24h') {
+    switch (format) {
+        case '12h':
+            return date.toLocaleTimeString('en-US', {
+                hour: 'numeric',
+                minute: '2-digit',
+                hour12: true
+            });
+        case 'iso':
+            return date.toISOString();
+        case '24h':
+        default:
+            return date.toTimeString().split(' ')[0].slice(0, 5); // HH:MM
+    }
+}
+/**
+ * Parse a duration string like "1h 30m" into milliseconds
+ * @param duration - duration string (e.g., "1h 30m", "2d", "45s")
+ */
+export function parseDuration(duration) {
+    const regex = /(\d+(?:\.\d+)?)\s*([a-zA-Z]+)/g;
+    let totalMs = 0;
+    let match;
+    while ((match = regex.exec(duration)) !== null) {
+        const value = parseFloat(match[1]);
+        const unit = match[2].toLowerCase();
+        switch (unit) {
+            case 'ms':
+            case 'millisecond':
+            case 'milliseconds':
+                totalMs += value;
+                break;
+            case 's':
+            case 'sec':
+            case 'second':
+            case 'seconds':
+                totalMs += value * MILLISECONDS_PER_SECOND;
+                break;
+            case 'm':
+            case 'min':
+            case 'minute':
+            case 'minutes':
+                totalMs += value * MILLISECONDS_PER_MINUTE;
+                break;
+            case 'h':
+            case 'hr':
+            case 'hour':
+            case 'hours':
+                totalMs += value * MILLISECONDS_PER_HOUR;
+                break;
+            case 'd':
+            case 'day':
+            case 'days':
+                totalMs += value * MILLISECONDS_PER_DAY;
+                break;
+            case 'w':
+            case 'week':
+            case 'weeks':
+                totalMs += value * MILLISECONDS_PER_WEEK;
+                break;
+            case 'mo':
+            case 'month':
+            case 'months':
+                totalMs += value * MILLISECONDS_PER_MONTH;
+                break;
+            case 'y':
+            case 'year':
+            case 'years':
+                totalMs += value * MILLISECONDS_PER_YEAR;
+                break;
+        }
+    }
+    return totalMs;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Main entry point for ts-time-utils library
+ * Re-exports all functions from individual modules for convenience
+ */
+export { formatDuration, timeAgo, formatTime, parseDuration } from './format.js';
+export { differenceInUnits, addTime, subtractTime, startOf, endOf, isBetween, businessDaysBetween } from './calculate.js';
+export { isValidDate, isLeapYear, isPast, isFuture, isToday, isYesterday, isTomorrow, isSameDay, isWeekend, isWeekday, isValidTimeString, isValidISOString } from './validate.js';
+export { calculateAge, getAgeInUnits, getLifeStage, getNextBirthday, getDaysUntilBirthday, isBirthday, type AgeResult } from './age.js';
+export { getWeekNumber, getWeekOfMonth, getQuarter, getDayOfYear, getWeeksInYear, getDaysInMonth, getDaysInYear, getEaster, getMonthsInYear, getDaysInMonthArray, getWeekdaysInMonth, getFirstDayOfMonth, getLastDayOfMonth, getFirstDayOfYear, getLastDayOfYear } from './calendar.js';
+export { parseDate, parseRelativeDate, parseTimeAgo, parseCustomFormat, parseManyFormats } from './parse.js';
+export { sleep, timeout, debounce, throttle, retry, createStopwatch, measureTime, measureAsync, benchmark, Stopwatch, type BenchmarkResult } from './performance.js';
+export { createInterval, isValidInterval, intervalDuration, intervalContains, intervalsOverlap, intervalIntersection, mergeIntervals, subtractInterval, splitIntervalByDay, totalIntervalCoverage, normalizeIntervals, type Interval } from './interval.js';
+export { getTimezoneOffset, formatInTimeZone, getZonedTime, convertDateToZone, isValidTimeZone, COMMON_TIMEZONES, getLocalOffset, compareZoneOffsets, reinterpretAsZone, type ZonedTime } from './timezone.js';
+export { DEFAULT_WORKING_HOURS, isWorkingDay, isWorkingTime, nextWorkingTime, workingTimeBetween, addWorkingHours, type WorkingHoursConfig } from './workingHours.js';
+export { today, yesterday, tomorrow, lastNDays, nextNDays, thisWeek, lastWeek, nextWeek, thisMonth, lastMonth, nextMonth, thisYear, lastYear, nextYear, rollingWindowDays, quarterRange, lastQuarter, nextQuarter, RANGE_PRESETS, type DateRange } from './rangePresets.js';
+export { MILLISECONDS_PER_SECOND, MILLISECONDS_PER_MINUTE, MILLISECONDS_PER_HOUR, MILLISECONDS_PER_DAY, MILLISECONDS_PER_WEEK, MILLISECONDS_PER_MONTH, MILLISECONDS_PER_YEAR, SECONDS_PER_MINUTE, SECONDS_PER_HOUR, SECONDS_PER_DAY, SECONDS_PER_WEEK, type TimeUnit, type FormatOptions } from './constants.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,cAAc,EACd,OAAO,EACP,UAAU,EACV,aAAa,EACd,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,iBAAiB,EACjB,OAAO,EACP,YAAY,EACZ,OAAO,EACP,KAAK,EACL,SAAS,EACT,mBAAmB,EACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,WAAW,EACX,UAAU,EACV,MAAM,EACN,QAAQ,EACR,OAAO,EACP,WAAW,EACX,UAAU,EACV,SAAS,EACT,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,eAAe,EACf,oBAAoB,EACpB,UAAU,EACV,KAAK,SAAS,EACf,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,aAAa,EACb,cAAc,EACd,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,KAAK,EACL,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,eAAe,EACf,WAAW,EACX,YAAY,EACZ,SAAS,EACT,SAAS,EACT,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,SAAS,EACf,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,KAAK,EACL,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,SAAS,EACT,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACX,WAAW,EACX,aAAa,EACb,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Main entry point for ts-time-utils library
+ * Re-exports all functions from individual modules for convenience
+ */
+// Format utilities
+export { formatDuration, timeAgo, formatTime, parseDuration } from './format.js';
+// Calculation utilities  
+export { differenceInUnits, addTime, subtractTime, startOf, endOf, isBetween, businessDaysBetween } from './calculate.js';
+// Validation utilities
+export { isValidDate, isLeapYear, isPast, isFuture, isToday, isYesterday, isTomorrow, isSameDay, isWeekend, isWeekday, isValidTimeString, isValidISOString } from './validate.js';
+// Age utilities
+export { calculateAge, getAgeInUnits, getLifeStage, getNextBirthday, getDaysUntilBirthday, isBirthday } from './age.js';
+// Calendar utilities
+export { getWeekNumber, getWeekOfMonth, getQuarter, getDayOfYear, getWeeksInYear, getDaysInMonth, getDaysInYear, getEaster, getMonthsInYear, getDaysInMonthArray, getWeekdaysInMonth, getFirstDayOfMonth, getLastDayOfMonth, getFirstDayOfYear, getLastDayOfYear } from './calendar.js';
+// Parse utilities
+export { parseDate, parseRelativeDate, parseTimeAgo, parseCustomFormat, parseManyFormats } from './parse.js';
+// Performance utilities
+export { sleep, timeout, debounce, throttle, retry, createStopwatch, measureTime, measureAsync, benchmark, Stopwatch } from './performance.js';
+// Interval utilities
+export { createInterval, isValidInterval, intervalDuration, intervalContains, intervalsOverlap, intervalIntersection, mergeIntervals, subtractInterval, splitIntervalByDay, totalIntervalCoverage, normalizeIntervals } from './interval.js';
+// Timezone utilities
+export { getTimezoneOffset, formatInTimeZone, getZonedTime, convertDateToZone, isValidTimeZone, COMMON_TIMEZONES, getLocalOffset, compareZoneOffsets, reinterpretAsZone } from './timezone.js';
+// Working hours utilities
+export { DEFAULT_WORKING_HOURS, isWorkingDay, isWorkingTime, nextWorkingTime, workingTimeBetween, addWorkingHours } from './workingHours.js';
+// Range preset utilities
+export { today, yesterday, tomorrow, lastNDays, nextNDays, thisWeek, lastWeek, nextWeek, thisMonth, lastMonth, nextMonth, thisYear, lastYear, nextYear, rollingWindowDays, quarterRange, lastQuarter, nextQuarter, RANGE_PRESETS } from './rangePresets.js';
+// Constants and types
+export { MILLISECONDS_PER_SECOND, MILLISECONDS_PER_MINUTE, MILLISECONDS_PER_HOUR, MILLISECONDS_PER_DAY, MILLISECONDS_PER_WEEK, MILLISECONDS_PER_MONTH, MILLISECONDS_PER_YEAR, SECONDS_PER_MINUTE, SECONDS_PER_HOUR, SECONDS_PER_DAY, SECONDS_PER_WEEK } from './constants.js';

package/dist/interval.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Interval utilities: operations on time intervals [start, end)
+ */
+export interface Interval {
+    start: Date;
+    end: Date;
+}
+/** Create an interval ensuring start <= end */
+export declare function createInterval(start: Date | string | number, end: Date | string | number): Interval | null;
+/** Validate an object is a proper interval */
+export declare function isValidInterval(i: any): i is Interval;
+/** Duration of interval in ms */
+export declare function intervalDuration(i: Interval): number;
+/** Whether interval contains date (inclusive start, exclusive end) */
+export declare function intervalContains(i: Interval, date: Date | number): boolean;
+/** Whether two intervals overlap */
+export declare function intervalsOverlap(a: Interval, b: Interval): boolean;
+/** Intersection of two intervals, or null */
+export declare function intervalIntersection(a: Interval, b: Interval): Interval | null;
+/** Merge overlapping or touching intervals into a minimal set */
+export declare function mergeIntervals(intervals: Interval[]): Interval[];
+/** Subtract interval b from a (can split into 0,1,2 intervals) */
+export declare function subtractInterval(a: Interval, b: Interval): Interval[];
+/** Split an interval into day-boundary intervals (UTC based) */
+export declare function splitIntervalByDay(i: Interval): Interval[];
+/** Total covered duration of possibly overlapping intervals */
+export declare function totalIntervalCoverage(intervals: Interval[]): number;
+/** Normalize array: filter invalid and merge */
+export declare function normalizeIntervals(intervals: (Interval | null | undefined)[]): Interval[];
+//# sourceMappingURL=interval.d.ts.map

package/dist/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../src/interval.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,IAAI,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;CACX;AAED,+CAA+C;AAC/C,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,IAAI,CAK1G;AAED,8CAA8C;AAC9C,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,CAErD;AAED,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,OAAO,CAG1E;AAED,oCAAoC;AACpC,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAElE;AAED,6CAA6C;AAC7C,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAI9E;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAgBhE;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAMrE;AAED,gEAAgE;AAChE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAU1D;AAED,+DAA+D;AAC/D,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,MAAM,CAEnE;AAED,gDAAgD;AAChD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,QAAQ,EAAE,CAEzF"}