@umituz/react-native-settings 5.3.36 → 5.3.38

package/dist/domains/notifications/presentation/hooks/useNotificationSettingsUI.d.ts

@@ -0,0 +1,13 @@
+/**
+ * useNotificationSettingsUI Hook
+ * Handles all business logic for notification settings screen
+ */
+export declare const useNotificationSettingsUI: () => {
+    preferences: import("../..").NotificationPreferences;
+    quietHours: import("../..").QuietHoursConfig;
+    isLoading: boolean;
+    handleMasterToggle: (value: boolean) => Promise<void>;
+    handleSoundToggle: (value: boolean) => Promise<void>;
+    handleVibrationToggle: (value: boolean) => Promise<void>;
+    handleQuietHoursToggle: (value: boolean) => Promise<void>;
+};

package/dist/domains/notifications/presentation/hooks/useTimePicker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useTimePicker Hook
+ * Encapsulates DateTimePicker logic for notification settings
+ */
+import type { QuietHoursConfig } from '../../infrastructure/services/types';
+export type PickerMode = 'start' | 'end' | null;
+export interface UseTimePickerParams {
+    quietHours: QuietHoursConfig;
+    onStartTimeChange: (hours: number, minutes: number) => void;
+    onEndTimeChange: (hours: number, minutes: number) => void;
+}
+export interface TimePickerHandlers {
+    pickerMode: PickerMode;
+    handleStartTimePress: () => void;
+    handleEndTimePress: () => void;
+    handleTimeChange: (event: {
+        type: string;
+    }, selectedDate?: Date) => void;
+    getPickerDate: () => Date;
+}
+export declare const useTimePicker: ({ quietHours, onStartTimeChange, onEndTimeChange, }: UseTimePickerParams) => TimePickerHandlers;

package/dist/domains/notifications/presentation/screens/NotificationSettingsScreen.d.ts

@@ -0,0 +1,12 @@
+/**
+ * NotificationSettingsScreen
+ * Clean presentation-only screen for notification settings
+ */
+import React from 'react';
+import type { NotificationSettingsTranslations, QuietHoursTranslations } from '../../infrastructure/services/types';
+export interface NotificationSettingsScreenProps {
+    translations: NotificationSettingsTranslations;
+    quietHoursTranslations: QuietHoursTranslations;
+    onHapticFeedback?: () => void;
+}
+export declare const NotificationSettingsScreen: React.FC<NotificationSettingsScreenProps>;

package/dist/domains/notifications/presentation/screens/NotificationSettingsScreen.styles.d.ts

@@ -0,0 +1,26 @@
+/**
+ * NotificationSettingsScreen Styles
+ * Extracted styles for better organization and maintainability
+ */
+import type { DesignTokens } from '@umituz/react-native-design-system/theme';
+export declare const createStyles: (tokens: DesignTokens) => {
+    container: {
+        flex: number;
+        padding: number;
+    };
+    loadingContainer: {
+        flex: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+    card: {
+        marginBottom: number;
+        padding: number;
+        backgroundColor: string;
+    };
+    divider: {
+        height: number;
+        backgroundColor: string;
+        marginVertical: number;
+    };
+};

package/dist/domains/notifications/presentation/screens/NotificationsScreen.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Notifications Screen - Dynamic and Reusable
+ *
+ * A clean notification settings screen that accepts all text and configuration
+ * as props to make it completely reusable across different applications.
+ */
+import React from 'react';
+export interface NotificationsScreenProps {
+    translations: {
+        title: string;
+        description: string;
+        loadingText?: string;
+    };
+    iconName?: string;
+    iconColor?: string;
+    testID?: string;
+}
+export declare const NotificationsScreen: React.FC<NotificationsScreenProps>;

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

@@ -0,0 +1,13 @@
+/**
+ * useQuietHoursActions Hook
+ * Manages quiet hours configuration
+ */
+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>;
+    isInQuietHours: () => boolean;
+};

package/dist/domains/notifications/quietHours/presentation/components/QuietHoursCard.d.ts

