@yuno-payments/yuno-sdk-react-native 1.0.16 → 1.0.17-rc.10

package/src/YunoSdk.ts

@@ -7,30 +7,39 @@ import type {
   StartPayment,
   SeamlessArguments,
   OneTimeTokenInfo,
+  TokenCollectedData,
+  HeadlessTokenResponse,
+  ThreeDSecureChallengeResponse,
+  EnrollmentCollectedData,
+  HeadlessEnrollmentResponse,
 } from './core/types';
 import { YunoStatus, YunoLanguage, CardFlow } from './core/enums';
 
 const LINKING_ERROR =
-  `The package '@y.uno/yuno-sdk-react-native' doesn't seem to be linked. Make sure: \n\n` +
+  `The package '@yuno/yuno-sdk-react-native' doesn't seem to be linked. Make sure: \n\n` +
   Platform.select({ ios: "- Run 'pod install'\n", default: '' }) +
   '- You rebuilt the app after installing the package\n' +
   '- You are not using Expo Go\n';
 
-const YunoSdkNative = NativeModules.YunoSdk
-  ? NativeModules.YunoSdk
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
-    );
+/**
+ * Devuelve el módulo nativo YunoSdk o lanza un error de linking
+ */
+function getYunoNative(): any {
+  const native = NativeModules.YunoSdk;
+  if (!native) {
+    throw new Error(LINKING_ERROR);
+  }
+  return native;
+}
 
 /**
- * Event emitter for Yuno SDK events.
+ * Devuelve un NativeEventEmitter para el módulo YunoSdk
+ * Se crea sólo cuando hace falta (no en top-level).
  */
-const eventEmitter = new NativeEventEmitter(YunoSdkNative);
+function getYunoEventEmitter(): NativeEventEmitter {
+  const native = getYunoNative();
+  return new NativeEventEmitter(native);
+}
 
 /**
  * Payment state event data.
@@ -85,13 +94,16 @@ export class YunoSdk {
   /**
    * Marks the SDK as initialized without calling the native initialize method.
    * This is useful when the SDK has been initialized from the native side (e.g., in MainActivity/YunoActivity).
-   * 
+   *
    * @param countryCode - ISO country code (e.g., 'US', 'BR', 'CO')
    * @param language - Optional language setting (defaults to EN)
-   * 
+   *
    * @internal
    */
