@deenruv/admin-ui 1.0.0

package/esm2022/core/providers/job-queue/job-queue.service.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import { EMPTY, interval, of, Subject, timer } from 'rxjs';
+import { debounceTime, map, mapTo, scan, shareReplay, switchMap } from 'rxjs/operators';
+import { JobState, Permission } from '../../common/generated-types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+export class JobQueueService {
+    constructor(dataService) {
+        this.dataService = dataService;
+        this.updateJob$ = new Subject();
+        this.onCompleteHandlers = new Map();
+        this.checkForJobs();
+        this.activeJobs$ = this.updateJob$.pipe(scan((jobMap, job) => this.handleJob(jobMap, job), new Map()), map(jobMap => Array.from(jobMap.values())), debounceTime(500), shareReplay(1));
+        this.subscription = this.activeJobs$
+            .pipe(switchMap(jobs => {
+            if (jobs.length) {
+                return interval(2500).pipe(mapTo(jobs));
+            }
+            else {
+                return of([]);
+            }
+        }))
+            .subscribe(jobs => {
+            if (jobs.length) {
+                this.dataService.settings.pollJobs(jobs.map(j => j.id)).single$.subscribe(data => {
+                    data.jobsById.forEach(job => {
+                        this.updateJob$.next(job);
+                    });
+                });
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    /**
+     * After a given delay, checks the server for any active jobs.
+     */
+    checkForJobs(delay = 1000) {
+        timer(delay)
+            .pipe(switchMap(() => this.dataService.client.userStatus().mapSingle(data => data.userStatus)), switchMap(userStatus => {
+            if (userStatus.permissions.includes(Permission.ReadSettings) && userStatus.isLoggedIn) {
+                return this.dataService.settings.getRunningJobs().single$;
+            }
+            else {
+                return EMPTY;
+            }
+        }))
+            .subscribe(data => data.jobs.items.forEach(job => this.updateJob$.next(job)));
+    }
+    addJob(jobId, onComplete) {
+        this.dataService.settings.getJob(jobId).single$.subscribe(({ job }) => {
+            if (job) {
+                this.updateJob$.next(job);
+                if (onComplete) {
+                    this.onCompleteHandlers.set(jobId, onComplete);
+                }
+            }
+        });
+    }
+    handleJob(jobMap, job) {
+        switch (job.state) {
+            case JobState.RUNNING:
+            case JobState.PENDING:
+                jobMap.set(job.id, job);
+                break;
+            case JobState.COMPLETED:
+            case JobState.FAILED:
+            case JobState.CANCELLED:
+                jobMap.delete(job.id);
+                const handler = this.onCompleteHandlers.get(job.id);
+                if (handler) {
+                    handler(job);
+                    this.onCompleteHandlers.delete(job.id);
+                }
+                break;
+        }
+        return jobMap;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JobQueueService, deps: [{ token: i1.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JobQueueService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JobQueueService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.DataService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-queue.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/job-queue/job-queue.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { EMPTY, interval, Observable, of, Subject, Subscription, timer } from 'rxjs';\nimport { debounceTime, map, mapTo, scan, shareReplay, switchMap } from 'rxjs/operators';\n\nimport { JobInfoFragment, JobState, Permission } from '../../common/generated-types';\nimport { DataService } from '../../data/providers/data.service';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class JobQueueService implements OnDestroy {\n    activeJobs$: Observable<JobInfoFragment[]>;\n\n    private updateJob$ = new Subject<JobInfoFragment>();\n    private onCompleteHandlers = new Map<string, (job: JobInfoFragment) => void>();\n    private readonly subscription: Subscription;\n\n    constructor(private dataService: DataService) {\n        this.checkForJobs();\n\n        this.activeJobs$ = this.updateJob$.pipe(\n            scan<JobInfoFragment, Map<string, JobInfoFragment>>(\n                (jobMap, job) => this.handleJob(jobMap, job),\n                new Map<string, JobInfoFragment>(),\n            ),\n            map(jobMap => Array.from(jobMap.values())),\n            debounceTime(500),\n            shareReplay(1),\n        );\n\n        this.subscription = this.activeJobs$\n            .pipe(\n                switchMap(jobs => {\n                    if (jobs.length) {\n                        return interval(2500).pipe(mapTo(jobs));\n                    } else {\n                        return of([]);\n                    }\n                }),\n            )\n            .subscribe(jobs => {\n                if (jobs.length) {\n                    this.dataService.settings.pollJobs(jobs.map(j => j.id)).single$.subscribe(data => {\n                        data.jobsById.forEach(job => {\n                            this.updateJob$.next(job);\n                        });\n                    });\n                }\n            });\n    }\n\n    ngOnDestroy(): void {\n        if (this.subscription) {\n            this.subscription.unsubscribe();\n        }\n    }\n\n    /**\n     * After a given delay, checks the server for any active jobs.\n     */\n    checkForJobs(delay = 1000) {\n        timer(delay)\n            .pipe(\n                switchMap(() => this.dataService.client.userStatus().mapSingle(data => data.userStatus)),\n                switchMap(userStatus => {\n                    if (userStatus.permissions.includes(Permission.ReadSettings) && userStatus.isLoggedIn) {\n                        return this.dataService.settings.getRunningJobs().single$;\n                    } else {\n                        return EMPTY;\n                    }\n                }),\n            )\n            .subscribe(data => data.jobs.items.forEach(job => this.updateJob$.next(job)));\n    }\n\n    addJob(jobId: string, onComplete?: (job: JobInfoFragment) => void) {\n        this.dataService.settings.getJob(jobId).single$.subscribe(({ job }) => {\n            if (job) {\n                this.updateJob$.next(job);\n                if (onComplete) {\n                    this.onCompleteHandlers.set(jobId, onComplete);\n                }\n            }\n        });\n    }\n\n    private handleJob(jobMap: Map<string, JobInfoFragment>, job: JobInfoFragment) {\n        switch (job.state) {\n            case JobState.RUNNING:\n            case JobState.PENDING:\n                jobMap.set(job.id, job);\n                break;\n            case JobState.COMPLETED:\n            case JobState.FAILED:\n            case JobState.CANCELLED:\n                jobMap.delete(job.id);\n                const handler = this.onCompleteHandlers.get(job.id);\n                if (handler) {\n                    handler(job);\n                    this.onCompleteHandlers.delete(job.id);\n                }\n                break;\n        }\n        return jobMap;\n    }\n}\n"]}

package/esm2022/core/providers/local-storage/local-storage.service.mjs

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * These keys are stored specific to a particular AdminId, so that multiple
+ * admins can use the same browser without interfering with each other's data.
+ */
+const ADMIN_SPECIFIC_KEYS = [
+    'activeTheme',
+    'dashboardWidgetLayout',
+    'activeTheme',
+    'livePreviewCollectionContents',
+    'dataTableConfig',
+];
+const PREFIX = 'vnd_';
+/**
+ * Wrapper around the browser's LocalStorage / SessionStorage object, for persisting data to the browser.
+ */
+export class LocalStorageService {
+    constructor(location) {
+        this.location = location;
+        this.adminId = '__global__';
+    }
+    setAdminId(adminId) {
+        this.adminId = adminId ?? '__global__';
+    }
+    /**
+     * Set a key-value pair in the browser's LocalStorage
+     */
+    set(key, value) {
+        const keyName = this.keyName(key);
+        localStorage.setItem(keyName, JSON.stringify(value));
+    }
+    /**
+     * Set a key-value pair specific to the current location (url)
+     */
+    setForCurrentLocation(key, value) {
+        const compositeKey = this.getLocationBasedKey(key);
+        this.set(compositeKey, value);
+    }
+    /**
+     * Set a key-value pair in the browser's SessionStorage
+     */
+    setForSession(key, value) {
+        const keyName = this.keyName(key);
+        sessionStorage.setItem(keyName, JSON.stringify(value));
+    }
+    /**
+     * Get the value of the given key from the SessionStorage or LocalStorage.
+     */
+    get(key) {
+        const keyName = this.keyName(key);
+        const item = sessionStorage.getItem(keyName) || localStorage.getItem(keyName);
+        let result;
+        try {
+            result = JSON.parse(item || 'null');
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(`Could not parse the localStorage value for "${key}" (${item})`);
+        }
+        return result;
+    }
+    /**
+     * Get the value of the given key for the current location (url)
+     */
+    getForCurrentLocation(key) {
+        const compositeKey = this.getLocationBasedKey(key);
+        return this.get(compositeKey);
+    }
+    remove(key) {
+        const keyName = this.keyName(key);
+        sessionStorage.removeItem(keyName);
+        localStorage.removeItem(keyName);
+    }
+    getLocationBasedKey(key) {
+        const path = this.location.path();
+        return key + path;
+    }
+    keyName(key) {
+        if (ADMIN_SPECIFIC_KEYS.includes(key)) {
+            return `${PREFIX}_${this.adminId}_${key}`;
+        }
+        else {
+            return `${PREFIX}_${key}`;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, deps: [{ token: i1.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Location }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-storage.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/local-storage/local-storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable } from '@angular/core';\n\nimport { LanguageCode } from '../../common/generated-types';\nimport { WidgetLayoutDefinition } from '../dashboard-widget/dashboard-widget-types';\n\nexport type DataTableConfig = {\n    [id: string]: {\n        visibility: string[];\n        order: { [id: string]: number };\n        showSearchFilterRow: boolean;\n        filterPresets: Array<{ name: string; value: string }>;\n    };\n};\n\nexport type LocalStorageTypeMap = {\n    activeChannelToken: string;\n    authToken: string;\n    uiLanguageCode: LanguageCode;\n    uiLocale: string | undefined;\n    contentLanguageCode: LanguageCode;\n    dashboardWidgetLayout: WidgetLayoutDefinition;\n    activeTheme: string;\n    livePreviewCollectionContents: boolean;\n    dataTableConfig: DataTableConfig;\n};\n\nexport type LocalStorageLocationBasedTypeMap = {\n    shippingTestOrder: any;\n    shippingTestAddress: any;\n};\n\n/**\n * These keys are stored specific to a particular AdminId, so that multiple\n * admins can use the same browser without interfering with each other's data.\n */\nconst ADMIN_SPECIFIC_KEYS: Array<keyof LocalStorageTypeMap> = [\n    'activeTheme',\n    'dashboardWidgetLayout',\n    'activeTheme',\n    'livePreviewCollectionContents',\n    'dataTableConfig',\n];\n\nconst PREFIX = 'vnd_';\n\n/**\n * Wrapper around the browser's LocalStorage / SessionStorage object, for persisting data to the browser.\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class LocalStorageService {\n    private adminId = '__global__';\n    constructor(private location: Location) {}\n\n    public setAdminId(adminId?: string | null) {\n        this.adminId = adminId ?? '__global__';\n    }\n\n    /**\n     * Set a key-value pair in the browser's LocalStorage\n     */\n    public set<K extends keyof LocalStorageTypeMap>(key: K, value: LocalStorageTypeMap[K]): void {\n        const keyName = this.keyName(key);\n        localStorage.setItem(keyName, JSON.stringify(value));\n    }\n\n    /**\n     * Set a key-value pair specific to the current location (url)\n     */\n    public setForCurrentLocation<K extends keyof LocalStorageLocationBasedTypeMap>(\n        key: K,\n        value: LocalStorageLocationBasedTypeMap[K],\n    ) {\n        const compositeKey = this.getLocationBasedKey(key);\n        this.set(compositeKey as any, value);\n    }\n\n    /**\n     * Set a key-value pair in the browser's SessionStorage\n     */\n    public setForSession<K extends keyof LocalStorageTypeMap>(key: K, value: LocalStorageTypeMap[K]): void {\n        const keyName = this.keyName(key);\n        sessionStorage.setItem(keyName, JSON.stringify(value));\n    }\n\n    /**\n     * Get the value of the given key from the SessionStorage or LocalStorage.\n     */\n    public get<K extends keyof LocalStorageTypeMap>(key: K): LocalStorageTypeMap[K] | null {\n        const keyName = this.keyName(key);\n        const item = sessionStorage.getItem(keyName) || localStorage.getItem(keyName);\n        let result: any;\n        try {\n            result = JSON.parse(item || 'null');\n        } catch (e: any) {\n            // eslint-disable-next-line no-console\n            console.error(`Could not parse the localStorage value for \"${key}\" (${item})`);\n        }\n        return result;\n    }\n\n    /**\n     * Get the value of the given key for the current location (url)\n     */\n    public getForCurrentLocation<K extends keyof LocalStorageLocationBasedTypeMap>(\n        key: K,\n    ): LocalStorageLocationBasedTypeMap[K] {\n        const compositeKey = this.getLocationBasedKey(key);\n        return this.get(compositeKey as any);\n    }\n\n    public remove(key: keyof LocalStorageTypeMap): void {\n        const keyName = this.keyName(key);\n        sessionStorage.removeItem(keyName);\n        localStorage.removeItem(keyName);\n    }\n\n    private getLocationBasedKey(key: string) {\n        const path = this.location.path();\n        return key + path;\n    }\n\n    private keyName(key: keyof LocalStorageTypeMap): string {\n        if (ADMIN_SPECIFIC_KEYS.includes(key)) {\n            return `${PREFIX}_${this.adminId}_${key}`;\n        } else {\n            return `${PREFIX}_${key}`;\n        }\n    }\n}\n"]}

package/esm2022/core/providers/localization/localization.service.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/i18n/i18n.service";
+import * as i2 from "../../data/providers/data.service";
+/**
+ * @description
+ * Provides localization helper functionality.
+ *
+ */
+export class LocalizationService {
+    constructor(i18nService, dataService) {
+        this.i18nService = i18nService;
+        this.dataService = dataService;
+        this.uiLanguageAndLocale$ = this.dataService.client?.uiState()?.stream$?.pipe(map(({ uiState }) => {
+            return [uiState.language, uiState.locale ?? undefined];
+        }));
+        this.direction$ = this.uiLanguageAndLocale$?.pipe(map(([languageCode]) => {
+            return this.i18nService.isRTL(languageCode) ? 'rtl' : 'ltr';
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationService, deps: [{ token: i1.I18nService }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.I18nService }, { type: i2.DataService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/modal/modal.service.mjs

@@ -0,0 +1,96 @@
+import { Injectable } from '@angular/core';
+import { from, Observable } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import { ModalDialogComponent } from '../../shared/components/modal-dialog/modal-dialog.component';
+import { SimpleDialogComponent } from '../../shared/components/simple-dialog/simple-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../overlay-host/overlay-host.service";
+/**
+ * @description
+ * This service is responsible for instantiating a ModalDialog component and
+ * embedding the specified component within.
+ *
+ * @docsCategory services
+ * @docsPage ModalService
+ * @docsWeight 0
+ */
+export class ModalService {
+    constructor(overlayHostService) {
+        this.overlayHostService = overlayHostService;
+    }
+    /**
+     * @description
+     * Create a modal from a component. The component must implement the {@link Dialog} interface.
+     * Additionally, the component should include templates for the title and the buttons to be
+     * displayed in the modal dialog. See example:
+     *
+     * @example
+     * ```ts
+     * class MyDialog implements Dialog {
+     *  resolveWith: (result?: any) => void;
+     *
+     *  okay() {
+     *    doSomeWork().subscribe(result => {
+     *      this.resolveWith(result);
+     *    })
+     *  }
+     *
+     *  cancel() {
+     *    this.resolveWith(false);
+     *  }
+     * }
+     * ```
+     *
+     * @example
+     * ```html
+     * <ng-template vdrDialogTitle>Title of the modal</ng-template>
+     *
+     * <p>
+     *   My Content
+     * </p>
+     *
+     * <ng-template vdrDialogButtons>
+     *   <button type="button"
+     *           class="btn"
+     *           (click)="cancel()">Cancel</button>
+     *   <button type="button"
+     *           class="btn btn-primary"
+     *           (click)="okay()">Okay</button>
+     * </ng-template>
+     * ```
+     */
+    fromComponent(component, options) {
+        return from(this.overlayHostService.getHostView()).pipe(mergeMap(hostView => {
+            const modalComponentRef = hostView.createComponent(ModalDialogComponent);
+            const modalInstance = modalComponentRef.instance;
+            modalInstance.childComponentType = component;
+            modalInstance.options = options;
+            return new Observable(subscriber => {
+                modalInstance.closeModal = (result) => {
+                    modalComponentRef.destroy();
+                    subscriber.next(result);
+                    subscriber.complete();
+                };
+            });
+        }));
+    }
+    /**
+     * @description
+     * Displays a modal dialog with the provided title, body and buttons.
+     */
+    dialog(config) {
+        return this.fromComponent(SimpleDialogComponent, {
+            locals: config,
+            size: config.size,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, deps: [{ token: i1.OverlayHostService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.OverlayHostService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/modal/modal.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/nav-builder/nav-builder-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-builder-types.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/nav-builder/nav-builder-types.ts"],"names":[],"mappings":"","sourcesContent":["import { Injector } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { Observable } from 'rxjs';\n\nimport { ActionBarLocationId } from '../../common/component-registry-types';\nimport { DataService } from '../../data/providers/data.service';\nimport { NotificationService } from '../notification/notification.service';\n\nexport type NavMenuBadgeType = 'none' | 'info' | 'success' | 'warning' | 'error';\n\n/**\n * @description\n * A color-coded notification badge which will be displayed by the\n * NavMenuItem's icon.\n *\n * @docsCategory nav-menu\n * @docsPage navigation-types\n */\nexport interface NavMenuBadge {\n    type: NavMenuBadgeType;\n    /**\n     * @description\n     * If true, the badge will propagate to the NavMenuItem's\n     * parent section, displaying a notification badge next\n     * to the section name.\n     */\n    propagateToSection?: boolean;\n}\n\n/**\n * @description\n * A NavMenuItem is a menu item in the main (left-hand side) nav\n * bar.\n *\n * @docsCategory nav-menu\n */\nexport interface NavMenuItem {\n    id: string;\n    label: string;\n    routerLink: RouterLinkDefinition;\n    onClick?: (event: MouseEvent) => void;\n    icon?: string;\n    /**\n     * Control the display of this item based on the user permissions.\n     */\n    requiresPermission?: string | ((userPermissions: string[]) => boolean);\n    statusBadge?: Observable<NavMenuBadge>;\n}\n\n/**\n * @description\n * A NavMenuSection is a grouping of links in the main\n * (left-hand side) nav bar.\n *\n * @docsCategory nav-menu\n */\nexport interface NavMenuSection {\n    id: string;\n    label: string;\n    items: NavMenuItem[];\n    icon?: string;\n    displayMode?: 'regular' | 'settings';\n    /**\n     * @description\n     * Control the display of this item based on the user permissions. Note: if you attempt to pass a\n     * {@link PermissionDefinition} object, you will get a compilation error. Instead, pass the plain\n     * string version. For example, if the permission is defined as:\n     * ```ts\n     * export const MyPermission = new PermissionDefinition('ProductReview');\n     * ```\n     * then the generated permission strings will be:\n     *\n     * - `CreateProductReview`\n     * - `ReadProductReview`\n     * - `UpdateProductReview`\n     * - `DeleteProductReview`\n     */\n    requiresPermission?: string | ((userPermissions: string[]) => boolean);\n    collapsible?: boolean;\n    collapsedByDefault?: boolean;\n}\n\n/**\n * @description\n * Providers & data available to the `onClick` & `buttonState` functions of an {@link ActionBarItem},\n * {@link ActionBarDropdownMenuItem} or {@link NavMenuItem}.\n *\n * @docsCategory action-bar\n */\nexport interface ActionBarContext {\n    /**\n     * @description\n     * The router's [ActivatedRoute](https://angular.dev/guide/routing/router-reference#activated-route) object for\n     * the current route. This object contains information about the route, its parameters, and additional data\n     * associated with the route.\n     */\n    route: ActivatedRoute;\n    /**\n     * @description\n     * The Angular [Injector](https://angular.dev/api/core/Injector) which can be used to get instances\n     * of services and other providers available in the application.\n     */\n    injector: Injector;\n    /**\n     * @description\n     * The [DataService](/reference/admin-ui-api/services/data-service), which provides methods for querying the\n     * server-side data.\n     */\n    dataService: DataService;\n    /**\n     * @description\n     * The [NotificationService](/reference/admin-ui-api/services/notification-service), which provides methods for\n     * displaying notifications to the user.\n     */\n    notificationService: NotificationService;\n    /**\n     * @description\n     * An observable of the current entity in a detail view. In a list view the observable will not emit any values.\n     *\n     * @example\n     * ```ts\n     * addActionBarDropdownMenuItem({\n     *     id: 'print-invoice',\n     *     locationId: 'order-detail',\n     *     label: 'Print Invoice',\n     *     icon: 'printer',\n     *     buttonState: context => {\n     *         // highlight-start\n     *         return context.entity$.pipe(\n     *             map((order) => {\n     *                 return order?.state === 'PaymentSettled'\n     *                     ? { disabled: false, visible: true }\n     *                     : { disabled: true, visible: true };\n     *             }),\n     *         );\n     *         // highlight-end\n     *     },\n     *     requiresPermission: ['UpdateOrder'],\n     * }),\n     * ```\n     *\n     * @since 2.2.0\n     */\n    entity$: Observable<Record<string, any> | undefined>;\n}\n\nexport interface ActionBarButtonState {\n    disabled: boolean;\n    visible: boolean;\n}\n\n/**\n * @description\n * A button in the ActionBar area at the top of one of the list or detail views.\n *\n * @docsCategory action-bar\n */\nexport interface ActionBarItem {\n    /**\n     * @description\n     * A unique identifier for the item.\n     */\n    id: string;\n    /**\n     * @description\n     * The label to display for the item. This can also be a translation token,\n     * e.g. `invoice-plugin.print-invoice`.\n     */\n    label: string;\n    /**\n     * @description\n     * The location in the UI where this button should be displayed.\n     */\n    locationId: ActionBarLocationId;\n    /**\n     * @description\n     * Deprecated since v2.1.0 - use `buttonState` instead.\n     * @deprecated - use `buttonState` instead.\n     */\n    disabled?: Observable<boolean>;\n    /**\n     * @description\n     * A function which returns an observable of the button state, allowing you to\n     * dynamically enable/disable or show/hide the button.\n     *\n     * @since 2.1.0\n     */\n    buttonState?: (context: ActionBarContext) => Observable<ActionBarButtonState>;\n    onClick?: (event: MouseEvent, context: ActionBarContext) => void;\n    routerLink?: RouterLinkDefinition;\n    buttonColor?: 'primary' | 'success' | 'warning';\n    buttonStyle?: 'solid' | 'outline' | 'link';\n    /**\n     * @description\n     * An optional icon to display in the button. The icon\n     * should be a valid shape name from the [Clarity Icons](https://core.clarity.design/foundation/icons/shapes/)\n     * set.\n     */\n    icon?: string;\n    /**\n     * @description\n     * Control the display of this item based on the user permissions. Note: if you attempt to pass a\n     * {@link PermissionDefinition} object, you will get a compilation error. Instead, pass the plain\n     * string version. For example, if the permission is defined as:\n     *\n     * ```ts\n     * export const MyPermission = new PermissionDefinition('ProductReview');\n     * ```\n     *\n     * then the generated permission strings will be:\n     *\n     * - `CreateProductReview`\n     * - `ReadProductReview`\n     * - `UpdateProductReview`\n     * - `DeleteProductReview`\n     */\n    requiresPermission?: string | string[];\n}\n\n/**\n * @description\n * A dropdown menu item in the ActionBar area at the top of one of the list or detail views.\n *\n * @docsCategory action-bar\n * @since 2.2.0\n */\nexport interface ActionBarDropdownMenuItem {\n    /**\n     * @description\n     * A unique identifier for the item.\n     */\n    id: string;\n    /**\n     * @description\n     * The label to display for the item. This can also be a translation token,\n     * e.g. `invoice-plugin.print-invoice`.\n     */\n    label: string;\n    /**\n     * @description\n     * The location in the UI where this menu item should be displayed.\n     */\n    locationId: ActionBarLocationId;\n    /**\n     * @description\n     * Whether to render a divider above this item.\n     */\n    hasDivider?: boolean;\n    /**\n     * @description\n     * A function which returns an observable of the button state, allowing you to\n     * dynamically enable/disable or show/hide the button.\n     */\n    buttonState?: (context: ActionBarContext) => Observable<ActionBarButtonState | undefined>;\n    onClick?: (event: MouseEvent, context: ActionBarContext) => void;\n    routerLink?: RouterLinkDefinition;\n    /**\n     * @description\n     * An optional icon to display with the item. The icon\n     * should be a valid shape name from the [Clarity Icons](https://core.clarity.design/foundation/icons/shapes/)\n     * set.\n     */\n    icon?: string;\n    /**\n     * @description\n     * Control the display of this item based on the user permissions. Note: if you attempt to pass a\n     * {@link PermissionDefinition} object, you will get a compilation error. Instead, pass the plain\n     * string version. For example, if the permission is defined as:\n     *\n     * ```ts\n     * export const MyPermission = new PermissionDefinition('ProductReview');\n     * ```\n     * then the generated permission strings will be:\n     *\n     * - `CreateProductReview`\n     * - `ReadProductReview`\n     * - `UpdateProductReview`\n     * - `DeleteProductReview`\n     */\n    requiresPermission?: string | string[];\n}\n\n/**\n * @description\n * A function which returns the router link for an {@link ActionBarItem} or {@link NavMenuItem}.\n *\n * @docsCategory action-bar\n */\nexport type RouterLinkDefinition = ((route: ActivatedRoute, context: ActionBarContext) => any[]) | any[];\n"]}

package/esm2022/core/providers/nav-builder/nav-builder.service.mjs

@@ -0,0 +1,174 @@
+import { Injectable } from '@angular/core';
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+import { BehaviorSubject, combineLatest, of } from 'rxjs';
+import { map, shareReplay } from 'rxjs/operators';
+import { Permission } from '../../common/generated-types';
+import * as i0 from "@angular/core";
+/**
+ * This service is used to define the contents of configurable menus in the application.
+ */
+export class NavBuilderService {
+    constructor() {
+        this.sectionBadges = {};
+        this.initialNavMenuConfig$ = new BehaviorSubject([]);
+        this.addedNavMenuSections = [];
+        this.addedNavMenuItems = [];
+        this.addedActionBarItems = [];
+        this.addedActionBarDropdownMenuItems = [];
+        this.setupStreams();
+    }
+    /**
+     * Used to define the initial sections and items of the main nav menu.
+     */
+    defineNavMenuSections(config) {
+        this.initialNavMenuConfig$.next(config);
+    }
+    /**
+     * Add a section to the main nav menu. Providing the `before` argument will
+     * move the section before any existing section with the specified id. If
+     * omitted (or if the id is not found) the section will be appended to the
+     * existing set of sections.
+     *
+     * Providing the `id` of an existing section will replace that section.
+     */
+    addNavMenuSection(config, before) {
+        this.addedNavMenuSections.push({ config, before });
+    }
+    /**
+     * Add a menu item to an existing section specified by `sectionId`. The id of the section
+     * can be found by inspecting the DOM and finding the `data-section-id` attribute.
+     * Providing the `before` argument will move the item before any existing item with the specified id.
+     * If omitted (or if the name is not found) the item will be appended to the
+     * end of the section.
+     *
+     * Providing the `id` of an existing item in that section will replace
+     * that item.
+     */
+    addNavMenuItem(config, sectionId, before) {
+        this.addedNavMenuItems.push({ config, sectionId, before });
+    }
+    /**
+     * Adds a button to the ActionBar at the top right of each list or detail view. The locationId can
+     * be determined by inspecting the DOM and finding the `<vdr-action-bar>` element and its
+     * `data-location-id` attribute.
+     */
+    addActionBarItem(config) {
+        if (!this.addedActionBarItems.find(item => item.id === config.id)) {
+            this.addedActionBarItems.push({
+                requiresPermission: Permission.Authenticated,
+                ...config,
+            });
+        }
+    }
+    /**
+     * Adds a dropdown menu to the ActionBar at the top right of each list or detail view. The locationId can
+     * be determined by inspecting the DOM and finding the `<vdr-action-bar>` element and its
+     * `data-location-id` attribute.
+     */
+    addActionBarDropdownMenuItem(config) {
+        if (!this.addedActionBarDropdownMenuItems.find(item => item.id === config.id)) {
+            this.addedActionBarDropdownMenuItems.push({
+                requiresPermission: Permission.Authenticated,
+                ...config,
+            });
+        }
+    }
+    getRouterLink(config, route) {
+        if (typeof config.routerLink === 'function') {
+            return config.routerLink(route, config.context);
+        }
+        if (Array.isArray(config.routerLink)) {
+            return config.routerLink;
+        }
+        return null;
+    }
+    setupStreams() {
+        const sectionAdditions$ = of(this.addedNavMenuSections);
+        const itemAdditions$ = of(this.addedNavMenuItems);
+        const combinedConfig$ = combineLatest(this.initialNavMenuConfig$, sectionAdditions$).pipe(map(([initialConfig, additions]) => {
+            for (const { config, before } of additions) {
+                if (!config.requiresPermission) {
+                    config.requiresPermission = Permission.Authenticated;
+                }
+                const existingIndex = initialConfig.findIndex(c => c.id === config.id);
+                if (-1 < existingIndex) {
+                    initialConfig[existingIndex] = config;
+                }
+                const beforeIndex = initialConfig.findIndex(c => c.id === before);
+                if (-1 < beforeIndex) {
+                    if (-1 < existingIndex) {
+                        initialConfig.splice(existingIndex, 1);
+                    }
+                    initialConfig.splice(beforeIndex, 0, config);
+                }
+                else if (existingIndex === -1) {
+                    initialConfig.push(config);
+                }
+            }
+            return initialConfig;
+        }), shareReplay(1));
+        this.menuConfig$ = combineLatest(combinedConfig$, itemAdditions$).pipe(map(([sections, additionalItems]) => {
+            for (const item of additionalItems) {
+                const section = sections.find(s => s.id === item.sectionId);
+                if (!section) {
+                    // eslint-disable-next-line no-console
+                    console.error(`Could not add menu item "${item.config.id}", section "${item.sectionId}" does not exist`);
+                }
+                else {
+                    const { config, sectionId, before } = item;
+                    const existingIndex = section.items.findIndex(i => i.id === config.id);
+                    if (-1 < existingIndex) {
+                        section.items[existingIndex] = config;
+                    }
+                    const beforeIndex = section.items.findIndex(i => i.id === before);
+                    if (-1 < beforeIndex) {
+                        if (-1 < existingIndex) {
+                            section.items.splice(existingIndex, 1);
+                        }
+                        section.items.splice(beforeIndex, 0, config);
+                    }
+                    else if (existingIndex === -1) {
+                        section.items.push(config);
+                    }
+                }
+            }
+            // Aggregate any badges defined for the nav items in each section
+            for (const section of sections) {
+                const itemBadgeStatuses = section.items
+                    .map(i => i.statusBadge)
+                    .filter(notNullOrUndefined);
+                this.sectionBadges[section.id] = combineLatest(itemBadgeStatuses).pipe(map(badges => {
+                    const propagatingBadges = badges.filter(b => b.propagateToSection);
+                    if (propagatingBadges.length === 0) {
+                        return 'none';
+                    }
+                    const statuses = propagatingBadges.map(b => b.type);
+                    if (statuses.includes('error')) {
+                        return 'error';
+                    }
+                    else if (statuses.includes('warning')) {
+                        return 'warning';
+                    }
+                    else if (statuses.includes('info')) {
+                        return 'info';
+                    }
+                    else {
+                        return 'none';
+                    }
+                }));
+            }
+            return sections;
+        }));
+        this.actionBarConfig$ = of(this.addedActionBarItems);
+        this.actionBarDropdownConfig$ = of(this.addedActionBarDropdownMenuItems);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavBuilderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavBuilderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavBuilderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-builder.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/nav-builder/nav-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';\nimport { BehaviorSubject, combineLatest, Observable, of } from 'rxjs';\nimport { map, shareReplay } from 'rxjs/operators';\n\nimport { Permission } from '../../common/generated-types';\n\nimport {\n    ActionBarContext,\n    ActionBarDropdownMenuItem,\n    ActionBarItem,\n    NavMenuBadgeType,\n    NavMenuItem,\n    NavMenuSection,\n    RouterLinkDefinition,\n} from './nav-builder-types';\n\n/**\n * This service is used to define the contents of configurable menus in the application.\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class NavBuilderService {\n    menuConfig$: Observable<NavMenuSection[]>;\n    actionBarConfig$: Observable<ActionBarItem[]>;\n    actionBarDropdownConfig$: Observable<ActionBarDropdownMenuItem[]>;\n    sectionBadges: { [sectionId: string]: Observable<NavMenuBadgeType> } = {};\n\n    private initialNavMenuConfig$ = new BehaviorSubject<NavMenuSection[]>([]);\n    private addedNavMenuSections: Array<{ config: NavMenuSection; before?: string }> = [];\n    private addedNavMenuItems: Array<{\n        config: NavMenuItem;\n        sectionId: string;\n        before?: string;\n    }> = [];\n    private addedActionBarItems: ActionBarItem[] = [];\n    private addedActionBarDropdownMenuItems: ActionBarDropdownMenuItem[] = [];\n\n    constructor() {\n        this.setupStreams();\n    }\n\n    /**\n     * Used to define the initial sections and items of the main nav menu.\n     */\n    defineNavMenuSections(config: NavMenuSection[]) {\n        this.initialNavMenuConfig$.next(config);\n    }\n\n    /**\n     * Add a section to the main nav menu. Providing the `before` argument will\n     * move the section before any existing section with the specified id. If\n     * omitted (or if the id is not found) the section will be appended to the\n     * existing set of sections.\n     *\n     * Providing the `id` of an existing section will replace that section.\n     */\n    addNavMenuSection(config: NavMenuSection, before?: string) {\n        this.addedNavMenuSections.push({ config, before });\n    }\n\n    /**\n     * Add a menu item to an existing section specified by `sectionId`. The id of the section\n     * can be found by inspecting the DOM and finding the `data-section-id` attribute.\n     * Providing the `before` argument will move the item before any existing item with the specified id.\n     * If omitted (or if the name is not found) the item will be appended to the\n     * end of the section.\n     *\n     * Providing the `id` of an existing item in that section will replace\n     * that item.\n     */\n    addNavMenuItem(config: NavMenuItem, sectionId: string, before?: string) {\n        this.addedNavMenuItems.push({ config, sectionId, before });\n    }\n\n    /**\n     * Adds a button to the ActionBar at the top right of each list or detail view. The locationId can\n     * be determined by inspecting the DOM and finding the `<vdr-action-bar>` element and its\n     * `data-location-id` attribute.\n     */\n    addActionBarItem(config: ActionBarItem) {\n        if (!this.addedActionBarItems.find(item => item.id === config.id)) {\n            this.addedActionBarItems.push({\n                requiresPermission: Permission.Authenticated,\n                ...config,\n            });\n        }\n    }\n\n    /**\n     * Adds a dropdown menu to the ActionBar at the top right of each list or detail view. The locationId can\n     * be determined by inspecting the DOM and finding the `<vdr-action-bar>` element and its\n     * `data-location-id` attribute.\n     */\n    addActionBarDropdownMenuItem(config: ActionBarDropdownMenuItem) {\n        if (!this.addedActionBarDropdownMenuItems.find(item => item.id === config.id)) {\n            this.addedActionBarDropdownMenuItems.push({\n                requiresPermission: Permission.Authenticated,\n                ...config,\n            });\n        }\n    }\n\n    getRouterLink(\n        config: { routerLink?: RouterLinkDefinition; context: ActionBarContext },\n        route: ActivatedRoute,\n    ): string[] | null {\n        if (typeof config.routerLink === 'function') {\n            return config.routerLink(route, config.context);\n        }\n        if (Array.isArray(config.routerLink)) {\n            return config.routerLink;\n        }\n        return null;\n    }\n\n    private setupStreams() {\n        const sectionAdditions$ = of(this.addedNavMenuSections);\n        const itemAdditions$ = of(this.addedNavMenuItems);\n\n        const combinedConfig$ = combineLatest(this.initialNavMenuConfig$, sectionAdditions$).pipe(\n            map(([initialConfig, additions]) => {\n                for (const { config, before } of additions) {\n                    if (!config.requiresPermission) {\n                        config.requiresPermission = Permission.Authenticated;\n                    }\n                    const existingIndex = initialConfig.findIndex(c => c.id === config.id);\n                    if (-1 < existingIndex) {\n                        initialConfig[existingIndex] = config;\n                    }\n                    const beforeIndex = initialConfig.findIndex(c => c.id === before);\n                    if (-1 < beforeIndex) {\n                        if (-1 < existingIndex) {\n                            initialConfig.splice(existingIndex, 1);\n                        }\n                        initialConfig.splice(beforeIndex, 0, config);\n                    } else if (existingIndex === -1) {\n                        initialConfig.push(config);\n                    }\n                }\n                return initialConfig;\n            }),\n            shareReplay(1),\n        );\n\n        this.menuConfig$ = combineLatest(combinedConfig$, itemAdditions$).pipe(\n            map(([sections, additionalItems]) => {\n                for (const item of additionalItems) {\n                    const section = sections.find(s => s.id === item.sectionId);\n                    if (!section) {\n                        // eslint-disable-next-line no-console\n                        console.error(\n                            `Could not add menu item \"${item.config.id}\", section \"${item.sectionId}\" does not exist`,\n                        );\n                    } else {\n                        const { config, sectionId, before } = item;\n                        const existingIndex = section.items.findIndex(i => i.id === config.id);\n                        if (-1 < existingIndex) {\n                            section.items[existingIndex] = config;\n                        }\n                        const beforeIndex = section.items.findIndex(i => i.id === before);\n                        if (-1 < beforeIndex) {\n                            if (-1 < existingIndex) {\n                                section.items.splice(existingIndex, 1);\n                            }\n                            section.items.splice(beforeIndex, 0, config);\n                        } else if (existingIndex === -1) {\n                            section.items.push(config);\n                        }\n                    }\n                }\n\n                // Aggregate any badges defined for the nav items in each section\n                for (const section of sections) {\n                    const itemBadgeStatuses = section.items\n                        .map(i => i.statusBadge)\n                        .filter(notNullOrUndefined);\n                    this.sectionBadges[section.id] = combineLatest(itemBadgeStatuses).pipe(\n                        map(badges => {\n                            const propagatingBadges = badges.filter(b => b.propagateToSection);\n                            if (propagatingBadges.length === 0) {\n                                return 'none';\n                            }\n                            const statuses = propagatingBadges.map(b => b.type);\n                            if (statuses.includes('error')) {\n                                return 'error';\n                            } else if (statuses.includes('warning')) {\n                                return 'warning';\n                            } else if (statuses.includes('info')) {\n                                return 'info';\n                            } else {\n                                return 'none';\n                            }\n                        }),\n                    );\n                }\n\n                return sections;\n            }),\n        );\n\n        this.actionBarConfig$ = of(this.addedActionBarItems);\n        this.actionBarDropdownConfig$ = of(this.addedActionBarDropdownMenuItems);\n    }\n}\n"]}