@umituz/react-native-settings 4.23.32 → 4.23.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-settings",
-  "version": "4.23.32",
+  "version": "4.23.34",
   "description": "Complete settings hub for React Native apps - consolidated package with settings, about, legal, appearance, feedback, FAQs, rating, and gamification",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -46,6 +46,7 @@
     "expo-notifications": ">=0.28.0",
     "expo-device": ">=6.0.0",
     "expo-haptics": ">=15.0.0",
+    "expo-store-review": ">=14.0.0",
     "@react-native-community/datetimepicker": ">=8.0.0",
     "react": ">=19.0.0",
     "react-native": ">=0.81.0",
@@ -91,6 +92,7 @@
     "expo-sharing": "^14.0.8",
     "expo-notifications": "~0.27.6",
     "expo-secure-store": "^15.0.8",
+    "expo-store-review": "~14.0.0",
     "expo-video": "^3.0.15",
     "expo-web-browser": "^12.0.0",
     "firebase": "^12.7.0",

package/src/domains/rating/application/services/RatingService.ts

@@ -0,0 +1,185 @@
+/**
+ * Rating Service
+ * Core business logic for app rating system
+ */
+
+import type { RatingConfig, RatingState } from "../../domain/entities/RatingConfig";
+import {
+  getEventCount,
+  incrementEventCount,
+  getLastPromptDate,
+  setLastPromptDate,
+  getHasRated,
+  setHasRated,
+  getDismissed,
+  setDismissed,
+  getRatingState,
+  reset as resetStorage,
+} from "../../infrastructure/storage/RatingStorage";
+
+/**
+ * Calculate days between two dates
+ */
+function daysBetween(dateString: string, now: Date): number {
+  const date = new Date(dateString);
+  const diffMs = now.getTime() - date.getTime();
+  return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+}
+
+/**
+ * Track an event occurrence
+ */
+export async function trackEvent(eventType: string): Promise<void> {
+  try {
+    await incrementEventCount(eventType);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      const count = await getEventCount(eventType);
+      console.log(`[RatingService] Event tracked: ${eventType}, count: ${count}`);
+    }
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingService] Error tracking event:", error);
+    }
+  }
+}
+
+/**
+ * Check if prompt should be shown based on criteria
+ */
+export async function shouldShowPrompt(config: RatingConfig): Promise<boolean> {
+  try {
+    const hasRated = await getHasRated();
+    if (hasRated) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[RatingService] User has already rated, skipping prompt");
+      }
+      return false;
+    }
+
+    const dismissed = await getDismissed();
+    if (dismissed) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[RatingService] User permanently dismissed prompt");
+      }
+      return false;
+    }
+
+    const eventCount = await getEventCount(config.eventType);
+    const minCount = config.minEventCount ?? 3;
+
+    if (eventCount < minCount) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log(
+          `[RatingService] Event count ${eventCount} < ${minCount}, not showing prompt`
+        );
+      }
+      return false;
+    }
+
+    const lastPromptDate = await getLastPromptDate(config.eventType);
+
+    if (lastPromptDate) {
+      const cooldownDays = config.cooldownDays ?? 90;
+      const daysSinceLastPrompt = daysBetween(lastPromptDate, new Date());
+
+      if (daysSinceLastPrompt < cooldownDays) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log(
+            `[RatingService] Cooldown period active: ${daysSinceLastPrompt}/${cooldownDays} days`
+          );
+        }
+        return false;
+      }
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[RatingService] All criteria met, prompt should be shown");
+    }
+
+    return true;
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingService] Error checking criteria:", error);
+    }
+    return false;
+  }
+}
+
+/**
+ * Mark that prompt was shown to user
+ */
+export async function markPromptShown(eventType: string): Promise<void> {
+  try {
+    const now = new Date().toISOString();
+    await setLastPromptDate(eventType, now);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[RatingService] Prompt shown marked for: ${eventType}`);
+    }
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingService] Error marking prompt shown:", error);
+    }
+  }
+}
+
+/**
+ * Mark that user has rated the app
+ */
+export async function markRated(): Promise<void> {
+  try {
+    await setHasRated(true);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[RatingService] User marked as rated");
+    }
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingService] Error marking rated:", error);
+    }
+  }
+}
+
+/**
+ * Mark that user permanently dismissed the prompt
+ */
+export async function markDismissed(): Promise<void> {
+  try {
+    await setDismissed(true);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[RatingService] User marked as dismissed");
+    }
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingService] Error marking dismissed:", error);
+    }
+  }
+}
+
+/**
+ * Get current rating state for event type
+ */
+export async function getState(eventType: string): Promise<RatingState> {
+  return getRatingState(eventType);
+}
+
+/**
+ * Reset rating data (for testing or specific event type)
+ */
+export async function reset(eventType?: string): Promise<void> {
+  try {
+    await resetStorage(eventType);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(
+        `[RatingService] Reset ${eventType ? `event: ${eventType}` : "all rating data"}`
+      );
+    }
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingService] Error resetting:", error);
+    }
+  }
+}

package/src/domains/rating/domain/entities/RatingConfig.ts

@@ -0,0 +1,158 @@
+/**
+ * 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 const DEFAULT_RATING_CONFIG: Required<
+  Omit<RatingConfig, "onPositiveFeedback" | "onNegativeFeedback" | "onPromptShown" | "onPromptDismissed">
+> = {
+  eventType: "app_usage",
+  minEventCount: 3,
+  cooldownDays: 90,
+  appName: "this app",
+  translations: {
+    title: "Enjoying the app?",
+    message: "If you love using our app, would you mind taking a moment to rate it?",
+    positiveButton: "Yes, I love it!",
+    negativeButton: "Not really",
+    laterButton: "Maybe later",
+  },
+};

package/src/domains/rating/index.ts

@@ -1,10 +1,10 @@
 /**
  * Rating Domain
- * Star ratings, user reviews, and statistics
+ * Star ratings, user reviews, statistics, and app store rating prompts
  */
 
 // =============================================================================
-// DOMAIN LAYER - Entities
+// DOMAIN LAYER - Entities (Star Ratings)
 // =============================================================================
 
 export type {
@@ -14,10 +14,36 @@ export type {
 } from './domain/entities/Rating';
 
 // =============================================================================
-// PRESENTATION LAYER - Components
+// DOMAIN LAYER - Entities (App Store Rating)
+// =============================================================================
+
+export type {
+  RatingConfig,
+  RatingState,
+  RatingTranslations,
+  UseAppRatingResult,
+} from './domain/entities/RatingConfig';
+
+export { DEFAULT_RATING_CONFIG } from './domain/entities/RatingConfig';
+
+// =============================================================================
+// PRESENTATION LAYER - Components (Star Ratings)
 // =============================================================================
 
 export { StarRating } from './presentation/components/StarRating';
 export type { StarRatingProps } from './presentation/components/StarRating';
 
+// =============================================================================
+// PRESENTATION LAYER - Components (App Store Rating)
+// =============================================================================
+
+export { RatingPromptModal } from './presentation/components/RatingPromptModal';
+export type { RatingPromptModalProps } from './presentation/components/RatingPromptModal';
+
+// =============================================================================
+// PRESENTATION LAYER - Hooks (App Store Rating)
+// =============================================================================
+
+export { useAppRating } from './presentation/hooks/useAppRating';
+
 

package/src/domains/rating/infrastructure/storage/RatingStorage.ts

@@ -0,0 +1,182 @@
+/**
+ * Rating Storage Repository
+ * Storage layer for rating system using design system storageRepository
+ */
+
+import { storageRepository, unwrap } from "@umituz/react-native-design-system";
+import type { RatingState } from "../../domain/entities/RatingConfig";
+
+/**
+ * Storage key generator
+ */
+const KEYS = {
+  eventCount: (eventType: string) => `rating.${eventType}.count`,
+  lastPrompt: (eventType: string) => `rating.${eventType}.lastPrompt`,
+  hasRated: "rating.hasRated",
+  dismissed: "rating.dismissed",
+} as const;
+
+/**
+ * Get event count for specific event type
+ */
+export async function getEventCount(eventType: string): Promise<number> {
+  try {
+    const result = await storageRepository.getString(KEYS.eventCount(eventType), "0");
+    const count = parseInt(unwrap(result, "0"), 10);
+    return Number.isNaN(count) ? 0 : count;
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error getting event count:", error);
+    }
+    return 0;
+  }
+}
+
+/**
+ * Set event count for specific event type
+ */
+export async function setEventCount(eventType: string, count: number): Promise<void> {
+  try {
+    await storageRepository.setString(KEYS.eventCount(eventType), count.toString());
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error setting event count:", error);
+    }
+  }
+}
+
+/**
+ * Increment event count for specific event type
+ */
+export async function incrementEventCount(eventType: string): Promise<void> {
+  const currentCount = await getEventCount(eventType);
+  await setEventCount(eventType, currentCount + 1);
+}
+
+/**
+ * Get last prompt date for specific event type
+ */
+export async function getLastPromptDate(eventType: string): Promise<string | null> {
+  try {
+    const result = await storageRepository.getString(KEYS.lastPrompt(eventType), "");
+    const date = unwrap(result, "");
+    return date || null;
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error getting last prompt date:", error);
+    }
+    return null;
+  }
+}
+
+/**
+ * Set last prompt date for specific event type
+ */
+export async function setLastPromptDate(eventType: string, date: string): Promise<void> {
+  try {
+    await storageRepository.setString(KEYS.lastPrompt(eventType), date);
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error setting last prompt date:", error);
+    }
+  }
+}
+
+/**
+ * Check if user has rated the app
+ */
+export async function getHasRated(): Promise<boolean> {
+  try {
+    const result = await storageRepository.getString(KEYS.hasRated, "false");
+    return unwrap(result, "false") === "true";
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error getting hasRated:", error);
+    }
+    return false;
+  }
+}
+
+/**
+ * Set whether user has rated the app
+ */
+export async function setHasRated(value: boolean): Promise<void> {
+  try {
+    await storageRepository.setString(KEYS.hasRated, value.toString());
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error setting hasRated:", error);
+    }
+  }
+}
+
+/**
+ * Check if user permanently dismissed the prompt
+ */
+export async function getDismissed(): Promise<boolean> {
+  try {
+    const result = await storageRepository.getString(KEYS.dismissed, "false");
+    return unwrap(result, "false") === "true";
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error getting dismissed:", error);
+    }
+    return false;
+  }
+}
+
+/**
+ * Set whether user permanently dismissed the prompt
+ */
+export async function setDismissed(value: boolean): Promise<void> {
+  try {
+    await storageRepository.setString(KEYS.dismissed, value.toString());
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error setting dismissed:", error);
+    }
+  }
+}
+
+/**
+ * Get complete rating state for specific event type
+ */
+export async function getRatingState(eventType: string): Promise<RatingState> {
+  const [eventCount, lastPromptDate, hasRated, dismissed] = await Promise.all([
+    getEventCount(eventType),
+    getLastPromptDate(eventType),
+    getHasRated(),
+    getDismissed(),
+  ]);
+
+  return {
+    eventCount,
+    lastPromptDate,
+    hasRated,
+    dismissed,
+  };
+}
+
+/**
+ * Reset rating data for specific event type or all data
+ */
+export async function reset(eventType?: string): Promise<void> {
+  try {
+    if (eventType) {
+      await storageRepository.removeItem(KEYS.eventCount(eventType));
+      await storageRepository.removeItem(KEYS.lastPrompt(eventType));
+    } else {
+      const allKeysResult = await storageRepository.getAllKeys();
+      const allKeys = unwrap(allKeysResult, []);
+      const ratingKeys = allKeys.filter((key) => key.startsWith("rating."));
+
+      await Promise.all(
+        ratingKeys.map((key) => storageRepository.removeItem(key))
+      );
+    }
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[RatingStorage] Error resetting data:", error);
+    }
+  }
+}

package/src/domains/rating/presentation/components/RatingPromptModal.tsx

@@ -0,0 +1,156 @@
+/**
+ * Rating Prompt Modal
+ * 2-step rating prompt: Custom modal → Native review prompt
+ */
+
+import React from "react";
+import { Modal, View, StyleSheet, type StyleProp, type ViewStyle } from "react-native";
+import {
+  AtomicText,
+  AtomicButton,
+  AtomicIcon,
+  useAppDesignTokens,
+  useResponsive,
+} from "@umituz/react-native-design-system";
+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 const RatingPromptModal: React.FC<RatingPromptModalProps> = ({
+  visible,
+  onPositive,
+  onNegative,
+  onLater,
+  onDismiss,
+  translations,
+  appName = "this app",
+}) => {
+  const tokens = useAppDesignTokens();
+  const responsive = useResponsive();
+
+  const defaultTranslations: RatingTranslations = {
+    title: translations?.title ?? "Enjoying the app?",
+    message:
+      translations?.message ??
+      `If you love using ${appName}, would you mind taking a moment to rate it?`,
+    positiveButton: translations?.positiveButton ?? "Yes, I love it!",
+    negativeButton: translations?.negativeButton ?? "Not really",
+    laterButton: translations?.laterButton ?? "Maybe later",
+  };
+
+  return (
+    <Modal
+      visible={visible}
+      transparent
+      animationType="none"
+      onRequestClose={onDismiss}
+      statusBarTranslucent
+    >
+      <View
+        style={[
+          styles.overlay,
+          { backgroundColor: "rgba(0, 0, 0, 0.5)" },
+        ]}
+      >
+        <View
+          style={[
+            styles.container,
+            {
+              backgroundColor: tokens.colors.surface,
+              borderRadius: tokens.borders.radius.xl,
+              padding: tokens.spacing.lg,
+              maxWidth: responsive.maxContentWidth * 0.85,
+              width: "90%",
+            },
+          ]}
+        >
+          <View style={styles.iconContainer}>
+            <AtomicIcon name="star" size="xl" color="primary" />
+          </View>
+
+          <AtomicText
+            type="headlineMedium"
+            color="onSurface"
+            style={[
+              styles.title,
+              { marginBottom: tokens.spacing.sm },
+            ]}
+          >
+            {defaultTranslations.title}
+          </AtomicText>
+
+          <AtomicText
+            type="bodyMedium"
+            color="onSurfaceVariant"
+            style={[
+              styles.message,
+              { marginBottom: tokens.spacing.lg },
+            ]}
+          >
+            {defaultTranslations.message}
+          </AtomicText>
+
+          <View style={[styles.buttonContainer, { gap: tokens.spacing.sm }]}>
+            <AtomicButton
+              variant="fill"
+              onPress={onPositive}
+              style={styles.button}
+            >
+              {defaultTranslations.positiveButton}
+            </AtomicButton>
+
+            <AtomicButton
+              variant="outline"
+              onPress={onNegative}
+              style={styles.button}
+            >
+              {defaultTranslations.negativeButton}
+            </AtomicButton>
+
+            <AtomicButton
+              variant="text"
+              onPress={onLater}
+              style={styles.button}
+            >
+              {defaultTranslations.laterButton}
+            </AtomicButton>
+          </View>
+        </View>
+      </View>
+    </Modal>
+  );
+};
+
+const styles = StyleSheet.create({
+  overlay: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+  },
+  container: {
+    alignItems: "center",
+  },
+  iconContainer: {
+    marginBottom: 16,
+  },
+  title: {
+    textAlign: "center",
+  },
+  message: {
+    textAlign: "center",
+  },
+  buttonContainer: {
+    width: "100%",
+  },
+  button: {
+    width: "100%",
+  },
+});

package/src/domains/rating/presentation/hooks/useAppRating.tsx

@@ -0,0 +1,128 @@
+/**
+ * useAppRating Hook
+ * React hook for app rating system
+ */
+
+import React, { useState, useCallback } from "react";
+import * as StoreReview from "expo-store-review";
+import type {
+  RatingConfig,
+  UseAppRatingResult,
+  RatingState,
+} from "../../domain/entities/RatingConfig";
+import { DEFAULT_RATING_CONFIG } from "../../domain/entities/RatingConfig";
+import * as RatingService from "../../application/services/RatingService";
+import { RatingPromptModal } from "../components/RatingPromptModal";
+
+/**
+ * App rating hook with 2-step prompt flow
+ */
+export function useAppRating(config: RatingConfig): UseAppRatingResult {
+  const [isVisible, setIsVisible] = useState(false);
+
+  const mergedConfig: RatingConfig = {
+    ...DEFAULT_RATING_CONFIG,
+    ...config,
+  };
+
+  const trackEvent = useCallback(async (): Promise<void> => {
+    await RatingService.trackEvent(mergedConfig.eventType);
+  }, [mergedConfig.eventType]);
+
+  const shouldShow = useCallback(async (): Promise<boolean> => {
+    return RatingService.shouldShowPrompt(mergedConfig);
+  }, [mergedConfig]);
+
+  const showPrompt = useCallback(async (): Promise<void> => {
+    setIsVisible(true);
+    await RatingService.markPromptShown(mergedConfig.eventType);
+
+    if (mergedConfig.onPromptShown) {
+      await mergedConfig.onPromptShown();
+    }
+  }, [mergedConfig]);
+
+  const checkAndShow = useCallback(async (): Promise<boolean> => {
+    const should = await shouldShow();
+
+    if (should) {
+      await showPrompt();
+      return true;
+    }
+
+    return false;
+  }, [shouldShow, showPrompt]);
+
+  const reset = useCallback(async (): Promise<void> => {
+    await RatingService.reset(mergedConfig.eventType);
+  }, [mergedConfig.eventType]);
+
+  const getState = useCallback(async (): Promise<RatingState> => {
+    return RatingService.getState(mergedConfig.eventType);
+  }, [mergedConfig.eventType]);
+
+  const handlePositive = useCallback(async () => {
+    setIsVisible(false);
+    await RatingService.markRated();
+
+    try {
+      const isAvailable = await StoreReview.isAvailableAsync();
+
+      if (isAvailable) {
+        await StoreReview.requestReview();
+      }
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[useAppRating] Error requesting review:", error);
+      }
+    }
+
+    if (mergedConfig.onPositiveFeedback) {
+      await mergedConfig.onPositiveFeedback();
+    }
+  }, [mergedConfig]);
+
+  const handleNegative = useCallback(async () => {
+    setIsVisible(false);
+
+    if (mergedConfig.onNegativeFeedback) {
+      await mergedConfig.onNegativeFeedback();
+    }
+  }, [mergedConfig]);
+
+  const handleLater = useCallback(() => {
+    setIsVisible(false);
+  }, []);
+
+  const handleDismiss = useCallback(async () => {
+    setIsVisible(false);
+    await RatingService.markDismissed();
+
+    if (mergedConfig.onPromptDismissed) {
+      await mergedConfig.onPromptDismissed();
+    }
+  }, [mergedConfig]);
+
+  const modal = (
+    <RatingPromptModal
+      visible={isVisible}
+      onPositive={handlePositive}
+      onNegative={handleNegative}
+      onLater={handleLater}
+      onDismiss={handleDismiss}
+      translations={mergedConfig.translations}
+      appName={mergedConfig.appName}
+    />
+  );
+
+  return {
+    trackEvent,
+    checkAndShow,
+    shouldShow,
+    showPrompt,
+    reset,
+    getState,
+    isVisible,
+    modal,
+  } as UseAppRatingResult & { modal: React.ReactNode };
+}

package/src/index.ts

@@ -109,8 +109,22 @@ export * from './domains/feedback';
 // FAQs Domain - Frequently asked questions
 export * from './domains/faqs';
 
-// Rating Domain - Star ratings, reviews, statistics
-export * from "./domains/rating";
+// Rating Domain - Star ratings, reviews, statistics, app store rating
+export {
+  StarRating,
+  RatingPromptModal,
+  useAppRating,
+  DEFAULT_RATING_CONFIG,
+  type RatingValue,
+  type Rating,
+  type RatingStats,
+  type RatingConfig as AppStoreRatingConfig,
+  type RatingState as AppStoreRatingState,
+  type RatingTranslations as AppStoreRatingTranslations,
+  type UseAppRatingResult,
+  type StarRatingProps,
+  type RatingPromptModalProps,
+} from "./domains/rating";
 
 // Video Tutorials Domain - Learning resources, tutorials
 export * from "./domains/video-tutorials";