@imihai/angular-datetime-picker 21.0.2 → 22.0.0

package/projects/picker/src/lib/date-time/adapter/luxon-date-time-adapter.class.ts

@@ -0,0 +1,307 @@
+/**
+ * luxon-date-time-adapter.class
+ */
+
+import { Inject, Injectable, Optional } from '@angular/core';
+import { DateTime, Info, Settings } from 'luxon';
+
+import {
+    DateTimeAdapter,
+    OWL_DATE_TIME_LOCALE,
+} from './date-time-adapter.class';
+
+@Injectable()
+export class LuxonDateTimeAdapter extends DateTimeAdapter<DateTime> {
+    public firstMonthOfTheYear = 0;
+
+    /**
+     * 0 - Sunday
+     * 1 - Monday
+     * ...
+     * 6 - Saturday
+     */
+    public firstDayOfTheWeek = 0;
+
+    public constructor(
+        @Optional()
+        @Inject(OWL_DATE_TIME_LOCALE)
+        private owlDateTimeLocale: string,
+    ) {
+        super();
+
+        this.setLocale(owlDateTimeLocale || Settings.defaultLocale || 'ru');
+    }
+
+    public getYear(date: DateTime): number {
+        return date.year;
+    }
+
+    /**
+     * Picker expects month index:
+     * 0 - January
+     * 11 - December
+     *
+     * Luxon uses:
+     * 1 - January
+     * 12 - December
+     */
+    public getMonth(date: DateTime): number {
+        return date.month - 1;
+    }
+
+    /**
+     * Picker expects:
+     * 0 - Sunday
+     * 6 - Saturday
+     *
+     * Luxon weekday:
+     * 1 - Monday
+     * 7 - Sunday
+     */
+    public getDay(date: DateTime): number {
+        return date.weekday % 7;
+    }
+
+    public getDate(date: DateTime): number {
+        return date.day;
+    }
+
+    public getHours(date: DateTime): number {
+        return date.hour;
+    }
+
+    public getMinutes(date: DateTime): number {
+        return date.minute;
+    }
+
+    public getSeconds(date: DateTime): number {
+        return date.second;
+    }
+
+    public getTime(date: DateTime): number {
+        return date.toMillis();
+    }
+
+    public getNumDaysInMonth(date: DateTime): number {
+        return date.daysInMonth ?? 0;
+    }
+
+    public differenceInCalendarDays(dateLeft: DateTime, dateRight: DateTime): number {
+        if (this.isValid(dateLeft) && this.isValid(dateRight)) {
+            return Math.round(
+                dateLeft.startOf('day').diff(dateRight.startOf('day'), 'days').days,
+            );
+        }
+
+        return null;
+    }
+
+    public getYearName(date: DateTime): string {
+        return date.setLocale(this.locale).toFormat('yyyy');
+    }
+
+    public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {
+        return Info.months(style, { locale: this.locale });
+    }
+
+    public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {
+        const weekdays = Info.weekdays(style, { locale: this.locale });
+
+        // Luxon returns Monday..Sunday.
+        // Existing picker expects Sunday..Saturday.
+        return [
+            weekdays[6],
+            ...weekdays.slice(0, 6),
+        ];
+    }
+
+    public getDateNames(): string[] {
+        return Array.from({ length: 31 }, (_, index) => `${index + 1}`);
+    }
+
+    public toIso8601(date: DateTime): string {
+        return date.toISO() ?? '';
+    }
+
+    public isEqual(dateLeft: DateTime, dateRight: DateTime): boolean {
+        if (this.isValid(dateLeft) && this.isValid(dateRight)) {
+            return dateLeft.toMillis() === dateRight.toMillis();
+        }
+
+        return false;
+    }
+
+    public isSameDay(dateLeft: DateTime, dateRight: DateTime): boolean {
+        if (this.isValid(dateLeft) && this.isValid(dateRight)) {
+            return (
+                dateLeft.year === dateRight.year &&
+                dateLeft.month === dateRight.month &&
+                dateLeft.day === dateRight.day
+            );
+        }
+
+        return false;
+    }
+
+    public isValid(date: DateTime): boolean {
+        return DateTime.isDateTime(date) && date.isValid;
+    }
+
+    public invalid(): DateTime {
+        return DateTime.invalid('Invalid date');
+    }
+
+    public isDateInstance(obj: unknown): boolean {
+        return DateTime.isDateTime(obj);
+    }
+
+    public addCalendarYears(date: DateTime, amount: number): DateTime {
+        return date.plus({ years: Number(amount) });
+    }
+
+    public addCalendarMonths(date: DateTime, amount: number): DateTime {
+        return date.plus({ months: Number(amount) });
+    }
+
+    public addCalendarDays(date: DateTime, amount: number): DateTime {
+        return date.plus({ days: Number(amount) });
+    }
+
+    public setHours(date: DateTime, amount: number): DateTime {
+        return date.set({ hour: amount });
+    }
+
+    public setMinutes(date: DateTime, amount: number): DateTime {
+        return date.set({ minute: amount });
+    }
+
+    public setSeconds(date: DateTime, amount: number): DateTime {
+        return date.set({ second: amount });
+    }
+
+    public createDate(
+        year: number,
+        month: number,
+        date: number,
+        hours = 0,
+        minutes = 0,
+        seconds = 0,
+    ): DateTime {
+        const result = DateTime.local(
+            year,
+            month + 1,
+            date,
+            hours,
+            minutes,
+            seconds,
+            0,
+        ).setLocale(this.locale);
+
+        if (!result.isValid) {
+            throw Error(
+                `LuxonDateTimeAdapter: Invalid date "${date}" for month with index "${month}".`,
+            );
+        }
+
+        return result;
+    }
+
+    public clone(date: DateTime): DateTime {
+        return DateTime.fromMillis(date.toMillis(), {
+            zone: date.zone,
+            locale: date.locale,
+        });
+    }
+
+    public now(): DateTime {
+        return DateTime.local().setLocale(this.locale);
+    }
+
+    public format(date: DateTime, displayFormat: string): string {
+        if (!this.isValid(date)) {
+            throw Error('LuxonDateTimeAdapter: Cannot format invalid date.');
+        }
+
+        return date.setLocale(this.locale).toFormat(displayFormat);
+    }
+
+    public parse(value: unknown, parseFormat: string | string[]): DateTime | null {
+        if (value == null || value === '') {
+            return null;
+        }
+
+        if (DateTime.isDateTime(value)) {
+            return value.isValid ? value.setLocale(this.locale) : this.invalid();
+        }
+
+        if (value instanceof Date) {
+            const date = DateTime.fromJSDate(value).setLocale(this.locale);
+
+            return date.isValid ? date : this.invalid();
+        }
+
+        if (typeof value === 'number') {
+            const date = DateTime.fromMillis(value).setLocale(this.locale);
+
+            return date.isValid ? date : this.invalid();
+        }
+
+        if (typeof value !== 'string') {
+            return this.invalid();
+        }
+
+        const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
+
+        for (const format of formats) {
+            const parsed = DateTime.fromFormat(value, format, {
+                locale: this.locale,
+            });
+
+            if (parsed.isValid) {
+                return parsed;
+            }
+        }
+
+        const iso = DateTime.fromISO(value, {
+            locale: this.locale,
+        });
+
+        return iso.isValid ? iso : this.invalid();
+    }
+
+    public deserialize(value: unknown): DateTime | null {
+        if (value == null || value === '') {
+            return null;
+        }
+
+        if (DateTime.isDateTime(value)) {
+            return value.isValid ? value.setLocale(this.locale) : this.invalid();
+        }
+
+        if (value instanceof Date) {
+            const date = DateTime.fromJSDate(value).setLocale(this.locale);
+
+            return date.isValid ? date : this.invalid();
+        }
+
+        if (typeof value === 'number') {
+            const date = DateTime.fromMillis(value).setLocale(this.locale);
+
+            return date.isValid ? date : this.invalid();
+        }
+
+        if (typeof value === 'string') {
+            const date = DateTime.fromISO(value, {
+                locale: this.locale,
+            });
+
+            return date.isValid ? date : this.invalid();
+        }
+
+        return this.invalid();
+    }
+
+    public override setLocale(locale: string): void {
+        super.setLocale(locale || 'ru');
+    }
+}

