@idealyst/payments 1.2.108 → 1.2.109

package/src/usePayments.ts

@@ -1,90 +1,149 @@
 import { useState, useCallback, useEffect, useRef } from 'react';
 import type {
-  UsePaymentsOptions,
-  UsePaymentsResult,
-  PaymentProviderStatus,
-  PaymentConfig,
-  PaymentError,
-  PaymentMethodAvailability,
-  PaymentSheetRequest,
-  PaymentResult,
+  UseIAPOptions,
+  UseIAPResult,
+  IAPProviderStatus,
+  IAPConfig,
+  IAPError,
+  IAPProduct,
+  IAPSubscription,
+  IAPPurchase,
 } from './types';
-import { INITIAL_PROVIDER_STATUS } from './constants';
 
 /**
- * Factory that creates a usePayments hook bound to platform-specific functions.
+ * Factory that creates a useIAP hook bound to platform-specific functions.
  * Each platform entry point calls this with the correct implementations.
  */
-export function createUsePaymentsHook(fns: {
-  initializePayments: (config: PaymentConfig) => Promise<void>;
-  checkPaymentAvailability: () => Promise<PaymentMethodAvailability[]>;
-  confirmPayment: (request: PaymentSheetRequest) => Promise<PaymentResult>;
-  createPaymentMethod: (request: PaymentSheetRequest) => Promise<PaymentResult>;
-  getPaymentStatus: () => PaymentProviderStatus;
+export function createUseIAPHook(fns: {
+  initializeIAP: (config?: IAPConfig) => Promise<void>;
+  getProducts: (skus: string[]) => Promise<IAPProduct[]>;
+  getSubscriptions: (skus: string[]) => Promise<IAPSubscription[]>;
+  purchaseProduct: (sku: string) => Promise<IAPPurchase>;
+  purchaseSubscription: (sku: string, offerToken?: string) => Promise<IAPPurchase>;
+  finishTransaction: (purchase: IAPPurchase, isConsumable?: boolean) => Promise<void>;
+  restorePurchases: () => Promise<IAPPurchase[]>;
+  getIAPStatus: () => IAPProviderStatus;
+  endConnection: () => Promise<void>;
 }) {
-  return function usePayments(
-    options: UsePaymentsOptions = {},
-  ): UsePaymentsResult {
-    const { config, autoCheckAvailability = true } = options;
+  return function useIAP(options: UseIAPOptions = {}): UseIAPResult {
+    const { config, productSkus, subscriptionSkus } = options;
 
-    const [status, setStatus] = useState<PaymentProviderStatus>(
-      INITIAL_PROVIDER_STATUS,
-    );
+    const [isReady, setIsReady] = useState(false);
     const [isProcessing, setIsProcessing] = useState(false);
-    const [error, setError] = useState<PaymentError | null>(null);
+    const [error, setError] = useState<IAPError | null>(null);
+    const [products, setProducts] = useState<IAPProduct[]>([]);
+    const [subscriptions, setSubscriptions] = useState<IAPSubscription[]>([]);
+    const [currentPurchase, setCurrentPurchase] = useState<IAPPurchase | null>(null);
     const initializedRef = useRef(false);
 
-    // Auto-initialize if config provided
+    // Auto-initialize and fetch products/subscriptions
     useEffect(() => {
-      if (!config || initializedRef.current) return;
+      if (initializedRef.current) return;
+      if (config === undefined && !productSkus && !subscriptionSkus) return;
       initializedRef.current = true;
 
       const init = async () => {
-        await fns.initializePayments(config);
-        const currentStatus = fns.getPaymentStatus();
-        setStatus(currentStatus);
-        setError(currentStatus.error ?? null);
-
-        if (autoCheckAvailability && currentStatus.state === 'ready') {
-          await fns.checkPaymentAvailability();
-          setStatus(fns.getPaymentStatus());
+        try {
+          await fns.initializeIAP(config);
+          const status = fns.getIAPStatus();
+
+          if (status.state === 'ready') {
+            setIsReady(true);
+
+            if (productSkus?.length) {
+              const prods = await fns.getProducts(productSkus);
+              setProducts(prods);
+            }
+            if (subscriptionSkus?.length) {
+              const subs = await fns.getSubscriptions(subscriptionSkus);
+              setSubscriptions(subs);
+            }
+          } else if (status.error) {
+            setError(status.error);
+          }
+        } catch (err) {
+          setError(err as IAPError);
         }
       };
       init();
-    }, [config, autoCheckAvailability]);
 
-    const initialize = useCallback(
-      async (initConfig: PaymentConfig) => {
-        setError(null);
-        await fns.initializePayments(initConfig);
-        const currentStatus = fns.getPaymentStatus();
-        setStatus(currentStatus);
-        setError(currentStatus.error ?? null);
-
-        if (autoCheckAvailability && currentStatus.state === 'ready') {
-          await fns.checkPaymentAvailability();
-          setStatus(fns.getPaymentStatus());
-        }
-      },
-      [autoCheckAvailability],
-    );
+      return () => {
+        fns.endConnection();
+      };
+    }, [config, productSkus, subscriptionSkus]);
+
+    const initialize = useCallback(async (initConfig?: IAPConfig) => {
+      setError(null);
+      try {
+        await fns.initializeIAP(initConfig);
+        const status = fns.getIAPStatus();
+        setIsReady(status.state === 'ready');
+        if (status.error) setError(status.error);
+      } catch (err) {
+        setError(err as IAPError);
+      }
+    }, []);
 
-    const checkAvailability = useCallback(async () => {
-      const result = await fns.checkPaymentAvailability();
-      setStatus(fns.getPaymentStatus());
-      return result;
+    const getProductsAction = useCallback(async (skus: string[]) => {
+      setIsProcessing(true);
+      setError(null);
+      try {
+        const result = await fns.getProducts(skus);
+        setProducts(result);
+        return result;
+      } catch (err) {
+        const iapError = err as IAPError;
+        setError(iapError);
+        throw iapError;
+      } finally {
+        setIsProcessing(false);
+      }
     }, []);
 
-    const confirmPaymentAction = useCallback(
-      async (request: PaymentSheetRequest) => {
+    const getSubscriptionsAction = useCallback(async (skus: string[]) => {
+      setIsProcessing(true);
+      setError(null);
+      try {
+        const result = await fns.getSubscriptions(skus);
+        setSubscriptions(result);
+        return result;
+      } catch (err) {
+        const iapError = err as IAPError;
+        setError(iapError);
+        throw iapError;
+      } finally {
+        setIsProcessing(false);
+      }
+    }, []);
+
+    const purchaseProductAction = useCallback(async (sku: string) => {
+      setIsProcessing(true);
+      setError(null);
+      try {
+        const purchase = await fns.purchaseProduct(sku);
+        setCurrentPurchase(purchase);
+        return purchase;
+      } catch (err) {
+        const iapError = err as IAPError;
+        setError(iapError);
+        throw iapError;
+      } finally {
+        setIsProcessing(false);
+      }
+    }, []);
+
+    const purchaseSubscriptionAction = useCallback(
+      async (sku: string, offerToken?: string) => {
         setIsProcessing(true);
         setError(null);
         try {
-          return await fns.confirmPayment(request);
+          const purchase = await fns.purchaseSubscription(sku, offerToken);
+          setCurrentPurchase(purchase);
+          return purchase;
         } catch (err) {
-          const paymentError = err as PaymentError;
-          setError(paymentError);
-          throw paymentError;
+          const iapError = err as IAPError;
+          setError(iapError);
+          throw iapError;
         } finally {
           setIsProcessing(false);
         }
@@ -92,45 +151,50 @@ export function createUsePaymentsHook(fns: {
       [],
     );
 
-    const createPaymentMethodAction = useCallback(
-      async (request: PaymentSheetRequest) => {
-        setIsProcessing(true);
-        setError(null);
+    const finishTransactionAction = useCallback(
+      async (purchase: IAPPurchase, isConsumable?: boolean) => {
         try {
-          return await fns.createPaymentMethod(request);
+          await fns.finishTransaction(purchase, isConsumable);
         } catch (err) {
-          const paymentError = err as PaymentError;
-          setError(paymentError);
-          throw paymentError;
-        } finally {
-          setIsProcessing(false);
+          const iapError = err as IAPError;
+          setError(iapError);
+          throw iapError;
         }
       },
       [],
     );
 
-    const clearError = useCallback(() => setError(null), []);
+    const restorePurchasesAction = useCallback(async () => {
+      setIsProcessing(true);
+      setError(null);
+      try {
+        return await fns.restorePurchases();
+      } catch (err) {
+        const iapError = err as IAPError;
+        setError(iapError);
+        throw iapError;
+      } finally {
+        setIsProcessing(false);
+      }
+    }, []);
 
-    const { availablePaymentMethods } = status;
+    const clearError = useCallback(() => setError(null), []);
 
     return {
-      status,
-      isReady: status.state === 'ready',
+      isReady,
       isProcessing,
-      availablePaymentMethods,
-      isApplePayAvailable: availablePaymentMethods.some(
-        (m) => m.type === 'apple_pay' && m.isAvailable,
-      ),
-      isGooglePayAvailable: availablePaymentMethods.some(
-        (m) => m.type === 'google_pay' && m.isAvailable,
-      ),
-      isPaymentAvailable: status.isPaymentAvailable,
       error,
+      products,
+      subscriptions,
+      currentPurchase,
 
       initialize,
-      checkAvailability,
-      confirmPayment: confirmPaymentAction,
-      createPaymentMethod: createPaymentMethodAction,
+      getProducts: getProductsAction,
+      getSubscriptions: getSubscriptionsAction,
+      purchaseProduct: purchaseProductAction,
+      purchaseSubscription: purchaseSubscriptionAction,
+      finishTransaction: finishTransactionAction,
+      restorePurchases: restorePurchasesAction,
       clearError,
     };
   };