@odx/angular 5.3.4 → 5.5.0

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

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

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

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

package/esm2022/components/notification/lib/notification.config.mjs

@@ -0,0 +1,11 @@
+import { makeEnvironmentProviders } from '@angular/core';
+import { createConfigTokens, orderBy } from '@odx/angular/utils';
+export const { NotificationConfig, NotificationDefaultConfig, injectNotificationConfig, provideNotificationConfig } = createConfigTokens('Notification', '@odx/angular/components/notification', {
+    options: { icon: 'core::globe', tags: [], dismissable: true },
+    sortFn: orderBy('createdAt', 'DESC'),
+    defaultIdPrefix: 'odx-notifications',
+});
+export function provideNotifications(config, ...features) {
+    return makeEnvironmentProviders([provideNotificationConfig(config ?? {}), features]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/notification/lib/notification.i18n.mjs

@@ -0,0 +1,11 @@
+export default {
+    en: {
+        title: 'Notifications',
+        dismissAll: 'Dismiss all',
+    },
+    de: {
+        title: 'Benachrichtigungen',
+        dismissAll: 'Alle entfernen',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLmkxOG4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9ub3RpZmljYXRpb24uaTE4bi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxlQUFlO0lBQ2IsRUFBRSxFQUFFO1FBQ0YsS0FBSyxFQUFFLGVBQWU7UUFDdEIsVUFBVSxFQUFFLGFBQWE7S0FDMUI7SUFDRCxFQUFFLEVBQUU7UUFDRixLQUFLLEVBQUUsb0JBQW9CO1FBQzNCLFVBQVUsRUFBRSxnQkFBZ0I7S0FDN0I7Q0FDbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRyYW5zbGF0aW9uT2JqZWN0IH0gZnJvbSAnQG9keC9hbmd1bGFyL2ludGVybmFsL3RyYW5zbGF0ZSc7XG5cbmV4cG9ydCBkZWZhdWx0IHtcbiAgZW46IHtcbiAgICB0aXRsZTogJ05vdGlmaWNhdGlvbnMnLFxuICAgIGRpc21pc3NBbGw6ICdEaXNtaXNzIGFsbCcsXG4gIH0sXG4gIGRlOiB7XG4gICAgdGl0bGU6ICdCZW5hY2hyaWNodGlndW5nZW4nLFxuICAgIGRpc21pc3NBbGw6ICdBbGxlIGVudGZlcm5lbicsXG4gIH0sXG59IGFzIFRyYW5zbGF0aW9uT2JqZWN0O1xuIl19

package/esm2022/components/notification/lib/notification.logger.mjs

@@ -0,0 +1,3 @@
+import { Logger } from '@odx/angular/internal';
+export default new Logger('@odx/angular/components/notification');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLmxvZ2dlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21wb25lbnRzL25vdGlmaWNhdGlvbi9zcmMvbGliL25vdGlmaWNhdGlvbi5sb2dnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRS9DLGVBQWUsSUFBSSxNQUFNLENBQUMsc0NBQXNDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ2dlciB9IGZyb20gJ0BvZHgvYW5ndWxhci9pbnRlcm5hbCc7XG5cbmV4cG9ydCBkZWZhdWx0IG5ldyBMb2dnZXIoJ0BvZHgvYW5ndWxhci9jb21wb25lbnRzL25vdGlmaWNhdGlvbicpO1xuIl19

package/esm2022/components/notification/lib/notification.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable, Injector, inject, runInInjectionContext } from '@angular/core';
+import { deepmerge } from '@odx/angular/internal';
+import { LocalizationService } from '@odx/angular/localization';
+import { getUniqueId, isFunction } from '@odx/angular/utils';
+import { filter, map, shareReplay } from 'rxjs';
+import { sortNotifications, toNotificationCollection } from './helpers';
+import { injectNotificationConfig } from './notification.config';
+import logger from './notification.logger';
+import { ODX_NOTIFICATION_QUEUE } from './notification.tokens';
+import * as i0 from "@angular/core";
+export class NotificationService {
+    constructor() {
+        this.config = injectNotificationConfig();
+        this.localizationService = inject(LocalizationService);
+        this.queue = inject(ODX_NOTIFICATION_QUEUE);
+        this.injector = inject(Injector);
+        this.notifications$ = this.queue.value$.pipe(sortNotifications(this.config.sortFn), toNotificationCollection(), shareReplay({ bufferSize: 1, refCount: true }));
+        this.unseenNotifications$ = this.notifications$.pipe(map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)), toNotificationCollection(), shareReplay({ bufferSize: 1, refCount: true }));
+        this.onNotificationAdd$ = this.queue.onAdd$;
+        this.onNotificationRemove$ = this.queue.onRemove$;
+        this.onNotificationUpdate$ = this.queue.onUpdate$;
+        this.onNotificationSeen$ = this.queue.onUpdate$.pipe(filter(({ hasBeenSeen }) => hasBeenSeen));
+    }
+    /**
+     * Fetches notifications filtered by a specified query and optionally sorted by a custom sort function.
+     *
+     * @param {NotificationQuery} query - A function or object to filter notifications.
+     * @param {NotificationSortFn} [sortFn] - An optional sorting function to order the filtered notifications.
+     * @returns {Observable<NotificationCollection>} An observable stream of the filtered (and optionally sorted) notification collection.
+     * @example
+     * // Fetch notifications with a specific tag, sorted by creation date
+     * const sortedNotifications$ = notificationService.getNotificationsBy$(
+     *   notification => notification.tags.includes('important'),
+     *   (a, b) => b.createdAt - a.createdAt
+     * );
+     */
+    getNotificationsBy$(query, sortFn) {
+        return this.queue.value$.pipe(map((notifications) => notifications.filter(query)), sortNotifications(sortFn), toNotificationCollection(), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    /**
+     * Loads a list of notifications into the service.
+     *
+     * @param {NotificationRef[]} refs - An array of notification references to be loaded.
+     * @example
+     * // Load multiple notifications at once
+     * notificationService.load([
+     *   { id: '1', item: { title: 'Notification 1' }, options: {dismissable: true, icon: 'plus', tags: ['important']}, hasBeenSeen: false, createdAt: Date.now() },
+     *   { id: '2', item: { title: 'Notification 2' }, options: {dismissable: true, icon: 'plus', tags: ['important']}, hasBeenSeen: false, createdAt: Date.now() }
+     * ]);
+     */
+    load(refs) {
+        this.queue.addMany(refs);
+    }
+    /**
+     * Creates a new notification and adds it to the notification queue.
+     *
+     * @param {Notification} item - The notification to create.
+     * @param {Partial<NotificationOptions>} [options] - Optional settings for the notification.
+     * @example
+     * // Create a new notification with custom options
+     * notificationService.create(
+     *   { title: 'New Notification' },
+     *   { dismissable: true, icon: 'plus', tags: ['important'] }
+     * );
+     */
+    create(item, options) {
+        this.queue.add({
+            id: item.id ?? getUniqueId(this.config.defaultIdPrefix),
+            createdAt: Date.now(),
+            item,
+            options: this.resolveOptions(options),
+            hasBeenSeen: false,
+        });
+    }
+    /**
+     * Marks a specific notification as seen.
+     *
+     * @param {NotificationRef} notificationRef - The reference to the notification to mark as seen.
+     * @example
+     * // Mark a notification as seen by its reference
+     * notificationService.markAsSeen(notificationRef);
+     */
+    markAsSeen(notificationRef) {
+        if (notificationRef.hasBeenSeen)
+            return;
+        this.queue.add({ ...notificationRef, hasBeenSeen: true });
+    }
+    /**
+     * Marks all notifications that match a specific query as seen.
+     *
+     * @param {NotificationQuery} query - The query to match notifications to mark as seen.
+     * @example
+     * // Mark all notifications with a specific tag as seen
+     * notificationService.markAsSeenBy(notification => notification.tags.includes('important'));
+     */
+    markAsSeenBy(query) {
+        for (const notificationRef of this.queue.toArray().filter(query)) {
+            this.markAsSeen(notificationRef);
+        }
+    }
+    /**
+     * Dismisses a specific notification.
+     *
+     * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.
+     * @example
+     * // Dismiss a notification by its reference
+     * notificationService.dismiss(notificationRef);
+     */
+    dismiss(notificationRef) {
+        if (!notificationRef.options.dismissable)
+            return;
+        this.queue.remove(notificationRef);
+    }
+    /**
+     * Dismisses all notifications that match a specific query.
+     *
+     * @param {NotificationQuery} query - The query to match notifications to dismiss.
+     * @example
+     * // Dismiss all notifications with a specific tag
+     * notificationService.dismissBy(notification => notification.tags.includes('expired'));
+     */
+    dismissBy(query) {
+        for (const item of this.queue.toArray().filter(query)) {
+            this.dismiss(item);
+        }
+    }
+    /**
+     * Dismisses all notifications.
+     *
+     * @example
+     * // Dismiss all notifications
+     * notificationService.dismissAll();
+     */
+    dismissAll() {
+        this.queue.clear();
+    }
+    /**
+     * Executes the action associated with a specific notification.
+     *
+     * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.
+     * @example
+     * // Execute action for a notification
+     * notificationService.executeAction(notificationRef);
+     */
+    executeAction(notificationRef) {
+        if (!notificationRef.options.action)
+            return;
+        const actionFn = this.config.actionMap?.[notificationRef.options.action];
+        if (!isFunction(actionFn)) {
+            logger.warn(`Cannot find action ${notificationRef.options.action} for notification reference: ${notificationRef}`);
+            return;
+        }
+        runInInjectionContext(this.injector, () => actionFn(notificationRef));
+    }
+    resolveOptions(options) {
+        return deepmerge(this.config.options, options ?? {}, {
+            icon: options?.icon ?? this.config.tagToIconMap?.[options?.tags?.[0] ?? ''] ?? this.config.options.icon,
+            language: options?.language ?? this.localizationService.getActiveLanguage(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/notification/src/lib/notification.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, inject, runInInjectionContext } from '@angular/core';\nimport { deepmerge } from '@odx/angular/internal';\nimport { LocalizationService } from '@odx/angular/localization';\nimport { getUniqueId, isFunction } from '@odx/angular/utils';\nimport { Observable, filter, map, shareReplay } from 'rxjs';\nimport { sortNotifications, toNotificationCollection } from './helpers';\nimport { Notification, NotificationCollection, NotificationOptions, NotificationQuery, NotificationRef, NotificationSortFn } from './models';\nimport { injectNotificationConfig } from './notification.config';\nimport logger from './notification.logger';\nimport { ODX_NOTIFICATION_QUEUE } from './notification.tokens';\n\n@Injectable({ providedIn: 'root' })\nexport class NotificationService {\n  private readonly config = injectNotificationConfig();\n  private readonly localizationService = inject(LocalizationService);\n  private readonly queue = inject(ODX_NOTIFICATION_QUEUE);\n  private readonly injector = inject(Injector);\n\n  public readonly notifications$ = this.queue.value$.pipe(\n    sortNotifications(this.config.sortFn),\n    toNotificationCollection(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly unseenNotifications$ = this.notifications$.pipe(\n    map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)),\n    toNotificationCollection(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly onNotificationAdd$ = this.queue.onAdd$;\n  public readonly onNotificationRemove$ = this.queue.onRemove$;\n  public readonly onNotificationUpdate$ = this.queue.onUpdate$;\n  public readonly onNotificationSeen$ = this.queue.onUpdate$.pipe(filter(({ hasBeenSeen }) => hasBeenSeen));\n\n  /**\n   * Fetches notifications filtered by a specified query and optionally sorted by a custom sort function.\n   *\n   * @param {NotificationQuery} query - A function or object to filter notifications.\n   * @param {NotificationSortFn} [sortFn] - An optional sorting function to order the filtered notifications.\n   * @returns {Observable<NotificationCollection>} An observable stream of the filtered (and optionally sorted) notification collection.\n   * @example\n   * // Fetch notifications with a specific tag, sorted by creation date\n   * const sortedNotifications$ = notificationService.getNotificationsBy$(\n   *   notification => notification.tags.includes('important'),\n   *   (a, b) => b.createdAt - a.createdAt\n   * );\n   */\n  public getNotificationsBy$(query: NotificationQuery, sortFn?: NotificationSortFn): Observable<NotificationCollection> {\n    return this.queue.value$.pipe(\n      map((notifications) => notifications.filter(query)),\n      sortNotifications(sortFn),\n      toNotificationCollection(),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n  }\n\n  /**\n   * Loads a list of notifications into the service.\n   *\n   * @param {NotificationRef[]} refs - An array of notification references to be loaded.\n   * @example\n   * // Load multiple notifications at once\n   * notificationService.load([\n   *   { id: '1', item: { title: 'Notification 1' }, options: {dismissable: true, icon: 'plus', tags: ['important']}, hasBeenSeen: false, createdAt: Date.now() },\n   *   { id: '2', item: { title: 'Notification 2' }, options: {dismissable: true, icon: 'plus', tags: ['important']}, hasBeenSeen: false, createdAt: Date.now() }\n   * ]);\n   */\n  public load(refs: NotificationRef[]): void {\n    this.queue.addMany(refs);\n  }\n\n  /**\n   * Creates a new notification and adds it to the notification queue.\n   *\n   * @param {Notification} item - The notification to create.\n   * @param {Partial<NotificationOptions>} [options] - Optional settings for the notification.\n   * @example\n   * // Create a new notification with custom options\n   * notificationService.create(\n   *   { title: 'New Notification' },\n   *   { dismissable: true, icon: 'plus', tags: ['important'] }\n   * );\n   */\n  public create(item: Notification, options?: Partial<NotificationOptions>): void {\n    this.queue.add({\n      id: item.id ?? getUniqueId(this.config.defaultIdPrefix),\n      createdAt: Date.now(),\n      item,\n      options: this.resolveOptions(options),\n      hasBeenSeen: false,\n    });\n  }\n\n  /**\n   * Marks a specific notification as seen.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to mark as seen.\n   * @example\n   * // Mark a notification as seen by its reference\n   * notificationService.markAsSeen(notificationRef);\n   */\n  public markAsSeen(notificationRef: NotificationRef): void {\n    if (notificationRef.hasBeenSeen) return;\n    this.queue.add({ ...notificationRef, hasBeenSeen: true });\n  }\n\n  /**\n   * Marks all notifications that match a specific query as seen.\n   *\n   * @param {NotificationQuery} query - The query to match notifications to mark as seen.\n   * @example\n   * // Mark all notifications with a specific tag as seen\n   * notificationService.markAsSeenBy(notification => notification.tags.includes('important'));\n   */\n  public markAsSeenBy(query: NotificationQuery): void {\n    for (const notificationRef of this.queue.toArray().filter(query)) {\n      this.markAsSeen(notificationRef);\n    }\n  }\n\n  /**\n   * Dismisses a specific notification.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.\n   * @example\n   * // Dismiss a notification by its reference\n   * notificationService.dismiss(notificationRef);\n   */\n  public dismiss(notificationRef: NotificationRef): void {\n    if (!notificationRef.options.dismissable) return;\n    this.queue.remove(notificationRef);\n  }\n\n  /**\n   * Dismisses all notifications that match a specific query.\n   *\n   * @param {NotificationQuery} query - The query to match notifications to dismiss.\n   * @example\n   * // Dismiss all notifications with a specific tag\n   * notificationService.dismissBy(notification => notification.tags.includes('expired'));\n   */\n  public dismissBy(query: NotificationQuery): void {\n    for (const item of this.queue.toArray().filter(query)) {\n      this.dismiss(item);\n    }\n  }\n\n  /**\n   * Dismisses all notifications.\n   *\n   * @example\n   * // Dismiss all notifications\n   * notificationService.dismissAll();\n   */\n  public dismissAll(): void {\n    this.queue.clear();\n  }\n\n  /**\n   * Executes the action associated with a specific notification.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.\n   * @example\n   * // Execute action for a notification\n   * notificationService.executeAction(notificationRef);\n   */\n  public executeAction(notificationRef: NotificationRef): void {\n    if (!notificationRef.options.action) return;\n    const actionFn = this.config.actionMap?.[notificationRef.options.action];\n    if (!isFunction(actionFn)) {\n      logger.warn(`Cannot find action ${notificationRef.options.action} for notification reference: ${notificationRef}`);\n      return;\n    }\n    runInInjectionContext(this.injector, () => actionFn(notificationRef));\n  }\n\n  private resolveOptions(options?: Partial<NotificationOptions>): NotificationOptions {\n    return deepmerge(this.config.options, options ?? {}, {\n      icon: options?.icon ?? this.config.tagToIconMap?.[options?.tags?.[0] ?? ''] ?? this.config.options.icon,\n      language: options?.language ?? this.localizationService.getActiveLanguage(),\n    }) as NotificationOptions;\n  }\n}\n"]}

package/esm2022/components/notification/lib/notification.tokens.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { Queue } from '@odx/angular/utils';
+export const ODX_NOTIFICATION_QUEUE = new InjectionToken('@odx/angular/component/notifications::Queue', {
+    providedIn: 'root',
+    factory: () => new Queue(),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLnRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21wb25lbnRzL25vdGlmaWNhdGlvbi9zcmMvbGliL25vdGlmaWNhdGlvbi50b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMvQyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHM0MsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsSUFBSSxjQUFjLENBQXlCLDZDQUE2QyxFQUFFO0lBQzlILFVBQVUsRUFBRSxNQUFNO0lBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLEtBQUssRUFBRTtDQUMzQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUXVldWUgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuaW1wb3J0IHsgTm90aWZpY2F0aW9uUmVmIH0gZnJvbSAnLi9tb2RlbHMnO1xuXG5leHBvcnQgY29uc3QgT0RYX05PVElGSUNBVElPTl9RVUVVRSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxRdWV1ZTxOb3RpZmljYXRpb25SZWY+PignQG9keC9hbmd1bGFyL2NvbXBvbmVudC9ub3RpZmljYXRpb25zOjpRdWV1ZScsIHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxuICBmYWN0b3J5OiAoKSA9PiBuZXcgUXVldWUoKSxcbn0pO1xuIl19

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

@@ -0,0 +1,2 @@
+export * from './notification-center.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ub3RpZmljYXRpb24tY2VudGVyLnNlcnZpY2UnO1xuIl19

package/esm2022/components/notification/lib/services/notification-center.service.mjs

@@ -0,0 +1,96 @@
+import { Injectable, computed, inject, signal } from '@angular/core';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { combineLatest, filter, isObservable, map, of, shareReplay, switchMap } from 'rxjs';
+import { getNotificationsByTags, toNotificationCollection } from '../helpers';
+import { NotificationService } from '../notification.service';
+import * as i0 from "@angular/core";
+/**
+ * A service for managing the notification center. This service provides functionalities
+ * to filter, sort, and manage actions on notifications.
+ */
+export class NotificationCenterService {
+    constructor() {
+        this.currentTag = signal(null);
+        this.currentSortFn = signal(undefined);
+        this.notificationService = inject(NotificationService);
+        this.notificationQuery = computed(() => getNotificationsByTags(this.currentTag()));
+        this.title = signal(null);
+        this.title$ = toObservable(this.title).pipe(switchMap((title) => (isObservable(title) ? title : of(title))), shareReplay({ bufferSize: 1, refCount: true }));
+        this.notifications$ = combineLatest([toObservable(this.notificationQuery), toObservable(this.currentSortFn)]).pipe(switchMap(([query, sortFn]) => this.notificationService.getNotificationsBy$(query, sortFn)));
+        this.unseenNotifications$ = this.notifications$.pipe(map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)), toNotificationCollection());
+        this.onNotificationAdd$ = this.queryEvent(this.notificationService.onNotificationAdd$);
+        this.onNotificationUpdate$ = this.queryEvent(this.notificationService.onNotificationUpdate$);
+        this.onNotificationRemove$ = this.queryEvent(this.notificationService.onNotificationRemove$);
+        this.onNotificationSeen$ = this.queryEvent(this.notificationService.onNotificationSeen$);
+    }
+    /**
+     * Sets the title for the notification center. The title can be static text or an observable for dynamic content.
+     *
+     * @param {DynamicTextContent | null} [value] - The title content for the notification center.
+     */
+    setTitle(value) {
+        this.title.set(value ?? null);
+    }
+    /**
+     * Sets the current tag to filter notifications. Only notifications with this tag will be included.
+     *
+     * @param {string | null} [value] - The tag to filter notifications by.
+     */
+    setTag(value) {
+        this.currentTag.set(value ?? null);
+    }
+    /**
+     * Sets the sort function used to order the notifications.
+     *
+     * @param {NotificationSortFn} [value] - The sort function to apply to the notifications.
+     */
+    setSortFn(value) {
+        this.currentSortFn.set(value);
+    }
+    /**
+     * Marks a given notification as seen. This does not remove the notification but updates its seen status.
+     *
+     * @param {NotificationRef} notificationRef - The reference to the notification to be marked as seen.
+     */
+    markAsSeen(notificationRef) {
+        this.notificationService.markAsSeen(notificationRef);
+    }
+    /**
+     * Marks all current filtered notifications as seen.
+     */
+    markAllAsSeen() {
+        this.notificationService.markAsSeenBy(this.notificationQuery());
+    }
+    /**
+     * Dismisses a specific notification.
+     *
+     * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.
+     */
+    dismiss(notificationRef) {
+        this.notificationService.dismiss(notificationRef);
+    }
+    /**
+     * Dismisses all notifications that match the current filter criteria.
+     */
+    dismissAll() {
+        this.notificationService.dismissBy(this.notificationQuery());
+    }
+    /**
+     * Executes the action associated with a specific notification and marks it as seen.
+     *
+     * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.
+     */
+    executeAction(notificationRef) {
+        this.markAsSeen(notificationRef);
+        this.notificationService.executeAction(notificationRef);
+    }
+    queryEvent(source$) {
+        return combineLatest([source$, toObservable(this.notificationQuery)]).pipe(filter(([notificationRef, query]) => query(notificationRef)), map(([notificationRef]) => notificationRef));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationCenterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationCenterService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NotificationCenterService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-center.service.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/components/notification/src/lib/services/notification-center.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, computed, inject, signal } from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';\nimport { Observable, combineLatest, filter, isObservable, map, of, shareReplay, switchMap } from 'rxjs';\nimport { getNotificationsByTags, toNotificationCollection } from '../helpers';\nimport { NotificationRef, NotificationSortFn } from '../models';\nimport { NotificationService } from '../notification.service';\n\n/**\n * A service for managing the notification center. This service provides functionalities\n * to filter, sort, and manage actions on notifications.\n */\n@Injectable()\nexport class NotificationCenterService {\n  private readonly currentTag = signal<string | null>(null);\n  private readonly currentSortFn = signal<NotificationSortFn>(undefined);\n  private readonly notificationService = inject(NotificationService);\n  private readonly notificationQuery = computed(() => getNotificationsByTags(this.currentTag()));\n  private readonly title = signal<DynamicTextContent | null>(null);\n\n  public readonly title$ = toObservable(this.title).pipe(\n    switchMap((title) => (isObservable(title) ? title : of(title))),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly notifications$ = combineLatest([toObservable(this.notificationQuery), toObservable(this.currentSortFn)]).pipe(\n    switchMap(([query, sortFn]) => this.notificationService.getNotificationsBy$(query, sortFn)),\n  );\n  public readonly unseenNotifications$ = this.notifications$.pipe(\n    map((collection) => collection.values.filter(({ hasBeenSeen }) => !hasBeenSeen)),\n    toNotificationCollection(),\n  );\n  public onNotificationAdd$ = this.queryEvent(this.notificationService.onNotificationAdd$);\n  public onNotificationUpdate$ = this.queryEvent(this.notificationService.onNotificationUpdate$);\n  public onNotificationRemove$ = this.queryEvent(this.notificationService.onNotificationRemove$);\n  public onNotificationSeen$ = this.queryEvent(this.notificationService.onNotificationSeen$);\n\n  /**\n   * Sets the title for the notification center. The title can be static text or an observable for dynamic content.\n   *\n   * @param {DynamicTextContent | null} [value] - The title content for the notification center.\n   */\n  public setTitle(value?: DynamicTextContent | null): void {\n    this.title.set(value ?? null);\n  }\n\n  /**\n   * Sets the current tag to filter notifications. Only notifications with this tag will be included.\n   *\n   * @param {string | null} [value] - The tag to filter notifications by.\n   */\n  public setTag(value?: string | null): void {\n    this.currentTag.set(value ?? null);\n  }\n\n  /**\n   * Sets the sort function used to order the notifications.\n   *\n   * @param {NotificationSortFn} [value] - The sort function to apply to the notifications.\n   */\n  public setSortFn(value?: NotificationSortFn): void {\n    this.currentSortFn.set(value);\n  }\n\n  /**\n   * Marks a given notification as seen. This does not remove the notification but updates its seen status.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to be marked as seen.\n   */\n  public markAsSeen(notificationRef: NotificationRef): void {\n    this.notificationService.markAsSeen(notificationRef);\n  }\n\n  /**\n   * Marks all current filtered notifications as seen.\n   */\n  public markAllAsSeen(): void {\n    this.notificationService.markAsSeenBy(this.notificationQuery());\n  }\n\n  /**\n   * Dismisses a specific notification.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification to dismiss.\n   */\n  public dismiss(notificationRef: NotificationRef): void {\n    this.notificationService.dismiss(notificationRef);\n  }\n\n  /**\n   * Dismisses all notifications that match the current filter criteria.\n   */\n  public dismissAll(): void {\n    this.notificationService.dismissBy(this.notificationQuery());\n  }\n\n  /**\n   * Executes the action associated with a specific notification and marks it as seen.\n   *\n   * @param {NotificationRef} notificationRef - The reference to the notification whose action to execute.\n   */\n  public executeAction(notificationRef: NotificationRef): void {\n    this.markAsSeen(notificationRef);\n    this.notificationService.executeAction(notificationRef);\n  }\n\n  private queryEvent(source$: Observable<NotificationRef>): Observable<NotificationRef> {\n    return combineLatest([source$, toObservable(this.notificationQuery)]).pipe(\n      filter(([notificationRef, query]) => query(notificationRef)),\n      map(([notificationRef]) => notificationRef),\n    );\n  }\n}\n"]}

package/esm2022/components/notification/odx-angular-components-notification.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2R4LWFuZ3VsYXItY29tcG9uZW50cy1ub3RpZmljYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vc3JjL29keC1hbmd1bGFyLWNvbXBvbmVudHMtbm90aWZpY2F0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/components/notification/testing/index.mjs

@@ -0,0 +1,2 @@
+export * from './lib/test-helpers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy9ub3RpZmljYXRpb24vdGVzdGluZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3Rlc3QtaGVscGVycyc7XG4iXX0=

package/esm2022/components/notification/testing/lib/test-helpers.mjs

@@ -0,0 +1,33 @@
+export function mockNotification(props) {
+    return {
+        title: 'TEST_NOTIFICATION_TITLE',
+        description: 'TEST_NOTIFICATION_DESCRIPTION',
+        ...props,
+    };
+}
+export function mockNotificationOptions(props) {
+    return {
+        dismissable: false,
+        icon: 'TEST_NOTIFICATION_ICON',
+        tags: ['TEST_NOTIFICATION_TAG'],
+        ...props,
+    };
+}
+export function mockNotificationRef(props) {
+    return {
+        id: 'TEST_NOTIFICATION',
+        createdAt: Date.now(),
+        hasBeenSeen: false,
+        item: mockNotification(props?.item),
+        options: mockNotificationOptions(props?.options),
+        ...props,
+    };
+}
+export function mockNotificationCollection(refs) {
+    return {
+        values: refs,
+        count: refs.length,
+        isEmpty: refs.length === 0,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/notification/testing/odx-angular-components-notification-testing.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2R4LWFuZ3VsYXItY29tcG9uZW50cy1ub3RpZmljYXRpb24tdGVzdGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21wb25lbnRzL25vdGlmaWNhdGlvbi90ZXN0aW5nL3NyYy9vZHgtYW5ndWxhci1jb21wb25lbnRzLW5vdGlmaWNhdGlvbi10ZXN0aW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/components/toast/lib/components/toast-container/toast-container.component.mjs

@@ -2,7 +2,7 @@ var ToastContainerComponent_1;
 import { __decorate } from "tslib";
 import { group, transition, trigger, useAnimation } from '@angular/animations';
 import { CommonModule } from '@angular/common';
-import { ChangeDetectionStrategy, Component, inject, Input, numberAttribute, Output, Renderer2, ViewEncapsulation, } from '@angular/core';
+import { ChangeDetectionStrategy, Component, Input, Output, Renderer2, ViewEncapsulation, inject, numberAttribute, } from '@angular/core';
 import { WindowRef } from '@odx/angular';
 import { collapse, expand, fadeIn, slideInRight } from '@odx/angular/animations';
 import { ChipComponent } from '@odx/angular/components/chip';
@@ -22,10 +22,10 @@ export let ToastContainerComponent = class ToastContainerComponent {
         this.toastService = inject(ToastService);
         this.trackById = trackById;
         this.element = injectElement();
-        this.items$ = this.toastService.queue$.pipe(map((refs) => refs.slice(0, this.maxItems)));
-        this.hiddenToasts$ = this.toastService.queue$.pipe(map((refs) => Math.max(0, refs.length - this.maxItems)));
+        this.items$ = this.toastService.toasts$.pipe(map((refs) => refs.slice(0, this.maxItems)));
+        this.hiddenToasts$ = this.toastService.toasts$.pipe(map((refs) => Math.max(0, refs.length - this.maxItems)));
         this.maxItems = 3;
-        this.dismiss = this.toastService.onRemove$;
+        this.dismiss = this.toastService.onToastRemove$;
     }
     static { ToastContainerComponent_1 = this; }
     static { this.INITIALIZED = false; }
@@ -43,7 +43,7 @@ export let ToastContainerComponent = class ToastContainerComponent {
         ToastContainerComponent_1.INITIALIZED = false;
     }
     onDismiss(itemRef) {
-        this.toastService.remove(itemRef);
+        this.toastService.dismiss(itemRef);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToastContainerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "16.2.12", type: ToastContainerComponent, isStandalone: true, selector: "odx-toast-container", inputs: { maxItems: ["maxItems", "maxItems", numberAttribute] }, outputs: { dismiss: "dismiss" }, ngImport: i0, template: "<odx-toast\n  @slide\n  [id]=\"toastRef.id\"\n  [title]=\"toastRef.item.title\"\n  [description]=\"toastRef.item.description\"\n  [actions]=\"toastRef.item.actions ?? []\"\n  [variant]=\"toastRef.item.variant\"\n  [options]=\"toastRef.options\"\n  (dismiss)=\"onDismiss(toastRef)\"\n  *ngFor=\"let toastRef of items$ | async; trackBy: trackById\"\n></odx-toast>\n<odx-chip class=\"odx-toast-container__counter\" *ngIf=\"hiddenToasts$ | async as more\">{{ more }} more Notifications</odx-chip>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "component", type: ChipComponent, selector: "odx-chip", inputs: ["removable", "size", "variant"], outputs: ["remove"] }, { kind: "component", type: ToastItemComponent, selector: "odx-toast", inputs: ["id", "title", "description", "variant", "actions", "options"], outputs: ["dismiss"] }], animations: [
@@ -78,4 +78,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             }], dismiss: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast-container.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular/components/toast/src/lib/components/toast-container/toast-container.component.ts","../../../../../../../../../libs/angular/components/toast/src/lib/components/toast-container/toast-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import { group, transition, trigger, useAnimation } from '@angular/animations';\nimport { CommonModule } from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  inject,\n  Input,\n  numberAttribute,\n  OnDestroy,\n  Output,\n  Renderer2,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { WindowRef } from '@odx/angular';\nimport { collapse, expand, fadeIn, slideInRight } from '@odx/angular/animations';\nimport { ChipComponent } from '@odx/angular/components/chip';\nimport { HeaderComponent } from '@odx/angular/components/header';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { injectElement, px, trackById } from '@odx/angular/utils';\nimport { map, Observable } from 'rxjs';\nimport { ToastRef } from '../../models';\nimport { ToastService } from '../../toast.service';\nimport { ToastItemComponent } from '../toast-item/toast-item.component';\n\nconst TOAST_ANIMATION_DELAY = '125ms';\n@CSSComponent('toast-container')\n@Component({\n  selector: 'odx-toast-container',\n  templateUrl: './toast-container.component.html',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  imports: [CommonModule, ChipComponent, ToastItemComponent],\n  animations: [\n    trigger('slide', [\n      transition(\n        ':enter',\n        group([\n          useAnimation(expand),\n          useAnimation(fadeIn(), { params: { delay: TOAST_ANIMATION_DELAY } }),\n          useAnimation(slideInRight, { params: { delay: TOAST_ANIMATION_DELAY } }),\n        ]),\n      ),\n      transition(':leave', group([useAnimation(collapse)])),\n    ]),\n  ],\n})\nexport class ToastContainerComponent implements AfterViewInit, OnDestroy {\n  private static INITIALIZED = false;\n\n  private readonly windowRef = inject(WindowRef);\n  private readonly renderer = inject(Renderer2);\n  private readonly toastService = inject(ToastService);\n\n  protected readonly trackById = trackById;\n\n  public readonly element = injectElement();\n  public readonly items$: Observable<ToastRef[]> = this.toastService.queue$.pipe(map((refs) => refs.slice(0, this.maxItems)));\n  public readonly hiddenToasts$: Observable<number> = this.toastService.queue$.pipe(map((refs) => Math.max(0, refs.length - this.maxItems)));\n\n  @Input({ transform: numberAttribute })\n  public maxItems = 3;\n\n  @Output()\n  public readonly dismiss = this.toastService.onRemove$;\n\n  public ngAfterViewInit(): void {\n    if (ToastContainerComponent.INITIALIZED) {\n      throw new Error('Only one toast container per application allowed');\n    }\n    ToastContainerComponent.INITIALIZED = true;\n    const headerElement = this.windowRef.queryByComponent(HeaderComponent);\n    if (headerElement) {\n      this.renderer.setStyle(this.element.nativeElement, 'top', px(headerElement.offsetHeight));\n    }\n  }\n\n  public ngOnDestroy(): void {\n    ToastContainerComponent.INITIALIZED = false;\n  }\n\n  protected onDismiss(itemRef: ToastRef): void {\n    this.toastService.remove(itemRef);\n  }\n}\n","<odx-toast\n  @slide\n  [id]=\"toastRef.id\"\n  [title]=\"toastRef.item.title\"\n  [description]=\"toastRef.item.description\"\n  [actions]=\"toastRef.item.actions ?? []\"\n  [variant]=\"toastRef.item.variant\"\n  [options]=\"toastRef.options\"\n  (dismiss)=\"onDismiss(toastRef)\"\n  *ngFor=\"let toastRef of items$ | async; trackBy: trackById\"\n></odx-toast>\n<odx-chip class=\"odx-toast-container__counter\" *ngIf=\"hiddenToasts$ | async as more\">{{ more }} more Notifications</odx-chip>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast-container.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/angular/components/toast/src/lib/components/toast-container/toast-container.component.ts","../../../../../../../../../libs/angular/components/toast/src/lib/components/toast-container/toast-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import { group, transition, trigger, useAnimation } from '@angular/animations';\nimport { CommonModule } from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  Input,\n  OnDestroy,\n  Output,\n  Renderer2,\n  ViewEncapsulation,\n  inject,\n  numberAttribute,\n} from '@angular/core';\nimport { WindowRef } from '@odx/angular';\nimport { collapse, expand, fadeIn, slideInRight } from '@odx/angular/animations';\nimport { ChipComponent } from '@odx/angular/components/chip';\nimport { HeaderComponent } from '@odx/angular/components/header';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { injectElement, px, trackById } from '@odx/angular/utils';\nimport { Observable, map } from 'rxjs';\nimport { ToastRef } from '../../models';\nimport { ToastService } from '../../toast.service';\nimport { ToastItemComponent } from '../toast-item/toast-item.component';\n\nconst TOAST_ANIMATION_DELAY = '125ms';\n@CSSComponent('toast-container')\n@Component({\n  selector: 'odx-toast-container',\n  templateUrl: './toast-container.component.html',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  imports: [CommonModule, ChipComponent, ToastItemComponent],\n  animations: [\n    trigger('slide', [\n      transition(\n        ':enter',\n        group([\n          useAnimation(expand),\n          useAnimation(fadeIn(), { params: { delay: TOAST_ANIMATION_DELAY } }),\n          useAnimation(slideInRight, { params: { delay: TOAST_ANIMATION_DELAY } }),\n        ]),\n      ),\n      transition(':leave', group([useAnimation(collapse)])),\n    ]),\n  ],\n})\nexport class ToastContainerComponent implements AfterViewInit, OnDestroy {\n  private static INITIALIZED = false;\n\n  private readonly windowRef = inject(WindowRef);\n  private readonly renderer = inject(Renderer2);\n  private readonly toastService = inject(ToastService);\n\n  protected readonly trackById = trackById;\n\n  public readonly element = injectElement();\n  public readonly items$: Observable<ToastRef[]> = this.toastService.toasts$.pipe(map((refs) => refs.slice(0, this.maxItems)));\n  public readonly hiddenToasts$: Observable<number> = this.toastService.toasts$.pipe(map((refs) => Math.max(0, refs.length - this.maxItems)));\n\n  @Input({ transform: numberAttribute })\n  public maxItems = 3;\n\n  @Output()\n  public readonly dismiss = this.toastService.onToastRemove$;\n\n  public ngAfterViewInit(): void {\n    if (ToastContainerComponent.INITIALIZED) {\n      throw new Error('Only one toast container per application allowed');\n    }\n    ToastContainerComponent.INITIALIZED = true;\n    const headerElement = this.windowRef.queryByComponent(HeaderComponent);\n    if (headerElement) {\n      this.renderer.setStyle(this.element.nativeElement, 'top', px(headerElement.offsetHeight));\n    }\n  }\n\n  public ngOnDestroy(): void {\n    ToastContainerComponent.INITIALIZED = false;\n  }\n\n  protected onDismiss(itemRef: ToastRef): void {\n    this.toastService.dismiss(itemRef);\n  }\n}\n","<odx-toast\n  @slide\n  [id]=\"toastRef.id\"\n  [title]=\"toastRef.item.title\"\n  [description]=\"toastRef.item.description\"\n  [actions]=\"toastRef.item.actions ?? []\"\n  [variant]=\"toastRef.item.variant\"\n  [options]=\"toastRef.options\"\n  (dismiss)=\"onDismiss(toastRef)\"\n  *ngFor=\"let toastRef of items$ | async; trackBy: trackById\"\n></odx-toast>\n<odx-chip class=\"odx-toast-container__counter\" *ngIf=\"hiddenToasts$ | async as more\">{{ more }} more Notifications</odx-chip>\n"]}

package/esm2022/components/toast/lib/toast.service.mjs

@@ -1,29 +1,59 @@
 import { Injectable } from '@angular/core';
 import { deepmerge } from '@odx/angular/internal';
 import { getUniqueId, Queue } from '@odx/angular/utils';
-import { share, Subject } from 'rxjs';
 import { injectToastConfig } from './toast.config';
 import * as i0 from "@angular/core";
 export class ToastService {
     constructor() {
         this.queue = new Queue();
-        this.onRemove$$ = new Subject();
         this.defaultOptions = injectToastConfig();
-        this.queue$ = this.queue.value$;
-        this.onRemove$ = this.onRemove$$.pipe(share());
+        this.toasts$ = this.queue.value$;
+        this.onUpdate$ = this.queue.onUpdate$;
+        this.onToastAdd$ = this.queue.onAdd$;
+        this.onToastUpdate$ = this.queue.onUpdate$;
+        this.onToastRemove$ = this.queue.onRemove$;
+        /**
+         * @deprecated Use `toasts$` instead
+         */
+        this.queue$ = this.toasts$;
+        /**
+         * @deprecated Use `onToastAdd$` instead
+         */
+        this.onAdd$ = this.onToastAdd$;
+        /**
+         * @deprecated Use `onToastRemove$` instead
+         */
+        this.onRemove$ = this.onToastRemove$;
     }
+    /**
+     * @deprecated Use `create` instead
+     */
     add(item, options = {}) {
+        return this.create(item, options);
+    }
+    create(item, options = {}) {
         return this.queue.add({
             id: item.id ?? getUniqueId('odx-toast'),
             item,
             options: deepmerge(this.defaultOptions, options),
         });
     }
-    remove(itemRef) {
-        this.queue.remove(itemRef);
-        this.onRemove$$.next(itemRef);
+    /**
+     * @deprecated Use `dismiss` instead
+     */
+    remove(refOrId) {
+        return this.dismiss(refOrId);
+    }
+    dismiss(refOrId) {
+        return this.queue.remove(refOrId);
     }
+    /**
+     * @deprecated Use `dismissAll` instead
+     */
     clear() {
+        return this.dismissAll();
+    }
+    dismissAll() {
         this.queue.clear();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -35,4 +65,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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