@primer-io/react-native 2.16.0 → 2.17.0-rc.1

package/lib/typescript/headless_checkout/PrimerHeadlessUniversalCheckoutRawDataManager.d.ts

@@ -1,18 +0,0 @@
-import type { PrimerRawData } from "..";
-import { PrimerError } from '../models/PrimerError';
-import type { PrimerInitializationData } from "src/models/PrimerInitializationData";
-export interface PrimerHeadlessUniversalCheckoutRawDataManagerOptions {
-    paymentMethodType: string;
-    onMetadataChange?: (metadata: any) => void;
-    onValidation?: (isValid: boolean, errors: PrimerError[] | undefined) => void;
-}
-declare class PrimerHeadlessUniversalCheckoutRawDataManagerClass {
-    constructor();
-    configure(options: PrimerHeadlessUniversalCheckoutRawDataManagerOptions): Promise<PrimerInitializationData | null>;
-    getRequiredInputElementTypes(): Promise<string[]>;
-    setRawData(rawData: PrimerRawData): Promise<void>;
-    submit(): Promise<void>;
-    disposeRawDataManager(): Promise<void>;
-}
-export declare const PrimerHeadlessUniversalCheckoutRawDataManager: PrimerHeadlessUniversalCheckoutRawDataManagerClass;
-export {};

package/lib/typescript/headless_checkout/RNPrimerHeadlessUniversalCheckout.d.ts

@@ -1,22 +0,0 @@
-type EventType = 'onHUCTokenizeStart' | 'onHUCPrepareStart' | 'onHUCAvailablePaymentMethodsLoaded' | 'onHUCPaymentMethodShow' | 'onTokenizeSuccess' | 'onResumeSuccess' | 'onResumePending' | 'onCheckoutReceivedAdditionalInfo' | 'onBeforePaymentCreate' | 'onBeforeClientSessionUpdate' | 'onClientSessionUpdate' | 'onCheckoutComplete' | 'onError';
-declare const RNPrimerHeadlessUniversalCheckout: {
-    addListener: (eventType: EventType, listener: (...args: any[]) => any) => void;
-    removeListener: (eventType: EventType, listener: (...args: any[]) => any) => void;
-    removeAllListenersForEvent(eventType: EventType): void;
-    removeAllListeners(): void;
-    getAssetForPaymentMethodType: (paymentMethodType: string, assetType: 'logo' | 'icon') => Promise<string>;
-    getAssetForCardNetwork: (cardNetwork: string, assetType: 'logo' | 'icon') => Promise<string>;
-    startWithClientToken(clientToken: string, settings: any): Promise<any>;
-    showPaymentMethod: (paymentMethodType: string) => Promise<void>;
-    handleTokenizationNewClientToken: (newClientToken: string) => Promise<void>;
-    handleTokenizationSuccess: () => Promise<void>;
-    handleTokenizationFailure: (errorMessage: string | null) => Promise<void>;
-    handleResumeWithNewClientToken: (newClientToken: string) => Promise<void>;
-    handleResumeSuccess: () => Promise<void>;
-    handleResumeFailure: (errorMessage: string | null) => Promise<void>;
-    handlePaymentCreationAbort: (errorMessage: string | null) => Promise<void>;
-    handlePaymentCreationContinue: () => Promise<void>;
-    setImplementedRNCallbacks: (implementedRNCallbacks: any) => Promise<void>;
-    disposePrimerHeadlessUniversalCheckout: () => Promise<void>;
-};
-export default RNPrimerHeadlessUniversalCheckout;

package/lib/typescript/headless_checkout/RNPrimerHeadlessUniversalCheckoutRawDataManager.d.ts

@@ -1,14 +0,0 @@
-import type { PrimerInitializationData } from 'src/models/PrimerInitializationData';
-type EventType = 'onMetadataChange' | 'onValidation' | 'onNativeError';
-declare const RNPrimerHeadlessUniversalCheckoutRawDataManager: {
-    addListener: (eventType: EventType, listener: (...args: any[]) => any) => void;
-    removeListener: (eventType: EventType, listener: (...args: any[]) => any) => void;
-    removeAllListenersForEvent(eventType: EventType): void;
-    removeAllListeners(): void;
-    configure: (paymentMethodType: string) => Promise<PrimerInitializationData | null>;
-    listRequiredInputElementTypesForPaymentMethodType: (paymentMethodType: string) => Promise<string[]>;
-    setRawData: (rawData: string) => Promise<void>;
-    submit: () => Promise<void>;
-    disposeRawDataManager: () => Promise<void>;
-};
-export default RNPrimerHeadlessUniversalCheckoutRawDataManager;

