react-native-iap 11.0.0-alpha.7 → 11.0.0-rc.1

package/lib/commonjs/iap.js

@@ -3,16 +3,50 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.validateReceiptIos = exports.validateReceiptAndroid = exports.validateReceiptAmazon = exports.setIosNativeModule = exports.setAndroidNativeModule = exports.requestSubscription = exports.requestPurchaseWithOfferIOS = exports.requestPurchase = exports.presentCodeRedemptionSheetIOS = exports.isIosStorekit2 = exports.initConnection = exports.getSubscriptions = exports.getReceiptIOS = exports.getPurchaseHistory = exports.getPromotedProductIOS = exports.getProducts = exports.getPendingPurchasesIOS = exports.getNativeModule = exports.getIosModule = exports.getInstallSourceAndroid = exports.getAvailablePurchases = exports.getAndroidModule = exports.flushFailedPurchasesCachedAsPendingAndroid = exports.finishTransaction = exports.endConnection = exports.deepLinkToSubscriptionsAndroid = exports.clearTransactionIOS = exports.clearProductsIOS = exports.buyPromotedProductIOS = exports.acknowledgePurchaseAndroid = void 0;
+exports.IapIosSk2 = exports.IapIos = exports.IapAndroid = exports.IapAmazon = void 0;
+Object.defineProperty(exports, "enableStorekit2", {
+  enumerable: true,
+  get: function () {
+    return _internal.enableStorekit2;
+  }
+});
+exports.initConnection = exports.getSubscriptions = exports.getPurchaseHistory = exports.getProducts = exports.getAvailablePurchases = exports.flushFailedPurchasesCachedAsPendingAndroid = exports.finishTransaction = exports.endConnection = void 0;
+Object.defineProperty(exports, "isIosStorekit2", {
+  enumerable: true,
+  get: function () {
+    return _internal.isIosStorekit2;
+  }
+});
+exports.requestSubscription = exports.requestPurchase = void 0;
 
 var _reactNative = require("react-native");
 
