@umituz/react-native-settings 5.4.18 → 5.4.20

package/dist/core/utils/logger.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Logger Utility
+ *
+ * Centralized logging with development mode support.
+ * All logging should go through this utility for consistency.
+ *
+ * @example
+ * ```ts
+ * import { logger } from '@/core/utils/logger';
+ *
+ * logger.info('MyComponent', 'Component mounted');
+ * logger.error('MyService', 'Operation failed', error);
+ * ```
+ */
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug';
+export interface LogContext {
+    component?: string;
+    service?: string;
+    domain?: string;
+    operation?: string;
+}
+/**
+ * Centralized logger with development mode support
+ */
+export declare class Logger {
+    private context;
+    constructor(context: LogContext);
+    /**
+     * Log info message (only in development)
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Log warning message (only in development)
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log error message (only in development)
+     */
+    error(message: string, error?: unknown, ...args: unknown[]): void;
+    /**
+     * Log debug message (only in development)
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Create a child logger with additional context
+     */
+    child(additionalContext: Partial<LogContext>): Logger;
+    /**
+     * Format log prefix with context
+     */
+    private formatPrefix;
+}
+/**
+ * Create a logger instance with context
+ *
+ * @example
+ * ```ts
+ * const logger = createLogger({ component: 'MyComponent' });
+ * logger.info('Something happened');
+ * // Output: [INFO] | MyComponent: Something happened
+ * ```
+ */
+export declare function createLogger(context: LogContext): Logger;
+/**
+ * Default logger instance for quick usage
+ */
+export declare const logger: Logger;
+/**
+ * Convenience functions for quick logging
+ */
+export declare const log: {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, error?: unknown, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+};

package/dist/core/utils/validators.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Common Validators
+ *
+ * Reusable validation functions for domains.
+ * All validators should be pure functions.
+ *
+ * @example
+ * ```ts
+ * import { validators } from '@/core/utils/validators';
+ *
+ * if (!validators.isValidEmail(email)) {
+ *   return { error: 'Invalid email' };
+ * }
+ * ```
+ */
+/**
+ * Common validation utilities
+ */
+export declare const validators: {
+    /**
+     * Check if value is not empty (null, undefined, or empty string)
+     */
+    isNotEmpty: <T>(value: T | null | undefined | "") => value is T;
+    /**
+     * Check if string is a valid email format
+     */
+    isValidEmail: (email: string) => boolean;
+    /**
+     * Check if string is a valid URL
+     */
+    isValidUrl: (url: string) => boolean;
+    /**
+     * Check if value is within range (inclusive)
+     */
+    isInRange: (value: number, min: number, max: number) => boolean;
+    /**
+     * Check if value is a positive number
+     */
+    isPositive: (value: number) => boolean;
+    /**
+     * Check if value is a non-negative number
+     */
+    isNonNegative: (value: number) => boolean;
+    /**
+     * Check if array has items
+     */
+    hasItems: <T>(array: T[] | readonly T[]) => boolean;
+    /**
+     * Check if value is a valid ISO date string
+     */
+    isValidISODate: (dateString: string) => boolean;
+    /**
+     * Check if date is in the past
+     */
+    isPastDate: (dateString: string) => boolean;
+    /**
+     * Check if date is in the future
+     */
+    isFutureDate: (dateString: string) => boolean;
+    /**
+     * Check if object has required properties
+     */
+    hasProperties: <T extends object>(obj: T, properties: (keyof T)[]) => boolean;
+    /**
+     * Check if string meets minimum length
+     */
+    hasMinLength: (str: string, min: number) => boolean;
+    /**
+     * Check if string meets maximum length
+     */
+    hasMaxLength: (str: string, max: number) => boolean;
+    /**
+     * Check if value is one of the allowed values
+     */
+    isOneOf: <T>(value: T, allowed: readonly T[]) => boolean;
+    /**
+     * Check if time is valid (hour: minute)
+     */
+    isValidTime: (hour: number, minute: number) => boolean;
+    /**
+     * Check if time range is valid (start before end)
+     */
+    isValidTimeRange: (startHour: number, startMinute: number, endHour: number, endMinute: number) => boolean;
+};
+/**
+ * Validation result type
+ */
+export type ValidationResult<T> = {
+    valid: true;
+    data: T;
+} | {
+    valid: false;
+    error: string;
+};
+/**
+ * Create a validation result
+ */
+export declare function valid<T>(data: T): ValidationResult<T>;
+/**
+ * Create an invalid validation result
+ */
+export declare function invalid(error: string): ValidationResult<never>;
+/**
+ * Chain multiple validations
+ *
+ * @example
+ * ```ts
+ * const result = validateAll(
+ *   validators.isValidEmail(email) || 'Invalid email',
+ *   validators.hasMinLength(email, 5) || 'Email too short'
+ * );
+ * ```
+ */
+export declare function validateAll(...checks: (boolean | string)[]): ValidationResult<null>;

