@umituz/react-native-notifications 1.0.0

package/src/infrastructure/config/notificationsConfig.ts

@@ -0,0 +1,98 @@
+/**
+ * Notifications Configuration
+ * Defines notification settings structure
+ */
+
+export interface NotificationSetting {
+  id: string;
+  titleKey: string;
+  descKey: string;
+  icon: string;
+}
+
+export interface NotificationSection {
+  id: string;
+  titleKey: string;
+  settings: NotificationSetting[];
+}
+
+export interface NotificationsConfig {
+  sections: NotificationSection[];
+}
+
+export const notificationsConfig: NotificationsConfig = {
+  sections: [
+    {
+      id: 'channels',
+      titleKey: 'notifications.channels',
+      settings: [
+        {
+          id: 'pushNotifications',
+          titleKey: 'notifications.push',
+          descKey: 'notifications.pushDesc',
+          icon: 'notifications',
+        },
+        {
+          id: 'emailNotifications',
+          titleKey: 'notifications.email',
+          descKey: 'notifications.emailDesc',
+          icon: 'email',
+        },
+        {
+          id: 'smsNotifications',
+          titleKey: 'notifications.sms',
+          descKey: 'notifications.smsDesc',
+          icon: 'message',
+        },
+      ],
+    },
+    {
+      id: 'content',
+      titleKey: 'notifications.content',
+      settings: [
+        {
+          id: 'appUpdates',
+          titleKey: 'notifications.updates',
+          descKey: 'notifications.updatesDesc',
+          icon: 'update',
+        },
+        {
+          id: 'features',
+          titleKey: 'notifications.features',
+          descKey: 'notifications.featuresDesc',
+          icon: 'new-releases',
+        },
+        {
+          id: 'tips',
+          titleKey: 'notifications.tips',
+          descKey: 'notifications.tipsDesc',
+          icon: 'tips-and-updates',
+        },
+      ],
+    },
+    {
+      id: 'activity',
+      titleKey: 'notifications.activity',
+      settings: [
+        {
+          id: 'reminders',
+          titleKey: 'notifications.reminders',
+          descKey: 'notifications.remindersDesc',
+          icon: 'alarm',
+        },
+        {
+          id: 'achievements',
+          titleKey: 'notifications.achievements',
+          descKey: 'notifications.achievementsDesc',
+          icon: 'emoji-events',
+        },
+        {
+          id: 'social',
+          titleKey: 'notifications.social',
+          descKey: 'notifications.socialDesc',
+          icon: 'people',
+        },
+      ],
+    },
+  ],
+};

package/src/infrastructure/hooks/actions/useNotificationActions.ts

