@esfaenza/access-control 15.2.13 → 16.0.2

package/{fesm2020 → fesm2022}/esfaenza-access-control.mjs

@@ -2,471 +2,471 @@ import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Optional, Inject, Directive, Input, Pipe, NgModule } from '@angular/core';
 import * as i1 from '@esfaenza/extensions';
 
-/** Token che racchiude la chiave custom da controllare quando si effettuano controlli sul ComponentContext */
-const ACC_CUSTOMKEY = new InjectionToken('ACC_CUSTOMKEY');
-/** Token che indica la condizione di default da aggiungere ai check utente */
-const ACC_DEF_COND = new InjectionToken('ACC_DEF_COND');
-/** Token che indica l'operatore della condizione di default da aggiungere ai check utente */
-const ACC_DEF_COND_OP = new InjectionToken('ACC_DEF_COND_OP');
-/** Modalità di Debug */
+/** Token che racchiude la chiave custom da controllare quando si effettuano controlli sul ComponentContext */
+const ACC_CUSTOMKEY = new InjectionToken('ACC_CUSTOMKEY');
+/** Token che indica la condizione di default da aggiungere ai check utente */
+const ACC_DEF_COND = new InjectionToken('ACC_DEF_COND');
+/** Token che indica l'operatore della condizione di default da aggiungere ai check utente */
+const ACC_DEF_COND_OP = new InjectionToken('ACC_DEF_COND_OP');
+/** Modalità di Debug */
 const ACC_DEBUG_MODE = new InjectionToken('ACC_DEBUG_MODE');
 
