@esfaenza/extensions 12.2.15 → 13.1.3

package/esfaenza-extensions.d.ts

@@ -1,6 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@esfaenza/extensions" />
 export * from './public-api';
-export { DefaultStorageProvider as ɵb } from './lib/models/providers/implementation/DefaultStorageProvider';
-export { DefaultSessionRetriever as ɵa } from './lib/models/session/implementation/DefaultSessionRetriever';

package/esm2020/esfaenza-extensions.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNmYWVuemEtZXh0ZW5zaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2V4dGVuc2lvbnMvc3JjL2VzZmFlbnphLWV4dGVuc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/lib/models/providers/implementation/DefaultStorageProvider.mjs

@@ -0,0 +1,79 @@
+import { Injectable } from "@angular/core";
+import { of } from "rxjs";
+import { BaseStorageProvider } from "../base/BaseStorageProvider";
+import * as i0 from "@angular/core";
+import * as i1 from "../../session/base/BaseSessionRetriever";
+/** Implementazione di default per la classe **BaseStorageProvider** */
+export class DefaultStorageProvider extends BaseStorageProvider {
+    /** @ignore Costruttore */
+    constructor(session) { super(session); }
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    setItem(key, value) {
+        try {
+            localStorage.setItem(key, JSON.stringify(value));
+            return of(true);
+        }
+        catch {
+            // Potrebbe arrivarmi un prefisso di salvataggio nella modalità di default. Questo serve per ripulire le stesse cose con quel prefisso e sperare di liberare spazio
+            if (value.savedprefix) {
+                console.warn("Spazio del local Storage insufficiente, prova a ripulirlo e risalvare");
+                //Pulisco tutte le view con nome che parta per "Hot"
+                for (let key in localStorage) {
+                    if (localStorage.hasOwnProperty(key) && key.startsWith(value.savedprefix))
+                        delete localStorage[key];
+                }
+                try {
+                    localStorage.setItem(key, JSON.stringify(value));
+                }
+                catch (e) {
+                    console.error("Spazio del local Storage insufficiente per salvare i risultati di ricerca con solo filtri. Non salvo nulla");
+                }
+            }
+            return of(false);
+        }
+    }
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    getItem(key) {
+        try {
+            var ret = JSON.parse(localStorage.getItem(key));
+            return of(ret);
+        }
+        catch {
+            return of(null);
+        }
+    }
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    removeItem(key) {
+        try {
+            localStorage.removeItem(key);
+            return of(true);
+        }
+        catch {
+            return of(false);
+        }
+    }
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    clear() {
+        try {
+            localStorage.clear();
+            return of(true);
+        }
+        catch {
+            return of(false);
+        }
+    }
+    /** @ignore Implementazione di Default con localStorage. Identity viene ignorata perché essendo già nel localStorage è già per sito */
+    getAll() {
+        var ret = {};
+        for (let key in localStorage) {
+            ret[key] = localStorage[key];
+        }
+        return of(ret);
+    }
+}
+DefaultStorageProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DefaultStorageProvider, deps: [{ token: i1.BaseSessionRetriever }], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultStorageProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DefaultStorageProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DefaultStorageProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.BaseSessionRetriever }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/session/implementation/DefaultSessionRetriever.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from "@angular/core";
+import { BaseSessionRetriever } from "../base/BaseSessionRetriever";
+import * as i0 from "@angular/core";
+/**
+ * Implementazione di default per la classe **BaseSessionRetriever**
+ */
+export class DefaultSessionRetriever extends BaseSessionRetriever {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor() { super(); }
+    /**
+     * Ottiene un ID sessione
+     *
+     * @returns {string} ID sessione
+     */
+    getSessionKey() {
+        return "DUMMY_SESSION";
+    }
+}
+DefaultSessionRetriever.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DefaultSessionRetriever, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultSessionRetriever.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DefaultSessionRetriever });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DefaultSessionRetriever, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVmYXVsdFNlc3Npb25SZXRyaWV2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9leHRlbnNpb25zL3NyYy9saWIvbW9kZWxzL3Nlc3Npb24vaW1wbGVtZW50YXRpb24vRGVmYXVsdFNlc3Npb25SZXRyaWV2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQzs7QUFFcEU7O0dBRUc7QUFFSCxNQUFNLE9BQU8sdUJBQXdCLFNBQVEsb0JBQW9CO0lBRTdEOzs7O09BSUc7SUFDSCxnQkFBZ0IsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBRTFCOzs7O09BSUc7SUFDSCxhQUFhO1FBQ1QsT0FBTyxlQUFlLENBQUM7SUFDM0IsQ0FBQzs7b0hBaEJRLHVCQUF1Qjt3SEFBdkIsdUJBQXVCOzJGQUF2Qix1QkFBdUI7a0JBRG5DLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgQmFzZVNlc3Npb25SZXRyaWV2ZXIgfSBmcm9tIFwiLi4vYmFzZS9CYXNlU2Vzc2lvblJldHJpZXZlclwiO1xyXG5cclxuLyoqXHJcbiAqIEltcGxlbWVudGF6aW9uZSBkaSBkZWZhdWx0IHBlciBsYSBjbGFzc2UgKipCYXNlU2Vzc2lvblJldHJpZXZlcioqXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBEZWZhdWx0U2Vzc2lvblJldHJpZXZlciBleHRlbmRzIEJhc2VTZXNzaW9uUmV0cmlldmVyIHtcclxuXHJcbiAgICAvKipcclxuICAgICAqIENvc3RydXR0b3JlXHJcbiAgICAgKiBcclxuICAgICAqIEBpZ25vcmVcclxuICAgICAqL1xyXG4gICAgY29uc3RydWN0b3IoKSB7IHN1cGVyKCk7IH1cclxuXHJcbiAgICAvKipcclxuICAgICAqIE90dGllbmUgdW4gSUQgc2Vzc2lvbmVcclxuICAgICAqIFxyXG4gICAgICogQHJldHVybnMge3N0cmluZ30gSUQgc2Vzc2lvbmVcclxuICAgICAqL1xyXG4gICAgZ2V0U2Vzc2lvbktleSgpOiBzdHJpbmcge1xyXG4gICAgICAgIHJldHVybiBcIkRVTU1ZX1NFU1NJT05cIjtcclxuICAgIH1cclxufSJdfQ==

