@odx/angular 5.3.4 → 5.5.0

package/esm2022/components/notification/lib/directives/notification-center.directive.mjs

@@ -0,0 +1,142 @@
+import { DestroyRef, Directive, Input, Output, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { DisabledController } from '@odx/angular';
+import { BadgeDirective } from '@odx/angular/components/badge';
+import { DropdownDirective } from '@odx/angular/components/dropdown';
+import { Position } from '@odx/angular/utils';
+import { map, merge, startWith, switchMap, tap } from 'rxjs';
+import { NotificationCenterComponent } from '../components';
+import { NotificationCenterService } from '../services';
+import * as i0 from "@angular/core";
+import * as i1 from "@odx/angular/components/badge";
+import * as i2 from "@odx/angular/components/dropdown";
+/**
+ * A directive that provides an interface for managing notifications.
+ * It allows configuring a notification center with dynamic content, sorting, and badge display functionalities.
+ */
+export class NotificationCenterDirective {
+    constructor() {
+        this.badgeDirective = inject(BadgeDirective, { self: true });
+        this.destroyRef = inject(DestroyRef);
+        this.disabledController = DisabledController.inject();
+        this.dropdownDirective = inject(DropdownDirective, { self: true });
+        this.notificationCenterService = inject(NotificationCenterService, { self: true });
+        this.dropdownStateChange$ = merge(this.dropdownDirective.beforeOpen, this.dropdownDirective.beforeClose).pipe(startWith(void 0));
+        this.badgeValue$ = this.notificationCenterService.unseenNotifications$.pipe(switchMap(({ count }) => this.dropdownStateChange$.pipe(map(() => this.formatBadgeValue(count)))));
+        /**
+         * An event that is emitted when a new notification is added.
+         * Listeners can use this event to react to new notifications being added to the notification center.
+         */
+        // eslint-disable-next-line @angular-eslint/no-output-rename
+        this.notificationAdd = this.notificationCenterService.onNotificationAdd$;
+        /**
+         * An event that is emitted when a notification is updated.
+         * This can be used to react to changes in notifications, such as their read status or content updates.
+         */
+        // eslint-disable-next-line @angular-eslint/no-output-rename
+        this.notificationUpdate = this.notificationCenterService.onNotificationUpdate$;
+        /**
+         * An event that is emitted when a notification is removed from the notification center.
+         * Use this event to handle the removal of notifications, such as cleaning up resources or updating UI elements.
+         */
+        // eslint-disable-next-line @angular-eslint/no-output-rename
+        this.notificationRemove = this.notificationCenterService.onNotificationRemove$;
+        /**
+         * An event that is emitted when a notification is marked as seen.
+         * This event can be used to perform actions when the user acknowledges a notification.
+         */
+        // eslint-disable-next-line @angular-eslint/no-output-rename
+        this.notificationSeen = this.notificationCenterService.onNotificationSeen$;
+    }
+    /**
+     * Sets the tag for filtering notifications. Only notifications with this tag will be shown in the notification center.
+     * @param value The tag value to filter notifications. If null, all notifications are shown.
+     */
+    set tag(value) {
+        this.notificationCenterService.setTag(value);
+    }
+    /**
+     * Sets the title of the notification center. The title can be dynamic and change based on the application state.
+     * @param value The title content, which can be a string or an Observable returning a string. Allows for dynamic titles.
+     */
+    set title(value) {
+        this.notificationCenterService.setTitle(value);
+    }
+    /**
+     * Sets the sorting function used to order notifications within the notification center.
+     * @param value A function that compares two notifications and returns the sort order.
+     *
+     * @example
+     *  sortFfn = (a: NotificationRef, b: NotificationRef) => {
+          if (a.createdAt < b.createdAt) return -1;
+          if (a.createdAt > b.createdAt) return 1;
+          return 0;
+        };
+     */
+    set sortFn(value) {
+        this.notificationCenterService.setSortFn(value);
+    }
+    ngOnInit() {
+        this.badgeDirective.position = Position.BOTTOM;
+        this.badgeDirective.offset = 6;
+        this.dropdownDirective.content = NotificationCenterComponent;
+        this.dropdownDirective.options = {
+            containerClass: 'odx-notification-center-overlay',
+            position: Position.BOTTOM_END,
+            enableFallback: false,
+        };
+    }
+    ngAfterViewInit() {
+        merge(this.handleBadgeUpdates(), this.handleDropdownUpdates()).pipe(takeUntilDestroyed(this.destroyRef)).subscribe();
+    }
+    formatBadgeValue(value) {
+        return this.dropdownDirective.isOpen || value === 0 ? null : value.toFixed(0);
+    }
+    handleBadgeUpdates() {
+        return this.badgeValue$.pipe(tap((value) => {
+            this.badgeDirective.value = value;
+            this.badgeDirective.ngOnChanges();
+        }));
+    }
+    handleDropdownUpdates() {
+        return this.notificationCenterService.notifications$.pipe(tap(({ isEmpty }) => {
+            this.disabledController?.setDisabledState(isEmpty);
+            if (!isEmpty)
+                return;
+            this.dropdownDirective.close();
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationCenterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: NotificationCenterDirective, isStandalone: true, selector: "[odxNotificationCenter]", inputs: { tag: ["odxNotificationCenter", "tag"], title: ["odxNotificationCenterTitle", "title"], sortFn: ["odxNotificationCenterSortFn", "sortFn"] }, outputs: { notificationAdd: "odxNotificationCenterAdd", notificationUpdate: "odxNotificationCenterUpdate", notificationRemove: "odxNotificationCenterRemove", notificationSeen: "odxNotificationCenterSeen" }, providers: [NotificationCenterService], hostDirectives: [{ directive: i1.BadgeDirective, inputs: ["odxBadgeVariant", "odxNotificationCenterBadgeVariant"] }, { directive: i2.DropdownDirective }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationCenterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[odxNotificationCenter]',
+                    hostDirectives: [{ directive: BadgeDirective, inputs: ['odxBadgeVariant:odxNotificationCenterBadgeVariant'] }, DropdownDirective],
+                    providers: [NotificationCenterService],
+                }]
+        }], propDecorators: { tag: [{
+                type: Input,
+                args: ['odxNotificationCenter']
+            }], title: [{
+                type: Input,
+                args: ['odxNotificationCenterTitle']
+            }], sortFn: [{
+                type: Input,
+                args: ['odxNotificationCenterSortFn']
+            }], notificationAdd: [{
+                type: Output,
+                args: ['odxNotificationCenterAdd']
+            }], notificationUpdate: [{
+                type: Output,
+                args: ['odxNotificationCenterUpdate']
+            }], notificationRemove: [{
+                type: Output,
+                args: ['odxNotificationCenterRemove']
+            }], notificationSeen: [{
+                type: Output,
+                args: ['odxNotificationCenterSeen']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-center.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/components/notification/src/lib/directives/notification-center.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, DestroyRef, Directive, Input, OnInit, Output, inject } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { DisabledController } from '@odx/angular';\nimport { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';\nimport { BadgeDirective } from '@odx/angular/components/badge';\nimport { DropdownDirective } from '@odx/angular/components/dropdown';\nimport { Position } from '@odx/angular/utils';\nimport { Observable, map, merge, startWith, switchMap, tap } from 'rxjs';\nimport { NotificationCenterComponent } from '../components';\nimport { NotificationSortFn } from '../models';\nimport { NotificationCenterService } from '../services';\n\n/**\n * A directive that provides an interface for managing notifications.\n * It allows configuring a notification center with dynamic content, sorting, and badge display functionalities.\n */\n@Directive({\n  standalone: true,\n  selector: '[odxNotificationCenter]',\n  hostDirectives: [{ directive: BadgeDirective, inputs: ['odxBadgeVariant:odxNotificationCenterBadgeVariant'] }, DropdownDirective],\n  providers: [NotificationCenterService],\n})\nexport class NotificationCenterDirective implements OnInit, AfterViewInit {\n  private readonly badgeDirective = inject(BadgeDirective, { self: true });\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly disabledController = DisabledController.inject();\n  private readonly dropdownDirective = inject(DropdownDirective, { self: true });\n  private readonly notificationCenterService = inject(NotificationCenterService, { self: true });\n  private readonly dropdownStateChange$ = merge(this.dropdownDirective.beforeOpen, this.dropdownDirective.beforeClose).pipe(startWith(void 0));\n  private readonly badgeValue$ = this.notificationCenterService.unseenNotifications$.pipe(\n    switchMap(({ count }) => this.dropdownStateChange$.pipe(map(() => this.formatBadgeValue(count)))),\n  );\n\n  /**\n   * Sets the tag for filtering notifications. Only notifications with this tag will be shown in the notification center.\n   * @param value The tag value to filter notifications. If null, all notifications are shown.\n   */\n  @Input('odxNotificationCenter')\n  public set tag(value: string | null) {\n    this.notificationCenterService.setTag(value);\n  }\n\n  /**\n   * Sets the title of the notification center. The title can be dynamic and change based on the application state.\n   * @param value The title content, which can be a string or an Observable returning a string. Allows for dynamic titles.\n   */\n  @Input('odxNotificationCenterTitle')\n  public set title(value: DynamicTextContent | null) {\n    this.notificationCenterService.setTitle(value);\n  }\n\n  /**\n   * Sets the sorting function used to order notifications within the notification center.\n   * @param value A function that compares two notifications and returns the sort order.\n   *\n   * @example\n   *  sortFfn = (a: NotificationRef, b: NotificationRef) => {\n        if (a.createdAt < b.createdAt) return -1;\n        if (a.createdAt > b.createdAt) return 1;\n        return 0;\n      };\n   */\n  @Input('odxNotificationCenterSortFn')\n  public set sortFn(value: NotificationSortFn) {\n    this.notificationCenterService.setSortFn(value);\n  }\n\n  /**\n   * An event that is emitted when a new notification is added.\n   * Listeners can use this event to react to new notifications being added to the notification center.\n   */\n  // eslint-disable-next-line @angular-eslint/no-output-rename\n  @Output('odxNotificationCenterAdd')\n  public notificationAdd = this.notificationCenterService.onNotificationAdd$;\n\n  /**\n   * An event that is emitted when a notification is updated.\n   * This can be used to react to changes in notifications, such as their read status or content updates.\n   */\n  // eslint-disable-next-line @angular-eslint/no-output-rename\n  @Output('odxNotificationCenterUpdate')\n  public notificationUpdate = this.notificationCenterService.onNotificationUpdate$;\n\n  /**\n   * An event that is emitted when a notification is removed from the notification center.\n   * Use this event to handle the removal of notifications, such as cleaning up resources or updating UI elements.\n   */\n  // eslint-disable-next-line @angular-eslint/no-output-rename\n  @Output('odxNotificationCenterRemove')\n  public notificationRemove = this.notificationCenterService.onNotificationRemove$;\n\n  /**\n   * An event that is emitted when a notification is marked as seen.\n   * This event can be used to perform actions when the user acknowledges a notification.\n   */\n  // eslint-disable-next-line @angular-eslint/no-output-rename\n  @Output('odxNotificationCenterSeen')\n  public notificationSeen = this.notificationCenterService.onNotificationSeen$;\n\n  public ngOnInit() {\n    this.badgeDirective.position = Position.BOTTOM;\n    this.badgeDirective.offset = 6;\n\n    this.dropdownDirective.content = NotificationCenterComponent;\n    this.dropdownDirective.options = {\n      containerClass: 'odx-notification-center-overlay',\n      position: Position.BOTTOM_END,\n      enableFallback: false,\n    };\n  }\n\n  public ngAfterViewInit() {\n    merge(this.handleBadgeUpdates(), this.handleDropdownUpdates()).pipe(takeUntilDestroyed(this.destroyRef)).subscribe();\n  }\n\n  private formatBadgeValue(value: number): string | null {\n    return this.dropdownDirective.isOpen || value === 0 ? null : value.toFixed(0);\n  }\n\n  private handleBadgeUpdates(): Observable<unknown> {\n    return this.badgeValue$.pipe(\n      tap((value: DynamicTextContent | null) => {\n        this.badgeDirective.value = value as DynamicTextContent;\n        this.badgeDirective.ngOnChanges();\n      }),\n    );\n  }\n\n  private handleDropdownUpdates(): Observable<unknown> {\n    return this.notificationCenterService.notifications$.pipe(\n      tap(({ isEmpty }) => {\n        this.disabledController?.setDisabledState(isEmpty);\n        if (!isEmpty) return;\n        this.dropdownDirective.close();\n      }),\n    );\n  }\n}\n"]}

package/esm2022/components/notification/lib/features/index.mjs

@@ -0,0 +1,6 @@
+export * from './with-browser-notifications';
+export * from './with-load-notifications';
+export * from './with-notification-transformer';
+export * from './with-peristent-notifications';
+export * from './with-save-notifications';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9mZWF0dXJlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3dpdGgtYnJvd3Nlci1ub3RpZmljYXRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vd2l0aC1sb2FkLW5vdGlmaWNhdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi93aXRoLW5vdGlmaWNhdGlvbi10cmFuc2Zvcm1lcic7XG5leHBvcnQgKiBmcm9tICcuL3dpdGgtcGVyaXN0ZW50LW5vdGlmaWNhdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi93aXRoLXNhdmUtbm90aWZpY2F0aW9ucyc7XG4iXX0=

package/esm2022/components/notification/lib/features/with-browser-notifications.mjs

@@ -0,0 +1,75 @@
+import { ENVIRONMENT_INITIALIZER, inject } from '@angular/core';
+import { makeNotificationFeature } from '../models';
+import { NotificationService } from '../notification.service';
+import { PersistentNotificationSerializer } from './with-peristent-notifications';
+/**
+ * Requests permission to display browser notifications and returns a boolean indicating whether permission was granted.
+ * @async
+ * @function requestBrowserNotificationPermissions
+ * @returns {Promise<boolean>} A promise that resolves to `true` if permission is granted, otherwise `false`.
+ */
+async function requestBrowserNotificationPermissions() {
+    if (!('Notification' in window))
+        return false;
+    if (Notification.permission === 'granted')
+        return true;
+    if (Notification.permission === 'denied')
+        return false;
+    const permission = await Notification.requestPermission();
+    return permission === 'granted';
+}
+/**
+ * Creates a function responsible for sending out browser notifications with the given options.
+ * @function sendBrowserNotification
+ * @param {NotificationSerializer} serializer - The serializer to use for notification data.
+ * @param {BrowserNotificationExtras} [options] - Additional options for the browser notification.
+ * @returns {SendBrowserNotificationFn} A function to send browser notifications.
+ */
+function sendBrowserNotification(serializer, options) {
+    return async (notificationRef) => {
+        if (!('Notification' in window))
+            return;
+        const [notificationObj] = await serializer.deserialize(await serializer.serialize([notificationRef]));
+        if (!notificationObj || notificationObj.hasBeenSeen)
+            return;
+        const { createdAt, item } = notificationObj;
+        new Notification(item.title, {
+            tag: notificationRef.options.tags?.[0],
+            lang: notificationRef.options.language,
+            ...options,
+            body: item.description,
+            timestamp: createdAt,
+        });
+    };
+}
+/**
+ * Configures the application to send browser notifications, using Angular's `ENVIRONMENT_INITIALIZER` for setup.
+ * @function withBrowserNotifications
+ * @param {WithBrowserNotificationsOptions} [options] - Optional configuration for browser notifications.
+ * @returns {NotificationFeature} A notification feature for integration into the application environment.
+ */
+export function withBrowserNotifications(options) {
+    return makeNotificationFeature([
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useFactory: () => {
+                const isEnabled = options?.isEnabled ?? true;
+                if (!isEnabled)
+                    return () => void 0;
+                const notificationService = inject(NotificationService);
+                const serializer = new PersistentNotificationSerializer();
+                const sendBrowserNotificationFn = options?.sendFn ?? sendBrowserNotification(serializer, options?.extras);
+                return async () => {
+                    if (!isEnabled)
+                        return;
+                    const permissionsGranted = await requestBrowserNotificationPermissions();
+                    if (!permissionsGranted)
+                        return;
+                    notificationService.onNotificationAdd$.subscribe(sendBrowserNotificationFn);
+                };
+            },
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/notification/lib/features/with-load-notifications.mjs

@@ -0,0 +1,45 @@
+import { ENVIRONMENT_INITIALIZER, inject } from '@angular/core';
+import { from, isObservable, of } from 'rxjs';
+import { makeNotificationFeature } from '../models';
+import { NotificationService } from '../notification.service';
+/**
+ * Loads notifications using the provided `loadFn`. This function abstracts over the differences
+ * between synchronous notifications, promises, and observables, providing a uniform Observable output.
+ * @function loadNotifications
+ * @param {LoadNotificationsFn} [loadFn] - An optional function to load notifications.
+ * @returns {Observable<NotificationRef[]>} An Observable stream of notification references.
+ */
+function loadNotifications(loadFn) {
+    const notifications = loadFn?.();
+    if (isObservable(notifications)) {
+        return notifications;
+    }
+    if (notifications instanceof Promise) {
+        return from(notifications);
+    }
+    return of(notifications ?? []);
+}
+/**
+ * Integrates notification loading into the application environment. This function uses the Angular
+ * `ENVIRONMENT_INITIALIZER` to ensure that notifications are loaded as part of the application's
+ * initialization process.
+ * @function withLoadNotifications
+ * @param {LoadNotificationsFn} loadFn - The function to load notifications.
+ * @returns {NotificationFeature} A notification feature configured to load notifications at startup.
+ */
+export function withLoadNotifications(loadFn) {
+    return makeNotificationFeature([
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useFactory: () => {
+                const notificationService = inject(NotificationService);
+                const notifications$ = loadNotifications(loadFn);
+                return () => {
+                    notifications$.subscribe((notificationRefs) => notificationService.load(notificationRefs));
+                };
+            },
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/notification/lib/features/with-notification-transformer.mjs

@@ -0,0 +1,34 @@
+import { InjectionToken, inject } from '@angular/core';
+import { makeNotificationFeature } from '../models';
+/**
+ * An InjectionToken for the NotificationTransformFn. This token can be used to inject
+ * a custom notification transformation function into the Angular DI system.
+ * @type {InjectionToken<NotificationTransformFn>}
+ */
+export const ODX_NOTIFICATION_TRANSFORMER = new InjectionToken('@odx/angular/components/notification::NotificationTransformer');
+/**
+ * Attempts to inject a NotificationTransformFn from the Angular DI system.
+ * If no provider is found, it returns null.
+ * @function injectNotificationTransform
+ * @returns {NotificationTransformFn | null} The injected NotificationTransformFn, or null if not provided.
+ */
+export function injectNotificationTransform() {
+    return inject(ODX_NOTIFICATION_TRANSFORMER, { optional: true });
+}
+/**
+ * Configures a notification transformation function to be used within the application.
+ * This function provides a mechanism to globally apply transformations to notifications
+ * before they are processed or displayed.
+ * @function withNotificationTransform
+ * @param {NotificationTransformFn} transformFn - The function to transform notifications.
+ * @returns {NotificationFeature} A NotificationFeature configured with the provided transformation function.
+ */
+export function withNotificationTransform(transformFn) {
+    return makeNotificationFeature([
+        {
+            provide: ODX_NOTIFICATION_TRANSFORMER,
+            useValue: transformFn,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/notification/lib/features/with-peristent-notifications.mjs

@@ -0,0 +1,94 @@
+import { deepmerge } from '@odx/angular/internal';
+import { isFunction, isString } from '@odx/angular/utils';
+import { firstValueFrom } from 'rxjs';
+import { makeNotificationFeature } from '../models';
+import { withLoadNotifications } from './with-load-notifications';
+import { withSaveNotifications } from './with-save-notifications';
+/**
+ * Implementation of NotificationSerializer for persistent storage.
+ * @class PersistentNotificationSerializer
+ * @implements {NotificationSerializer}
+ */
+export class PersistentNotificationSerializer {
+    /**
+     * Serializes an array of NotificationRef objects into a string.
+     * @function serialize
+     * @memberof NotificationSerializer
+     * @param {NotificationRef[]} value - The notification references to serialize.
+     * @returns {Promise<string>} A promise that resolves to the serialized string representation of notification references.
+     */
+    async serialize(value) {
+        const serializedNotifications = await Promise.all(value.map(async (ref) => deepmerge(ref, {
+            item: {
+                title: await this.serializeDynamicTextContent(ref.item.title),
+                description: await this.serializeDynamicTextContent(ref.item.description),
+            },
+        })));
+        return JSON.stringify(serializedNotifications);
+    }
+    /**
+     * Deserializes a string into an array of NotificationRef objects.
+     * @function deserialize
+     * @memberof NotificationSerializer
+     * @param {string} value - The string representation of notification references to deserialize.
+     * @returns {Promise<NotificationRef[]>} A promise that resolves to the deserialized notification references.
+     */
+    async deserialize(value) {
+        return JSON.parse(value);
+    }
+    async serializeDynamicTextContent(content) {
+        if (!content)
+            return '';
+        if (isString(content))
+            return content;
+        return firstValueFrom(content).catch(() => '');
+    }
+}
+/**
+ * Initializes and returns a function for loading persistent notifications.
+ * @function initPersistentNotifications
+ * @param {WithPersistentNotificationsStorageOptions} options - The storage options including serializer and storage key.
+ * @returns {LoadNotificationsFn} A function to load notifications from storage.
+ */
+export function initPersistentNotifications({ storage, storageKey, serializer, idTransformer, }) {
+    return async () => {
+        const storedValue = storage.getItem(storageKey);
+        if (!storedValue)
+            return [];
+        const notificationRefs = await serializer.deserialize(storedValue);
+        if (isFunction(idTransformer)) {
+            for (const notificationRef of notificationRefs) {
+                notificationRef.item.id = notificationRef.id = idTransformer(notificationRef);
+            }
+        }
+        return notificationRefs;
+    };
+}
+/**
+ * Returns a function for persisting notifications.
+ * @function persistNotifications
+ * @param {WithPersistentNotificationsStorageOptions} options - The storage options including serializer and storage key.
+ * @returns {SaveNotificationsFn} A function to save notifications to storage.
+ */
+export function persistNotifications({ storage, storageKey, serializer }) {
+    return async (notificationRefs) => {
+        storage.setItem(storageKey, await serializer.serialize(notificationRefs));
+    };
+}
+/**
+ * Configures the application to use persistent notifications, automatically loading from and saving to the configured storage.
+ * @function withPersistentNotifications
+ * @param {Partial<WithPersistentNotificationsOptions>} [options] - Optional configuration for persistent notifications.
+ * @returns {NotificationFeature} A notification feature configured for persistence.
+ */
+export function withPersistentNotifications(options) {
+    const storageOptions = {
+        storageKey: options?.storageOptions?.storageKey ?? '@odx/angular/components/notification::Storage',
+        storage: options?.storageOptions?.storage ?? localStorage,
+        serializer: options?.storageOptions?.serializer ?? new PersistentNotificationSerializer(),
+    };
+    const initFn = options?.initFn ?? initPersistentNotifications(storageOptions);
+    const saveFn = options?.saveFn ?? persistNotifications(storageOptions);
+    return makeNotificationFeature([withLoadNotifications(initFn), withSaveNotifications(saveFn)]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-peristent-notifications.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/components/notification/src/lib/features/with-peristent-notifications.ts"],"names":[],"mappings":"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","sourcesContent":["import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';\nimport { deepmerge } from '@odx/angular/internal';\nimport { isFunction, isString } from '@odx/angular/utils';\nimport { firstValueFrom } from 'rxjs';\nimport { NotificationFeature, NotificationRef, makeNotificationFeature } from '../models';\nimport { LoadNotificationsFn, withLoadNotifications } from './with-load-notifications';\nimport { SaveNotificationsFn, withSaveNotifications } from './with-save-notifications';\n\nexport interface NotificationSerializer {\n  serialize(value: NotificationRef[]): Promise<string>;\n  deserialize(value: string): Promise<NotificationRef[]>;\n}\n\n/**\n * Implementation of NotificationSerializer for persistent storage.\n * @class PersistentNotificationSerializer\n * @implements {NotificationSerializer}\n */\nexport class PersistentNotificationSerializer implements NotificationSerializer {\n  /**\n   * Serializes an array of NotificationRef objects into a string.\n   * @function serialize\n   * @memberof NotificationSerializer\n   * @param {NotificationRef[]} value - The notification references to serialize.\n   * @returns {Promise<string>} A promise that resolves to the serialized string representation of notification references.\n   */\n  public async serialize(value: NotificationRef[]): Promise<string> {\n    const serializedNotifications = await Promise.all(\n      value.map(async (ref) =>\n        deepmerge(ref, {\n          item: {\n            title: await this.serializeDynamicTextContent(ref.item.title),\n            description: await this.serializeDynamicTextContent(ref.item.description),\n          },\n        }),\n      ),\n    );\n\n    return JSON.stringify(serializedNotifications);\n  }\n\n  /**\n   * Deserializes a string into an array of NotificationRef objects.\n   * @function deserialize\n   * @memberof NotificationSerializer\n   * @param {string} value - The string representation of notification references to deserialize.\n   * @returns {Promise<NotificationRef[]>} A promise that resolves to the deserialized notification references.\n   */\n  public async deserialize(value: string): Promise<NotificationRef[]> {\n    return JSON.parse(value);\n  }\n\n  private async serializeDynamicTextContent(content?: DynamicTextContent): Promise<string> {\n    if (!content) return '';\n    if (isString(content)) return content;\n\n    return firstValueFrom(content).catch(() => '');\n  }\n}\n\nexport interface WithPersistentNotificationsStorageOptions {\n  storageKey: string;\n  storage: Storage;\n  serializer: NotificationSerializer;\n  idTransformer?: (notificationRef: NotificationRef) => string;\n}\n\nexport interface WithPersistentNotificationsOptions {\n  initFn: LoadNotificationsFn;\n  saveFn: SaveNotificationsFn;\n  storageOptions: WithPersistentNotificationsStorageOptions;\n}\n\n/**\n * Initializes and returns a function for loading persistent notifications.\n * @function initPersistentNotifications\n * @param {WithPersistentNotificationsStorageOptions} options - The storage options including serializer and storage key.\n * @returns {LoadNotificationsFn} A function to load notifications from storage.\n */\nexport function initPersistentNotifications({\n  storage,\n  storageKey,\n  serializer,\n  idTransformer,\n}: WithPersistentNotificationsStorageOptions): LoadNotificationsFn {\n  return async () => {\n    const storedValue = storage.getItem(storageKey);\n    if (!storedValue) return [];\n    const notificationRefs = await serializer.deserialize(storedValue);\n\n    if (isFunction(idTransformer)) {\n      for (const notificationRef of notificationRefs) {\n        notificationRef.item.id = notificationRef.id = idTransformer(notificationRef);\n      }\n    }\n\n    return notificationRefs;\n  };\n}\n\n/**\n * Returns a function for persisting notifications.\n * @function persistNotifications\n * @param {WithPersistentNotificationsStorageOptions} options - The storage options including serializer and storage key.\n * @returns {SaveNotificationsFn} A function to save notifications to storage.\n */\nexport function persistNotifications({ storage, storageKey, serializer }: WithPersistentNotificationsStorageOptions): SaveNotificationsFn {\n  return async (notificationRefs: NotificationRef[]) => {\n    storage.setItem(storageKey, await serializer.serialize(notificationRefs));\n  };\n}\n\n/**\n * Configures the application to use persistent notifications, automatically loading from and saving to the configured storage.\n * @function withPersistentNotifications\n * @param {Partial<WithPersistentNotificationsOptions>} [options] - Optional configuration for persistent notifications.\n * @returns {NotificationFeature} A notification feature configured for persistence.\n */\nexport function withPersistentNotifications(options?: Partial<WithPersistentNotificationsOptions>): NotificationFeature {\n  const storageOptions: WithPersistentNotificationsStorageOptions = {\n    storageKey: options?.storageOptions?.storageKey ?? '@odx/angular/components/notification::Storage',\n    storage: options?.storageOptions?.storage ?? localStorage,\n    serializer: options?.storageOptions?.serializer ?? new PersistentNotificationSerializer(),\n  };\n  const initFn = options?.initFn ?? initPersistentNotifications(storageOptions);\n  const saveFn = options?.saveFn ?? persistNotifications(storageOptions);\n\n  return makeNotificationFeature([withLoadNotifications(initFn), withSaveNotifications(saveFn)]);\n}\n"]}

package/esm2022/components/notification/lib/features/with-save-notifications.mjs

@@ -0,0 +1,45 @@
+import { ENVIRONMENT_INITIALIZER, Injector, inject, runInInjectionContext } from '@angular/core';
+import { firstValueFrom, isObservable } from 'rxjs';
+import { makeNotificationFeature } from '../models';
+import { NotificationService } from '../notification.service';
+/**
+ * Asynchronously saves notifications using the provided save function. It handles Observable and Promise results seamlessly.
+ * @async
+ * @function saveNotifications
+ * @param {NotificationRef[]} notifications - The notifications to be saved.
+ * @param {SaveNotificationsFn} [saveFn] - Optional custom save function.
+ * @returns {Promise<void>} A promise that resolves when the save operation is complete.
+ */
+async function saveNotifications(notifications, saveFn) {
+    const save = saveFn?.(notifications);
+    if (isObservable(save)) {
+        await firstValueFrom(save);
+    }
+    else if (save instanceof Promise) {
+        await save;
+    }
+}
+/**
+ * Configures the application to automatically save notifications using a specified save function.
+ * This setup integrates with Angular's environment initialization process to ensure notifications are saved as needed.
+ * @function withSaveNotifications
+ * @param {SaveNotificationsFn} saveFn - The function to save notifications.
+ * @returns {NotificationFeature} A notification feature configured to automatically save notifications.
+ */
+export function withSaveNotifications(saveFn) {
+    return makeNotificationFeature([
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useFactory: () => {
+                const injector = Injector.create({ parent: inject(Injector), providers: [] });
+                const notificationService = inject(NotificationService);
+                const saveFnWithContext = (notifications) => runInInjectionContext(injector, () => saveFn(notifications));
+                return () => {
+                    notificationService.notifications$.subscribe(({ values }) => saveNotifications(values, saveFnWithContext));
+                };
+            },
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/notification/lib/helpers/get-notifications-by-tag.mjs

@@ -0,0 +1,7 @@
+export function getNotificationsByTags(...tags) {
+    const cachedTags = new Set(tags.filter(Boolean));
+    return ({ options }) => {
+        return cachedTags.size < 1 || options.tags.every((tag) => cachedTags.has(tag));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW5vdGlmaWNhdGlvbnMtYnktdGFnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2NvbXBvbmVudHMvbm90aWZpY2F0aW9uL3NyYy9saWIvaGVscGVycy9nZXQtbm90aWZpY2F0aW9ucy1ieS10YWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLHNCQUFzQixDQUFDLEdBQUcsSUFBc0M7SUFDOUUsTUFBTSxVQUFVLEdBQUcsSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBRWpELE9BQU8sQ0FBQyxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUU7UUFDckIsT0FBTyxVQUFVLENBQUMsSUFBSSxHQUFHLENBQUMsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ2pGLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb3RpZmljYXRpb25RdWVyeSB9IGZyb20gJy4uL21vZGVscyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXROb3RpZmljYXRpb25zQnlUYWdzKC4uLnRhZ3M6IEFycmF5PHN0cmluZyB8IG51bGwgfCB1bmRlZmluZWQ+KTogTm90aWZpY2F0aW9uUXVlcnkge1xuICBjb25zdCBjYWNoZWRUYWdzID0gbmV3IFNldCh0YWdzLmZpbHRlcihCb29sZWFuKSk7XG5cbiAgcmV0dXJuICh7IG9wdGlvbnMgfSkgPT4ge1xuICAgIHJldHVybiBjYWNoZWRUYWdzLnNpemUgPCAxIHx8IG9wdGlvbnMudGFncy5ldmVyeSgodGFnKSA9PiBjYWNoZWRUYWdzLmhhcyh0YWcpKTtcbiAgfTtcbn1cbiJdfQ==

package/esm2022/components/notification/lib/helpers/index.mjs

@@ -0,0 +1,4 @@
+export * from './get-notifications-by-tag';
+export * from './sort-notifications';
+export * from './to-notification-collection';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9oZWxwZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9nZXQtbm90aWZpY2F0aW9ucy1ieS10YWcnO1xuZXhwb3J0ICogZnJvbSAnLi9zb3J0LW5vdGlmaWNhdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi90by1ub3RpZmljYXRpb24tY29sbGVjdGlvbic7XG4iXX0=

package/esm2022/components/notification/lib/helpers/sort-notifications.mjs

@@ -0,0 +1,10 @@
+import { isFunction } from '@odx/angular/utils';
+import { tap } from 'rxjs';
+export function sortNotifications(sortFn) {
+    return (source$) => source$.pipe(tap((values) => {
+        if (!isFunction(sortFn))
+            return;
+        values.sort(sortFn);
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1ub3RpZmljYXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2NvbXBvbmVudHMvbm90aWZpY2F0aW9uL3NyYy9saWIvaGVscGVycy9zb3J0LW5vdGlmaWNhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2hELE9BQU8sRUFBNEIsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBR3JELE1BQU0sVUFBVSxpQkFBaUIsQ0FBQyxNQUEyQjtJQUMzRCxPQUFPLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FDakIsT0FBTyxDQUFDLElBQUksQ0FDVixHQUFHLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRTtRQUNiLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDO1lBQUUsT0FBTztRQUNoQyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3RCLENBQUMsQ0FBQyxDQUNILENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNGdW5jdGlvbiB9IGZyb20gJ0BvZHgvYW5ndWxhci91dGlscyc7XG5pbXBvcnQgeyBNb25vVHlwZU9wZXJhdG9yRnVuY3Rpb24sIHRhcCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgTm90aWZpY2F0aW9uUmVmLCBOb3RpZmljYXRpb25Tb3J0Rm4gfSBmcm9tICcuLi9tb2RlbHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gc29ydE5vdGlmaWNhdGlvbnMoc29ydEZuPzogTm90aWZpY2F0aW9uU29ydEZuKTogTW9ub1R5cGVPcGVyYXRvckZ1bmN0aW9uPE5vdGlmaWNhdGlvblJlZltdPiB7XG4gIHJldHVybiAoc291cmNlJCkgPT5cbiAgICBzb3VyY2UkLnBpcGUoXG4gICAgICB0YXAoKHZhbHVlcykgPT4ge1xuICAgICAgICBpZiAoIWlzRnVuY3Rpb24oc29ydEZuKSkgcmV0dXJuO1xuICAgICAgICB2YWx1ZXMuc29ydChzb3J0Rm4pO1xuICAgICAgfSksXG4gICAgKTtcbn1cbiJdfQ==

package/esm2022/components/notification/lib/helpers/to-notification-collection.mjs

@@ -0,0 +1,9 @@
+import { map } from 'rxjs';
+export function toNotificationCollection() {
+    return (source$) => source$.pipe(map((notificationRefs) => ({
+        values: notificationRefs,
+        count: notificationRefs.length,
+        isEmpty: notificationRefs.length === 0,
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG8tbm90aWZpY2F0aW9uLWNvbGxlY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9oZWxwZXJzL3RvLW5vdGlmaWNhdGlvbi1jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBb0IsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRzdDLE1BQU0sVUFBVSx3QkFBd0I7SUFDdEMsT0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQ2pCLE9BQU8sQ0FBQyxJQUFJLENBQ1YsR0FBRyxDQUFDLENBQUMsZ0JBQWdCLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDekIsTUFBTSxFQUFFLGdCQUFnQjtRQUN4QixLQUFLLEVBQUUsZ0JBQWdCLENBQUMsTUFBTTtRQUM5QixPQUFPLEVBQUUsZ0JBQWdCLENBQUMsTUFBTSxLQUFLLENBQUM7S0FDdkMsQ0FBQyxDQUFDLENBQ0osQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPcGVyYXRvckZ1bmN0aW9uLCBtYXAgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IE5vdGlmaWNhdGlvbkNvbGxlY3Rpb24sIE5vdGlmaWNhdGlvblJlZiB9IGZyb20gJy4uL21vZGVscyc7XG5cbmV4cG9ydCBmdW5jdGlvbiB0b05vdGlmaWNhdGlvbkNvbGxlY3Rpb24oKTogT3BlcmF0b3JGdW5jdGlvbjxOb3RpZmljYXRpb25SZWZbXSwgTm90aWZpY2F0aW9uQ29sbGVjdGlvbj4ge1xuICByZXR1cm4gKHNvdXJjZSQpID0+XG4gICAgc291cmNlJC5waXBlKFxuICAgICAgbWFwKChub3RpZmljYXRpb25SZWZzKSA9PiAoe1xuICAgICAgICB2YWx1ZXM6IG5vdGlmaWNhdGlvblJlZnMsXG4gICAgICAgIGNvdW50OiBub3RpZmljYXRpb25SZWZzLmxlbmd0aCxcbiAgICAgICAgaXNFbXB0eTogbm90aWZpY2F0aW9uUmVmcy5sZW5ndGggPT09IDAsXG4gICAgICB9KSksXG4gICAgKTtcbn1cbiJdfQ==

package/esm2022/components/notification/lib/models/index.mjs

@@ -0,0 +1,9 @@
+export * from './notification';
+export * from './notification-action';
+export * from './notification-collection';
+export * from './notification-feature';
+export * from './notification-options';
+export * from './notification-query';
+export * from './notification-sort-fn';
+export * from './notification.ref';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ub3RpZmljYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9ub3RpZmljYXRpb24tYWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9uLWNvbGxlY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9ub3RpZmljYXRpb24tZmVhdHVyZSc7XG5leHBvcnQgKiBmcm9tICcuL25vdGlmaWNhdGlvbi1vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9uLXF1ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9uLXNvcnQtZm4nO1xuZXhwb3J0ICogZnJvbSAnLi9ub3RpZmljYXRpb24ucmVmJztcbiJdfQ==

package/esm2022/components/notification/lib/models/notification-action.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLWFjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21wb25lbnRzL25vdGlmaWNhdGlvbi9zcmMvbGliL21vZGVscy9ub3RpZmljYXRpb24tYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOb3RpZmljYXRpb25SZWYgfSBmcm9tICcuL25vdGlmaWNhdGlvbi5yZWYnO1xuXG5leHBvcnQgdHlwZSBOb3RpZmljYXRpb25BY3Rpb24gPSAobm90aWZpY2F0aW9uUmVmOiBOb3RpZmljYXRpb25SZWYpID0+IHZvaWQ7XG4iXX0=

package/esm2022/components/notification/lib/models/notification-collection.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLWNvbGxlY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9tb2RlbHMvbm90aWZpY2F0aW9uLWNvbGxlY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5vdGlmaWNhdGlvblJlZiB9IGZyb20gJy4vbm90aWZpY2F0aW9uLnJlZic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTm90aWZpY2F0aW9uQ29sbGVjdGlvbiB7XG4gIHZhbHVlczogTm90aWZpY2F0aW9uUmVmW107XG4gIGNvdW50OiBudW1iZXI7XG4gIGlzRW1wdHk6IGJvb2xlYW47XG59XG4iXX0=

package/esm2022/components/notification/lib/models/notification-feature.mjs

@@ -0,0 +1,4 @@
+export function makeNotificationFeature(provider) {
+    return provider;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLWZlYXR1cmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9tb2RlbHMvbm90aWZpY2F0aW9uLWZlYXR1cmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxVQUFVLHVCQUF1QixDQUFDLFFBQW1FO0lBQ3pHLE9BQU8sUUFBd0MsQ0FBQztBQUNsRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRW52aXJvbm1lbnRQcm92aWRlcnMsIFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCB0eXBlIE5vdGlmaWNhdGlvbkZlYXR1cmUgPSBFbnZpcm9ubWVudFByb3ZpZGVycyAmIHsgybVvZHhCcmFuZDogJ0BvZHgvYW5ndWxhci9jb21wb25lbnRzL25vdGlmaWNhdGlvbjo6Tm90aWZpY2F0aW9uRmVhdHVyZScgfTtcblxuZXhwb3J0IGZ1bmN0aW9uIG1ha2VOb3RpZmljYXRpb25GZWF0dXJlKHByb3ZpZGVyOiAoUHJvdmlkZXIgfCBOb3RpZmljYXRpb25GZWF0dXJlKVtdIHwgRW52aXJvbm1lbnRQcm92aWRlcnMpOiBOb3RpZmljYXRpb25GZWF0dXJlIHtcbiAgcmV0dXJuIHByb3ZpZGVyIGFzIG5ldmVyIGFzIE5vdGlmaWNhdGlvbkZlYXR1cmU7XG59XG4iXX0=

package/esm2022/components/notification/lib/models/notification-options.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9tb2RlbHMvbm90aWZpY2F0aW9uLW9wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgTm90aWZpY2F0aW9uT3B0aW9ucyB7XG4gIGljb246IHN0cmluZztcbiAgdGFnczogc3RyaW5nW107XG4gIGRpc21pc3NhYmxlOiBib29sZWFuO1xuICBhY3Rpb24/OiBzdHJpbmc7XG4gIGxhbmd1YWdlPzogc3RyaW5nO1xufVxuIl19

package/esm2022/components/notification/lib/models/notification-query.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLXF1ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2NvbXBvbmVudHMvbm90aWZpY2F0aW9uL3NyYy9saWIvbW9kZWxzL25vdGlmaWNhdGlvbi1xdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTm90aWZpY2F0aW9uUmVmIH0gZnJvbSAnLi9ub3RpZmljYXRpb24ucmVmJztcblxuZXhwb3J0IHR5cGUgTm90aWZpY2F0aW9uUXVlcnkgPSAobm90aWZpY2F0aW9uUmVmOiBOb3RpZmljYXRpb25SZWYpID0+IGJvb2xlYW47XG4iXX0=

package/esm2022/components/notification/lib/models/notification-sort-fn.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLXNvcnQtZm4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9tb2RlbHMvbm90aWZpY2F0aW9uLXNvcnQtZm4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5vdGlmaWNhdGlvblJlZiB9IGZyb20gJy4vbm90aWZpY2F0aW9uLnJlZic7XG5cbmV4cG9ydCB0eXBlIE5vdGlmaWNhdGlvblNvcnRGbiA9IFBhcmFtZXRlcnM8QXJyYXk8Tm90aWZpY2F0aW9uUmVmPlsnc29ydCddPlswXTtcbiJdfQ==