cmat 0.0.3

package/esm2022/components/adapter/dayjs-date-adapter.mjs

@@ -0,0 +1,198 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import localeData from 'dayjs/plugin/localeData';
+import LocalizedFormat from 'dayjs/plugin/localizedFormat';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import * as i0 from "@angular/core";
+/** InjectionToken for Dayjs date adapter to configure options. */
+export 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
+export 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. */
+export 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]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dayjs-date-adapter.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/adapter/dayjs-date-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\r\nimport { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';\r\nimport dayjs, { Dayjs } from 'dayjs';\r\nimport utc from 'dayjs/plugin/utc';\r\nimport localeData from 'dayjs/plugin/localeData';\r\nimport LocalizedFormat from 'dayjs/plugin/localizedFormat';\r\nimport customParseFormat from 'dayjs/plugin/customParseFormat';\r\n\r\n\r\nexport interface DayJsDateAdapterOptions {\r\n    /**\r\n     * Turns the use of utc dates on or off.\r\n     * Changing this will change how Angular Material components like DatePicker output dates.\r\n     * {@default false}\r\n     */\r\n    useUtc?: boolean;\r\n}\r\n\r\n/** InjectionToken for Dayjs date adapter to configure options. */\r\nexport const CMAT_DAYJS_DATE_ADAPTER_OPTIONS = new InjectionToken<DayJsDateAdapterOptions>(\r\n    'CMAT_DAYJS_DATE_ADAPTER_OPTIONS', {\r\n    providedIn: 'root',\r\n    factory: CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY\r\n});\r\n\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function CMAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY(): DayJsDateAdapterOptions {\r\n    return {\r\n        useUtc: false\r\n    };\r\n}\r\n\r\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\r\n    const valuesArray = Array(length);\r\n    for (let i = 0; i < length; i++) {\r\n        valuesArray[i] = valueFunction(i);\r\n    }\r\n    return valuesArray;\r\n}\r\n\r\n@Injectable()\r\n/** Adapts Dayjs Dates for use with Angular Material. */\r\nexport class DayjsDateAdapter extends DateAdapter<Dayjs> {\r\n    private _localeData: {\r\n        firstDayOfWeek: number;\r\n        longMonths: string[];\r\n        shortMonths: string[];\r\n        dates: string[];\r\n        longDaysOfWeek: string[];\r\n        shortDaysOfWeek: string[];\r\n        narrowDaysOfWeek: string[];\r\n    };\r\n\r\n    constructor(@Optional() @Inject(MAT_DATE_LOCALE) public dateLocale: string,\r\n        @Optional() @Inject(CMAT_DAYJS_DATE_ADAPTER_OPTIONS) private _options?: DayJsDateAdapterOptions) {\r\n        super();\r\n\r\n        this._initializeParser(dateLocale);\r\n    }\r\n    private get _shouldUseUtc(): boolean {\r\n        const { useUtc }: DayJsDateAdapterOptions = this._options || {};\r\n        return !!useUtc;\r\n    }\r\n\r\n    override setLocale(locale: string): void {\r\n        super.setLocale(locale);\r\n\r\n        const dayJsLocaleData = this._dayJs().localeData();\r\n        this._localeData = {\r\n            firstDayOfWeek: dayJsLocaleData.firstDayOfWeek(),\r\n            longMonths: dayJsLocaleData.months(),\r\n            shortMonths: dayJsLocaleData.monthsShort(),\r\n            dates: range(31, i => this.createDate(2017, 0, i + 1).format('D')),\r\n            longDaysOfWeek: range(7, i => this._dayJs().set('day', i).format('dddd')),\r\n            shortDaysOfWeek: dayJsLocaleData.weekdaysShort(),\r\n            narrowDaysOfWeek: dayJsLocaleData.weekdaysMin(),\r\n        };\r\n    }\r\n\r\n    getYear(date: Dayjs): number {\r\n        return this._dayJs(date).year();\r\n    }\r\n\r\n    getMonth(date: Dayjs): number {\r\n        return this._dayJs(date).month();\r\n    }\r\n\r\n    getDate(date: Dayjs): number {\r\n        return this._dayJs(date).date();\r\n    }\r\n\r\n    getDayOfWeek(date: Dayjs): number {\r\n        return this._dayJs(date).day();\r\n    }\r\n\r\n    getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\r\n        return style === 'long' ? this._localeData.longMonths : this._localeData.shortMonths;\r\n    }\r\n\r\n    getDateNames(): string[] {\r\n        return this._localeData.dates;\r\n    }\r\n\r\n    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\r\n        if (style === 'long') {\r\n            return this._localeData.longDaysOfWeek;\r\n        }\r\n        if (style === 'short') {\r\n            return this._localeData.shortDaysOfWeek;\r\n        }\r\n        return this._localeData.narrowDaysOfWeek;\r\n    }\r\n\r\n    getYearName(date: Dayjs): string {\r\n        return this._dayJs(date).format('YYYY');\r\n    }\r\n\r\n    getFirstDayOfWeek(): number {\r\n        return this._localeData.firstDayOfWeek;\r\n    }\r\n\r\n    getNumDaysInMonth(date: Dayjs): number {\r\n        return this._dayJs(date).daysInMonth();\r\n    }\r\n\r\n    clone(date: Dayjs): Dayjs {\r\n        return date.clone();\r\n    }\r\n\r\n    createDate(year: number, month: number, date: number): Dayjs {\r\n        const returnDayjs = this._dayJs()\r\n            .set('year', year)\r\n            .set('month', month)\r\n            .set('date', date);\r\n        return returnDayjs;\r\n    }\r\n\r\n    today(): Dayjs {\r\n        return this._dayJs();\r\n    }\r\n\r\n    parse(value: any, parseFormat: string): Dayjs | null {\r\n        if (value && typeof value === 'string') {\r\n            return this._dayJs(value, parseFormat, this.locale);\r\n        }\r\n        return value ? this._dayJs(value).locale(this.locale) : null;\r\n    }\r\n\r\n    format(date: Dayjs, displayFormat: string): string {\r\n        if (!this.isValid(date)) {\r\n            throw Error('DayjsDateAdapter: Cannot format invalid date.');\r\n        }\r\n        return date.locale(this.locale).format(displayFormat);\r\n    }\r\n\r\n    addCalendarYears(date: Dayjs, years: number): Dayjs {\r\n        return date.add(years, 'year');\r\n    }\r\n\r\n    addCalendarMonths(date: Dayjs, months: number): Dayjs {\r\n        return date.add(months, 'month');\r\n    }\r\n\r\n    addCalendarDays(date: Dayjs, days: number): Dayjs {\r\n        return date.add(days, 'day');\r\n    }\r\n\r\n    toIso8601(date: Dayjs): string {\r\n        return date.toISOString();\r\n    }\r\n\r\n    /**\r\n     * Attempts to deserialize a value to a valid date object. This is different from parsing in that\r\n     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601\r\n     * string). The default implementation does not allow any deserialization, it simply checks that\r\n     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this\r\n     * method on all of it's `@Input()` properties that accept dates. It is therefore possible to\r\n     * support passing values from your backend directly to these properties by overriding this method\r\n     * to also deserialize the format used by your backend.\r\n     *\r\n     * @param value The value to be deserialized into a date object.\r\n     * @returns The deserialized date object, either a valid date, null if the value can be\r\n     *     deserialized into a null date (e.g. the empty string), or an invalid date.\r\n     */\r\n    override deserialize(value: any): Dayjs | null {\r\n        let date: any;\r\n        if (value instanceof Date) {\r\n            date = this._dayJs(value);\r\n        } else if (this.isDateInstance(value)) {\r\n            // NOTE: assumes that cloning also sets the correct locale.\r\n            return this.clone(value);\r\n        }\r\n        if (typeof value === 'string') {\r\n            if (!value) {\r\n                return null;\r\n            }\r\n            date = this._dayJs(value).toISOString();\r\n        }\r\n        if (date && this.isValid(date)) {\r\n            return this._dayJs(date); // NOTE: Is this necessary since Dayjs is immutable and Moment was not?\r\n        }\r\n        return super.deserialize(value);\r\n    }\r\n\r\n    isDateInstance(obj: any): boolean {\r\n        return dayjs.isDayjs(obj);\r\n    }\r\n\r\n    isValid(date: Dayjs): boolean {\r\n        return this._dayJs(date).isValid();\r\n    }\r\n\r\n    invalid(): Dayjs {\r\n        return this._dayJs(null);\r\n    }\r\n\r\n    private _dayJs(input?: any, format?: string, locale?: string): Dayjs {\r\n        if (!this._shouldUseUtc) {\r\n            return dayjs(input, { format, locale }, locale);\r\n        }\r\n        return dayjs(input, { format, locale, utc: this._shouldUseUtc }, locale).utc();\r\n    }\r\n\r\n    private _initializeParser(dateLocale: string): void {\r\n        if (this._shouldUseUtc) {\r\n            dayjs.extend(utc);\r\n        }\r\n\r\n        dayjs.extend(LocalizedFormat);\r\n        dayjs.extend(customParseFormat);\r\n        dayjs.extend(localeData);\r\n\r\n        this.setLocale(dateLocale);\r\n    }\r\n}\r\n"]}

package/esm2022/components/adapter/dayjs-date-formats.mjs

@@ -0,0 +1,12 @@
+export const CMAT_DAYJS_DATE_FORMATS = {
+    parse: {
+        dateInput: 'YYYY/MM/DD',
+    },
+    display: {
+        dateInput: 'YYYY/MM/DD',
+        monthYearLabel: 'YYYY MMM',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'YYYY MMMM',
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF5anMtZGF0ZS1mb3JtYXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9jb21wb25lbnRzL2FkYXB0ZXIvZGF5anMtZGF0ZS1mb3JtYXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFtQjtJQUNuRCxLQUFLLEVBQUU7UUFDSCxTQUFTLEVBQUUsWUFBWTtLQUMxQjtJQUNELE9BQU8sRUFBRTtRQUNMLFNBQVMsRUFBRSxZQUFZO1FBQ3ZCLGNBQWMsRUFBRSxVQUFVO1FBQzFCLGFBQWEsRUFBRSxJQUFJO1FBQ25CLGtCQUFrQixFQUFFLFdBQVc7S0FDbEM7Q0FDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTWF0RGF0ZUZvcm1hdHMgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9jb3JlJztcclxuXHJcbmV4cG9ydCBjb25zdCBDTUFUX0RBWUpTX0RBVEVfRk9STUFUUzogTWF0RGF0ZUZvcm1hdHMgPSB7XHJcbiAgICBwYXJzZToge1xyXG4gICAgICAgIGRhdGVJbnB1dDogJ1lZWVkvTU0vREQnLFxyXG4gICAgfSxcclxuICAgIGRpc3BsYXk6IHtcclxuICAgICAgICBkYXRlSW5wdXQ6ICdZWVlZL01NL0REJyxcclxuICAgICAgICBtb250aFllYXJMYWJlbDogJ1lZWVkgTU1NJyxcclxuICAgICAgICBkYXRlQTExeUxhYmVsOiAnTEwnLFxyXG4gICAgICAgIG1vbnRoWWVhckExMXlMYWJlbDogJ1lZWVkgTU1NTScsXHJcbiAgICB9XHJcbn07XHJcbiJdfQ==

package/esm2022/components/adapter/dayjs-datetime-adapter.mjs

@@ -0,0 +1,100 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { MAT_DATE_LOCALE } from '@angular/material/core';
+import { DatetimeAdapter } from './datetime-adapter';
+import dayjs from 'dayjs';
+import localeData from 'dayjs/plugin/localeData';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+export 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(31, i => super.createDate(2017, 0, i + 1).format('D')),
+            hours: range(24, i => this.createDatetime(2017, 0, 1, i, 0).format('H')),
+            minutes: range(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 }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dayjs-datetime-adapter.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/adapter/dayjs-datetime-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\r\nimport { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';\r\nimport { DatetimeAdapter } from './datetime-adapter';\r\nimport dayjs, { Dayjs } from 'dayjs';\r\nimport localeData from 'dayjs/plugin/localeData';\r\n\r\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\r\n    const valuesArray = Array(length);\r\n    for (let i = 0; i < length; i++) {\r\n        valuesArray[i] = valueFunction(i);\r\n    }\r\n    return valuesArray;\r\n}\r\n\r\n@Injectable()\r\nexport class DayjsDatetimeAdapter extends DatetimeAdapter<Dayjs> {\r\n\r\n    private _localeData: {\r\n        firstDayOfWeek: number;\r\n        longMonths: string[];\r\n        shortMonths: string[];\r\n        dates: string[];\r\n        hours: string[];\r\n        minutes: string[];\r\n        longDaysOfWeek: string[];\r\n        shortDaysOfWeek: string[];\r\n        narrowDaysOfWeek: string[];\r\n    };\r\n\r\n    constructor(@Optional() @Inject(MAT_DATE_LOCALE) matDateLocale: string,\r\n        _delegate: DateAdapter<Dayjs>) {\r\n        super(_delegate);\r\n        this.setLocale(matDateLocale || dayjs.locale());\r\n        dayjs.extend(localeData);\r\n    }\r\n\r\n    override setLocale(locale: string): void {\r\n        super.setLocale(locale);\r\n\r\n        const dayjsLocaleData = dayjs.localeData();\r\n        this._localeData = {\r\n            firstDayOfWeek: dayjsLocaleData.firstDayOfWeek(),\r\n            longMonths: dayjsLocaleData.months(),\r\n            shortMonths: dayjsLocaleData.monthsShort(),\r\n            dates: range(31, i => super.createDate(2017, 0, i + 1).format('D')),\r\n            hours: range(24, i => this.createDatetime(2017, 0, 1, i, 0).format('H')),\r\n            minutes: range(60, i => this.createDatetime(2017, 0, 1, 1, i).format('m')),\r\n            longDaysOfWeek: dayjsLocaleData.weekdays(),\r\n            shortDaysOfWeek: dayjsLocaleData.weekdaysShort(),\r\n            narrowDaysOfWeek: dayjsLocaleData.weekdaysMin()\r\n        };\r\n    }\r\n\r\n    getHour(date: Dayjs): number {\r\n        return super.clone(date).hour();\r\n    }\r\n\r\n    getMinute(date: Dayjs): number {\r\n        return super.clone(date).minute();\r\n    }\r\n\r\n    isInNextMonth(startDate: Dayjs, endDate: Dayjs): boolean {\r\n        const nextMonth = this._getDateInNextMonth(startDate);\r\n        return super.sameMonthAndYear(nextMonth, endDate);\r\n    }\r\n\r\n    createDatetime(year: number, month: number, date: number, hour: number, minute: number): Dayjs {\r\n        // Check for invalid month and date (except upper bound on date which we have to check after\r\n        // creating the Date).\r\n        if (month < 0 || month > 11) {\r\n            throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\r\n        }\r\n\r\n        if (date < 1) {\r\n            throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\r\n        }\r\n\r\n        if (hour < 0 || hour > 23) {\r\n            throw Error(`Invalid hour \"${hour}\". Hour has to be between 0 and 23.`);\r\n        }\r\n\r\n        if (minute < 0 || minute > 59) {\r\n            throw Error(`Invalid minute \"${minute}\". Minute has to be between 0 and 59.`);\r\n        }\r\n\r\n        const result = dayjs(new Date(year, month, date, hour, minute));\r\n\r\n        // If the result isn't valid, the date must have been out of bounds for this month.\r\n        if (!result.isValid()) {\r\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    getFirstDateOfMonth(date: Dayjs): Dayjs {\r\n        return super.clone(date).startOf('month');\r\n    }\r\n\r\n    getHourNames(): string[] {\r\n        return this._localeData.hours;\r\n    }\r\n\r\n    getMinuteNames(): string[] {\r\n        return this._localeData.minutes;\r\n    }\r\n\r\n    addCalendarHours(date: Dayjs, hours: number): Dayjs {\r\n        return super.clone(date).add(hours, 'hour');\r\n    }\r\n\r\n    addCalendarMinutes(date: Dayjs, minutes: number): Dayjs {\r\n        return super.clone(date).add(minutes, 'minute');\r\n    }\r\n\r\n    override deserialize(value: any): Dayjs | null {\r\n        return this._delegate.deserialize(value);\r\n    }\r\n\r\n    private _getDateInNextMonth(date: Dayjs): Dayjs {\r\n        return super.clone(date).date(1).add(1, 'month');\r\n    }\r\n}\r\n"]}

package/esm2022/components/adapter/dayjs-datetime-formats.mjs

@@ -0,0 +1,21 @@
+export 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'
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF5anMtZGF0ZXRpbWUtZm9ybWF0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9hZGFwdGVyL2RheWpzLWRhdGV0aW1lLWZvcm1hdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQXdCO0lBQzVELEtBQUssRUFBRTtRQUNILFNBQVMsRUFBRSxHQUFHO1FBQ2QsVUFBVSxFQUFFLE1BQU07UUFDbEIsU0FBUyxFQUFFLElBQUk7UUFDZixhQUFhLEVBQUUsTUFBTTtRQUNyQixTQUFTLEVBQUUsTUFBTTtLQUNwQjtJQUNELE9BQU8sRUFBRTtRQUNMLFNBQVMsRUFBRSxHQUFHO1FBQ2QsVUFBVSxFQUFFLE1BQU07UUFDbEIsYUFBYSxFQUFFLE1BQU07UUFDckIsU0FBUyxFQUFFLElBQUk7UUFDZixTQUFTLEVBQUUsTUFBTTtRQUNqQixjQUFjLEVBQUUsVUFBVTtRQUMxQixhQUFhLEVBQUUsSUFBSTtRQUNuQixrQkFBa0IsRUFBRSxXQUFXO1FBQy9CLG9CQUFvQixFQUFFLGNBQWM7S0FDdkM7Q0FDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ21hdERhdGV0aW1lRm9ybWF0cyB9IGZyb20gJy4vZGF0ZXRpbWUtZm9ybWF0cyc7XHJcblxyXG5leHBvcnQgY29uc3QgQ01BVF9EQVlKU19EQVRFVElNRV9GT1JNQVRTOiBDbWF0RGF0ZXRpbWVGb3JtYXRzID0ge1xyXG4gICAgcGFyc2U6IHtcclxuICAgICAgICBkYXRlSW5wdXQ6ICdMJyxcclxuICAgICAgICBtb250aElucHV0OiAnTU1NTScsXHJcbiAgICAgICAgdGltZUlucHV0OiAnTFQnLFxyXG4gICAgICAgIGRhdGV0aW1lSW5wdXQ6ICdMIExUJyxcclxuICAgICAgICB5ZWFySW5wdXQ6ICdZWVlZJ1xyXG4gICAgfSxcclxuICAgIGRpc3BsYXk6IHtcclxuICAgICAgICBkYXRlSW5wdXQ6ICdMJyxcclxuICAgICAgICBtb250aElucHV0OiAnTU1NTScsXHJcbiAgICAgICAgZGF0ZXRpbWVJbnB1dDogJ0wgTFQnLFxyXG4gICAgICAgIHRpbWVJbnB1dDogJ0xUJyxcclxuICAgICAgICB5ZWFySW5wdXQ6ICdZWVlZJyxcclxuICAgICAgICBtb250aFllYXJMYWJlbDogJ01NTSBZWVlZJyxcclxuICAgICAgICBkYXRlQTExeUxhYmVsOiAnTEwnLFxyXG4gICAgICAgIG1vbnRoWWVhckExMXlMYWJlbDogJ01NTU0gWVlZWScsXHJcbiAgICAgICAgcG9wdXBIZWFkZXJEYXRlTGFiZWw6ICdNTU0gREQsICBkZGQnXHJcbiAgICB9XHJcbn07XHJcbiJdfQ==

package/esm2022/components/adapter/native-datetime-adapter.mjs

@@ -0,0 +1,130 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { MAT_DATE_LOCALE } from '@angular/material/core';
+import { DatetimeAdapter } from './datetime-adapter';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+/** The default hour names to use if Intl API is not available. */
+const DEFAULT_HOUR_NAMES = range(24, i => String(i));
+/** The default minute names to use if Intl API is not available. */
+const DEFAULT_MINUTE_NAMES = range(60, i => String(i));
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+export 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 }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-datetime-adapter.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/adapter/native-datetime-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\r\nimport { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';\r\nimport { DatetimeAdapter } from './datetime-adapter';\r\n\r\n/** The default hour names to use if Intl API is not available. */\r\nconst DEFAULT_HOUR_NAMES = range(24, i => String(i));\r\n\r\n/** The default minute names to use if Intl API is not available. */\r\nconst DEFAULT_MINUTE_NAMES = range(60, i => String(i));\r\n\r\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\r\n  const valuesArray = Array(length);\r\n  for (let i = 0; i < length; i++) {\r\n    valuesArray[i] = valueFunction(i);\r\n  }\r\n  return valuesArray;\r\n}\r\n\r\n@Injectable()\r\nexport class CNativeDatetimeAdapter extends DatetimeAdapter<Date> {\r\n\r\n  constructor(@Optional() @Inject(MAT_DATE_LOCALE) matDateLocale: string, _delegate: DateAdapter<Date>) {\r\n    super(_delegate);\r\n    this.setLocale(matDateLocale);\r\n  }\r\n\r\n  override clone(date: Date): Date {\r\n    return this.createDatetime(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date), this.getMinute(date));\r\n  }\r\n\r\n  getHour(date: Date): number {\r\n    return date.getHours();\r\n  }\r\n\r\n  getMinute(date: Date): number {\r\n    return date.getMinutes();\r\n  }\r\n\r\n  isInNextMonth(startDate: Date, endDate: Date): boolean {\r\n    const nextMonth = this._getDateInNextMonth(startDate);\r\n    return this.sameMonthAndYear(nextMonth, endDate);\r\n  }\r\n\r\n  createDatetime(year: number, month: number, date: number, hour: number, minute: number): Date {\r\n    // Check for invalid month and date (except upper bound on date which we have to check after\r\n    // creating the Date).\r\n    if (month < 0 || month > 11) {\r\n      throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\r\n    }\r\n\r\n    if (date < 1) {\r\n      throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\r\n    }\r\n\r\n    if (hour < 0 || hour > 23) {\r\n      throw Error(`Invalid hour \"${hour}\". Hour has to be between 0 and 23.`);\r\n    }\r\n\r\n    if (minute < 0 || minute > 59) {\r\n      throw Error(`Invalid minute \"${minute}\". Minute has to be between 0 and 59.`);\r\n    }\r\n\r\n    const result = this._createDateWithOverflow(year, month, date, hour, minute);\r\n\r\n    // Check that the date wasn't above the upper bound for the month, causing the month to overflow\r\n    if (result.getMonth() !== month) {\r\n      throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  getFirstDateOfMonth(date: Date): Date {\r\n    const result = new Date();\r\n    result.setFullYear(date.getFullYear(), date.getMonth(), 1);\r\n    return result;\r\n  }\r\n\r\n  getHourNames(): string[] {\r\n    return DEFAULT_HOUR_NAMES;\r\n  }\r\n\r\n  getMinuteNames(): string[] {\r\n    return DEFAULT_MINUTE_NAMES;\r\n  }\r\n\r\n  override addCalendarYears(date: Date, years: number): Date {\r\n    return this.addCalendarMonths(date, years * 12);\r\n  }\r\n\r\n  override addCalendarMonths(date: Date, months: number): Date {\r\n    let newDate = this._createDateWithOverflow(\r\n      this.getYear(date), this.getMonth(date) + months, this.getDate(date), this.getHour(date), this.getMinute(date));\r\n\r\n    // It's possible to wind up in the wrong month if the original month has more days than the new\r\n    // month. In this case we want to go to the last day of the desired month.\r\n    // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't\r\n    // guarantee this.\r\n    if (this.getMonth(newDate) !== ((this.getMonth(date) + months) % 12 + 12) % 12) {\r\n      newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0, this.getHour(date), this.getMinute(date));\r\n    }\r\n\r\n    return newDate;\r\n  }\r\n\r\n  override addCalendarDays(date: Date, days: number): Date {\r\n    return this._createDateWithOverflow(\r\n      this.getYear(date), this.getMonth(date), this.getDate(date) + days, this.getHour(date), this.getMinute(date));\r\n  }\r\n\r\n  addCalendarHours(date: Date, hours: number): Date {\r\n    return this._createDateWithOverflow(\r\n      this.getYear(date), this.getMonth(date), this.getDate(date),\r\n      this.getHour(date) + hours, this.getMinute(date));\r\n  }\r\n\r\n  addCalendarMinutes(date: Date, minutes: number): Date {\r\n    return this._createDateWithOverflow(\r\n      this.getYear(date), this.getMonth(date), this.getDate(date),\r\n      this.getHour(date), this.getMinute(date) + minutes);\r\n  }\r\n\r\n  override toIso8601(date: Date): string {\r\n    return super.toIso8601(date) + 'T' + [\r\n      this._2digit(date.getUTCHours()),\r\n      this._2digit(date.getUTCMinutes())\r\n    ].join(':');\r\n  }\r\n\r\n  private _getDateInNextMonth(date: Date): Date {\r\n    return new Date(date.getFullYear(), date.getMonth() + 1, 1,\r\n      date.getHours(), date.getMinutes());\r\n  }\r\n\r\n\r\n  /**\r\n   * Pads a number to make it two digits.\r\n   *\r\n   * @param n The number to pad.\r\n   * @returns The padded number.\r\n   */\r\n  private _2digit(n: number): string {\r\n    return ('00' + n).slice(-2);\r\n  }\r\n\r\n  /* Creates a date but allows the month and date to overflow. */\r\n  private _createDateWithOverflow(year: number, month: number, date: number,\r\n    hours: number, minutes: number): Date {\r\n    const result = new Date(year, month, date, hours, minutes);\r\n\r\n    // We need to correct for the fact that JS native Date treats years in range [0, 99] as\r\n    // abbreviations for 19xx.\r\n    if (year >= 0 && year < 100) {\r\n      result.setFullYear(this.getYear(result) - 1900);\r\n    }\r\n    return result;\r\n  }\r\n}\r\n"]}

package/esm2022/components/adapter/native-datetime-formats.mjs

@@ -0,0 +1,15 @@
+export 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' }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/adapter/public-api.mjs

@@ -0,0 +1,9 @@
+export * from './datetime-adapter';
+export * from './datetime-formats';
+export * from './native-datetime-adapter';
+export * from './native-datetime-formats';
+export * from './dayjs-datetime-adapter';
+export * from './dayjs-datetime-formats';
+export * from './dayjs-date-adapter';
+export * from './dayjs-date-formats';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9hZGFwdGVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRldGltZS1hZGFwdGVyJztcclxuZXhwb3J0ICogZnJvbSAnLi9kYXRldGltZS1mb3JtYXRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9uYXRpdmUtZGF0ZXRpbWUtYWRhcHRlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbmF0aXZlLWRhdGV0aW1lLWZvcm1hdHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RheWpzLWRhdGV0aW1lLWFkYXB0ZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL2RheWpzLWRhdGV0aW1lLWZvcm1hdHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RheWpzLWRhdGUtYWRhcHRlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGF5anMtZGF0ZS1mb3JtYXRzJztcclxuIl19

package/esm2022/components/breadcrumb/breadcrumb-item.directive.mjs

@@ -0,0 +1,19 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * This directive is used to customize the breadcrumb label behavior
+ * *cmatBreadcrumbItem directive can be used in the child element of cmat-breadcrumb
+ * Usage: refer to the demo - app.component.html
+ */
+export class CmatBreadcrumbItemDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatBreadcrumbItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatBreadcrumbItemDirective, isStandalone: true, selector: "[cmatBreadcrumbItem]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatBreadcrumbItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cmatBreadcrumbItem]',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYi1pdGVtLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9icmVhZGNydW1iL2JyZWFkY3J1bWItaXRlbS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFMUM7Ozs7R0FJRztBQUtILE1BQU0sT0FBTywyQkFBMkI7OEdBQTNCLDJCQUEyQjtrR0FBM0IsMkJBQTJCOzsyRkFBM0IsMkJBQTJCO2tCQUp2QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxzQkFBc0I7b0JBQ2hDLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuLyoqXHJcbiAqIFRoaXMgZGlyZWN0aXZlIGlzIHVzZWQgdG8gY3VzdG9taXplIHRoZSBicmVhZGNydW1iIGxhYmVsIGJlaGF2aW9yXHJcbiAqICpjbWF0QnJlYWRjcnVtYkl0ZW0gZGlyZWN0aXZlIGNhbiBiZSB1c2VkIGluIHRoZSBjaGlsZCBlbGVtZW50IG9mIGNtYXQtYnJlYWRjcnVtYlxyXG4gKiBVc2FnZTogcmVmZXIgdG8gdGhlIGRlbW8gLSBhcHAuY29tcG9uZW50Lmh0bWxcclxuICovXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6ICdbY21hdEJyZWFkY3J1bWJJdGVtXScsXHJcbiAgICBzdGFuZGFsb25lOiB0cnVlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDbWF0QnJlYWRjcnVtYkl0ZW1EaXJlY3RpdmUge1xyXG59XHJcbiJdfQ==