expo-iap 2.2.0-rc.1 → 2.2.0-rc.3

package/build/ExpoIap.types.js

@@ -45,4 +45,3 @@ export class PurchaseError {
         this.productId = productId;
     }
 }
-//# sourceMappingURL=ExpoIap.types.js.map

package/build/ExpoIap.types.ts

@@ -0,0 +1,125 @@
+import {
+  ProductAndroid,
+  ProductPurchaseAndroid,
+  RequestPurchaseAndroidProps,
+  RequestSubscriptionAndroidProps,
+  SubscriptionProductAndroid,
+} from './types/ExpoIapAndroid.types';
+import {
+  ProductIos,
+  ProductPurchaseIos,
+  RequestPurchaseIosProps,
+  RequestSubscriptionIosProps,
+  SubscriptionProductIos,
+} from './types/ExpoIapIos.types';
+
+export type ChangeEventPayload = {
+  value: string;
+};
+
+/**
+ * Base product type with common properties shared between iOS and Android
+ */
+export type ProductBase = {
+  id: string;
+  title: string;
+  description: string;
+  type: ProductType;
+  displayName?: string;
+  displayPrice?: string;
+  price?: number;
+  currency?: string;
+};
+
+// Define literal platform types for better type discrimination
+export type IosPlatform = {platform: 'ios'};
+export type AndroidPlatform = {platform: 'android'};
+
+export enum ProductType {
+  InAppPurchase = 'inapp',
+  Subscription = 'subs',
+}
+
+// Common base purchase type
+export type PurchaseBase = {
+  id: string;
+  transactionId?: string;
+  transactionDate: number;
+  transactionReceipt: string;
+  purchaseToken?: string;
+};
+
+// Union type for platform-specific product types with proper discriminators
+export type Product =
+  | (ProductAndroid & AndroidPlatform)
+  | (ProductIos & IosPlatform);
+
+// Union type for platform-specific purchase types with proper discriminators
+export type ProductPurchase =
+  | (ProductPurchaseAndroid & AndroidPlatform)
+  | (ProductPurchaseIos & IosPlatform);
+
+// Union type for platform-specific subscription purchase types with proper discriminators
+export type SubscriptionPurchase =
+  | (ProductPurchaseAndroid & AndroidPlatform & { autoRenewingAndroid: boolean })
+  | (ProductPurchaseIos & IosPlatform);
+
+export type Purchase = ProductPurchase | SubscriptionPurchase;
+
+export type RequestPurchaseProps =
+  | RequestPurchaseIosProps
+  | RequestPurchaseAndroidProps;
+
+export type SubscriptionProduct =
+  | (SubscriptionProductAndroid & AndroidPlatform)
+  | (SubscriptionProductIos & IosPlatform);
+
+export type RequestSubscriptionProps =
+  | RequestSubscriptionAndroidProps
+  | RequestSubscriptionIosProps;
+
+export type PurchaseResult = {
+  responseCode?: number;
+  debugMessage?: string;
+  code?: string;
+  message?: string;
+  purchaseToken?: string;
+};
+
+export enum ErrorCode {
+  E_UNKNOWN = 'E_UNKNOWN',
+  E_USER_CANCELLED = 'E_USER_CANCELLED',
+  E_USER_ERROR = 'E_USER_ERROR',
+  E_ITEM_UNAVAILABLE = 'E_ITEM_UNAVAILABLE',
+  E_REMOTE_ERROR = 'E_REMOTE_ERROR',
+  E_NETWORK_ERROR = 'E_NETWORK_ERROR',
+  E_SERVICE_ERROR = 'E_SERVICE_ERROR',
+  E_RECEIPT_FAILED = 'E_RECEIPT_FAILED',
+  E_RECEIPT_FINISHED_FAILED = 'E_RECEIPT_FINISHED_FAILED',
+  E_NOT_PREPARED = 'E_NOT_PREPARED',
+  E_NOT_ENDED = 'E_NOT_ENDED',
+  E_ALREADY_OWNED = 'E_ALREADY_OWNED',
+  E_DEVELOPER_ERROR = 'E_DEVELOPER_ERROR',
+  E_BILLING_RESPONSE_JSON_PARSE_ERROR = 'E_BILLING_RESPONSE_JSON_PARSE_ERROR',
+  E_DEFERRED_PAYMENT = 'E_DEFERRED_PAYMENT',
+  E_INTERRUPTED = 'E_INTERRUPTED',
+  E_IAP_NOT_AVAILABLE = 'E_IAP_NOT_AVAILABLE',
+}
+
+export class PurchaseError implements Error {
+  constructor(
+    public name: string,
+    public message: string,
+    public responseCode?: number,
+    public debugMessage?: string,
+    public code?: ErrorCode,
+    public productId?: string,
+  ) {
+    this.name = '[expo-iap]: PurchaseError';
+    this.message = message;
+    this.responseCode = responseCode;
+    this.debugMessage = debugMessage;
+    this.code = code;
+    this.productId = productId;
+  }
+}