-// Angular
-/**
- * Entrypoint di tutte le operazioni esposte dalla libreria access-control
- */
-class AccessControlService {
-    /** @ignore */
-    constructor(ACC_DEF_COND, ACC_DEF_COND_OP, emb) {
-        this.ACC_DEF_COND = ACC_DEF_COND;
-        this.ACC_DEF_COND_OP = ACC_DEF_COND_OP;
-        this.emb = emb;
-        /**
-         * Indica se l'Identity è stata inizializzata
-         */
-        this.Initialized = false;
-        /**
-         * Indica se sono state effettuate inizializzazioni di Custom Permissions
-         */
-        this.InitializedCustom = false;
-        /** @ignore */
-        this.cache = {};
-        /** @ignore */
-        this.taggedItemsCache = [];
-    }
-    /**
-     * Inizializza l'Identity del servizio con il modello specificato
-     *
-     * @params {{ Roles: string[], Permissions: string[] }} identity Identità applicativa con ruoli e permessi
-     */
-    initializeIdentity(identity) {
-        this.Identity = identity;
-        this.Initialized = true;
-    }
-    /**
-     * Inizializza i permessi Custom del servizio con il modello specificato
-     *
-     * @param {{ key: string, items: string[] }[]} customPermissions Permessi Custom
-     */
-    initializeCustomPermissions(customPermissions) {
-        for (let i = 0; i < customPermissions.length; i++) {
-            if (customPermissions[i].key.length > 1) {
-                console.error("[@esfaenza/access-control] Custom permission initialized with keys longer than a single characters. Ignoring EVERYTHING.");
-                return;
-            }
-        }
-        // Custom permission sull'embedding aggiunta automaticamente se non presente
-        if (!customPermissions.find(t => t.key === "X"))
-            customPermissions.push({ key: "X", items: [this.emb.Embedded ? "1" : "0"] });
-        this.taggedItemsCache = customPermissions;
-        this.InitializedCustom = true;
-    }
-    /**
-     * Indica se nella sessione attuale esiste un utente loggato. Fa un semplice controllo di presenza sull'Identity
-     */
-    isLoggedIn() {
-        return !!this.Identity;
-    }
-    /**
-     * Expression è scritta tipo --> R:Role1 && P:Permission1 || (R:Role2 && P:Permission1)
-     * Quindi piuttosto che implementarsi un parser della madonna in stile Alessandro prendo la strada stronza e veloce con l'eval :P
-     *
-     * @ignore
-     */
-    hasACExpression(expression, absolute = false) {
-        if (!this.Initialized)
-            console.error("Access Control System has not been initialized. Call this.accessControl.initialize(..., ...) before using the service");
-        if (!expression)
-            return true;
-        if (!this.Identity) {
-            console.warn("Elemento Identity non specificato in Access Control. Gli accessi saranno tutti liberi di default");
-            return true;
-        }
-        // Espressione già valutata, non serve rivalutarla
-        if (this.cache[expression])
-            return this.cache[expression];
-        var RolesPermissionsRegexp = /!?.:[^|&()]+/g;
-        var matches = expression.match(RolesPermissionsRegexp);
-        if (!matches)
-            throw "Espressione Access Control non valida: " + expression + ". Assicurarsi che sia scritta in modo corretto";
-        // Per condizioni dirette sull'embedding si considera sempre che siano operazioni assolute
-        if (expression == 'X:0' || expression == 'X:1')
-            absolute = true;
-        matches.forEach(t => {
-            var splits = t.split(':');
-            // Per ruoli e permessi, se ho condizioni di default e l'espressione non è assoluta, wrappo ogni elemento con le espressioni di default
-            // Per le custom permissions invece, dato che sono cose staccate da ruoli e permessi, non ha mai senso farlo
-            if (splits[0] == "R" || splits[0] == "!R") {
-                if (this.ACC_DEF_COND && this.ACC_DEF_COND_OP && !absolute) {
-                    let tmpReplace = `(${t} ${this.ACC_DEF_COND_OP} ${this.ACC_DEF_COND})`;
-                    var matches2 = tmpReplace.match(RolesPermissionsRegexp);
-                    matches2.forEach(t2 => {
-                        var splits2 = t2.split(':');
-                        if (splits2[0] == "R" || splits2[0] == "!R")
-                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasRole('" + splits2[1].trim() + "')");
-                        else if (splits2[0] == "P" || splits2[0] == "!P")
-                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasPermission('" + splits2[1].trim() + "')");
-                        else
-                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasCustom('" + splits2[1].trim() + "')");
-                    });
-                    expression = expression.replace(t.trim(), tmpReplace);
-                }
-                else
-                    expression = expression.replace(t.trim(), (t.startsWith("!") ? '!' : '') + "this.hasRole('" + splits[1].trim() + "')");
-            }
-            else if (splits[0] == "P" || splits[0] == "!P") {
-                if (this.ACC_DEF_COND && this.ACC_DEF_COND_OP && !absolute) {
-                    let tmpReplace = `(${t} ${this.ACC_DEF_COND_OP} ${this.ACC_DEF_COND})`;
-                    var matches2 = tmpReplace.match(RolesPermissionsRegexp);
-                    matches2.forEach(t2 => {
-                        var splits2 = t2.split(':');
-                        if (splits2[0] == "R" || splits2[0] == "!R")
-                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasRole('" + splits2[1].trim() + "')");
-                        else if (splits2[0] == "P" || splits2[0] == "!P")
-                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasPermission('" + splits2[1].trim() + "')");
-                        else
-                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasCustom('" + splits2[1].trim() + "')");
-                    });
-                    expression = expression.replace(t.trim(), tmpReplace);
-                }
-                else
-                    expression = expression.replace(t.trim(), (t.startsWith("!") ? '!' : '') + "this.hasPermission('" + splits[1].trim() + "')");
-            }
-            else
-                expression = expression.replace(t.trim(), (t.startsWith("!") ? '!' : '') + "this.hasCustom('" + splits[1].trim() + "', '" + ((t.startsWith("!") ? splits[0].trim().charAt(1) : splits[0].trim())) + "')");
-        });
-        var ret = eval(expression);
-        // Cache valore
-        this.cache[expression] = ret;
-        return ret;
-    }
-    /**
-     * Utilizzato da hasACExpression dentro eval
-     *
-     * @ignore
-     */
-    hasRole(role) {
-        if (!this.Identity) {
-            console.warn("Elemento Identity non specificato in Access Control. Gli accessi saranno tutti liberi di default");
-            return true;
-        }
-        return this.Identity.Roles && this.Identity.Roles.length > 0 && this.Identity.Roles.indexOf(role) != -1;
-    }
-    /**
-     * Utilizzato da hasACExpression dentro eval
-     *
-     * @ignore
-     */
-    hasPermission(permission) {
-        if (!this.Identity) {
-            console.warn("Elemento Identity non specificato in Access Control. Gli accessi saranno tutti liberi di default");
-            return true;
-        }
-        return this.Identity.Permissions && this.Identity.Permissions.length > 0 && this.Identity.Permissions.indexOf(permission) != -1;
-    }
-    /**
-     * Utilizzato da hasACExpression dentro eval
-     *
-     * @ignore
-     */
-    hasCustom(value, tag) {
-        var items = this.taggedItemsCache.find(t => t.key == tag)?.items;
-        if (!items)
-            return true;
-        else if (items.length == 0)
-            return false;
-        else {
-            var found = items.find(t => t == value);
-            return found != null && found != undefined;
-        }
-    }
-    /**
-     * Entry point che controlla un'espressione identificante un permesso, ad esempio "P:visualizzazione" controlla che l'utente collegato abbia un permesso che si chiama "visualizzazione"
-     */
-    has(expr, absolute = false) {
-        return this.hasACExpression(expr, absolute);
-    }
-}
-AccessControlService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlService, deps: [{ token: ACC_DEF_COND, optional: true }, { token: ACC_DEF_COND_OP, optional: true }, { token: i1.AppEmbeddingExtensions }], target: i0.ɵɵFactoryTarget.Injectable });
-AccessControlService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlService, providedIn: "root" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: "root" }]
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [ACC_DEF_COND]
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [ACC_DEF_COND_OP]
+// Angular
+/**
+ * Entrypoint di tutte le operazioni esposte dalla libreria access-control
+ */
+class AccessControlService {
+    /** @ignore */
+    constructor(ACC_DEF_COND, ACC_DEF_COND_OP, emb) {
+        this.ACC_DEF_COND = ACC_DEF_COND;
+        this.ACC_DEF_COND_OP = ACC_DEF_COND_OP;
+        this.emb = emb;
+        /**
+         * Indica se l'Identity è stata inizializzata
+         */
+        this.Initialized = false;
+        /**
+         * Indica se sono state effettuate inizializzazioni di Custom Permissions
+         */
+        this.InitializedCustom = false;
+        /** @ignore */
+        this.cache = {};
+        /** @ignore */
+        this.taggedItemsCache = [];
+    }
+    /**
+     * Inizializza l'Identity del servizio con il modello specificato
+     *
+     * @params {{ Roles: string[], Permissions: string[] }} identity Identità applicativa con ruoli e permessi
+     */
+    initializeIdentity(identity) {
+        this.Identity = identity;
+        this.Initialized = true;
+    }
+    /**
+     * Inizializza i permessi Custom del servizio con il modello specificato
+     *
+     * @param {{ key: string, items: string[] }[]} customPermissions Permessi Custom
+     */
+    initializeCustomPermissions(customPermissions) {
+        for (let i = 0; i < customPermissions.length; i++) {
+            if (customPermissions[i].key.length > 1) {
+                console.error("[@esfaenza/access-control] Custom permission initialized with keys longer than a single characters. Ignoring EVERYTHING.");
+                return;
+            }
+        }
+        // Custom permission sull'embedding aggiunta automaticamente se non presente
+        if (!customPermissions.find(t => t.key === "X"))
+            customPermissions.push({ key: "X", items: [this.emb.Embedded ? "1" : "0"] });
+        this.taggedItemsCache = customPermissions;
+        this.InitializedCustom = true;
+    }
+    /**
+     * Indica se nella sessione attuale esiste un utente loggato. Fa un semplice controllo di presenza sull'Identity
+     */
+    isLoggedIn() {
+        return !!this.Identity;
+    }
+    /**
+     * Expression è scritta tipo --> R:Role1 && P:Permission1 || (R:Role2 && P:Permission1)
+     * Quindi piuttosto che implementarsi un parser della madonna in stile Alessandro prendo la strada stronza e veloce con l'eval :P
+     *
+     * @ignore
+     */
+    hasACExpression(expression, absolute = false) {
+        if (!this.Initialized)
+            console.error("Access Control System has not been initialized. Call this.accessControl.initialize(..., ...) before using the service");
+        if (!expression)
+            return true;
+        if (!this.Identity) {
+            console.warn("Elemento Identity non specificato in Access Control. Gli accessi saranno tutti liberi di default");
+            return true;
+        }
+        // Espressione già valutata, non serve rivalutarla
+        if (this.cache[expression])
+            return this.cache[expression];
+        var RolesPermissionsRegexp = /!?.:[^|&()]+/g;
+        var matches = expression.match(RolesPermissionsRegexp);
+        if (!matches)
+            throw "Espressione Access Control non valida: " + expression + ". Assicurarsi che sia scritta in modo corretto";
+        // Per condizioni dirette sull'embedding si considera sempre che siano operazioni assolute
+        if (expression == 'X:0' || expression == 'X:1')
+            absolute = true;
+        matches.forEach(t => {
+            var splits = t.split(':');
+            // Per ruoli e permessi, se ho condizioni di default e l'espressione non è assoluta, wrappo ogni elemento con le espressioni di default
+            // Per le custom permissions invece, dato che sono cose staccate da ruoli e permessi, non ha mai senso farlo
+            if (splits[0] == "R" || splits[0] == "!R") {
+                if (this.ACC_DEF_COND && this.ACC_DEF_COND_OP && !absolute) {
+                    let tmpReplace = `(${t} ${this.ACC_DEF_COND_OP} ${this.ACC_DEF_COND})`;
+                    var matches2 = tmpReplace.match(RolesPermissionsRegexp);
+                    matches2.forEach(t2 => {
+                        var splits2 = t2.split(':');
+                        if (splits2[0] == "R" || splits2[0] == "!R")
+                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasRole('" + splits2[1].trim() + "')");
+                        else if (splits2[0] == "P" || splits2[0] == "!P")
+                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasPermission('" + splits2[1].trim() + "')");
+                        else
+                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasCustom('" + splits2[1].trim() + "')");
+                    });
+                    expression = expression.replace(t.trim(), tmpReplace);
+                }
+                else
+                    expression = expression.replace(t.trim(), (t.startsWith("!") ? '!' : '') + "this.hasRole('" + splits[1].trim() + "')");
+            }
+            else if (splits[0] == "P" || splits[0] == "!P") {
+                if (this.ACC_DEF_COND && this.ACC_DEF_COND_OP && !absolute) {
+                    let tmpReplace = `(${t} ${this.ACC_DEF_COND_OP} ${this.ACC_DEF_COND})`;
+                    var matches2 = tmpReplace.match(RolesPermissionsRegexp);
+                    matches2.forEach(t2 => {
+                        var splits2 = t2.split(':');
+                        if (splits2[0] == "R" || splits2[0] == "!R")
+                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasRole('" + splits2[1].trim() + "')");
+                        else if (splits2[0] == "P" || splits2[0] == "!P")
+                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasPermission('" + splits2[1].trim() + "')");
+                        else
+                            tmpReplace = tmpReplace.replace(t2.trim(), (t2.startsWith("!") ? '!' : '') + "this.hasCustom('" + splits2[1].trim() + "')");
+                    });
+                    expression = expression.replace(t.trim(), tmpReplace);
+                }
+                else
+                    expression = expression.replace(t.trim(), (t.startsWith("!") ? '!' : '') + "this.hasPermission('" + splits[1].trim() + "')");
+            }
+            else
+                expression = expression.replace(t.trim(), (t.startsWith("!") ? '!' : '') + "this.hasCustom('" + splits[1].trim() + "', '" + ((t.startsWith("!") ? splits[0].trim().charAt(1) : splits[0].trim())) + "')");
+        });
+        var ret = eval(expression);
+        // Cache valore
+        this.cache[expression] = ret;
+        return ret;
+    }
+    /**
+     * Utilizzato da hasACExpression dentro eval
+     *
+     * @ignore
+     */
+    hasRole(role) {
+        if (!this.Identity) {
+            console.warn("Elemento Identity non specificato in Access Control. Gli accessi saranno tutti liberi di default");
+            return true;
+        }
+        return this.Identity.Roles && this.Identity.Roles.length > 0 && this.Identity.Roles.indexOf(role) != -1;
+    }
+    /**
+     * Utilizzato da hasACExpression dentro eval
+     *
+     * @ignore
+     */
+    hasPermission(permission) {
+        if (!this.Identity) {
+            console.warn("Elemento Identity non specificato in Access Control. Gli accessi saranno tutti liberi di default");
+            return true;
+        }
+        return this.Identity.Permissions && this.Identity.Permissions.length > 0 && this.Identity.Permissions.indexOf(permission) != -1;
+    }
+    /**
+     * Utilizzato da hasACExpression dentro eval
+     *
+     * @ignore
+     */
+    hasCustom(value, tag) {
+        var items = this.taggedItemsCache.find(t => t.key == tag)?.items;
+        if (!items)
+            return true;
+        else if (items.length == 0)
+            return false;
+        else {
+            var found = items.find(t => t == value);
+            return found != null && found != undefined;
+        }
+    }
+    /**
+     * Entry point che controlla un'espressione identificante un permesso, ad esempio "P:visualizzazione" controlla che l'utente collegato abbia un permesso che si chiama "visualizzazione"
+     */
+    has(expr, absolute = false) {
+        return this.hasACExpression(expr, absolute);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlService, deps: [{ token: ACC_DEF_COND, optional: true }, { token: ACC_DEF_COND_OP, optional: true }, { token: i1.AppEmbeddingExtensions }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ACC_DEF_COND]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ACC_DEF_COND_OP]
                 }] }, { type: i1.AppEmbeddingExtensions }]; } });
 
