react-native-iap 14.1.0 → 14.1.1-rc.1

package/src/hooks/useIAP.ts

@@ -1,6 +1,6 @@
 // External dependencies
-import { useCallback, useEffect, useState, useRef } from 'react'
-import { Platform } from 'react-native'
+import {useCallback, useEffect, useState, useRef} from 'react';
+import {Platform} from 'react-native';
 
 // Internal modules
 import {
@@ -16,8 +16,8 @@ import {
   validateReceipt as validateReceiptInternal,
   getActiveSubscriptions,
   hasActiveSubscriptions,
-} from '../'
-import { syncIOS, requestPromotedProductIOS, buyPromotedProductIOS } from '../'
+} from '../';
+import {syncIOS, requestPromotedProductIOS, buyPromotedProductIOS} from '../';
 
 // Types
 import type {
@@ -29,76 +29,76 @@ import type {
   RequestPurchaseProps,
   RequestSubscriptionProps,
   ActiveSubscription,
-} from '../types'
+} from '../types';
 
 // Types for event subscriptions
 interface EventSubscription {
-  remove(): void
+  remove(): void;
 }
 
 type UseIap = {
-  connected: boolean
-  products: Product[]
-  promotedProductsIOS: Purchase[]
-  promotedProductIdIOS?: string
-  subscriptions: SubscriptionProduct[]
-  availablePurchases: Purchase[]
-  currentPurchase?: Purchase
-  currentPurchaseError?: PurchaseError
-  promotedProductIOS?: Product
-  activeSubscriptions: ActiveSubscription[]
-  clearCurrentPurchase: () => void
-  clearCurrentPurchaseError: () => void
+  connected: boolean;
+  products: Product[];
+  promotedProductsIOS: Purchase[];
+  promotedProductIdIOS?: string;
+  subscriptions: SubscriptionProduct[];
+  availablePurchases: Purchase[];
+  currentPurchase?: Purchase;
+  currentPurchaseError?: PurchaseError;
+  promotedProductIOS?: Product;
+  activeSubscriptions: ActiveSubscription[];
+  clearCurrentPurchase: () => void;
+  clearCurrentPurchaseError: () => void;
   finishTransaction: ({
     purchase,
     isConsumable,
   }: {
-    purchase: Purchase
-    isConsumable?: boolean
-  }) => Promise<PurchaseResult | boolean>
-  getAvailablePurchases: () => Promise<void>
+    purchase: Purchase;
+    isConsumable?: boolean;
+  }) => Promise<PurchaseResult | boolean>;
+  getAvailablePurchases: () => Promise<void>;
   fetchProducts: (params: {
-    skus: string[]
-    type?: 'inapp' | 'subs'
-  }) => Promise<void>
+    skus: string[];
+    type?: 'inapp' | 'subs';
+  }) => Promise<void>;
   /**
    * @deprecated Use fetchProducts({ skus, type: 'inapp' }) instead. This method will be removed in version 3.0.0.
    * Note: This method internally uses fetchProducts, so no deprecation warning is shown.
    */
-  getProducts: (skus: string[]) => Promise<void>
+  getProducts: (skus: string[]) => Promise<void>;
   /**
    * @deprecated Use fetchProducts({ skus, type: 'subs' }) instead. This method will be removed in version 3.0.0.
    * Note: This method internally uses fetchProducts, so no deprecation warning is shown.
    */