package/build/ExpoIapModule.js

@@ -2,4 +2,3 @@ import { requireNativeModule } from 'expo-modules-core';
 // It loads the native module object from the JSI or falls back to
 // the bridge module (from NativeModulesProxy) if the remote debugger is on.
 export default requireNativeModule('ExpoIap');
-//# sourceMappingURL=ExpoIapModule.js.map

package/build/ExpoIapModule.ts

@@ -0,0 +1,5 @@
+import {requireNativeModule} from 'expo-modules-core';
+
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('ExpoIap');

package/build/index.js

@@ -186,4 +186,3 @@ export const finishTransaction = ({ purchase, isConsumable, developerPayloadAndr
     }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
 };
 export * from './useIap';
-//# sourceMappingURL=index.js.map

package/build/index.ts

@@ -0,0 +1,354 @@
+// Import the native module. On web, it will be resolved to ExpoIap.web.ts
+// and on native platforms to ExpoIap.ts
+import {NativeModulesProxy, EventEmitter} from 'expo-modules-core';
+import {Platform} from 'react-native';
+import {
+  Product,
+  ProductPurchase,
+  ProductType,
+  Purchase,
+  PurchaseError,
+  PurchaseResult,
+  RequestSubscriptionProps,
+  SubscriptionProduct,
+  SubscriptionPurchase,
+} from './ExpoIap.types';
+import ExpoIapModule from './ExpoIapModule';
+import {
+  RequestPurchaseAndroidProps,
+  RequestSubscriptionAndroidProps,
+} from './types/ExpoIapAndroid.types';
+import {
+  PaymentDiscount,
+  RequestPurchaseIosProps,
+  RequestSubscriptionIosProps,
+} from './types/ExpoIapIos.types';
+import {isProductIos, isSubscriptionProductIos} from './modules/ios';
+import {
+  isProductAndroid,
+  isSubscriptionProductAndroid,
+} from './modules/android';
+
+export * from './modules/android';
+export * from './modules/ios';
+
+// Get the native constant value.
+export const PI = ExpoIapModule.PI;
+
+export enum IapEvent {
+  PurchaseUpdated = 'purchase-updated',
+  PurchaseError = 'purchase-error',
+  TransactionIapUpdated = 'iap-transaction-updated',
+}
+
+export async function setValueAsync(value: string) {
+  return await ExpoIapModule.setValueAsync(value);
+}
+
+export const emitter = new EventEmitter(
+  ExpoIapModule ?? NativeModulesProxy.ExpoIap,
+);
+
+export const purchaseUpdatedListener = (
+  listener: (event: Purchase) => void,
+) => {
+  const emitterSubscription = emitter.addListener(
+    IapEvent.PurchaseUpdated,
+    listener,
+  );
+  return emitterSubscription;
+};
+
+export const purchaseErrorListener = (
+  listener: (error: PurchaseError) => void,
+) => {
+  return emitter.addListener<PurchaseError>(IapEvent.PurchaseError, listener);
+};
+
+export function initConnection() {
+  return ExpoIapModule.initConnection();
+}
+
+export const getProducts = async (skus: string[]): Promise<Product[]> => {
+  console.log('getProducts', skus);
+  if (!skus?.length) {
+    return Promise.reject(new Error('"skus" is required'));
+  }
+
+  return Platform.select({
+    ios: async () => {
+      const items = await ExpoIapModule.getItems(skus);
+      console.log('items', items);
+      return items.filter((item: unknown) => isProductIos<Product>(item));
+    },
+    android: async () => {
+      const products = await ExpoIapModule.getItemsByType(
+        ProductType.InAppPurchase,
+        skus,
+      );
+      return products.filter((product: unknown) =>
+        isProductAndroid<Product>(product),
+      );
+    },
+    default: () => Promise.reject(new Error('Unsupported Platform')),
+  })();
+};
+
+export const getSubscriptions = async (
+  skus: string[],
+): Promise<SubscriptionProduct[]> => {
+  if (!skus?.length) {
+    return Promise.reject(new Error('"skus" is required'));
+  }
+
+  return Platform.select({
+    ios: async () => {
+      const rawItems = await ExpoIapModule.getItems(skus);
+
+      return rawItems.filter((item: unknown) => {
+        if (!isSubscriptionProductIos(item)) return false;
+        return (
+          typeof item === 'object' &&
+          item !== null &&
+          'id' in item &&
+          typeof item.id === 'string' &&
+          skus.includes(item.id)
+        );
+      }) as SubscriptionProduct[];
+    },
+    android: async () => {
+      const rawItems = await ExpoIapModule.getItemsByType('subs', skus);
+
+      return rawItems.filter((item: unknown) => {
+        if (!isSubscriptionProductAndroid(item)) return false;
+        return (
+          typeof item === 'object' &&
+          item !== null &&
+          'id' in item &&
+          typeof item.id === 'string' &&
+          skus.includes(item.id)
+        );
+      }) as SubscriptionProduct[];
+    },
+    default: () => Promise.reject(new Error('Unsupported Platform')),
+  })();
+};
+
+export async function endConnection(): Promise<boolean> {
+  return ExpoIapModule.endConnection();
+}
+
+export const getPurchaseHistory = ({
+  alsoPublishToEventListener = false,
+  onlyIncludeActiveItems = false,
+}: {
+  alsoPublishToEventListener?: boolean;
+  onlyIncludeActiveItems?: boolean;
+} = {}): Promise<ProductPurchase[]> =>
+  (
+    Platform.select({
+      ios: async () => {
+        return ExpoIapModule.getAvailableItems(
+          alsoPublishToEventListener,
+          onlyIncludeActiveItems,
+        );
+      },
+      android: async () => {
+        const products = await ExpoIapModule.getPurchaseHistoryByType(
+          ProductType.InAppPurchase,
+        );
+
+        const subscriptions = await ExpoIapModule.getPurchaseHistoryByType(
+          ProductType.Subscription,
+        );
+
+        return products.concat(subscriptions);
+      },
+    }) || (() => Promise.resolve([]))
+  )();
+
+export const getAvailablePurchases = ({
+  alsoPublishToEventListener = false,
+  onlyIncludeActiveItems = true,
+}: {
+  alsoPublishToEventListener?: boolean;
+  onlyIncludeActiveItems?: boolean;
+} = {}): Promise<ProductPurchase[]> =>
+  (
+    Platform.select({
+      ios: () =>
+        ExpoIapModule.getAvailableItems(
+          alsoPublishToEventListener,
+          onlyIncludeActiveItems,
+        ),
+      android: async () => {
+        const products = await ExpoIapModule.getAvailableItemsByType(
+          ProductType.InAppPurchase,
+        );
+
+        const subscriptions = await ExpoIapModule.getAvailableItemsByType(
+          ProductType.Subscription,
+        );
+
+        return products.concat(subscriptions);
+      },
+    }) || (() => Promise.resolve([]))
+  )();
+
+const offerToRecordIos = (
+  offer: PaymentDiscount | undefined,
+): Record<keyof PaymentDiscount, string> | undefined => {
+  if (!offer) {
+    return undefined;
+  }
+  return {
+    identifier: offer.identifier,
+    keyIdentifier: offer.keyIdentifier,
+    nonce: offer.nonce,
+    signature: offer.signature,
+    timestamp: offer.timestamp.toString(),
+  };
+};
+
+export const requestPurchase = (
+  request: RequestPurchaseIosProps | RequestPurchaseAndroidProps,
+): Promise<ProductPurchase | ProductPurchase[] | void> =>
+  (
+    Platform.select({
+      ios: async () => {
+        if (!('sku' in request)) {
+          throw new Error('sku is required for iOS purchase');
+        }
+
+        const {sku, appAccountToken, quantity, withOffer} = request;
+
+        const offer = offerToRecordIos(withOffer);
+
+        const purchase = await ExpoIapModule.buyProduct(
+          sku,
+          appAccountToken,
+          quantity ?? -1,
+          offer,
+        );
+
+        return Promise.resolve(purchase);
+      },
+      android: async () => {
+        if (!('skus' in request) || !request.skus.length) {
+          throw new Error('skus is required for Android purchase');
+        }
+
+        const {
+          skus,
+          obfuscatedAccountIdAndroid,
+          obfuscatedProfileIdAndroid,
+          isOfferPersonalized,
+        } = request;
+
+        return ExpoIapModule.buyItemByType({
+          type: ProductType.InAppPurchase,
+          skuArr: skus,
+          purchaseToken: undefined,
+          replacementMode: -1,
+          obfuscatedAccountId: obfuscatedAccountIdAndroid,
+          obfuscatedProfileId: obfuscatedProfileIdAndroid,
+          offerTokenArr: [],
+          isOfferPersonalized: isOfferPersonalized ?? false,
+        });
+      },
+    }) || Promise.resolve
+  )();
+
+export const requestSubscription = (
+  request: RequestSubscriptionProps,
+): Promise<SubscriptionPurchase | SubscriptionPurchase[] | null | void> =>
+  (
+    Platform.select({
+      ios: async () => {
+        if (!('sku' in request)) {
+          throw new Error('sku is required for iOS subscriptions');
+        }
+
+        const {sku, appAccountToken, quantity, withOffer} =
+          request as RequestSubscriptionIosProps;
+
+        const offer = offerToRecordIos(withOffer);
+
+        const purchase = await ExpoIapModule.buyProduct(
+          sku,
+          appAccountToken,
+          quantity ?? -1,
+          offer,
+        );
+
+        return Promise.resolve(purchase as SubscriptionPurchase);
+      },
+      android: async () => {
+        const {
+          skus,
+          isOfferPersonalized,
+          obfuscatedAccountIdAndroid,
+          obfuscatedProfileIdAndroid,
+          subscriptionOffers,
+          replacementModeAndroid,
+          purchaseTokenAndroid,
+        } = request as RequestSubscriptionAndroidProps;
+
+        return ExpoIapModule.buyItemByType({
+          type: ProductType.Subscription,
+          skuArr: skus.map((so) => so),
+          purchaseToken: purchaseTokenAndroid,
+          replacementMode: replacementModeAndroid,
+          obfuscatedAccountId: obfuscatedAccountIdAndroid,
+          obfuscatedProfileId: obfuscatedProfileIdAndroid,
+          offerTokenArr: subscriptionOffers.map((so) => so.offerToken),
+          isOfferPersonalized: isOfferPersonalized ?? false,
+        });
+      },
+    }) || (() => Promise.resolve(null))
+  )();
+
+export const finishTransaction = ({
+  purchase,
+  isConsumable,
+  developerPayloadAndroid,
+}: {
+  purchase: Purchase;
+  isConsumable?: boolean;
+  developerPayloadAndroid?: string;
+}): Promise<PurchaseResult | boolean> => {
+  return (
+    Platform.select({
+      ios: async () => {
+        const transactionId = purchase.transactionId;
+
+        if (!transactionId) {
+          return Promise.reject(
+            new Error('transactionId required to finish iOS transaction'),
+          );
+        }
+        await ExpoIapModule.finishTransaction(transactionId);
+        return Promise.resolve(true);
+      },
+      android: async () => {
+        if (purchase?.purchaseToken) {
+          if (!isConsumable) {
+            return Promise.reject(
+              new Error('purchase is not suitable to be purchased'),
+            );
+          }
+
+          return ExpoIapModule.consumeProduct(
+            purchase.purchaseToken,
+            developerPayloadAndroid,
+          );
+        }
+        return Promise.reject(
+          new Error('purchase is not suitable to be purchased'),
+        );
+      },
+    }) || (() => Promise.reject(new Error('Unsupported Platform')))
+  )();
+};
+
+export * from './useIap';