@@ -0,0 +1,233 @@
+import { useCallback } from 'react';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as Notifications from 'expo-notifications';
+import type {
+  SendNotificationOptions,
+  Notification,
+  NotificationChannel,
+  NotificationPreferences,
+} from '../types';
+import { NotificationDelivery } from '../../services/delivery/NotificationDelivery';
+import { ChannelManager } from '../../services/channels/ChannelManager';
+import { PreferencesManager } from '../../services/preferences/PreferencesManager';
+
+/**
+ * useNotificationActions - Offline Notification Actions
+ *
+ * All actions use AsyncStorage and expo-notifications.
+ * NO backend - pure offline.
+ */
+export const useNotificationActions = (state: any, setters: any) => {
+  const {
+    setNotifications,
+    setUnreadCount,
+    setChannels,
+    setPreferences,
+    setError,
+  } = setters;
+
+  const notificationDelivery = new NotificationDelivery();
+  const channelManager = new ChannelManager();
+  const preferencesManager = new PreferencesManager();
+
+  const sendNotification = useCallback(
+    async (options: SendNotificationOptions): Promise<Notification[]> => {
+      try {
+        setError(null);
+
+        // Create notification
+        const notification: Notification = {
+          id: `notif_${Date.now()}`,
+          title: options.title,
+          body: options.body,
+          data: options.data,
+          scheduled_for: options.scheduled_for?.toISOString(),
+          created_at: new Date().toISOString(),
+          read: false,
+        };
+
+        // Save to AsyncStorage
+        const data = await AsyncStorage.getItem('@notifications:list');
+        const notifications: Notification[] = data ? JSON.parse(data) : [];
+        notifications.unshift(notification);
+        await AsyncStorage.setItem(
+          '@notifications:list',
+          JSON.stringify(notifications)
+        );
+
+        // Deliver using expo-notifications
+        await notificationDelivery.deliver(notification);
+
+        return [notification];
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to send notification'
+        );
+        return [];
+      }
+    },
+    [setError]
+  );
+
+  const markAsRead = useCallback(
+    async (notificationId: string): Promise<boolean> => {
+      try {
+        const data = await AsyncStorage.getItem('@notifications:list');
+        const notifications: Notification[] = data ? JSON.parse(data) : [];
+
+        const updated = notifications.map((n) =>
+          n.id === notificationId ? { ...n, read: true } : n
+        );
+
+        await AsyncStorage.setItem(
+          '@notifications:list',
+          JSON.stringify(updated)
+        );
+
+        setNotifications((prev: Notification[]) =>
+          prev.map((n) =>
+            n.id === notificationId ? { ...n, read: true } : n
+          )
+        );
+        setUnreadCount((prev: number) => Math.max(0, prev - 1));
+
+        return true;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to mark as read'
+        );
+        return false;
+      }
+    },
+    [setNotifications, setUnreadCount, setError]
+  );
+
+  const markAllAsRead = useCallback(async (): Promise<boolean> => {
+    try {
+      const data = await AsyncStorage.getItem('@notifications:list');
+      const notifications: Notification[] = data ? JSON.parse(data) : [];
+
+      const updated = notifications.map((n) => ({ ...n, read: true }));
+
+      await AsyncStorage.setItem('@notifications:list', JSON.stringify(updated));
+
+      setNotifications((prev: Notification[]) =>
+        prev.map((n) => ({ ...n, read: true }))
+      );
+      setUnreadCount(0);
+
+      return true;
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : 'Failed to mark all as read'
+      );
+      return false;
+    }
+  }, [setNotifications, setUnreadCount, setError]);
+
+  const deleteNotification = useCallback(
+    async (notificationId: string): Promise<boolean> => {
+      try {
+        const data = await AsyncStorage.getItem('@notifications:list');
+        const notifications: Notification[] = data ? JSON.parse(data) : [];
+
+        const deleted = notifications.find((n) => n.id === notificationId);
+        const filtered = notifications.filter((n) => n.id !== notificationId);
+
+        await AsyncStorage.setItem(
+          '@notifications:list',
+          JSON.stringify(filtered)
+        );
+
+        setNotifications((prev: Notification[]) =>
+          prev.filter((n) => n.id !== notificationId)
+        );
+
+        if (deleted && !deleted.read) {
+          setUnreadCount((prev: number) => Math.max(0, prev - 1));
+        }
+
+        return true;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to delete notification'
+        );
+        return false;
+      }
+    },
+    [setNotifications, setUnreadCount, setError]
+  );
+
+  const registerChannel = useCallback(
+    async (
+      channelType: 'push' | 'in_app',
+      preferences: Record<string, any> = {}
+    ): Promise<NotificationChannel | null> => {
+      try {
+        const channel = await channelManager.register(channelType, preferences);
+        if (channel) {
+          setChannels((prev: NotificationChannel[]) => [...prev, channel]);
+        }
+        return channel;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to register channel'
+        );
+        return null;
+      }
+    },
+    [setChannels, setError]
+  );
+
+  const verifyChannel = useCallback(
+    async (channelId: string): Promise<boolean> => {
+      try {
+        const success = await channelManager.verify(channelId);
+        if (success) {
+          setChannels((prev: NotificationChannel[]) =>
+            prev.map((c) =>
+              c.id === channelId ? { ...c, is_verified: true } : c
+            )
+          );
+        }
+        return success;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to verify channel'
+        );
+        return false;
+      }
+    },
+    [setChannels, setError]
+  );
+
+  const updatePreferences = useCallback(
+    async (newPreferences: Partial<NotificationPreferences>): Promise<boolean> => {
+      try {
+        const success = await preferencesManager.update(newPreferences);
+        if (success) {
+          setPreferences((prev: NotificationPreferences | null) =>
+            prev ? { ...prev, ...newPreferences } : null
+          );
+        }
+        return success;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : 'Failed to update preferences'
+        );
+        return false;
+      }
+    },
+    [setPreferences, setError]
+  );
+
+  return {
+    sendNotification,
+    markAsRead,
+    markAllAsRead,
+    deleteNotification,
+    registerChannel,
+    verifyChannel,
+    updatePreferences,
+  };
+};

package/src/infrastructure/hooks/state/useNotificationsState.ts

