@umituz/react-native-settings 5.3.36 → 5.3.38

package/dist/domains/localization/infrastructure/storage/localizationStoreUtils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Localization Store Utilities
+ * Extracted business logic for localization store
+ */
+/**
+ * Manages localization initialization state
+ */
+export declare class InitializationManager {
+    private inProgress;
+    private promise;
+    initialize(isAlreadyInitialized: boolean, setState: (state: Partial<{
+        currentLanguage: string;
+        isRTL: boolean;
+        isInitialized: boolean;
+    }>) => void): Promise<void>;
+    reset(): void;
+}
+/**
+ * Manages debounced language switching with pending promise handling
+ * FIXED: Properly rejects pending promises on error
+ */
+export declare class LanguageSwitchManager {
+    private timer;
+    private pendingResolvers;
+    /**
+     * Sets language with debounce and promise handling
+     */
+    setLanguage(languageCode: string, setState: (state: Partial<{
+        currentLanguage: string;
+        isRTL: boolean;
+    }>) => void): Promise<void>;
+    /**
+     * Clears any pending language switch and resolves all promises
+     */
+    reset(): void;
+}
+/**
+ * Localization getters
+ */
+export declare const localizationGetters: {
+    getCurrentLanguage: (currentLanguage: string) => import("./types/Language").Language;
+    isLanguageSupported: (code: string) => boolean;
+    getSupportedLanguages: () => import("./types/Language").Language[];
+};

package/dist/domains/localization/infrastructure/storage/types/Language.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Language Type
+ * Generic language interface for localization packages
+ * This is a base configuration that can be extended by consuming applications
+ */
+export interface Language {
+    code: string;
+    name: string;
+    nativeName: string;
+    flag?: string;
+    isRTL?: boolean;
+}

package/dist/domains/localization/infrastructure/storage/types/LocalizationState.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Localization State Interface
+ * Defines the shape of localization state management
+ */
+import type { Language } from './Language';
+export type { Language };
+export interface LocalizationState {
+    currentLanguage: string;
+    isRTL: boolean;
+    isInitialized: boolean;
+    supportedLanguages: Language[];
+}
+export interface LocalizationActions {
+    initialize: () => Promise<void>;
+    setLanguage: (languageCode: string) => Promise<void>;
+    reset: () => void;
+}
+export interface LocalizationGetters {
+    getCurrentLanguage: () => Language | undefined;
+    isLanguageSupported: (code: string) => boolean;
+    getSupportedLanguages: () => Language[];
+}

package/dist/domains/localization/presentation/components/LanguageItem.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Language Item Component
+ *
+ * Renders a single language item in the language selection list
+ * Theme-aware component that adapts to light/dark mode
+ */
+import React from 'react';
+import { type StyleProp, type ViewStyle, type TextStyle } from 'react-native';
+import type { Language } from '../../infrastructure/storage/types/Language';
+interface LanguageItemProps {
+    item: Language;
+    isSelected: boolean;
+    onSelect: (code: string) => void;
+    customStyles?: {
+        languageItem?: StyleProp<ViewStyle>;
+        languageContent?: StyleProp<ViewStyle>;
+        languageText?: StyleProp<ViewStyle>;
+        flag?: StyleProp<TextStyle>;
+        nativeName?: StyleProp<TextStyle>;
+    };
+}
+export declare const LanguageItem: React.FC<LanguageItemProps>;
+export {};

package/dist/domains/localization/presentation/components/LanguageItem.styles.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Language Item Component Styles
+ */
+export declare const styles: {
+    languageItem: {
+        flexDirection: "row";
+        alignItems: "center";
+        justifyContent: "space-between";
+        borderWidth: number;
+    };
+    selectedLanguageItem: {
+        borderWidth: number;
+    };
+    languageContent: {
+        flexDirection: "row";
+        alignItems: "center";
+        flex: number;
+    };
+    flag: {
+        fontSize: number;
+        marginRight: number;
+    };
+    languageText: {
+        flex: number;
+        flexShrink: number;
+    };
+    nativeName: {};
+    languageName: {};
+    checkIcon: {};
+};

package/dist/domains/localization/presentation/components/LanguageSection.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type ViewStyle } from 'react-native';
+export interface LanguageSectionConfig {
+    route?: string;
+    onPress?: () => void;
+    title?: string;
+    description?: string;
+    defaultLanguageDisplay?: string;
+}
+export interface LanguageSectionProps {
+    config?: LanguageSectionConfig;
+    containerStyle?: ViewStyle;
+    sectionTitle?: string;
+}
+export declare const LanguageSection: React.FC<LanguageSectionProps>;

