react-native-webview-bootpay 13.8.42 → 13.13.4

package/windows/ReactNativeWebView/ReactWebView2.cpp

@@ -3,95 +3,38 @@
 
 #include "pch.h"
 #include "ReactWebView2.h"
+#include "ReactWebViewHelpers.h"
 
 #if HAS_WEBVIEW2
 #include "JSValueXaml.h"
 #include "ReactWebView2.g.cpp"
 #include <winrt/Windows.Foundation.Metadata.h>
+#include <winrt/Windows.System.h>
 #include <optional>
-#include <iostream>
-#include <vector>
-#include <algorithm>
-#include <cctype>
 
+namespace mux {
+    using namespace winrt::Microsoft::UI::Xaml::Controls;
+}
 
 namespace winrt {
     using namespace Microsoft::ReactNative;
     using namespace Windows::Foundation;
-    using namespace Windows::UI;
-    using namespace Windows::UI::Xaml;
-    using namespace Windows::UI::Xaml::Controls;
-    using namespace Microsoft::UI::Xaml::Controls;
     using namespace Microsoft::Web::WebView2::Core;
     using namespace Windows::Data::Json;
     using namespace Windows::UI::Popups;
-    using namespace Windows::UI::Xaml::Input;
-    using namespace Windows::UI::Xaml::Media;
+    using namespace Windows::Web::Http;
     using namespace Windows::Storage::Streams;
+    using namespace Windows::Security::Cryptography;
+    using namespace xaml;
+    using namespace xaml::Controls;
+    using namespace xaml::Input;
+    using namespace xaml::Media;
 } // namespace winrt
 
 namespace winrt::ReactNativeWebView::implementation {
-    namespace helpers {
-        std::string trimString(const std::string& str) {
-            std::string trimmedString = str;
-
-            // Trim from start
-            trimmedString.erase(0, trimmedString.find_first_not_of(" \t\n\r\f\v"));
-
-            // Trim from end
-            trimmedString.erase(trimmedString.find_last_not_of(" \t\n\r\f\v") + 1);
-
-            return trimmedString;
-        }
-        std::vector<std::string> splitString(
-            const std::string& str,
-            const std::string& delim) {
-            std::vector<std::string> tokens;
-            auto startPos = 0;
-            auto endPos = str.find(delim);
-
-            while (endPos != std::string::npos) {
-                auto token = str.substr(startPos, endPos - startPos);
-                tokens.push_back(trimString(token));
-
-                startPos = endPos + delim.length();
-                endPos = str.find(delim, startPos);
-            }
-
-            auto lastToken = str.substr(startPos);
-            tokens.push_back(trimString(lastToken));
-
-            return tokens;
-        }
-
-        std::map<std::string, std::string> parseSetCookieHeader(
-            const std::string& setCookieHeader) {
-            std::map<std::string, std::string> cookie;
-
-            // Split the header into individual cookie strings
-            auto cookieStrings = splitString(setCookieHeader, ";");
-
-            // Extract the cookie name and value from the first string
-            auto nameValuePair = splitString(cookieStrings[0], "=");
-            cookie["Name"] = trimString(nameValuePair[0]);
-            cookie["Value"] = trimString(nameValuePair[1]);
-
-            // Extract the attributes from the remaining strings
-            for (std::size_t i = 1; i < cookieStrings.size(); ++i) {
-                auto attributeValuePair = splitString(cookieStrings[i], "=");
-                auto attributeName = attributeValuePair[0];
-                auto attributeValue =
-                    attributeValuePair.size() > 1 ? attributeValuePair[1] : "";
-                cookie[attributeName] = trimString(attributeValue);
-            }
-
-            return cookie;
-        }
-    } // namespace HP
-
 
     ReactWebView2::ReactWebView2(winrt::IReactContext const& reactContext) : m_reactContext(reactContext) {
-        m_webView = winrt::WebView2();
+        m_webView = mux::WebView2();
         this->Content(m_webView);
         RegisterEvents();
     }
@@ -101,18 +44,18 @@ namespace winrt::ReactNativeWebView::implementation {
     void ReactWebView2::RegisterEvents() {
         m_navigationStartingRevoker = m_webView.NavigationStarting(
             winrt::auto_revoke, [ref = get_weak()](auto const& sender, auto const& args) {
-            if (auto self = ref.get()) {
-                self->OnNavigationStarting(sender, args);
-            }
+                if (auto self = ref.get()) {
+                    self->OnNavigationStarting(sender, args);
+                }
 
-        });
+            });
 
         m_navigationCompletedRevoker = m_webView.NavigationCompleted(
             winrt::auto_revoke, [ref = get_weak()](auto const& sender, auto const& args) {
-            if (auto self = ref.get()) {
-                self->OnNavigationCompleted(sender, args);
-            }
-        });
+                if (auto self = ref.get()) {
+                    self->OnNavigationCompleted(sender, args);
+                }
+            });
 
         m_CoreWebView2InitializedRevoker = m_webView.CoreWebView2Initialized(
             winrt::auto_revoke, [ref = get_weak()](auto const& sender, auto const& args){
@@ -122,6 +65,71 @@ namespace winrt::ReactNativeWebView::implementation {
         });
     }
 
