ts-time-utils 0.0.1

package/dist/rangePresets.d.ts

@@ -0,0 +1,45 @@
+/** Predefined date range helpers (returns [start,end]) */
+export interface DateRange {
+    start: Date;
+    end: Date;
+}
+export declare function today(now?: Date): DateRange;
+export declare function yesterday(now?: Date): DateRange;
+export declare function tomorrow(now?: Date): DateRange;
+export declare function lastNDays(n: number, now?: Date): DateRange;
+export declare function nextNDays(n: number, now?: Date): DateRange;
+export declare function thisWeek(now?: Date): DateRange;
+export declare function lastWeek(now?: Date): DateRange;
+export declare function nextWeek(now?: Date): DateRange;
+export declare function thisMonth(now?: Date): DateRange;
+export declare function lastMonth(now?: Date): DateRange;
+export declare function nextMonth(now?: Date): DateRange;
+export declare function thisYear(now?: Date): DateRange;
+export declare function lastYear(now?: Date): DateRange;
+export declare function nextYear(now?: Date): DateRange;
+export declare function rollingWindowDays(days: number, now?: Date): DateRange;
+export declare function quarterRange(date?: Date): DateRange;
+export declare function lastQuarter(date?: Date): DateRange;
+export declare function nextQuarter(date?: Date): DateRange;
+/** Map of preset functions for dynamic access */
+export declare const RANGE_PRESETS: {
+    today: typeof today;
+    yesterday: typeof yesterday;
+    tomorrow: typeof tomorrow;
+    last7Days: (now?: Date) => DateRange;
+    last30Days: (now?: Date) => DateRange;
+    next7Days: (now?: Date) => DateRange;
+    thisWeek: typeof thisWeek;
+    lastWeek: typeof lastWeek;
+    nextWeek: typeof nextWeek;
+    thisMonth: typeof thisMonth;
+    lastMonth: typeof lastMonth;
+    nextMonth: typeof nextMonth;
+    thisYear: typeof thisYear;
+    lastYear: typeof lastYear;
+    nextYear: typeof nextYear;
+    quarter: typeof quarterRange;
+    lastQuarter: typeof lastQuarter;
+    nextQuarter: typeof nextQuarter;
+};
+//# sourceMappingURL=rangePresets.d.ts.map

package/dist/rangePresets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rangePresets.d.ts","sourceRoot":"","sources":["../src/rangePresets.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAE1D,MAAM,WAAW,SAAS;IAAG,KAAK,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,IAAI,CAAC;CAAE;AAQtD,wBAAgB,KAAK,CAAC,GAAG,OAAa,GAAG,SAAS,CAA4B;AAC9E,wBAAgB,SAAS,CAAC,GAAG,OAAa,GAAG,SAAS,CAKrD;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAKpD;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,OAAa,GAAG,SAAS,CAIhE;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,OAAa,GAAG,SAAS,CAIhE;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAOpD;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAKpD;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAKpD;AAED,wBAAgB,SAAS,CAAC,GAAG,OAAa,GAAG,SAAS,CAIrD;AAED,wBAAgB,SAAS,CAAC,GAAG,OAAa,GAAG,SAAS,CAKrD;AAED,wBAAgB,SAAS,CAAC,GAAG,OAAa,GAAG,SAAS,CAKrD;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAIpD;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAKpD;AAED,wBAAgB,QAAQ,CAAC,GAAG,OAAa,GAAG,SAAS,CAKpD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAa,GAAG,SAAS,CAI3E;AAED,wBAAgB,YAAY,CAAC,IAAI,OAAa,GAAG,SAAS,CAKzD;AAED,wBAAgB,WAAW,CAAC,IAAI,OAAa,GAAG,SAAS,CAKxD;AAED,wBAAgB,WAAW,CAAC,IAAI,OAAa,GAAG,SAAS,CAKxD;AAED,iDAAiD;AACjD,eAAO,MAAM,aAAa;;;;sBAEN,IAAI;uBACH,IAAI;sBACL,IAAI;;;;;;;;;;;;;CAKvB,CAAC"}