@@ -0,0 +1,14 @@
+/**
+ * QuietHoursCard Component
+ * Displays and manages quiet hours settings
+ */
+import React from 'react';
+import type { QuietHoursConfig, QuietHoursTranslations } from '../../../infrastructure/services/types';
+export interface QuietHoursCardProps {
+    config: QuietHoursConfig;
+    translations: QuietHoursTranslations;
+    onToggle: (enabled: boolean) => void;
+    onStartTimePress: () => void;
+    onEndTimePress: () => void;
+}
+export declare const QuietHoursCard: React.FC<QuietHoursCardProps>;

package/dist/domains/notifications/reminders/infrastructure/config/reminderPresets.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Reminder Presets Configuration
+ * Default time presets and frequency options for reminders
+ */
+import type { TimePreset, ReminderFrequency } from '../../../infrastructure/services/types';
+export declare const DEFAULT_TIME_PRESETS: TimePreset[];
+export interface FrequencyOption {
+    id: ReminderFrequency;
+    labelKey: string;
+    iconName: string;
+}
+export declare const FREQUENCY_OPTIONS: FrequencyOption[];
+export interface WeekdayOption {
+    id: number;
+    labelKey: string;
+    shortLabelKey: string;
+}
+export declare const WEEKDAY_OPTIONS: WeekdayOption[];
+export declare const getTimePresetById: (id: string) => TimePreset | undefined;
+export declare const formatTime: (hour: number, minute: number) => string;
+export declare const parseTime: (timeString: string) => {
+    hour: number;
+    minute: number;
+};

package/dist/domains/notifications/reminders/infrastructure/hooks/useReminderActions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * useReminderActions Hook
+ * Handles reminder CRUD operations with notification scheduling
+ */
+import type { Reminder, CreateReminderInput, UpdateReminderInput } from '../../../infrastructure/services/types';
+export declare const useReminderActions: () => {
+    createReminder: (input: CreateReminderInput) => Promise<Reminder>;
+    editReminder: (id: string, input: UpdateReminderInput) => Promise<void>;
+    removeReminder: (id: string) => Promise<void>;
+    toggleReminderEnabled: (id: string) => Promise<void>;
+};

package/dist/domains/notifications/reminders/presentation/components/FormButton.d.ts

@@ -0,0 +1,12 @@
+/**
+ * FormButton Component
+ * Simple button for forms
+ */
+import React from 'react';
+export interface FormButtonProps {
+    label: string;
+    onPress: () => void;
+    variant?: 'primary' | 'secondary';
+    disabled?: boolean;
+}
+export declare const FormButton: React.FC<FormButtonProps>;

package/dist/domains/notifications/reminders/presentation/components/FrequencySelector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * FrequencySelector Component
+ * Allows selection of reminder frequency
+ */
+import React from 'react';
+import type { ReminderFrequency } from '../../../infrastructure/services/types';
+import type { FrequencyOption } from '../../infrastructure/config/reminderPresets';
+export interface FrequencySelectorProps {
+    options: FrequencyOption[];
+    selectedFrequency: ReminderFrequency;
+    onSelect: (frequency: ReminderFrequency) => void;
+    getLabel: (labelKey: string) => string;
+}
+export declare const FrequencySelector: React.FC<FrequencySelectorProps>;

package/dist/domains/notifications/reminders/presentation/components/ReminderForm.constants.d.ts

@@ -0,0 +1,28 @@
+import type { Reminder, CreateReminderInput, TimePreset } from '../../../infrastructure/services/types';
+export declare const DEFAULT_HOUR = 9;
+export declare const DEFAULT_MINUTE = 0;
+export declare const DEFAULT_WEEKDAY = 2;
+export declare const MAX_TITLE_LENGTH = 100;
+export declare const MAX_BODY_LENGTH = 500;
+export interface ReminderFormTranslations {
+    titleLabel: string;
+    titlePlaceholder: string;
+    bodyLabel: string;
+    bodyPlaceholder: string;
+    timeLabel: string;
+    frequencyLabel: string;
+    weekdayLabel: string;
+    saveButton: string;
+    cancelButton: string;
+    customTimeLabel: string;
+    getPresetLabel: (key: string) => string;
+    getFrequencyLabel: (key: string) => string;
+    getWeekdayLabel: (key: string) => string;
+}
+export interface ReminderFormProps {
+    initialData?: Reminder;
+    translations: ReminderFormTranslations;
+    onSave: (data: CreateReminderInput) => void;
+    onCancel: () => void;
+    timePresets?: TimePreset[];
+}

