@umituz/react-native-notifications 1.1.7 → 1.3.1

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

@@ -1,131 +0,0 @@
-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';
-
-export const useNotificationRefresh = (pageSize: number, setters: any) => {
-  const {
-    setNotifications,
-    setUnreadCount,
-    setChannels,
-    setPreferences,
-    setLoading,
-    setError,
-    setHasMore,
-  } = setters;
-
-  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);
-
-      const data = await AsyncStorage.getItem('@notifications:list');
-      const allNotifications: Notification[] = data ? JSON.parse(data) : [];
-
-      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, 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);
-
-        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);
-
-        devLog('[useNotificationRefresh] Loaded more notifications:', moreNotifications.length);
-      } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') {
-          return;
-        }
-        setError(
-          err instanceof Error
-            ? err.message
-            : 'Failed to load more notifications'
-        );
-      } finally {
-        setLoading(false);
-        cleanup();
-      }
-    },
-    [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) {
-      devError('[useNotificationRefresh] Failed to refresh channels:', err);
-    }
-  }, [setChannels]);
-
-  const refreshPreferences = useCallback(async () => {
-    try {
-      const prefsData = await preferencesManager.get();
-      setPreferences(prefsData);
-
-      devLog('[useNotificationRefresh] Refreshed preferences');
-    } catch (err) {
-      devError('[useNotificationRefresh] Failed to refresh preferences:', err);
-    }
-  }, [setPreferences]);
-
-  return {
-    refreshNotifications,
-    loadMoreNotifications,
-    refreshChannels,
-    refreshPreferences,
-    cleanup,
-  };
-};

package/src/infrastructure/services/channels/ChannelManager.ts