package/dist/domains/localization/presentation/providers/LocalizationManager.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LocalizationProvider
+ * Initializes i18n with app translations and manages language state
+ */
+import React from "react";
+interface LocalizationProviderProps {
+    children: React.ReactNode;
+    translations: Record<string, Record<string, unknown>>;
+    defaultLanguage?: string;
+}
+export declare const LocalizationManager: React.FC<LocalizationProviderProps>;
+export {};

package/dist/domains/localization/presentation/screens/LanguageSelectionScreen.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Language Selection Screen
+ * Generic language selector with search functionality
+ */
+import React from 'react';
+import type { LanguageSelectionScreenProps } from './LanguageSelectionScreen.types';
+export declare const LanguageSelectionScreen: React.FC<LanguageSelectionScreenProps>;

package/dist/domains/localization/presentation/screens/LanguageSelectionScreen.styles.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Language Selection Screen Styles
+ */
+export declare const styles: {
+    container: {};
+    listContent: {};
+};

package/dist/domains/localization/presentation/screens/LanguageSelectionScreen.types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Language Selection Screen Types
+ */
+import type React from 'react';
+import type { Language } from '../../infrastructure/storage/types/Language';
+export interface LanguageSelectionScreenProps {
+    renderLanguageItem?: (item: Language, isSelected: boolean, onSelect: (code: string) => void) => React.ReactNode;
+    renderSearchInput?: (value: string, onChange: (value: string) => void, placeholder: string) => React.ReactNode;
+    headerTitle?: string;
+    onBackPress?: () => void;
+    styles?: {
+        container?: object;
+        searchContainer?: object;
+        languageItem?: object;
+        languageContent?: object;
+        languageText?: object;
+        flag?: object;
+        nativeName?: object;
+        searchInput?: object;
+        searchIcon?: object;
+        clearButton?: object;
+        listContent?: object;
+    };
+    searchPlaceholder?: string;
+    testID?: string;
+}

package/dist/domains/notifications/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Notifications Package - Public API
+ * Offline-first local notifications using expo-notifications
+ */
+export type { NotificationTrigger, ScheduleNotificationOptions, ScheduledNotification, TimePreset, ReminderFrequency, Reminder, CreateReminderInput, UpdateReminderInput, QuietHoursConfig, NotificationPreferences, ReminderTranslations, QuietHoursTranslations, NotificationSettingsTranslations, } from './infrastructure/services/types';
+export { notificationsConfig } from './infrastructure/config/notificationsConfig';
+export type { NotificationSetting, NotificationSection, NotificationsConfig, } from './infrastructure/config/notificationsConfig';
+export { DEFAULT_TIME_PRESETS, FREQUENCY_OPTIONS, WEEKDAY_OPTIONS, getTimePresetById, formatTime, parseTime, } from './reminders/infrastructure/config/reminderPresets';
+export type { FrequencyOption, WeekdayOption } from './reminders/infrastructure/config/reminderPresets';
+export { NotificationService, notificationService } from './infrastructure/services/NotificationService';
+export { NotificationManager } from './infrastructure/services/NotificationManager';
+export { useNotificationStore, useNotificationPermissions, useNotificationInitialized, useNotificationPreferences, useQuietHours, useReminders, useEnabledReminders, useReminderById, useRemindersLoading, useRemindersInitialized, } from './infrastructure/storage/UnifiedNotificationStore';
+export { useNotificationSettings } from './infrastructure/hooks/useNotificationSettings';
+export { useReminderActions } from './reminders/infrastructure/hooks/useReminderActions';
+export { useQuietHoursActions } from './quietHours/infrastructure/hooks/useQuietHoursActions';
+export { useNotificationSettingsUI } from './presentation/hooks/useNotificationSettingsUI';
+export { NotificationsScreen } from './presentation/screens/NotificationsScreen';
+export type { NotificationsScreenProps } from './presentation/screens/NotificationsScreen';
+export { NotificationSettingsScreen } from './presentation/screens/NotificationSettingsScreen';
+export type { NotificationSettingsScreenProps } from './presentation/screens/NotificationSettingsScreen';
+export { ReminderListScreen } from './reminders/presentation/screens/ReminderListScreen';
+export type { ReminderListScreenProps } from './reminders/presentation/screens/ReminderListScreen';
+export { NotificationsSection } from './presentation/components/NotificationsSection';
+export type { NotificationsSectionProps, NotificationsSectionConfig } from './presentation/components/NotificationsSection';
+export { TimePresetSelector } from './reminders/presentation/components/TimePresetSelector';
+export type { TimePresetSelectorProps } from './reminders/presentation/components/TimePresetSelector';
+export { FrequencySelector } from './reminders/presentation/components/FrequencySelector';
+export type { FrequencySelectorProps } from './reminders/presentation/components/FrequencySelector';
+export { WeekdaySelector } from './reminders/presentation/components/WeekdaySelector';
+export type { WeekdaySelectorProps } from './reminders/presentation/components/WeekdaySelector';
+export { ReminderItem } from './reminders/presentation/components/ReminderItem';
+export type { ReminderItemProps, ReminderItemTranslations } from './reminders/presentation/components/ReminderItem';
+export { ReminderForm } from './reminders/presentation/components/ReminderForm';
+export type { ReminderFormProps, ReminderFormTranslations } from './reminders/presentation/components/ReminderForm.constants';
+export { FormButton } from './reminders/presentation/components/FormButton';
+export type { FormButtonProps } from './reminders/presentation/components/FormButton';
+export { QuietHoursCard } from './quietHours/presentation/components/QuietHoursCard';
+export type { QuietHoursCardProps } from './quietHours/presentation/components/QuietHoursCard';
+export { RemindersNavRow } from './presentation/components/RemindersNavRow';
+export type { RemindersNavRowProps } from './presentation/components/RemindersNavRow';
+export { SettingRow } from './presentation/components/SettingRow';
+export type { SettingRowProps } from './presentation/components/SettingRow';
+export { generateId, generateReminderId } from './infrastructure/utils/idGenerator';
+export { buildTrigger } from './infrastructure/utils/triggerBuilder';
+export { useTimePicker } from './presentation/hooks/useTimePicker';
+export type { PickerMode, UseTimePickerParams, TimePickerHandlers } from './presentation/hooks/useTimePicker';

