nuxeo-development-framework 3.8.2 → 3.8.3

package/esm2015/lib/components/notifications/components/notifications-settings/notifications-settings.component.js

@@ -0,0 +1,163 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Output, } from '@angular/core';
+import { BehaviorSubject, combineLatest, ReplaySubject } from 'rxjs';
+import { finalize, map, switchMap, takeUntil, tap } from 'rxjs/operators';
+import { BaseNotification } from '../base-notifications.component';
+import { mapDefinitionToPresenter, mapSubscriptionToPresenter, } from './notifications-settings.adapter';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../Core/services/translation/translation.service";
+import * as i2 from "../../../custom-toastr/services/custom-toastr.service";
+import * as i3 from "@angular/material/progress-spinner";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/slide-toggle";
+import * as i6 from "@angular/common";
+import * as i7 from "@ngx-translate/core";
+import * as i8 from "./check-if-subscribed.pipe";
+export class NotificationsSettingsComponent extends BaseNotification {
+    constructor(inject, _translateService, _cdr, _toastrService, _environment) {
+        super(inject);
+        this.inject = inject;
+        this._translateService = _translateService;
+        this._cdr = _cdr;
+        this._toastrService = _toastrService;
+        this._environment = _environment;
+        this.onSubscribe = new EventEmitter();
+        this.onUnsubscribe = new EventEmitter();
+        this._channelSub = new ReplaySubject();
+        this.isLoadingResult = false;
+        this._subscriptionsSub = new BehaviorSubject([]);
+        this.settings$ = this._prepareSettings();
+    }
+    set channel(value) {
+        this._channel = value;
+        if (value) {
+            this._channelSub.next(value);
+        }
+    }
+    get currentLang() {
+        return this._translateService.userLang;
+    }
+    get _appKey() {
+        var _a;
+        return (_a = this._environment) === null || _a === void 0 ? void 0 : _a.appKey;
+    }
+    getSubscriptionsByChannel(channel) {
+        return this.notificationsService
+            .getSubscriptions({
+            notfsubscription_channel: channel,
+        })
+            .pipe(map((data) => data.map(mapSubscriptionToPresenter)));
+    }
+    getDefinitionsByChannel(channel) {
+        return this.notificationsService
+            .getDefinitions({
+            notfnotificationdef_channel: channel,
+        })
+            .pipe(map((response) => {
+            return response.reduce((group, item) => {
+                if (!this._matchItem(item, channel)) {
+                    return group;
+                }
+                const _data = mapDefinitionToPresenter(item);
+                return this._groupBy(group, _data);
+            }, {});
+        }));
+    }
+    settingChanged(definition, state) {
+        if (state.checked) {
+            this._handleSubscribe(definition);
+        }
+        else {
+            this._handleUnsubscribe(definition);
+        }
+    }
+    _prepareSettings() {
+        return this._channelSub.pipe(tap(() => {
+            this.isLoadingResult = true;
+        }), switchMap((channel) => {
+            const definition = this.getDefinitionsByChannel(channel.id);
+            const subscriptions = this.getSubscriptionsByChannel(channel.id).pipe(switchMap((data) => {
+                this._subscriptionsSub.next(data);
+                return this._subscriptionsSub.asObservable();
+            }));
+            return combineLatest([definition, subscriptions]).pipe(map(([definitions, subscriptions]) => ({ definitions, subscriptions })), tap(() => {
+                this.isLoadingResult = false;
+                this._cdr.detectChanges();
+            }));
+        }));
+    }
+    _handleSubscribe(definition) {
+        this.changingItemId = definition.uid;
+        this.notificationsService
+            .subscribe(definition.uid)
+            .pipe(switchMap(() => this.getSubscriptionsByChannel(this._channel.id).pipe(finalize(() => {
+            this.changingItemId = null;
+            this._cdr.detectChanges();
+        }))), takeUntil(this.destroy$))
+            .subscribe((res) => {
+            this.onSubscribe.emit(definition);
+            this._subscriptionsSub.next(res);
+            this._toastrService.show('success', 'notifications.notifications', 'notifications.subscribedDone');
+        });
+    }
+    _handleUnsubscribe(definition) {
+        const subscriptions = this._subscriptionsSub.getValue();
+        const _subscription = this._findSubscription(subscriptions, definition);
+        if (!_subscription) {
+            return;
+        }
+        this.changingItemId = definition.uid;
+        this.notificationsService
+            .unsubscribe(_subscription.uid)
+            .pipe(switchMap(() => this.getSubscriptionsByChannel(this._channel.id).pipe(finalize(() => {
+            this.changingItemId = null;
+            this._cdr.detectChanges();
+        }))), finalize(() => {
+            this.changingItemId = null;
+            this._cdr.detectChanges();
+        }), takeUntil(this.destroy$))
+            .subscribe((res) => {
+            this._subscriptionsSub.next(res);
+            this.onUnsubscribe.emit(_subscription);
+            this._toastrService.show('success', 'notifications.notifications', 'notifications.unsubscribedDone');
+        });
+    }
+    _findSubscription(subscriptions, definition) {
+        return subscriptions.find((sub) => {
+            return (sub.channel == definition.channel &&
+                sub.applicationKey == definition.applicationKey &&
+                sub.notificationKey == definition.notificationKey);
+        });
+    }
+    _matchItem(def, channel) {
+        return (def.properties['notif_def:applicationKey'] == this._appKey &&
+            def.properties['notif_def:channel'] == channel);
+    }
+    _groupBy(group, item) {
+        var _a;
+        const key = item['sourceType'];
+        group[key] = (_a = group[key]) !== null && _a !== void 0 ? _a : [];
+        group[key].push(item);
+        return group;
+    }
+}
+NotificationsSettingsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsSettingsComponent, deps: [{ token: i0.Injector }, { token: i1.TranslationService }, { token: i0.ChangeDetectorRef }, { token: i2.CustomToastrService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Component });
+NotificationsSettingsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: NotificationsSettingsComponent, selector: "app-notifications-settings", inputs: { channel: "channel" }, outputs: { onSubscribe: "onSubscribe", onUnsubscribe: "onUnsubscribe" }, usesInheritance: true, ngImport: i0, template: "<mat-spinner *ngIf=\"isLoadingResult\" class=\"mt-4 mx-auto\" [diameter]=\"48\"></mat-spinner>\r\n<div *ngIf=\"settings$ | async as settings\" class=\"notifications-settings\">\r\n  <ng-container *ngIf=\"!isLoadingResult && settings.definitions\">\r\n    <div\r\n      *ngFor=\"let group of settings.definitions | keyvalue\"\r\n      class=\"notifications-settings__section notifications-settings__section--{{\r\n        group.key\r\n      }}\"\r\n    >\r\n      <div class=\"notifications-settings__section__title\">\r\n        <mat-icon> tune </mat-icon>\r\n        <strong> {{ 'vocabulary.VOC_Notf_SourceTypes.' + group.key | translate }}</strong>\r\n      </div>\r\n      <div class=\"notifications-settings__section__content\">\r\n        <div *ngFor=\"let definition of group.value\" class=\"notifications-settings__group\">\r\n          <mat-slide-toggle\r\n            [name]=\"definition.title\"\r\n            [checked]=\"\r\n              definition.autoSubscription\r\n                ? true\r\n                : (definition | checkIfSubscribed : settings.subscriptions)\r\n            \"\r\n            class=\"notifications-settings__group__toggle\"\r\n            [class.is-loading]=\"changingItemId === definition.uid\"\r\n            [disabled]=\"definition.autoSubscription\"\r\n            (change)=\"settingChanged(definition, $event)\"\r\n          >\r\n          </mat-slide-toggle>\r\n          <span class=\"notifications-settings__group__title\"\r\n            >{{ currentLang == 'ar' ? definition?.arTitle : definition?.enTitle }}\r\n          </span>\r\n\r\n          <p class=\"notifications-settings__group__description\">\r\n            {{\r\n              currentLang == 'ar' ? definition?.arDescription : definition?.enDescription\r\n            }}\r\n          </p>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-container>\r\n</div>\r\n", styles: [".notifications-settings{padding:var(--notifications-settings-padding, 1rem 0)}.notifications-settings__section{border:var(--setting-section-border, 1px solid #f0f0f0);border-radius:var(--setting-section-radius, 6px);padding:var(--settings-section-padding, 1rem);margin-block:var(--settings-section-margin-block, 0 1.5rem);margin-inline:var(--settings-section-margin-inline, 0)}.notifications-settings__section__title{display:var(--setting-section-title-display, flex);align-items:var(--setting-section-title-items, center);grid-gap:var(--setting-section-title-gap, .5rem);gap:var(--setting-section-title-gap, .5rem);padding-block:var(--setting-section-title-padding-block, .5rem);border-bottom:var(--setting-section-title-border-bottom, 1px solid #f0f0f0);background:var(--setting-section-title-background, transparent);color:var(--setting-section-title-color, #2f258a)}.notifications-settings__section__content{padding-block:var(--setting-section-content-padding-block, 1rem 0);display:var(--setting-section-content-display, grid);grid-template-columns:var(--setting-section-content-columns, repeat(auto-fit, minmax(490px, 1fr)));grid-gap:var(--setting-section-content-gap, 1rem);gap:var(--setting-section-content-gap, 1rem)}.notifications-settings__group{display:var(--setting-group-display, grid);grid-template-columns:var(--setting-group-columns, auto 1fr);background:var(--setting-group-background, transparent);padding:var(--setting-group-padding, .2rem 0);grid-gap:var(--setting-group-gap, .1rem 1rem);gap:var(--setting-group-gap, .1rem 1rem)}.notifications-settings__group__toggle{order:var(--setting-toggle-order)}.notifications-settings__group__toggle.is-loading{--loading-color: var(--setting-toggle-loader-color, #9189dd36);opacity:.5}.notifications-settings__group__toggle.is-loading ::ng-deep{pointer-events:none}.notifications-settings__group__toggle.is-loading ::ng-deep .mat-slide-toggle-thumb{animation:animateLoader 1.5s linear infinite}.notifications-settings__group__toggle.is-loading ::ng-deep label{margin-bottom:0}.notifications-settings__group__description{color:var(--setting-option-description-color, #666);font-size:var(--setting-option-description-size, .8rem);grid-column:var(--setting-option-description-column, 2)}@keyframes animateLoader{0%{box-shadow:0 0 0 2px var(--loading-color),0 0 0 4px var(--loading-color),0 0 0 6px var(--loading-color),0 0 0 8px var(--loading-color)}50%{box-shadow:0 0 0 1px var(--loading-color),0 0 0 3px var(--loading-color),0 0 0 4px var(--loading-color),0 0 0 5px var(--loading-color),0 0 0 6px var(--loading-color)}to{box-shadow:0 0 0 2px var(--loading-color),0 0 0 4px var(--loading-color),0 0 0 6px var(--loading-color),0 0 0 8px var(--loading-color)}}\n"], components: [{ type: i3.MatSpinner, selector: "mat-spinner", inputs: ["color"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i5.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["disabled", "disableRipple", "color", "tabIndex", "name", "id", "labelPosition", "aria-label", "aria-labelledby", "required", "checked"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "async": i6.AsyncPipe, "keyvalue": i6.KeyValuePipe, "translate": i7.TranslatePipe, "checkIfSubscribed": i8.CheckIfSubscribedPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsSettingsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-notifications-settings',
+                    templateUrl: './notifications-settings.component.html',
+                    styleUrls: ['./notifications-settings.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.TranslationService }, { type: i0.ChangeDetectorRef }, { type: i2.CustomToastrService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; }, propDecorators: { onSubscribe: [{
+                type: Output
+            }], onUnsubscribe: [{
+                type: Output
+            }], channel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifications-settings.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/notifications/components/notifications-settings/notifications-settings.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/notifications/components/notifications-settings/notifications-settings.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  Inject,\r\n  Injector,\r\n  Input,\r\n  Output,\r\n} from '@angular/core';\r\nimport { MatSlideToggleChange } from '@angular/material/slide-toggle';\r\nimport { BehaviorSubject, combineLatest, ReplaySubject } from 'rxjs';\r\nimport { finalize, map, switchMap, takeUntil, tap } from 'rxjs/operators';\r\nimport { TranslationService } from '../../../../Core/services/translation/translation.service';\r\nimport { CustomToastrService } from '../../../custom-toastr/services/custom-toastr.service';\r\nimport {\r\n  NotificationDefinitionModel,\r\n  NotificationDefinitionPresenter,\r\n  NotificationSubscriptionPresenter,\r\n  VocabularyType,\r\n} from '../../models';\r\nimport { BaseNotification } from '../base-notifications.component';\r\nimport {\r\n  mapDefinitionToPresenter,\r\n  mapSubscriptionToPresenter,\r\n} from './notifications-settings.adapter';\r\n\r\n@Component({\r\n  selector: 'app-notifications-settings',\r\n  templateUrl: './notifications-settings.component.html',\r\n  styleUrls: ['./notifications-settings.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class NotificationsSettingsComponent extends BaseNotification {\r\n  @Output() onSubscribe = new EventEmitter<NotificationDefinitionPresenter>();\r\n  @Output() onUnsubscribe = new EventEmitter<Record<string, any>>();\r\n\r\n  private readonly _channelSub = new ReplaySubject<VocabularyType>();\r\n\r\n  changingItemId: string;\r\n  isLoadingResult = false;\r\n  private _channel: VocabularyType;\r\n  @Input() set channel(value: VocabularyType) {\r\n    this._channel = value;\r\n    if (value) {\r\n      this._channelSub.next(value);\r\n    }\r\n  }\r\n\r\n  get currentLang() {\r\n    return this._translateService.userLang;\r\n  }\r\n  private get _appKey() {\r\n    return this._environment?.appKey;\r\n  }\r\n\r\n  private readonly _subscriptionsSub = new BehaviorSubject<\r\n    NotificationSubscriptionPresenter[]\r\n  >([]);\r\n\r\n  readonly settings$ = this._prepareSettings();\r\n\r\n  constructor(\r\n    protected inject: Injector,\r\n    private _translateService: TranslationService,\r\n    private _cdr: ChangeDetectorRef,\r\n    private _toastrService: CustomToastrService,\r\n    @Inject('environment') private _environment: Record<string, any>\r\n  ) {\r\n    super(inject);\r\n  }\r\n\r\n  getSubscriptionsByChannel(channel: string) {\r\n    return this.notificationsService\r\n      .getSubscriptions({\r\n        notfsubscription_channel: channel,\r\n      })\r\n      .pipe(map((data) => data.map(mapSubscriptionToPresenter)));\r\n  }\r\n\r\n  getDefinitionsByChannel(channel: string) {\r\n    return this.notificationsService\r\n      .getDefinitions({\r\n        notfnotificationdef_channel: channel,\r\n      })\r\n      .pipe(\r\n        map((response) => {\r\n          return response.reduce((group, item) => {\r\n            if (!this._matchItem(item, channel)) {\r\n              return group;\r\n            }\r\n            const _data = mapDefinitionToPresenter(item);\r\n            return this._groupBy(group, _data);\r\n          }, {} as Record<string, NotificationDefinitionPresenter[]>);\r\n        })\r\n      );\r\n  }\r\n\r\n  settingChanged(\r\n    definition: NotificationDefinitionPresenter,\r\n    state: MatSlideToggleChange\r\n  ) {\r\n    if (state.checked) {\r\n      this._handleSubscribe(definition);\r\n    } else {\r\n      this._handleUnsubscribe(definition);\r\n    }\r\n  }\r\n\r\n  private _prepareSettings() {\r\n    return this._channelSub.pipe(\r\n      tap(() => {\r\n        this.isLoadingResult = true;\r\n      }),\r\n      switchMap((channel) => {\r\n        const definition = this.getDefinitionsByChannel(channel.id);\r\n        const subscriptions = this.getSubscriptionsByChannel(channel.id).pipe(\r\n          switchMap((data) => {\r\n            this._subscriptionsSub.next(data);\r\n            return this._subscriptionsSub.asObservable();\r\n          })\r\n        );\r\n        return combineLatest([definition, subscriptions]).pipe(\r\n          map(([definitions, subscriptions]) => ({ definitions, subscriptions })),\r\n          tap(() => {\r\n            this.isLoadingResult = false;\r\n            this._cdr.detectChanges();\r\n          })\r\n        );\r\n      })\r\n    );\r\n  }\r\n\r\n  private _handleSubscribe(definition: NotificationDefinitionPresenter) {\r\n    this.changingItemId = definition.uid;\r\n    this.notificationsService\r\n      .subscribe(definition.uid)\r\n      .pipe(\r\n        switchMap(() =>\r\n          this.getSubscriptionsByChannel(this._channel.id).pipe(\r\n            finalize(() => {\r\n              this.changingItemId = null;\r\n              this._cdr.detectChanges();\r\n            })\r\n          )\r\n        ),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe((res) => {\r\n        this.onSubscribe.emit(definition);\r\n        this._subscriptionsSub.next(res);\r\n        this._toastrService.show(\r\n          'success',\r\n          'notifications.notifications',\r\n          'notifications.subscribedDone'\r\n        );\r\n      });\r\n  }\r\n\r\n  private _handleUnsubscribe(definition: NotificationDefinitionPresenter) {\r\n    const subscriptions = this._subscriptionsSub.getValue();\r\n    const _subscription = this._findSubscription(subscriptions, definition);\r\n    if (!_subscription) {\r\n      return;\r\n    }\r\n\r\n    this.changingItemId = definition.uid;\r\n    this.notificationsService\r\n      .unsubscribe(_subscription.uid)\r\n      .pipe(\r\n        switchMap(() =>\r\n          this.getSubscriptionsByChannel(this._channel.id).pipe(\r\n            finalize(() => {\r\n              this.changingItemId = null;\r\n              this._cdr.detectChanges();\r\n            })\r\n          )\r\n        ),\r\n        finalize(() => {\r\n          this.changingItemId = null;\r\n          this._cdr.detectChanges();\r\n        }),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe((res) => {\r\n        this._subscriptionsSub.next(res);\r\n        this.onUnsubscribe.emit(_subscription);\r\n        this._toastrService.show(\r\n          'success',\r\n          'notifications.notifications',\r\n          'notifications.unsubscribedDone'\r\n        );\r\n      });\r\n  }\r\n\r\n  private _findSubscription(\r\n    subscriptions: NotificationSubscriptionPresenter[],\r\n    definition: NotificationDefinitionPresenter\r\n  ) {\r\n    return subscriptions.find((sub) => {\r\n      return (\r\n        sub.channel == definition.channel &&\r\n        sub.applicationKey == definition.applicationKey &&\r\n        sub.notificationKey == definition.notificationKey\r\n      );\r\n    });\r\n  }\r\n\r\n  private _matchItem(def: NotificationDefinitionModel, channel: string) {\r\n    return (\r\n      def.properties['notif_def:applicationKey'] == this._appKey &&\r\n      def.properties['notif_def:channel'] == channel\r\n    );\r\n  }\r\n\r\n  private _groupBy(group: Record<string, any>, item: NotificationDefinitionPresenter) {\r\n    const key = item['sourceType'];\r\n    group[key] = group[key] ?? [];\r\n    group[key].push(item);\r\n    return group;\r\n  }\r\n}\r\n","<mat-spinner *ngIf=\"isLoadingResult\" class=\"mt-4 mx-auto\" [diameter]=\"48\"></mat-spinner>\r\n<div *ngIf=\"settings$ | async as settings\" class=\"notifications-settings\">\r\n  <ng-container *ngIf=\"!isLoadingResult && settings.definitions\">\r\n    <div\r\n      *ngFor=\"let group of settings.definitions | keyvalue\"\r\n      class=\"notifications-settings__section notifications-settings__section--{{\r\n        group.key\r\n      }}\"\r\n    >\r\n      <div class=\"notifications-settings__section__title\">\r\n        <mat-icon> tune </mat-icon>\r\n        <strong> {{ 'vocabulary.VOC_Notf_SourceTypes.' + group.key | translate }}</strong>\r\n      </div>\r\n      <div class=\"notifications-settings__section__content\">\r\n        <div *ngFor=\"let definition of group.value\" class=\"notifications-settings__group\">\r\n          <mat-slide-toggle\r\n            [name]=\"definition.title\"\r\n            [checked]=\"\r\n              definition.autoSubscription\r\n                ? true\r\n                : (definition | checkIfSubscribed : settings.subscriptions)\r\n            \"\r\n            class=\"notifications-settings__group__toggle\"\r\n            [class.is-loading]=\"changingItemId === definition.uid\"\r\n            [disabled]=\"definition.autoSubscription\"\r\n            (change)=\"settingChanged(definition, $event)\"\r\n          >\r\n          </mat-slide-toggle>\r\n          <span class=\"notifications-settings__group__title\"\r\n            >{{ currentLang == 'ar' ? definition?.arTitle : definition?.enTitle }}\r\n          </span>\r\n\r\n          <p class=\"notifications-settings__group__description\">\r\n            {{\r\n              currentLang == 'ar' ? definition?.arDescription : definition?.enDescription\r\n            }}\r\n          </p>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-container>\r\n</div>\r\n"]}

package/esm2015/lib/components/notifications/components/notifications-sidebar/notifications-sidebar-content.js

@@ -0,0 +1,28 @@
+import { Directive, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export const NOTIFICATION_SIDEBAR_CONTENT = new InjectionToken('NotificationItemDirective');
+export class NotificationSidebarContentDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+NotificationSidebarContentDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationSidebarContentDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+NotificationSidebarContentDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: NotificationSidebarContentDirective, selector: "[appNotificationSidebarContent]", providers: [
+        {
+            provide: NOTIFICATION_SIDEBAR_CONTENT,
+            useExisting: NotificationSidebarContentDirective,
+        },
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationSidebarContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appNotificationSidebarContent]',
+                    providers: [
+                        {
+                            provide: NOTIFICATION_SIDEBAR_CONTENT,
+                            useExisting: NotificationSidebarContentDirective,
+                        },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9ucy1zaWRlYmFyLWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25vdGlmaWNhdGlvbnMvY29tcG9uZW50cy9ub3RpZmljYXRpb25zLXNpZGViYXIvbm90aWZpY2F0aW9ucy1zaWRlYmFyLWNvbnRlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQWUsTUFBTSxlQUFlLENBQUM7O0FBRXZFLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUN2QyxJQUFJLGNBQWMsQ0FBc0MsMkJBQTJCLENBQUMsQ0FBQztBQVd2RixNQUFNLE9BQU8sbUNBQW1DO0lBQzlDLFlBQW1CLFFBQTBCO1FBQTFCLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBQUcsQ0FBQzs7aUlBRHRDLG1DQUFtQztxSEFBbkMsbUNBQW1DLDBEQVBuQztRQUNUO1lBQ0UsT0FBTyxFQUFFLDRCQUE0QjtZQUNyQyxXQUFXLEVBQUUsbUNBQW1DO1NBQ2pEO0tBQ0Y7NEZBRVUsbUNBQW1DO2tCQVQvQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxpQ0FBaUM7b0JBQzNDLFNBQVMsRUFBRTt3QkFDVDs0QkFDRSxPQUFPLEVBQUUsNEJBQTRCOzRCQUNyQyxXQUFXLHFDQUFxQzt5QkFDakQ7cUJBQ0Y7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGlvblRva2VuLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuZXhwb3J0IGNvbnN0IE5PVElGSUNBVElPTl9TSURFQkFSX0NPTlRFTlQgPVxyXG4gIG5ldyBJbmplY3Rpb25Ub2tlbjxOb3RpZmljYXRpb25TaWRlYmFyQ29udGVudERpcmVjdGl2ZT4oJ05vdGlmaWNhdGlvbkl0ZW1EaXJlY3RpdmUnKTtcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAnW2FwcE5vdGlmaWNhdGlvblNpZGViYXJDb250ZW50XScsXHJcbiAgcHJvdmlkZXJzOiBbXHJcbiAgICB7XHJcbiAgICAgIHByb3ZpZGU6IE5PVElGSUNBVElPTl9TSURFQkFSX0NPTlRFTlQsXHJcbiAgICAgIHVzZUV4aXN0aW5nOiBOb3RpZmljYXRpb25TaWRlYmFyQ29udGVudERpcmVjdGl2ZSxcclxuICAgIH0sXHJcbiAgXSxcclxufSlcclxuZXhwb3J0IGNsYXNzIE5vdGlmaWNhdGlvblNpZGViYXJDb250ZW50RGlyZWN0aXZlIHtcclxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHt9XHJcbn1cclxuIl19

package/esm2015/lib/components/notifications/components/notifications-sidebar/notifications-sidebar.component.js

@@ -0,0 +1,158 @@
+import { animate, animation, style, transition, trigger, useAnimation, } from '@angular/animations';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, EventEmitter, Inject, Input, Output, TemplateRef, ViewEncapsulation, } from '@angular/core';
+import { NOTIFICATION_SIDEBAR_CONTENT } from './notifications-sidebar-content';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const showAnimation = animation([
+    style({ transform: '{{transform}}', opacity: 0 }),
+    animate('{{transition}}'),
+]);
+const hideAnimation = animation([
+    animate('{{transition}}', style({ transform: '{{transform}}', opacity: 0 })),
+]);
+export class NotificationsSidebarComponent {
+    constructor(document, el, renderer, cd) {
+        this.document = document;
+        this.el = el;
+        this.renderer = renderer;
+        this.cd = cd;
+        this.transformOptions = 'translate3d(-100%, 0px, 0px)';
+        this.transitionOptions = '150ms cubic-bezier(0, 0, 0.2, 1)';
+        this.appendToBody = true;
+        this.clearOnCLose = true;
+        this._position = 'left';
+        this.visibleChange = new EventEmitter();
+        this.onShow = new EventEmitter();
+        this.onHide = new EventEmitter();
+    }
+    set visible(val) {
+        this._visible = val;
+    }
+    get visible() {
+        return this._visible;
+    }
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        this._position = value;
+        switch (value) {
+            case 'left':
+                this.transformOptions = 'translate3d(-100%, 0px, 0px)';
+                break;
+            case 'right':
+                this.transformOptions = 'translate3d(100%, 0px, 0px)';
+                break;
+        }
+    }
+    ngOnInit() { }
+    onAnimationStart({ toState, element }) {
+        if (toState === 'visible') {
+            this._container = element;
+            this.appendContainer();
+            this.show();
+        }
+    }
+    onAnimationEnd({ toState }) {
+        if (toState === 'void') {
+            this.hide(false);
+        }
+    }
+    appendContainer() {
+        if (this.appendToBody) {
+            this.renderer.appendChild(this.document.body, this._container);
+        }
+    }
+    close(event) {
+        event.preventDefault();
+        this.hide();
+        this.visible = false;
+        this.visibleChange.emit(false);
+        if (this.clearOnCLose) {
+            this._container = null;
+        }
+    }
+    show() {
+        this.enableOverLay();
+        this.onShow.emit(null);
+        this.visibleChange.emit(true);
+    }
+    hide(emit = true) {
+        if (emit) {
+            this.onHide.emit(null);
+        }
+        this.disableOverlay();
+    }
+    enableOverLay() {
+        if (!this._mask) {
+            this._mask = this.renderer.createElement('div');
+            this.renderer.setStyle(this._mask, 'zIndex', 'calc(var(--notification-sidebar-z-index, 1050) - 1)');
+            this.renderer.addClass(this._mask, 'notification-sidebar__overlay');
+            this._maskClickListener = this.renderer.listen(this._mask, 'click', (event) => {
+                this.close(event);
+            });
+            this.renderer.appendChild(this.document.body, this._mask);
+        }
+    }
+    disableOverlay() {
+        if (this._mask) {
+            this.renderer.removeChild(this.document.body, this._mask);
+            this._mask = null;
+        }
+        if (this._maskClickListener) {
+            this._maskClickListener();
+            this._maskClickListener = null;
+        }
+    }
+    ngOnDestroy() {
+        if (this.visible) {
+            this.disableOverlay();
+        }
+        this._container = null;
+    }
+}
+NotificationsSidebarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsSidebarComponent, deps: [{ token: DOCUMENT }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+NotificationsSidebarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: NotificationsSidebarComponent, selector: "app-notifications-sidebar", inputs: { appendToBody: "appendToBody", clearOnCLose: "clearOnCLose", visible: "visible", position: "position" }, outputs: { visibleChange: "visibleChange", onShow: "onShow", onHide: "onHide" }, queries: [{ propertyName: "contentTemplate", first: true, predicate: NOTIFICATION_SIDEBAR_CONTENT, descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: "<div\r\n  #container\r\n  *ngIf=\"visible\"\r\n  class=\"notification-sidebar\"\r\n  [class.notification-sidebar__left]=\"position === 'left'\"\r\n  [class.notification-sidebar__right]=\"position === 'right'\"\r\n  [@panelState]=\"{\r\n    value: 'visible',\r\n    params: { transform: transformOptions, transition: transitionOptions }\r\n  }\"\r\n  (@panelState.start)=\"onAnimationStart($event)\"\r\n  (@panelState.done)=\"onAnimationEnd($event)\"\r\n  role=\"complementary\"\r\n  [attr.data-pc-name]=\"'sidebar'\"\r\n  [attr.data-pc-section]=\"'root'\"\r\n>\r\n  <div class=\"notification-sidebar__content\">\r\n    <ng-content></ng-content>\r\n    <ng-container [ngTemplateOutlet]=\"contentTemplate\"></ng-container>\r\n  </div>\r\n</div>\r\n", styles: [".notification-sidebar{position:fixed;transition:transform .3s;display:flex;flex-direction:column;width:var(--n-sidebar-width, min(80vw, 30rem));height:var(--n-sidebar-height, 100%);background:var(--n-sidebar-background, #fff);border-radius:var(--n-sidebar-radius);box-shadow:var(--n-sidebar-shadow, 0 0 25px #8b8b8b);z-index:var(--notification-sidebar-z-index, 1050)}.notification-sidebar__content{position:relative;overflow-y:auto;flex-grow:1}.notification-sidebar__left{top:0;left:0;--n-sidebar-radius: var(--n-sidebar-right-radius, 0 16px 16px 0)}.notification-sidebar__right{top:0;right:0;--n-sidebar-radius: var(--n-sidebar-left-radius, 16px 0 0 16px)}.notification-sidebar__overlay{position:fixed;transition:transform .3s;top:0;left:0;width:100%;height:100%;background:var(--n-sidebar-overlay-background, rgba(0, 0, 0, .05))}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], animations: [
+        trigger('panelState', [
+            transition('void => visible', [useAnimation(showAnimation)]),
+            transition('visible => void', [useAnimation(hideAnimation)]),
+        ]),
+    ], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsSidebarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-notifications-sidebar',
+                    templateUrl: './notifications-sidebar.component.html',
+                    styleUrls: ['./notifications-sidebar.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    animations: [
+                        trigger('panelState', [
+                            transition('void => visible', [useAnimation(showAnimation)]),
+                            transition('visible => void', [useAnimation(hideAnimation)]),
+                        ]),
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { appendToBody: [{
+                type: Input
+            }], clearOnCLose: [{
+                type: Input
+            }], visible: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], contentTemplate: [{
+                type: ContentChild,
+                args: [NOTIFICATION_SIDEBAR_CONTENT, { read: TemplateRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifications-sidebar.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/notifications/components/notifications-sidebar/notifications-sidebar.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/notifications/components/notifications-sidebar/notifications-sidebar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  animate,\r\n  animation,\r\n  style,\r\n  transition,\r\n  trigger,\r\n  useAnimation,\r\n} from '@angular/animations';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ContentChild,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Inject,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  Renderer2,\r\n  TemplateRef,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { NOTIFICATION_SIDEBAR_CONTENT } from './notifications-sidebar-content';\r\n\r\nconst showAnimation = animation([\r\n  style({ transform: '{{transform}}', opacity: 0 }),\r\n  animate('{{transition}}'),\r\n]);\r\n\r\nconst hideAnimation = animation([\r\n  animate('{{transition}}', style({ transform: '{{transform}}', opacity: 0 })),\r\n]);\r\n\r\n@Component({\r\n  selector: 'app-notifications-sidebar',\r\n  templateUrl: './notifications-sidebar.component.html',\r\n  styleUrls: ['./notifications-sidebar.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n  animations: [\r\n    trigger('panelState', [\r\n      transition('void => visible', [useAnimation(showAnimation)]),\r\n      transition('visible => void', [useAnimation(hideAnimation)]),\r\n    ]),\r\n  ],\r\n})\r\nexport class NotificationsSidebarComponent implements OnInit, OnDestroy {\r\n  transformOptions: any = 'translate3d(-100%, 0px, 0px)';\r\n  transitionOptions: string = '150ms cubic-bezier(0, 0, 0.2, 1)';\r\n  private _mask: HTMLDivElement | null | undefined;\r\n  private _container: HTMLDivElement | null | undefined;\r\n  private _maskClickListener: VoidFunction | null | undefined;\r\n\r\n  @Input() appendToBody = true;\r\n  @Input() clearOnCLose = true;\r\n\r\n  private _visible: boolean | undefined;\r\n  @Input() set visible(val: boolean) {\r\n    this._visible = val;\r\n  }\r\n\r\n  get visible(): boolean {\r\n    return this._visible as boolean;\r\n  }\r\n\r\n  private _position: string = 'left';\r\n  get position(): string {\r\n    return this._position;\r\n  }\r\n\r\n  @Input() set position(value: string) {\r\n    this._position = value;\r\n    switch (value) {\r\n      case 'left':\r\n        this.transformOptions = 'translate3d(-100%, 0px, 0px)';\r\n        break;\r\n      case 'right':\r\n        this.transformOptions = 'translate3d(100%, 0px, 0px)';\r\n        break;\r\n    }\r\n  }\r\n\r\n  @Output() visibleChange: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n  @Output() onShow: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() onHide: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n  @ContentChild(NOTIFICATION_SIDEBAR_CONTENT, { read: TemplateRef, static: true })\r\n  contentTemplate: TemplateRef<any> | undefined;\r\n\r\n  constructor(\r\n    @Inject(DOCUMENT) private document: Document,\r\n    public el: ElementRef,\r\n    public renderer: Renderer2,\r\n    public cd: ChangeDetectorRef\r\n  ) {}\r\n\r\n  ngOnInit(): void {}\r\n\r\n  onAnimationStart({ toState, element }) {\r\n    if (toState === 'visible') {\r\n      this._container = element;\r\n      this.appendContainer();\r\n      this.show();\r\n    }\r\n  }\r\n\r\n  onAnimationEnd({ toState }) {\r\n    if (toState === 'void') {\r\n      this.hide(false);\r\n    }\r\n  }\r\n\r\n  appendContainer() {\r\n    if (this.appendToBody) {\r\n      this.renderer.appendChild(this.document.body, this._container);\r\n    }\r\n  }\r\n\r\n  close(event: Event) {\r\n    event.preventDefault();\r\n    this.hide();\r\n    this.visible = false;\r\n    this.visibleChange.emit(false);\r\n    if (this.clearOnCLose) {\r\n      this._container = null;\r\n    }\r\n  }\r\n\r\n  show() {\r\n    this.enableOverLay();\r\n    this.onShow.emit(null);\r\n    this.visibleChange.emit(true);\r\n  }\r\n\r\n  hide(emit: boolean = true) {\r\n    if (emit) {\r\n      this.onHide.emit(null);\r\n    }\r\n\r\n    this.disableOverlay();\r\n  }\r\n\r\n  enableOverLay() {\r\n    if (!this._mask) {\r\n      this._mask = this.renderer.createElement('div');\r\n      this.renderer.setStyle(\r\n        this._mask,\r\n        'zIndex',\r\n        'calc(var(--notification-sidebar-z-index, 1050) - 1)'\r\n      );\r\n      this.renderer.addClass(this._mask, 'notification-sidebar__overlay');\r\n      this._maskClickListener = this.renderer.listen(this._mask, 'click', (event: any) => {\r\n        this.close(event);\r\n      });\r\n      this.renderer.appendChild(this.document.body, this._mask);\r\n    }\r\n  }\r\n\r\n  disableOverlay() {\r\n    if (this._mask) {\r\n      this.renderer.removeChild(this.document.body, this._mask);\r\n      this._mask = null;\r\n    }\r\n    if (this._maskClickListener) {\r\n      this._maskClickListener();\r\n      this._maskClickListener = null;\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    if (this.visible) {\r\n      this.disableOverlay();\r\n    }\r\n    this._container = null;\r\n  }\r\n}\r\n","<div\r\n  #container\r\n  *ngIf=\"visible\"\r\n  class=\"notification-sidebar\"\r\n  [class.notification-sidebar__left]=\"position === 'left'\"\r\n  [class.notification-sidebar__right]=\"position === 'right'\"\r\n  [@panelState]=\"{\r\n    value: 'visible',\r\n    params: { transform: transformOptions, transition: transitionOptions }\r\n  }\"\r\n  (@panelState.start)=\"onAnimationStart($event)\"\r\n  (@panelState.done)=\"onAnimationEnd($event)\"\r\n  role=\"complementary\"\r\n  [attr.data-pc-name]=\"'sidebar'\"\r\n  [attr.data-pc-section]=\"'root'\"\r\n>\r\n  <div class=\"notification-sidebar__content\">\r\n    <ng-content></ng-content>\r\n    <ng-container [ngTemplateOutlet]=\"contentTemplate\"></ng-container>\r\n  </div>\r\n</div>\r\n"]}

package/esm2015/lib/components/notifications/constants/date.js

@@ -0,0 +1,8 @@
+export const FILTER_DATES_TYPE = {
+    lastDay: 'from_now-24H_to_now',
+    lastWeek: 'from_now-7d_to_now',
+    lastMonth: 'from_now-1M_to_now',
+    lastHalfYear: 'from_now-6M_to_now',
+    lastYear: 'from_now-1y_to_now',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvbm90aWZpY2F0aW9ucy9jb25zdGFudHMvZGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRztJQUMvQixPQUFPLEVBQUUscUJBQXFCO0lBQzlCLFFBQVEsRUFBRSxvQkFBb0I7SUFDOUIsU0FBUyxFQUFFLG9CQUFvQjtJQUMvQixZQUFZLEVBQUUsb0JBQW9CO0lBQ2xDLFFBQVEsRUFBRSxvQkFBb0I7Q0FDdEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBGSUxURVJfREFURVNfVFlQRSA9IHtcclxuICBsYXN0RGF5OiAnZnJvbV9ub3ctMjRIX3RvX25vdycsXHJcbiAgbGFzdFdlZWs6ICdmcm9tX25vdy03ZF90b19ub3cnLFxyXG4gIGxhc3RNb250aDogJ2Zyb21fbm93LTFNX3RvX25vdycsXHJcbiAgbGFzdEhhbGZZZWFyOiAnZnJvbV9ub3ctNk1fdG9fbm93JyxcclxuICBsYXN0WWVhcjogJ2Zyb21fbm93LTF5X3RvX25vdycsXHJcbn0gYXMgY29uc3Q7XHJcbiJdfQ==

package/esm2015/lib/components/notifications/constants/index.js

@@ -0,0 +1,5 @@
+export * from './date';
+export * from './pagination';
+export * from './panel';
+export * from './status';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25vdGlmaWNhdGlvbnMvY29uc3RhbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRlJztcclxuZXhwb3J0ICogZnJvbSAnLi9wYWdpbmF0aW9uJztcclxuZXhwb3J0ICogZnJvbSAnLi9wYW5lbCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3RhdHVzJztcclxuIl19

package/esm2015/lib/components/notifications/constants/pagination.js

@@ -0,0 +1,5 @@
+export const PAGINATION_MODE = {
+    scroll: 'scroll',
+    navigator: 'navigator',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvbm90aWZpY2F0aW9ucy9jb25zdGFudHMvcGFnaW5hdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUc7SUFDN0IsTUFBTSxFQUFFLFFBQVE7SUFDaEIsU0FBUyxFQUFFLFdBQVc7Q0FDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFBBR0lOQVRJT05fTU9ERSA9IHtcclxuICBzY3JvbGw6ICdzY3JvbGwnLFxyXG4gIG5hdmlnYXRvcjogJ25hdmlnYXRvcicsXHJcbn0gYXMgY29uc3Q7XHJcbiJdfQ==

package/esm2015/lib/components/notifications/constants/panel.js

@@ -0,0 +1,5 @@
+export const PANEL_MODE = {
+    panel: 'panel',
+    sidebar: 'sidebar',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFuZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25vdGlmaWNhdGlvbnMvY29uc3RhbnRzL3BhbmVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixLQUFLLEVBQUUsT0FBTztJQUNkLE9BQU8sRUFBRSxTQUFTO0NBQ1YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBQQU5FTF9NT0RFID0ge1xyXG4gIHBhbmVsOiAncGFuZWwnLFxyXG4gIHNpZGViYXI6ICdzaWRlYmFyJyxcclxufSBhcyBjb25zdDtcclxuIl19

package/esm2015/lib/components/notifications/constants/status.js

@@ -0,0 +1,10 @@
+export const NOTIFICATION_STATUS = {
+    new: 'New',
+    read: 'Read',
+    unRead: 'UnRead',
+};
+export const SUBSCRIPTION_STATE = {
+    subscribed: 'Subscribed',
+    unsubscribed: 'Unsubscribed',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdHVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbnV4ZW8tZGV2ZWxvcG1lbnQtZnJhbWV3b3JrL3NyYy9saWIvY29tcG9uZW50cy9ub3RpZmljYXRpb25zL2NvbnN0YW50cy9zdGF0dXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7SUFDakMsR0FBRyxFQUFFLEtBQUs7SUFDVixJQUFJLEVBQUUsTUFBTTtJQUNaLE1BQU0sRUFBRSxRQUFRO0NBQ1IsQ0FBQztBQUVYLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHO0lBQ2hDLFVBQVUsRUFBRSxZQUFZO0lBQ3hCLFlBQVksRUFBRSxjQUFjO0NBQ3BCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgTk9USUZJQ0FUSU9OX1NUQVRVUyA9IHtcclxuICBuZXc6ICdOZXcnLFxyXG4gIHJlYWQ6ICdSZWFkJyxcclxuICB1blJlYWQ6ICdVblJlYWQnLFxyXG59IGFzIGNvbnN0O1xyXG5cclxuZXhwb3J0IGNvbnN0IFNVQlNDUklQVElPTl9TVEFURSA9IHtcclxuICBzdWJzY3JpYmVkOiAnU3Vic2NyaWJlZCcsXHJcbiAgdW5zdWJzY3JpYmVkOiAnVW5zdWJzY3JpYmVkJyxcclxufSBhcyBjb25zdDtcclxuIl19

package/esm2015/lib/components/notifications/containers/index.js

@@ -0,0 +1,3 @@
+export * from './notifications-list-container/notifications-list-container.component';
+export * from './notifications-settings-container/notifications-settings-container.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25vdGlmaWNhdGlvbnMvY29udGFpbmVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVFQUF1RSxDQUFBO0FBQ3JGLGNBQWMsK0VBQStFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25vdGlmaWNhdGlvbnMtbGlzdC1jb250YWluZXIvbm90aWZpY2F0aW9ucy1saXN0LWNvbnRhaW5lci5jb21wb25lbnQnXHJcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9ucy1zZXR0aW5ncy1jb250YWluZXIvbm90aWZpY2F0aW9ucy1zZXR0aW5ncy1jb250YWluZXIuY29tcG9uZW50J1xyXG4iXX0=