package/projects/picker/src/lib/date-time/adapter/luxon-date-time-format.class.ts

@@ -0,0 +1,11 @@
+import { OwlDateTimeFormats } from './date-time-format.class';
+
+export const OWL_LUXON_DATE_TIME_FORMATS: OwlDateTimeFormats = {
+    parseInput: 'dd.MM.yyyy HH:mm',
+    fullPickerInput: 'dd.MM.yyyy HH:mm',
+    datePickerInput: 'dd.MM.yyyy',
+    timePickerInput: 'HH:mm',
+    monthYearLabel: 'LLL yyyy',
+    dateA11yLabel: 'dd.MM.yyyy',
+    monthYearA11yLabel: 'LLLL yyyy',
+};

package/projects/picker/src/lib/date-time/adapter/luxon-date-time.module.ts

@@ -0,0 +1,31 @@
+/**
+ * luxon-date-time.module
+ */
+
+import { NgModule } from '@angular/core';
+
+import { DateTimeAdapter } from './date-time-adapter.class';
+import { OWL_DATE_TIME_FORMATS } from './date-time-format.class';
+import { LuxonDateTimeAdapter } from './luxon-date-time-adapter.class';
+import { OWL_LUXON_DATE_TIME_FORMATS } from './luxon-date-time-format.class';
+
+@NgModule({
+    providers: [
+        {
+            provide: DateTimeAdapter,
+            useClass: LuxonDateTimeAdapter,
+        },
+    ],
+})
+export class LuxonDateTimeModule {}
+
+@NgModule({
+    imports: [LuxonDateTimeModule],
+    providers: [
+        {
+            provide: OWL_DATE_TIME_FORMATS,
+            useValue: OWL_LUXON_DATE_TIME_FORMATS,
+        },
+    ],
+})
+export class OwlLuxonDateTimeModule {}