package/dist/rangePresets.js

@@ -0,0 +1,124 @@
+/** Predefined date range helpers (returns [start,end]) */
+function todayRange(now = new Date()) {
+    const start = new Date(now);
+    start.setHours(0, 0, 0, 0);
+    const end = new Date(start);
+    end.setDate(end.getDate() + 1);
+    return { start, end };
+}
+export function today(now = new Date()) { return todayRange(now); }
+export function yesterday(now = new Date()) {
+    const t = todayRange(now);
+    const end = new Date(t.start); // yesterday end equals today start
+    const start = new Date(end);
+    start.setDate(start.getDate() - 1);
+    return { start, end };
+}
+export function tomorrow(now = new Date()) {
+    const t = todayRange(now);
+    t.start.setDate(t.start.getDate() + 1);
+    t.end.setDate(t.end.getDate() + 1);
+    return t;
+}
+export function lastNDays(n, now = new Date()) {
+    const end = new Date(now);
+    const start = new Date(end);
+    start.setDate(start.getDate() - n);
+    return { start, end };
+}
+export function nextNDays(n, now = new Date()) {
+    const start = new Date(now);
+    const end = new Date(start);
+    end.setDate(end.getDate() + n);
+    return { start, end };
+}
+export function thisWeek(now = new Date()) {
+    const start = new Date(now);
+    const day = start.getDay(); // 0 Sunday
+    start.setHours(0, 0, 0, 0);
+    start.setDate(start.getDate() - day); // start of week Sunday
+    const end = new Date(start);
+    end.setDate(end.getDate() + 7);
+    return { start, end };
+}
+export function lastWeek(now = new Date()) {
+    const w = thisWeek(now);
+    w.start.setDate(w.start.getDate() - 7);
+    w.end.setDate(w.end.getDate() - 7);
+    return w;
+}
+export function nextWeek(now = new Date()) {
+    const w = thisWeek(now);
+    w.start.setDate(w.start.getDate() + 7);
+    w.end.setDate(w.end.getDate() + 7);
+    return w;
+}
+export function thisMonth(now = new Date()) {
+    const start = new Date(now.getFullYear(), now.getMonth(), 1);
+    const end = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    return { start, end };
+}
+export function lastMonth(now = new Date()) {
+    const m = thisMonth(now);
+    m.start.setMonth(m.start.getMonth() - 1);
+    m.end.setMonth(m.end.getMonth() - 1);
+    return m;
+}
+export function nextMonth(now = new Date()) {
+    const m = thisMonth(now);
+    m.start.setMonth(m.start.getMonth() + 1);
+    m.end.setMonth(m.end.getMonth() + 1);
+    return m;
+}
+export function thisYear(now = new Date()) {
+    const start = new Date(now.getFullYear(), 0, 1);
+    const end = new Date(now.getFullYear() + 1, 0, 1);
+    return { start, end };
+}
+export function lastYear(now = new Date()) {
+    const y = thisYear(now);
+    y.start.setFullYear(y.start.getFullYear() - 1);
+    y.end.setFullYear(y.end.getFullYear() - 1);
+    return y;
+}
+export function nextYear(now = new Date()) {
+    const y = thisYear(now);
+    y.start.setFullYear(y.start.getFullYear() + 1);
+    y.end.setFullYear(y.end.getFullYear() + 1);
+    return y;
+}
+export function rollingWindowDays(days, now = new Date()) {
+    const end = new Date(now);
+    const start = new Date(end);
+    start.setDate(start.getDate() - days);
+    return { start, end };
+}
+export function quarterRange(date = new Date()) {
+    const q = Math.floor(date.getMonth() / 3); // 0-3
+    const start = new Date(date.getFullYear(), q * 3, 1);
+    const end = new Date(date.getFullYear(), q * 3 + 3, 1);
+    return { start, end };
+}
+export function lastQuarter(date = new Date()) {
+    const q = quarterRange(date);
+    q.start.setMonth(q.start.getMonth() - 3);
+    q.end.setMonth(q.end.getMonth() - 3);
+    return q;
+}
+export function nextQuarter(date = new Date()) {
+    const q = quarterRange(date);
+    q.start.setMonth(q.start.getMonth() + 3);
+    q.end.setMonth(q.end.getMonth() + 3);
+    return q;
+}
+/** Map of preset functions for dynamic access */
+export const RANGE_PRESETS = {
+    today, yesterday, tomorrow,
+    last7Days: (now) => lastNDays(7, now),
+    last30Days: (now) => lastNDays(30, now),
+    next7Days: (now) => nextNDays(7, now),
+    thisWeek, lastWeek, nextWeek,
+    thisMonth, lastMonth, nextMonth,
+    thisYear, lastYear, nextYear,
+    quarter: quarterRange, lastQuarter, nextQuarter,
+};