-  getSubscriptions: (skus: string[]) => Promise<void>
+  getSubscriptions: (skus: string[]) => Promise<void>;
   requestPurchase: (params: {
-    request: RequestPurchaseProps | RequestSubscriptionProps
-    type?: 'inapp' | 'subs'
-  }) => Promise<any>
+    request: RequestPurchaseProps | RequestSubscriptionProps;
+    type?: 'inapp' | 'subs';
+  }) => Promise<any>;
   validateReceipt: (
     sku: string,
     androidOptions?: {
-      packageName: string
-      productToken: string
-      accessToken: string
-      isSub?: boolean
-    }
-  ) => Promise<any>
-  restorePurchases: () => Promise<void> // 구매 복원 함수 추가
-  requestPromotedProductIOS: () => Promise<any | null>
-  buyPromotedProductIOS: () => Promise<void>
+      packageName: string;
+      productToken: string;
+      accessToken: string;
+      isSub?: boolean;
+    },
+  ) => Promise<any>;
+  restorePurchases: () => Promise<void>; // 구매 복원 함수 추가
+  requestPromotedProductIOS: () => Promise<any | null>;
+  buyPromotedProductIOS: () => Promise<void>;
   getActiveSubscriptions: (
-    subscriptionIds?: string[]
-  ) => Promise<ActiveSubscription[]>
-  hasActiveSubscriptions: (subscriptionIds?: string[]) => Promise<boolean>
-}
+    subscriptionIds?: string[],
+  ) => Promise<ActiveSubscription[]>;
+  hasActiveSubscriptions: (subscriptionIds?: string[]) => Promise<boolean>;
+};
 
 export interface UseIapOptions {
-  onPurchaseSuccess?: (purchase: Purchase) => void
-  onPurchaseError?: (error: PurchaseError) => void
-  onSyncError?: (error: Error) => void
-  shouldAutoSyncPurchases?: boolean // New option to control auto-syncing
-  onPromotedProductIOS?: (product: Product) => void
+  onPurchaseSuccess?: (purchase: Purchase) => void;
+  onPurchaseError?: (error: PurchaseError) => void;
+  onSyncError?: (error: Error) => void;
+  shouldAutoSyncPurchases?: boolean; // New option to control auto-syncing
+  onPromotedProductIOS?: (product: Product) => void;
 }
 
 /**
@@ -106,193 +106,193 @@ export interface UseIapOptions {
  * See documentation at https://expo-iap.hyo.dev/docs/hooks/useIAP
  */
 export function useIAP(options?: UseIapOptions): UseIap {
-  const [connected, setConnected] = useState<boolean>(false)
-  const [products, setProducts] = useState<Product[]>([])
-  const [promotedProductsIOS] = useState<Purchase[]>([])
-  const [subscriptions, setSubscriptions] = useState<SubscriptionProduct[]>([])
-  const [availablePurchases, setAvailablePurchases] = useState<Purchase[]>([])
-  const [currentPurchase, setCurrentPurchase] = useState<Purchase>()
-  const [promotedProductIOS, setPromotedProductIOS] = useState<Product>()
+  const [connected, setConnected] = useState<boolean>(false);
+  const [products, setProducts] = useState<Product[]>([]);
+  const [promotedProductsIOS] = useState<Purchase[]>([]);
+  const [subscriptions, setSubscriptions] = useState<SubscriptionProduct[]>([]);
+  const [availablePurchases, setAvailablePurchases] = useState<Purchase[]>([]);
+  const [currentPurchase, setCurrentPurchase] = useState<Purchase>();
+  const [promotedProductIOS, setPromotedProductIOS] = useState<Product>();
   const [currentPurchaseError, setCurrentPurchaseError] =
-    useState<PurchaseError>()
-  const [promotedProductIdIOS] = useState<string>()
+    useState<PurchaseError>();
+  const [promotedProductIdIOS] = useState<string>();
   const [activeSubscriptions, setActiveSubscriptions] = useState<
     ActiveSubscription[]
-  >([])
+  >([]);
 
-  const optionsRef = useRef<UseIapOptions | undefined>(options)
+  const optionsRef = useRef<UseIapOptions | undefined>(options);
 
   // Helper function to merge arrays with duplicate checking
   const mergeWithDuplicateCheck = useCallback(
     <T>(
       existingItems: T[],
       newItems: T[],
-      getKey: (item: T) => string
+      getKey: (item: T) => string,
     ): T[] => {
-      const merged = [...existingItems]
+      const merged = [...existingItems];
       newItems.forEach((newItem) => {
         const isDuplicate = merged.some(
-          (existingItem) => getKey(existingItem) === getKey(newItem)
-        )
+          (existingItem) => getKey(existingItem) === getKey(newItem),
+        );
         if (!isDuplicate) {
-          merged.push(newItem)
+          merged.push(newItem);
         }
-      })
-      return merged
+      });
+      return merged;
     },
