@yuno-payments/yuno-sdk-react-native 1.0.16

package/src/YunoSdk.ts

@@ -0,0 +1,518 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+import type {
+  YunoConfig,
+  IosConfig,
+  AndroidConfig,
+  EnrollmentArguments,
+  StartPayment,
+  SeamlessArguments,
+  OneTimeTokenInfo,
+} 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` +
+  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);
+        },
+      }
+    );
+
+/**
+ * Event emitter for Yuno SDK events.
+ */
+const eventEmitter = new NativeEventEmitter(YunoSdkNative);
+
+/**
+ * Payment state event data.
+ */
+export interface YunoPaymentState {
+  /** One-time token generated for the payment */
+  token?: string;
+  /** Payment status */
+  status: YunoStatus;
+}
+
+/**
+ * Enrollment state event data.
+ */
+export interface YunoEnrollmentState {
+  /** Enrollment status */
+  status: YunoStatus;
+}
+
+/**
+ * Yuno SDK class for React Native.
+ *
+ * This class provides methods to initialize and interact with the Yuno payment SDK.
+ *
+ * @example
+ * ```typescript
+ * import { YunoSdk, YunoLanguage, CardFlow } from '@y.uno/yuno-sdk-react-native';
+ *
+ * // Initialize the SDK
+ * await YunoSdk.initialize({
+ *   apiKey: 'your_api_key',
+ *   countryCode: 'US',
+ *   yunoConfig: {
+ *     lang: YunoLanguage.EN,
+ *     cardFlow: CardFlow.STEP_BY_STEP,
+ *     saveCardEnabled: true,
+ *   },
+ * });
+ *
+ * // Listen to payment events
+ * YunoSdk.onPaymentStatus((state) => {
+ *   if (state.token) {
+ *   }
+ * });
+ * ```
+ */
+export class YunoSdk {
+  private static countryCode: string | null = null;
+  private static language: YunoLanguage | null = null;
+  private static isInitialized: boolean = false;
+
+  /**
+   * 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 {
+    this.countryCode = countryCode;
+    this.language = language;
+    this.isInitialized = true;
+  }
+
+  /**
+   * Initializes the Yuno SDK with the required configuration.
+   *
+   * This method must be called before any other SDK operations.
+   *
+   * @param params - Configuration parameters for SDK initialization
+   * @param params.apiKey - Your Yuno API key
+   * @param params.countryCode - ISO country code (e.g., 'US', 'BR', 'CO')
+   * @param params.yunoConfig - Optional Yuno SDK configuration
+   * @param params.iosConfig - Optional iOS-specific configuration
+   * @param params.androidConfig - Optional Android-specific configuration
+   *
+   * @example
+   * ```typescript
+   * await YunoSdk.initialize({
+   *   apiKey: 'your_api_key_here',
+   *   countryCode: 'CO',
+   *   yunoConfig: {
+   *     lang: YunoLanguage.ES,
+   *     cardFlow: CardFlow.ONE_STEP,
+   *     saveCardEnabled: true,
+   *     keepLoader: false,
+   *     isDynamicViewEnabled: true,
+   *   },
+   * });
+   * ```
+   */
+  static async initialize(params: {
+    apiKey: string;
+    countryCode: string;
+    yunoConfig?: YunoConfig;
+    iosConfig?: IosConfig;
+    androidConfig?: AndroidConfig;
+  }): Promise<void> {
+    const {
+      apiKey,
+      countryCode,
+      yunoConfig = {},
+      iosConfig = {},
+      androidConfig = {},
+    } = params;
+
+    // Set default values
+    const config: YunoConfig = {
+      lang: yunoConfig.lang ?? YunoLanguage.EN,
+      cardFlow: yunoConfig.cardFlow ?? CardFlow.ONE_STEP,
+      saveCardEnabled: yunoConfig.saveCardEnabled ?? false,
+      keepLoader: yunoConfig.keepLoader ?? false,
+      isDynamicViewEnabled: yunoConfig.isDynamicViewEnabled ?? false,
+      cardFormDeployed: yunoConfig.cardFormDeployed ?? false,
+    };
+
+    // Store country code and language
+    this.countryCode = countryCode;
+    this.language = config.lang!;
+
+    await YunoSdkNative.initialize(
+      apiKey,
+      countryCode,
+      config,
+      iosConfig,
+      androidConfig
+    );
+
+    this.isInitialized = true;
+  }
+
+  /**
+   * Starts an enrollment payment flow.
+   *
+   * @param params - Enrollment configuration
+   *
+   * @example
+   * ```typescript
+   * await YunoSdk.enrollmentPayment({
+   *   customerSession: 'customer_session_token',
+   *   showPaymentStatus: true,
+   *   countryCode: 'US',
+   * });
+   * ```
+   */
+  static async enrollmentPayment(params: EnrollmentArguments): Promise<void> {
+    this.checkInitialized();
+
+    const args = {
+      ...params,
+      countryCode: params.countryCode ?? this.getCountryCode(),
+    };
+
+    return YunoSdkNative.enrollmentPayment(args);
+  }
+
+  /**
+   * Starts a payment lite flow.
+   *
+   * @param params - Payment configuration
+   * @param countryCode - Optional country code override
+   *
+   * @example
+   * ```typescript
+   * await YunoSdk.startPaymentLite({
+   *   checkoutSession: 'checkout_session_token',
+   *   methodSelected: {
+   *     vaultedToken: 'token_12345',
+   *     paymentMethodType: 'CARD',
+   *   },
+   *   showPaymentStatus: true,
+   * });
+   * ```
+   */
+  static async startPaymentLite(
+    params: StartPayment,
+    countryCode?: string
+  ): Promise<void> {
+    this.checkInitialized();
+
+    const code = countryCode ?? this.getCountryCode();
+    return YunoSdkNative.startPaymentLite(params, code);
+  }
+
+  /**
+   * Starts a full payment flow.
+   *
+   * @param showPaymentStatus - Whether to show payment status screen
+   *
+   * @example
+   * ```typescript
+   * await YunoSdk.startPayment(true);
+   * ```
+   */
+  static async startPayment(showPaymentStatus: boolean = true): Promise<void> {
+    this.checkInitialized();
+    return YunoSdkNative.startPayment(showPaymentStatus);
+  }
+
+  /**
+   * Continues a previously started payment.
+   *
+   * @param checkoutSession - The checkout session token
+   * @param countryCode - Optional country code (uses initialized country code if not provided)
+   * @param showPaymentStatus - Whether to show payment status screen
+   *
+   * @example
+   * ```typescript
+   * await YunoSdk.continuePayment('checkout_session_token', 'CO', true);
+   * ```
+   */
+  static async continuePayment(
+    checkoutSession: string,
+    countryCode?: string,
+    showPaymentStatus: boolean = true
+  ): Promise<void> {
+    this.checkInitialized();
+    const code = countryCode ?? this.getCountryCode();
+    return YunoSdkNative.continuePayment(checkoutSession, code, showPaymentStatus);
+  }
+
+  /**
+   * Starts a seamless payment lite flow.
+   *
+   * @param params - Seamless payment configuration
+   * @returns Promise resolving to the payment status
+   *
+   * @example
+   * ```typescript
+   * const status = await YunoSdk.startPaymentSeamlessLite({
+   *   checkoutSession: 'checkout_session_token',
+   *   methodSelected: {
+   *     vaultedToken: 'token_12345',
+   *     paymentMethodType: 'CARD',
+   *   },
+   *   showPaymentStatus: true,
+   *   countryCode: 'US',
+   * });
+   *
+   * ```
+   */
+  static async startPaymentSeamlessLite(
+    params: SeamlessArguments
+  ): Promise<YunoStatus> {
+    this.checkInitialized();
+
+    const args = {
+      ...params,
+      countryCode: params.countryCode ?? this.getCountryCode(),
+    };
+
+    const statusString = await YunoSdkNative.startPaymentSeamlessLite(
+      args,
+      this.getLanguage()
+    );
+
+    return statusString as YunoStatus;
+  }
+
+  /**
+   * Hides the loading indicator.
+   *
+   * @example
+   * ```typescript
+   * await YunoSdk.hideLoader();
+   * ```
+   */
+  static async hideLoader(): Promise<void> {
+    this.checkInitialized();
+    return YunoSdkNative.hideLoader();
+  }
+
+  /**
+   * Handles a deep link for payment resumption (iOS only).
+   *
+   * @param url - Deep link URL
+   *
+   * @example
+   * ```typescript
+   * import { Linking } from 'react-native';
+   *
+   * Linking.addEventListener('url', async (event) => {
+   *   await YunoSdk.receiveDeeplink(event.url);
+   * });
+   * ```
+   */
+  static async receiveDeeplink(url: string): Promise<void> {
+    if (Platform.OS !== 'ios') {
+      console.warn('receiveDeeplink is only available on iOS');
+      return;
+    }
+
+    this.checkInitialized();
+    return YunoSdkNative.receiveDeeplink(url);
+  }
+
+  /**
+   * Gets the last One Time Token (OTT) that was generated.
+   * This is useful when the OTT event was emitted while React Native was paused
+   * (e.g., during a payment flow in a native activity).
+   *
+   * @returns Promise resolving to the last OTT token, or null if none exists
+   *
+   * @example
+   * ```typescript
+   * // After returning from a payment flow
+   * const lastOtt = await YunoSdk.getLastOneTimeToken();
+   * if (lastOtt) {
+   *   // Use the token for payment processing
+   * }
+   * ```
+   */
+  static async getLastOneTimeToken(): Promise<string | null> {
+    return YunoSdkNative.getLastOneTimeToken();
+  }
+
+  /**
+   * Gets the last OneTimeTokenInfo object stored by the SDK.
+   * This is useful for recovering token information after the app returns from the native payment UI.
+   *
+   * @returns Promise resolving to OneTimeTokenInfo or null if no token info is stored
+   *
+   * @example
+   * ```typescript
+   * const tokenInfo = await YunoSdk.getLastOneTimeTokenInfo();
+   * if (tokenInfo) {
+   * }
+   * ```
+   */
+  static async getLastOneTimeTokenInfo(): Promise<OneTimeTokenInfo | null> {
+    return YunoSdkNative.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
+   * await YunoSdk.clearLastOneTimeToken();
+   * ```
+   */
+  static async clearLastOneTimeToken(): Promise<void> {
+    return YunoSdkNative.clearLastOneTimeToken();
+  }
+
+  /**
+   * Subscribes to payment status events.
+   *
+   * @param listener - Callback function to handle payment state changes
+   * @returns Subscription object with remove() method
+   *
+   * @example
+   * ```typescript
+   * const subscription = YunoSdk.onPaymentStatus((state) => {
+   *   switch (state.status) {
+   *     case YunoStatus.SUCCEEDED:
+   *       break;
+   *     case YunoStatus.FAILED:
+   *       break;
+   *     // ... handle other cases
+   *   }
+   * });
+   *
+   * // Later, remove the listener
+   * subscription.remove();
+   * ```
+   */
+  static onPaymentStatus(listener: (state: YunoPaymentState) => void): {
+    remove: () => void;
+  } {
+    const subscription = eventEmitter.addListener(
+      'YunoPaymentStatus',
+      listener
+    );
+    return { remove: () => subscription.remove() };
+  }
+
+  /**
+   * Subscribes to enrollment status events.
+   *
+   * @param listener - Callback function to handle enrollment state changes
+   * @returns Subscription object with remove() method
+   *
+   * @example
+   * ```typescript
+   * const subscription = YunoSdk.onEnrollmentStatus((state) => {
+   *   switch (state.status) {
+   *     case YunoStatus.SUCCEEDED:
+   *       break;
+   *     case YunoStatus.FAILED:
+   *       break;
+   *     // ... handle other cases
+   *   }
+   * });
+   *
+   * // Later, remove the listener
+   * subscription.remove();
+   * ```
+   */
+  static onEnrollmentStatus(listener: (state: YunoEnrollmentState) => void): {
+    remove: () => void;
+  } {
+    const subscription = eventEmitter.addListener(
+      'YunoEnrollmentStatus',
+      listener
+    );
+    return { remove: () => subscription.remove() };
+  }
+
+  /**
+   * Subscribes to one-time token (OTT) events.
+   *
+   * @param listener - Callback function to handle OTT generation
+   * @returns Subscription object with remove() method
+   *
+   * @example
+   * ```typescript
+   * const subscription = YunoSdk.onOneTimeToken((token) => {
+   *   // Use token for payment processing
+   * });
+   *
+   * // Later, remove the listener
+   * subscription.remove();
+   * ```
+   */
+  static onOneTimeToken(listener: (token: string) => void): {
+    remove: () => void;
+  } {
+    const subscription = eventEmitter.addListener('YunoOneTimeToken', listener);
+    return { remove: () => subscription.remove() };
+  }
+
+  /**
+   * Subscribes to one-time token info events with extended information.
+   * This event provides additional details beyond just the token string,
+   * including card data and customer information.
+   *
+   * @param listener - Callback function to handle OTT info
+   * @returns Subscription object with remove() method
+   *
+   * @example
+   * ```typescript
+   * const subscription = YunoSdk.onOneTimeTokenInfo((tokenInfo) => {
+   * });
+   *
+   * // Later, remove the listener
+   * subscription.remove();
+   * ```
+   */
+  static onOneTimeTokenInfo(listener: (tokenInfo: OneTimeTokenInfo) => void): {
+    remove: () => void;
+  } {
+    const subscription = eventEmitter.addListener('YunoOneTimeTokenInfo', listener);
+    return { remove: () => subscription.remove() };
+  }
+
+  private static checkInitialized(): void {
+    if (!this.isInitialized) {
+      throw new Error(
+        'YunoSdk is not initialized. Call YunoSdk.initialize() first.'
+      );
+    }
+  }
+
+  private static getCountryCode(): string {
+    if (!this.countryCode) {
+      throw new Error('Country code not set. Call YunoSdk.initialize() first.');
+    }
+    return this.countryCode;
+  }
+
+  private static getLanguage(): YunoLanguage {
+    if (!this.language) {
+      throw new Error('Language not set. Call YunoSdk.initialize() first.');
+    }
+    return this.language;
+  }
+}

