react-native-iap 14.2.2 → 14.2.3

package/src/index.ts

@@ -1,6 +1,6 @@
 // External dependencies
-import { Platform } from 'react-native'
-import { NitroModules } from 'react-native-nitro-modules'
+import {Platform} from 'react-native';
+import {NitroModules} from 'react-native-nitro-modules';
 
 // Internal modules
 import type {
@@ -9,7 +9,7 @@ import type {
   NitroReceiptValidationParams,
   NitroReceiptValidationResultIOS,
   NitroReceiptValidationResultAndroid,
-} from './specs/RnIap.nitro'
+} from './specs/RnIap.nitro';
 import type {
   Product,
   Purchase,
@@ -24,16 +24,16 @@ import type {
   RequestPurchaseIosProps,
   RequestPurchaseAndroidProps,
   SubscriptionStatusIOS,
-} from './types'
-import type { ProductRequest } from './types'
+} from './types';
+import type {ProductRequest} from './types';
 import {
   convertNitroProductToProduct,
   convertNitroPurchaseToPurchase,
   validateNitroProduct,
   validateNitroPurchase,
   convertNitroSubscriptionStatusToSubscriptionStatusIOS,
-} from './utils/type-bridge'
-import { parseErrorStringToJsonObj } from './utils/error'
+} from './utils/type-bridge';
+import {parseErrorStringToJsonObj} from './utils/error';
 
 // Export all types
 export type {
@@ -41,67 +41,67 @@ export type {
   NitroProduct,
   NitroPurchase,
   NitroPurchaseResult,
-} from './specs/RnIap.nitro'
-export * from './types'
-export * from './utils/error'
+} from './specs/RnIap.nitro';
+export * from './types';
+export * from './utils/error';
 
 // Types for event listeners
 export interface EventSubscription {
-  remove(): void
+  remove(): void;
 }
 
 // ActiveSubscription and PurchaseError types are already exported via 'export * from ./types'
 
 // Export hooks
-export { useIAP } from './hooks/useIAP'
+export {useIAP} from './hooks/useIAP';
 
 // iOS promoted product aliases for API parity
 export const getPromotedProductIOS = async (): Promise<Product | null> =>
-  requestPromotedProductIOS()
+  requestPromotedProductIOS();
 export const requestPurchaseOnPromotedProductIOS = async (): Promise<void> =>
-  buyPromotedProductIOS()
+  buyPromotedProductIOS();
 
 // Restore completed transactions (cross-platform)
 export const restorePurchases = async (
   options: PurchaseOptions = {
     alsoPublishToEventListenerIOS: false,
     onlyIncludeActiveItemsIOS: true,
-  }
+  },
 ): Promise<Purchase[]> => {
   if (Platform.OS === 'ios') {
-    await syncIOS()
+    await syncIOS();
   }
-  return getAvailablePurchases(options)
-}
+  return getAvailablePurchases(options);
+};
 
 // Development utilities removed - use type bridge functions directly if needed
 
 // Create the RnIap HybridObject instance (internal use only)
