@quadrel-enterprise-ui/framework 1.0.0 → 18.19.1

package/esm2022/lib/notifications/notification/notification.component.mjs

@@ -0,0 +1,511 @@
+// @ts-strict-ignore
+import { Component, ElementRef, HostBinding, Input } from '@angular/core';
+import { QdNotificationsService } from '../services/notifications-service.service';
+import { QdSnackbarService } from '../services/snackbar.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/notifications-service.service";
+import * as i2 from "../services/snackbar.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../../icon/icon/icon.component";
+import * as i5 from "@ngx-translate/core";
+/**
+ *  **QdNotification** displays a single notification item within a **QdNotifications** container.
+ *
+ * # Notifications Service
+ *
+ * The **Notifications Service** can be used to catch errors from the backend. In addition, this service provides several methods to display messages.
+ *
+ * ## Notification from Backend
+ *
+ * The **QdUiModule** provides an HTTP interceptor that displays request errors as snackbar notifications. To get the proper notification messages for the corresponding backend errors, please comply with these conventions.
+ *
+ * ### Example of a response object
+ *
+ * The backend service response has to contain an errorCode field. This error code will be mapped to get the translation for the notification message.
+ *
+ * ```json
+ * {
+ *   "errorCode": "TRANSPORT_COCKPIT_PERSISTENCE_ERROR",
+ *   "errorMessage": "TRANSPORT_COCKPIT_PERSISTENCE_ERROR: Could not find Declaration wih id: b78e0734-ae1b-434e-b44d-b48797f5696d"
+ * }
+ * ```
+ *
+ * ### Define Error Codes in the QdUiModule
+ *
+ * The **QdUiModule** expects an enum with error codes as the second parameter. For these given error codes you can define specific notification messages.
+ *
+ * This is an example configuration of the **QdUiModule** in the **app.module.ts**.
+ *
+ * ```typescript
+ * enum ErrorCodes {
+ *   TRANSPORT_COCKPIT_PERSISTENCE_ERROR,
+ *   TRANSPORT_COCKPIT_VALIDATION_ERROR
+ * }
+ * ```
+ *
+ * ```typescript
+ * imports: [
+ *   ...
+ *   QdUiModule.forRoot(appEnvironment, ErrorCodes),
+ *   ...
+ * ]
+ * ```
+ *
+ * ### Translations:
+ *
+ * You can define the specific backend error notification messages for the respective error codes under `"ERROR"` in the translation files.
+ *
+ * ```json
+ * {
+ *   ...
+ *
+ *   "ERROR": {
+ *     "TRANSPORT_COCKPIT_PERSISTENCE_ERROR": "In der Datenbank ist ein Fehler aufgetreten",
+ *     "TRANSPORT_COCKPIT_VALIDATION_ERROR": "Ungültige Eingabe"
+ *   }
+ * }
+ * ```
+ *
+ * ### Default error messages
+ *
+ * A default error message is shown if no error code is given in the backend response or the error code is not defined in the `ErrorCodes` enum that you pass to the **QdUiModule**.
+ *
+ * To override the default error messages you have to add the corresponding HTTP error code in the `ErrorCodes` enum. Then you can define a custom default error message in the translation files.
+ *
+ * ```typescript
+ * enum ErrorCodes {
+ *   ...,
+ *   HTTP_BAD_REQUEST,
+ *   HTTP_UNAUTHORIZED,
+ *   HTTP_FORBIDDEN,
+ *   HTTP_NOT_FOUND,
+ *   HTTP_SERVER_ERROR,
+ *   HTTP_UNKNOWN_ERROR
+ * }
+ * ```
+ *
+ * ```json
+ * {
+ *   ...
+ *
+ *   "ERROR": {
+ *     "HTTP_BAD_REQUEST": "This is a custom error message for a response with the HTTP status code 400.",
+ *     "HTTP_UNAUTHORIZED": "This is a custom error message for a response with the HTTP status code 401.",
+ *     "HTTP_FORBIDDEN": "This is a custom error message for a response with the HTTP status code 403.",
+ *     "HTTP_NOT_FOUND": "This is a custom error message for a response with the HTTP status code 404.",
+ *     "HTTP_SERVER_ERROR": "This is a custom error message for a response with some server error (HTTP status code 5xx).",
+ *     "HTTP_UNKNOWN_ERROR": "This is a custom error message for all other errors."
+ *   }
+ * }
+ * ```
+ *
+ * ### Component:
+ *
+ * ```typescript
+ * class MyNotificationComponent {
+ *   data;
+ *
+ *   constructor(private http: HttpClient) {}
+ *
+ *   private setData(data) {
+ *     this.data = data;
+ *   }
+ *
+ *   public callApiEndPoint() {
+ *     // This way you can display the content in the frontend.
+ *     return this.http.get('route/to/endpoint').subscribe({
+ *       next: res => this.setData(res),
+ *       error: err => this.setData(err)
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * The errors are rendered into a container, which by default has the attribute `context="qdPanel"`.
+ *
+ * ```html
+ * <!-- Landing pad for notifications -->
+ * <qd-notifications></qd-notifications>
+ * ```
+ *
+ * ## Notifications via service
+ *
+ * ### Interfaces:
+ *
+ * ```typescript
+ * interface QdNotification {
+ *   uuid?: string;
+ *   context?: string;
+ *   type: QdNotificationType;
+ *   i18n: QdNotificationTranslation;
+ *   title?: QdNotificationTitle;
+ *   date?: Date;
+ *   lifeTime?: number;
+ *   disableClose?: boolean;
+ *   onClose?: () => void;
+ *   showAsSnackbar?: boolean;
+ *   snackbarOptions?: QdSnackbarNotificationOptions;
+ *   showAsOsNotification?: boolean;
+ *   osNotificationOptions?: QdOsNotificationOptions;
+ * }
+ *
+ * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';
+ *
+ * type QdNotificationTranslation = string;
+ * type QdNotificationTitle = { i18n: string };
+ *
+ * type QdNotifications = QdNotification[];
+ *
+ * interface QdSnackbarNotificationOptions {
+ *   lifeTime?: number;
+ *   disableClose?: boolean;
+ *   onClose?: () => void;
+ * }
+ *
+ * interface QdOsNotificationOptions {
+ *   silent?: boolean;
+ *   lifeTime?: number;
+ *   onClose?: (event) => void;
+ *   onClick?: (event) => void;
+ * }
+ * ```
+ *
+ * The Notifications Service provides some methods to display them in the frontend.
+ *
+ * ### Component
+ *
+ * ```typescript
+ * class MyNotificationComponent {
+ *   constructor(private notificationsService: QdNotificationsService) {}
+ *
+ *   public add(context: string, notification: QdNotification): void {
+ *     this.notificationsService.add(context, notification);
+ *   }
+ * }
+ * ```
+ *
+ * ### Type QdNotification (Second param of the add method)
+ *
+ * ```typescript
+ * interface QdNotification {
+ *   ...
+ *
+ *   type: QdNotificationType;
+ *   i18n: string;
+ *   lifeTime?: number;
+ * }
+ *
+ * type QdNotifications = QdNotification[];
+ * ```
+ *
+ * ### Type QdNotificationType
+ *
+ * ```typescript
+ * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';
+ * ```
+ *
+ * ### Template
+ *
+ * ```html
+ * <button (click)="add('qdPanel', { type: 'critical', i18n: 'i18n.error.critical' })">Add Notification</button>
+ * ```
+ *
+ * ### Template for displaying notifications - for instance in the Info Panel
+ *
+ * ```html
+ * <qd-notifications></qd-notifications>
+ * ```
+ *
+ * ## Notifications as a snackbar
+ *
+ * You can also display the notifications as a snack bar. They are then on top of the layout system. What you need to do is to place the directive `qdSnackbarListener` there. Also, just add the `showAsSnackbar` parameter to the method call.
+ *
+ * ### Example
+ *
+ * ```html
+ * <qd-container qdSnackbarListener> My Container Content </qd-container>
+ *
+ * <button (click)="addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsSnackbar: true })">
+ *   Add Notification
+ * </button>
+ * ```
+ *
+ * All notifications are now displayed by the directive contained in the `qd-container`. Also, all notifications from the backend are displayed there.
+ *
+ * **Recommendation of the Quadrel Team**: Place the `qdSnackbarListener` directly on top of the layout system - so for example in the **AppComponent**.
+ *
+ * ### Options
+ *
+ * You can also pass a configuration object in the `snackbarOptions` parameter to customize the snackbar notification or to set an `onClose` handler.
+ * When you close the main notification, the snackbar notification will be closed automatically. The snackbar notification can be closed for itself alone.
+ *
+ * In the `snackbarOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,
+ * the snackbar notification will also be closed. So the life time of the snackbar notification only can be shorter.
+ *
+ * ## OS Notifications
+ *
+ * To bring a notification to the foreground, even if the application window is not in focus, you can also push the notification as an OS Notification.
+ * Then the notification will also be pushed through the Notification browser API and will be displayed on your operating system (e.g. Windows/Linux).
+ * In the future, the OS Notifications will also be pushed as smartphone system notifications. Currently, only desktop notifications are supported.
+ *
+ * ### Example
+ *
+ * ```html
+ * <button (click)="addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsOsNotification: true })">
+ *   Add Notification
+ * </button>
+ * ```
+ *
+ * ### Options
+ *
+ * You can also pass a configuration object in the `osNotificationOptions` parameter to customize the OS notification or to set `onClick` and `onClose` handlers.
+ * When you close the main notification, the OS notification will be closed automatically. The OS notification can be closed for itself alone.
+ *
+ * In the `osNotificationOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,
+ * the OS notification will also be closed. So the life time of the OS notification only can be shorter.
+ *
+ * ### Deep links
+ *
+ * To open a deep link when the OS notification is clicked, use the following code for the click handler:
+ *
+ * ```typescript
+ * event.preventDefault();
+ * window.open('https://your/deep/link');
+ * ```
+ *
+ * ## Notifications via service (multiple instances)
+ *
+ * ### Object of multiple notifications
+ *
+ * ```typescript
+ * const BULK: QdNotifications = [
+ *   {
+ *     type: 'critical',
+ *     i18n: 'i18n.error.1'
+ *   },
+ *   {
+ *     type: 'critical',
+ *     i18n: 'i18n.error.2'
+ *   }
+ * ];
+ * ```
+ *
+ * ### Component
+ *
+ * ```typescript
+ * class MyNotificationComponent {
+ *   bulk: QdNotifications = BULK;
+ *
+ *   constructor(private notificationsService: QdNotificationsService, public modalService: QdModalService) {}
+ *
+ *   openNotificationModal(mrn) {
+ *     // MRN represents a unique context
+ *     this.modalService.open(MyNotificationModalComponent, { data: { mrn } });
+ *
+ *     // Adds the notifications when opening
+ *     this.notificationsService.addBulk(mrn, this.bulk);
+ *   }
+ * }
+ * ```
+ *
+ * ### Template
+ *
+ * ```html
+ * <mat-table [dataSource]="dataSource">
+ *   <ng-container matColumnDef="mrn">
+ *     <mat-header-cell *matHeaderCellDef class="center">Mrn.</mat-header-cell>
+ *     <mat-cell *matCellDef="let element" class="center">
+ *       <button mat-button color="primary" (click)="openNotificationModal(element.mrn)">
+ *         <!-- MRN represents a unique context -->
+ *         {{ element.mrn }}
+ *       </button>
+ *     </mat-cell>
+ *   </ng-container>
+ * </mat-table>
+ * ```
+ *
+ * ## Notification Events
+ *
+ * You can define an `onClose` callback for each notification type. When the main notification is closed, then
+ * the corresponding snackbar notification and OS notification will also be closed and all events will be fired.
+ *
+ * ```typescript
+ * class MyNotificationComponent {
+ *   constructor(private notificationsService: QdNotificationsService) {}
+ *
+ *   showNotification(): void {
+ *     this.notificationsService.add(
+ *       'qdPanel',
+ *       {
+ *         type: 'critical',
+ *         i18n: 'i18n.error.critical',
+ *         onClose: () => console.log('Notification closed.'),
+ *         showAsSnackbar: true,
+ *         snackbarOptions: {
+ *           onClose: () => console.log('Snackbar Notification closed.')
+ *         }
+ *         showAsOsNotification: true,
+ *         osNotificationOptions: {
+ *           onClose: () => console.log('OS Notification closed.')
+ *         }
+ *       }
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * Especially for the OS notification an `onClick` handler can be defined. With the onClick handler it's also possible
+ * to define a deep link that will be opened on click with the following code:
+ *
+ * ```typescript
+ * this.notificationsService.add(
+ *   'qdPanel',
+ *   {
+ *     type: 'critical',
+ *     i18n: 'i18n.error.critical',
+ *     showAsOsNotification: true,
+ *     osNotificationOptions: {
+ *       onClick: (event) => {
+ *         event.preventDefault();
+ *         window.open('https://your/deep/link');
+ *       }
+ *     }
+ *   }
+ * );
+ * ```
+ *
+ * ## Inline Notifications
+ *
+ * Notifications can also be inserted directly into the template.
+ *
+ * ```html
+ * <qd-notification [type]="type" [notification]="notification">
+ *   <qd-notification-content> test notification content </qd-notification-content>
+ * </qd-notification>
+ * ```
+ *
+ * ```typescript
+ * // The type can be defined with the type input
+ * type = 'critical';
+ *
+ * // ... or in the notification config
+ * notification: QdNotification = {
+ *   type: 'critical'
+ * }
+ * ```
+ *
+ * The content can also be defined in the config. Then you don't have to put a `qd-notification-content`
+ * element into the `qd-notification`.
+ *
+ * ```html
+ * <qd-notification [notification]="notification"></qd-notification>
+ * ```
+ *
+ * ```typescript
+ * notification: QdNotification = {
+ *   type: 'critical',
+ *   i18n: 'i18n.error.critical'
+ * }
+ * ```
+ *
+ * ## Multiline Notifications
+ *
+ * To create a multiline notification you simply can insert `\n` in the i18n translation text. Line breaks (`\n`) are
+ * not considered if you use the `<qd-notification-content>` variant. Line breaks only work if you define the
+ * i18n key in the notification config.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * notification: QdNotification = {
+ *   type: 'warning',
+ *   i18n: 'i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired'
+ * }
+ * ```
+ *
+ * ```json
+ * {
+ *   ...
+ *
+ *   "i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired": "The inventory result must be checked and the control result recorded. \nAttention: The transit period has expired upon arrival at the Authorized Place",
+ * }
+ * ```
+ *
+ * ### Notifications Service
+ *
+ * | Method                       | Params                                                 | description                                      | default |
+ * | ---------------------------- | ------------------------------------------------------ | ------------------------------------------------ | ------- |
+ * | getNotificationsForContext() | context: string                                        | Returns notification stream for context.         | -       |
+ * | add()                        | context: string, notification: QdNotification          | Adds a single notification.                      | -       |
+ * | addBulk()                    | context: string, notifications: QdNotifications        | Adds multiple notifications.                     | -       |
+ * | remove()                     | context: string, id: string                            | Removes specific notification.                   | -       |
+ * | removeAll()                  | context: string                                        | Removes all notifications in context.            | -       |
+ * | reset()                      | -                                                      | Clear all notifications.                         | -       |
+ */
+export class QdNotificationComponent {
+    notificationService;
+    snackbarService;
+    element;
+    /**
+     * Defines the type of this notification.
+     */
+    type = 'critical';
+    /**
+     * Configuration of a notification.
+     */
+    notification;
+    get typeClassName() {
+        return `qd-notification qd-notification-${this.getType()}`;
+    }
+    get closeable() {
+        return this.notification ? !this.notification.disableClose : true;
+    }
+    constructor(notificationService, snackbarService, element) {
+        this.notificationService = notificationService;
+        this.snackbarService = snackbarService;
+        this.element = element;
+    }
+    getType() {
+        return this.notification?.type || this.type;
+    }
+    getIcon() {
+        switch (this.getType()) {
+            case 'success':
+                return 'checkCircleSolid';
+            case 'info':
+                return 'checkCircleSolid';
+            case 'warning':
+                return 'warningHexFilled';
+            case 'critical':
+                return 'exclamationCircleSolid';
+        }
+    }
+    remove() {
+        if (this.isNotificationInSnackbar()) {
+            this.snackbarService.close(this.notification.uuid);
+        }
+        else {
+            this.notificationService.remove(this.notification.context, this.notification.uuid);
+        }
+    }
+    handleLinkClick() {
+        this.notification.link.handler();
+    }
+    isNotificationInSnackbar() {
+        return !!this.element.nativeElement.closest('qd-snackbar');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationComponent, deps: [{ token: i1.QdNotificationsService }, { token: i2.QdSnackbarService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdNotificationComponent, selector: "qd-notification", inputs: { type: "type", notification: "notification" }, host: { properties: { "attr.class": "this.typeClassName" }, classAttribute: "qd-notification" }, ngImport: i0, template: "<qd-icon *ngIf=\"closeable\" [icon]=\"'timesLarge'\" class=\"closer\" (click)=\"remove()\"></qd-icon>\n<qd-icon [icon]=\"this.getIcon()\" class=\"icon\"></qd-icon>\n\n<ng-content select=\"qd-notification-content\"></ng-content>\n\n<div class=\"title\" *ngIf=\"notification?.title\">{{ notification.title.i18n | translate }}</div>\n<div class=\"message\">\n  <span>{{ notification?.i18n | translate }}</span>\n  <a class=\"link\" *ngIf=\"notification?.link\" (click)=\"handleLinkClick()\">{{ notification.link.i18n | translate }}</a>\n</div>\n", styles: [":host{position:relative;z-index:9999!important;display:block;width:100%;padding:1rem 2rem .5rem 2.75rem;border-width:.0625rem;border-style:solid;border-left-width:.25rem;margin-bottom:.5rem;background:#fff;box-shadow:0 0 .625rem #979797;font-size:.875rem;gap:.5rem;line-height:1rem}:host.qd-notification-info{border-color:#069}:host.qd-notification-info .icon,:host.qd-notification-info .title{color:#069}:host.qd-notification-warning{border-color:#ff9b00}:host.qd-notification-warning .icon,:host.qd-notification-warning .title{color:#ff9b00}:host.qd-notification-critical{border-color:#c70023}:host.qd-notification-critical .icon,:host.qd-notification-critical .title{color:#c70023}:host.qd-notification-success{border-color:#00813a}:host.qd-notification-success .icon,:host.qd-notification-success .title{color:#00813a}:host .icon{position:absolute;top:.9375rem;left:1rem;font-size:1.25rem}:host .closer{position:absolute;top:1rem;right:.75rem;color:#171717;cursor:pointer;font-size:.8125rem;font-weight:600}:host .title{margin-bottom:.375rem;font-weight:500}:host .message{margin-bottom:.25rem;white-space:pre-wrap}:host .link{margin-bottom:.375rem;margin-left:.375rem;color:#069;cursor:pointer}:host .link:hover{text-decoration:underline}:host:host-context(qd-snackbar) .link{display:block;margin-top:.375rem;margin-left:0}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.QdIconComponent, selector: "qd-icon", inputs: ["icon"] }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-notification', host: { class: 'qd-notification' }, template: "<qd-icon *ngIf=\"closeable\" [icon]=\"'timesLarge'\" class=\"closer\" (click)=\"remove()\"></qd-icon>\n<qd-icon [icon]=\"this.getIcon()\" class=\"icon\"></qd-icon>\n\n<ng-content select=\"qd-notification-content\"></ng-content>\n\n<div class=\"title\" *ngIf=\"notification?.title\">{{ notification.title.i18n | translate }}</div>\n<div class=\"message\">\n  <span>{{ notification?.i18n | translate }}</span>\n  <a class=\"link\" *ngIf=\"notification?.link\" (click)=\"handleLinkClick()\">{{ notification.link.i18n | translate }}</a>\n</div>\n", styles: [":host{position:relative;z-index:9999!important;display:block;width:100%;padding:1rem 2rem .5rem 2.75rem;border-width:.0625rem;border-style:solid;border-left-width:.25rem;margin-bottom:.5rem;background:#fff;box-shadow:0 0 .625rem #979797;font-size:.875rem;gap:.5rem;line-height:1rem}:host.qd-notification-info{border-color:#069}:host.qd-notification-info .icon,:host.qd-notification-info .title{color:#069}:host.qd-notification-warning{border-color:#ff9b00}:host.qd-notification-warning .icon,:host.qd-notification-warning .title{color:#ff9b00}:host.qd-notification-critical{border-color:#c70023}:host.qd-notification-critical .icon,:host.qd-notification-critical .title{color:#c70023}:host.qd-notification-success{border-color:#00813a}:host.qd-notification-success .icon,:host.qd-notification-success .title{color:#00813a}:host .icon{position:absolute;top:.9375rem;left:1rem;font-size:1.25rem}:host .closer{position:absolute;top:1rem;right:.75rem;color:#171717;cursor:pointer;font-size:.8125rem;font-weight:600}:host .title{margin-bottom:.375rem;font-weight:500}:host .message{margin-bottom:.25rem;white-space:pre-wrap}:host .link{margin-bottom:.375rem;margin-left:.375rem;color:#069;cursor:pointer}:host .link:hover{text-decoration:underline}:host:host-context(qd-snackbar) .link{display:block;margin-top:.375rem;margin-left:0}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdNotificationsService }, { type: i2.QdSnackbarService }, { type: i0.ElementRef }], propDecorators: { type: [{
+                type: Input
+            }], notification: [{
+                type: Input
+            }], typeClassName: [{
+                type: HostBinding,
+                args: ['attr.class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.ts","../../../../../../libs/qd-ui/src/lib/notifications/notification/notification.component.html"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;;;;;;;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAibG;AAOH,MAAM,OAAO,uBAAuB;IAoBf;IACA;IACT;IArBV;;OAEG;IACM,IAAI,GAAuB,UAAU,CAAC;IAE/C;;OAEG;IACM,YAAY,CAAiB;IAEtC,IAA+B,aAAa;QAC1C,OAAO,mCAAmC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;IAC7D,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;IACpE,CAAC;IAED,YACmB,mBAA2C,EAC3C,eAAkC,EAC3C,OAAmB;QAFV,wBAAmB,GAAnB,mBAAmB,CAAwB;QAC3C,oBAAe,GAAf,eAAe,CAAmB;QAC3C,YAAO,GAAP,OAAO,CAAY;IAC1B,CAAC;IAEJ,OAAO;QACL,OAAO,IAAI,CAAC,YAAY,EAAE,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;IAC9C,CAAC;IAED,OAAO;QACL,QAAQ,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YACvB,KAAK,SAAS;gBACZ,OAAO,kBAAkB,CAAC;YAC5B,KAAK,MAAM;gBACT,OAAO,kBAAkB,CAAC;YAC5B,KAAK,SAAS;gBACZ,OAAO,kBAAkB,CAAC;YAC5B,KAAK,UAAU;gBACb,OAAO,wBAAwB,CAAC;QACpC,CAAC;IACH,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;YACpC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IACnC,CAAC;IAEO,wBAAwB;QAC9B,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;uGAxDU,uBAAuB;2FAAvB,uBAAuB,gNC9bpC,giBAUA;;2FDoba,uBAAuB;kBANnC,SAAS;+BACE,iBAAiB,QAGrB,EAAE,KAAK,EAAE,iBAAiB,EAAE;oJAMzB,IAAI;sBAAZ,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAEyB,aAAa;sBAA3C,WAAW;uBAAC,YAAY","sourcesContent":["// @ts-strict-ignore\nimport { Component, ElementRef, HostBinding, Input } from '@angular/core';\nimport { QdNotification, QdNotificationType } from '../interfaces/notifications';\nimport { QdNotificationsService } from '../services/notifications-service.service';\nimport { QdSnackbarService } from '../services/snackbar.service';\n\n/**\n *  **QdNotification** displays a single notification item within a **QdNotifications** container.\n *\n * # Notifications Service\n *\n * The **Notifications Service** can be used to catch errors from the backend. In addition, this service provides several methods to display messages.\n *\n * ## Notification from Backend\n *\n * The **QdUiModule** provides an HTTP interceptor that displays request errors as snackbar notifications. To get the proper notification messages for the corresponding backend errors, please comply with these conventions.\n *\n * ### Example of a response object\n *\n * The backend service response has to contain an errorCode field. This error code will be mapped to get the translation for the notification message.\n *\n * ```json\n * {\n *   \"errorCode\": \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR\",\n *   \"errorMessage\": \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR: Could not find Declaration wih id: b78e0734-ae1b-434e-b44d-b48797f5696d\"\n * }\n * ```\n *\n * ### Define Error Codes in the QdUiModule\n *\n * The **QdUiModule** expects an enum with error codes as the second parameter. For these given error codes you can define specific notification messages.\n *\n * This is an example configuration of the **QdUiModule** in the **app.module.ts**.\n *\n * ```typescript\n * enum ErrorCodes {\n *   TRANSPORT_COCKPIT_PERSISTENCE_ERROR,\n *   TRANSPORT_COCKPIT_VALIDATION_ERROR\n * }\n * ```\n *\n * ```typescript\n * imports: [\n *   ...\n *   QdUiModule.forRoot(appEnvironment, ErrorCodes),\n *   ...\n * ]\n * ```\n *\n * ### Translations:\n *\n * You can define the specific backend error notification messages for the respective error codes under `\"ERROR\"` in the translation files.\n *\n * ```json\n * {\n *   ...\n *\n *   \"ERROR\": {\n *     \"TRANSPORT_COCKPIT_PERSISTENCE_ERROR\": \"In der Datenbank ist ein Fehler aufgetreten\",\n *     \"TRANSPORT_COCKPIT_VALIDATION_ERROR\": \"Ungültige Eingabe\"\n *   }\n * }\n * ```\n *\n * ### Default error messages\n *\n * A default error message is shown if no error code is given in the backend response or the error code is not defined in the `ErrorCodes` enum that you pass to the **QdUiModule**.\n *\n * To override the default error messages you have to add the corresponding HTTP error code in the `ErrorCodes` enum. Then you can define a custom default error message in the translation files.\n *\n * ```typescript\n * enum ErrorCodes {\n *   ...,\n *   HTTP_BAD_REQUEST,\n *   HTTP_UNAUTHORIZED,\n *   HTTP_FORBIDDEN,\n *   HTTP_NOT_FOUND,\n *   HTTP_SERVER_ERROR,\n *   HTTP_UNKNOWN_ERROR\n * }\n * ```\n *\n * ```json\n * {\n *   ...\n *\n *   \"ERROR\": {\n *     \"HTTP_BAD_REQUEST\": \"This is a custom error message for a response with the HTTP status code 400.\",\n *     \"HTTP_UNAUTHORIZED\": \"This is a custom error message for a response with the HTTP status code 401.\",\n *     \"HTTP_FORBIDDEN\": \"This is a custom error message for a response with the HTTP status code 403.\",\n *     \"HTTP_NOT_FOUND\": \"This is a custom error message for a response with the HTTP status code 404.\",\n *     \"HTTP_SERVER_ERROR\": \"This is a custom error message for a response with some server error (HTTP status code 5xx).\",\n *     \"HTTP_UNKNOWN_ERROR\": \"This is a custom error message for all other errors.\"\n *   }\n * }\n * ```\n *\n * ### Component:\n *\n * ```typescript\n * class MyNotificationComponent {\n *   data;\n *\n *   constructor(private http: HttpClient) {}\n *\n *   private setData(data) {\n *     this.data = data;\n *   }\n *\n *   public callApiEndPoint() {\n *     // This way you can display the content in the frontend.\n *     return this.http.get('route/to/endpoint').subscribe({\n *       next: res => this.setData(res),\n *       error: err => this.setData(err)\n *     });\n *   }\n * }\n * ```\n *\n * The errors are rendered into a container, which by default has the attribute `context=\"qdPanel\"`.\n *\n * ```html\n * <!-- Landing pad for notifications -->\n * <qd-notifications></qd-notifications>\n * ```\n *\n * ## Notifications via service\n *\n * ### Interfaces:\n *\n * ```typescript\n * interface QdNotification {\n *   uuid?: string;\n *   context?: string;\n *   type: QdNotificationType;\n *   i18n: QdNotificationTranslation;\n *   title?: QdNotificationTitle;\n *   date?: Date;\n *   lifeTime?: number;\n *   disableClose?: boolean;\n *   onClose?: () => void;\n *   showAsSnackbar?: boolean;\n *   snackbarOptions?: QdSnackbarNotificationOptions;\n *   showAsOsNotification?: boolean;\n *   osNotificationOptions?: QdOsNotificationOptions;\n * }\n *\n * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';\n *\n * type QdNotificationTranslation = string;\n * type QdNotificationTitle = { i18n: string };\n *\n * type QdNotifications = QdNotification[];\n *\n * interface QdSnackbarNotificationOptions {\n *   lifeTime?: number;\n *   disableClose?: boolean;\n *   onClose?: () => void;\n * }\n *\n * interface QdOsNotificationOptions {\n *   silent?: boolean;\n *   lifeTime?: number;\n *   onClose?: (event) => void;\n *   onClick?: (event) => void;\n * }\n * ```\n *\n * The Notifications Service provides some methods to display them in the frontend.\n *\n * ### Component\n *\n * ```typescript\n * class MyNotificationComponent {\n *   constructor(private notificationsService: QdNotificationsService) {}\n *\n *   public add(context: string, notification: QdNotification): void {\n *     this.notificationsService.add(context, notification);\n *   }\n * }\n * ```\n *\n * ### Type QdNotification (Second param of the add method)\n *\n * ```typescript\n * interface QdNotification {\n *   ...\n *\n *   type: QdNotificationType;\n *   i18n: string;\n *   lifeTime?: number;\n * }\n *\n * type QdNotifications = QdNotification[];\n * ```\n *\n * ### Type QdNotificationType\n *\n * ```typescript\n * type QdNotificationType = 'info' | 'warning' | 'critical' | 'success';\n * ```\n *\n * ### Template\n *\n * ```html\n * <button (click)=\"add('qdPanel', { type: 'critical', i18n: 'i18n.error.critical' })\">Add Notification</button>\n * ```\n *\n * ### Template for displaying notifications - for instance in the Info Panel\n *\n * ```html\n * <qd-notifications></qd-notifications>\n * ```\n *\n * ## Notifications as a snackbar\n *\n * You can also display the notifications as a snack bar. They are then on top of the layout system. What you need to do is to place the directive `qdSnackbarListener` there. Also, just add the `showAsSnackbar` parameter to the method call.\n *\n * ### Example\n *\n * ```html\n * <qd-container qdSnackbarListener> My Container Content </qd-container>\n *\n * <button (click)=\"addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsSnackbar: true })\">\n *   Add Notification\n * </button>\n * ```\n *\n * All notifications are now displayed by the directive contained in the `qd-container`. Also, all notifications from the backend are displayed there.\n *\n * **Recommendation of the Quadrel Team**: Place the `qdSnackbarListener` directly on top of the layout system - so for example in the **AppComponent**.\n *\n * ### Options\n *\n * You can also pass a configuration object in the `snackbarOptions` parameter to customize the snackbar notification or to set an `onClose` handler.\n * When you close the main notification, the snackbar notification will be closed automatically. The snackbar notification can be closed for itself alone.\n *\n * In the `snackbarOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,\n * the snackbar notification will also be closed. So the life time of the snackbar notification only can be shorter.\n *\n * ## OS Notifications\n *\n * To bring a notification to the foreground, even if the application window is not in focus, you can also push the notification as an OS Notification.\n * Then the notification will also be pushed through the Notification browser API and will be displayed on your operating system (e.g. Windows/Linux).\n * In the future, the OS Notifications will also be pushed as smartphone system notifications. Currently, only desktop notifications are supported.\n *\n * ### Example\n *\n * ```html\n * <button (click)=\"addNotification('qdPanel', { type: 'critical', i18n: 'i18n.error.critical', showAsOsNotification: true })\">\n *   Add Notification\n * </button>\n * ```\n *\n * ### Options\n *\n * You can also pass a configuration object in the `osNotificationOptions` parameter to customize the OS notification or to set `onClick` and `onClose` handlers.\n * When you close the main notification, the OS notification will be closed automatically. The OS notification can be closed for itself alone.\n *\n * In the `osNotificationOptions` configuration object you can override the properties `disableClose` and `lifeTime`. When the main notification is closed,\n * the OS notification will also be closed. So the life time of the OS notification only can be shorter.\n *\n * ### Deep links\n *\n * To open a deep link when the OS notification is clicked, use the following code for the click handler:\n *\n * ```typescript\n * event.preventDefault();\n * window.open('https://your/deep/link');\n * ```\n *\n * ## Notifications via service (multiple instances)\n *\n * ### Object of multiple notifications\n *\n * ```typescript\n * const BULK: QdNotifications = [\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.1'\n *   },\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.2'\n *   }\n * ];\n * ```\n *\n * ### Component\n *\n * ```typescript\n * class MyNotificationComponent {\n *   bulk: QdNotifications = BULK;\n *\n *   constructor(private notificationsService: QdNotificationsService, public modalService: QdModalService) {}\n *\n *   openNotificationModal(mrn) {\n *     // MRN represents a unique context\n *     this.modalService.open(MyNotificationModalComponent, { data: { mrn } });\n *\n *     // Adds the notifications when opening\n *     this.notificationsService.addBulk(mrn, this.bulk);\n *   }\n * }\n * ```\n *\n * ### Template\n *\n * ```html\n * <mat-table [dataSource]=\"dataSource\">\n *   <ng-container matColumnDef=\"mrn\">\n *     <mat-header-cell *matHeaderCellDef class=\"center\">Mrn.</mat-header-cell>\n *     <mat-cell *matCellDef=\"let element\" class=\"center\">\n *       <button mat-button color=\"primary\" (click)=\"openNotificationModal(element.mrn)\">\n *         <!-- MRN represents a unique context -->\n *         {{ element.mrn }}\n *       </button>\n *     </mat-cell>\n *   </ng-container>\n * </mat-table>\n * ```\n *\n * ## Notification Events\n *\n * You can define an `onClose` callback for each notification type. When the main notification is closed, then\n * the corresponding snackbar notification and OS notification will also be closed and all events will be fired.\n *\n * ```typescript\n * class MyNotificationComponent {\n *   constructor(private notificationsService: QdNotificationsService) {}\n *\n *   showNotification(): void {\n *     this.notificationsService.add(\n *       'qdPanel',\n *       {\n *         type: 'critical',\n *         i18n: 'i18n.error.critical',\n *         onClose: () => console.log('Notification closed.'),\n *         showAsSnackbar: true,\n *         snackbarOptions: {\n *           onClose: () => console.log('Snackbar Notification closed.')\n *         }\n *         showAsOsNotification: true,\n *         osNotificationOptions: {\n *           onClose: () => console.log('OS Notification closed.')\n *         }\n *       }\n *     );\n *   }\n * }\n * ```\n *\n * Especially for the OS notification an `onClick` handler can be defined. With the onClick handler it's also possible\n * to define a deep link that will be opened on click with the following code:\n *\n * ```typescript\n * this.notificationsService.add(\n *   'qdPanel',\n *   {\n *     type: 'critical',\n *     i18n: 'i18n.error.critical',\n *     showAsOsNotification: true,\n *     osNotificationOptions: {\n *       onClick: (event) => {\n *         event.preventDefault();\n *         window.open('https://your/deep/link');\n *       }\n *     }\n *   }\n * );\n * ```\n *\n * ## Inline Notifications\n *\n * Notifications can also be inserted directly into the template.\n *\n * ```html\n * <qd-notification [type]=\"type\" [notification]=\"notification\">\n *   <qd-notification-content> test notification content </qd-notification-content>\n * </qd-notification>\n * ```\n *\n * ```typescript\n * // The type can be defined with the type input\n * type = 'critical';\n *\n * // ... or in the notification config\n * notification: QdNotification = {\n *   type: 'critical'\n * }\n * ```\n *\n * The content can also be defined in the config. Then you don't have to put a `qd-notification-content`\n * element into the `qd-notification`.\n *\n * ```html\n * <qd-notification [notification]=\"notification\"></qd-notification>\n * ```\n *\n * ```typescript\n * notification: QdNotification = {\n *   type: 'critical',\n *   i18n: 'i18n.error.critical'\n * }\n * ```\n *\n * ## Multiline Notifications\n *\n * To create a multiline notification you simply can insert `\\n` in the i18n translation text. Line breaks (`\\n`) are\n * not considered if you use the `<qd-notification-content>` variant. Line breaks only work if you define the\n * i18n key in the notification config.\n *\n * ### Example\n *\n * ```typescript\n * notification: QdNotification = {\n *   type: 'warning',\n *   i18n: 'i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired'\n * }\n * ```\n *\n * ```json\n * {\n *   ...\n *\n *   \"i18n.ncts.declaration.detailInventoryResult.notification.transitDeadlineExpired\": \"The inventory result must be checked and the control result recorded. \\nAttention: The transit period has expired upon arrival at the Authorized Place\",\n * }\n * ```\n *\n * ### Notifications Service\n *\n * | Method                       | Params                                                 | description                                      | default |\n * | ---------------------------- | ------------------------------------------------------ | ------------------------------------------------ | ------- |\n * | getNotificationsForContext() | context: string                                        | Returns notification stream for context.         | -       |\n * | add()                        | context: string, notification: QdNotification          | Adds a single notification.                      | -       |\n * | addBulk()                    | context: string, notifications: QdNotifications        | Adds multiple notifications.                     | -       |\n * | remove()                     | context: string, id: string                            | Removes specific notification.                   | -       |\n * | removeAll()                  | context: string                                        | Removes all notifications in context.            | -       |\n * | reset()                      | -                                                      | Clear all notifications.                         | -       |\n */\n@Component({\n  selector: 'qd-notification',\n  templateUrl: './notification.component.html',\n  styleUrls: ['./notification.component.scss'],\n  host: { class: 'qd-notification' }\n})\nexport class QdNotificationComponent {\n  /**\n   * Defines the type of this notification.\n   */\n  @Input() type: QdNotificationType = 'critical';\n\n  /**\n   * Configuration of a notification.\n   */\n  @Input() notification: QdNotification;\n\n  @HostBinding('attr.class') get typeClassName(): string {\n    return `qd-notification qd-notification-${this.getType()}`;\n  }\n\n  get closeable(): boolean {\n    return this.notification ? !this.notification.disableClose : true;\n  }\n\n  constructor(\n    private readonly notificationService: QdNotificationsService,\n    private readonly snackbarService: QdSnackbarService,\n    private element: ElementRef\n  ) {}\n\n  getType(): QdNotificationType {\n    return this.notification?.type || this.type;\n  }\n\n  getIcon(): string {\n    switch (this.getType()) {\n      case 'success':\n        return 'checkCircleSolid';\n      case 'info':\n        return 'checkCircleSolid';\n      case 'warning':\n        return 'warningHexFilled';\n      case 'critical':\n        return 'exclamationCircleSolid';\n    }\n  }\n\n  remove(): void {\n    if (this.isNotificationInSnackbar()) {\n      this.snackbarService.close(this.notification.uuid);\n    } else {\n      this.notificationService.remove(this.notification.context, this.notification.uuid);\n    }\n  }\n\n  handleLinkClick(): void {\n    this.notification.link.handler();\n  }\n\n  private isNotificationInSnackbar(): boolean {\n    return !!this.element.nativeElement.closest('qd-snackbar');\n  }\n}\n","<qd-icon *ngIf=\"closeable\" [icon]=\"'timesLarge'\" class=\"closer\" (click)=\"remove()\"></qd-icon>\n<qd-icon [icon]=\"this.getIcon()\" class=\"icon\"></qd-icon>\n\n<ng-content select=\"qd-notification-content\"></ng-content>\n\n<div class=\"title\" *ngIf=\"notification?.title\">{{ notification.title.i18n | translate }}</div>\n<div class=\"message\">\n  <span>{{ notification?.i18n | translate }}</span>\n  <a class=\"link\" *ngIf=\"notification?.link\" (click)=\"handleLinkClick()\">{{ notification.link.i18n | translate }}</a>\n</div>\n"]}

package/esm2022/lib/notifications/notification-content/notification-content.component.mjs

@@ -0,0 +1,14 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * **QdNotificationContent**: a container for the content of a single **QdNotification** item.
+ */
+export class QdNotificationContentComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdNotificationContentComponent, selector: "qd-notification-content", ngImport: i0, template: "<ng-content></ng-content>\n" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-notification-content', template: "<ng-content></ng-content>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLWNvbnRlbnQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xZC11aS9zcmMvbGliL25vdGlmaWNhdGlvbnMvbm90aWZpY2F0aW9uLWNvbnRlbnQvbm90aWZpY2F0aW9uLWNvbnRlbnQuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xZC11aS9zcmMvbGliL25vdGlmaWNhdGlvbnMvbm90aWZpY2F0aW9uLWNvbnRlbnQvbm90aWZpY2F0aW9uLWNvbnRlbnQuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFMUM7O0dBRUc7QUFLSCxNQUFNLE9BQU8sOEJBQThCO3VHQUE5Qiw4QkFBOEI7MkZBQTlCLDhCQUE4QiwrRENUM0MsNkJBQ0E7OzJGRFFhLDhCQUE4QjtrQkFKMUMsU0FBUzsrQkFDRSx5QkFBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiAqKlFkTm90aWZpY2F0aW9uQ29udGVudCoqOiBhIGNvbnRhaW5lciBmb3IgdGhlIGNvbnRlbnQgb2YgYSBzaW5nbGUgKipRZE5vdGlmaWNhdGlvbioqIGl0ZW0uXG4gKi9cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3FkLW5vdGlmaWNhdGlvbi1jb250ZW50JyxcbiAgdGVtcGxhdGVVcmw6ICcuL25vdGlmaWNhdGlvbi1jb250ZW50LmNvbXBvbmVudC5odG1sJ1xufSlcbmV4cG9ydCBjbGFzcyBRZE5vdGlmaWNhdGlvbkNvbnRlbnRDb21wb25lbnQge31cbiIsIjxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiJdfQ==

package/esm2022/lib/notifications/notifications/notifications.component.mjs

@@ -0,0 +1,35 @@
+// @ts-strict-ignore
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { QdNotificationsService } from '../services/notifications-service.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/notifications-service.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../notification/notification.component";
+/**
+ * **QdNotifications** creates a container for the single **QdNotification** items.
+ */
+export class QdNotificationsComponent {
+    notificationService;
+    notifications;
+    /**
+     * The context can be assigned to control the positioning of the notifications.
+     */
+    context = 'qdPanel';
+    constructor(notificationService) {
+        this.notificationService = notificationService;
+    }
+    ngOnInit() {
+        this.notificationService
+            .getNotificationsForContext(this.context)
+            .subscribe(notifications => (this.notifications = notifications));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsComponent, deps: [{ token: i1.QdNotificationsService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdNotificationsComponent, selector: "qd-notifications", inputs: { context: "context" }, ngImport: i0, template: "<qd-notification *ngFor=\"let notification of notifications\" [notification]=\"notification\"></qd-notification>\n", styles: [".panel-type-control qd-notifications{display:block;width:100%;padding:1rem 1.5rem}.panel-type-info qd-notifications .qd-notification{background:#fff}qd-notifications qd-notification+qd-notification{margin-top:1rem}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i3.QdNotificationComponent, selector: "qd-notification", inputs: ["type", "notification"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdNotificationsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-notifications', encapsulation: ViewEncapsulation.None, template: "<qd-notification *ngFor=\"let notification of notifications\" [notification]=\"notification\"></qd-notification>\n", styles: [".panel-type-control qd-notifications{display:block;width:100%;padding:1rem 1.5rem}.panel-type-info qd-notifications .qd-notification{background:#fff}qd-notifications qd-notification+qd-notification{margin-top:1rem}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdNotificationsService }], propDecorators: { context: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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