-    []
-  )
+    [],
+  );
 
   useEffect(() => {
-    optionsRef.current = options
-  }, [options])
+    optionsRef.current = options;
+  }, [options]);
 
   const subscriptionsRef = useRef<{
-    purchaseUpdate?: EventSubscription
-    purchaseError?: EventSubscription
-    promotedProductsIOS?: EventSubscription
-    promotedProductIOS?: EventSubscription
-  }>({})
+    purchaseUpdate?: EventSubscription;
+    purchaseError?: EventSubscription;
+    promotedProductsIOS?: EventSubscription;
+    promotedProductIOS?: EventSubscription;
+  }>({});
 
-  const subscriptionsRefState = useRef<SubscriptionProduct[]>([])
+  const subscriptionsRefState = useRef<SubscriptionProduct[]>([]);
 
   useEffect(() => {
-    subscriptionsRefState.current = subscriptions
-  }, [subscriptions])
+    subscriptionsRefState.current = subscriptions;
+  }, [subscriptions]);
 
   const clearCurrentPurchase = useCallback(() => {
-    setCurrentPurchase(undefined)
-  }, [])
+    setCurrentPurchase(undefined);
+  }, []);
 
   const clearCurrentPurchaseError = useCallback(() => {
-    setCurrentPurchaseError(undefined)
-  }, [])
+    setCurrentPurchaseError(undefined);
+  }, []);
 
   const getProductsInternal = useCallback(
     async (skus: string[]): Promise<void> => {
       try {
-        const result = await fetchProducts({ skus, type: 'inapp' })
+        const result = await fetchProducts({skus, type: 'inapp'});
         setProducts((prevProducts: Product[]) =>
           mergeWithDuplicateCheck(
             prevProducts,
             result as Product[],
-            (product: Product) => product.id
-          )
-        )
+            (product: Product) => product.id,
+          ),
+        );
       } catch (error) {
-        console.error('Error fetching products:', error)
+        console.error('Error fetching products:', error);
       }
     },
-    [mergeWithDuplicateCheck]
-  )
+    [mergeWithDuplicateCheck],
+  );
 
   const getSubscriptionsInternal = useCallback(
     async (skus: string[]): Promise<void> => {
       try {
-        const result = await fetchProducts({ skus, type: 'subs' })
+        const result = await fetchProducts({skus, type: 'subs'});
         setSubscriptions((prevSubscriptions: SubscriptionProduct[]) =>
           mergeWithDuplicateCheck(
             prevSubscriptions,
             result as SubscriptionProduct[],
-            (subscription: SubscriptionProduct) => subscription.id
-          )
-        )
+            (subscription: SubscriptionProduct) => subscription.id,
+          ),
+        );
       } catch (error) {
-        console.error('Error fetching subscriptions:', error)
+        console.error('Error fetching subscriptions:', error);
       }
     },
-    [mergeWithDuplicateCheck]
-  )
+    [mergeWithDuplicateCheck],
+  );
 
   const fetchProductsInternal = useCallback(
     async (params: {
-      skus: string[]
-      type?: 'inapp' | 'subs'
+      skus: string[];
+      type?: 'inapp' | 'subs';
     }): Promise<void> => {
       try {
-        const result = await fetchProducts(params)
+        const result = await fetchProducts(params);
         if (params.type === 'subs') {
           setSubscriptions((prevSubscriptions: SubscriptionProduct[]) =>
             mergeWithDuplicateCheck(
               prevSubscriptions,
               result as SubscriptionProduct[],
-              (subscription: SubscriptionProduct) => subscription.id
-            )
-          )
+              (subscription: SubscriptionProduct) => subscription.id,
+            ),
+          );
         } else {
           setProducts((prevProducts: Product[]) =>
             mergeWithDuplicateCheck(
               prevProducts,
               result as Product[],
-              (product: Product) => product.id
-            )
-          )
+              (product: Product) => product.id,
+            ),
+          );
         }
       } catch (error) {
-        console.error('Error fetching products:', error)
+        console.error('Error fetching products:', error);
       }
     },