package/src/core/enums/CardFlow.ts

@@ -0,0 +1,18 @@
+/**
+ * Enum representing the card flow type for payment processing.
+ *
+ * @example
+ * ```typescript
+ * import { CardFlow } from '@y.uno/yuno-sdk-react-native';
+ *
+ * const config = {
+ *   cardFlow: CardFlow.ONE_STEP,
+ * };
+ * ```
+ */
+export enum CardFlow {
+  /** One-step card flow */
+  ONE_STEP = 'ONE_STEP',
+  /** Step-by-step card flow */
+  STEP_BY_STEP = 'STEP_BY_STEP',
+}

package/src/core/enums/YunoLanguage.ts

@@ -0,0 +1,50 @@
+/**
+ * Enum representing the languages supported by the Yuno SDK.
+ *
+ * @example
+ * ```typescript
+ * import { YunoLanguage } from '@y.uno/yuno-sdk-react-native';
+ *
+ * const language = YunoLanguage.ES;
+ * ```
+ */
+export enum YunoLanguage {
+  /** English language */
+  EN = 'EN',
+  /** Spanish language */
+  ES = 'ES',
+  /** Portuguese language */
+  PT = 'PT',
+  /** Indonesian language */
+  ID = 'ID',
+  /** Malay language */
+  MY = 'MY',
+  /** Malaysian language */
+  MS = 'MS',
+  /** French language */
+  FR = 'FR',
+  /** Polish language */
+  PL = 'PL',
+  /** Italian language */
+  IT = 'IT',
+  /** German language */
+  DE = 'DE',
+  /** Russian language */
+  RU = 'RU',
+  /** Turkish language */
+  TR = 'TR',
+  /** Dutch language */
+  NL = 'NL',
+  /** Swedish language */
+  SV = 'SV',
+  /** Thai language */
+  TH = 'TH',
+  /** Filipino language */
+  FIL = 'FIL',
+  /** Vietnamese language */
+  VI = 'VI',
+  /** Chinese Simplified language */
+  ZH_CN = 'ZH-CN',
+  /** Chinese Traditional language */
+  ZH_TW = 'ZH-TW',
+}