package/dist/domains/notifications/reminders/presentation/components/ReminderForm.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ReminderForm Component
+ * Form for creating and editing reminders
+ */
+import React from 'react';
+import { type ReminderFormProps } from './ReminderForm.constants';
+export declare const ReminderForm: React.FC<ReminderFormProps>;

package/dist/domains/notifications/reminders/presentation/components/ReminderForm.styles.d.ts

@@ -0,0 +1,31 @@
+import type { useAppDesignTokens } from '@umituz/react-native-design-system/theme';
+export declare const createReminderFormStyles: (tokens: ReturnType<typeof useAppDesignTokens>) => {
+    container: {
+        flex: number;
+        padding: number;
+        backgroundColor: string;
+    };
+    section: {
+        marginBottom: number;
+    };
+    label: {
+        color: string;
+        marginBottom: number;
+    };
+    input: {
+        backgroundColor: string;
+        borderRadius: number;
+        padding: number;
+        fontSize: number;
+        color: string;
+    };
+    multilineInput: {
+        minHeight: number;
+        textAlignVertical: "top";
+    };
+    buttonRow: {
+        flexDirection: "row";
+        gap: number;
+        marginTop: number;
+    };
+};

package/dist/domains/notifications/reminders/presentation/components/ReminderItem.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ReminderItem Component
+ * Displays a single reminder with toggle and actions
+ */
+import React from 'react';
+import type { Reminder } from '../../../infrastructure/services/types';
+export interface ReminderItemTranslations {
+    frequencyOnce: string;
+    frequencyDaily: string;
+    frequencyWeekly: string;
+    frequencyMonthly: string;
+}
+export interface ReminderItemProps {
+    reminder: Reminder;
+    translations: ReminderItemTranslations;
+    onToggle: (id: string) => void;
+    onEdit: (reminder: Reminder) => void;
+    onDelete: (id: string) => void;
+}
+export declare const ReminderItem: React.FC<ReminderItemProps>;

package/dist/domains/notifications/reminders/presentation/components/TimePresetSelector.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TimePresetSelector Component
+ * Allows selection of preset times or custom time
+ */
+import React from 'react';
+import type { TimePreset } from '../../../infrastructure/services/types';
+export interface TimePresetSelectorProps {
+    presets: TimePreset[];
+    selectedPresetId?: string;
+    customTime?: {
+        hour: number;
+        minute: number;
+    };
+    onSelectPreset: (preset: TimePreset) => void;
+    onSelectCustom: () => void;
+    getPresetLabel: (labelKey: string) => string;
+    customLabel: string;
+    isCustomSelected: boolean;
+}
+export declare const TimePresetSelector: React.FC<TimePresetSelectorProps>;

package/dist/domains/notifications/reminders/presentation/components/WeekdaySelector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WeekdaySelector Component
+ * Allows selection of a weekday for weekly reminders
+ */
+import React from 'react';
+export interface WeekdaySelectorProps {
+    selectedWeekday: number;
+    onSelect: (weekday: number) => void;
+    getLabel: (key: string) => string;
+}
+export declare const WeekdaySelector: React.FC<WeekdaySelectorProps>;

package/dist/domains/notifications/reminders/presentation/screens/ReminderListScreen.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ReminderListScreen
+ * Displays list of reminders with add, edit, delete functionality
+ */
+import React from 'react';
+import type { Reminder, ReminderTranslations } from '../../../infrastructure/services/types';
+export interface ReminderListScreenProps {
+    translations: ReminderTranslations;
+    onAddPress: () => void;
+    onEditPress: (reminder: Reminder) => void;
+    maxReminders?: number;
+}
+export declare const ReminderListScreen: React.FC<ReminderListScreenProps>;

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

@@ -0,0 +1,33 @@
+/**
+ * Rating Service
+ * Core business logic for app rating system
+ */
+import type { RatingConfig, RatingState } from "../../domain/entities/RatingConfig";
+/**
+ * Track an event occurrence
+ */
+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/domain/entities/Rating.d.ts

