ts-time-utils 3.0.4 → 4.1.0

package/dist/precision.js

@@ -0,0 +1,491 @@
+/**
+ * @fileoverview High-precision time utilities
+ * Handles nanoseconds, BigInt timestamps, sub-millisecond operations
+ */
+/**
+ * Create a nanosecond timestamp from components
+ */
+export function createNanosecondTimestamp(milliseconds, nanoseconds = 0) {
+    // Normalize: ensure nanoseconds is 0-999999
+    const extraMs = Math.floor(nanoseconds / 1000000);
+    const normalizedNs = nanoseconds % 1000000;
+    const totalMs = milliseconds + extraMs;
+    const totalNanoseconds = BigInt(totalMs) * BigInt(1000000) + BigInt(normalizedNs);
+    return {
+        milliseconds: totalMs,
+        nanoseconds: normalizedNs,
+        totalNanoseconds,
+    };
+}
+/**
+ * Create a nanosecond timestamp from BigInt
+ */
+export function fromNanoseconds(totalNs) {
+    const ms = Number(totalNs / BigInt(1000000));
+    const ns = Number(totalNs % BigInt(1000000));
+    return {
+        milliseconds: ms,
+        nanoseconds: ns,
+        totalNanoseconds: totalNs,
+    };
+}
+/**
+ * Create a nanosecond timestamp from a Date
+ */
+export function dateToNanoseconds(date) {
+    return createNanosecondTimestamp(date.getTime(), 0);
+}
+/**
+ * Convert nanosecond timestamp to Date (loses sub-millisecond precision)
+ */
+export function nanosecondsToDate(timestamp) {
+    return new Date(timestamp.milliseconds);
+}
+/**
+ * Add two nanosecond timestamps
+ */
+export function addNanoseconds(a, b) {
+    return fromNanoseconds(a.totalNanoseconds + b.totalNanoseconds);
+}
+/**
+ * Subtract nanosecond timestamps
+ */
+export function subtractNanoseconds(a, b) {
+    return fromNanoseconds(a.totalNanoseconds - b.totalNanoseconds);
+}
+/**
+ * Compare nanosecond timestamps
+ * @returns -1 if a < b, 0 if equal, 1 if a > b
+ */
+export function compareNanoseconds(a, b) {
+    if (a.totalNanoseconds < b.totalNanoseconds)
+        return -1;
+    if (a.totalNanoseconds > b.totalNanoseconds)
+        return 1;
+    return 0;
+}
+/**
+ * Get current time with nanosecond precision (if available)
+ * Falls back to millisecond precision if performance.now() not available
+ */
+export function nowNanoseconds() {
+    const now = Date.now();
+    // Try to get sub-millisecond precision from performance.now()
+    if (typeof performance !== 'undefined' && performance.now) {
+        const perfNow = performance.now();
+        const microSeconds = Math.round((perfNow % 1) * 1000);
+        return createNanosecondTimestamp(now, microSeconds * 1000);
+    }
+    return createNanosecondTimestamp(now, 0);
+}
+/**
+ * Format nanosecond timestamp to ISO string with sub-millisecond precision
+ */
+export function formatNanoseconds(timestamp) {
+    const date = nanosecondsToDate(timestamp);
+    const isoBase = date.toISOString().slice(0, -1); // Remove trailing 'Z'
+    // Add nanoseconds (6 additional digits after milliseconds)
+    const nsStr = timestamp.nanoseconds.toString().padStart(6, '0');
+    return `${isoBase}${nsStr}Z`;
+}
+/**
+ * Parse ISO string with nanosecond precision
+ */
+export function parseNanoseconds(isoString) {
+    // Match ISO format: 2024-03-25T14:30:45.123456789Z
+    const match = isoString.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3,9})Z?$/);
+    if (!match) {
+        // Try standard parsing
+        const date = new Date(isoString);
+        if (isNaN(date.getTime()))
+            return null;
+        return dateToNanoseconds(date);
+    }
+    const [, year, month, day, hour, minute, second, fraction] = match;
+    // Build base date with milliseconds
+    const ms = parseInt(fraction.slice(0, 3).padEnd(3, '0'), 10);
+    const date = new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10), parseInt(hour, 10), parseInt(minute, 10), parseInt(second, 10), ms);
+    // Calculate nanoseconds beyond milliseconds
+    const nsFraction = fraction.slice(3).padEnd(6, '0');
+    const nanoseconds = parseInt(nsFraction, 10);
+    return createNanosecondTimestamp(date.getTime(), nanoseconds);
+}
+// ============= High-Resolution Duration =============
+/**
+ * Create a high-resolution duration
+ */
+export function createHighResDuration(seconds, nanoseconds = 0) {
+    // Normalize: carry over extra seconds from nanoseconds
+    const extraSeconds = Math.floor(nanoseconds / 1000000000);
+    const normalizedNs = nanoseconds % 1000000000;
+    return {
+        seconds: seconds + extraSeconds,
+        nanoseconds: normalizedNs,
+    };
+}
+/**
+ * Add two high-resolution durations
+ */
+export function addHighResDuration(a, b) {
+    const totalNs = a.nanoseconds + b.nanoseconds;
+    const extraSeconds = Math.floor(totalNs / 1000000000);
+    const ns = totalNs % 1000000000;
+    return {
+        seconds: a.seconds + b.seconds + extraSeconds,
+        nanoseconds: ns,
+    };
+}
+/**
+ * Subtract high-resolution durations
+ */
+export function subtractHighResDuration(a, b) {
+    let totalNs = a.nanoseconds - b.nanoseconds;
+    let seconds = a.seconds - b.seconds;
+    if (totalNs < 0) {
+        seconds -= 1;
+        totalNs += 1000000000;
+    }
+    return { seconds, nanoseconds: totalNs };
+}
+/**
+ * Convert high-resolution duration to milliseconds
+ */
+export function highResDurationToMs(duration) {
+    return duration.seconds * 1000 + duration.nanoseconds / 1000000;
+}
+/**
+ * Convert milliseconds to high-resolution duration
+ */
+export function msToHighResDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const nanoseconds = Math.round((ms % 1000) * 1000000);
+    return { seconds, nanoseconds };
+}
+// ============= BigInt Timestamp Support =============
+/**
+ * Convert Unix epoch milliseconds to BigInt
+ */
+export function toBigIntMs(date) {
+    return BigInt(date.getTime());
+}
+/**
+ * Convert BigInt milliseconds to Date
+ */
+export function fromBigIntMs(ms) {
+    return new Date(Number(ms));
+}
+/**
+ * Convert Unix epoch seconds to BigInt
+ */
+export function toBigIntSeconds(date) {
+    return BigInt(Math.floor(date.getTime() / 1000));
+}
+/**
+ * Convert BigInt seconds to Date
+ */
+export function fromBigIntSeconds(seconds) {
+    return new Date(Number(seconds) * 1000);
+}
+/**
+ * Add milliseconds (as BigInt) to a date
+ */
+export function addBigIntMs(date, ms) {
+    const current = toBigIntMs(date);
+    return fromBigIntMs(current + ms);
+}
+/**
+ * Subtract milliseconds (as BigInt) from a date
+ */
+export function subtractBigIntMs(date, ms) {
+    const current = toBigIntMs(date);
+    return fromBigIntMs(current - ms);
+}
+/**
+ * Calculate difference between dates in BigInt milliseconds
+ */
+export function diffBigIntMs(a, b) {
+    return toBigIntMs(a) - toBigIntMs(b);
+}
+/**
+ * Check if a date falls in a DST transition gap (skipped time)
+ * @param date - Date to check
+ * @param timeZone - IANA timezone (optional, uses local if not provided)
+ */
+export function isInDSTGap(date, timeZone) {
+    if (timeZone) {
+        // For specific timezone, we need to check around this time
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hour: 'numeric',
+            minute: 'numeric',
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour12: false,
+        });
+        // Get 1 minute before and after
+        const before = new Date(date.getTime() - 60000);
+        const after = new Date(date.getTime() + 60000);
+        const beforeParts = formatter.formatToParts(before);
+        const afterParts = formatter.formatToParts(after);
+        const getMinuteValue = (parts) => {
+            const h = parseInt(parts.find(p => p.type === 'hour')?.value || '0', 10);
+            const m = parseInt(parts.find(p => p.type === 'minute')?.value || '0', 10);
+            return h * 60 + m;
+        };
+        // If there's a jump of more than 2 minutes between 1 min before and 1 min after,
+        // we're likely in a gap
+        const beforeMinute = getMinuteValue(beforeParts);
+        const afterMinute = getMinuteValue(afterParts);
+        const diff = afterMinute - beforeMinute;
+        // Account for day boundary
+        const adjustedDiff = diff < 0 ? diff + 1440 : diff;
+        return adjustedDiff > 62; // Allow 2 minute variance + DST gap (typically 60 min)
+    }
+    // For local timezone, compare UTC offset around this time
+    const before = new Date(date.getTime() - 60000);
+    const after = new Date(date.getTime() + 60000);
+    const offsetBefore = before.getTimezoneOffset();
+    const offsetAfter = after.getTimezoneOffset();
+    // If offset changes and goes from larger to smaller (spring forward), it's a gap
+    return offsetBefore > offsetAfter;
+}
+/**
+ * Check if a date falls in a DST overlap (ambiguous time)
+ * @param date - Date to check
+ * @param timeZone - IANA timezone (optional, uses local if not provided)
+ */
+export function isInDSTOverlap(date, timeZone) {
+    if (timeZone) {
+        // Similar approach as isInDSTGap but for fall-back
+        // This is harder to detect accurately without full TZ database
+        return false; // Simplified: would need TZ data for accurate detection
+    }
+    // For local timezone
+    const before = new Date(date.getTime() - 60000);
+    const after = new Date(date.getTime() + 60000);
+    const offsetBefore = before.getTimezoneOffset();
+    const offsetAfter = after.getTimezoneOffset();
+    // If offset goes from smaller to larger (fall back), it's an overlap
+    return offsetBefore < offsetAfter;
+}
+/**
+ * Find DST transitions in a year for local timezone
+ */
+export function getDSTTransitionsInYear(year) {
+    const transitions = [];
+    let prevOffset = new Date(year, 0, 1).getTimezoneOffset();
+    // Check each day of the year
+    for (let month = 0; month < 12; month++) {
+        const daysInMonth = new Date(year, month + 1, 0).getDate();
+        for (let day = 1; day <= daysInMonth; day++) {
+            const date = new Date(year, month, day);
+            const currentOffset = date.getTimezoneOffset();
+            if (currentOffset !== prevOffset) {
+                // Found a transition - now find exact hour
+                for (let hour = 0; hour < 24; hour++) {
+                    const hourDate = new Date(year, month, day, hour);
+                    const hourOffset = hourDate.getTimezoneOffset();
+                    if (hourOffset !== prevOffset) {
+                        const toDST = hourOffset < prevOffset;
+                        const adjustmentMinutes = Math.abs(hourOffset - prevOffset);
+                        transitions.push({
+                            utc: new Date(Date.UTC(year, month, day, hour)),
+                            local: hourDate,
+                            toDST,
+                            offsetBefore: -prevOffset, // Convert to positive = UTC+X
+                            offsetAfter: -hourOffset,
+                            adjustmentMinutes,
+                        });
+                        prevOffset = hourOffset;
+                        break;
+                    }
+                }
+            }
+            prevOffset = currentOffset;
+        }
+    }
+    return transitions;
+}
+/**
+ * Resolve ambiguous time in DST overlap
+ * @param date - Potentially ambiguous date
+ * @param prefer - Prefer 'earlier' or 'later' interpretation
+ */
+export function resolveAmbiguousTime(date, prefer = 'earlier') {
+    if (!isInDSTOverlap(date)) {
+        return date;
+    }
+    // During overlap, the same local time occurs twice
+    // The 'earlier' occurrence is DST (smaller offset)
+    // The 'later' occurrence is standard time (larger offset)
+    const offset = date.getTimezoneOffset();
+    if (prefer === 'earlier') {
+        // Return DST interpretation (typically 1 hour earlier in UTC)
+        return new Date(date.getTime() - 60 * 60 * 1000);
+    }
+    else {
+        // Return standard time interpretation
+        return date;
+    }
+}
+// ============= Invalid Date Handling =============
+/**
+ * Validated Date wrapper that guarantees a valid date
+ */
+export class ValidDate {
+    constructor(date) {
+        this._date = date;
+    }
+    /**
+     * Create a ValidDate, throws if invalid
+     */
+    static from(date) {
+        if (isNaN(date.getTime())) {
+            throw new Error('Invalid Date');
+        }
+        return new ValidDate(date);
+    }
+    /**
+     * Create a ValidDate, returns null if invalid
+     */
+    static tryFrom(date) {
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+        return new ValidDate(date);
+    }
+    /**
+     * Create from timestamp, throws if invalid
+     */
+    static fromTimestamp(ms) {
+        const date = new Date(ms);
+        return ValidDate.from(date);
+    }
+    /**
+     * Create from ISO string, throws if invalid
+     */
+    static fromISO(isoString) {
+        const date = new Date(isoString);
+        return ValidDate.from(date);
+    }
+    /**
+     * Get the underlying Date object
+     */
+    get value() {
+        return new Date(this._date.getTime()); // Return copy for immutability
+    }
+    /**
+     * Get timestamp
+     */
+    get time() {
+        return this._date.getTime();
+    }
+    /**
+     * Format to ISO string
+     */
+    toISOString() {
+        return this._date.toISOString();
+    }
+    /**
+     * Format to locale string
+     */
+    toLocaleString(locale, options) {
+        return this._date.toLocaleString(locale, options);
+    }
+}
+/**
+ * Ensure a date is valid, with fallback
+ */
+export function ensureValidDate(date, fallback = new Date()) {
+    return isNaN(date.getTime()) ? fallback : date;
+}
+/**
+ * Parse date with validation
+ */
+export function parseValidDate(input) {
+    if (input instanceof Date) {
+        return isNaN(input.getTime()) ? null : input;
+    }
+    const date = new Date(input);
+    return isNaN(date.getTime()) ? null : date;
+}
+/**
+ * Assert date is valid, throws if not
+ */
+export function assertValidDate(date, message) {
+    if (isNaN(date.getTime())) {
+        throw new Error(message || 'Invalid Date');
+    }
+}
+// ============= Leap Second Awareness =============
+/**
+ * Known leap seconds (added at end of these dates, 23:59:60 UTC)
+ * List from https://www.ietf.org/timezones/data/leap-seconds.list
+ */
+export const LEAP_SECONDS = [
+    new Date('1972-06-30T23:59:59Z'),
+    new Date('1972-12-31T23:59:59Z'),
+    new Date('1973-12-31T23:59:59Z'),
+    new Date('1974-12-31T23:59:59Z'),
+    new Date('1975-12-31T23:59:59Z'),
+    new Date('1976-12-31T23:59:59Z'),
+    new Date('1977-12-31T23:59:59Z'),
+    new Date('1978-12-31T23:59:59Z'),
+    new Date('1979-12-31T23:59:59Z'),
+    new Date('1981-06-30T23:59:59Z'),
+    new Date('1982-06-30T23:59:59Z'),
+    new Date('1983-06-30T23:59:59Z'),
+    new Date('1985-06-30T23:59:59Z'),
+    new Date('1987-12-31T23:59:59Z'),
+    new Date('1989-12-31T23:59:59Z'),
+    new Date('1990-12-31T23:59:59Z'),
+    new Date('1992-06-30T23:59:59Z'),
+    new Date('1993-06-30T23:59:59Z'),
+    new Date('1994-06-30T23:59:59Z'),
+    new Date('1995-12-31T23:59:59Z'),
+    new Date('1997-06-30T23:59:59Z'),
+    new Date('1998-12-31T23:59:59Z'),
+    new Date('2005-12-31T23:59:59Z'),
+    new Date('2008-12-31T23:59:59Z'),
+    new Date('2012-06-30T23:59:59Z'),
+    new Date('2015-06-30T23:59:59Z'),
+    new Date('2016-12-31T23:59:59Z'),
+];
+/**
+ * Get number of leap seconds between two dates
+ */
+export function leapSecondsBetween(start, end) {
+    let count = 0;
+    for (const ls of LEAP_SECONDS) {
+        if (ls >= start && ls < end) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Check if a date is near a leap second (within 1 second)
+ */
+export function isNearLeapSecond(date) {
+    const time = date.getTime();
+    return LEAP_SECONDS.some(ls => Math.abs(ls.getTime() - time) <= 1000);
+}
+/**
+ * Convert TAI (International Atomic Time) to UTC
+ * TAI = UTC + accumulated leap seconds + 10 (initial offset)
+ */
+export function taiToUtc(taiMs) {
+    // Count leap seconds before this TAI time
+    const utcApprox = new Date(taiMs);
+    const leapSeconds = leapSecondsBetween(new Date(0), utcApprox);
+    // TAI started 10 seconds ahead of UTC at Unix epoch
+    return new Date(taiMs - (leapSeconds + 10) * 1000);
+}
+/**
+ * Convert UTC to TAI
+ */
+export function utcToTai(date) {
+    const leapSeconds = leapSecondsBetween(new Date(0), date);
+    return date.getTime() + (leapSeconds + 10) * 1000;
+}

package/dist/scheduling.d.ts

@@ -0,0 +1,206 @@
+/**
+ * @fileoverview Scheduling and booking utilities
+ * Provides slot generation, availability checking, and conflict detection
+ */
+import type { DateRange, DateInput, WorkingHoursConfig, RecurrenceRule } from './types.js';
+/** Configuration for scheduling operations */
+export interface SchedulingConfig {
+    /** Working hours configuration */
+    workingHours?: WorkingHoursConfig;
+    /** Buffer time between appointments in minutes */
+    bufferMinutes?: number;
+    /** Default slot duration in minutes */
+    slotDuration?: number;
+    /** Holidays to exclude */
+    holidays?: Date[];
+}
+/** A time slot with availability status */
+export interface Slot {
+    start: Date;
+    end: Date;
+    available: boolean;
+}
+/** A booking with optional metadata */
+export interface Booking extends DateRange {
+    id?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Default scheduling configuration */
+export declare const DEFAULT_SCHEDULING_CONFIG: SchedulingConfig;
+/**
+ * Generates time slots for a single day
+ * @param date - The date to generate slots for
+ * @param config - Scheduling configuration
+ * @returns Array of slots for the day
+ *
+ * @example
+ * ```ts
+ * const slots = generateSlots(new Date('2024-01-15'), { slotDuration: 30 });
+ * // Returns 30-minute slots during working hours
+ * ```
+ */
+export declare function generateSlots(date: DateInput, config?: SchedulingConfig): Slot[];
+/**
+ * Generates time slots for a date range
+ * @param range - The date range to generate slots for
+ * @param config - Scheduling configuration
+ * @returns Array of slots for all days in range
+ *
+ * @example
+ * ```ts
+ * const range = { start: new Date('2024-01-15'), end: new Date('2024-01-17') };
+ * const slots = generateSlotsForRange(range, { slotDuration: 60 });
+ * ```
+ */
+export declare function generateSlotsForRange(range: DateRange, config?: SchedulingConfig): Slot[];
+/**
+ * Gets available slots for a day, excluding existing bookings
+ * @param date - The date to check
+ * @param bookings - Existing bookings
+ * @param config - Scheduling configuration
+ * @returns Array of available slots
+ *
+ * @example
+ * ```ts
+ * const bookings = [{ start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') }];
+ * const available = getAvailableSlots(new Date('2024-01-15'), bookings);
+ * ```
+ */
+export declare function getAvailableSlots(date: DateInput, bookings: Booking[], config?: SchedulingConfig): Slot[];
+/**
+ * Finds the next available slot of specified duration
+ * @param after - Start searching after this date
+ * @param bookings - Existing bookings
+ * @param duration - Required slot duration in minutes
+ * @param config - Scheduling configuration
+ * @returns Next available slot or null if none found within 30 days
+ *
+ * @example
+ * ```ts
+ * const nextSlot = findNextAvailable(new Date(), bookings, 60);
+ * if (nextSlot) console.log(`Next 1-hour slot at ${nextSlot.start}`);
+ * ```
+ */
+export declare function findNextAvailable(after: DateInput, bookings: Booking[], duration: number, config?: SchedulingConfig): Slot | null;
+/**
+ * Checks if a slot is available (no conflicts with existing bookings)
+ * @param slot - The slot to check
+ * @param bookings - Existing bookings
+ * @returns True if slot is available
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T14:00'), end: new Date('2024-01-15T15:00') };
+ * if (isSlotAvailable(slot, existingBookings)) {
+ *   // Book the slot
+ * }
+ * ```
+ */
+export declare function isSlotAvailable(slot: DateRange, bookings: Booking[]): boolean;
+/**
+ * Finds bookings that conflict with a proposed time range
+ * @param bookings - Existing bookings
+ * @param proposed - Proposed time range
+ * @returns Array of conflicting bookings
+ *
+ * @example
+ * ```ts
+ * const conflicts = findConflicts(existingBookings, { start: propStart, end: propEnd });
+ * if (conflicts.length > 0) {
+ *   console.log('Conflicts with:', conflicts);
+ * }
+ * ```
+ */
+export declare function findConflicts(bookings: Booking[], proposed: DateRange): Booking[];
+/**
+ * Checks if a proposed time range has any conflicts
+ * @param bookings - Existing bookings
+ * @param proposed - Proposed time range
+ * @returns True if there are conflicts
+ *
+ * @example
+ * ```ts
+ * if (hasConflict(existingBookings, proposedMeeting)) {
+ *   console.log('Time slot not available');
+ * }
+ * ```
+ */
+export declare function hasConflict(bookings: Booking[], proposed: DateRange): boolean;
+/**
+ * Adds buffer time around a slot
+ * @param slot - The original slot
+ * @param bufferMinutes - Buffer time in minutes
+ * @returns New slot with buffer added
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') };
+ * const buffered = addBuffer(slot, 15);
+ * // buffered.start = 09:45, buffered.end = 11:15
+ * ```
+ */
+export declare function addBuffer(slot: DateRange, bufferMinutes: number): DateRange;
+/**
+ * Removes buffer time from a slot
+ * @param slot - The buffered slot
+ * @param bufferMinutes - Buffer time in minutes to remove
+ * @returns New slot with buffer removed
+ *
+ * @example
+ * ```ts
+ * const bufferedSlot = { start: new Date('2024-01-15T09:45'), end: new Date('2024-01-15T11:15') };
+ * const original = removeBuffer(bufferedSlot, 15);
+ * // original.start = 10:00, original.end = 11:00
+ * ```
+ */
+export declare function removeBuffer(slot: DateRange, bufferMinutes: number): DateRange;
+/**
+ * Expands recurring availability pattern into concrete slots
+ * @param pattern - Recurrence pattern
+ * @param range - Date range to expand within
+ * @param config - Scheduling configuration
+ * @returns Array of slots from the recurring pattern
+ *
+ * @example
+ * ```ts
+ * const pattern = {
+ *   frequency: 'weekly',
+ *   startDate: new Date('2024-01-01'),
+ *   byWeekday: [1, 3, 5], // Mon, Wed, Fri
+ *   until: new Date('2024-12-31')
+ * };
+ * const slots = expandRecurringAvailability(pattern, range);
+ * ```
+ */
+export declare function expandRecurringAvailability(pattern: RecurrenceRule, range: DateRange, config?: SchedulingConfig): Slot[];
+/**
+ * Merges adjacent or overlapping bookings
+ * @param bookings - Array of bookings to merge
+ * @returns Array of merged bookings
+ *
+ * @example
+ * ```ts
+ * const bookings = [
+ *   { start: new Date('2024-01-15T09:00'), end: new Date('2024-01-15T10:00') },
+ *   { start: new Date('2024-01-15T10:00'), end: new Date('2024-01-15T11:00') }
+ * ];
+ * const merged = mergeBookings(bookings);
+ * // [{ start: 09:00, end: 11:00 }]
+ * ```
+ */
+export declare function mergeBookings(bookings: Booking[]): Booking[];
+/**
+ * Splits a slot at a specific time
+ * @param slot - The slot to split
+ * @param at - The time to split at
+ * @returns Tuple of two slots, or null if split point is outside slot
+ *
+ * @example
+ * ```ts
+ * const slot = { start: new Date('2024-01-15T09:00'), end: new Date('2024-01-15T11:00'), available: true };
+ * const [before, after] = splitSlot(slot, new Date('2024-01-15T10:00'));
+ * // before: 09:00-10:00, after: 10:00-11:00
+ * ```
+ */
+export declare function splitSlot(slot: Slot, at: DateInput): [Slot, Slot] | null;
+//# sourceMappingURL=scheduling.d.ts.map

package/dist/scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../src/scheduling.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAK3F,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC;CACnB;AAED,2CAA2C;AAC3C,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,IAAI,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,uCAAuC;AACvC,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,uCAAuC;AACvC,eAAO,MAAM,yBAAyB,EAAE,gBAKvC,CAAC;AAkBF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,GAAE,gBAAqB,GAAG,IAAI,EAAE,CAqCpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,GAAE,gBAAqB,GAAG,IAAI,EAAE,CAe7F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,OAAO,EAAE,EACnB,MAAM,GAAE,gBAAqB,GAC5B,IAAI,EAAE,CAmBR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,gBAAqB,GAC5B,IAAI,GAAG,IAAI,CAmBb;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAE7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,SAAS,GAAG,OAAO,EAAE,CAEjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,SAAS,GAAG,OAAO,CAE7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,SAAS,CAM3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,SAAS,CAM9E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,SAAS,EAChB,MAAM,GAAE,gBAAqB,GAC5B,IAAI,EAAE,CAUR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAS5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,IAAI,CAmBxE"}