-const iap = NitroModules.createHybridObject<RnIap>('RnIap')
+const iap = NitroModules.createHybridObject<RnIap>('RnIap');
 
 /**
  * Initialize connection to the store
  */
 export const initConnection = async (): Promise<boolean> => {
   try {
-    return await iap.initConnection()
+    return await iap.initConnection();
   } catch (error) {
-    console.error('Failed to initialize IAP connection:', error)
-    throw error
+    console.error('Failed to initialize IAP connection:', error);
+    throw error;
   }
-}
+};
 
 /**
  * End connection to the store
  */
 export const endConnection = async (): Promise<boolean> => {
   try {
-    return await iap.endConnection()
+    return await iap.endConnection();
   } catch (error) {
-    console.error('Failed to end IAP connection:', error)
-    throw error
+    console.error('Failed to end IAP connection:', error);
+    throw error;
   }
-}
+};
 
 /**
  * Fetch products from the store
@@ -125,41 +125,41 @@ export const fetchProducts = async ({
 }: ProductRequest): Promise<Product[]> => {
   try {
     if (!skus || skus.length === 0) {
-      throw new Error('No SKUs provided')
+      throw new Error('No SKUs provided');
     }
 
     if (type === 'all') {
       const [inappNitro, subsNitro] = await Promise.all([
         iap.fetchProducts(skus, 'inapp'),
         iap.fetchProducts(skus, 'subs'),
-      ])
-      const allNitro = [...inappNitro, ...subsNitro]
-      const validAll = allNitro.filter(validateNitroProduct)
+      ]);
+      const allNitro = [...inappNitro, ...subsNitro];
+      const validAll = allNitro.filter(validateNitroProduct);
       if (validAll.length !== allNitro.length) {
         console.warn(
-          `[fetchProducts] Some products failed validation: ${allNitro.length - validAll.length} invalid`
-        )
+          `[fetchProducts] Some products failed validation: ${allNitro.length - validAll.length} invalid`,
+        );
       }
-      return validAll.map(convertNitroProductToProduct)
+      return validAll.map(convertNitroProductToProduct);
     }
 
-    const nitroProducts = await iap.fetchProducts(skus, type)
+    const nitroProducts = await iap.fetchProducts(skus, type);
 
     // Validate and convert NitroProducts to TypeScript Products
-    const validProducts = nitroProducts.filter(validateNitroProduct)
+    const validProducts = nitroProducts.filter(validateNitroProduct);
     if (validProducts.length !== nitroProducts.length) {
       console.warn(
-        `[fetchProducts] Some products failed validation: ${nitroProducts.length - validProducts.length} invalid`
-      )
+        `[fetchProducts] Some products failed validation: ${nitroProducts.length - validProducts.length} invalid`,
+      );
     }
 
-    const typedProducts = validProducts.map(convertNitroProductToProduct)
-    return typedProducts
+    const typedProducts = validProducts.map(convertNitroProductToProduct);
+    return typedProducts;
   } catch (error) {
-    console.error('[fetchProducts] Failed:', error)
-    throw error
+    console.error('[fetchProducts] Failed:', error);
+    throw error;
   }
-}
+};
 
 /**
  * Request a purchase for products or subscriptions
@@ -203,65 +203,65 @@ export const requestPurchase = async ({
   request,
   type = 'inapp',
 }: {
-  request: RequestPurchaseProps | RequestSubscriptionProps
-  type?: 'inapp' | 'subs'
+  request: RequestPurchaseProps | RequestSubscriptionProps;
+  type?: 'inapp' | 'subs';
 }): Promise<void> => {
   try {
     // Validate platform-specific requests
     if (Platform.OS === 'ios') {
-      const iosRequest = request.ios
+      const iosRequest = request.ios;
       if (!iosRequest?.sku) {
         throw new Error(
-          'Invalid request for iOS. The `sku` property is required.'
-        )
+          'Invalid request for iOS. The `sku` property is required.',
+        );
       }
     } else if (Platform.OS === 'android') {
-      const androidRequest = request.android
+      const androidRequest = request.android;
       if (!androidRequest?.skus?.length) {
         throw new Error(
-          'Invalid request for Android. The `skus` property is required and must be a non-empty array.'
-        )
+          'Invalid request for Android. The `skus` property is required and must be a non-empty array.',
+        );
       }
     } else {
-      throw new Error('Unsupported platform')
+      throw new Error('Unsupported platform');
     }
 
     // Transform the request for the unified interface
-    const unifiedRequest: any = {}
+    const unifiedRequest: any = {};
 
     if (Platform.OS === 'ios' && request.ios) {
-      const iosReq = request.ios as RequestPurchaseIosProps
+      const iosReq = request.ios as RequestPurchaseIosProps;
       const autoFinishSubs =
         type === 'subs' &&
-        iosReq.andDangerouslyFinishTransactionAutomatically == null
+        iosReq.andDangerouslyFinishTransactionAutomatically == null;
       unifiedRequest.ios = {
         ...iosReq,
         // Align with native SwiftUI flow: auto-finish subscriptions by default
         ...(autoFinishSubs
-          ? { andDangerouslyFinishTransactionAutomatically: true }
+          ? {andDangerouslyFinishTransactionAutomatically: true}
           : {}),
-      } as RequestPurchaseIosProps
+      } as RequestPurchaseIosProps;
     }
 
     if (Platform.OS === 'android' && request.android) {
       if (type === 'subs') {
-        const subsRequest = request.android as RequestSubscriptionAndroidProps
+        const subsRequest = request.android as RequestSubscriptionAndroidProps;
         unifiedRequest.android = {
           ...subsRequest,
           subscriptionOffers: subsRequest.subscriptionOffers || [],
-        } as RequestPurchaseAndroidProps
+        } as RequestPurchaseAndroidProps;
       } else {
-        unifiedRequest.android = request.android
+        unifiedRequest.android = request.android;
       }
     }
 
     // Call unified method - returns void, listen for events instead
-    await iap.requestPurchase(unifiedRequest)
+    await iap.requestPurchase(unifiedRequest);
   } catch (error) {
-    console.error('Failed to request purchase:', error)
-    throw error
+    console.error('Failed to request purchase:', error);
+    throw error;
   }
-}
+};
 
 /**
  * Get available purchases (purchased items not yet consumed/finished)
@@ -282,7 +282,7 @@ export const getAvailablePurchases = async ({
 }: PurchaseOptions = {}): Promise<Purchase[]> => {
   try {
     // Create unified options
-    const options: any = {}
+    const options: any = {};
 
     if (Platform.OS === 'ios') {
       // Provide both new and deprecated keys for compatibility
@@ -291,46 +291,46 @@ export const getAvailablePurchases = async ({
         onlyIncludeActiveItemsIOS,
         alsoPublishToEventListener: alsoPublishToEventListenerIOS,
         onlyIncludeActiveItems: onlyIncludeActiveItemsIOS,
-      }
+      };
     } else if (Platform.OS === 'android') {
       // For Android, we need to call twice for inapp and subs
       const inappNitroPurchases = await iap.getAvailablePurchases({
-        android: { type: 'inapp' },
-      })
+        android: {type: 'inapp'},
+      });
       const subsNitroPurchases = await iap.getAvailablePurchases({
-        android: { type: 'subs' },
-      })
+        android: {type: 'subs'},
+      });
 
       // Validate and convert both sets of purchases
-      const allNitroPurchases = [...inappNitroPurchases, ...subsNitroPurchases]
-      const validPurchases = allNitroPurchases.filter(validateNitroPurchase)
+      const allNitroPurchases = [...inappNitroPurchases, ...subsNitroPurchases];
+      const validPurchases = allNitroPurchases.filter(validateNitroPurchase);
       if (validPurchases.length !== allNitroPurchases.length) {
         console.warn(
-          `[getAvailablePurchases] Some Android purchases failed validation: ${allNitroPurchases.length - validPurchases.length} invalid`
-        )
+          `[getAvailablePurchases] Some Android purchases failed validation: ${allNitroPurchases.length - validPurchases.length} invalid`,
+        );
       }
 
-      return validPurchases.map(convertNitroPurchaseToPurchase)
+      return validPurchases.map(convertNitroPurchaseToPurchase);
     } else {
-      throw new Error('Unsupported platform')
+      throw new Error('Unsupported platform');
     }
 
-    const nitroPurchases = await iap.getAvailablePurchases(options)
+    const nitroPurchases = await iap.getAvailablePurchases(options);
 
     // Validate and convert NitroPurchases to TypeScript Purchases
-    const validPurchases = nitroPurchases.filter(validateNitroPurchase)
+    const validPurchases = nitroPurchases.filter(validateNitroPurchase);
     if (validPurchases.length !== nitroPurchases.length) {
       console.warn(
-        `[getAvailablePurchases] Some purchases failed validation: ${nitroPurchases.length - validPurchases.length} invalid`
-      )
+        `[getAvailablePurchases] Some purchases failed validation: ${nitroPurchases.length - validPurchases.length} invalid`,
+      );
     }
 
-    return validPurchases.map(convertNitroPurchaseToPurchase)
+    return validPurchases.map(convertNitroPurchaseToPurchase);
   } catch (error) {
-    console.error('Failed to get available purchases:', error)
-    throw error
+    console.error('Failed to get available purchases:', error);
+    throw error;
   }
-}
+};
 
 /**
  * Finish a transaction (consume or acknowledge)
@@ -352,58 +352,58 @@ export const finishTransaction = async ({
 }: FinishTransactionParams): Promise<NitroPurchaseResult | boolean> => {
   try {
     // Create unified params
-    const params: any = {}
+    const params: any = {};
 
     if (Platform.OS === 'ios') {
       if (!purchase.id) {
-        throw new Error('purchase.id required to finish iOS transaction')
+        throw new Error('purchase.id required to finish iOS transaction');
       }
       params.ios = {
         transactionId: purchase.id,
-      }
+      };
     } else if (Platform.OS === 'android') {
-      const androidPurchase = purchase as PurchaseAndroid
+      const androidPurchase = purchase as PurchaseAndroid;
       const token =
-        androidPurchase.purchaseToken || androidPurchase.purchaseTokenAndroid
+        androidPurchase.purchaseToken || androidPurchase.purchaseTokenAndroid;
 
       if (!token) {
-        throw new Error('purchaseToken required to finish Android transaction')
+        throw new Error('purchaseToken required to finish Android transaction');
       }
 
       params.android = {
         purchaseToken: token,
         isConsumable,
-      }
+      };
     } else {
-      throw new Error('Unsupported platform')
+      throw new Error('Unsupported platform');
     }
 
-    const result = await iap.finishTransaction(params)
+    const result = await iap.finishTransaction(params);
 
     // Handle variant return type
     if (typeof result === 'boolean') {
-      return result
+      return result;
     }
     // It's a PurchaseResult
-    return result as NitroPurchaseResult
+    return result as NitroPurchaseResult;
   } catch (error) {
     // If iOS transaction has already been auto-finished natively, treat as success
     if (Platform.OS === 'ios') {
-      const err = parseErrorStringToJsonObj(error)
-      const msg = (err?.message || '').toString()
-      const code = (err?.code || '').toString()
+      const err = parseErrorStringToJsonObj(error);
+      const msg = (err?.message || '').toString();
+      const code = (err?.code || '').toString();
       if (
         msg.includes('Transaction not found') ||
         code === 'E_ITEM_UNAVAILABLE'
       ) {
         // Consider already finished
-        return true
+        return true;
       }
     }
-    console.error('Failed to finish transaction:', error)
-    throw error
+    console.error('Failed to finish transaction:', error);
+    throw error;
   }
-}
+};
 
 /**
  * Acknowledge a purchase (Android only)
@@ -415,11 +415,13 @@ export const finishTransaction = async ({
  * ```
  */
 export const acknowledgePurchaseAndroid = async (
-  purchaseToken: string
+  purchaseToken: string,
 ): Promise<NitroPurchaseResult> => {
   try {
     if (Platform.OS !== 'android') {
-      throw new Error('acknowledgePurchaseAndroid is only available on Android')
+      throw new Error(
+        'acknowledgePurchaseAndroid is only available on Android',
+      );
     }
 
     const result = await iap.finishTransaction({
@@ -427,7 +429,7 @@ export const acknowledgePurchaseAndroid = async (
         purchaseToken,
         isConsumable: false,
       },
-    })
+    });
 
     // Result is a variant, extract PurchaseResult
     if (typeof result === 'boolean') {
@@ -437,14 +439,14 @@ export const acknowledgePurchaseAndroid = async (
         code: '0',
         message: 'Success',
         purchaseToken,
-      }
+      };
     }
