expo-iap 3.0.7 → 3.1.0

package/build/index.js

@@ -3,29 +3,23 @@ import { NativeModulesProxy } from 'expo-modules-core';
 import { Platform } from 'react-native';
 // Internal modules
 import ExpoIapModule from './ExpoIapModule';
-import { isProductIOS, validateReceiptIOS, deepLinkToSubscriptionsIOS, syncIOS, } from './modules/ios';
+import { isProductIOS, validateReceiptIOS, deepLinkToSubscriptionsIOS, syncIOS, getStorefrontIOS, } from './modules/ios';
 import { isProductAndroid, validateReceiptAndroid, deepLinkToSubscriptionsAndroid, } from './modules/android';
-// Types
-import { ErrorCode, } from './types';
-import { PurchaseError } from './purchase-error';
+import { ErrorCode } from './types';
+import { createPurchaseError } from './utils/errorMapping';
 // Export all types
 export * from './types';
-export { ErrorCodeUtils, ErrorCodeMapping } from './purchase-error';
 export * from './modules/android';
 export * from './modules/ios';
 // Export subscription helpers
 export { getActiveSubscriptions, hasActiveSubscriptions, } from './helpers/subscription';
 // Get the native constant value
-export const PI = ExpoIapModule.PI;
 export var OpenIapEvent;
 (function (OpenIapEvent) {
     OpenIapEvent["PurchaseUpdated"] = "purchase-updated";
     OpenIapEvent["PurchaseError"] = "purchase-error";
     OpenIapEvent["PromotedProductIOS"] = "promoted-product-ios";
 })(OpenIapEvent || (OpenIapEvent = {}));
-export function setValueAsync(value) {
-    return ExpoIapModule.setValueAsync(value);
-}
 // Ensure the emitter has proper EventEmitter interface
 export const emitter = (ExpoIapModule ||
     NativeModulesProxy.ExpoIap);
@@ -36,7 +30,7 @@ const normalizeProductType = (type) => {
     if (!type || type === 'inapp' || type === 'in-app') {
         return {
             canonical: 'in-app',
-            native: 'inapp',
+            native: 'in-app',
         };
     }
     if (type === 'subs') {
@@ -45,26 +39,39 @@ const normalizeProductType = (type) => {
             native: 'subs',
         };
     }
+    if (type === 'all') {
+        return {
+            canonical: 'all',
+            native: 'all',
+        };
+    }
     throw new Error(`Unsupported product type: ${type}`);
 };
+const normalizePurchasePlatform = (purchase) => {
+    const platform = purchase.platform;
+    if (typeof platform !== 'string') {
+        return purchase;
+    }
+    const lowered = platform.toLowerCase();
+    if (lowered === platform || (lowered !== 'ios' && lowered !== 'android')) {
+        return purchase;
+    }
+    return { ...purchase, platform: lowered };
+};
+const normalizePurchaseArray = (purchases) => purchases.map((purchase) => normalizePurchasePlatform(purchase));
 export const purchaseUpdatedListener = (listener) => {
-    console.log('[JS] Registering purchaseUpdatedListener');
     const wrappedListener = (event) => {
-        console.log('[JS] purchaseUpdatedListener fired:', event);
-        listener(event);
+        const normalized = normalizePurchasePlatform(event);
+        listener(normalized);
     };
     const emitterSubscription = emitter.addListener(OpenIapEvent.PurchaseUpdated, wrappedListener);
-    console.log('[JS] purchaseUpdatedListener registered successfully');
     return emitterSubscription;
 };
 export const purchaseErrorListener = (listener) => {
-    console.log('[JS] Registering purchaseErrorListener');
     const wrappedListener = (error) => {
-        console.log('[JS] purchaseErrorListener fired:', error);
         listener(error);
     };
     const emitterSubscription = emitter.addListener(OpenIapEvent.PurchaseError, wrappedListener);
-    console.log('[JS] purchaseErrorListener registered successfully');
     return emitterSubscription;
 };
 /**
@@ -94,116 +101,80 @@ export const promotedProductListenerIOS = (listener) => {
     }
     return emitter.addListener(OpenIapEvent.PromotedProductIOS, listener);
 };
-export function initConnection() {
-    const result = ExpoIapModule.initConnection();
-    return Promise.resolve(result);
-}
-export async function endConnection() {
-    return ExpoIapModule.endConnection();
-}
+export const initConnection = async () => ExpoIapModule.initConnection();
+export const endConnection = async () => ExpoIapModule.endConnection();
 /**
  * Fetch products with unified API (v2.7.0+)
  *
- * @param params - Product fetch configuration
- * @param params.skus - Array of product SKUs to fetch
- * @param params.type - Type of products: 'in-app' for regular products (default) or 'subs' for subscriptions
- *
- * @example
- * ```typescript
- * // Regular products
- * const products = await fetchProducts({
- *   skus: ['product1', 'product2'],
- *   type: 'in-app'
- * });
- *
- * // Subscriptions
- * const subscriptions = await fetchProducts({
- *   skus: ['sub1', 'sub2'],
- *   type: 'subs'
- * });
- * ```
+ * @param request - Product fetch configuration
+ * @param request.skus - Array of product SKUs to fetch
+ * @param request.type - Product query type: 'in-app', 'subs', or 'all'
  */
