@umituz/react-native-settings 5.3.37 → 5.3.38

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

@@ -0,0 +1,62 @@
+/**
+ * Support Section Component
+ * Renders Support entry points: Feedback and Rating
+ * Agnostic of UI implementation via render props
+ */
+import React from "react";
+import type { FeedbackType } from "../../domain/entities/FeedbackEntity";
+export interface FeedbackConfig {
+    enabled?: boolean;
+    title?: string;
+    description?: string;
+    initialType?: FeedbackType;
+    onSubmit?: (data: {
+        type: FeedbackType;
+        rating: number;
+        description: string;
+        title: string;
+    }) => Promise<void>;
+    onPress?: () => void;
+}
+export interface RatingConfig {
+    enabled?: boolean;
+    title?: string;
+    description?: string;
+    storeUrl?: string;
+    onRate?: () => void;
+}
+export interface FeedbackModalTexts {
+    title?: string;
+    ratingLabel: string;
+    descriptionPlaceholder: string;
+    submitButton: string;
+    submittingButton: string;
+    feedbackTypes: Array<{
+        type: FeedbackType;
+        label: string;
+    }>;
+    defaultTitle: (type: FeedbackType) => string;
+}
+export interface SupportSectionProps {
+    feedbackConfig: {
+        enabled: boolean;
+        config?: FeedbackConfig;
+    };
+    ratingConfig: {
+        enabled: boolean;
+        config?: RatingConfig;
+    };
+    renderSection: (props: {
+        title: string;
+        children: React.ReactNode;
+    }) => React.ReactElement | null;
+    renderItem: (props: {
+        title: string;
+        icon: string;
+        onPress: () => void;
+        isLast?: boolean;
+    }) => React.ReactElement | null;
+    /** Texts for the feedback modal */
+    feedbackModalTexts?: FeedbackModalTexts;
+}
+export declare const SupportSection: React.FC<SupportSectionProps>;

package/dist/domains/feedback/presentation/hooks/useFeedbackForm.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Feedback Form Hook
+ */
+import type { FeedbackType, FeedbackRating } from '../../domain/entities/FeedbackEntity';
+export interface FeedbackFormState {
+    type: FeedbackType;
+    title: string;
+    description: string;
+    rating?: FeedbackRating;
+}
+export declare function useFeedbackForm(defaultValues?: Partial<FeedbackFormState>): {
+    formState: FeedbackFormState;
+    setType: (type: FeedbackType) => void;
+    setTitle: (title: string) => void;
+    setDescription: (description: string) => void;
+    setRating: (rating: FeedbackRating | undefined) => void;
+    reset: () => void;
+    isValid: boolean;
+};

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

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const FeatureRequestScreen: React.FC<any>;

package/dist/domains/gamification/components/AchievementCard.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AchievementCard Component
+ * Displays achievement - all text via props
+ */
+import React from "react";
+import { type ViewStyle, type TextStyle } from "react-native";
+export interface AchievementCardProps {
+    title: string;
+    description: string;
+    icon: React.ReactNode;
+    isUnlocked: boolean;
+    progress: number;
+    containerStyle?: ViewStyle;
+    titleStyle?: TextStyle;
+    descriptionStyle?: TextStyle;
+    progressBarStyle?: ViewStyle;
+    unlockedColor?: string;
+    lockedColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    subtextColor?: string;
+}
+export declare const AchievementCard: React.FC<AchievementCardProps>;

package/dist/domains/gamification/components/AchievementItem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AchievementItem Component
+ * List item for achievements - all text via props
+ */
+import React from "react";
+import type { AchievementItemProps } from "./types/AchievementItemProps";
+export declare const AchievementItem: React.FC<AchievementItemProps>;

package/dist/domains/gamification/components/AchievementToast.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AchievementToast Component
+ * Shows achievement unlock notification - all text via props
+ */
+import React from "react";
+import { type ViewStyle, type TextStyle } from "react-native";
+export interface AchievementToastProps {
+    visible: boolean;
+    title: string;
+    label: string;
+    icon: React.ReactNode;
+    onDismiss: () => void;
+    duration?: number;
+    containerStyle?: ViewStyle;
+    labelStyle?: TextStyle;
+    titleStyle?: TextStyle;
+    backgroundColor?: string;
+    textColor?: string;
+    labelColor?: string;
+}
+export declare const AchievementToast: React.FC<AchievementToastProps>;