-    return result as NitroPurchaseResult
+    return result as NitroPurchaseResult;
   } catch (error) {
-    console.error('Failed to acknowledge purchase Android:', error)
-    throw error
+    console.error('Failed to acknowledge purchase Android:', error);
+    throw error;
   }
-}
+};
 
 /**
  * Consume a purchase (Android only)
@@ -456,11 +458,11 @@ export const acknowledgePurchaseAndroid = async (
  * ```
  */
 export const consumePurchaseAndroid = async (
-  purchaseToken: string
+  purchaseToken: string,
 ): Promise<NitroPurchaseResult> => {
   try {
     if (Platform.OS !== 'android') {
-      throw new Error('consumePurchaseAndroid is only available on Android')
+      throw new Error('consumePurchaseAndroid is only available on Android');
     }
 
     const result = await iap.finishTransaction({
@@ -468,7 +470,7 @@ export const consumePurchaseAndroid = async (
         purchaseToken,
         isConsumable: true,
       },
-    })
+    });
 
     // Result is a variant, extract PurchaseResult
     if (typeof result === 'boolean') {
@@ -478,21 +480,21 @@ export const consumePurchaseAndroid = async (
         code: '0',
         message: 'Success',
         purchaseToken,
-      }
+      };
     }
-    return result as NitroPurchaseResult
+    return result as NitroPurchaseResult;
   } catch (error) {
-    console.error('Failed to consume purchase Android:', error)
-    throw error
+    console.error('Failed to consume purchase Android:', error);
+    throw error;
   }
