@odx/angular 5.3.4 → 5.4.0

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":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAwC,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAC1F,OAAO,EAAuB,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAuB,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAOvF;;;;GAIG;AACH,MAAM,OAAO,gCAAgC;IAC3C;;;;;;OAMG;IACI,KAAK,CAAC,SAAS,CAAC,KAAwB;QAC7C,MAAM,uBAAuB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/C,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CACtB,SAAS,CAAC,GAAG,EAAE;YACb,IAAI,EAAE;gBACJ,KAAK,EAAE,MAAM,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC7D,WAAW,EAAE,MAAM,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC;aAC1E;SACF,CAAC,CACH,CACF,CAAC;QAEF,OAAO,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,CAAC;IACjD,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,WAAW,CAAC,KAAa;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,2BAA2B,CAAC,OAA4B;QACpE,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,CAAC;QACxB,IAAI,QAAQ,CAAC,OAAO,CAAC;YAAE,OAAO,OAAO,CAAC;QAEtC,OAAO,cAAc,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;IACjD,CAAC;CACF;AAeD;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CAAC,EAC1C,OAAO,EACP,UAAU,EACV,UAAU,EACV,aAAa,GAC6B;IAC1C,OAAO,KAAK,IAAI,EAAE;QAChB,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,WAAW;YAAE,OAAO,EAAE,CAAC;QAC5B,MAAM,gBAAgB,GAAG,MAAM,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAEnE,IAAI,UAAU,CAAC,aAAa,CAAC,EAAE;YAC7B,KAAK,MAAM,eAAe,IAAI,gBAAgB,EAAE;gBAC9C,eAAe,CAAC,IAAI,CAAC,EAAE,GAAG,eAAe,CAAC,EAAE,GAAG,aAAa,CAAC,eAAe,CAAC,CAAC;aAC/E;SACF;QAED,OAAO,gBAAgB,CAAC;IAC1B,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAA6C;IACjH,OAAO,KAAK,EAAE,gBAAmC,EAAE,EAAE;QACnD,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,UAAU,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC5E,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CAAC,OAAqD;IAC/F,MAAM,cAAc,GAA8C;QAChE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,IAAI,+CAA+C;QAClG,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,IAAI,YAAY;QACzD,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,UAAU,IAAI,IAAI,gCAAgC,EAAE;KAC1F,CAAC;IACF,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,2BAA2B,CAAC,cAAc,CAAC,CAAC;IAC9E,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,oBAAoB,CAAC,cAAc,CAAC,CAAC;IAEvE,OAAO,uBAAuB,CAAC,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AACjG,CAAC","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 = inject(Injector);
+                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==

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