@esfaenza/extensions 15.2.45 → 16.2.0

package/esm2022/lib/services/extensions.clipboard.service.mjs

@@ -0,0 +1,221 @@
+// Angular
+import { Injectable, Optional } from "@angular/core";
+// Librerie
+import Swal from "sweetalert2";
+import { first } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "./extensions.messages.service";
+import * as i2 from "@esfaenza/localizations";
+/**
+ * Service che fornisce un accesso base in lettura/scrittura sulla clipboard
+ */
+export class ClipboardService {
+    msgService;
+    locProvider;
+    /**
+     * Oggetto statico di localizzazione per i messaggi di questa Service
+     */
+    loc = {
+        "Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation": {
+            'en-US': "Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation",
+            'it-IT': "Mi dispiace ma Firefox non supporta l'accesso diretto alla Clipboard, se non attraverso le estensioni. Si prega di usare Chrome"
+        },
+        "Generic error during 'copy' command execution": {
+            'en-US': "Generic error during 'copy' command execution",
+            'it-IT': "Errore generico durante l'esecuzione del comando 'copy'"
+        },
+        "Error during Clipboard content read operation": {
+            'en-US': "Error during Clipboard content read operation",
+            'it-IT': "Errore nella lettura del contenuto della Clipboard"
+        },
+        "Error during Clipboard content copy operation": {
+            'en-US': "Error during Clipboard content copy operation",
+            'it-IT': "Errore nella scrittura del contenuto nella Clipboard"
+        },
+        "Please insert your clipboard content": {
+            'en-US': "Please insert your clipboard content",
+            'it-IT': "Si prega di incollare il contenuto della Clipboard"
+        },
+        "User input required": {
+            'en-US': "User input required",
+            'it-IT': "Richiesto Input utente"
+        },
+        "Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation": {
+            'en-US': "Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation",
+            'it-IT': "Il browser corrente non supporta la lettura diretta dei dati della Clipboard, si prega di effettuare un'incolla (CTRL + V) nella casella di testo e confermare l'operazione"
+        },
+        "Confirm": {
+            'en-US': "Confirm",
+            'it-IT': "Conferma"
+        },
+        "Cancel": {
+            'en-US': "Cancel",
+            'it-IT': "Annulla"
+        },
+    };
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(msgService, locProvider) {
+        this.msgService = msgService;
+        this.locProvider = locProvider;
+    }
+    /**
+     * Prende il valore della clipboard.
+     * Si può specificare se ci si aspetta una lista o una matrice di valori in modo da ricevere già un risultato utilizzabile
+     *
+     * @param {'array' | 'matrix'} style Stile dell'output desiderato, se array o matrice
+     * @param {Function} valueFoundCallback Callback che questa funzione chiamerà una volta ottenuto i valori richiesti dalla clipboard
+     */
+    async getClipboard(style, valueFoundCallback) {
+        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
+        if (navigator.userAgent.indexOf("Firefox") != -1) {
+            Swal.fire({
+                title: this.loc["User input required"][LOCALE],
+                text: this.loc["Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation"][LOCALE],
+                input: 'textarea',
+                icon: "warning",
+                confirmButtonText: this.loc["Confirm"][LOCALE],
+                cancelButtonText: this.loc["Cancel"][LOCALE],
+                showCancelButton: true,
+                customClass: {
+                    confirmButton: "btn btn-primary",
+                    cancelButton: "btn btn-secondary app-margin-right-15",
+                    container: "app-wrap",
+                },
+                reverseButtons: true,
+                allowOutsideClick: false,
+                inputValidator: (value) => {
+                    if (!value)
+                        return this.loc["Please insert your clipboard content"][LOCALE];
+                }
+            }).then(t => {
+                if (t.isConfirmed) {
+                    console.log("[@esfaenza/extensions] Retrieving input data from user input");
+                    this.doClipboardDataGet(t.value, style, valueFoundCallback);
+                }
+            });
+            return;
+        }
+        if (window.clipboardData) {
+            console.log("[@esfaenza/extensions] Found clipboardData");
+            let data = window.clipboardData.getData("Text");
+            this.doClipboardDataGet(data, style, valueFoundCallback);
+        }
+        else if (window.navigator.clipboard) {
+            console.log("[@esfaenza/extensions] Found navigator clipboard");
+            window.navigator.permissions.query({ name: 'clipboard-read' }).then(result => {
+                if (!(result.state === 'granted' || result.state === 'prompt')) {
+                    console.error("[@esfaenza/extensions] Clipboard permission not granted");
+                    if (valueFoundCallback)
+                        valueFoundCallback([]);
+                    return;
+                }
+                console.log("[@esfaenza/extensions] Clipboard permission granted, retrieving values");
+                window.navigator.clipboard.readText()
+                    .then((t) => this.doClipboardDataGet(t, style, valueFoundCallback))
+                    .catch((err) => this.msgService.simpleError(this.loc["Error during Clipboard content read operation"][LOCALE] + ": " + err));
+            });
+        }
+    }
+    /** @ignore */
+    doClipboardDataGet(clipboardText, style, valueFoundCallback) {
+        console.log("[@esfaenza/extensions] Retrieved clipboard values: " + clipboardText);
+        let value = style == "array" ? this.getClipboardLines(clipboardText) :
+            style == "matrix" ? this.getClipboardMatrix(clipboardText) : [];
+        console.log(`[@esfaenza/extensions] Adapted for ${style}: ${JSON.stringify(value)}`);
+        if (valueFoundCallback)
+            valueFoundCallback(value);
+    }
+    /**
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline)
+     *
+     * @param {string} data contenuto letto dalla clipboard
+     *
+     * @returns {string[]} Array contenente il testo preso dalla clipboard diviso per riga
+     */
+    getClipboardLines(data) {
+        let trimmedData = data.trim();
+        if (!trimmedData.includes("\r\n") && trimmedData.includes("\n"))
+            return trimmedData.split("\n");
+        return trimmedData.split("\r\n");
+    }
+    /**
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline) e colonne (separate da tab)
+     *
+     * @param {string} data contenuto letto dalla clipboard
+     *
+     * @returns {string[][]} Matrice contenente il testo preso dalla clipboard diviso per riga e colonna
+     */
+    getClipboardMatrix(data) {
+        var ret = [];
+        var rows = !data.includes("\r\n") && data.includes("\n") ? data.split("\n") : data.split("\r\n");
+        // A quanto pare ogni valore è separato da un \t... spero che sia uno standard di quando si copia da excel altrimenti ciao
+        for (let i = 0; i < rows.length; i++)
+            ret.push(rows[i].split('\t').map(t => t.trim()));
+        return ret;
+    }
+    /**
+     * Metodo che copia un testo all'interno della clipboard
+     *
+     * @param {string} text Testo da inserire nella clipboard
+     */
+    async copyTextToClipboard(text) {
+        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
+        var textArea = document.createElement("textarea");
+        //
+        // *** This styling is an extra step which is likely not required. ***
+        //
+        // Why is it here? To ensure:
+        // 1. the element is able to have focus and selection.
+        // 2. if element was to flash render it has minimal visual impact.
+        // 3. less flakyness with selection and copying which **might** occur if
+        //    the textarea element is not visible.
+        //
+        // The likelihood is the element won't even render, not even a flash,
+        // so some of these are just precautions. However in IE the element
+        // is visible whilst the popup box asking the user for permission for
+        // the web page to copy to the clipboard.
+        //
+        // Place in top-left corner of screen regardless of scroll position.
+        textArea.style.position = "fixed";
+        textArea.style.top = "0";
+        textArea.style.left = "0";
+        // Ensure it has a small width and height. Setting to 1px / 1em
+        // doesn't work as this gives a negative w/h on some browsers.
+        textArea.style.width = "2em";
+        textArea.style.height = "2em";
+        // We don't need padding, reducing the size if it does flash render.
+        textArea.style.padding = "0";
+        // Clean up any borders.
+        textArea.style.border = "none";
+        textArea.style.outline = "none";
+        textArea.style.boxShadow = "none";
+        // Avoid flash of white box if rendered for any reason.
+        textArea.style.background = "transparent";
+        textArea.value = text;
+        document.body.appendChild(textArea);
+        textArea.focus();
+        textArea.select();
+        try {
+            var successful = document.execCommand("copy");
+            if (!successful)
+                this.msgService.simpleError(this.loc["Generic error during 'copy' command execution"][LOCALE]);
+        }
+        catch (err) {
+            this.msgService.simpleError(this.loc["Error during Clipboard content copy operation"][LOCALE] + ": " + err);
+        }
+        document.body.removeChild(textArea);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClipboardService, deps: [{ token: i1.MessageService }, { token: i2.BaseLocalization, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClipboardService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClipboardService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.MessageService }, { type: i2.BaseLocalization, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.clipboard.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.clipboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable, Optional } from \"@angular/core\";\r\n\r\n// Es\r\nimport { BaseLocalization } from \"@esfaenza/localizations\";\r\n\r\n// Modelli\r\nimport { MessageService } from './extensions.messages.service';\r\n\r\n// Librerie\r\nimport Swal from \"sweetalert2\";\r\nimport { first } from \"rxjs/operators\";\r\n\r\n/**\r\n * Service che fornisce un accesso base in lettura/scrittura sulla clipboard\r\n */\r\n@Injectable({providedIn: \"root\"})\r\nexport class ClipboardService {\r\n\r\n    /**\r\n     * Oggetto statico di localizzazione per i messaggi di questa Service\r\n     */\r\n    private loc = {\r\n        \"Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation\": {\r\n            'en-US': \"Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation\",\r\n            'it-IT': \"Mi dispiace ma Firefox non supporta l'accesso diretto alla Clipboard, se non attraverso le estensioni. Si prega di usare Chrome\"\r\n        },\r\n        \"Generic error during 'copy' command execution\": {\r\n            'en-US': \"Generic error during 'copy' command execution\",\r\n            'it-IT': \"Errore generico durante l'esecuzione del comando 'copy'\"\r\n        },\r\n        \"Error during Clipboard content read operation\": {\r\n            'en-US': \"Error during Clipboard content read operation\",\r\n            'it-IT': \"Errore nella lettura del contenuto della Clipboard\"\r\n        },\r\n        \"Error during Clipboard content copy operation\":{\r\n            'en-US': \"Error during Clipboard content copy operation\",\r\n            'it-IT': \"Errore nella scrittura del contenuto nella Clipboard\"\r\n        },\r\n        \"Please insert your clipboard content\": {\r\n            'en-US': \"Please insert your clipboard content\",\r\n            'it-IT': \"Si prega di incollare il contenuto della Clipboard\"\r\n        },\r\n        \"User input required\": {\r\n            'en-US': \"User input required\",\r\n            'it-IT': \"Richiesto Input utente\"\r\n        },\r\n        \"Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation\": {\r\n            'en-US': \"Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation\",\r\n            'it-IT': \"Il browser corrente non supporta la lettura diretta dei dati della Clipboard, si prega di effettuare un'incolla (CTRL + V) nella casella di testo e confermare l'operazione\"\r\n        },\r\n        \"Confirm\": {\r\n            'en-US': \"Confirm\",\r\n            'it-IT': \"Conferma\"\r\n        },\r\n        \"Cancel\": {\r\n            'en-US': \"Cancel\",\r\n            'it-IT': \"Annulla\"\r\n        },\r\n    };\r\n\r\n    /**\r\n     * Costruttore\r\n     * \r\n     * @ignore\r\n     */\r\n    public constructor(private msgService: MessageService, @Optional() private locProvider: BaseLocalization) { }\r\n\r\n    /**\r\n     * Prende il valore della clipboard. \r\n     * Si può specificare se ci si aspetta una lista o una matrice di valori in modo da ricevere già un risultato utilizzabile\r\n     * \r\n     * @param {'array' | 'matrix'} style Stile dell'output desiderato, se array o matrice\r\n     * @param {Function} valueFoundCallback Callback che questa funzione chiamerà una volta ottenuto i valori richiesti dalla clipboard\r\n     */\r\n    public async getClipboard(style: 'array' | 'matrix', valueFoundCallback : (values: string[] | string[][]) => void) {\r\n        let LOCALE = this.locProvider ?  await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';\r\n\r\n        if (navigator.userAgent.indexOf(\"Firefox\") != -1) {\r\n            \r\n            Swal.fire({\r\n                title: this.loc[\"User input required\"][LOCALE],\r\n                text: this.loc[\"Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation\"][LOCALE],\r\n                input: 'textarea',\r\n                icon: \"warning\",\r\n                confirmButtonText: this.loc[\"Confirm\"][LOCALE],\r\n                cancelButtonText: this.loc[\"Cancel\"][LOCALE],\r\n                showCancelButton: true,\r\n                customClass: {\r\n                    confirmButton: \"btn btn-primary\",\r\n                    cancelButton: \"btn btn-secondary app-margin-right-15\",\r\n                    container: \"app-wrap\",\r\n                },\r\n                reverseButtons: true,\r\n                allowOutsideClick: false,\r\n                inputValidator: (value) => {\r\n                  if (!value)\r\n                    return this.loc[\"Please insert your clipboard content\"][LOCALE]\r\n                }\r\n              }).then(t => {\r\n                  if (t.isConfirmed) {\r\n                      console.log(\"[@esfaenza/extensions] Retrieving input data from user input\");\r\n                      this.doClipboardDataGet(t.value, style, valueFoundCallback);\r\n                  }\r\n              });\r\n              return;\r\n        }\r\n\r\n        if ((<any>window).clipboardData) {\r\n            console.log(\"[@esfaenza/extensions] Found clipboardData\");\r\n            let data = (<any>window).clipboardData.getData(\"Text\");\r\n            this.doClipboardDataGet(data, style, valueFoundCallback);\r\n        }\r\n\r\n        else if ((<any>window).navigator.clipboard) {\r\n            console.log(\"[@esfaenza/extensions] Found navigator clipboard\");\r\n            (<any>window).navigator.permissions.query({ name: 'clipboard-read' }).then(result => {\r\n                if (!(result.state === 'granted' || result.state === 'prompt'))\r\n                {\r\n                    console.error(\"[@esfaenza/extensions] Clipboard permission not granted\");\r\n                    if (valueFoundCallback) valueFoundCallback([]);\r\n                    return;\r\n                }\r\n\r\n                console.log(\"[@esfaenza/extensions] Clipboard permission granted, retrieving values\");\r\n                (<any>window).navigator.clipboard.readText()\r\n                    .then((t: string) => this.doClipboardDataGet(t, style, valueFoundCallback))\r\n                    .catch((err: any) => this.msgService.simpleError(this.loc[\"Error during Clipboard content read operation\"][LOCALE] + \": \" + err));\r\n            });\r\n        }\r\n    }\r\n\r\n    /** @ignore */\r\n    private doClipboardDataGet(clipboardText: string, style: \"matrix\" | \"array\", valueFoundCallback: Function) {\r\n        console.log(\"[@esfaenza/extensions] Retrieved clipboard values: \" + clipboardText);\r\n        let value = style == \"array\" ? this.getClipboardLines(clipboardText) :\r\n            style == \"matrix\" ? this.getClipboardMatrix(clipboardText) : [];\r\n        console.log(`[@esfaenza/extensions] Adapted for ${style}: ${JSON.stringify(value)}`);\r\n        if (valueFoundCallback) valueFoundCallback(value);\r\n    }\r\n\r\n    /**\r\n     * Ottiene il contenuto della clipboard diviso per righe (separate da newline)\r\n     * \r\n     * @param {string} data contenuto letto dalla clipboard\r\n     * \r\n     * @returns {string[]} Array contenente il testo preso dalla clipboard diviso per riga\r\n     */\r\n    private getClipboardLines(data: string): string[] {\r\n        let trimmedData = data.trim();\r\n\r\n        if (!trimmedData.includes(\"\\r\\n\") && trimmedData.includes(\"\\n\"))\r\n            return trimmedData.split(\"\\n\");\r\n\r\n        return trimmedData.split(\"\\r\\n\");\r\n    }\r\n\r\n    /**\r\n     * Ottiene il contenuto della clipboard diviso per righe (separate da newline) e colonne (separate da tab)\r\n     * \r\n     * @param {string} data contenuto letto dalla clipboard\r\n     * \r\n     * @returns {string[][]} Matrice contenente il testo preso dalla clipboard diviso per riga e colonna\r\n     */\r\n    private getClipboardMatrix(data: string): string[][] {\r\n        var ret: string[][] = [];\r\n        var rows = !data.includes(\"\\r\\n\") && data.includes(\"\\n\") ? data.split(\"\\n\") : data.split(\"\\r\\n\");\r\n\r\n        // A quanto pare ogni valore è separato da un \\t... spero che sia uno standard di quando si copia da excel altrimenti ciao\r\n        for (let i = 0; i < rows.length; i++)\r\n            ret.push(rows[i].split('\\t').map(t => t.trim()));\r\n        return ret;\r\n    }\r\n\r\n    /**\r\n     * Metodo che copia un testo all'interno della clipboard\r\n     * \r\n     * @param {string} text Testo da inserire nella clipboard\r\n     */\r\n    public async copyTextToClipboard(text: string) {\r\n        let LOCALE = this.locProvider ?  await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';\r\n\r\n        var textArea = document.createElement(\"textarea\");\r\n\r\n        //\r\n        // *** This styling is an extra step which is likely not required. ***\r\n        //\r\n        // Why is it here? To ensure:\r\n        // 1. the element is able to have focus and selection.\r\n        // 2. if element was to flash render it has minimal visual impact.\r\n        // 3. less flakyness with selection and copying which **might** occur if\r\n        //    the textarea element is not visible.\r\n        //\r\n        // The likelihood is the element won't even render, not even a flash,\r\n        // so some of these are just precautions. However in IE the element\r\n        // is visible whilst the popup box asking the user for permission for\r\n        // the web page to copy to the clipboard.\r\n        //\r\n\r\n        // Place in top-left corner of screen regardless of scroll position.\r\n        textArea.style.position = \"fixed\";\r\n        textArea.style.top = \"0\";\r\n        textArea.style.left = \"0\";\r\n\r\n        // Ensure it has a small width and height. Setting to 1px / 1em\r\n        // doesn't work as this gives a negative w/h on some browsers.\r\n        textArea.style.width = \"2em\";\r\n        textArea.style.height = \"2em\";\r\n\r\n        // We don't need padding, reducing the size if it does flash render.\r\n        textArea.style.padding = \"0\";\r\n\r\n        // Clean up any borders.\r\n        textArea.style.border = \"none\";\r\n        textArea.style.outline = \"none\";\r\n        textArea.style.boxShadow = \"none\";\r\n\r\n        // Avoid flash of white box if rendered for any reason.\r\n        textArea.style.background = \"transparent\";\r\n\r\n        textArea.value = text;\r\n\r\n        document.body.appendChild(textArea);\r\n        textArea.focus();\r\n        textArea.select();\r\n\r\n        try {\r\n            var successful = document.execCommand(\"copy\");\r\n            if(!successful)\r\n                this.msgService.simpleError(this.loc[\"Generic error during 'copy' command execution\"][LOCALE]);\r\n        } catch (err) {\r\n            this.msgService.simpleError(this.loc[\"Error during Clipboard content copy operation\"][LOCALE] + \": \"+ err);\r\n        }\r\n\r\n        document.body.removeChild(textArea);\r\n    }\r\n}"]}

package/esm2022/lib/services/extensions.dates.service.mjs

@@ -0,0 +1,244 @@
+// Angular
+import { Injectable, Inject, Optional } from "@angular/core";
+// Modelli
+import { EXT_ALLOW_UTC } from "../tokens";
+// Librerie
+import { first } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/localizations";
+/**
+* Service che fornisce dei metodi di estensione per la gestione/manipolazione delle date
+*/
+export class DateService {
+    locProvider;
+    allowUtc;
+    /**
+     * Oggetto statico di localizzazione per i messaggi di questa Service
+     */
+    loc = {
+        "SMALL_DATE_FORMAT": { 'en-US': "MM/DD/YYYY", 'it-IT': "DD/MM/YYYY" },
+        "FULL_DATE_FORMAT": { 'en-US': "MM/DD/YYYY HH:mm:ss", 'it-IT': "DD/MM/YYYY HH:mm:ss" },
+        "FULL_DATE_FORMAT_NO_SS": { 'en-US': "MM/DD/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" },
+        "SMALL_DATE_DISPLAY_FORMAT": { 'en-US': "DD/MM/YYYY", 'it-IT': "DD/MM/YYYY" },
+        "SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR": { 'en-US': "DD/MM/YYYY HH", 'it-IT': "DD/MM/YYYY HH" },
+        "SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE": { 'en-US': "DD/MM/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" },
+        "FULL_DATE_DISPLAY_FORMAT": { 'en-US': "DD/MM/YYYY HH:mm:ss", 'it-IT': "DD/MM/YYYY HH:mm:ss" },
+        "FULL_DATE_DISPLAY_FORMAT_NO_SS": { 'en-US': "DD/MM/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" }
+    };
+    /**
+     * Oggetto di configurazione per tenere da conto le informazioni sui formati
+     */
+    cfg = {
+        fulldate: "",
+        fulldateDisplay: "",
+        smallDate: "",
+        fulldateNoSS: "",
+        smallDateWithH: "",
+        smallDateWithM: "",
+        fulldateDisplayNoSS: ""
+    };
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(locProvider, allowUtc) {
+        this.locProvider = locProvider;
+        this.allowUtc = allowUtc;
+        this.init();
+    }
+    async init() {
+        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
+        this.cfg.smallDate = this.loc["SMALL_DATE_FORMAT"][LOCALE];
+        this.cfg.fulldate = this.loc["FULL_DATE_FORMAT"][LOCALE];
+        this.cfg.fulldateNoSS = this.loc["FULL_DATE_FORMAT_NO_SS"][LOCALE];
+        this.cfg.fulldateDisplay = this.loc["FULL_DATE_DISPLAY_FORMAT"][LOCALE];
+        this.cfg.fulldateDisplayNoSS = this.loc["FULL_DATE_DISPLAY_FORMAT_NO_SS"][LOCALE];
+        this.cfg.smallDate = this.loc["SMALL_DATE_DISPLAY_FORMAT"][LOCALE];
+        this.cfg.smallDateWithH = this.loc["SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR"][LOCALE];
+        this.cfg.smallDateWithM = this.loc["SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE"][LOCALE];
+    }
+    /**
+     * Aggiusta una data in "istante finale" in base a qual è la parte di data significativa.
+     *
+     * Es. Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
+     *
+     * @param {any} date Data qualsiasi (Date, stringa, dayjs...), verrà ricondotta ad un oggetto dayJs
+     * @param {'day' | 'hour' | 'minute'} timepart Parte significativa della data
+     * @param {boolean} printSeconds Indica se effettuare la stampa dei secondi o no
+     */
+    adjustDateToFinalInstant(date, timepart, printSeconds = true) {
+        let mydt = this.getDateConvertion(date);
+        if (mydt == null)
+            return "FE: Not a Date";
+        let isZeroTime = mydt.startOf(timepart).valueOf() === mydt.valueOf();
+        if (!isZeroTime) {
+            if (timepart == "day" && mydt.subtract(1, "hour").hour() == mydt.hour()) {
+                // Se l'ora precedente è lo stesso orario dell'ora attuale l'istante finale dev'essere mandato avanti di 1
+                mydt = mydt.add(1, "hour");
+            }
+            return printSeconds ? mydt.format(this.cfg.fulldateDisplay) : mydt.format(this.cfg.fulldateDisplayNoSS);
+        }
+        let tmpValue = mydt.subtract(1, timepart);
+        let value = "";
+        // Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
+        if (timepart == 'day')
+            value = tmpValue.format(this.cfg.smallDate) + " 24:00" + (printSeconds ? ':00' : '');
+        // Istante finale dei minuti: giorno 05/10/1992 04:00:00 --> 05/10/1992 03:60(:00)
+        else if (timepart == 'hour')
+            value = tmpValue.format(this.cfg.smallDateWithH) + ":60" + (printSeconds ? ':00' : '');
+        // Istante finale dei secondi: giorno 05/10/1992 04:10:00 --> 05/10/1992 04:09:60
+        else if (timepart == 'minute')
+            value = tmpValue.format(this.cfg.smallDateWithM) + ":60";
+        return value;
+    }
+    /**
+     * Funzione che effettua l'ordinamento fra 2 date in base alla direzione specificata
+     *
+     * @param {any} a Prima data per il confronto
+     * @param {any} b Seconda data per il confronto
+     * @param {'asc' | 'desc'} direction Direzione rispetto a cui ordinare le due date
+     *
+     * @returns {number} 0 se le date sono uguali, 1 se la data A deve venire logicamente prima della data B, -1 altrimenti
+     */
+    dateSort(a, b, direction) {
+        if (a < b)
+            return direction == 'asc' ? 1 : -1;
+        else if (a > b)
+            return direction == 'asc' ? -1 : 1;
+        // con a uguale a b
+        return 0;
+    }
+    /**
+     * Effettua il trim dei secondi da una data espressa come stringa
+     *
+     * @param {string} value Data espressa come stringa
+     *
+     * @returns {string} Data senza i secondi
+     */
+    trimSeconds(value) {
+        //I numeri mangiati da dayjs spesso vengono ricondotti a date vere. Mi assicuro che se ci sono solo numeri proseguo
+        if (!isNaN(value))
+            return value;
+        //Se non ho qualcosa del tipo XX/YY/ZZZZ aa:bb:cc di sicuro non è una data che mi interessa
+        if (!/^\d\d\/\d\d\/\d\d\d\d \d\d:\d\d:\d\d$/g.test(value))
+            return value;
+        //In questo caso mi arrivano valori che devono essere stampati as-is, solo tagliando i secondi
+        return "'" + value.substr(0, value.length - 3);
+    }
+    /**
+     * Data una lista di date Da e una lista di date A restituisce un oggetto rappresentante il range che include tutte le date passate
+     *
+     * @param {any[]} fromDates Lista dei Da
+     * @param {any[]} toDates Lista dei A
+     *
+     * @returns {{ from: any, to: any }} Range di date Da - A che include tutti i valori di **fromDates** e **toDates**
+     */
+    getMinMaxDatesRange(fromDates, toDates) {
+        let datesFroms = [];
+        let datesTo = [];
+        for (let i = 0; i < fromDates.length; i++) {
+            let d = fromDates[i];
+            var convertion = this.getDateConvertion(d);
+            if (convertion)
+                datesFroms.push(convertion);
+        }
+        for (let i = 0; i < toDates.length; i++) {
+            let d = toDates[i];
+            var convertion = this.getDateConvertion(d);
+            if (convertion)
+                datesTo.push(convertion);
+        }
+        return { from: dayjs.min(datesFroms), to: dayjs.max(datesTo) };
+    }
+    /**
+     * Ottiene la conversione di una data in qualsiasi formato al formato standard DayJs
+     *
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} useUtc Indica se usare l'estensione utc di Dayjs per parsare la data o no
+     *
+     * @returns {any} Data in modalità DayJs
+     */
+    getDateConvertion(date, useUtc = false) {
+        if (!date)
+            return null;
+        if (this.isDayJs(date))
+            return date;
+        if (this.isJsDate(date))
+            return useUtc ? dayjs.utc(date) : dayjs(date);
+        // Se non c'è la proprietà length vuol dire che non è una stringa e a questo punto non ho idea di che minchia sia
+        let length = date.length;
+        if (!length)
+            return null;
+        if (useUtc && !this.allowUtc)
+            throw "@esfaenza/extensions: Richiesta data UTC ma da configurazione la libreria non lo supporta";
+        // Per risparmiare chiamate a tentoni, in base alla lunghezza della stringa chiamo direttamente il metodo giusto, 
+        // controllando poi che mi generi una data come me la aspetto io
+        let tryThis = null;
+        let toCall = useUtc ? dayjs.utc : dayjs;
+        // Se la data contiene la lettera "T" vuol dire che è una data del tipo 2020-10-15T00:00:00, direttamente parsabile dal dayjs col locale corretto.
+        // Per il resto mi baso sulla lunghezza della stringa
+        if (date.includes("T"))
+            tryThis = toCall(date);
+        else if (length == this.cfg.fulldate.length)
+            tryThis = toCall(date, this.cfg.fulldate);
+        else if (length == this.cfg.smallDate.length)
+            tryThis = toCall(date, this.cfg.smallDate);
+        else if (length == this.cfg.fulldateNoSS.length)
+            tryThis = toCall(date, this.cfg.fulldateNoSS);
+        if (tryThis && tryThis.isValid && tryThis.isValid())
+            return tryThis;
+        // Se niente funziona, null. 
+        // Ricondurre l'Input ad una data non è possibile.
+        return null;
+    }
+    /**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse una data vera e propria, **false** altrimenti
+     *
+     * @param {any} check Oggetto da controllare
+     *
+     * @returns {boolean} Indicazione se l'oggetto è un vero Date di Javascript o no
+     */
+    isJsDate(check) {
+        return check && Object.prototype.toString.call(check) === "[object Date]" && !isNaN(check);
+    }
+    /**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse un DayJs vero e proprio, **false** altrimenti
+     *
+     * @param {any} check Oggetto da controllare
+     * @returns {boolean} Indicazione se l'oggetto è un vero DayJs o no
+     */
+    isDayJs(check) {
+        // Non uso instanceof perché sarebbe estremamente più lento
+        // Non uso nemmeno isDayjs() della libreria Dayjs dato che ha lo stesso problema: https://github.com/iamkun/dayjs/blob/06f88f425828b1ce96b737332d25145a95a4ee9d/src/index.js#L9
+        return check.$D !== undefined && check.$M !== undefined && check.$y !== undefined;
+    }
+    /**
+     * Ottiene la formattazione di una data in base alla versione richiesta "small" o "long" e a se stampare o meno i secondi
+     *
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} small Indica se formattarla con un formato breve (se **true**) o un formato più lungo (se **false**)
+     *
+     * @returns {string} Data formattata nel formato richiesto
+     */
+    getFormatted(date, small, seconds) {
+        var date = this.getDateConvertion(date);
+        if (!date)
+            return null;
+        return date.format(small ? this.cfg.smallDate : seconds ? this.cfg.fulldateDisplay : this.cfg.fulldateDisplayNoSS);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateService, deps: [{ token: i1.BaseLocalization, optional: true }, { token: EXT_ALLOW_UTC, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.BaseLocalization, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [EXT_ALLOW_UTC]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.dates.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.dates.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable, Inject, Optional } from \"@angular/core\";\r\n\r\n// Es\r\nimport { BaseLocalization } from \"@esfaenza/localizations\";\r\n\r\n// Modelli\r\nimport { EXT_ALLOW_UTC } from \"../tokens\";\r\n\r\n// Librerie\r\nimport { first } from \"rxjs/operators\";\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\n declare var dayjs: any;\r\n\r\n /**\r\n * Service che fornisce dei metodi di estensione per la gestione/manipolazione delle date\r\n */\r\n @Injectable({providedIn: \"root\"})\r\nexport class DateService {\r\n    \r\n    /**\r\n     * Oggetto statico di localizzazione per i messaggi di questa Service\r\n     */\r\n    private loc = {\r\n        \"SMALL_DATE_FORMAT\": { 'en-US': \"MM/DD/YYYY\", 'it-IT': \"DD/MM/YYYY\" },\r\n        \"FULL_DATE_FORMAT\": { 'en-US': \"MM/DD/YYYY HH:mm:ss\", 'it-IT': \"DD/MM/YYYY HH:mm:ss\" },\r\n        \"FULL_DATE_FORMAT_NO_SS\": { 'en-US': \"MM/DD/YYYY HH:mm\", 'it-IT': \"DD/MM/YYYY HH:mm\" },\r\n        \"SMALL_DATE_DISPLAY_FORMAT\": { 'en-US': \"DD/MM/YYYY\", 'it-IT': \"DD/MM/YYYY\" },\r\n        \"SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR\": { 'en-US': \"DD/MM/YYYY HH\", 'it-IT': \"DD/MM/YYYY HH\" },\r\n        \"SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE\": { 'en-US': \"DD/MM/YYYY HH:mm\", 'it-IT': \"DD/MM/YYYY HH:mm\" },\r\n        \"FULL_DATE_DISPLAY_FORMAT\": { 'en-US': \"DD/MM/YYYY HH:mm:ss\", 'it-IT': \"DD/MM/YYYY HH:mm:ss\" },\r\n        \"FULL_DATE_DISPLAY_FORMAT_NO_SS\": { 'en-US': \"DD/MM/YYYY HH:mm\", 'it-IT': \"DD/MM/YYYY HH:mm\" }\r\n    };\r\n\r\n    /**\r\n     * Oggetto di configurazione per tenere da conto le informazioni sui formati\r\n     */\r\n    private cfg = {\r\n        fulldate: \"\",\r\n        fulldateDisplay: \"\",\r\n        smallDate: \"\",\r\n        fulldateNoSS: \"\",\r\n        smallDateWithH: \"\",\r\n        smallDateWithM: \"\",\r\n        fulldateDisplayNoSS: \"\"\r\n    }\r\n\r\n    /**\r\n     * Costruttore\r\n     * \r\n     * @ignore\r\n     */\r\n    public constructor(@Optional() private locProvider: BaseLocalization, @Optional() @Inject(EXT_ALLOW_UTC) private allowUtc: boolean) {\r\n        this.init();\r\n    }\r\n\r\n    async init(){\r\n        let LOCALE = this.locProvider ?  await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';\r\n        \r\n        this.cfg.smallDate = this.loc[\"SMALL_DATE_FORMAT\"][LOCALE];\r\n        this.cfg.fulldate = this.loc[\"FULL_DATE_FORMAT\"][LOCALE];\r\n        this.cfg.fulldateNoSS = this.loc[\"FULL_DATE_FORMAT_NO_SS\"][LOCALE];\r\n        this.cfg.fulldateDisplay = this.loc[\"FULL_DATE_DISPLAY_FORMAT\"][LOCALE];\r\n        this.cfg.fulldateDisplayNoSS  =this.loc[\"FULL_DATE_DISPLAY_FORMAT_NO_SS\"][LOCALE];\r\n        this.cfg.smallDate = this.loc[\"SMALL_DATE_DISPLAY_FORMAT\"][LOCALE];\r\n        this.cfg.smallDateWithH = this.loc[\"SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR\"][LOCALE];\r\n        this.cfg.smallDateWithM = this.loc[\"SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE\"][LOCALE];\r\n    }\r\n    /**\r\n     * Aggiusta una data in \"istante finale\" in base a qual è la parte di data significativa.\r\n     * \r\n     * Es. Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)\r\n     * \r\n     * @param {any} date Data qualsiasi (Date, stringa, dayjs...), verrà ricondotta ad un oggetto dayJs\r\n     * @param {'day' | 'hour' | 'minute'} timepart Parte significativa della data\r\n     * @param {boolean} printSeconds Indica se effettuare la stampa dei secondi o no\r\n     */\r\n    public adjustDateToFinalInstant(date: any, timepart: 'day' | 'hour' | 'minute', printSeconds: boolean = true): string {\r\n        let mydt = this.getDateConvertion(date);\r\n        if (mydt == null) return \"FE: Not a Date\";\r\n\r\n        let isZeroTime = mydt.startOf(timepart).valueOf() === mydt.valueOf();\r\n        if (!isZeroTime) {\r\n            if (timepart == \"day\" && mydt.subtract(1, \"hour\").hour() == mydt.hour()) {\r\n                // Se l'ora precedente è lo stesso orario dell'ora attuale l'istante finale dev'essere mandato avanti di 1\r\n                mydt = mydt.add(1, \"hour\");\r\n            }\r\n\r\n            return printSeconds ? mydt.format(this.cfg.fulldateDisplay) : mydt.format(this.cfg.fulldateDisplayNoSS);\r\n        }\r\n\r\n        let tmpValue = mydt.subtract(1, timepart);\r\n        let value = \"\";\r\n\r\n        // Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)\r\n        if (timepart == 'day')\r\n            value = tmpValue.format(this.cfg.smallDate) + \" 24:00\" + (printSeconds ? ':00' : '');\r\n\r\n        // Istante finale dei minuti: giorno 05/10/1992 04:00:00 --> 05/10/1992 03:60(:00)\r\n        else if (timepart == 'hour')\r\n            value = tmpValue.format(this.cfg.smallDateWithH) + \":60\" + (printSeconds ? ':00' : '');\r\n\r\n        // Istante finale dei secondi: giorno 05/10/1992 04:10:00 --> 05/10/1992 04:09:60\r\n        else if (timepart == 'minute')\r\n            value = tmpValue.format(this.cfg.smallDateWithM) + \":60\";\r\n\r\n        return value;\r\n    }\r\n\r\n    /**\r\n     * Funzione che effettua l'ordinamento fra 2 date in base alla direzione specificata\r\n     * \r\n     * @param {any} a Prima data per il confronto\r\n     * @param {any} b Seconda data per il confronto\r\n     * @param {'asc' | 'desc'} direction Direzione rispetto a cui ordinare le due date\r\n     * \r\n     * @returns {number} 0 se le date sono uguali, 1 se la data A deve venire logicamente prima della data B, -1 altrimenti\r\n     */\r\n    public dateSort(a: any, b: any, direction: 'asc' | 'desc'): number {\r\n        if (a < b) return direction == 'asc' ? 1 : -1;\r\n        else if (a > b) return direction == 'asc' ? -1 : 1;\r\n\r\n        // con a uguale a b\r\n        return 0;\r\n    }\r\n\r\n    /**\r\n     * Effettua il trim dei secondi da una data espressa come stringa\r\n     * \r\n     * @param {string} value Data espressa come stringa\r\n     * \r\n     * @returns {string} Data senza i secondi\r\n     */\r\n    public trimSeconds(value: string): string {\r\n        //I numeri mangiati da dayjs spesso vengono ricondotti a date vere. Mi assicuro che se ci sono solo numeri proseguo\r\n        if (!isNaN(<any>value))\r\n            return value;\r\n\r\n        //Se non ho qualcosa del tipo XX/YY/ZZZZ aa:bb:cc di sicuro non è una data che mi interessa\r\n        if (!/^\\d\\d\\/\\d\\d\\/\\d\\d\\d\\d \\d\\d:\\d\\d:\\d\\d$/g.test(value))\r\n            return value;\r\n\r\n        //In questo caso mi arrivano valori che devono essere stampati as-is, solo tagliando i secondi\r\n        return \"'\" + value.substr(0, value.length - 3);\r\n    }\r\n\r\n    /**\r\n     * Data una lista di date Da e una lista di date A restituisce un oggetto rappresentante il range che include tutte le date passate\r\n     * \r\n     * @param {any[]} fromDates Lista dei Da\r\n     * @param {any[]} toDates Lista dei A\r\n     * \r\n     * @returns {{ from: any, to: any }} Range di date Da - A che include tutti i valori di **fromDates** e **toDates**\r\n     */\r\n    public getMinMaxDatesRange(fromDates: any[], toDates: any[]): { from: any, to: any } {\r\n        let datesFroms: any[] = [];\r\n        let datesTo: any[] = [];\r\n\r\n        for(let i = 0; i < fromDates.length; i++)\r\n        {\r\n            let d = fromDates[i];\r\n            var convertion = this.getDateConvertion(d);\r\n            if (convertion)\r\n                datesFroms.push(convertion);\r\n        }\r\n\r\n        for(let i = 0; i < toDates.length; i++)\r\n        {\r\n            let d = toDates[i];\r\n            var convertion = this.getDateConvertion(d);\r\n            if (convertion)\r\n                datesTo.push(convertion);\r\n        }\r\n\r\n        return { from: dayjs.min(datesFroms), to: dayjs.max(datesTo) };\r\n    }\r\n\r\n    /**\r\n     * Ottiene la conversione di una data in qualsiasi formato al formato standard DayJs\r\n     * \r\n     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs\r\n     * @param {boolean} useUtc Indica se usare l'estensione utc di Dayjs per parsare la data o no\r\n     * \r\n     * @returns {any} Data in modalità DayJs\r\n     */\r\n    public getDateConvertion(date: any, useUtc: boolean = false): any {\r\n        if (!date)\r\n            return null;\r\n\r\n        if (this.isDayJs(date))\r\n            return date;\r\n\r\n        if(this.isJsDate(date))\r\n            return useUtc ? dayjs.utc(date): dayjs(date);\r\n\r\n        // Se non c'è la proprietà length vuol dire che non è una stringa e a questo punto non ho idea di che minchia sia\r\n        let length = date.length;\r\n        if (!length)\r\n            return null;\r\n\r\n        if (useUtc && !this.allowUtc)\r\n            throw \"@esfaenza/extensions: Richiesta data UTC ma da configurazione la libreria non lo supporta\";\r\n\r\n        // Per risparmiare chiamate a tentoni, in base alla lunghezza della stringa chiamo direttamente il metodo giusto, \r\n        // controllando poi che mi generi una data come me la aspetto io\r\n        let tryThis = null;\r\n        let toCall = useUtc ? dayjs.utc : dayjs;\r\n\r\n        // Se la data contiene la lettera \"T\" vuol dire che è una data del tipo 2020-10-15T00:00:00, direttamente parsabile dal dayjs col locale corretto.\r\n        // Per il resto mi baso sulla lunghezza della stringa\r\n        if ((<string>date).includes(\"T\"))\r\n            tryThis = toCall(date);\r\n        else if (length == this.cfg.fulldate.length)\r\n            tryThis = toCall(date, this.cfg.fulldate);\r\n        else if (length == this.cfg.smallDate.length)\r\n            tryThis = toCall(date, this.cfg.smallDate);\r\n        else if (length == this.cfg.fulldateNoSS.length)\r\n            tryThis = toCall(date, this.cfg.fulldateNoSS)\r\n\r\n        if (tryThis && tryThis.isValid && tryThis.isValid())\r\n            return tryThis;\r\n\r\n        // Se niente funziona, null. \r\n        // Ricondurre l'Input ad una data non è possibile.\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * Helper che restituisce **true** qualora l'oggetto passato fosse una data vera e propria, **false** altrimenti\r\n     * \r\n     * @param {any} check Oggetto da controllare\r\n     * \r\n     * @returns {boolean} Indicazione se l'oggetto è un vero Date di Javascript o no\r\n     */\r\n    private isJsDate(check: any): boolean {\r\n        return check && Object.prototype.toString.call(check) === \"[object Date]\" && !isNaN(check);\r\n    }\r\n\r\n    /**\r\n     * Helper che restituisce **true** qualora l'oggetto passato fosse un DayJs vero e proprio, **false** altrimenti\r\n     * \r\n     * @param {any} check Oggetto da controllare\r\n     * @returns {boolean} Indicazione se l'oggetto è un vero DayJs o no\r\n     */\r\n     private isDayJs(check: any): boolean {\r\n        // Non uso instanceof perché sarebbe estremamente più lento\r\n        // Non uso nemmeno isDayjs() della libreria Dayjs dato che ha lo stesso problema: https://github.com/iamkun/dayjs/blob/06f88f425828b1ce96b737332d25145a95a4ee9d/src/index.js#L9\r\n        return check.$D !== undefined && check.$M !== undefined && check.$y !== undefined;\r\n    }\r\n\r\n    /**\r\n     * Ottiene la formattazione di una data in base alla versione richiesta \"small\" o \"long\" e a se stampare o meno i secondi\r\n     * \r\n     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs\r\n     * @param {boolean} small Indica se formattarla con un formato breve (se **true**) o un formato più lungo (se **false**)\r\n     * \r\n     * @returns {string} Data formattata nel formato richiesto\r\n     */\r\n    public getFormatted(date: any, small: boolean, seconds: boolean): string {\r\n        var date = this.getDateConvertion(date);\r\n        if (!date) return null;\r\n\r\n        return date.format(small ? this.cfg.smallDate : seconds ? this.cfg.fulldateDisplay : this.cfg.fulldateDisplayNoSS);\r\n    }\r\n}"]}