-// Angular
-/**
- * Direttiva che permette di gestire il controllo accessi su componenti HTML.
- *
- * Per gli esempi di utilizzo fare riferimento al README.
- */
-class AccessControlDirective {
-    /**
-     * Costruttore
-     *
-     * @ignore
-     */
-    constructor(templateRef, viewContainer, _ac) {
-        this.templateRef = templateRef;
-        this.viewContainer = viewContainer;
-        this._ac = _ac;
-        /**
-         * Espressione da processare scritta come {Chiave}:{Valore}
-         *
-         * Le {Chiave} disponibili sono di default "R" per i ruoli e "P" per i permessi. È possibile espanderle con le Custom Permissions.
-         *
-         * Nelle ultime versioni del template è anche presente di default la custom permission "X" che indica se l'applicaizone è Esterna o no
-         */
-        this.ac = null;
-        /** Indica che l'esporessione **ac** è assoluta, cioè che non può essere modificata internamente ad esempio per aggiungere condizioni di default */
-        this.acAbsolute = false;
-    }
-    ngOnInit() {
-        var allow = this._ac.has(this.ac, this.acAbsolute);
-        //Se ho i permessi, proseguo creando la vista nel DOM, altrimenti rimuovo il template
-        if (allow)
-            this.viewContainer.createEmbeddedView(this.templateRef);
-        else
-            this.viewContainer.clear();
-    }
-}
-AccessControlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: AccessControlService }], target: i0.ɵɵFactoryTarget.Directive });
-AccessControlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: AccessControlDirective, selector: "[ac]", inputs: { ac: "ac", acAbsolute: "acAbsolute" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ac]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: AccessControlService }]; }, propDecorators: { ac: [{
-                type: Input
-            }], acAbsolute: [{
-                type: Input
+// Angular
+/**
+ * Direttiva che permette di gestire il controllo accessi su componenti HTML.
+ *
+ * Per gli esempi di utilizzo fare riferimento al README.
+ */
+class AccessControlDirective {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(templateRef, viewContainer, _ac) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this._ac = _ac;
+        /**
+         * Espressione da processare scritta come {Chiave}:{Valore}
+         *
+         * Le {Chiave} disponibili sono di default "R" per i ruoli e "P" per i permessi. È possibile espanderle con le Custom Permissions.
+         *
+         * Nelle ultime versioni del template è anche presente di default la custom permission "X" che indica se l'applicaizone è Esterna o no
+         */
+        this.ac = null;
+        /** Indica che l'esporessione **ac** è assoluta, cioè che non può essere modificata internamente ad esempio per aggiungere condizioni di default */
+        this.acAbsolute = false;
+    }
+    ngOnInit() {
+        var allow = this._ac.has(this.ac, this.acAbsolute);
+        //Se ho i permessi, proseguo creando la vista nel DOM, altrimenti rimuovo il template
+        if (allow)
+            this.viewContainer.createEmbeddedView(this.templateRef);
+        else
+            this.viewContainer.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: AccessControlService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AccessControlDirective, selector: "[ac]", inputs: { ac: "ac", acAbsolute: "acAbsolute" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ac]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: AccessControlService }]; }, propDecorators: { ac: [{
+                type: Input
+            }], acAbsolute: [{
+                type: Input
             }] } });
 