+    void ReactWebView2::RegisterCoreWebView2Events()
+    {
+        // We need to wait for the CoreWebView component to be initialized before registering its event listeners
+        assert(m_webView.CoreWebView2());
+        m_webResourceRequestedRevoker = m_webView.CoreWebView2().WebResourceRequested(
+            winrt::auto_revoke,
+            [ref = get_weak()](auto const& sender, auto const& args)
+            {
+                if (auto self = ref.get())
+                {
+                    self->OnCoreWebView2ResourceRequseted(sender, args);
+                }
+            });
+
+        m_CoreWebView2DOMContentLoadedRevoker = m_webView.CoreWebView2().DOMContentLoaded(
+            winrt::auto_revoke,
+            [ref = get_weak()](auto const& sender, auto const& args)
+            {
+                if (auto self = ref.get())
+                {
+                    self->OnCoreWebView2DOMContentLoaded(sender, args);
+                }
+            });
+
+        m_frameNavigationStartingRevoker = m_webView.CoreWebView2().FrameNavigationStarting(
+            winrt::auto_revoke,
+            [ref = get_weak()](auto const& sender, auto const& args)
+            {
+                if (auto self = ref.get())
+                {
+                    self->OnCoreWebView2FrameNavigationStarted(sender, args);
+                }
+            });
+
+        m_frameNavigationCompletedRevoker = m_webView.CoreWebView2().FrameNavigationCompleted(
+            winrt::auto_revoke,
+            [ref = get_weak()](auto const& sender, auto const& args)
+            {
+                if (auto self = ref.get())
+                {
+                    self->OnCoreWebView2FrameNavigationCompleted(sender, args);
+                }
+            });
+
+        m_sourceChangedRevoker = m_webView.CoreWebView2().SourceChanged(
+            winrt::auto_revoke,
+            [ref = get_weak()](auto const& sender, auto const& args)
+            {
+                if (auto self = ref.get())
+                {
+                    self->OnCoreWebView2SourceChanged(sender, args);
+                }
+            });
+
+        m_newWindowRequestedRevoker = m_webView.CoreWebView2().NewWindowRequested(
+            winrt::auto_revoke,
+            [ref = get_weak()](auto const& sender, auto const& args)
+            {
+                if (auto self = ref.get())
+                {
+                    self->OnCoreWebView2NewWindowRequested(sender, args);
+                }
+            });
+    }
+
     bool ReactWebView2::Is17763OrHigher() {
         static std::optional<bool> hasUniversalAPIContract_v7;
 
@@ -131,7 +139,7 @@ namespace winrt::ReactNativeWebView::implementation {
         return hasUniversalAPIContract_v7.value();
     }
 
-    void ReactWebView2::WriteWebViewNavigationEventArg(winrt::WebView2 const& sender, winrt::IJSValueWriter const& eventDataWriter) {
+    void ReactWebView2::WriteWebViewNavigationEventArg(mux::WebView2 const& sender, winrt::IJSValueWriter const& eventDataWriter) {
         auto tag = this->GetValue(winrt::FrameworkElement::TagProperty()).as<winrt::IPropertyValue>().GetInt64();
         WriteProperty(eventDataWriter, L"canGoBack", sender.CanGoBack());
         WriteProperty(eventDataWriter, L"canGoForward", sender.CanGoForward());
@@ -144,7 +152,7 @@ namespace winrt::ReactNativeWebView::implementation {
         }
     }
 
-    void ReactWebView2::OnNavigationStarting(winrt::WebView2 const& webView, winrt::CoreWebView2NavigationStartingEventArgs const& /* args */) {
+    void ReactWebView2::OnNavigationStarting(mux::WebView2 const& webView, winrt::CoreWebView2NavigationStartingEventArgs const& /* args */) {
         m_reactContext.DispatchEvent(
             *this,
             L"topLoadingStart",
@@ -156,7 +164,12 @@ namespace winrt::ReactNativeWebView::implementation {
 
 
         if (m_messagingEnabled) {
-            m_messageToken = webView.WebMessageReceived([this](auto const& /* sender */, winrt::CoreWebView2WebMessageReceivedEventArgs const& messageArgs)
+            if (m_messageToken)
+            {
+                // In case the webview has a new navigation, we need to clean up the old WebMessageReceived handler
+                webView.WebMessageReceived(m_messageToken);
+            }
+            m_messageToken = webView.WebMessageReceived([this](auto const& /* sender */ , winrt::CoreWebView2WebMessageReceivedEventArgs const& messageArgs)
                 {
                     try {
                         auto message = messageArgs.TryGetWebMessageAsString();
@@ -174,7 +187,7 @@ namespace winrt::ReactNativeWebView::implementation {
         HandleMessageFromJS(message);
     }
 
-    void ReactWebView2::OnNavigationCompleted(winrt::WebView2 const& webView, winrt::CoreWebView2NavigationCompletedEventArgs const& /* args */) {
+    void ReactWebView2::OnNavigationCompleted(mux::WebView2 const& webView, winrt::CoreWebView2NavigationCompletedEventArgs const& /* args */) {
         m_reactContext.DispatchEvent(
             *this,
             L"topLoadingFinish",
@@ -186,52 +199,140 @@ namespace winrt::ReactNativeWebView::implementation {
 
         if (m_messagingEnabled) {
             winrt::hstring message = LR"(window.alert = function (msg) {window.chrome.webview.postMessage(`{"type":"__alert","message":"${msg}"}`)};
-                window.ReactNativeWebView = {postMessage: function (data) {window.chrome.webview.postMessage(String(data))}};)";
+                window.ReactNativeWebView = {postMessage: function (data) {window.chrome.webview.postMessage(String(data))}};
+                const originalPostMessage = globalThis.postMessage;
+                globalThis.postMessage = function (data) { originalPostMessage(data); globalThis.ReactNativeWebView.postMessage(typeof data == 'string' ? data : JSON.stringify(data));};)";
             webView.ExecuteScriptAsync(message);
         }
     }
 
-    void ReactWebView2::OnCoreWebView2Initialized(winrt::Microsoft::UI::Xaml::Controls::WebView2 const& sender, winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs const& /* args */) {
+    void ReactWebView2::OnCoreWebView2Initialized(mux::WebView2 const& sender, mux::CoreWebView2InitializedEventArgs const& /* args */) {
         assert(sender.CoreWebView2());
 
+        RegisterCoreWebView2Events();
+
         if (m_navigateToHtml != L"") {
             m_webView.NavigateToString(m_navigateToHtml);
             m_navigateToHtml = L"";
         }
-        else if (m_navigationWithHeaders.has_value()) {
-            auto headers = m_navigationWithHeaders.value().second;
+        if (!m_request.empty())
+        {
+            auto uriString = winrt::to_hstring(m_request.at("uri").AsString());
+            sender.CoreWebView2().AddWebResourceRequestedFilter(
+                uriString, winrt::CoreWebView2WebResourceContext::All);
+        }
+    }
 
-            auto stream = InMemoryRandomAccessStream();
+    void ReactWebView2::OnCoreWebView2ResourceRequseted(
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+        winrt::CoreWebView2WebResourceRequestedEventArgs const& args)
+    {
+        assert(sender);
+        if (!m_request.empty()) {
+            auto uriString = winrt::to_hstring(m_request.at("uri").AsString());
+            if (args.Request().Uri() == uriString) {
+                SetupRequest(m_request, args.Request());
+            }
+        }
+    }
 
-            // construct headers string 
-            winrt::hstring headers_str;
-            for (auto const& header : headers) {
-                if (header.Key() == L"cookie" || header.Key() == L"Cookie") {
-                    WriteCookiesToWebView2(header.Value());
-                }
-                else {
-                    headers_str = headers_str + header.Key() + L": " +
-                        header.Value() + L"\r\n";
-                }
+    void ReactWebView2::OnCoreWebView2DOMContentLoaded(
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2DOMContentLoadedEventArgs const& /* args */)
+    {
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topDOMContentLoaded",
+            [&](winrt::IJSValueWriter const& eventDataWriter) noexcept
+            {
+                eventDataWriter.WriteObjectBegin();
+                WriteWebViewNavigationEventArg(m_webView, eventDataWriter);
+                eventDataWriter.WriteObjectEnd();
+            });
+        if (!m_injectedJavascript.empty())
+        {
+            sender.ExecuteScriptAsync(m_injectedJavascript);
+        }
+    }
 
-            }
+    void ReactWebView2::OnCoreWebView2FrameNavigationStarted(
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& /* sender */,
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationStartingEventArgs const& /* args */)
+    {
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topFrameNavigationStart",
+            [&](winrt::IJSValueWriter const& eventDataWriter) noexcept
+            {
+                eventDataWriter.WriteObjectBegin();
+                WriteWebViewNavigationEventArg(m_webView, eventDataWriter);
+                eventDataWriter.WriteObjectEnd();
+            });
+    }
 
-            auto request =
-                m_webView.CoreWebView2().Environment().CreateWebResourceRequest(
-                    m_navigationWithHeaders.value().first,
-                    L"GET",
-                    stream,
-                    headers_str
-                );
+    void ReactWebView2::OnCoreWebView2FrameNavigationCompleted(
+    winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& /* sender */,
+    winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationCompletedEventArgs const& /* args */)
+    {
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topFrameNavigationFinish",
+            [&](winrt::IJSValueWriter const& eventDataWriter) noexcept
+            {
+                eventDataWriter.WriteObjectBegin();
+                WriteWebViewNavigationEventArg(m_webView, eventDataWriter);
+                eventDataWriter.WriteObjectEnd();
+            });
+    }
+
+    void ReactWebView2::OnCoreWebView2SourceChanged(
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& /* sender */,
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2SourceChangedEventArgs const& /* args */)
+    {
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topSourceChanged",
+            [&](winrt::IJSValueWriter const& eventDataWriter) noexcept
+            {
+                eventDataWriter.WriteObjectBegin();
+                WriteWebViewNavigationEventArg(m_webView, eventDataWriter);
+                eventDataWriter.WriteObjectEnd();
+            });
+    }
 
-            m_webView.CoreWebView2().NavigateWithWebResourceRequest(request);
-            m_navigationWithHeaders.reset();
+    void ReactWebView2::OnCoreWebView2NewWindowRequested(
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2NewWindowRequestedEventArgs const& args)
+    {
+        if (m_linkHandlingEnabled) {
+            m_reactContext.DispatchEvent(
+                *this,
+                L"topOpenWindow",
+                [&](winrt::IJSValueWriter const& eventDataWriter) noexcept
+                {
+                    eventDataWriter.WriteObjectBegin();
+                    WriteProperty(eventDataWriter, L"targetUrl", args.Uri());
+                    eventDataWriter.WriteObjectEnd();
+                });
+            args.Handled(true);
+        } else {
+            try
+            {
+                winrt::Windows::Foundation::Uri uri(args.Uri());
+                winrt::Windows::System::Launcher::LaunchUriAsync(uri);
+                args.Handled(true);
+            }
+            catch (winrt::hresult_error& e)
+            {
+                // Do Nothing
+            }
         }
     }
 
     void ReactWebView2::HandleMessageFromJS(winrt::hstring const& message) {
         winrt::JsonObject jsonObject;
-        if (winrt::JsonObject::TryParse(message, jsonObject)) {
+        if (winrt::JsonObject::TryParse(message, jsonObject) && jsonObject.HasKey(L"type"))
+        {
             if (auto v = jsonObject.Lookup(L"type"); v && v.ValueType() == JsonValueType::String) {
                 auto type = v.GetString();
                 if (type == L"__alert") {
@@ -248,23 +349,47 @@ namespace winrt::ReactNativeWebView::implementation {
             L"topMessage",
             [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
                 eventDataWriter.WriteObjectBegin();
-                {
-                    WriteProperty(eventDataWriter, L"data", message);
-                }
+                WriteProperty(eventDataWriter, L"data", message);
                 eventDataWriter.WriteObjectEnd();
             });
     }
 
-    void ReactWebView2::MessagingEnabled(bool enabled) noexcept {
+    void ReactWebView2::MessagingEnabled(bool enabled) noexcept{
         m_messagingEnabled = enabled;
     }
 
-    bool ReactWebView2::MessagingEnabled() const noexcept {
+    bool ReactWebView2::MessagingEnabled() const noexcept{
         return m_messagingEnabled;
     }
 
+    void ReactWebView2::LinkHandlingEnabled(bool enabled) noexcept {
+        m_linkHandlingEnabled = enabled;
+    }
+
+    bool ReactWebView2::LinkHandlingEnabled() const noexcept {
+        return m_linkHandlingEnabled;
+    }
+
+    void ReactWebView2::WebResourceRequestSource(Microsoft::ReactNative::JSValueObject const& source) noexcept
+    {
+        m_request = std::move(source.Copy());
+    }
+
+    JSValueObject ReactWebView2::WebResourceRequestSource() const noexcept
+    {
+        return m_request.Copy();
+    }
+
+    void ReactWebView2::InjectedJavascript(winrt::hstring const& injectedJavascript) noexcept {
+        m_injectedJavascript = injectedJavascript;
+    }
+
+    winrt::hstring ReactWebView2::InjectedJavascript() const noexcept
+    {
+        return m_injectedJavascript;
+    }
 
-    void ReactWebView2::NavigateToHtml(winrt::hstring html) {
+    void ReactWebView2::NavigateToHtml(winrt::hstring const& html) {
         if (m_webView.CoreWebView2()) {
             m_webView.NavigateToString(html);
         }
@@ -274,33 +399,73 @@ namespace winrt::ReactNativeWebView::implementation {
         }
     }
 
-    void ReactWebView2::NavigateWithHeaders(winrt::hstring uri, IMapView<winrt::hstring, winrt::hstring> headers) {
-        m_navigationWithHeaders = std::make_pair(uri, headers);
-        m_webView.EnsureCoreWebView2Async();
+    winrt::fire_and_forget ReactWebView2::NavigateWithWebResourceRequest(Microsoft::ReactNative::IJSValueReader const& source)
+    {
+        m_request = JSValueObject::ReadFrom(source);
+        co_await m_webView.EnsureCoreWebView2Async();
+        assert(m_webView.CoreWebView2());
+        if (m_webView.CoreWebView2())
+        {
+            auto uri = winrt::Uri(winrt::to_hstring(m_request.at("uri").AsString()));
+            auto method = (m_request.find("method") != m_request.end()) ? m_request.at("method").AsString() : "GET";
+            auto webResourceRequest = m_webView.CoreWebView2().Environment().CreateWebResourceRequest(
+                uri.ToString(), winrt::to_hstring(method), nullptr, L"");
+
+            SetupRequest(m_request.Copy(), webResourceRequest);
+
+            m_webView.CoreWebView2().NavigateWithWebResourceRequest(webResourceRequest);
+        }
     }
 
-    void ReactWebView2::WriteCookiesToWebView2(winrt::hstring cookies) {
+    void ReactWebView2::WriteCookiesToWebView2(std::string const& cookies) {
         // Persisting cookies passed from JS
         // Cookies are separated by ;, and adheres to the Set-Cookie HTTP header format of RFC-6265.
 
-        auto cm = m_webView.CoreWebView2().CookieManager();
-        auto cookies_list =
-            helpers::splitString(winrt::to_string(cookies), ";,");
-        for (const auto& cookie_str : cookies_list) {
-            auto cookieData = helpers::parseSetCookieHeader(helpers::trimString(cookie_str));
+        auto cookieManager = m_webView.CoreWebView2().CookieManager();
+        auto cookiesList = ReactWebViewHelpers::SplitString(cookies, ";,");
+        for (const auto& cookie_str : cookiesList) {
+            auto cookieData = ReactWebViewHelpers::ParseSetCookieHeader(ReactWebViewHelpers::TrimString(cookie_str));
 
             if (!cookieData.count("Name") || !cookieData.count("Value")) {
                 continue;
             }
-            auto cookie = cm.CreateCookie(
+
+            auto cookie = cookieManager.CreateCookie(
                 winrt::to_hstring(cookieData["Name"]),
                 winrt::to_hstring(cookieData["Value"]),
-                cookieData.count("Domain")
-                ? winrt::to_hstring(cookieData["Domain"])
-                : L"",
-                cookieData.count("Path")
-                ? winrt::to_hstring(cookieData["Path"]) : L"");
-            cm.AddOrUpdateCookie(cookie);
+                cookieData.count("Domain") ? winrt::to_hstring(cookieData["Domain"]) : L"",
+                cookieData.count("Path") ? winrt::to_hstring(cookieData["Path"]) : L"");
+            cookieManager.AddOrUpdateCookie(cookie);
+        }
+    }
+
+    void ReactWebView2::SetupRequest(Microsoft::ReactNative::JSValueObject const& srcMap, winrt::Microsoft::Web::WebView2::Core::CoreWebView2WebResourceRequest const& request) {
+        bool hasHeaders = srcMap.find("headers") != srcMap.end();
+        auto method = srcMap.find("method") != srcMap.end() ? srcMap.at("method").AsString() : "GET";
+        request.Method(winrt::to_hstring(method));
+        if (method == "POST")
+        {
+            auto formBody = srcMap.at("body").AsString();
+            winrt::InMemoryRandomAccessStream formContent;
+            winrt::IBuffer buffer{winrt::CryptographicBuffer::ConvertStringToBinary(
+                winrt::to_hstring(formBody), winrt::BinaryStringEncoding::Utf8)};
+            formContent.ReadAsync(buffer, buffer.Length(), InputStreamOptions::None);
+            request.Content(formContent);
+        }
+        if (hasHeaders)
+        {
+            for (auto const& header : srcMap.at("headers").AsObject())
+            {
+                auto const& headerKey = header.first;
+                auto const& headerValue = header.second;
+                if (headerValue.IsNull())
+                    continue;
+                if (headerKey == "Cookie") {
+                    WriteCookiesToWebView2(headerValue.AsString());
+                } else {
+                    request.Headers().SetHeader(winrt::to_hstring(headerKey), winrt::to_hstring(headerValue.AsString()));
+                }
+            }
         }
     }
 } // namespace winrt::ReactNativeWebView::implementation

package/windows/ReactNativeWebView/ReactWebView2.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #if HAS_WEBVIEW2
-
 #include "winrt/Microsoft.ReactNative.h"
 #include "NativeModules.h"
 #include "ReactWebView2.g.h"
@@ -20,14 +19,23 @@ namespace winrt::ReactNativeWebView::implementation {
         ReactWebView2(Microsoft::ReactNative::IReactContext const& reactContext);
         void MessagingEnabled(bool enabled) noexcept;
         bool MessagingEnabled() const noexcept;
-        void NavigateToHtml(winrt::hstring html);
-        void NavigateWithHeaders(winrt::hstring uri, IMapView<winrt::hstring, winrt::hstring> headers);
+        void LinkHandlingEnabled(bool enabled) noexcept;
+        bool LinkHandlingEnabled() const noexcept;
+        void WebResourceRequestSource(Microsoft::ReactNative::JSValueObject const& source) noexcept;
+        Microsoft::ReactNative::JSValueObject WebResourceRequestSource() const noexcept;
+        void InjectedJavascript(winrt::hstring const& injectedJavascript) noexcept;
+        winrt::hstring InjectedJavascript() const noexcept;
+        void NavigateToHtml(winrt::hstring const& html);
+        winrt::fire_and_forget NavigateWithWebResourceRequest(Microsoft::ReactNative::IJSValueReader const& source);
         ~ReactWebView2();
 
     private:
         winrt::hstring m_navigateToHtml = L"";
-        std::optional<std::pair<winrt::hstring, IMapView<winrt::hstring, winrt::hstring>>> m_navigationWithHeaders;
+        winrt::Microsoft::ReactNative::JSValueObject m_request{};
         bool m_messagingEnabled{ true };
+        bool m_linkHandlingEnabled{ true };
+        winrt::hstring m_injectedJavascript = L"";
+
 
         winrt::Microsoft::UI::Xaml::Controls::WebView2 m_webView{ nullptr };
         Microsoft::ReactNative::IReactContext m_reactContext{ nullptr };
@@ -35,15 +43,44 @@ namespace winrt::ReactNativeWebView::implementation {
         winrt::Microsoft::UI::Xaml::Controls::WebView2::NavigationStarting_revoker m_navigationStartingRevoker{};
         winrt::Microsoft::UI::Xaml::Controls::WebView2::NavigationCompleted_revoker m_navigationCompletedRevoker{};
         winrt::Microsoft::UI::Xaml::Controls::WebView2::CoreWebView2Initialized_revoker m_CoreWebView2InitializedRevoker{};
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2::WebResourceRequested_revoker
+            m_webResourceRequestedRevoker{};
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2::DOMContentLoaded_revoker
+            m_CoreWebView2DOMContentLoadedRevoker{};
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2::FrameNavigationStarting_revoker m_frameNavigationStartingRevoker{};
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2::FrameNavigationCompleted_revoker m_frameNavigationCompletedRevoker{};
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2::SourceChanged_revoker m_sourceChangedRevoker{};
+        winrt::Microsoft::Web::WebView2::Core::CoreWebView2::NewWindowRequested_revoker m_newWindowRequestedRevoker{};
         void HandleMessageFromJS(winrt::hstring const& message);
         void RegisterEvents();
-        void WriteCookiesToWebView2(winrt::hstring cookies);
+        void RegisterCoreWebView2Events();
         void WriteWebViewNavigationEventArg(winrt::Microsoft::UI::Xaml::Controls::WebView2 const& sender, winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter);
         void OnNavigationStarting(winrt::Microsoft::UI::Xaml::Controls::WebView2 const& sender, winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationStartingEventArgs const& args);
         void OnNavigationCompleted(winrt::Microsoft::UI::Xaml::Controls::WebView2 const& sender, winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationCompletedEventArgs const& args);
         void OnCoreWebView2Initialized(winrt::Microsoft::UI::Xaml::Controls::WebView2 const& sender, winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs const& args);
+        void OnCoreWebView2ResourceRequseted(
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2WebResourceRequestedEventArgs const& args);
+        void OnCoreWebView2DOMContentLoaded(
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2DOMContentLoadedEventArgs const& args);
+        void OnCoreWebView2FrameNavigationStarted(
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationStartingEventArgs const& args);
+        void OnCoreWebView2FrameNavigationCompleted(
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationCompletedEventArgs const& args);
+        void OnCoreWebView2SourceChanged(
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2SourceChangedEventArgs const& args);
+        void OnCoreWebView2NewWindowRequested(
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2 const& sender,
+            winrt::Microsoft::Web::WebView2::Core::CoreWebView2NewWindowRequestedEventArgs const& args);
+
         void OnMessagePosted(hstring const& message);
         bool Is17763OrHigher();
+        void WriteCookiesToWebView2(std::string const& cookies);
+        void SetupRequest(Microsoft::ReactNative::JSValueObject const& srcMap, winrt::Microsoft::Web::WebView2::Core::CoreWebView2WebResourceRequest const& request);
     };
 } // namespace winrt::ReactNativeWebView2::implementation