-export const fetchProducts = async ({ skus, type, }) => {
-    if (!skus?.length) {
-        throw new PurchaseError({
+export const fetchProducts = async (request) => {
+    console.log('fetchProducts called with:', request);
+    const { skus, type } = request ?? {};
+    if (!Array.isArray(skus) || skus.length === 0) {
+        throw createPurchaseError({
             message: 'No SKUs provided',
             code: ErrorCode.EmptySkuList,
         });
     }
     const { canonical, native } = normalizeProductType(type);
+    const skuSet = new Set(skus);
+    const filterIosItems = (items) => items.filter((item) => {
+        if (!isProductIOS(item)) {
+            return false;
+        }
+        const candidate = item;
+        return typeof candidate.id === 'string' && skuSet.has(candidate.id);
+    });
+    const filterAndroidItems = (items) => items.filter((item) => {
+        if (!isProductAndroid(item)) {
+            return false;
+        }
+        const candidate = item;
+        return typeof candidate.id === 'string' && skuSet.has(candidate.id);
+    });
+    const castResult = (items) => {
+        if (canonical === 'in-app') {
+            return items;
+        }
+        if (canonical === 'subs') {
+            return items;
+        }
+        return items;
+    };
     if (Platform.OS === 'ios') {
         const rawItems = await ExpoIapModule.fetchProducts({ skus, type: native });
-        const filteredItems = rawItems.filter((item) => {
-            if (!isProductIOS(item)) {
-                return false;
-            }
-            const isValid = typeof item === 'object' &&
-                item !== null &&
-                'id' in item &&
-                typeof item.id === 'string' &&
-                skus.includes(item.id);
-            return isValid;
-        });
-        return canonical === 'in-app'
-            ? filteredItems
-            : filteredItems;
+        return castResult(filterIosItems(rawItems));
     }
     if (Platform.OS === 'android') {
-        const items = await ExpoIapModule.fetchProducts(native, skus);
-        const filteredItems = items.filter((item) => {
-            if (!isProductAndroid(item))
-                return false;
-            return (typeof item === 'object' &&
-                item !== null &&
-                'id' in item &&
-                typeof item.id === 'string' &&
-                skus.includes(item.id));
-        });
-        return canonical === 'in-app'
-            ? filteredItems
-            : filteredItems;
+        const rawItems = await ExpoIapModule.fetchProducts(native, skus);
+        return castResult(filterAndroidItems(rawItems));
     }
     throw new Error('Unsupported platform');
 };
-export const getAvailablePurchases = ({ alsoPublishToEventListenerIOS = false, onlyIncludeActiveItemsIOS = true, } = {}) => (Platform.select({
-    ios: () => ExpoIapModule.getAvailableItems(alsoPublishToEventListenerIOS, onlyIncludeActiveItemsIOS),
-    android: () => ExpoIapModule.getAvailableItems(),
-}) || (() => Promise.resolve([])))();
-/**
- * Restore completed transactions (cross-platform behavior)
- *
- * - iOS: perform a lightweight sync to refresh transactions and ignore sync errors,
- *   then fetch available purchases to surface restored items to the app.
- * - Android: simply fetch available purchases (restoration happens via query).
- *
- * This helper returns the restored/available purchases so callers can update UI/state.
- *
- * @param options.alsoPublishToEventListenerIOS - iOS only: whether to also publish to the event listener
- * @param options.onlyIncludeActiveItemsIOS - iOS only: whether to only include active items
- * @returns Promise resolving to the list of available/restored purchases
- */
-export const restorePurchases = async (options = {}) => {
-    if (Platform.OS === 'ios') {
-        // Perform best-effort sync on iOS and ignore sync errors to avoid blocking restore flow
-        await syncIOS().catch(() => undefined);
-    }
-    // Then, fetch available purchases for both platforms
-    const purchases = await getAvailablePurchases({
-        alsoPublishToEventListenerIOS: options.alsoPublishToEventListenerIOS ?? false,
-        onlyIncludeActiveItemsIOS: options.onlyIncludeActiveItemsIOS ?? true,
-    });
-    return purchases;
-};
-const offerToRecordIOS = (offer) => {
-    if (!offer)
-        return undefined;
-    return {
-        identifier: offer.identifier,
-        keyIdentifier: offer.keyIdentifier,
-        nonce: offer.nonce,
-        signature: offer.signature,
-        timestamp: offer.timestamp.toString(),
+export const getAvailablePurchases = async (options) => {
+    const normalizedOptions = {
+        alsoPublishToEventListenerIOS: options?.alsoPublishToEventListenerIOS ?? false,
+        onlyIncludeActiveItemsIOS: options?.onlyIncludeActiveItemsIOS ?? true,
     };
+    const resolvePurchases = Platform.select({
+        ios: () => ExpoIapModule.getAvailableItems(normalizedOptions.alsoPublishToEventListenerIOS, normalizedOptions.onlyIncludeActiveItemsIOS),
+        android: () => ExpoIapModule.getAvailableItems(),
+    }) ?? (() => Promise.resolve([]));
+    const purchases = await resolvePurchases();
+    return normalizePurchaseArray(purchases);
+};
+export const getStorefront = async () => {
+    // Cross-platform storefront
+    if (Platform.OS === 'android') {
+        if (typeof ExpoIapModule.getStorefrontAndroid === 'function') {
+            return ExpoIapModule.getStorefrontAndroid();
+        }
+        return '';
+    }
+    return getStorefrontIOS();
 };
 function normalizeRequestProps(request, platform) {
     // Platform-specific format - directly return the appropriate platform data
@@ -240,8 +211,8 @@ function normalizeRequestProps(request, platform) {
  * });
  * ```
  */
-export const requestPurchase = (requestObj) => {
-    const { request, type } = requestObj;
+export const requestPurchase = async (args) => {
+    const { request, type } = args;
     const { canonical, native } = normalizeProductType(type);
     const isInAppPurchase = canonical === 'in-app';
     if (Platform.OS === 'ios') {
@@ -249,18 +220,30 @@ export const requestPurchase = (requestObj) => {
         if (!normalizedRequest?.sku) {
             throw new Error('Invalid request for iOS. The `sku` property is required and must be a string.');
         }
-        const { sku, andDangerouslyFinishTransactionAutomatically = false, appAccountToken, quantity, withOffer, } = normalizedRequest;
-        return (async () => {
-            const offer = offerToRecordIOS(withOffer ?? undefined);
-            const purchase = await ExpoIapModule.requestPurchase({
-                sku,
-                andDangerouslyFinishTransactionAutomatically,
-                appAccountToken,
-                quantity,
-                withOffer: offer,
-            });
-            return purchase;
-        })();
+        let payload;
+        if (canonical === 'in-app') {
+            payload = {
+                type: 'in-app',
+                request: request,
+            };
+        }
+        else if (canonical === 'subs') {
+            payload = {
+                type: 'subs',
+                request: request,
+            };
+        }
+        else {
+            throw new Error(`Unsupported product type: ${canonical}`);
+        }
+        const purchase = (await ExpoIapModule.requestPurchase(payload));
+        if (Array.isArray(purchase)) {
+            return normalizePurchaseArray(purchase);
+        }
+        if (purchase) {
+            return normalizePurchasePlatform(purchase);
+        }
+        return canonical === 'subs' ? [] : null;
     }
     if (Platform.OS === 'android') {
         if (isInAppPurchase) {
@@ -269,18 +252,17 @@ export const requestPurchase = (requestObj) => {
                 throw new Error('Invalid request for Android. The `skus` property is required and must be a non-empty array.');
             }
             const { skus, obfuscatedAccountIdAndroid, obfuscatedProfileIdAndroid, isOfferPersonalized, } = normalizedRequest;
-            return (async () => {
-                return ExpoIapModule.requestPurchase({
-                    type: native,
-                    skuArr: skus,
-                    purchaseToken: undefined,
-                    replacementMode: -1,
-                    obfuscatedAccountId: obfuscatedAccountIdAndroid,
-                    obfuscatedProfileId: obfuscatedProfileIdAndroid,
-                    offerTokenArr: [],
-                    isOfferPersonalized: isOfferPersonalized ?? false,
-                });
-            })();
+            const result = (await ExpoIapModule.requestPurchase({
+                type: native,
+                skuArr: skus,
+                purchaseToken: undefined,
+                replacementMode: -1,
+                obfuscatedAccountId: obfuscatedAccountIdAndroid,
+                obfuscatedProfileId: obfuscatedProfileIdAndroid,
+                offerTokenArr: [],
+                isOfferPersonalized: isOfferPersonalized ?? false,
+            }));
+            return normalizePurchaseArray(result);
         }
         if (canonical === 'subs') {
             const normalizedRequest = normalizeRequestProps(request, 'android');
@@ -291,90 +273,94 @@ export const requestPurchase = (requestObj) => {
             const normalizedOffers = subscriptionOffers ?? [];
             const replacementMode = replacementModeAndroid ?? -1;
             const purchaseToken = purchaseTokenAndroid ?? undefined;
-            return (async () => {
-                return ExpoIapModule.requestPurchase({
-                    type: native,
-                    skuArr: skus,
-                    purchaseToken,
-                    replacementMode,
-                    obfuscatedAccountId: obfuscatedAccountIdAndroid,
-                    obfuscatedProfileId: obfuscatedProfileIdAndroid,
-                    offerTokenArr: normalizedOffers.map((so) => so.offerToken),
-                    subscriptionOffers: normalizedOffers,
-                    isOfferPersonalized: isOfferPersonalized ?? false,
-                });
-            })();
+            const result = (await ExpoIapModule.requestPurchase({
+                type: native,
+                skuArr: skus,
+                purchaseToken,
+                replacementMode,
+                obfuscatedAccountId: obfuscatedAccountIdAndroid,
+                obfuscatedProfileId: obfuscatedProfileIdAndroid,
+                offerTokenArr: normalizedOffers.map((offer) => offer.offerToken),
+                subscriptionOffers: normalizedOffers,
+                isOfferPersonalized: isOfferPersonalized ?? false,
+            }));
+            return normalizePurchaseArray(result);
         }
         throw new Error("Invalid request for Android: Expected a valid request object with 'skus' array.");
     }
-    return Promise.resolve(); // Fallback for unsupported platforms
+    throw new Error('Platform not supported');
 };
-export const finishTransaction = ({ purchase, isConsumable = false, }) => {
-    return (Platform.select({
-        ios: async () => {
-            const transactionId = purchase.id;
-            if (!transactionId) {
-                return Promise.reject(new Error('purchase.id required to finish iOS transaction'));
-            }
-            await ExpoIapModule.finishTransaction(transactionId);
-            return Promise.resolve(true);
-        },
-        android: async () => {
-            const androidPurchase = purchase;
-            // Use purchaseToken if available, fallback to purchaseTokenAndroid for backward compatibility
-            const token = androidPurchase.purchaseToken;
-            if (!token) {
-                return Promise.reject(new PurchaseError({
-                    message: 'Purchase token is required to finish transaction',
-                    code: ErrorCode.DeveloperError,
-                    productId: androidPurchase.productId,
-                    platform: 'android',
-                }));
-            }
-            if (isConsumable) {
-                return ExpoIapModule.consumePurchaseAndroid(token);
-            }
-            return ExpoIapModule.acknowledgePurchaseAndroid(token);
-        },
-    }) || (() => Promise.reject(new Error('Unsupported Platform'))))();
+export const finishTransaction = async ({ purchase, isConsumable = false, }) => {
+    if (Platform.OS === 'ios') {
+        await ExpoIapModule.finishTransaction(purchase, isConsumable);
+        return;
+    }
+    if (Platform.OS === 'android') {
+        const token = purchase.purchaseToken ?? undefined;
+        if (!token) {
+            throw createPurchaseError({
+                message: 'Purchase token is required to finish transaction',
+                code: ErrorCode.DeveloperError,
+                productId: purchase.productId,
+                platform: 'android',
+            });
+        }
+        if (isConsumable) {
+            await ExpoIapModule.consumePurchaseAndroid(token);
+            return;
+        }
+        await ExpoIapModule.acknowledgePurchaseAndroid(token);
+        return;
+    }
+    throw new Error('Unsupported Platform');
 };
 /**
- * Retrieves the current storefront information from iOS App Store
- *
- * @returns Promise resolving to the storefront country code
- * @throws Error if called on non-iOS platform
+ * Restore completed transactions (cross-platform behavior)
  *
- * @example
- * ```typescript
- * const storefront = await getStorefrontIOS();
- * console.log(storefront); // 'US'
- * ```
+ * - iOS: perform a lightweight sync to refresh transactions and ignore sync errors,
+ *   then fetch available purchases to surface restored items to the app.
+ * - Android: simply fetch available purchases (restoration happens via query).
  *
- * @platform iOS
+ * This helper triggers the refresh flows but does not return the purchases; consumers should
+ * call `getAvailablePurchases` or rely on hook state to inspect the latest items.
  */
-export const getStorefrontIOS = () => {
-    if (Platform.OS !== 'ios') {
-        console.warn('getStorefrontIOS: This method is only available on iOS');
-        return Promise.resolve('');
+export const restorePurchases = async () => {
+    if (Platform.OS === 'ios') {
+        await syncIOS().catch(() => undefined);
     }
-    return ExpoIapModule.getStorefrontIOS();
+    await getAvailablePurchases({
+        alsoPublishToEventListenerIOS: false,
+        onlyIncludeActiveItemsIOS: true,
+    });
 };
 /**
- * Gets the storefront country code from the underlying native store.
- * Returns a two-letter country code such as 'US', 'KR', or empty string on failure.
+ * Deeplinks to native interface that allows users to manage their subscriptions
+ * @param options.skuAndroid - Required for Android to locate specific subscription (ignored on iOS)
+ * @param options.packageNameAndroid - Required for Android to identify your app (ignored on iOS)
+ *
+ * @returns Promise that resolves when the deep link is successfully opened
+ *
+ * @throws {Error} When called on unsupported platform or when required Android parameters are missing
+ *
+ * @example
+ * import { deepLinkToSubscriptions } from 'expo-iap';
  *
- * @platform ios
- * @platform android
+ * // Works on both iOS and Android
+ * await deepLinkToSubscriptions({
+ *   skuAndroid: 'your_subscription_sku',
+ *   packageNameAndroid: 'com.example.app'
+ * });
  */
-export const getStorefront = () => {
-    // Cross-platform storefront
+export const deepLinkToSubscriptions = async (options) => {
+    if (Platform.OS === 'ios') {
+        await deepLinkToSubscriptionsIOS();
+        return;
+    }
     if (Platform.OS === 'android') {
-        if (typeof ExpoIapModule.getStorefrontAndroid === 'function') {
-            return ExpoIapModule.getStorefrontAndroid();
-        }
-        return Promise.resolve('');
+        await deepLinkToSubscriptionsAndroid(options ?? null);
+        return;
     }
-    return getStorefrontIOS();
+    throw new Error(`Unsupported platform: ${Platform.OS}`);
 };
 /**
  * Internal receipt validation function (NOT RECOMMENDED for production use)
@@ -384,59 +370,28 @@ export const getStorefront = () => {
  * - iOS: Send receipt data to Apple's verification endpoint from your server
  * - Android: Use Google Play Developer API with service account credentials
  */
-export const validateReceipt = async (sku, androidOptions) => {
+export const validateReceipt = async (options) => {
+    const { sku, androidOptions } = options;
     if (Platform.OS === 'ios') {
-        return await validateReceiptIOS(sku);
+        return validateReceiptIOS({ sku });
     }
-    else if (Platform.OS === 'android') {
+    if (Platform.OS === 'android') {
         if (!androidOptions ||
             !androidOptions.packageName ||
             !androidOptions.productToken ||
             !androidOptions.accessToken) {
             throw new Error('Android validation requires packageName, productToken, and accessToken');
         }
-        return await validateReceiptAndroid({
+        return validateReceiptAndroid({
             packageName: androidOptions.packageName,
             productId: sku,
             productToken: androidOptions.productToken,
             accessToken: androidOptions.accessToken,
-            isSub: androidOptions.isSub,
-        });
-    }
-    else {
-        throw new Error('Platform not supported');
-    }
-};
-/**
- * Deeplinks to native interface that allows users to manage their subscriptions
- * @param options.skuAndroid - Required for Android to locate specific subscription (ignored on iOS)
- * @param options.packageNameAndroid - Required for Android to identify your app (ignored on iOS)
- *
- * @returns Promise that resolves when the deep link is successfully opened
- *
- * @throws {Error} When called on unsupported platform or when required Android parameters are missing
- *
- * @example
- * import { deepLinkToSubscriptions } from 'expo-iap';
- *
- * // Works on both iOS and Android
- * await deepLinkToSubscriptions({
- *   skuAndroid: 'your_subscription_sku',
- *   packageNameAndroid: 'com.example.app'
- * });
- */
-export const deepLinkToSubscriptions = (options) => {
-    if (Platform.OS === 'ios') {
-        return deepLinkToSubscriptionsIOS();
-    }
-    if (Platform.OS === 'android') {
-        return deepLinkToSubscriptionsAndroid({
-            sku: options?.skuAndroid,
-            packageName: options?.packageNameAndroid,
+            isSub: androidOptions.isSub ?? undefined,
         });
     }
-    return Promise.reject(new Error(`Unsupported platform: ${Platform.OS}`));
+    throw new Error('Platform not supported');
 };
 export * from './useIAP';
-export * from './utils/errorMapping';
+export { ErrorCodeUtils, ErrorCodeMapping, createPurchaseError, createPurchaseErrorFromPlatform, } from './utils/errorMapping';
 //# sourceMappingURL=index.js.map