package/dist/timezone.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Timezone utilities (rely on Intl API, fallbacks where possible)
+ */
+export interface ZonedTime {
+    date: Date;
+    zone: string;
+    offsetMinutes: number;
+}
+/** Get offset (minutes) for a zone at a given date */
+export declare function getTimezoneOffset(zone: string, date?: Date): number | null;
+/** Format date/time in a zone */
+export declare function formatInTimeZone(date: Date, zone: string, options?: Intl.DateTimeFormatOptions): string;
+/** Get a lightweight ZonedTime object */
+export declare function getZonedTime(date: Date, zone: string): ZonedTime | null;
+/** Convert a date (treated as absolute moment) to another zone's clock components */
+export declare function convertDateToZone(date: Date, zone: string): {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+} | null;
+/** Check if provided zone string is a valid IANA zone */
+export declare function isValidTimeZone(zone: string): boolean;
+/** List a subset of common timezones (cannot enumerate all via API) */
+export declare const COMMON_TIMEZONES: string[];
+/** Get current local offset in minutes */
+export declare function getLocalOffset(): number;
+/** Compare two timezones offset at given date */
+export declare function compareZoneOffsets(zoneA: string, zoneB: string, date?: Date): number | null;
+/** Shift a date by target zone offset difference relative to current local zone.
+ * This does not change the absolute moment; instead returns a new Date representing
+ * the same wall clock time in the target zone interpreted as local.
+ * For example useful for naive scheduling.
+ */
+export declare function reinterpretAsZone(date: Date, targetZone: string): Date | null;
+//# sourceMappingURL=timezone.d.ts.map

package/dist/timezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../src/timezone.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,sDAAsD;AACtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,IAAiB,GAAG,MAAM,GAAG,IAAI,CAgBtF;AAED,iCAAiC;AACjC,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,IAAI,CAAC,qBAA0B,GAAG,MAAM,CAG3G;AAED,yCAAyC;AACzC,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAIvE;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;CAAE,GAAG,IAAI,CAoB9J;AAED,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOrD;AAED,uEAAuE;AACvE,eAAO,MAAM,gBAAgB,UAK5B,CAAC;AAEF,0CAA0C;AAC1C,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,iDAAiD;AACjD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,IAAiB,GAAG,MAAM,GAAG,IAAI,CAKvG;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAI7E"}

package/dist/timezone.js