package/projects/picker/src/lib/date-time/adapter/unix-timestamp-adapter/unix-timestamp-date-time-adapter.class.ts

@@ -0,0 +1,356 @@
+/**
+ * unix-timestamp-date-time-adapter.class
+ */
+
+import { Inject, Injectable, Optional } from '@angular/core';
+import { DateTime, Info, Settings } from 'luxon';
+
+import {
+    DateTimeAdapter,
+    OWL_DATE_TIME_LOCALE,
+} from '../date-time-adapter.class';
+
+@Injectable()
+export class UnixTimestampDateTimeAdapter extends DateTimeAdapter<number> {
+    public firstMonthOfTheYear = 0;
+
+    /**
+     * Picker expects:
+     * 0 - Sunday
+     * 1 - Monday
+     * ...
+     * 6 - Saturday
+     */
+    public firstDayOfTheWeek = 0;
+
+    public constructor(
+        @Optional()
+        @Inject(OWL_DATE_TIME_LOCALE)
+        private owlDateTimeLocale: string,
+    ) {
+        super();
+
+        this.setLocale(owlDateTimeLocale || Settings.defaultLocale || 'ru');
+    }
+
+    public getYear(date: number): number {
+        return this.fromTimestamp(date).year;
+    }
+
+    /**
+     * Picker expects:
+     * 0 - January
+     * 11 - December
+     *
+     * Luxon uses:
+     * 1 - January
+     * 12 - December
+     */
+    public getMonth(date: number): number {
+        return this.fromTimestamp(date).month - 1;
+    }
+
+    /**
+     * Picker expects:
+     * 0 - Sunday
+     * 6 - Saturday
+     *
+     * Luxon weekday:
+     * 1 - Monday
+     * 7 - Sunday
+     */
+    public getDay(date: number): number {
+        return this.fromTimestamp(date).weekday % 7;
+    }
+
+    public getDate(date: number): number {
+        return this.fromTimestamp(date).day;
+    }
+
+    public getHours(date: number): number {
+        return this.fromTimestamp(date).hour;
+    }
+
+    public getMinutes(date: number): number {
+        return this.fromTimestamp(date).minute;
+    }
+
+    public getSeconds(date: number): number {
+        return this.fromTimestamp(date).second;
+    }
+
+    public getTime(date: number): number {
+        return date;
+    }
+
+    public getNumDaysInMonth(date: number): number {
+        return this.fromTimestamp(date).daysInMonth ?? 0;
+    }
+
+    public differenceInCalendarDays(dateLeft: number, dateRight: number): number {
+        if (!this.isValid(dateLeft) || !this.isValid(dateRight)) {
+            return Number.NaN;
+        }
+
+        return Math.round(
+            this.fromTimestamp(dateLeft)
+                .startOf('day')
+                .diff(this.fromTimestamp(dateRight).startOf('day'), 'days').days,
+        );
+    }
+
+    public getYearName(date: number): string {
+        return this.fromTimestamp(date).toFormat('yyyy');
+    }
+
+    public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {
+        return Info.months(style, { locale: this.locale });
+    }
+
+    public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {
+        const weekdays = Info.weekdays(style, { locale: this.locale });
+
+        // Luxon returns Monday..Sunday.
+        // Existing picker expects Sunday..Saturday.
+        return [
+            weekdays[6],
+            ...weekdays.slice(0, 6),
+        ];
+    }
+
+    public getDateNames(): string[] {
+        return Array.from({ length: 31 }, (_, index) => `${index + 1}`);
+    }
+
+    public toIso8601(date: number): string {
+        return this.fromTimestamp(date).toISO() ?? '';
+    }
+
+    public isEqual(dateLeft: number, dateRight: number): boolean {
+        if (!this.isValid(dateLeft) || !this.isValid(dateRight)) {
+            return false;
+        }
+
+        return dateLeft === dateRight;
+    }
+
+    public isSameDay(dateLeft: number, dateRight: number): boolean {
+        if (!this.isValid(dateLeft) || !this.isValid(dateRight)) {
+            return false;
+        }
+
+        return this.fromTimestamp(dateLeft).hasSame(
+            this.fromTimestamp(dateRight),
+            'day',
+        );
+    }
+
+    public isValid(date: number): boolean {
+        return typeof date === 'number' && !Number.isNaN(date);
+    }
+
+    public invalid(): number {
+        return NaN;
+    }
+
+    public isDateInstance(obj: unknown): boolean {
+        return typeof obj === 'number';
+    }
+
+    public addCalendarYears(date: number, amount: number): number {
+        return this.fromTimestamp(date)
+            .plus({ years: Number(amount) })
+            .toMillis();
+    }
+
+    public addCalendarMonths(date: number, amount: number): number {
+        return this.fromTimestamp(date)
+            .plus({ months: Number(amount) })
+            .toMillis();
+    }
+
+    public addCalendarDays(date: number, amount: number): number {
+        return this.fromTimestamp(date)
+            .plus({ days: Number(amount) })
+            .toMillis();
+    }
+
+    public setHours(date: number, amount: number): number {
+        return this.fromTimestamp(date)
+            .set({ hour: amount })
+            .toMillis();
+    }
+
+    public setMinutes(date: number, amount: number): number {
+        return this.fromTimestamp(date)
+            .set({ minute: amount })
+            .toMillis();
+    }
+
+    public setSeconds(date: number, amount: number): number {
+        return this.fromTimestamp(date)
+            .set({ second: amount })
+            .toMillis();
+    }
+
+    public createDate(
+        year: number,
+        month: number,
+        date: number,
+        hours = 0,
+        minutes = 0,
+        seconds = 0,
+    ): number {
+        const result = DateTime.local(
+            year,
+            month + 1,
+            date,
+            hours,
+            minutes,
+            seconds,
+            0,
+        ).setLocale(this.locale);
+
+        if (!result.isValid) {
+            throw Error(
+                `UnixTimestampDateTimeAdapter: Invalid date "${date}" for month with index "${month}".`,
+            );
+        }
+
+        return result.toMillis();
+    }
+
+    public clone(date: number): number {
+        return date;
+    }
+
+    public now(): number {
+        return DateTime.local()
+            .setLocale(this.locale)
+            .toMillis();
+    }
+
+    /**
+     * Hybrid formatter:
+     * - string => Luxon format, e.g. 'dd.MM.yyyy HH:mm'
+     * - Intl.DateTimeFormatOptions => old adapter-compatible formatting
+     */
+    public format(
+        date: number,
+        displayFormat: string | Intl.DateTimeFormatOptions,
+    ): string {
+        if (!this.isValid(date)) {
+            throw Error('UnixTimestampDateTimeAdapter: Cannot format invalid date.');
+        }
+
+        const dt = this.fromTimestamp(date);
+
+        if (typeof displayFormat === 'string') {
+            return dt.toFormat(displayFormat);
+        }
+
+        return this.stripDirectionalityCharacters(
+            dt.toJSDate().toLocaleDateString(this.locale, displayFormat),
+        );
+    }
+
+    public parse(value: unknown, parseFormat: string | string[] | null): number | null {
+        if (value == null || value === '') {
+            return null;
+        }
+
+        if (typeof value === 'number') {
+            return this.isValid(value) ? value : this.invalid();
+        }
+
+        if (value instanceof Date) {
+            const date = DateTime.fromJSDate(value).setLocale(this.locale);
+
+            return date.isValid ? date.toMillis() : this.invalid();
+        }
+
+        if (DateTime.isDateTime(value)) {
+            return value.isValid
+                ? value.setLocale(this.locale).toMillis()
+                : this.invalid();
+        }
+
+        if (typeof value !== 'string') {
+            return this.invalid();
+        }
+
+        if (parseFormat) {
+            const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
+
+            for (const format of formats) {
+                if (typeof format !== 'string') {
+                    continue;
+                }
+
+                const parsed = DateTime.fromFormat(value, format, {
+                    locale: this.locale,
+                });
+
+                if (parsed.isValid) {
+                    return parsed.toMillis();
+                }
+            }
+        }
+
+        const iso = DateTime.fromISO(value, {
+            locale: this.locale,
+        });
+
+        if (iso.isValid) {
+            return iso.toMillis();
+        }
+
+        const jsDate = DateTime.fromJSDate(new Date(value)).setLocale(this.locale);
+
+        return jsDate.isValid ? jsDate.toMillis() : this.invalid();
+    }
+
+    public override deserialize(value: unknown): number | null {
+        if (value == null || value === '') {
+            return null;
+        }
+
+        if (typeof value === 'number') {
+            return this.isValid(value) ? value : this.invalid();
+        }
+
+        if (value instanceof Date) {
+            const date = DateTime.fromJSDate(value).setLocale(this.locale);
+
+            return date.isValid ? date.toMillis() : this.invalid();
+        }
+
+        if (DateTime.isDateTime(value)) {
+            return value.isValid
+                ? value.setLocale(this.locale).toMillis()
+                : this.invalid();
+        }
+
+        if (typeof value === 'string') {
+            const date = DateTime.fromISO(value, {
+                locale: this.locale,
+            });
+
+            return date.isValid ? date.toMillis() : this.invalid();
+        }
+
+        return this.invalid();
+    }
+
+    public override setLocale(locale: string): void {
+        super.setLocale(locale || 'ru');
+    }
+
+    private fromTimestamp(timestamp: number): DateTime {
+        return DateTime.fromMillis(timestamp).setLocale(this.locale);
+    }
+
+    private stripDirectionalityCharacters(value: string): string {
+        return value.replace(/[\u200e\u200f]/g, '');
+    }
+}

package/projects/picker/src/lib/date-time/adapter/unix-timestamp-adapter/unix-timestamp-date-time-format.class.ts

@@ -0,0 +1,14 @@
+/**
+ * unix-timestamp-date-time-format.class
+ */
+import {OwlDateTimeFormats} from '../date-time-format.class';
+
+export const OWL_UNIX_TIMESTAMP_DATE_TIME_FORMATS: OwlDateTimeFormats = {
+    parseInput: null,
+    fullPickerInput: {year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric'},
+    datePickerInput: {year: 'numeric', month: 'numeric', day: 'numeric'},
+    timePickerInput: {hour: 'numeric', minute: 'numeric'},
+    monthYearLabel: {year: 'numeric', month: 'short'},
+    dateA11yLabel: {year: 'numeric', month: 'long', day: 'numeric'},
+    monthYearA11yLabel: {year: 'numeric', month: 'long'},
+};