-    [mergeWithDuplicateCheck]
-  )
+    [mergeWithDuplicateCheck],
+  );
 
   const getAvailablePurchasesInternal = useCallback(async (): Promise<void> => {
     try {
-      const result = await getAvailablePurchases()
-      setAvailablePurchases(result)
+      const result = await getAvailablePurchases();
+      setAvailablePurchases(result);
     } catch (error) {
-      console.error('Error fetching available purchases:', error)
+      console.error('Error fetching available purchases:', error);
     }
-  }, [])
+  }, []);
 
   const getActiveSubscriptionsInternal = useCallback(
     async (subscriptionIds?: string[]): Promise<ActiveSubscription[]> => {
       try {
-        const result = await getActiveSubscriptions(subscriptionIds)
-        setActiveSubscriptions(result)
-        return result
+        const result = await getActiveSubscriptions(subscriptionIds);
+        setActiveSubscriptions(result);
+        return result;
       } catch (error) {
-        console.error('Error getting active subscriptions:', error)
+        console.error('Error getting active subscriptions:', error);
         // Don't clear existing activeSubscriptions on error - preserve current state
         // This prevents the UI from showing empty state when there are temporary network issues
-        return []
+        return [];
       }
     },
-    []
-  )
+    [],
+  );
 
   const hasActiveSubscriptionsInternal = useCallback(
     async (subscriptionIds?: string[]): Promise<boolean> => {
       try {
-        return await hasActiveSubscriptions(subscriptionIds)
+        return await hasActiveSubscriptions(subscriptionIds);
       } catch (error) {
-        console.error('Error checking active subscriptions:', error)
-        return false
+        console.error('Error checking active subscriptions:', error);
+        return false;
       }
     },
-    []
-  )
+    [],
+  );
 
   const finishTransaction = useCallback(
     async ({
       purchase,
       isConsumable,
     }: {
-      purchase: Purchase
-      isConsumable?: boolean
+      purchase: Purchase;
+      isConsumable?: boolean;
     }): Promise<PurchaseResult | boolean> => {
       try {
         return await finishTransactionInternal({
           purchase,
           isConsumable,
-        })
+        });
       } catch (err) {
-        throw err
+        throw err;
       } finally {
         if (purchase.id === currentPurchase?.id) {
-          clearCurrentPurchase()
+          clearCurrentPurchase();
         }
         if (purchase.id === currentPurchaseError?.productId) {
-          clearCurrentPurchaseError()
+          clearCurrentPurchaseError();
         }
       }
     },
@@ -301,118 +301,118 @@ export function useIAP(options?: UseIapOptions): UseIap {
       currentPurchaseError?.productId,
       clearCurrentPurchase,
       clearCurrentPurchaseError,
-    ]
-  )
+    ],
+  );
 
   const requestPurchaseWithReset = useCallback(
-    async (requestObj: { request: any; type?: 'inapp' | 'subs' }) => {
-      clearCurrentPurchase()
-      clearCurrentPurchaseError()
+    async (requestObj: {request: any; type?: 'inapp' | 'subs'}) => {
+      clearCurrentPurchase();
+      clearCurrentPurchaseError();
 
       try {
-        return await requestPurchaseInternal(requestObj)
+        return await requestPurchaseInternal(requestObj);
       } catch (error) {
-        throw error
+        throw error;
       }
     },
-    [clearCurrentPurchase, clearCurrentPurchaseError]
-  )
+    [clearCurrentPurchase, clearCurrentPurchaseError],
+  );
 
   const restorePurchases = useCallback(async (): Promise<void> => {
     try {
       if (Platform.OS === 'ios') {
         await syncIOS().catch((error) => {
           if (optionsRef.current?.onSyncError) {
-            optionsRef.current.onSyncError(error)
+            optionsRef.current.onSyncError(error);
           } else {
-            console.warn('Error restoring purchases:', error)
+            console.warn('Error restoring purchases:', error);
           }
-        })
+        });
       }
-      await getAvailablePurchasesInternal()
+      await getAvailablePurchasesInternal();
     } catch (error) {
-      console.warn('Failed to restore purchases:', error)
+      console.warn('Failed to restore purchases:', error);
     }