package/dist/domains/ai-consent/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @umituz/react-native-settings - AI Consent Domain
+ *
+ * AI consent management for React Native apps
+ * Required by Apple App Store Guidelines 5.1.1(i) & 5.1.2(i)
+ *
+ * Displays AI technology disclosure and obtains user consent before
+ * using AI generation features.
+ *
+ * Usage:
+ *   import {
+ *     AIConsentScreen,
+ *     AIConsentModal,
+ *     AIConsentSetting,
+ *     useAIConsent
+ *   } from '@umituz/react-native-settings/ai-consent';
+ *
+ *   // Show modal on app launch
+ *   const { isConsentModalVisible, handleAcceptConsent, handleDeclineConsent } = useAIConsent();
+ *
+ *   <AIConsentModal
+ *     visible={isConsentModalVisible}
+ *     onAccept={handleAcceptConsent}
+ *     onDecline={handleDeclineConsent}
+ *   />
+ *
+ *   // Add to settings screen
+ *   <AIConsentSetting />
+ */
+export { AIConsentModal } from './presentation/components/AIConsentModal';
+export type { AIConsentModalProps } from './presentation/components/AIConsentModal';
+export { AIConsentSetting } from './presentation/components/AIConsentSetting';
+export type { AIConsentSettingProps } from './presentation/components/AIConsentSetting';
+export { AIConsentScreen } from './presentation/screens/AIConsentScreen';
+export type { AIConsentScreenProps, AIConsentScreenParams, AIProvider } from './presentation/screens/AIConsentScreen';
+export { useAIConsent } from './presentation/hooks/useAIConsent';
+export type { UseAIConsentReturn, AIConsentState } from './presentation/hooks/useAIConsent';

package/dist/domains/ai-consent/presentation/components/AIConsentModal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AI Consent Modal
+ *
+ * Modal wrapper for AI consent screen.
+ * Required by Apple App Store Guidelines 5.1.1(i) & 5.1.2(i)
+ *
+ * Displays on first app launch before any AI features are used.
+ * Can also be shown manually from settings.
+ *
+ * Usage:
+ *   <AIConsentModal
+ *     visible={isConsentModalVisible}
+ *     onAccept={handleAccept}
+ *     onDecline={handleDecline}
+ *   />
+ */
+import React from 'react';
+import { type AIProvider } from '../screens/AIConsentScreen';
+export interface AIConsentModalProps {
+    visible: boolean;
+    onAccept: () => void;
+    onDecline: () => void;
+    providers?: AIProvider[];
+    customMessage?: string;
+}
+export declare const AIConsentModal: React.FC<AIConsentModalProps>;

