@acorex/core 19.12.0-next.1 → 19.12.0-next.3

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

@@ -1,4 +1,4 @@
-import { AXEventTypes, AXEventService } from '@acorex/core/events';
+import { AXEventService } from '@acorex/core/events';
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, Pipe, NgModule } from '@angular/core';
 import { BehaviorSubject, Subject } from 'rxjs';
@@ -6,8 +6,9 @@ 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 { AXLocaleEvents, AXLocaleService } from '@acorex/core/locale';
 import * as i1 from '@acorex/core/format';
-import { AXFormatModule } from '@acorex/core/format';
+import { AXFormatService, AXFormatModule } from '@acorex/core/format';
 
 class AXCalendar {
     /**
@@ -19,9 +20,9 @@ class AXCalendar {
     get weekend() {
         return this._config.weekend;
     }
-    get formats() {
-        return this._config.formats;
-    }
+    // public get formats(): AXDateTimeDisplayFormats {
+    //   return this._config.formats;
+    // }
     get weekdays() {
         return this._config.weekdays;
     }
@@ -36,38 +37,74 @@ class AXDateTime {
     constructor(value, calendar) {
         //TODO: remove unused items
         this._formatKeys = {
-            ss: () => this.pad(this.date.getSeconds(), 2),
+            // 0 1 ... 58 59
             s: () => this.date.getSeconds().toString(),
-            //
-            dd: () => this.pad(this.calendar.dayOfMonth(this.date), 2),
+            // 00 01 ... 58 59
+            ss: () => this.pad(this.date.getSeconds(), 2),
+            // 0 1 ... 5 6 day of week ***
+            d: () => (this.calendar.dayOfWeek(this.date) - 1).toString(),
+            //  Su Mo ... Fr Sa ***
+            dd: () => translateSync(`dateTime.weekdays.short.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            ddd: () => translateSync(`dateTime.weekdays.short.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            // Sunday Monday ... Friday Saturday
+            dddd: () => translateSync(`dateTime.weekdays.long.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            // 1 2 ... 30 31
+            D: () => this.calendar.dayOfMonth(this.date).toString(),
+            // 01 02 ... 30 31 day of month
             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}`),
+            // 1 2 ... 364 365
+            DDD: () => this.calendar.dayOfYear(this.date).toString(),
+            // 001 002 ... 364 365 day of year
+            DDDD: () => this.pad(this.calendar.dayOfYear(this.date), 3),
+            // 1 2 ... 52 53
+            w: () => this.calendar.weekOfYear(this.date).toString(),
+            // 01 02 ... 52 53
+            ww: () => this.pad(this.calendar.weekOfYear(this.date), 2),
+            // 1 2 ... 11 12
+            M: () => this.calendar.monthOfYear(this.date).toString(),
+            // 01 02 ... 11 12
             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),
+            // Jan Feb ... Nov Dec
+            MMM: () => translateSync(`dateTime.months.${this.calendar.name()}.short.${this.calendar.monthOfYear(this.date) - 1}`),
+            // January February ... November December
+            MMMM: () => translateSync(`dateTime.months.${this.calendar.name()}.long.${this.calendar.monthOfYear(this.date) - 1}`),
+            // 1 2 ... 7
+            E: () => this.calendar.dayOfWeek(this.date).toString(),
+            // 01 02 ... 07
+            EE: () => this.pad(this.calendar.dayOfWeek(this.date), 2),
+            // Sun Mon ... Sat
+            EEE: () => translateSync(`dateTime.weekdays.short.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            // Sunday Monday ... Saturday
+            EEEE: () => translateSync(`dateTime.weekdays.long.${this.calendar.weekdays[this.calendar.dayOfWeek(this.date) - 1]}`),
+            // 1 2 ... 2020 ...
+            y: () => this.calendar.year(this.date).toString(),
+            // 70 71 ... 29 30
             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),
+            // 1970 1971 ... 2029 2030
+            yyyy: () => this.pad(this.calendar.year(this.date), 4),
+            YYYY: () => this.pad(this.calendar.year(this.date), 4),
+            // 0 1 ... 58 59
+            m: () => this.date.getMinutes().toString(),
+            // 00 01 ... 58 59
+            mm: () => this.pad(this.date.getMinutes(), 2),
+            // 0 1 ... 11 12
             h: () => (this.date.getHours() % 12 || 12).toString(),
+            // 00 01 ... 11 12
+            hh: () => this.pad(this.date.getHours() % 12 || 12, 2),
+            // 0 1 ... 23 24
+            H: () => this.date.getHours().toString(),
+            // 00 01 ... 23 24
+            HH: () => this.pad(this.date.getHours(), 2),
+            // TODO: i18n
+            // AM PM
+            A: () => (this.date.getHours() < 12 ? 'AM' : 'PM').toUpperCase(),
+            // am pm
+            a: () => (this.date.getHours() < 12 ? 'am' : 'pm').toLowerCase(),
+            // TODO: review
+            Z: () => '',
+            ZZZZ: () => '',
             //
-            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')),
@@ -78,7 +115,7 @@ class AXDateTime {
             //
             datetime: (options) => this.format('date time', { locale: options.locale }),
         };
-        this._language = () => (isBrowser() ? navigator.language : 'en-GB');
+        this._language = () => (isBrowser() ? navigator.language : 'en-US');
         this._calendar = calendar;
         this._date = value;
     }
@@ -140,8 +177,11 @@ class AXDateTime {
         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;
+            if (f && typeof f === 'function') {
+                const r = f(effectiveOptions);
+                return r;
+            }
+            return matched;
         });
     }
     getDateTimeFormatByLocale(locale, style) {
@@ -279,6 +319,8 @@ class AXDateTimeRange {
             minutes: 0,
             hours: 0,
             days: 0,
+            // NOTE: Calculating exact calendar months/years component is complex
+            // from milliseconds alone. We'll set these to 0.
             months: 0,
             years: 0,
             total: {
@@ -288,46 +330,54 @@ class AXDateTimeRange {
                 hours: 0,
                 days: 0,
                 weeks: 0,
+                // NOTE: total.months and total.years are approximate based on average lengths
                 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;
+        // Constants for time units in milliseconds
+        const ONE_MILLISECOND = 1;
+        const ONE_SECOND = 1000 * ONE_MILLISECOND;
+        const ONE_MINUTE = 60 * ONE_SECOND;
+        const ONE_HOUR = 60 * ONE_MINUTE;
+        const ONE_DAY = 24 * ONE_HOUR;
+        const ONE_WEEK = 7 * ONE_DAY;
+        // Average lengths for approximate total months/years
+        const ONE_YEAR_AVG = 365.25 * ONE_DAY;
+        const ONE_MONTH_AVG = ONE_YEAR_AVG / 12;
         const startTime = this._startTime.date.getTime();
         const endTime = this._endTime.date.getTime();
+        // Calculate the absolute difference in milliseconds
         const diff = Math.abs(endTime - startTime);
-        //
+        // --- Calculate Total Durations ---
         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));
+        result.total.seconds = diff / ONE_SECOND;
+        result.total.minutes = diff / ONE_MINUTE;
+        result.total.hours = diff / ONE_HOUR;
+        result.total.days = diff / ONE_DAY; // Includes fractional days
+        result.total.weeks = diff / ONE_WEEK; // Includes fractional weeks
+        result.total.months = diff / ONE_MONTH_AVG; // Approximate
+        result.total.years = diff / ONE_YEAR_AVG; // Approximate
+        // --- Calculate Component Parts ---
+        let remainingMillis = diff;
+        // Calculate full days and update remaining milliseconds
+        result.days = Math.floor(remainingMillis / ONE_DAY);
+        remainingMillis %= ONE_DAY; // Get the remainder milliseconds after taking out full days
+        // Calculate full hours from the remainder
+        result.hours = Math.floor(remainingMillis / ONE_HOUR);
+        remainingMillis %= ONE_HOUR; // Get the remainder milliseconds after taking out full hours
+        // Calculate full minutes from the remainder
+        result.minutes = Math.floor(remainingMillis / ONE_MINUTE);
+        remainingMillis %= ONE_MINUTE; // Get the remainder milliseconds after taking out full minutes
+        // Calculate full seconds from the remainder
+        result.seconds = Math.floor(remainingMillis / ONE_SECOND);
+        remainingMillis %= ONE_SECOND; // Get the remainder milliseconds after taking out full seconds
+        // The final remainder is the milliseconds component
+        result.miliseconds = remainingMillis;
+        // As noted above, setting month/year components to 0 as accurate
+        // calendar-aware calculation is not implemented here.
+        result.months = 0;
+        result.years = 0;
         return result;
     }
     enumurate(unit = 'day', amount = 1) {
@@ -343,7 +393,7 @@ class AXDateTimeRange {
     }
 }
 
-class GeorgianCalendar extends AXCalendar {
+class AXGregorianCalendar extends AXCalendar {
     /**
      * @ignore
      */
@@ -354,7 +404,7 @@ class GeorgianCalendar extends AXCalendar {
         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';
+        return 'gregorian';
     }
     dayOfMonth(date) {
         return date.getDate();
@@ -540,14 +590,14 @@ class GeorgianCalendar extends AXCalendar {
     }
 }
 
-class JalaliCalendar extends AXCalendar {
+class AXSolarHijriCalendar extends AXCalendar {
     /**
      * @ignore
      */
     constructor(config) {
         super(config);
         /*
-        Jalaali years starting the 33-year rule.
+        SolarHijri 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];
     }
@@ -556,13 +606,13 @@ class JalaliCalendar extends AXCalendar {
         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';
+        return 'solar-hijri';
     }
     dayOfMonth(date) {
-        return this.toJalaali(date).day;
+        return this.toSolarHijri(date).day;
     }
     dayOfYear(date) {
-        const j = this.toJalaali(date);
+        const j = this.toSolarHijri(date);
         return (j.month <= 6 ? (j.month - 1) * 31 : 6 * 31 + (j.month - 7) * 30) + j.day;
     }
     dayOfWeek(date) {
@@ -574,10 +624,10 @@ class JalaliCalendar extends AXCalendar {
         return Math.ceil(((date.getTime() - firstDay.date.getTime()) / 86400000 + firstDay.date.getDay() + 1) / 7);
     }
     year(date) {
-        return this.toJalaali(date).year;
+        return this.toSolarHijri(date).year;
     }
     monthOfYear(date) {
-        return this.toJalaali(date).month;
+        return this.toSolarHijri(date).month;
     }
     add(date, unit, amount) {
         let value = date.valueOf();
@@ -621,7 +671,7 @@ class JalaliCalendar extends AXCalendar {
                 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
+                const lastDayOfNewMonth = this.SolarHijriMonthLength(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());
@@ -653,7 +703,7 @@ class JalaliCalendar extends AXCalendar {
     }
     set(date, unit, value) {
         const clone = new Date(date.valueOf());
-        const jDate = this.toJalaali(clone);
+        const jDate = this.toSolarHijri(clone);
         switch (unit) {
             case 'second':
                 clone.setHours(clone.getHours(), clone.getMinutes(), value, clone.getMilliseconds());
@@ -738,13 +788,13 @@ class JalaliCalendar extends AXCalendar {
             case 'month': {
                 const jy = this.year(date);
                 const jm = this.monthOfYear(date);
-                const jd = this.jalaaliMonthLength(jy, jm);
+                const jd = this.SolarHijriMonthLength(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));
+                const gDate = this.toGregorian(jy, 12, this.SolarHijriMonthLength(jy, 12));
                 return new AXDateTime(gDate, this).endOf('day');
             }
         }
@@ -763,9 +813,9 @@ class JalaliCalendar extends AXCalendar {
         return new AXDateTime(date, this);
     }
     /*
-    Converts a Gregorian date to Jalaali.
+    Converts a Gregorian date to SolarHijri.
   */
-    toJalaali(date) {
+    toSolarHijri(date) {
         const gd = date.getDate();
         const gm = date.getMonth() + 1;
         const gy = date.getFullYear();
@@ -777,47 +827,47 @@ class JalaliCalendar extends AXCalendar {
         };
     }
     /*
-      Converts a Jalaali date to Gregorian.
+      Converts a SolarHijri 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.
+      Checks whether a SolarHijri 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);
+    isValidSolarHijriDate(jy, jm, jd) {
+        return jy >= -61 && jy <= 3177 && jm >= 1 && jm <= 12 && jd >= 1 && jd <= this.SolarHijriMonthLength(jy, jm);
     }
     /*
       Is this a leap year or not?
     */
-    isLeapJalaaliYear(jy) {
+    isLeapSolarHijriYear(jy) {
         return this.jalCalLeap(jy) === 0;
     }
     /*
-      Number of days in a given month in a Jalaali year.
+      Number of days in a given month in a SolarHijri year.
     */
-    jalaaliMonthLength(jy, jm) {
+    SolarHijriMonthLength(jy, jm) {
         if (jm <= 6)
             return 31;
         if (jm <= 11)
             return 30;
-        if (this.isLeapJalaaliYear(jy))
+        if (this.isLeapSolarHijriYear(jy))
             return 30;
         return 29;
     }
     /*
-        This determines if the Jalaali (Persian) year is
+        This determines if the SolarHijri (Persian) year is
         leap (366-day long) or is the common year (365 days)
     
-        @param jy Jalaali calendar year (-61 to 3177)
+        @param jy SolarHijri 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);
+            throw new Error('Invalid SolarHijri year ' + jy);
         for (i = 1; i < bl; i += 1) {
             jm = this.breaks[i];
             jump = jm - jp;
@@ -837,8 +887,8 @@ class JalaliCalendar extends AXCalendar {
     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.
+            throw new Error('Invalid SolarHijri year ' + jy);
+        // Find the limiting years for the SolarHijri year jy.
         for (i = 1; i < bl; i += 1) {
             jm = this.breaks[i];
             jump = jm - jp;
@@ -849,7 +899,7 @@ class JalaliCalendar extends AXCalendar {
         }
         n = jy - jp;
         // Find the number of leap years from AD 621 to the beginning
-        // of the current Jalaali year in the Persian calendar.
+        // of the current SolarHijri 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;
@@ -899,7 +949,7 @@ class JalaliCalendar extends AXCalendar {
             }
         }
         else {
-            // Previous Jalaali year.
+            // Previous SolarHijri year.
             jy -= 1;
             k += 179;
             if (r.leap === 1)
@@ -932,8 +982,8 @@ class JalaliCalendar extends AXCalendar {
             gd: gd,
         };
     }
-    jalaaliWeek(jy, jm, jd) {
-        let dayOfWeek = this.jalaaliToDateObject(jy, jm, jd, 0, 0, 0, 0).getDay();
+    SolarHijriWeek(jy, jm, jd) {
+        let dayOfWeek = this.SolarHijriToDateObject(jy, jm, jd, 0, 0, 0, 0).getDay();
         let startDayDifference = dayOfWeek == 6 ? 0 : -(dayOfWeek + 1);
         let endDayDifference = 6 + startDayDifference;
         return {
@@ -941,7 +991,7 @@ class JalaliCalendar extends AXCalendar {
             friday: this.d2j(this.j2d(jy, jm, jd + endDayDifference)),
         };
     }
-    jalaaliToDateObject(jy, jm, jd, h = 0, m = 0, s = 0, ms = 0) {
+    SolarHijriToDateObject(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);
     }
@@ -965,31 +1015,15 @@ const AX_DATETIME_CONFIG = new InjectionToken('AX_DATETIME_CONFIG', {
     },
 });
 const AXDateTimeDefaultConfig = {
-    calendar: 'georgian',
+    calendar: 'gregorian',
     calendars: {
-        georgian: new GeorgianCalendar({
+        gregorian: new AXGregorianCalendar({
             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',
-            },
+            weekend: [5, 6]
         }),
-        jalali: new JalaliCalendar({
+        "solar-hijri": new AXSolarHijriCalendar({
             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',
-            },
         }),
     },
 };
@@ -1028,7 +1062,7 @@ class AXCalendarService {
             const calendar = this.resolveCalendar(name);
             this.activeCalendar.next(calendar);
             this.eventService.emitEvent({
-                type: AXEventTypes.AXCalendarChanged,
+                type: AXLocaleEvents.AXCalendarChanged,
                 payload: this.getActiveCalendar(),
             });
         }
@@ -1040,11 +1074,19 @@ class AXCalendarService {
         this.config = inject(AX_DATETIME_CONFIG);
         this._holidaysLoader = inject(AX_DATETIME_HOLIDAYS_LOADER);
         this.eventService = inject(AXEventService);
+        this.formatService = inject(AXFormatService);
+        this.localeService = inject(AXLocaleService);
         this.activeCalendar = new BehaviorSubject(this.getDefaultCalendar());
         this.calendarChanges$ = this.activeCalendar.asObservable();
         this.onHolidaysChanged = new Subject();
         this._holidays = [];
         this.loadHolidays();
+        //
+        this.localeService.profileChanged$.subscribe((locale) => {
+            if (locale?.calendar?.system) {
+                this.setActiveCalendar(locale.calendar.system);
+            }
+        });
     }
     loadHolidays(options) {
         return this._holidaysLoader.getHolidays(options).then((value) => {
@@ -1052,11 +1094,15 @@ class AXCalendarService {
             this.onHolidaysChanged.next(this._holidays);
         });
     }
-    isDate(value) {
+    isValidDate(value) {
         try {
             if (!value) {
                 return false;
             }
+            // 
+            if (value instanceof AXDateTime) {
+                return true;
+            }
             // Check if it's a Date object
             if (value instanceof Date) {
                 return !isNaN(value.getTime());
@@ -1083,10 +1129,13 @@ class AXCalendarService {
     create(value, calendarName) {
         try {
             const calendar = calendarName ? this.resolveCalendar(calendarName) : this.calendar;
-            if (!this.isDate(value)) {
+            if (!this.isValidDate(value)) {
                 throw new Error(`Invalid Date value: ${value}`);
             }
-            if (typeof value === 'string') {
+            if (value instanceof AXDateTime) {
+                return value;
+            }
+            else if (typeof value === 'string') {
                 return new AXDateTime(new Date(value), calendar);
             }
             else if (value instanceof Date) {
@@ -1131,6 +1180,13 @@ class AXCalendarService {
         const date = value instanceof AXDateTime ? value.date : value;
         return new AXDateTime(date, calendar);
     }
+    format(value, format, options) {
+        const calendar = options?.calendar ? this.resolveCalendar(options.calendar) : this.calendar;
+        return this.formatService.format(value, 'datetime', {
+            format: format,
+            calendar: calendar.name(),
+        });
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXCalendarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXCalendarService, providedIn: 'root' }); }
 }
@@ -1145,6 +1201,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImpor
 class AXDateTimePipe {
     constructor() {
         this._calendarService = inject(AXCalendarService);
+        this.formatService = inject(AXFormatService);
     }
     transform(value, format, calendarName) {
         if (value == null) {
@@ -1155,7 +1212,7 @@ class AXDateTimePipe {
             calendar = this._calendarService.resolveCalendar(calendarName);
         }
         const val = this._calendarService.convert(value, calendar.name());
-        return val.format(format);
+        return this.formatService.format(val, 'datetime', format);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
     static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimePipe, isStandalone: true, name: "axDate" }); }
@@ -1167,12 +1224,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImpor
 
 class AXDateTimeFormatter {
     constructor() {
+        this.localeService = inject(AXLocaleService);
         this.calendarService = inject(AXCalendarService);
     }
     get name() {
         return 'datetime';
     }
     format(value, options) {
+        if (isNil(value)) {
+            return '';
+        }
+        //
+        if (!this.calendarService.isValidDate(value))
+            return 'Invalid date';
+        //
         const effectiveOptions = typeof options == 'object'
             ? {
                 format: options.format ?? 'date',
@@ -1183,15 +1248,29 @@ class AXDateTimeFormatter {
                 format: options,
                 calendar: this.calendarService.calendar.name(),
             };
-        const date = (value instanceof Date) ? value :
-            (typeof value == "number" || typeof value == "string" ? new Date(value) : null);
         //
-        if (!date)
-            return "";
+        const formats = this.localeService.activeProfile().formats;
+        const map = {
+            longDate: formats.date.long,
+            shortDate: formats.date.short,
+            mediumDate: formats.date.medium,
+            date: formats.date.short,
+            //
+            longTime: formats.time.long,
+            shortTime: formats.time.short,
+            mediumTime: formats.time.medium,
+            time: formats.time.short,
+            //
+            long: formats.datetime.long,
+            short: formats.datetime.short,
+            medium: formats.datetime.medium,
+            full: formats.datetime.full,
+        };
+        const format = map[effectiveOptions.format] ?? effectiveOptions.format ?? map['date'];
         //
         return this.calendarService
-            .create(date, effectiveOptions.calendar)
-            .format(effectiveOptions.format, { locale: effectiveOptions.locale });
+            .convert(value, effectiveOptions.calendar)
+            .format(format, { locale: effectiveOptions.locale });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimeFormatter }); }
@@ -1337,11 +1416,105 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImpor
             type: Injectable
         }] });
 
+class AXDateFormatter {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+        this.localeService = inject(AXLocaleService);
+    }
+    get name() {
+        return 'date';
+    }
+    format(value, options) {
+        if (isNil(value)) {
+            return "";
+        }
+        //
+        if (!this.calendarService.isValidDate(value))
+            return "Invalid date";
+        //
+        const effectiveOptions = typeof options == 'object'
+            ? {
+                format: options.format ?? 'short',
+                locale: options.locale,
+                calendar: options.calendar ?? this.calendarService.calendar.name(),
+            }
+            : {
+                format: options,
+                calendar: this.calendarService.calendar.name(),
+            };
+        //
+        const formats = this.localeService.activeProfile().formats;
+        const map = {
+            "short": formats.date.short,
+            "medium": formats.date.medium,
+            "long": formats.date.long,
+            "full": formats.date.full,
+        };
+        const format = map[effectiveOptions.format] ?? effectiveOptions.format ?? map['short'];
+        //
+        return this.calendarService
+            .convert(value, effectiveOptions.calendar)
+            .format(format, { locale: effectiveOptions.locale });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateFormatter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateFormatter, decorators: [{
+            type: Injectable
+        }] });
+
+class AXTimeFormatter {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+        this.localeService = inject(AXLocaleService);
+    }
+    get name() {
+        return 'time';
+    }
+    format(value, options) {
+        if (isNil(value)) {
+            return '';
+        }
+        //
+        if (!this.calendarService.isValidDate(value))
+            return 'Invalid date';
+        //
+        const effectiveOptions = typeof options == 'object'
+            ? {
+                format: options.format ?? 'short',
+                locale: options.locale,
+                calendar: options.calendar ?? this.calendarService.calendar.name(),
+            }
+            : {
+                format: options,
+                calendar: this.calendarService.calendar.name(),
+            };
+        //
+        const formats = this.localeService.activeProfile().formats;
+        const map = {
+            short: formats.time.short,
+            medium: formats.time.medium,
+            long: formats.time.long,
+            full: formats.time.full,
+        };
+        const format = map[effectiveOptions.format] ?? effectiveOptions.format ?? map['short'];
+        //
+        return this.calendarService
+            .convert(value, effectiveOptions.calendar)
+            .format(format, { locale: effectiveOptions.locale });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXTimeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXTimeFormatter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXTimeFormatter, decorators: [{
+            type: Injectable
+        }] });
+
 class AXDateTimeModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimeModule, imports: [i1.AXFormatModule, AXDateTimePipe], exports: [AXDateTimePipe] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimeModule, imports: [AXFormatModule.forChild({
-                formatters: [AXDateTimeFormatter, AXTimeLeftFormatter, AXTimeDurationFormatter],
+                formatters: [AXDateTimeFormatter, AXDateFormatter, AXTimeFormatter, AXTimeLeftFormatter, AXTimeDurationFormatter],
             })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImport: i0, type: AXDateTimeModule, decorators: [{
@@ -1349,7 +1522,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImpor
             args: [{
                     imports: [
                         AXFormatModule.forChild({
-                            formatters: [AXDateTimeFormatter, AXTimeLeftFormatter, AXTimeDurationFormatter],
+                            formatters: [AXDateTimeFormatter, AXDateFormatter, AXTimeFormatter, AXTimeLeftFormatter, AXTimeDurationFormatter],
                         }),
                         AXDateTimePipe,
                     ],
@@ -1361,5 +1534,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.5", ngImpor
  * 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 };
+export { AXCalendar, AXCalendarMonth, AXCalendarService, AXDateTime, AXDateTimeDefaultConfig, AXDateTimeFormatter, AXDateTimeModule, AXDateTimePipe, AXDateTimeRange, AXGregorianCalendar, AXHolidaysLoaderDefault, AXSolarHijriCalendar, AXTimeLeftFormatter, AX_DATETIME_CONFIG, AX_DATETIME_HOLIDAYS_LOADER, dateTimeConfig };
 //# sourceMappingURL=acorex-core-date-time.mjs.map