-}
+};
 
 // ============================================================================
 // EVENT LISTENERS
 // ============================================================================
 
 // Store wrapped listeners for proper removal
-const listenerMap = new WeakMap<Function, Function>()
+const listenerMap = new WeakMap<Function, Function>();
 
 /**
  * Purchase updated event listener
@@ -515,35 +517,35 @@ const listenerMap = new WeakMap<Function, Function>()
  * ```
  */
 export const purchaseUpdatedListener = (
-  listener: (purchase: Purchase) => void
+  listener: (purchase: Purchase) => void,
 ): EventSubscription => {
   // Wrap the listener to convert NitroPurchase to Purchase
   const wrappedListener = (nitroPurchase: any) => {
     if (validateNitroPurchase(nitroPurchase)) {
-      const convertedPurchase = convertNitroPurchaseToPurchase(nitroPurchase)
-      listener(convertedPurchase)
+      const convertedPurchase = convertNitroPurchaseToPurchase(nitroPurchase);
+      listener(convertedPurchase);
     } else {
       console.error(
         'Invalid purchase data received from native:',
-        nitroPurchase
-      )
+        nitroPurchase,
+      );
     }
-  }
+  };
 
   // Store the wrapped listener for removal
-  listenerMap.set(listener, wrappedListener)
-  iap.addPurchaseUpdatedListener(wrappedListener)
+  listenerMap.set(listener, wrappedListener);
+  iap.addPurchaseUpdatedListener(wrappedListener);
 
   return {
     remove: () => {
-      const wrapped = listenerMap.get(listener)
+      const wrapped = listenerMap.get(listener);
       if (wrapped) {
-        iap.removePurchaseUpdatedListener(wrapped as any)
-        listenerMap.delete(listener)
+        iap.removePurchaseUpdatedListener(wrapped as any);
+        listenerMap.delete(listener);
       }
     },
-  }
-}
+  };
+};
 
 /**
  * Purchase error event listener
@@ -573,19 +575,19 @@ export const purchaseUpdatedListener = (
  * ```
  */
 export const purchaseErrorListener = (
-  listener: (error: NitroPurchaseResult) => void
+  listener: (error: NitroPurchaseResult) => void,
 ): EventSubscription => {
   // Store the listener for removal
-  listenerMap.set(listener, listener)
-  iap.addPurchaseErrorListener(listener as any)
+  listenerMap.set(listener, listener);
+  iap.addPurchaseErrorListener(listener as any);
 
   return {
     remove: () => {
-      iap.removePurchaseErrorListener(listener as any)
-      listenerMap.delete(listener)
+      iap.removePurchaseErrorListener(listener as any);
+      listenerMap.delete(listener);
     },
-  }
-}
+  };
+};
 
 /**
  * iOS-only listener for App Store promoted product events.
@@ -608,42 +610,42 @@ export const purchaseErrorListener = (
  * @platform iOS
  */
 export const promotedProductListenerIOS = (
-  listener: (product: Product) => void
+  listener: (product: Product) => void,
 ): EventSubscription => {
   if (Platform.OS !== 'ios') {
     console.warn(
-      'promotedProductListenerIOS: This listener is only available on iOS'
-    )
-    return { remove: () => {} }
+      'promotedProductListenerIOS: This listener is only available on iOS',
+    );
+    return {remove: () => {}};
   }
 
   // Wrap the listener to convert NitroProduct to Product
   const wrappedListener = (nitroProduct: any) => {
     if (validateNitroProduct(nitroProduct)) {
-      const convertedProduct = convertNitroProductToProduct(nitroProduct)
-      listener(convertedProduct)
+      const convertedProduct = convertNitroProductToProduct(nitroProduct);
+      listener(convertedProduct);
     } else {
       console.error(
         'Invalid promoted product data received from native:',
-        nitroProduct
-      )
+        nitroProduct,
+      );
     }