package/lib/typescript/headless_checkout/types.d.ts

@@ -1,22 +0,0 @@
-import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
-import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
-import type { PrimerTokenizationHandler, PrimerResumeHandler, PrimerPaymentCreationHandler, PrimerErrorHandler } from '../models/PrimerInterfaces';
-import type { PrimerClientSession } from '../models/PrimerClientSession';
-import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData';
-import type { PrimerError } from '../models/PrimerError';
-export interface PrimerHeadlessUniversalCheckoutStartResponse {
-    paymentMethodTypes: string[];
-}
-export interface PrimerHeadlessUniversalCheckoutCallbacks {
-    onBeforeClientSessionUpdate?: () => void;
-    onClientSessionUpdate?: (clientSession: PrimerClientSession) => void;
-    onBeforePaymentCreate?: (checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData, handler: PrimerPaymentCreationHandler) => void;
-    onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
-    onTokenizeSuccess?: (paymentMethodTokenData: PrimerPaymentMethodTokenData, handler: PrimerTokenizationHandler) => void;
-    onResumeSuccess?: (resumeToken: string, handler: PrimerResumeHandler) => void;
-    onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler | undefined) => void;
-    onPrepareStart?: (paymentMethodType: string) => void;
-    onTokenizeStart?: (paymentMethodType: string) => void;
-    onPaymentMethodShow?: (paymentMethodType: string) => void;
-    onAvailablePaymentMethodTypesLoad?: (paymentMethodTypes: string[]) => void;
-}

package/src/headless_checkout/PrimerHeadlessUniversalCheckout.ts

