@rxap/layout 15.0.0 → 16.0.0-dev.0

package/esm2022/lib/navigation/navigation.component.mjs

@@ -0,0 +1,131 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ChangeDetectionStrategy, Input, ChangeDetectorRef, ViewEncapsulation, HostBinding, Inject } from '@angular/core';
+import { Required, coerceBoolean } from '@rxap/utilities';
+import { NavigationService } from './navigation.service';
+import { tap } from 'rxjs/operators';
+import { SidenavComponentService } from '../sidenav/sidenav.component.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/flex-layout/flex";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/divider";
+import * as i4 from "./navigation-item/navigation-item.component";
+import * as i5 from "./navigation.service";
+import * as i6 from "../sidenav/sidenav.component.service";
+const _c0 = ["rxap-navigation", ""];
+function NavigationComponent_ng_template_0_ng_template_0_div_1_span_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r1 = i0.ɵɵnextContext(3).$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(item_r1.title);
+} }
+function NavigationComponent_ng_template_0_ng_template_0_div_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 4);
+    i0.ɵɵtemplate(1, NavigationComponent_ng_template_0_ng_template_0_div_1_span_1_Template, 2, 1, "span", 5);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const item_r1 = i0.ɵɵnextContext(2).$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", item_r1.title);
+} }
+function NavigationComponent_ng_template_0_ng_template_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider", 2);
+    i0.ɵɵtemplate(1, NavigationComponent_ng_template_0_ng_template_0_div_1_Template, 2, 1, "div", 3);
+    i0.ɵɵpipe(2, "async");
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", !i0.ɵɵpipeBind1(2, 1, ctx_r2.sidenav.collapsed$));
+} }
+function NavigationComponent_ng_template_0_ng_template_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "li", 6);
+} if (rf & 2) {
+    const item_r1 = i0.ɵɵnextContext().$implicit;
+    const ctx_r3 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("level", ctx_r3.level)("item", ctx_r3.asNavigationItem(item_r1));
+} }
+function NavigationComponent_ng_template_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, NavigationComponent_ng_template_0_ng_template_0_Template, 3, 3, "ng-template", 1);
+    i0.ɵɵtemplate(1, NavigationComponent_ng_template_0_ng_template_1_Template, 1, 2, "ng-template", 1);
+} if (rf & 2) {
+    const item_r1 = ctx.$implicit;
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngIf", ctx_r0.isNavigationDividerItem(item_r1));
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.isNavigationItem(item_r1));
+} }
+class NavigationComponent {
+    set root(value) {
+        this._root = coerceBoolean(value);
+    }
+    constructor(navigationService, cdr, sidenav) {
+        this.navigationService = navigationService;
+        this.cdr = cdr;
+        this.sidenav = sidenav;
+        this._root = false;
+        this.level = 0;
+    }
+    ngOnInit() {
+        if (this._root) {
+            this.items = [];
+            this.subscription = this.navigationService.config$
+                .pipe(tap((navigation) => (this.items = navigation)), tap(() => this.cdr.detectChanges()))
+                .subscribe();
+        }
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    // region type save item property
+    // required to check the type of the item property in the ngFor loop
+    isNavigationDividerItem(item) {
+        return item['divider'];
+    }
+    isNavigationItem(item) {
+        return !this.isNavigationDividerItem(item);
+    }
+    asNavigationItem(item) {
+        if (!this.isNavigationItem(item)) {
+            throw new Error('The item is not a NavigationItem');
+        }
+        return item;
+    }
+    static { this.ɵfac = function NavigationComponent_Factory(t) { return new (t || NavigationComponent)(i0.ɵɵdirectiveInject(NavigationService), i0.ɵɵdirectiveInject(ChangeDetectorRef), i0.ɵɵdirectiveInject(SidenavComponentService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: NavigationComponent, selectors: [["ul", "rxap-navigation", ""]], hostAttrs: [1, "rxap-navigation"], hostVars: 2, hostBindings: function NavigationComponent_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵclassProp("rxap-root-navigation", ctx._root);
+        } }, inputs: { root: "root", items: "items", level: "level" }, attrs: _c0, decls: 1, vars: 1, consts: [["ngFor", "", 3, "ngForOf"], [3, "ngIf"], ["fxFlex", "nogrow"], ["class", "divider-title", "fxFlex", "nogrow", "fxLayout", "row", "fxLayoutAlign", "start end", 4, "ngIf"], ["fxFlex", "nogrow", "fxLayout", "row", "fxLayoutAlign", "start end", 1, "divider-title"], ["fxFlex", "nogrow", 4, "ngIf"], ["rxap-navigation-item", "", 1, "item", 3, "level", "item"]], template: function NavigationComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, NavigationComponent_ng_template_0_Template, 2, 2, "ng-template", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngForOf", ctx.items);
+        } }, dependencies: [i1.DefaultLayoutDirective, i1.DefaultLayoutAlignDirective, i1.DefaultFlexDirective, i2.NgForOf, i2.NgIf, i3.MatDivider, i4.NavigationItemComponent, i2.AsyncPipe], styles: [".rxap-navigation{list-style-type:none;padding:0}.rxap-navigation .divider-title{padding-left:18px;height:28px;align-content:center}\n"], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    Required,
+    __metadata("design:type", Array)
+], NavigationComponent.prototype, "items", void 0);
+export { NavigationComponent };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NavigationComponent, [{
+        type: Component,
+        args: [{ selector: 'ul[rxap-navigation]', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: { class: 'rxap-navigation' }, template: "<ng-template [ngForOf]=\"items\" let-item ngFor>\n  <ng-template [ngIf]=\"isNavigationDividerItem(item)\">\n    <mat-divider fxFlex=\"nogrow\"></mat-divider>\n    <div *ngIf=\"!(sidenav.collapsed$ | async)\" class=\"divider-title\" fxFlex=\"nogrow\" fxLayout=\"row\" fxLayoutAlign=\"start end\">\n      <span fxFlex=\"nogrow\" *ngIf=\"item.title\">{{item.title}}</span>\n    </div>\n  </ng-template>\n  <ng-template [ngIf]=\"isNavigationItem(item)\">\n    <li class=\"item\" rxap-navigation-item [level]=\"level\" [item]=\"asNavigationItem(item)\"></li>\n  </ng-template>\n</ng-template>\n", styles: [".rxap-navigation{list-style-type:none;padding:0}.rxap-navigation .divider-title{padding-left:18px;height:28px;align-content:center}\n"] }]
+    }], function () { return [{ type: i5.NavigationService, decorators: [{
+                type: Inject,
+                args: [NavigationService]
+            }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                type: Inject,
+                args: [ChangeDetectorRef]
+            }] }, { type: i6.SidenavComponentService, decorators: [{
+                type: Inject,
+                args: [SidenavComponentService]
+            }] }]; }, { _root: [{
+            type: HostBinding,
+            args: ['class.rxap-root-navigation']
+        }], root: [{
+            type: Input
+        }], items: [{
+            type: Input
+        }], level: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/navigation/navigation.component.module.mjs

@@ -20,21 +20,22 @@ import * as i4 from "@angular/common";
 import * as i5 from "@rxap/material-directives/icon";
 import * as i6 from "@angular/material/core";
 import * as i7 from "@angular/material/legacy-tooltip";
-export class NavigationComponentModule {
+class NavigationComponentModule {
+    static { this.ɵfac = function NavigationComponentModule_Factory(t) { return new (t || NavigationComponentModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: NavigationComponentModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [MatIconModule,
+            MatButtonModule,
+            FlexLayoutModule,
+            RouterModule,
+            CommonModule,
+            IconDirectiveModule,
+            MatRippleModule,
+            MatDividerModule,
+            StopPropagationDirectiveModule,
+            MatTooltipModule,
+            ReplaceRouterPathsPipeModule] }); }
 }
-NavigationComponentModule.ɵfac = function NavigationComponentModule_Factory(t) { return new (t || NavigationComponentModule)(); };
-NavigationComponentModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: NavigationComponentModule });
-NavigationComponentModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [MatIconModule,
-        MatButtonModule,
-        FlexLayoutModule,
-        RouterModule,
-        CommonModule,
-        IconDirectiveModule,
-        MatRippleModule,
-        MatDividerModule,
-        StopPropagationDirectiveModule,
-        MatTooltipModule,
-        ReplaceRouterPathsPipeModule] });
+export { NavigationComponentModule };
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NavigationComponentModule, [{
         type: NgModule,
         args: [{
@@ -67,4 +68,4 @@ NavigationComponentModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports:
         MatTooltipModule,
         ReplaceRouterPathsPipeModule], exports: [NavigationComponent] }); })();
 i0.ɵɵsetComponentScope(NavigationItemComponent, [i1.MatIcon, i2.DefaultFlexDirective, i3.RouterLink, i3.RouterLinkActive, i4.NgForOf, i4.NgIf, i5.IconDirective, i6.MatRipple, i7.MatLegacyTooltip, NavigationComponent], [i4.AsyncPipe]);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi5jb21wb25lbnQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9sYXlvdXQvc3JjL2xpYi9uYXZpZ2F0aW9uL25hdmlnYXRpb24uY29tcG9uZW50Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzdELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBQ3RGLE9BQU8sRUFBRSxxQkFBcUIsSUFBSSxlQUFlLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMzRixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDeEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNyRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDekQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDN0QsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHNCQUFzQixJQUFJLGdCQUFnQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7Ozs7Ozs7OztBQW9COUYsTUFBTSxPQUFPLHlCQUF5Qjs7a0dBQXpCLHlCQUF5QjsyRUFBekIseUJBQXlCOytFQWRsQyxhQUFhO1FBQ2IsZUFBZTtRQUNmLGdCQUFnQjtRQUNoQixZQUFZO1FBQ1osWUFBWTtRQUNaLG1CQUFtQjtRQUNuQixlQUFlO1FBQ2YsZ0JBQWdCO1FBQ2hCLDhCQUE4QjtRQUM5QixnQkFBZ0I7UUFDaEIsNEJBQTRCO3VGQUluQix5QkFBeUI7Y0FqQnJDLFFBQVE7ZUFBQztnQkFDUixZQUFZLEVBQUUsQ0FBRSxtQkFBbUIsRUFBRSx1QkFBdUIsQ0FBRTtnQkFDOUQsT0FBTyxFQUFPO29CQUNaLGFBQWE7b0JBQ2IsZUFBZTtvQkFDZixnQkFBZ0I7b0JBQ2hCLFlBQVk7b0JBQ1osWUFBWTtvQkFDWixtQkFBbUI7b0JBQ25CLGVBQWU7b0JBQ2YsZ0JBQWdCO29CQUNoQiw4QkFBOEI7b0JBQzlCLGdCQUFnQjtvQkFDaEIsNEJBQTRCO2lCQUM3QjtnQkFDRCxPQUFPLEVBQU8sQ0FBRSxtQkFBbUIsQ0FBRTthQUN0Qzs7d0ZBQ1kseUJBQXlCLG1CQWhCcEIsbUJBQW1CLEVBQUUsdUJBQXVCLGFBRTFELGFBQWE7UUFDYixlQUFlO1FBQ2YsZ0JBQWdCO1FBQ2hCLFlBQVk7UUFDWixZQUFZO1FBQ1osbUJBQW1CO1FBQ25CLGVBQWU7UUFDZixnQkFBZ0I7UUFDaEIsOEJBQThCO1FBQzlCLGdCQUFnQjtRQUNoQiw0QkFBNEIsYUFFZCxtQkFBbUI7dUJBZEUsdUJBQXVCLHNKQUE1QyxtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTmF2aWdhdGlvbkNvbXBvbmVudCB9IGZyb20gJy4vbmF2aWdhdGlvbi5jb21wb25lbnQnO1xuaW1wb3J0IHsgTmF2aWdhdGlvbkl0ZW1Db21wb25lbnQgfSBmcm9tICcuL25hdmlnYXRpb24taXRlbS9uYXZpZ2F0aW9uLWl0ZW0uY29tcG9uZW50JztcbmltcG9ydCB7IE1hdExlZ2FjeUJ1dHRvbk1vZHVsZSBhcyBNYXRCdXR0b25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9sZWdhY3ktYnV0dG9uJztcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9pY29uJztcbmltcG9ydCB7IEZsZXhMYXlvdXRNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mbGV4LWxheW91dCc7XG5pbXBvcnQgeyBSb3V0ZXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IFJlcGxhY2VSb3V0ZXJQYXRoc1BpcGVNb2R1bGUgfSBmcm9tICcuL3JlcGxhY2Utcm91dGVyLXBhdGhzLnBpcGUnO1xuaW1wb3J0IHsgSWNvbkRpcmVjdGl2ZU1vZHVsZSB9IGZyb20gJ0ByeGFwL21hdGVyaWFsLWRpcmVjdGl2ZXMvaWNvbic7XG5pbXBvcnQgeyBNYXRSaXBwbGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9jb3JlJztcbmltcG9ydCB7IE1hdERpdmlkZXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaXZpZGVyJztcbmltcG9ydCB7IFN0b3BQcm9wYWdhdGlvbkRpcmVjdGl2ZU1vZHVsZSB9IGZyb20gJ0ByeGFwL2RpcmVjdGl2ZXMnO1xuaW1wb3J0IHsgTWF0TGVnYWN5VG9vbHRpcE1vZHVsZSBhcyBNYXRUb29sdGlwTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvbGVnYWN5LXRvb2x0aXAnO1xuXG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogWyBOYXZpZ2F0aW9uQ29tcG9uZW50LCBOYXZpZ2F0aW9uSXRlbUNvbXBvbmVudCBdLFxuICBpbXBvcnRzOiAgICAgIFtcbiAgICBNYXRJY29uTW9kdWxlLFxuICAgIE1hdEJ1dHRvbk1vZHVsZSxcbiAgICBGbGV4TGF5b3V0TW9kdWxlLFxuICAgIFJvdXRlck1vZHVsZSxcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgSWNvbkRpcmVjdGl2ZU1vZHVsZSxcbiAgICBNYXRSaXBwbGVNb2R1bGUsXG4gICAgTWF0RGl2aWRlck1vZHVsZSxcbiAgICBTdG9wUHJvcGFnYXRpb25EaXJlY3RpdmVNb2R1bGUsXG4gICAgTWF0VG9vbHRpcE1vZHVsZSxcbiAgICBSZXBsYWNlUm91dGVyUGF0aHNQaXBlTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6ICAgICAgWyBOYXZpZ2F0aW9uQ29tcG9uZW50IF1cbn0pXG5leHBvcnQgY2xhc3MgTmF2aWdhdGlvbkNvbXBvbmVudE1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/navigation/navigation.service.mjs