package/build/modules/android.js

@@ -55,4 +55,3 @@ export const validateReceiptAndroid = async ({ packageName, productId, productTo
 export const acknowledgePurchaseAndroid = ({ token, developerPayload, }) => {
     return ExpoIapModule.acknowledgePurchase(token, developerPayload);
 };
-//# sourceMappingURL=android.js.map

package/build/modules/android.ts

@@ -0,0 +1,99 @@
+import {Linking} from 'react-native';
+import {PurchaseResult} from '../ExpoIap.types';
+import {ReceiptAndroid} from '../types/ExpoIapAndroid.types';
+import ExpoIapModule from '../ExpoIapModule';
+
+// Type guards
+export function isProductAndroid<T extends {platform?: string}>(
+  item: unknown,
+): item is T & {platform: 'android'} {
+  return (
+    item != null &&
+    typeof item === 'object' &&
+    'platform' in item &&
+    item.platform === 'android'
+  );
+}
+
+export function isSubscriptionProductAndroid<T extends {platform?: string}>(
+  item: unknown,
+): item is T & {platform: 'android'} {
+  return isProductAndroid(item);
+}
+
+/**
+ * Deep link to subscriptions screen on Android.
+ * @param {string} sku The product's SKU (on Android)
+ * @returns {Promise<void>}
+ */
+export const deepLinkToSubscriptionsAndroid = async ({
+  sku,
+}: {
+  sku: string;
+}): Promise<void> => {
+  return Linking.openURL(
+    `https://play.google.com/store/account/subscriptions?package=${await ExpoIapModule.getPackageName()}&sku=${sku}`,
+  );
+};
+
+/**
+ * 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>}
+ */
+export const validateReceiptAndroid = async ({
+  packageName,
+  productId,
+  productToken,
+  accessToken,
+  isSub,
+}: {
+  packageName: string;
+  productId: string;
+  productToken: string;
+  accessToken: string;
+  isSub?: boolean;
+}): Promise<ReceiptAndroid> => {
+  const type = isSub ? 'subscriptions' : 'products';
+
+  const url =
+    'https://androidpublisher.googleapis.com/androidpublisher/v3/applications' +
+    `/${packageName}/purchases/${type}/${productId}` +
+    `/tokens/${productToken}?access_token=${accessToken}`;
+
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw Object.assign(new Error(response.statusText), {
+      statusCode: response.status,
+    });
+  }
+
+  return response.json();
+};
+
+/**
+ * Acknowledge a product (on Android.) No-op on iOS.
+ * @param {string} token The product's token (on Android)
+ * @returns {Promise<PurchaseResult | void>}
+ */
+export const acknowledgePurchaseAndroid = ({
+  token,
+  developerPayload,
+}: {
+  token: string;
+  developerPayload?: string;
+}): Promise<PurchaseResult | boolean | void> => {
+  return ExpoIapModule.acknowledgePurchase(token, developerPayload);
+};

package/build/modules/ios.js

@@ -45,4 +45,3 @@ export const beginRefundRequest = (sku) => ExpoIapModule.beginRefundRequest(sku)
  *
  */
 export const showManageSubscriptions = () => ExpoIapModule.showManageSubscriptions();
-//# sourceMappingURL=ios.js.map

package/build/modules/ios.ts

@@ -0,0 +1,84 @@
+import {Platform} from 'react-native';
+import {emitter, IapEvent} from '..';
+import {ProductPurchase, PurchaseError} from '../ExpoIap.types';
+import type {ProductStatusIos} from '../types/ExpoIapIos.types';
+import ExpoIapModule from '../ExpoIapModule';
+
+export type TransactionEvent = {
+  transaction?: ProductPurchase;
+  error?: PurchaseError;
+};
+
+// Listeners
+export const transactionUpdatedIos = (
+  listener: (event: TransactionEvent) => void,
+) => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('This method is only available on iOS');
+  }
+
+  return emitter.addListener(IapEvent.TransactionIapUpdated, listener);
+};
+
+// Type guards
+export function isProductIos<T extends {platform?: string}>(
+  item: unknown,
+): item is T & {platform: 'ios'} {
+  return (
+    item != null &&
+    typeof item === 'object' &&
+    'platform' in item &&
+    item.platform === 'ios'
+  );
+}
+
+export function isSubscriptionProductIos<T extends {platform?: string}>(
+  item: unknown,
+): item is T & {platform: 'ios'} {
+  return isProductIos(item);
+}
+
+// Functions
+/**
+ * Sync state with Appstore (iOS only)
+ * https://developer.apple.com/documentation/storekit/appstore/3791906-sync
+ */
+export const sync = (): Promise<null> => ExpoIapModule.sync();
+
+/**
+ *
+ */
+export const isEligibleForIntroOffer = (groupID: string): Promise<boolean> =>
+  ExpoIapModule.isEligibleForIntroOffer(groupID);
+
+/**
+ *
+ */
+
+export const subscriptionStatus = (sku: string): Promise<ProductStatusIos[]> =>
+  ExpoIapModule.subscriptionStatus(sku);
+
+/**
+ *
+ */
+export const currentEntitlement = (sku: string): Promise<ProductPurchase> =>
+  ExpoIapModule.currentEntitlement(sku);
+
+/**
+ *
+ */
+export const latestTransaction = (sku: string): Promise<ProductPurchase> =>
+  ExpoIapModule.latestTransaction(sku);
+
+/**
+ *
+ */
+type RefundRequestStatus = 'success' | 'userCancelled';
+export const beginRefundRequest = (sku: string): Promise<RefundRequestStatus> =>
+  ExpoIapModule.beginRefundRequest(sku);
+
+/**
+ *
+ */
+export const showManageSubscriptions = (): Promise<null> =>
+  ExpoIapModule.showManageSubscriptions();

package/build/types/ExpoIapAndroid.types.js

@@ -26,4 +26,3 @@ export var PurchaseStateAndroid;
     PurchaseStateAndroid[PurchaseStateAndroid["PURCHASED"] = 1] = "PURCHASED";
     PurchaseStateAndroid[PurchaseStateAndroid["PENDING"] = 2] = "PENDING";
 })(PurchaseStateAndroid || (PurchaseStateAndroid = {}));
-//# sourceMappingURL=ExpoIapAndroid.types.js.map