@@ -0,0 +1,15 @@
+export type RatingValue = 0 | 1 | 2 | 3 | 4 | 5;
+export interface Rating {
+    id: string;
+    userId: string;
+    entityId: string;
+    entityType: string;
+    value: RatingValue;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RatingStats {
+    average: number;
+    count: number;
+    distribution: Record<RatingValue, number>;
+}

package/dist/domains/rating/domain/entities/RatingConfig.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Rating Configuration
+ * Types and interfaces for app rating system
+ */
+import type React from "react";
+/**
+ * Rating prompt configuration
+ */
+export interface RatingConfig {
+    /**
+     * Type of event to track (e.g., "ai_generation", "onboarding_completed")
+     */
+    eventType: string;
+    /**
+     * Minimum number of events before showing prompt
+     * @default 3
+     */
+    minEventCount?: number;
+    /**
+     * Cooldown period in days before showing prompt again
+     * @default 90
+     */
+    cooldownDays?: number;
+    /**
+     * App name to display in prompt
+     */
+    appName?: string;
+    /**
+     * Custom translations for the prompt
+     */
+    translations?: RatingTranslations;
+    /**
+     * Callback when user gives positive feedback
+     */
+    onPositiveFeedback?: () => void | Promise<void>;
+    /**
+     * Callback when user gives negative feedback
+     */
+    onNegativeFeedback?: () => void | Promise<void>;
+    /**
+     * Callback after prompt is shown
+     */
+    onPromptShown?: () => void | Promise<void>;
+    /**
+     * Callback when prompt is dismissed
+     */
+    onPromptDismissed?: () => void | Promise<void>;
+}
+/**
+ * Custom translations for rating prompt
+ */
+export interface RatingTranslations {
+    title: string;
+    message: string;
+    positiveButton: string;
+    negativeButton: string;
+    laterButton?: string;
+}
+/**
+ * Rating state stored in AsyncStorage
+ */
+export interface RatingState {
+    /**
+     * Event count for specific event type
+     */
+    eventCount: number;
+    /**
+     * Last time prompt was shown (ISO date string)
+     */
+    lastPromptDate: string | null;
+    /**
+     * Whether user has rated the app
+     */
+    hasRated: boolean;
+    /**
+     * Whether user permanently dismissed the prompt
+     */
+    dismissed: boolean;
+}
+/**
+ * Result of useAppRating hook
+ */
+export interface UseAppRatingResult {
+    /**
+     * Track an event (e.g., generation completed)
+     */
+    trackEvent: () => Promise<void>;
+    /**
+     * Check if should show prompt and show it automatically
+     */
+    checkAndShow: () => Promise<boolean>;
+    /**
+     * Manually check if criteria is met (without showing)
+     */
+    shouldShow: () => Promise<boolean>;
+    /**
+     * Manually show the rating prompt
+     */
+    showPrompt: () => Promise<void>;
+    /**
+     * Reset all rating data (for testing)
+     */
+    reset: () => Promise<void>;
+    /**
+     * Get current rating state
+     */
+    getState: () => Promise<RatingState>;
+    /**
+     * Whether prompt is currently visible
+     */
+    isVisible: boolean;
+    /**
+     * Modal component to render in your screen
+     */
+    modal: React.ReactNode;
+}
+/**
+ * Default rating configuration
+ */
+export declare const DEFAULT_RATING_CONFIG: Required<Omit<RatingConfig, "onPositiveFeedback" | "onNegativeFeedback" | "onPromptShown" | "onPromptDismissed">>;

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

@@ -0,0 +1,12 @@
+/**
+ * Rating Domain
+ * Star ratings, user reviews, statistics, and app store rating prompts
+ */
+export type { RatingValue, Rating, RatingStats, } from './domain/entities/Rating';
+export type { RatingConfig, RatingState, RatingTranslations, UseAppRatingResult, } from './domain/entities/RatingConfig';
+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 { useAppRating } from './presentation/hooks/useAppRating';

package/dist/domains/rating/infrastructure/storage/RatingStorage.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Rating Storage Repository
+ * Storage layer for rating system using design system storageRepository
+ */
+import type { RatingState } from "../../domain/entities/RatingConfig";
+/**
+ * Get event count for specific event type
+ */
+export declare function getEventCount(eventType: string): Promise<number>;
+/**
+ * Set event count for specific event type
+ */
+export declare function setEventCount(eventType: string, count: number): Promise<void>;
+/**
+ * Increment event count for specific event type.
+ * Chains operations per-key to prevent concurrent read-modify-write races.
+ */
+export declare function incrementEventCount(eventType: string): Promise<void>;
+/**
+ * Get last prompt date for specific event type
+ */
+export declare function getLastPromptDate(eventType: string): Promise<string | null>;
+/**
+ * Set last prompt date for specific event type
+ */
+export declare function setLastPromptDate(eventType: string, date: string): Promise<void>;
+/**
+ * Check if user has rated the app
+ */
+export declare function getHasRated(): Promise<boolean>;
+/**
+ * Set whether user has rated the app
+ */
+export declare function setHasRated(value: boolean): Promise<void>;
+/**
+ * Check if user permanently dismissed the prompt
+ */
+export declare function getDismissed(): Promise<boolean>;
+/**
+ * Set whether user permanently dismissed the prompt
+ */
+export declare function setDismissed(value: boolean): Promise<void>;
+/**
+ * Get complete rating state for specific event type
+ */
+export declare function getRatingState(eventType: string): Promise<RatingState>;
+/**
+ * Reset rating data for specific event type or all data
+ */
+export declare function reset(eventType?: string): Promise<void>;

package/dist/domains/rating/presentation/components/RatingPromptModal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rating Prompt Modal
+ * 2-step rating prompt: Custom modal → Native review prompt
+ */
+import React from "react";
+import type { RatingTranslations } from "../../domain/entities/RatingConfig";
+export interface RatingPromptModalProps {
+    visible: boolean;
+    onPositive: () => void;
+    onNegative: () => void;
+    onLater: () => void;
+    onDismiss: () => void;
+    translations?: RatingTranslations;
+    appName?: string;
+}
+export declare const RatingPromptModal: React.FC<RatingPromptModalProps>;

package/dist/domains/rating/presentation/components/StarRating.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { ViewStyle } from "react-native";
+export interface StarRatingProps {
+    rating: number;
+    maxRating?: number;
+    onRatingChange?: (rating: number) => void;
+    size?: number;
+    activeColor?: string;
+    inactiveColor?: string;
+    disabled?: boolean;
+    style?: ViewStyle;
+}
+export declare const StarRating: React.FC<StarRatingProps>;

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

@@ -0,0 +1,9 @@
+/**
+ * useAppRating Hook
+ * React hook for app rating system
+ */
+import type { RatingConfig, UseAppRatingResult } from "../../domain/entities/RatingConfig";
+/**
+ * App rating hook with 2-step prompt flow
+ */
+export declare function useAppRating(config: RatingConfig): UseAppRatingResult;

package/dist/domains/video-tutorials/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Video Tutorials Domain
+ *
+ * Props-based component - pass tutorials data from app config
+ *
+ * Usage:
+ *   import { VideoTutorialsScreen, VideoTutorialCard, VideoTutorial } from '@umituz/react-native-settings';
+ *
+ *   <VideoTutorialsScreen
+ *     tutorials={myTutorials}
+ *     featuredTutorials={myFeaturedTutorials}
+ *     onTutorialPress={(tutorial) => Linking.openURL(tutorial.videoUrl)}
+ *   />
+ */
+export * from "./types";
+export * from "./presentation/screens/VideoTutorialsScreen";
+export * from "./presentation/components/VideoTutorialCard";
+export * from "./presentation/components/VideoTutorialSection";

package/dist/domains/video-tutorials/presentation/components/VideoTutorialCard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Video Tutorial Card Component
+ * Single Responsibility: Display individual video tutorial card
+ */
+import React from "react";
+import type { VideoTutorial } from "../../types";
+interface VideoTutorialCardProps {
+    readonly tutorial: VideoTutorial;
+    readonly onPress: () => void;
+    readonly horizontal?: boolean;
+}
+export declare const VideoTutorialCard: React.FC<VideoTutorialCardProps>;
+export {};