@capgo/inappbrowser 7.0.0 → 7.1.1

package/ios/Plugin/WKWebViewController.swift

@@ -19,6 +19,11 @@ private struct UrlsHandledByApp {
     static var blank = true
 }
 
+public struct WKWebViewCredentials {
+    var username: String
+    var password: String
+}
+
 @objc public protocol WKWebViewControllerDelegate {
     @objc optional func webViewController(_ controller: WKWebViewController, canDismiss url: URL) -> Bool
 
@@ -28,7 +33,17 @@ private struct UrlsHandledByApp {
     @objc optional func webViewController(_ controller: WKWebViewController, decidePolicy url: URL, navigationType: NavigationType) -> Bool
 }
 
-open class WKWebViewController: UIViewController {
+extension Dictionary {
+    func mapKeys<T>(_ transform: (Key) throws -> T) rethrows -> [T: Value] {
+        var dictionary = [T: Value]()
+        for (key, value) in self {
+            dictionary[try transform(key)] = value
+        }
+        return dictionary
+    }
+}
+
+open class WKWebViewController: UIViewController, WKScriptMessageHandler {
 
     public init() {
         super.init(nibName: nil, bundle: nil)
@@ -38,23 +53,27 @@ open class WKWebViewController: UIViewController {
         super.init(coder: aDecoder)
     }
 
-    public init(source: WKWebSource?) {
+    public init(source: WKWebSource?, credentials: WKWebViewCredentials? = nil) {
         super.init(nibName: nil, bundle: nil)
         self.source = source
+        self.credentials = credentials
         self.initWebview()
     }
 
-    public init(url: URL) {
+    public init(url: URL, credentials: WKWebViewCredentials? = nil) {
         super.init(nibName: nil, bundle: nil)
         self.source = .remote(url)
+        self.credentials = credentials
         self.initWebview()
     }
 
-    public init(url: URL, headers: [String: String]) {
+    public init(url: URL, headers: [String: String], isInspectable: Bool, credentials: WKWebViewCredentials? = nil, preventDeeplink: Bool) {
         super.init(nibName: nil, bundle: nil)
         self.source = .remote(url)
+        self.credentials = credentials
         self.setHeaders(headers: headers)
-        self.initWebview()
+        self.setPreventDeeplink(preventDeeplink: preventDeeplink)
+        self.initWebview(isInspectable: isInspectable)
     }
 
     open var hasDynamicTitle = false
@@ -74,16 +93,34 @@ open class WKWebViewController: UIViewController {
     var viewHeightLandscape: CGFloat?
     var viewHeightPortrait: CGFloat?
     var currentViewHeight: CGFloat?
+    open var closeModal = false
+    open var closeModalTitle = ""
+    open var closeModalDescription = ""
+    open var closeModalOk = ""
+    open var closeModalCancel = ""
+    open var ignoreUntrustedSSLError = false
+    var viewWasPresented = false
+    var preventDeeplink: Bool = false
+
+    internal var preShowSemaphore: DispatchSemaphore?
+    internal var preShowError: String?
 
     func setHeaders(headers: [String: String]) {
         self.headers = headers
-        let userAgent = self.headers?["User-Agent"]
+        let lowercasedHeaders = headers.mapKeys { $0.lowercased() }
+        let userAgent = lowercasedHeaders["user-agent"]
         self.headers?.removeValue(forKey: "User-Agent")
-        if userAgent != nil {
+        self.headers?.removeValue(forKey: "user-agent")
+
+        if let userAgent = userAgent {
             self.customUserAgent = userAgent
         }
     }
 
+    func setPreventDeeplink(preventDeeplink: Bool) {
+        self.preventDeeplink = preventDeeplink
+    }
+
     internal var customUserAgent: String? {
         didSet {
             guard let agent = userAgent else {
@@ -113,7 +150,8 @@ open class WKWebViewController: UIViewController {
 
     open var websiteTitleInNavigationBar = true
     open var doneBarButtonItemPosition: NavigationBarPosition = .right
-    open var leftNavigaionBarItemTypes: [BarButtonItemType] = []
+    open var preShowScript: String?
+    open var leftNavigationBarItemTypes: [BarButtonItemType] = []
     open var rightNavigaionBarItemTypes: [BarButtonItemType] = []
     open var toolbarItemTypes: [BarButtonItemType] = [.back, .forward, .reload, .activity]
 
@@ -123,6 +161,8 @@ open class WKWebViewController: UIViewController {
     open var stopBarButtonItemImage: UIImage?
     open var activityBarButtonItemImage: UIImage?
 
+    open var buttonNearDoneIcon: UIImage?
+
     fileprivate var webView: WKWebView?
     fileprivate var progressView: UIProgressView?
 
@@ -173,6 +213,8 @@ open class WKWebViewController: UIViewController {
         return UIBarButtonItem(barButtonSystemItem: .flexibleSpace, target: nil, action: nil)
     }()
 
+    fileprivate var credentials: WKWebViewCredentials?
+
     deinit {
         webView?.removeObserver(self, forKeyPath: estimatedProgressKeyPath)
         if websiteTitleInNavigationBar {
@@ -188,7 +230,64 @@ open class WKWebViewController: UIViewController {
         }
     }
 
-    open func initWebview() {
+    open func setCredentials(credentials: WKWebViewCredentials?) {
+        self.credentials = credentials
+    }
+
+    // Method to send a message from Swift to JavaScript
+    open func postMessageToJS(message: [String: Any]) {
+        if let jsonData = try? JSONSerialization.data(withJSONObject: message, options: []),
+           let jsonString = String(data: jsonData, encoding: .utf8) {
+            let script = "window.dispatchEvent(new CustomEvent('messageFromNative', { detail: \(jsonString) }));"
+            webView?.evaluateJavaScript(script, completionHandler: nil)
+        }
+    }
+
+    // Method to receive messages from JavaScript
+    public func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+        if message.name == "messageHandler" {
+            if let messageBody = message.body as? [String: Any] {
+                print("Received message from JavaScript:", messageBody)
+                self.capBrowserPlugin?.notifyListeners("messageFromWebview", data: messageBody)
+            } else {
+                print("Received non-dictionary message from JavaScript:", message.body)
+                self.capBrowserPlugin?.notifyListeners("messageFromWebview", data: ["rawMessage": String(describing: message.body)])
+            }
+        } else if message.name == "preShowScriptSuccess" {
+            guard let semaphore = preShowSemaphore else {
+                print("[InAppBrowser - preShowScriptSuccess]: Semaphore not found")
+                return
+            }
+
+            semaphore.signal()
+        } else if message.name == "preShowScriptError" {
+            guard let semaphore = preShowSemaphore else {
+                print("[InAppBrowser - preShowScriptError]: Semaphore not found")
+                return
+            }
+            print("[InAppBrowser - preShowScriptError]: Error!!!!")
+            semaphore.signal()
+        }
+    }
+
+    func injectJavaScriptInterface() {
+        let script = """
+                if (!window.mobileApp) {
+                        window.mobileApp = {
+                                postMessage: function(message) {
+                                        if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.messageHandler) {
+                                                window.webkit.messageHandlers.messageHandler.postMessage(message);
+                                        }
+                                }
+                        };
+                }
+                """
+        DispatchQueue.main.async {
+            self.webView?.evaluateJavaScript(script, completionHandler: nil)
+        }
+    }
+
+    open func initWebview(isInspectable: Bool = true) {
 
         self.view.backgroundColor = UIColor.white
 
@@ -196,8 +295,18 @@ open class WKWebViewController: UIViewController {
         self.edgesForExtendedLayout = [.bottom]
 
         let webConfiguration = WKWebViewConfiguration()
+        let userContentController = WKUserContentController()
+        userContentController.add(self, name: "messageHandler")
+        userContentController.add(self, name: "preShowScriptError")
+        userContentController.add(self, name: "preShowScriptSuccess")
+        webConfiguration.userContentController = userContentController
         let webView = WKWebView(frame: .zero, configuration: webConfiguration)
 
+        if webView.responds(to: Selector(("setInspectable:"))) {
+            // Fix: https://stackoverflow.com/questions/76216183/how-to-debug-wkwebview-in-ios-16-4-1-using-xcode-14-2/76603043#76603043
+            webView.perform(Selector(("setInspectable:")), with: isInspectable)
+        }
+
         webView.uiDelegate = self
         webView.navigationDelegate = self
 
@@ -223,8 +332,6 @@ open class WKWebViewController: UIViewController {
             self.previousToolbarState = (navigation.toolbar.tintColor, navigation.toolbar.isHidden)
         }
 
-        //        self.restateViewHeight()
-
         if let s = self.source {
             self.load(source: s)
         } else {
@@ -242,19 +349,19 @@ open class WKWebViewController: UIViewController {
         var bottomPadding = CGFloat(0.0)
         var topPadding = CGFloat(0.0)
         if #available(iOS 11.0, *) {
-            let window = UIApplication.shared.keyWindow
-            bottomPadding = (window?.safeAreaInsets.bottom)!
-            topPadding = (window?.safeAreaInsets.top)!
+            let window = UIApplication.shared.windows.first(where: { $0.isKeyWindow })
+            bottomPadding = window?.safeAreaInsets.bottom ?? 0.0
+            topPadding = window?.safeAreaInsets.top ?? 0.0
         }
         if UIDevice.current.orientation.isPortrait {
             self.navigationController?.toolbar.isHidden = false
             if self.viewHeightPortrait == nil {
                 self.viewHeightPortrait = self.view.safeAreaLayoutGuide.layoutFrame.size.height
                 if toolbarItemTypes.count == 0 {
-                    self.viewHeightPortrait! = self.viewHeightPortrait! + bottomPadding
+                    self.viewHeightPortrait! += bottomPadding
                 }
                 if self.navigationController?.navigationBar.isHidden == true {
-                    self.viewHeightPortrait = self.viewHeightPortrait! + topPadding
+                    self.viewHeightPortrait! += topPadding
                 }
             }
             self.currentViewHeight = self.viewHeightPortrait
@@ -263,10 +370,10 @@ open class WKWebViewController: UIViewController {
             if self.viewHeightLandscape == nil {
                 self.viewHeightLandscape = self.view.safeAreaLayoutGuide.layoutFrame.size.height
                 if toolbarItemTypes.count == 0 {
-                    self.viewHeightLandscape! = self.viewHeightLandscape! + bottomPadding
+                    self.viewHeightLandscape! += bottomPadding
                 }
                 if self.navigationController?.navigationBar.isHidden == true {
-                    self.viewHeightLandscape = self.viewHeightLandscape! + topPadding
+                    self.viewHeightLandscape! += topPadding
                 }
             }
             self.currentViewHeight = self.viewHeightLandscape
@@ -286,8 +393,11 @@ open class WKWebViewController: UIViewController {
 
     override open func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
-        self.setupViewElements()
-        setUpState()
+        if !self.viewWasPresented {
+            self.setupViewElements()
+            setUpState()
+            self.viewWasPresented = true
+        }
     }
 
     override open func viewWillDisappear(_ animated: Bool) {
@@ -295,34 +405,33 @@ open class WKWebViewController: UIViewController {
         rollbackState()
     }
 
-    override open func didReceiveMemoryWarning() {
-        super.didReceiveMemoryWarning()
-        // Dispose of any resources that can be recreated.
-    }
-
     override open func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
         switch keyPath {
         case estimatedProgressKeyPath?:
-            guard let estimatedProgress = self.webView?.estimatedProgress else {
-                return
-            }
-            self.progressView?.alpha = 1
-            self.progressView?.setProgress(Float(estimatedProgress), animated: true)
-
-            if estimatedProgress >= 1.0 {
-                UIView.animate(withDuration: 0.3, delay: 0.3, options: .curveEaseOut, animations: {
-                    self.progressView?.alpha = 0
-                }, completion: {
-                    _ in
-                    self.progressView?.setProgress(0, animated: false)
-                })
+            DispatchQueue.main.async {
+                guard let estimatedProgress = self.webView?.estimatedProgress else {
+                    return
+                }
+                self.progressView?.alpha = 1
+                self.progressView?.setProgress(Float(estimatedProgress), animated: true)
+
+                if estimatedProgress >= 1.0 {
+                    UIView.animate(withDuration: 0.3, delay: 0.3, options: .curveEaseOut, animations: {
+                        self.progressView?.alpha = 0
+                    }, completion: {
+                        _ in
+                        self.progressView?.setProgress(0, animated: false)
+                    })
+                }
             }
         case titleKeyPath?:
             if self.hasDynamicTitle {
                 self.navigationItem.title = webView?.url?.host
             }
         case "URL":
+
             self.capBrowserPlugin?.notifyListeners("urlChangeEvent", data: ["url": webView?.url?.absoluteString ?? ""])
+            self.injectJavaScriptInterface()
         default:
             super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
         }
@@ -344,7 +453,9 @@ public extension WKWebViewController {
     }
 
     func load(remote: URL) {
-        webView?.load(createRequest(url: remote))
+        DispatchQueue.main.async {
+            self.webView?.load(self.createRequest(url: remote))
+        }
     }
 
     func load(file: URL, access: URL) {
@@ -360,6 +471,15 @@ public extension WKWebViewController {
             webView?.go(to: firstPageItem)
         }
     }
+    func reload() {
+        webView?.reload()
+    }
+
+    func executeScript(script: String, completion: ((Any?, Error?) -> Void)? = nil) {
+        DispatchQueue.main.async { [weak self] in
+            self?.webView?.evaluateJavaScript(script, completionHandler: completion)
+        }
+    }
 }
 
 // MARK: - Fileprivate Methods
@@ -444,7 +564,7 @@ fileprivate extension WKWebViewController {
         //        if presentingViewController != nil {
         switch doneBarButtonItemPosition {
         case .left:
-            if !leftNavigaionBarItemTypes.contains(where: { type in
+            if !leftNavigationBarItemTypes.contains(where: { type in
                 switch type {
                 case .done:
                     return true
@@ -452,7 +572,7 @@ fileprivate extension WKWebViewController {
                     return false
                 }
             }) {
-                leftNavigaionBarItemTypes.insert(.done, at: 0)
+                leftNavigationBarItemTypes.insert(.done, at: 0)
             }
         case .right:
             if !rightNavigaionBarItemTypes.contains(where: { type in
@@ -470,7 +590,7 @@ fileprivate extension WKWebViewController {
         }
         //        }
 
-        navigationItem.leftBarButtonItems = leftNavigaionBarItemTypes.map {
+        navigationItem.leftBarButtonItems = leftNavigationBarItemTypes.map {
             barButtonItemType in
             if let barButtonItem = barButtonItem(barButtonItemType) {
                 return barButtonItem
@@ -478,13 +598,17 @@ fileprivate extension WKWebViewController {
             return UIBarButtonItem()
         }
 
-        navigationItem.rightBarButtonItems = rightNavigaionBarItemTypes.map {
+        var rightBarButtons = rightNavigaionBarItemTypes.map {
             barButtonItemType in
             if let barButtonItem = barButtonItem(barButtonItemType) {
                 return barButtonItem
             }
             return UIBarButtonItem()
         }
+        if rightBarButtons.count == 1 && buttonNearDoneIcon != nil && rightBarButtons[0] == doneBarButtonItem {
+            rightBarButtons.append(UIBarButtonItem(image: buttonNearDoneIcon, style: .plain, target: self, action: #selector(buttonNearDoneDidClick)))
+        }
+        navigationItem.rightBarButtonItems = rightBarButtons
 
         if toolbarItemTypes.count > 0 {
             for index in 0..<toolbarItemTypes.count - 1 {
@@ -492,13 +616,14 @@ fileprivate extension WKWebViewController {
             }
         }
 
-        setToolbarItems(toolbarItemTypes.map {
+        let gen = toolbarItemTypes.map {
             barButtonItemType -> UIBarButtonItem in
             if let barButtonItem = barButtonItem(barButtonItemType) {
                 return barButtonItem
             }
             return UIBarButtonItem()
-        }, animated: true)
+        }
+        setToolbarItems(gen, animated: true)
     }
 
     func updateBarButtonItems() {
@@ -617,6 +742,10 @@ fileprivate extension WKWebViewController {
         webView?.goForward()
     }
 
+    @objc func buttonNearDoneDidClick(sender: AnyObject) {
+        self.capBrowserPlugin?.notifyListeners("buttonNearDoneClick", data: [:])
+    }
+
     @objc func reloadDidClick(sender: AnyObject) {
         webView?.stopLoading()
         if webView?.url != nil {
@@ -666,13 +795,14 @@ fileprivate extension WKWebViewController {
             self.present(alert, animated: true, completion: nil)
         } else {
             let activityViewController = UIActivityViewController(activityItems: items, applicationActivities: nil)
+            #imageLiteral(resourceName: "simulator_screenshot_B8B44B8D-EB30-425C-9BF4-1F37697A8459.png")
             activityViewController.setValue(self.shareSubject ?? self.title, forKey: "subject")
             activityViewController.popoverPresentationController?.barButtonItem = (sender as! UIBarButtonItem)
             self.present(activityViewController, animated: true, completion: nil)
         }
     }
 
-    @objc func doneDidClick(sender: AnyObject) {
+    func closeView () {
         var canDismiss = true
         if let url = self.source?.url {
             canDismiss = delegate?.webViewController?(self, canDismiss: url) ?? true
@@ -684,6 +814,21 @@ fileprivate extension WKWebViewController {
         }
     }
 
+    @objc func doneDidClick(sender: AnyObject) {
+        // check if closeModal is true, if true display alert before close
+        if self.closeModal {
+            let alert = UIAlertController(title: self.closeModalTitle, message: self.closeModalDescription, preferredStyle: UIAlertController.Style.alert)
+            alert.addAction(UIAlertAction(title: self.closeModalOk, style: UIAlertAction.Style.default, handler: { _ in
+                self.closeView()
+            }))
+            alert.addAction(UIAlertAction(title: self.closeModalCancel, style: UIAlertAction.Style.default, handler: nil))
+            self.present(alert, animated: true, completion: nil)
+        } else {
+            self.closeView()
+        }
+
+    }
+
     @objc func customDidClick(sender: BlockBarButtonItem) {
         sender.block?(self)
     }
@@ -693,11 +838,59 @@ fileprivate extension WKWebViewController {
 
 // MARK: - WKUIDelegate
 extension WKWebViewController: WKUIDelegate {
-
+    public func webView(_ webView: WKWebView, runJavaScriptAlertPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping () -> Void) {
+        // Ensure UI updates are on the main thread
+        DispatchQueue.main.async {
+            let alertController = UIAlertController(title: nil, message: message, preferredStyle: .alert)
+            self.present(alertController, animated: true, completion: nil)
+        }
+        completionHandler()
+    }
 }
 
 // MARK: - WKNavigationDelegate
 extension WKWebViewController: WKNavigationDelegate {
+    internal func injectPreShowScript() {
+        if preShowSemaphore != nil {
+            return
+        }
+
+        // TODO: implement interface
+        let script = """
+                        async function preShowFunction() {
+                        \(self.preShowScript ?? "")
+                        };
+                        preShowFunction().then(
+                                () => window.webkit.messageHandlers.preShowScriptSuccess.postMessage({})
+                        ).catch(
+                                err => {
+                                        console.error('Preshow error', err);
+                                        window.webkit.messageHandlers.preShowScriptError.postMessage(JSON.stringify(err, Object.getOwnPropertyNames(err)));
+                                }
+                        )
+                        """
+        print("[InAppBrowser - InjectPreShowScript] PreShowScript script: \(script)")
+
+        self.preShowSemaphore = DispatchSemaphore(value: 0)
+        self.executeScript(script: script) // this will run on the main thread
+
+        defer {
+            self.preShowSemaphore = nil
+            self.preShowError = nil
+        }
+
+        if self.preShowSemaphore?.wait(timeout: .now() + 10) == .timedOut {
+            print("[InAppBrowser - InjectPreShowScript] PreShowScript running for over 10 seconds. The plugin will not wait any longer!")
+            return
+        }
+
+        //            "async function preShowFunction() {\n" +
+        //            self.preShowScript + "\n" +
+        //            "};\n" +
+        //            "preShowFunction().then(() => window.PreShowScriptInterface.success()).catch(err => { console.error('Preshow error', err); window.PreShowScriptInterface.error(JSON.stringify(err, Object.getOwnPropertyNames(err))) })";
+
+    }
+
     public func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
         updateBarButtonItems()
         self.progressView?.progress = 0
@@ -708,7 +901,21 @@ extension WKWebViewController: WKNavigationDelegate {
     }
     public func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
         if !didpageInit && self.capBrowserPlugin?.isPresentAfterPageLoad == true {
-            self.capBrowserPlugin?.presentView()
+            // injectPreShowScript will block, don't execute on the main thread
+            if self.preShowScript != nil && !self.preShowScript!.isEmpty {
+                DispatchQueue.global(qos: .userInitiated).async {
+                    self.injectPreShowScript()
+                    DispatchQueue.main.async { [weak self] in
+                        self?.capBrowserPlugin?.presentView()
+                    }
+                }
+            } else {
+                self.capBrowserPlugin?.presentView()
+            }
+        } else if self.preShowScript != nil && !self.preShowScript!.isEmpty && self.capBrowserPlugin?.isPresentAfterPageLoad == true {
+            DispatchQueue.global(qos: .userInitiated).async {
+                self.injectPreShowScript()
+            }
         }
         didpageInit = true
         updateBarButtonItems()
@@ -717,6 +924,8 @@ extension WKWebViewController: WKNavigationDelegate {
             self.url = url
             delegate?.webViewController?(self, didFinish: url)
         }
+        self.injectJavaScriptInterface()
+        self.capBrowserPlugin?.notifyListeners("browserPageLoaded", data: [:])
     }
 
     public func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
@@ -726,6 +935,7 @@ extension WKWebViewController: WKNavigationDelegate {
             self.url = url
             delegate?.webViewController?(self, didFail: url, withError: error)
         }
+        self.capBrowserPlugin?.notifyListeners("pageLoadError", data: [:])
     }
 
     public func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
@@ -735,46 +945,76 @@ extension WKWebViewController: WKNavigationDelegate {
             self.url = url
             delegate?.webViewController?(self, didFail: url, withError: error)
         }
+        self.capBrowserPlugin?.notifyListeners("pageLoadError", data: [:])
     }
 
     public func webView(_ webView: WKWebView, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
-        if let bypassedSSLHosts = bypassedSSLHosts, bypassedSSLHosts.contains(challenge.protectionSpace.host) {
+        if let credentials = credentials,
+           challenge.protectionSpace.receivesCredentialSecurely,
+           let url = webView.url, challenge.protectionSpace.host == url.host, challenge.protectionSpace.protocol == url.scheme, challenge.protectionSpace.port == url.port ?? (url.scheme == "https" ? 443 : url.scheme == "http" ? 80 : nil) {
+            let urlCredential = URLCredential(user: credentials.username, password: credentials.password, persistence: .none)
+            completionHandler(.useCredential, urlCredential)
+        } else if let bypassedSSLHosts = bypassedSSLHosts, bypassedSSLHosts.contains(challenge.protectionSpace.host) {
             let credential = URLCredential(trust: challenge.protectionSpace.serverTrust!)
             completionHandler(.useCredential, credential)
         } else {
-            completionHandler(.performDefaultHandling, nil)
+            guard self.ignoreUntrustedSSLError else {
+                completionHandler(.performDefaultHandling, nil)
+                return
+            }
+            /* allows to open links with self-signed certificates
+             Follow Apple's guidelines https://developer.apple.com/documentation/foundation/url_loading_system/handling_an_authentication_challenge/performing_manual_server_trust_authentication
+             */
+            guard let serverTrust = challenge.protectionSpace.serverTrust  else {
+                completionHandler(.useCredential, nil)
+                return
+            }
+            let credential = URLCredential(trust: serverTrust)
+            completionHandler(.useCredential, credential)
         }
+        self.injectJavaScriptInterface()
     }
 
     public func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
         var actionPolicy: WKNavigationActionPolicy = .allow
-        defer {
-            decisionHandler(actionPolicy)
+
+        if self.preventDeeplink {
+            actionPolicy = .preventDeeplinkActionPolicy
         }
+
         guard let u = navigationAction.request.url else {
-            print("Cannot handle empty URLs")
+            decisionHandler(actionPolicy)
+            return
+        }
+
+        // Check if the URL is an App Store URL
+        if u.absoluteString.contains("apps.apple.com") {
+            UIApplication.shared.open(u, options: [:], completionHandler: nil)
+            // Cancel the navigation in the web view
+            decisionHandler(.cancel)
             return
         }
 
         if !self.allowsFileURL && u.isFileURL {
             print("Cannot handle file URLs")
+            decisionHandler(.cancel)
             return
         }
 
         if handleURLWithApp(u, targetFrame: navigationAction.targetFrame) {
             actionPolicy = .cancel
-            return
         }
 
         if u.host == self.source?.url?.host, let cookies = availableCookies, !checkRequestCookies(navigationAction.request, cookies: cookies) {
             self.load(remote: u)
             actionPolicy = .cancel
-            return
         }
 
         if let navigationType = NavigationType(rawValue: navigationAction.navigationType.rawValue), let result = delegate?.webViewController?(self, decidePolicy: u, navigationType: navigationType) {
             actionPolicy = result ? .allow : .cancel
         }
+        self.injectJavaScriptInterface()
+        decisionHandler(actionPolicy)
     }
 }
 
@@ -782,3 +1022,7 @@ class BlockBarButtonItem: UIBarButtonItem {
 
     var block: ((WKWebViewController) -> Void)?
 }
+
+extension WKNavigationActionPolicy {
+    static let preventDeeplinkActionPolicy = WKNavigationActionPolicy(rawValue: WKNavigationActionPolicy.allow.rawValue + 2)!
+}