@javascriptcommon/react-native-webview 13.12.16

package/windows/ReactNativeWebView/ReactWebView2.cpp

@@ -0,0 +1,473 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#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>
+
+namespace mux {
+    using namespace winrt::Microsoft::UI::Xaml::Controls;
+}
+
+namespace winrt {
+    using namespace Microsoft::ReactNative;
+    using namespace Windows::Foundation;
+    using namespace Microsoft::Web::WebView2::Core;
+    using namespace Windows::Data::Json;
+    using namespace Windows::UI::Popups;
+    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 {
+
+    ReactWebView2::ReactWebView2(winrt::IReactContext const& reactContext) : m_reactContext(reactContext) {
+        m_webView = mux::WebView2();
+        this->Content(m_webView);
+        RegisterEvents();
+    }
+
+    ReactWebView2::~ReactWebView2() {}
+
+    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);
+                }
+
+            });
+
+        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);
+                }
+            });
+
+        m_CoreWebView2InitializedRevoker = m_webView.CoreWebView2Initialized(
+            winrt::auto_revoke, [ref = get_weak()](auto const& sender, auto const& args){
+            if (auto self = ref.get()) {
+                self->OnCoreWebView2Initialized(sender, args);
+            }
+        });
+    }
+
+    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;
+
+        if (!hasUniversalAPIContract_v7.has_value()) {
+            hasUniversalAPIContract_v7 = winrt::Windows::Foundation::Metadata::ApiInformation::IsApiContractPresent(L"Windows.Foundation.UniversalApiContract", 7);
+        }
+        return hasUniversalAPIContract_v7.value();
+    }
+
+    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());
+        if (Is17763OrHigher()) {
+            WriteProperty(eventDataWriter, L"loading", !sender.IsLoaded());
+        }
+        WriteProperty(eventDataWriter, L"target", tag);
+        if (auto uri = sender.Source()) {
+            WriteProperty(eventDataWriter, L"url", uri.AbsoluteCanonicalUri());
+        }
+    }
+
+    void ReactWebView2::OnNavigationStarting(mux::WebView2 const& webView, winrt::CoreWebView2NavigationStartingEventArgs const& /* args */) {
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topLoadingStart",
+            [&](winrt::IJSValueWriter const& eventDataWriter) noexcept {
+                eventDataWriter.WriteObjectBegin();
+                WriteWebViewNavigationEventArg(webView, eventDataWriter);
+                eventDataWriter.WriteObjectEnd();
+            });
+
+
+        if (m_messagingEnabled) {
+            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();
+                        this->OnMessagePosted(message);
+                    }
+                    catch (...) {
+                        return;
+                    }
+                });
+        }
+    }
+
+    void ReactWebView2::OnMessagePosted(hstring const& message)
+    {
+        HandleMessageFromJS(message);
+    }
+
+    void ReactWebView2::OnNavigationCompleted(mux::WebView2 const& webView, winrt::CoreWebView2NavigationCompletedEventArgs const& /* args */) {
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topLoadingFinish",
+            [&](winrt::IJSValueWriter const& eventDataWriter) noexcept {
+                eventDataWriter.WriteObjectBegin();
+                WriteWebViewNavigationEventArg(webView, eventDataWriter);
+                eventDataWriter.WriteObjectEnd();
+            });
+
+        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))}};
+                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(mux::WebView2 const& sender, mux::CoreWebView2InitializedEventArgs const& /* args */) {
+        assert(sender.CoreWebView2());
+
+        RegisterCoreWebView2Events();
+
+        if (m_navigateToHtml != L"") {
+            m_webView.NavigateToString(m_navigateToHtml);
+            m_navigateToHtml = L"";
+        }
+        if (!m_request.empty())
+        {
+            auto uriString = winrt::to_hstring(m_request.at("uri").AsString());
+            sender.CoreWebView2().AddWebResourceRequestedFilter(
+                uriString, winrt::CoreWebView2WebResourceContext::All);
+        }
+    }
+
+    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());
+            }
+        }
+    }
+
+    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();
+            });
+    }
+
+    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();
+            });
+    }
+
+    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) && jsonObject.HasKey(L"type"))
+        {
+            if (auto v = jsonObject.Lookup(L"type"); v && v.ValueType() == JsonValueType::String) {
+                auto type = v.GetString();
+                if (type == L"__alert") {
+                    auto dialog = winrt::MessageDialog(jsonObject.GetNamedString(L"message"));
+                    dialog.Commands().Append(winrt::UICommand(L"OK"));
+                    dialog.ShowAsync();
+                    return;
+                }
+            }
+        }
+
+        m_reactContext.DispatchEvent(
+            *this,
+            L"topMessage",
+            [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+                eventDataWriter.WriteObjectBegin();
+                WriteProperty(eventDataWriter, L"data", message);
+                eventDataWriter.WriteObjectEnd();
+            });
+    }
+
+    void ReactWebView2::MessagingEnabled(bool enabled) noexcept{
+        m_messagingEnabled = enabled;
+    }
+
+    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 const& html) {
+        if (m_webView.CoreWebView2()) {
+            m_webView.NavigateToString(html);
+        }
+        else {
+            m_webView.EnsureCoreWebView2Async();
+            m_navigateToHtml = html;
+        }
+    }
+
+    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(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 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 = 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"");
+            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
+
+#endif // HAS_WEBVIEW2

package/windows/ReactNativeWebView/ReactWebView2.h

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#if HAS_WEBVIEW2
+#include "winrt/Microsoft.ReactNative.h"
+#include "NativeModules.h"
+#include "ReactWebView2.g.h"
+
+#include "winrt/ReactNativeWebView.h"
+
+using namespace winrt::ReactNativeWebView;
+
+namespace winrt::ReactNativeWebView::implementation {
+
+    class ReactWebView2 : public ReactWebView2T<ReactWebView2> {
+    public:
+        ReactWebView2(Microsoft::ReactNative::IReactContext const& reactContext);
+        void MessagingEnabled(bool enabled) noexcept;
+        bool MessagingEnabled() const noexcept;
+        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"";
+        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 };
+        winrt::event_token m_messageToken;
+        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 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
+
+namespace winrt::ReactNativeWebView::factory_implementation {
+    struct ReactWebView2 : ReactWebView2T<ReactWebView2, implementation::ReactWebView2> {};
+} // namespace winrt::ReactNativeWebView2::factory_implementation
+
+#endif // HAS_WEBVIEW2