package/dist/domains/ai-consent/presentation/components/AIConsentSetting.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AIConsentSetting Component
+ *
+ * Settings list item for AI consent management.
+ * Shows current consent status and navigates to full consent screen.
+ *
+ * Features:
+ * - Displays consent status (accepted/declined/pending)
+ * - Tappable card that opens AI consent screen
+ * - Icon with background color
+ * - Internationalized
+ * - Universal across iOS, Android, Web
+ *
+ * Usage:
+ *   import { AIConsentSetting } from '@umituz/react-native-settings/ai-consent';
+ *
+ *   <AIConsentSetting />
+ */
+import React from 'react';
+export interface AIConsentSettingProps {
+    /** Custom title */
+    title?: string;
+    /** Custom description when consented */
+    consentedDescription?: string;
+    /** Custom description when not consented */
+    notConsentedDescription?: string;
+}
+export declare const AIConsentSetting: React.FC<AIConsentSettingProps>;

package/dist/domains/ai-consent/presentation/hooks/useAIConsent.d.ts

@@ -0,0 +1,27 @@
+/**
+ * useAIConsent Hook
+ * Manages AI consent state and display logic
+ * Required by Apple App Store Guidelines 5.1.1(i) & 5.1.2(i)
+ *
+ * Features:
+ * - Checks if user has consented to AI services
+ * - Shows modal on first use
+ * - Persists consent state
+ * - Memoized for performance
+ */
+export interface AIConsentState {
+    hasConsented: boolean;
+    consentTimestamp?: number;
+    consentVersion?: string;
+}
+export interface UseAIConsentReturn {
+    isLoading: boolean;
+    isConsentModalVisible: boolean;
+    hasConsented: boolean;
+    consentState: AIConsentState | null;
+    handleAcceptConsent: () => Promise<void>;
+    handleDeclineConsent: () => void;
+    showConsentModal: () => void;
+    checkConsent: () => Promise<void>;
+}
+export declare const useAIConsent: () => UseAIConsentReturn;

package/dist/domains/ai-consent/presentation/screens/AIConsentScreen.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AI Consent Screen
+ *
+ * Full screen for displaying AI technology disclosure and consent.
+ * Required by Apple App Store Guidelines 5.1.1(i) & 5.1.2(i)
+ *
+ * Features:
+ * - Lists all AI providers and their purposes
+ * - Explains data sharing practices
+ * - Provides privacy policy links
+ * - Accept/Decline buttons
+ * - Scrollable content
+ */
+import React from 'react';
+export interface AIProvider {
+    name: string;
+    purpose: string;
+    privacyUrl: string;
+}
+export interface AIConsentScreenParams {
+    providers?: AIProvider[];
+    customMessage?: string;
+    onAccept?: () => void;
+    onDecline?: () => void;
+    [key: string]: unknown;
+}
+export interface AIConsentScreenProps {
+    route?: {
+        params?: AIConsentScreenParams;
+    };
+    providers?: AIProvider[];
+    customMessage?: string;
+    onAccept?: () => void;
+    onDecline?: () => void;
+    standalone?: boolean;
+}
+export declare const AIConsentScreen: React.FC<AIConsentScreenProps>;

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

@@ -11,7 +11,5 @@ export { DisclaimerSetting } from './presentation/components/DisclaimerSetting';
 export type { DisclaimerSettingProps } from './presentation/components/DisclaimerSetting';
 export { DisclaimerCard } from './presentation/components/DisclaimerCard';
 export type { DisclaimerCardProps } from './presentation/components/DisclaimerCard';
-export { DisclaimerModal } from './presentation/components/DisclaimerModal';
-export type { DisclaimerModalProps } from './presentation/components/DisclaimerModal';
 export { DisclaimerScreen } from './presentation/screens/DisclaimerScreen';
 export type { DisclaimerScreenProps } from './presentation/screens/DisclaimerScreen';

package/dist/domains/disclaimer/presentation/components/DisclaimerSetting.d.ts

@@ -5,10 +5,9 @@
  * Used in About screens for apps that require disclaimers
  *
  * Features:
- * - Tappable card that opens full disclaimer modal
+ * - Tappable card that opens full disclaimer screen
  * - Warning icon with background color
  * - Internationalized title and message