package/dist/domains/notifications/infrastructure/config/notificationsConfig.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 declare const notificationsConfig: NotificationsConfig;

package/dist/domains/notifications/infrastructure/hooks/useNotificationSettings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Simple notification settings hook
+ */
+export declare const useNotificationSettings: () => {
+    notificationsEnabled: boolean;
+    setNotificationsEnabled: (value: boolean) => void;
+    isLoading: boolean;
+};

package/dist/domains/notifications/infrastructure/services/NotificationBadgeManager.d.ts

@@ -0,0 +1,4 @@
+export declare class NotificationBadgeManager {
+    getBadgeCount(): Promise<number>;
+    setBadgeCount(count: number): Promise<void>;
+}

package/dist/domains/notifications/infrastructure/services/NotificationManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * NotificationManager - Core Notification Operations
+ *
+ * Offline-first notification system using expo-notifications.
+ * Works in ALL apps (offline, online, hybrid) - no backend required.
+ */
+import type { ScheduleNotificationOptions, ScheduledNotification } from './types';
+export declare class NotificationManager {
+    private permissions;
+    private scheduler;
+    private badgeManager;
+    constructor();
+    static configure(): void;
+    requestPermissions(): Promise<boolean>;
+    hasPermissions(): Promise<boolean>;
+    scheduleNotification(options: ScheduleNotificationOptions): Promise<string>;
+    cancelNotification(notificationId: string): Promise<void>;
+    cancelAllNotifications(): Promise<void>;
+    getScheduledNotifications(): Promise<ScheduledNotification[]>;
+    dismissAllNotifications(): Promise<void>;
+    getBadgeCount(): Promise<number>;
+    setBadgeCount(count: number): Promise<void>;
+}

package/dist/domains/notifications/infrastructure/services/NotificationPermissions.d.ts

@@ -0,0 +1,5 @@
+export declare class NotificationPermissions {
+    requestPermissions(): Promise<boolean>;
+    hasPermissions(): Promise<boolean>;
+    private createAndroidChannels;
+}

package/dist/domains/notifications/infrastructure/services/NotificationScheduler.d.ts

@@ -0,0 +1,7 @@
+import type { ScheduleNotificationOptions, ScheduledNotification } from './types';
+export declare class NotificationScheduler {
+    scheduleNotification(options: ScheduleNotificationOptions): Promise<string>;
+    cancelNotification(notificationId: string): Promise<void>;
+    cancelAllNotifications(): Promise<void>;
+    getScheduledNotifications(): Promise<ScheduledNotification[]>;
+}

package/dist/domains/notifications/infrastructure/services/NotificationService.d.ts

