@acorex/core 7.17.26 → 7.17.27

package/fesm2022/acorex-core-dateTime.mjs

@@ -1,8 +1,9 @@
 import * as i0 from '@angular/core';
 import { inject, InjectionToken, Injectable, Pipe, NgModule } from '@angular/core';
-import { Subject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 import { AX_GLOBAL_CONFIG } from '@acorex/core/config';
-import { orderBy, set, isNil } from 'lodash-es';
+import { defaults, orderBy, set, isNil } from 'lodash-es';
+import { translateSync } from '@acorex/core/translation';
 import * as i1 from '@acorex/core/format';
 import { AXFormatModule } from '@acorex/core/format';
 
@@ -19,11 +20,8 @@ class AXCalendar {
     get formats() {
         return this._config.formats;
     }
-    get dayNames() {
-        return this._config.dayNames;
-    }
-    get monthNames() {
-        return this._config.monthNames;
+    get weekdays() {
+        return this._config.weekdays;
     }
 }
 class AXDateTime {
@@ -34,6 +32,7 @@ class AXDateTime {
         return this._calendar;
     }
     constructor(value, calendar) {
+        //TODO: remove unused items
         this._formatKeys = {
             ss: () => this.pad(this.date.getSeconds(), 2),
             s: () => this.date.getSeconds().toString(),
@@ -45,13 +44,14 @@ class AXDateTime {
             mm: () => this.pad(this.date.getMinutes(), 2),
             m: () => this.date.getMinutes().toString(),
             //
-            MMMM: () => this.calendar.monthNames[this.calendar.monthOfYear(this.date) - 1].long,
-            MMM: () => this.calendar.monthNames[this.calendar.monthOfYear(this.date) - 1].short,
+            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),
             //
-            DDDD: () => this.calendar.dayNames[this.calendar.dayOfWeek(this.date) - 1].long,
-            DDD: () => this.calendar.dayNames[this.calendar.dayOfWeek(this.date) - 1].short,
+            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),
@@ -66,7 +66,15 @@ class AXDateTime {
             //
             A: () => (this.date.getHours() < 12 ? 'am' : 'pm'),
             a: () => (this.date.getHours() < 12 ? 'am' : 'pm'),
-            //"date": () => this.format(this.getFormatPattern('fa-IR', 'date')),
+            '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(this.getDateTimeFormatByLocale(options.locale, 'longTime')),
         };
         this._calendar = calendar;
         this._date = value;
@@ -122,14 +130,58 @@ class AXDateTime {
     endOf(unit = 'day') {
         return this._calendar.endOf(this.date, unit);
     }
-    format(format = this.calendar.formats.dateTimeDisplay) {
+    format(format = this.getDateTimeFormatByLocale(navigator.language, 'shortDate'), options) {
+        const effectiveOptions = defaults({}, options, {
+            locale: navigator.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();
+            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;
@@ -875,26 +927,8 @@ const AXDateTimeDefaultConfig = {
     calendar: 'georgian',
     calendars: {
         georgian: new GeorgianCalendar({
-            dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'].map((d) => ({
-                long: d,
-                short: d.substring(0, 3),
-                letter: d[0],
-            })),
-            monthNames: [
-                'January',
-                'February',
-                'March',
-                'April',
-                'May',
-                'June',
-                'July',
-                'August',
-                'September',
-                'October',
-                'November',
-                'December',
-            ].map((d) => ({ long: d, short: d.substring(0, 3), letter: d[0] })),
-            weekend: [6, 7],
+            weekdays: [0, 1, 2, 3, 4, 5, 6],
+            weekend: [5, 6],
             formats: {
                 dateInput: 'yyyy/MM/dd',
                 timeInput: 'HH:mm',
@@ -905,13 +939,8 @@ const AXDateTimeDefaultConfig = {
             },
         }),
         jalali: new JalaliCalendar({
-            monthNames: 'فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند'
-                .split('_')
-                .map((d) => ({ long: d, short: d, letter: d[0] })),
-            dayNames: 'شنبه_یکشنبه_دوشنبه_سه شنبه_چهارشنبه_پنج شنبه_جمعه'
-                .split('_')
-                .map((d) => ({ long: d, short: d[0], letter: d[0] })),
-            weekend: [7],
+            weekdays: [6, 0, 1, 2, 3, 4, 5],
+            weekend: [6],
             formats: {
                 dateInput: 'yyyy/MM/dd',
                 timeInput: 'HH:mm',
@@ -945,14 +974,26 @@ const AX_DATETIME_HOLIDAYS_LOADER = new InjectionToken('AX_DATETIME_HOLIDAYS_LOA
 
 class AXCalendarService {
     get calendar() {
-        return this._config.calendars[this._config.calendar];
+        return this.getActiveCalendar();
+    }
+    getDefaultCalendar() {
+        return this.config.calendars[this.config.calendar];
+    }
+    getActiveCalendar() {
+        return this.activeCalendar.getValue();
+    }
+    setActiveCalendar(name) {
+        const calendar = this.resolveCalendar(name);
+        this.activeCalendar.next(calendar);
     }
     get holidays() {
         return this._holidays;
     }
     constructor() {
-        this._config = inject(AX_DATETIME_CONFIG);
+        this.config = inject(AX_DATETIME_CONFIG);
         this._holidaysLoader = inject(AX_DATETIME_HOLIDAYS_LOADER);
+        this.activeCalendar = new BehaviorSubject(this.getDefaultCalendar());
+        this.calendarChanges$ = this.activeCalendar.asObservable();
         this.onHolidaysChanged = new Subject();
         this._holidays = [];
         this.loadHolidays();
@@ -978,7 +1019,7 @@ class AXCalendarService {
         return new AXDateTime(new Date(), calendar);
     }
     resolveCalendar(name) {
-        const c = this._config.calendars[name];
+        const c = this.config.calendars[name];
         if (!c) {
             console.error(`"${name}" is not a valid calendar name!`);
             return this.calendar;
@@ -986,10 +1027,6 @@ class AXCalendarService {
         return c;
     }
     convert(value, calendarName) {
-        // const isISOString = val => {
-        //     const d = new Date(val);
-        //     return !Number.isNaN(d.valueOf()) && d.toISOString() === val;
-        // };
         const isISOString = (str) => {
             if (!/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d{3}Z)?/.test(str))
                 return false;
@@ -1022,9 +1059,18 @@ class AXDateTimeFormatter {
     get name() {
         return 'datetime';
     }
-    format(value, ...args) {
-        const formatStr = (args.length ? args[0] : null);
-        return this.calendarService.create(value).format(formatStr);
+    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.0.8", ngImport: i0, type: AXDateTimeFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeFormatter }); }
@@ -1032,17 +1078,18 @@ class AXDateTimeFormatter {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeFormatter, decorators: [{
             type: Injectable
         }] });
+
 class AXTimeLeftFormatter {
     get name() {
         return 'timeleft';
     }
-    format(value, ...args) {
+    format(value, options) {
         const milliseconds = Number(value);
         if (milliseconds === null || isNaN(milliseconds)) {
             return "Calculating...";
         }
         const durationInSeconds = Math.round(milliseconds / 1000);
-        let format = args[0];
+        let format = options?.format;
         // Determine the best format if format is null
         if (isNil(format)) {
             if (durationInSeconds < 45)
@@ -1120,6 +1167,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImpor
             type: Injectable
         }] });
 
+/**
+ * @deprecated The pipe should not be used, use format instead
+ */
 class AXDateTimePipe {
     constructor() {
         this._calendarService = inject(AXCalendarService);
@@ -1133,12 +1183,7 @@ class AXDateTimePipe {
             calendar = this._calendarService.resolveCalendar(calendarName);
         }
         const val = this._calendarService.convert(value, calendar.name());
-        if (!format) {
-            return val.format(calendar.formats.dateDisplay);
-        }
-        else {
-            return val.format(format);
-        }
+        return val.format(format);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
     static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimePipe, name: "axDate" }); }
@@ -1149,25 +1194,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImpor
         }] });
 
 class AXDateTimeModule {
-    constructor(service) {
-        service.register(new AXDateTimeFormatter(), new AXTimeLeftFormatter());
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, deps: [{ token: i1.AXFormatterRegistryService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, declarations: [AXDateTimePipe], imports: [AXFormatModule], exports: [AXDateTimePipe] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, imports: [AXFormatModule] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, declarations: [AXDateTimePipe], imports: [i1.AXFormatModule], exports: [AXDateTimePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, imports: [AXFormatModule.forChild({ formatters: [AXDateTimeFormatter, AXTimeLeftFormatter] })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: AXDateTimeModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXFormatModule],
+                    imports: [AXFormatModule.forChild({ formatters: [AXDateTimeFormatter, AXTimeLeftFormatter] })],
                     exports: [AXDateTimePipe],
                     declarations: [AXDateTimePipe],
                 }]
-        }], ctorParameters: () => [{ type: i1.AXFormatterRegistryService }] });
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXCalendar, AXCalendarMonth, AXCalendarService, AXDateTime, AXDateTimeDefaultConfig, AXDateTimeModule, AXDateTimePipe, AXDateTimeRange, AXHolidaysLoaderDefault, AX_DATETIME_CONFIG, AX_DATETIME_HOLIDAYS_LOADER, GeorgianCalendar, JalaliCalendar, dateTimeConfig };
+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-dateTime.mjs.map