- * - Full-screen modal with scrollable content
  * - NO shadows (CLAUDE.md compliance)
  * - Universal across iOS, Android, Web (NO Platform.OS checks)
  *

package/dist/domains/disclaimer/presentation/screens/DisclaimerScreen.d.ts

@@ -1,27 +1,18 @@
 /**
- * DisclaimerScreen Component
+ * Disclaimer Screen
  *
- * Full-screen disclaimer display for navigation-based usage
- * Can be registered as a screen in navigation stack
- *
- * Features:
- * - SafeAreaView wrapper for proper display
- * - Scrollable content for long disclaimers
- * - Customizable title and content via props or translations
- * - NO shadows (CLAUDE.md compliance)
- * - Universal across iOS, Android, Web
+ * Full screen for displaying disclaimer/important legal notice.
+ * Replaces modal approach with native navigation.
  */
 import React from 'react';
+export interface DisclaimerScreenParams {
+    title: string;
+    content: string;
+    [key: string]: unknown;
+}
 export interface DisclaimerScreenProps {
-    /** Custom title (overrides translation) */
-    title?: string;
-    /** Custom title translation key */
-    titleKey?: string;
-    /** Custom content (overrides translation) */
-    content?: string;
-    /** Custom content translation key */
-    contentKey?: string;
-    /** Custom icon name */
-    iconName?: string;
+    route: {
+        params: DisclaimerScreenParams;
+    };
 }
 export declare const DisclaimerScreen: React.FC<DisclaimerScreenProps>;

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

@@ -3,9 +3,10 @@
  * User feedback, bug reports, feature requests
  */
 export * from './presentation/components/FeedbackForm';
-export * from './presentation/components/FeedbackModal';
 export { SupportSection } from './presentation/components/SupportSection';
 export type { SupportSectionProps, FeedbackModalTexts } from './presentation/components/SupportSection';
 export * from './presentation/hooks/useFeedbackForm';
 export * from './domain/entities/FeedbackEntity';
 export * from './domain/entities/FeatureRequestEntity';
+export { FeedbackScreen } from './presentation/screens/FeedbackScreen';
+export type { FeedbackScreenProps, FeedbackScreenParams } from './presentation/screens/FeedbackScreen';

package/dist/domains/feedback/presentation/components/SupportSection.d.ts

@@ -56,7 +56,7 @@ export interface SupportSectionProps {
         onPress: () => void;
         isLast?: boolean;
     }) => React.ReactElement | null;
-    /** Texts for the feedback modal */
+    /** Texts for the feedback screen */
     feedbackModalTexts?: FeedbackModalTexts;
 }
 export declare const SupportSection: React.FC<SupportSectionProps>;

package/dist/domains/feedback/presentation/screens/FeedbackScreen.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Feedback Screen
+ *
+ * Full screen for submitting feedback.
+ * Replaces modal approach with native navigation.
+ */
+import React from 'react';
+import type { FeedbackType } from '../../domain/entities/FeedbackEntity';
+import type { FeedbackFormProps } from '../components/FeedbackFormProps';
+export interface FeedbackScreenParams {
+    initialType?: FeedbackType;
+    title?: string;
+    texts: FeedbackFormProps['texts'];
+    [key: string]: unknown;
+}
+export interface FeedbackScreenProps {
+    route: {
+        params: FeedbackScreenParams;
+    };
+}
+export declare const FeedbackScreen: React.FC<FeedbackScreenProps>;

package/dist/domains/gamification/types/index.d.ts