-/**
- * Token da iniettare per ogni singolo componente per cui si vuole disattivare/attivare massivamente degli input in maniera contestuale
- */
-class ComponentContext {
-}
-ComponentContext.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ComponentContext, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ComponentContext.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ComponentContext });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ComponentContext, decorators: [{
-            type: Injectable
+/**
+ * Token da iniettare per ogni singolo componente per cui si vuole disattivare/attivare massivamente degli input in maniera contestuale
+ */
+class ComponentContext {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ComponentContext, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ComponentContext }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ComponentContext, decorators: [{
+            type: Injectable
         }] });
 
-// Angular
-/**
- * Direttiva che permette di capire se l'elemento HTML su cui è utilizzata dev'essere disabilitato o no.
- *
- * Non ha effetto sugli elementi dichiarati in componenti che non dichiarano alcun ComponentContext
- */
-class ContextAwareDirective {
-    /**
-     * Costruttore
-     *
-     * @ignore
-     */
-    constructor(element, context, ac, ACC_CUSTOMKEY) {
-        this.context = context;
-        this.ac = ac;
-        this.ACC_CUSTOMKEY = ACC_CUSTOMKEY;
-        var allow = !this.context || !this.context.name || !this.ACC_CUSTOMKEY || this.ac.has(this.ACC_CUSTOMKEY + ":" + this.context.name);
-        if (!allow)
-            element.nativeElement.setAttribute("enabled", "true");
-    }
-}
-ContextAwareDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextAwareDirective, deps: [{ token: i0.ElementRef }, { token: ComponentContext, optional: true }, { token: AccessControlService }, { token: ACC_CUSTOMKEY, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-ContextAwareDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: ContextAwareDirective, selector: "[contextAware]", ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ContextAwareDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[contextAware]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: ComponentContext, decorators: [{
-                    type: Optional
-                }] }, { type: AccessControlService }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [ACC_CUSTOMKEY]
+// Angular
+/**
+ * Direttiva che permette di capire se l'elemento HTML su cui è utilizzata dev'essere disabilitato o no.
+ *
+ * Non ha effetto sugli elementi dichiarati in componenti che non dichiarano alcun ComponentContext
+ */
+class ContextAwareDirective {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(element, context, ac, ACC_CUSTOMKEY) {
+        this.context = context;
+        this.ac = ac;
+        this.ACC_CUSTOMKEY = ACC_CUSTOMKEY;
+        var allow = !this.context || !this.context.name || !this.ACC_CUSTOMKEY || this.ac.has(this.ACC_CUSTOMKEY + ":" + this.context.name);
+        if (!allow)
+            element.nativeElement.setAttribute("enabled", "true");
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContextAwareDirective, deps: [{ token: i0.ElementRef }, { token: ComponentContext, optional: true }, { token: AccessControlService }, { token: ACC_CUSTOMKEY, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ContextAwareDirective, selector: "[contextAware]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContextAwareDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[contextAware]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: ComponentContext, decorators: [{
+                    type: Optional
+                }] }, { type: AccessControlService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ACC_CUSTOMKEY]
                 }] }]; } });
 
