cmat 0.0.3

package/fesm2022/cmat-components-adapter.mjs

@@ -0,0 +1,600 @@
+import * as i1 from '@angular/material/core';
+import { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Optional, Inject } from '@angular/core';
+import dayjs from 'dayjs';
+import localeData from 'dayjs/plugin/localeData';
+import utc from 'dayjs/plugin/utc';
+import LocalizedFormat from 'dayjs/plugin/localizedFormat';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+
+class DatetimeAdapter extends DateAdapter {
+    constructor(_delegate) {
+        super();
+        this._delegate = _delegate;
+    }
+    getValidDateOrNull(obj) {
+        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;
+    }
+    compareDatetime(first, second, respectMinutePart = true) {
+        return this.compareDate(first, second) ||
+            this.getHour(first) - this.getHour(second) ||
+            (respectMinutePart && this.getMinute(first) - this.getMinute(second));
+    }
+    sameDatetime(first, second) {
+        if (first && second) {
+            const firstValid = this.isValid(first);
+            const secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareDatetime(first, second);
+            }
+            return firstValid === secondValid;
+        }
+        return first === second;
+    }
+    sameYear(first, second) {
+        return first && second && this.getYear(first) === this.getYear(second);
+    }
+    sameDay(first, second) {
+        return first && second && this.getDate(first) === this.getDate(second) && this.sameMonthAndYear(first, second);
+    }
+    sameHour(first, second) {
+        return first && second && this.getHour(first) === this.getHour(second) && this.sameDay(first, second);
+    }
+    sameMinute(first, second) {
+        return first && second && this.getMinute(first) === this.getMinute(second) && this.sameHour(first, second);
+    }
+    sameMonthAndYear(first, second) {
+        if (first && second) {
+            const firstValid = this.isValid(first);
+            const secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !(this.getYear(first) - this.getYear(second) ||
+                    this.getMonth(first) - this.getMonth(second));
+            }
+            return firstValid === secondValid;
+        }
+        return first === second;
+    }
+    // delegate
+    clone(date) {
+        return this._delegate.clone(date);
+    }
+    addCalendarYears(date, years) {
+        return this._delegate.addCalendarYears(date, years);
+    }
+    addCalendarMonths(date, months) {
+        return this._delegate.addCalendarMonths(date, months);
+    }
+    addCalendarDays(date, days) {
+        return this._delegate.addCalendarDays(date, days);
+    }
+    getYear(date) {
+        return this._delegate.getYear(date);
+    }
+    getMonth(date) {
+        return this._delegate.getMonth(date);
+    }
+    getDate(date) {
+        return this._delegate.getDate(date);
+    }
+    getDayOfWeek(date) {
+        return this._delegate.getDayOfWeek(date);
+    }
+    getMonthNames(style) {
+        return this._delegate.getMonthNames(style);
+    }
+    getDateNames() {
+        return this._delegate.getDateNames();
+    }
+    getDayOfWeekNames(style) {
+        return this._delegate.getDayOfWeekNames(style);
+    }
+    getYearName(date) {
+        return this._delegate.getYearName(date);
+    }
+    getFirstDayOfWeek() {
+        return this._delegate.getFirstDayOfWeek();
+    }
+    getNumDaysInMonth(date) {
+        return this._delegate.getNumDaysInMonth(date);
+    }
+    createDate(year, month, date) {
+        return this._delegate.createDate(year, month, date);
+    }
+    today() {
+        return this._delegate.today();
+    }
+    parse(value, parseFormat) {
+        return this._delegate.parse(value, parseFormat);
+    }
+    format(date, displayFormat) {
+        return this._delegate.format(date, displayFormat);
+    }
+    toIso8601(date) {
+        return this._delegate.toIso8601(date);
+    }
+    isDateInstance(obj) {
+        return this._delegate.isDateInstance(obj);
+    }
+    isValid(date) {
+        return this._delegate.isValid(date);
+    }
+    invalid() {
+        return this._delegate.invalid();
+    }
+    clampDate(date, min, max) {
+        if (min && this.compareDatetime(date, min) < 0) {
+            return min;
+        }
+        if (max && this.compareDatetime(date, max) > 0) {
+            return max;
+        }
+        return date;
+    }
+}
+
+const CMAT_DATETIME_FORMATS = new InjectionToken('cmat-datetime-formats');
+
+/** The default hour names to use if Intl API is not available. */
+const DEFAULT_HOUR_NAMES = range$2(24, i => String(i));
+/** The default minute names to use if Intl API is not available. */
+const DEFAULT_MINUTE_NAMES = range$2(60, i => String(i));
+function range$2(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+class CNativeDatetimeAdapter extends DatetimeAdapter {
+    constructor(matDateLocale, _delegate) {
+        super(_delegate);
+        this.setLocale(matDateLocale);
+    }
+    clone(date) {
+        return this.createDatetime(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date), this.getMinute(date));
+    }
+    getHour(date) {
+        return date.getHours();
+    }
+    getMinute(date) {
+        return date.getMinutes();
+    }
+    isInNextMonth(startDate, endDate) {
+        const nextMonth = this._getDateInNextMonth(startDate);
+        return this.sameMonthAndYear(nextMonth, endDate);
+    }
+    createDatetime(year, month, date, hour, minute) {
+        // Check for invalid month and date (except upper bound on date which we have to check after
+        // creating the Date).
+        if (month < 0 || month > 11) {
+            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+        }
+        if (date < 1) {
+            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+        }
+        if (hour < 0 || hour > 23) {
+            throw Error(`Invalid hour "${hour}". Hour has to be between 0 and 23.`);
+        }
+        if (minute < 0 || minute > 59) {
+            throw Error(`Invalid minute "${minute}". Minute has to be between 0 and 59.`);
+        }
+        const result = this._createDateWithOverflow(year, month, date, hour, minute);
+        // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+        if (result.getMonth() !== month) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    getFirstDateOfMonth(date) {
+        const result = new Date();
+        result.setFullYear(date.getFullYear(), date.getMonth(), 1);
+        return result;
+    }
+    getHourNames() {
+        return DEFAULT_HOUR_NAMES;
+    }
+    getMinuteNames() {
+        return DEFAULT_MINUTE_NAMES;
+    }
+    addCalendarYears(date, years) {
+        return this.addCalendarMonths(date, years * 12);
+    }
+    addCalendarMonths(date, months) {
+        let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date), this.getHour(date), this.getMinute(date));
+        // It's possible to wind up in the wrong month if the original month has more days than the new
+        // month. In this case we want to go to the last day of the desired month.
+        // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't
+        // guarantee this.
+        if (this.getMonth(newDate) !== ((this.getMonth(date) + months) % 12 + 12) % 12) {
+            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0, this.getHour(date), this.getMinute(date));
+        }
+        return newDate;
+    }
+    addCalendarDays(date, days) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days, this.getHour(date), this.getMinute(date));
+    }
+    addCalendarHours(date, hours) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date) + hours, this.getMinute(date));
+    }
+    addCalendarMinutes(date, minutes) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date), this.getMinute(date) + minutes);
+    }
+    toIso8601(date) {
+        return super.toIso8601(date) + 'T' + [
+            this._2digit(date.getUTCHours()),
+            this._2digit(date.getUTCMinutes())
+        ].join(':');
+    }
+    _getDateInNextMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 1, date.getHours(), date.getMinutes());
+    }
+    /**
+     * Pads a number to make it two digits.
+     *
+     * @param n The number to pad.
+     * @returns The padded number.
+     */
+    _2digit(n) {
+        return ('00' + n).slice(-2);
+    }
+    /* Creates a date but allows the month and date to overflow. */
+    _createDateWithOverflow(year, month, date, hours, minutes) {
+        const result = new Date(year, month, date, hours, minutes);
+        // We need to correct for the fact that JS native Date treats years in range [0, 99] as
+        // abbreviations for 19xx.
+        if (year >= 0 && year < 100) {
+            result.setFullYear(this.getYear(result) - 1900);
+        }
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CNativeDatetimeAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: i1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CNativeDatetimeAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CNativeDatetimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DATE_LOCALE]
+                }] }, { type: i1.DateAdapter }] });
+
+const CMAT_NATIVE_DATETIME_FORMATS = {
+    parse: {},
+    display: {
+        dateInput: { year: 'numeric', month: '2-digit', day: '2-digit' },
+        monthInput: { month: 'long' },
+        datetimeInput: { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' },
+        timeInput: { hour: '2-digit', minute: '2-digit' },
+        yearInput: { year: 'numeric' },
+        monthYearLabel: { year: 'numeric', month: 'short' },
+        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+        monthYearA11yLabel: { year: 'numeric', month: 'long' },
+        popupHeaderDateLabel: { weekday: 'short', month: 'short', day: '2-digit' }
+    }
+};
+
+function range$1(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+class DayjsDatetimeAdapter extends DatetimeAdapter {
+    constructor(matDateLocale, _delegate) {
+        super(_delegate);
+        this.setLocale(matDateLocale || dayjs.locale());
+        dayjs.extend(localeData);
+    }
+    setLocale(locale) {
+        super.setLocale(locale);
+        const dayjsLocaleData = dayjs.localeData();
+        this._localeData = {
+            firstDayOfWeek: dayjsLocaleData.firstDayOfWeek(),
+            longMonths: dayjsLocaleData.months(),
+            shortMonths: dayjsLocaleData.monthsShort(),
+            dates: range$1(31, i => super.createDate(2017, 0, i + 1).format('D')),
+            hours: range$1(24, i => this.createDatetime(2017, 0, 1, i, 0).format('H')),
+            minutes: range$1(60, i => this.createDatetime(2017, 0, 1, 1, i).format('m')),
+            longDaysOfWeek: dayjsLocaleData.weekdays(),
+            shortDaysOfWeek: dayjsLocaleData.weekdaysShort(),
+            narrowDaysOfWeek: dayjsLocaleData.weekdaysMin()
+        };
+    }
+    getHour(date) {
+        return super.clone(date).hour();
+    }
+    getMinute(date) {
+        return super.clone(date).minute();
+    }
+    isInNextMonth(startDate, endDate) {
+        const nextMonth = this._getDateInNextMonth(startDate);
+        return super.sameMonthAndYear(nextMonth, endDate);
+    }
+    createDatetime(year, month, date, hour, minute) {
+        // Check for invalid month and date (except upper bound on date which we have to check after
+        // creating the Date).
+        if (month < 0 || month > 11) {
+            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+        }
+        if (date < 1) {
+            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+        }
+        if (hour < 0 || hour > 23) {
+            throw Error(`Invalid hour "${hour}". Hour has to be between 0 and 23.`);
+        }
+        if (minute < 0 || minute > 59) {
+            throw Error(`Invalid minute "${minute}". Minute has to be between 0 and 59.`);
+        }
+        const result = dayjs(new Date(year, month, date, hour, minute));
+        // If the result isn't valid, the date must have been out of bounds for this month.
+        if (!result.isValid()) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    getFirstDateOfMonth(date) {
+        return super.clone(date).startOf('month');
+    }
+    getHourNames() {
+        return this._localeData.hours;
+    }
+    getMinuteNames() {
+        return this._localeData.minutes;
+    }
+    addCalendarHours(date, hours) {
+        return super.clone(date).add(hours, 'hour');
+    }
+    addCalendarMinutes(date, minutes) {
+        return super.clone(date).add(minutes, 'minute');
+    }
+    deserialize(value) {
+        return this._delegate.deserialize(value);
+    }
+    _getDateInNextMonth(date) {
+        return super.clone(date).date(1).add(1, 'month');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: DayjsDatetimeAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: i1.DateAdapter }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: DayjsDatetimeAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: DayjsDatetimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DATE_LOCALE]
+                }] }, { type: i1.DateAdapter }] });
+
+const CMAT_DAYJS_DATETIME_FORMATS = {
+    parse: {
+        dateInput: 'L',
+        monthInput: 'MMMM',
+        timeInput: 'LT',
+        datetimeInput: 'L LT',
+        yearInput: 'YYYY'
+    },
+    display: {
+        dateInput: 'L',
+        monthInput: 'MMMM',
+        datetimeInput: 'L LT',
+        timeInput: 'LT',
+        yearInput: 'YYYY',
+        monthYearLabel: 'MMM YYYY',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'MMMM YYYY',
+        popupHeaderDateLabel: 'MMM DD,  ddd'
+    }
+};
+
+/** InjectionToken for Dayjs date adapter to configure options. */
+const CMAT_DAYJS_DATE_ADAPTER_OPTIONS = new InjectionToken('CMAT_DAYJS_DATE_ADAPTER_OPTIONS', {
+    providedIn: 'root',
+    factory: CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY
+});
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY() {
+    return {
+        useUtc: false
+    };
+}
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+/** Adapts Dayjs Dates for use with Angular Material. */
+class DayjsDateAdapter extends DateAdapter {
+    constructor(dateLocale, _options) {
+        super();
+        this.dateLocale = dateLocale;
+        this._options = _options;
+        this._initializeParser(dateLocale);
+    }
+    get _shouldUseUtc() {
+        const { useUtc } = this._options || {};
+        return !!useUtc;
+    }
+    setLocale(locale) {
+        super.setLocale(locale);
+        const dayJsLocaleData = this._dayJs().localeData();
+        this._localeData = {
+            firstDayOfWeek: dayJsLocaleData.firstDayOfWeek(),
+            longMonths: dayJsLocaleData.months(),
+            shortMonths: dayJsLocaleData.monthsShort(),
+            dates: range(31, i => this.createDate(2017, 0, i + 1).format('D')),
+            longDaysOfWeek: range(7, i => this._dayJs().set('day', i).format('dddd')),
+            shortDaysOfWeek: dayJsLocaleData.weekdaysShort(),
+            narrowDaysOfWeek: dayJsLocaleData.weekdaysMin(),
+        };
+    }
+    getYear(date) {
+        return this._dayJs(date).year();
+    }
+    getMonth(date) {
+        return this._dayJs(date).month();
+    }
+    getDate(date) {
+        return this._dayJs(date).date();
+    }
+    getDayOfWeek(date) {
+        return this._dayJs(date).day();
+    }
+    getMonthNames(style) {
+        return style === 'long' ? this._localeData.longMonths : this._localeData.shortMonths;
+    }
+    getDateNames() {
+        return this._localeData.dates;
+    }
+    getDayOfWeekNames(style) {
+        if (style === 'long') {
+            return this._localeData.longDaysOfWeek;
+        }
+        if (style === 'short') {
+            return this._localeData.shortDaysOfWeek;
+        }
+        return this._localeData.narrowDaysOfWeek;
+    }
+    getYearName(date) {
+        return this._dayJs(date).format('YYYY');
+    }
+    getFirstDayOfWeek() {
+        return this._localeData.firstDayOfWeek;
+    }
+    getNumDaysInMonth(date) {
+        return this._dayJs(date).daysInMonth();
+    }
+    clone(date) {
+        return date.clone();
+    }
+    createDate(year, month, date) {
+        const returnDayjs = this._dayJs()
+            .set('year', year)
+            .set('month', month)
+            .set('date', date);
+        return returnDayjs;
+    }
+    today() {
+        return this._dayJs();
+    }
+    parse(value, parseFormat) {
+        if (value && typeof value === 'string') {
+            return this._dayJs(value, parseFormat, this.locale);
+        }
+        return value ? this._dayJs(value).locale(this.locale) : null;
+    }
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('DayjsDateAdapter: Cannot format invalid date.');
+        }
+        return date.locale(this.locale).format(displayFormat);
+    }
+    addCalendarYears(date, years) {
+        return date.add(years, 'year');
+    }
+    addCalendarMonths(date, months) {
+        return date.add(months, 'month');
+    }
+    addCalendarDays(date, days) {
+        return date.add(days, 'day');
+    }
+    toIso8601(date) {
+        return date.toISOString();
+    }
+    /**
+     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+     * string). The default implementation does not allow any deserialization, it simply checks that
+     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
+     * method on all of it's `@Input()` properties that accept dates. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     *
+     * @param value The value to be deserialized into a date object.
+     * @returns The deserialized date object, either a valid date, null if the value can be
+     *     deserialized into a null date (e.g. the empty string), or an invalid date.
+     */
+    deserialize(value) {
+        let date;
+        if (value instanceof Date) {
+            date = this._dayJs(value);
+        }
+        else if (this.isDateInstance(value)) {
+            // NOTE: assumes that cloning also sets the correct locale.
+            return this.clone(value);
+        }
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            date = this._dayJs(value).toISOString();
+        }
+        if (date && this.isValid(date)) {
+            return this._dayJs(date); // NOTE: Is this necessary since Dayjs is immutable and Moment was not?
+        }
+        return super.deserialize(value);
+    }
+    isDateInstance(obj) {
+        return dayjs.isDayjs(obj);
+    }
+    isValid(date) {
+        return this._dayJs(date).isValid();
+    }
+    invalid() {
+        return this._dayJs(null);
+    }
+    _dayJs(input, format, locale) {
+        if (!this._shouldUseUtc) {
+            return dayjs(input, { format, locale }, locale);
+        }
+        return dayjs(input, { format, locale, utc: this._shouldUseUtc }, locale).utc();
+    }
+    _initializeParser(dateLocale) {
+        if (this._shouldUseUtc) {
+            dayjs.extend(utc);
+        }
+        dayjs.extend(LocalizedFormat);
+        dayjs.extend(customParseFormat);
+        dayjs.extend(localeData);
+        this.setLocale(dateLocale);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: DayjsDateAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: CMAT_DAYJS_DATE_ADAPTER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: DayjsDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: DayjsDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DATE_LOCALE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CMAT_DAYJS_DATE_ADAPTER_OPTIONS]
+                }] }] });
+
+const CMAT_DAYJS_DATE_FORMATS = {
+    parse: {
+        dateInput: 'YYYY/MM/DD',
+    },
+    display: {
+        dateInput: 'YYYY/MM/DD',
+        monthYearLabel: 'YYYY MMM',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'YYYY MMMM',
+    }
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CMAT_DATETIME_FORMATS, CMAT_DAYJS_DATETIME_FORMATS, CMAT_DAYJS_DATE_ADAPTER_OPTIONS, CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY, CMAT_DAYJS_DATE_FORMATS, CMAT_NATIVE_DATETIME_FORMATS, CNativeDatetimeAdapter, DatetimeAdapter, DayjsDateAdapter, DayjsDatetimeAdapter };
+//# sourceMappingURL=cmat-components-adapter.mjs.map