@zezosoft/react-native-zezopay 1.0.2 → 1.0.4

package/src/ZezoPay/utils/hooks/useZezoPay.ts

@@ -1,320 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useAsync } from './useAsync';
-import {
-  ZezoPayClient,
-  type ICheckoutResult,
-  type ISummaryItem,
-  type PaymentProvider,
-  type ZezoPayCallbacks,
-  type HandlePayment,
-  type IReadyPaymentProvider,
-  type ICheckoutPayload,
-  type BaseCheckoutInput,
-} from '@zezosoft/zezopay-client';
-import { Platform } from 'react-native';
-import { Razorpay } from '../../Payments/Providers';
-
-export const allowedProviders: PaymentProvider[] = ['razorpay'];
-
-/**
- * Parameters for the useZezoPay hook
- * @interface UseZezoPayParams
- */
-interface UseZezoPayParams {
-  publicKey: string;
-  userInfo: { _id: string; name: string; email?: string; phone?: string };
-  subscriptionId?: string;
-  digitalProductId?: string;
-  summaryItems?: ISummaryItem[];
-  handlePayment?: HandlePayment;
-  callback?: ZezoPayCallbacks;
-}
-
-/**
- * Custom hook to handle payments with ZezoPay SDK.
- * Manages payment providers, summary items, and checkout process.
- * @param params - Configuration for the ZezoPay client
- * @returns Object with payment state and methods
- */
-export const useZezoPay = ({
-  publicKey,
-  userInfo,
-  subscriptionId,
-  digitalProductId,
-  summaryItems: initialItems = [],
-  handlePayment,
-  callback,
-}: UseZezoPayParams) => {
-  // Input validation
-  if (!publicKey) throw new Error('publicKey is required');
-  if (!userInfo?._id || !userInfo?.name)
-    throw new Error('userInfo must include _id and name');
-
-  // SDK client
-  const zezopay = useMemo(
-    () =>
-      new ZezoPayClient({
-        publicKey,
-        platform: Platform.OS === 'ios' ? 'ios' : 'android',
-      }),
-    [publicKey]
-  );
-
-  // States
-  const [selectedPayment, setSelectedPayment] =
-    useState<PaymentProvider | null>(null);
-  const [summaryItems, setSummaryItems] =
-    useState<ISummaryItem[]>(initialItems);
-  const [voucherCode, setVoucherCode] = useState('');
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [isSuccess, setIsSuccess] = useState(false);
-  const [error, setError] = useState('');
-
-  // Load payment providers
-  const {
-    result: providers,
-    loading,
-    error: providerError,
-  } = useAsync(async () => {
-    try {
-      const data = (await zezopay.payments.providers())?.data || [];
-      const filtered = data.filter((p: IReadyPaymentProvider) =>
-        allowedProviders.includes(p.provider as PaymentProvider)
-      );
-      if (!filtered.length) {
-        throw new Error('No supported payment providers available');
-      }
-      return filtered;
-    } catch (err) {
-      throw err;
-    }
-  }, [publicKey]);
-
-  // Auto-select first provider
-  useEffect(() => {
-    if (providers?.length && !selectedPayment) {
-      setSelectedPayment(providers[0]?.provider as PaymentProvider);
-    }
-  }, [providers, selectedPayment]);
-
-  // Total price calculation
-  const totalPrice = useMemo(() => {
-    if (!summaryItems.length) return 0;
-    return Number(
-      summaryItems
-        .reduce((sum, item) => {
-          let price = item.price || 0;
-          if (item.discount) {
-            if (typeof item.discount === 'number') {
-              price = (price * (100 - item.discount)) / 100;
-            } else if (item.discount.type === 'percentage') {
-              price = (price * (100 - item.discount.amount)) / 100;
-            } else if (item.discount.type === 'fixed') {
-              price = Math.max(0, price - item.discount.amount); // Prevent negative prices
-            }
-          }
-          return sum + price;
-        }, 0)
-        .toFixed(2)
-    );
-  }, [summaryItems]);
-
-  // Remove item from summary
-  const removeItem = useCallback((id: string | number) => {
-    setSummaryItems((prev) => prev.filter((item) => item.id !== id));
-  }, []);
-
-  // Default checkout handler
-  const defaultHandlePayment: HandlePayment = useCallback(
-    async ({
-      provider,
-      subscriptionId: subId,
-      digitalProductId: dpId,
-      userInfo: paymentUserInfo,
-    }) => {
-      if (!provider || !allowedProviders.includes(provider)) {
-        throw new Error(`Invalid payment provider: ${provider || 'none'}`);
-      }
-
-      // Common payload properties
-      const basePayload: BaseCheckoutInput = {
-        provider,
-        userId: paymentUserInfo._id,
-        metadata: { userInfo: paymentUserInfo },
-        ...(voucherCode && { coupon_code: voucherCode }), // Include coupon_code if provided
-      };
-
-      // Construct payload based on type
-      let payload: ICheckoutPayload;
-
-      if (subId) {
-        payload = {
-          ...basePayload,
-          type: 'subscription',
-          subscriptionId: subId,
-        };
-      } else if (dpId) {
-        payload = {
-          ...basePayload,
-          type: 'digital-product',
-          digitalProductId: dpId,
-        };
-      } else {
-        if (totalPrice <= 0) {
-          throw new Error(
-            'Price must be greater than zero for normal payments'
-          );
-        }
-        payload = { ...basePayload, type: 'normal', price: totalPrice };
-      }
-
-      try {
-        const result = await zezopay.payments.checkout(payload);
-        if (result.status !== 200) {
-          throw new Error(`Checkout failed with status: ${result.status}`);
-        }
-        return result.data;
-      } catch (err) {
-        throw err;
-      }
-    },
-    [voucherCode, totalPrice, zezopay.payments]
-  );
-
-  const paymentFn = handlePayment || defaultHandlePayment;
-
-  // Payment handler
-  const paymentHandler = useCallback(
-    async (order: ICheckoutResult) => {
-      if (!selectedPayment) {
-        throw new Error('No payment provider selected');
-      }
-      if (!order?.orderId || !order?.price || !order?.currency) {
-        throw new Error(
-          'Invalid order details: missing orderId, price, or currency'
-        );
-      }
-
-      try {
-        if (selectedPayment === 'razorpay') {
-          const razorpay = new Razorpay();
-          await razorpay.open({
-            amount: order.price * 100,
-            currency: order.currency,
-            order_id: order.orderId,
-            publicKey: order.publicKey || publicKey, // Fallback to publicKey
-            handler(response) {
-              if (response.razorpay_payment_id) {
-                callback?.onSuccess?.({
-                  status: 'success',
-                  order_id: response.razorpay_order_id,
-                  signature: response.razorpay_signature,
-                  payment_id: response.razorpay_payment_id,
-                });
-                setIsSuccess(true);
-                setError('');
-              } else {
-                const err = new Error('Payment failed: No payment ID received');
-                setError(err.message);
-                callback?.onFailure?.(err);
-              }
-            },
-            OnError(err) {
-              const errorMessage =
-                err?.description ||
-                err?.message ||
-                err?.details?.error?.description ||
-                'Payment failed unexpectedly';
-
-              setError(errorMessage);
-              callback?.onFailure?.(err);
-            },
-            prefill: {
-              user_email: userInfo.email,
-              user_name: userInfo.name,
-              user_phone: userInfo.phone,
-            },
-          });
-        } else {
-          throw new Error(`Unsupported payment provider: ${selectedPayment}`);
-        }
-      } catch (err) {
-        throw err;
-      }
-    },
-    [selectedPayment, userInfo, callback, publicKey]
-  );
-
-  // Handle pay now
-  const handlePayNow = useCallback(async () => {
-    if (isProcessing) return; // Prevent multiple submissions
-    if (!selectedPayment) {
-      setError('Please select a payment provider');
-      return;
-    }
-    if (!summaryItems.length) {
-      setError('Cart is empty. Add items to proceed.');
-      return;
-    }
-    if (totalPrice <= 0) {
-      setError('Total price must be greater than zero');
-      return;
-    }
-
-    setError('');
-    setIsProcessing(true); // ✅ Set processing to true at the start
-
-    try {
-      const order = await paymentFn({
-        provider: selectedPayment,
-        subscriptionId,
-        digitalProductId,
-        userInfo,
-      });
-
-      if (!order) {
-        const err = new Error('No order data returned from checkout');
-        setError(err.message);
-        callback?.onError?.(err);
-        return;
-      }
-
-      await paymentHandler(order);
-    } catch (err: any) {
-      const errorMessage = err.message || 'Payment failed unexpectedly';
-      setError(errorMessage);
-      callback?.onError?.(err);
-    } finally {
-      setIsProcessing(false);
-    }
-  }, [
-    isProcessing,
-    selectedPayment,
-    summaryItems,
-    totalPrice,
-    paymentFn,
-    subscriptionId,
-    digitalProductId,
-    userInfo,
-    paymentHandler,
-    callback,
-  ]);
-
-  return {
-    selectedPayment,
-    setSelectedPayment,
-    summaryItems,
-    setSummaryItems,
-    totalPrice,
-    voucherCode,
-    setVoucherCode,
-    isProcessing,
-    isSuccess,
-    error,
-    providers: providers || [],
-    loading,
-    providerError,
-    removeItem,
-    handlePayNow,
-  };
-};

package/src/ZezoPay/utils/index.ts

@@ -1,16 +0,0 @@
-export function formatCurrency({
-  amount,
-  currency = 'INR',
-  minimumFractionDigits = 2,
-}: {
-  amount: number;
-  currency?: string;
-  minimumFractionDigits?: number;
-}): string {
-  return new Intl.NumberFormat('en-IN', {
-    style: 'currency',
-    currency,
-    minimumFractionDigits,
-    maximumFractionDigits: 2,
-  }).format(amount);
-}

package/src/index.tsx

@@ -1 +0,0 @@
-export * from './ZezoPay';