@nivinjoseph/n-date 1.0.1

package/dist/date-time.js

@@ -0,0 +1,753 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { given } from "@nivinjoseph/n-defensive";
+import { DateTime as LuxonDateTime, Interval as LuxonInterval } from "luxon";
+import { Serializable, serialize, Duration, TypeHelper } from "@nivinjoseph/n-util";
+import { DateTimeFormat, DateTimeFormat_DEFAULT } from "./date-time-format.js";
+/**
+ * A robust date and time handling system with timezone support.
+ * This class provides comprehensive functionality for date/time manipulation, comparison, and formatting.
+ *
+ * @example
+ * ```typescript
+ * const now = DateTime.now("UTC");
+ * const future = now.addTime(Duration.fromHours(2));
+ * const isAfter = future.isAfter(now);
+ * ```
+ */
+let DateTime = (() => {
+    let _classDecorators = [serialize("Ndate")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Serializable;
+    let _instanceExtraInitializers = [];
+    let _get_value_decorators;
+    let _get_zone_decorators;
+    var DateTime = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _get_value_decorators = [serialize];
+            _get_zone_decorators = [serialize];
+            __esDecorate(this, null, _get_value_decorators, { kind: "getter", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _get_zone_decorators, { kind: "getter", name: "zone", static: false, private: false, access: { has: obj => "zone" in obj, get: obj => obj.zone }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DateTime = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static _fixedNow = null;
+        static _relativeNow = null;
+        _value = __runInitializers(this, _instanceExtraInitializers);
+        _zone;
+        _dateTime;
+        _timestamp;
+        _dateCode;
+        _timeCode;
+        _dateValue;
+        _timeValue;
+        /**
+         * Gets the system's local timezone.
+         *
+         * @returns The local timezone identifier.
+         */
+        static get currentZone() { return LuxonDateTime.local().zoneName; }
+        /**
+         * Gets the formatted date and time string.
+         */
+        get value() { return this._value; }
+        /**
+         * Gets the timezone identifier.
+         */
+        get zone() { return this._zone; }
+        /**
+         * Gets the Unix timestamp in seconds.
+         */
+        get timestamp() { return this._timestamp; }
+        /**
+         * Gets the date code in YYYYMMDD format.
+         */
+        get dateCode() { return this._dateCode; }
+        /**
+         * Gets the time code in HHMMSS format.
+         */
+        get timeCode() { return this._timeCode; }
+        /**
+         * Gets the date value in YYYY-MM-DD format.
+         */
+        get dateValue() { return this._dateValue; }
+        /**
+         * Gets the time value in HH:mm:ss format.
+         */
+        get timeValue() { return this._timeValue; }
+        /**
+         * Gets whether this DateTime is in the past.
+         */
+        get isPast() { return this.isBefore(DateTime.now()); }
+        /**
+         * Gets whether this DateTime is in the future.
+         */
+        get isFuture() { return this.isAfter(DateTime.now()); }
+        /**
+         * Creates a new DateTime instance.
+         *
+         * @param data - The DateTime data containing value and zone.
+         * @throws Error if the value or zone is invalid.
+         */
+        constructor(data) {
+            super(data);
+            let { value, zone } = data;
+            given(value, "value").ensureHasValue().ensureIsString();
+            value = value.trim()
+                .split("")
+                .take(DateTimeFormat.yearMonthDayHourMinuteSecond.length)
+                .join("");
+            if (value.matchesFormat("####"))
+                value = `${value}-01`; // MM
+            if (value.matchesFormat("####-##"))
+                value = `${value}-01`; // dd
+            if (value.matchesFormat("####-##-##"))
+                value = `${value} 00`; // HH
+            if (value.matchesFormat("####-##-## ##"))
+                value = `${value}:00`; // mm
+            if (value.matchesFormat("####-##-## ##:##"))
+                value = `${value}:00`; // ss
+            given(value, "value")
+                .ensure(t => t.matchesFormat("####-##-## ##:##:##"), "Invalid format");
+            const [date, time] = value.split(" ");
+            const dateSplit = date.split("-");
+            // const _year = Number.parseInt(dateSplit[0]);
+            const month = Number.parseInt(dateSplit[1]);
+            const day = Number.parseInt(dateSplit[2]);
+            given(month, "month").ensureHasValue().ensureIsNumber().ensure(t => t >= 1 && t <= 12);
+            given(day, "day").ensureHasValue().ensureIsNumber().ensure(t => t >= 1 && t <= 31);
+            const timeSplit = time.split(":");
+            const hour = Number.parseInt(timeSplit[0]);
+            const minute = Number.parseInt(timeSplit[1]);
+            const second = Number.parseInt(timeSplit[2]);
+            given(hour, "hour").ensureHasValue().ensureIsNumber().ensure(t => t >= 0 && t <= 23);
+            given(minute, "minute").ensureHasValue().ensureIsNumber().ensure(t => t >= 0 && t <= 59);
+            given(second, "second").ensureHasValue().ensureIsNumber().ensure(t => t >= 0 && t <= 59);
+            given(zone, "zone").ensureHasValue().ensureIsString();
+            zone = zone.trim();
+            if (zone.toLowerCase() === "utc")
+                zone = zone.toLowerCase();
+            DateTime._validateZone(zone);
+            const dateTime = LuxonDateTime.fromFormat(value, DateTimeFormat.yearMonthDayHourMinuteSecond, { zone });
+            given(data, "data")
+                .ensure(_ => dateTime.isValid, `value and zone is invalid (${dateTime.invalidReason}: ${dateTime.invalidExplanation})`);
+            this._value = value;
+            this._zone = zone;
+            this._dateTime = dateTime;
+            this._timestamp = this._dateTime.toUnixInteger();
+            this._dateCode = dateSplit.join("");
+            this._timeCode = timeSplit.join("");
+            this._dateValue = date;
+            this._timeValue = time;
+        }
+        /**
+         * Sets a fixed timestamp for testing purposes. All calls to DateTime.now() will return this fixed time.
+         *
+         * @param timestamp - The Unix timestamp in seconds to use as the fixed "now" time.
+         * @throws Error if timestamp is not a valid number.
+         */
+        static useFixedNow(timestamp) {
+            given(timestamp, "timestamp").ensureHasValue().ensureIsNumber();
+            DateTime._fixedNow = timestamp;
+            DateTime._relativeNow = null;
+        }
+        /**
+         * Sets a relative timestamp for testing purposes. DateTime.now() will return times relative to this base timestamp,
+         * advancing as real time advances.
+         *
+         * @param timestamp - The Unix timestamp in seconds to use as the base "now" time.
+         * @throws Error if timestamp is not a valid number.
+         */
+        static useRelativeNow(timestamp) {
+            given(timestamp, "timestamp").ensureHasValue().ensureIsNumber();
+            DateTime._relativeNow = {
+                baseTimestamp: timestamp,
+                baseRealTime: Date.now()
+            };
+            DateTime._fixedNow = null;
+        }
+        /**
+         * Resets any fixed or relative "now" time set by useFixedNow or useRelativeNow.
+         * DateTime.now() will return the actual current time after calling this method.
+         */
+        static resetFixedOrRelativeNow() {
+            DateTime._fixedNow = null;
+            DateTime._relativeNow = null;
+        }
+        /**
+         * Creates a DateTime instance for the current time.
+         *
+         * @param zone - The timezone identifier. If not specified, UTC is used.
+         * @returns A new DateTime instance representing the current time.
+         */
+        static now(zone) {
+            given(zone, "zone").ensureIsString();
+            // Check if we're using fixed or relative now for testing
+            let timestamp = null;
+            if (DateTime._fixedNow !== null) {
+                timestamp = DateTime._fixedNow;
+            }
+            else if (DateTime._relativeNow !== null) {
+                const elapsedMs = Date.now() - DateTime._relativeNow.baseRealTime;
+                timestamp = DateTime._relativeNow.baseTimestamp + Math.floor(elapsedMs / 1000);
+            }
+            // If we have a timestamp, use it
+            if (timestamp !== null) {
+                const targetZone = zone ?? "utc";
+                return DateTime.createFromTimestamp(timestamp, targetZone);
+            }
+            // Otherwise, use real current time
+            if (zone != null) {
+                return new DateTime({
+                    value: LuxonDateTime.now().setZone(zone).toFormat(DateTimeFormat_DEFAULT),
+                    zone
+                });
+            }
+            else {
+                return new DateTime({
+                    value: LuxonDateTime.utc().toFormat(DateTimeFormat_DEFAULT),
+                    zone: "utc"
+                });
+            }
+        }
+        /**
+         * Creates a DateTime from a Unix timestamp.
+         *
+         * @param timestamp - The number of seconds since the Unix epoch.
+         * @param zone - The timezone identifier.
+         * @returns A new DateTime instance.
+         */
+        static createFromTimestamp(timestamp, zone) {
+            given(timestamp, "timestamp").ensureHasValue().ensureIsNumber();
+            given(zone, "zone").ensureHasValue().ensureIsString();
+            const dateTimeString = LuxonDateTime.fromSeconds(timestamp)
+                .setZone(zone).toFormat(DateTimeFormat_DEFAULT);
+            return new DateTime({
+                value: dateTimeString,
+                zone
+            });
+        }
+        /**
+         * Creates a DateTime from milliseconds since the Unix epoch.
+         *
+         * @param milliseconds - The number of milliseconds since the Unix epoch.
+         * @param zone - The timezone identifier.
+         * @returns A new DateTime instance.
+         */
+        static createFromMilliSecondsSinceEpoch(milliseconds, zone) {
+            given(milliseconds, "milliseconds").ensureHasValue().ensureIsNumber();
+            given(zone, "zone").ensureHasValue().ensureIsString();
+            const dateTimeString = LuxonDateTime.fromMillis(milliseconds)
+                .setZone(zone).toFormat(DateTimeFormat_DEFAULT);
+            return new DateTime({
+                value: dateTimeString,
+                zone
+            });
+        }
+        /**
+         * Creates a DateTime from date and time codes.
+         *
+         * @param dateCode - The date code in YYYYMMDD format.
+         * @param timeCode - The time code in HHMM format.
+         * @param zone - The timezone identifier.
+         * @returns A new DateTime instance.
+         */
+        static createFromCodes(dateCode, timeCode, zone) {
+            given(dateCode, "dateCode").ensureHasValue().ensureIsString()
+                .ensure(t => t.matchesFormat("########"));
+            given(timeCode, "timeCode").ensureHasValue().ensureIsString()
+                .ensure(t => t.matchesFormat("######"));
+            given(zone, "zone").ensureHasValue().ensureIsString();
+            const dateCodeSplit = dateCode.split("");
+            const timeCodeSplit = timeCode.split("");
+            const year = dateCodeSplit.take(4).join("");
+            const month = dateCodeSplit.skip(4).take(2).join("");
+            const day = dateCodeSplit.skip(6).join("");
+            const hour = timeCodeSplit.take(2).join("");
+            const minute = timeCodeSplit.skip(2).take(2).join("");
+            const second = timeCodeSplit.skip(4).join("");
+            const dateTimeString = `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+            return new DateTime({
+                value: dateTimeString,
+                zone
+            });
+        }
+        /**
+         * Creates a DateTime from date and time values.
+         *
+         * @param dateValue - The date in YYYY-MM-DD format.
+         * @param timeValue - The time in HH:mm format.
+         * @param zone - The timezone identifier.
+         * @returns A new DateTime instance.
+         */
+        static createFromValues(dateValue, timeValue, zone) {
+            given(dateValue, "dateValue").ensureHasValue().ensureIsString()
+                .ensure(t => t.matchesFormat("####-##-##"));
+            given(timeValue, "timeValue").ensureHasValue().ensureIsString()
+                .ensure(t => t.matchesFormat("##:##:##"));
+            given(zone, "zone").ensureHasValue().ensureIsString();
+            const dateTimeString = `${dateValue} ${timeValue}`;
+            return new DateTime({
+                value: dateTimeString,
+                zone
+            });
+        }
+        /**
+         * Returns the earlier of two DateTime instances.
+         *
+         * @param dateTime1 - The first DateTime instance.
+         * @param dateTime2 - The second DateTime instance.
+         * @returns The earlier DateTime instance.
+         */
+        static min(dateTime1, dateTime2) {
+            given(dateTime1, "dateTime1").ensureHasValue().ensureIsType(DateTime);
+            given(dateTime2, "dateTime2").ensureHasValue().ensureIsType(DateTime);
+            if (dateTime1.valueOf() < dateTime2.valueOf())
+                return dateTime1;
+            return dateTime2;
+        }
+        /**
+         * Returns the later of two DateTime instances.
+         *
+         * @param dateTime1 - The first DateTime instance.
+         * @param dateTime2 - The second DateTime instance.
+         * @returns The later DateTime instance.
+         */
+        static max(dateTime1, dateTime2) {
+            given(dateTime1, "dateTime1").ensureHasValue().ensureIsType(DateTime);
+            given(dateTime2, "dateTime2").ensureHasValue().ensureIsType(DateTime);
+            if (dateTime1.valueOf() > dateTime2.valueOf())
+                return dateTime1;
+            return dateTime2;
+        }
+        /**
+         * Validates if a string matches the DateTime format "yyyy-MM-dd HH:mm".
+         *
+         * @param value - The string to validate.
+         * @returns True if the string matches the format, false otherwise.
+         */
+        static validateDateTimeFormat(value, format) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (value == null || value.isEmptyOrWhiteSpace())
+                return false;
+            return LuxonDateTime.fromFormat(value, format).isValid;
+        }
+        /**
+         * Validates if a string matches the date format "yyyy-MM-dd".
+         *
+         * @param value - The string to validate.
+         * @returns True if the string matches the format, false otherwise.
+         */
+        static validateDateFormat(value) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (value == null || value.isEmptyOrWhiteSpace())
+                return false;
+            return LuxonDateTime.fromFormat(value, "yyyy-MM-dd").isValid;
+        }
+        /**
+         * Validates if a string matches the time format  "HH:mm".
+         *
+         * @param value - The string to validate.
+         * @returns True if the string matches the format, false otherwise.
+         */
+        static validateTimeFormat(value) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (value == null || value.isEmptyOrWhiteSpace())
+                return false;
+            return LuxonDateTime.fromFormat(value, "HH:mm").isValid;
+        }
+        /**
+         * Validates if a string is a valid timezone.
+         *
+         * @param zone - The timezone string to validate.
+         * @returns True if the timezone is valid, false otherwise.
+         */
+        static validateTimeZone(zone) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (zone == null || zone.isEmptyOrWhiteSpace())
+                return false;
+            try {
+                DateTime._validateZone(zone);
+            }
+            catch {
+                return false;
+            }
+            return LuxonDateTime.now().setZone(zone).isValid;
+        }
+        /**
+         * Validates a timezone string.
+         *
+         * @param zone - The timezone string to validate.
+         * @throws Error if the timezone is invalid.
+         * @private
+         */
+        static _validateZone(zone) {
+            zone = zone.trim();
+            if (zone.toLowerCase() === "utc")
+                return;
+            given(zone, "zone")
+                .ensureWhen(zone.toLowerCase() === "local", _ => false, "should not use local zone")
+                .ensureWhen(zone.toLowerCase().startsWith("utc+"), t => {
+                // range is +00:00 to +14:00 (https://en.wikipedia.org/wiki/List_of_UTC_offsets)
+                let offset = t.split("+").takeLast().trim();
+                if (!offset.contains(":"))
+                    offset = `${offset}:00`;
+                const [hour, minute] = offset.split(":").map(t => TypeHelper.parseNumber(t));
+                if (hour == null || minute == null)
+                    return false;
+                return (hour >= 0 && hour < 14 && minute >= 0 && minute < 60)
+                    || (hour === 14 && minute === 0);
+            }, "Invalid UTC offset for zone")
+                .ensureWhen(zone.toLowerCase().startsWith("utc-"), t => {
+                // range is -00:00 to -12:00 (https://en.wikipedia.org/wiki/List_of_UTC_offsets)
+                let offset = t.split("-").takeLast();
+                if (!offset.contains(":"))
+                    offset = `${offset}:00`;
+                const [hour, minute] = offset.split(":").map(t => TypeHelper.parseNumber(t));
+                if (hour == null || minute == null)
+                    return false;
+                return hour >= 0 && hour < 12 && minute >= 0 && minute < 60
+                    || (hour === 12 && minute === 0);
+            }, "Invalid UTC offset for zone");
+        }
+        /**
+         * Gets the numeric value of this DateTime.
+         *
+         * @returns The milliseconds since the Unix epoch.
+         */
+        valueOf() {
+            return this._dateTime.valueOf();
+        }
+        /**
+         * Compares this DateTime with another for equality.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if the DateTime instances are equal, false otherwise.
+         */
+        equals(value) {
+            given(value, "value").ensureIsType(DateTime);
+            if (value == null)
+                return false;
+            if (value === this)
+                return true;
+            return value.value === this._value && value.zone === this._zone;
+        }
+        /**
+         * Returns the string representation of this DateTime.
+         *
+         * @returns The string representation in the format "YYYY-MM-DD HH:mm:ss zone".
+         */
+        toString() {
+            return `${this._value} ${this._zone}`;
+        }
+        /**
+         * Returns the date and time string.
+         *
+         * @returns The string in the format "YYYY-MM-DD HH:mm:ss".
+         */
+        toStringDateTime() {
+            return this._value;
+        }
+        /**
+         * Returns the ISO string representation.
+         *
+         * @returns The ISO 8601 string representation.
+         */
+        toStringISO() {
+            return this._dateTime.toISO({ format: "extended", includeOffset: true });
+        }
+        /**
+         * Formats a DateTime object to a string using the specified format
+         * @param dateTime The DateTime object to format
+         * @param format The format to use (defaults to yearMonthDayHourMinute: "yyyy-MM-dd HH:mm")
+         * @returns The formatted datetime string
+         */
+        format(format = DateTimeFormat.yearMonthDayHourMinuteSecond) {
+            // For the default format, use the built-in toStringDateTime()
+            if (format === DateTimeFormat.yearMonthDayHourMinuteSecond)
+                return this.toStringDateTime();
+            // For other formats, parse and reformat
+            const value = this.toStringDateTime();
+            // Parse the value (format: "yyyy-MM-dd HH:mm:ss")
+            const [date, time] = value.split(" ");
+            const [year, month, day] = date.split("-");
+            const [hour, minute, _second] = time.split(":");
+            switch (format) {
+                case DateTimeFormat.yearMonthDayHourMinute:
+                    return `${year}-${month}-${day} ${hour}:${minute}`;
+                case DateTimeFormat.yearMonthDayHour:
+                    return `${year}-${month}-${day} ${hour}`;
+                case DateTimeFormat.yearMonthDay:
+                    return `${year}-${month}-${day}`;
+                case DateTimeFormat.yearMonth:
+                    return `${year}-${month}`;
+                case DateTimeFormat.year:
+                    return year;
+                default:
+                    return value;
+            }
+        }
+        /**
+         * Formats a DateTime object to a string using extended format capabilities.
+         * This method leverages Luxon's full formatting capabilities for more complex formatting needs.
+         *
+         * @param format - The format string to use. Can be a predefined DateTimeFormatExt or any custom Luxon format string.
+         * @returns The formatted datetime string.
+         *
+         * @example
+         * ```typescript
+         * const dt = DateTime.now("America/New_York");
+         * dt.formatExt("DD HH:mm:ss"); // "Jul 2, 2023 15:30:20"
+         * dt.formatExt("MMMM d, yyyy"); // "July 2, 2023"
+         * dt.formatExt("EEEE DD"); // "Friday Jul 2, 2023"
+         *
+         * export type DateTimeFormatExt =
+            "DD HH:mm:ss" // Jul 2, 2023 15:30:20
+            | "MMMM d, HH:mm:ss"  // Jul 2 15:30:20
+            | "DD HH:mm" // Jul 2, 2023 15:30
+            | "MMMM d, HH:mm"  // Jul 2 15:30
+            | "yyyy/LL/dd" // 2023/07/21
+            | "yyyy/LL/dd HH:mm:ss"
+            | "yyyy/LL/dd HH:mm"
+            | "yyyy-MM-dd" // 2023-07-21
+            | "HH:mm:ss" // 15:30:20
+            | "HH:mm" // 15:30
+            | "DDD" // July 21, 2023
+            | "DD" // Jul 21, 2023
+            | "yyyy-MM" // 2023-07
+            | "MMMM yyyy" // July 2023
+            | "DDDD" // Sunday, July 9, 2023
+            | "EEEE DD" // Friday Aug 4, 2023
+            | "LLL yyyy" // Jul 2025
+            | "LLLL yyyy" // July 2025
+            | "MMMM d" // November 2
+            | "LLL d" // Nov 2
+            ;
+         *
+         * ```
+         */
+        formatExt(format) {
+            given(format, "format").ensureHasValue().ensureIsString();
+            return this._dateTime.toFormat(format);
+        }
+        /**
+         * Checks if this DateTime represents the same instant as another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if the DateTime instances represent the same instant, false otherwise.
+         */
+        isSame(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return this.valueOf() === value.valueOf();
+        }
+        /**
+         * Checks if this DateTime is before another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if this DateTime is before the other, false otherwise.
+         */
+        isBefore(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return this.valueOf() < value.valueOf();
+        }
+        /**
+         * Checks if this DateTime is the same or before another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if this DateTime is the same or before the other, false otherwise.
+         */
+        isSameOrBefore(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return this.valueOf() <= value.valueOf();
+        }
+        /**
+         * Checks if this DateTime is after another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if this DateTime is after the other, false otherwise.
+         */
+        isAfter(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return this.valueOf() > value.valueOf();
+        }
+        /**
+         * Checks if this DateTime is the same or after another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if this DateTime is the same or after the other, false otherwise.
+         */
+        isSameOrAfter(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return this.valueOf() >= value.valueOf();
+        }
+        /**
+         * Checks if this DateTime is between two others.
+         *
+         * @param start - The start DateTime.
+         * @param end - The end DateTime.
+         * @returns True if this DateTime is between start and end, false otherwise.
+         * @throws Error if end is before start.
+         */
+        isBetween(start, end) {
+            given(start, "start").ensureHasValue().ensureIsType(DateTime);
+            given(end, "end").ensureHasValue().ensureIsType(DateTime)
+                .ensure(t => t.isSameOrAfter(start), "must be same or after start");
+            return this.isSameOrAfter(start) && this.isSameOrBefore(end);
+        }
+        /**
+         * Calculates the time difference between this DateTime and another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns A Duration representing the time difference.
+         */
+        timeDiff(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return Duration.fromMilliSeconds(Math.abs(this.valueOf() - value.valueOf()));
+        }
+        /**
+         * Calculates the days difference between this DateTime and another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns The number of days difference.
+         */
+        daysDiff(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            return Math.abs(Number.parseInt(this._dateTime.diff(value._dateTime, ["days"]).days.toString()));
+        }
+        /**
+         * Checks if this DateTime is on the same day as another.
+         *
+         * @param value - The DateTime to compare with.
+         * @returns True if the DateTime instances are on the same day, false otherwise.
+         */
+        isSameDay(value) {
+            given(value, "value").ensureHasValue().ensureIsType(DateTime);
+            const daysDiff = this._dateTime.diff(value._dateTime, ["days"]).days;
+            return Math.abs(daysDiff) < 1;
+        }
+        /**
+         * Adds a duration to this DateTime. this accounts for shift in DST
+         *
+         * @param time - The duration to add.
+         * @returns A new DateTime instance with the duration added.
+         */
+        addTime(time) {
+            given(time, "time").ensureHasValue().ensureIsObject().ensureIsInstanceOf(Duration);
+            return new DateTime({
+                value: this._dateTime.plus({ milliseconds: time.toMilliSeconds() }).toFormat(DateTimeFormat_DEFAULT),
+                zone: this._zone
+            });
+        }
+        /**
+         * Subtracts a duration from this DateTime. this accounts for shift in DST
+         *
+         * @param time - The duration to subtract.
+         * @returns A new DateTime instance with the duration subtracted.
+         */
+        subtractTime(time) {
+            given(time, "time").ensureHasValue().ensureIsObject().ensureIsInstanceOf(Duration);
+            return new DateTime({
+                value: this._dateTime.minus({ milliseconds: time.toMilliSeconds() }).toFormat(DateTimeFormat_DEFAULT),
+                zone: this._zone
+            });
+        }
+        /**
+         * Adds days to this DateTime. this doesn't change time based on DST
+         *
+         * @param days - The number of days to add.
+         * @returns A new DateTime instance with the days added.
+         * @throws Error if days is not a positive integer.
+         */
+        addDays(days) {
+            given(days, "days").ensureHasValue().ensureIsNumber()
+                .ensure(t => t >= 0 && Number.isInteger(t), "days should be positive integer");
+            return new DateTime({
+                value: this._dateTime.plus({ days }).toFormat(DateTimeFormat_DEFAULT),
+                zone: this._zone
+            });
+        }
+        /**
+         * Subtracts days from this DateTime. this doesn't change time based on DST
+         *
+         * @param days - The number of days to subtract.
+         * @returns A new DateTime instance with the days subtracted.
+         * @throws Error if days is not a positive integer.
+         */
+        subtractDays(days) {
+            given(days, "days").ensureHasValue().ensureIsNumber()
+                .ensure(t => t >= 0 && Number.isInteger(t), "days should be positive integer");
+            return new DateTime({
+                value: this._dateTime.minus({ days }).toFormat(DateTimeFormat_DEFAULT),
+                zone: this._zone
+            });
+        }
+        /**
+         * Gets an array of DateTime instances for each day of the month.
+         *
+         * @returns An array of DateTime instances, where:
+         * - First element is the start of the month (e.g., "2023-06-01 00:00")
+         * - Last element is the end of the month (e.g., "2023-06-30 23:59")
+         * - Elements in between represent the start of each day (e.g., "2023-06-11 00:00")
+         */
+        getDaysOfMonth() {
+            const startOfMonth = this._dateTime.startOf("month");
+            const endOfMonth = this._dateTime.endOf("month");
+            const luxonDays = LuxonInterval.fromDateTimes(startOfMonth, endOfMonth).splitBy({ days: 1 })
+                .map((t) => t.start);
+            luxonDays[0] = startOfMonth;
+            luxonDays[luxonDays.length - 1] = endOfMonth;
+            return luxonDays.map(t => new DateTime({
+                value: t.toFormat(DateTimeFormat_DEFAULT),
+                zone: this._zone
+            }));
+        }
+        /**
+         * Converts this DateTime to a different timezone.
+         *
+         * @param zone - The target timezone.
+         * @returns A new DateTime instance in the specified timezone.
+         * @throws Error if the timezone is invalid.
+         */
+        convertToZone(zone) {
+            given(zone, "zone").ensureHasValue().ensureIsString()
+                .ensure(t => DateTime.validateTimeZone(t));
+            if (zone === this.zone)
+                return this;
+            const newDateTime = this._dateTime.setZone(zone).toFormat(DateTimeFormat_DEFAULT);
+            return new DateTime({
+                value: newDateTime,
+                zone
+            });
+        }
+        /**
+         * Checks if this DateTime is within a time range.
+         *
+         * @param startTimeCode - The start time code in HHMM format.
+         * @param endTimeCode - The end time code in HHMM format.
+         * @returns True if this DateTime is within the time range, false otherwise.
+         * @throws Error if the time codes are invalid or if endTimeCode is before startTimeCode.
+         */
+        isWithinTimeRange(startTimeCode, endTimeCode) {
+            given(startTimeCode, "startTimeCode").ensureHasValue().ensureIsString()
+                .ensure(t => t.matchesFormat("######"))
+                .ensure(t => Number.parseInt(t) >= 0 && Number.parseInt(t) <= 235959);
+            given(endTimeCode, "endTimeCode").ensureHasValue().ensureIsString()
+                .ensure(t => t.matchesFormat("######"))
+                .ensure(t => Number.parseInt(t) >= 0 && Number.parseInt(t) <= 235959)
+                .ensure(t => Number.parseInt(t) >= Number.parseInt(startTimeCode), "must be >= startTimeCode");
+            const startDateTime = DateTime.createFromCodes(this.dateCode, startTimeCode, this.zone);
+            const endDateTime = DateTime.createFromCodes(this.dateCode, endTimeCode, this.zone);
+            return this.isBetween(startDateTime, endDateTime);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return DateTime = _classThis;
+})();
+export { DateTime };
+//# sourceMappingURL=date-time.js.map