@vendure/admin-ui 1.4.7 → 2.0.0-next.0

package/esm2020/core/components/breadcrumb/breadcrumb.component.mjs

@@ -0,0 +1,124 @@
+import { Component } from '@angular/core';
+import { NavigationEnd, PRIMARY_OUTLET } from '@angular/router';
+import { flatten } from 'lodash';
+import { combineLatest as observableCombineLatest, Observable, of as observableOf, Subject } from 'rxjs';
+import { filter, map, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../data/providers/data.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+/**
+ * A breadcrumbs component which reads the route config and any route that has a `data.breadcrumb` property will
+ * be displayed in the breadcrumb trail.
+ *
+ * The `breadcrumb` property can be a string or a function. If a function, it will be passed the route's `data`
+ * object (which will include all resolved keys) and any route params, and should return a BreadcrumbValue.
+ *
+ * See the test config to get an idea of allowable configs for breadcrumbs.
+ */
+export class BreadcrumbComponent {
+    constructor(router, route, dataService) {
+        this.router = router;
+        this.route = route;
+        this.dataService = dataService;
+        this.destroy$ = new Subject();
+        this.breadcrumbs$ = this.router.events.pipe(filter(event => event instanceof NavigationEnd), takeUntil(this.destroy$), startWith(true), switchMap(() => this.generateBreadcrumbs(this.route.root)));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    generateBreadcrumbs(rootRoute) {
+        const breadcrumbParts = this.assembleBreadcrumbParts(rootRoute);
+        const breadcrumbObservables$ = breadcrumbParts.map(({ value$, path }) => {
+            return value$.pipe(map(value => {
+                if (isBreadcrumbLabelLinkPair(value)) {
+                    return {
+                        label: value.label,
+                        link: this.normalizeRelativeLinks(value.link, path),
+                    };
+                }
+                else if (isBreadcrumbPairArray(value)) {
+                    return value.map(val => ({
+                        label: val.label,
+                        link: this.normalizeRelativeLinks(val.link, path),
+                    }));
+                }
+                else {
+                    return {
+                        label: value,
+                        link: '/' + path.join('/'),
+                    };
+                }
+            }));
+        });
+        return observableCombineLatest(breadcrumbObservables$).pipe(map(links => flatten(links)));
+    }
+    /**
+     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.
+     */
+    assembleBreadcrumbParts(rootRoute) {
+        const breadcrumbParts = [];
+        const inferredUrl = '';
+        const segmentPaths = [];
+        let currentRoute = rootRoute;
+        do {
+            const childRoutes = currentRoute.children;
+            currentRoute = null;
+            childRoutes.forEach((route) => {
+                if (route.outlet === PRIMARY_OUTLET) {
+                    const routeSnapshot = route.snapshot;
+                    let breadcrumbDef = route.routeConfig && route.routeConfig.data && route.routeConfig.data['breadcrumb'];
+                    segmentPaths.push(routeSnapshot.url.map(segment => segment.path).join('/'));
+                    if (breadcrumbDef) {
+                        if (isBreadcrumbFunction(breadcrumbDef)) {
+                            breadcrumbDef = breadcrumbDef(routeSnapshot.data, routeSnapshot.params, this.dataService);
+                        }
+                        const observableValue = isObservable(breadcrumbDef)
+                            ? breadcrumbDef
+                            : observableOf(breadcrumbDef);
+                        breadcrumbParts.push({ value$: observableValue, path: segmentPaths.slice() });
+                    }
+                    currentRoute = route;
+                }
+            });
+        } while (currentRoute);
+        return breadcrumbParts;
+    }
+    /**
+     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:
+     * * `./`   - this appends the rest of the link segments to the current active route
+     * * `../`  - this removes the last segment of the current active route, and appends the link segments
+     *            to the parent route.
+     */
+    normalizeRelativeLinks(link, segmentPaths) {
+        const clone = link.slice();
+        if (clone[0] === './') {
+            clone[0] = segmentPaths.join('/');
+        }
+        if (clone[0] === '../') {
+            clone[0] = segmentPaths.slice(0, -1).join('/');
+        }
+        return clone.filter(segment => segment !== '');
+    }
+}
+BreadcrumbComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: BreadcrumbComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Component });
+BreadcrumbComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: BreadcrumbComponent, selector: "vdr-breadcrumb", ngImport: i0, template: "<nav role=\"navigation\">\r\n    <ul class=\"breadcrumbs\">\r\n        <li *ngFor=\"let breadcrumb of (breadcrumbs$ | async); let isLast = last\">\r\n            <a [routerLink]=\"breadcrumb.link\" *ngIf=\"!isLast\">{{ breadcrumb.label | translate }}</a>\r\n            <ng-container *ngIf=\"isLast\">{{ breadcrumb.label | translate }}</ng-container>\r\n        </li>\r\n    </ul>\r\n</nav>\r\n", styles: ["@charset \"UTF-8\";:host{display:block;padding:0 1rem}.breadcrumbs{list-style-type:none}.breadcrumbs li{font-size:16px;display:inline-block;margin-right:10px}.breadcrumbs li:not(:last-child):after{content:\"\\203a\";top:0;color:var(--color-grey-400);margin-left:10px}\n"], directives: [{ type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo", "routerLink"] }], pipes: { "async": i3.AsyncPipe, "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: BreadcrumbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-breadcrumb', template: "<nav role=\"navigation\">\r\n    <ul class=\"breadcrumbs\">\r\n        <li *ngFor=\"let breadcrumb of (breadcrumbs$ | async); let isLast = last\">\r\n            <a [routerLink]=\"breadcrumb.link\" *ngIf=\"!isLast\">{{ breadcrumb.label | translate }}</a>\r\n            <ng-container *ngIf=\"isLast\">{{ breadcrumb.label | translate }}</ng-container>\r\n        </li>\r\n    </ul>\r\n</nav>\r\n", styles: ["@charset \"UTF-8\";:host{display:block;padding:0 1rem}.breadcrumbs{list-style-type:none}.breadcrumbs li{font-size:16px;display:inline-block;margin-right:10px}.breadcrumbs li:not(:last-child):after{content:\"\\203a\";top:0;color:var(--color-grey-400);margin-left:10px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.DataService }]; } });
+function isBreadcrumbFunction(value) {
+    return typeof value === 'function';
+}
+function isObservable(value) {
+    return value instanceof Observable;
+}
+function isBreadcrumbLabelLinkPair(value) {
+    return value.hasOwnProperty('label') && value.hasOwnProperty('link');
+}
+function isBreadcrumbPairArray(value) {
+    return Array.isArray(value) && isBreadcrumbLabelLinkPair(value[0]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.component.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/components/breadcrumb/breadcrumb.component.ts","../../../../../src/lib/core/src/components/breadcrumb/breadcrumb.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnDestroy } from '@angular/core';\r\nimport { ActivatedRoute, Data, NavigationEnd, Params, PRIMARY_OUTLET, Router } from '@angular/router';\r\nimport { flatten } from 'lodash';\r\nimport { combineLatest as observableCombineLatest, Observable, of as observableOf, Subject } from 'rxjs';\r\nimport { filter, map, startWith, switchMap, takeUntil } from 'rxjs/operators';\r\n\r\nimport { DataService } from '../../data/providers/data.service';\r\n\r\nexport type BreadcrumbString = string;\r\nexport interface BreadcrumbLabelLinkPair {\r\n    label: string;\r\n    link: any[];\r\n}\r\nexport type BreadcrumbValue = BreadcrumbString | BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[];\r\nexport type BreadcrumbFunction = (\r\n    data: Data,\r\n    params: Params,\r\n    dataService: DataService,\r\n) => BreadcrumbValue | Observable<BreadcrumbValue>;\r\nexport type BreadcrumbDefinition = BreadcrumbValue | BreadcrumbFunction | Observable<BreadcrumbValue>;\r\n\r\n/**\r\n * A breadcrumbs component which reads the route config and any route that has a `data.breadcrumb` property will\r\n * be displayed in the breadcrumb trail.\r\n *\r\n * The `breadcrumb` property can be a string or a function. If a function, it will be passed the route's `data`\r\n * object (which will include all resolved keys) and any route params, and should return a BreadcrumbValue.\r\n *\r\n * See the test config to get an idea of allowable configs for breadcrumbs.\r\n */\r\n@Component({\r\n    selector: 'vdr-breadcrumb',\r\n    templateUrl: './breadcrumb.component.html',\r\n    styleUrls: ['./breadcrumb.component.scss'],\r\n})\r\nexport class BreadcrumbComponent implements OnDestroy {\r\n    breadcrumbs$: Observable<Array<{ link: string | any[]; label: string }>>;\r\n    private destroy$ = new Subject<void>();\r\n\r\n    constructor(private router: Router, private route: ActivatedRoute, private dataService: DataService) {\r\n        this.breadcrumbs$ = this.router.events.pipe(\r\n            filter(event => event instanceof NavigationEnd),\r\n            takeUntil(this.destroy$),\r\n            startWith(true),\r\n            switchMap(() => this.generateBreadcrumbs(this.route.root)),\r\n        );\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    private generateBreadcrumbs(\r\n        rootRoute: ActivatedRoute,\r\n    ): Observable<Array<{ link: Array<string | any>; label: string }>> {\r\n        const breadcrumbParts = this.assembleBreadcrumbParts(rootRoute);\r\n        const breadcrumbObservables$ = breadcrumbParts.map(({ value$, path }) => {\r\n            return value$.pipe(\r\n                map(value => {\r\n                    if (isBreadcrumbLabelLinkPair(value)) {\r\n                        return {\r\n                            label: value.label,\r\n                            link: this.normalizeRelativeLinks(value.link, path),\r\n                        };\r\n                    } else if (isBreadcrumbPairArray(value)) {\r\n                        return value.map(val => ({\r\n                            label: val.label,\r\n                            link: this.normalizeRelativeLinks(val.link, path),\r\n                        }));\r\n                    } else {\r\n                        return {\r\n                            label: value,\r\n                            link: '/' + path.join('/'),\r\n                        };\r\n                    }\r\n                }),\r\n            ) as Observable<BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[]>;\r\n        });\r\n\r\n        return observableCombineLatest(breadcrumbObservables$).pipe(map(links => flatten(links)));\r\n    }\r\n\r\n    /**\r\n     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.\r\n     */\r\n    private assembleBreadcrumbParts(\r\n        rootRoute: ActivatedRoute,\r\n    ): Array<{ value$: Observable<BreadcrumbValue>; path: string[] }> {\r\n        const breadcrumbParts: Array<{ value$: Observable<BreadcrumbValue>; path: string[] }> = [];\r\n        const inferredUrl = '';\r\n        const segmentPaths: string[] = [];\r\n        let currentRoute: ActivatedRoute | null = rootRoute;\r\n        do {\r\n            const childRoutes = currentRoute.children;\r\n            currentRoute = null;\r\n            childRoutes.forEach((route: ActivatedRoute) => {\r\n                if (route.outlet === PRIMARY_OUTLET) {\r\n                    const routeSnapshot = route.snapshot;\r\n                    let breadcrumbDef: BreadcrumbDefinition | undefined =\r\n                        route.routeConfig && route.routeConfig.data && route.routeConfig.data['breadcrumb'];\r\n                    segmentPaths.push(routeSnapshot.url.map(segment => segment.path).join('/'));\r\n\r\n                    if (breadcrumbDef) {\r\n                        if (isBreadcrumbFunction(breadcrumbDef)) {\r\n                            breadcrumbDef = breadcrumbDef(\r\n                                routeSnapshot.data,\r\n                                routeSnapshot.params,\r\n                                this.dataService,\r\n                            );\r\n                        }\r\n                        const observableValue = isObservable(breadcrumbDef)\r\n                            ? breadcrumbDef\r\n                            : observableOf(breadcrumbDef);\r\n                        breadcrumbParts.push({ value$: observableValue, path: segmentPaths.slice() });\r\n                    }\r\n                    currentRoute = route;\r\n                }\r\n            });\r\n        } while (currentRoute);\r\n\r\n        return breadcrumbParts;\r\n    }\r\n\r\n    /**\r\n     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:\r\n     * * `./`   - this appends the rest of the link segments to the current active route\r\n     * * `../`  - this removes the last segment of the current active route, and appends the link segments\r\n     *            to the parent route.\r\n     */\r\n    private normalizeRelativeLinks(link: any[], segmentPaths: string[]): any[] {\r\n        const clone = link.slice();\r\n        if (clone[0] === './') {\r\n            clone[0] = segmentPaths.join('/');\r\n        }\r\n        if (clone[0] === '../') {\r\n            clone[0] = segmentPaths.slice(0, -1).join('/');\r\n        }\r\n        return clone.filter(segment => segment !== '');\r\n    }\r\n}\r\n\r\nfunction isBreadcrumbFunction(value: BreadcrumbDefinition): value is BreadcrumbFunction {\r\n    return typeof value === 'function';\r\n}\r\n\r\nfunction isObservable(value: BreadcrumbDefinition): value is Observable<BreadcrumbValue> {\r\n    return value instanceof Observable;\r\n}\r\n\r\nfunction isBreadcrumbLabelLinkPair(value: BreadcrumbValue): value is BreadcrumbLabelLinkPair {\r\n    return value.hasOwnProperty('label') && value.hasOwnProperty('link');\r\n}\r\n\r\nfunction isBreadcrumbPairArray(value: BreadcrumbValue): value is BreadcrumbLabelLinkPair[] {\r\n    return Array.isArray(value) && isBreadcrumbLabelLinkPair(value[0]);\r\n}\r\n","<nav role=\"navigation\">\r\n    <ul class=\"breadcrumbs\">\r\n        <li *ngFor=\"let breadcrumb of (breadcrumbs$ | async); let isLast = last\">\r\n            <a [routerLink]=\"breadcrumb.link\" *ngIf=\"!isLast\">{{ breadcrumb.label | translate }}</a>\r\n            <ng-container *ngIf=\"isLast\">{{ breadcrumb.label | translate }}</ng-container>\r\n        </li>\r\n    </ul>\r\n</nav>\r\n"]}

package/esm2020/core/components/channel-switcher/channel-switcher.component.mjs

@@ -0,0 +1,58 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
+import { combineLatest } from 'rxjs';
+import { filter, map, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+import * as i2 from "../../providers/local-storage/local-storage.service";
+import * as i3 from "../../shared/components/dropdown/dropdown.component";
+import * as i4 from "../../shared/components/channel-badge/channel-badge.component";
+import * as i5 from "../../shared/components/dropdown/dropdown-menu.component";
+import * as i6 from "../../shared/components/dropdown/dropdown-trigger.directive";
+import * as i7 from "@clr/angular";
+import * as i8 from "@angular/common";
+import * as i9 from "../../shared/components/form-field/form-field-control.directive";
+import * as i10 from "@angular/forms";
+import * as i11 from "../../shared/components/dropdown/dropdown-item.directive";
+import * as i12 from "@ngx-translate/core";
+import * as i13 from "../../shared/pipes/channel-label.pipe";
+export class ChannelSwitcherComponent {
+    constructor(dataService, localStorageService) {
+        this.dataService = dataService;
+        this.localStorageService = localStorageService;
+        this.displayFilterThreshold = 10;
+        this.filterControl = new FormControl('');
+    }
+    ngOnInit() {
+        const channels$ = this.dataService.client.userStatus().mapStream(data => data.userStatus.channels);
+        const filterTerm$ = this.filterControl.valueChanges.pipe(startWith(''));
+        this.channels$ = combineLatest(channels$, filterTerm$).pipe(map(([channels, filterTerm]) => {
+            return filterTerm
+                ? channels.filter(c => c.code.toLocaleLowerCase().includes(filterTerm.toLocaleLowerCase()))
+                : channels;
+        }));
+        this.channelCount$ = channels$.pipe(map(channels => channels.length));
+        const activeChannel$ = this.dataService.client
+            .userStatus()
+            .mapStream(data => data.userStatus.channels.find(c => c.id === data.userStatus.activeChannelId))
+            .pipe(filter(notNullOrUndefined));
+        this.activeChannelCode$ = activeChannel$.pipe(map(channel => channel.code));
+    }
+    setActiveChannel(channelId) {
+        this.dataService.client.setActiveChannel(channelId).subscribe(({ setActiveChannel }) => {
+            const activeChannel = setActiveChannel.channels.find(c => c.id === channelId);
+            if (activeChannel) {
+                this.localStorageService.set('activeChannelToken', activeChannel.token);
+            }
+            this.filterControl.patchValue('');
+        });
+    }
+}
+ChannelSwitcherComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChannelSwitcherComponent, deps: [{ token: i1.DataService }, { token: i2.LocalStorageService }], target: i0.ɵɵFactoryTarget.Component });
+ChannelSwitcherComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: ChannelSwitcherComponent, selector: "vdr-channel-switcher", ngImport: i0, template: "<ng-container>\r\n    <vdr-dropdown>\r\n        <button class=\"btn btn-link active-channel\" vdrDropdownTrigger>\r\n            <vdr-channel-badge [channelCode]=\"activeChannelCode$ | async\"></vdr-channel-badge>\r\n            <span class=\"active-channel\">{{\r\n                activeChannelCode$ | async | channelCodeToLabel | translate\r\n            }}</span>\r\n            <span class=\"trigger\"><clr-icon shape=\"caret down\"></clr-icon></span>\r\n        </button>\r\n        <vdr-dropdown-menu vdrPosition=\"bottom-right\">\r\n            <input\r\n                *ngIf=\"((channelCount$ | async) || 0) >= displayFilterThreshold\"\r\n                [formControl]=\"filterControl\"\r\n                type=\"text\"\r\n                class=\"ml2 mr2\"\r\n                [placeholder]=\"'common.filter' | translate\"\r\n            />\r\n            <button\r\n                *ngFor=\"let channel of channels$ | async\"\r\n                type=\"button\"\r\n                vdrDropdownItem\r\n                (click)=\"setActiveChannel(channel.id)\"\r\n            >\r\n                <vdr-channel-badge [channelCode]=\"channel.code\"></vdr-channel-badge>\r\n                {{ channel.code | channelCodeToLabel | translate }}\r\n            </button>\r\n        </vdr-dropdown-menu>\r\n    </vdr-dropdown>\r\n</ng-container>\r\n", styles: [":host{display:flex;align-items:center;margin:0 .5rem;height:2.5rem}.active-channel{color:var(--color-grey-200)}.active-channel clr-icon{color:#fff}\n"], components: [{ type: i3.DropdownComponent, selector: "vdr-dropdown", inputs: ["manualToggle"] }, { type: i4.ChannelBadgeComponent, selector: "vdr-channel-badge", inputs: ["channelCode"] }, { type: i5.DropdownMenuComponent, selector: "vdr-dropdown-menu", inputs: ["vdrPosition"] }], directives: [{ type: i6.DropdownTriggerDirective, selector: "[vdrDropdownTrigger]" }, { type: i7.ClrIconCustomTag, selector: "clr-icon" }, { type: i8.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i9.FormFieldControlDirective, selector: "input, textarea, select" }, { type: i10.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i10.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i10.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i8.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i11.DropdownItemDirective, selector: "[vdrDropdownItem]" }], pipes: { "async": i8.AsyncPipe, "translate": i12.TranslatePipe, "channelCodeToLabel": i13.ChannelLabelPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ChannelSwitcherComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-channel-switcher', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container>\r\n    <vdr-dropdown>\r\n        <button class=\"btn btn-link active-channel\" vdrDropdownTrigger>\r\n            <vdr-channel-badge [channelCode]=\"activeChannelCode$ | async\"></vdr-channel-badge>\r\n            <span class=\"active-channel\">{{\r\n                activeChannelCode$ | async | channelCodeToLabel | translate\r\n            }}</span>\r\n            <span class=\"trigger\"><clr-icon shape=\"caret down\"></clr-icon></span>\r\n        </button>\r\n        <vdr-dropdown-menu vdrPosition=\"bottom-right\">\r\n            <input\r\n                *ngIf=\"((channelCount$ | async) || 0) >= displayFilterThreshold\"\r\n                [formControl]=\"filterControl\"\r\n                type=\"text\"\r\n                class=\"ml2 mr2\"\r\n                [placeholder]=\"'common.filter' | translate\"\r\n            />\r\n            <button\r\n                *ngFor=\"let channel of channels$ | async\"\r\n                type=\"button\"\r\n                vdrDropdownItem\r\n                (click)=\"setActiveChannel(channel.id)\"\r\n            >\r\n                <vdr-channel-badge [channelCode]=\"channel.code\"></vdr-channel-badge>\r\n                {{ channel.code | channelCodeToLabel | translate }}\r\n            </button>\r\n        </vdr-dropdown-menu>\r\n    </vdr-dropdown>\r\n</ng-container>\r\n", styles: [":host{display:flex;align-items:center;margin:0 .5rem;height:2.5rem}.active-channel{color:var(--color-grey-200)}.active-channel clr-icon{color:#fff}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i2.LocalStorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"channel-switcher.component.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/components/channel-switcher/channel-switcher.component.ts","../../../../../src/lib/core/src/components/channel-switcher/channel-switcher.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, OnInit } from '@angular/core';\r\nimport { FormControl } from '@angular/forms';\r\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\r\nimport { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\nimport { combineLatest, Observable } from 'rxjs';\r\nimport { filter, map, startWith } from 'rxjs/operators';\r\n\r\nimport { CurrentUserChannel } from '../../common/generated-types';\r\nimport { DataService } from '../../data/providers/data.service';\r\nimport { LocalStorageService } from '../../providers/local-storage/local-storage.service';\r\n\r\n@Component({\r\n    selector: 'vdr-channel-switcher',\r\n    templateUrl: './channel-switcher.component.html',\r\n    styleUrls: ['./channel-switcher.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class ChannelSwitcherComponent implements OnInit {\r\n    readonly displayFilterThreshold = 10;\r\n    channels$: Observable<CurrentUserChannel[]>;\r\n    channelCount$: Observable<number>;\r\n    filterControl = new FormControl('');\r\n    activeChannelCode$: Observable<string>;\r\n    constructor(private dataService: DataService, private localStorageService: LocalStorageService) {}\r\n\r\n    ngOnInit() {\r\n        const channels$ = this.dataService.client.userStatus().mapStream(data => data.userStatus.channels);\r\n        const filterTerm$ = this.filterControl.valueChanges.pipe<string>(startWith(''));\r\n        this.channels$ = combineLatest(channels$, filterTerm$).pipe(\r\n            map(([channels, filterTerm]) => {\r\n                return filterTerm\r\n                    ? channels.filter(c =>\r\n                          c.code.toLocaleLowerCase().includes(filterTerm.toLocaleLowerCase()),\r\n                      )\r\n                    : channels;\r\n            }),\r\n        );\r\n        this.channelCount$ = channels$.pipe(map(channels => channels.length));\r\n        const activeChannel$ = this.dataService.client\r\n            .userStatus()\r\n            .mapStream(data => data.userStatus.channels.find(c => c.id === data.userStatus.activeChannelId))\r\n            .pipe(filter(notNullOrUndefined));\r\n        this.activeChannelCode$ = activeChannel$.pipe(map(channel => channel.code));\r\n    }\r\n\r\n    setActiveChannel(channelId: string) {\r\n        this.dataService.client.setActiveChannel(channelId).subscribe(({ setActiveChannel }) => {\r\n            const activeChannel = setActiveChannel.channels.find(c => c.id === channelId);\r\n            if (activeChannel) {\r\n                this.localStorageService.set('activeChannelToken', activeChannel.token);\r\n            }\r\n            this.filterControl.patchValue('');\r\n        });\r\n    }\r\n}\r\n","<ng-container>\r\n    <vdr-dropdown>\r\n        <button class=\"btn btn-link active-channel\" vdrDropdownTrigger>\r\n            <vdr-channel-badge [channelCode]=\"activeChannelCode$ | async\"></vdr-channel-badge>\r\n            <span class=\"active-channel\">{{\r\n                activeChannelCode$ | async | channelCodeToLabel | translate\r\n            }}</span>\r\n            <span class=\"trigger\"><clr-icon shape=\"caret down\"></clr-icon></span>\r\n        </button>\r\n        <vdr-dropdown-menu vdrPosition=\"bottom-right\">\r\n            <input\r\n                *ngIf=\"((channelCount$ | async) || 0) >= displayFilterThreshold\"\r\n                [formControl]=\"filterControl\"\r\n                type=\"text\"\r\n                class=\"ml2 mr2\"\r\n                [placeholder]=\"'common.filter' | translate\"\r\n            />\r\n            <button\r\n                *ngFor=\"let channel of channels$ | async\"\r\n                type=\"button\"\r\n                vdrDropdownItem\r\n                (click)=\"setActiveChannel(channel.id)\"\r\n            >\r\n                <vdr-channel-badge [channelCode]=\"channel.code\"></vdr-channel-badge>\r\n                {{ channel.code | channelCodeToLabel | translate }}\r\n            </button>\r\n        </vdr-dropdown-menu>\r\n    </vdr-dropdown>\r\n</ng-container>\r\n"]}

