ts-time-utils 4.1.0 → 4.4.0

package/dist/{scheduling.js → scheduling.cjs}

@@ -1,13 +1,28 @@
+"use strict";
 /**
  * @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';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SCHEDULING_CONFIG = void 0;
+exports.generateSlots = generateSlots;
+exports.generateSlotsForRange = generateSlotsForRange;
+exports.getAvailableSlots = getAvailableSlots;
+exports.findNextAvailable = findNextAvailable;
+exports.isSlotAvailable = isSlotAvailable;
+exports.findConflicts = findConflicts;
+exports.hasConflict = hasConflict;
+exports.addBuffer = addBuffer;
+exports.removeBuffer = removeBuffer;
+exports.expandRecurringAvailability = expandRecurringAvailability;
+exports.mergeBookings = mergeBookings;
+exports.splitSlot = splitSlot;
+const dateRange_js_1 = require("./dateRange.cjs");
+const workingHours_js_1 = require("./workingHours.cjs");
+const recurrence_js_1 = require("./recurrence.cjs");
 /** Default scheduling configuration */
-export const DEFAULT_SCHEDULING_CONFIG = {
-    workingHours: DEFAULT_WORKING_HOURS,
+exports.DEFAULT_SCHEDULING_CONFIG = {
+    workingHours: workingHours_js_1.DEFAULT_WORKING_HOURS,
     bufferMinutes: 0,
     slotDuration: 30,
     holidays: []
@@ -39,19 +54,19 @@ function isHoliday(date, holidays) {
  * // Returns 30-minute slots during working hours
  * ```
  */
-export function generateSlots(date, config = {}) {
+function generateSlots(date, config = {}) {
     const d = toDate(date);
-    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config };
-    const workingHours = cfg.workingHours ?? DEFAULT_WORKING_HOURS;
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config };
+    const workingHours = cfg.workingHours ?? workingHours_js_1.DEFAULT_WORKING_HOURS;
     // Check if it's a working day and not a holiday
-    if (!isWorkingDay(d, workingHours))
+    if (!(0, workingHours_js_1.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);
+    const dayStart = (0, workingHours_js_1.getWorkDayStart)(d, workingHours);
+    const dayEnd = (0, workingHours_js_1.getWorkDayEnd)(d, workingHours);
     let current = new Date(dayStart);
     while (current < dayEnd) {
         const slotEnd = new Date(current.getTime() + slotDuration * 60 * 1000);
@@ -59,7 +74,7 @@ export function generateSlots(date, config = {}) {
         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);
+            const available = (0, workingHours_js_1.isWorkingTime)(midpoint, workingHours);
             slots.push({
                 start: new Date(current),
                 end: new Date(slotEnd),
@@ -82,7 +97,7 @@ export function generateSlots(date, config = {}) {
  * const slots = generateSlotsForRange(range, { slotDuration: 60 });
  * ```
  */
-export function generateSlotsForRange(range, config = {}) {
+function generateSlotsForRange(range, config = {}) {
     const slots = [];
     const current = new Date(range.start);
     current.setHours(0, 0, 0, 0);
@@ -108,8 +123,8 @@ export function generateSlotsForRange(range, config = {}) {
  * const available = getAvailableSlots(new Date('2024-01-15'), bookings);
  * ```
  */
-export function getAvailableSlots(date, bookings, config = {}) {
-    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config };
+function getAvailableSlots(date, bookings, config = {}) {
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config };
     const slots = generateSlots(date, cfg);
     const bufferMs = (cfg.bufferMinutes ?? 0) * 60 * 1000;
     return slots.map(slot => {
@@ -118,7 +133,7 @@ export function getAvailableSlots(date, bookings, config = {}) {
             start: new Date(slot.start.getTime() - bufferMs),
             end: new Date(slot.end.getTime() + bufferMs)
         };
-        const hasConflict = bookings.some(booking => dateRangeOverlap(checkRange, booking));
+        const hasConflict = bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(checkRange, booking));
         return {
             ...slot,
             available: slot.available && !hasConflict
@@ -139,9 +154,9 @@ export function getAvailableSlots(date, bookings, config = {}) {
  * if (nextSlot) console.log(`Next 1-hour slot at ${nextSlot.start}`);
  * ```
  */
-export function findNextAvailable(after, bookings, duration, config = {}) {
+function findNextAvailable(after, bookings, duration, config = {}) {
     const startDate = toDate(after);
-    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config, slotDuration: duration };
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config, slotDuration: duration };
     // Search up to 30 days ahead
     for (let dayOffset = 0; dayOffset < 30; dayOffset++) {
         const checkDate = new Date(startDate);
@@ -169,8 +184,8 @@ export function findNextAvailable(after, bookings, duration, config = {}) {
  * }
  * ```
  */
-export function isSlotAvailable(slot, bookings) {
-    return !bookings.some(booking => dateRangeOverlap(slot, booking));
+function isSlotAvailable(slot, bookings) {
+    return !bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(slot, booking));
 }
 /**
  * Finds bookings that conflict with a proposed time range
@@ -186,8 +201,8 @@ export function isSlotAvailable(slot, bookings) {
  * }
  * ```
  */
-export function findConflicts(bookings, proposed) {
-    return bookings.filter(booking => dateRangeOverlap(booking, proposed));
+function findConflicts(bookings, proposed) {
+    return bookings.filter(booking => (0, dateRange_js_1.dateRangeOverlap)(booking, proposed));
 }
 /**
  * Checks if a proposed time range has any conflicts
@@ -202,8 +217,8 @@ export function findConflicts(bookings, proposed) {
  * }
  * ```
  */
-export function hasConflict(bookings, proposed) {
-    return bookings.some(booking => dateRangeOverlap(booking, proposed));
+function hasConflict(bookings, proposed) {
+    return bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(booking, proposed));
 }
 /**
  * Adds buffer time around a slot
@@ -218,7 +233,7 @@ export function hasConflict(bookings, proposed) {
  * // buffered.start = 09:45, buffered.end = 11:15
  * ```
  */
-export function addBuffer(slot, bufferMinutes) {
+function addBuffer(slot, bufferMinutes) {
     const bufferMs = bufferMinutes * 60 * 1000;
     return {
         start: new Date(slot.start.getTime() - bufferMs),
@@ -238,7 +253,7 @@ export function addBuffer(slot, bufferMinutes) {
  * // original.start = 10:00, original.end = 11:00
  * ```
  */
-export function removeBuffer(slot, bufferMinutes) {
+function removeBuffer(slot, bufferMinutes) {
     const bufferMs = bufferMinutes * 60 * 1000;
     return {
         start: new Date(slot.start.getTime() + bufferMs),
@@ -263,8 +278,8 @@ export function removeBuffer(slot, bufferMinutes) {
  * const slots = expandRecurringAvailability(pattern, range);
  * ```
  */
-export function expandRecurringAvailability(pattern, range, config = {}) {
-    const occurrences = getOccurrencesBetween(pattern, range.start, range.end);
+function expandRecurringAvailability(pattern, range, config = {}) {
+    const occurrences = (0, recurrence_js_1.getOccurrencesBetween)(pattern, range.start, range.end);
     const slots = [];
     for (const occurrence of occurrences) {
         const daySlots = generateSlots(occurrence, config);
@@ -287,10 +302,10 @@ export function expandRecurringAvailability(pattern, range, config = {}) {
  * // [{ start: 09:00, end: 11:00 }]
  * ```
  */
-export function mergeBookings(bookings) {
+function mergeBookings(bookings) {
     if (bookings.length === 0)
         return [];
-    const ranges = mergeDateRanges(bookings);
+    const ranges = (0, dateRange_js_1.mergeDateRanges)(bookings);
     return ranges.map(range => ({
         start: range.start,
         end: range.end
@@ -309,7 +324,7 @@ export function mergeBookings(bookings) {
  * // before: 09:00-10:00, after: 10:00-11:00
  * ```
  */
-export function splitSlot(slot, at) {
+function splitSlot(slot, at) {
     const splitTime = toDate(at);
     if (splitTime <= slot.start || splitTime >= slot.end) {
         return null;

package/dist/{serialize.js → serialize.cjs}

@@ -1,10 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeDate = serializeDate;
+exports.deserializeDate = deserializeDate;
+exports.createDateReviver = createDateReviver;
+exports.createDateReplacer = createDateReplacer;
+exports.parseISOString = parseISOString;
+exports.toEpochTimestamp = toEpochTimestamp;
+exports.fromEpochTimestamp = fromEpochTimestamp;
+exports.createEpochTimestamp = createEpochTimestamp;
+exports.toDateObject = toDateObject;
+exports.fromDateObject = fromDateObject;
+exports.isValidISODateString = isValidISODateString;
+exports.isValidEpochTimestamp = isValidEpochTimestamp;
+exports.cloneDate = cloneDate;
+exports.datesEqual = datesEqual;
+exports.now = now;
+exports.parseJSONWithDates = parseJSONWithDates;
+exports.stringifyWithDates = stringifyWithDates;
 /**
  * Safe JSON date serialization and deserialization utilities
  */
 /**
  * Safely serialize a date to JSON with various format options
  */
-export function serializeDate(date, options = {}) {
+function serializeDate(date, options = {}) {
     const { format = 'iso', includeTimezone = false, useUTC = false, precision = 'milliseconds', customFormat } = options;
     const dateObj = normalizeDate(date);
     if (!dateObj) {
@@ -30,7 +49,7 @@ export function serializeDate(date, options = {}) {
 /**
  * Safely deserialize a date from various formats
  */
-export function deserializeDate(serializedDate, options = {}) {
+function deserializeDate(serializedDate, options = {}) {
     const { useUTC = false } = options;
     try {
         if (typeof serializedDate === 'string') {
@@ -59,7 +78,7 @@ export function deserializeDate(serializedDate, options = {}) {
 /**
  * Create a safe JSON reviver function for automatic date parsing
  */
-export function createDateReviver(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
+function createDateReviver(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
     return (key, value) => {
         if (dateKeys.includes(key) && (typeof value === 'string' || typeof value === 'number')) {
             const parsed = deserializeDate(value, options);
@@ -71,7 +90,7 @@ export function createDateReviver(dateKeys = ['createdAt', 'updatedAt', 'date',
 /**
  * Create a safe JSON replacer function for automatic date serialization
  */
-export function createDateReplacer(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
+function createDateReplacer(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
     return (key, value) => {
         if (dateKeys.includes(key)) {
             if (value instanceof Date) {
@@ -91,7 +110,7 @@ export function createDateReplacer(dateKeys = ['createdAt', 'updatedAt', 'date',
 /**
  * Parse ISO string with better error handling
  */
-export function parseISOString(isoString, useUTC = false) {
+function parseISOString(isoString, useUTC = false) {
     if (!isoString || typeof isoString !== 'string') {
         return null;
     }
@@ -120,7 +139,7 @@ export function parseISOString(isoString, useUTC = false) {
 /**
  * Convert date to epoch timestamp with specified precision
  */
-export function toEpochTimestamp(date, precision = 'milliseconds') {
+function toEpochTimestamp(date, precision = 'milliseconds') {
     const dateObj = normalizeDate(date);
     if (!dateObj) {
         throw new Error('Invalid date provided for epoch conversion');
@@ -139,7 +158,7 @@ export function toEpochTimestamp(date, precision = 'milliseconds') {
 /**
  * Create date from epoch timestamp with specified precision
  */
-export function fromEpochTimestamp(timestamp, precision = 'milliseconds') {
+function fromEpochTimestamp(timestamp, precision = 'milliseconds') {
     let ms;
     switch (precision) {
         case 'seconds':
@@ -158,7 +177,7 @@ export function fromEpochTimestamp(timestamp, precision = 'milliseconds') {
 /**
  * Create epoch timestamp with metadata
  */
-export function createEpochTimestamp(date, precision = 'milliseconds', timezone) {
+function createEpochTimestamp(date, precision = 'milliseconds', timezone) {
     return {
         timestamp: toEpochTimestamp(date, precision),
         precision,
@@ -168,7 +187,7 @@ export function createEpochTimestamp(date, precision = 'milliseconds', timezone)
 /**
  * Convert date to safe object representation
  */
-export function toDateObject(date, includeTimezone = false) {
+function toDateObject(date, includeTimezone = false) {
     const dateObj = normalizeDate(date);
     if (!dateObj) {
         throw new Error('Invalid date provided for object conversion');
@@ -195,7 +214,7 @@ export function toDateObject(date, includeTimezone = false) {
 /**
  * Create date from object representation
  */
-export function fromDateObject(dateObj) {
+function fromDateObject(dateObj) {
     // Validate required fields
     if (!dateObj || typeof dateObj !== 'object') {
         throw new Error('Invalid date object provided');
@@ -228,7 +247,7 @@ export function fromDateObject(dateObj) {
 /**
  * Check if a string is a valid ISO date string for serialization
  */
-export function isValidISODateString(dateString) {
+function isValidISODateString(dateString) {
     if (!dateString || typeof dateString !== 'string') {
         return false;
     }
@@ -238,7 +257,7 @@ export function isValidISODateString(dateString) {
 /**
  * Check if a number is a valid epoch timestamp
  */
-export function isValidEpochTimestamp(timestamp, precision = 'milliseconds') {
+function isValidEpochTimestamp(timestamp, precision = 'milliseconds') {
     if (typeof timestamp !== 'number' || isNaN(timestamp)) {
         return false;
     }
@@ -265,14 +284,14 @@ export function isValidEpochTimestamp(timestamp, precision = 'milliseconds') {
 /**
  * Clone a date safely (avoids reference issues)
  */
-export function cloneDate(date) {
+function cloneDate(date) {
     const dateObj = normalizeDate(date);
     return dateObj ? new Date(dateObj.getTime()) : null;
 }
 /**
  * Compare two dates for equality (ignoring milliseconds if specified)
  */
-export function datesEqual(date1, date2, precision = 'milliseconds') {
+function datesEqual(date1, date2, precision = 'milliseconds') {
     const d1 = normalizeDate(date1);
     const d2 = normalizeDate(date2);
     if (!d1 || !d2) {
@@ -295,7 +314,7 @@ export function datesEqual(date1, date2, precision = 'milliseconds') {
 /**
  * Get current timestamp in various formats
  */
-export function now(format = 'date') {
+function now(format = 'date') {
     const current = new Date();
     switch (format) {
         case 'iso':
@@ -312,7 +331,7 @@ export function now(format = 'date') {
 /**
  * Safely handle JSON parsing with date conversion
  */
-export function parseJSONWithDates(jsonString, dateKeys, options) {
+function parseJSONWithDates(jsonString, dateKeys, options) {
     try {
         return JSON.parse(jsonString, createDateReviver(dateKeys, options));
     }
@@ -323,7 +342,7 @@ export function parseJSONWithDates(jsonString, dateKeys, options) {
 /**
  * Safely handle JSON stringification with date conversion
  */
-export function stringifyWithDates(obj, dateKeys, options, space) {
+function stringifyWithDates(obj, dateKeys, options, space) {
     try {
         return JSON.stringify(obj, createDateReplacer(dateKeys, options), space);
     }

package/dist/{temporal.js → temporal.cjs}

@@ -1,8 +1,23 @@
+"use strict";
 /**
  * @fileoverview Temporal API compatibility layer
  * Provides Temporal-like objects that work with native Date
  * When Temporal ships natively, these become thin wrappers
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPlainDate = toPlainDate;
+exports.toPlainTime = toPlainTime;
+exports.toPlainDateTime = toPlainDateTime;
+exports.toZonedDateTime = toZonedDateTime;
+exports.toInstant = toInstant;
+exports.createDuration = createDuration;
+exports.parseDuration = parseDuration;
+exports.nowInstant = nowInstant;
+exports.nowPlainDateTime = nowPlainDateTime;
+exports.nowPlainDate = nowPlainDate;
+exports.nowPlainTime = nowPlainTime;
+exports.nowZonedDateTime = nowZonedDateTime;
+exports.fromTemporal = fromTemporal;
 // Helper functions
 function getWeekNumber(date) {
     const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
@@ -552,7 +567,7 @@ class InstantImpl {
         return new Date(this.epochMilliseconds);
     }
 }
-export function toPlainDate(dateOrYear, month, day) {
+function toPlainDate(dateOrYear, month, day) {
     if (dateOrYear instanceof Date) {
         return new PlainDateImpl(dateOrYear.getFullYear(), dateOrYear.getMonth() + 1, dateOrYear.getDate());
     }
@@ -561,7 +576,7 @@ export function toPlainDate(dateOrYear, month, day) {
     }
     return new PlainDateImpl(dateOrYear, month, day);
 }
-export function toPlainTime(dateOrHour, minute, second, millisecond) {
+function toPlainTime(dateOrHour, minute, second, millisecond) {
     if (dateOrHour instanceof Date) {
         return new PlainTimeImpl(dateOrHour.getHours(), dateOrHour.getMinutes(), dateOrHour.getSeconds(), dateOrHour.getMilliseconds());
     }
@@ -570,7 +585,7 @@ export function toPlainTime(dateOrHour, minute, second, millisecond) {
     }
     return new PlainTimeImpl(dateOrHour, minute, second, millisecond);
 }
-export function toPlainDateTime(dateOrYear, month, day, hour, minute, second, millisecond) {
+function toPlainDateTime(dateOrYear, month, day, hour, minute, second, millisecond) {
     if (dateOrYear instanceof Date) {
         return new PlainDateTimeImpl(dateOrYear.getFullYear(), dateOrYear.getMonth() + 1, dateOrYear.getDate(), dateOrYear.getHours(), dateOrYear.getMinutes(), dateOrYear.getSeconds(), dateOrYear.getMilliseconds());
     }
@@ -582,10 +597,10 @@ export function toPlainDateTime(dateOrYear, month, day, hour, minute, second, mi
 /**
  * Create a ZonedDateTime from a Date object and timezone
  */
-export function toZonedDateTime(date, timeZone) {
+function toZonedDateTime(date, timeZone) {
     return new ZonedDateTimeImpl(date.getTime(), timeZone);
 }
-export function toInstant(dateOrEpoch) {
+function toInstant(dateOrEpoch) {
     if (dateOrEpoch instanceof Date) {
         return new InstantImpl(dateOrEpoch.getTime());
     }
@@ -597,13 +612,13 @@ export function toInstant(dateOrEpoch) {
 /**
  * Create a Duration from components
  */
-export function createDuration(fields = {}) {
+function createDuration(fields = {}) {
     return new DurationImpl(fields);
 }
 /**
  * Parse an ISO 8601 duration string
  */
-export function parseDuration(str) {
+function parseDuration(str) {
     const match = str.match(/^(-)?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/);
     if (!match)
         throw new Error(`Invalid duration: ${str}`);
@@ -625,36 +640,36 @@ export function parseDuration(str) {
 /**
  * Get current instant
  */
-export function nowInstant() {
+function nowInstant() {
     return new InstantImpl(Date.now());
 }
 /**
  * Get current PlainDateTime in local timezone
  */
-export function nowPlainDateTime() {
+function nowPlainDateTime() {
     return toPlainDateTime(new Date());
 }
 /**
  * Get current PlainDate in local timezone
  */
-export function nowPlainDate() {
+function nowPlainDate() {
     return toPlainDate(new Date());
 }
 /**
  * Get current PlainTime in local timezone
  */
-export function nowPlainTime() {
+function nowPlainTime() {
     return toPlainTime(new Date());
 }
 /**
  * Get current ZonedDateTime in specified timezone
  */
-export function nowZonedDateTime(timeZone) {
+function nowZonedDateTime(timeZone) {
     return toZonedDateTime(new Date(), timeZone);
 }
 /**
  * Convert Temporal-like object back to Date
  */
-export function fromTemporal(temporal) {
+function fromTemporal(temporal) {
     return temporal.toDate();
 }