-// Angular
-/**
- * Pipe che restituisce **true** quando il controllo sugli accessi ha successo, false altrimenti
- *
- * Per gli esempi di utilizzo fare riferimento al README.
- */
-class AccessControlPipe {
-    /** @ignore Costruttore */
-    constructor(_ac) {
-        this._ac = _ac;
-    }
-    /**
-     * Trasforma l'espressione ac in un booleano
-     * @param value Espressione ac
-     * @param absolute Indica se valutare **ac** in maniera assoluta o meno
-     * @returns **true** se la condizione è verificata, **false** altrimenti
-     */
-    transform(value, absolute) {
-        return this._ac.has(value, absolute);
-    }
-}
-AccessControlPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlPipe, deps: [{ token: AccessControlService }], target: i0.ɵɵFactoryTarget.Pipe });
-AccessControlPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: AccessControlPipe, name: "ac" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'ac' }]
+// Angular
+/**
+ * Pipe che restituisce **true** quando il controllo sugli accessi ha successo, false altrimenti
+ *
+ * Per gli esempi di utilizzo fare riferimento al README.
+ */
+class AccessControlPipe {
+    /** @ignore Costruttore */
+    constructor(_ac) {
+        this._ac = _ac;
+    }
+    /**
+     * Trasforma l'espressione ac in un booleano
+     * @param value Espressione ac
+     * @param absolute Indica se valutare **ac** in maniera assoluta o meno
+     * @returns **true** se la condizione è verificata, **false** altrimenti
+     */
+    transform(value, absolute) {
+        return this._ac.has(value, absolute);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlPipe, deps: [{ token: AccessControlService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AccessControlPipe, name: "ac" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'ac' }]
         }], ctorParameters: function () { return [{ type: AccessControlService }]; } });
 