package/dist/domains/gamification/components/GamificationScreen/AchievementsList.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GamificationScreen AchievementsList Component
+ */
+import React from "react";
+import { type TextStyle } from "react-native";
+import type { AchievementItemProps } from "../types/AchievementItemProps";
+export interface AchievementsListProps {
+    achievementsTitle: string;
+    achievements: Array<Omit<AchievementItemProps, "accentColor" | "backgroundColor" | "textColor" | "subtextColor" | "lockedOpacity">>;
+    emptyAchievementsText?: string;
+    accentColor: string;
+    cardBackgroundColor: string;
+    textColor: string;
+    subtextColor: string;
+    sectionTitleStyle?: TextStyle;
+}
+export declare const AchievementsList: React.FC<AchievementsListProps>;

package/dist/domains/gamification/components/GamificationScreen/GamificationScreen.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GamificationScreen - Pure Presentational Component
+ * Renders the gamification dashboard with all data provided as props
+ * Under 200 lines - only presentation logic
+ */
+import React from "react";
+import type { GamificationScreenProps } from "./types";
+/**
+ * Internal component that renders the screen with all props
+ */
+export declare const GamificationScreenInner: React.FC<GamificationScreenProps>;

package/dist/domains/gamification/components/GamificationScreen/GamificationScreenWithConfig.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GamificationScreen With Config
+ * Component that uses the hook to fetch data and render the screen
+ * Separated to satisfy React Hooks rules
+ */
+import React from "react";
+import type { GamificationConfigProps } from "./types";
+/**
+ * Component that uses the hook - separated to satisfy React Hooks rules
+ */
+export declare const GamificationScreenWithConfig: React.FC<GamificationConfigProps>;

package/dist/domains/gamification/components/GamificationScreen/StatsGrid.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GamificationScreen StatsGrid Component
+ */
+import React from "react";
+import { type TextStyle } from "react-native";
+import type { StatsCardProps } from "../StatsCard";
+export interface StatsGridProps {
+    statsTitle: string;
+    stats: Array<Omit<StatsCardProps, "accentColor" | "backgroundColor" | "textColor" | "subtextColor">>;
+    accentColor: string;
+    cardBackgroundColor: string;
+    textColor: string;
+    subtextColor: string;
+    sectionTitleStyle?: TextStyle;
+}
+export declare const StatsGrid: React.FC<StatsGridProps>;

package/dist/domains/gamification/components/GamificationScreen/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GamificationScreen Component
+ * Full gamification screen with integrated hook
+ * Generic for 100+ apps - NO hardcoded strings
+ *
+ * Split into multiple files to keep each under 200 lines:
+ * - GamificationScreen.tsx: Pure presentational component
+ * - GamificationScreenWithConfig.tsx: Config-based version with hook
+ * - index.tsx: Main entry point that routes to appropriate component
+ */
+import React from "react";
+import type { GamificationScreenProps, GamificationConfigProps } from "./types";
+/**
+ * GamificationScreen that accepts either detailed props OR a config object
+ * When config is provided, a hook consumer component is used
+ */
+export declare const GamificationScreen: React.FC<GamificationScreenProps | GamificationConfigProps>;

package/dist/domains/gamification/components/GamificationScreen/styles.d.ts

@@ -0,0 +1,40 @@
+/**
+ * GamificationScreen Styles
+ */
+export declare const styles: {
+    container: {
+        flex: number;
+    };
+    scrollView: {
+        flex: number;
+    };
+    scrollContent: {
+        padding: number;
+        paddingBottom: number;
+    };
+    header: {
+        marginBottom: number;
+    };
+    title: {
+        fontSize: number;
+        fontWeight: "bold";
+    };
+    section: {
+        marginBottom: number;
+    };
+    sectionTitle: {
+        fontSize: number;
+        fontWeight: "600";
+        marginBottom: number;
+    };
+    statsGrid: {
+        flexDirection: "row";
+        flexWrap: "wrap";
+        gap: number;
+    };
+    emptyText: {
+        fontSize: number;
+        textAlign: "center";
+        paddingVertical: number;
+    };
+};

