@umituz/react-native-notifications 1.0.6 → 1.1.1

package/src/infrastructure/hooks/useNotifications.ts

@@ -1,8 +1,10 @@
-import { useEffect } from 'react';
+import { useEffect, useCallback } from 'react';
 import { useNotificationsState } from './state/useNotificationsState';
 import { useNotificationActions } from './actions/useNotificationActions';
+import { useNotificationManagementActions } from './actions/useNotificationManagementActions';
 import { useNotificationRefresh } from './utils/useNotificationRefresh';
 import type { UseNotificationsOptions } from './types';
+import { devLog } from '../utils/dev';
 
 export * from './types';
 
@@ -31,10 +33,25 @@ export function useNotifications(userId: string, options: UseNotificationsOption
   };
 
   const actions = useNotificationActions(state, setters);
+  const managementActions = useNotificationManagementActions(state, setters);
   const refresh = useNotificationRefresh(pageSize, setters);
 
-  const loadMoreNotifications = () => 
-    refresh.loadMoreNotifications(state.notifications.length, state.hasMore, state.loading);
+  const loadMoreNotifications = useCallback(() => 
+    refresh.loadMoreNotifications(state.notifications.length, state.hasMore, state.loading),
+    [refresh, state.notifications.length, state.hasMore, state.loading]
+  );
+
+  const cleanup = useCallback(() => {
+    setNotifications([]);
+    setChannels([]);
+    setUnreadCount(0);
+    setPreferences(null);
+    setError(null);
+    setLoading(false);
+    setHasMore(true);
+
+    devLog('[useNotifications] Cleaned up notification state');
+  }, [setNotifications, setChannels, setUnreadCount, setPreferences, setError, setLoading, setHasMore]);
 
   // Load initial data
   useEffect(() => {
@@ -43,14 +60,11 @@ export function useNotifications(userId: string, options: UseNotificationsOption
       refresh.refreshChannels();
       refresh.refreshPreferences();
     } else {
-      setNotifications([]);
-      setChannels([]);
-      setUnreadCount(0);
-      setPreferences(null);
+      cleanup();
     }
-  }, [userId]);
+  }, [userId, cleanup]);
 
-  // Auto-refresh setup
+  // Auto-refresh setup with proper cleanup
   useEffect(() => {
     if (!autoRefresh || !userId) return;
 
@@ -58,13 +72,25 @@ export function useNotifications(userId: string, options: UseNotificationsOption
       refresh.refreshNotifications();
     }, refreshInterval);
 
-    return () => clearInterval(interval);
+    return () => {
+      clearInterval(interval);
+      devLog('[useNotifications] Auto-refresh interval cleared');
+    };
   }, [autoRefresh, userId, refreshInterval]);
 
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      devLog('[useNotifications] Component unmounted, cleaning up');
+    };
+  }, []);
+
   return {
     ...state,
     ...actions,
+    ...managementActions,
     ...refresh,
     loadMoreNotifications,
+    cleanup,
   };
-}
+}

package/src/infrastructure/hooks/utils/useNotificationRefresh.ts

@@ -1,15 +1,10 @@
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { Notification } from '../types';
 import { ChannelManager } from '../../services/channels/ChannelManager';
 import { PreferencesManager } from '../../services/preferences/PreferencesManager';
+import { devLog, devError } from '../../utils/dev';
 