package/src/core/enums/YunoStatus.ts

@@ -0,0 +1,32 @@
+/**
+ * Enum representing the possible statuses of a Yuno payment or enrollment operation.
+ *
+ * @example
+ * ```typescript
+ * import { YunoStatus } from '@y.uno/yuno-sdk-react-native';
+ *
+ * function handlePaymentStatus(status: YunoStatus) {
+ *   switch (status) {
+ *     case YunoStatus.SUCCEEDED:
+ *       break;
+ *     case YunoStatus.REJECTED:
+ *       break;
+ *     // ... handle other cases
+ *   }
+ * }
+ * ```
+ */
+export enum YunoStatus {
+  /** Payment/operation was rejected */
+  REJECTED = 'REJECTED',
+  /** Payment/operation succeeded */
+  SUCCEEDED = 'SUCCEEDED',
+  /** Payment/operation failed */
+  FAILED = 'FAILED',
+  /** Payment/operation is being processed */
+  PROCESSING = 'PROCESSING',
+  /** An internal error occurred */
+  INTERNAL_ERROR = 'INTERNAL_ERROR',
+  /** Operation was cancelled by the user */
+  CANCELLED_BY_USER = 'CANCELLED_BY_USER',
+}

package/src/core/enums/index.ts

@@ -0,0 +1,3 @@
+export { YunoLanguage } from './YunoLanguage';
+export { YunoStatus } from './YunoStatus';
+export { CardFlow } from './CardFlow';