-  }, [getAvailablePurchasesInternal])
+  }, [getAvailablePurchasesInternal]);
 
   const validateReceipt = useCallback(
     async (
       sku: string,
       androidOptions?: {
-        packageName: string
-        productToken: string
-        accessToken: string
-        isSub?: boolean
-      }
+        packageName: string;
+        productToken: string;
+        accessToken: string;
+        isSub?: boolean;
+      },
     ) => {
-      return validateReceiptInternal(sku, androidOptions)
+      return validateReceiptInternal(sku, androidOptions);
     },
-    []
-  )
+    [],
+  );
 
   const initIapWithSubscriptions = useCallback(async (): Promise<void> => {
-    const result = await initConnection()
-    setConnected(result)
+    const result = await initConnection();
+    setConnected(result);
 
     if (result) {
       subscriptionsRef.current.purchaseUpdate = purchaseUpdatedListener(
         async (purchase: Purchase) => {
-          setCurrentPurchaseError(undefined)
-          setCurrentPurchase(purchase)
+          setCurrentPurchaseError(undefined);
+          setCurrentPurchase(purchase);
 
           // Always refresh subscription state after a purchase event
           try {
-            await getActiveSubscriptionsInternal()
-            await getAvailablePurchasesInternal()
+            await getActiveSubscriptionsInternal();
+            await getAvailablePurchasesInternal();
           } catch (e) {
             // Non-fatal: UI will still update from event data
-            console.warn('[useIAP] post-purchase refresh failed:', e)
+            console.warn('[useIAP] post-purchase refresh failed:', e);
           }
 
           if (optionsRef.current?.onPurchaseSuccess) {
-            optionsRef.current.onPurchaseSuccess(purchase)
+            optionsRef.current.onPurchaseSuccess(purchase);
           }
-        }
-      )
+        },
+      );
 
       subscriptionsRef.current.purchaseError = purchaseErrorListener(
         (error: PurchaseError) => {
-          setCurrentPurchase(undefined)
-          setCurrentPurchaseError(error)
+          setCurrentPurchase(undefined);
+          setCurrentPurchaseError(error);
 
           if (optionsRef.current?.onPurchaseError) {
-            optionsRef.current.onPurchaseError(error)
+            optionsRef.current.onPurchaseError(error);
           }
-        }
-      )
+        },
+      );
 
       if (Platform.OS === 'ios') {
         // iOS promoted products listener
         subscriptionsRef.current.promotedProductsIOS =
           promotedProductListenerIOS((product: Product) => {
-            setPromotedProductIOS(product)
+            setPromotedProductIOS(product);
 
             if (optionsRef.current?.onPromotedProductIOS) {
-              optionsRef.current.onPromotedProductIOS(product)
+              optionsRef.current.onPromotedProductIOS(product);
             }
-          })
+          });
       }
     }
-  }, [getActiveSubscriptionsInternal, getAvailablePurchasesInternal])
+  }, [getActiveSubscriptionsInternal, getAvailablePurchasesInternal]);
 
   useEffect(() => {
-    initIapWithSubscriptions()
-    const currentSubscriptions = subscriptionsRef.current
+    initIapWithSubscriptions();
+    const currentSubscriptions = subscriptionsRef.current;
 
     return () => {
-      currentSubscriptions.purchaseUpdate?.remove()
-      currentSubscriptions.purchaseError?.remove()
-      currentSubscriptions.promotedProductsIOS?.remove()
-      currentSubscriptions.promotedProductIOS?.remove()
-      endConnection()
-      setConnected(false)
-    }
-  }, [initIapWithSubscriptions])
+      currentSubscriptions.purchaseUpdate?.remove();
+      currentSubscriptions.purchaseError?.remove();
+      currentSubscriptions.promotedProductsIOS?.remove();
+      currentSubscriptions.promotedProductIOS?.remove();
+      endConnection();
+      setConnected(false);
+    };
+  }, [initIapWithSubscriptions]);
 
   return {
     connected,
@@ -439,5 +439,5 @@ export function useIAP(options?: UseIapOptions): UseIap {
     buyPromotedProductIOS,
     getActiveSubscriptions: getActiveSubscriptionsInternal,
     hasActiveSubscriptions: hasActiveSubscriptionsInternal,
-  }
+  };
 }