@@ -0,0 +1,46 @@
+import { useState } from 'react';
+import type { NotificationsState } from '../types';
+
+export const useNotificationsState = () => {
+  const [state, setState] = useState<NotificationsState>({
+    notifications: [],
+    channels: [],
+    unreadCount: 0,
+    preferences: null,
+    loading: false,
+    error: null,
+    hasMore: true,
+  });
+
+  const setNotifications = (notifications: NotificationsState['notifications']) =>
+    setState(prev => ({ ...prev, notifications }));
+
+  const setChannels = (channels: NotificationsState['channels']) =>
+    setState(prev => ({ ...prev, channels }));
+
+  const setUnreadCount = (unreadCount: number) =>
+    setState(prev => ({ ...prev, unreadCount }));
+
+  const setPreferences = (preferences: NotificationsState['preferences']) =>
+    setState(prev => ({ ...prev, preferences }));
+
+  const setLoading = (loading: boolean) =>
+    setState(prev => ({ ...prev, loading }));
+
+  const setError = (error: string | null) =>
+    setState(prev => ({ ...prev, error }));
+
+  const setHasMore = (hasMore: boolean) =>
+    setState(prev => ({ ...prev, hasMore }));
+
+  return {
+    state,
+    setNotifications,
+    setChannels,
+    setUnreadCount,
+    setPreferences,
+    setLoading,
+    setError,
+    setHasMore,
+  };
+};

package/src/infrastructure/hooks/types.ts

@@ -0,0 +1,83 @@
+/**
+ * Notification Hook Types - Offline-First
+ *
+ * All types for offline local notifications.
+ * NO backend dependencies.
+ */
+
+/**
+ * Local notification entity
+ */
+export interface Notification {
+  id: string;
+  title: string;
+  body: string;
+  data?: Record<string, any>;
+  scheduled_for?: string;
+  created_at: string;
+  read: boolean;
+}
+
+/**
+ * Notification channel (push or in-app only)
+ */
+export interface NotificationChannel {
+  id: string;
+  channel_type: 'push' | 'in_app';
+  channel_address: string;
+  preferences: Record<string, any>;
+  is_verified: boolean;
+  is_active: boolean;
+  created_at: string;
+}
+
+/**
+ * Notification preferences
+ */
+export interface NotificationPreferences {
+  push_enabled: boolean;
+  quiet_hours: {
+    enabled: boolean;
+    start_time: string;
+    end_time: string;
+    timezone: string;
+  };
+  categories: {
+    reminders: { push: boolean; in_app: boolean };
+    updates: { push: boolean; in_app: boolean };
+    alerts: { push: boolean; in_app: boolean };
+  };
+}
+
+/**
+ * Options for sending notification
+ */
+export interface SendNotificationOptions {
+  title: string;
+  body: string;
+  data?: Record<string, any>;
+  scheduled_for?: Date;
+  category?: 'reminders' | 'updates' | 'alerts';
+}
+
+/**
+ * State for useNotifications hook
+ */
+export interface NotificationsState {
+  notifications: Notification[];
+  channels: NotificationChannel[];
+  unreadCount: number;
+  preferences: NotificationPreferences | null;
+  loading: boolean;
+  error: string | null;
+  hasMore: boolean;
+}
+
+/**
+ * Options for useNotifications hook
+ */
+export interface UseNotificationsOptions {
+  autoRefresh?: boolean;
+  refreshInterval?: number;
+  pageSize?: number;
+}

package/src/infrastructure/hooks/useNotificationSettings.ts