@@ -1,111 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import * as Notifications from 'expo-notifications';
-import type { NotificationChannel } from '../types';
-
-/**
- * ChannelManager - Offline Notification Channel Management
- *
- * Manages push notification tokens and preferences in AsyncStorage.
- * Only supports local push and in-app notifications.
- *
- * NO backend, NO email/SMS - pure offline.
- */
-export class ChannelManager {
-  private static STORAGE_KEY = '@notifications:channels';
-
-  async register(
-    channelType: 'push' | 'in_app',
-    preferences: Record<string, any> = {}
-  ): Promise<NotificationChannel | null> {
-    try {
-      // Get push token for local notifications
-      const token =
-        channelType === 'push'
-          ? (await Notifications.getExpoPushTokenAsync()).data
-          : 'in_app';
-
-      const channel: NotificationChannel = {
-        id: `${channelType}_${Date.now()}`,
-        channel_type: channelType,
-        channel_address: token,
-        preferences,
-        is_verified: true, // Local channels always verified
-        is_active: true,
-        created_at: new Date().toISOString(),
-      };
-
-      // Store in AsyncStorage
-      const channels = await this.getAllChannels();
-      channels.push(channel);
-      await AsyncStorage.setItem(
-        ChannelManager.STORAGE_KEY,
-        JSON.stringify(channels)
-      );
-
-      return channel;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  async verify(channelId: string): Promise<boolean> {
-    try {
-      const channels = await this.getAllChannels();
-      const index = channels.findIndex((c) => c.id === channelId);
-
-      if (index !== -1) {
-        channels[index].is_verified = true;
-        await AsyncStorage.setItem(
-          ChannelManager.STORAGE_KEY,
-          JSON.stringify(channels)
-        );
-        return true;
-      }
-
-      return false;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  async getActiveChannels(): Promise<NotificationChannel[]> {
-    try {
-      const channels = await this.getAllChannels();
-      return channels.filter((c) => c.is_active && c.is_verified);
-    } catch (error) {
-      return [];
-    }
-  }
-
-  private async getAllChannels(): Promise<NotificationChannel[]> {
-    try {
-      const data = await AsyncStorage.getItem(ChannelManager.STORAGE_KEY);
-      return data ? JSON.parse(data) : [];
-    } catch (error) {
-      return [];
-    }
-  }
-
-  private async update(
-    channelId: string,
-    updates: Partial<NotificationChannel>
-  ): Promise<NotificationChannel | null> {
-    try {
-      const channels = await this.getAllChannels();
-      const index = channels.findIndex((c) => c.id === channelId);
-
-      if (index !== -1) {
-        channels[index] = { ...channels[index], ...updates };
-        await AsyncStorage.setItem(
-          ChannelManager.STORAGE_KEY,
-          JSON.stringify(channels)
-        );
-        return channels[index];
-      }
-
-      return null;
-    } catch (error) {
-      return null;
-    }
-  }
-}

package/src/infrastructure/services/delivery/NotificationDelivery.ts

@@ -1,83 +0,0 @@
-import * as Notifications from 'expo-notifications';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import type { Notification } from '../types';
-import { devLog, devError } from '../../utils/dev';
-
-export class NotificationDelivery {
-  private static STORAGE_KEY = '@notifications:delivered';
-
-  async deliver(notification: Notification): Promise<void> {
-    try {
-      await Notifications.scheduleNotificationAsync({
-        content: {
-          title: notification.title,
-          body: notification.body,
-          data: { notificationId: notification.id },
-        },
-        trigger: notification.scheduled_for
-          ? { date: new Date(notification.scheduled_for) }
-          : null,
-      });
-
-      await this.updateStatus(notification.id, 'delivered');
-
-      devLog('[NotificationDelivery] Notification delivered:', notification.id);
-    } catch (error) {
-      await this.updateStatus(notification.id, 'failed');
-      
-      devError('[NotificationDelivery] Delivery failed:', notification.id, error);
-      throw error;
-    }
-  }
-
-  private async updateStatus(
-    notificationId: string,
-    status: 'delivered' | 'failed'
-  ): Promise<void> {
-    try {
-      const delivered = await this.getDelivered();
-      delivered[notificationId] = {
-        status,
-        delivered_at: new Date().toISOString(),
-      };
-      await AsyncStorage.setItem(
-        NotificationDelivery.STORAGE_KEY,
-        JSON.stringify(delivered)
-      );
-
-      devLog('[NotificationDelivery] Status updated:', notificationId, status);
-    } catch (error) {
-      devError('[NotificationDelivery] Status update failed:', notificationId, error);
-    }
-  }
-
-  private async getDelivered(): Promise<Record<string, any>> {
-    try {
-      const data = await AsyncStorage.getItem(NotificationDelivery.STORAGE_KEY);
-      return data ? JSON.parse(data) : {};
-    } catch (error) {
-      devError('[NotificationDelivery] Failed to get delivered notifications:', error);
-      return {};
-    }
-  }
-
-  async getDeliveryStatus(notificationId: string): Promise<string | null> {
-    try {
-      const delivered = await this.getDelivered();
-      return delivered[notificationId]?.status || null;
-    } catch (error) {
-      devError('[NotificationDelivery] Failed to get delivery status:', notificationId, error);
-      return null;
-    }
-  }
-
-  async clearDeliveryHistory(): Promise<void> {
-    try {
-      await AsyncStorage.removeItem(NotificationDelivery.STORAGE_KEY);
-      
-      devLog('[NotificationDelivery] Delivery history cleared');
-    } catch (error) {
-      devError('[NotificationDelivery] Failed to clear delivery history:', error);
-    }
-  }
-}

package/src/infrastructure/services/preferences/PreferencesManager.ts

@@ -1,77 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import type { NotificationPreferences } from '../types';
-
-/**
- * PreferencesManager - Offline Notification Preferences
- *
- * Stores preferences in AsyncStorage (offline-capable).
- * Only supports local push and in-app notifications.
- *
- * NO backend, NO email/SMS - pure offline.
- */
-export class PreferencesManager {
-  private static STORAGE_KEY = '@notifications:preferences';
-
-  async get(): Promise<NotificationPreferences> {
-    try {
-      const data = await AsyncStorage.getItem(PreferencesManager.STORAGE_KEY);
-      return data ? JSON.parse(data) : this.getDefaults();
-    } catch (error) {
-      return this.getDefaults();
-    }
-  }
-
-  async update(preferences: Partial<NotificationPreferences>): Promise<boolean> {
-    try {
-      const current = await this.get();
-      const updated = {
-        ...current,
-        ...preferences,
-        categories: { ...current.categories, ...preferences.categories },
-      };
-
-      await AsyncStorage.setItem(
-        PreferencesManager.STORAGE_KEY,
-        JSON.stringify(updated)
-      );
-
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  isChannelEnabled(
-    channelType: 'push' | 'in_app',
-    prefs: NotificationPreferences
-  ): boolean {
-    if (channelType === 'in_app') return true;
-    return prefs.push_enabled ?? true;
-  }
-
-  isInQuietHours(quietHours: NotificationPreferences['quiet_hours']): boolean {
-    if (!quietHours.enabled) return false;
-    const currentTime = new Date().toTimeString().slice(0, 5);
-    return (
-      currentTime >= quietHours.start_time ||
-      currentTime <= quietHours.end_time
-    );
-  }
-
-  private getDefaults(): NotificationPreferences {
-    return {
-      push_enabled: true,
-      quiet_hours: {
-        enabled: false,
-        start_time: '22:00',
-        end_time: '08:00',
-        timezone: 'UTC',
-      },
-      categories: {
-        reminders: { push: true, in_app: true },
-        updates: { push: true, in_app: true },
-        alerts: { push: true, in_app: true },
-      },
-    };
-  }
-}