@esfaenza/material-dayjs-adapter 12.2.6 → 13.1.0

package/esfaenza-material-dayjs-adapter.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@esfaenza/material-dayjs-adapter" />
 export * from './public-api';

package/esm2020/lib/adapter/DayjsDateAdapter.mjs

@@ -0,0 +1,373 @@
+// Angular
+import { Inject, Injectable } from "@angular/core";
+import { DateAdapter, MAT_DATE_LOCALE } from "@angular/material/core";
+import * as i0 from "@angular/core";
+/**
+ * Adapter per permettere a Material di funzionare senza problemi con DayJs. Per altri provider di date (es. moment) l'adapter viene fornito
+ * nativamente da Angular. Per DayJs invece bisogna reimplementarselo
+ */
+export class DayJsDateAdapter extends DateAdapter {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(dateLocale) {
+        super();
+        this.setLocale(dateLocale);
+    }
+    /**
+     * Imposta il locale utilizzato per tutte le date
+     *
+     * @param {string} locale Locale da impostare
+     */
+    setLocale(locale) {
+        super.setLocale(locale);
+        // il localeData si potrebbe prendere da this.dayJs().localeData(); ma io voglio usare le date solo nel formato italiano quindi cablo quello
+        switch (locale) {
+            case 'it':
+                import("dayjs/locale/it").then(mod => { this.loadLoacleDataModule(mod.default); });
+                break;
+            // In dayjs, nel locale "en" e basta non esistono i 3/4 delle info perché sono le cose generiche ereditate dai locali en-gb, en-au ecc...
+            // quindi mi baso sul locale inglese Britannico, ma comunque I'ts Coming Rome
+            case 'en':
+                import("dayjs/locale/en-gb").then(mod => { this.loadLoacleDataModule(mod.default); });
+                break;
+            default: throw `Locale non riconosicuto '${locale}'. Locali consentiti: 'it', 'en'`;
+        }
+    }
+    /**
+     * Effettua il caricamento del localeData coi nomi dei mesi, giorni ecc partendo dal modulo importato
+     *
+     * @param {any} mod Modulo caricato contenente il locale desiderato
+     */
+    loadLoacleDataModule(mod) {
+        this._localeData = {
+            firstDayOfWeek: mod.weekStart,
+            longMonths: mod.months,
+            shortMonths: mod.monthsShort,
+            dates: this.range(31, (i) => this.createDate(2017, 0, i + 1).format('D')),
+            longDaysOfWeek: mod.weekdays,
+            shortDaysOfWeek: mod.weekdaysShort,
+            narrowDaysOfWeek: mod.weekdaysMin,
+        };
+    }
+    /**
+     * Ottiene le ore da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Ore
+     */
+    getHour(date) {
+        return date.get("hour");
+    }
+    /**
+     * Ottiene i minuti da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Minuti
+     */
+    getMinute(date) {
+        return date.get("minute");
+    }
+    /**
+     * Ottiene i secondi da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Secondi
+     */
+    getSecond(date) {
+        return date.get("second");
+    }
+    /**
+     * Imposta le ore di una data Dayjs
+     *
+     * @param {Dayjs} date Data da modificare
+     * @param {number} value Valore da impostare per le ore
+     */
+    setHour(date, value) {
+        date.$H = value;
+    }
+    /**
+     * Imposta i minuti di una data Dayjs
+     *
+     * @param {Dayjs} date Data da modificare
+     * @param {number} value Valore da impostare per i minuti
+     */
+    setMinute(date, value) {
+        date.$m = value;
+    }
+    /**
+     * Imposta i secondi di una data Dayjs
+     *
+     * @param {Dayjs} date Data da modificare
+     * @param {number} value Valore da impostare per i secondi
+     */
+    setSecond(date, value) {
+        date.$s = value;
+    }
+    /**
+     * Ottiene l'anno da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Anno
+     */
+    getYear(date) {
+        return date.get("year");
+    }
+    /**
+     * Ottiene il mese da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Mese
+     */
+    getMonth(date) {
+        return date.get("month");
+    }
+    /**
+     * Ottiene il giorno da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Giorno
+     */
+    getDate(date) {
+        return date.get("date");
+    }
+    /**
+     * Ottiene il giorno della settimana da un DayJs
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Giorno della settimana da 1 a 7
+     */
+    getDayOfWeek(date) {
+        return date.get("day");
+    }
+    /**
+     * Ottiene i nomi dei mesi
+     *
+     * @param {"long" | "short" | "narrow"} style Stile dei nomi richiesto
+     *
+     * @returns {string[]} Lista dei mesi espressi in base al parametro **style**
+     */
+    getMonthNames(style) {
+        return style == 'long' ? this._localeData.longMonths : this._localeData.shortMonths;
+    }
+    /**
+     * Ottiene i nomi dei giorni del mese
+     *
+     * @returns {string[]} Lista dei giorni del mese (da '1' a '31')
+     */
+    getDateNames() {
+        return this._localeData.dates;
+    }
+    /**
+     * Ottiene i nomi dei giorni della settimana
+     *
+     * @param {"long" | "short" | "narrow"} style Stile dei nomi richiesto
+     *
+     * @returns {string[]} Lista dei giorni della settimana espressi in base al parametro **style**
+     */
+    getDayOfWeekNames(style) {
+        if (style == 'long')
+            return this._localeData.longDaysOfWeek;
+        else if (style == 'short')
+            return this._localeData.shortDaysOfWeek;
+        return this._localeData.narrowDaysOfWeek;
+    }
+    /**
+     * Ottiene il nome dell'anno
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {string} Anno
+     */
+    getYearName(date) {
+        return this.getYear(date).toString();
+    }
+    /**
+     * Ottiene il primo giorno della settimana
+     *
+     * @returns {number} Indice del primo giorno della settimana
+     */
+    getFirstDayOfWeek() {
+        return this._localeData.firstDayOfWeek;
+    }
+    /**
+     * Ottiene il numero di giorni nel mese corrente
+     *
+     * @param {Dayjs} date Data Dayjs
+     *
+     * @returns {number} Numero di giorni
+     */
+    getNumDaysInMonth(date) {
+        return date.daysInMonth();
+    }
+    /**
+     * Ottiene il clone di una data Dayjs
+     *
+     * @param {Dayjs} Data da clonare
+     *
+     * @returns {Dayjs} Clone
+     */
+    clone(date) {
+        // Visto che ho modificato l'istanza originale a manazza (vedi setHour, setMinute, setSecond) l'oggetto è danneggiato e per restituire un clone buono
+        // devo ricrearlo prendendo pezzo per pezzo
+        // Il mese è un indice 0-11 quindi devo dargli un +1 qua
+        return dayjs(`${this.getYear(date)}-${this.getMonth(date) + 1}-${this.getDate(date)} ${this.getHour(date)}:${this.getMinute(date)}:${this.getSecond(date)}`);
+    }
+    /**
+     * Crea una data partendo da anno, mese e giorno
+     *
+     * @param {number} year Anno
+     * @param {number} month Mese
+     * @param {number} date Giorno
+     *
+     * @returns {Dayjs} Oggetto generato in base ai parametri **year**, **month**, e **date**
+     */
+    createDate(year, month, 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.`);
+        //Il mese è un indice 0-11 quindi devo dargli un +1 qua
+        const result = dayjs(`${year}-${month + 1}-${date}`);
+        if (!result.isValid())
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        return result;
+    }
+    /**
+     * Restituisce la data che rappresenta la giornata di oggi
+     *
+     * @returns {Dayjs} Oggi
+     */
+    today() {
+        return dayjs();
+    }
+    /**
+     * Effettua il parse di una data, eventualmente in base al formato specificato
+     *
+     * @param {any} value Valore da parsare
+     * @param {string} parseFormat Formato in cui leggere il valore
+     *
+     * @returns {Dayjs} Data generata
+     */
+    parse(value, parseFormat) {
+        if (value && typeof value == 'string')
+            return dayjs(value, parseFormat);
+        return value ? dayjs(value) : null;
+    }
+    /**
+     * Formatta una data in base al formato specificato
+     *
+     * @param {Dayjs} date Data da formattare
+     * @param {string} displayFormat Formato in cui mostrare la data
+     *
+     * @returns {string} Data formattata
+     */
+    format(date, displayFormat) {
+        if (!this.isValid(date))
+            throw Error('DateAdapter: Cannot format invalid date.');
+        return date.format(displayFormat);
+    }
+    /**
+     * Aggiunge ad una data il numero specificato di anni
+     *
+     * @param {Dayjs} date Data a cui aggiungere gli anni
+     * @param {number} years Anni da aggiungere
+     *
+     * @returns {Dayjs} Data con l'aggiunta degli anni specificati
+     */
+    addCalendarYears(date, years) {
+        return date.add(years, "year");
+    }
+    /**
+     * Aggiunge ad una data il numero specificato di mesi
+     *
+     * @param {Dayjs} date Data a cui aggiungere i mesi
+     * @param {months} months Mesi da aggiungere
+     *
+     * @returns {Dayjs} Data con l'aggiunta dei mesi specificati
+     */
+    addCalendarMonths(date, months) {
+        return date.add(months, "month");
+    }
+    /**
+     * Aggiunge ad una data il numero specificato di giorni
+     *
+     * @param {Dayjs} date Data a cui aggiungere i giorni
+     * @param {months} days Giorni da aggiungere
+     *
+     * @returns {Dayjs} Data con l'aggiunta dei giorni specificati
+     */
+    addCalendarDays(date, days) {
+        return date.add(days, "day");
+    }
+    /**
+     * Trasforma la data specificata in una stringa ISO8601
+     *
+     * @param {Dayjs} date Data
+     *
+     * @returns {string} Rappresentazione in ISO8601
+     */
+    toIso8601(date) {
+        return date.toISOString();
+    }
+    /**
+     * Controlla se l'oggetto passato è effettivamente un DayJs
+     *
+     * @param {any} obj Oggetto da verificare se è una data o meno
+     *
+     * @returns {boolean} **true** se l'oggetto è un DayJs, **false** altrimenti
+     */
+    isDateInstance(obj) {
+        return dayjs.isDayjs(obj);
+    }
+    /**
+     * Controlla il DayJs passato e verifica se è valido
+     *
+     * @param {Dayjs} date Data da verificare
+     *
+     * @returns {boolean} **true** se il DayJs è valido, **false** altrimenti
+     */
+    isValid(date) {
+        return date.isValid();
+    }
+    /**
+     * Restituisce un DayJs invalido
+     *
+     * @returns {DayJs} Data Invalida
+     */
+    invalid() {
+        return dayjs("Invalid Date");
+    }
+    /**
+     * Crea un range di una lunghezza specifica e per ogni indice del range richiama un callback che valorizza l'elemento di quell'indice
+     *
+     * @param {number} length Lunghezza del range
+     * @param {Function} valueFunction Callback che deve generare il valore desiderato per ogni indice
+     *
+     * @returns {T[]} Array dei valori generati
+     */
+    range(length, valueFunction) {
+        const valuesArray = Array(length);
+        for (let i = 0; i < length; i++)
+            valuesArray[i] = valueFunction(i);
+        return valuesArray;
+    }
+}
+DayJsDateAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DayJsDateAdapter, deps: [{ token: MAT_DATE_LOCALE }], target: i0.ɵɵFactoryTarget.Injectable });
+DayJsDateAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DayJsDateAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DayJsDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DATE_LOCALE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DayjsDateAdapter.js","sourceRoot":"","sources":["../../../../../projects/material-dayjs-adapter/src/lib/adapter/DayjsDateAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Inject, Injectable } from \"@angular/core\";\r\nimport { DateAdapter, MAT_DATE_LOCALE } from \"@angular/material/core\";\r\n\r\n// Dayjs\r\nimport { Dayjs } from \"dayjs\";\r\n\r\n/**\r\n * Dichiarazione della variabile globale dayjs. L'onere di \"crearla\" è affidato all'applicazione che utilizza questa libreria, \r\n * che dovrà importare lo script globale di dayjs nella CLI\r\n */\r\ndeclare var dayjs: any;\r\n\r\n/**\r\n * Adapter per permettere a Material di funzionare senza problemi con DayJs. Per altri provider di date (es. moment) l'adapter viene fornito \r\n * nativamente da Angular. Per DayJs invece bisogna reimplementarselo\r\n */\r\n@Injectable()\r\nexport class DayJsDateAdapter extends DateAdapter<Dayjs>{\r\n\r\n    /**\r\n     * Cache dei dati del locale Italiano\r\n     */\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    /**\r\n     * Costruttore\r\n     * \r\n     * @ignore\r\n     */\r\n    constructor(@Inject(MAT_DATE_LOCALE) dateLocale: string) {\r\n        super();\r\n\r\n        this.setLocale(dateLocale);\r\n    }\r\n\r\n    /**\r\n     * Imposta il locale utilizzato per tutte le date\r\n     * \r\n     * @param {string} locale Locale da impostare\r\n     */\r\n    public setLocale(locale: string) {\r\n        super.setLocale(locale);\r\n\r\n        // il localeData si potrebbe prendere da this.dayJs().localeData(); ma io voglio usare le date solo nel formato italiano quindi cablo quello\r\n        switch (locale) {\r\n            case 'it': import(\"dayjs/locale/it\").then(mod => { this.loadLoacleDataModule(mod.default) }); break;\r\n            // In dayjs, nel locale \"en\" e basta non esistono i 3/4 delle info perché sono le cose generiche ereditate dai locali en-gb, en-au ecc...\r\n            // quindi mi baso sul locale inglese Britannico, ma comunque I'ts Coming Rome\r\n            case 'en': import(\"dayjs/locale/en-gb\").then(mod => { this.loadLoacleDataModule(mod.default) }); break;\r\n            default: throw `Locale non riconosicuto '${locale}'. Locali consentiti: 'it', 'en'`;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Effettua il caricamento del localeData coi nomi dei mesi, giorni ecc partendo dal modulo importato\r\n     * \r\n     * @param {any} mod Modulo caricato contenente il locale desiderato\r\n     */\r\n    private loadLoacleDataModule(mod: any) {\r\n        this._localeData = {\r\n            firstDayOfWeek: mod.weekStart,\r\n            longMonths: mod.months,\r\n            shortMonths: mod.monthsShort,\r\n            dates: this.range(31, (i) => this.createDate(2017, 0, i + 1).format('D')),\r\n            longDaysOfWeek: mod.weekdays,\r\n            shortDaysOfWeek: mod.weekdaysShort,\r\n            narrowDaysOfWeek: mod.weekdaysMin,\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Ottiene le ore da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Ore\r\n     */\r\n    public getHour(date: Dayjs): number {\r\n        return date.get(\"hour\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene i minuti da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Minuti\r\n     */\r\n    public getMinute(date: Dayjs): number {\r\n        return date.get(\"minute\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene i secondi da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Secondi\r\n     */\r\n    public getSecond(date: Dayjs): number {\r\n        return date.get(\"second\");\r\n    }\r\n\r\n    /**\r\n     * Imposta le ore di una data Dayjs\r\n     * \r\n     * @param {Dayjs} date Data da modificare\r\n     * @param {number} value Valore da impostare per le ore\r\n     */\r\n    public setHour(date: Dayjs, value: number): void {\r\n        (<any>date).$H = value;\r\n    }\r\n\r\n    /**\r\n     * Imposta i minuti di una data Dayjs\r\n     * \r\n     * @param {Dayjs} date Data da modificare\r\n     * @param {number} value Valore da impostare per i minuti\r\n     */\r\n    public setMinute(date: Dayjs, value: number): void {\r\n        (<any>date).$m = value;\r\n    }\r\n\r\n    /**\r\n     * Imposta i secondi di una data Dayjs\r\n     * \r\n     * @param {Dayjs} date Data da modificare\r\n     * @param {number} value Valore da impostare per i secondi\r\n     */\r\n    public setSecond(date: Dayjs, value: number): void {\r\n        (<any>date).$s = value;\r\n    }\r\n\r\n    /**\r\n     * Ottiene l'anno da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Anno\r\n     */\r\n    public getYear(date: Dayjs): number {\r\n        return date.get(\"year\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene il mese da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Mese\r\n     */\r\n    public getMonth(date: Dayjs): number {\r\n        return date.get(\"month\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene il giorno da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Giorno\r\n     */\r\n    public getDate(date: Dayjs): number {\r\n        return date.get(\"date\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene il giorno della settimana da un DayJs\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Giorno della settimana da 1 a 7\r\n     */\r\n    public getDayOfWeek(date: Dayjs): number {\r\n        return date.get(\"day\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene i nomi dei mesi\r\n     * \r\n     * @param {\"long\" | \"short\" | \"narrow\"} style Stile dei nomi richiesto\r\n     * \r\n     * @returns {string[]} Lista dei mesi espressi in base al parametro **style**\r\n     */\r\n    public getMonthNames(style: \"long\" | \"short\" | \"narrow\"): string[] {\r\n        return style == 'long' ? this._localeData.longMonths : this._localeData.shortMonths;\r\n    }\r\n\r\n    /**\r\n     * Ottiene i nomi dei giorni del mese\r\n     * \r\n     * @returns {string[]} Lista dei giorni del mese (da '1' a '31')\r\n     */\r\n    public getDateNames(): string[] {\r\n        return this._localeData.dates;\r\n    }\r\n\r\n    /**\r\n     * Ottiene i nomi dei giorni della settimana\r\n     * \r\n     * @param {\"long\" | \"short\" | \"narrow\"} style Stile dei nomi richiesto\r\n     * \r\n     * @returns {string[]} Lista dei giorni della settimana espressi in base al parametro **style**\r\n     */\r\n    public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\r\n        if (style == 'long')\r\n            return this._localeData.longDaysOfWeek;\r\n        else if (style == 'short')\r\n            return this._localeData.shortDaysOfWeek;\r\n\r\n        return this._localeData.narrowDaysOfWeek;\r\n    }\r\n\r\n    /**\r\n     * Ottiene il nome dell'anno\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {string} Anno\r\n     */\r\n    public getYearName(date: Dayjs): string {\r\n        return this.getYear(date).toString();\r\n    }\r\n\r\n    /**\r\n     * Ottiene il primo giorno della settimana\r\n     * \r\n     * @returns {number} Indice del primo giorno della settimana\r\n     */\r\n    public getFirstDayOfWeek(): number {\r\n        return this._localeData.firstDayOfWeek;\r\n    }\r\n\r\n    /**\r\n     * Ottiene il numero di giorni nel mese corrente\r\n     * \r\n     * @param {Dayjs} date Data Dayjs\r\n     * \r\n     * @returns {number} Numero di giorni\r\n     */\r\n    public getNumDaysInMonth(date: Dayjs): number {\r\n        return date.daysInMonth();\r\n    }\r\n\r\n    /**\r\n     * Ottiene il clone di una data Dayjs\r\n     * \r\n     * @param {Dayjs} Data da clonare\r\n     * \r\n     * @returns {Dayjs} Clone\r\n     */\r\n    public clone(date: Dayjs): Dayjs {\r\n        // Visto che ho modificato l'istanza originale a manazza (vedi setHour, setMinute, setSecond) l'oggetto è danneggiato e per restituire un clone buono\r\n        // devo ricrearlo prendendo pezzo per pezzo\r\n        // Il mese è un indice 0-11 quindi devo dargli un +1 qua\r\n        return dayjs(`${this.getYear(date)}-${this.getMonth(date) + 1}-${this.getDate(date)} ${this.getHour(date)}:${this.getMinute(date)}:${this.getSecond(date)}`);\r\n    }\r\n\r\n    /**\r\n     * Crea una data partendo da anno, mese e giorno\r\n     * \r\n     * @param {number} year Anno\r\n     * @param {number} month Mese\r\n     * @param {number} date Giorno\r\n     * \r\n     * @returns {Dayjs} Oggetto generato in base ai parametri **year**, **month**, e **date**\r\n     */\r\n    public createDate(year: number, month: number, date: number): Dayjs {\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        if (date < 1)\r\n            throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\r\n\r\n        //Il mese è un indice 0-11 quindi devo dargli un +1 qua\r\n        const result = dayjs(`${year}-${month + 1}-${date}`)\r\n\r\n        if (!result.isValid())\r\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\r\n\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Restituisce la data che rappresenta la giornata di oggi\r\n     * \r\n     * @returns {Dayjs} Oggi\r\n     */\r\n    public today(): Dayjs {\r\n        return dayjs();\r\n    }\r\n\r\n    /**\r\n     * Effettua il parse di una data, eventualmente in base al formato specificato\r\n     * \r\n     * @param {any} value Valore da parsare\r\n     * @param {string} parseFormat Formato in cui leggere il valore\r\n     * \r\n     * @returns {Dayjs} Data generata\r\n     */\r\n    public parse(value: any, parseFormat: string): Dayjs {\r\n        if (value && typeof value == 'string')\r\n            return dayjs(value, parseFormat);\r\n\r\n        return value ? dayjs(value) : null;\r\n    }\r\n\r\n    /**\r\n     * Formatta una data in base al formato specificato\r\n     * \r\n     * @param {Dayjs} date Data da formattare\r\n     * @param {string} displayFormat Formato in cui mostrare la data\r\n     * \r\n     * @returns {string} Data formattata\r\n     */\r\n    public format(date: Dayjs, displayFormat: any): string {\r\n        if (!this.isValid(date))\r\n            throw Error('DateAdapter: Cannot format invalid date.');\r\n            \r\n        return date.format(displayFormat)\r\n    }\r\n\r\n    /**\r\n     * Aggiunge ad una data il numero specificato di anni\r\n     * \r\n     * @param {Dayjs} date Data a cui aggiungere gli anni\r\n     * @param {number} years Anni da aggiungere\r\n     * \r\n     * @returns {Dayjs} Data con l'aggiunta degli anni specificati\r\n     */\r\n    public addCalendarYears(date: Dayjs, years: number): Dayjs {\r\n        return date.add(years, \"year\");\r\n    }\r\n\r\n    /**\r\n     * Aggiunge ad una data il numero specificato di mesi\r\n     * \r\n     * @param {Dayjs} date Data a cui aggiungere i mesi\r\n     * @param {months} months Mesi da aggiungere\r\n     * \r\n     * @returns {Dayjs} Data con l'aggiunta dei mesi specificati\r\n     */\r\n    public addCalendarMonths(date: Dayjs, months: number): Dayjs {\r\n        return date.add(months, \"month\");\r\n    }\r\n\r\n    /**\r\n     * Aggiunge ad una data il numero specificato di giorni\r\n     * \r\n     * @param {Dayjs} date Data a cui aggiungere i giorni\r\n     * @param {months} days Giorni da aggiungere\r\n     * \r\n     * @returns {Dayjs} Data con l'aggiunta dei giorni specificati\r\n     */\r\n    public addCalendarDays(date: Dayjs, days: number): Dayjs {\r\n        return date.add(days, \"day\");\r\n    }\r\n\r\n    /**\r\n     * Trasforma la data specificata in una stringa ISO8601\r\n     * \r\n     * @param {Dayjs} date Data\r\n     * \r\n     * @returns {string} Rappresentazione in ISO8601\r\n     */\r\n    public toIso8601(date: Dayjs): string {\r\n        return date.toISOString();\r\n    }\r\n\r\n    /**\r\n     * Controlla se l'oggetto passato è effettivamente un DayJs\r\n     * \r\n     * @param {any} obj Oggetto da verificare se è una data o meno\r\n     * \r\n     * @returns {boolean} **true** se l'oggetto è un DayJs, **false** altrimenti\r\n     */\r\n    public isDateInstance(obj: any): boolean {\r\n        return dayjs.isDayjs(obj);\r\n    }\r\n\r\n    /**\r\n     * Controlla il DayJs passato e verifica se è valido\r\n     * \r\n     * @param {Dayjs} date Data da verificare\r\n     * \r\n     * @returns {boolean} **true** se il DayJs è valido, **false** altrimenti\r\n     */\r\n    public isValid(date: Dayjs): boolean {\r\n        return date.isValid();\r\n    }\r\n\r\n    /**\r\n     * Restituisce un DayJs invalido\r\n     * \r\n     * @returns {DayJs} Data Invalida\r\n     */\r\n    public invalid(): Dayjs {\r\n        return dayjs(\"Invalid Date\");\r\n    }\r\n\r\n    /**\r\n     * Crea un range di una lunghezza specifica e per ogni indice del range richiama un callback che valorizza l'elemento di quell'indice\r\n     * \r\n     * @param {number} length Lunghezza del range\r\n     * @param {Function} valueFunction Callback che deve generare il valore desiderato per ogni indice\r\n     * \r\n     * @returns {T[]} Array dei valori generati\r\n     */\r\n    private 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        return valuesArray;\r\n    }\r\n}"]}

package/esm2020/lib/adapter/MatDayjsDateModule.mjs

@@ -0,0 +1,35 @@
+import { NgModule } from '@angular/core';
+import { DateAdapter, MAT_DATE_FORMATS, MAT_DATE_LOCALE } from '@angular/material/core';
+import { DayJsDateAdapter } from './DayjsDateAdapter';
+import * as i0 from "@angular/core";
+/**
+ * Formati di default per la presentazione degli input quali il DatePicker di Angular Material.
+ * Cablati a quelli italiani ignorando quelli di BurgerLand per non impazzire
+ */
+export const MAT_DAYJS_DATE_FORMATS = {
+    parse: { dateInput: 'DD/MM/YYYY' },
+    display: {
+        dateInput: 'DD/MM/YYYY',
+        monthYearLabel: 'MM YYYY',
+        dateA11yLabel: 'DD/MM/YYYY',
+        monthYearA11yLabel: 'MM YYYY',
+    }
+};
+export class MatDayjsDateModule {
+}
+MatDayjsDateModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MatDayjsDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MatDayjsDateModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MatDayjsDateModule });
+MatDayjsDateModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MatDayjsDateModule, providers: [
+        { provide: MAT_DATE_FORMATS, useValue: MAT_DAYJS_DATE_FORMATS },
+        { provide: DateAdapter, useClass: DayJsDateAdapter, deps: [MAT_DATE_LOCALE] }
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MatDayjsDateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        { provide: MAT_DATE_FORMATS, useValue: MAT_DAYJS_DATE_FORMATS },
+                        { provide: DateAdapter, useClass: DayJsDateAdapter, deps: [MAT_DATE_LOCALE] }
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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