-/**
- * useNotificationRefresh - Offline Notification Refresh
- *
- * Uses AsyncStorage for local data.
- * NO backend - pure offline.
- */
 export const useNotificationRefresh = (pageSize: number, setters: any) => {
   const {
     setNotifications,
@@ -21,39 +16,57 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
     setHasMore,
   } = setters;
 
-  const channelManager = new ChannelManager();
-  const preferencesManager = new PreferencesManager();
+  const channelManager = useRef(new ChannelManager()).current;
+  const preferencesManager = useRef(new PreferencesManager()).current;
+  const abortController = useRef<AbortController | null>(null);
+
+  const cleanup = useCallback(() => {
+    if (abortController.current) {
+      abortController.current.abort();
+      abortController.current = null;
+    }
+  }, []);
 
   const refreshNotifications = useCallback(async () => {
     try {
+      cleanup();
+      abortController.current = new AbortController();
+
       setLoading(true);
       setError(null);
 
-      // Load from AsyncStorage
       const data = await AsyncStorage.getItem('@notifications:list');
       const allNotifications: Notification[] = data ? JSON.parse(data) : [];
 
-      // Paginate
       const paginated = allNotifications.slice(0, pageSize);
       const unread = allNotifications.filter((n) => !n.read).length;
 
       setNotifications(paginated);
       setUnreadCount(unread);
       setHasMore(allNotifications.length > pageSize);
+
+      devLog('[useNotificationRefresh] Refreshed notifications:', paginated.length);
     } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        return;
+      }
       setError(
         err instanceof Error ? err.message : 'Failed to load notifications'
       );
     } finally {
       setLoading(false);
+      cleanup();
     }
-  }, [pageSize, setNotifications, setUnreadCount, setHasMore, setLoading, setError]);
+  }, [pageSize, setNotifications, setUnreadCount, setHasMore, setLoading, setError, cleanup]);
 
   const loadMoreNotifications = useCallback(
     async (currentLength: number, hasMore: boolean, loading: boolean) => {
       if (!hasMore || loading) return;
 
       try {
+        cleanup();
+        abortController.current = new AbortController();
+
         setLoading(true);
         setError(null);
 
@@ -67,7 +80,12 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
 
         setNotifications((prev: any[]) => [...prev, ...moreNotifications]);
         setHasMore(allNotifications.length > currentLength + pageSize);
+
+        devLog('[useNotificationRefresh] Loaded more notifications:', moreNotifications.length);
       } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+          return;
+        }
         setError(
           err instanceof Error
             ? err.message
@@ -75,17 +93,20 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
         );
       } finally {
         setLoading(false);
+        cleanup();
       }
     },
-    [pageSize, setNotifications, setHasMore, setLoading, setError]
+    [pageSize, setNotifications, setHasMore, setLoading, setError, cleanup]
   );
 
   const refreshChannels = useCallback(async () => {
     try {
       const channelsData = await channelManager.getActiveChannels();
       setChannels(channelsData);
+
+      devLog('[useNotificationRefresh] Refreshed channels:', channelsData.length);
     } catch (err) {
-      // Silent failure
+      devError('[useNotificationRefresh] Failed to refresh channels:', err);
     }
   }, [setChannels]);
 
@@ -93,8 +114,10 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
     try {
       const prefsData = await preferencesManager.get();
       setPreferences(prefsData);
+
+      devLog('[useNotificationRefresh] Refreshed preferences');
     } catch (err) {
-      // Silent failure
+      devError('[useNotificationRefresh] Failed to refresh preferences:', err);
     }
   }, [setPreferences]);
 
@@ -103,5 +126,6 @@ export const useNotificationRefresh = (pageSize: number, setters: any) => {
     loadMoreNotifications,
     refreshChannels,
     refreshPreferences,
+    cleanup,
   };
-};
+};

package/src/infrastructure/services/NotificationBadgeManager.ts

@@ -0,0 +1,28 @@
+import * as Notifications from 'expo-notifications';
+import { Platform } from 'react-native';
+import { devError } from '../utils/dev';
+
+export class NotificationBadgeManager {
+  async getBadgeCount(): Promise<number> {
+    try {
+      if (Platform.OS === 'ios') {
+        return await Notifications.getBadgeCountAsync();
+      }
+      return 0;
+    } catch (error) {
+      devError('[NotificationBadgeManager] Get badge count failed:', error);
+      return 0;
+    }
+  }
+
+  async setBadgeCount(count: number): Promise<void> {
+    try {
+      if (Platform.OS === 'ios') {
+        await Notifications.setBadgeCountAsync(count);
+      }
+    } catch (error) {
+      devError('[NotificationBadgeManager] Set badge count failed:', error);
+      throw error;
+    }
+  }
+}