package/esm2020/lib/modules/extensions.full.module.mjs

@@ -0,0 +1,58 @@
+// Angular
+import { NgModule } from '@angular/core';
+import { EXT_LOCALE, EXT_FANCY_ALERTS, APPSEARCH_PREFIX, EXT_ALLOW_UTC } from '../tokens';
+// Servizi
+import { ClipboardService } from "../services/extensions.clipboard.service";
+import { DateService } from "../services/extensions.dates.service";
+import { ExportService } from "../services/extensions.exports.service";
+import { HashingService } from "../services/extensions.hashing.service";
+import { MessageService } from "../services/extensions.messages.service";
+import { UtilityService } from "../services/extensions.utilities.service";
+import { StorageService } from '../services/extensions.storage.service';
+// Providers
+import { BaseSessionRetriever } from '../models/session/base/BaseSessionRetriever';
+import { DefaultSessionRetriever } from '../models/session/implementation/DefaultSessionRetriever';
+import { BaseStorageProvider } from '../models/providers/base/BaseStorageProvider';
+import { DefaultStorageProvider } from '../models/providers/implementation/DefaultStorageProvider';
+import * as i0 from "@angular/core";
+/**
+ * Modulo di estensione che registra autonomamente **TUTTI** i servizi di estensione:
+ * ClipboardService,
+ * DateService,
+ * ExportService,
+ * HashingService,
+ * MessageService,
+ * UtilityService,
+ * StorageService,
+ *
+ * con eventuali provider che utilizzano
+ */
+export class FullExtensionsModule {
+    static forRoot(config) {
+        return {
+            ngModule: FullExtensionsModule,
+            providers: [
+                ClipboardService,
+                DateService,
+                ExportService,
+                HashingService,
+                MessageService,
+                UtilityService,
+                StorageService,
+                { provide: EXT_LOCALE, useValue: config?.locale || 'it-IT' },
+                { provide: EXT_FANCY_ALERTS, useValue: config?.fancy_alerts || true },
+                { provide: APPSEARCH_PREFIX, useValue: config?.appsearch_prefix || 'Hot' },
+                { provide: EXT_ALLOW_UTC, useValue: config?.allow_utc == null ? false : config?.allow_utc },
+                { provide: BaseSessionRetriever, useClass: config?.sessionRetriever || DefaultSessionRetriever },
+                { provide: BaseStorageProvider, useClass: config?.storageProvider || DefaultStorageProvider },
+            ]
+        };
+    }
+}
+FullExtensionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FullExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FullExtensionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FullExtensionsModule });
+FullExtensionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FullExtensionsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FullExtensionsModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/extensions.module.mjs