@@ -0,0 +1,144 @@
+import { Injectable, Inject, Optional, INJECTOR } from '@angular/core';
+import { ReplaySubject, of, combineLatest, from } from 'rxjs';
+import { IsNavigationInsertItem, IsNavigationItem, IsNavigationDividerItem } from './navigation-item';
+import { RXAP_NAVIGATION_CONFIG, RXAP_NAVIGATION_CONFIG_INSERTS } from '../tokens';
+import { switchMap, map, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+class NavigationService {
+    constructor(navigation, injector, inserts = null) {
+        this.injector = injector;
+        this.inserts = new Map();
+        this.navigation$ = new ReplaySubject(1);
+        if (typeof navigation === 'function') {
+            this.navigation = navigation();
+        }
+        else {
+            this.navigation = navigation;
+        }
+        if (inserts) {
+            Object.entries(inserts).forEach(([id, insert]) => this.insert(id, insert, false));
+        }
+        this.updateNavigation();
+        this.config$ = this.navigation$.pipe(switchMap((navigationWithoutStatusCheck) => this.checkNavigationStatusProviders(navigationWithoutStatusCheck)));
+    }
+    /**
+     * @deprecated use add instead
+     * @param id
+     * @param value
+     * @param update
+     */
+    insert(id, value, update = true) {
+        this.add(id, value, update);
+    }
+    add(id, value, update = true) {
+        this.inserts.set(id, value);
+        if (update) {
+            this.updateNavigation();
+        }
+    }
+    has(id) {
+        return this.inserts.has(id);
+    }
+    get(id) {
+        return this.inserts.get(id);
+    }
+    remove(id, update = true) {
+        this.inserts.delete(id);
+        if (update) {
+            this.updateNavigation();
+        }
+    }
+    updateNavigation() {
+        this.navigation$.next(this.replaceInserts(this.navigation));
+    }
+    /**
+     * @internal
+     * @param navigationItem
+     */
+    checkNavigationItemStatusProviders(navigationItem) {
+        if (IsNavigationDividerItem(navigationItem) || !navigationItem.status) {
+            return of(navigationItem);
+        }
+        const isVisibleArray$ = navigationItem.status
+            .map((statusToken) => this.injector.get(statusToken))
+            .map((status) => {
+            const isVisible = status.isVisible(navigationItem);
+            if (typeof isVisible === 'boolean') {
+                return of(isVisible);
+            }
+            else {
+                return from(isVisible);
+            }
+        }).map(isVisible$ => isVisible$.pipe(catchError(e => {
+            console.error('isVisible method failed: ' + e.message);
+            return of(false);
+        })));
+        // TODO : dont wait for all status services to complete, but cancel waiting if one returns false
+        return combineLatest(isVisibleArray$).pipe(map((isVisibleArray) => isVisibleArray.reduce((acc, isVisible) => acc && isVisible, true)), map((isVisible) => (isVisible ? navigationItem : null)), switchMap((navigationItemOrNull) => {
+            if (navigationItemOrNull) {
+                if (navigationItemOrNull.children?.length) {
+                    return this.checkNavigationStatusProviders(navigationItemOrNull.children).pipe(map((children) => ({
+                        ...navigationItemOrNull,
+                        children,
+                    })));
+                }
+                return of(navigationItemOrNull);
+            }
+            return of(null);
+        }));
+    }
+    /**
+     * @internal
+     * @param navigationItem
+     */
+    checkNavigationStatusProviders(navigation) {
+        return combineLatest(navigation.map((navigationItem) => this.checkNavigationItemStatusProviders(navigationItem))).pipe(map((navigationWithNullItems) => {
+            const cleanNavigation = [];
+            for (const navigationItem of navigationWithNullItems) {
+                if (navigationItem !== null) {
+                    cleanNavigation.push(navigationItem);
+                }
+            }
+            return cleanNavigation;
+        }));
+    }
+    replaceInserts(navigationWithInserts) {
+        const navigation = [];
+        for (const navigationItem of navigationWithInserts) {
+            if (IsNavigationInsertItem(navigationItem)) {
+                if (this.inserts.has(navigationItem.insert)) {
+                    navigation.push(...this.replaceInserts(this.inserts.get(navigationItem.insert)));
+                }
+            }
+            else if (IsNavigationItem(navigationItem)) {
+                navigation.push({
+                    ...navigationItem,
+                    children: this.replaceInserts(navigationItem.children ?? []),
+                });
+            }
+            else if (IsNavigationDividerItem(navigationItem)) {
+                navigation.push(navigationItem);
+            }
+        }
+        return navigation;
+    }
+    static { this.ɵfac = function NavigationService_Factory(t) { return new (t || NavigationService)(i0.ɵɵinject(RXAP_NAVIGATION_CONFIG), i0.ɵɵinject(INJECTOR), i0.ɵɵinject(RXAP_NAVIGATION_CONFIG_INSERTS, 8)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NavigationService, factory: NavigationService.ɵfac, providedIn: 'root' }); }
+}
+export { NavigationService };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NavigationService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [RXAP_NAVIGATION_CONFIG]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [INJECTOR]
+            }] }, { type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [RXAP_NAVIGATION_CONFIG_INSERTS]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation.service.js","sourceRoot":"","sources":["../../../../../../libs/layout/src/lib/navigation/navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Injector } from '@angular/core';\nimport {\n  Injectable,\n  Inject,\n  Optional,\n  INJECTOR\n} from '@angular/core';\nimport {\n  Observable,\n  ReplaySubject,\n  of,\n  combineLatest,\n  from\n} from 'rxjs';\nimport {\n  Navigation,\n  NavigationWithInserts,\n  IsNavigationInsertItem,\n  IsNavigationItem,\n  IsNavigationDividerItem,\n  NavigationItem,\n  NavigationDividerItem\n} from './navigation-item';\nimport {\n  RXAP_NAVIGATION_CONFIG,\n  RXAP_NAVIGATION_CONFIG_INSERTS\n} from '../tokens';\nimport {\n  switchMap,\n  map,\n  catchError\n} from 'rxjs/operators';\n\n@Injectable({ providedIn: 'root' })\nexport class NavigationService {\n  public readonly config$: Observable<Navigation>;\n\n  private inserts = new Map<string, NavigationWithInserts>();\n\n  private readonly navigation: NavigationWithInserts;\n\n  private readonly navigation$ = new ReplaySubject<Navigation>(1);\n\n  constructor(\n    @Inject(RXAP_NAVIGATION_CONFIG)\n    navigation: any,\n    @Inject(INJECTOR)\n    private readonly injector: Injector,\n    @Optional()\n    @Inject(RXAP_NAVIGATION_CONFIG_INSERTS)\n    inserts: any | null = null\n  ) {\n    if (typeof navigation === 'function') {\n      this.navigation = navigation();\n    } else {\n      this.navigation = navigation;\n    }\n    if (inserts) {\n      Object.entries(inserts).forEach(([id, insert]: [string, any]) =>\n        this.insert(id, insert, false)\n      );\n    }\n    this.updateNavigation();\n    this.config$ = this.navigation$.pipe(\n      switchMap((navigationWithoutStatusCheck) =>\n        this.checkNavigationStatusProviders(navigationWithoutStatusCheck)\n      )\n    );\n  }\n\n  /**\n   * @deprecated use add instead\n   * @param id\n   * @param value\n   * @param update\n   */\n  public insert(\n    id: string,\n    value: NavigationWithInserts,\n    update: boolean = true\n  ): void {\n    this.add(id, value, update);\n  }\n\n  public add(\n    id: string,\n    value: NavigationWithInserts,\n    update: boolean = true\n  ): void {\n    this.inserts.set(id, value);\n    if (update) {\n      this.updateNavigation();\n    }\n  }\n\n  public has(id: string): boolean {\n    return this.inserts.has(id);\n  }\n\n  public get(id: string): NavigationWithInserts | undefined {\n    return this.inserts.get(id);\n  }\n\n  public remove(id: string, update: boolean = true): void {\n    this.inserts.delete(id);\n    if (update) {\n      this.updateNavigation();\n    }\n  }\n\n  public updateNavigation(): void {\n    this.navigation$.next(this.replaceInserts(this.navigation));\n  }\n\n  /**\n   * @internal\n   * @param navigationItem\n   */\n  public checkNavigationItemStatusProviders(\n    navigationItem: NavigationItem | NavigationDividerItem\n  ): Observable<NavigationItem | NavigationDividerItem | null> {\n    if (IsNavigationDividerItem(navigationItem) || !navigationItem.status) {\n      return of(navigationItem);\n    }\n    const isVisibleArray$: Array<Observable<boolean>> = navigationItem.status\n      .map((statusToken) => this.injector.get(statusToken))\n      .map((status) => {\n        const isVisible = status.isVisible(navigationItem);\n        if (typeof isVisible === 'boolean') {\n          return of(isVisible);\n        } else {\n          return from(isVisible);\n        }\n      }).map(isVisible$ => isVisible$.pipe(catchError(e => {\n        console.error('isVisible method failed: ' + e.message);\n        return of(false);\n      })));\n    // TODO : dont wait for all status services to complete, but cancel waiting if one returns false\n    return combineLatest(isVisibleArray$).pipe(\n      map((isVisibleArray) =>\n        isVisibleArray.reduce((acc, isVisible) => acc && isVisible, true)\n      ),\n      map((isVisible) => (isVisible ? navigationItem : null)),\n      switchMap((navigationItemOrNull) => {\n        if (navigationItemOrNull) {\n          if (navigationItemOrNull.children?.length) {\n            return this.checkNavigationStatusProviders(\n              navigationItemOrNull.children\n            ).pipe(\n              map((children) => ({\n                ...navigationItemOrNull,\n                children,\n              }))\n            );\n          }\n          return of(navigationItemOrNull);\n        }\n        return of(null);\n      })\n    );\n  }\n\n  /**\n   * @internal\n   * @param navigationItem\n   */\n  public checkNavigationStatusProviders(\n    navigation: Navigation\n  ): Observable<Navigation> {\n    return combineLatest(\n      navigation.map((navigationItem) =>\n        this.checkNavigationItemStatusProviders(navigationItem)\n      )\n    ).pipe(\n      map((navigationWithNullItems) => {\n        const cleanNavigation: Navigation = [];\n\n        for (const navigationItem of navigationWithNullItems) {\n          if (navigationItem !== null) {\n            cleanNavigation.push(navigationItem);\n          }\n        }\n\n        return cleanNavigation;\n      })\n    );\n  }\n\n  private replaceInserts(\n    navigationWithInserts: NavigationWithInserts\n  ): Navigation {\n    const navigation: Navigation = [];\n\n    for (const navigationItem of navigationWithInserts) {\n      if (IsNavigationInsertItem(navigationItem)) {\n        if (this.inserts.has(navigationItem.insert)) {\n          navigation.push(\n            ...this.replaceInserts(this.inserts.get(navigationItem.insert)!)\n          );\n        }\n      } else if (IsNavigationItem(navigationItem)) {\n        navigation.push({\n          ...navigationItem,\n          children: this.replaceInserts(navigationItem.children ?? []),\n        });\n      } else if (IsNavigationDividerItem(navigationItem)) {\n        navigation.push(navigationItem);\n      }\n    }\n\n    return navigation;\n  }\n}\n"]}

package/esm2022/lib/navigation/replace-router-paths.pipe.mjs

@@ -0,0 +1,36 @@
+import { NgModule, Pipe } from '@angular/core';
+import { ReplaceRouterPathsService } from './replace-router-paths.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./replace-router-paths.service";
+class ReplaceRouterPathsPipe {
+    constructor(rrp) {
+        this.rrp = rrp;
+    }
+    transform(routerLink) {
+        return this.rrp.transform(routerLink);
+    }
+    static { this.ɵfac = function ReplaceRouterPathsPipe_Factory(t) { return new (t || ReplaceRouterPathsPipe)(i0.ɵɵdirectiveInject(i1.ReplaceRouterPathsService, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "replaceRouterPaths", type: ReplaceRouterPathsPipe, pure: true }); }
+}
+export { ReplaceRouterPathsPipe };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReplaceRouterPathsPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'replaceRouterPaths'
+            }]
+    }], function () { return [{ type: i1.ReplaceRouterPathsService }]; }, null); })();
+class ReplaceRouterPathsPipeModule {
+    static { this.ɵfac = function ReplaceRouterPathsPipeModule_Factory(t) { return new (t || ReplaceRouterPathsPipeModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ReplaceRouterPathsPipeModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({}); }
+}
+export { ReplaceRouterPathsPipeModule };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReplaceRouterPathsPipeModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [ReplaceRouterPathsPipe],
+                exports: [ReplaceRouterPathsPipe]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ReplaceRouterPathsPipeModule, { declarations: [ReplaceRouterPathsPipe], exports: [ReplaceRouterPathsPipe] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwbGFjZS1yb3V0ZXItcGF0aHMucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbGF5b3V0L3NyYy9saWIvbmF2aWdhdGlvbi9yZXBsYWNlLXJvdXRlci1wYXRocy5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxRQUFRLEVBQ1IsSUFBSSxFQUVMLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDOzs7QUFFM0UsTUFHYSxzQkFBc0I7SUFDakMsWUFDUyxHQUE4QjtRQUE5QixRQUFHLEdBQUgsR0FBRyxDQUEyQjtJQUNwQyxDQUFDO0lBRUosU0FBUyxDQUFDLFVBQW9CO1FBQzVCLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDeEMsQ0FBQzt1RkFQVSxzQkFBc0I7NEZBQXRCLHNCQUFzQjs7U0FBdEIsc0JBQXNCO3VGQUF0QixzQkFBc0I7Y0FIbEMsSUFBSTtlQUFDO2dCQUNKLElBQUksRUFBRSxvQkFBb0I7YUFDM0I7O0FBV0QsTUFJYSw0QkFBNEI7NkZBQTVCLDRCQUE0QjttRUFBNUIsNEJBQTRCOzs7U0FBNUIsNEJBQTRCO3VGQUE1Qiw0QkFBNEI7Y0FKeEMsUUFBUTtlQUFDO2dCQUNSLFlBQVksRUFBRSxDQUFFLHNCQUFzQixDQUFFO2dCQUN4QyxPQUFPLEVBQU8sQ0FBRSxzQkFBc0IsQ0FBRTthQUN6Qzs7d0ZBQ1ksNEJBQTRCLG1CQWQ1QixzQkFBc0IsYUFBdEIsc0JBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgTmdNb2R1bGUsXG4gIFBpcGUsXG4gIFBpcGVUcmFuc2Zvcm1cbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBSZXBsYWNlUm91dGVyUGF0aHNTZXJ2aWNlIH0gZnJvbSAnLi9yZXBsYWNlLXJvdXRlci1wYXRocy5zZXJ2aWNlJztcblxuQFBpcGUoe1xuICBuYW1lOiAncmVwbGFjZVJvdXRlclBhdGhzJ1xufSlcbmV4cG9ydCBjbGFzcyBSZXBsYWNlUm91dGVyUGF0aHNQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyBycnA6IFJlcGxhY2VSb3V0ZXJQYXRoc1NlcnZpY2VcbiAgKSB7fVxuXG4gIHRyYW5zZm9ybShyb3V0ZXJMaW5rOiBzdHJpbmdbXSk6IE9ic2VydmFibGU8c3RyaW5nW10+IHtcbiAgICByZXR1cm4gdGhpcy5ycnAudHJhbnNmb3JtKHJvdXRlckxpbmspO1xuICB9XG59XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogWyBSZXBsYWNlUm91dGVyUGF0aHNQaXBlIF0sXG4gIGV4cG9ydHM6ICAgICAgWyBSZXBsYWNlUm91dGVyUGF0aHNQaXBlIF1cbn0pXG5leHBvcnQgY2xhc3MgUmVwbGFjZVJvdXRlclBhdGhzUGlwZU1vZHVsZSB7fVxuIl19

package/esm2022/lib/navigation/replace-router-paths.service.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+class ReplaceRouterPathsService {
+    transform(routerLink) {
+        return of(routerLink);
+    }
+    static { this.ɵfac = function ReplaceRouterPathsService_Factory(t) { return new (t || ReplaceRouterPathsService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ReplaceRouterPathsService, factory: ReplaceRouterPathsService.ɵfac, providedIn: 'root' }); }
+}
+export { ReplaceRouterPathsService };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReplaceRouterPathsService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwbGFjZS1yb3V0ZXItcGF0aHMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbGF5b3V0L3NyYy9saWIvbmF2aWdhdGlvbi9yZXBsYWNlLXJvdXRlci1wYXRocy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUVMLEVBQUUsRUFDSCxNQUFNLE1BQU0sQ0FBQzs7QUFFZCxNQUNhLHlCQUF5QjtJQUU3QixTQUFTLENBQUMsVUFBb0I7UUFDbkMsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDeEIsQ0FBQzswRkFKVSx5QkFBeUI7dUVBQXpCLHlCQUF5QixXQUF6Qix5QkFBeUIsbUJBRFosTUFBTTs7U0FDbkIseUJBQXlCO3VGQUF6Qix5QkFBeUI7Y0FEckMsVUFBVTtlQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIE9ic2VydmFibGUsXG4gIG9mXG59IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIFJlcGxhY2VSb3V0ZXJQYXRoc1NlcnZpY2Uge1xuXG4gIHB1YmxpYyB0cmFuc2Zvcm0ocm91dGVyTGluazogc3RyaW5nW10pOiBPYnNlcnZhYmxlPHN0cmluZ1tdPiB7XG4gICAgcmV0dXJuIG9mKHJvdXRlckxpbmspO1xuICB9XG5cbn1cbiJdfQ==

package/esm2022/lib/sidenav/sidenav-footer.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, TemplateRef, Inject } from '@angular/core';
+import * as i0 from "@angular/core";
+class SidenavFooterDirective {
+    constructor(template) {
+        this.template = template;
+    }
+    static { this.ɵfac = function SidenavFooterDirective_Factory(t) { return new (t || SidenavFooterDirective)(i0.ɵɵdirectiveInject(TemplateRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SidenavFooterDirective, selectors: [["", "rxapSidenavFooter", ""]] }); }
+}
+export { SidenavFooterDirective };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SidenavFooterDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[rxapSidenavFooter]',
+            }]
+    }], function () { return [{ type: i0.TemplateRef, decorators: [{
+                type: Inject,
+                args: [TemplateRef]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZW5hdi1mb290ZXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9sYXlvdXQvc3JjL2xpYi9zaWRlbmF2L3NpZGVuYXYtZm9vdGVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRS9ELE1BR2Esc0JBQXNCO0lBQ2pDLFlBRWtCLFFBQTJCO1FBQTNCLGFBQVEsR0FBUixRQUFRLENBQW1CO0lBQzFDLENBQUM7dUZBSk8sc0JBQXNCLHVCQUV2QixXQUFXO29FQUZWLHNCQUFzQjs7U0FBdEIsc0JBQXNCO3VGQUF0QixzQkFBc0I7Y0FIbEMsU0FBUztlQUFDO2dCQUNULFFBQVEsRUFBRSxxQkFBcUI7YUFDaEM7O3NCQUdJLE1BQU07dUJBQUMsV0FBVyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbcnhhcFNpZGVuYXZGb290ZXJdJyxcbn0pXG5leHBvcnQgY2xhc3MgU2lkZW5hdkZvb3RlckRpcmVjdGl2ZSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIEBJbmplY3QoVGVtcGxhdGVSZWYpXG4gICAgcHVibGljIHJlYWRvbmx5IHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjx2b2lkPlxuICApIHt9XG59XG4iXX0=

package/esm2022/lib/sidenav/sidenav-header.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, Inject, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+class SidenavHeaderDirective {
+    constructor(template) {
+        this.template = template;
+    }
+    static { this.ɵfac = function SidenavHeaderDirective_Factory(t) { return new (t || SidenavHeaderDirective)(i0.ɵɵdirectiveInject(TemplateRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SidenavHeaderDirective, selectors: [["", "rxapSidenavHeader", ""]] }); }
+}
+export { SidenavHeaderDirective };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SidenavHeaderDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[rxapSidenavHeader]',
+            }]
+    }], function () { return [{ type: i0.TemplateRef, decorators: [{
+                type: Inject,
+                args: [TemplateRef]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZW5hdi1oZWFkZXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9sYXlvdXQvc3JjL2xpYi9zaWRlbmF2L3NpZGVuYXYtaGVhZGVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRS9ELE1BR2Esc0JBQXNCO0lBQ2pDLFlBRWtCLFFBQTJCO1FBQTNCLGFBQVEsR0FBUixRQUFRLENBQW1CO0lBQzFDLENBQUM7dUZBSk8sc0JBQXNCLHVCQUV2QixXQUFXO29FQUZWLHNCQUFzQjs7U0FBdEIsc0JBQXNCO3VGQUF0QixzQkFBc0I7Y0FIbEMsU0FBUztlQUFDO2dCQUNULFFBQVEsRUFBRSxxQkFBcUI7YUFDaEM7O3NCQUdJLE1BQU07dUJBQUMsV0FBVyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5qZWN0LCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbcnhhcFNpZGVuYXZIZWFkZXJdJyxcbn0pXG5leHBvcnQgY2xhc3MgU2lkZW5hdkhlYWRlckRpcmVjdGl2ZSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIEBJbmplY3QoVGVtcGxhdGVSZWYpXG4gICAgcHVibGljIHJlYWRvbmx5IHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjx2b2lkPlxuICApIHt9XG59XG4iXX0=

package/esm2022/lib/sidenav/sidenav.component.mjs

@@ -0,0 +1,121 @@
+import { Component, ChangeDetectionStrategy, ContentChild } from '@angular/core';
+import { SidenavFooterDirective } from './sidenav-footer.directive';
+import { SidenavHeaderDirective } from './sidenav-header.directive';
+import { SidenavComponentService } from './sidenav.component.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./sidenav.component.service";
+import * as i2 from "@angular/flex-layout/flex";
+import * as i3 from "@angular/flex-layout/extended";
+import * as i4 from "../navigation/navigation.component";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/divider";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@angular/material/legacy-button";
+function SidenavComponent_ng_template_3_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function SidenavComponent_ng_template_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 11);
+    i0.ɵɵpipe(1, "async");
+    i0.ɵɵtemplate(2, SidenavComponent_ng_template_3_ng_container_2_Template, 1, 0, "ng-container", 12);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(3, "mat-divider", 13);
+    i0.ɵɵpipe(4, "async");
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    let tmp_1_0;
+    i0.ɵɵproperty("fxHide", i0.ɵɵpipeBind1(1, 3, ctx_r0.sidenav.collapsed$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngTemplateOutlet", (tmp_1_0 = ctx_r0.sidenavHeaderDirective == null ? null : ctx_r0.sidenavHeaderDirective.template) !== null && tmp_1_0 !== undefined ? tmp_1_0 : null);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("fxHide", i0.ɵɵpipeBind1(4, 5, ctx_r0.sidenav.collapsed$));
+} }
+function SidenavComponent_ng_template_15_ng_container_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function SidenavComponent_ng_template_15_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider", 13);
+    i0.ɵɵpipe(1, "async");
+    i0.ɵɵelementStart(2, "div", 14);
+    i0.ɵɵpipe(3, "async");
+    i0.ɵɵtemplate(4, SidenavComponent_ng_template_15_ng_container_4_Template, 1, 0, "ng-container", 12);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    let tmp_2_0;
+    i0.ɵɵproperty("fxHide", i0.ɵɵpipeBind1(1, 3, ctx_r1.sidenav.collapsed$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("fxHide", i0.ɵɵpipeBind1(3, 5, ctx_r1.sidenav.collapsed$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngTemplateOutlet", (tmp_2_0 = ctx_r1.sidenavFooterDirective == null ? null : ctx_r1.sidenavFooterDirective.template) !== null && tmp_2_0 !== undefined ? tmp_2_0 : null);
+} }
+const _c2 = function (a0) { return { "collapsed": a0 }; };
+class SidenavComponent {
+    constructor(sidenav) {
+        this.sidenav = sidenav;
+    }
+    static { this.ɵfac = function SidenavComponent_Factory(t) { return new (t || SidenavComponent)(i0.ɵɵdirectiveInject(i1.SidenavComponentService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SidenavComponent, selectors: [["rxap-sidenav"]], contentQueries: function SidenavComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, SidenavFooterDirective, 5);
+            i0.ɵɵcontentQuery(dirIndex, SidenavHeaderDirective, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.sidenavFooterDirective = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.sidenavHeaderDirective = _t.first);
+        } }, hostAttrs: [1, "rxap-layout-sidenav"], decls: 16, vars: 15, consts: function () { let i18n_0; if (typeof ngI18nClosureMode !== "undefined" && ngI18nClosureMode) {
+            /**
+             * @suppress {msgDescriptions}
+             */
+            const MSG_EXTERNAL_1144722711335201698$$LIB_SIDENAV_SIDENAV_COMPONENT_TS_1 = goog.getMsg("Collapse sidebar");
+            i18n_0 = MSG_EXTERNAL_1144722711335201698$$LIB_SIDENAV_SIDENAV_COMPONENT_TS_1;
+        }
+        else {
+            i18n_0 = $localize `:␟98effe6eb558f87ab061ab608a31b44adec4e2ae␟1144722711335201698:Collapse sidebar`;
+        } return [[1, "container", 3, "ngClass"], ["fxLayout", "column", "fxLayoutAlign", "space-between stretch", 1, "inner"], [3, "ngIf"], ["fxFlex", "grow", 1, "nav-container"], ["fxLayout", "column", "root", "", "rxap-navigation", ""], ["fxFlex", "nogrow"], ["mat-button", "", "fxFlex", "nogrow", 1, "sidebar-toggle", 3, "ngClass", "click"], ["fxLayout", "row", "fxLayoutAlign", "start center", "fxLayoutGap", "16px", 1, "sidebar-toggle-inner"], ["fxFlex", "nogrow", 1, "arrow"], ["fxFlex", "grow", 1, "label", 3, "fxHide"], i18n_0, ["fxFlex", "nogrow", 1, "header", 3, "fxHide"], [4, "ngTemplateOutlet"], ["fxFlex", "nogrow", 3, "fxHide"], ["fxFlex", "nogrow", 1, "footer", 3, "fxHide"]]; }, template: function SidenavComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0);
+            i0.ɵɵpipe(1, "async");
+            i0.ɵɵelementStart(2, "div", 1);
+            i0.ɵɵtemplate(3, SidenavComponent_ng_template_3_Template, 5, 7, "ng-template", 2);
+            i0.ɵɵelementStart(4, "div", 3);
+            i0.ɵɵelement(5, "ul", 4);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(6, "mat-divider", 5);
+            i0.ɵɵelementStart(7, "button", 6);
+            i0.ɵɵlistener("click", function SidenavComponent_Template_button_click_7_listener() { return ctx.sidenav.toggleNavigationCollapse(); });
+            i0.ɵɵpipe(8, "async");
+            i0.ɵɵelementStart(9, "span", 7)(10, "mat-icon", 8);
+            i0.ɵɵtext(11, "double_arrow");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(12, "span", 9);
+            i0.ɵɵi18n(13, 10);
+            i0.ɵɵpipe(14, "async");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵtemplate(15, SidenavComponent_ng_template_15_Template, 5, 7, "ng-template", 2);
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            let tmp_4_0;
+            i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(11, _c2, i0.ɵɵpipeBind1(1, 5, ctx.sidenav.collapsed$)));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", ctx.sidenavHeaderDirective == null ? null : ctx.sidenavHeaderDirective.template);
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(13, _c2, i0.ɵɵpipeBind1(8, 7, ctx.sidenav.collapsed$)));
+            i0.ɵɵadvance(5);
+            i0.ɵɵproperty("fxHide", i0.ɵɵpipeBind1(14, 9, ctx.sidenav.collapsed$));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", (tmp_4_0 = ctx.sidenavFooterDirective == null ? null : ctx.sidenavFooterDirective.template) !== null && tmp_4_0 !== undefined ? tmp_4_0 : null);
+        } }, dependencies: [i2.DefaultLayoutDirective, i2.DefaultLayoutGapDirective, i2.DefaultLayoutAlignDirective, i2.DefaultFlexDirective, i3.DefaultShowHideDirective, i3.DefaultClassDirective, i4.NavigationComponent, i5.NgClass, i5.NgIf, i5.NgTemplateOutlet, i6.MatDivider, i7.MatIcon, i8.MatLegacyButton, i5.AsyncPipe], styles: [".container[_ngcontent-%COMP%], .container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]{height:100%}.container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{padding-bottom:12px}.container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]   .footer[_ngcontent-%COMP%]{padding-top:12px}.container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]   .nav-container[_ngcontent-%COMP%]{overflow-y:scroll;padding-top:12px}.container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]   .nav-container[_ngcontent-%COMP%]::-webkit-scrollbar{width:6px}.container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]   .nav-container[_ngcontent-%COMP%]::-webkit-scrollbar-track{border-radius:2px}.container[_ngcontent-%COMP%]   .inner[_ngcontent-%COMP%]   .nav-container[_ngcontent-%COMP%]::-webkit-scrollbar-thumb{border-radius:10px}.container[_ngcontent-%COMP%]   .sidebar-toggle[_ngcontent-%COMP%]{min-height:48px}.container[_ngcontent-%COMP%]   .sidebar-toggle[_ngcontent-%COMP%]   .sidebar-toggle-inner[_ngcontent-%COMP%]{padding:0}.container[_ngcontent-%COMP%]   .sidebar-toggle[_ngcontent-%COMP%]   .arrow[_ngcontent-%COMP%]{transform:rotate(180deg)}.container[_ngcontent-%COMP%]   .sidebar-toggle.collapsed[_ngcontent-%COMP%]   .arrow[_ngcontent-%COMP%]{transform:initial}.container[_ngcontent-%COMP%]   .sidebar-toggle.collapsed[_ngcontent-%COMP%]   .sidebar-toggle-inner[_ngcontent-%COMP%]{justify-content:space-around!important}"], changeDetection: 0 }); }
+}
+export { SidenavComponent };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SidenavComponent, [{
+        type: Component,
+        args: [{ selector: 'rxap-sidenav', changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                    class: 'rxap-layout-sidenav'
+                }, template: "<div class=\"container\" [ngClass]=\"{ 'collapsed': sidenav.collapsed$ | async }\">\n  <div class=\"inner\"\n       fxLayout=\"column\"\n       fxLayoutAlign=\"space-between stretch\">\n    <ng-template [ngIf]=\"sidenavHeaderDirective?.template\">\n      <div fxFlex=\"nogrow\" class=\"header\" [fxHide]=\"sidenav.collapsed$ | async\">\n        <ng-container *ngTemplateOutlet=\"sidenavHeaderDirective?.template ?? null\"></ng-container>\n      </div>\n      <mat-divider fxFlex=\"nogrow\" [fxHide]=\"sidenav.collapsed$ | async\"></mat-divider>\n    </ng-template>\n    <div fxFlex=\"grow\" class=\"nav-container\">\n      <ul fxLayout=\"column\" root rxap-navigation></ul>\n    </div>\n    <mat-divider fxFlex=\"nogrow\"></mat-divider>\n    <button mat-button class=\"sidebar-toggle\" [ngClass]=\"{ 'collapsed': sidenav.collapsed$ | async }\" fxFlex=\"nogrow\"\n            (click)=\"sidenav.toggleNavigationCollapse()\">\n      <span class=\"sidebar-toggle-inner\" fxLayout=\"row\" fxLayoutAlign=\"start center\" fxLayoutGap=\"16px\">\n        <mat-icon fxFlex=\"nogrow\" class=\"arrow\">double_arrow</mat-icon>\n        <span [fxHide]=\"sidenav.collapsed$ | async\" class=\"label\" fxFlex=\"grow\" i18n>Collapse sidebar</span>\n      </span>\n    </button>\n    <ng-template [ngIf]=\"sidenavFooterDirective?.template ?? null\">\n      <mat-divider fxFlex=\"nogrow\" [fxHide]=\"sidenav.collapsed$ | async\"></mat-divider>\n      <div fxFlex=\"nogrow\" class=\"footer\" [fxHide]=\"sidenav.collapsed$ | async\">\n        <ng-container *ngTemplateOutlet=\"sidenavFooterDirective?.template ?? null\"></ng-container>\n      </div>\n    </ng-template>\n  </div>\n</div>\n", styles: [".container,.container .inner{height:100%}.container .inner .header{padding-bottom:12px}.container .inner .footer{padding-top:12px}.container .inner .nav-container{overflow-y:scroll;padding-top:12px}.container .inner .nav-container::-webkit-scrollbar{width:6px}.container .inner .nav-container::-webkit-scrollbar-track{border-radius:2px}.container .inner .nav-container::-webkit-scrollbar-thumb{border-radius:10px}.container .sidebar-toggle{min-height:48px}.container .sidebar-toggle .sidebar-toggle-inner{padding:0}.container .sidebar-toggle .arrow{transform:rotate(180deg)}.container .sidebar-toggle.collapsed .arrow{transform:initial}.container .sidebar-toggle.collapsed .sidebar-toggle-inner{justify-content:space-around!important}\n"] }]
+    }], function () { return [{ type: i1.SidenavComponentService }]; }, { sidenavFooterDirective: [{
+            type: ContentChild,
+            args: [SidenavFooterDirective]
+        }], sidenavHeaderDirective: [{
+            type: ContentChild,
+            args: [SidenavHeaderDirective]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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