@hamak/notification 0.5.1

package/dist/impl/core/notification-service.js

@@ -0,0 +1,269 @@
+import { generateNotificationId } from '../utils/id-generator';
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    maxNotifications: 50,
+    defaultDuration: 5000,
+    position: 'top-right',
+    enableSound: false,
+    enablePersistence: false,
+};
+/**
+ * Core implementation of the notification service
+ */
+export class NotificationService {
+    constructor(config, logger) {
+        Object.defineProperty(this, "notifications", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.config = {
+            ...DEFAULT_CONFIG,
+            persistenceKey: 'hamak:notifications',
+            ...config,
+        };
+        this.logger = logger;
+        // Load persisted notifications if enabled
+        if (this.config.enablePersistence) {
+            this.loadFromStorage();
+        }
+        this.logger.debug('NotificationService initialized', {
+            config: this.config,
+        });
+    }
+    /**
+     * Create a notification with full control
+     */
+    notify(notification) {
+        const id = generateNotificationId();
+        const timestamp = Date.now();
+        const fullNotification = {
+            id,
+            timestamp,
+            duration: notification.duration ?? this.config.defaultDuration,
+            ...notification,
+        };
+        // Add to notifications list
+        this.notifications.unshift(fullNotification);
+        // Enforce max notifications limit
+        if (this.notifications.length > this.config.maxNotifications) {
+            const removed = this.notifications.splice(this.config.maxNotifications);
+            removed.forEach((n) => this.clearTimer(n.id));
+        }
+        // Setup auto-dismiss timer if duration is set
+        if (fullNotification.duration && fullNotification.duration > 0) {
+            this.setupAutoDismiss(id, fullNotification.duration);
+        }
+        // Persist if enabled
+        if (this.config.enablePersistence) {
+            this.saveToStorage();
+        }
+        // Notify listeners
+        this.notifyListeners();
+        this.logger.debug('Notification created', {
+            id,
+            type: fullNotification.type,
+            title: fullNotification.title,
+            source: fullNotification.source,
+        });
+        return id;
+    }
+    /**
+     * Create an info notification
+     */
+    info(message, title = 'Info', options) {
+        return this.notify({
+            type: 'info',
+            title,
+            message,
+            ...options,
+        });
+    }
+    /**
+     * Create a success notification
+     */
+    success(message, title = 'Success', options) {
+        return this.notify({
+            type: 'success',
+            title,
+            message,
+            ...options,
+        });
+    }
+    /**
+     * Create a warning notification
+     */
+    warning(message, title = 'Warning', options) {
+        return this.notify({
+            type: 'warning',
+            title,
+            message,
+            ...options,
+        });
+    }
+    /**
+     * Create an error notification
+     */
+    error(message, title = 'Error', options) {
+        return this.notify({
+            type: 'error',
+            title,
+            message,
+            duration: 0, // Errors don't auto-dismiss by default
+            ...options,
+        });
+    }
+    /**
+     * Dismiss a specific notification
+     */
+    dismiss(id) {
+        const index = this.notifications.findIndex((n) => n.id === id);
+        if (index !== -1) {
+            this.notifications.splice(index, 1);
+            this.clearTimer(id);
+            if (this.config.enablePersistence) {
+                this.saveToStorage();
+            }
+            this.notifyListeners();
+            this.logger.debug('Notification dismissed', { id });
+        }
+    }
+    /**
+     * Dismiss all notifications
+     */
+    dismissAll() {
+        const count = this.notifications.length;
+        this.notifications = [];
+        // Clear all timers
+        this.timers.forEach((timer) => clearTimeout(timer));
+        this.timers.clear();
+        if (this.config.enablePersistence) {
+            this.saveToStorage();
+        }
+        this.notifyListeners();
+        this.logger.debug('All notifications dismissed', { count });
+    }
+    /**
+     * Get all current notifications
+     */
+    getAll() {
+        return [...this.notifications];
+    }
+    /**
+     * Subscribe to notification changes
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        this.logger.debug('Listener subscribed', { listenerCount: this.listeners.size });
+        // Return unsubscribe function
+        return () => {
+            this.listeners.delete(listener);
+            this.logger.debug('Listener unsubscribed', { listenerCount: this.listeners.size });
+        };
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        this.timers.forEach((timer) => clearTimeout(timer));
+        this.timers.clear();
+        this.listeners.clear();
+        this.notifications = [];
+        this.logger.debug('NotificationService destroyed');
+    }
+    /**
+     * Setup auto-dismiss timer for a notification
+     */
+    setupAutoDismiss(id, duration) {
+        const timer = setTimeout(() => {
+            this.dismiss(id);
+        }, duration);
+        this.timers.set(id, timer);
+    }
+    /**
+     * Clear timer for a notification
+     */
+    clearTimer(id) {
+        const timer = this.timers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.timers.delete(id);
+        }
+    }
+    /**
+     * Notify all listeners of changes
+     */
+    notifyListeners() {
+        const notifications = this.getAll();
+        this.listeners.forEach((listener) => {
+            try {
+                listener(notifications);
+            }
+            catch (error) {
+                this.logger.error('Error in notification listener', error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    /**
+     * Save notifications to localStorage
+     */
+    saveToStorage() {
+        if (typeof localStorage === 'undefined')
+            return;
+        try {
+            localStorage.setItem(this.config.persistenceKey, JSON.stringify(this.notifications));
+        }
+        catch (error) {
+            this.logger.warn('Failed to persist notifications', { message: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * Load notifications from localStorage
+     */
+    loadFromStorage() {
+        if (typeof localStorage === 'undefined')
+            return;
+        try {
+            const stored = localStorage.getItem(this.config.persistenceKey);
+            if (stored) {
+                const notifications = JSON.parse(stored);
+                // Only restore recent notifications (within last hour)
+                const oneHourAgo = Date.now() - 60 * 60 * 1000;
+                this.notifications = notifications.filter((n) => n.timestamp > oneHourAgo);
+                this.logger.debug('Notifications loaded from storage', {
+                    count: this.notifications.length,
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to load persisted notifications', { message: error instanceof Error ? error.message : String(error) });
+        }
+    }
+}

package/dist/impl/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @hamak/notification (impl)
+ *
+ * Core implementation of the notification system.
+ * Provides NotificationService, plugin factory, and Redux integration.
+ *
+ * @packageDocumentation
+ */
+export * from './core/index';
+export * from './plugin/index';
+export * from './store/index';
+export * from './utils/index';
+export type { INotification, INotificationService, NotificationType, NotificationOptions, NotificationListener, } from '../api/index';
+export { NOTIFICATION_SERVICE_TOKEN } from '../api/index';
+export type { NotificationPluginConfig, NotificationPosition, NotificationPluginModule, NotificationEvents, } from '../spi/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,cAAc,CAAC;AAG7B,cAAc,gBAAgB,CAAC;AAG/B,cAAc,eAAe,CAAC;AAG9B,cAAc,eAAe,CAAC;AAG9B,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAG1D,YAAY,EACV,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,kBAAkB,GACnB,MAAM,cAAc,CAAC"}

package/dist/impl/index.js

@@ -0,0 +1,17 @@
+/**
+ * @hamak/notification (impl)
+ *
+ * Core implementation of the notification system.
+ * Provides NotificationService, plugin factory, and Redux integration.
+ *
+ * @packageDocumentation
+ */
+// Export core implementation
+export * from './core/index';
+// Export plugin factory
+export * from './plugin/index';
+// Export store integration
+export * from './store/index';
+// Export utilities
+export * from './utils/index';
+export { NOTIFICATION_SERVICE_TOKEN } from '../api/index';

package/dist/impl/plugin/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Plugin factory for notification system
+ */
+export { createNotificationPlugin } from './notification-plugin-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/impl/plugin/index.js

@@ -0,0 +1,4 @@
+/**
+ * Plugin factory for notification system
+ */
+export { createNotificationPlugin } from './notification-plugin-factory';

package/dist/impl/plugin/notification-plugin-factory.d.ts

@@ -0,0 +1,26 @@
+import type { PluginModule } from '@hamak/microkernel-spi';
+import type { NotificationPluginConfig } from '../../spi/index';
+/**
+ * Create a notification plugin for the microkernel
+ *
+ * @param config - Configuration options for the notification plugin
+ * @returns A plugin module ready to be registered with the host
+ *
+ * @example
+ * ```typescript
+ * import { createNotificationPlugin } from '@hamak/notification-impl';
+ *
+ * const notificationPlugin = createNotificationPlugin({
+ *   maxNotifications: 100,
+ *   defaultDuration: 3000,
+ *   position: 'top-right',
+ *   enablePersistence: true
+ * });
+ *
+ * const host = new Host();
+ * host.registerPlugin('notification', manifest, notificationPlugin);
+ * await host.bootstrapAllAtRoot();
+ * ```
+ */
+export declare function createNotificationPlugin(config?: NotificationPluginConfig): PluginModule;
+//# sourceMappingURL=notification-plugin-factory.d.ts.map

package/dist/impl/plugin/notification-plugin-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-plugin-factory.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/notification-plugin-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,wBAAwB,CAAC;AAIlF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAMhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,GAAE,wBAA6B,GACpC,YAAY,CAiHd"}

package/dist/impl/plugin/notification-plugin-factory.js

@@ -0,0 +1,120 @@
+import { LOG_MANAGER_TOKEN } from '@hamak/logging/api';
+import { NOTIFICATION_SERVICE_TOKEN } from '../../api/index';
+import { NotificationService } from '../core/notification-service';
+import { notificationReducer } from '../store/notification-reducer';
+/**
+ * Create a notification plugin for the microkernel
+ *
+ * @param config - Configuration options for the notification plugin
+ * @returns A plugin module ready to be registered with the host
+ *
+ * @example
+ * ```typescript
+ * import { createNotificationPlugin } from '@hamak/notification-impl';
+ *
+ * const notificationPlugin = createNotificationPlugin({
+ *   maxNotifications: 100,
+ *   defaultDuration: 3000,
+ *   position: 'top-right',
+ *   enablePersistence: true
+ * });
+ *
+ * const host = new Host();
+ * host.registerPlugin('notification', manifest, notificationPlugin);
+ * await host.bootstrapAllAtRoot();
+ * ```
+ */
+export function createNotificationPlugin(config = {}) {
+    let notificationService;
+    let logger;
+    return {
+        async initialize(ctx) {
+            // Resolve logger
+            const logManager = ctx.resolve(LOG_MANAGER_TOKEN);
+            logger = logManager.createLogger({ plugin: 'notification', module: 'plugin' });
+            // Create notification service
+            notificationService = new NotificationService(config, logger);
+            // Register service in DI container
+            ctx.provide({ provide: NOTIFICATION_SERVICE_TOKEN, useValue: notificationService });
+            // Register store reducer if ui-store is available
+            try {
+                // Try to resolve STORE_EXTENSIONS_TOKEN (optional dependency)
+                const STORE_EXTENSIONS_TOKEN = Symbol.for('@hamak/ui-store:StoreExtensionsRegistry');
+                const storeExtensions = ctx.resolve(STORE_EXTENSIONS_TOKEN);
+                if (storeExtensions && typeof storeExtensions.register === 'function') {
+                    storeExtensions.register('notification', {
+                        reducers: {
+                            notifications: notificationReducer,
+                        },
+                    });
+                    logger.debug('Notification reducer registered with store');
+                }
+            }
+            catch (error) {
+                logger.debug('Store not available, skipping reducer registration', { message: error instanceof Error ? error.message : String(error) });
+            }
+            // Register commands
+            ctx.commands.register('notification.show', (args) => {
+                const { type = 'info', message, title, ...options } = args;
+                return notificationService.notify({ type, message, title, ...options });
+            });
+            ctx.commands.register('notification.info', (args) => {
+                const { message, title, ...options } = args;
+                return notificationService.info(message, title, options);
+            });
+            ctx.commands.register('notification.success', (args) => {
+                const { message, title, ...options } = args;
+                return notificationService.success(message, title, options);
+            });
+            ctx.commands.register('notification.warning', (args) => {
+                const { message, title, ...options } = args;
+                return notificationService.warning(message, title, options);
+            });
+            ctx.commands.register('notification.error', (args) => {
+                const { message, title, ...options } = args;
+                return notificationService.error(message, title, options);
+            });
+            ctx.commands.register('notification.dismiss', (args) => {
+                const { id } = args;
+                notificationService.dismiss(id);
+            });
+            ctx.commands.register('notification.dismissAll', () => {
+                notificationService.dismissAll();
+            });
+            logger.info('Notification plugin initialized', {
+                maxNotifications: config.maxNotifications,
+                defaultDuration: config.defaultDuration,
+                position: config.position,
+                enablePersistence: config.enablePersistence,
+            });
+        },
+        async activate(ctx) {
+            // Resolve the notification service
+            const service = ctx.resolve(NOTIFICATION_SERVICE_TOKEN);
+            // Setup hook listeners for cross-plugin notifications
+            ctx.hooks.on('notification:show', (data) => {
+                service.notify(data);
+                logger.debug('Notification shown via hook', { data });
+            });
+            // Emit ready event
+            ctx.hooks.emit('notification:ready', { service });
+            logger.info('Notification plugin activated');
+            // Show a welcome notification if in debug mode
+            if (config.maxNotifications !== undefined) {
+                service.info('Notification system ready', 'System', {
+                    duration: 3000,
+                    source: 'notification-plugin',
+                    metadata: { plugin: 'notification' },
+                });
+            }
+        },
+        async deactivate() {
+            logger.info('Notification plugin deactivating');
+            // Cleanup
+            if (notificationService) {
+                notificationService.destroy();
+            }
+            logger.info('Notification plugin deactivated');
+        },
+    };
+}

package/dist/impl/store/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redux store integration
+ */
+export { notificationReducer, type NotificationState } from './notification-reducer';
+export { NOTIFICATION_ACTIONS, addNotification, dismissNotification, dismissAllNotifications, markNotificationsRead, setAllNotifications, type NotificationAction, } from './notification-actions';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/store/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,kBAAkB,GACxB,MAAM,wBAAwB,CAAC"}

package/dist/impl/store/index.js

@@ -0,0 +1,5 @@
+/**
+ * Redux store integration
+ */
+export { notificationReducer } from './notification-reducer';
+export { NOTIFICATION_ACTIONS, addNotification, dismissNotification, dismissAllNotifications, markNotificationsRead, setAllNotifications, } from './notification-actions';

package/dist/impl/store/notification-actions.d.ts

@@ -0,0 +1,54 @@
+import type { INotification } from '../../api/index';
+/**
+ * Redux action types for notification state management
+ */
+export declare const NOTIFICATION_ACTIONS: {
+    readonly ADD: "notification/add";
+    readonly DISMISS: "notification/dismiss";
+    readonly DISMISS_ALL: "notification/dismissAll";
+    readonly MARK_READ: "notification/markRead";
+    readonly SET_ALL: "notification/setAll";
+};
+/**
+ * Action creators for notification state
+ */
+export interface NotificationAddAction {
+    type: typeof NOTIFICATION_ACTIONS.ADD;
+    payload: INotification;
+}
+export interface NotificationDismissAction {
+    type: typeof NOTIFICATION_ACTIONS.DISMISS;
+    payload: string;
+}
+export interface NotificationDismissAllAction {
+    type: typeof NOTIFICATION_ACTIONS.DISMISS_ALL;
+}
+export interface NotificationMarkReadAction {
+    type: typeof NOTIFICATION_ACTIONS.MARK_READ;
+}
+export interface NotificationSetAllAction {
+    type: typeof NOTIFICATION_ACTIONS.SET_ALL;
+    payload: INotification[];
+}
+export type NotificationAction = NotificationAddAction | NotificationDismissAction | NotificationDismissAllAction | NotificationMarkReadAction | NotificationSetAllAction;
+/**
+ * Add a notification
+ */
+export declare function addNotification(notification: INotification): NotificationAddAction;
+/**
+ * Dismiss a notification by ID
+ */
+export declare function dismissNotification(id: string): NotificationDismissAction;
+/**
+ * Dismiss all notifications
+ */
+export declare function dismissAllNotifications(): NotificationDismissAllAction;
+/**
+ * Mark all notifications as read
+ */
+export declare function markNotificationsRead(): NotificationMarkReadAction;
+/**
+ * Set all notifications (used for syncing with service)
+ */
+export declare function setAllNotifications(notifications: INotification[]): NotificationSetAllAction;
+//# sourceMappingURL=notification-actions.d.ts.map

package/dist/impl/store/notification-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-actions.d.ts","sourceRoot":"","sources":["../../../src/impl/store/notification-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;CAMvB,CAAC;AAEX;;GAEG;AAEH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,OAAO,oBAAoB,CAAC,GAAG,CAAC;IACtC,OAAO,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,OAAO,oBAAoB,CAAC,OAAO,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,OAAO,oBAAoB,CAAC,WAAW,CAAC;CAC/C;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,OAAO,oBAAoB,CAAC,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,OAAO,oBAAoB,CAAC,OAAO,CAAC;IAC1C,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,kBAAkB,GAC1B,qBAAqB,GACrB,yBAAyB,GACzB,4BAA4B,GAC5B,0BAA0B,GAC1B,wBAAwB,CAAC;AAE7B;;GAEG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,aAAa,GAAG,qBAAqB,CAKlF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,yBAAyB,CAKzE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,4BAA4B,CAItE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,0BAA0B,CAIlE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,EAAE,GAAG,wBAAwB,CAK5F"}

package/dist/impl/store/notification-actions.js

@@ -0,0 +1,53 @@
+/**
+ * Redux action types for notification state management
+ */
+export const NOTIFICATION_ACTIONS = {
+    ADD: 'notification/add',
+    DISMISS: 'notification/dismiss',
+    DISMISS_ALL: 'notification/dismissAll',
+    MARK_READ: 'notification/markRead',
+    SET_ALL: 'notification/setAll',
+};
+/**
+ * Add a notification
+ */
+export function addNotification(notification) {
+    return {
+        type: NOTIFICATION_ACTIONS.ADD,
+        payload: notification,
+    };
+}
+/**
+ * Dismiss a notification by ID
+ */
+export function dismissNotification(id) {
+    return {
+        type: NOTIFICATION_ACTIONS.DISMISS,
+        payload: id,
+    };
+}
+/**
+ * Dismiss all notifications
+ */
+export function dismissAllNotifications() {
+    return {
+        type: NOTIFICATION_ACTIONS.DISMISS_ALL,
+    };
+}
+/**
+ * Mark all notifications as read
+ */
+export function markNotificationsRead() {
+    return {
+        type: NOTIFICATION_ACTIONS.MARK_READ,
+    };
+}
+/**
+ * Set all notifications (used for syncing with service)
+ */
+export function setAllNotifications(notifications) {
+    return {
+        type: NOTIFICATION_ACTIONS.SET_ALL,
+        payload: notifications,
+    };
+}

package/dist/impl/store/notification-reducer.d.ts

@@ -0,0 +1,23 @@
+import type { INotification } from '../../api/index';
+import { type NotificationAction } from './notification-actions';
+/**
+ * State shape for notifications in Redux store
+ */
+export interface NotificationState {
+    /**
+     * All active notifications
+     */
+    items: INotification[];
+    /**
+     * Count of unread notifications
+     */
+    unreadCount: number;
+}
+/**
+ * Notification reducer
+ *
+ * This reducer manages notification state in Redux.
+ * It should be kept in sync with the NotificationService via subscriptions.
+ */
+export declare function notificationReducer(state: NotificationState | undefined, action: NotificationAction): NotificationState;
+//# sourceMappingURL=notification-reducer.d.ts.map

package/dist/impl/store/notification-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-reducer.d.ts","sourceRoot":"","sources":["../../../src/impl/store/notification-reducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAwB,KAAK,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEvF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,KAAK,EAAE,aAAa,EAAE,CAAC;IAEvB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAUD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,YAAe,EACvC,MAAM,EAAE,kBAAkB,GACzB,iBAAiB,CAqCnB"}

package/dist/impl/store/notification-reducer.js

@@ -0,0 +1,47 @@
+import { NOTIFICATION_ACTIONS } from './notification-actions';
+/**
+ * Initial state
+ */
+const initialState = {
+    items: [],
+    unreadCount: 0,
+};
+/**
+ * Notification reducer
+ *
+ * This reducer manages notification state in Redux.
+ * It should be kept in sync with the NotificationService via subscriptions.
+ */
+export function notificationReducer(state = initialState, action) {
+    switch (action.type) {
+        case NOTIFICATION_ACTIONS.ADD:
+            return {
+                ...state,
+                items: [action.payload, ...state.items],
+                unreadCount: state.unreadCount + 1,
+            };
+        case NOTIFICATION_ACTIONS.DISMISS:
+            return {
+                ...state,
+                items: state.items.filter((n) => n.id !== action.payload),
+            };
+        case NOTIFICATION_ACTIONS.DISMISS_ALL:
+            return {
+                ...state,
+                items: [],
+                unreadCount: 0,
+            };
+        case NOTIFICATION_ACTIONS.MARK_READ:
+            return {
+                ...state,
+                unreadCount: 0,
+            };
+        case NOTIFICATION_ACTIONS.SET_ALL:
+            return {
+                ...state,
+                items: action.payload,
+            };
+        default:
+            return state;
+    }
+}