package/src/infrastructure/services/NotificationManager.ts

@@ -1,42 +1,24 @@
 /**
- * NotificationManager
+ * NotificationManager - Core Notification Operations
  *
  * Offline-first notification system using expo-notifications.
  * Works in ALL apps (offline, online, hybrid) - no backend required.
- *
- * Features:
- * - Schedule notifications for specific dates/times
- * - Repeating notifications (daily, weekly, monthly)
- * - Android notification channels
- * - Permission handling
- * - Cancel individual or all notifications
- * - Works completely offline
- *
- * Use Cases:
- * - Reminders (bills, tasks, appointments)
- * - Habit tracking (daily streaks)
- * - Medication reminders
- * - Any app needing local notifications
- *
- * @module NotificationManager
  */
 
 import * as Notifications from 'expo-notifications';
 import * as Device from 'expo-device';
 import { Platform } from 'react-native';
+import { NotificationPermissions } from './NotificationPermissions';
+import { NotificationScheduler } from './NotificationScheduler';
+import { NotificationBadgeManager } from './NotificationBadgeManager';
+import { devLog, devError } from '../utils/dev';
 
-/**
- * Trigger types for notifications
- */
 export type NotificationTrigger =
   | { type: 'date'; date: Date }
   | { type: 'daily'; hour: number; minute: number }
   | { type: 'weekly'; weekday: number; hour: number; minute: number }
   | { type: 'monthly'; day: number; hour: number; minute: number };
 