@@ -0,0 +1,99 @@
+/**
+ * Timezone utilities (rely on Intl API, fallbacks where possible)
+ */
+/** Get offset (minutes) for a zone at a given date */
+export function getTimezoneOffset(zone, date = new Date()) {
+    try {
+        const dtf = new Intl.DateTimeFormat('en-US', { timeZone: zone, timeZoneName: 'shortOffset', hour: '2-digit' });
+        const parts = dtf.formatToParts(date);
+        const tzPart = parts.find(p => p.type === 'timeZoneName');
+        if (!tzPart)
+            return null;
+        // Examples: "GMT+2", "UTC-05:00"
+        const match = tzPart.value.match(/([+-])(\d{1,2})(?::?(\d{2}))?/);
+        if (!match)
+            return 0; // could be GMT or UTC with no offset
+        const sign = match[1] === '-' ? -1 : 1;
+        const hours = parseInt(match[2], 10);
+        const mins = match[3] ? parseInt(match[3], 10) : 0;
+        return sign * (hours * 60 + mins);
+    }
+    catch {
+        return null;
+    }
+}
+/** Format date/time in a zone */
+export function formatInTimeZone(date, zone, options = {}) {
+    const fmt = new Intl.DateTimeFormat('en-US', { timeZone: zone, ...options });
+    return fmt.format(date);
+}
+/** Get a lightweight ZonedTime object */
+export function getZonedTime(date, zone) {
+    const offset = getTimezoneOffset(zone, date);
+    if (offset == null)
+        return null;
+    return { date: new Date(date), zone, offsetMinutes: offset };
+}
+/** Convert a date (treated as absolute moment) to another zone's clock components */
+export function convertDateToZone(date, zone) {
+    try {
+        const fmt = new Intl.DateTimeFormat('en-US', {
+            timeZone: zone,
+            year: 'numeric', month: '2-digit', day: '2-digit',
+            hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false
+        });
+        const parts = fmt.formatToParts(date);
+        const get = (type) => parseInt(parts.find(p => p.type === type)?.value || '0', 10);
+        return {
+            year: get('year'),
+            month: get('month'),
+            day: get('day'),
+            hour: get('hour'),
+            minute: get('minute'),
+            second: get('second')
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Check if provided zone string is a valid IANA zone */
+export function isValidTimeZone(zone) {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: zone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** List a subset of common timezones (cannot enumerate all via API) */
+export const COMMON_TIMEZONES = [
+    'UTC', 'Etc/UTC', 'Europe/London', 'Europe/Paris', 'Europe/Berlin', 'Europe/Madrid', 'Europe/Rome',
+    'America/New_York', 'America/Chicago', 'America/Denver', 'America/Los_Angeles', 'America/Toronto', 'America/Sao_Paulo',
+    'Asia/Tehran', 'Asia/Dubai', 'Asia/Tokyo', 'Asia/Shanghai', 'Asia/Singapore', 'Asia/Kolkata', 'Asia/Hong_Kong',
+    'Australia/Sydney', 'Pacific/Auckland'
+];
+/** Get current local offset in minutes */
+export function getLocalOffset() {
+    return -new Date().getTimezoneOffset();
+}
+/** Compare two timezones offset at given date */
+export function compareZoneOffsets(zoneA, zoneB, date = new Date()) {
+    const a = getTimezoneOffset(zoneA, date);
+    const b = getTimezoneOffset(zoneB, date);
+    if (a == null || b == null)
+        return null;
+    return a - b; // positive if A ahead of B
+}
+/** Shift a date by target zone offset difference relative to current local zone.
+ * This does not change the absolute moment; instead returns a new Date representing
+ * the same wall clock time in the target zone interpreted as local.
+ * For example useful for naive scheduling.
+ */
+export function reinterpretAsZone(date, targetZone) {
+    const target = convertDateToZone(date, targetZone);
+    if (!target)
+        return null;
+    return new Date(Date.UTC(target.year, target.month - 1, target.day, target.hour, target.minute, target.second));
+}

package/dist/validate.d.ts

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

package/dist/validate.d.ts.map

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

package/dist/validate.js

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

package/dist/workingHours.d.ts

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

package/dist/workingHours.d.ts.map

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

package/dist/workingHours.js

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