-  static markAsInitialized(countryCode: string = 'CO', language: YunoLanguage = YunoLanguage.EN): void {
+  static markAsInitialized(
+    countryCode: string = 'CO',
+    language: YunoLanguage = YunoLanguage.EN
+  ): void {
     this.countryCode = countryCode;
     this.language = language;
     this.isInitialized = true;
@@ -153,7 +165,7 @@ export class YunoSdk {
     this.countryCode = countryCode;
     this.language = config.lang!;
 
-    await YunoSdkNative.initialize(
+    await getYunoNative().initialize(
       apiKey,
       countryCode,
       config,
@@ -186,7 +198,7 @@ export class YunoSdk {
       countryCode: params.countryCode ?? this.getCountryCode(),
     };
 
-    return YunoSdkNative.enrollmentPayment(args);
+    return getYunoNative().enrollmentPayment(args);
   }
 
   /**
@@ -214,7 +226,7 @@ export class YunoSdk {
     this.checkInitialized();
 
     const code = countryCode ?? this.getCountryCode();
-    return YunoSdkNative.startPaymentLite(params, code);
+    return getYunoNative().startPaymentLite(params, code);
   }
 
   /**
@@ -229,7 +241,7 @@ export class YunoSdk {
    */
   static async startPayment(showPaymentStatus: boolean = true): Promise<void> {
     this.checkInitialized();
-    return YunoSdkNative.startPayment(showPaymentStatus);
+    return getYunoNative().startPayment(showPaymentStatus);
   }
 
   /**
@@ -251,7 +263,11 @@ export class YunoSdk {
   ): Promise<void> {
     this.checkInitialized();
     const code = countryCode ?? this.getCountryCode();
-    return YunoSdkNative.continuePayment(checkoutSession, code, showPaymentStatus);
+    return getYunoNative().continuePayment(
+      checkoutSession,
+      code,
+      showPaymentStatus
+    );
   }
 
   /**
@@ -284,7 +300,7 @@ export class YunoSdk {
       countryCode: params.countryCode ?? this.getCountryCode(),
     };
 
-    const statusString = await YunoSdkNative.startPaymentSeamlessLite(
+    const statusString = await getYunoNative().startPaymentSeamlessLite(
       args,
       this.getLanguage()
     );
@@ -302,7 +318,7 @@ export class YunoSdk {
    */
   static async hideLoader(): Promise<void> {
     this.checkInitialized();
-    return YunoSdkNative.hideLoader();
+    return getYunoNative().hideLoader();
   }
 
   /**
@@ -326,7 +342,7 @@ export class YunoSdk {
     }
 
     this.checkInitialized();
-    return YunoSdkNative.receiveDeeplink(url);
+    return getYunoNative().receiveDeeplink(url);
   }
 
   /**
@@ -346,7 +362,7 @@ export class YunoSdk {
    * ```
    */
   static async getLastOneTimeToken(): Promise<string | null> {
-    return YunoSdkNative.getLastOneTimeToken();
+    return getYunoNative().getLastOneTimeToken();
   }
 
   /**
@@ -363,16 +379,16 @@ export class YunoSdk {
    * ```
    */
   static async getLastOneTimeTokenInfo(): Promise<OneTimeTokenInfo | null> {
-    return YunoSdkNative.getLastOneTimeTokenInfo();
+    return getYunoNative().getLastOneTimeTokenInfo();
   }
 
   /**
    * Clears the last OTT tokens stored by the SDK.
    * This is useful to ensure clean state before starting a new payment flow.
-   * 
+   *
    * Note: This is automatically called at the start of each payment/enrollment flow,
    * but you can call it manually if needed.
-   * 
+   *
    * @example
    * ```typescript
    * // Clear OTT before starting a new payment
@@ -380,7 +396,25 @@ export class YunoSdk {
    * ```
    */
   static async clearLastOneTimeToken(): Promise<void> {
-    return YunoSdkNative.clearLastOneTimeToken();
+    return getYunoNative().clearLastOneTimeToken();
+  }
+
+  /**
+   * Clears the last stored payment status.
+   * This should be called at the start of each new payment flow
+   * to prevent stale status from previous flows affecting new transactions.
+   *
+   * @returns Promise that resolves when the status is cleared
+   *
+   * @example
+   * ```typescript
+   * // Clear payment status before starting a new flow
+   * await YunoSdk.clearLastPaymentStatus();
+   * await YunoSdk.startPayment({ checkoutSession, countryCode });
+   * ```
+   */
+  static async clearLastPaymentStatus(): Promise<void> {
+    return getYunoNative().clearLastPaymentStatus();
   }
 
   /**
@@ -408,10 +442,8 @@ export class YunoSdk {
   static onPaymentStatus(listener: (state: YunoPaymentState) => void): {
     remove: () => void;
   } {
-    const subscription = eventEmitter.addListener(
-      'YunoPaymentStatus',
-      listener
-    );
+    const emitter = getYunoEventEmitter();
+    const subscription = emitter.addListener('YunoPaymentStatus', listener);
     return { remove: () => subscription.remove() };
   }
 
@@ -440,10 +472,8 @@ export class YunoSdk {
   static onEnrollmentStatus(listener: (state: YunoEnrollmentState) => void): {
     remove: () => void;
   } {
-    const subscription = eventEmitter.addListener(
-      'YunoEnrollmentStatus',
-      listener
-    );
+    const emitter = getYunoEventEmitter();
+    const subscription = emitter.addListener('YunoEnrollmentStatus', listener);
     return { remove: () => subscription.remove() };
   }
 
@@ -466,7 +496,8 @@ export class YunoSdk {
   static onOneTimeToken(listener: (token: string) => void): {
     remove: () => void;
   } {
-    const subscription = eventEmitter.addListener('YunoOneTimeToken', listener);
+    const emitter = getYunoEventEmitter();
+    const subscription = emitter.addListener('YunoOneTimeToken', listener);
     return { remove: () => subscription.remove() };
   }
 
@@ -490,7 +521,8 @@ export class YunoSdk {
   static onOneTimeTokenInfo(listener: (tokenInfo: OneTimeTokenInfo) => void): {
     remove: () => void;
   } {
-    const subscription = eventEmitter.addListener('YunoOneTimeTokenInfo', listener);
+    const emitter = getYunoEventEmitter();
+    const subscription = emitter.addListener('YunoOneTimeTokenInfo', listener);
     return { remove: () => subscription.remove() };
   }
 
@@ -515,4 +547,149 @@ export class YunoSdk {
     }
     return this.language;
   }
+
+  // ==================== HEADLESS PAYMENT FLOW ====================
+
+  /**
+   * Generate a one-time token (OTT) from collected payment data using the headless flow.
+   * This method allows you to tokenize payment information without using the UI components.
+   *
+   * @param tokenCollectedData The payment data to tokenize
+   * @param checkoutSession The checkout session ID
+   * @param countryCode The country code for the payment (optional, uses initialized value if not provided)
+   * @returns Promise resolving to the generated token or rejecting with an error
+   *
+   * @example
+   * ```typescript
+   * import { YunoSdk, CardType } from '@yuno-payments/yuno-sdk-react-native';
+   *
+   * try {
+   *   const result = await YunoSdk.generateToken({
+   *     checkoutSession: '73ed16c5-4481-4dce-af42-404b68e21027',
+   *     paymentMethod: {
+   *       type: 'CARD',
+   *       vaultedToken: null,
+   *       card: {
+   *         save: false,
+   *         detail: {
+   *           expirationMonth: 11,
+   *           expirationYear: 25,
+   *           number: '4000000000001091',
+   *           securityCode: '123',
+   *           holderName: 'John Doe',
+   *           type: CardType.CREDIT,
+   *         },
+   *       },
+   *     },
+   *   }, 'checkoutSessionId', 'BR');
+   *
+   *   console.log('Token:', result.token);
+   * } catch (error) {
+   *   console.error('Token generation failed:', error);
+   * }
+   * ```
+   */
+  static async generateToken(
+    tokenCollectedData: TokenCollectedData,
+    checkoutSession: string,
+    countryCode?: string
+  ): Promise<HeadlessTokenResponse> {
+    const native = getYunoNative();
+    const country = countryCode || this.getCountryCode();
+
+    return native.generateToken(tokenCollectedData, checkoutSession, country);
+  }
+
+  /**
+   * Get the 3D Secure challenge URL for a checkout session using the headless flow.
+   * This is typically called after successfully generating a token to handle 3DS verification.
+   *
+   * @param checkoutSession The checkout session ID
+   * @param countryCode The country code for the payment (optional, uses initialized value if not provided)
+   * @returns Promise resolving to the 3DS challenge response
+   *
+   * @example
+   * ```typescript
+   * import { YunoSdk } from '@yuno-payments/yuno-sdk-react-native';
+   *
+   * try {
+   *   // First generate token
+   *   const tokenResult = await YunoSdk.generateToken(paymentData, checkoutSession, 'BR');
+   *
+   *   // Then get 3DS challenge URL if needed
+   *   const challengeResult = await YunoSdk.getThreeDSecureChallenge(checkoutSession, 'BR');
+   *
+   *   if (challengeResult.type === 'URL') {
+   *     console.log('3DS URL:', challengeResult.data);
+   *     // Open this URL in a WebView for the user to complete 3DS verification
+   *   }
+   * } catch (error) {
+   *   console.error('3DS challenge failed:', error);
+   * }
+   * ```
+   */
+  static async getThreeDSecureChallenge(
+    checkoutSession: string,
+    countryCode?: string
+  ): Promise<ThreeDSecureChallengeResponse> {
+    const native = getYunoNative();
+    const country = countryCode || this.getCountryCode();
+
+    return native.getThreeDSecureChallenge(checkoutSession, country);
+  }
+
+  // ==================== HEADLESS ENROLLMENT FLOW ====================
+
+  /**
+   * Continue enrollment to create a vaulted token from collected payment data using the headless flow.
+   * This method allows you to save payment information without using the UI components.
+   *
+   * @param enrollmentCollectedData The enrollment data to process
+   * @param customerSession The customer session ID
+   * @param countryCode The country code for the enrollment (optional, uses initialized value if not provided)
+   * @returns Promise resolving to the vaulted token or rejecting with an error
+   *
+   * @example
+   * ```typescript
+   * import { YunoSdk, CardType } from '@yuno-payments/yuno-sdk-react-native';
+   *
+   * try {
+   *   const result = await YunoSdk.continueEnrollment({
+   *     customerSession: '73ed16c5-4481-4dce-af42-404b68e21027',
+   *     paymentMethod: {
+   *       type: 'CARD',
+   *       card: {
+   *         save: true,
+   *         detail: {
+   *           expirationMonth: 11,
+   *           expirationYear: 25,
+   *           number: '4000000000001091',
+   *           securityCode: '123',
+   *           holderName: 'John Doe',
+   *           type: CardType.CREDIT,
+   *         },
+   *       },
+   *     },
+   *   }, 'customerSessionId', 'BR');
+   *
+   *   console.log('Vaulted Token:', result.vaultedToken);
+   * } catch (error) {
+   *   console.error('Enrollment failed:', error);
+   * }
+   * ```
+   */
+  static async continueEnrollment(
+    enrollmentCollectedData: EnrollmentCollectedData,
+    customerSession: string,
+    countryCode?: string
+  ): Promise<HeadlessEnrollmentResponse> {
+    const native = getYunoNative();
+    const country = countryCode || this.getCountryCode();
+
+    return native.continueEnrollment(
+      enrollmentCollectedData,
+      customerSession,
+      country
+    );
+  }
 }

package/src/core/types/HeadlessTypes.ts

@@ -0,0 +1,110 @@
+/**
+ * Headless Payment Flow Types
+ * These types mirror the native SDK's TokenCollectedData structure
+ */
+
+export enum CardType {
+  CREDIT = 'CREDIT',
+  DEBIT = 'DEBIT',
+}
+
+export interface Detail {
+  expirationMonth?: number;
+  expirationYear?: number;
+  number?: string;
+  securityCode?: string;
+  holderName?: string;
+  type?: CardType;
+}
+
+export interface Installment {
+  id: string;
+  value: number;
+}
+
+export interface CardData {
+  save?: boolean;
+  detail?: Detail;
+  installment?: Installment;
+}
+
+export interface Document {
+  type: string;
+  number: string;
+}
+
+export interface Phone {
+  countryCode: string;
+  number: string;
+}
+
+export interface Address {
+  street?: string;
+  number?: string;
+  complement?: string;
+  neighborhood?: string;
+  city?: string;
+  state?: string;
+  zipCode?: string;
+  country?: string;
+}
+
+export interface Customer {
+  id: string;
+  merchantCustomerId: string;
+  firstName?: string;
+  lastName?: string;
+  dateOfBirth?: string;
+  email?: string;
+  country?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  document?: Document;
+  phone?: Phone;
+  billingAddress?: Address;
+  shippingAddress?: Address;
+}
+
+export interface PaymentMethod {
+  type: string;
+  vaultedToken?: string | null;
+  card?: CardData;
+  customer?: Customer;
+}
+
+export interface TokenCollectedData {
+  checkoutSession?: string;
+  customerSession?: string;
+  paymentMethod: PaymentMethod;
+}
+
+export interface ThreeDSecureChallengeResponse {
+  type: string;
+  data: string;
+}
+
+export interface HeadlessTokenResponse {
+  token?: string;
+  error?: string;
+}
+
+/**
+ * Headless Enrollment Flow Types
+ * These types mirror the native SDK's EnrollmentCollectedData structure
+ */
+
+export interface EnrollmentMethod {
+  type: string;
+  card: CardData;
+  customer?: Customer;
+}
+
+export interface EnrollmentCollectedData {
+  customerSession: string;
+  paymentMethod: EnrollmentMethod;
+}
+
+export interface HeadlessEnrollmentResponse {
+  vaultedToken?: string;
+  error?: string;
+}

package/src/core/types/OneTimeTokenInfo.ts

@@ -204,4 +204,3 @@ export interface OneTimeTokenInfo {
    */
   customer?: CustomerPayerInformation | null;
 }
-

package/src/core/types/index.ts

@@ -5,3 +5,20 @@ export type { EnrollmentArguments } from './EnrollmentArguments';
 export type { StartPayment, MethodSelected } from './StartPayment';
 export type { SeamlessArguments } from './SeamlessArguments';
 export type { OneTimeTokenInfo } from './OneTimeTokenInfo';
+export type {
+  TokenCollectedData,
+  PaymentMethod,
+  CardData,
+  Detail,
+  Installment,
+  Customer,
+  Document,
+  Phone,
+  Address,
+  CardType,
+  ThreeDSecureChallengeResponse,
+  HeadlessTokenResponse,
+  EnrollmentCollectedData,
+  EnrollmentMethod,
+  HeadlessEnrollmentResponse,
+} from './HeadlessTypes';