ts-time-utils 4.0.1 → 4.4.0

package/dist/esm/plugins.js

@@ -19,38 +19,20 @@
  * chain(new Date()).nextMonday().format('YYYY-MM-DD');
  * ```
  */
-// Import ChainedDate class directly - safe because chain.js doesn't import plugins.js
-// We need the actual class (not just the type) to modify its prototype
-let ChainedDateConstructor = null;
+import { ChainedDate } from './chain.js';
 /**
- * Get ChainedDate class lazily to ensure it's fully initialized
+ * Get ChainedDate class for prototype mutation.
+ * Importing `plugins` now brings in `chain` directly, so the class is available
+ * without a hidden global handshake.
  */
 function getChainedDate() {
-    if (!ChainedDateConstructor) {
-        // Use dynamic import that works in both CJS and ESM
-        try {
-            // Try ESM import path first
-            ChainedDateConstructor = globalThis.__chainedDateClass;
-            if (!ChainedDateConstructor) {
-                // Fallback: The class will be set by chain.js when it loads
-                throw new Error('ChainedDate not yet loaded. Import chain.js before using plugins.');
-            }
-        }
-        catch (e) {
-            throw new Error('ChainedDate class not available. Ensure chain.js is imported before registering plugins.');
-        }
+    if (!ChainedDate) {
+        throw new Error('ChainedDate export is not available yet. Import chain.js before registering plugins.');
     }
-    return ChainedDateConstructor;
-}
-/**
- * Initialize the plugin system with ChainedDate class
- * This is called automatically when chain.js is imported
- * @internal
- */
-export function __initPluginSystem(ChainedDateClass) {
-    ChainedDateConstructor = ChainedDateClass;
+    return ChainedDate;
 }
 const registry = {};
+const methodStates = {};
 /**
  * Extend ChainedDate with custom methods
  *
@@ -80,23 +62,23 @@ export function extend(pluginName, methods) {
     if (registry[pluginName]) {
         throw new Error(`Plugin "${pluginName}" is already registered. Use a different name or uninstall first.`);
     }
-    // Get ChainedDate class and save original methods before overwriting
     const ChainedDateClass = getChainedDate();
-    const originalMethods = new Map();
     Object.entries(methods).forEach(([methodName, fn]) => {
-        // Save original method if it exists
+        const current = ChainedDateClass.prototype[methodName];
+        if (!methodStates[methodName]) {
+            methodStates[methodName] = {
+                original: typeof current === 'function' ? current : undefined,
+                owners: []
+            };
+        }
         if (methodName in ChainedDateClass.prototype) {
-            const original = ChainedDateClass.prototype[methodName];
-            if (typeof original === 'function') {
-                originalMethods.set(methodName, original);
-            }
             console.warn(`Method "${methodName}" already exists on ChainedDate and will be overwritten`);
         }
+        methodStates[methodName].owners.push(pluginName);
         // Add the plugin method
         ChainedDateClass.prototype[methodName] = fn;
     });
-    // Register the plugin with its original methods
-    registry[pluginName] = { plugin: methods, originalMethods };
+    registry[pluginName] = { plugin: methods };
 }
 /**
  * Remove a plugin and its methods from ChainedDate
@@ -113,20 +95,32 @@ export function uninstall(pluginName) {
     if (!entry) {
         throw new Error(`Plugin "${pluginName}" is not registered`);
     }
-    // Get ChainedDate class and restore/remove methods
     const ChainedDateClass = getChainedDate();
     Object.keys(entry.plugin).forEach((methodName) => {
-        // If there was an original method, restore it
-        const original = entry.originalMethods.get(methodName);
-        if (original) {
-            ChainedDateClass.prototype[methodName] = original;
+        const state = methodStates[methodName];
+        if (!state) {
+            delete ChainedDateClass.prototype[methodName];
+            return;
+        }
+        state.owners = state.owners.filter((owner) => owner !== pluginName);
+        const nextOwner = state.owners[state.owners.length - 1];
+        if (nextOwner) {
+            const nextPlugin = registry[nextOwner];
+            if (nextPlugin && methodName in nextPlugin.plugin) {
+                ChainedDateClass.prototype[methodName] = nextPlugin.plugin[methodName];
+                return;
+            }
+            delete ChainedDateClass.prototype[methodName];
+            return;
+        }
+        if (state.original) {
+            ChainedDateClass.prototype[methodName] = state.original;
         }
         else {
-            // Otherwise, delete the method entirely
             delete ChainedDateClass.prototype[methodName];
         }
+        delete methodStates[methodName];
     });
-    // Remove from registry
     delete registry[pluginName];
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAqBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}
+{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAmBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}

package/dist/esm/recurrence.js

@@ -43,19 +43,17 @@ export function createRecurrence(rule) {
         isRecurrenceDate: (date) => isRecurrenceDate(date, rule),
         getAllOccurrences: (limit = 100) => {
             const occurrences = [];
-            let current = new Date(startDate);
-            let count = 0;
-            while (count < limit) {
+            let current = new Date(startDate.getTime() - 1);
+            while (occurrences.length < limit) {
                 if (rule.until && current > new Date(rule.until))
                     break;
-                if (rule.count && count >= rule.count)
+                if (rule.count && occurrences.length >= rule.count)
                     break;
                 const next = getNextOccurrence(rule, current);
                 if (!next)
                     break;
                 occurrences.push(next);
                 current = new Date(next.getTime() + 1);
-                count++;
             }
             return occurrences;
         }

package/dist/esm/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/esm/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"}

package/dist/esm/scheduling.js

@@ -0,0 +1,329 @@
+/**
+ * @fileoverview Scheduling and booking utilities
+ * Provides slot generation, availability checking, and conflict detection
+ */
+import { dateRangeOverlap, mergeDateRanges } from './dateRange.js';
+import { isWorkingDay, isWorkingTime, DEFAULT_WORKING_HOURS, getWorkDayStart, getWorkDayEnd } from './workingHours.js';
+import { getOccurrencesBetween } from './recurrence.js';
+/** Default scheduling configuration */
+export const DEFAULT_SCHEDULING_CONFIG = {
+    workingHours: DEFAULT_WORKING_HOURS,
+    bufferMinutes: 0,
+    slotDuration: 30,
+    holidays: []
+};
+/**
+ * Helper to convert DateInput to Date
+ */
+function toDate(input) {
+    if (input instanceof Date)
+        return new Date(input);
+    return new Date(input);
+}
+/**
+ * Check if a date is a holiday
+ */
+function isHoliday(date, holidays) {
+    const dateStr = date.toISOString().split('T')[0];
+    return holidays.some(h => h.toISOString().split('T')[0] === dateStr);
+}
+/**
+ * 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 function generateSlots(date, config = {}) {
+    const d = toDate(date);
+    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config };
+    const workingHours = cfg.workingHours ?? DEFAULT_WORKING_HOURS;
+    // Check if it's a working day and not a holiday
+    if (!isWorkingDay(d, workingHours))
+        return [];
+    if (cfg.holidays && isHoliday(d, cfg.holidays))
+        return [];
+    const slots = [];
+    const slotDuration = cfg.slotDuration ?? 30;
+    const dayStart = getWorkDayStart(d, workingHours);
+    const dayEnd = getWorkDayEnd(d, workingHours);
+    let current = new Date(dayStart);
+    while (current < dayEnd) {
+        const slotEnd = new Date(current.getTime() + slotDuration * 60 * 1000);
+        // Don't create slots that extend past working hours
+        if (slotEnd <= dayEnd) {
+            // Check if slot is during working time (not during breaks)
+            const midpoint = new Date(current.getTime() + (slotDuration * 60 * 1000) / 2);
+            const available = isWorkingTime(midpoint, workingHours);
+            slots.push({
+                start: new Date(current),
+                end: new Date(slotEnd),
+                available
+            });
+        }
+        current = slotEnd;
+    }
+    return slots;
+}
+/**
+ * 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 function generateSlotsForRange(range, config = {}) {
+    const slots = [];
+    const current = new Date(range.start);
+    current.setHours(0, 0, 0, 0);
+    const endDate = new Date(range.end);
+    endDate.setHours(23, 59, 59, 999);
+    while (current <= endDate) {
+        const daySlots = generateSlots(current, config);
+        slots.push(...daySlots);
+        current.setDate(current.getDate() + 1);
+    }
+    return slots;
+}
+/**
+ * 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 function getAvailableSlots(date, bookings, config = {}) {
+    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config };
+    const slots = generateSlots(date, cfg);
+    const bufferMs = (cfg.bufferMinutes ?? 0) * 60 * 1000;
+    return slots.map(slot => {
+        // Expand slot by buffer for conflict checking
+        const checkRange = {
+            start: new Date(slot.start.getTime() - bufferMs),
+            end: new Date(slot.end.getTime() + bufferMs)
+        };
+        const hasConflict = bookings.some(booking => dateRangeOverlap(checkRange, booking));
+        return {
+            ...slot,
+            available: slot.available && !hasConflict
+        };
+    });
+}
+/**
+ * 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 function findNextAvailable(after, bookings, duration, config = {}) {
+    const startDate = toDate(after);
+    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config, slotDuration: duration };
+    // Search up to 30 days ahead
+    for (let dayOffset = 0; dayOffset < 30; dayOffset++) {
+        const checkDate = new Date(startDate);
+        checkDate.setDate(checkDate.getDate() + dayOffset);
+        const availableSlots = getAvailableSlots(checkDate, bookings, cfg);
+        for (const slot of availableSlots) {
+            if (slot.available && slot.start >= startDate) {
+                return slot;
+            }
+        }
+    }
+    return 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 function isSlotAvailable(slot, bookings) {
+    return !bookings.some(booking => dateRangeOverlap(slot, booking));
+}
+/**
+ * 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 function findConflicts(bookings, proposed) {
+    return bookings.filter(booking => dateRangeOverlap(booking, proposed));
+}
+/**
+ * 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 function hasConflict(bookings, proposed) {
+    return bookings.some(booking => dateRangeOverlap(booking, proposed));
+}
+/**
+ * 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 function addBuffer(slot, bufferMinutes) {
+    const bufferMs = bufferMinutes * 60 * 1000;
+    return {
+        start: new Date(slot.start.getTime() - bufferMs),
+        end: new Date(slot.end.getTime() + bufferMs)
+    };
+}
+/**
+ * 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 function removeBuffer(slot, bufferMinutes) {
+    const bufferMs = bufferMinutes * 60 * 1000;
+    return {
+        start: new Date(slot.start.getTime() + bufferMs),
+        end: new Date(slot.end.getTime() - bufferMs)
+    };
+}
+/**
+ * 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 function expandRecurringAvailability(pattern, range, config = {}) {
+    const occurrences = getOccurrencesBetween(pattern, range.start, range.end);
+    const slots = [];
+    for (const occurrence of occurrences) {
+        const daySlots = generateSlots(occurrence, config);
+        slots.push(...daySlots);
+    }
+    return slots;
+}
+/**
+ * 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 function mergeBookings(bookings) {
+    if (bookings.length === 0)
+        return [];
+    const ranges = mergeDateRanges(bookings);
+    return ranges.map(range => ({
+        start: range.start,
+        end: range.end
+    }));
+}
+/**
+ * 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 function splitSlot(slot, at) {
+    const splitTime = toDate(at);
+    if (splitTime <= slot.start || splitTime >= slot.end) {
+        return null;
+    }
+    return [
+        {
+            start: new Date(slot.start),
+            end: new Date(splitTime),
+            available: slot.available
+        },
+        {
+            start: new Date(splitTime),
+            end: new Date(slot.end),
+            available: slot.available
+        }
+    ];
+}