package/esm2020/core/components/main-nav/main-nav.component.mjs

@@ -0,0 +1,270 @@
+import { Component } from '@angular/core';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { map, startWith } from 'rxjs/operators';
+import { Permission } from '../../common/generated-types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../providers/nav-builder/nav-builder.service";
+import * as i3 from "../../providers/health-check/health-check.service";
+import * as i4 from "../../providers/job-queue/job-queue.service";
+import * as i5 from "../../data/providers/data.service";
+import * as i6 from "../../shared/components/ui-extension-point/ui-extension-point.component";
+import * as i7 from "../../shared/components/status-badge/status-badge.component";
+import * as i8 from "@clr/angular";
+import * as i9 from "@angular/common";
+import * as i10 from "../../shared/components/form-field/form-field-control.directive";
+import * as i11 from "@ngx-translate/core";
+export class MainNavComponent {
+    constructor(route, router, navBuilderService, healthCheckService, jobQueueService, dataService) {
+        this.route = route;
+        this.router = router;
+        this.navBuilderService = navBuilderService;
+        this.healthCheckService = healthCheckService;
+        this.jobQueueService = jobQueueService;
+        this.dataService = dataService;
+    }
+    shouldDisplayLink(menuItem) {
+        if (!this.userPermissions) {
+            return false;
+        }
+        if (!menuItem.requiresPermission) {
+            return true;
+        }
+        if (typeof menuItem.requiresPermission === 'string') {
+            return this.userPermissions.includes(menuItem.requiresPermission);
+        }
+        if (typeof menuItem.requiresPermission === 'function') {
+            return menuItem.requiresPermission(this.userPermissions);
+        }
+    }
+    ngOnInit() {
+        this.defineNavMenu();
+        this.subscription = this.dataService.client
+            .userStatus()
+            .mapStream(({ userStatus }) => {
+            this.userPermissions = userStatus.permissions;
+        })
+            .subscribe();
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    getRouterLink(item) {
+        return this.navBuilderService.getRouterLink(item, this.route);
+    }
+    defineNavMenu() {
+        function allow(...permissions) {
+            return userPermissions => {
+                for (const permission of permissions) {
+                    if (userPermissions.includes(permission)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+        }
+        this.navBuilderService.defineNavMenuSections([
+            {
+                requiresPermission: allow(Permission.ReadCatalog, Permission.ReadProduct, Permission.ReadFacet, Permission.ReadCollection, Permission.ReadAsset),
+                id: 'catalog',
+                label: _('nav.catalog'),
+                items: [
+                    {
+                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadProduct),
+                        id: 'products',
+                        label: _('nav.products'),
+                        icon: 'library',
+                        routerLink: ['/catalog', 'products'],
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadFacet),
+                        id: 'facets',
+                        label: _('nav.facets'),
+                        icon: 'tag',
+                        routerLink: ['/catalog', 'facets'],
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadCollection),
+                        id: 'collections',
+                        label: _('nav.collections'),
+                        icon: 'folder-open',
+                        routerLink: ['/catalog', 'collections'],
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadAsset),
+                        id: 'assets',
+                        label: _('nav.assets'),
+                        icon: 'image-gallery',
+                        routerLink: ['/catalog', 'assets'],
+                    },
+                ],
+            },
+            {
+                id: 'sales',
+                label: _('nav.sales'),
+                requiresPermission: allow(Permission.ReadOrder),
+                items: [
+                    {
+                        requiresPermission: allow(Permission.ReadOrder),
+                        id: 'orders',
+                        label: _('nav.orders'),
+                        routerLink: ['/orders'],
+                        icon: 'shopping-cart',
+                    },
+                ],
+            },
+            {
+                id: 'customers',
+                label: _('nav.customers'),
+                requiresPermission: allow(Permission.ReadCustomer, Permission.ReadCustomerGroup),
+                items: [
+                    {
+                        requiresPermission: allow(Permission.ReadCustomer),
+                        id: 'customers',
+                        label: _('nav.customers'),
+                        routerLink: ['/customer', 'customers'],
+                        icon: 'user',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadCustomerGroup),
+                        id: 'customer-groups',
+                        label: _('nav.customer-groups'),
+                        routerLink: ['/customer', 'groups'],
+                        icon: 'users',
+                    },
+                ],
+            },
+            {
+                id: 'marketing',
+                label: _('nav.marketing'),
+                requiresPermission: allow(Permission.ReadPromotion),
+                items: [
+                    {
+                        requiresPermission: allow(Permission.ReadPromotion),
+                        id: 'promotions',
+                        label: _('nav.promotions'),
+                        routerLink: ['/marketing', 'promotions'],
+                        icon: 'asterisk',
+                    },
+                ],
+            },
+            {
+                id: 'settings',
+                label: _('nav.settings'),
+                requiresPermission: allow(Permission.ReadSettings, Permission.ReadChannel, Permission.ReadAdministrator, Permission.ReadShippingMethod, Permission.ReadPaymentMethod, Permission.ReadTaxCategory, Permission.ReadTaxRate, Permission.ReadCountry, Permission.ReadZone, Permission.UpdateGlobalSettings),
+                collapsible: true,
+                collapsedByDefault: true,
+                items: [
+                    {
+                        requiresPermission: allow(Permission.ReadChannel),
+                        id: 'channels',
+                        label: _('nav.channels'),
+                        routerLink: ['/settings', 'channels'],
+                        icon: 'layers',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadAdministrator),
+                        id: 'administrators',
+                        label: _('nav.administrators'),
+                        routerLink: ['/settings', 'administrators'],
+                        icon: 'administrator',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadAdministrator),
+                        id: 'roles',
+                        label: _('nav.roles'),
+                        routerLink: ['/settings', 'roles'],
+                        icon: 'users',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadShippingMethod),
+                        id: 'shipping-methods',
+                        label: _('nav.shipping-methods'),
+                        routerLink: ['/settings', 'shipping-methods'],
+                        icon: 'truck',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadPaymentMethod),
+                        id: 'payment-methods',
+                        label: _('nav.payment-methods'),
+                        routerLink: ['/settings', 'payment-methods'],
+                        icon: 'credit-card',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadTaxCategory),
+                        id: 'tax-categories',
+                        label: _('nav.tax-categories'),
+                        routerLink: ['/settings', 'tax-categories'],
+                        icon: 'view-list',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadTaxRate),
+                        id: 'tax-rates',
+                        label: _('nav.tax-rates'),
+                        routerLink: ['/settings', 'tax-rates'],
+                        icon: 'calculator',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadCountry),
+                        id: 'countries',
+                        label: _('nav.countries'),
+                        routerLink: ['/settings', 'countries'],
+                        icon: 'flag',
+                    },
+                    {
+                        requiresPermission: allow(Permission.ReadZone),
+                        id: 'zones',
+                        label: _('nav.zones'),
+                        routerLink: ['/settings', 'zones'],
+                        icon: 'world',
+                    },
+                    {
+                        requiresPermission: allow(Permission.UpdateGlobalSettings),
+                        id: 'global-settings',
+                        label: _('nav.global-settings'),
+                        routerLink: ['/settings', 'global-settings'],
+                        icon: 'cog',
+                    },
+                ],
+            },
+            {
+                id: 'system',
+                label: _('nav.system'),
+                requiresPermission: Permission.ReadSystem,
+                collapsible: true,
+                collapsedByDefault: true,
+                items: [
+                    {
+                        id: 'job-queue',
+                        label: _('nav.job-queue'),
+                        routerLink: ['/system', 'jobs'],
+                        icon: 'tick-chart',
+                        statusBadge: this.jobQueueService.activeJobs$.pipe(startWith([]), map(jobs => ({
+                            type: jobs.length === 0 ? 'none' : 'info',
+                            propagateToSection: jobs.length > 0,
+                        }))),
+                    },
+                    {
+                        id: 'system-status',
+                        label: _('nav.system-status'),
+                        routerLink: ['/system', 'system-status'],
+                        icon: 'rack-server',
+                        statusBadge: this.healthCheckService.status$.pipe(map(status => ({
+                            type: status === 'ok' ? 'success' : 'error',
+                            propagateToSection: status === 'error',
+                        }))),
+                    },
+                ],
+            },
+        ]);
+    }
+}
+MainNavComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MainNavComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.NavBuilderService }, { token: i3.HealthCheckService }, { token: i4.JobQueueService }, { token: i5.DataService }], target: i0.ɵɵFactoryTarget.Component });
+MainNavComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: MainNavComponent, selector: "vdr-main-nav", ngImport: i0, template: "<nav class=\"sidenav\" [clr-nav-level]=\"2\">\r\n    <section class=\"sidenav-content\">\r\n        <ng-container *ngFor=\"let section of navBuilderService.navMenuConfig$ | async\">\r\n            <section\r\n                class=\"nav-group\"\r\n                [attr.data-section-id]=\"section.id\"\r\n                [class.collapsible]=\"section.collapsible\"\r\n                *ngIf=\"shouldDisplayLink(section)\"\r\n            >\r\n                <vdr-ui-extension-point [locationId]=\"section.id\" api=\"navMenu\" [topPx]=\"-6\" [leftPx]=\"8\">\r\n                    <ng-container *ngIf=\"navBuilderService.sectionBadges[section.id] | async as sectionBadge\">\r\n                        <vdr-status-badge\r\n                            *ngIf=\"sectionBadge !== 'none'\"\r\n                            [type]=\"sectionBadge\"\r\n                        ></vdr-status-badge>\r\n                    </ng-container>\r\n                    <input [id]=\"section.id\" type=\"checkbox\" [checked]=\"section.collapsedByDefault\" />\r\n                    <label class=\"nav-group-header\" [for]=\"section.id\">{{ section.label | translate }}</label>\r\n                    <ul class=\"nav-list\">\r\n                        <ng-container *ngFor=\"let item of section.items\">\r\n                            <li *ngIf=\"shouldDisplayLink(item)\">\r\n                                <a\r\n                                    class=\"nav-link\"\r\n                                    [attr.data-item-id]=\"section.id\"\r\n                                    [routerLink]=\"getRouterLink(item)\"\r\n                                    routerLinkActive=\"active\"\r\n                                >\r\n                                    <ng-container *ngIf=\"item.statusBadge | async as itemBadge\">\r\n                                        <vdr-status-badge\r\n                                            *ngIf=\"itemBadge.type !== 'none'\"\r\n                                            [type]=\"itemBadge.type\"\r\n                                        ></vdr-status-badge>\r\n                                    </ng-container>\r\n                                    <clr-icon [attr.shape]=\"item.icon || 'block'\" size=\"20\"></clr-icon>\r\n                                    {{ item.label | translate }}\r\n                                </a>\r\n                            </li>\r\n                        </ng-container>\r\n                    </ul>\r\n                </vdr-ui-extension-point>\r\n            </section>\r\n        </ng-container>\r\n    </section>\r\n</nav>\r\n", styles: [":host{order:-1;background-color:var(--clr-nav-background-color)}nav.sidenav{height:100%;width:10.8rem;border-right-color:var(--clr-sidenav-border-color)}.sidenav .nav-group .nav-list{margin:0}.sidenav .nav-group .nav-group-header{margin:0;line-height:1.2}.sidenav .nav-group .nav-link{display:inline-flex;line-height:1rem;padding-right:.6rem}.nav-list clr-icon{flex-shrink:0;margin-right:12px}.nav-group{-webkit-hyphens:auto;hyphens:auto}.nav-group,.nav-link{position:relative}.nav-group vdr-status-badge{left:10px;top:6px}.nav-link vdr-status-badge{left:25px;top:3px}\n"], components: [{ type: i6.UiExtensionPointComponent, selector: "vdr-ui-extension-point", inputs: ["locationId", "topPx", "leftPx", "api"] }, { type: i7.StatusBadgeComponent, selector: "vdr-status-badge", inputs: ["type"] }], directives: [{ type: i8.ClrNavLevel, selector: "[clr-nav-level]", inputs: ["clr-nav-level"] }, { type: i9.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i9.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i10.FormFieldControlDirective, selector: "input, textarea, select" }, { type: i8.ClrLabel, selector: "label", inputs: ["for"] }, { type: i1.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo", "routerLink"] }, { type: i1.RouterLinkActive, selector: "[routerLinkActive]", inputs: ["routerLinkActiveOptions", "routerLinkActive"], outputs: ["isActiveChange"], exportAs: ["routerLinkActive"] }, { type: i8.ClrIconCustomTag, selector: "clr-icon" }], pipes: { "async": i9.AsyncPipe, "translate": i11.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: MainNavComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-main-nav', template: "<nav class=\"sidenav\" [clr-nav-level]=\"2\">\r\n    <section class=\"sidenav-content\">\r\n        <ng-container *ngFor=\"let section of navBuilderService.navMenuConfig$ | async\">\r\n            <section\r\n                class=\"nav-group\"\r\n                [attr.data-section-id]=\"section.id\"\r\n                [class.collapsible]=\"section.collapsible\"\r\n                *ngIf=\"shouldDisplayLink(section)\"\r\n            >\r\n                <vdr-ui-extension-point [locationId]=\"section.id\" api=\"navMenu\" [topPx]=\"-6\" [leftPx]=\"8\">\r\n                    <ng-container *ngIf=\"navBuilderService.sectionBadges[section.id] | async as sectionBadge\">\r\n                        <vdr-status-badge\r\n                            *ngIf=\"sectionBadge !== 'none'\"\r\n                            [type]=\"sectionBadge\"\r\n                        ></vdr-status-badge>\r\n                    </ng-container>\r\n                    <input [id]=\"section.id\" type=\"checkbox\" [checked]=\"section.collapsedByDefault\" />\r\n                    <label class=\"nav-group-header\" [for]=\"section.id\">{{ section.label | translate }}</label>\r\n                    <ul class=\"nav-list\">\r\n                        <ng-container *ngFor=\"let item of section.items\">\r\n                            <li *ngIf=\"shouldDisplayLink(item)\">\r\n                                <a\r\n                                    class=\"nav-link\"\r\n                                    [attr.data-item-id]=\"section.id\"\r\n                                    [routerLink]=\"getRouterLink(item)\"\r\n                                    routerLinkActive=\"active\"\r\n                                >\r\n                                    <ng-container *ngIf=\"item.statusBadge | async as itemBadge\">\r\n                                        <vdr-status-badge\r\n                                            *ngIf=\"itemBadge.type !== 'none'\"\r\n                                            [type]=\"itemBadge.type\"\r\n                                        ></vdr-status-badge>\r\n                                    </ng-container>\r\n                                    <clr-icon [attr.shape]=\"item.icon || 'block'\" size=\"20\"></clr-icon>\r\n                                    {{ item.label | translate }}\r\n                                </a>\r\n                            </li>\r\n                        </ng-container>\r\n                    </ul>\r\n                </vdr-ui-extension-point>\r\n            </section>\r\n        </ng-container>\r\n    </section>\r\n</nav>\r\n", styles: [":host{order:-1;background-color:var(--clr-nav-background-color)}nav.sidenav{height:100%;width:10.8rem;border-right-color:var(--clr-sidenav-border-color)}.sidenav .nav-group .nav-list{margin:0}.sidenav .nav-group .nav-group-header{margin:0;line-height:1.2}.sidenav .nav-group .nav-link{display:inline-flex;line-height:1rem;padding-right:.6rem}.nav-list clr-icon{flex-shrink:0;margin-right:12px}.nav-group{-webkit-hyphens:auto;hyphens:auto}.nav-group,.nav-link{position:relative}.nav-group vdr-status-badge{left:10px;top:6px}.nav-link vdr-status-badge{left:25px;top:3px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i1.Router }, { type: i2.NavBuilderService }, { type: i3.HealthCheckService }, { type: i4.JobQueueService }, { type: i5.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main-nav.component.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/components/main-nav/main-nav.component.ts","../../../../../src/lib/core/src/components/main-nav/main-nav.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAqB,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,yCAAyC,CAAC;AAEtE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;;;;;;;;;;;;;AAY1D,MAAM,OAAO,gBAAgB;IACzB,YACY,KAAqB,EACrB,MAAc,EACf,iBAAoC,EACnC,kBAAsC,EACtC,eAAgC,EAChC,WAAwB;QALxB,UAAK,GAAL,KAAK,CAAgB;QACrB,WAAM,GAAN,MAAM,CAAQ;QACf,sBAAiB,GAAjB,iBAAiB,CAAmB;QACnC,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,oBAAe,GAAf,eAAe,CAAiB;QAChC,gBAAW,GAAX,WAAW,CAAa;IACjC,CAAC;IAKJ,iBAAiB,CAAC,QAAiD;QAC/D,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACvB,OAAO,KAAK,CAAC;SAChB;QACD,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE;YAC9B,OAAO,IAAI,CAAC;SACf;QACD,IAAI,OAAO,QAAQ,CAAC,kBAAkB,KAAK,QAAQ,EAAE;YACjD,OAAO,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;SACrE;QACD,IAAI,OAAO,QAAQ,CAAC,kBAAkB,KAAK,UAAU,EAAE;YACnD,OAAO,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SAC5D;IACL,CAAC;IAED,QAAQ;QACJ,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM;aACtC,UAAU,EAAE;aACZ,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;YAC1B,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,WAAW,CAAC;QAClD,CAAC,CAAC;aACD,SAAS,EAAE,CAAC;IACrB,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;SACnC;IACL,CAAC;IAED,aAAa,CAAC,IAAiB;QAC3B,OAAO,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC;IAEO,aAAa;QACjB,SAAS,KAAK,CAAC,GAAG,WAAqB;YACnC,OAAO,eAAe,CAAC,EAAE;gBACrB,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;oBAClC,IAAI,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;wBACtC,OAAO,IAAI,CAAC;qBACf;iBACJ;gBACD,OAAO,KAAK,CAAC;YACjB,CAAC,CAAC;QACN,CAAC;QAED,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,CAAC;YACzC;gBACI,kBAAkB,EAAE,KAAK,CACrB,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,SAAS,EACpB,UAAU,CAAC,cAAc,EACzB,UAAU,CAAC,SAAS,CACvB;gBACD,EAAE,EAAE,SAAS;gBACb,KAAK,EAAE,CAAC,CAAC,aAAa,CAAC;gBACvB,KAAK,EAAE;oBACH;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC;wBACzE,EAAE,EAAE,UAAU;wBACd,KAAK,EAAE,CAAC,CAAC,cAAc,CAAC;wBACxB,IAAI,EAAE,SAAS;wBACf,UAAU,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC;qBACvC;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,SAAS,CAAC;wBACvE,EAAE,EAAE,QAAQ;wBACZ,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC;wBACtB,IAAI,EAAE,KAAK;wBACX,UAAU,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;qBACrC;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,cAAc,CAAC;wBAC5E,EAAE,EAAE,aAAa;wBACjB,KAAK,EAAE,CAAC,CAAC,iBAAiB,CAAC;wBAC3B,IAAI,EAAE,aAAa;wBACnB,UAAU,EAAE,CAAC,UAAU,EAAE,aAAa,CAAC;qBAC1C;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,SAAS,CAAC;wBACvE,EAAE,EAAE,QAAQ;wBACZ,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC;wBACtB,IAAI,EAAE,eAAe;wBACrB,UAAU,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;qBACrC;iBACJ;aACJ;YACD;gBACI,EAAE,EAAE,OAAO;gBACX,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC;gBACrB,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC;gBAC/C,KAAK,EAAE;oBACH;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC;wBAC/C,EAAE,EAAE,QAAQ;wBACZ,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC;wBACtB,UAAU,EAAE,CAAC,SAAS,CAAC;wBACvB,IAAI,EAAE,eAAe;qBACxB;iBACJ;aACJ;YACD;gBACI,EAAE,EAAE,WAAW;gBACf,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;gBACzB,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,YAAY,EAAE,UAAU,CAAC,iBAAiB,CAAC;gBAChF,KAAK,EAAE;oBACH;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC;wBAClD,EAAE,EAAE,WAAW;wBACf,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;wBACzB,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;wBACtC,IAAI,EAAE,MAAM;qBACf;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC;wBACvD,EAAE,EAAE,iBAAiB;wBACrB,KAAK,EAAE,CAAC,CAAC,qBAAqB,CAAC;wBAC/B,UAAU,EAAE,CAAC,WAAW,EAAE,QAAQ,CAAC;wBACnC,IAAI,EAAE,OAAO;qBAChB;iBACJ;aACJ;YACD;gBACI,EAAE,EAAE,WAAW;gBACf,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;gBACzB,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC;gBACnD,KAAK,EAAE;oBACH;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC;wBACnD,EAAE,EAAE,YAAY;wBAChB,KAAK,EAAE,CAAC,CAAC,gBAAgB,CAAC;wBAC1B,UAAU,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC;wBACxC,IAAI,EAAE,UAAU;qBACnB;iBACJ;aACJ;YACD;gBACI,EAAE,EAAE,UAAU;gBACd,KAAK,EAAE,CAAC,CAAC,cAAc,CAAC;gBACxB,kBAAkB,EAAE,KAAK,CACrB,UAAU,CAAC,YAAY,EACvB,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,iBAAiB,EAC5B,UAAU,CAAC,kBAAkB,EAC7B,UAAU,CAAC,iBAAiB,EAC5B,UAAU,CAAC,eAAe,EAC1B,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,QAAQ,EACnB,UAAU,CAAC,oBAAoB,CAClC;gBACD,WAAW,EAAE,IAAI;gBACjB,kBAAkB,EAAE,IAAI;gBACxB,KAAK,EAAE;oBACH;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC;wBACjD,EAAE,EAAE,UAAU;wBACd,KAAK,EAAE,CAAC,CAAC,cAAc,CAAC;wBACxB,UAAU,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC;wBACrC,IAAI,EAAE,QAAQ;qBACjB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC;wBACvD,EAAE,EAAE,gBAAgB;wBACpB,KAAK,EAAE,CAAC,CAAC,oBAAoB,CAAC;wBAC9B,UAAU,EAAE,CAAC,WAAW,EAAE,gBAAgB,CAAC;wBAC3C,IAAI,EAAE,eAAe;qBACxB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC;wBACvD,EAAE,EAAE,OAAO;wBACX,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC;wBACrB,UAAU,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC;wBAClC,IAAI,EAAE,OAAO;qBAChB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,kBAAkB,CAAC;wBACxD,EAAE,EAAE,kBAAkB;wBACtB,KAAK,EAAE,CAAC,CAAC,sBAAsB,CAAC;wBAChC,UAAU,EAAE,CAAC,WAAW,EAAE,kBAAkB,CAAC;wBAC7C,IAAI,EAAE,OAAO;qBAChB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC;wBACvD,EAAE,EAAE,iBAAiB;wBACrB,KAAK,EAAE,CAAC,CAAC,qBAAqB,CAAC;wBAC/B,UAAU,EAAE,CAAC,WAAW,EAAE,iBAAiB,CAAC;wBAC5C,IAAI,EAAE,aAAa;qBACtB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,eAAe,CAAC;wBACrD,EAAE,EAAE,gBAAgB;wBACpB,KAAK,EAAE,CAAC,CAAC,oBAAoB,CAAC;wBAC9B,UAAU,EAAE,CAAC,WAAW,EAAE,gBAAgB,CAAC;wBAC3C,IAAI,EAAE,WAAW;qBACpB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC;wBACjD,EAAE,EAAE,WAAW;wBACf,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;wBACzB,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;wBACtC,IAAI,EAAE,YAAY;qBACrB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC;wBACjD,EAAE,EAAE,WAAW;wBACf,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;wBACzB,UAAU,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;wBACtC,IAAI,EAAE,MAAM;qBACf;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC;wBAC9C,EAAE,EAAE,OAAO;wBACX,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC;wBACrB,UAAU,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC;wBAClC,IAAI,EAAE,OAAO;qBAChB;oBACD;wBACI,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,oBAAoB,CAAC;wBAC1D,EAAE,EAAE,iBAAiB;wBACrB,KAAK,EAAE,CAAC,CAAC,qBAAqB,CAAC;wBAC/B,UAAU,EAAE,CAAC,WAAW,EAAE,iBAAiB,CAAC;wBAC5C,IAAI,EAAE,KAAK;qBACd;iBACJ;aACJ;YACD;gBACI,EAAE,EAAE,QAAQ;gBACZ,KAAK,EAAE,CAAC,CAAC,YAAY,CAAC;gBACtB,kBAAkB,EAAE,UAAU,CAAC,UAAU;gBACzC,WAAW,EAAE,IAAI;gBACjB,kBAAkB,EAAE,IAAI;gBACxB,KAAK,EAAE;oBACH;wBACI,EAAE,EAAE,WAAW;wBACf,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;wBACzB,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC;wBAC/B,IAAI,EAAE,YAAY;wBAClB,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAC9C,SAAS,CAAC,EAAE,CAAC,EACb,GAAG,CACC,IAAI,CAAC,EAAE,CACH,CAAC;4BACG,IAAI,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;4BACzC,kBAAkB,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC;yBACrB,CAAA,CACzB,CACJ;qBACJ;oBACD;wBACI,EAAE,EAAE,eAAe;wBACnB,KAAK,EAAE,CAAC,CAAC,mBAAmB,CAAC;wBAC7B,UAAU,EAAE,CAAC,SAAS,EAAE,eAAe,CAAC;wBACxC,IAAI,EAAE,aAAa;wBACnB,WAAW,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAC7C,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;4BACX,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO;4BAC3C,kBAAkB,EAAE,MAAM,KAAK,OAAO;yBACzC,CAAC,CAAC,CACN;qBACJ;iBACJ;aACJ;SACJ,CAAC,CAAC;IACP,CAAC;;6GAvRQ,gBAAgB;iGAAhB,gBAAgB,oDClB7B,qiFA4CA;2FD1Ba,gBAAgB;kBAL5B,SAAS;+BACI,cAAc","sourcesContent":["import { Component, OnDestroy, OnInit } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\nimport { Subscription } from 'rxjs';\nimport { map, startWith } from 'rxjs/operators';\n\nimport { Permission } from '../../common/generated-types';\nimport { DataService } from '../../data/providers/data.service';\nimport { HealthCheckService } from '../../providers/health-check/health-check.service';\nimport { JobQueueService } from '../../providers/job-queue/job-queue.service';\nimport { NavMenuBadge, NavMenuItem } from '../../providers/nav-builder/nav-builder-types';\nimport { NavBuilderService } from '../../providers/nav-builder/nav-builder.service';\n\n@Component({\n    selector: 'vdr-main-nav',\n    templateUrl: './main-nav.component.html',\n    styleUrls: ['./main-nav.component.scss'],\n})\nexport class MainNavComponent implements OnInit, OnDestroy {\n    constructor(\n        private route: ActivatedRoute,\n        private router: Router,\n        public navBuilderService: NavBuilderService,\n        private healthCheckService: HealthCheckService,\n        private jobQueueService: JobQueueService,\n        private dataService: DataService,\n    ) {}\n\n    private userPermissions: string[];\n    private subscription: Subscription;\n\n    shouldDisplayLink(menuItem: Pick<NavMenuItem, 'requiresPermission'>) {\n        if (!this.userPermissions) {\n            return false;\n        }\n        if (!menuItem.requiresPermission) {\n            return true;\n        }\n        if (typeof menuItem.requiresPermission === 'string') {\n            return this.userPermissions.includes(menuItem.requiresPermission);\n        }\n        if (typeof menuItem.requiresPermission === 'function') {\n            return menuItem.requiresPermission(this.userPermissions);\n        }\n    }\n\n    ngOnInit(): void {\n        this.defineNavMenu();\n        this.subscription = this.dataService.client\n            .userStatus()\n            .mapStream(({ userStatus }) => {\n                this.userPermissions = userStatus.permissions;\n            })\n            .subscribe();\n    }\n\n    ngOnDestroy() {\n        if (this.subscription) {\n            this.subscription.unsubscribe();\n        }\n    }\n\n    getRouterLink(item: NavMenuItem) {\n        return this.navBuilderService.getRouterLink(item, this.route);\n    }\n\n    private defineNavMenu() {\n        function allow(...permissions: string[]): (userPermissions: string[]) => boolean {\n            return userPermissions => {\n                for (const permission of permissions) {\n                    if (userPermissions.includes(permission)) {\n                        return true;\n                    }\n                }\n                return false;\n            };\n        }\n\n        this.navBuilderService.defineNavMenuSections([\n            {\n                requiresPermission: allow(\n                    Permission.ReadCatalog,\n                    Permission.ReadProduct,\n                    Permission.ReadFacet,\n                    Permission.ReadCollection,\n                    Permission.ReadAsset,\n                ),\n                id: 'catalog',\n                label: _('nav.catalog'),\n                items: [\n                    {\n                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadProduct),\n                        id: 'products',\n                        label: _('nav.products'),\n                        icon: 'library',\n                        routerLink: ['/catalog', 'products'],\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadFacet),\n                        id: 'facets',\n                        label: _('nav.facets'),\n                        icon: 'tag',\n                        routerLink: ['/catalog', 'facets'],\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadCollection),\n                        id: 'collections',\n                        label: _('nav.collections'),\n                        icon: 'folder-open',\n                        routerLink: ['/catalog', 'collections'],\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadCatalog, Permission.ReadAsset),\n                        id: 'assets',\n                        label: _('nav.assets'),\n                        icon: 'image-gallery',\n                        routerLink: ['/catalog', 'assets'],\n                    },\n                ],\n            },\n            {\n                id: 'sales',\n                label: _('nav.sales'),\n                requiresPermission: allow(Permission.ReadOrder),\n                items: [\n                    {\n                        requiresPermission: allow(Permission.ReadOrder),\n                        id: 'orders',\n                        label: _('nav.orders'),\n                        routerLink: ['/orders'],\n                        icon: 'shopping-cart',\n                    },\n                ],\n            },\n            {\n                id: 'customers',\n                label: _('nav.customers'),\n                requiresPermission: allow(Permission.ReadCustomer, Permission.ReadCustomerGroup),\n                items: [\n                    {\n                        requiresPermission: allow(Permission.ReadCustomer),\n                        id: 'customers',\n                        label: _('nav.customers'),\n                        routerLink: ['/customer', 'customers'],\n                        icon: 'user',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadCustomerGroup),\n                        id: 'customer-groups',\n                        label: _('nav.customer-groups'),\n                        routerLink: ['/customer', 'groups'],\n                        icon: 'users',\n                    },\n                ],\n            },\n            {\n                id: 'marketing',\n                label: _('nav.marketing'),\n                requiresPermission: allow(Permission.ReadPromotion),\n                items: [\n                    {\n                        requiresPermission: allow(Permission.ReadPromotion),\n                        id: 'promotions',\n                        label: _('nav.promotions'),\n                        routerLink: ['/marketing', 'promotions'],\n                        icon: 'asterisk',\n                    },\n                ],\n            },\n            {\n                id: 'settings',\n                label: _('nav.settings'),\n                requiresPermission: allow(\n                    Permission.ReadSettings,\n                    Permission.ReadChannel,\n                    Permission.ReadAdministrator,\n                    Permission.ReadShippingMethod,\n                    Permission.ReadPaymentMethod,\n                    Permission.ReadTaxCategory,\n                    Permission.ReadTaxRate,\n                    Permission.ReadCountry,\n                    Permission.ReadZone,\n                    Permission.UpdateGlobalSettings,\n                ),\n                collapsible: true,\n                collapsedByDefault: true,\n                items: [\n                    {\n                        requiresPermission: allow(Permission.ReadChannel),\n                        id: 'channels',\n                        label: _('nav.channels'),\n                        routerLink: ['/settings', 'channels'],\n                        icon: 'layers',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadAdministrator),\n                        id: 'administrators',\n                        label: _('nav.administrators'),\n                        routerLink: ['/settings', 'administrators'],\n                        icon: 'administrator',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadAdministrator),\n                        id: 'roles',\n                        label: _('nav.roles'),\n                        routerLink: ['/settings', 'roles'],\n                        icon: 'users',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadShippingMethod),\n                        id: 'shipping-methods',\n                        label: _('nav.shipping-methods'),\n                        routerLink: ['/settings', 'shipping-methods'],\n                        icon: 'truck',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadPaymentMethod),\n                        id: 'payment-methods',\n                        label: _('nav.payment-methods'),\n                        routerLink: ['/settings', 'payment-methods'],\n                        icon: 'credit-card',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadTaxCategory),\n                        id: 'tax-categories',\n                        label: _('nav.tax-categories'),\n                        routerLink: ['/settings', 'tax-categories'],\n                        icon: 'view-list',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadTaxRate),\n                        id: 'tax-rates',\n                        label: _('nav.tax-rates'),\n                        routerLink: ['/settings', 'tax-rates'],\n                        icon: 'calculator',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadCountry),\n                        id: 'countries',\n                        label: _('nav.countries'),\n                        routerLink: ['/settings', 'countries'],\n                        icon: 'flag',\n                    },\n                    {\n                        requiresPermission: allow(Permission.ReadZone),\n                        id: 'zones',\n                        label: _('nav.zones'),\n                        routerLink: ['/settings', 'zones'],\n                        icon: 'world',\n                    },\n                    {\n                        requiresPermission: allow(Permission.UpdateGlobalSettings),\n                        id: 'global-settings',\n                        label: _('nav.global-settings'),\n                        routerLink: ['/settings', 'global-settings'],\n                        icon: 'cog',\n                    },\n                ],\n            },\n            {\n                id: 'system',\n                label: _('nav.system'),\n                requiresPermission: Permission.ReadSystem,\n                collapsible: true,\n                collapsedByDefault: true,\n                items: [\n                    {\n                        id: 'job-queue',\n                        label: _('nav.job-queue'),\n                        routerLink: ['/system', 'jobs'],\n                        icon: 'tick-chart',\n                        statusBadge: this.jobQueueService.activeJobs$.pipe(\n                            startWith([]),\n                            map(\n                                jobs =>\n                                    ({\n                                        type: jobs.length === 0 ? 'none' : 'info',\n                                        propagateToSection: jobs.length > 0,\n                                    } as NavMenuBadge),\n                            ),\n                        ),\n                    },\n                    {\n                        id: 'system-status',\n                        label: _('nav.system-status'),\n                        routerLink: ['/system', 'system-status'],\n                        icon: 'rack-server',\n                        statusBadge: this.healthCheckService.status$.pipe(\n                            map(status => ({\n                                type: status === 'ok' ? 'success' : 'error',\n                                propagateToSection: status === 'error',\n                            })),\n                        ),\n                    },\n                ],\n            },\n        ]);\n    }\n}\n","<nav class=\"sidenav\" [clr-nav-level]=\"2\">\r\n    <section class=\"sidenav-content\">\r\n        <ng-container *ngFor=\"let section of navBuilderService.navMenuConfig$ | async\">\r\n            <section\r\n                class=\"nav-group\"\r\n                [attr.data-section-id]=\"section.id\"\r\n                [class.collapsible]=\"section.collapsible\"\r\n                *ngIf=\"shouldDisplayLink(section)\"\r\n            >\r\n                <vdr-ui-extension-point [locationId]=\"section.id\" api=\"navMenu\" [topPx]=\"-6\" [leftPx]=\"8\">\r\n                    <ng-container *ngIf=\"navBuilderService.sectionBadges[section.id] | async as sectionBadge\">\r\n                        <vdr-status-badge\r\n                            *ngIf=\"sectionBadge !== 'none'\"\r\n                            [type]=\"sectionBadge\"\r\n                        ></vdr-status-badge>\r\n                    </ng-container>\r\n                    <input [id]=\"section.id\" type=\"checkbox\" [checked]=\"section.collapsedByDefault\" />\r\n                    <label class=\"nav-group-header\" [for]=\"section.id\">{{ section.label | translate }}</label>\r\n                    <ul class=\"nav-list\">\r\n                        <ng-container *ngFor=\"let item of section.items\">\r\n                            <li *ngIf=\"shouldDisplayLink(item)\">\r\n                                <a\r\n                                    class=\"nav-link\"\r\n                                    [attr.data-item-id]=\"section.id\"\r\n                                    [routerLink]=\"getRouterLink(item)\"\r\n                                    routerLinkActive=\"active\"\r\n                                >\r\n                                    <ng-container *ngIf=\"item.statusBadge | async as itemBadge\">\r\n                                        <vdr-status-badge\r\n                                            *ngIf=\"itemBadge.type !== 'none'\"\r\n                                            [type]=\"itemBadge.type\"\r\n                                        ></vdr-status-badge>\r\n                                    </ng-container>\r\n                                    <clr-icon [attr.shape]=\"item.icon || 'block'\" size=\"20\"></clr-icon>\r\n                                    {{ item.label | translate }}\r\n                                </a>\r\n                            </li>\r\n                        </ng-container>\r\n                    </ul>\r\n                </vdr-ui-extension-point>\r\n            </section>\r\n        </ng-container>\r\n    </section>\r\n</nav>\r\n"]}