ts-time-utils 3.0.0 → 4.0.1

package/dist/esm/temporal.js

@@ -0,0 +1,660 @@
+/**
+ * @fileoverview Temporal API compatibility layer
+ * Provides Temporal-like objects that work with native Date
+ * When Temporal ships natively, these become thin wrappers
+ */
+// Helper functions
+function getWeekNumber(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
+}
+function getDayOfYear(date) {
+    const start = new Date(date.getFullYear(), 0, 0);
+    const diff = date.getTime() - start.getTime();
+    return Math.floor(diff / 86400000);
+}
+function getDaysInMonth(year, month) {
+    return new Date(year, month, 0).getDate();
+}
+function getDaysInYear(year) {
+    return isLeapYear(year) ? 366 : 365;
+}
+function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
+}
+function formatOffset(offsetMinutes) {
+    const sign = offsetMinutes >= 0 ? '+' : '-';
+    const absMinutes = Math.abs(offsetMinutes);
+    const hours = Math.floor(absMinutes / 60);
+    const mins = absMinutes % 60;
+    return `${sign}${hours.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}`;
+}
+function compareDates(a, b) {
+    const diff = a.getTime() - b.getTime();
+    return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+}
+// Duration implementation
+class DurationImpl {
+    constructor(fields = {}) {
+        this.years = fields.years || 0;
+        this.months = fields.months || 0;
+        this.weeks = fields.weeks || 0;
+        this.days = fields.days || 0;
+        this.hours = fields.hours || 0;
+        this.minutes = fields.minutes || 0;
+        this.seconds = fields.seconds || 0;
+        this.milliseconds = fields.milliseconds || 0;
+    }
+    get sign() {
+        const total = this.years + this.months + this.weeks + this.days +
+            this.hours + this.minutes + this.seconds + this.milliseconds;
+        return total < 0 ? -1 : total > 0 ? 1 : 0;
+    }
+    get blank() {
+        return this.sign === 0;
+    }
+    toString() {
+        if (this.blank)
+            return 'PT0S';
+        let result = this.sign < 0 ? '-P' : 'P';
+        if (this.years)
+            result += `${Math.abs(this.years)}Y`;
+        if (this.months)
+            result += `${Math.abs(this.months)}M`;
+        if (this.weeks)
+            result += `${Math.abs(this.weeks)}W`;
+        if (this.days)
+            result += `${Math.abs(this.days)}D`;
+        const hasTime = this.hours || this.minutes || this.seconds || this.milliseconds;
+        if (hasTime) {
+            result += 'T';
+            if (this.hours)
+                result += `${Math.abs(this.hours)}H`;
+            if (this.minutes)
+                result += `${Math.abs(this.minutes)}M`;
+            if (this.seconds || this.milliseconds) {
+                const secs = Math.abs(this.seconds) + Math.abs(this.milliseconds) / 1000;
+                result += `${secs}S`;
+            }
+        }
+        return result;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    negated() {
+        return new DurationImpl({
+            years: -this.years,
+            months: -this.months,
+            weeks: -this.weeks,
+            days: -this.days,
+            hours: -this.hours,
+            minutes: -this.minutes,
+            seconds: -this.seconds,
+            milliseconds: -this.milliseconds,
+        });
+    }
+    abs() {
+        return new DurationImpl({
+            years: Math.abs(this.years),
+            months: Math.abs(this.months),
+            weeks: Math.abs(this.weeks),
+            days: Math.abs(this.days),
+            hours: Math.abs(this.hours),
+            minutes: Math.abs(this.minutes),
+            seconds: Math.abs(this.seconds),
+            milliseconds: Math.abs(this.milliseconds),
+        });
+    }
+    add(other) {
+        return new DurationImpl({
+            years: this.years + (other.years || 0),
+            months: this.months + (other.months || 0),
+            weeks: this.weeks + (other.weeks || 0),
+            days: this.days + (other.days || 0),
+            hours: this.hours + (other.hours || 0),
+            minutes: this.minutes + (other.minutes || 0),
+            seconds: this.seconds + (other.seconds || 0),
+            milliseconds: this.milliseconds + (other.milliseconds || 0),
+        });
+    }
+    subtract(other) {
+        return new DurationImpl({
+            years: this.years - (other.years || 0),
+            months: this.months - (other.months || 0),
+            weeks: this.weeks - (other.weeks || 0),
+            days: this.days - (other.days || 0),
+            hours: this.hours - (other.hours || 0),
+            minutes: this.minutes - (other.minutes || 0),
+            seconds: this.seconds - (other.seconds || 0),
+            milliseconds: this.milliseconds - (other.milliseconds || 0),
+        });
+    }
+    total(unit) {
+        // Convert everything to milliseconds first
+        const MS_PER_SECOND = 1000;
+        const MS_PER_MINUTE = 60 * MS_PER_SECOND;
+        const MS_PER_HOUR = 60 * MS_PER_MINUTE;
+        const MS_PER_DAY = 24 * MS_PER_HOUR;
+        const MS_PER_WEEK = 7 * MS_PER_DAY;
+        // Approximate month/year (not calendar-accurate)
+        const MS_PER_MONTH = 30 * MS_PER_DAY;
+        const MS_PER_YEAR = 365 * MS_PER_DAY;
+        const totalMs = this.milliseconds +
+            this.seconds * MS_PER_SECOND +
+            this.minutes * MS_PER_MINUTE +
+            this.hours * MS_PER_HOUR +
+            this.days * MS_PER_DAY +
+            this.weeks * MS_PER_WEEK +
+            this.months * MS_PER_MONTH +
+            this.years * MS_PER_YEAR;
+        switch (unit) {
+            case 'milliseconds': return totalMs;
+            case 'seconds': return totalMs / MS_PER_SECOND;
+            case 'minutes': return totalMs / MS_PER_MINUTE;
+            case 'hours': return totalMs / MS_PER_HOUR;
+            case 'days': return totalMs / MS_PER_DAY;
+            case 'weeks': return totalMs / MS_PER_WEEK;
+            case 'months': return totalMs / MS_PER_MONTH;
+            case 'years': return totalMs / MS_PER_YEAR;
+        }
+    }
+}
+// PlainDate implementation
+class PlainDateImpl {
+    constructor(year, month, day) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+    }
+    get dayOfWeek() {
+        const d = new Date(this.year, this.month - 1, this.day);
+        return d.getDay() === 0 ? 7 : d.getDay(); // ISO: 1=Monday, 7=Sunday
+    }
+    get dayOfYear() {
+        return getDayOfYear(new Date(this.year, this.month - 1, this.day));
+    }
+    get weekOfYear() {
+        return getWeekNumber(new Date(this.year, this.month - 1, this.day));
+    }
+    get daysInMonth() {
+        return getDaysInMonth(this.year, this.month);
+    }
+    get daysInYear() {
+        return getDaysInYear(this.year);
+    }
+    get monthsInYear() {
+        return 12;
+    }
+    get inLeapYear() {
+        return isLeapYear(this.year);
+    }
+    toString() {
+        const y = this.year.toString().padStart(4, '0');
+        const m = this.month.toString().padStart(2, '0');
+        const d = this.day.toString().padStart(2, '0');
+        return `${y}-${m}-${d}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    equals(other) {
+        return this.year === other.year && this.month === other.month && this.day === other.day;
+    }
+    compare(other) {
+        const otherDate = new Date(other.year, other.month - 1, other.day);
+        return compareDates(this.toDate(), otherDate);
+    }
+    add(duration) {
+        const date = this.toDate();
+        if (duration.years)
+            date.setFullYear(date.getFullYear() + duration.years);
+        if (duration.months)
+            date.setMonth(date.getMonth() + duration.months);
+        if (duration.weeks)
+            date.setDate(date.getDate() + duration.weeks * 7);
+        if (duration.days)
+            date.setDate(date.getDate() + duration.days);
+        return toPlainDate(date);
+    }
+    subtract(duration) {
+        return this.add({
+            years: -(duration.years || 0),
+            months: -(duration.months || 0),
+            weeks: -(duration.weeks || 0),
+            days: -(duration.days || 0),
+        });
+    }
+    until(other) {
+        const otherDate = new Date(other.year, other.month - 1, other.day);
+        const diffMs = otherDate.getTime() - this.toDate().getTime();
+        const days = Math.floor(diffMs / 86400000);
+        return createDuration({ days });
+    }
+    since(other) {
+        const otherImpl = new PlainDateImpl(other.year, other.month, other.day);
+        return otherImpl.until(this);
+    }
+    with(fields) {
+        return new PlainDateImpl(fields.year ?? this.year, fields.month ?? this.month, fields.day ?? this.day);
+    }
+    toDate() {
+        return new Date(this.year, this.month - 1, this.day);
+    }
+}
+// PlainTime implementation
+class PlainTimeImpl {
+    constructor(hour = 0, minute = 0, second = 0, millisecond = 0) {
+        this.hour = hour;
+        this.minute = minute;
+        this.second = second;
+        this.millisecond = millisecond;
+    }
+    toString() {
+        const h = this.hour.toString().padStart(2, '0');
+        const m = this.minute.toString().padStart(2, '0');
+        const s = this.second.toString().padStart(2, '0');
+        if (this.millisecond) {
+            const ms = this.millisecond.toString().padStart(3, '0');
+            return `${h}:${m}:${s}.${ms}`;
+        }
+        return `${h}:${m}:${s}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    equals(other) {
+        return this.hour === other.hour && this.minute === other.minute &&
+            this.second === other.second && this.millisecond === other.millisecond;
+    }
+    compare(other) {
+        const a = this.hour * 3600000 + this.minute * 60000 + this.second * 1000 + this.millisecond;
+        const b = other.hour * 3600000 + other.minute * 60000 + other.second * 1000 + other.millisecond;
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+    add(duration) {
+        let totalMs = this.hour * 3600000 + this.minute * 60000 + this.second * 1000 + this.millisecond;
+        if (duration.hours)
+            totalMs += duration.hours * 3600000;
+        if (duration.minutes)
+            totalMs += duration.minutes * 60000;
+        if (duration.seconds)
+            totalMs += duration.seconds * 1000;
+        if (duration.milliseconds)
+            totalMs += duration.milliseconds;
+        // Wrap around 24 hours
+        totalMs = ((totalMs % 86400000) + 86400000) % 86400000;
+        const hour = Math.floor(totalMs / 3600000);
+        const minute = Math.floor((totalMs % 3600000) / 60000);
+        const second = Math.floor((totalMs % 60000) / 1000);
+        const millisecond = totalMs % 1000;
+        return new PlainTimeImpl(hour, minute, second, millisecond);
+    }
+    subtract(duration) {
+        return this.add({
+            hours: -(duration.hours || 0),
+            minutes: -(duration.minutes || 0),
+            seconds: -(duration.seconds || 0),
+            milliseconds: -(duration.milliseconds || 0),
+        });
+    }
+    with(fields) {
+        return new PlainTimeImpl(fields.hour ?? this.hour, fields.minute ?? this.minute, fields.second ?? this.second, fields.millisecond ?? this.millisecond);
+    }
+}
+// PlainDateTime implementation
+class PlainDateTimeImpl {
+    constructor(year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.hour = hour;
+        this.minute = minute;
+        this.second = second;
+        this.millisecond = millisecond;
+    }
+    get dayOfWeek() {
+        const d = new Date(this.year, this.month - 1, this.day);
+        return d.getDay() === 0 ? 7 : d.getDay();
+    }
+    get dayOfYear() {
+        return getDayOfYear(new Date(this.year, this.month - 1, this.day));
+    }
+    get weekOfYear() {
+        return getWeekNumber(new Date(this.year, this.month - 1, this.day));
+    }
+    toString() {
+        const date = this.toPlainDate().toString();
+        const time = this.toPlainTime().toString();
+        return `${date}T${time}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    equals(other) {
+        return this.toPlainDate().equals(other.toPlainDate()) &&
+            this.toPlainTime().equals(other.toPlainTime());
+    }
+    compare(other) {
+        const otherDate = new Date(other.year, other.month - 1, other.day, other.hour, other.minute, other.second, other.millisecond);
+        return compareDates(this.toDate(), otherDate);
+    }
+    add(duration) {
+        const date = this.toDate();
+        if (duration.years)
+            date.setFullYear(date.getFullYear() + duration.years);
+        if (duration.months)
+            date.setMonth(date.getMonth() + duration.months);
+        if (duration.weeks)
+            date.setDate(date.getDate() + duration.weeks * 7);
+        if (duration.days)
+            date.setDate(date.getDate() + duration.days);
+        if (duration.hours)
+            date.setHours(date.getHours() + duration.hours);
+        if (duration.minutes)
+            date.setMinutes(date.getMinutes() + duration.minutes);
+        if (duration.seconds)
+            date.setSeconds(date.getSeconds() + duration.seconds);
+        if (duration.milliseconds)
+            date.setMilliseconds(date.getMilliseconds() + duration.milliseconds);
+        return toPlainDateTime(date);
+    }
+    subtract(duration) {
+        return this.add({
+            years: -(duration.years || 0),
+            months: -(duration.months || 0),
+            weeks: -(duration.weeks || 0),
+            days: -(duration.days || 0),
+            hours: -(duration.hours || 0),
+            minutes: -(duration.minutes || 0),
+            seconds: -(duration.seconds || 0),
+            milliseconds: -(duration.milliseconds || 0),
+        });
+    }
+    until(other) {
+        const otherDate = new Date(other.year, other.month - 1, other.day, other.hour, other.minute, other.second, other.millisecond);
+        const diffMs = otherDate.getTime() - this.toDate().getTime();
+        const days = Math.floor(diffMs / 86400000);
+        const remainingMs = diffMs % 86400000;
+        const hours = Math.floor(remainingMs / 3600000);
+        const minutes = Math.floor((remainingMs % 3600000) / 60000);
+        const seconds = Math.floor((remainingMs % 60000) / 1000);
+        const milliseconds = remainingMs % 1000;
+        return createDuration({ days, hours, minutes, seconds, milliseconds });
+    }
+    since(other) {
+        const otherImpl = new PlainDateTimeImpl(other.year, other.month, other.day, other.hour, other.minute, other.second, other.millisecond);
+        return otherImpl.until(this);
+    }
+    with(fields) {
+        return new PlainDateTimeImpl(fields.year ?? this.year, fields.month ?? this.month, fields.day ?? this.day, fields.hour ?? this.hour, fields.minute ?? this.minute, fields.second ?? this.second, fields.millisecond ?? this.millisecond);
+    }
+    toPlainDate() {
+        return new PlainDateImpl(this.year, this.month, this.day);
+    }
+    toPlainTime() {
+        return new PlainTimeImpl(this.hour, this.minute, this.second, this.millisecond);
+    }
+    toDate() {
+        return new Date(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond);
+    }
+}
+// ZonedDateTime implementation
+class ZonedDateTimeImpl {
+    constructor(epochMs, timeZone) {
+        this._date = new Date(epochMs);
+        this.timeZone = timeZone;
+    }
+    get _parts() {
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: this.timeZone,
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+            hour12: false,
+        });
+        const parts = formatter.formatToParts(this._date);
+        const result = {};
+        for (const part of parts) {
+            if (part.type !== 'literal') {
+                result[part.type] = parseInt(part.value, 10);
+            }
+        }
+        return {
+            year: result.year,
+            month: result.month,
+            day: result.day,
+            hour: result.hour === 24 ? 0 : result.hour, // Handle midnight
+            minute: result.minute,
+            second: result.second,
+        };
+    }
+    get year() { return this._parts.year; }
+    get month() { return this._parts.month; }
+    get day() { return this._parts.day; }
+    get hour() { return this._parts.hour; }
+    get minute() { return this._parts.minute; }
+    get second() { return this._parts.second; }
+    get millisecond() { return this._date.getMilliseconds(); }
+    get epochMilliseconds() { return this._date.getTime(); }
+    get offset() {
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: this.timeZone,
+            timeZoneName: 'shortOffset',
+        });
+        const parts = formatter.formatToParts(this._date);
+        const offsetPart = parts.find(p => p.type === 'timeZoneName');
+        return offsetPart?.value.replace('GMT', '') || '+00:00';
+    }
+    toString() {
+        const dt = `${this.toPlainDateTime().toString()}`;
+        return `${dt}${this.offset}[${this.timeZone}]`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    equals(other) {
+        return this.epochMilliseconds === other.epochMilliseconds && this.timeZone === other.timeZone;
+    }
+    add(duration) {
+        const dt = this.toPlainDateTime().add(duration);
+        return toZonedDateTime(dt.toDate(), this.timeZone);
+    }
+    subtract(duration) {
+        const dt = this.toPlainDateTime().subtract(duration);
+        return toZonedDateTime(dt.toDate(), this.timeZone);
+    }
+    with(fields) {
+        const dt = this.toPlainDateTime().with(fields);
+        return toZonedDateTime(dt.toDate(), this.timeZone);
+    }
+    toPlainDate() {
+        const p = this._parts;
+        return new PlainDateImpl(p.year, p.month, p.day);
+    }
+    toPlainTime() {
+        const p = this._parts;
+        return new PlainTimeImpl(p.hour, p.minute, p.second, this.millisecond);
+    }
+    toPlainDateTime() {
+        const p = this._parts;
+        return new PlainDateTimeImpl(p.year, p.month, p.day, p.hour, p.minute, p.second, this.millisecond);
+    }
+    toInstant() {
+        return new InstantImpl(this.epochMilliseconds);
+    }
+    toDate() {
+        return new Date(this._date.getTime());
+    }
+}
+// Instant implementation
+class InstantImpl {
+    constructor(epochMs) {
+        this.epochMilliseconds = epochMs;
+    }
+    get epochSeconds() {
+        return Math.floor(this.epochMilliseconds / 1000);
+    }
+    toString() {
+        return new Date(this.epochMilliseconds).toISOString();
+    }
+    toJSON() {
+        return this.toString();
+    }
+    equals(other) {
+        return this.epochMilliseconds === other.epochMilliseconds;
+    }
+    compare(other) {
+        const diff = this.epochMilliseconds - other.epochMilliseconds;
+        return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+    }
+    add(duration) {
+        let ms = this.epochMilliseconds;
+        if (duration.days)
+            ms += duration.days * 86400000;
+        if (duration.hours)
+            ms += duration.hours * 3600000;
+        if (duration.minutes)
+            ms += duration.minutes * 60000;
+        if (duration.seconds)
+            ms += duration.seconds * 1000;
+        if (duration.milliseconds)
+            ms += duration.milliseconds;
+        return new InstantImpl(ms);
+    }
+    subtract(duration) {
+        return this.add({
+            days: -(duration.days || 0),
+            hours: -(duration.hours || 0),
+            minutes: -(duration.minutes || 0),
+            seconds: -(duration.seconds || 0),
+            milliseconds: -(duration.milliseconds || 0),
+        });
+    }
+    until(other) {
+        const diffMs = other.epochMilliseconds - this.epochMilliseconds;
+        return createDuration({ milliseconds: diffMs });
+    }
+    since(other) {
+        const otherImpl = new InstantImpl(other.epochMilliseconds);
+        return otherImpl.until(this);
+    }
+    toZonedDateTime(timeZone) {
+        return new ZonedDateTimeImpl(this.epochMilliseconds, timeZone);
+    }
+    toDate() {
+        return new Date(this.epochMilliseconds);
+    }
+}
+export function toPlainDate(dateOrYear, month, day) {
+    if (dateOrYear instanceof Date) {
+        return new PlainDateImpl(dateOrYear.getFullYear(), dateOrYear.getMonth() + 1, dateOrYear.getDate());
+    }
+    if (typeof dateOrYear === 'object' && 'year' in dateOrYear) {
+        return new PlainDateImpl(dateOrYear.year, dateOrYear.month, dateOrYear.day);
+    }
+    return new PlainDateImpl(dateOrYear, month, day);
+}
+export function toPlainTime(dateOrHour, minute, second, millisecond) {
+    if (dateOrHour instanceof Date) {
+        return new PlainTimeImpl(dateOrHour.getHours(), dateOrHour.getMinutes(), dateOrHour.getSeconds(), dateOrHour.getMilliseconds());
+    }
+    if (typeof dateOrHour === 'object' && 'hour' in dateOrHour) {
+        return new PlainTimeImpl(dateOrHour.hour, dateOrHour.minute, dateOrHour.second, dateOrHour.millisecond);
+    }
+    return new PlainTimeImpl(dateOrHour, minute, second, millisecond);
+}
+export 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());
+    }
+    if (typeof dateOrYear === 'object' && 'year' in dateOrYear) {
+        return new PlainDateTimeImpl(dateOrYear.year, dateOrYear.month, dateOrYear.day, dateOrYear.hour, dateOrYear.minute, dateOrYear.second, dateOrYear.millisecond);
+    }
+    return new PlainDateTimeImpl(dateOrYear, month, day, hour, minute, second, millisecond);
+}
+/**
+ * Create a ZonedDateTime from a Date object and timezone
+ */
+export function toZonedDateTime(date, timeZone) {
+    return new ZonedDateTimeImpl(date.getTime(), timeZone);
+}
+export function toInstant(dateOrEpoch) {
+    if (dateOrEpoch instanceof Date) {
+        return new InstantImpl(dateOrEpoch.getTime());
+    }
+    if (typeof dateOrEpoch === 'object' && 'epochMilliseconds' in dateOrEpoch) {
+        return new InstantImpl(dateOrEpoch.epochMilliseconds);
+    }
+    return new InstantImpl(dateOrEpoch);
+}
+/**
+ * Create a Duration from components
+ */
+export function createDuration(fields = {}) {
+    return new DurationImpl(fields);
+}
+/**
+ * Parse an ISO 8601 duration string
+ */
+export 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}`);
+    const sign = match[1] === '-' ? -1 : 1;
+    const seconds = match[8] ? parseFloat(match[8]) : 0;
+    const wholeSeconds = Math.floor(seconds);
+    const milliseconds = Math.round((seconds - wholeSeconds) * 1000);
+    return new DurationImpl({
+        years: sign * (parseInt(match[2], 10) || 0),
+        months: sign * (parseInt(match[3], 10) || 0),
+        weeks: sign * (parseInt(match[4], 10) || 0),
+        days: sign * (parseInt(match[5], 10) || 0),
+        hours: sign * (parseInt(match[6], 10) || 0),
+        minutes: sign * (parseInt(match[7], 10) || 0),
+        seconds: sign * wholeSeconds,
+        milliseconds: sign * milliseconds,
+    });
+}
+/**
+ * Get current instant
+ */
+export function nowInstant() {
+    return new InstantImpl(Date.now());
+}
+/**
+ * Get current PlainDateTime in local timezone
+ */
+export function nowPlainDateTime() {
+    return toPlainDateTime(new Date());
+}
+/**
+ * Get current PlainDate in local timezone
+ */
+export function nowPlainDate() {
+    return toPlainDate(new Date());
+}
+/**
+ * Get current PlainTime in local timezone
+ */
+export function nowPlainTime() {
+    return toPlainTime(new Date());
+}
+/**
+ * Get current ZonedDateTime in specified timezone
+ */
+export function nowZonedDateTime(timeZone) {
+    return toZonedDateTime(new Date(), timeZone);
+}
+/**
+ * Convert Temporal-like object back to Date
+ */
+export function fromTemporal(temporal) {
+    return temporal.toDate();
+}

package/dist/esm/validate.d.ts

@@ -110,4 +110,34 @@ export declare function isInLastNDays(date: Date, n: number): boolean;
  * @param n - number of days
  */
 export declare function isInNextNDays(date: Date, n: number): boolean;
+/**
+ * Check if two dates are in the same hour
+ * @param date1 - first date
+ * @param date2 - second date
+ */
+export declare function isSameHour(date1: Date, date2: Date): boolean;
+/**
+ * Check if two dates are in the same minute
+ * @param date1 - first date
+ * @param date2 - second date
+ */
+export declare function isSameMinute(date1: Date, date2: Date): boolean;
+/**
+ * Check if two dates are in the same second
+ * @param date1 - first date
+ * @param date2 - second date
+ */
+export declare function isSameSecond(date1: Date, date2: Date): boolean;
+/**
+ * Check if a date is in a specific quarter
+ * @param date - date to check
+ * @param quarter - quarter (1-4)
+ */
+export declare function isInQuarter(date: Date, quarter: 1 | 2 | 3 | 4): boolean;
+/**
+ * Check if two dates are in the same quarter
+ * @param date1 - first date
+ * @param date2 - second date
+ */
+export declare function isSameQuarter(date1: Date, date2: Date): boolean;
 //# sourceMappingURL=validate.d.ts.map

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

@@ -1 +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;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAW5D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAK7D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAE5D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE9C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE/C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAE,IAAI,EAAO,GAAG,OAAO,CAIxE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAU5D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAU5D"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/validate.ts"],"names":[],"mappings":"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"}