-class AccessControlModule {
-    static forRoot(config) {
-        return {
-            ngModule: AccessControlModule,
-            providers: [
-                { provide: ACC_CUSTOMKEY, useValue: config?.contextAwareKey || null },
-                { provide: ACC_DEF_COND, useValue: config?.defaultCondition || null },
-                { provide: ACC_DEF_COND_OP, useValue: config?.defaultConditionLogicalOperator || '||' },
-                { provide: ACC_DEBUG_MODE, useValue: config?.debugMode || false },
-            ]
-        };
-    }
-}
-AccessControlModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AccessControlModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: AccessControlModule, declarations: [AccessControlDirective, ContextAwareDirective, AccessControlPipe], exports: [AccessControlDirective, ContextAwareDirective, AccessControlPipe] });
-AccessControlModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AccessControlModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [AccessControlDirective, ContextAwareDirective, AccessControlPipe],
-                    exports: [AccessControlDirective, ContextAwareDirective, AccessControlPipe]
-                }]
+class AccessControlModule {
+    static forRoot(config) {
+        return {
+            ngModule: AccessControlModule,
+            providers: [
+                { provide: ACC_CUSTOMKEY, useValue: config?.contextAwareKey || null },
+                { provide: ACC_DEF_COND, useValue: config?.defaultCondition || null },
+                { provide: ACC_DEF_COND_OP, useValue: config?.defaultConditionLogicalOperator || '||' },
+                { provide: ACC_DEBUG_MODE, useValue: config?.debugMode || false },
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AccessControlModule, declarations: [AccessControlDirective, ContextAwareDirective, AccessControlPipe], exports: [AccessControlDirective, ContextAwareDirective, AccessControlPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AccessControlDirective, ContextAwareDirective, AccessControlPipe],
+                    exports: [AccessControlDirective, ContextAwareDirective, AccessControlPipe]
+                }]
         }] });
 