+var IapAmazon = _interopRequireWildcard(require("./modules/amazon"));
+
+exports.IapAmazon = IapAmazon;
+
+var IapAndroid = _interopRequireWildcard(require("./modules/android"));
+
+exports.IapAndroid = IapAndroid;
+
+var IapIos = _interopRequireWildcard(require("./modules/ios"));
+
+exports.IapIos = IapIos;
+
+var IapIosSk2 = _interopRequireWildcard(require("./modules/iosSk2"));
+
+exports.IapIosSk2 = IapIosSk2;
+
 var _appleSk = require("./types/appleSk2");
 
 var _internal = require("./internal");
 
 var _types = require("./types");
 
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 const {
   RNIapIos,
   RNIapIosSk2,
@@ -21,78 +55,51 @@ const {
 } = _reactNative.NativeModules;
 const ANDROID_ITEM_TYPE_SUBSCRIPTION = _types.ProductType.subs;
 const ANDROID_ITEM_TYPE_IAP = _types.ProductType.inapp;
+/**
+ * Init module for purchase flow. Required on Android. In ios it will check whether user canMakePayment.
+ * ## Usage
 
-const getInstallSourceAndroid = () => {
-  return RNIapModule ? _types.InstallSourceAndroid.GOOGLE_PLAY : _types.InstallSourceAndroid.AMAZON;
-};
-
-exports.getInstallSourceAndroid = getInstallSourceAndroid;
-let androidNativeModule = RNIapModule;
-let iosNativeModule = RNIapIosSk2;
-
-const isIosStorekit2 = () => iosNativeModule === RNIapIosSk2;
-
-exports.isIosStorekit2 = isIosStorekit2;
-
-const setAndroidNativeModule = nativeModule => {
-  androidNativeModule = nativeModule;
-};
-
-exports.setAndroidNativeModule = setAndroidNativeModule;
-
-const setIosNativeModule = nativeModule => {
-  iosNativeModule = nativeModule;
-};
-
-exports.setIosNativeModule = setIosNativeModule;
-
-const checkNativeAndroidAvailable = () => {
-  if (!RNIapModule && !RNIapAmazonModule) {
-    throw new Error('IAP_NOT_AVAILABLE');
-  }
-};
-
-const getAndroidModule = () => {
-  checkNativeAndroidAvailable();
-  return androidNativeModule ? androidNativeModule : RNIapModule ? RNIapModule : RNIapAmazonModule;
-};
-
-exports.getAndroidModule = getAndroidModule;
-
-const checkNativeIOSAvailable = () => {
-  if (!RNIapIos && !RNIapIosSk2) {
-    throw new Error('IAP_NOT_AVAILABLE');
-  }
-};
-
-const getIosModule = () => {
-  checkNativeIOSAvailable();
-  return iosNativeModule ? iosNativeModule : RNIapIosSk2 ? RNIapIosSk2 : RNIapIos;
-};
+```tsx
+import React, {useEffect} from 'react';
+import {View} from 'react-native';
+import {initConnection} from 'react-native-iap';
 
-exports.getIosModule = getIosModule;
+const App = () => {
+  useEffect(() => {
+    void initConnection();
+  }, []);
 
-const getNativeModule = () => {
-  return _internal.isAndroid ? getAndroidModule() : getIosModule();
+  return <View />;
 };
-/**
- * Init module for purchase flow. Required on Android. In ios it will check whether user canMakePayment.
- * @returns {Promise<boolean>}
+```
  */
 
-
-exports.getNativeModule = getNativeModule;
-
-const initConnection = () => getNativeModule().initConnection();
+const initConnection = () => (0, _internal.getNativeModule)().initConnection();
 /**
- * End module for purchase flow.
+ * Disconnects from native SDK
+ * Usage
+ * ```tsx
+import React, {useEffect} from 'react';
+import {View} from 'react-native';
+import {endConnection} from 'react-native-iap';
+
+const App = () => {
+  useEffect(() => {
+    return () => {
+      void endConnection();
+    };
+  }, []);
+
+  return <View />;
+};
+```
  * @returns {Promise<void>}
  */
 
 
 exports.initConnection = initConnection;
 
-const endConnection = () => getNativeModule().endConnection();
+const endConnection = () => (0, _internal.getNativeModule)().endConnection();
 /**
  * Consume all 'ghost' purchases (that is, pending payment that already failed but is still marked as pending in Play Store cache). Android only.
  * @returns {Promise<boolean>}
@@ -101,11 +108,50 @@ const endConnection = () => getNativeModule().endConnection();
 
 exports.endConnection = endConnection;
 
-const flushFailedPurchasesCachedAsPendingAndroid = () => getAndroidModule().flushFailedPurchasesCachedAsPending();
+const flushFailedPurchasesCachedAsPendingAndroid = () => (0, _internal.getAndroidModule)().flushFailedPurchasesCachedAsPending();
 /**
  * Get a list of products (consumable and non-consumable items, but not subscriptions)
- * @param {string[]} skus The item skus
- * @returns {Promise<Product[]>}
+ ## Usage
+
+```ts
+import React, {useState} from 'react';
+import {Platform} from 'react-native';
+import {getProducts, Product} from 'react-native-iap';
+
+const skus = Platform.select({
+  ios: ['com.example.consumableIos'],
+  android: ['com.example.consumableAndroid'],
+});
+
+const App = () => {
+  const [products, setProducts] = useState<Product[]>([]);
+
+  const handleProducts = async () => {
+    const items = await getProducts({skus});
+
+    setProducts(items);
+  };
+
+  useEffect(() => {
+    void handleProducts();
+  }, []);
+
+  return (
+    <>
+      {products.map((product) => (
+        <Text key={product.productId}>{product.productId}</Text>
+      ))}
+    </>
+  );
+};
+```
+
+Just a few things to keep in mind:
+
+- You can get your products in `componentDidMount`, `useEffect` or another appropriate area of your app.
+- Since a user may start your app with a bad or no internet connection, preparing/getting the items more than once may be a good idea.
+- If the user has no IAPs available when the app starts first, you may want to check again when the user enters your IAP store.
+
  */
 
 
@@ -119,7 +165,7 @@ const getProducts = _ref => {
     ios: async () => {
       let items;
 
-      if (isIosStorekit2()) {
+      if ((0, _internal.isIosStorekit2)()) {
         items = (await RNIapIosSk2.getItems(skus)).map(_appleSk.productSk2Map);
       } else {
         items = await RNIapIos.getItems(skus);
@@ -128,15 +174,31 @@ const getProducts = _ref => {
       return items.filter(item => skus.includes(item.productId) && item.type === 'iap');
     },
     android: async () => {
-      const products = await getAndroidModule().getItemsByType(ANDROID_ITEM_TYPE_IAP, skus);
+      const products = await (0, _internal.getAndroidModule)().getItemsByType(ANDROID_ITEM_TYPE_IAP, skus);
       return (0, _internal.fillProductsWithAdditionalData)(products);
     }
   }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
 /**
  * Get a list of subscriptions
- * @param {string[]} skus The item skus
- * @returns {Promise<Subscription[]>}
+ * ## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {View} from 'react-native';
+import {getSubscriptions} from 'react-native-iap';
+
+const App = () => {
+  const subscriptions = useCallback(
+    async () =>
+      await getSubscriptions(['com.example.product1', 'com.example.product2']),
+    [],
+  );
+
+  return <View />;
+};
+```
+
  */
 
 
@@ -150,7 +212,7 @@ const getSubscriptions = _ref2 => {
     ios: async () => {
       let items;
 
-      if (isIosStorekit2()) {
+      if ((0, _internal.isIosStorekit2)()) {
         items = (await RNIapIosSk2.getItems(skus)).map(_appleSk.subscriptionSk2Map);
       } else {
         items = await RNIapIos.getItems(skus);
@@ -159,14 +221,33 @@ const getSubscriptions = _ref2 => {
       return items.filter(item => skus.includes(item.productId) && item.type === 'subs');
     },
     android: async () => {
-      const subscriptions = await getAndroidModule().getItemsByType(ANDROID_ITEM_TYPE_SUBSCRIPTION, skus);
+      const subscriptions = await (0, _internal.getAndroidModule)().getItemsByType(ANDROID_ITEM_TYPE_SUBSCRIPTION, skus);
       return (0, _internal.fillProductsWithAdditionalData)(subscriptions);
     }
   }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
 /**
  * Gets an inventory of purchases made by the user regardless of consumption status
- * @returns {Promise<(ProductPurchase | SubscriptionPurchase)[]>}
+ * ## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {View} from 'react-native';
+import {getPurchaseHistory} from 'react-native-iap';
+
+const App = () => {
+  const history = useCallback(
+    async () =>
+      await getPurchaseHistory([
+        'com.example.product1',
+        'com.example.product2',
+      ]),
+    [],
+  );
+
+  return <View />;
+};
+```
  */
 
 
@@ -174,7 +255,7 @@ exports.getSubscriptions = getSubscriptions;
 
 const getPurchaseHistory = () => (_reactNative.Platform.select({
   ios: async () => {
-    return getIosModule().getAvailableItems();
+    return (0, _internal.getIosModule)().getAvailableItems();
   },
   android: async () => {
     if (RNIapAmazonModule) {
@@ -188,7 +269,81 @@ const getPurchaseHistory = () => (_reactNative.Platform.select({
 }) || (() => Promise.resolve([])))();
 /**
  * Get all purchases made by the user (either non-consumable, or haven't been consumed yet)
- * @returns {Promise<(ProductPurchase | SubscriptionPurchase)[]>}
+ * ## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {View} from 'react-native';
+import {getAvailablePurchases} from 'react-native-iap';
+
+const App = () => {
+  const availablePurchases = useCallback(
+    async () => await getAvailablePurchases(),
+    [],
+  );
+
+  return <View />;
+};
+```
+
+## Restoring purchases
+
+You can use `getAvailablePurchases()` to do what's commonly understood as "restoring" purchases.
+
+:::note
+For debugging you may want to consume all items, you have then to iterate over the purchases returned by `getAvailablePurchases()`.
+:::
+
+:::warning
+Beware that if you consume an item without having recorded the purchase in your database the user may have paid for something without getting it delivered and you will have no way to recover the receipt to validate and restore their purchase.
+:::
+
+```tsx
+import React from 'react';
+import {Button} from 'react-native';
+import {getAvailablePurchases,finishTransaction} from 'react-native-iap';
+
+const App = () => {
+  handleRestore = async () => {
+    try {
+      const purchases = await getAvailablePurchases();
+      const newState = {premium: false, ads: true};
+      let titles = [];
+
+      await Promise.all(purchases.map(async purchase => {
+        switch (purchase.productId) {
+          case 'com.example.premium':
+            newState.premium = true;
+            titles.push('Premium Version');
+            break;
+
+          case 'com.example.no_ads':
+            newState.ads = false;
+            titles.push('No Ads');
+            break;
+
+          case 'com.example.coins100':
+            await finishTransaction(purchase.purchaseToken);
+            CoinStore.addCoins(100);
+        }
+      })
+
+      Alert.alert(
+        'Restore Successful',
+        `You successfully restored the following purchases: ${titles.join(', ')}`,
+      );
+    } catch (error) {
+      console.warn(error);
+      Alert.alert(error.message);
+    }
+  };
+
+  return (
+    <Button title="Restore purchases" onPress={handleRestore} />
+  )
+};
+```
+ * 
  */
 
 
@@ -196,7 +351,7 @@ exports.getPurchaseHistory = getPurchaseHistory;
 
 const getAvailablePurchases = () => (_reactNative.Platform.select({
   ios: async () => {
-    return getIosModule().getAvailableItems();
+    return (0, _internal.getIosModule)().getAvailableItems();
   },
   android: async () => {
     if (RNIapAmazonModule) {
@@ -210,14 +365,70 @@ const getAvailablePurchases = () => (_reactNative.Platform.select({
 }) || (() => Promise.resolve([])))();
 /**
  * Request a purchase for product. This will be received in `PurchaseUpdatedListener`.
- * @param {string} sku The product's sku/ID
- * @param {string} [appAccountToken] UUID representing the purchaser
- * @param {boolean} [andDangerouslyFinishTransactionAutomaticallyIOS] You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.
- * @param {string} [obfuscatedAccountIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's account in your app.
- * @param {string} [obfuscatedProfileIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app.
- * @param {string[]} [skus] Product Ids to purchase. Note that this is only for Android. iOS only uses a single SKU. If not provided, it'll default to using [sku] for backward-compatibility
- * @param {boolean} [isOfferPersonalized] Defaults to false, Only for Android V5
- * @returns {Promise<ProductPurchase>}
+ * Request a purchase for a product (consumables or non-consumables).
+
+The response will be received through the `PurchaseUpdatedListener`.
+
+:::note
+`andDangerouslyFinishTransactionAutomatically` defaults to false. We recommend
+always keeping at false, and verifying the transaction receipts on the server-side.
+:::
+
+## Signature
+
+```ts
+requestPurchase(
+ The product's sku/ID 
+  sku,
+
+  
+   * You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user.
+   * @default false
+   
+  andDangerouslyFinishTransactionAutomaticallyIOS = false,
+
+  /** Specifies an optional obfuscated string that is uniquely associated with the user's account in your app. 
+  obfuscatedAccountIdAndroid,
+
+  Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app. 
+  obfuscatedProfileIdAndroid,
+
+   The purchaser's user ID 
+  applicationUsername,
+): Promise<ProductPurchase>;
+```
+
+## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {Button} from 'react-native';
+import {requestPurchase, Product, Sku, getProducts} from 'react-native-iap';
+
+const App = () => {
+  const products = useCallback(
+    async () => getProducts(['com.example.product']),
+    [],
+  );
+
+  const handlePurchase = async (sku: Sku) => {
+    await requestPurchase({sku});
+  };
+
+  return (
+    <>
+      {products.map((product) => (
+        <Button
+          key={product.productId}
+          title="Buy product"
+          onPress={() => handlePurchase(product.productId)}
+        />
+      ))}
+    </>
+  );
+};
+```
+
  */
 
 
@@ -247,7 +458,12 @@ const requestPurchase = _ref3 => {
         console.warn('You are dangerously allowing react-native-iap to finish your transaction automatically. You should set andDangerouslyFinishTransactionAutomatically to false when calling requestPurchase and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.');
       }
 
-      return getIosModule().buyProduct(sku, andDangerouslyFinishTransactionAutomaticallyIOS, appAccountToken, quantity ?? -1, withOffer);
+      if ((0, _internal.isIosStorekit2)()) {
+        const offer = (0, _appleSk.offerSk2Map)(withOffer);
+        return RNIapIosSk2.buyProduct(sku, andDangerouslyFinishTransactionAutomaticallyIOS, appAccountToken, quantity ?? -1, offer);
+      } else {
+        return RNIapIos.buyProduct(sku, andDangerouslyFinishTransactionAutomaticallyIOS, appAccountToken, quantity ?? -1, withOffer);
+      }
     },
     android: async () => {
       if (_internal.isAmazon) {
@@ -261,22 +477,87 @@ const requestPurchase = _ref3 => {
           return Promise.reject(new Error('skus is required for Android purchase'));
         }
 
-        return getAndroidModule().buyItemByType(ANDROID_ITEM_TYPE_IAP, skus !== null && skus !== void 0 && skus.length ? skus : [sku], undefined, -1, obfuscatedAccountIdAndroid, obfuscatedProfileIdAndroid, [], isOfferPersonalized ?? false);
+        return (0, _internal.getAndroidModule)().buyItemByType(ANDROID_ITEM_TYPE_IAP, skus !== null && skus !== void 0 && skus.length ? skus : [sku], undefined, -1, obfuscatedAccountIdAndroid, obfuscatedProfileIdAndroid, [], isOfferPersonalized ?? false);
       }
     }
   }) || Promise.resolve)();
 };
 /**
  * Request a purchase for product. This will be received in `PurchaseUpdatedListener`.
- * @param {string} [sku] The product's sku/ID
- * @param {string} [appAccountToken] The purchaser's user ID
- * @param {boolean} [andDangerouslyFinishTransactionAutomaticallyIOS] You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.
- * @param {string} [purchaseTokenAndroid] purchaseToken that the user is upgrading or downgrading from (Android).
- * @param {ProrationModesAndroid} [prorationModeAndroid] UNKNOWN_SUBSCRIPTION_UPGRADE_DOWNGRADE_POLICY, IMMEDIATE_WITH_TIME_PRORATION, IMMEDIATE_AND_CHARGE_PRORATED_PRICE, IMMEDIATE_WITHOUT_PRORATION, DEFERRED
- * @param {string} [obfuscatedAccountIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's account in your app.
- * @param {string} [obfuscatedProfileIdAndroid] Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app.
- * @param {SubscriptionOffers[]} [subscriptionOffers] Array of SubscriptionOffers. Every sku must be paired with a corresponding offerToken
- * @returns {Promise<SubscriptionPurchase | null>} Promise resolves to null when using proratioModesAndroid=DEFERRED, and to a SubscriptionPurchase otherwise
+ * Request a purchase for a subscription.
+
+The response will be received through the `PurchaseUpdatedListener`.
+
+:::note
+`andDangerouslyFinishTransactionAutomatically` defaults to false. We recommend
+always keeping at false, and verifying the transaction receipts on the server-side.
+:::
+
+## Signature
+
+```ts
+requestSubscription(
+  The product's sku/ID 
+  sku,
+
+
+   * You should set this to false and call finishTransaction manually when you have delivered the purchased goods to the user.
+   * @default false
+
+  andDangerouslyFinishTransactionAutomaticallyIOS = false,
+
+   purchaseToken that the user is upgrading or downgrading from (Android). 
+  purchaseTokenAndroid,
+
+  UNKNOWN_SUBSCRIPTION_UPGRADE_DOWNGRADE_POLICY, IMMEDIATE_WITH_TIME_PRORATION, IMMEDIATE_AND_CHARGE_PRORATED_PRICE, IMMEDIATE_WITHOUT_PRORATION, DEFERRED 
+  prorationModeAndroid = -1,
+
+  /** Specifies an optional obfuscated string that is uniquely associated with the user's account in your app. 
+  obfuscatedAccountIdAndroid,
+
+  Specifies an optional obfuscated string that is uniquely associated with the user's profile in your app. 
+  obfuscatedProfileIdAndroid,
+
+  The purchaser's user ID 
+  applicationUsername,
+): Promise<SubscriptionPurchase>
+```
+
+## Usage
+
+```tsx
+import React, {useCallback} from 'react';
+import {Button} from 'react-native';
+import {
+  requestSubscription,
+  Product,
+  Sku,
+  getSubscriptions,
+} from 'react-native-iap';
+
+const App = () => {
+  const subscriptions = useCallback(
+    async () => getSubscriptions(['com.example.subscription']),
+    [],
+  );
+
+  const handlePurchase = async (sku: Sku) => {
+    await requestSubscription({sku});
+  };
+
+  return (
+    <>
+      {subscriptions.map((subscription) => (
+        <Button
+          key={subscription.productId}
+          title="Buy subscription"
+          onPress={() => handlePurchase(subscription.productId)}
+        />
+      ))}
+    </>
+  );
+};
+```
  */
 
 
@@ -308,7 +589,12 @@ const requestSubscription = _ref4 => {
         console.warn('You are dangerously allowing react-native-iap to finish your transaction automatically. You should set andDangerouslyFinishTransactionAutomatically to false when calling requestPurchase and call finishTransaction manually when you have delivered the purchased goods to the user. It defaults to true to provide backwards compatibility. Will default to false in version 4.0.0.');
       }
 
-      return getIosModule().buyProduct(sku, andDangerouslyFinishTransactionAutomaticallyIOS, appAccountToken, quantity ?? -1, withOffer);
+      if ((0, _internal.isIosStorekit2)()) {
+        const offer = (0, _appleSk.offerSk2Map)(withOffer);
+        return RNIapIosSk2.buyProduct(sku, andDangerouslyFinishTransactionAutomaticallyIOS, appAccountToken, quantity ?? -1, offer);
+      } else {
+        return RNIapIos.buyProduct(sku, andDangerouslyFinishTransactionAutomaticallyIOS, appAccountToken, quantity ?? -1, withOffer);
+      }
     },
     android: async () => {
       if (_internal.isAmazon) {
@@ -334,10 +620,22 @@ const requestSubscription = _ref4 => {
  *   Call this after you have persisted the purchased state to your server or local data in your app.
  *   `react-native-iap` will continue to deliver the purchase updated events with the successful purchase until you finish the transaction. **Even after the app has relaunched.**
  *   Android: it will consume purchase for consumables and acknowledge purchase for non-consumables.
- * @param {object} purchase The purchase that you would like to finish.
- * @param {boolean} isConsumable Checks if purchase is consumable. Has effect on `android`.
- * @param {string} developerPayloadAndroid Android developerPayload.
- * @returns {Promise<string | void> }
+ *   
+```tsx
+import React from 'react';
+import {Button} from 'react-native';
+import {finishTransaction} from 'react-native-iap';
+
+const App = () => {
+  const handlePurchase = async () => {
+    // ... handle the purchase request
+
+    const result = finishTransaction(purchase);
+  };
+
+  return <Button title="Buy product" onPress={handlePurchase} />;
+};
+``` 
  */
 
 
@@ -357,14 +655,14 @@ const finishTransaction = _ref5 => {
         return Promise.reject(new Error('transactionId required to finish iOS transaction'));
       }
 
-      return getIosModule().finishTransaction(transactionId);
+      return (0, _internal.getIosModule)().finishTransaction(transactionId);
     },
     android: async () => {
       if (purchase !== null && purchase !== void 0 && purchase.purchaseToken) {
         if (isConsumable) {
-          return getAndroidModule().consumeProduct(purchase.purchaseToken, developerPayloadAndroid);
+          return (0, _internal.getAndroidModule)().consumeProduct(purchase.purchaseToken, developerPayloadAndroid);
         } else if (purchase.userIdAmazon || !purchase.isAcknowledgedAndroid && purchase.purchaseStateAndroid === _types.PurchaseStateAndroid.PURCHASED) {
-          return getAndroidModule().acknowledgePurchase(purchase.purchaseToken, developerPayloadAndroid);
+          return (0, _internal.getAndroidModule)().acknowledgePurchase(purchase.purchaseToken, developerPayloadAndroid);
         } else {
           return Promise.reject(new Error('purchase is not suitable to be purchased'));
         }
@@ -374,241 +672,6 @@ const finishTransaction = _ref5 => {
     }
   }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
-/**
- * Clear Transaction (iOS only)
- *   Finish remaining transactions. Related to issue #257 and #801
- *     link : https://github.com/dooboolab/react-native-iap/issues/257
- *            https://github.com/dooboolab/react-native-iap/issues/801
- * @returns {Promise<void>}
- */
-
 
 exports.finishTransaction = finishTransaction;
-
-const clearTransactionIOS = () => getIosModule().clearTransaction();
-/**
- * Clear valid Products (iOS only)
- *   Remove all products which are validated by Apple server.
- * @returns {void}
- */
-
-
-exports.clearTransactionIOS = clearTransactionIOS;
-
-const clearProductsIOS = () => getIosModule().clearProducts();
-/**
- * Acknowledge a product (on Android.) No-op on iOS.
- * @param {string} token The product's token (on Android)
- * @returns {Promise<PurchaseResult | void>}
- */
-
-
-exports.clearProductsIOS = clearProductsIOS;
-
-const acknowledgePurchaseAndroid = _ref6 => {
-  let {
-    token,
-    developerPayload
-  } = _ref6;
-  return getAndroidModule().acknowledgePurchase(token, developerPayload);
-};
-/**
- * Deep link to subscriptions screen on Android. No-op on iOS.
- * @param {string} sku The product's SKU (on Android)
- * @returns {Promise<void>}
- */
-
-
-exports.acknowledgePurchaseAndroid = acknowledgePurchaseAndroid;
-
-const deepLinkToSubscriptionsAndroid = async _ref7 => {
-  let {
-    sku
-  } = _ref7;
-  checkNativeAndroidAvailable();
-  return _reactNative.Linking.openURL(`https://play.google.com/store/account/subscriptions?package=${await RNIapModule.getPackageName()}&sku=${sku}`);
-};
-/**
- * Should Add Store Payment (iOS only)
- *   Indicates the the App Store purchase should continue from the app instead of the App Store.
- * @returns {Promise<Product | null>} promoted product
- */
-
-
-exports.deepLinkToSubscriptionsAndroid = deepLinkToSubscriptionsAndroid;
-
-const getPromotedProductIOS = () => {
-  if (!isIosStorekit2) {
-    return getIosModule().promotedProduct();
-  } else {
-    return Promise.reject('Only available on SK1');
-  }
-};
-/**
- * Buy the currently selected promoted product (iOS only)
- *   Initiates the payment process for a promoted product. Should only be called in response to the `iap-promoted-product` event.
- * @returns {Promise<void>}
- */
-
-
-exports.getPromotedProductIOS = getPromotedProductIOS;
-
-const buyPromotedProductIOS = () => getIosModule().buyPromotedProduct();
-
-exports.buyPromotedProductIOS = buyPromotedProductIOS;
-const TEST_RECEIPT = 21007;
-
-const requestAgnosticReceiptValidationIos = async receiptBody => {
-  const response = await (0, _internal.enhancedFetch)('https://buy.itunes.apple.com/verifyReceipt', {
-    method: 'POST',
-    body: receiptBody
-  }); // Best practice is to check for test receipt and check sandbox instead
-  // https://developer.apple.com/documentation/appstorereceipts/verifyreceipt
-
-  if (response && response.status === TEST_RECEIPT) {
-    const testResponse = await (0, _internal.enhancedFetch)('https://sandbox.itunes.apple.com/verifyReceipt', {
-      method: 'POST',
-      body: receiptBody
-    });
-    return testResponse;
-  }
-
-  return response;
-};
-/**
- * Buy products or subscriptions with offers (iOS only)
- *
- * Runs the payment process with some info you must fetch
- * from your server.
- * @param {string} sku The product identifier
- * @param {string} forUser  An user identifier on you system
- * @param {Apple.PaymentDiscount} withOffer The offer information
- * @param {string} withOffer.identifier The offer identifier
- * @param {string} withOffer.keyIdentifier Key identifier that it uses to generate the signature
- * @param {string} withOffer.nonce An UUID returned from the server
- * @param {string} withOffer.signature The actual signature returned from the server
- * @param {number} withOffer.timestamp The timestamp of the signature
- * @returns {Promise<void>}
- */
-
-
-const requestPurchaseWithOfferIOS = _ref8 => {
-  let {
-    sku,
-    forUser,
-    withOffer
-  } = _ref8;
-  return getIosModule().buyProductWithOffer(sku, forUser, withOffer);
-};
-/**
- * Validate receipt for iOS.
- * @param {object} receiptBody the receipt body to send to apple server.
- * @param {boolean} isTest whether this is in test environment which is sandbox.
- * @returns {Promise<Apple.ReceiptValidationResponse | false>}
- */
-
-
-exports.requestPurchaseWithOfferIOS = requestPurchaseWithOfferIOS;
-
-const validateReceiptIos = async _ref9 => {
-  let {
-    receiptBody,
-    isTest
-  } = _ref9;
-
-  if (isTest == null) {
-    return await requestAgnosticReceiptValidationIos(receiptBody);
-  }
-
-  const url = isTest ? 'https://sandbox.itunes.apple.com/verifyReceipt' : 'https://buy.itunes.apple.com/verifyReceipt';
-  return await (0, _internal.enhancedFetch)(url);
-};
-/**
- * Validate receipt for Android. NOTE: This method is here for debugging purposes only. Including
- * your access token in the binary you ship to users is potentially dangerous.
- * Use server side validation instead for your production builds
- * @param {string} packageName package name of your app.
- * @param {string} productId product id for your in app product.
- * @param {string} productToken token for your purchase.
- * @param {string} accessToken accessToken from googleApis.
- * @param {boolean} isSub whether this is subscription or inapp. `true` for subscription.
- * @returns {Promise<object>}
- */
-
-
-exports.validateReceiptIos = validateReceiptIos;
-
-const validateReceiptAndroid = async _ref10 => {
-  let {
-    packageName,
-    productId,
-    productToken,
-    accessToken,
-    isSub
-  } = _ref10;
-  const type = isSub ? 'subscriptions' : 'products';
-  const url = 'https://androidpublisher.googleapis.com/androidpublisher/v3/applications' + `/${packageName}/purchases/${type}/${productId}` + `/tokens/${productToken}?access_token=${accessToken}`;
-  return await (0, _internal.enhancedFetch)(url);
-};
-/**
- * Validate receipt for Amazon. NOTE: This method is here for debugging purposes only. Including
- * your developer secret in the binary you ship to users is potentially dangerous.
- * Use server side validation instead for your production builds
- * @param {string} developerSecret: from the Amazon developer console.
- * @param {string} userId who purchased the item.
- * @param {string} receiptId long obfuscated string returned when purchasing the item
- * @param {boolean} useSandbox Defaults to true, use sandbox environment or production.
- * @returns {Promise<object>}
- */
-
-
-exports.validateReceiptAndroid = validateReceiptAndroid;
-
-const validateReceiptAmazon = async _ref11 => {
-  let {
-    developerSecret,
-    userId,
-    receiptId,
-    useSandbox = true
-  } = _ref11;
-  const sandBoxUrl = useSandbox ? 'sandbox/' : '';
-  const url = `https://appstore-sdk.amazon.com/${sandBoxUrl}version/1.0/verifyReceiptId/developer/${developerSecret}/user/${userId}/receiptId/${receiptId}`;
-  return await (0, _internal.enhancedFetch)(url);
-};
-/**
- * Get the current receipt base64 encoded in IOS.
- * @param {forceRefresh?:boolean}
- * @returns {Promise<ProductPurchase[]>}
- */
-
-
-exports.validateReceiptAmazon = validateReceiptAmazon;
-
-const getPendingPurchasesIOS = async () => getIosModule().getPendingTransactions();
-/**
- * Get the current receipt base64 encoded in IOS.
- * @param {forceRefresh?:boolean}
- * @returns {Promise<string>}
- */
-
-
-exports.getPendingPurchasesIOS = getPendingPurchasesIOS;
-
-const getReceiptIOS = async _ref12 => {
-  let {
-    forceRefresh
-  } = _ref12;
-  return getIosModule().requestReceipt(forceRefresh ?? false);
-};
-/**
- * Launches a modal to register the redeem offer code in IOS.
- * @returns {Promise<null>}
- */
-
-
-exports.getReceiptIOS = getReceiptIOS;
-
-const presentCodeRedemptionSheetIOS = async () => getIosModule().presentCodeRedemptionSheet();
-
-exports.presentCodeRedemptionSheetIOS = presentCodeRedemptionSheetIOS;
 //# sourceMappingURL=iap.js.map