package/src/core/index.ts

@@ -0,0 +1,2 @@
+export * from './enums';
+export * from './types';

package/src/core/types/AndroidConfig.ts

@@ -0,0 +1,17 @@
+/**
+ * Android-specific configuration for the Yuno SDK.
+ *
+ * @example
+ * ```typescript
+ * import { AndroidConfig } from '@y.uno/yuno-sdk-react-native';
+ *
+ * const androidConfig: AndroidConfig = {
+ *   // Add Android-specific configurations here
+ * };
+ * ```
+ */
+export interface AndroidConfig {
+  // Android-specific configuration properties
+  // Can be extended based on native SDK requirements
+  [key: string]: any;
+}

package/src/core/types/EnrollmentArguments.ts

@@ -0,0 +1,32 @@
+/**
+ * Arguments for enrollment payment operations.
+ *
+ * @example
+ * ```typescript
+ * import { EnrollmentArguments } from '@y.uno/yuno-sdk-react-native';
+ *
+ * const enrollmentArgs: EnrollmentArguments = {
+ *   customerSession: 'customer_session_token',
+ *   showPaymentStatus: true,
+ *   countryCode: 'US',
+ * };
+ * ```
+ */
+export interface EnrollmentArguments {
+  /**
+   * Customer session token.
+   */
+  customerSession: string;
+
+  /**
+   * Whether to show payment status.
+   * @default true
+   */
+  showPaymentStatus?: boolean;
+
+  /**
+   * Country code for the payment.
+   * If not provided, uses the default country code from initialization.
+   */
+  countryCode?: string;
+}

package/src/core/types/IosConfig.ts

@@ -0,0 +1,17 @@
+/**
+ * iOS-specific configuration for the Yuno SDK.
+ *
+ * @example
+ * ```typescript
+ * import { IosConfig } from '@y.uno/yuno-sdk-react-native';
+ *
+ * const iosConfig: IosConfig = {
+ *   // Add iOS-specific configurations here
+ * };
+ * ```
+ */
+export interface IosConfig {
+  // iOS-specific configuration properties
+  // Can be extended based on native SDK requirements
+  [key: string]: any;
+}