ts-time-utils 1.0.0 → 2.0.0

package/dist/esm/compare.js

@@ -0,0 +1,417 @@
+/**
+ * @fileoverview Date comparison, sorting, and array manipulation utilities
+ */
+/**
+ * Compare two dates for sorting
+ * @param a - First date
+ * @param b - Second date
+ * @returns Negative if a < b, positive if a > b, 0 if equal
+ * @example
+ * [date3, date1, date2].sort(compareDates) // [date1, date2, date3]
+ */
+export function compareDates(a, b) {
+    return a.getTime() - b.getTime();
+}
+/**
+ * Compare two dates in reverse order for sorting
+ * @param a - First date
+ * @param b - Second date
+ * @returns Positive if a < b, negative if a > b, 0 if equal
+ * @example
+ * [date1, date3, date2].sort(compareDatesDesc) // [date3, date2, date1]
+ */
+export function compareDatesDesc(a, b) {
+    return b.getTime() - a.getTime();
+}
+/**
+ * Sort an array of dates
+ * @param dates - Array of dates to sort
+ * @param direction - Sort direction: 'asc' (oldest first) or 'desc' (newest first)
+ * @returns New sorted array (does not mutate original)
+ * @example
+ * sortDates([date3, date1, date2]) // [date1, date2, date3]
+ * sortDates([date1, date2, date3], 'desc') // [date3, date2, date1]
+ */
+export function sortDates(dates, direction = 'asc') {
+    const sorted = [...dates];
+    sorted.sort(direction === 'asc' ? compareDates : compareDatesDesc);
+    return sorted;
+}
+/**
+ * Find the minimum (earliest) date in an array
+ * @param dates - Array of dates
+ * @returns The earliest date, or undefined if array is empty
+ * @example
+ * minDate([date2, date1, date3]) // date1
+ */
+export function minDate(dates) {
+    if (dates.length === 0)
+        return undefined;
+    return dates.reduce((min, date) => (date < min ? date : min));
+}
+/**
+ * Find the maximum (latest) date in an array
+ * @param dates - Array of dates
+ * @returns The latest date, or undefined if array is empty
+ * @example
+ * maxDate([date1, date3, date2]) // date3
+ */
+export function maxDate(dates) {
+    if (dates.length === 0)
+        return undefined;
+    return dates.reduce((max, date) => (date > max ? date : max));
+}
+/**
+ * Find the date range (min and max) in an array
+ * @param dates - Array of dates
+ * @returns Object with min and max dates, or undefined if array is empty
+ * @example
+ * dateRange([date2, date1, date3]) // { min: date1, max: date3 }
+ */
+export function dateExtent(dates) {
+    if (dates.length === 0)
+        return undefined;
+    let min = dates[0];
+    let max = dates[0];
+    for (const date of dates) {
+        if (date < min)
+            min = date;
+        if (date > max)
+            max = date;
+    }
+    return { min, max };
+}
+/**
+ * Remove duplicate dates from an array
+ * @param dates - Array of dates
+ * @param precision - Precision for comparison: 'ms' (exact), 'second', 'minute', 'hour', 'day'
+ * @returns New array with duplicates removed (preserves first occurrence)
+ * @example
+ * uniqueDates([date1, date1Copy, date2]) // [date1, date2]
+ */
+export function uniqueDates(dates, precision = 'ms') {
+    const seen = new Set();
+    const result = [];
+    for (const date of dates) {
+        const key = getDateKey(date, precision);
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(date);
+        }
+    }
+    return result;
+}
+/**
+ * Get a numeric key for a date based on precision
+ */
+function getDateKey(date, precision) {
+    switch (precision) {
+        case 'ms':
+            return date.getTime();
+        case 'second':
+            return Math.floor(date.getTime() / 1000);
+        case 'minute':
+            return Math.floor(date.getTime() / 60000);
+        case 'hour':
+            return Math.floor(date.getTime() / 3600000);
+        case 'day':
+            return Math.floor(date.getTime() / 86400000);
+    }
+}
+/**
+ * Find the closest date to a target from an array of candidates
+ * @param target - The target date
+ * @param candidates - Array of candidate dates
+ * @returns The closest date, or undefined if candidates is empty
+ * @example
+ * closestDate(targetDate, [date1, date2, date3]) // closest to target
+ */
+export function closestDate(target, candidates) {
+    if (candidates.length === 0)
+        return undefined;
+    const targetTime = target.getTime();
+    let closest = candidates[0];
+    let minDiff = Math.abs(closest.getTime() - targetTime);
+    for (const candidate of candidates) {
+        const diff = Math.abs(candidate.getTime() - targetTime);
+        if (diff < minDiff) {
+            minDiff = diff;
+            closest = candidate;
+        }
+    }
+    return closest;
+}
+/**
+ * Find the closest future date to a target
+ * @param target - The target date
+ * @param candidates - Array of candidate dates
+ * @returns The closest future date, or undefined if none found
+ */
+export function closestFutureDate(target, candidates) {
+    const targetTime = target.getTime();
+    const futureDates = candidates.filter(d => d.getTime() > targetTime);
+    return minDate(futureDates);
+}
+/**
+ * Find the closest past date to a target
+ * @param target - The target date
+ * @param candidates - Array of candidate dates
+ * @returns The closest past date, or undefined if none found
+ */
+export function closestPastDate(target, candidates) {
+    const targetTime = target.getTime();
+    const pastDates = candidates.filter(d => d.getTime() < targetTime);
+    return maxDate(pastDates);
+}
+/**
+ * Clamp a date to be within a range
+ * @param date - The date to clamp
+ * @param min - Minimum allowed date
+ * @param max - Maximum allowed date
+ * @returns The clamped date
+ * @example
+ * clampDate(earlyDate, minDate, maxDate) // returns minDate
+ * clampDate(lateDate, minDate, maxDate) // returns maxDate
+ * clampDate(middleDate, minDate, maxDate) // returns middleDate
+ */
+export function clampDate(date, min, max) {
+    if (date < min)
+        return new Date(min);
+    if (date > max)
+        return new Date(max);
+    return new Date(date);
+}
+/**
+ * Check if a date is within a range (inclusive)
+ * @param date - The date to check
+ * @param min - Start of range
+ * @param max - End of range
+ * @returns True if date is within range
+ */
+export function isDateInRange(date, min, max) {
+    const time = date.getTime();
+    return time >= min.getTime() && time <= max.getTime();
+}
+/**
+ * Filter dates to only those within a range
+ * @param dates - Array of dates
+ * @param min - Start of range
+ * @param max - End of range
+ * @returns New array with only dates in range
+ */
+export function filterDatesInRange(dates, min, max) {
+    return dates.filter(date => isDateInRange(date, min, max));
+}
+/**
+ * Group dates by a key function
+ * @param dates - Array of dates
+ * @param keyFn - Function to generate group key from date
+ * @returns Map of key to array of dates
+ * @example
+ * groupDates(dates, d => d.getFullYear()) // Map { 2023 => [...], 2024 => [...] }
+ * groupDates(dates, d => d.toISOString().slice(0, 7)) // Group by month
+ */
+export function groupDates(dates, keyFn) {
+    const groups = new Map();
+    for (const date of dates) {
+        const key = keyFn(date);
+        const group = groups.get(key);
+        if (group) {
+            group.push(date);
+        }
+        else {
+            groups.set(key, [date]);
+        }
+    }
+    return groups;
+}
+/**
+ * Group dates by year
+ * @param dates - Array of dates
+ * @returns Map of year to array of dates
+ */
+export function groupDatesByYear(dates) {
+    return groupDates(dates, d => d.getFullYear());
+}
+/**
+ * Group dates by month (YYYY-MM format)
+ * @param dates - Array of dates
+ * @returns Map of month key to array of dates
+ */
+export function groupDatesByMonth(dates) {
+    return groupDates(dates, d => {
+        const year = d.getFullYear();
+        const month = String(d.getMonth() + 1).padStart(2, '0');
+        return `${year}-${month}`;
+    });
+}
+/**
+ * Group dates by day (YYYY-MM-DD format)
+ * @param dates - Array of dates
+ * @returns Map of day key to array of dates
+ */
+export function groupDatesByDay(dates) {
+    return groupDates(dates, d => d.toISOString().slice(0, 10));
+}
+/**
+ * Group dates by day of week (0-6, Sunday-Saturday)
+ * @param dates - Array of dates
+ * @returns Map of day of week to array of dates
+ */
+export function groupDatesByDayOfWeek(dates) {
+    return groupDates(dates, d => d.getDay());
+}
+/**
+ * Calculate the median date from an array
+ * @param dates - Array of dates
+ * @returns The median date, or undefined if array is empty
+ */
+export function medianDate(dates) {
+    if (dates.length === 0)
+        return undefined;
+    const sorted = sortDates(dates);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        // Average of two middle values
+        const time1 = sorted[mid - 1].getTime();
+        const time2 = sorted[mid].getTime();
+        return new Date((time1 + time2) / 2);
+    }
+    return new Date(sorted[mid]);
+}
+/**
+ * Calculate the average/mean date from an array
+ * @param dates - Array of dates
+ * @returns The average date, or undefined if array is empty
+ */
+export function averageDate(dates) {
+    if (dates.length === 0)
+        return undefined;
+    const sum = dates.reduce((acc, date) => acc + date.getTime(), 0);
+    return new Date(sum / dates.length);
+}
+/**
+ * Round a date to the nearest unit
+ * @param date - The date to round
+ * @param unit - Unit to round to
+ * @returns New rounded date
+ * @example
+ * roundDate(new Date('2024-03-15T14:37:00'), 'hour') // 2024-03-15T15:00:00
+ * roundDate(new Date('2024-03-15T14:22:00'), 'hour') // 2024-03-15T14:00:00
+ */
+export function roundDate(date, unit) {
+    const d = new Date(date);
+    switch (unit) {
+        case 'minute':
+            if (d.getSeconds() >= 30) {
+                d.setMinutes(d.getMinutes() + 1);
+            }
+            d.setSeconds(0, 0);
+            break;
+        case 'hour':
+            if (d.getMinutes() >= 30) {
+                d.setHours(d.getHours() + 1);
+            }
+            d.setMinutes(0, 0, 0);
+            break;
+        case 'day':
+            if (d.getHours() >= 12) {
+                d.setDate(d.getDate() + 1);
+            }
+            d.setHours(0, 0, 0, 0);
+            break;
+    }
+    return d;
+}
+/**
+ * Snap a date to a grid interval
+ * @param date - The date to snap
+ * @param intervalMinutes - Interval in minutes (e.g., 15 for quarter-hour)
+ * @param mode - Snap mode: 'floor' (down), 'ceil' (up), or 'round' (nearest)
+ * @returns New snapped date
+ * @example
+ * snapDate(new Date('2024-03-15T14:37:00'), 15) // 2024-03-15T14:30:00
+ * snapDate(new Date('2024-03-15T14:37:00'), 15, 'ceil') // 2024-03-15T14:45:00
+ */
+export function snapDate(date, intervalMinutes, mode = 'round') {
+    const ms = date.getTime();
+    const intervalMs = intervalMinutes * 60 * 1000;
+    let snapped;
+    switch (mode) {
+        case 'floor':
+            snapped = Math.floor(ms / intervalMs) * intervalMs;
+            break;
+        case 'ceil':
+            snapped = Math.ceil(ms / intervalMs) * intervalMs;
+            break;
+        case 'round':
+            snapped = Math.round(ms / intervalMs) * intervalMs;
+            break;
+    }
+    return new Date(snapped);
+}
+/**
+ * Check if dates are in chronological order
+ * @param dates - Array of dates
+ * @param strict - If true, requires strictly increasing (no duplicates)
+ * @returns True if dates are in order
+ */
+export function isChronological(dates, strict = false) {
+    for (let i = 1; i < dates.length; i++) {
+        const prev = dates[i - 1].getTime();
+        const curr = dates[i].getTime();
+        if (strict ? curr <= prev : curr < prev) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Get the span (duration) between min and max dates
+ * @param dates - Array of dates
+ * @returns Duration in milliseconds, or 0 if less than 2 dates
+ */
+export function dateSpan(dates) {
+    const extent = dateExtent(dates);
+    if (!extent)
+        return 0;
+    return extent.max.getTime() - extent.min.getTime();
+}
+/**
+ * Partition dates into buckets based on a predicate
+ * @param dates - Array of dates
+ * @param predicate - Function that returns true for dates in first partition
+ * @returns Tuple of [matching, non-matching] date arrays
+ */
+export function partitionDates(dates, predicate) {
+    const matching = [];
+    const nonMatching = [];
+    for (const date of dates) {
+        if (predicate(date)) {
+            matching.push(date);
+        }
+        else {
+            nonMatching.push(date);
+        }
+    }
+    return [matching, nonMatching];
+}
+/**
+ * Get the nth date from an array (supports negative indices)
+ * @param dates - Array of dates (will be sorted)
+ * @param n - Index (0-based, negative counts from end)
+ * @returns The nth date, or undefined if out of bounds
+ * @example
+ * nthDate(dates, 0) // earliest
+ * nthDate(dates, -1) // latest
+ * nthDate(dates, 2) // third earliest
+ */
+export function nthDate(dates, n) {
+    if (dates.length === 0)
+        return undefined;
+    const sorted = sortDates(dates);
+    const index = n < 0 ? sorted.length + n : n;
+    if (index < 0 || index >= sorted.length)
+        return undefined;
+    return sorted[index];
+}

package/dist/esm/countdown.d.ts

@@ -0,0 +1,217 @@
+/**
+ * @fileoverview Countdown and timer utilities for tracking time until/since a target date
+ * Provides countdown timers, remaining time calculations, and progress tracking
+ */
+import type { DateInput } from './types.js';
+/**
+ * Represents the remaining time broken down by units
+ */
+export interface RemainingTime {
+    /** Total milliseconds remaining */
+    totalMilliseconds: number;
+    /** Total seconds remaining */
+    totalSeconds: number;
+    /** Total minutes remaining */
+    totalMinutes: number;
+    /** Total hours remaining */
+    totalHours: number;
+    /** Total days remaining */
+    totalDays: number;
+    /** Milliseconds component (0-999) */
+    milliseconds: number;
+    /** Seconds component (0-59) */
+    seconds: number;
+    /** Minutes component (0-59) */
+    minutes: number;
+    /** Hours component (0-23) */
+    hours: number;
+    /** Days component */
+    days: number;
+    /** Weeks component */
+    weeks: number;
+    /** Whether the target date has passed */
+    isExpired: boolean;
+}
+/**
+ * Options for countdown creation
+ */
+export interface CountdownOptions {
+    /** Callback fired on each tick */
+    onTick?: (remaining: RemainingTime) => void;
+    /** Callback fired when countdown reaches zero */
+    onComplete?: () => void;
+    /** Callback fired if target date is in the past */
+    onExpired?: () => void;
+    /** Tick interval in milliseconds (default: 1000) */
+    interval?: number;
+    /** Whether to fire onTick immediately (default: true) */
+    immediate?: boolean;
+}
+/**
+ * Countdown timer instance
+ */
+export interface Countdown {
+    /** Start the countdown */
+    start: () => void;
+    /** Stop the countdown */
+    stop: () => void;
+    /** Reset countdown with a new target date */
+    reset: (targetDate: DateInput) => void;
+    /** Get current remaining time */
+    getRemaining: () => RemainingTime;
+    /** Check if countdown is running */
+    isRunning: () => boolean;
+    /** Check if target date has passed */
+    isExpired: () => boolean;
+}
+/**
+ * Creates a countdown timer to a target date
+ * @param targetDate - The date to count down to
+ * @param options - Countdown options and callbacks
+ * @returns A countdown instance with control methods
+ *
+ * @example
+ * ```ts
+ * const countdown = createCountdown(
+ *   new Date('2024-12-31T23:59:59'),
+ *   {
+ *     onTick: (remaining) => {
+ *       console.log(`${remaining.days}d ${remaining.hours}h ${remaining.minutes}m ${remaining.seconds}s`);
+ *     },
+ *     onComplete: () => {
+ *       console.log('Happy New Year!');
+ *     }
+ *   }
+ * );
+ *
+ * countdown.start();
+ * // Later...
+ * countdown.stop();
+ * ```
+ */
+export declare function createCountdown(targetDate: DateInput, options?: CountdownOptions): Countdown;
+/**
+ * Gets the remaining time until/since a target date
+ * @param targetDate - The target date
+ * @param fromDate - The date to calculate from (defaults to now)
+ * @returns Object with remaining time broken down by units
+ *
+ * @example
+ * ```ts
+ * const remaining = getRemainingTime(new Date('2024-12-31'));
+ * console.log(`${remaining.days} days, ${remaining.hours} hours remaining`);
+ *
+ * // Check if expired
+ * if (remaining.isExpired) {
+ *   console.log('Target date has passed');
+ * }
+ * ```
+ */
+export declare function getRemainingTime(targetDate: DateInput, fromDate?: DateInput): RemainingTime;
+/**
+ * Formats the remaining time as a human-readable string
+ * @param targetDate - The target date
+ * @param options - Formatting options
+ * @returns Formatted countdown string
+ *
+ * @example
+ * ```ts
+ * formatCountdown(new Date('2024-12-31'));
+ * // "45d 12h 30m 15s"
+ *
+ * formatCountdown(new Date('2024-12-31'), { units: ['days', 'hours'] });
+ * // "45 days, 12 hours"
+ *
+ * formatCountdown(new Date('2024-12-31'), { short: false });
+ * // "45 days 12 hours 30 minutes 15 seconds"
+ * ```
+ */
+export declare function formatCountdown(targetDate: DateInput, options?: {
+    /** Date to calculate from (defaults to now) */
+    from?: DateInput;
+    /** Units to include in output */
+    units?: ('weeks' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds')[];
+    /** Use short format (d, h, m, s) */
+    short?: boolean;
+    /** Maximum number of units to show */
+    maxUnits?: number;
+    /** Show zero values */
+    showZero?: boolean;
+    /** Separator between units */
+    separator?: string;
+}): string;
+/**
+ * Checks if a date has expired (is in the past)
+ * @param date - The date to check
+ * @param fromDate - The reference date (defaults to now)
+ * @returns True if the date is in the past
+ *
+ * @example
+ * ```ts
+ * isExpired(new Date('2020-01-01')); // true
+ * isExpired(new Date('2030-01-01')); // false
+ * ```
+ */
+export declare function isExpired(date: DateInput, fromDate?: DateInput): boolean;
+/**
+ * Calculates the progress percentage between two dates
+ * @param startDate - The start date
+ * @param endDate - The end date
+ * @param currentDate - The current date (defaults to now)
+ * @returns Progress percentage (0-100), clamped to range
+ *
+ * @example
+ * ```ts
+ * const progress = getProgressPercentage(
+ *   new Date('2024-01-01'),
+ *   new Date('2024-12-31'),
+ *   new Date('2024-07-01')
+ * );
+ * console.log(`${progress}% complete`); // ~50% complete
+ * ```
+ */
+export declare function getProgressPercentage(startDate: DateInput, endDate: DateInput, currentDate?: DateInput): number;
+/**
+ * Gets time until a target date in a specific unit
+ * @param targetDate - The target date
+ * @param unit - The unit to return
+ * @param fromDate - The date to calculate from (defaults to now)
+ * @returns Time remaining in the specified unit
+ *
+ * @example
+ * ```ts
+ * getTimeUntil(new Date('2024-12-31'), 'days'); // 45.5
+ * getTimeUntil(new Date('2024-12-31'), 'hours'); // 1092
+ * getTimeUntil(new Date('2024-12-31'), 'weeks'); // 6.5
+ * ```
+ */
+export declare function getTimeUntil(targetDate: DateInput, unit: 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks', fromDate?: DateInput): number;
+/**
+ * Creates a deadline object with useful methods
+ * @param targetDate - The deadline date
+ * @returns An object with deadline-related methods
+ *
+ * @example
+ * ```ts
+ * const deadline = createDeadline(new Date('2024-12-31'));
+ *
+ * deadline.isExpired(); // false
+ * deadline.daysRemaining(); // 45
+ * deadline.hoursRemaining(); // 1092
+ * deadline.formatRemaining(); // "45d 12h 30m"
+ * deadline.progressFrom(new Date('2024-01-01')); // 67.5%
+ * ```
+ */
+export declare function createDeadline(targetDate: DateInput): {
+    target: Date;
+    isExpired: () => boolean;
+    getRemaining: () => RemainingTime;
+    daysRemaining: () => number;
+    hoursRemaining: () => number;
+    minutesRemaining: () => number;
+    secondsRemaining: () => number;
+    formatRemaining: (options?: Parameters<typeof formatCountdown>[1]) => string;
+    progressFrom: (startDate: DateInput) => number;
+    countdown: (options?: CountdownOptions) => Countdown;
+};
+//# sourceMappingURL=countdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"countdown.d.ts","sourceRoot":"","sources":["../../src/countdown.ts"],"names":[],"mappings":"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"}