general-library-union 2.7.24 → 2.7.26

package/esm2022/src/app/layout/app.menu.component.mjs

@@ -0,0 +1,51 @@
+import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AppMenuitemComponent } from './app.menuitem.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/servicios/menu.service";
+import * as i2 from "../core/servicios/utils.service";
+import * as i3 from "@angular/common";
+export class AppMenuComponent {
+    menuService;
+    utilsService;
+    subcription;
+    model;
+    /**
+     *
+     */
+    constructor(menuService, utilsService) {
+        this.menuService = menuService;
+        this.utilsService = utilsService;
+    }
+    ngOnInit() {
+        if (window.location.href.toString().includes('admonPortal')) {
+            this.model = [{
+                    label: "Inicio",
+                    icon: "pi pi-home",
+                    routerLink: this.utilsService.obtenerBase() + "/admonPortal/inicio",
+                    visible: true,
+                    items: [],
+                }];
+        }
+        else {
+            this.model = [{
+                    label: "Inicio",
+                    icon: "pi pi-home",
+                    routerLink: this.utilsService.obtenerBase() + "/inicio",
+                    visible: true,
+                    items: [],
+                }];
+        }
+        this.subcription = this.menuService.menu.subscribe((menu) => {
+            this.model[0].label = menu.label;
+            this.model[0].items = menu.items;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AppMenuComponent, deps: [{ token: i1.MenuService }, { token: i2.UtilsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.4", type: AppMenuComponent, isStandalone: true, selector: "app-menu", ngImport: i0, template: "<ul class=\"layout-menu\">\n    <ng-container *ngFor=\"let item of model; let i = index;\">\n        <li app-menuitem *ngIf=\"!item.separator\" [item]=\"item\" [index]=\"i\" [root]=\"true\"></li>\n        <li *ngIf=\"item.separator\" class=\"menu-separator\"></li>\n    </ng-container>\n</ul>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: AppMenuitemComponent, selector: "[app-menuitem]", inputs: ["item", "index", "root", "parentKey"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AppMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-menu', imports: [CommonModule, AppMenuitemComponent], standalone: true, template: "<ul class=\"layout-menu\">\n    <ng-container *ngFor=\"let item of model; let i = index;\">\n        <li app-menuitem *ngIf=\"!item.separator\" [item]=\"item\" [index]=\"i\" [root]=\"true\"></li>\n        <li *ngIf=\"item.separator\" class=\"menu-separator\"></li>\n    </ng-container>\n</ul>" }]
+        }], ctorParameters: () => [{ type: i1.MenuService }, { type: i2.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/layout/app.menu.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class MenuService {
+    menuSource = new Subject();
+    resetSource = new Subject();
+    menuSource$ = this.menuSource.asObservable();
+    resetSource$ = this.resetSource.asObservable();
+    onMenuStateChange(event) {
+        this.menuSource.next(event);
+    }
+    reset() {
+        this.resetSource.next(true);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: MenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: MenuService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: MenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLm1lbnUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvbGF5b3V0L2FwcC5tZW51LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQU0vQixNQUFNLE9BQU8sV0FBVztJQUVaLFVBQVUsR0FBRyxJQUFJLE9BQU8sRUFBbUIsQ0FBQztJQUM1QyxXQUFXLEdBQUcsSUFBSSxPQUFPLEVBQUUsQ0FBQztJQUVwQyxXQUFXLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUM3QyxZQUFZLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUUvQyxpQkFBaUIsQ0FBQyxLQUFzQjtRQUNwQyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQsS0FBSztRQUNELElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hDLENBQUM7dUdBZFEsV0FBVzsyR0FBWCxXQUFXLGNBRlIsTUFBTTs7MkZBRVQsV0FBVztrQkFIdkIsVUFBVTttQkFBQztvQkFDUixVQUFVLEVBQUUsTUFBTTtpQkFDckIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBNZW51Q2hhbmdlRXZlbnQgfSBmcm9tICcuL2FwaS9tZW51Y2hhbmdlZXZlbnQnO1xuXG5ASW5qZWN0YWJsZSh7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIE1lbnVTZXJ2aWNlIHtcblxuICAgIHByaXZhdGUgbWVudVNvdXJjZSA9IG5ldyBTdWJqZWN0PE1lbnVDaGFuZ2VFdmVudD4oKTtcbiAgICBwcml2YXRlIHJlc2V0U291cmNlID0gbmV3IFN1YmplY3QoKTtcblxuICAgIG1lbnVTb3VyY2UkID0gdGhpcy5tZW51U291cmNlLmFzT2JzZXJ2YWJsZSgpO1xuICAgIHJlc2V0U291cmNlJCA9IHRoaXMucmVzZXRTb3VyY2UuYXNPYnNlcnZhYmxlKCk7XG5cbiAgICBvbk1lbnVTdGF0ZUNoYW5nZShldmVudDogTWVudUNoYW5nZUV2ZW50KSB7XG4gICAgICAgIHRoaXMubWVudVNvdXJjZS5uZXh0KGV2ZW50KTtcbiAgICB9XG5cbiAgICByZXNldCgpIHtcbiAgICAgICAgdGhpcy5yZXNldFNvdXJjZS5uZXh0KHRydWUpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/src/app/layout/app.menuitem.component.mjs

@@ -0,0 +1,296 @@
+import { Component, HostBinding, Input, ViewChild } from '@angular/core';
+import { NavigationEnd, RouterModule } from '@angular/router';
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { filter } from 'rxjs/operators';
+import { DomHandler } from 'primeng/dom';
+import { CommonModule } from '@angular/common';
+import { TooltipModule } from 'primeng/tooltip';
+import * as i0 from "@angular/core";
+import * as i1 from "./service/app.layout.service";
+import * as i2 from "@angular/router";
+import * as i3 from "./app.menu.service";
+import * as i4 from "../core/servicios/utils.service";
+import * as i5 from "@angular/common";
+import * as i6 from "primeng/tooltip";
+export class AppMenuitemComponent {
+    layoutService;
+    cd;
+    router;
+    menuService;
+    utilsService;
+    item;
+    index;
+    root;
+    parentKey;
+    submenu;
+    active = false;
+    menuSourceSubscription;
+    menuResetSubscription;
+    key = "";
+    url = window.location.href;
+    constructor(layoutService, cd, router, menuService, utilsService) {
+        this.layoutService = layoutService;
+        this.cd = cd;
+        this.router = router;
+        this.menuService = menuService;
+        this.utilsService = utilsService;
+        this.menuSourceSubscription = this.menuService.menuSource$.subscribe(value => {
+            Promise.resolve(null).then(() => {
+                if (value.routeEvent) {
+                    this.active = (value.key === this.key || value.key.startsWith(this.key + '-')) ? true : false;
+                }
+                else {
+                    if (value.key !== this.key && !value.key.startsWith(this.key + '-')) {
+                        this.active = false;
+                    }
+                }
+            });
+        });
+        this.menuResetSubscription = this.menuService.resetSource$.subscribe(() => {
+            this.active = false;
+        });
+        this.router.events.pipe(filter(event => event instanceof NavigationEnd))
+            .subscribe(params => {
+            if (this.isSlimPlus || this.isSlim || this.isHorizontal) {
+                this.active = false;
+            }
+            else {
+                if (this.item.routerLink) {
+                    this.updateActiveStateFromRoute();
+                }
+            }
+        });
+    }
+    ngOnInit() {
+        this.key = this.parentKey ? this.parentKey + '-' + this.index : String(this.index);
+        if (!(this.isSlimPlus || this.isSlim || this.isHorizontal) && this.item.routerLink) {
+            this.updateActiveStateFromRoute();
+        }
+    }
+    ngAfterViewChecked() {
+        if (this.root && this.active && this.layoutService.isDesktop() && (this.layoutService.isHorizontal() || this.layoutService.isSlim() || this.layoutService.isSlimPlus())) {
+            this.calculatePosition(this.submenu?.nativeElement, this.submenu?.nativeElement.parentElement);
+        }
+    }
+    updateActiveStateFromRoute() {
+        let activeRoute = this.router.isActive(this.item.routerLink[0], { paths: 'exact', queryParams: 'ignored', matrixParams: 'ignored', fragment: 'ignored' });
+        if (activeRoute) {
+            this.menuService.onMenuStateChange({ key: this.key, routeEvent: true });
+        }
+    }
+    onSubmenuAnimated(event) {
+        if (event.toState === 'visible' && this.layoutService.isDesktop() && (this.layoutService.isHorizontal() || this.layoutService.isSlim() || this.layoutService.isSlimPlus())) {
+            const el = event.element;
+            const elParent = el.parentElement;
+            this.calculatePosition(el, elParent);
+        }
+    }
+    calculatePosition(overlay, target) {
+        if (overlay) {
+            const { left, top } = target.getBoundingClientRect();
+            const [vWidth, vHeight] = [window.innerWidth, window.innerHeight];
+            const [oWidth, oHeight] = [overlay.offsetWidth, overlay.offsetHeight];
+            const scrollbarWidth = DomHandler.calculateScrollbarWidth();
+            const topbarEl = document.querySelector('.layout-topbar');
+            const topbarHeight = topbarEl?.offsetHeight || 0;
+            // reset
+            overlay.style.top = '';
+            overlay.style.left = '';
+            if (this.layoutService.isHorizontal()) {
+                const width = left + oWidth + scrollbarWidth;
+                overlay.style.left = vWidth < width ? `${left - (width - vWidth)}px` : `${left}px`;
+            }
+            else if (this.layoutService.isSlim() || this.layoutService.isSlimPlus()) {
+                const topOffset = top - topbarHeight;
+                const height = topOffset + oHeight + topbarHeight;
+                overlay.style.top = vHeight < height ? `${topOffset - (height - vHeight)}px` : `${topOffset}px`;
+            }
+        }
+    }
+    itemClick(event) {
+        // avoid processing disabled items
+        if (this.item.disabled) {
+            event.preventDefault();
+            return;
+        }
+        // navigate with hover
+        if (this.root && this.isSlim || this.isHorizontal || this.isSlimPlus) {
+            this.layoutService.state.menuHoverActive = !this.layoutService.state.menuHoverActive;
+        }
+        // execute command
+        if (this.item.command) {
+            this.item.command({ originalEvent: event, item: this.item });
+        }
+        // toggle active state
+        if (this.item.items) {
+            this.active = !this.active;
+            if (this.root && this.active && (this.isSlim || this.isHorizontal || this.isSlimPlus)) {
+                this.layoutService.onOverlaySubmenuOpen();
+            }
+        }
+        else {
+            if (this.layoutService.isMobile()) {
+                this.layoutService.state.staticMenuMobileActive = false;
+            }
+            if (this.isSlim || this.isHorizontal || this.isSlimPlus) {
+                this.menuService.reset();
+                this.layoutService.state.menuHoverActive = false;
+            }
+        }
+        this.menuService.onMenuStateChange({ key: this.key });
+    }
+    onMouseEnter() {
+        // activate item on hover
+        if (this.root && (this.isSlim || this.isHorizontal || this.isSlimPlus) && this.layoutService.isDesktop()) {
+            if (this.layoutService.state.menuHoverActive) {
+                this.active = true;
+                this.menuService.onMenuStateChange({ key: this.key });
+            }
+        }
+    }
+    get submenuAnimation() {
+        if (this.layoutService.isDesktop() && (this.layoutService.isHorizontal() || this.layoutService.isSlim() || this.layoutService.isSlimPlus()))
+            return this.active ? 'visible' : 'hidden';
+        else
+            return this.root ? 'expanded' : (this.active ? 'expanded' : 'collapsed');
+    }
+    get isHorizontal() {
+        return this.layoutService.isHorizontal();
+    }
+    get isSlim() {
+        return this.layoutService.isSlim();
+    }
+    get isSlimPlus() {
+        return this.layoutService.isSlimPlus();
+    }
+    get activeClass() {
+        return this.active && !this.root;
+    }
+    ngOnDestroy() {
+        if (this.menuSourceSubscription) {
+            this.menuSourceSubscription.unsubscribe();
+        }
+        if (this.menuResetSubscription) {
+            this.menuResetSubscription.unsubscribe();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AppMenuitemComponent, deps: [{ token: i1.LayoutService }, { token: i0.ChangeDetectorRef }, { token: i2.Router }, { token: i3.MenuService }, { token: i4.UtilsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.4", type: AppMenuitemComponent, isStandalone: true, selector: "[app-menuitem]", inputs: { item: "item", index: "index", root: "root", parentKey: "parentKey" }, host: { properties: { "class.layout-root-menuitem": "this.root", "class.active-menuitem": "this.activeClass" } }, viewQueries: [{ propertyName: "submenu", first: true, predicate: ["submenu"], descendants: true }], ngImport: i0, template: `
+		<ng-container>
+            <div *ngIf="root && item.visible !== false" class="layout-menuitem-root-text">
+                <span>{{item.label}}</span>
+                <i class="layout-menuitem-root-icon pi pi-fw pi-ellipsis-h"></i>
+            </div>
+			<a *ngIf="(!item.routerLink || item.items) && item.visible !== false" [attr.href]="item.url" (click)="itemClick($event)"  (mouseenter)="onMouseEnter()"
+			   [ngClass]="item.class" [attr.target]="item.target" tabindex="0" pRipple [pTooltip]="item.label" [tooltipDisabled]="!(isSlim && root && !active)">
+				<i [ngClass]="item.icon" class="layout-menuitem-icon"></i>
+				<span class="layout-menuitem-text">{{item.label}}</span>
+				<i class="pi pi-fw pi-angle-down layout-submenu-toggler" *ngIf="item.items"></i>
+			</a>
+			<a *ngIf="(item.routerLink && !item.items) && item.visible !== false" (click)="itemClick($event)" (mouseenter)="onMouseEnter()" [ngClass]="item.class"
+			   [routerLink]="'/'+utilsService.obtenerBase()+ (url.toString().includes('admonPortal') ? '/admonPortal' : '') +item.routerLink" routerLinkActive="active-route" [routerLinkActiveOptions]="item.routerLinkActiveOptions||{ paths: 'exact', queryParams: 'ignored', matrixParams: 'ignored', fragment: 'ignored' }"
+               [fragment]="item.fragment" [queryParamsHandling]="item.queryParamsHandling" [preserveFragment]="item.preserveFragment"
+               [skipLocationChange]="item.skipLocationChange" [replaceUrl]="item.replaceUrl" [state]="item.state" [queryParams]="item.queryParams"
+               [attr.target]="item.target" tabindex="0" pRipple [pTooltip]="item.label" [tooltipDisabled]="!(isSlim && root)">
+				<i [ngClass]="item.icon" class="layout-menuitem-icon"></i>
+				<span class="layout-menuitem-text">{{item.label}}</span>
+				<i class="pi pi-fw pi-angle-down layout-submenu-toggler" *ngIf="item.items"></i>
+			</a>
+
+			<ul #submenu *ngIf="item.items && item.visible !== false" [@children]="submenuAnimation" (@children.done)="onSubmenuAnimated($event)">
+				<ng-template ngFor let-child let-i="index" [ngForOf]="item.items">
+					<li app-menuitem [item]="child" [index]="i" [parentKey]="key" [class]="child.badgeClass"></li>
+				</ng-template>
+			</ul>
+		</ng-container>
+    `, isInline: true, dependencies: [{ kind: "component", type: AppMenuitemComponent, selector: "[app-menuitem]", inputs: ["item", "index", "root", "parentKey"] }, { kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: RouterModule }, { kind: "directive", type: i2.RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "directive", type: i2.RouterLinkActive, selector: "[routerLinkActive]", inputs: ["routerLinkActiveOptions", "ariaCurrentWhenActive", "routerLinkActive"], outputs: ["isActiveChange"], exportAs: ["routerLinkActive"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i6.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }], animations: [
+            trigger('children', [
+                state('collapsed', style({
+                    height: '0'
+                })),
+                state('expanded', style({
+                    height: '*'
+                })),
+                state('hidden', style({
+                    display: 'none'
+                })),
+                state('visible', style({
+                    display: 'block'
+                })),
+                transition('collapsed <=> expanded', animate('400ms cubic-bezier(0.86, 0, 0.07, 1)'))
+            ])
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AppMenuitemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: '[app-menuitem]',
+                    standalone: true,
+                    imports: [CommonModule, RouterModule, TooltipModule],
+                    template: `
+		<ng-container>
+            <div *ngIf="root && item.visible !== false" class="layout-menuitem-root-text">
+                <span>{{item.label}}</span>
+                <i class="layout-menuitem-root-icon pi pi-fw pi-ellipsis-h"></i>
+            </div>
+			<a *ngIf="(!item.routerLink || item.items) && item.visible !== false" [attr.href]="item.url" (click)="itemClick($event)"  (mouseenter)="onMouseEnter()"
+			   [ngClass]="item.class" [attr.target]="item.target" tabindex="0" pRipple [pTooltip]="item.label" [tooltipDisabled]="!(isSlim && root && !active)">
+				<i [ngClass]="item.icon" class="layout-menuitem-icon"></i>
+				<span class="layout-menuitem-text">{{item.label}}</span>
+				<i class="pi pi-fw pi-angle-down layout-submenu-toggler" *ngIf="item.items"></i>
+			</a>
+			<a *ngIf="(item.routerLink && !item.items) && item.visible !== false" (click)="itemClick($event)" (mouseenter)="onMouseEnter()" [ngClass]="item.class"
+			   [routerLink]="'/'+utilsService.obtenerBase()+ (url.toString().includes('admonPortal') ? '/admonPortal' : '') +item.routerLink" routerLinkActive="active-route" [routerLinkActiveOptions]="item.routerLinkActiveOptions||{ paths: 'exact', queryParams: 'ignored', matrixParams: 'ignored', fragment: 'ignored' }"
+               [fragment]="item.fragment" [queryParamsHandling]="item.queryParamsHandling" [preserveFragment]="item.preserveFragment"
+               [skipLocationChange]="item.skipLocationChange" [replaceUrl]="item.replaceUrl" [state]="item.state" [queryParams]="item.queryParams"
+               [attr.target]="item.target" tabindex="0" pRipple [pTooltip]="item.label" [tooltipDisabled]="!(isSlim && root)">
+				<i [ngClass]="item.icon" class="layout-menuitem-icon"></i>
+				<span class="layout-menuitem-text">{{item.label}}</span>
+				<i class="pi pi-fw pi-angle-down layout-submenu-toggler" *ngIf="item.items"></i>
+			</a>
+
+			<ul #submenu *ngIf="item.items && item.visible !== false" [@children]="submenuAnimation" (@children.done)="onSubmenuAnimated($event)">
+				<ng-template ngFor let-child let-i="index" [ngForOf]="item.items">
+					<li app-menuitem [item]="child" [index]="i" [parentKey]="key" [class]="child.badgeClass"></li>
+				</ng-template>
+			</ul>
+		</ng-container>
+    `,
+                    animations: [
+                        trigger('children', [
+                            state('collapsed', style({
+                                height: '0'
+                            })),
+                            state('expanded', style({
+                                height: '*'
+                            })),
+                            state('hidden', style({
+                                display: 'none'
+                            })),
+                            state('visible', style({
+                                display: 'block'
+                            })),
+                            transition('collapsed <=> expanded', animate('400ms cubic-bezier(0.86, 0, 0.07, 1)'))
+                        ])
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i1.LayoutService }, { type: i0.ChangeDetectorRef }, { type: i2.Router }, { type: i3.MenuService }, { type: i4.UtilsService }], propDecorators: { item: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], root: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.layout-root-menuitem']
+            }], parentKey: [{
+                type: Input
+            }], submenu: [{
+                type: ViewChild,
+                args: ['submenu']
+            }], activeClass: [{
+                type: HostBinding,
+                args: ['class.active-menuitem']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.menuitem.component.js","sourceRoot":"","sources":["../../../../../src/app/layout/app.menuitem.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, ElementRef, HostBinding, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';\nimport { NavigationEnd, Router, RouterModule } from '@angular/router';\nimport { animate, AnimationEvent, state, style, transition, trigger } from '@angular/animations';\nimport { Subscription } from 'rxjs';\nimport { filter } from 'rxjs/operators';\nimport { MenuService } from './app.menu.service';\nimport { LayoutService } from './service/app.layout.service';\nimport {DomHandler} from 'primeng/dom';\nimport { UtilsService } from '../core/servicios/utils.service';\nimport { CommonModule } from '@angular/common';\nimport { TooltipModule } from 'primeng/tooltip';\n\n@Component({\n    // eslint-disable-next-line @angular-eslint/component-selector\n    selector: '[app-menuitem]',\n    standalone: true,\n    imports: [CommonModule, RouterModule, TooltipModule],\n    template: `\n\t\t<ng-container>\n            <div *ngIf=\"root && item.visible !== false\" class=\"layout-menuitem-root-text\">\n                <span>{{item.label}}</span>\n                <i class=\"layout-menuitem-root-icon pi pi-fw pi-ellipsis-h\"></i>\n            </div>\n\t\t\t<a *ngIf=\"(!item.routerLink || item.items) && item.visible !== false\" [attr.href]=\"item.url\" (click)=\"itemClick($event)\"  (mouseenter)=\"onMouseEnter()\"\n\t\t\t   [ngClass]=\"item.class\" [attr.target]=\"item.target\" tabindex=\"0\" pRipple [pTooltip]=\"item.label\" [tooltipDisabled]=\"!(isSlim && root && !active)\">\n\t\t\t\t<i [ngClass]=\"item.icon\" class=\"layout-menuitem-icon\"></i>\n\t\t\t\t<span class=\"layout-menuitem-text\">{{item.label}}</span>\n\t\t\t\t<i class=\"pi pi-fw pi-angle-down layout-submenu-toggler\" *ngIf=\"item.items\"></i>\n\t\t\t</a>\n\t\t\t<a *ngIf=\"(item.routerLink && !item.items) && item.visible !== false\" (click)=\"itemClick($event)\" (mouseenter)=\"onMouseEnter()\" [ngClass]=\"item.class\"\n\t\t\t   [routerLink]=\"'/'+utilsService.obtenerBase()+ (url.toString().includes('admonPortal') ? '/admonPortal' : '') +item.routerLink\" routerLinkActive=\"active-route\" [routerLinkActiveOptions]=\"item.routerLinkActiveOptions||{ paths: 'exact', queryParams: 'ignored', matrixParams: 'ignored', fragment: 'ignored' }\"\n               [fragment]=\"item.fragment\" [queryParamsHandling]=\"item.queryParamsHandling\" [preserveFragment]=\"item.preserveFragment\"\n               [skipLocationChange]=\"item.skipLocationChange\" [replaceUrl]=\"item.replaceUrl\" [state]=\"item.state\" [queryParams]=\"item.queryParams\"\n               [attr.target]=\"item.target\" tabindex=\"0\" pRipple [pTooltip]=\"item.label\" [tooltipDisabled]=\"!(isSlim && root)\">\n\t\t\t\t<i [ngClass]=\"item.icon\" class=\"layout-menuitem-icon\"></i>\n\t\t\t\t<span class=\"layout-menuitem-text\">{{item.label}}</span>\n\t\t\t\t<i class=\"pi pi-fw pi-angle-down layout-submenu-toggler\" *ngIf=\"item.items\"></i>\n\t\t\t</a>\n\n\t\t\t<ul #submenu *ngIf=\"item.items && item.visible !== false\" [@children]=\"submenuAnimation\" (@children.done)=\"onSubmenuAnimated($event)\">\n\t\t\t\t<ng-template ngFor let-child let-i=\"index\" [ngForOf]=\"item.items\">\n\t\t\t\t\t<li app-menuitem [item]=\"child\" [index]=\"i\" [parentKey]=\"key\" [class]=\"child.badgeClass\"></li>\n\t\t\t\t</ng-template>\n\t\t\t</ul>\n\t\t</ng-container>\n    `,\n    animations: [\n        trigger('children', [\n            state('collapsed', style({\n                height: '0'\n            })),\n            state('expanded', style({\n                height: '*'\n            })),\n            state('hidden', style({\n                display: 'none'\n            })),\n            state('visible', style({\n                display: 'block'\n            })),\n            transition('collapsed <=> expanded', animate('400ms cubic-bezier(0.86, 0, 0.07, 1)'))\n        ])\n    ]\n})\nexport class AppMenuitemComponent implements OnInit, OnDestroy {\n\n    @Input() item: any;\n\n    @Input() index!: number;\n\n    @Input() @HostBinding('class.layout-root-menuitem') root!: boolean;\n\n    @Input() parentKey!: string;\n\n    @ViewChild('submenu') submenu!: ElementRef;\n\n    active = false;\n\n    menuSourceSubscription: Subscription;\n\n    menuResetSubscription: Subscription;\n\n    key: string = \"\";\n\n    url = window.location.href;\n\n    constructor(public layoutService: LayoutService, private cd: ChangeDetectorRef, public router: Router, private menuService: MenuService, public utilsService: UtilsService) {\n        this.menuSourceSubscription = this.menuService.menuSource$.subscribe(value => {\n            Promise.resolve(null).then(() => {\n                if (value.routeEvent) {\n                    this.active = (value.key === this.key || value.key.startsWith(this.key + '-')) ? true : false;\n                }\n                else {\n                    if (value.key !== this.key && !value.key.startsWith(this.key + '-')) {\n                        this.active = false;\n                    }\n                }\n            });\n        });\n\n        this.menuResetSubscription = this.menuService.resetSource$.subscribe(() => {\n            this.active = false;\n        });\n\n        this.router.events.pipe(filter(event => event instanceof NavigationEnd))\n            .subscribe(params => {\n                if (this.isSlimPlus || this.isSlim || this.isHorizontal) {\n                    this.active = false;\n                }\n                else {\n                    if (this.item.routerLink) {\n                        this.updateActiveStateFromRoute();\n                    }\n                }\n            });\n    }\n\n    ngOnInit() {\n        this.key = this.parentKey ? this.parentKey + '-' + this.index : String(this.index);\n\n        if (!(this.isSlimPlus || this.isSlim || this.isHorizontal) && this.item.routerLink) {\n            this.updateActiveStateFromRoute();\n        }\n    }\n\n    ngAfterViewChecked() {\n        if (this.root && this.active && this.layoutService.isDesktop() && (this.layoutService.isHorizontal() || this.layoutService.isSlim()|| this.layoutService.isSlimPlus())) {\n            this.calculatePosition(this.submenu?.nativeElement, this.submenu?.nativeElement.parentElement);\n        }\n    }\n\n    updateActiveStateFromRoute() {\n        let activeRoute = this.router.isActive(this.item.routerLink[0], { paths: 'exact', queryParams: 'ignored', matrixParams: 'ignored', fragment: 'ignored' });\n\n        if (activeRoute) {\n            this.menuService.onMenuStateChange({key: this.key, routeEvent: true});\n        }\n    }\n\n    onSubmenuAnimated(event: AnimationEvent) {\n        if (event.toState === 'visible' && this.layoutService.isDesktop() && (this.layoutService.isHorizontal() || this.layoutService.isSlim()|| this.layoutService.isSlimPlus())) {\n            const el = <HTMLUListElement> event.element;\n            const elParent = <HTMLUListElement> el.parentElement;\n            this.calculatePosition(el, elParent);\n        }\n    }\n\n    calculatePosition(overlay: HTMLElement, target: HTMLElement) {\n        if (overlay) {\n            const { left, top } = target.getBoundingClientRect();\n            const [vWidth, vHeight] = [window.innerWidth, window.innerHeight];\n            const [oWidth, oHeight] = [overlay.offsetWidth, overlay.offsetHeight];\n            const scrollbarWidth = DomHandler.calculateScrollbarWidth();\n            const topbarEl = document.querySelector('.layout-topbar') as HTMLElement;\n            const topbarHeight = topbarEl?.offsetHeight || 0;\n            // reset\n            overlay.style.top = '';\n            overlay.style.left = '';\n\n            if (this.layoutService.isHorizontal()) {\n                const width = left + oWidth + scrollbarWidth;\n                overlay.style.left = vWidth < width ? `${left - (width - vWidth)}px` : `${left}px`;\n            } else if ( this.layoutService.isSlim() || this.layoutService.isSlimPlus()) {\n                const topOffset = top - topbarHeight;\n                const height = topOffset + oHeight + topbarHeight;\n                overlay.style.top = vHeight < height ? `${topOffset - (height - vHeight)}px` : `${topOffset}px`;\n            }\n        }\n    }\n\n    itemClick(event: Event) {\n        // avoid processing disabled items\n        if (this.item.disabled) {\n            event.preventDefault();\n            return;\n        }\n\n        // navigate with hover\n        if (this.root && this.isSlim || this.isHorizontal || this.isSlimPlus) {\n            this.layoutService.state.menuHoverActive = !this.layoutService.state.menuHoverActive;\n        }\n\n        // execute command\n        if (this.item.command) {\n            this.item.command({ originalEvent: event, item: this.item });\n        }\n\n        // toggle active state\n        if (this.item.items) {\n            this.active = !this.active;\n\n            if (this.root && this.active && (this.isSlim || this.isHorizontal || this.isSlimPlus)) {\n                this.layoutService.onOverlaySubmenuOpen();\n            }\n        }\n        else {\n            if (this.layoutService.isMobile()) {\n                this.layoutService.state.staticMenuMobileActive = false;\n            }\n\n            if (this.isSlim || this.isHorizontal || this.isSlimPlus) {\n                this.menuService.reset();\n                this.layoutService.state.menuHoverActive = false;\n            }\n        }\n\n        this.menuService.onMenuStateChange({key: this.key});\n    }\n\n    onMouseEnter() {\n        // activate item on hover\n        if (this.root && (this.isSlim || this.isHorizontal || this.isSlimPlus) && this.layoutService.isDesktop()) {\n            if (this.layoutService.state.menuHoverActive) {\n                this.active = true;\n                this.menuService.onMenuStateChange({key: this.key});\n            }\n        }\n    }\n\n    get submenuAnimation() {\n        if (this.layoutService.isDesktop() && (this.layoutService.isHorizontal() || this.layoutService.isSlim()|| this.layoutService.isSlimPlus()))\n            return this.active ? 'visible' : 'hidden';\n        else\n            return this.root ? 'expanded' : (this.active ? 'expanded' : 'collapsed');\n    }\n\n    get isHorizontal() {\n        return this.layoutService.isHorizontal();\n    }\n\n    get isSlim() {\n        return this.layoutService.isSlim();\n    }\n    get isSlimPlus() {\n        return this.layoutService.isSlimPlus();\n    }\n\n    @HostBinding('class.active-menuitem')\n    get activeClass() {\n        return this.active && !this.root;\n    }\n\n    ngOnDestroy() {\n        if (this.menuSourceSubscription) {\n            this.menuSourceSubscription.unsubscribe();\n        }\n\n        if (this.menuResetSubscription) {\n            this.menuResetSubscription.unsubscribe();\n        }\n    }\n}\n"]}

package/esm2022/src/app/layout/app.menuprofile.component.mjs

@@ -0,0 +1,78 @@
+import { Component } from '@angular/core';
+import { trigger, transition, style, animate } from '@angular/animations';
+import { TooltipModule } from 'primeng/tooltip';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "./service/app.layout.service";
+import * as i2 from "../core/servicios/auth.service";
+import * as i3 from "primeng/tooltip";
+import * as i4 from "@angular/common";
+export class AppMenuProfileComponent {
+    layoutService;
+    el;
+    authService;
+    constructor(layoutService, el, authService) {
+        this.layoutService = layoutService;
+        this.el = el;
+        this.authService = authService;
+    }
+    toggleMenu() {
+        this.layoutService.onMenuProfileToggle();
+    }
+    get isHorizontal() {
+        return this.layoutService.isHorizontal() && this.layoutService.isDesktop();
+    }
+    get menuProfileActive() {
+        return this.layoutService.state.menuProfileActive;
+    }
+    get menuProfilePosition() {
+        return this.layoutService.config.menuProfilePosition;
+    }
+    get isTooltipDisabled() {
+        return !this.layoutService.isSlim();
+    }
+    get nombreUsuario() {
+        return this.authService.getTokenKey('nombreUsuario');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AppMenuProfileComponent, deps: [{ token: i1.LayoutService }, { token: i0.ElementRef }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.4", type: AppMenuProfileComponent, isStandalone: true, selector: "app-menu-profile", ngImport: i0, template: "<div class=\"layout-menu-profile\">\n    <button class=\"p-link\" pTooltip=\"Profile\" [tooltipDisabled]=\"isTooltipDisabled\">\n        <span>\n            <strong>{{nombreUsuario}}</strong>\n        </span>\n        <i class=\"layout-menu-profile-toggler pi pi-fw\" [ngClass]=\"{'pi-user': menuProfilePosition === 'start' || isHorizontal, 'pi-users': menuProfilePosition === 'end' && !isHorizontal}\"></i>\n    </button>\n\n    <!--<ul *ngIf=\"menuProfileActive\" [@menu]=\"isHorizontal ? 'overlay' : 'inline'\">\n        <li pTooltip=\"Settings\" [tooltipDisabled]=\"isTooltipDisabled\" [routerLink]=\"['/profile/create']\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-cog pi-fw\"></i>\n                <span>Settings</span>\n            </button>\n        </li>\n        <li pTooltip=\"Profile\" [tooltipDisabled]=\"isTooltipDisabled\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-file-o pi-fw\"></i>\n                <span>Profile</span>\n            </button>\n        </li>\n        <li pTooltip=\"Support\" [tooltipDisabled]=\"isTooltipDisabled\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-compass pi-fw\"></i>\n                <span>Support</span>\n            </button>\n        </li>\n        <li pTooltip=\"Logout\" [tooltipDisabled]=\"isTooltipDisabled\" [routerLink]=\"['/auth/login2']\">\n            <button class=\"p-link\">\n                <i class=\"pi pi-power-off pi-fw\"></i>\n                <span>Logout</span>\n            </button>\n        </li>\n    </ul>-->\n</div>\n", dependencies: [{ kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i3.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], animations: [
+            trigger('menu', [
+                transition('void => inline', [
+                    style({ height: 0 }),
+                    animate('400ms cubic-bezier(0.86, 0, 0.07, 1)', style({ opacity: 1, height: '*' })),
+                ]),
+                transition('inline => void', [
+                    animate('400ms cubic-bezier(0.86, 0, 0.07, 1)', style({ opacity: 0, height: '0' }))
+                ]),
+                transition('void => overlay', [
+                    style({ opacity: 0, transform: 'scaleY(0.8)' }),
+                    animate('.12s cubic-bezier(0, 0, 0.2, 1)')
+                ]),
+                transition('overlay => void', [
+                    animate('.1s linear', style({ opacity: 0 }))
+                ])
+            ])
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AppMenuProfileComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-menu-profile', imports: [TooltipModule, CommonModule], standalone: true, animations: [
+                        trigger('menu', [
+                            transition('void => inline', [
+                                style({ height: 0 }),
+                                animate('400ms cubic-bezier(0.86, 0, 0.07, 1)', style({ opacity: 1, height: '*' })),
+                            ]),
+                            transition('inline => void', [
+                                animate('400ms cubic-bezier(0.86, 0, 0.07, 1)', style({ opacity: 0, height: '0' }))
+                            ]),
+                            transition('void => overlay', [
+                                style({ opacity: 0, transform: 'scaleY(0.8)' }),
+                                animate('.12s cubic-bezier(0, 0, 0.2, 1)')
+                            ]),
+                            transition('overlay => void', [
+                                animate('.1s linear', style({ opacity: 0 }))
+                            ])
+                        ])
+                    ], template: "<div class=\"layout-menu-profile\">\n    <button class=\"p-link\" pTooltip=\"Profile\" [tooltipDisabled]=\"isTooltipDisabled\">\n        <span>\n            <strong>{{nombreUsuario}}</strong>\n        </span>\n        <i class=\"layout-menu-profile-toggler pi pi-fw\" [ngClass]=\"{'pi-user': menuProfilePosition === 'start' || isHorizontal, 'pi-users': menuProfilePosition === 'end' && !isHorizontal}\"></i>\n    </button>\n\n    <!--<ul *ngIf=\"menuProfileActive\" [@menu]=\"isHorizontal ? 'overlay' : 'inline'\">\n        <li pTooltip=\"Settings\" [tooltipDisabled]=\"isTooltipDisabled\" [routerLink]=\"['/profile/create']\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-cog pi-fw\"></i>\n                <span>Settings</span>\n            </button>\n        </li>\n        <li pTooltip=\"Profile\" [tooltipDisabled]=\"isTooltipDisabled\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-file-o pi-fw\"></i>\n                <span>Profile</span>\n            </button>\n        </li>\n        <li pTooltip=\"Support\" [tooltipDisabled]=\"isTooltipDisabled\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-compass pi-fw\"></i>\n                <span>Support</span>\n            </button>\n        </li>\n        <li pTooltip=\"Logout\" [tooltipDisabled]=\"isTooltipDisabled\" [routerLink]=\"['/auth/login2']\">\n            <button class=\"p-link\">\n                <i class=\"pi pi-power-off pi-fw\"></i>\n                <span>Logout</span>\n            </button>\n        </li>\n    </ul>-->\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i1.LayoutService }, { type: i0.ElementRef }, { type: i2.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.menuprofile.component.js","sourceRoot":"","sources":["../../../../../src/app/layout/app.menuprofile.component.ts","../../../../../src/app/layout/app.menuprofile.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef } from '@angular/core';\nimport { trigger, transition, style, animate } from '@angular/animations';\nimport { LayoutService } from './service/app.layout.service';\nimport { AuthService } from '../core/servicios/auth.service';\nimport { TooltipModule } from 'primeng/tooltip';\nimport { CommonModule } from '@angular/common';\n\n@Component({\n    selector: 'app-menu-profile',\n    imports: [TooltipModule, CommonModule],\n    standalone: true,\n    templateUrl: './app.menuprofile.component.html',\n    animations: [\n        trigger('menu', [\n            transition('void => inline', [\n                style({ height: 0 }),\n                animate('400ms cubic-bezier(0.86, 0, 0.07, 1)', style({ opacity: 1, height: '*' })),\n            ]),\n            transition('inline => void', [\n                animate('400ms cubic-bezier(0.86, 0, 0.07, 1)', style({ opacity: 0, height: '0' }))\n            ]),\n            transition('void => overlay', [\n                style({ opacity: 0, transform: 'scaleY(0.8)' }),\n                animate('.12s cubic-bezier(0, 0, 0.2, 1)')\n            ]),\n            transition('overlay => void', [\n                animate('.1s linear', style({ opacity: 0 }))\n            ])\n        ])\n    ]\n})\nexport class AppMenuProfileComponent {\n\n    constructor(public layoutService: LayoutService, public el: ElementRef,\n                public authService: AuthService) { }\n\n    toggleMenu() {\n        this.layoutService.onMenuProfileToggle();\n    }\n\n    get isHorizontal() {\n       return this.layoutService.isHorizontal() && this.layoutService.isDesktop();\n    }\n\n    get menuProfileActive(): boolean {\n        return this.layoutService.state.menuProfileActive;\n    }\n\n    get menuProfilePosition(): string {\n        return this.layoutService.config.menuProfilePosition;\n    }\n\n    get isTooltipDisabled(): boolean {\n        return !this.layoutService.isSlim();\n    }\n\n    get nombreUsuario(): string {\n        return this.authService.getTokenKey('nombreUsuario')\n    }\n}\n","<div class=\"layout-menu-profile\">\n    <button class=\"p-link\" pTooltip=\"Profile\" [tooltipDisabled]=\"isTooltipDisabled\">\n        <span>\n            <strong>{{nombreUsuario}}</strong>\n        </span>\n        <i class=\"layout-menu-profile-toggler pi pi-fw\" [ngClass]=\"{'pi-user': menuProfilePosition === 'start' || isHorizontal, 'pi-users': menuProfilePosition === 'end' && !isHorizontal}\"></i>\n    </button>\n\n    <!--<ul *ngIf=\"menuProfileActive\" [@menu]=\"isHorizontal ? 'overlay' : 'inline'\">\n        <li pTooltip=\"Settings\" [tooltipDisabled]=\"isTooltipDisabled\" [routerLink]=\"['/profile/create']\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-cog pi-fw\"></i>\n                <span>Settings</span>\n            </button>\n        </li>\n        <li pTooltip=\"Profile\" [tooltipDisabled]=\"isTooltipDisabled\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-file-o pi-fw\"></i>\n                <span>Profile</span>\n            </button>\n        </li>\n        <li pTooltip=\"Support\" [tooltipDisabled]=\"isTooltipDisabled\">\n            <button class=\"p-link\" [routerLink]=\"['/documentation']\">\n                <i class=\"pi pi-compass pi-fw\"></i>\n                <span>Support</span>\n            </button>\n        </li>\n        <li pTooltip=\"Logout\" [tooltipDisabled]=\"isTooltipDisabled\" [routerLink]=\"['/auth/login2']\">\n            <button class=\"p-link\">\n                <i class=\"pi pi-power-off pi-fw\"></i>\n                <span>Logout</span>\n            </button>\n        </li>\n    </ul>-->\n</div>\n"]}