@@ -0,0 +1,31 @@
+/**
+ * NotificationService
+ *
+ * Simple facade for offline notification system.
+ * Works in ALL apps - offline, online, hybrid - no backend required.
+ *
+ * @module NotificationService
+ */
+import { NotificationManager } from './NotificationManager';
+export * from './types';
+/**
+ * Notification service singleton
+ * Provides simple access to notification manager
+ */
+export declare class NotificationService {
+    private static instance;
+    private isConfigured;
+    readonly notifications: NotificationManager;
+    private constructor();
+    private ensureConfigured;
+    static getInstance(): NotificationService;
+    /**
+     * Request notification permissions
+     */
+    requestPermissions(): Promise<boolean>;
+    /**
+     * Check if permissions are granted
+     */
+    hasPermissions(): Promise<boolean>;
+}
+export declare const notificationService: NotificationService;

package/dist/domains/notifications/infrastructure/services/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Offline-First Notification Types
+ * Uses expo-notifications for local device notifications
+ */
+import * as Notifications from 'expo-notifications';
+export interface NotificationChannel {
+    id: string;
+    channel_type: 'push' | 'in_app';
+    channel_address: string;
+    preferences: Record<string, unknown>;
+    is_verified: boolean;
+    is_active: boolean;
+    created_at: string;
+}
+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;
+};
+export type NotificationData = Record<string, string | number | boolean | null>;
+export interface ScheduleNotificationOptions {
+    title: string;
+    body: string;
+    data?: NotificationData;
+    trigger: NotificationTrigger;
+    sound?: boolean | string;
+    badge?: number;
+    categoryIdentifier?: string;
+}
+export interface ScheduledNotification {
+    identifier: string;
+    content: {
+        title: string;
+        body: string;
+        data: NotificationData;
+    };
+    trigger: Notifications.NotificationTrigger;
+}
+export interface TimePreset {
+    id: string;
+    hour: number;
+    minute: number;
+    labelKey: string;
+    iconName: string;
+}
+export type ReminderFrequency = 'once' | 'daily' | 'weekly' | 'monthly';
+export interface Reminder {
+    id: string;
+    title: string;
+    body: string;
+    frequency: ReminderFrequency;
+    timePresetId?: string;
+    hour: number;
+    minute: number;
+    weekday?: number;
+    dayOfMonth?: number;
+    enabled: boolean;
+    notificationId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateReminderInput {
+    title: string;
+    body: string;
+    frequency: ReminderFrequency;
+    timePresetId?: string;
+    hour: number;
+    minute: number;
+    weekday?: number;
+    dayOfMonth?: number;
+}
+export interface UpdateReminderInput {
+    title?: string;
+    body?: string;
+    frequency?: ReminderFrequency;
+    timePresetId?: string;
+    hour?: number;
+    minute?: number;
+    weekday?: number;
+    dayOfMonth?: number;
+    enabled?: boolean;
+}
+export interface QuietHoursConfig {
+    enabled: boolean;
+    startHour: number;
+    startMinute: number;
+    endHour: number;
+    endMinute: number;
+}
+export interface NotificationPreferences {
+    enabled: boolean;
+    sound: boolean;
+    vibration: boolean;
+    quietHours: QuietHoursConfig;
+}
+export interface ReminderTranslations {
+    screenTitle: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    addButtonLabel: string;
+    editButtonLabel: string;
+    deleteButtonLabel: string;
+    enabledLabel: string;
+    disabledLabel: string;
+    frequencyOnce: string;
+    frequencyDaily: string;
+    frequencyWeekly: string;
+    frequencyMonthly: string;
+    timeLabel: string;
+    titlePlaceholder: string;
+    bodyPlaceholder: string;
+    saveButtonLabel: string;
+    cancelButtonLabel: string;
+}
+export interface QuietHoursTranslations {
+    title: string;
+    description: string;
+    startTimeLabel: string;
+    endTimeLabel: string;
+    enabledLabel: string;
+}
+export interface NotificationSettingsTranslations {
+    screenTitle: string;
+    masterToggleTitle: string;
+    masterToggleDescription: string;
+    soundTitle: string;
+    soundDescription: string;
+    vibrationTitle: string;
+    vibrationDescription: string;
+    remindersTitle: string;
+    remindersDescription: string;
+    quietHoursTitle: string;
+    quietHoursDescription: string;
+}

package/dist/domains/notifications/infrastructure/storage/UnifiedNotificationStore.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Unified Notification Store
+ * Consolidates NotificationsStore, RemindersStore, and PreferencesStore
+ *
+ * Production-ready implementation with:
+ * - Single source of truth for all notification state
+ * - Proper state partializing (transient vs persistent)
+ * - Type-safe actions and selectors
+ * - Data migration support
+ */
+import type { Reminder, QuietHoursConfig, NotificationPreferences } from '../services/types';
+interface NotificationState {
+    hasPermissions: boolean;
+    isInitialized: boolean;
+    isLoading: boolean;
+    preferences: NotificationPreferences;
+    reminders: Reminder[];
+}
+interface NotificationActions {
+    setPermissions: (granted: boolean) => void;
+    setInitialized: (initialized: boolean) => void;
+    initialize: () => void;
+    updatePreferences: (updates: Partial<NotificationPreferences>) => void;
+    updateQuietHours: (quietHours: QuietHoursConfig) => void;
+    addReminder: (reminder: Reminder) => void;
+    updateReminder: (id: string, updates: Partial<Reminder>) => void;
+    deleteReminder: (id: string) => void;
+    toggleReminder: (id: string) => void;
+    reset: () => void;
+    resetReminders: () => void;
+}
+export declare const useNotificationStore: import("zustand").UseBoundStore<import("zustand").StoreApi<NotificationState & NotificationActions>>;
+export declare const useNotificationPermissions: () => boolean;
+export declare const useNotificationInitialized: () => boolean;
+export declare const useRemindersLoading: () => boolean;
+export declare const useRemindersInitialized: () => boolean;
+export declare const useNotificationPreferences: () => NotificationPreferences;
+export declare const useQuietHours: () => QuietHoursConfig;
+export declare const useReminders: () => Reminder[];
+export declare const useEnabledReminders: () => Reminder[];
+export declare const useReminderById: (id: string) => Reminder;
+export {};

package/dist/domains/notifications/infrastructure/utils/idGenerator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ID Generator Utility
+ * Generates unique IDs for entities
+ */
+export declare const generateId: (prefix?: string) => string;
+export declare const generateReminderId: () => string;

package/dist/domains/notifications/infrastructure/utils/triggerBuilder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Trigger Builder Utility
+ * Builds notification triggers from reminder data
+ */
+import type { NotificationTrigger, Reminder } from '../services/types';
+export declare const buildTrigger: (reminder: Reminder) => NotificationTrigger;

package/dist/domains/notifications/presentation/components/NotificationsSection.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { StyleProp, ViewStyle } from 'react-native';
+export interface NotificationsSectionConfig {
+    route?: string;
+    onPress?: () => void;
+    title?: string;
+    description?: string;
+    sectionTitle?: string;
+}
+export interface NotificationsSectionProps {
+    config?: NotificationsSectionConfig;
+    containerStyle?: StyleProp<ViewStyle>;
+    noBackground?: boolean;
+    hideMargin?: boolean;
+}
+export declare const NotificationsSection: React.FC<NotificationsSectionProps>;

package/dist/domains/notifications/presentation/components/RemindersNavRow.d.ts

@@ -0,0 +1,12 @@
+/**
+ * RemindersNavRow Component
+ * Reusable navigation row for reminders section with badge
+ */
+import React from 'react';
+export interface RemindersNavRowProps {
+    title: string;
+    description: string;
+    count: number;
+    onPress: () => void;
+}
+export declare const RemindersNavRow: React.FC<RemindersNavRowProps>;

package/dist/domains/notifications/presentation/components/RemindersNavRow.styles.d.ts

@@ -0,0 +1,34 @@
+/**
+ * RemindersNavRow Styles
+ */
+import type { DesignTokens } from '@umituz/react-native-design-system/theme';
+export declare const createStyles: (tokens: DesignTokens) => {
+    navRow: {
+        flexDirection: "row";
+        alignItems: "center";
+    };
+    iconContainer: {
+        width: number;
+        height: number;
+        borderRadius: number;
+        backgroundColor: string;
+        justifyContent: "center";
+        alignItems: "center";
+        marginRight: number;
+    };
+    textContainer: {
+        flex: number;
+        marginRight: number;
+    };
+    badge: {
+        backgroundColor: string;
+        paddingHorizontal: number;
+        paddingVertical: number;
+        borderRadius: number;
+        marginRight: number;
+    };
+    badgeText: {
+        color: string;
+        fontWeight: "600";
+    };
+};

package/dist/domains/notifications/presentation/components/SettingRow.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Setting Row Component
+ * Reusable toggle row for settings
+ */
+import React from 'react';
+export interface SettingRowProps {
+    iconName: string;
+    title: string;
+    description: string;
+    value: boolean;
+    onToggle: (value: boolean) => void;
+    onHapticFeedback?: () => void;
+}
+export declare const SettingRow: React.FC<SettingRowProps>;