@@ -0,0 +1,28 @@
+// Angular
+import { NgModule } from '@angular/core';
+// Modelli
+import { EXT_LOCALE, EXT_FANCY_ALERTS, APPSEARCH_PREFIX, EXT_ALLOW_UTC } from '../tokens';
+import * as i0 from "@angular/core";
+/**
+ * Modulo di estensione che non registra nessun servizio di estensione, dovranno essere dichiarati 1 per 1 dall'applicazione che li utilizza
+ */
+export class ExtensionsModule {
+    static forRoot(config) {
+        return {
+            ngModule: ExtensionsModule,
+            providers: [
+                { provide: EXT_LOCALE, useValue: config?.locale || 'it-IT' },
+                { provide: EXT_FANCY_ALERTS, useValue: config?.fancy_alerts || true },
+                { provide: APPSEARCH_PREFIX, useValue: config?.appsearch_prefix || 'Hot' },
+                { provide: EXT_ALLOW_UTC, useValue: config?.allow_utc == null ? false : config?.allow_utc }
+            ]
+        };
+    }
+}
+ExtensionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ExtensionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ExtensionsModule });
+ExtensionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ExtensionsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ExtensionsModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,165 @@
+// Angular
+import { Injectable, Inject, Optional } from "@angular/core";
+import { EXT_LOCALE } from "../tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "./extensions.messages.service";
+/**
+ * Service che fornisce un accesso base in lettura/scrittura sulla clipboard
+ */
+export class ClipboardService {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(msgService, LOCALE) {
+        this.msgService = msgService;
+        this.LOCALE = LOCALE;
+        /**
+         * Oggetto statico di localizzazione per i messaggi di questa Service
+         */
+        this.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"
+            }
+        };
+    }
+    /**
+     * 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
+     */
+    getClipboard(style, valueFoundCallback) {
+        if (navigator.userAgent.indexOf("Firefox") != -1) {
+            //https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/readText
+            this.msgService.simpleError(this.loc["Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation"][this.LOCALE ?? 'it-IT']);
+            return;
+        }
+        if (window.clipboardData) {
+            let data = window.clipboardData.getData("Text");
+            var value = style == "array" ? this.getClipboardLines(data) :
+                style == "matrix" ? this.getClipboardMatrix(data) : [];
+            if (valueFoundCallback)
+                valueFoundCallback(value);
+        }
+        else if (window.navigator.clipboard) {
+            window.navigator.permissions.query({ name: 'clipboard-read' }).then(result => {
+                if (!(result.state === 'granted' || result.state === 'prompt'))
+                    if (valueFoundCallback)
+                        valueFoundCallback([]);
+                window.navigator.clipboard.readText()
+                    .then(t => {
+                    var value = style == "array" ? this.getClipboardLines(t) :
+                        style == "matrix" ? this.getClipboardMatrix(t) : [];
+                    if (valueFoundCallback)
+                        valueFoundCallback(value);
+                })
+                    .catch(err => {
+                    this.msgService.simpleError(this.loc["Error during Clipboard content read operation"][this.LOCALE ?? 'it-IT'] + ": " + err);
+                });
+            });
+        }
+    }
+    /**
+     * 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) {
+        return data.trim().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.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
+     */
+    copyTextToClipboard(text) {
+        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"][this.LOCALE ?? 'it-IT']);
+        }
+        catch (err) {
+            this.msgService.simpleError(this.loc["Error during Clipboard content copy operation"][this.LOCALE ?? 'it-IT'] + ": " + err);
+        }
+        document.body.removeChild(textArea);
+    }
+}
+ClipboardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ClipboardService, deps: [{ token: i1.MessageService }, { token: EXT_LOCALE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ClipboardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ClipboardService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ClipboardService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MessageService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [EXT_LOCALE]
+                }] }]; } });
+//# 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, Inject, Optional } from \"@angular/core\";\r\n\r\n// Modelli\r\nimport { MessageService } from './extensions.messages.service';\r\nimport { EXT_LOCALE } from \"../tokens\";\r\n\r\n/**\r\n * Service che fornisce un accesso base in lettura/scrittura sulla clipboard\r\n */\r\n@Injectable()\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    };\r\n\r\n    /**\r\n     * Costruttore\r\n     * \r\n     * @ignore\r\n     */\r\n    public constructor(private msgService: MessageService, @Optional() @Inject(EXT_LOCALE) private LOCALE: string) { }\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 getClipboard(style: 'array' | 'matrix', valueFoundCallback : (values: string[] | string[][]) => void) {\r\n        if (navigator.userAgent.indexOf(\"Firefox\") != -1) {\r\n            //https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/readText\r\n            this.msgService.simpleError(this.loc[\"Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation\"][this.LOCALE ?? 'it-IT']);\r\n            return;\r\n        }\r\n\r\n        if ((<any>window).clipboardData) {\r\n            let data = (<any>window).clipboardData.getData(\"Text\");\r\n            var value = style == \"array\"? this.getClipboardLines(data) : \r\n                        style == \"matrix\" ? this.getClipboardMatrix(data) : [];\r\n            if (valueFoundCallback) valueFoundCallback(value);\r\n        }\r\n\r\n        else if ((<any>window).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                    if (valueFoundCallback) valueFoundCallback([]);\r\n\r\n                (<any>window).navigator.clipboard.readText()\r\n                    .then(t => {\r\n                        var value = style == \"array\"? this.getClipboardLines(t) : \r\n                                    style == \"matrix\" ? this.getClipboardMatrix(t) : [];\r\n                        if (valueFoundCallback) valueFoundCallback(value);\r\n                    })\r\n                    .catch(err => { \r\n                        this.msgService.simpleError(this.loc[\"Error during Clipboard content read operation\"][this.LOCALE ?? 'it-IT'] + \": \"+ err);\r\n                     });\r\n            });\r\n        }\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        return data.trim().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.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 copyTextToClipboard(text: string) {\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\"][this.LOCALE ?? 'it-IT']);\r\n        } catch (err) {\r\n            this.msgService.simpleError(this.loc[\"Error during Clipboard content copy operation\"][this.LOCALE ?? 'it-IT'] + \": \"+ err);\r\n        }\r\n\r\n        document.body.removeChild(textArea);\r\n    }\r\n}"]}