-  }
+  };
 
   // Store the wrapped listener for removal
-  listenerMap.set(listener, wrappedListener)
-  iap.addPromotedProductListenerIOS(wrappedListener)
+  listenerMap.set(listener, wrappedListener);
+  iap.addPromotedProductListenerIOS(wrappedListener);
 
   return {
     remove: () => {
-      const wrapped = listenerMap.get(listener)
+      const wrapped = listenerMap.get(listener);
       if (wrapped) {
-        iap.removePromotedProductListenerIOS(wrapped as any)
-        listenerMap.delete(listener)
+        iap.removePromotedProductListenerIOS(wrapped as any);
+        listenerMap.delete(listener);
       }
     },
-  }
-}
+  };
+};
 
 // ============================================================================
 // iOS-SPECIFIC FUNCTIONS
@@ -658,30 +660,30 @@ export const promotedProductListenerIOS = (
 export const validateReceipt = async (
   sku: string,
   androidOptions?: {
-    packageName: string
-    productToken: string
-    accessToken: string
-    isSub?: boolean
-  }
+    packageName: string;
+    productToken: string;
+    accessToken: string;
+    isSub?: boolean;
+  },
 ): Promise<import('./types').ReceiptValidationResult> => {
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
     const params: NitroReceiptValidationParams = {
       sku,
       androidOptions,
-    }
+    };
 