@@ -61,6 +61,7 @@ export interface GamificationState {
     streak: StreakState;
     isLoading: boolean;
     isInitialized: boolean;
+    _config?: GamificationConfig;
 }
 export interface GamificationActions {
     initialize: (config: GamificationConfig) => Promise<void>;

package/dist/domains/gamification/utils/calculations.d.ts

@@ -3,6 +3,9 @@
  * Pure utility functions - NO side effects
  */
 import type { LevelDefinition, LevelState, AchievementDefinition } from "../types";
+export declare const DEFAULT_LEVEL_RANGE = 100;
+export declare const DEFAULT_POINTS_PER_LEVEL = 50;
+export declare const MAX_PROGRESS = 100;
 export declare const calculateLevel: (points: number, levels: LevelDefinition[]) => LevelState;
 export declare const checkAchievementUnlock: (definition: AchievementDefinition, tasksCompleted: number, currentStreak: number) => boolean;
 export declare const updateAchievementProgress: (definition: AchievementDefinition, tasksCompleted: number, currentStreak: number) => number;

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

@@ -10,7 +10,7 @@ export { LanguageSelectionScreen } from './presentation/screens/LanguageSelectio
 export type { LanguageSelectionScreenProps } from './presentation/screens/LanguageSelectionScreen.types';
 export { LanguageSection } from './presentation/components/LanguageSection';
 export type { LanguageSectionProps, LanguageSectionConfig } from './presentation/components/LanguageSection';
-export { default as i18n } from './infrastructure/config/i18n';
+export { i18n } from './infrastructure/config/i18n';
 export { I18nInitializer } from './infrastructure/config/I18nInitializer';
 export { DEFAULT_LANGUAGE, getLanguageByCode, isLanguageSupported, getDefaultLanguage, getDeviceLocale, searchLanguages, } from './infrastructure/config/languages';
 export type { Language, ILocalizationRepository } from './domain/repositories/ILocalizationRepository';

package/dist/domains/localization/infrastructure/config/i18n.d.ts

@@ -4,4 +4,4 @@
  * Raw i18n instance - use I18nInitializer for configuration
  */
 import i18n from 'i18next';
-export default i18n;
+export { i18n };

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

@@ -1,18 +1,21 @@
 /**
- * NotificationService
+ * Notification Service
  *
  * Simple facade for offline notification system.
  * Works in ALL apps - offline, online, hybrid - no backend required.
+ * Refactored to extend BaseService.
  *
  * @module NotificationService
  */
 import { NotificationManager } from './NotificationManager';
+import { BaseService } from '../../../../core/base/BaseService';
 export * from './types';
 /**
  * Notification service singleton
  * Provides simple access to notification manager
  */
-export declare class NotificationService {
+export declare class NotificationService extends BaseService {
+    protected serviceName: string;
     private static instance;
     private isConfigured;
     readonly notifications: NotificationManager;

package/dist/domains/notifications/quietHours/infrastructure/hooks/useQuietHoursActions.d.ts

@@ -5,9 +5,9 @@
 import type { QuietHoursConfig } from '../../../infrastructure/services/types';
 export declare const useQuietHoursActions: () => {
     quietHours: QuietHoursConfig;
-    setQuietHoursEnabled: (enabled: boolean) => Promise<void>;
-    setStartTime: (hour: number, minute: number) => Promise<void>;
-    setEndTime: (hour: number, minute: number) => Promise<void>;
-    setQuietHours: (config: QuietHoursConfig) => Promise<void>;
+    setQuietHoursEnabled: (enabled: boolean) => void;
+    setStartTime: (hour: number, minute: number) => void;
+    setEndTime: (hour: number, minute: number) => void;
+    setQuietHours: (config: QuietHoursConfig) => void;
     isInQuietHours: () => boolean;
 };

package/dist/domains/rating/application/services/RatingService.d.ts

@@ -1,33 +1,62 @@
 /**
  * Rating Service
- * Core business logic for app rating system
+ *
+ * Core business logic for app rating system.
+ * Refactored to extend BaseService for consistent error handling.
+ *
+ * @module RatingService
  */
 import type { RatingConfig, RatingState } from "../../domain/entities/RatingConfig";
-/**
- * Track an event occurrence
+import { BaseService } from "../../../../core/base/BaseService";
+/**
+ * Rating Service Class
+ */
+export declare class RatingService extends BaseService {
+    protected serviceName: string;
+    /**
+     * Track an event occurrence
+     */
+    trackEvent(eventType: string): Promise<void>;
+    /**
+     * Check if prompt should be shown based on criteria
+     */
+    shouldShowPrompt(config: RatingConfig): Promise<boolean>;
+    /**
+     * Mark that prompt was shown to user
+     */
+    markPromptShown(eventType: string): Promise<void>;
+    /**
+     * Mark that user has rated the app
+     */
+    markRated(): Promise<void>;
+    /**
+     * Mark that user permanently dismissed the prompt
+     */
+    markDismissed(): Promise<void>;
+    /**
+     * Get current rating state for event type
+     */
+    getState(eventType: string): Promise<RatingState>;
+    /**
+     * Reset rating data (for testing or specific event type)
+     */
+    reset(eventType?: string): Promise<void>;
+}
+/**
+ * Get rating service singleton instance
+ */
+export declare function getRatingService(): RatingService;
+/**
+ * Default export for backward compatibility
+ */
+export declare const ratingService: RatingService;
+/**
+ * Static convenience functions that delegate to singleton
  */
 export declare function trackEvent(eventType: string): Promise<void>;
-/**
- * Check if prompt should be shown based on criteria
- */
 export declare function shouldShowPrompt(config: RatingConfig): Promise<boolean>;
-/**
- * Mark that prompt was shown to user
- */
 export declare function markPromptShown(eventType: string): Promise<void>;
-/**
- * Mark that user has rated the app
- */
 export declare function markRated(): Promise<void>;
-/**
- * Mark that user permanently dismissed the prompt
- */
 export declare function markDismissed(): Promise<void>;
-/**
- * Get current rating state for event type
- */
 export declare function getState(eventType: string): Promise<RatingState>;
-/**
- * Reset rating data (for testing or specific event type)
- */
 export declare function reset(eventType?: string): Promise<void>;

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

@@ -7,6 +7,6 @@ export type { RatingConfig, RatingState, RatingTranslations, UseAppRatingResult,
 export { DEFAULT_RATING_CONFIG } from './domain/entities/RatingConfig';
 export { StarRating } from './presentation/components/StarRating';
 export type { StarRatingProps } from './presentation/components/StarRating';
-export { RatingPromptModal } from './presentation/components/RatingPromptModal';
-export type { RatingPromptModalProps } from './presentation/components/RatingPromptModal';
+export { RatingPromptScreen } from './presentation/screens/RatingPromptScreen';
+export type { RatingPromptScreenProps, RatingPromptScreenParams } from './presentation/screens/RatingPromptScreen';
 export { useAppRating } from './presentation/hooks/useAppRating';

package/dist/domains/rating/presentation/hooks/useAppRating.d.ts

@@ -5,6 +5,6 @@
  */
 import type { RatingConfig, UseAppRatingResult } from "../../domain/entities/RatingConfig";
 /**
- * App rating hook with 2-step prompt flow
+ * App rating hook with navigation-based prompt flow
  */
 export declare function useAppRating(config: RatingConfig): UseAppRatingResult;

package/dist/domains/rating/presentation/screens/RatingPromptScreen.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rating Prompt Screen
+ *
+ * Full screen for app rating prompt.
+ * Replaces modal approach with native navigation.
+ */
+import React from 'react';
+import type { RatingTranslations } from '../../domain/entities/RatingConfig';
+export interface RatingPromptScreenParams {
+    appName?: string;
+    translations?: RatingTranslations;
+    onPositive?: () => void;
+    onNegative?: () => void;
+    onLater?: () => void;
+    [key: string]: unknown;
+}
+export interface RatingPromptScreenProps {
+    route: {
+        params: RatingPromptScreenParams;
+    };
+}
+export declare const RatingPromptScreen: React.FC<RatingPromptScreenProps>;