@deuna/react-native-sdk 1.0.3 → 1.0.4

package/src/DeunaSDK.ts

@@ -1,5 +1,6 @@
 import {
   BaseDeuna,
+  ClosedAction,
   CustomStyles,
   GetStateFn,
   InitElementsWidgetParams,
@@ -18,21 +19,25 @@ import {
   VoucherWidgetCallbacks,
 } from './types';
 import {
-  BaseWebViewController,
   DeunaWebViewController,
   WebViewDelegate,
 } from './controllers/BaseWebViewController';
 import { PaymentWidgetController } from './controllers/PaymentWidgetController';
-import { OpenInNewTabController } from './controllers/OpenInNewTabController';
-import { getWidgetController } from './helpers/getController';
-import { Completer } from './helpers/Completer';
+import { buildDeunaWidgetController } from './helpers/buildDeunaWidgetController';
 import { ElementsWidgetController } from './controllers/ElementsWidgetController';
 import { DownloadType, Mode, OnDownloadFile } from './interfaces/types';
-import { Platform } from 'react-native';
 import { DeviceFingerprintController } from './controllers/DeviceFingerprintController';
-import { DEVICE_FINGERPRINT_URL } from './interfaces/constants';
+import {
+  DEVICE_FINGERPRINT_URL,
+  DOMAINS_MUST_BE_USE_CROSS_PLATFORM_BROWSER,
+} from './interfaces/constants';
 import { SubmitStrategy } from './helpers/SubmitStrategy';
 import { getSubmitStrategy } from './helpers/getSubmitStrategy';
+import { WebViewManager } from './helpers/ViewManager';
+import {
+  ExternalUrlBrowser,
+  ExternalUrlHelper,
+} from './helpers/ExternalUrlHelper';
 
 export class DeunaSDK extends BaseDeuna {
   constructor(
@@ -42,8 +47,6 @@ export class DeunaSDK extends BaseDeuna {
     super();
   }
 
-  mode: Mode | null = null;
-
   setCustomStyleFn?: SetCustomStyle | undefined;
   refetchOrderFn?: RefetchOrder | undefined;
   getStateFn?: GetStateFn | undefined;
@@ -52,23 +55,12 @@ export class DeunaSDK extends BaseDeuna {
   closeFn?: (() => void) | undefined;
 
   private listeners: Set<() => void> = new Set();
-  webViewController: DeunaWebViewController | null = null;
-  newTabWebViewController: BaseWebViewController | null = null;
-  deviceFingerprintController: DeviceFingerprintController | null = null;
-  submitStrategy: SubmitStrategy | null = null;
 
-  modalDismissPromise: Completer<void> | null = null;
-  newTabModalDismissPromise: Completer<void> | null = null;
+  deunaWidgetManager = new WebViewManager<DeunaWebViewController>();
+  externalUrlHelper = new ExternalUrlHelper();
 
-  get safeWebViewController(): DeunaWebViewController {
-    if (!this.webViewController) {
-      const errorMessage =
-        'A variant of the init method must be called first. Please call initPaymentWidget, initVoucherWidget, or another init method before using this functionality.';
-      console.error(errorMessage);
-      throw new Error(errorMessage);
-    }
-    return this.webViewController;
-  }
+  deviceFingerprintController: DeviceFingerprintController | null = null;
+  submitStrategy: SubmitStrategy | null = null;
 
   /**
    * Generates a device fingerprint, creates a invisible webview to get the device fingerprint
@@ -108,12 +100,11 @@ export class DeunaSDK extends BaseDeuna {
     mode?: Mode;
   }): void => {
     const { controller, mode } = params;
-    this.mode = mode ?? Mode.MODAL;
-    if (this.mode === Mode.MODAL && Platform.OS === 'ios') {
-      this.modalDismissPromise = new Completer<void>();
-    }
-    this.webViewController = controller;
-    this.webViewController.delegate = this.buildDelegate();
+    this.deunaWidgetManager.initialize({
+      controller,
+      mode: mode ?? Mode.MODAL,
+      delegate: this.buildDelegate(),
+    });
     this.notifyListeners();
   };
 
@@ -129,7 +120,7 @@ export class DeunaSDK extends BaseDeuna {
     }
   ) {
     this.setWidgetController({
-      controller: getWidgetController(this.config, {
+      controller: buildDeunaWidgetController(this.config, {
         widget: 'payment',
         ...props,
       }),
@@ -146,7 +137,7 @@ export class DeunaSDK extends BaseDeuna {
     props: InitElementsWidgetParams & { mode?: Mode; sessionId?: string }
   ) {
     this.setWidgetController({
-      controller: getWidgetController(this.config, {
+      controller: buildDeunaWidgetController(this.config, {
         widget: 'elements',
         ...props,
       }),
@@ -161,7 +152,7 @@ export class DeunaSDK extends BaseDeuna {
    */
   async initNextAction(props: InitNextActionWidgetParams & { mode: Mode }) {
     this.setWidgetController({
-      controller: getWidgetController(this.config, {
+      controller: buildDeunaWidgetController(this.config, {
         widget: 'nextAction',
         ...props,
       }),
@@ -181,7 +172,7 @@ export class DeunaSDK extends BaseDeuna {
     }
   ) {
     this.setWidgetController({
-      controller: getWidgetController(this.config, {
+      controller: buildDeunaWidgetController(this.config, {
         widget: 'voucher',
         ...props,
       }),
@@ -190,7 +181,7 @@ export class DeunaSDK extends BaseDeuna {
   }
 
   isValid = async (): Promise<boolean> => {
-    return this.safeWebViewController.isValid();
+    return this.deunaWidgetManager.controller.isValid();
   };
 
   submit = async (): Promise<SubmitResult> => {
@@ -198,7 +189,7 @@ export class DeunaSDK extends BaseDeuna {
     const submitStrategy = await getSubmitStrategy(this);
 
     if (!submitStrategy) {
-      return this.safeWebViewController.submit();
+      return this.deunaWidgetManager.controller.submit();
     }
 
     this.submitStrategy = submitStrategy;
@@ -207,57 +198,63 @@ export class DeunaSDK extends BaseDeuna {
   };
 
   setCustomStyle = async (style: Partial<CustomStyles>): Promise<void> => {
-    return this.safeWebViewController.setCustomStyle(style);
+    return this.deunaWidgetManager.controller.setCustomStyle(style);
   };
 
   refetchOrder = async (): Promise<Json | null> => {
-    return this.safeWebViewController.refetchOrder();
+    return this.deunaWidgetManager.controller.refetchOrder();
   };
 
   getWidgetState = async (): Promise<State> => {
-    return this.safeWebViewController.getWidgetState();
+    return this.deunaWidgetManager.controller.getWidgetState();
   };
 
   /**
    * Closes the DEUNA widget and releases the resources
    */
   close = async (): Promise<void> => {
-    if (this.webViewController instanceof PaymentWidgetController) {
-      this.webViewController.callbacks.onClosed?.(
-        this.webViewController.closedAction
-      );
-    } else if (this.webViewController instanceof ElementsWidgetController) {
-      this.webViewController.callbacks.onClosed?.(
-        this.webViewController.closedAction
-      );
+    if (!this.deunaWidgetManager.isInitialized) {
+      return;
     }
-    this.onCloseNewTab();
-    await this.newTabModalDismissPromise?.wait;
-    this.newTabWebViewController?.dispose();
 
-    this.webViewController?.dispose();
-    // reset all prop
-    this.newTabWebViewController = null;
-    this.webViewController = null;
-    this.mode = null;
-
-    await this.submitStrategy?.deunaSDK.close();
-    this.submitStrategy = null;
-
-    this.notifyListeners();
-
-    // if the widget was shown in modal mode, wait for the modal to be dismissed
-    await this.modalDismissPromise?.wait;
-    this.modalDismissPromise = null;
-    this.onDestroyed?.();
-  };
-
-  onModalDismissed = () => {
-    this.modalDismissPromise?.complete();
-  };
-
-  onNewTabDismissed = () => {
-    this.newTabModalDismissPromise?.complete();
+    try {
+      let onClosedCallback: ((action: ClosedAction) => void) | undefined;
+      const closedAction = this.deunaWidgetManager.controller.closedAction;
+
+      if (
+        this.deunaWidgetManager.controller instanceof PaymentWidgetController
+      ) {
+        onClosedCallback =
+          this.deunaWidgetManager.controller.callbacks.onClosed;
+      } else if (
+        this.deunaWidgetManager.controller instanceof ElementsWidgetController
+      ) {
+        onClosedCallback =
+          this.deunaWidgetManager.controller.callbacks.onClosed;
+      }
+
+      // If the external url was opened in a Safari View Controller or a Custom Chrome Tab
+      // we need to wait until the browser is dismissed
+      await this.externalUrlHelper.waitForClose();
+
+      // Destroy the main webview and dismiss the modal
+      this.deunaWidgetManager.destroy();
+
+      // Close the submit strategy if it exists
+      await this.submitStrategy?.deunaSDK.close();
+      this.submitStrategy = null;
+
+      // Notify listeners that the widget has been closed
+      this.notifyListeners();
+
+      // Notify the user that the widget has been closed
+      this.onDestroyed?.();
+
+      // Notify the widget that the user has closed the widget
+      onClosedCallback?.(closedAction);
+    } catch (error) {
+      console.error('Error closing the widget', error);
+    }
   };
 
   addListener = (listener: () => void) => {
@@ -273,21 +270,22 @@ export class DeunaSDK extends BaseDeuna {
   };
 
   private notifyDownloadFile = (url: string) => {
-    if (this.safeWebViewController instanceof PaymentWidgetController) {
-      this.safeWebViewController.callbacks.onDownloadFile?.({
+    if (this.deunaWidgetManager.controller instanceof PaymentWidgetController) {
+      this.deunaWidgetManager.controller.callbacks.onDownloadFile?.({
         type: DownloadType.URL,
         data: url,
       });
     }
   };
 
-  onCloseNewTab = () => {
-    if (this.webViewController) {
-      this.webViewController.redirectUrl = null;
+  /**
+   * Closes the external URL Webview
+   */
+  onCloseExternalUrl = async () => {
+    if (this.externalUrlHelper.externalUrlWebViewController) {
+      await this.externalUrlHelper.closeWebView();
+      this.notifyListeners();
     }
-    this.newTabWebViewController?.dispose();
-    this.newTabWebViewController = null;
-    this.notifyListeners();
   };
 
   /**
@@ -298,19 +296,33 @@ export class DeunaSDK extends BaseDeuna {
    */
   buildDelegate = (): WebViewDelegate => {
     return {
-      onOpenInNewTab: (url) => {
-        this.newTabWebViewController = new OpenInNewTabController(url);
-        if (Platform.OS === 'ios') {
-          this.newTabModalDismissPromise = new Completer<void>();
+      onOpenExternalUrl: (url) => {
+        try {
+          const host = new URL(url).host;
+          let browser = ExternalUrlBrowser.WEB_VIEW;
+          // Check if the URL is from a domain that must be opened in a cross platform browser (SafariView or Chrome Custom Tab)
+          for (const domain of DOMAINS_MUST_BE_USE_CROSS_PLATFORM_BROWSER) {
+            if (host.includes(domain)) {
+              browser = ExternalUrlBrowser.CROSS_PLATFORM_BROWSER;
+              break;
+            }
+          }
+
+          this.externalUrlHelper.openUrl({
+            url,
+            browser,
+            delegate: {
+              onCloseExternalUrl: this.onCloseExternalUrl,
+              onFileDownload: this.notifyDownloadFile,
+            },
+          });
+          this.notifyListeners();
+        } catch (error) {
+          console.error('Error opening external URL', error);
         }
-        this.newTabWebViewController.delegate = {
-          onFileDownload: this.notifyDownloadFile,
-          onNewTabWindowClose: this.onCloseNewTab,
-        };
-        this.notifyListeners();
       },
+      onCloseExternalUrl: this.onCloseExternalUrl,
       onCloseButtonPressed: this.close, // Close the payment widget when the user presses the close button
-      onCloseSubWebView: this.onCloseNewTab, // Close the new tab web view when the DEUNA widget emits an error event or when the purchase is successful
       onFileDownload: this.notifyDownloadFile, // Notify the user when a request to download a file is made
     };
   };

package/src/components/DeunaWidget.tsx

@@ -3,10 +3,9 @@ import { useEffect, useRef, useState } from 'react';
 
 import { DeunaSDK } from '../DeunaSDK';
 import { DeunaWebView } from './DeunaWebView';
-import { NewTabWebView } from './NewTabWebView';
-import { DeunaWebViewController } from '../controllers/BaseWebViewController';
 import { Mode } from '../interfaces/types';
 import { DeviceFingerprintWebView } from './DeviceFingerprintWebView';
+import { ExternalUrlWebView } from './ExternalUrlWebView';
 
 interface DeunaWidgetProps {
   instance: DeunaSDK;
@@ -52,7 +51,9 @@ export const DeunaWidget = (props: DeunaWidgetProps) => {
 const DeunaWidgetContainer = (props: DeunaWidgetProps) => {
   const { instance } = props;
   const instanceRef = useRef(instance);
-  const [mode, setMode] = useState<Mode | null>(instance.mode);
+  const [isVisible, setIsVisible] = useState(
+    instanceRef.current.deunaWidgetManager.isInitialized
+  );
 
   useEffect(() => {
     instanceRef.current = instance;
@@ -62,74 +63,76 @@ const DeunaWidgetContainer = (props: DeunaWidgetProps) => {
   // has changed
   useEffect(() => {
     const listener = () => {
-      setMode(instanceRef.current.mode);
+      setIsVisible(instanceRef.current.deunaWidgetManager.isInitialized);
     };
 
     instanceRef.current.addListener(listener);
 
     return () => {
       instanceRef.current.removeListener(listener);
-      instanceRef.current.webViewController?.dispose();
+      if (instanceRef.current.deunaWidgetManager.isInitialized) {
+        instanceRef.current.deunaWidgetManager.controller?.dispose();
+      }
     };
   }, []);
 
-  const isModal = mode === Mode.MODAL;
-  const isEmbedded = mode === Mode.EMBEDDED;
-
   /**
    * This function is used to close the widget
    */
   const onClose = () => {
-    const controller = instanceRef.current
-      .webViewController as DeunaWebViewController;
+    const controller = instanceRef.current.deunaWidgetManager.controller;
     controller.closedAction = 'userAction';
     instanceRef.current.close();
   };
 
   // render the widget if mode is not null
+  const viewManager = instanceRef.current.deunaWidgetManager;
+  const controller = viewManager.isInitialized ? viewManager.controller : null;
+
+  const isModal = isVisible && viewManager.mode === Mode.MODAL;
+  const isEmbedded = isVisible && viewManager.mode === Mode.EMBEDDED;
+
   return (
     <>
-      <Modal
-        presentationStyle="pageSheet"
-        animationType="slide"
-        onRequestClose={onClose}
-        onDismiss={instanceRef.current.onModalDismissed}
-        visible={isModal}
-      >
-        {isModal && (
+      {isModal && (
+        <Modal
+          presentationStyle="pageSheet"
+          animationType="slide"
+          onRequestClose={onClose}
+        >
           <SafeAreaView style={styles.container}>
             <View style={styles.container}>
               <DeunaWebView
-                url={instanceRef.current.webViewController?.url ?? ''}
-                onWebView={instanceRef.current.webViewController?.setWebView}
-                onMessage={instanceRef.current.webViewController?.onMessage}
-                onLoad={instanceRef.current.webViewController?.onLoad}
-                onError={instanceRef.current.webViewController?.onError}
+                url={controller?.url ?? ''}
+                onWebView={controller?.setWebView}
+                onMessage={controller?.onMessage}
+                onLoad={controller?.onLoad}
+                onError={controller?.onError}
                 onShouldStartLoadWithRequest={
-                  instanceRef.current.webViewController
-                    ?.onShouldStartLoadWithRequest
+                  controller?.onShouldStartLoadWithRequest
                 }
               />
-              <NewTabWebView instance={instanceRef.current} />
+              <ExternalUrlWebView instance={instanceRef.current} />
             </View>
           </SafeAreaView>
-        )}
-      </Modal>
+        </Modal>
+      )}
 
-      {isEmbedded && <NewTabWebView instance={instanceRef.current} />}
+      {isEmbedded && <ExternalUrlWebView instance={instanceRef.current} />}
 
       {isEmbedded && (
         <DeunaWebView
-          url={instanceRef.current.webViewController?.url ?? ''}
-          onWebView={instanceRef.current.webViewController?.setWebView}
-          onMessage={instanceRef.current.webViewController?.onMessage}
-          onLoad={instanceRef.current.webViewController?.onLoad}
-          onError={instanceRef.current.webViewController?.onError}
+          url={controller?.url ?? ''}
+          onWebView={controller?.setWebView}
+          onMessage={controller?.onMessage}
+          onLoad={controller?.onLoad}
+          onError={controller?.onError}
           onShouldStartLoadWithRequest={
-            instanceRef.current.webViewController?.onShouldStartLoadWithRequest
+            controller?.onShouldStartLoadWithRequest
           }
         />
       )}
+
       <DeviceFingerprintWebView instance={instanceRef.current} />
     </>
   );

package/src/components/ExternalUrlWebView.tsx

@@ -0,0 +1,65 @@
+import { useEffect, useRef, useState } from 'react';
+import { DeunaSDK } from '../DeunaSDK';
+import { Modal, SafeAreaView, StyleSheet } from 'react-native';
+import { DeunaWebView } from './DeunaWebView';
+
+interface ExternalUrlWebViewProps {
+  instance: DeunaSDK;
+}
+
+export const ExternalUrlWebView = (props: ExternalUrlWebViewProps) => {
+  const { instance } = props;
+  const instanceRef = useRef<DeunaSDK>(instance);
+  const [visible, setVisible] = useState(false);
+
+  useEffect(() => {
+    instanceRef.current = instance;
+  }, [instance]);
+
+  // Listen when the DeunaSDK instance configuration
+  // has changed
+  useEffect(() => {
+    const ref = instanceRef.current;
+    const listener = () => {
+      const isVisible = !!ref.externalUrlHelper.externalUrlWebViewController;
+      setVisible(isVisible);
+    };
+
+    instanceRef.current.addListener(listener);
+
+    return () => {
+      ref.removeListener(listener);
+      ref.externalUrlHelper.externalUrlWebViewController?.dispose();
+    };
+  }, []);
+
+  const externalUrlWebViewController =
+    instanceRef.current.externalUrlHelper.externalUrlWebViewController;
+
+  return (
+    <>
+      {visible && (
+        <Modal
+          presentationStyle="pageSheet"
+          animationType="slide"
+          onRequestClose={instanceRef.current.onCloseExternalUrl}
+        >
+          <SafeAreaView style={styles.container}>
+            <DeunaWebView
+              url={externalUrlWebViewController?.url ?? ''}
+              onWebView={externalUrlWebViewController?.setWebView}
+              onMessage={externalUrlWebViewController?.onMessage}
+              onLoad={externalUrlWebViewController?.onLoad}
+              onError={externalUrlWebViewController?.onError}
+              onShouldStartLoadWithRequest={
+                externalUrlWebViewController?.onShouldStartLoadWithRequest
+              }
+            />
+          </SafeAreaView>
+        </Modal>
+      )}
+    </>
+  );
+};
+
+const styles = StyleSheet.create({ container: { flex: 1 } });

package/src/controllers/BaseWebViewController.ts

@@ -13,20 +13,19 @@ import { Platform } from 'react-native';
 import { ShouldStartLoadRequest } from 'react-native-webview/lib/WebViewTypes';
 
 export interface WebViewDelegate {
-  onOpenInNewTab?: (url: string) => void;
+  onOpenExternalUrl?: (url: string) => void;
   onCloseButtonPressed?: () => void;
-  onCloseSubWebView?: () => void;
   onFileDownload?: (url: string) => void;
-  onNewTabWindowClose?: () => void;
+  onCloseExternalUrl?: () => void;
 }
 
 export enum WebViewEventType {
   consoleLog = 'consoleLog',
   eventDispatch = 'eventDispatch',
   jsExecutor = 'jsExecutor',
-  openInNewTab = 'openInNewTab',
+  openExternalUrl = 'openExternalUrl',
   redirect = 'redirect',
-  newTabWindowClose = 'newTabWindowClose',
+  closeExternalUrl = 'closeExternalUrl',
 }
 
 const DOWNLOAD_FILE_REGEX =
@@ -34,7 +33,6 @@ const DOWNLOAD_FILE_REGEX =
 
 export abstract class BaseWebViewController {
   initialized = false;
-  redirectUrl: string | null = null;
   webView: WebView | null = null;
   url: string | null = null;
 
@@ -78,26 +76,22 @@ export abstract class BaseWebViewController {
    * @returns boolean indicating if the URL should be loaded in current WebView
    */
   onShouldStartLoadWithRequest = (request: ShouldStartLoadRequest) => {
-    // Prevent loading if it's the redirect URL
-    if (this.redirectUrl === request.url) {
-      return false;
+    if (this.url === request.url) {
+      return true;
     }
 
-    const isNewNavigation = request.isTopFrame && request.url !== this.url;
-    const isClickNavigation = request.navigationType === 'click';
-    const shouldHandleInNewTab = !this.urlMustBeLoadedInTheSameWebView(
+    const isAndroid = Platform.OS === 'android';
+
+    const isNewNavigation = isAndroid
+      ? request.url.startsWith('https://')
+      : request.navigationType === 'click';
+
+    const shouldOpenExternally = !this.urlMustBeLoadedInTheSameWebView(
       request.url
     );
 
-    // For iOS, check both click navigation and new navigation
-    // For Android, only check new navigation
-    const shouldOpenInNewTab =
-      Platform.OS === 'ios'
-        ? (isClickNavigation || isNewNavigation) && shouldHandleInNewTab
-        : isNewNavigation && shouldHandleInNewTab;
-
-    if (shouldOpenInNewTab) {
-      this.delegate?.onOpenInNewTab?.(request.url);
+    if (isNewNavigation && shouldOpenExternally) {
+      this.delegate?.onOpenExternalUrl?.(request.url);
       return false;
     }
 
@@ -158,18 +152,18 @@ export abstract class DeunaWebViewController extends BaseWebViewController {
         this.jsExecutor.requests.get(requestId)?.(data);
         this.jsExecutor.requests.delete(requestId);
       },
-      [WebViewEventType.openInNewTab]: () => {
-        this.delegate?.onOpenInNewTab?.(eventData.url);
+      [WebViewEventType.openExternalUrl]: () => {
+        this.delegate?.onOpenExternalUrl?.(eventData.url);
       },
       [WebViewEventType.redirect]: () => {
         if (this.redirectUrl) {
           return;
         }
         this.redirectUrl = eventData.url;
-        this.delegate?.onOpenInNewTab?.(eventData.url);
+        this.delegate?.onOpenExternalUrl?.(eventData.url);
       },
-      [WebViewEventType.newTabWindowClose]: () => {
-        this.delegate?.onNewTabWindowClose?.();
+      [WebViewEventType.closeExternalUrl]: () => {
+        this.delegate?.onCloseExternalUrl?.();
       },
     };
 
@@ -180,7 +174,7 @@ export abstract class DeunaWebViewController extends BaseWebViewController {
     this.webView?.injectJavaScript(
       `
     window.open = function(url, target, features) {
-      window.ReactNativeWebView.postMessage(JSON.stringify({ type: '${WebViewEventType.openInNewTab}', url }));
+      window.ReactNativeWebView.postMessage(JSON.stringify({ type: '${WebViewEventType.openExternalUrl}', url }));
     };
     console.log = function(message) {
         window.ReactNativeWebView.postMessage(JSON.stringify({ type: '${WebViewEventType.consoleLog}', message }));

package/src/controllers/ElementsWidgetController.ts

@@ -37,12 +37,11 @@ export class ElementsWidgetController extends DeunaWebViewController {
         this.delegate?.onCloseButtonPressed?.();
       },
       [ElementsEventType.vaultSaveSuccess]: () => {
-        this.delegate?.onCloseSubWebView?.();
+        this.delegate?.onCloseExternalUrl?.();
         this.callbacks.onSuccess?.(event.data);
       },
       [ElementsEventType.vaultSaveError]: () => {
-        this.delegate?.onCloseSubWebView?.();
-        this.delegate?.onCloseSubWebView?.();
+        this.delegate?.onCloseExternalUrl?.();
         const { metadata } = elementsEvent.data;
 
         if (metadata) {

package/src/controllers/{OpenInNewTabController.ts → ExternalUrlController.ts}

@@ -5,7 +5,7 @@ import {
 } from './BaseWebViewController';
 import { DeunaLogs } from '../DeunaLogs';
 
-export class OpenInNewTabController extends BaseWebViewController {
+export class ExternalUrlController extends BaseWebViewController {
   constructor(readonly url: string) {
     super();
     this.url = url;
@@ -16,7 +16,7 @@ export class OpenInNewTabController extends BaseWebViewController {
   };
 
   onError = (event: any) => {
-    console.warn(event);
+    DeunaLogs.error(`EXTERNAL URL ERROR`, event);
   };
 
   urlMustBeLoadedInTheSameWebView = (url: string) => {
@@ -41,7 +41,7 @@ export class OpenInNewTabController extends BaseWebViewController {
         window.ReactNativeWebView.postMessage(JSON.stringify({ type: '${WebViewEventType.consoleLog}', message }));
       };
       window.close = function() {
-        window.ReactNativeWebView.postMessage(JSON.stringify({ type: '${WebViewEventType.newTabWindowClose}', data: '' }));
+        window.ReactNativeWebView.postMessage(JSON.stringify({ type: '${WebViewEventType.closeExternalUrl}', data: '' }));
       };
       (function() {
            setTimeout(function() {

package/src/controllers/PaymentWidgetController.ts

@@ -85,11 +85,11 @@ export class PaymentWidgetController extends DeunaWebViewController {
         this.callbacks.onPaymentProcessing?.();
       },
       [CheckoutEventType.purchase]: () => {
-        this.delegate?.onCloseSubWebView?.();
+        this.delegate?.onCloseExternalUrl?.();
         this.callbacks.onSuccess?.(checkoutEvent.data.order);
       },
       [CheckoutEventType.purchaseError]: () => {
-        this.delegate?.onCloseSubWebView?.();
+        this.delegate?.onCloseExternalUrl?.();
         const { metadata } = checkoutEvent.data;
 
         if (metadata) {