@acorex/core 16.0.2 → 17.0.1

package/fesm2022/acorex-core-date-time.mjs

@@ -0,0 +1,1305 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, Pipe, NgModule } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { AX_GLOBAL_CONFIG } from '@acorex/core/config';
+import { defaults, orderBy, set, isNil } from 'lodash-es';
+import { isBrowser } from '@acorex/core/platform';
+import { translateSync } from '@acorex/core/translation';
+import { AXEventTypes, AXEventService } from '@acorex/core/events';
+import * as i1 from '@acorex/core/format';
+import { AXFormatModule } from '@acorex/core/format';
+
+class AXCalendar {
+    /**
+     * @ignore
+     */
+    constructor(config) {
+        this._config = config;
+    }
+    get weekend() {
+        return this._config.weekend;
+    }
+    get formats() {
+        return this._config.formats;
+    }
+    get weekdays() {
+        return this._config.weekdays;
+    }
+}
+class AXDateTime {
+    get date() {
+        return this._date;
+    }
+    get calendar() {
+        return this._calendar;
+    }
+    constructor(value, calendar) {
+        //TODO: remove unused items
+        this._formatKeys = {
+            ss: () => this.pad(this.date.getSeconds(), 2),
+            s: () => this.date.getSeconds().toString(),
+            //
+            dd: () => this.pad(this.calendar.dayOfMonth(this.date), 2),
+            DD: () => this.pad(this.calendar.dayOfMonth(this.date), 2),
+            d: () => this.calendar.dayOfMonth(this.date).toString(),
+            //
+            mm: () => this.pad(this.date.getMinutes(), 2),
+            m: () => this.date.getMinutes().toString(),
+            //
+            MMMM: () => translateSync(`dateTime.months.${this.calendar.name()}.long.${this.calendar.monthOfYear(this.date) - 1}`),
+            MMM: () => translateSync(`dateTime.months.${this.calendar.name()}.short.${this.calendar.monthOfYear(this.date) - 1}`),
+            MM: () => this.pad(this.calendar.monthOfYear(this.date), 2),
+            M: () => this.calendar.monthOfYear(this.date),
+            //
+            E: () => translateSync(`dateTime.weekdays.long.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            DDD: () => translateSync(`dateTime.weekdays.short.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            DDDD: () => this._formatKeys['E'](),
+            //
+            yyyy: () => this.pad(this.calendar.year(this.date), 4),
+            YYYY: () => this.pad(this.calendar.year(this.date), 4),
+            yy: () => this.pad(this.calendar.year(this.date), 4).substring(2),
+            YY: () => this.pad(this.calendar.year(this.date), 4).substring(2),
+            //
+            HH: () => this.pad(this.date.getHours(), 2),
+            H: () => this.date.getHours().toString(),
+            //
+            hh: () => this.pad(this.date.getHours() % 12 || 12, 2),
+            h: () => (this.date.getHours() % 12 || 12).toString(),
+            //
+            A: () => (this.date.getHours() < 12 ? 'am' : 'pm'),
+            a: () => (this.date.getHours() < 12 ? 'am' : 'pm'),
+            date: (options) => this.format(this.getDateTimeFormatByLocale(options.locale, 'shortDate')),
+            shortDate: (options) => this.format(this.getDateTimeFormatByLocale(options.locale, 'shortDate')),
+            longDate: (options) => this.format(this.getDateTimeFormatByLocale(options.locale, 'longDate')),
+            //
+            shortTime: (options) => this.format(this.getDateTimeFormatByLocale(options.locale, 'shortTime')),
+            time: (options) => this.format(this.getDateTimeFormatByLocale(options.locale, 'shortTime')),
+            longTime: (options) => this.format(this.getDateTimeFormatByLocale(options.locale, 'longTime')),
+            //
+            datetime: (options) => this.format('date time', { locale: options.locale }),
+        };
+        this._language = () => (isBrowser() ? navigator.language : 'en-GB');
+        this._calendar = calendar;
+        this._date = value;
+    }
+    clone() {
+        return new AXDateTime(this.date, this.calendar);
+    }
+    get dayOfMonth() {
+        return this._calendar.dayOfMonth(this.date);
+    }
+    get dayOfYear() {
+        return this._calendar.dayOfYear(this.date);
+    }
+    get dayOfWeek() {
+        return this._calendar.dayOfWeek(this.date);
+    }
+    get hour() {
+        return this._date.getHours();
+    }
+    get minute() {
+        return this._date.getMinutes();
+    }
+    get second() {
+        return this._date.getSeconds();
+    }
+    get year() {
+        return this._calendar.year(this.date);
+    }
+    get monthOfYear() {
+        return this._calendar.monthOfYear(this.date);
+    }
+    get weekOfYear() {
+        return this._calendar.weekOfYear(this.date);
+    }
+    get month() {
+        return new AXCalendarMonth(this);
+    }
+    add(unit, amount) {
+        return this._calendar.add(this.date, unit, amount);
+    }
+    set(unit = 'day', value) {
+        return this._calendar.set(this.date, unit, value);
+    }
+    duration(end) {
+        const date = end instanceof AXDateTime ? end.date : end;
+        const val = new AXDateTime(date, this.calendar);
+        const range = new AXDateTimeRange(this, val);
+        return range.duration();
+    }
+    startOf(unit = 'day') {
+        return this._calendar.startOf(this.date, unit);
+    }
+    endOf(unit = 'day') {
+        return this._calendar.endOf(this.date, unit);
+    }
+    format(format = this.getDateTimeFormatByLocale(this._language(), 'shortDate'), options) {
+        const effectiveOptions = defaults({}, options, {
+            locale: this._language(),
+        });
+        const re = new RegExp(orderBy(Object.keys(this._formatKeys), (c) => c.length, ['desc']).join('|'), 'gi');
+        return format.replace(re, (matched) => {
+            const f = this._formatKeys[matched];
+            const r = f(effectiveOptions);
+            return r;
+        });
+    }
+    getDateTimeFormatByLocale(locale, style) {
+        let options = {};
+        switch (style) {
+            case 'shortDate': // Year, Month, Day
+                options = { year: 'numeric', month: '2-digit', day: '2-digit' };
+                break;
+            case 'longDate': // Weekday, Month name, Day, Year
+                options = {
+                    weekday: 'long',
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                };
+                break;
+            case 'shortTime': // Hour, Minute
+                options = { hour: '2-digit', minute: '2-digit', hour12: false };
+                break;
+            case 'longTime': // Hour, Minute, Second
+                options = {
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    hour12: false,
+                };
+                break;
+        }
+        const formatter = new Intl.DateTimeFormat(locale, options);
+        // Get parts of the date and/or time
+        const parts = formatter.formatToParts(new Date());
+        // Map parts to their respective format
+        const formatMap = {
+            day: 'dd',
+            month: style == 'longDate' ? 'MMMM' : 'MM',
+            year: 'yyyy',
+            hour: 'HH',
+            minute: 'mm',
+            second: 'ss',
+            weekday: 'E',
+            literal: '',
+        };
+        // Construct the date and/or time format string
+        return parts
+            .map((part) => {
+            if (part.type === 'literal') {
+                // Use the literal part directly as separator
+                return part.value;
+            }
+            else {
+                return formatMap[part.type] || part.value;
+            }
+        })
+            .join('');
+    }
+    pad(n, width, z = '0') {
+        n = n + '';
+        return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+    }
+    equal(value, unit = 'day') {
+        return this.compare(value, unit) == 0;
+    }
+    compare(value, unit = 'day') {
+        const date = value instanceof AXDateTime ? value.date : value;
+        const val = new AXDateTime(date, this.calendar);
+        const func = (v1, v2) => {
+            if (v1 == v2) {
+                return 0;
+            }
+            else if (v1 > v2) {
+                return 1;
+            }
+            else {
+                return -1;
+            }
+        };
+        let p = 0;
+        switch (unit) {
+            case 'year':
+                return func(this.year, val.year);
+            case 'week':
+                p = this.compare(val, 'year');
+                return p == 0 ? func(this.weekOfYear, val.weekOfYear) : p;
+            case 'month':
+                p = this.compare(val, 'year');
+                return p == 0 ? func(this.monthOfYear, val.monthOfYear) : p;
+            case 'day':
+                p = this.compare(val, 'year');
+                return p == 0 ? func(this.dayOfYear, val.dayOfYear) : p;
+            case 'hour':
+                p = this.compare(val, 'day');
+                return p == 0 ? func(this.hour, val.hour) : p;
+            case 'minute':
+                p = this.compare(val, 'hour');
+                return p == 0 ? func(this.minute, val.minute) : p;
+            case 'second':
+                p = this.compare(val, 'minute');
+                return p == 0 ? func(this.second, val.second) : p;
+            default:
+                return func(this.date.getTime(), val.date.getTime());
+        }
+    }
+}
+class AXCalendarMonth {
+    get range() {
+        return this._range;
+    }
+    set range(v) {
+        this._range = v;
+    }
+    get totalDays() {
+        return this.range.endTime.dayOfMonth;
+    }
+    constructor(date) {
+        this.index = date.date.getMonth();
+        this.name = date.format('MMMM');
+        this.range = new AXDateTimeRange(new AXDateTime(date.startOf('month').date, date.calendar), new AXDateTime(date.endOf('month').date, date.calendar));
+    }
+}
+class AXDateTimeRange {
+    get startTime() {
+        return this._startTime;
+    }
+    get endTime() {
+        return this._endTime;
+    }
+    constructor(startTime, endTime) {
+        this._startTime = startTime;
+        this._endTime = endTime;
+    }
+    duration() {
+        const result = {
+            miliseconds: 0,
+            seconds: 0,
+            minutes: 0,
+            hours: 0,
+            days: 0,
+            months: 0,
+            years: 0,
+            total: {
+                miliseconds: 0,
+                seconds: 0,
+                minutes: 0,
+                hours: 0,
+                days: 0,
+                weeks: 0,
+                months: 0,
+                years: 0,
+            },
+        };
+        const one_second = 1000;
+        const one_min = one_second * 60;
+        const one_hour = one_min * 60;
+        const one_day = one_hour * 24;
+        const one_week = one_day * 7;
+        const one_year = 365.25 * one_day;
+        const one_month = one_year / 12;
+        const startTime = this._startTime.date.getTime();
+        const endTime = this._endTime.date.getTime();
+        const diff = Math.abs(endTime - startTime);
+        //
+        result.total.miliseconds = diff;
+        result.total.seconds = Number((diff / one_second).toFixed(2));
+        result.total.minutes = Number((diff / one_min).toFixed(2));
+        result.total.hours = Number((diff / one_hour).toFixed(2));
+        result.total.days = Number((diff / one_day).toFixed(2));
+        result.total.weeks = Number((diff / one_week).toFixed(2));
+        //
+        // let months = (this.endTime.year - this.startTime.year) * 12;
+        // months += this.endTime.monthOfYear - this.startTime.monthOfYear + 1;
+        // if (this.endTime.dayOfYear < this.startTime.dayOfYear) {
+        //     months--;
+        // }
+        // result.total.months = Math.abs(months);
+        // TODO: review
+        result.total.months = Number((diff / one_month).toFixed(2));
+        result.total.years = Number((diff / one_year).toFixed(2));
+        //
+        result.miliseconds = result.total.miliseconds % 1000;
+        result.seconds = Number((result.total.seconds % 60).toFixed(0));
+        result.minutes = Number((result.total.minutes % 60).toFixed(0));
+        result.hours = Number((result.total.hours % 24).toFixed(0));
+        // TODO: review
+        result.days = Number((result.total.days % 30.4).toFixed(0));
+        result.months = Number((result.total.months % 12).toFixed(0));
+        result.years = Number(result.total.years.toFixed(0));
+        return result;
+    }
+    enumurate(unit = 'day', amount = 1) {
+        const result = [];
+        let item = this._startTime.clone();
+        while (item.compare(this._endTime, unit) < 1) {
+            if (!result.some((c) => c.equal(item, unit))) {
+                result.push(item);
+            }
+            item = item.add(unit, amount);
+        }
+        return result;
+    }
+}
+
+class GeorgianCalendar extends AXCalendar {
+    /**
+     * @ignore
+     */
+    constructor(config) {
+        super(config);
+    }
+    create(value) {
+        return new AXDateTime(new Date(value.year, value.month - 1, value.date, value.hours || 0, value.minutes || 0, value.seconds || 0, value.ms || 0), this);
+    }
+    name() {
+        return 'georgian';
+    }
+    dayOfMonth(date) {
+        return date.getDate();
+    }
+    dayOfYear(date) {
+        let result = 0;
+        let m = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+        if (this.isLeap(date)) {
+            m[1] = 29;
+        }
+        for (let i = 0; i < date.getMonth(); i++) {
+            result = result + m[i];
+        }
+        result += date.getDate();
+        return result;
+    }
+    dayOfWeek(date) {
+        return date.getDay() + 1;
+    }
+    weekOfYear(date) {
+        const firstDay = new AXDateTime(date, this).startOf('year');
+        return Math.ceil(((date.getTime() - firstDay.date.getTime()) / 86400000 +
+            firstDay.date.getDay() +
+            1) /
+            7);
+    }
+    year(date) {
+        return date.getFullYear();
+    }
+    monthOfYear(date) {
+        return date.getMonth() + 1;
+    }
+    add(date, unit, amount) {
+        let value = date.valueOf();
+        switch (unit) {
+            case 'second':
+                value += 1000 * amount;
+                break;
+            case 'minute':
+                value += 60000 * amount;
+                break;
+            case 'hour':
+                value += 3600000 * amount;
+                break;
+            case 'month': {
+                const v = new Date(value);
+                // Calculate the new year and month considering the amount
+                let newYear = v.getFullYear();
+                let newMonth = v.getMonth() + amount;
+                // Adjust for year overflow or underflow
+                while (newMonth > 11) {
+                    newMonth -= 12;
+                    newYear++;
+                }
+                while (newMonth < 0) {
+                    newMonth += 12;
+                    newYear--;
+                }
+                // Set the date to the first of the month to prevent overflow
+                v.setDate(1);
+                v.setFullYear(newYear);
+                v.setMonth(newMonth);
+                // Get the last day of the new month
+                const lastDayOfMonth = new Date(newYear, newMonth + 1, 0).getDate();
+                // Set the date to either the original day or the last day of the new month, whichever is smaller
+                const originalDay = date.getDate();
+                v.setDate(Math.min(originalDay, lastDayOfMonth));
+                value = v.valueOf();
+                break;
+            }
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break;
+            case 'year': {
+                const newDate = new Date(value);
+                newDate.setFullYear(newDate.getFullYear() + amount);
+                // Handling for leap years: if the original date is February 29th, and the new year is not a leap year,
+                // set the date to February 28th.
+                if (date.getMonth() === 1 &&
+                    date.getDate() === 29 &&
+                    newDate.getMonth() !== 1) {
+                    newDate.setMonth(1);
+                    newDate.setDate(28);
+                }
+                value = newDate.valueOf();
+                break;
+            }
+            case 'day':
+            default:
+                value += 86400000 * amount;
+        }
+        return new AXDateTime(new Date(value), this);
+    }
+    set(date, unit, value) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), value, clone.getMilliseconds());
+                break;
+            case 'minute':
+                clone.setHours(clone.getHours(), value, clone.getSeconds(), clone.getMilliseconds());
+                break;
+            case 'hour':
+                clone.setHours(value, clone.getMinutes(), clone.getSeconds(), clone.getMilliseconds());
+                break;
+            default:
+            case 'day':
+                clone.setDate(value);
+                break;
+            case 'week':
+                break;
+            case 'month':
+                clone.setMonth(Math.max(0, value - 1));
+                break;
+            case 'year':
+                clone.setFullYear(value);
+                break;
+        }
+        return new AXDateTime(clone, this);
+    }
+    startOf(date, unit) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 0);
+                return new AXDateTime(clone, this);
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 0, 0);
+                return new AXDateTime(clone, this);
+            case 'hour':
+                clone.setHours(clone.getHours(), 0, 0, 0);
+                return new AXDateTime(clone, this);
+            default:
+            case 'day':
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this);
+            case 'week': {
+                const start = 1; // Week starts on Monday
+                const day = clone.getDay();
+                const diff = clone.getDate() - day + (day == 0 ? -6 : start - day);
+                clone.setDate(diff);
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this);
+            }
+            case 'month':
+                clone.setDate(1);
+                return new AXDateTime(clone, this).startOf('day');
+            case 'year':
+                clone.setMonth(0);
+                clone.setDate(1);
+                return new AXDateTime(clone, this).startOf('day');
+        }
+    }
+    endOf(date, unit) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 999);
+                return new AXDateTime(clone, this);
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 59, 999);
+                return new AXDateTime(clone, this);
+            case 'hour':
+                clone.setHours(clone.getHours(), 59, 59, 999);
+                return new AXDateTime(clone, this);
+            default:
+            case 'day':
+                clone.setHours(23, 59, 59, 999);
+                return new AXDateTime(clone, this);
+            case 'week':
+                return this.startOf(date, 'week').add('day', 6).endOf('day');
+            case 'month': {
+                const dateObj = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+                dateObj.setHours(23, 59, 59, 999);
+                return new AXDateTime(dateObj, this);
+            }
+            case 'year':
+                clone.setMonth(11);
+                return new AXDateTime(clone, this).endOf('month');
+        }
+    }
+    isLeap(date) {
+        let leapYear = new Date(date.getFullYear(), 1, 29);
+        return leapYear.getDate() == 29;
+    }
+    parse(value) {
+        return new AXDateTime(new Date(value), this);
+    }
+}
+
+class JalaliCalendar extends AXCalendar {
+    /**
+     * @ignore
+     */
+    constructor(config) {
+        super(config);
+        /*
+        Jalaali years starting the 33-year rule.
+      */
+        this.breaks = [
+            -61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210, 1635, 2060, 2097,
+            2192, 2262, 2324, 2394, 2456, 3178,
+        ];
+    }
+    create(value) {
+        const a = this.toGregorian(value.year, value.month, value.date);
+        return new AXDateTime(new Date(a.getFullYear(), a.getMonth(), a.getDate(), value.hours || 0, value.minutes || 0, value.seconds || 0, value.ms || 0), this);
+    }
+    name() {
+        return 'jalali';
+    }
+    dayOfMonth(date) {
+        return this.toJalaali(date).day;
+    }
+    dayOfYear(date) {
+        const j = this.toJalaali(date);
+        return ((j.month <= 6 ? (j.month - 1) * 31 : 6 * 31 + (j.month - 7) * 30) + j.day);
+    }
+    dayOfWeek(date) {
+        return date.getDay() == 6 ? 1 : date.getDay() + 2;
+    }
+    weekOfYear(date) {
+        //TODO : apply jalali
+        const firstDay = new AXDateTime(date, this).startOf('year');
+        return Math.ceil(((date.getTime() - firstDay.date.getTime()) / 86400000 +
+            firstDay.date.getDay() +
+            1) /
+            7);
+    }
+    year(date) {
+        return this.toJalaali(date).year;
+    }
+    monthOfYear(date) {
+        return this.toJalaali(date).month;
+    }
+    add(date, unit, amount) {
+        let value = date.valueOf();
+        switch (unit) {
+            case 'second':
+                value += 1000 * amount;
+                break;
+            case 'minute':
+                value += 60000 * amount;
+                break;
+            case 'hour':
+                value += 3600000 * amount;
+                break;
+            case 'month': {
+                // const v = new Date(value);
+                // let jd = this.dayOfMonth(date);
+                // let jm = this.monthOfYear(date);
+                // let jy = this.year(date);
+                // const nm = jm + amount;
+                // const ny = nm % 12 ? Math.floor(nm / 12) : 0;
+                // jy += ny;
+                // jm = nm - ny * 12;
+                // const vv = this.toGregorian(jy, jm, jd);
+                // v.setFullYear(vv.getFullYear());
+                // v.setMonth(vv.getMonth());
+                // v.setDate(vv.getDate());
+                // value = v.valueOf();
+                // break;
+                let jd = this.dayOfMonth(date);
+                let jm = this.monthOfYear(date);
+                let jy = this.year(date);
+                let newMonth = jm + amount;
+                let yearsToAdd = Math.floor(newMonth / 12);
+                newMonth = newMonth % 12;
+                if (newMonth <= 0) {
+                    newMonth += 12;
+                    yearsToAdd--;
+                }
+                jy += yearsToAdd;
+                // Temporary set to first of the month to prevent rollover
+                const tempDate = this.toGregorian(jy, newMonth, 1);
+                const gregorianDate = new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate());
+                // Adjust the day to either the original day or the last day of the new month, whichever is smaller
+                const lastDayOfNewMonth = this.jalaaliMonthLength(jy, newMonth); // Implement this method to find the last day in a Jalali month
+                jd = Math.min(jd, lastDayOfNewMonth);
+                const finalDate = this.toGregorian(jy, newMonth, jd);
+                gregorianDate.setFullYear(finalDate.getFullYear());
+                gregorianDate.setMonth(finalDate.getMonth());
+                gregorianDate.setDate(finalDate.getDate());
+                value = gregorianDate.valueOf();
+                break;
+            }
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break;
+            case 'year': {
+                const v = new Date(value);
+                let jd = this.dayOfMonth(date);
+                let jm = this.monthOfYear(date);
+                let jy = this.year(date);
+                const vv = this.toGregorian(jy + amount, jm, jd);
+                v.setFullYear(vv.getFullYear());
+                v.setMonth(vv.getMonth());
+                v.setDate(vv.getDate());
+                value = v.valueOf();
+                break;
+            }
+            case 'day':
+            default:
+                value += 86400000 * amount;
+        }
+        return new AXDateTime(new Date(value), this);
+    }
+    set(date, unit, value) {
+        const clone = new Date(date.valueOf());
+        const jDate = this.toJalaali(clone);
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), value, clone.getMilliseconds());
+                break;
+            case 'minute':
+                clone.setHours(clone.getHours(), value, clone.getSeconds(), clone.getMilliseconds());
+                break;
+            case 'hour':
+                clone.setHours(value, clone.getMinutes(), clone.getSeconds(), clone.getMilliseconds());
+                break;
+            default:
+            case 'day': {
+                const gDate = this.toGregorian(jDate.year, jDate.month, value);
+                clone.setDate(gDate.getDate());
+                break;
+            }
+            case 'week':
+                break;
+            case 'month': {
+                const gDate2 = this.toGregorian(jDate.year, value, jDate.day);
+                clone.setMonth(gDate2.getMonth());
+                break;
+            }
+            case 'year': {
+                const gDate3 = this.toGregorian(value, jDate.month, jDate.day);
+                clone.setFullYear(gDate3.getFullYear());
+                break;
+            }
+        }
+        return new AXDateTime(clone, this);
+    }
+    startOf(date, unit) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 0);
+                return new AXDateTime(clone, this);
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 0, 0);
+                return new AXDateTime(clone, this);
+            case 'hour':
+                clone.setHours(clone.getHours(), 0, 0, 0);
+                return new AXDateTime(clone, this);
+            default:
+            case 'day':
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this);
+            case 'week':
+                return new AXDateTime(clone, this)
+                    .add('day', -this.dayOfWeek(clone) + 1)
+                    .startOf('day');
+            case 'month': {
+                const jy = this.year(date);
+                const jm = this.monthOfYear(date);
+                const gDate = this.toGregorian(jy, jm, 1);
+                return new AXDateTime(gDate, this).startOf('day');
+            }
+            case 'year': {
+                const jy = this.year(date);
+                const gDate = this.toGregorian(jy, 1, 1);
+                return new AXDateTime(gDate, this).startOf('day');
+            }
+        }
+    }
+    endOf(date, unit) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 999);
+                return new AXDateTime(clone, this);
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 59, 999);
+                return new AXDateTime(clone, this);
+            case 'hour':
+                clone.setHours(clone.getHours(), 59, 59, 999);
+                return new AXDateTime(clone, this);
+            default:
+            case 'day':
+                clone.setHours(23, 59, 59, 999);
+                return new AXDateTime(clone, this);
+            case 'week': {
+                return this.startOf(date, 'week').add('day', 6).endOf('day');
+            }
+            case 'month': {
+                const jy = this.year(date);
+                const jm = this.monthOfYear(date);
+                const jd = this.jalaaliMonthLength(jy, jm);
+                const gDate = this.toGregorian(jy, jm, jd);
+                return new AXDateTime(gDate, this).endOf('day');
+            }
+            case 'year': {
+                const jy = this.year(date);
+                const gDate = this.toGregorian(jy, 12, this.jalaaliMonthLength(jy, 12));
+                return new AXDateTime(gDate, this).endOf('day');
+            }
+        }
+    }
+    parse(value) {
+        const [y, M, d, h, m, s, ms] = value.split(/[^a-zA-Z0-9]+/gi);
+        const date = this.toGregorian(Number(y) ?? 0, Number(M) ?? 1, Number(d) ?? 1);
+        if (h != null)
+            date.setHours(Number(h));
+        if (m != null)
+            date.setMinutes(Number(m));
+        if (s != null)
+            date.setSeconds(Number(s));
+        if (ms != null)
+            date.setMilliseconds(Number(d));
+        return new AXDateTime(date, this);
+    }
+    /*
+    Converts a Gregorian date to Jalaali.
+  */
+    toJalaali(date) {
+        const gd = date.getDate();
+        const gm = date.getMonth() + 1;
+        const gy = date.getFullYear();
+        const r = this.d2j(this.g2d(gy, gm, gd));
+        return {
+            year: r.jy,
+            month: r.jm,
+            day: r.jd,
+        };
+    }
+    /*
+      Converts a Jalaali date to Gregorian.
+    */
+    toGregorian(jy, jm, jd) {
+        const g = this.d2g(this.j2d(jy, jm, jd));
+        return new Date(g.gy, g.gm - 1, g.gd);
+    }
+    /*
+      Checks whether a Jalaali date is valid or not.
+    */
+    isValidJalaaliDate(jy, jm, jd) {
+        return (jy >= -61 &&
+            jy <= 3177 &&
+            jm >= 1 &&
+            jm <= 12 &&
+            jd >= 1 &&
+            jd <= this.jalaaliMonthLength(jy, jm));
+    }
+    /*
+      Is this a leap year or not?
+    */
+    isLeapJalaaliYear(jy) {
+        return this.jalCalLeap(jy) === 0;
+    }
+    /*
+      Number of days in a given month in a Jalaali year.
+    */
+    jalaaliMonthLength(jy, jm) {
+        if (jm <= 6)
+            return 31;
+        if (jm <= 11)
+            return 30;
+        if (this.isLeapJalaaliYear(jy))
+            return 30;
+        return 29;
+    }
+    /*
+        This determines if the Jalaali (Persian) year is
+        leap (366-day long) or is the common year (365 days)
+    
+        @param jy Jalaali calendar year (-61 to 3177)
+        @returns number of years since the last leap year (0 to 4)
+     */
+    jalCalLeap(jy) {
+        let bl = this.breaks.length, jp = this.breaks[0], jm, jump, leap, n, i;
+        if (jy < jp || jy >= this.breaks[bl - 1])
+            throw new Error('Invalid Jalaali year ' + jy);
+        for (i = 1; i < bl; i += 1) {
+            jm = this.breaks[i];
+            jump = jm - jp;
+            if (jy < jm)
+                break;
+            jp = jm;
+        }
+        n = jy - jp;
+        if (jump - n < 6)
+            n = n - jump + this.div(jump + 4, 33) * 33;
+        leap = this.mod(this.mod(n + 1, 33) - 1, 4);
+        if (leap === -1) {
+            leap = 4;
+        }
+        return leap;
+    }
+    jalCal(jy, withoutLeap) {
+        let bl = this.breaks.length, gy = jy + 621, leapJ = -14, jp = this.breaks[0], jm, jump, leap, leapG, march, n, i;
+        if (jy < jp || jy >= this.breaks[bl - 1])
+            throw new Error('Invalid Jalaali year ' + jy);
+        // Find the limiting years for the Jalaali year jy.
+        for (i = 1; i < bl; i += 1) {
+            jm = this.breaks[i];
+            jump = jm - jp;
+            if (jy < jm)
+                break;
+            leapJ = leapJ + this.div(jump, 33) * 8 + this.div(this.mod(jump, 33), 4);
+            jp = jm;
+        }
+        n = jy - jp;
+        // Find the number of leap years from AD 621 to the beginning
+        // of the current Jalaali year in the Persian calendar.
+        leapJ = leapJ + this.div(n, 33) * 8 + this.div(this.mod(n, 33) + 3, 4);
+        if (this.mod(jump, 33) === 4 && jump - n === 4)
+            leapJ += 1;
+        // And the same in the Gregorian calendar (until the year gy).
+        leapG = this.div(gy, 4) - this.div((this.div(gy, 100) + 1) * 3, 4) - 150;
+        // Determine the Gregorian date of Farvardin the 1st.
+        march = 20 + leapJ - leapG;
+        // return with gy and march when we don't need leap
+        if (withoutLeap)
+            return { gy: gy, march: march };
+        // Find how many years have passed since the last leap year.
+        if (jump - n < 6)
+            n = n - jump + this.div(jump + 4, 33) * 33;
+        leap = this.mod(this.mod(n + 1, 33) - 1, 4);
+        if (leap === -1) {
+            leap = 4;
+        }
+        return {
+            leap: leap,
+            gy: gy,
+            march: march,
+        };
+    }
+    j2d(jy, jm, jd) {
+        let r = this.jalCal(jy, true);
+        return (this.g2d(r.gy, 3, r.march) +
+            (jm - 1) * 31 -
+            this.div(jm, 7) * (jm - 7) +
+            jd -
+            1);
+    }
+    d2j(jdn) {
+        let gy = this.d2g(jdn).gy, // Calculate Gregorian year (gy).
+        jy = gy - 621, r = this.jalCal(jy, false), jdn1f = this.g2d(gy, 3, r.march), jd, jm, k;
+        // Find number of days that passed since 1 Farvardin.
+        k = jdn - jdn1f;
+        if (k >= 0) {
+            if (k <= 185) {
+                // The first 6 months.
+                jm = 1 + this.div(k, 31);
+                jd = this.mod(k, 31) + 1;
+                return {
+                    jy: jy,
+                    jm: jm,
+                    jd: jd,
+                };
+            }
+            else {
+                // The remaining months.
+                k -= 186;
+            }
+        }
+        else {
+            // Previous Jalaali year.
+            jy -= 1;
+            k += 179;
+            if (r.leap === 1)
+                k += 1;
+        }
+        jm = 7 + this.div(k, 30);
+        jd = this.mod(k, 30) + 1;
+        return {
+            jy: jy,
+            jm: jm,
+            jd: jd,
+        };
+    }
+    g2d(gy, gm, gd) {
+        let d = this.div((gy + this.div(gm - 8, 6) + 100100) * 1461, 4) +
+            this.div(153 * this.mod(gm + 9, 12) + 2, 5) +
+            gd -
+            34840408;
+        d =
+            d -
+                this.div(this.div(gy + 100100 + this.div(gm - 8, 6), 100) * 3, 4) +
+                752;
+        return d;
+    }
+    d2g(jdn) {
+        let j, i, gd, gm, gy;
+        j = 4 * jdn + 139361631;
+        j = j + this.div(this.div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908;
+        i = this.div(this.mod(j, 1461), 4) * 5 + 308;
+        gd = this.div(this.mod(i, 153), 5) + 1;
+        gm = this.mod(this.div(i, 153), 12) + 1;
+        gy = this.div(j, 1461) - 100100 + this.div(8 - gm, 6);
+        return {
+            gy: gy,
+            gm: gm,
+            gd: gd,
+        };
+    }
+    jalaaliWeek(jy, jm, jd) {
+        let dayOfWeek = this.jalaaliToDateObject(jy, jm, jd, 0, 0, 0, 0).getDay();
+        let startDayDifference = dayOfWeek == 6 ? 0 : -(dayOfWeek + 1);
+        let endDayDifference = 6 + startDayDifference;
+        return {
+            saturday: this.d2j(this.j2d(jy, jm, jd + startDayDifference)),
+            friday: this.d2j(this.j2d(jy, jm, jd + endDayDifference)),
+        };
+    }
+    jalaaliToDateObject(jy, jm, jd, h = 0, m = 0, s = 0, ms = 0) {
+        let gregorianCalenderDate = this.toGregorian(jy, jm, jd);
+        return new Date(gregorianCalenderDate.getFullYear(), gregorianCalenderDate.getMonth() - 1, gregorianCalenderDate.getDate(), h || 0, m || 0, s || 0, ms || 0);
+    }
+    /*
+      Utility helper functions.
+    */
+    div(a, b) {
+        return ~~(a / b);
+    }
+    mod(a, b) {
+        return a - ~~(a / b) * b;
+    }
+}
+
+const AX_DATETIME_CONFIG = new InjectionToken('AX_DATETIME_CONFIG', {
+    providedIn: 'root',
+    factory: () => {
+        const global = inject(AX_GLOBAL_CONFIG);
+        set(global, 'dateTime', AX_DATETIME_CONFIG);
+        return AXDateTimeDefaultConfig;
+    },
+});
+const AXDateTimeDefaultConfig = {
+    calendar: 'georgian',
+    calendars: {
+        georgian: new GeorgianCalendar({
+            weekdays: [0, 1, 2, 3, 4, 5, 6],
+            weekend: [5, 6],
+            formats: {
+                dateInput: 'yyyy/MM/dd',
+                timeInput: 'HH:mm',
+                dateTimeInput: 'yyyy/MM/dd HH:mm',
+                dateDisplay: 'DDDD, d MMM yyyy',
+                timeDisplay: 'HH:mm',
+                dateTimeDisplay: 'DDDD, d MMM yyyy HH:mm',
+            },
+        }),
+        jalali: new JalaliCalendar({
+            weekdays: [6, 0, 1, 2, 3, 4, 5],
+            weekend: [6],
+            formats: {
+                dateInput: 'yyyy/MM/dd',
+                timeInput: 'HH:mm',
+                dateTimeInput: 'yyyy/MM/dd HH:mm',
+                dateDisplay: 'DDDD, d MMM yyyy',
+                timeDisplay: 'HH:mm',
+                dateTimeDisplay: 'DDDD, d MMM yyyy HH:mm',
+            },
+        }),
+    },
+};
+function dateTimeConfig(config = {}) {
+    const result = {
+        ...AXDateTimeDefaultConfig,
+        ...config,
+    };
+    return result;
+}
+
+class AXHolidaysLoaderDefault {
+    getHolidays(options) {
+        return Promise.resolve([]);
+    }
+}
+const AX_DATETIME_HOLIDAYS_LOADER = new InjectionToken('AX_DATETIME_HOLIDAYS_LOADER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXHolidaysLoaderDefault();
+    },
+});
+
+class AXCalendarService {
+    get calendar() {
+        return this.getActiveCalendar();
+    }
+    getDefaultCalendar() {
+        return this.config.calendars[this.config.calendar];
+    }
+    getActiveCalendar() {
+        return this.activeCalendar.getValue();
+    }
+    setActiveCalendar(name) {
+        if (name != this.calendar.name()) {
+            const calendar = this.resolveCalendar(name);
+            this.activeCalendar.next(calendar);
+            this.eventService.emitEvent({
+                type: AXEventTypes.AXCalendarChanged,
+                payload: this.getActiveCalendar(),
+            });
+        }
+    }
+    get holidays() {
+        return this._holidays;
+    }
+    constructor() {
+        this.config = inject(AX_DATETIME_CONFIG);
+        this._holidaysLoader = inject(AX_DATETIME_HOLIDAYS_LOADER);
+        this.eventService = inject(AXEventService);
+        this.activeCalendar = new BehaviorSubject(this.getDefaultCalendar());
+        this.calendarChanges$ = this.activeCalendar.asObservable();
+        this.onHolidaysChanged = new Subject();
+        this._holidays = [];
+        this.loadHolidays();
+    }
+    loadHolidays(options) {
+        return this._holidaysLoader.getHolidays(options).then((value) => {
+            this._holidays = value;
+            this.onHolidaysChanged.next(this._holidays);
+        });
+    }
+    create(value, calendarName) {
+        const calendar = calendarName
+            ? this.resolveCalendar(calendarName)
+            : this.calendar;
+        if (value instanceof Date) {
+            return new AXDateTime(value, calendar);
+        }
+        else if (value?.year && value?.month) {
+            return calendar.create(value);
+        }
+        return this.now();
+    }
+    now(calendarName) {
+        const calendar = calendarName
+            ? this.resolveCalendar(calendarName)
+            : this.calendar;
+        return new AXDateTime(new Date(), calendar);
+    }
+    resolveCalendar(name) {
+        const c = this.config.calendars[name];
+        if (!c) {
+            console.error(`"${name}" is not a valid calendar name!`);
+            return this.calendar;
+        }
+        return c;
+    }
+    convert(value, calendarName) {
+        const isISOString = (str) => {
+            if (!/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d{3}Z)?/.test(str))
+                return false;
+            const d = new Date(str);
+            return d instanceof Date && !isNaN(d.getTime()); // valid date
+        };
+        //
+        const calendar = calendarName
+            ? this.resolveCalendar(calendarName)
+            : this.calendar;
+        if (typeof value === 'string') {
+            if (isISOString(value))
+                return new AXDateTime(new Date(value), calendar);
+            else
+                return calendar.parse(value);
+        }
+        const date = value instanceof AXDateTime ? value.date : value;
+        return new AXDateTime(date, calendar);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXCalendarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXCalendarService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXCalendarService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class AXDateTimeFormatter {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+    }
+    get name() {
+        return 'datetime';
+    }
+    format(value, options) {
+        const effectiveOptions = typeof options == 'object'
+            ? {
+                format: options.format ?? 'date',
+                locale: options.locale,
+                calendar: options.calendar ?? this.calendarService.calendar.name(),
+            }
+            : {
+                format: options,
+                calendar: this.calendarService.calendar.name(),
+            };
+        return this.calendarService
+            .create(value, effectiveOptions.calendar)
+            .format(effectiveOptions.format, { locale: effectiveOptions.locale });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeFormatter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeFormatter, decorators: [{
+            type: Injectable
+        }] });
+
+class AXTimeLeftFormatter {
+    get name() {
+        return 'timeleft';
+    }
+    format(value, options) {
+        const milliseconds = Number(value);
+        if (milliseconds === null || isNaN(milliseconds)) {
+            return 'Calculating...';
+        }
+        const durationInSeconds = Math.round(milliseconds / 1000);
+        let format = options?.format;
+        // Determine the best format if format is null
+        if (isNil(format)) {
+            if (durationInSeconds < 45)
+                format = 's';
+            else if (durationInSeconds < 60 * 45)
+                format = 'm';
+            else if (durationInSeconds < 60 * 60 * 22)
+                format = 'h';
+            else if (durationInSeconds < 60 * 60 * 24 * 26)
+                format = 'd';
+            else if (durationInSeconds < 60 * 60 * 24 * 320)
+                format = 'M';
+            else
+                format = 'y';
+        }
+        // Helper function for zero-padding
+        const pad = (num) => num.toString().padStart(2, '0');
+        switch (format) {
+            case 's':
+                return `${durationInSeconds} seconds left`;
+            case 'ss':
+                return `${pad(durationInSeconds)} seconds left`;
+            case 'm':
+                return `${Math.round(durationInSeconds / 60)} minute${durationInSeconds >= 120 ? 's' : ''} left`;
+            case 'mm':
+                return `${pad(Math.round(durationInSeconds / 60))} minutes left`;
+            case 'h':
+            case 'H':
+                if (durationInSeconds < 60 * 89)
+                    return 'an hour left';
+                return `${Math.round(durationInSeconds / 3600)} hour${durationInSeconds >= 60 * 180 ? 's' : ''} left`;
+            case 'hh':
+            case 'HH':
+                if (durationInSeconds < 60 * 89)
+                    return '01 hour left';
+                return `${pad(Math.round(durationInSeconds / 3600))} hours left`;
+            case 'd':
+            case 'D':
+                if (durationInSeconds < 60 * 60 * 35)
+                    return 'a day left';
+                return `${Math.round(durationInSeconds / (3600 * 24))} day${durationInSeconds >= 60 * 60 * 70 ? 's' : ''} left`;
+            case 'dd':
+            case 'DD':
+                if (durationInSeconds < 60 * 60 * 35)
+                    return '01 day left';
+                return `${pad(Math.round(durationInSeconds / (3600 * 24)))} days left`;
+            case 'M':
+                if (durationInSeconds < 60 * 60 * 24 * 45)
+                    return 'a month left';
+                return `${Math.round(durationInSeconds / (3600 * 24 * 30))} month${durationInSeconds >= 60 * 60 * 24 * 90 ? 's' : ''} left`;
+            case 'MM':
+                if (durationInSeconds < 60 * 60 * 24 * 45)
+                    return '01 month left';
+                return `${pad(Math.round(durationInSeconds / (3600 * 24 * 30)))} months left`;
+            case 'y':
+            case 'Y':
+                if (durationInSeconds < 60 * 60 * 24 * 547)
+                    return 'a year left';
+                return `${Math.round(durationInSeconds / (3600 * 24 * 365))} year${durationInSeconds >= 60 * 60 * 24 * 730 ? 's' : ''} left`;
+            case 'yy':
+            case 'YY':
+            case 'yyyy':
+            case 'YYYY':
+                if (durationInSeconds < 60 * 60 * 24 * 547)
+                    return '01 year left';
+                return `${pad(Math.round(durationInSeconds / (3600 * 24 * 365)))} years left`;
+            default:
+                return 'Invalid format';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXTimeLeftFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXTimeLeftFormatter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXTimeLeftFormatter, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * @deprecated The pipe should not be used, use format instead
+ */
+class AXDateTimePipe {
+    constructor() {
+        this._calendarService = inject(AXCalendarService);
+    }
+    transform(value, format, calendarName) {
+        if (value == null) {
+            return '';
+        }
+        let calendar = this._calendarService.calendar;
+        if (calendarName) {
+            calendar = this._calendarService.resolveCalendar(calendarName);
+        }
+        const val = this._calendarService.convert(value, calendar.name());
+        return val.format(format);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimePipe, name: "axDate" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'axDate' }]
+        }] });
+
+class AXDateTimeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeModule, declarations: [AXDateTimePipe], imports: [i1.AXFormatModule], exports: [AXDateTimePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeModule, imports: [AXFormatModule.forChild({
+                formatters: [AXDateTimeFormatter, AXTimeLeftFormatter],
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AXDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXFormatModule.forChild({
+                            formatters: [AXDateTimeFormatter, AXTimeLeftFormatter],
+                        }),
+                    ],
+                    exports: [AXDateTimePipe],
+                    declarations: [AXDateTimePipe],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXCalendar, AXCalendarMonth, AXCalendarService, AXDateTime, AXDateTimeDefaultConfig, AXDateTimeFormatter, AXDateTimeModule, AXDateTimePipe, AXDateTimeRange, AXHolidaysLoaderDefault, AXTimeLeftFormatter, AX_DATETIME_CONFIG, AX_DATETIME_HOLIDAYS_LOADER, GeorgianCalendar, JalaliCalendar, dateTimeConfig };
+//# sourceMappingURL=acorex-core-date-time.mjs.map