-/**
- * Configurazione Modulo AccessControl. Se non fornita verrà generata automaticamente con locale 'it-IT'
- */
-class AccessControlModuleConfig {
+/**
+ * Configurazione Modulo AccessControl. Se non fornita verrà generata automaticamente con locale 'it-IT'
+ */
+class AccessControlModuleConfig {
 }
 
-/**
- * Router Guard base per proteggere l'accesso alle route dell'applicazione. Per utilizzarla è sufficiente ereditarla e, nel costruttore della classe
- * che la ereditavalorizzare la variabile Routes con le route permesse dal modulo e il permesso per cui si vuole riservare l'accesso. Ad esempio:
- *
- * ```typescript
- * @Injectable()
- * export class HasAuthGuardComponent extends BaseRouterGuard {
- *      constructor(acc: AccessControlService, router: Router, ms: MessageService, ts: BaseTokenService) {
- *          super(ms, acc, router, ts);
- *          this.Routes = [
- *              { route: "page_route", permission: "P:perm_one" },
- *              { route: "*", permission: "R:role_one" }
- *          ]
- *      }
- * }
- * ```
- */
-class AccessControlRouteGuard {
-    /**
-     * @ignore
-     */
-    constructor(msgService, ac, router) {
-        this.msgService = msgService;
-        this.ac = ac;
-        this.router = router;
-        /**
-         * Route di login che serve per reindirizzare alla pagina di login in caso di fallimento del controllo sui Permessi
-         *
-         * @default
-         */
-        this.LoginRoute = "login";
-        /**
-         * Permette di specificare delle Route sempre consentite, anche a livello di "Radice". Ad esempio la Root "test" permetterà
-         * l'accesso a tutte le route che anche solo iniziano per "test"
-         */
-        this.AlwaysAllowedRoots = [];
-        /**
-         * Lista di Route con la loro espressione di controllo per valutare i permessi
-         */
-        this.Routes = [];
-    }
-    /**
-     * @ignore
-     */
-    canActivateChild(route, _) {
-        var url = route.url.join('/');
-        //Se l'applicazione non è pronta e non sto navigando nelle pagine consentite
-        if (!this.ac.Initialized && !this.AlwaysAllowedRoots.find(r => url.indexOf(r) != -1))
-            return Promise.resolve(false);
-        var routeMatched = false;
-        for (let i = 0; i < this.Routes.length; i++) {
-            let r = this.Routes[i];
-            //Se faccio match con la route significa che ho navigato in una delle route conosciute, altrimenti avverto ma lascio andare
-            if (url.indexOf(r.route) != -1) {
-                routeMatched = true;
-                return this.handleMatch(url, r);
-            }
-        }
-        //Se non faccio nessun match ma ho una route wildcard (*) prendo quella e controllo su quella
-        if (!routeMatched) {
-            var wildcardRoute = this.Routes.find(r => r.route == "*");
-            if (wildcardRoute)
-                return this.handleMatch(url, wildcardRoute);
-            else
-                console.log("Navigaizone avvenuta su route sconosciuta: " + url);
-        }
-        return Promise.resolve(true);
-    }
-    /**
-     * @ignore
-     */
-    handleMatch(fromurl, r) {
-        let identity = this.ac.Identity;
-        if (this.ac.has(r.permission) ||
-            (
-            // Considero anche la possibilità di avere l'access control inizializzato ma che l'account scope non sia ancora presente
-            // in questo caso suppongo sia un hard refresh e mi fido del fatto che l'utente possa entrarci
-            // TODO: Fixare meglio concatenando una promise che va a prendere l'account scope se serve
-            this.ac.Initialized &&
-                (!identity.Roles || identity.Roles.length == 0) &&
-                (!identity.Permissions || identity.Permissions.length == 0)))
-            return Promise.resolve(true);
-        else {
-            //Se sono nel sito originale (non ho aperto un newtab) blocco la navigazione
-            //Se ho aperto una nuova tab invece rispedisco al login
-            if (window.history.length > 2 && this.ac.isLoggedIn()) {
-                this.msgService.simpleError("Page Unauthorized");
-                return Promise.resolve(false);
-            }
-            else {
-                this.onRedirectInProgress();
-                this.router.navigate([this.LoginRoute, { fromUrl: fromurl }]);
-            }
-        }
-    }
-    /**
-     * Callback che viene eseguito prima che la Guard reindirizzi al login
-     */
-    onRedirectInProgress() {
-    }
+/**
+ * Router Guard base per proteggere l'accesso alle route dell'applicazione. Per utilizzarla è sufficiente ereditarla e, nel costruttore della classe
+ * che la ereditavalorizzare la variabile Routes con le route permesse dal modulo e il permesso per cui si vuole riservare l'accesso. Ad esempio:
+ *
+ * ```typescript
+ * @Injectable()
+ * export class HasAuthGuardComponent extends BaseRouterGuard {
+ *      constructor(acc: AccessControlService, router: Router, ms: MessageService, ts: BaseTokenService) {
+ *          super(ms, acc, router, ts);
+ *          this.Routes = [
+ *              { route: "page_route", permission: "P:perm_one" },
+ *              { route: "*", permission: "R:role_one" }
+ *          ]
+ *      }
+ * }
+ * ```
+ */
+class AccessControlRouteGuard {
+    /**
+     * @ignore
+     */
+    constructor(msgService, ac, router) {
+        this.msgService = msgService;
+        this.ac = ac;
+        this.router = router;
+        /**
+         * Route di login che serve per reindirizzare alla pagina di login in caso di fallimento del controllo sui Permessi
+         *
+         * @default
+         */
+        this.LoginRoute = "login";
+        /**
+         * Permette di specificare delle Route sempre consentite, anche a livello di "Radice". Ad esempio la Root "test" permetterà
+         * l'accesso a tutte le route che anche solo iniziano per "test"
+         */
+        this.AlwaysAllowedRoots = [];
+        /**
+         * Lista di Route con la loro espressione di controllo per valutare i permessi
+         */
+        this.Routes = [];
+    }
+    /**
+     * @ignore
+     */
+    canActivateChild(route, _) {
+        var url = route.url.join('/');
+        //Se l'applicazione non è pronta e non sto navigando nelle pagine consentite
+        if (!this.ac.Initialized && !this.AlwaysAllowedRoots.find(r => url.indexOf(r) != -1))
+            return Promise.resolve(false);
+        var routeMatched = false;
+        for (let i = 0; i < this.Routes.length; i++) {
+            let r = this.Routes[i];
+            //Se faccio match con la route significa che ho navigato in una delle route conosciute, altrimenti avverto ma lascio andare
+            if (url.indexOf(r.route) != -1) {
+                routeMatched = true;
+                return this.handleMatch(url, r);
+            }
+        }
+        //Se non faccio nessun match ma ho una route wildcard (*) prendo quella e controllo su quella
+        if (!routeMatched) {
+            var wildcardRoute = this.Routes.find(r => r.route == "*");
+            if (wildcardRoute)
+                return this.handleMatch(url, wildcardRoute);
+            else
+                console.log("Navigaizone avvenuta su route sconosciuta: " + url);
+        }
+        return Promise.resolve(true);
+    }
+    /**
+     * @ignore
+     */
+    handleMatch(fromurl, r) {
+        let identity = this.ac.Identity;
+        if (this.ac.has(r.permission) ||
+            (
+            // Considero anche la possibilità di avere l'access control inizializzato ma che l'account scope non sia ancora presente
+            // in questo caso suppongo sia un hard refresh e mi fido del fatto che l'utente possa entrarci
+            // TODO: Fixare meglio concatenando una promise che va a prendere l'account scope se serve
+            this.ac.Initialized &&
+                (!identity.Roles || identity.Roles.length == 0) &&
+                (!identity.Permissions || identity.Permissions.length == 0)))
+            return Promise.resolve(true);
+        else {
+            //Se sono nel sito originale (non ho aperto un newtab) blocco la navigazione
+            //Se ho aperto una nuova tab invece rispedisco al login
+            if (window.history.length > 2 && this.ac.isLoggedIn()) {
+                this.msgService.simpleError("Page Unauthorized");
+                return Promise.resolve(false);
+            }
+            else {
+                this.onRedirectInProgress();
+                this.router.navigate([this.LoginRoute, { fromUrl: fromurl }]);
+            }
+        }
+    }
+    /**
+     * Callback che viene eseguito prima che la Guard reindirizzi al login
+     */
+    onRedirectInProgress() {
+    }
 }
 
-/*
- * Public API Surface of access-control
+/*
+ * Public API Surface of access-control
  */
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { ACC_CUSTOMKEY, ACC_DEBUG_MODE, ACC_DEF_COND, ACC_DEF_COND_OP, AccessControlDirective, AccessControlModule, AccessControlModuleConfig, AccessControlPipe, AccessControlRouteGuard, AccessControlService, ComponentContext, ContextAwareDirective };