@@ -0,0 +1,45 @@
+import { useState, useEffect } from 'react';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const STORAGE_KEY = 'notifications_enabled';
+
+/**
+ * Simple notification settings hook
+ * Manages a single toggle for enabling/disabling notifications
+ */
+export const useNotificationSettings = () => {
+  const [notificationsEnabled, setNotificationsEnabled] = useState(true);
+  const [isLoading, setIsLoading] = useState(true);
+
+  useEffect(() => {
+    const loadSettings = async () => {
+      try {
+        const value = await AsyncStorage.getItem(STORAGE_KEY);
+        if (value !== null) {
+          setNotificationsEnabled(value === 'true');
+        }
+      } catch (error) {
+        // Silent failure - use default value
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    loadSettings();
+  }, []);
+
+  const toggleNotifications = async (value: boolean) => {
+    setNotificationsEnabled(value);
+    try {
+      await AsyncStorage.setItem(STORAGE_KEY, value.toString());
+    } catch (error) {
+      // Silent failure
+    }
+  };
+
+  return {
+    notificationsEnabled,
+    setNotificationsEnabled: toggleNotifications,
+    isLoading,
+  };
+};

package/src/infrastructure/hooks/useNotifications.ts

@@ -0,0 +1,70 @@
+import { useEffect } from 'react';
+import { useNotificationsState } from './state/useNotificationsState';
+import { useNotificationActions } from './actions/useNotificationActions';
+import { useNotificationRefresh } from './utils/useNotificationRefresh';
+import type { UseNotificationsOptions } from './types';
+
+export * from './types';
+
+export function useNotifications(userId: string, options: UseNotificationsOptions = {}) {
+  const { autoRefresh = false, refreshInterval = 30000, pageSize = 20 } = options;
+
+  const {
+    state,
+    setNotifications,
+    setChannels,
+    setUnreadCount,
+    setPreferences,
+    setLoading,
+    setError,
+    setHasMore,
+  } = useNotificationsState();
+
+  const setters = {
+    setNotifications,
+    setChannels,
+    setUnreadCount,
+    setPreferences,
+    setLoading,
+    setError,
+    setHasMore,
+  };
+
+  const actions = useNotificationActions(state, setters);
+  const refresh = useNotificationRefresh(pageSize, setters);
+
+  const loadMoreNotifications = () => 
+    refresh.loadMoreNotifications(state.notifications.length, state.hasMore, state.loading);
+
+  // Load initial data
+  useEffect(() => {
+    if (userId) {
+      refresh.refreshNotifications();
+      refresh.refreshChannels();
+      refresh.refreshPreferences();
+    } else {
+      setNotifications([]);
+      setChannels([]);
+      setUnreadCount(0);
+      setPreferences(null);
+    }
+  }, [userId]);
+
+  // Auto-refresh setup
+  useEffect(() => {
+    if (!autoRefresh || !userId) return;
+
+    const interval = setInterval(() => {
+      refresh.refreshNotifications();
+    }, refreshInterval);
+
+    return () => clearInterval(interval);
+  }, [autoRefresh, userId, refreshInterval]);
+
+  return {
+    ...state,
+    ...actions,
+    ...refresh,
+    loadMoreNotifications,
+  };
+}

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

@@ -0,0 +1,107 @@
+import { useCallback } 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';
+
+/**
+ * useNotificationRefresh - Offline Notification Refresh
+ *
+ * Uses AsyncStorage for local data.
+ * NO backend - pure offline.
+ */
+export const useNotificationRefresh = (pageSize: number, setters: any) => {
+  const {
+    setNotifications,
+    setUnreadCount,
+    setChannels,
+    setPreferences,
+    setLoading,
+    setError,
+    setHasMore,
+  } = setters;
+
+  const channelManager = new ChannelManager();
+  const preferencesManager = new PreferencesManager();
+
+  const refreshNotifications = useCallback(async () => {
+    try {
+      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);
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : 'Failed to load notifications'
+      );
+    } finally {
+      setLoading(false);
+    }
+  }, [pageSize, setNotifications, setUnreadCount, setHasMore, setLoading, setError]);
+
+  const loadMoreNotifications = useCallback(
+    async (currentLength: number, hasMore: boolean, loading: boolean) => {
+      if (!hasMore || loading) return;
+
+      try {
+        setLoading(true);
+        setError(null);
+
+        const data = await AsyncStorage.getItem('@notifications:list');
+        const allNotifications: Notification[] = data ? JSON.parse(data) : [];
+
+        const moreNotifications = allNotifications.slice(
+          currentLength,
+          currentLength + pageSize
+        );
+
+        setNotifications((prev: any[]) => [...prev, ...moreNotifications]);
+        setHasMore(allNotifications.length > currentLength + pageSize);
+      } catch (err) {
+        setError(
+          err instanceof Error
+            ? err.message
+            : 'Failed to load more notifications'
+        );
+      } finally {
+        setLoading(false);
+      }
+    },
+    [pageSize, setNotifications, setHasMore, setLoading, setError]
+  );
+
+  const refreshChannels = useCallback(async () => {
+    try {
+      const channelsData = await channelManager.getActiveChannels();
+      setChannels(channelsData);
+    } catch (err) {
+      // Silent failure
+    }
+  }, [setChannels]);
+
+  const refreshPreferences = useCallback(async () => {
+    try {
+      const prefsData = await preferencesManager.get();
+      setPreferences(prefsData);
+    } catch (err) {
+      // Silent failure
+    }
+  }, [setPreferences]);
+
+  return {
+    refreshNotifications,
+    loadMoreNotifications,
+    refreshChannels,
+    refreshPreferences,
+  };
+};