package/dist/domains/gamification/components/GamificationScreen/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * GamificationScreen Types
+ * Generic types for 100+ apps - NO app-specific code
+ */
+import type React from 'react';
+import type { LevelProgressProps } from "../LevelProgress";
+import type { StatsCardProps } from "../StatsCard";
+import type { AchievementItemProps } from "../types/AchievementItemProps";
+import type { StreakDisplayProps } from "../StreakDisplay";
+import type { ViewStyle, TextStyle } from "react-native";
+import type { GamificationConfig } from "../../types";
+export interface GamificationConfigProps extends Partial<Omit<GamificationScreenProps, 'config'>> {
+    config: GamificationConfig;
+}
+export interface GamificationScreenProps {
+    title: string;
+    statsTitle: string;
+    achievementsTitle: string;
+    streakTitle: string;
+    levelProps: Omit<LevelProgressProps, "primaryColor" | "backgroundColor" | "textColor" | "subtextColor">;
+    stats: Array<Omit<StatsCardProps, "accentColor" | "backgroundColor" | "textColor" | "subtextColor">>;
+    achievements: Array<Omit<AchievementItemProps, "accentColor" | "backgroundColor" | "textColor" | "subtextColor" | "lockedOpacity">>;
+    streakProps?: Omit<StreakDisplayProps, "primaryColor" | "backgroundColor" | "textColor" | "subtextColor">;
+    emptyAchievementsText?: string;
+    containerStyle?: ViewStyle;
+    headerStyle?: ViewStyle;
+    titleStyle?: TextStyle;
+    sectionTitleStyle?: TextStyle;
+    accentColor?: string;
+    backgroundColor?: string;
+    cardBackgroundColor?: string;
+    textColor?: string;
+    subtextColor?: string;
+    headerComponent?: React.ReactNode;
+}
+export interface GamificationScreenStyleProps {
+    accentColor: string;
+    backgroundColor: string;
+    cardBackgroundColor: string;
+    textColor: string;
+    subtextColor: string;
+}

package/dist/domains/gamification/components/LevelProgress.d.ts

@@ -0,0 +1,27 @@
+/**
+ * LevelProgress Component
+ * Displays level and progress - all text via props
+ */
+import React from "react";
+import { type ViewStyle, type TextStyle } from "react-native";
+export interface LevelProgressProps {
+    level: number;
+    points: number;
+    levelTitle: string;
+    pointsToNext: number;
+    progress: number;
+    showPoints?: boolean;
+    containerStyle?: ViewStyle;
+    titleStyle?: TextStyle;
+    subtitleStyle?: TextStyle;
+    progressBarStyle?: ViewStyle;
+    progressFillStyle?: ViewStyle;
+    badgeStyle?: ViewStyle;
+    badgeTextStyle?: TextStyle;
+    primaryColor?: string;
+    secondaryColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    subtextColor?: string;
+}
+export declare const LevelProgress: React.FC<LevelProgressProps>;

package/dist/domains/gamification/components/PointsBadge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * PointsBadge Component
+ * Displays points with optional icon - all text via props
+ */
+import React from "react";
+import { type ViewStyle, type TextStyle } from "react-native";
+export interface PointsBadgeProps {
+    points: number;
+    icon?: React.ReactNode;
+    containerStyle?: ViewStyle;
+    textStyle?: TextStyle;
+    backgroundColor?: string;
+    textColor?: string;
+    borderColor?: string;
+}
+export declare const PointsBadge: React.FC<PointsBadgeProps>;

package/dist/domains/gamification/components/StatsCard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * StatsCard Component - Modern Design
+ * Clean card-based stat display with large emoji icons
+ */
+import React from "react";
+import { type ViewStyle, type TextStyle } from "react-native";
+export interface StatsCardProps {
+    value: number;
+    label: string;
+    icon?: React.ReactNode | string;
+    suffix?: string;
+    containerStyle?: ViewStyle;
+    valueStyle?: TextStyle;
+    labelStyle?: TextStyle;
+    accentColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    subtextColor?: string;
+}
+export declare const StatsCard: React.FC<StatsCardProps>;

package/dist/domains/gamification/components/StreakDisplay.d.ts

@@ -0,0 +1,21 @@
+/**
+ * StreakDisplay Component - Modern Design
+ * Clean card-based design with gradient fire icon
+ */
+import React from "react";
+import { type ViewStyle, type TextStyle } from "react-native";
+export interface StreakDisplayProps {
+    current: number;
+    longest: number;
+    bestLabel: string;
+    daysLabel: string;
+    icon?: React.ReactNode | string;
+    containerStyle?: ViewStyle;
+    numberStyle?: TextStyle;
+    labelStyle?: TextStyle;
+    primaryColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    subtextColor?: string;
+}
+export declare const StreakDisplay: React.FC<StreakDisplayProps>;

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

