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

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

@@ -0,0 +1,268 @@
+import { APP_INITIALIZER, Injectable } from '@angular/core';
+import { notNullOrUndefined } from '@vendure/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";
+/**
+ * @description
+ * 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.
+ * This should be used in the NgModule `providers` array of your ui extension module.
+ *
+ * @example
+ * ```TypeScript
+ * \@NgModule({
+ *   imports: [SharedModule],
+ *   providers: [
+ *     addNavMenuSection({
+ *       id: 'reports',
+ *       label: 'Reports',
+ *       items: [{
+ *           // ...
+ *       }],
+ *     },
+ *     'settings'),
+ *   ],
+ * })
+ * export class MyUiExtensionModule {}
+ * ```
+ * @docsCategory nav-menu
+ */
+export function addNavMenuSection(config, before) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addNavMenuSection(config, before);
+        },
+        deps: [NavBuilderService],
+    };
+}
+/**
+ * @description
+ * 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.
+ *
+ * This should be used in the NgModule `providers` array of your ui extension module.
+ *
+ * @example
+ * ```TypeScript
+ * \@NgModule({
+ *   imports: [SharedModule],
+ *   providers: [
+ *     addNavMenuItem({
+ *       id: 'reviews',
+ *       label: 'Product Reviews',
+ *       routerLink: ['/extensions/reviews'],
+ *       icon: 'star',
+ *     },
+ *     'marketing'),
+ *   ],
+ * })
+ * export class MyUiExtensionModule {}
+ * ``
+ *
+ * @docsCategory nav-menu
+ */
+export function addNavMenuItem(config, sectionId, before) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addNavMenuItem(config, sectionId, before);
+        },
+        deps: [NavBuilderService],
+    };
+}
+/**
+ * @description
+ * 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.
+ *
+ * This should be used in the NgModule `providers` array of your ui extension module.
+ *
+ * @example
+ * ```TypeScript
+ * \@NgModule({
+ *   imports: [SharedModule],
+ *   providers: [
+ *     addActionBarItem({
+ *      id: 'print-invoice'
+ *      label: 'Print Invoice',
+ *      locationId: 'order-detail',
+ *      routerLink: ['/extensions/invoicing'],
+ *     }),
+ *   ],
+ * })
+ * export class MyUiExtensionModule {}
+ * ```
+ * @docsCategory action-bar
+ */
+export function addActionBarItem(config) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addActionBarItem(config);
+        },
+        deps: [NavBuilderService],
+    };
+}
+/**
+ * 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.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) {
+        this.addedActionBarItems.push({
+            requiresPermission: Permission.Authenticated,
+            ...config,
+        });
+    }
+    getRouterLink(config, route) {
+        if (typeof config.routerLink === 'function') {
+            return config.routerLink(route);
+        }
+        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.navMenuConfig$ = combineLatest(combinedConfig$, itemAdditions$).pipe(map(([sections, additionalItems]) => {
+            for (const item of additionalItems) {
+                const section = sections.find(s => s.id === item.sectionId);
+                if (!section) {
+                    // tslint: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);
+    }
+}
+NavBuilderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NavBuilderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NavBuilderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NavBuilderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NavBuilderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# 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 { APP_INITIALIZER, Injectable, Provider } from '@angular/core';\r\nimport { ActivatedRoute } from '@angular/router';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\nimport { BehaviorSubject, combineLatest, Observable, of } from 'rxjs';\r\nimport { map, shareReplay } from 'rxjs/operators';\r\n\r\nimport { Permission } from '../../common/generated-types';\r\n\r\nimport {\r\n    ActionBarItem,\r\n    NavMenuBadgeType,\r\n    NavMenuItem,\r\n    NavMenuSection,\r\n    RouterLinkDefinition,\r\n} from './nav-builder-types';\r\n\r\n/**\r\n * @description\r\n * Add a section to the main nav menu. Providing the `before` argument will\r\n * move the section before any existing section with the specified id. If\r\n * omitted (or if the id is not found) the section will be appended to the\r\n * existing set of sections.\r\n * This should be used in the NgModule `providers` array of your ui extension module.\r\n *\r\n * @example\r\n * ```TypeScript\r\n * \\@NgModule({\r\n *   imports: [SharedModule],\r\n *   providers: [\r\n *     addNavMenuSection({\r\n *       id: 'reports',\r\n *       label: 'Reports',\r\n *       items: [{\r\n *           // ...\r\n *       }],\r\n *     },\r\n *     'settings'),\r\n *   ],\r\n * })\r\n * export class MyUiExtensionModule {}\r\n * ```\r\n * @docsCategory nav-menu\r\n */\r\nexport function addNavMenuSection(config: NavMenuSection, before?: string): Provider {\r\n    return {\r\n        provide: APP_INITIALIZER,\r\n        multi: true,\r\n        useFactory: (navBuilderService: NavBuilderService) => () => {\r\n            navBuilderService.addNavMenuSection(config, before);\r\n        },\r\n        deps: [NavBuilderService],\r\n    };\r\n}\r\n\r\n/**\r\n * @description\r\n * Add a menu item to an existing section specified by `sectionId`. The id of the section\r\n * can be found by inspecting the DOM and finding the `data-section-id` attribute.\r\n * Providing the `before` argument will move the item before any existing item with the specified id.\r\n * If omitted (or if the name is not found) the item will be appended to the\r\n * end of the section.\r\n *\r\n * This should be used in the NgModule `providers` array of your ui extension module.\r\n *\r\n * @example\r\n * ```TypeScript\r\n * \\@NgModule({\r\n *   imports: [SharedModule],\r\n *   providers: [\r\n *     addNavMenuItem({\r\n *       id: 'reviews',\r\n *       label: 'Product Reviews',\r\n *       routerLink: ['/extensions/reviews'],\r\n *       icon: 'star',\r\n *     },\r\n *     'marketing'),\r\n *   ],\r\n * })\r\n * export class MyUiExtensionModule {}\r\n * ``\r\n *\r\n * @docsCategory nav-menu\r\n */\r\nexport function addNavMenuItem(config: NavMenuItem, sectionId: string, before?: string): Provider {\r\n    return {\r\n        provide: APP_INITIALIZER,\r\n        multi: true,\r\n        useFactory: (navBuilderService: NavBuilderService) => () => {\r\n            navBuilderService.addNavMenuItem(config, sectionId, before);\r\n        },\r\n        deps: [NavBuilderService],\r\n    };\r\n}\r\n\r\n/**\r\n * @description\r\n * Adds a button to the ActionBar at the top right of each list or detail view. The locationId can\r\n * be determined by inspecting the DOM and finding the <vdr-action-bar> element and its\r\n * `data-location-id` attribute.\r\n *\r\n * This should be used in the NgModule `providers` array of your ui extension module.\r\n *\r\n * @example\r\n * ```TypeScript\r\n * \\@NgModule({\r\n *   imports: [SharedModule],\r\n *   providers: [\r\n *     addActionBarItem({\r\n *      id: 'print-invoice'\r\n *      label: 'Print Invoice',\r\n *      locationId: 'order-detail',\r\n *      routerLink: ['/extensions/invoicing'],\r\n *     }),\r\n *   ],\r\n * })\r\n * export class MyUiExtensionModule {}\r\n * ```\r\n * @docsCategory action-bar\r\n */\r\nexport function addActionBarItem(config: ActionBarItem): Provider {\r\n    return {\r\n        provide: APP_INITIALIZER,\r\n        multi: true,\r\n        useFactory: (navBuilderService: NavBuilderService) => () => {\r\n            navBuilderService.addActionBarItem(config);\r\n        },\r\n        deps: [NavBuilderService],\r\n    };\r\n}\r\n\r\n/**\r\n * This service is used to define the contents of configurable menus in the application.\r\n */\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class NavBuilderService {\r\n    navMenuConfig$: Observable<NavMenuSection[]>;\r\n    actionBarConfig$: Observable<ActionBarItem[]>;\r\n    sectionBadges: { [sectionId: string]: Observable<NavMenuBadgeType> } = {};\r\n\r\n    private initialNavMenuConfig$ = new BehaviorSubject<NavMenuSection[]>([]);\r\n    private addedNavMenuSections: Array<{ config: NavMenuSection; before?: string }> = [];\r\n    private addedNavMenuItems: Array<{\r\n        config: NavMenuItem;\r\n        sectionId: string;\r\n        before?: string;\r\n    }> = [];\r\n    private addedActionBarItems: ActionBarItem[] = [];\r\n\r\n    constructor() {\r\n        this.setupStreams();\r\n    }\r\n\r\n    /**\r\n     * Used to define the initial sections and items of the main nav menu.\r\n     */\r\n    defineNavMenuSections(config: NavMenuSection[]) {\r\n        this.initialNavMenuConfig$.next(config);\r\n    }\r\n\r\n    /**\r\n     * Add a section to the main nav menu. Providing the `before` argument will\r\n     * move the section before any existing section with the specified id. If\r\n     * omitted (or if the id is not found) the section will be appended to the\r\n     * existing set of sections.\r\n     *\r\n     * Providing the `id` of an existing section will replace that section.\r\n     */\r\n    addNavMenuSection(config: NavMenuSection, before?: string) {\r\n        this.addedNavMenuSections.push({ config, before });\r\n    }\r\n\r\n    /**\r\n     * Add a menu item to an existing section specified by `sectionId`. The id of the section\r\n     * can be found by inspecting the DOM and finding the `data-section-id` attribute.\r\n     * Providing the `before` argument will move the item before any existing item with the specified id.\r\n     * If omitted (or if the name is not found) the item will be appended to the\r\n     * end of the section.\r\n     *\r\n     * Providing the `id` of an existing item in that section will replace\r\n     * that item.\r\n     */\r\n    addNavMenuItem(config: NavMenuItem, sectionId: string, before?: string) {\r\n        this.addedNavMenuItems.push({ config, sectionId, before });\r\n    }\r\n\r\n    /**\r\n     * Adds a button to the ActionBar at the top right of each list or detail view. The locationId can\r\n     * be determined by inspecting the DOM and finding the <vdr-action-bar> element and its\r\n     * `data-location-id` attribute.\r\n     */\r\n    addActionBarItem(config: ActionBarItem) {\r\n        this.addedActionBarItems.push({\r\n            requiresPermission: Permission.Authenticated,\r\n            ...config,\r\n        });\r\n    }\r\n\r\n    getRouterLink(config: { routerLink?: RouterLinkDefinition }, route: ActivatedRoute): string[] | null {\r\n        if (typeof config.routerLink === 'function') {\r\n            return config.routerLink(route);\r\n        }\r\n        if (Array.isArray(config.routerLink)) {\r\n            return config.routerLink;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private setupStreams() {\r\n        const sectionAdditions$ = of(this.addedNavMenuSections);\r\n        const itemAdditions$ = of(this.addedNavMenuItems);\r\n\r\n        const combinedConfig$ = combineLatest(this.initialNavMenuConfig$, sectionAdditions$).pipe(\r\n            map(([initialConfig, additions]) => {\r\n                for (const { config, before } of additions) {\r\n                    if (!config.requiresPermission) {\r\n                        config.requiresPermission = Permission.Authenticated;\r\n                    }\r\n                    const existingIndex = initialConfig.findIndex(c => c.id === config.id);\r\n                    if (-1 < existingIndex) {\r\n                        initialConfig[existingIndex] = config;\r\n                    }\r\n                    const beforeIndex = initialConfig.findIndex(c => c.id === before);\r\n                    if (-1 < beforeIndex) {\r\n                        if (-1 < existingIndex) {\r\n                            initialConfig.splice(existingIndex, 1);\r\n                        }\r\n                        initialConfig.splice(beforeIndex, 0, config);\r\n                    } else if (existingIndex === -1) {\r\n                        initialConfig.push(config);\r\n                    }\r\n                }\r\n                return initialConfig;\r\n            }),\r\n            shareReplay(1),\r\n        );\r\n\r\n        this.navMenuConfig$ = combineLatest(combinedConfig$, itemAdditions$).pipe(\r\n            map(([sections, additionalItems]) => {\r\n                for (const item of additionalItems) {\r\n                    const section = sections.find(s => s.id === item.sectionId);\r\n                    if (!section) {\r\n                        // tslint:disable-next-line:no-console\r\n                        console.error(\r\n                            `Could not add menu item \"${item.config.id}\", section \"${item.sectionId}\" does not exist`,\r\n                        );\r\n                    } else {\r\n                        const { config, sectionId, before } = item;\r\n                        const existingIndex = section.items.findIndex(i => i.id === config.id);\r\n                        if (-1 < existingIndex) {\r\n                            section.items[existingIndex] = config;\r\n                        }\r\n                        const beforeIndex = section.items.findIndex(i => i.id === before);\r\n                        if (-1 < beforeIndex) {\r\n                            if (-1 < existingIndex) {\r\n                                section.items.splice(existingIndex, 1);\r\n                            }\r\n                            section.items.splice(beforeIndex, 0, config);\r\n                        } else if (existingIndex === -1) {\r\n                            section.items.push(config);\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Aggregate any badges defined for the nav items in each section\r\n                for (const section of sections) {\r\n                    const itemBadgeStatuses = section.items\r\n                        .map(i => i.statusBadge)\r\n                        .filter(notNullOrUndefined);\r\n                    this.sectionBadges[section.id] = combineLatest(itemBadgeStatuses).pipe(\r\n                        map(badges => {\r\n                            const propagatingBadges = badges.filter(b => b.propagateToSection);\r\n                            if (propagatingBadges.length === 0) {\r\n                                return 'none';\r\n                            }\r\n                            const statuses = propagatingBadges.map(b => b.type);\r\n                            if (statuses.includes('error')) {\r\n                                return 'error';\r\n                            } else if (statuses.includes('warning')) {\r\n                                return 'warning';\r\n                            } else if (statuses.includes('info')) {\r\n                                return 'info';\r\n                            } else {\r\n                                return 'none';\r\n                            }\r\n                        }),\r\n                    );\r\n                }\r\n\r\n                return sections;\r\n            }),\r\n        );\r\n\r\n        this.actionBarConfig$ = of(this.addedActionBarItems);\r\n    }\r\n}\r\n"]}

package/esm2020/core/providers/notification/notification.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { NotificationComponent } from '../../components/notification/notification.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../i18n/i18n.service";
+import * as i2 from "../overlay-host/overlay-host.service";
+// How many ms before the toast is dismissed.
+const TOAST_DURATION = 3000;
+/**
+ * @description
+ * Provides toast notification functionality.
+ *
+ * @example
+ * ```TypeScript
+ * class MyComponent {
+ *   constructor(private notificationService: NotificationService) {}
+ *
+ *   save() {
+ *     this.notificationService
+ *         .success(_('asset.notify-create-assets-success'), {
+ *           count: successCount,
+ *         });
+ *   }
+ * }
+ *
+ * @docsCategory providers
+ * @docsPage NotificationService
+ * @docsWeight 0
+ */
+export class NotificationService {
+    constructor(i18nService, resolver, overlayHostService) {
+        this.i18nService = i18nService;
+        this.resolver = resolver;
+        this.overlayHostService = overlayHostService;
+        this.openToastRefs = [];
+    }
+    get hostView() {
+        return this.overlayHostService.getHostView();
+    }
+    /**
+     * @description
+     * Display a success toast notification
+     */
+    success(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'success',
+        });
+    }
+    /**
+     * @description
+     * Display an info toast notification
+     */
+    info(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'info',
+        });
+    }
+    /**
+     * @description
+     * Display a warning toast notification
+     */
+    warning(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'warning',
+        });
+    }
+    /**
+     * @description
+     * Display an error toast notification
+     */
+    error(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'error',
+            duration: 20000,
+        });
+    }
+    /**
+     * @description
+     * Display a toast notification.
+     */
+    notify(config) {
+        this.createToast(config);
+    }
+    /**
+     * Load a ToastComponent into the DOM host location.
+     */
+    async createToast(config) {
+        const toastFactory = this.resolver.resolveComponentFactory(NotificationComponent);
+        const hostView = await this.hostView;
+        const ref = hostView.createComponent(toastFactory);
+        const toast = ref.instance;
+        const dismissFn = this.createDismissFunction(ref);
+        toast.type = config.type || 'info';
+        toast.message = config.message;
+        toast.translationVars = this.translateTranslationVars(config.translationVars || {});
+        toast.registerOnClickFn(dismissFn);
+        let timerId;
+        if (!config.duration || 0 < config.duration) {
+            timerId = setTimeout(dismissFn, config.duration || TOAST_DURATION);
+        }
+        this.openToastRefs.unshift({ ref, timerId });
+        setTimeout(() => this.calculatePositions());
+    }
+    /**
+     * Returns a function which will destroy the toast component and
+     * remove it from the openToastRefs array.
+     */
+    createDismissFunction(ref) {
+        return () => {
+            const toast = ref.instance;
+            const index = this.openToastRefs.map(o => o.ref).indexOf(ref);
+            if (this.openToastRefs[index]) {
+                clearTimeout(this.openToastRefs[index].timerId);
+            }
+            toast.fadeOut().then(() => {
+                ref.destroy();
+                this.openToastRefs.splice(index, 1);
+                this.calculatePositions();
+            });
+        };
+    }
+    /**
+     * Calculate and set the top offsets for each of the open toasts.
+     */
+    calculatePositions() {
+        let cumulativeHeight = 10;
+        this.openToastRefs.forEach(obj => {
+            const toast = obj.ref.instance;
+            toast.offsetTop = cumulativeHeight;
+            cumulativeHeight += toast.getHeight() + 6;
+        });
+    }
+    translateTranslationVars(translationVars) {
+        for (const [key, val] of Object.entries(translationVars)) {
+            if (typeof val === 'string') {
+                translationVars[key] = this.i18nService.translate(val);
+            }
+        }
+        return translationVars;
+    }
+}
+NotificationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NotificationService, deps: [{ token: i1.I18nService }, { token: i0.ComponentFactoryResolver }, { token: i2.OverlayHostService }], target: i0.ɵɵFactoryTarget.Injectable });
+NotificationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NotificationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.I18nService }, { type: i0.ComponentFactoryResolver }, { type: i2.OverlayHostService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/notification/notification.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,UAAU,EAAoB,MAAM,eAAe,CAAC;AAErG,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;;;;AA2B7F,6CAA6C;AAC7C,MAAM,cAAc,GAAG,IAAI,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,MAAM,OAAO,mBAAmB;IAO5B,YACY,WAAwB,EACxB,QAAkC,EAClC,kBAAsC;QAFtC,gBAAW,GAAX,WAAW,CAAa;QACxB,aAAQ,GAAR,QAAQ,CAA0B;QAClC,uBAAkB,GAAlB,kBAAkB,CAAoB;QAL1C,kBAAa,GAAsE,EAAE,CAAC;IAM3F,CAAC;IAVJ,IAAY,QAAQ;QAChB,OAAO,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;IACjD,CAAC;IAUD;;;OAGG;IACH,OAAO,CAAC,OAAe,EAAE,eAAoD;QACzE,IAAI,CAAC,MAAM,CAAC;YACR,OAAO;YACP,eAAe;YACf,IAAI,EAAE,SAAS;SAClB,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACH,IAAI,CAAC,OAAe,EAAE,eAAoD;QACtE,IAAI,CAAC,MAAM,CAAC;YACR,OAAO;YACP,eAAe;YACf,IAAI,EAAE,MAAM;SACf,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,OAAe,EAAE,eAAoD;QACzE,IAAI,CAAC,MAAM,CAAC;YACR,OAAO;YACP,eAAe;YACf,IAAI,EAAE,SAAS;SAClB,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAe,EAAE,eAAoD;QACvE,IAAI,CAAC,MAAM,CAAC;YACR,OAAO;YACP,eAAe;YACf,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,KAAK;SAClB,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,MAAmB;QACtB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,WAAW,CAAC,MAAmB;QACzC,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,qBAAqB,CAAC,CAAC;QAClF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC;QACrC,MAAM,GAAG,GAAG,QAAQ,CAAC,eAAe,CAAwB,YAAY,CAAC,CAAC;QAC1E,MAAM,KAAK,GAA0B,GAAG,CAAC,QAAQ,CAAC;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC;QAClD,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC;QACnC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/B,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;QACpF,KAAK,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAEnC,IAAI,OAAO,CAAC;QACZ,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,EAAE;YACzC,OAAO,GAAG,UAAU,CAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,IAAI,cAAc,CAAC,CAAC;SACtE;QAED,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;QAC7C,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACK,qBAAqB,CAAC,GAAwC;QAClE,OAAO,GAAG,EAAE;YACR,MAAM,KAAK,GAA0B,GAAG,CAAC,QAAQ,CAAC;YAClD,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAE9D,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE;gBAC3B,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC;aACnD;YAED,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;gBACtB,GAAG,CAAC,OAAO,EAAE,CAAC;gBACd,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBACpC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC9B,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACK,kBAAkB;QACtB,IAAI,gBAAgB,GAAG,EAAE,CAAC;QAE1B,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAC7B,MAAM,KAAK,GAA0B,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC;YACtD,KAAK,CAAC,SAAS,GAAG,gBAAgB,CAAC;YACnC,gBAAgB,IAAI,KAAK,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,wBAAwB,CAAC,eAAmD;QAGhF,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE;YACtD,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;gBACzB,eAAe,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;aAC1D;SACJ;QACD,OAAO,eAAe,CAAC;IAC3B,CAAC;;gHAxIQ,mBAAmB;oHAAnB,mBAAmB,cAFhB,MAAM;2FAET,mBAAmB;kBAH/B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { ComponentFactoryResolver, ComponentRef, Injectable, ViewContainerRef } from '@angular/core';\r\n\r\nimport { NotificationComponent } from '../../components/notification/notification.component';\r\nimport { I18nService } from '../i18n/i18n.service';\r\nimport { OverlayHostService } from '../overlay-host/overlay-host.service';\r\n\r\n/**\r\n * @description\r\n * The types of notification available.\r\n *\r\n * @docsCategory providers\r\n * @docsPage NotificationService\r\n */\r\nexport type NotificationType = 'info' | 'success' | 'error' | 'warning';\r\n\r\n/**\r\n * @description\r\n * Configuration for a toast notification.\r\n *\r\n * @docsCategory providers\r\n * @docsPage NotificationService\r\n */\r\nexport interface ToastConfig {\r\n    message: string;\r\n    translationVars?: { [key: string]: string | number };\r\n    type?: NotificationType;\r\n    duration?: number;\r\n}\r\n\r\n// How many ms before the toast is dismissed.\r\nconst TOAST_DURATION = 3000;\r\n\r\n/**\r\n * @description\r\n * Provides toast notification functionality.\r\n *\r\n * @example\r\n * ```TypeScript\r\n * class MyComponent {\r\n *   constructor(private notificationService: NotificationService) {}\r\n *\r\n *   save() {\r\n *     this.notificationService\r\n *         .success(_('asset.notify-create-assets-success'), {\r\n *           count: successCount,\r\n *         });\r\n *   }\r\n * }\r\n *\r\n * @docsCategory providers\r\n * @docsPage NotificationService\r\n * @docsWeight 0\r\n */\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class NotificationService {\r\n    private get hostView(): Promise<ViewContainerRef> {\r\n        return this.overlayHostService.getHostView();\r\n    }\r\n\r\n    private openToastRefs: Array<{ ref: ComponentRef<NotificationComponent>; timerId: any }> = [];\r\n\r\n    constructor(\r\n        private i18nService: I18nService,\r\n        private resolver: ComponentFactoryResolver,\r\n        private overlayHostService: OverlayHostService,\r\n    ) {}\r\n\r\n    /**\r\n     * @description\r\n     * Display a success toast notification\r\n     */\r\n    success(message: string, translationVars?: { [key: string]: string | number }): void {\r\n        this.notify({\r\n            message,\r\n            translationVars,\r\n            type: 'success',\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Display an info toast notification\r\n     */\r\n    info(message: string, translationVars?: { [key: string]: string | number }): void {\r\n        this.notify({\r\n            message,\r\n            translationVars,\r\n            type: 'info',\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Display a warning toast notification\r\n     */\r\n    warning(message: string, translationVars?: { [key: string]: string | number }): void {\r\n        this.notify({\r\n            message,\r\n            translationVars,\r\n            type: 'warning',\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Display an error toast notification\r\n     */\r\n    error(message: string, translationVars?: { [key: string]: string | number }): void {\r\n        this.notify({\r\n            message,\r\n            translationVars,\r\n            type: 'error',\r\n            duration: 20000,\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Display a toast notification.\r\n     */\r\n    notify(config: ToastConfig): void {\r\n        this.createToast(config);\r\n    }\r\n\r\n    /**\r\n     * Load a ToastComponent into the DOM host location.\r\n     */\r\n    private async createToast(config: ToastConfig): Promise<void> {\r\n        const toastFactory = this.resolver.resolveComponentFactory(NotificationComponent);\r\n        const hostView = await this.hostView;\r\n        const ref = hostView.createComponent<NotificationComponent>(toastFactory);\r\n        const toast: NotificationComponent = ref.instance;\r\n        const dismissFn = this.createDismissFunction(ref);\r\n        toast.type = config.type || 'info';\r\n        toast.message = config.message;\r\n        toast.translationVars = this.translateTranslationVars(config.translationVars || {});\r\n        toast.registerOnClickFn(dismissFn);\r\n\r\n        let timerId;\r\n        if (!config.duration || 0 < config.duration) {\r\n            timerId = setTimeout(dismissFn, config.duration || TOAST_DURATION);\r\n        }\r\n\r\n        this.openToastRefs.unshift({ ref, timerId });\r\n        setTimeout(() => this.calculatePositions());\r\n    }\r\n\r\n    /**\r\n     * Returns a function which will destroy the toast component and\r\n     * remove it from the openToastRefs array.\r\n     */\r\n    private createDismissFunction(ref: ComponentRef<NotificationComponent>): () => void {\r\n        return () => {\r\n            const toast: NotificationComponent = ref.instance;\r\n            const index = this.openToastRefs.map(o => o.ref).indexOf(ref);\r\n\r\n            if (this.openToastRefs[index]) {\r\n                clearTimeout(this.openToastRefs[index].timerId);\r\n            }\r\n\r\n            toast.fadeOut().then(() => {\r\n                ref.destroy();\r\n                this.openToastRefs.splice(index, 1);\r\n                this.calculatePositions();\r\n            });\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Calculate and set the top offsets for each of the open toasts.\r\n     */\r\n    private calculatePositions(): void {\r\n        let cumulativeHeight = 10;\r\n\r\n        this.openToastRefs.forEach(obj => {\r\n            const toast: NotificationComponent = obj.ref.instance;\r\n            toast.offsetTop = cumulativeHeight;\r\n            cumulativeHeight += toast.getHeight() + 6;\r\n        });\r\n    }\r\n\r\n    private translateTranslationVars(translationVars: { [key: string]: string | number }): {\r\n        [key: string]: string | number;\r\n    } {\r\n        for (const [key, val] of Object.entries(translationVars)) {\r\n            if (typeof val === 'string') {\r\n                translationVars[key] = this.i18nService.translate(val);\r\n            }\r\n        }\r\n        return translationVars;\r\n    }\r\n}\r\n"]}

package/esm2020/core/providers/overlay-host/overlay-host.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * The OverlayHostService is used to get a reference to the ViewConainerRef of the
+ * OverlayHost component, so that other components may insert components & elements
+ * into the DOM at that point.
+ */
+export class OverlayHostService {
+    constructor() {
+        this.promiseResolveFns = [];
+    }
+    /**
+     * Used to pass in the ViewContainerRed from the OverlayHost component.
+     * Should not be used by any other component.
+     */
+    registerHostView(viewContainerRef) {
+        this.hostView = viewContainerRef;
+        if (0 < this.promiseResolveFns.length) {
+            this.resolveHostView();
+        }
+    }
+    /**
+     * Returns a promise which resolves to the ViewContainerRef of the OverlayHost
+     * component. This can then be used to insert components and elements into the
+     * DOM at that point.
+     */
+    getHostView() {
+        return new Promise((resolve) => {
+            this.promiseResolveFns.push(resolve);
+            if (this.hostView !== undefined) {
+                this.resolveHostView();
+            }
+        });
+    }
+    resolveHostView() {
+        this.promiseResolveFns.forEach(resolve => resolve(this.hostView));
+        this.promiseResolveFns = [];
+    }
+}
+OverlayHostService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: OverlayHostService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayHostService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: OverlayHostService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: OverlayHostService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS1ob3N0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3Byb3ZpZGVycy9vdmVybGF5LWhvc3Qvb3ZlcmxheS1ob3N0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBb0IsTUFBTSxlQUFlLENBQUM7O0FBRTdEOzs7O0dBSUc7QUFJSCxNQUFNLE9BQU8sa0JBQWtCO0lBSC9CO1FBS1ksc0JBQWlCLEdBQWlDLEVBQUUsQ0FBQztLQStCaEU7SUE3Qkc7OztPQUdHO0lBQ0gsZ0JBQWdCLENBQUMsZ0JBQWtDO1FBQy9DLElBQUksQ0FBQyxRQUFRLEdBQUcsZ0JBQWdCLENBQUM7UUFDakMsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sRUFBRTtZQUNuQyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7U0FDMUI7SUFDTCxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILFdBQVc7UUFDUCxPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBOEIsRUFBRSxFQUFFO1lBQ2xELElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDckMsSUFBSSxJQUFJLENBQUMsUUFBUSxLQUFLLFNBQVMsRUFBRTtnQkFDN0IsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO2FBQzFCO1FBQ0wsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRU8sZUFBZTtRQUNuQixJQUFJLENBQUMsaUJBQWlCLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1FBQ2xFLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxFQUFFLENBQUM7SUFDaEMsQ0FBQzs7K0dBaENRLGtCQUFrQjttSEFBbEIsa0JBQWtCLGNBRmYsTUFBTTsyRkFFVCxrQkFBa0I7a0JBSDlCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuLyoqXHJcbiAqIFRoZSBPdmVybGF5SG9zdFNlcnZpY2UgaXMgdXNlZCB0byBnZXQgYSByZWZlcmVuY2UgdG8gdGhlIFZpZXdDb25haW5lclJlZiBvZiB0aGVcclxuICogT3ZlcmxheUhvc3QgY29tcG9uZW50LCBzbyB0aGF0IG90aGVyIGNvbXBvbmVudHMgbWF5IGluc2VydCBjb21wb25lbnRzICYgZWxlbWVudHNcclxuICogaW50byB0aGUgRE9NIGF0IHRoYXQgcG9pbnQuXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSh7XHJcbiAgICBwcm92aWRlZEluOiAncm9vdCcsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBPdmVybGF5SG9zdFNlcnZpY2Uge1xyXG4gICAgcHJpdmF0ZSBob3N0VmlldzogVmlld0NvbnRhaW5lclJlZjtcclxuICAgIHByaXZhdGUgcHJvbWlzZVJlc29sdmVGbnM6IEFycmF5PChyZXN1bHQ6IGFueSkgPT4gdm9pZD4gPSBbXTtcclxuXHJcbiAgICAvKipcclxuICAgICAqIFVzZWQgdG8gcGFzcyBpbiB0aGUgVmlld0NvbnRhaW5lclJlZCBmcm9tIHRoZSBPdmVybGF5SG9zdCBjb21wb25lbnQuXHJcbiAgICAgKiBTaG91bGQgbm90IGJlIHVzZWQgYnkgYW55IG90aGVyIGNvbXBvbmVudC5cclxuICAgICAqL1xyXG4gICAgcmVnaXN0ZXJIb3N0Vmlldyh2aWV3Q29udGFpbmVyUmVmOiBWaWV3Q29udGFpbmVyUmVmKTogdm9pZCB7XHJcbiAgICAgICAgdGhpcy5ob3N0VmlldyA9IHZpZXdDb250YWluZXJSZWY7XHJcbiAgICAgICAgaWYgKDAgPCB0aGlzLnByb21pc2VSZXNvbHZlRm5zLmxlbmd0aCkge1xyXG4gICAgICAgICAgICB0aGlzLnJlc29sdmVIb3N0VmlldygpO1xyXG4gICAgICAgIH1cclxuICAgIH1cclxuXHJcbiAgICAvKipcclxuICAgICAqIFJldHVybnMgYSBwcm9taXNlIHdoaWNoIHJlc29sdmVzIHRvIHRoZSBWaWV3Q29udGFpbmVyUmVmIG9mIHRoZSBPdmVybGF5SG9zdFxyXG4gICAgICogY29tcG9uZW50LiBUaGlzIGNhbiB0aGVuIGJlIHVzZWQgdG8gaW5zZXJ0IGNvbXBvbmVudHMgYW5kIGVsZW1lbnRzIGludG8gdGhlXHJcbiAgICAgKiBET00gYXQgdGhhdCBwb2ludC5cclxuICAgICAqL1xyXG4gICAgZ2V0SG9zdFZpZXcoKTogUHJvbWlzZTxWaWV3Q29udGFpbmVyUmVmPiB7XHJcbiAgICAgICAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlOiAocmVzdWx0OiBhbnkpID0+IHZvaWQpID0+IHtcclxuICAgICAgICAgICAgdGhpcy5wcm9taXNlUmVzb2x2ZUZucy5wdXNoKHJlc29sdmUpO1xyXG4gICAgICAgICAgICBpZiAodGhpcy5ob3N0VmlldyAhPT0gdW5kZWZpbmVkKSB7XHJcbiAgICAgICAgICAgICAgICB0aGlzLnJlc29sdmVIb3N0VmlldygpO1xyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSByZXNvbHZlSG9zdFZpZXcoKTogdm9pZCB7XHJcbiAgICAgICAgdGhpcy5wcm9taXNlUmVzb2x2ZUZucy5mb3JFYWNoKHJlc29sdmUgPT4gcmVzb2x2ZSh0aGlzLmhvc3RWaWV3KSk7XHJcbiAgICAgICAgdGhpcy5wcm9taXNlUmVzb2x2ZUZucyA9IFtdO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==