@@ -1,358 +0,0 @@
-import RNPrimerHeadlessUniversalCheckout from './RNPrimerHeadlessUniversalCheckout';
-import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
-import type { PrimerCheckoutAdditionalInfo } from '../models/PrimerCheckoutAdditionalInfo';
-import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
-import type { PrimerTokenizationHandler, PrimerResumeHandler, PrimerPaymentCreationHandler } from '../models/PrimerInterfaces';
-import type { PrimerHeadlessUniversalCheckoutStartResponse } from './types';
-import type { PrimerSettings } from '../models/PrimerSettings';
-import type { PrimerClientSession } from '../models/PrimerClientSession';
-import { PrimerError } from '../models/PrimerError';
-import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData';
-
-///////////////////////////////////////////
-// DECISION HANDLERS
-///////////////////////////////////////////
-
-// Tokenization Handler
-
-const tokenizationHandler: PrimerTokenizationHandler = {
-  handleFailure: async (errorMessage: string) => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage);
-    } catch (err) {
-      console.error(err);
-    }
-  },
-
-  handleSuccess: async () => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handleTokenizationSuccess();
-    } catch (err) {
-      console.error(err);
-    }
-  },
-
-  continueWithNewClientToken: async (newClientToken: string) => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
-    } catch (err) {
-      console.error(err);
-    }
-  }
-}
-
-// Resume Handler
-
-const resumeHandler: PrimerResumeHandler = {
-  handleFailure: async (errorMessage: string) => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handleResumeFailure(errorMessage);
-    } catch (err) {
-      console.error(err);
-    }
-  },
-
-  handleSuccess: async () => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handleResumeSuccess();
-    } catch (err) {
-      console.error(err);
-    }
-  },
-
-  continueWithNewClientToken: async (newClientToken: string) => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
-    } catch (err) {
-      console.error(err);
-    }
-  }
-}
-
-// Payment Creation Handler
-
-const paymentCreationHandler: PrimerPaymentCreationHandler = {
-  abortPaymentCreation: async (errorMessage: string) => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage);
-    } catch (err) {
-      console.error(err);
-    }
-  },
-
-  continuePaymentCreation: async () => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
-    } catch (err) {
-      console.error(err);
-    }
-  }
-}
-
-export let primerSettings: PrimerSettings | undefined = undefined;
-
-async function configureListeners(): Promise<void> {
-  return new Promise(async (resolve, reject) => {
-    try {
-      RNPrimerHeadlessUniversalCheckout.removeAllListeners();
-
-      let implementedRNCallbacks: any = {
-        onCheckoutComplete: (primerSettings?.onCheckoutComplete !== undefined),
-        onBeforePaymentCreate: (primerSettings?.onBeforePaymentCreate !== undefined),
-        onBeforeClientSessionUpdate: (primerSettings?.onBeforeClientSessionUpdate !== undefined),
-        onClientSessionUpdate: (primerSettings?.onClientSessionUpdate !== undefined),
-        onTokenizeSuccess: (primerSettings?.onTokenizeSuccess !== undefined),
-        onResumeSuccess: (primerSettings?.onResumeSuccess !== undefined),
-        onResumePending: (primerSettings?.onResumePending !== undefined),
-        onCheckoutReceivedAdditionalInfo: (primerSettings?.onCheckoutReceivedAdditionalInfo !== undefined),
-        onDismiss: false,
-        onError: (primerSettings?.onError !== undefined),
-        onHUCAvailablePaymentMethodsLoaded: (primerSettings?.onAvailablePaymentMethodsLoad !== undefined),
-        onHUCPrepareStart: (primerSettings?.onPrepareStart !== undefined),
-        onHUCTokenizeStart: (primerSettings?.onTokenizeStart !== undefined),
-        onHUCPaymentMethodShow: (primerSettings?.onPaymentMethodShow !== undefined)
-      };
-
-      await RNPrimerHeadlessUniversalCheckout.setImplementedRNCallbacks(implementedRNCallbacks);
-
-      if (implementedRNCallbacks.onCheckoutComplete) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onCheckoutComplete',
-          (data) => {
-            console.log('onCheckoutComplete');
-            if (primerSettings && primerSettings.onCheckoutComplete) {
-              const checkoutData: PrimerCheckoutData = data;
-              primerSettings.onCheckoutComplete(checkoutData);
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onResumePending) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onResumePending',
-          (additionalInfo) => {
-            if (primerSettings && primerSettings.onResumePending) {
-              const checkoutAdditionalInfo: PrimerCheckoutAdditionalInfo = additionalInfo;
-              primerSettings.onResumePending(checkoutAdditionalInfo);
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onCheckoutReceivedAdditionalInfo) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onCheckoutReceivedAdditionalInfo',
-          (additionalInfo) => {
-            if (primerSettings && primerSettings.onCheckoutReceivedAdditionalInfo) {
-              const checkoutAdditionalInfo: PrimerCheckoutAdditionalInfo = additionalInfo;
-              primerSettings.onCheckoutReceivedAdditionalInfo(checkoutAdditionalInfo);
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onHUCPrepareStart) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onHUCPrepareStart',
-          (data) => {
-            console.log('onHUCPrepareStart');
-            if (primerSettings && primerSettings.onPrepareStart) {
-              primerSettings.onPrepareStart(data.paymentMethodType || 'not implemented');
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onHUCTokenizeStart) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onHUCTokenizeStart',
-          (data) => {
-            console.log('onHUCTokenizeStart');
-            if (primerSettings && primerSettings.onTokenizeStart) {
-              primerSettings.onTokenizeStart(data.paymentMethodType || 'not implemented');
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onHUCPaymentMethodShow) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onHUCPaymentMethodShow',
-          (data) => {
-            console.log('onHUCPaymentMethodShow');
-            if (primerSettings && primerSettings.onPaymentMethodShow) {
-              primerSettings.onPaymentMethodShow(data.paymentMethodType || 'not implemented');
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onHUCAvailablePaymentMethodsLoaded) {
-        RNPrimerHeadlessUniversalCheckout.addListener(
-          'onHUCAvailablePaymentMethodsLoaded',
-          (data) => {
-            console.log('onHUCAvailablePaymentMethodsLoaded');
-            if (primerSettings && primerSettings.onAvailablePaymentMethodsLoad) {
-              if (data && data.paymentMethodTypes) {
-                const paymentMethodTypes: string[] = data.paymentMethodTypes;
-                const availablePaymentMethodTypes = paymentMethodTypes;
-                primerSettings.onAvailablePaymentMethodsLoad(availablePaymentMethodTypes || ['not implemented']);
-              } else {
-                primerSettings.onAvailablePaymentMethodsLoad(['not implemented']);
-              }
-
-            } else {
-              // Ignore!
-            }
-          }
-        );
-      }
-
-      if (implementedRNCallbacks.onBeforePaymentCreate) {
-        RNPrimerHeadlessUniversalCheckout.addListener('onBeforePaymentCreate', data => {
-          if (primerSettings && primerSettings.onBeforePaymentCreate) {
-            const checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData = data;
-            primerSettings.onBeforePaymentCreate(checkoutPaymentMethodData, paymentCreationHandler);
-          }
-        });
-      }
-
-      if (implementedRNCallbacks.onBeforeClientSessionUpdate) {
-        RNPrimerHeadlessUniversalCheckout.addListener('onBeforeClientSessionUpdate', _ => {
-          if (primerSettings && primerSettings.onBeforeClientSessionUpdate) {
-            primerSettings.onBeforeClientSessionUpdate();
-          }
-        });
-      }
-
-      if (implementedRNCallbacks.onClientSessionUpdate) {
-        RNPrimerHeadlessUniversalCheckout.addListener('onClientSessionUpdate', data => {
-          if (primerSettings && primerSettings.onClientSessionUpdate) {
-            const clientSession: PrimerClientSession = data;
-            primerSettings.onClientSessionUpdate(clientSession);
-          }
-        });
-      }
-
-      if (implementedRNCallbacks.onTokenizeSuccess) {
-        RNPrimerHeadlessUniversalCheckout.addListener('onTokenizeSuccess', data => {
-          if (primerSettings && primerSettings.onTokenizeSuccess) {
-            const paymentMethodTokenData: PrimerPaymentMethodTokenData = data;
-            primerSettings.onTokenizeSuccess(paymentMethodTokenData, tokenizationHandler);
-          }
-        });
-      }
-
-      if (implementedRNCallbacks.onResumeSuccess) {
-        RNPrimerHeadlessUniversalCheckout.addListener('onResumeSuccess', data => {
-          if (primerSettings && primerSettings.onResumeSuccess && data.resumeToken) {
-            primerSettings.onResumeSuccess(data.resumeToken, resumeHandler);
-          }
-        });
-      }
-
-      if (implementedRNCallbacks.onError) {
-        RNPrimerHeadlessUniversalCheckout.addListener('onError', data => {
-          if (data && data.error && data.error.errorId && primerSettings && primerSettings.onError) {
-            const errorId: string = data.error.errorId;
-            const description: string | undefined = data.error.description;
-            const recoverySuggestion: string | undefined = data.error.recoverySuggestion;
-            const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion);
-
-            if (data.checkoutData) {
-              primerSettings.onError(primerError, data.checkoutData, undefined);
-            } else {
-              primerSettings.onError(primerError, null, undefined);
-            }
-          }
-        });
-      }
-
-      resolve();
-
-    } catch (err) {
-      reject(err);
-    }
-  });
-}
-
-class PrimerHeadlessUniversalCheckoutClass {
-
-  ///////////////////////////////////////////
-  // Init
-  ///////////////////////////////////////////
-  constructor() {
-
-  }
-
-  ///////////////////////////////////////////
-  // API
-  ///////////////////////////////////////////
-  startWithClientToken(
-    clientToken: string,
-    settings: PrimerSettings
-  ): Promise<string[]> {
-    primerSettings = settings;
-
-    return new Promise(async (resolve, reject) => {
-      try {
-        await configureListeners();
-        const hucResponse: PrimerHeadlessUniversalCheckoutStartResponse = await RNPrimerHeadlessUniversalCheckout.startWithClientToken(clientToken, settings);
-        const availablePaymentMethodTypes: string[] = hucResponse.paymentMethodTypes;
-        resolve(availablePaymentMethodTypes);
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  async showPaymentMethod(paymentMethodType: string): Promise<void> {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await RNPrimerHeadlessUniversalCheckout.showPaymentMethod(paymentMethodType);
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  getAssetForPaymentMethodType(
-    paymentMethodType: string,
-    assetType: 'logo' | 'icon'
-  ): Promise<string> {
-    return RNPrimerHeadlessUniversalCheckout.getAssetForPaymentMethodType(
-      paymentMethodType,
-      assetType
-    );
-  }
-
-  getAssetForCardNetwork(
-    cardNetwork: string,
-    assetType: 'logo' | 'icon'
-  ): Promise<string> {
-    return RNPrimerHeadlessUniversalCheckout.getAssetForCardNetwork(
-      cardNetwork,
-      assetType
-    );
-  }
-
-  disposePrimerHeadlessUniversalCheckout(): Promise<void> {
-    return RNPrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
-  }
-}
-
-export const PrimerHeadlessUniversalCheckout = new PrimerHeadlessUniversalCheckoutClass();

package/src/headless_checkout/PrimerHeadlessUniversalCheckoutRawDataManager.ts

@@ -1,109 +0,0 @@
-import type { PrimerRawData } from "..";
-import RNPrimerHeadlessUniversalCheckoutRawDataManager from "./RNPrimerHeadlessUniversalCheckoutRawDataManager";
-import { primerSettings } from "./PrimerHeadlessUniversalCheckout"
-import { PrimerError } from '../models/PrimerError';
-import type { PrimerInitializationData } from "src/models/PrimerInitializationData";
-
-let primerHeadlessUniversalCheckoutRawDataManagerOptions: PrimerHeadlessUniversalCheckoutRawDataManagerOptions | undefined;
-
-async function configureListeners(): Promise<void> {
-    return new Promise(async (resolve, reject) => {
-        try {
-            RNPrimerHeadlessUniversalCheckoutRawDataManager.removeAllListeners();
-
-            RNPrimerHeadlessUniversalCheckoutRawDataManager.addListener('onMetadataChange', data => {
-                if (primerHeadlessUniversalCheckoutRawDataManagerOptions && primerHeadlessUniversalCheckoutRawDataManagerOptions.onMetadataChange) {
-                    primerHeadlessUniversalCheckoutRawDataManagerOptions.onMetadataChange(data);
-                }
-            });
-
-            RNPrimerHeadlessUniversalCheckoutRawDataManager.addListener('onValidation', data => {
-                if (primerHeadlessUniversalCheckoutRawDataManagerOptions && primerHeadlessUniversalCheckoutRawDataManagerOptions.onValidation) {
-                    let errors: PrimerError[] = [];
-                    for (const errData of (data.errors || [])) {
-                        const errorId: string = errData.errorId;
-                        const description: string | undefined = errData.description;
-                        const recoverySuggestion: string | undefined = errData.recoverySuggestion;
-                        const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion);
-                        errors.push(primerError);
-                    }
-
-                    primerHeadlessUniversalCheckoutRawDataManagerOptions.onValidation(data.isValid, errors.length === 0 ? undefined : errors);
-                }
-            });
-
-            RNPrimerHeadlessUniversalCheckoutRawDataManager.addListener('onNativeError', data => {
-                if (primerSettings && primerSettings.onError) {
-                    const errorId: string = data.error.errorId;
-                    const description: string | undefined = data.error.description;
-                    const recoverySuggestion: string | undefined = data.error.recoverySuggestion;
-                    const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion);
-                    primerSettings.onError(primerError, null, undefined);
-                }
-            });
-            resolve();
-
-        } catch (err) {
-            reject(err);
-        }
-    });
-}
-
-export interface PrimerHeadlessUniversalCheckoutRawDataManagerOptions {
-    paymentMethodType: string;
-    onMetadataChange?: (metadata: any) => void;
-    onValidation?: (isValid: boolean, errors: PrimerError[] | undefined) => void;
-}
-
-class PrimerHeadlessUniversalCheckoutRawDataManagerClass {
-
-    ///////////////////////////////////////////
-    // Init
-    ///////////////////////////////////////////
-    constructor() {
-
-    }
-
-    ///////////////////////////////////////////
-    // API
-    ///////////////////////////////////////////
-
-    configure(options: PrimerHeadlessUniversalCheckoutRawDataManagerOptions): Promise<PrimerInitializationData | null> {
-        primerHeadlessUniversalCheckoutRawDataManagerOptions = options;
-        configureListeners();
-        return RNPrimerHeadlessUniversalCheckoutRawDataManager.configure(primerHeadlessUniversalCheckoutRawDataManagerOptions.paymentMethodType);
-    }
-
-    async getRequiredInputElementTypes(): Promise<string[]> {
-        return new Promise(async (resolve, reject) => {
-            if (
-                primerHeadlessUniversalCheckoutRawDataManagerOptions &&
-                primerHeadlessUniversalCheckoutRawDataManagerOptions.paymentMethodType
-            ) {
-                try {
-                    const inputElementTypes = await RNPrimerHeadlessUniversalCheckoutRawDataManager.listRequiredInputElementTypesForPaymentMethodType(primerHeadlessUniversalCheckoutRawDataManagerOptions.paymentMethodType);
-                    resolve(inputElementTypes);
-                } catch (err) {
-                    reject(err);
-                }
-            } else {
-                const err = new PrimerError("manager-not-configured", "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.");
-                reject(err);
-            }
-        })
-    }
-
-    setRawData(rawData: PrimerRawData): Promise<void> {
-        return RNPrimerHeadlessUniversalCheckoutRawDataManager.setRawData(JSON.stringify(rawData));
-    }
-
-    submit(): Promise<void> {
-        return RNPrimerHeadlessUniversalCheckoutRawDataManager.submit();
-    }
-
-    disposeRawDataManager(): Promise<void> {
-         return RNPrimerHeadlessUniversalCheckoutRawDataManager.disposeRawDataManager();
-    }
-}
-
-export const PrimerHeadlessUniversalCheckoutRawDataManager = new PrimerHeadlessUniversalCheckoutRawDataManagerClass();

package/src/headless_checkout/RNPrimerHeadlessUniversalCheckoutRawDataManager.ts

@@ -1,104 +0,0 @@
-import { NativeEventEmitter, NativeModules } from 'react-native';
-import type { PrimerInitializationData } from 'src/models/PrimerInitializationData';
-
-const { PrimerHeadlessUniversalCheckoutRawDataManager } = NativeModules;
-const eventEmitter = new NativeEventEmitter(PrimerHeadlessUniversalCheckoutRawDataManager);
-
-type EventType =
-    | 'onMetadataChange'
-    | 'onValidation'
-    | 'onNativeError';
-
-const eventTypes: EventType[] = [
-    'onMetadataChange',
-    'onValidation',
-    'onNativeError'
-];
-
-const RNPrimerHeadlessUniversalCheckoutRawDataManager = {
-
-    ///////////////////////////////////////////
-    // Event Emitter
-    ///////////////////////////////////////////
-    addListener: (eventType: EventType, listener: (...args: any[]) => any) => {
-        eventEmitter.addListener(eventType, listener);
-    },
-
-    removeListener: (eventType: EventType, listener: (...args: any[]) => any) => {
-        eventEmitter.removeListener(eventType, listener);
-    },
-
-    removeAllListenersForEvent(eventType: EventType) {
-        eventEmitter.removeAllListeners(eventType);
-    },
-
-    removeAllListeners() {
-        eventTypes.forEach((eventType) => RNPrimerHeadlessUniversalCheckoutRawDataManager.removeAllListenersForEvent(eventType));
-    },
-
-    ///////////////////////////////////////////
-    // Native API
-    ///////////////////////////////////////////
-
-    configure: (paymentMethodType: string): Promise<PrimerInitializationData | null> => {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await PrimerHeadlessUniversalCheckoutRawDataManager.initialize(paymentMethodType);
-                const initializationData: PrimerInitializationData = await PrimerHeadlessUniversalCheckoutRawDataManager.configure();
-                resolve(initializationData);
-            } catch (e) {
-                reject(e);
-            }
-        });
-    },
-
-    listRequiredInputElementTypesForPaymentMethodType: (paymentMethodType: string): Promise<string[]> => {
-        return new Promise(async (resolve, reject) => {
-            try {
-                const res = await PrimerHeadlessUniversalCheckoutRawDataManager.listRequiredInputElementTypesForPaymentMethodType(paymentMethodType);
-                if (res.inputElementTypes) {
-                    resolve(res.inputElementTypes);
-                } else {
-                    resolve([])
-                }
-            } catch (e) {
-                reject(e);
-            }
-        });
-    },
-
-    setRawData: (rawData: string): Promise<void> => {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await PrimerHeadlessUniversalCheckoutRawDataManager.setRawData(rawData);
-                resolve();
-            } catch (e) {
-                reject(e);
-            }
-        });
-    },
-
-    submit: (): Promise<void> => {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await PrimerHeadlessUniversalCheckoutRawDataManager.submit();
-                resolve();
-            } catch (e) {
-                reject(e);
-            }
-        });
-    },
-
-    disposeRawDataManager: (): Promise<void> => {
-        return new Promise(async (resolve, reject) => {
-            try {
-                 await PrimerHeadlessUniversalCheckoutRawDataManager.disposeRawDataManager();
-                 resolve();
-            } catch (e) {
-                 reject(e);
-            }
-         });
-    },
-}
-
-export default RNPrimerHeadlessUniversalCheckoutRawDataManager;