@@ -0,0 +1,14 @@
+/**
+ * Gamification Components
+ * All text via props - NO hardcoded strings
+ */
+export { LevelProgress, type LevelProgressProps } from "./LevelProgress";
+export { PointsBadge, type PointsBadgeProps } from "./PointsBadge";
+export { AchievementCard, type AchievementCardProps } from "./AchievementCard";
+export { AchievementToast, type AchievementToastProps } from "./AchievementToast";
+export { StreakDisplay, type StreakDisplayProps } from "./StreakDisplay";
+export { StatsCard, type StatsCardProps } from "./StatsCard";
+export { AchievementItem } from "./AchievementItem";
+export type { AchievementItemProps } from "./types/AchievementItemProps";
+export { GamificationScreen } from "./GamificationScreen/index";
+export type { GamificationScreenProps, GamificationConfigProps } from "./GamificationScreen/types";

package/dist/domains/gamification/components/styles/achievementItemStyles.d.ts

@@ -0,0 +1,71 @@
+/**
+ * AchievementItem Styles
+ */
+export declare const achievementItemStyles: {
+    container: {
+        flexDirection: "row";
+        alignItems: "center";
+        padding: number;
+        borderRadius: number;
+        marginBottom: number;
+    };
+    iconContainer: {
+        width: number;
+        height: number;
+        borderRadius: number;
+        alignItems: "center";
+        justifyContent: "center";
+        marginRight: number;
+    };
+    content: {
+        flex: number;
+    };
+    header: {
+        flexDirection: "row";
+        alignItems: "center";
+        justifyContent: "space-between";
+        marginBottom: number;
+    };
+    title: {
+        fontSize: number;
+        fontWeight: "600";
+        flex: number;
+    };
+    checkmark: {
+        width: number;
+        height: number;
+        borderRadius: number;
+        alignItems: "center";
+        justifyContent: "center";
+        marginLeft: number;
+    };
+    checkmarkText: {
+        fontSize: number;
+        fontWeight: "bold";
+    };
+    description: {
+        fontSize: number;
+        lineHeight: number;
+    };
+    progressContainer: {
+        marginTop: number;
+        flexDirection: "row";
+        alignItems: "center";
+        gap: number;
+    };
+    progressBar: {
+        flex: number;
+        height: number;
+        borderRadius: number;
+        overflow: "hidden";
+    };
+    progressFill: {
+        height: "100%";
+        borderRadius: number;
+    };
+    progressText: {
+        fontSize: number;
+        minWidth: number;
+        textAlign: "right";
+    };
+};

package/dist/domains/gamification/components/types/AchievementItemProps.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AchievementItem Props Types
+ */
+import type { ViewStyle, TextStyle } from 'react-native';
+export interface AchievementItemProps {
+    id?: string;
+    title: string;
+    description: string;
+    icon: React.ReactNode | string;
+    isUnlocked: boolean;
+    progress: number;
+    threshold: number;
+    progressLabel?: string;
+    containerStyle?: ViewStyle;
+    titleStyle?: TextStyle;
+    descriptionStyle?: TextStyle;
+    accentColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    subtextColor?: string;
+    lockedOpacity?: number;
+}

package/dist/domains/gamification/hooks/useGamification.d.ts

@@ -0,0 +1,22 @@
+/**
+ * useGamification Hook
+ * Main hook for gamification operations
+ */
+import type { GamificationConfig, LevelState, Achievement } from "../types";
+export interface UseGamificationReturn {
+    points: number;
+    totalTasksCompleted: number;
+    level: LevelState;
+    streak: {
+        current: number;
+        longest: number;
+    };
+    achievements: Achievement[];
+    isLoading: boolean;
+    isInitialized: boolean;
+    initialize: (config: GamificationConfig) => Promise<void>;
+    completeTask: () => void;
+    addPoints: (amount: number) => void;
+    reset: () => Promise<void>;
+}
+export declare const useGamification: (config?: GamificationConfig) => UseGamificationReturn;

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