-/**
- * Options for scheduling a notification
- */
 export interface ScheduleNotificationOptions {
   title: string;
   body: string;
@@ -47,9 +29,6 @@ export interface ScheduleNotificationOptions {
   categoryIdentifier?: string;
 }
 
-/**
- * Scheduled notification details
- */
 export interface ScheduledNotification {
   identifier: string;
   content: {
@@ -60,16 +39,17 @@ export interface ScheduledNotification {
   trigger: any;
 }
 
-/**
- * NotificationManager
- *
- * Handles all notification operations using expo-notifications.
- * Works completely offline - no backend, no user IDs, just device-local notifications.
- */
 export class NotificationManager {
-  /**
-   * Configure notification handler (how notifications appear when app is in foreground)
-   */
+  private permissions: NotificationPermissions;
+  private scheduler: NotificationScheduler;
+  private badgeManager: NotificationBadgeManager;
+
+  constructor() {
+    this.permissions = new NotificationPermissions();
+    this.scheduler = new NotificationScheduler();
+    this.badgeManager = new NotificationBadgeManager();
+  }
+
   static configure() {
     Notifications.setNotificationHandler({
       handleNotification: async () => ({
@@ -78,250 +58,104 @@ export class NotificationManager {
         shouldSetBadge: true,
       }),
     });
+
+    devLog('[NotificationManager] Configured notification handler');
   }
 
-  /**
-   * Request notification permissions
-   * iOS: Shows system permission dialog
-   * Android: Permissions granted by default (Android 13+ requires runtime permission)
-   */
   async requestPermissions(): Promise<boolean> {
     try {
-      if (!Device.isDevice) {
-        console.warn('[NotificationManager] Notifications only work on physical devices');
-        return false;
-      }
-
-      const permissionsResponse = await Notifications.getPermissionsAsync();
-      const existingStatus = (permissionsResponse as any).status || ((permissionsResponse as any).granted ? 'granted' : 'denied');
-      let finalStatus = existingStatus;
-
-      if (existingStatus !== 'granted') {
-        const requestResponse = await Notifications.requestPermissionsAsync();
-        finalStatus = (requestResponse as any).status || ((requestResponse as any).granted ? 'granted' : 'denied');
-      }
-
-      if (Platform.OS === 'android') {
-        await this.createAndroidChannels();
-      }
-
-      return finalStatus === 'granted';
+      const result = await this.permissions.requestPermissions();
+      
+      devLog('[NotificationManager] Permissions requested:', result);
+      
+      return result;
     } catch (error) {
-      console.error('[NotificationManager] Permission request failed:', error);
+      devError('[NotificationManager] Permission request failed:', error);
       return false;
     }
   }
 
-  /**
-   * Check if notification permissions are granted
-   */
   async hasPermissions(): Promise<boolean> {
     try {
-      if (!Device.isDevice) return false;
-      const permissionsResponse = await Notifications.getPermissionsAsync();
-      return (permissionsResponse as any).status === 'granted' || (permissionsResponse as any).granted === true;
+      return await this.permissions.hasPermissions();
     } catch (error) {
-      console.error('[NotificationManager] Permission check failed:', error);
+      devError('[NotificationManager] Permission check failed:', error);
       return false;
     }
   }
 
-  /**
-   * Create Android notification channels (required for Android 8+)
-   */
-  private async createAndroidChannels(): Promise<void> {
-    if (Platform.OS !== 'android') return;
-
-    try {
-      await Notifications.setNotificationChannelAsync('default', {
-        name: 'Default',
-        importance: Notifications.AndroidImportance.DEFAULT,
-        vibrationPattern: [0, 250, 250, 250],
-        sound: 'default',
-        lightColor: '#3B82F6',
-      });
-
-      await Notifications.setNotificationChannelAsync('reminders', {
-        name: 'Reminders',
-        importance: Notifications.AndroidImportance.HIGH,
-        vibrationPattern: [0, 250, 250, 250],
-        sound: 'default',
-        lightColor: '#3B82F6',
-        enableVibrate: true,
-      });
-
-      await Notifications.setNotificationChannelAsync('urgent', {
-        name: 'Urgent',
-        importance: Notifications.AndroidImportance.MAX,
-        vibrationPattern: [0, 500, 250, 500],
-        sound: 'default',
-        lightColor: '#EF4444',
-        enableVibrate: true,
-      });
-    } catch (error) {
-      console.error('[NotificationManager] Android channel creation failed:', error);
-    }
-  }
-
-  /**
-   * Schedule a notification
-   *
-   * @example
-   * // Specific date
-   * const id = await manager.scheduleNotification({
-   *   title: 'Bill Reminder',
-   *   body: 'Electricity bill due today',
-   *   trigger: { type: 'date', date: new Date('2025-01-15T09:00:00') }
-   * });
-   *
-   * @example
-   * // Daily reminder
-   * const id = await manager.scheduleNotification({
-   *   title: 'Daily Workout',
-   *   body: 'Time for your morning workout!',
-   *   trigger: { type: 'daily', hour: 7, minute: 0 }
-   * });
-   */
   async scheduleNotification(options: ScheduleNotificationOptions): Promise<string> {
     try {
-      const { title, body, data = {}, trigger, sound = true, badge, categoryIdentifier } = options;
-
-      let notificationTrigger: any;
-
-      if (trigger.type === 'date') {
-        notificationTrigger = {
-          date: trigger.date,
-          channelId: categoryIdentifier || 'default',
-        };
-      } else if (trigger.type === 'daily') {
-        notificationTrigger = {
-          hour: trigger.hour,
-          minute: trigger.minute,
-          repeats: true,
-          channelId: categoryIdentifier || 'reminders',
-        };
-      } else if (trigger.type === 'weekly') {
-        notificationTrigger = {
-          weekday: trigger.weekday,
-          hour: trigger.hour,
-          minute: trigger.minute,
-          repeats: true,
-          channelId: categoryIdentifier || 'reminders',
-        };
-      } else if (trigger.type === 'monthly') {
-        notificationTrigger = {
-          day: trigger.day,
-          hour: trigger.hour,
-          minute: trigger.minute,
-          repeats: true,
-          channelId: categoryIdentifier || 'reminders',
-        };
-      }
-
-      const notificationId = await Notifications.scheduleNotificationAsync({
-        content: {
-          title,
-          body,
-          data,
-          sound: sound === true ? 'default' : sound || undefined,
-          badge,
-          categoryIdentifier,
-          priority: Notifications.AndroidNotificationPriority.HIGH,
-          vibrate: [0, 250, 250, 250],
-        },
-        trigger: notificationTrigger,
-      });
-
-      return notificationId;
+      const id = await this.scheduler.scheduleNotification(options);
+      
+      devLog('[NotificationManager] Notification scheduled:', id);
+      
+      return id;
     } catch (error) {
-      console.error('[NotificationManager] Schedule notification failed:', error);
+      devError('[NotificationManager] Schedule notification failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Cancel a scheduled notification
-   */
   async cancelNotification(notificationId: string): Promise<void> {
     try {
-      await Notifications.cancelScheduledNotificationAsync(notificationId);
+      await this.scheduler.cancelNotification(notificationId);
+      
+      devLog('[NotificationManager] Notification cancelled:', notificationId);
     } catch (error) {
-      console.error('[NotificationManager] Cancel notification failed:', error);
+      devError('[NotificationManager] Cancel notification failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Cancel all scheduled notifications
-   */
   async cancelAllNotifications(): Promise<void> {
     try {
-      await Notifications.cancelAllScheduledNotificationsAsync();
+      await this.scheduler.cancelAllNotifications();
+      
+      devLog('[NotificationManager] All notifications cancelled');
     } catch (error) {
-      console.error('[NotificationManager] Cancel all notifications failed:', error);
+      devError('[NotificationManager] Cancel all notifications failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Get all scheduled notifications
-   */
   async getScheduledNotifications(): Promise<ScheduledNotification[]> {
     try {
-      const notifications = await Notifications.getAllScheduledNotificationsAsync();
-      return notifications.map(notification => ({
-        identifier: notification.identifier,
-        content: {
-          title: notification.content.title || '',
-          body: notification.content.body || '',
-          data: notification.content.data as Record<string, any>,
-        },
-        trigger: notification.trigger,
-      }));
+      return await this.scheduler.getScheduledNotifications();
     } catch (error) {
-      console.error('[NotificationManager] Get scheduled notifications failed:', error);
+      devError('[NotificationManager] Get scheduled notifications failed:', error);
       return [];
     }
   }
 
-  /**
-   * Dismiss all delivered notifications (clear from notification center)
-   */
   async dismissAllNotifications(): Promise<void> {
     try {
       await Notifications.dismissAllNotificationsAsync();
+      
+      devLog('[NotificationManager] All notifications dismissed');
     } catch (error) {
-      console.error('[NotificationManager] Dismiss all notifications failed:', error);
+      devError('[NotificationManager] Dismiss all notifications failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Get notification badge count (iOS only)
-   */
   async getBadgeCount(): Promise<number> {
     try {
-      if (Platform.OS === 'ios') {
-        return await Notifications.getBadgeCountAsync();
-      }
-      return 0;
+      return await this.badgeManager.getBadgeCount();
     } catch (error) {
-      console.error('[NotificationManager] Get badge count failed:', error);
+      devError('[NotificationManager] Get badge count failed:', error);
       return 0;
     }
   }
 
-  /**
-   * Set notification badge count (iOS only)
-   */
   async setBadgeCount(count: number): Promise<void> {
     try {
-      if (Platform.OS === 'ios') {
-        await Notifications.setBadgeCountAsync(count);
-      }
+      await this.badgeManager.setBadgeCount(count);
+      
+      devLog('[NotificationManager] Badge count set:', count);
     } catch (error) {
-      console.error('[NotificationManager] Set badge count failed:', error);
+      devError('[NotificationManager] Set badge count failed:', error);
       throw error;
     }
   }
-}
+}