react-native-iap 10.1.0 → 10.1.2

package/README.md

@@ -19,7 +19,6 @@ Read the [documentation](https://react-native-iap.dooboolab.com). See the [troub
 Please [fund the project](https://opencollective.com/react-native-iap) if you are willing the maintainers to make the repository sustainable.
 
 - [andresesfm](https://github.com/andresesfm)
-- [jeremybarbet](https://github.com/jeremybarbet)
 
 > The fund goes to maintainers.
 

package/ios/RNIapIos.swift

@@ -390,7 +390,7 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
     ) {
         requestReceiptData(withBlock: refresh) { [self] receiptData, error in
             if error == nil {
-                resolve(receiptData?.base64EncodedString(options: []))
+                resolve(receiptData?.base64EncodedString(options: [.endLineWithCarriageReturn]))
             } else {
                 reject(standardErrorCode(9), "Invalid receipt", nil)
             }
@@ -423,7 +423,7 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
                         "transactionId": item.transactionIdentifier,
                         "productId": item.payment.productIdentifier,
                         "quantity": "\(item.payment.quantity)",
-                        "transactionReceipt": receipt.base64EncodedString(options: [])
+                        "transactionReceipt": receipt.base64EncodedString(options: [.endLineWithCarriageReturn])
                     ]
 
                     output.append(purchase)
@@ -907,7 +907,7 @@ class RNIapIos: RCTEventEmitter, SKRequestDelegate, SKPaymentTransactionObserver
                     "transactionDate": transaction.transactionDate?.millisecondsSince1970String,
                     "transactionId": transaction.transactionIdentifier,
                     "productId": transaction.payment.productIdentifier,
-                    "transactionReceipt": receiptData?.base64EncodedString(options: [])
+                    "transactionReceipt": receiptData?.base64EncodedString(options: [.endLineWithCarriageReturn])
                 ]
 
                 // originalTransaction is available for restore purchase and purchase of cancelled/expired subscriptions

package/lib/commonjs/iap.js

@@ -63,7 +63,21 @@ const getNativeModule = () => {
 };
 /**
  * Init module for purchase flow. Required on Android. In ios it will check whether user canMakePayment.
- * @returns {Promise<boolean>}
+ * ## Usage
+
+```tsx
+import React, {useEffect} from 'react';
+import {View} from 'react-native';
+import {initConnection} from 'react-native-iap';
+
+const App = () => {
+  useEffect(() => {
+    void initConnection();
+  }, []);
+
+  return <View />;
+};
+```
  */
 
 
@@ -71,7 +85,23 @@ exports.getNativeModule = getNativeModule;
 
 const initConnection = () => 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>}
  */
 
@@ -90,8 +120,47 @@ exports.endConnection = endConnection;
 const flushFailedPurchasesCachedAsPendingAndroid = () => 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.
+
  */
 
 
@@ -114,8 +183,24 @@ const getProducts = _ref => {
 };
 /**
  * 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 />;
+};
+```
+
  */
 
 
@@ -138,7 +223,26 @@ const getSubscriptions = _ref2 => {
 };
 /**
  * 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 />;
+};
+```
  */
 
 
@@ -160,7 +264,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} />
+  )
+};
+```
+ * 
  */
 
 
@@ -182,14 +360,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} [applicationUsername] 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} [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)}
+        />
+      ))}
+    </>
+  );
+};
+```
+
  */
 
 
@@ -236,15 +470,80 @@ const requestPurchase = _ref3 => {
 };
 /**
  * Request a purchase for product. This will be received in `PurchaseUpdatedListener`.
- * @param {string} [sku] The product's sku/ID
- * @param {string} [applicationUsername] 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)}
+        />
+      ))}
+    </>
+  );
+};
+```
  */
 
 
@@ -314,10 +613,22 @@ const requestPurchaseWithQuantityIOS = _ref5 => {
  *   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} />;
+};
+``` 
  */
 
 
@@ -495,7 +806,10 @@ const validateReceiptIos = async _ref10 => {
   }
 
   const url = isTest ? 'https://sandbox.itunes.apple.com/verifyReceipt' : 'https://buy.itunes.apple.com/verifyReceipt';
-  return await (0, _internal.enhancedFetch)(url);
+  return await (0, _internal.enhancedFetch)(url, {
+    method: 'POST',
+    body: receiptBody
+  });
 };
 /**
  * Validate receipt for Android. NOTE: This method is here for debugging purposes only. Including