@@ -0,0 +1,13 @@
+/**
+ * Gamification Domain
+ * Part of @umituz/react-native-settings
+ *
+ * Generic gamification system for React Native apps
+ * All text via props - NO hardcoded strings
+ * Designed for 100+ apps
+ */
+export type { AchievementDefinition, Achievement, LevelDefinition, LevelState, StreakState, GamificationConfig, GamificationSettingsConfig, GamificationState, GamificationActions, GamificationStore, } from "./types";
+export { useGamificationStore } from "./store/gamificationStore";
+export { useGamification, type UseGamificationReturn } from "./hooks/useGamification";
+export { calculateLevel, checkAchievementUnlock, updateAchievementProgress, isStreakActive, isSameDay, } from "./utils/calculations";
+export { LevelProgress, type LevelProgressProps, PointsBadge, type PointsBadgeProps, AchievementCard, type AchievementCardProps, AchievementToast, type AchievementToastProps, StreakDisplay, type StreakDisplayProps, StatsCard, type StatsCardProps, AchievementItem, type AchievementItemProps, GamificationScreen, type GamificationScreenProps, } from "./components";

package/dist/domains/gamification/store/gamificationStore.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Gamification Store
+ * Zustand store with persist middleware
+ */
+import type { GamificationState, GamificationActions } from "../types";
+export declare const useGamificationStore: import("zustand").UseBoundStore<import("zustand").StoreApi<GamificationState & GamificationActions>>;

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

@@ -0,0 +1,99 @@
+/**
+ * Gamification Types
+ * Generic types for 100+ apps - NO app-specific code
+ */
+export interface AchievementDefinition {
+    id: string;
+    threshold: number;
+    type: "count" | "streak" | "milestone";
+    title: string;
+    description: string;
+    icon: string;
+}
+export interface Achievement extends AchievementDefinition {
+    isUnlocked: boolean;
+    unlockedAt?: string;
+    progress: number;
+}
+export interface LevelDefinition {
+    level: number;
+    minPoints: number;
+    maxPoints: number;
+}
+export interface LevelState {
+    currentLevel: number;
+    currentPoints: number;
+    pointsToNext: number;
+    progress: number;
+}
+export interface StreakState {
+    current: number;
+    longest: number;
+    lastActivityDate: string | null;
+}
+export interface GamificationTranslations {
+    title?: string;
+    statsTitle?: string;
+    pointsLabel?: string;
+    totalCompletedLabel?: string;
+    achievementsTitle?: string;
+    streakTitle?: string;
+    bestStreak?: string;
+    currentStreak?: string;
+    days?: string;
+    levelTitle?: string;
+    emptyAchievements?: string;
+}
+export interface GamificationConfig {
+    storageKey: string;
+    achievements: AchievementDefinition[];
+    levels: LevelDefinition[];
+    pointsPerAction?: number;
+    streakBonusMultiplier?: number;
+    enabled?: boolean;
+    translations?: GamificationTranslations;
+}
+export type GamificationSettingsConfig = GamificationConfig;
+export interface GamificationState {
+    points: number;
+    totalTasksCompleted: number;
+    achievements: Achievement[];
+    streak: StreakState;
+    isLoading: boolean;
+    isInitialized: boolean;
+}
+export interface GamificationActions {
+    initialize: (config: GamificationConfig) => Promise<void>;
+    addPoints: (amount: number) => void;
+    completeTask: () => void;
+    updateStreak: () => void;
+    checkAchievements: () => Achievement[];
+    reset: () => Promise<void>;
+}
+export type GamificationStore = GamificationState & GamificationActions;
+export interface LevelProgressProps {
+    level: number;
+    points: number;
+    levelTitle: string;
+    pointsToNext: number;
+    progress: number;
+    showPoints?: boolean;
+}
+export interface AchievementCardProps {
+    title: string;
+    description: string;
+    icon: string;
+    isUnlocked: boolean;
+    progress: number;
+    threshold: number;
+}
+export interface StreakDisplayProps {
+    current: number;
+    longest: number;
+    streakLabel: string;
+    bestLabel: string;
+}
+export interface PointsBadgeProps {
+    points: number;
+    label?: string;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Gamification Calculations
+ * Pure utility functions - NO side effects
+ */
+import type { LevelDefinition, LevelState, AchievementDefinition } from "../types";
+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;
+export declare const isStreakActive: (lastActivityDate: string | null) => boolean;
+export declare const isSameDay: (date1: Date, date2: Date) => boolean;