-    const nitroResult = await iap.validateReceipt(params)
+    const nitroResult = await iap.validateReceipt(params);
 
     // Convert Nitro result to public API result
     if (Platform.OS === 'ios') {
-      const iosResult = nitroResult as NitroReceiptValidationResultIOS
+      const iosResult = nitroResult as NitroReceiptValidationResultIOS;
       const result: ReceiptValidationResultIOS = {
         isValid: iosResult.isValid,
         receiptData: iosResult.receiptData,
@@ -689,11 +691,11 @@ export const validateReceipt = async (
         latestTransaction: iosResult.latestTransaction
           ? convertNitroPurchaseToPurchase(iosResult.latestTransaction)
           : undefined,
-      }
-      return result
+      };
+      return result;
     } else {
       // Android
-      const androidResult = nitroResult as NitroReceiptValidationResultAndroid
+      const androidResult = nitroResult as NitroReceiptValidationResultAndroid;
       const result: ReceiptValidationResultAndroid = {
         autoRenewing: androidResult.autoRenewing,
         betaProduct: androidResult.betaProduct,
@@ -713,15 +715,15 @@ export const validateReceipt = async (
         term: androidResult.term,
         termSku: androidResult.termSku,
         testTransaction: androidResult.testTransaction,
-      }
-      return result
+      };
+      return result;
     }
   } catch (error) {
-    console.error('[validateReceipt] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[validateReceipt] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Sync iOS purchases with App Store (iOS only)
@@ -730,24 +732,24 @@ export const validateReceipt = async (
  */
 export const syncIOS = async (): Promise<boolean> => {
   if (Platform.OS !== 'ios') {
-    throw new Error('syncIOS is only available on iOS')
+    throw new Error('syncIOS is only available on iOS');
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.syncIOS()
+    return await iap.syncIOS();
   } catch (error) {
-    console.error('[syncIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[syncIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Request the promoted product from the App Store (iOS only)
@@ -756,28 +758,28 @@ export const syncIOS = async (): Promise<boolean> => {
  */
 export const requestPromotedProductIOS = async (): Promise<Product | null> => {
   if (Platform.OS !== 'ios') {
-    return null
+    return null;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    const nitroProduct = await iap.requestPromotedProductIOS()
+    const nitroProduct = await iap.requestPromotedProductIOS();
     if (nitroProduct) {
-      return convertNitroProductToProduct(nitroProduct)
+      return convertNitroProductToProduct(nitroProduct);
     }
-    return null
+    return null;
   } catch (error) {
-    console.error('[getPromotedProductIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[getPromotedProductIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Present the code redemption sheet for offer codes (iOS only)
@@ -786,24 +788,24 @@ export const requestPromotedProductIOS = async (): Promise<Product | null> => {
  */
 export const presentCodeRedemptionSheetIOS = async (): Promise<boolean> => {
   if (Platform.OS !== 'ios') {
-    return false
+    return false;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.presentCodeRedemptionSheetIOS()
+    return await iap.presentCodeRedemptionSheetIOS();
   } catch (error) {
-    console.error('[presentCodeRedemptionSheetIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[presentCodeRedemptionSheetIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Buy promoted product on iOS
@@ -812,24 +814,24 @@ export const presentCodeRedemptionSheetIOS = async (): Promise<boolean> => {
  */
 export const buyPromotedProductIOS = async (): Promise<void> => {
   if (Platform.OS !== 'ios') {
-    throw new Error('buyPromotedProductIOS is only available on iOS')
+    throw new Error('buyPromotedProductIOS is only available on iOS');
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    await iap.buyPromotedProductIOS()
+    await iap.buyPromotedProductIOS();
   } catch (error) {
-    console.error('[buyPromotedProductIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[buyPromotedProductIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Clear unfinished transactions on iOS
@@ -838,24 +840,24 @@ export const buyPromotedProductIOS = async (): Promise<void> => {
  */
 export const clearTransactionIOS = async (): Promise<void> => {
   if (Platform.OS !== 'ios') {
-    return
+    return;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    await iap.clearTransactionIOS()
+    await iap.clearTransactionIOS();
   } catch (error) {
-    console.error('[clearTransactionIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[clearTransactionIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Begin a refund request for a product on iOS 15+
@@ -864,27 +866,27 @@ export const clearTransactionIOS = async (): Promise<void> => {
  * @platform iOS
  */
 export const beginRefundRequestIOS = async (
-  sku: string
+  sku: string,
 ): Promise<string | null> => {
   if (Platform.OS !== 'ios') {
-    return null
+    return null;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.beginRefundRequestIOS(sku)
+    return await iap.beginRefundRequestIOS(sku);
   } catch (error) {
-    console.error('[beginRefundRequestIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[beginRefundRequestIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get subscription status for a product (iOS only)
@@ -894,31 +896,31 @@ export const beginRefundRequestIOS = async (
  * @platform iOS
  */
 export const subscriptionStatusIOS = async (
-  sku: string
+  sku: string,
 ): Promise<SubscriptionStatusIOS[]> => {
   if (Platform.OS !== 'ios') {
-    throw new Error('subscriptionStatusIOS is only available on iOS')
+    throw new Error('subscriptionStatusIOS is only available on iOS');
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    const statuses = await iap.subscriptionStatusIOS(sku)
-    if (!statuses || !Array.isArray(statuses)) return []
+    const statuses = await iap.subscriptionStatusIOS(sku);
+    if (!statuses || !Array.isArray(statuses)) return [];
     return statuses.map((s) =>
-      convertNitroSubscriptionStatusToSubscriptionStatusIOS(s as any)
-    )
+      convertNitroSubscriptionStatusToSubscriptionStatusIOS(s as any),
+    );
   } catch (error) {
-    console.error('[subscriptionStatusIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[subscriptionStatusIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get current entitlement for a product (iOS only)
@@ -927,31 +929,31 @@ export const subscriptionStatusIOS = async (
  * @platform iOS
  */
 export const currentEntitlementIOS = async (
-  sku: string
+  sku: string,
 ): Promise<Purchase | null> => {
   if (Platform.OS !== 'ios') {
-    return null
+    return null;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    const nitroPurchase = await iap.currentEntitlementIOS(sku)
+    const nitroPurchase = await iap.currentEntitlementIOS(sku);
     if (nitroPurchase) {
-      return convertNitroPurchaseToPurchase(nitroPurchase)
+      return convertNitroPurchaseToPurchase(nitroPurchase);
     }
-    return null
+    return null;
   } catch (error) {
-    console.error('[currentEntitlementIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[currentEntitlementIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get latest transaction for a product (iOS only)
@@ -960,31 +962,31 @@ export const currentEntitlementIOS = async (
  * @platform iOS
  */
 export const latestTransactionIOS = async (
-  sku: string
+  sku: string,
 ): Promise<Purchase | null> => {
   if (Platform.OS !== 'ios') {
-    return null
+    return null;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    const nitroPurchase = await iap.latestTransactionIOS(sku)
+    const nitroPurchase = await iap.latestTransactionIOS(sku);
     if (nitroPurchase) {
-      return convertNitroPurchaseToPurchase(nitroPurchase)
+      return convertNitroPurchaseToPurchase(nitroPurchase);
     }
-    return null
+    return null;
   } catch (error) {
-    console.error('[latestTransactionIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[latestTransactionIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get pending transactions (iOS only)
@@ -993,25 +995,25 @@ export const latestTransactionIOS = async (
  */
 export const getPendingTransactionsIOS = async (): Promise<Purchase[]> => {
   if (Platform.OS !== 'ios') {
-    return []
+    return [];
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    const nitroPurchases = await iap.getPendingTransactionsIOS()
-    return nitroPurchases.map(convertNitroPurchaseToPurchase)
+    const nitroPurchases = await iap.getPendingTransactionsIOS();
+    return nitroPurchases.map(convertNitroPurchaseToPurchase);
   } catch (error) {
-    console.error('[getPendingTransactionsIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[getPendingTransactionsIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Show manage subscriptions screen (iOS only)
@@ -1020,25 +1022,25 @@ export const getPendingTransactionsIOS = async (): Promise<Purchase[]> => {
  */
 export const showManageSubscriptionsIOS = async (): Promise<Purchase[]> => {
   if (Platform.OS !== 'ios') {
-    return []
+    return [];
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    const nitroPurchases = await iap.showManageSubscriptionsIOS()
-    return nitroPurchases.map(convertNitroPurchaseToPurchase)
+    const nitroPurchases = await iap.showManageSubscriptionsIOS();
+    return nitroPurchases.map(convertNitroPurchaseToPurchase);
   } catch (error) {
-    console.error('[showManageSubscriptionsIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[showManageSubscriptionsIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Check if user is eligible for intro offer (iOS only)
@@ -1047,27 +1049,27 @@ export const showManageSubscriptionsIOS = async (): Promise<Purchase[]> => {
  * @platform iOS
  */
 export const isEligibleForIntroOfferIOS = async (
-  groupID: string
+  groupID: string,
 ): Promise<boolean> => {
   if (Platform.OS !== 'ios') {
-    return false
+    return false;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.isEligibleForIntroOfferIOS(groupID)
+    return await iap.isEligibleForIntroOfferIOS(groupID);
   } catch (error) {
-    console.error('[isEligibleForIntroOfferIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[isEligibleForIntroOfferIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get receipt data (iOS only)
@@ -1076,24 +1078,24 @@ export const isEligibleForIntroOfferIOS = async (
  */
 export const getReceiptDataIOS = async (): Promise<string> => {
   if (Platform.OS !== 'ios') {
-    throw new Error('getReceiptDataIOS is only available on iOS')
+    throw new Error('getReceiptDataIOS is only available on iOS');
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.getReceiptDataIOS()
+    return await iap.getReceiptDataIOS();
   } catch (error) {
-    console.error('[getReceiptDataIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[getReceiptDataIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Check if transaction is verified (iOS only)
@@ -1102,27 +1104,27 @@ export const getReceiptDataIOS = async (): Promise<string> => {
  * @platform iOS
  */
 export const isTransactionVerifiedIOS = async (
-  sku: string
+  sku: string,
 ): Promise<boolean> => {
   if (Platform.OS !== 'ios') {
-    return false
+    return false;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.isTransactionVerifiedIOS(sku)
+    return await iap.isTransactionVerifiedIOS(sku);
   } catch (error) {
-    console.error('[isTransactionVerifiedIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[isTransactionVerifiedIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get transaction JWS representation (iOS only)
@@ -1131,27 +1133,27 @@ export const isTransactionVerifiedIOS = async (
  * @platform iOS
  */
 export const getTransactionJwsIOS = async (
-  sku: string
+  sku: string,
 ): Promise<string | null> => {
   if (Platform.OS !== 'ios') {
-    return null
+    return null;
   }
 
   if (!iap) {
     const errorJson = parseErrorStringToJsonObj(
-      'RnIap: Service not initialized. Call initConnection() first.'
-    )
-    throw new Error(errorJson.message)
+      'RnIap: Service not initialized. Call initConnection() first.',
+    );
+    throw new Error(errorJson.message);
   }
 
   try {
-    return await iap.getTransactionJwsIOS(sku)
+    return await iap.getTransactionJwsIOS(sku);
   } catch (error) {
-    console.error('[getTransactionJwsIOS] Failed:', error)
-    const errorJson = parseErrorStringToJsonObj(error)
-    throw new Error(errorJson.message)
+    console.error('[getTransactionJwsIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
   }
-}
+};
 
 /**
  * Get the storefront identifier for the user's App Store account (iOS only)
@@ -1166,18 +1168,18 @@ export const getTransactionJwsIOS = async (
  */
 export const getStorefrontIOS = async (): Promise<string> => {
   if (Platform.OS !== 'ios') {
-    throw new Error('getStorefrontIOS is only available on iOS')
+    throw new Error('getStorefrontIOS is only available on iOS');
   }
 
   try {
     // Call the native method to get storefront
-    const storefront = await iap.getStorefrontIOS()
-    return storefront
+    const storefront = await iap.getStorefrontIOS();
+    return storefront;
   } catch (error) {
-    console.error('Failed to get storefront:', error)
-    throw error
+    console.error('Failed to get storefront:', error);
+    throw error;
   }
-}
+};
 
 /**
  * iOS only - Gets the original app transaction ID if the app was purchased from the App Store
@@ -1200,24 +1202,24 @@ export const getStorefrontIOS = async (): Promise<string> => {
  */
 export const getAppTransactionIOS = async (): Promise<string | null> => {
   if (Platform.OS !== 'ios') {
-    throw new Error('getAppTransactionIOS is only available on iOS')
+    throw new Error('getAppTransactionIOS is only available on iOS');
   }
 
   try {
     // Call the native method to get app transaction
-    const appTransaction = await iap.getAppTransactionIOS()
-    return appTransaction
+    const appTransaction = await iap.getAppTransactionIOS();
+    return appTransaction;
   } catch (error) {
-    console.error('Failed to get app transaction:', error)
-    throw error
+    console.error('Failed to get app transaction:', error);
+    throw error;
   }
-}
+};
 
 // Export subscription helpers
 export {
   getActiveSubscriptions,
   hasActiveSubscriptions,
-} from './helpers/subscription'
+} from './helpers/subscription';
 
 // Type conversion utilities
 export {
@@ -1227,15 +1229,15 @@ export {
   validateNitroProduct,
   validateNitroPurchase,
   checkTypeSynchronization,
-} from './utils/type-bridge'
+} from './utils/type-bridge';
 
 // Deprecated exports for backward compatibility
 /**
  * @deprecated Use acknowledgePurchaseAndroid instead
  */
-export const acknowledgePurchase = acknowledgePurchaseAndroid
+export const acknowledgePurchase = acknowledgePurchaseAndroid;
 
 /**
  * @deprecated Use consumePurchaseAndroid instead
  */
-export const consumePurchase = consumePurchaseAndroid
+export const consumePurchase = consumePurchaseAndroid;